From ed08daff79d5c8d91f4d6fc730d3792dd444aa98 Mon Sep 17 00:00:00 2001 From: Ryan Roussel Date: Sat, 12 Sep 2026 15:40:43 -0500 Subject: [PATCH 1/6] initial commit --- .gitignore | 2 + docs/examples/rl/inverted_pendulum.ipynb | 14354 +++++++++++++++++++ docs/examples/rl/inverted_pendulum.py | 92 + pyproject.toml | 7 +- xopt/evaluator.py | 149 +- xopt/generators/__init__.py | 6 + xopt/generators/rl_generator.py | 104 + xopt/tests/generators/test_rl_generator.py | 108 + xopt/tests/test_evaluator.py | 32 + xopt/tests/test_generator.py | 19 + xopt/vocs.py | 65 +- 11 files changed, 14884 insertions(+), 54 deletions(-) create mode 100644 docs/examples/rl/inverted_pendulum.ipynb create mode 100644 docs/examples/rl/inverted_pendulum.py create mode 100644 xopt/generators/rl_generator.py create mode 100644 xopt/tests/generators/test_rl_generator.py diff --git a/.gitignore b/.gitignore index 78ebf2da5..ce5baf49f 100644 --- a/.gitignore +++ b/.gitignore @@ -2,6 +2,8 @@ docs/examples/ga/nsga2/assets/yaml_runner_example/nsga2_output docs/examples/ga/nsga2/assets/yaml_runner_example/nsga2_from_checkpoint_output docs/examples/ga/nsga2/yaml_interface/assets/yaml_runner_example.zip +docs/examples/rl/sac_pendulum.zip +docs/examples/rl/inverted_pendulum_reward.png # Byte-compiled / optimized / DLL files __pycache__/ diff --git a/docs/examples/rl/inverted_pendulum.ipynb b/docs/examples/rl/inverted_pendulum.ipynb new file mode 100644 index 000000000..c94c2d6bf --- /dev/null +++ b/docs/examples/rl/inverted_pendulum.ipynb @@ -0,0 +1,14354 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "646d8ad0", + "metadata": {}, + "source": [ + "# Deploying a trained RL policy in Xopt: inverted pendulum\n", + "\n", + "This notebook shows how to use a **reinforcement-learning policy trained externally**\n", + "(with [stable-baselines3](https://stable-baselines3.readthedocs.io/)) inside Xopt via\n", + "`RLGenerator`, which steps a gymnasium environment through `GymEvaluator`.\n", + "\n", + "Xopt does not train or update the policy here -- it is frozen at deployment time.\n", + "Training happens once, outside of Xopt (see `train_policy` below, or run\n", + "[`inverted_pendulum.py`](inverted_pendulum.py) directly), and the resulting policy is\n", + "simply used for inference by `RLGenerator.generate()`.\n", + "\n", + "Requires the optional `rl` extra: `pip install xopt[rl]`.\n" + ] + }, + { + "cell_type": "markdown", + "id": "d287f697", + "metadata": {}, + "source": [ + "## Setup and imports\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "be07dc11", + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "\n", + "import gymnasium as gym\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from IPython.display import HTML\n", + "from matplotlib import animation\n", + "from stable_baselines3 import SAC\n", + "\n", + "from gest_api.vocs import VOCS\n", + "from xopt import Xopt\n", + "from xopt.evaluator import GymEvaluator\n", + "from xopt.generators.rl_generator import RLGenerator\n", + "from xopt.vocs import ContextualVariable\n", + "\n", + "MODEL_PATH = Path(\"sac_pendulum.zip\")\n", + "ACTION_NAMES = [\"torque\"]\n", + "OBSERVATION_NAMES = [\"cos_theta\", \"sin_theta\", \"theta_dot\"]\n" + ] + }, + { + "cell_type": "markdown", + "id": "3399f268", + "metadata": {}, + "source": [ + "## Train (or load) the policy -- entirely outside of Xopt\n", + "\n", + "If `sac_pendulum.zip` already exists (e.g. from running `inverted_pendulum.py`), it is\n", + "loaded directly; otherwise a SAC policy is trained here for a modest number of timesteps.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "0d80d8b4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "if MODEL_PATH.exists():\n", + " policy = SAC.load(MODEL_PATH)\n", + "else:\n", + " train_env = gym.make(\"Pendulum-v1\")\n", + " policy = SAC(\"MlpPolicy\", train_env, verbose=0)\n", + " policy.learn(total_timesteps=20_000)\n", + " policy.save(MODEL_PATH)\n", + " train_env.close()\n", + "\n", + "policy\n" + ] + }, + { + "cell_type": "markdown", + "id": "b6f47ed3", + "metadata": {}, + "source": [ + "## Configure Xopt: VOCS, GymEvaluator, RLGenerator\n", + "\n", + "- `torque` is the action variable the policy controls.\n", + "- `cos_theta`, `sin_theta`, `theta_dot` are `ContextualVariable`s: contextual inputs to\n", + " the policy that Xopt does not optimize over.\n", + "- `reward` is logged as the objective for bookkeeping/plotting only -- the frozen policy,\n", + " not this objective, decides the next action.\n", + "\n", + "The environment is created with `render_mode=\"rgb_array\"` so we can grab frames for the\n", + "animation below. We also override the random reset with a non-ideal (but easily\n", + "recoverable) starting angle, so the rollout below first shows a quick recovery before\n", + "the later perturbation.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "edf5dcd3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\n", + " Xopt\n", + "________________________________\n", + "Version: 3.0.2.dev40+g9eb7a7409.d20260604\n", + "Data size: 0\n", + "Config as YAML:\n", + "data_dump_file: null\n", + "evaluator:\n", + " action_history: []\n", + " action_mode: delta\n", + " action_space_names:\n", + " - torque\n", + " env: gymnasium.wrappers.common.TimeLimit\n", + " function: xopt.evaluator.GymEvaluator._evaluate_function\n", + " function_kwargs: {}\n", + " max_workers: 1\n", + " observation_space_names:\n", + " - cos_theta\n", + " - sin_theta\n", + " - theta_dot\n", + " vectorized: false\n", + "generator:\n", + " action_space_names:\n", + " - torque\n", + " deterministic: true\n", + " initial_observation:\n", + " cos_theta: -0.4161468365471424\n", + " sin_theta: 0.9092974268256817\n", + " theta_dot: 0.0\n", + " name: rl_policy\n", + " observation_space_names:\n", + " - cos_theta\n", + " - sin_theta\n", + " - theta_dot\n", + " policy: stable_baselines3.sac.sac.SAC\n", + " returns_id: false\n", + " supports_batch_generation: false\n", + " supports_constraints: false\n", + " supports_contextual_variables: true\n", + " supports_discrete_variables: false\n", + " supports_multi_objective: false\n", + " supports_single_objective: true\n", + " vocs:\n", + " constants: {}\n", + " constraints: {}\n", + " objectives:\n", + " reward:\n", + " dtype: null\n", + " type: MaximizeObjective\n", + " observables: {}\n", + " variables:\n", + " cos_theta:\n", + " default_value: null\n", + " domain:\n", + " - -inf\n", + " - inf\n", + " dtype: null\n", + " type: ContextualVariable\n", + " sin_theta:\n", + " default_value: null\n", + " domain:\n", + " - -inf\n", + " - inf\n", + " dtype: null\n", + " type: ContextualVariable\n", + " theta_dot:\n", + " default_value: null\n", + " domain:\n", + " - -inf\n", + " - inf\n", + " dtype: null\n", + " type: ContextualVariable\n", + " torque:\n", + " default_value: null\n", + " domain:\n", + " - -2.0\n", + " - 2.0\n", + " dtype: null\n", + " type: ContinuousVariable\n", + "serialize_inline: false\n", + "serialize_torch: false\n", + "stopping_condition: null\n", + "strict: true\n", + "xopt_dump_file: null\n" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vocs = VOCS(\n", + " variables={\n", + " \"torque\": [-2.0, 2.0],\n", + " \"cos_theta\": ContextualVariable(),\n", + " \"sin_theta\": ContextualVariable(),\n", + " \"theta_dot\": ContextualVariable(),\n", + " },\n", + " objectives={\"reward\": \"MAXIMIZE\"},\n", + ")\n", + "\n", + "env = gym.make(\"Pendulum-v1\", render_mode=\"rgb_array\")\n", + "evaluator = GymEvaluator(\n", + " env=env,\n", + " action_space_names=ACTION_NAMES,\n", + " observation_space_names=OBSERVATION_NAMES,\n", + " max_workers=1,\n", + ")\n", + "\n", + "# start well off-vertical (but not a full hang-down swing-up) so recovery is quick\n", + "INITIAL_THETA = 2.0\n", + "INITIAL_THETA_DOT = 0.0\n", + "env.unwrapped.state = np.array([INITIAL_THETA, INITIAL_THETA_DOT])\n", + "evaluator._current_observation = np.array(\n", + " [np.cos(INITIAL_THETA), np.sin(INITIAL_THETA), INITIAL_THETA_DOT]\n", + ")\n", + "\n", + "generator = RLGenerator(\n", + " vocs=vocs,\n", + " policy=policy,\n", + " action_space_names=ACTION_NAMES,\n", + " observation_space_names=OBSERVATION_NAMES,\n", + " initial_observation=evaluator.current_observation,\n", + ")\n", + "\n", + "X = Xopt(generator=generator, evaluator=evaluator)\n", + "X\n" + ] + }, + { + "cell_type": "markdown", + "id": "68a64504", + "metadata": {}, + "source": [ + "## Run the trained agent on the pendulum\n", + "\n", + "Step Xopt forward for one episode, capturing a render frame after every step for the\n", + "animation below. Halfway through, we manually kick the pendulum's angular velocity to\n", + "simulate an external disturbance and check that the frozen policy recovers.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "8163417a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
torquerewardterminatedtruncatedinfocos_thetasin_thetatheta_dotnext_cos_thetanext_sin_thetanext_theta_dotxopt_runtimexopt_error
195-0.389575-0.006222FalseFalse{}0.9969670.0778310.0006330.9969640.0778590.0005700.000065False
196-0.389675-0.006226FalseFalse{}0.9969640.0778590.0005700.9969620.0778850.0005130.000074False
197-0.389766-0.006230FalseFalse{}0.9969620.0778850.0005130.9969610.0779080.0004620.000106False
198-0.389847-0.006234FalseFalse{}0.9969610.0779080.0004620.9969590.0779290.0004160.000067False
199-0.389920-0.006237FalseTrue{}0.9969590.0779290.0004160.9969570.0779480.0003750.000128False
\n", + "
" + ], + "text/plain": [ + " torque reward terminated truncated info cos_theta sin_theta \\\n", + "195 -0.389575 -0.006222 False False {} 0.996967 0.077831 \n", + "196 -0.389675 -0.006226 False False {} 0.996964 0.077859 \n", + "197 -0.389766 -0.006230 False False {} 0.996962 0.077885 \n", + "198 -0.389847 -0.006234 False False {} 0.996961 0.077908 \n", + "199 -0.389920 -0.006237 False True {} 0.996959 0.077929 \n", + "\n", + " theta_dot next_cos_theta next_sin_theta next_theta_dot xopt_runtime \\\n", + "195 0.000633 0.996964 0.077859 0.000570 0.000065 \n", + "196 0.000570 0.996962 0.077885 0.000513 0.000074 \n", + "197 0.000513 0.996961 0.077908 0.000462 0.000106 \n", + "198 0.000462 0.996959 0.077929 0.000416 0.000067 \n", + "199 0.000416 0.996957 0.077948 0.000375 0.000128 \n", + "\n", + " xopt_error \n", + "195 False \n", + "196 False \n", + "197 False \n", + "198 False \n", + "199 False " + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "N_STEPS = 200\n", + "PERTURBATION_STEP = N_STEPS // 2\n", + "PERTURBATION_THETA_DOT = 8.0\n", + "\n", + "frames = [env.render()]\n", + "for step in range(N_STEPS):\n", + " X.step()\n", + " if step == PERTURBATION_STEP:\n", + " # simulate an external disturbance: kick the angular velocity mid-flight\n", + " theta, theta_dot = env.unwrapped.state\n", + " env.unwrapped.state = np.array([theta, theta_dot + PERTURBATION_THETA_DOT])\n", + " frames.append(env.render())\n", + "\n", + "env.close()\n", + "X.data.tail()\n" + ] + }, + { + "cell_type": "markdown", + "id": "7ec2c007", + "metadata": {}, + "source": [ + "## Visualize the state trajectory and reward\n", + "\n", + "The dashed line marks the mid-rollout disturbance; the policy was never trained on this\n", + "exact perturbation, so recovery afterward demonstrates its robustness.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "2a299156", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "data = X.data.reset_index(drop=True)\n", + "theta = np.arctan2(data[\"sin_theta\"], data[\"cos_theta\"])\n", + "\n", + "fig, axes = plt.subplots(3, 1, figsize=(7, 7), sharex=True)\n", + "\n", + "axes[0].plot(theta)\n", + "axes[0].set_ylabel(r\"$\\theta$ (rad)\")\n", + "\n", + "axes[1].plot(data[\"theta_dot\"])\n", + "axes[1].set_ylabel(r\"$\\dot{\\theta}$ (rad/s)\")\n", + "\n", + "axes[2].plot(data[\"reward\"].cumsum())\n", + "axes[2].set_ylabel(\"cumulative reward\")\n", + "axes[2].set_xlabel(\"step\")\n", + "\n", + "for ax in axes:\n", + " ax.axvline(PERTURBATION_STEP, color=\"red\", linestyle=\"--\", label=\"perturbation\")\n", + "axes[0].legend()\n", + "\n", + "fig.suptitle(\"RLGenerator rollout: frozen SAC policy recovering from a perturbation\")\n", + "fig.tight_layout()\n" + ] + }, + { + "cell_type": "markdown", + "id": "22214cd4", + "metadata": {}, + "source": [ + "## Animate the pendulum swing-up inline\n", + "\n", + "Renders the captured `rgb_array` frames as an inline JS animation (`to_jshtml`, no\n", + "`ffmpeg` required).\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "4059503f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
\n", + " \n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + "
\n", + "
\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fig_anim, ax_anim = plt.subplots(figsize=(4, 4))\n", + "ax_anim.axis(\"off\")\n", + "im = ax_anim.imshow(frames[0])\n", + "\n", + "\n", + "def _update(frame):\n", + " im.set_data(frame)\n", + " return (im,)\n", + "\n", + "\n", + "ani = animation.FuncAnimation(fig_anim, _update, frames=frames, interval=50, blit=True)\n", + "plt.close(fig_anim)\n", + "HTML(ani.to_jshtml())\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "xopt-dev", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/examples/rl/inverted_pendulum.py b/docs/examples/rl/inverted_pendulum.py new file mode 100644 index 000000000..870cb2c89 --- /dev/null +++ b/docs/examples/rl/inverted_pendulum.py @@ -0,0 +1,92 @@ +""" +Reinforcement-learning example: swing up an inverted pendulum with Xopt. + +This script has two independent parts: + +1. ``train_policy`` trains a SAC policy on gymnasium's ``Pendulum-v1`` with + stable-baselines3, entirely outside of Xopt (the policy is just saved to disk). +2. ``run_with_xopt`` loads that frozen policy and deploys it through + ``RLGenerator`` + ``GymEvaluator`` to run one Xopt-driven rollout. + +Run with: ``python docs/examples/rl/inverted_pendulum.py`` +Requires the optional ``rl`` extra: ``pip install xopt[rl]``. +""" + +from pathlib import Path + +import gymnasium as gym +import matplotlib.pyplot as plt +from stable_baselines3 import SAC + +from gest_api.vocs import VOCS +from xopt import Xopt +from xopt.evaluator import GymEvaluator +from xopt.generators.rl_generator import RLGenerator +from xopt.vocs import ContextualVariable + +MODEL_PATH = Path(__file__).parent / "sac_pendulum.zip" +ACTION_NAMES = ["torque"] +OBSERVATION_NAMES = ["cos_theta", "sin_theta", "theta_dot"] + + +def train_policy() -> SAC: + """Train (or load a previously cached) SAC policy on Pendulum-v1.""" + if MODEL_PATH.exists(): + return SAC.load(MODEL_PATH) + + env = gym.make("Pendulum-v1") + model = SAC("MlpPolicy", env, verbose=0) + model.learn(total_timesteps=20_000) + model.save(MODEL_PATH) + env.close() + return model + + +def run_with_xopt(policy: SAC, n_steps: int = 200): + """Deploy the frozen policy inside Xopt via RLGenerator + GymEvaluator.""" + vocs = VOCS( + variables={ + "torque": [-2.0, 2.0], + "cos_theta": ContextualVariable(), + "sin_theta": ContextualVariable(), + "theta_dot": ContextualVariable(), + }, + objectives={"reward": "MAXIMIZE"}, + ) + + env = gym.make("Pendulum-v1") + evaluator = GymEvaluator( + env=env, + action_space_names=ACTION_NAMES, + observation_space_names=OBSERVATION_NAMES, + max_workers=1, + ) + generator = RLGenerator( + vocs=vocs, + policy=policy, + action_space_names=ACTION_NAMES, + observation_space_names=OBSERVATION_NAMES, + initial_observation=evaluator.current_observation, + ) + + X = Xopt(generator=generator, evaluator=evaluator) + for _ in range(n_steps): + X.step() + + env.close() + return X.data + + +if __name__ == "__main__": + trained_policy = train_policy() + data = run_with_xopt(trained_policy) + + print(f"ran {len(data)} steps, cumulative reward = {data['reward'].sum():.2f}") + + plt.plot(data["reward"].cumsum()) + plt.xlabel("step") + plt.ylabel("cumulative reward") + plt.title("Inverted pendulum: RLGenerator rollout with a frozen SAC policy") + plot_path = Path(__file__).parent / "inverted_pendulum_reward.png" + plt.savefig(plot_path) + print(f"saved plot to {plot_path}") diff --git a/pyproject.toml b/pyproject.toml index 0fbb7b02e..7b0514d9c 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -31,7 +31,7 @@ dependencies = [ "tqdm", "orjson", "matplotlib", - "gest-api>=0.2" + "gest-api" ] description = "Flexible optimization of arbitrary problems in Python." dynamic = [ "version" ] @@ -66,6 +66,11 @@ doc = [ "mkdocstrings", "mkdocstrings-python", ] +rl = [ + "gymnasium", + "stable-baselines3", + "pygame", +] [project.urls] Homepage = "https://github.com/xopt-org/xopt" diff --git a/xopt/evaluator.py b/xopt/evaluator.py index ed7768237..f52d4ce85 100644 --- a/xopt/evaluator.py +++ b/xopt/evaluator.py @@ -2,12 +2,15 @@ from concurrent.futures import Executor, Future, ProcessPoolExecutor from enum import Enum from threading import Lock -from typing import Callable, Dict, List, Union +from typing import TYPE_CHECKING, Callable, Dict, List, Optional, Union import numpy as np import pandas as pd from pandas import DataFrame -from pydantic import ConfigDict, Field, model_validator +from pydantic import ConfigDict, Field, PrivateAttr, model_validator + +if TYPE_CHECKING: + import gymnasium as gym from xopt.errors import XoptError from xopt.pydantic import NormalExecutor, XoptBaseModel @@ -437,3 +440,145 @@ def shutdown(self, wait: bool = True): """ with self._shutdownLock: self._shutdown = True + + +try: + import gymnasium as gym # noqa: F811 + + _HAS_GYMNASIUM = True +except ModuleNotFoundError: + _HAS_GYMNASIUM = False + +if not _HAS_GYMNASIUM: + logger.debug("gymnasium not installed, GymEvaluator is not available") +else: + + class GymEvaluator(Evaluator): + """ + Evaluator for OpenAI Gym environments. + + Parameters + ---------- + env : gym.Env + The Gym environment. + action_space_names : List[str] + Names of action space dimensions. + observation_space_names : List[str] + Names of observation space dimensions. + """ + + env: gym.Env + action_space_names: List[str] + observation_space_names: List[str] + action_history: List[np.ndarray] = [] + action_mode: str + + # state the environment is in right now, i.e. the state the *next* action + # will be applied to. Tracked internally since env.step() only returns the + # state *after* the action, and env.reset()'s return value would otherwise + # be discarded. + _current_observation: Optional[np.ndarray] = PrivateAttr(default=None) + + def __init__( + self, + env: gym.Env, + action_space_names: List[str], + observation_space_names: List[str], + **kwargs, + ): + """ + Initialize the GymEvaluator. + + Parameters + ---------- + env : gym.Env + The name of the environment. + action_space_names : List[str] + Names of action space dimensions. + observation_space_names : List[str] + Names of observation space dimensions. + """ + + if hasattr(env, "action_mode"): + action_mode = env.action_mode + else: + action_mode = "delta" + + logger.debug(f"Using action mode: {action_mode}") + + function = self._evaluate_function + + super().__init__( + env=env, + action_space_names=action_space_names, + observation_space_names=observation_space_names, + function=function, + action_mode=action_mode, + **kwargs, + ) + self.reset() + + def reset(self): + """ + Reset the environment and clear the action history. + """ + observation, _ = self.env.reset() + self._current_observation = observation + self.action_history = [] + + @property + def current_observation(self) -> Dict[str, float]: + """Current observation dict, i.e. the state the next action will be applied to.""" + return { + name: float(self._current_observation[i]) + for i, name in enumerate(self.observation_space_names) + } + + def _evaluate_function(self, x: dict) -> dict: + """ + Evaluate the given input using the environment. + + Parameters + ---------- + x : dict + The input dictionary to evaluate. + + Returns + ------- + dict + The evaluation results. + """ + xopt_action = np.array([x[name] for name in self.action_space_names]) + + # if self.action_mode == "delta": + # action = target_state - self.current_action_state + # else: + # action = target_state + action = xopt_action + + # snapshot the state the action is actually applied to -- env.step() + # computes reward from this state, not from the state it returns, so + # pairing the action with the returned observation would associate it + # with the wrong (resulting, not originating) state. + state = self._current_observation + + observation, reward, terminated, truncated, info = self.env.step(action) + self.action_history.append(action) + self._current_observation = observation + + observations = { + name: float(state[i]) + for i, name in enumerate(self.observation_space_names) + } + next_observations = { + f"next_{name}": float(observation[i]) + for i, name in enumerate(self.observation_space_names) + } + + # TODO: Multi-objective support + return { + "reward": reward, + "terminated": terminated, + "truncated": truncated, + "info": info, + } | observations | next_observations \ No newline at end of file diff --git a/xopt/generators/__init__.py b/xopt/generators/__init__.py index 776ed8d32..f4d1794de 100644 --- a/xopt/generators/__init__.py +++ b/xopt/generators/__init__.py @@ -28,6 +28,7 @@ "ga": {"cnsga", "nsga2"}, "es": {"extremum_seeking"}, "rcds": {"rcds"}, + "rl": {"rl_policy"}, } @@ -125,6 +126,11 @@ def get_generator_dynamic(name: str) -> type[Generator]: generators[name] = RCDSGenerator return RCDSGenerator + elif name in all_generator_names["rl"]: + from xopt.generators.rl_generator import RLGenerator + + generators[name] = RLGenerator + return RLGenerator raise KeyError diff --git a/xopt/generators/rl_generator.py b/xopt/generators/rl_generator.py new file mode 100644 index 000000000..64f8ac1a7 --- /dev/null +++ b/xopt/generators/rl_generator.py @@ -0,0 +1,104 @@ +import logging +from typing import Any, ClassVar, Dict, List + +import numpy as np +from pydantic import ConfigDict, model_validator + +from xopt.errors import GeneratorError, VOCSError +from xopt.generator import Generator +from xopt.vocs import ContextualVariable + +from gest_api.vocs import ContinuousVariable + +logger = logging.getLogger(__name__) + + +class RLGenerator(Generator): + """ + Generator that deploys a reinforcement-learning policy trained externally + (outside Xopt) against a stateful evaluator such as `GymEvaluator`. + + The policy must expose a stable-baselines3 style + ``predict(observation, deterministic) -> (action, state)`` method. Xopt does + not train or update the policy; it is only used for inference. + + Parameters + ---------- + policy : Any + Trained policy object with a ``predict(observation, deterministic)`` method. + action_space_names : List[str] + VOCS variable names the policy's action maps to, in policy output order. + observation_space_names : List[str] + VOCS variable names the policy's observation is built from, in policy input order. + initial_observation : Dict[str, float] + Observation used to select the very first action, before any data exists. + deterministic : bool, default=True + Whether to sample the policy deterministically. + """ + + name: ClassVar[str] = "rl_policy" + supports_batch_generation: bool = False + supports_single_objective: bool = True + supports_multi_objective: bool = False + supports_constraints: bool = False + supports_discrete_variables: bool = False + supports_contextual_variables: bool = True + + policy: Any + action_space_names: List[str] + observation_space_names: List[str] + initial_observation: Dict[str, float] + deterministic: bool = True + + model_config = ConfigDict(arbitrary_types_allowed=True) + + @model_validator(mode="after") + def _validate_rl_names(self): + for name in self.action_space_names: + if name not in self.vocs.variables: + raise VOCSError(f"action variable `{name}` not found in vocs.variables") + if isinstance(self.vocs.variables[name], ContextualVariable): + raise VOCSError( + f"action variable `{name}` cannot be a ContextualVariable" + ) + if not isinstance(self.vocs.variables[name], ContinuousVariable): + raise VOCSError(f"action variable `{name}` must be a ContinuousVariable") + + for name in self.observation_space_names: + if name not in self.vocs.variables: + raise VOCSError( + f"observation variable `{name}` not found in vocs.variables" + ) + if not isinstance(self.vocs.variables[name], ContextualVariable): + raise VOCSError( + f"observation variable `{name}` must be a ContextualVariable" + ) + + missing = set(self.observation_space_names) - set(self.initial_observation) + if missing: + raise VOCSError(f"initial_observation is missing entries for {missing}") + + return self + + def _current_observation(self) -> Dict[str, float]: + """Latest known observation, from the last evaluated row or the initial fallback.""" + if self.data is None or len(self.data) == 0: + return self.initial_observation + + last_row = self.data.iloc[-1] + return {name: float(last_row[f"next_{name}"]) for name in self.observation_space_names} + + def generate(self, n_candidates: int) -> List[Dict[str, float]]: + if n_candidates != 1: + raise GeneratorError( + "RLGenerator only supports generating one candidate at a time" + ) + + observation = self._current_observation() + obs_array = np.array([observation[name] for name in self.observation_space_names]) + + action, _state = self.policy.predict(obs_array, deterministic=self.deterministic) + + return [ + {name: float(action[i]) for i, name in enumerate(self.action_space_names)} + ] diff --git a/xopt/tests/generators/test_rl_generator.py b/xopt/tests/generators/test_rl_generator.py new file mode 100644 index 000000000..0b7fff3e6 --- /dev/null +++ b/xopt/tests/generators/test_rl_generator.py @@ -0,0 +1,108 @@ +import numpy as np +import pytest + +from xopt import Xopt +from xopt.errors import GeneratorError, VOCSError +from xopt.generators.rl_generator import RLGenerator +from xopt.vocs import ContextualVariable + +from gest_api.vocs import VOCS + + +class StubPolicy: + """Fixed-action stand-in for a trained stable-baselines3 policy.""" + + def predict(self, observation, deterministic=True): + return np.array([0.0]), None + + +def _build_vocs(): + return VOCS( + variables={ + "torque": [-2.0, 2.0], + "cos_theta": ContextualVariable(), + "sin_theta": ContextualVariable(), + "theta_dot": ContextualVariable(), + }, + objectives={"reward": "MAXIMIZE"}, + ) + + +class TestRLGenerator: + def test_generate_uses_initial_observation(self): + vocs = _build_vocs() + obs_names = ["cos_theta", "sin_theta", "theta_dot"] + generator = RLGenerator( + vocs=vocs, + policy=StubPolicy(), + action_space_names=["torque"], + observation_space_names=obs_names, + initial_observation={"cos_theta": 1.0, "sin_theta": 0.0, "theta_dot": 0.0}, + ) + + candidates = generator.generate(1) + assert candidates == [{"torque": 0.0}] + + def test_generate_rejects_batch(self): + vocs = _build_vocs() + generator = RLGenerator( + vocs=vocs, + policy=StubPolicy(), + action_space_names=["torque"], + observation_space_names=["cos_theta", "sin_theta", "theta_dot"], + initial_observation={"cos_theta": 1.0, "sin_theta": 0.0, "theta_dot": 0.0}, + ) + with pytest.raises(GeneratorError): + generator.generate(2) + + def test_action_name_must_be_continuous(self): + vocs = _build_vocs() + with pytest.raises(VOCSError): + RLGenerator( + vocs=vocs, + policy=StubPolicy(), + action_space_names=["cos_theta"], + observation_space_names=["sin_theta", "theta_dot"], + initial_observation={"sin_theta": 0.0, "theta_dot": 0.0}, + ) + + def test_observation_name_must_be_contextual_variable(self): + vocs = _build_vocs() + with pytest.raises(VOCSError): + RLGenerator( + vocs=vocs, + policy=StubPolicy(), + action_space_names=["torque"], + observation_space_names=["torque"], + initial_observation={"torque": 0.0}, + ) + + def test_run_with_gym_evaluator(self): + gym = pytest.importorskip("gymnasium") + from xopt.evaluator import GymEvaluator + + vocs = _build_vocs() + obs_names = ["cos_theta", "sin_theta", "theta_dot"] + env = gym.make("Pendulum-v1") + evaluator = GymEvaluator( + env=env, + action_space_names=["torque"], + observation_space_names=obs_names, + max_workers=1, + ) + generator = RLGenerator( + vocs=vocs, + policy=StubPolicy(), + action_space_names=["torque"], + observation_space_names=obs_names, + initial_observation=evaluator.current_observation, + ) + + X = Xopt(generator=generator, evaluator=evaluator) + for _ in range(3): + X.step() + + assert len(X.data) == 3 + for name in obs_names: + assert f"next_{name}" in X.data.columns + assert all(X.data["torque"] == 0.0) diff --git a/xopt/tests/test_evaluator.py b/xopt/tests/test_evaluator.py index 8029c30f4..f3158d492 100644 --- a/xopt/tests/test_evaluator.py +++ b/xopt/tests/test_evaluator.py @@ -192,3 +192,35 @@ def test_evaluate_data_vectorized(self): assert result.shape[0] == 5 assert "f" in result.columns assert all(result["f"] == candidates["x1"] ** 2 + candidates["x2"] ** 2) + + +class TestGymEvaluator: + def test_current_observation_and_step(self): + gym = pytest.importorskip("gymnasium") + from xopt.evaluator import GymEvaluator + + env = gym.make("Pendulum-v1") + obs_names = ["cos_theta", "sin_theta", "theta_dot"] + evaluator = GymEvaluator( + env=env, + action_space_names=["torque"], + observation_space_names=obs_names, + ) + + # current_observation should match the reset observation + env.reset(seed=0) + evaluator.reset() + assert evaluator.current_observation == { + name: pytest.approx(float(evaluator._current_observation[i])) + for i, name in enumerate(obs_names) + } + + result = evaluator.evaluate({"torque": 0.0}) + assert set(obs_names).issubset(result) + assert {f"next_{n}" for n in obs_names}.issubset(result) + assert "reward" in result + + # current_observation should now reflect the post-step state + assert evaluator.current_observation == { + name: pytest.approx(result[f"next_{name}"]) for name in obs_names + } diff --git a/xopt/tests/test_generator.py b/xopt/tests/test_generator.py index 98cb237c4..322a19a78 100644 --- a/xopt/tests/test_generator.py +++ b/xopt/tests/test_generator.py @@ -16,6 +16,13 @@ from gest_api.vocs import VOCS +class _StubPolicy: + """Fixed-action stand-in for a trained RL policy, used in generator serialization tests.""" + + def predict(self, observation, deterministic=True): + return [0.0], None + + class PatchGenerator(Generator): """ Test generator class for testing purposes. @@ -115,6 +122,18 @@ def test_serialization_loading(self, name): ).model_dump() json.dumps(gen_config) + gen_class(vocs=test_vocs, **gen_config) + elif name in ["rl_policy"]: + # policy is an externally-trained runtime object, not JSON-serializable by design + test_vocs = VOCS( + variables={"x1": [0, 1], "obs": ContextualVariable()}, + objectives={"y1": "MINIMIZE"}, + ) + gen_config["policy"] = _StubPolicy() + gen_config["action_space_names"] = ["x1"] + gen_config["observation_space_names"] = ["obs"] + gen_config["initial_observation"] = {"obs": 0.0} + gen_class(vocs=test_vocs, **gen_config) else: test_vocs = deepcopy(TEST_VOCS_BASE) diff --git a/xopt/vocs.py b/xopt/vocs.py index d132fc97e..d402ede97 100644 --- a/xopt/vocs.py +++ b/xopt/vocs.py @@ -17,15 +17,28 @@ from xopt.errors import FeasibilityError from gest_api.vocs import ( VOCS, + ContinuousVariable, GreaterThanConstraint, LessThanConstraint, BoundsConstraint, DiscreteVariable, MaximizeObjective, - ContextualVariable, ) +class ContextualVariable(ContinuousVariable): + """ + A variable that is not optimized over, but rather is observed and can be conditioned on. + + By default, contextual variables are unbounded. In contexts that require finite bounds, + bounds are inferred from the currently available data. + """ + + def __init__(self, **kwargs): + kwargs.setdefault("domain", [-float("inf"), float("inf")]) + super().__init__(**kwargs) + + def resolve_contextual_variable_bounds( variable: ContextualVariable, data: pd.Series | None, @@ -634,56 +647,6 @@ def get_feasibility_data( return fdata -def get_local_region(vocs: VOCS, center_point: dict, fraction: float = 0.1) -> dict: - """ - Calculates the bounds of a local region around a center point with side lengths - equal to a fixed fraction of the input space for each variable - - Parameters - ---------- - vocs : VOCS - The variable-objective-constraint space (VOCS) defining the problem. - center_point : dict - A dictionary representing the center point of the local region. The keys should match - the variable names in the VOCS, and the values should be the corresponding - values for each variable. - fraction : float, optional - The fraction of the input space to define the local region. Defaults to 0.1 (10%). - - Returns - ------- - dict - A dictionary containing the bounds of the local region for each variable. - - """ - if not center_point.keys() == set(vocs.variable_names): - raise KeyError("Center point keys must match vocs variable names") - - bounds = {} - widths = { - ele: vocs.variables[ele].domain[1] - vocs.variables[ele].domain[0] - for ele in vocs.variable_names - } - - for name in vocs.variable_names: - bounds[name] = [ - np.max( - ( - center_point[name] - widths[name] * fraction, - vocs.variables[name].domain[0], - ) - ), - np.min( - ( - center_point[name] + widths[name] * fraction, - vocs.variables[name].domain[1], - ) - ), - ] - - return bounds - - def normalize_inputs(vocs: VOCS, input_points: pd.DataFrame) -> pd.DataFrame: """ Normalize input data (transform data into the range [0,1]) based on the From 66918e97dc50083121668b05d22778c119200ea9 Mon Sep 17 00:00:00 2001 From: Ryan Roussel Date: Mon, 14 Sep 2026 11:59:39 -0500 Subject: [PATCH 2/6] restore vocs --- xopt/vocs.py | 65 +++++++++++++++++++++++++++++++++++++++++----------- 1 file changed, 51 insertions(+), 14 deletions(-) diff --git a/xopt/vocs.py b/xopt/vocs.py index d402ede97..d132fc97e 100644 --- a/xopt/vocs.py +++ b/xopt/vocs.py @@ -17,28 +17,15 @@ from xopt.errors import FeasibilityError from gest_api.vocs import ( VOCS, - ContinuousVariable, GreaterThanConstraint, LessThanConstraint, BoundsConstraint, DiscreteVariable, MaximizeObjective, + ContextualVariable, ) -class ContextualVariable(ContinuousVariable): - """ - A variable that is not optimized over, but rather is observed and can be conditioned on. - - By default, contextual variables are unbounded. In contexts that require finite bounds, - bounds are inferred from the currently available data. - """ - - def __init__(self, **kwargs): - kwargs.setdefault("domain", [-float("inf"), float("inf")]) - super().__init__(**kwargs) - - def resolve_contextual_variable_bounds( variable: ContextualVariable, data: pd.Series | None, @@ -647,6 +634,56 @@ def get_feasibility_data( return fdata +def get_local_region(vocs: VOCS, center_point: dict, fraction: float = 0.1) -> dict: + """ + Calculates the bounds of a local region around a center point with side lengths + equal to a fixed fraction of the input space for each variable + + Parameters + ---------- + vocs : VOCS + The variable-objective-constraint space (VOCS) defining the problem. + center_point : dict + A dictionary representing the center point of the local region. The keys should match + the variable names in the VOCS, and the values should be the corresponding + values for each variable. + fraction : float, optional + The fraction of the input space to define the local region. Defaults to 0.1 (10%). + + Returns + ------- + dict + A dictionary containing the bounds of the local region for each variable. + + """ + if not center_point.keys() == set(vocs.variable_names): + raise KeyError("Center point keys must match vocs variable names") + + bounds = {} + widths = { + ele: vocs.variables[ele].domain[1] - vocs.variables[ele].domain[0] + for ele in vocs.variable_names + } + + for name in vocs.variable_names: + bounds[name] = [ + np.max( + ( + center_point[name] - widths[name] * fraction, + vocs.variables[name].domain[0], + ) + ), + np.min( + ( + center_point[name] + widths[name] * fraction, + vocs.variables[name].domain[1], + ) + ), + ] + + return bounds + + def normalize_inputs(vocs: VOCS, input_points: pd.DataFrame) -> pd.DataFrame: """ Normalize input data (transform data into the range [0,1]) based on the From d2311341abf8382f424cab75432e728beb2ea0ae Mon Sep 17 00:00:00 2001 From: Ryan Roussel Date: Mon, 14 Sep 2026 12:02:12 -0500 Subject: [PATCH 3/6] linting --- docs/examples/rl/inverted_pendulum.ipynb | 14105 +-------------------- xopt/evaluator.py | 16 +- xopt/generators/rl_generator.py | 17 +- 3 files changed, 40 insertions(+), 14098 deletions(-) diff --git a/docs/examples/rl/inverted_pendulum.ipynb b/docs/examples/rl/inverted_pendulum.ipynb index c94c2d6bf..93c9be5c4 100644 --- a/docs/examples/rl/inverted_pendulum.ipynb +++ b/docs/examples/rl/inverted_pendulum.ipynb @@ -29,7 +29,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "id": "be07dc11", "metadata": {}, "outputs": [], @@ -51,7 +51,7 @@ "\n", "MODEL_PATH = Path(\"sac_pendulum.zip\")\n", "ACTION_NAMES = [\"torque\"]\n", - "OBSERVATION_NAMES = [\"cos_theta\", \"sin_theta\", \"theta_dot\"]\n" + "OBSERVATION_NAMES = [\"cos_theta\", \"sin_theta\", \"theta_dot\"]" ] }, { @@ -67,21 +67,10 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "id": "0d80d8b4", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "if MODEL_PATH.exists():\n", " policy = SAC.load(MODEL_PATH)\n", @@ -92,7 +81,7 @@ " policy.save(MODEL_PATH)\n", " train_env.close()\n", "\n", - "policy\n" + "policy" ] }, { @@ -116,104 +105,10 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "id": "edf5dcd3", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "\n", - " Xopt\n", - "________________________________\n", - "Version: 3.0.2.dev40+g9eb7a7409.d20260604\n", - "Data size: 0\n", - "Config as YAML:\n", - "data_dump_file: null\n", - "evaluator:\n", - " action_history: []\n", - " action_mode: delta\n", - " action_space_names:\n", - " - torque\n", - " env: gymnasium.wrappers.common.TimeLimit\n", - " function: xopt.evaluator.GymEvaluator._evaluate_function\n", - " function_kwargs: {}\n", - " max_workers: 1\n", - " observation_space_names:\n", - " - cos_theta\n", - " - sin_theta\n", - " - theta_dot\n", - " vectorized: false\n", - "generator:\n", - " action_space_names:\n", - " - torque\n", - " deterministic: true\n", - " initial_observation:\n", - " cos_theta: -0.4161468365471424\n", - " sin_theta: 0.9092974268256817\n", - " theta_dot: 0.0\n", - " name: rl_policy\n", - " observation_space_names:\n", - " - cos_theta\n", - " - sin_theta\n", - " - theta_dot\n", - " policy: stable_baselines3.sac.sac.SAC\n", - " returns_id: false\n", - " supports_batch_generation: false\n", - " supports_constraints: false\n", - " supports_contextual_variables: true\n", - " supports_discrete_variables: false\n", - " supports_multi_objective: false\n", - " supports_single_objective: true\n", - " vocs:\n", - " constants: {}\n", - " constraints: {}\n", - " objectives:\n", - " reward:\n", - " dtype: null\n", - " type: MaximizeObjective\n", - " observables: {}\n", - " variables:\n", - " cos_theta:\n", - " default_value: null\n", - " domain:\n", - " - -inf\n", - " - inf\n", - " dtype: null\n", - " type: ContextualVariable\n", - " sin_theta:\n", - " default_value: null\n", - " domain:\n", - " - -inf\n", - " - inf\n", - " dtype: null\n", - " type: ContextualVariable\n", - " theta_dot:\n", - " default_value: null\n", - " domain:\n", - " - -inf\n", - " - inf\n", - " dtype: null\n", - " type: ContextualVariable\n", - " torque:\n", - " default_value: null\n", - " domain:\n", - " - -2.0\n", - " - 2.0\n", - " dtype: null\n", - " type: ContinuousVariable\n", - "serialize_inline: false\n", - "serialize_torch: false\n", - "stopping_condition: null\n", - "strict: true\n", - "xopt_dump_file: null\n" - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "vocs = VOCS(\n", " variables={\n", @@ -250,7 +145,7 @@ ")\n", "\n", "X = Xopt(generator=generator, evaluator=evaluator)\n", - "X\n" + "X" ] }, { @@ -267,159 +162,10 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": null, "id": "8163417a", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
torquerewardterminatedtruncatedinfocos_thetasin_thetatheta_dotnext_cos_thetanext_sin_thetanext_theta_dotxopt_runtimexopt_error
195-0.389575-0.006222FalseFalse{}0.9969670.0778310.0006330.9969640.0778590.0005700.000065False
196-0.389675-0.006226FalseFalse{}0.9969640.0778590.0005700.9969620.0778850.0005130.000074False
197-0.389766-0.006230FalseFalse{}0.9969620.0778850.0005130.9969610.0779080.0004620.000106False
198-0.389847-0.006234FalseFalse{}0.9969610.0779080.0004620.9969590.0779290.0004160.000067False
199-0.389920-0.006237FalseTrue{}0.9969590.0779290.0004160.9969570.0779480.0003750.000128False
\n", - "
" - ], - "text/plain": [ - " torque reward terminated truncated info cos_theta sin_theta \\\n", - "195 -0.389575 -0.006222 False False {} 0.996967 0.077831 \n", - "196 -0.389675 -0.006226 False False {} 0.996964 0.077859 \n", - "197 -0.389766 -0.006230 False False {} 0.996962 0.077885 \n", - "198 -0.389847 -0.006234 False False {} 0.996961 0.077908 \n", - "199 -0.389920 -0.006237 False True {} 0.996959 0.077929 \n", - "\n", - " theta_dot next_cos_theta next_sin_theta next_theta_dot xopt_runtime \\\n", - "195 0.000633 0.996964 0.077859 0.000570 0.000065 \n", - "196 0.000570 0.996962 0.077885 0.000513 0.000074 \n", - "197 0.000513 0.996961 0.077908 0.000462 0.000106 \n", - "198 0.000462 0.996959 0.077929 0.000416 0.000067 \n", - "199 0.000416 0.996957 0.077948 0.000375 0.000128 \n", - "\n", - " xopt_error \n", - "195 False \n", - "196 False \n", - "197 False \n", - "198 False \n", - "199 False " - ] - }, - "execution_count": 26, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "N_STEPS = 200\n", "PERTURBATION_STEP = N_STEPS // 2\n", @@ -435,7 +181,7 @@ " frames.append(env.render())\n", "\n", "env.close()\n", - "X.data.tail()\n" + "X.data.tail()" ] }, { @@ -451,21 +197,10 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": null, "id": "2a299156", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "data = X.data.reset_index(drop=True)\n", "theta = np.arctan2(data[\"sin_theta\"], data[\"cos_theta\"])\n", @@ -487,7 +222,7 @@ "axes[0].legend()\n", "\n", "fig.suptitle(\"RLGenerator rollout: frozen SAC policy recovering from a perturbation\")\n", - "fig.tight_layout()\n" + "fig.tight_layout()" ] }, { @@ -503,13816 +238,10 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": null, "id": "4059503f", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
\n", - " \n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - "
\n", - "
\n", - "\n", - "\n", - "\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "fig_anim, ax_anim = plt.subplots(figsize=(4, 4))\n", "ax_anim.axis(\"off\")\n", @@ -14326,7 +255,7 @@ "\n", "ani = animation.FuncAnimation(fig_anim, _update, frames=frames, interval=50, blit=True)\n", "plt.close(fig_anim)\n", - "HTML(ani.to_jshtml())\n" + "HTML(ani.to_jshtml())" ] } ], diff --git a/xopt/evaluator.py b/xopt/evaluator.py index f52d4ce85..ba169d149 100644 --- a/xopt/evaluator.py +++ b/xopt/evaluator.py @@ -576,9 +576,13 @@ def _evaluate_function(self, x: dict) -> dict: } # TODO: Multi-objective support - return { - "reward": reward, - "terminated": terminated, - "truncated": truncated, - "info": info, - } | observations | next_observations \ No newline at end of file + return ( + { + "reward": reward, + "terminated": terminated, + "truncated": truncated, + "info": info, + } + | observations + | next_observations + ) diff --git a/xopt/generators/rl_generator.py b/xopt/generators/rl_generator.py index 64f8ac1a7..95dfa6f8e 100644 --- a/xopt/generators/rl_generator.py +++ b/xopt/generators/rl_generator.py @@ -62,7 +62,9 @@ def _validate_rl_names(self): f"action variable `{name}` cannot be a ContextualVariable" ) if not isinstance(self.vocs.variables[name], ContinuousVariable): - raise VOCSError(f"action variable `{name}` must be a ContinuousVariable") + raise VOCSError( + f"action variable `{name}` must be a ContinuousVariable" + ) for name in self.observation_space_names: if name not in self.vocs.variables: @@ -86,7 +88,10 @@ def _current_observation(self) -> Dict[str, float]: return self.initial_observation last_row = self.data.iloc[-1] - return {name: float(last_row[f"next_{name}"]) for name in self.observation_space_names} + return { + name: float(last_row[f"next_{name}"]) + for name in self.observation_space_names + } def generate(self, n_candidates: int) -> List[Dict[str, float]]: if n_candidates != 1: @@ -95,9 +100,13 @@ def generate(self, n_candidates: int) -> List[Dict[str, float]]: ) observation = self._current_observation() - obs_array = np.array([observation[name] for name in self.observation_space_names]) + obs_array = np.array( + [observation[name] for name in self.observation_space_names] + ) - action, _state = self.policy.predict(obs_array, deterministic=self.deterministic) + action, _state = self.policy.predict( + obs_array, deterministic=self.deterministic + ) return [ {name: float(action[i]) for i, name in enumerate(self.action_space_names)} From 1be6a28c77d57ff2c49cc79dc95e00f58010b01e Mon Sep 17 00:00:00 2001 From: Ryan Roussel Date: Mon, 14 Sep 2026 12:10:54 -0500 Subject: [PATCH 4/6] add smoke test to reduce training --- docs/examples/rl/inverted_pendulum.ipynb | 14445 ++++++++++++++++++++- 1 file changed, 14433 insertions(+), 12 deletions(-) diff --git a/docs/examples/rl/inverted_pendulum.ipynb b/docs/examples/rl/inverted_pendulum.ipynb index 93c9be5c4..44c23168a 100644 --- a/docs/examples/rl/inverted_pendulum.ipynb +++ b/docs/examples/rl/inverted_pendulum.ipynb @@ -29,12 +29,13 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "be07dc11", "metadata": {}, "outputs": [], "source": [ "from pathlib import Path\n", + "import os\n", "\n", "import gymnasium as gym\n", "import matplotlib.pyplot as plt\n", @@ -67,17 +68,39 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "0d80d8b4", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/rroussel/miniforge3/envs/xopt-dev/lib/python3.13/site-packages/torch/cuda/__init__.py:187: UserWarning: CUDA initialization: The NVIDIA driver on your system is too old (found version 12060). Please update your GPU driver by downloading and installing a new version from the URL: http://www.nvidia.com/Download/index.aspx Alternatively, go to: https://pytorch.org to install a PyTorch version that has been compiled with your version of the CUDA driver. (Triggered internally at /pytorch/c10/cuda/CUDAFunctions.cpp:119.)\n", + " return torch._C._cuda_getDeviceCount() > 0\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ + "SMOKE_TEST = os.environ.get(\"SMOKE_TEST\")\n", + "\n", "if MODEL_PATH.exists():\n", " policy = SAC.load(MODEL_PATH)\n", "else:\n", + " n_timesteps = 2 if SMOKE_TEST else 20_000\n", " train_env = gym.make(\"Pendulum-v1\")\n", " policy = SAC(\"MlpPolicy\", train_env, verbose=0)\n", - " policy.learn(total_timesteps=20_000)\n", + " policy.learn(total_timesteps=n_timesteps)\n", " policy.save(MODEL_PATH)\n", " train_env.close()\n", "\n", @@ -105,10 +128,104 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "edf5dcd3", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "\n", + " Xopt\n", + "________________________________\n", + "Version: 3.1.2.dev8+g78579d2fc.d20260629\n", + "Data size: 0\n", + "Config as YAML:\n", + "data_dump_file: null\n", + "evaluator:\n", + " action_history: []\n", + " action_mode: delta\n", + " action_space_names:\n", + " - torque\n", + " env: gymnasium.wrappers.common.TimeLimit\n", + " function: xopt.evaluator.GymEvaluator._evaluate_function\n", + " function_kwargs: {}\n", + " max_workers: 1\n", + " observation_space_names:\n", + " - cos_theta\n", + " - sin_theta\n", + " - theta_dot\n", + " vectorized: false\n", + "generator:\n", + " action_space_names:\n", + " - torque\n", + " deterministic: true\n", + " initial_observation:\n", + " cos_theta: -0.4161468365471424\n", + " sin_theta: 0.9092974268256817\n", + " theta_dot: 0.0\n", + " name: rl_policy\n", + " observation_space_names:\n", + " - cos_theta\n", + " - sin_theta\n", + " - theta_dot\n", + " policy: stable_baselines3.sac.sac.SAC\n", + " returns_id: false\n", + " supports_batch_generation: false\n", + " supports_constraints: false\n", + " supports_contextual_variables: true\n", + " supports_discrete_variables: false\n", + " supports_multi_objective: false\n", + " supports_single_objective: true\n", + " vocs:\n", + " constants: {}\n", + " constraints: {}\n", + " objectives:\n", + " reward:\n", + " dtype: null\n", + " type: MaximizeObjective\n", + " observables: {}\n", + " variables:\n", + " cos_theta:\n", + " default_value: null\n", + " domain:\n", + " - -inf\n", + " - inf\n", + " dtype: null\n", + " type: ContextualVariable\n", + " sin_theta:\n", + " default_value: null\n", + " domain:\n", + " - -inf\n", + " - inf\n", + " dtype: null\n", + " type: ContextualVariable\n", + " theta_dot:\n", + " default_value: null\n", + " domain:\n", + " - -inf\n", + " - inf\n", + " dtype: null\n", + " type: ContextualVariable\n", + " torque:\n", + " default_value: null\n", + " domain:\n", + " - -2.0\n", + " - 2.0\n", + " dtype: null\n", + " type: ContinuousVariable\n", + "serialize_inline: false\n", + "serialize_torch: false\n", + "stopping_condition: null\n", + "strict: true\n", + "xopt_dump_file: null\n" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "vocs = VOCS(\n", " variables={\n", @@ -162,10 +279,167 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "8163417a", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/rroussel/miniforge3/envs/xopt-dev/lib/python3.13/site-packages/pygame/pkgdata.py:25: UserWarning: pkg_resources is deprecated as an API. See https://setuptools.pypa.io/en/latest/pkg_resources.html. The pkg_resources package is slated for removal as early as 2025-11-30. Refrain from using this package or pin to Setuptools<81.\n", + " from pkg_resources import resource_stream, resource_exists\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
torquerewardterminatedtruncatedinfocos_thetasin_thetatheta_dotnext_cos_thetanext_sin_thetanext_theta_dotxopt_runtimexopt_error
1950.811645-13.395098FalseFalse{}-0.8790680.4766968.000000-0.9953100.0967418.0000000.000064False
1960.836323-15.670899FalseFalse{}-0.9953100.0967418.000000-0.954414-0.2984888.0000000.000058False
1970.831927-14.457690FalseFalse{}-0.954414-0.2984888.000000-0.766030-0.6428057.9009230.000056False
1980.792272-12.213481FalseFalse{}-0.766030-0.6428057.900923-0.475700-0.8796087.5376610.000063False
1990.720002-9.952805FalseTrue{}-0.475700-0.8796087.537661-0.145939-0.9892946.9859550.000078False
\n", + "
" + ], + "text/plain": [ + " torque reward terminated truncated info cos_theta sin_theta \\\n", + "195 0.811645 -13.395098 False False {} -0.879068 0.476696 \n", + "196 0.836323 -15.670899 False False {} -0.995310 0.096741 \n", + "197 0.831927 -14.457690 False False {} -0.954414 -0.298488 \n", + "198 0.792272 -12.213481 False False {} -0.766030 -0.642805 \n", + "199 0.720002 -9.952805 False True {} -0.475700 -0.879608 \n", + "\n", + " theta_dot next_cos_theta next_sin_theta next_theta_dot xopt_runtime \\\n", + "195 8.000000 -0.995310 0.096741 8.000000 0.000064 \n", + "196 8.000000 -0.954414 -0.298488 8.000000 0.000058 \n", + "197 8.000000 -0.766030 -0.642805 7.900923 0.000056 \n", + "198 7.900923 -0.475700 -0.879608 7.537661 0.000063 \n", + "199 7.537661 -0.145939 -0.989294 6.985955 0.000078 \n", + "\n", + " xopt_error \n", + "195 False \n", + "196 False \n", + "197 False \n", + "198 False \n", + "199 False " + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "N_STEPS = 200\n", "PERTURBATION_STEP = N_STEPS // 2\n", @@ -197,10 +471,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "2a299156", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "data = X.data.reset_index(drop=True)\n", "theta = np.arctan2(data[\"sin_theta\"], data[\"cos_theta\"])\n", @@ -238,10 +523,14138 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "4059503f", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
\n", + " \n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + "
\n", + "
\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "fig_anim, ax_anim = plt.subplots(figsize=(4, 4))\n", "ax_anim.axis(\"off\")\n", @@ -257,6 +14670,14 @@ "plt.close(fig_anim)\n", "HTML(ani.to_jshtml())" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a3fea83d", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From 760f49fc431fed22fafd449cee6f0990ed4c9389 Mon Sep 17 00:00:00 2001 From: Ryan Roussel Date: Tue, 15 Sep 2026 11:52:27 -0500 Subject: [PATCH 5/6] Update test-notebooks.yml --- .github/workflows/test-notebooks.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/test-notebooks.yml b/.github/workflows/test-notebooks.yml index 64ddf12b1..296f39d8a 100644 --- a/.github/workflows/test-notebooks.yml +++ b/.github/workflows/test-notebooks.yml @@ -46,7 +46,7 @@ jobs: mpi: openmpi - name: Install dependencies - run: uv sync --extra dev + run: uv sync --extra dev --extra rl - name: Execute notebooks in parallel id: execute From 759e58c241edb92d583e1cdeddbc0836bc753409 Mon Sep 17 00:00:00 2001 From: Ryan Roussel Date: Tue, 15 Sep 2026 12:08:05 -0500 Subject: [PATCH 6/6] clear outputs --- docs/examples/rl/inverted_pendulum.ipynb | 14431 +-------------------- 1 file changed, 11 insertions(+), 14420 deletions(-) diff --git a/docs/examples/rl/inverted_pendulum.ipynb b/docs/examples/rl/inverted_pendulum.ipynb index 44c23168a..7d693d8f4 100644 --- a/docs/examples/rl/inverted_pendulum.ipynb +++ b/docs/examples/rl/inverted_pendulum.ipynb @@ -29,7 +29,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "be07dc11", "metadata": {}, "outputs": [], @@ -68,29 +68,10 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "0d80d8b4", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/rroussel/miniforge3/envs/xopt-dev/lib/python3.13/site-packages/torch/cuda/__init__.py:187: UserWarning: CUDA initialization: The NVIDIA driver on your system is too old (found version 12060). Please update your GPU driver by downloading and installing a new version from the URL: http://www.nvidia.com/Download/index.aspx Alternatively, go to: https://pytorch.org to install a PyTorch version that has been compiled with your version of the CUDA driver. (Triggered internally at /pytorch/c10/cuda/CUDAFunctions.cpp:119.)\n", - " return torch._C._cuda_getDeviceCount() > 0\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "SMOKE_TEST = os.environ.get(\"SMOKE_TEST\")\n", "\n", @@ -128,104 +109,10 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "edf5dcd3", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "\n", - " Xopt\n", - "________________________________\n", - "Version: 3.1.2.dev8+g78579d2fc.d20260629\n", - "Data size: 0\n", - "Config as YAML:\n", - "data_dump_file: null\n", - "evaluator:\n", - " action_history: []\n", - " action_mode: delta\n", - " action_space_names:\n", - " - torque\n", - " env: gymnasium.wrappers.common.TimeLimit\n", - " function: xopt.evaluator.GymEvaluator._evaluate_function\n", - " function_kwargs: {}\n", - " max_workers: 1\n", - " observation_space_names:\n", - " - cos_theta\n", - " - sin_theta\n", - " - theta_dot\n", - " vectorized: false\n", - "generator:\n", - " action_space_names:\n", - " - torque\n", - " deterministic: true\n", - " initial_observation:\n", - " cos_theta: -0.4161468365471424\n", - " sin_theta: 0.9092974268256817\n", - " theta_dot: 0.0\n", - " name: rl_policy\n", - " observation_space_names:\n", - " - cos_theta\n", - " - sin_theta\n", - " - theta_dot\n", - " policy: stable_baselines3.sac.sac.SAC\n", - " returns_id: false\n", - " supports_batch_generation: false\n", - " supports_constraints: false\n", - " supports_contextual_variables: true\n", - " supports_discrete_variables: false\n", - " supports_multi_objective: false\n", - " supports_single_objective: true\n", - " vocs:\n", - " constants: {}\n", - " constraints: {}\n", - " objectives:\n", - " reward:\n", - " dtype: null\n", - " type: MaximizeObjective\n", - " observables: {}\n", - " variables:\n", - " cos_theta:\n", - " default_value: null\n", - " domain:\n", - " - -inf\n", - " - inf\n", - " dtype: null\n", - " type: ContextualVariable\n", - " sin_theta:\n", - " default_value: null\n", - " domain:\n", - " - -inf\n", - " - inf\n", - " dtype: null\n", - " type: ContextualVariable\n", - " theta_dot:\n", - " default_value: null\n", - " domain:\n", - " - -inf\n", - " - inf\n", - " dtype: null\n", - " type: ContextualVariable\n", - " torque:\n", - " default_value: null\n", - " domain:\n", - " - -2.0\n", - " - 2.0\n", - " dtype: null\n", - " type: ContinuousVariable\n", - "serialize_inline: false\n", - "serialize_torch: false\n", - "stopping_condition: null\n", - "strict: true\n", - "xopt_dump_file: null\n" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "vocs = VOCS(\n", " variables={\n", @@ -279,167 +166,10 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "8163417a", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/rroussel/miniforge3/envs/xopt-dev/lib/python3.13/site-packages/pygame/pkgdata.py:25: UserWarning: pkg_resources is deprecated as an API. See https://setuptools.pypa.io/en/latest/pkg_resources.html. The pkg_resources package is slated for removal as early as 2025-11-30. Refrain from using this package or pin to Setuptools<81.\n", - " from pkg_resources import resource_stream, resource_exists\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
torquerewardterminatedtruncatedinfocos_thetasin_thetatheta_dotnext_cos_thetanext_sin_thetanext_theta_dotxopt_runtimexopt_error
1950.811645-13.395098FalseFalse{}-0.8790680.4766968.000000-0.9953100.0967418.0000000.000064False
1960.836323-15.670899FalseFalse{}-0.9953100.0967418.000000-0.954414-0.2984888.0000000.000058False
1970.831927-14.457690FalseFalse{}-0.954414-0.2984888.000000-0.766030-0.6428057.9009230.000056False
1980.792272-12.213481FalseFalse{}-0.766030-0.6428057.900923-0.475700-0.8796087.5376610.000063False
1990.720002-9.952805FalseTrue{}-0.475700-0.8796087.537661-0.145939-0.9892946.9859550.000078False
\n", - "
" - ], - "text/plain": [ - " torque reward terminated truncated info cos_theta sin_theta \\\n", - "195 0.811645 -13.395098 False False {} -0.879068 0.476696 \n", - "196 0.836323 -15.670899 False False {} -0.995310 0.096741 \n", - "197 0.831927 -14.457690 False False {} -0.954414 -0.298488 \n", - "198 0.792272 -12.213481 False False {} -0.766030 -0.642805 \n", - "199 0.720002 -9.952805 False True {} -0.475700 -0.879608 \n", - "\n", - " theta_dot next_cos_theta next_sin_theta next_theta_dot xopt_runtime \\\n", - "195 8.000000 -0.995310 0.096741 8.000000 0.000064 \n", - "196 8.000000 -0.954414 -0.298488 8.000000 0.000058 \n", - "197 8.000000 -0.766030 -0.642805 7.900923 0.000056 \n", - "198 7.900923 -0.475700 -0.879608 7.537661 0.000063 \n", - "199 7.537661 -0.145939 -0.989294 6.985955 0.000078 \n", - "\n", - " xopt_error \n", - "195 False \n", - "196 False \n", - "197 False \n", - "198 False \n", - "199 False " - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "N_STEPS = 200\n", "PERTURBATION_STEP = N_STEPS // 2\n", @@ -471,21 +201,10 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "2a299156", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAArIAAAKyCAYAAAApeT2AAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnXV4FFf3x7+zFnc3kpAEd3d3CqUtpUJLgVJaCjXq7fuW6o+3Rql7oV6sLjgUd7dACEHiQnST1fv7Y3Y2s8lusrtZmZncz/Ps8yS7s7P3jt1zz/necxhCCAGFQqFQKBQKhSIyZN5uAIVCoVAoFAqF4gzUkKVQKBQKhUKhiBJqyFIoFAqFQqFQRAk1ZCkUCoVCoVAoooQashQKhUKhUCgUUUINWQqFQqFQKBSKKKGGLIVCoVAoFApFlFBDlkKhUCgUCoUiSqghS6FQKBQKhUIRJdSQpUiS7du3g2EYbN++3fze7NmzkZKS4rU2OYJer8dTTz2FpKQkyGQyTJs2zdtNorSAlStXgmEY5OTkmN8bMWIERowY4bU2tTZSUlIwe/Zsr/x2dXU15s2bh9jYWDAMg0cffdQr7aA4BjeOrF271iO/xzAMXnzxRY/8lpSQtCHLDR7cS6FQICEhAbNnz0Zubm6j7UeMGIEuXbrYte8TJ05gzpw5SE1Nha+vLwIDA9GjRw889dRTyM7OdnVXvMoPP/yA5cuXe7sZomDPnj148cUXUV5e3qL9fPXVV3jzzTcxffp0fP3113jsscdc00CB8ccff2D48OGIjo6Gv78/2rZtixkzZmD9+vVWtzcYDIiPjwfDMPjnn3+a3Pcvv/yCiRMnIjIyEiqVCvHx8ZgxYwa2bt3qjq5QKDb5v//7P6xcuRILFizAt99+i7vvvtvbTZIEarUaL774ooXDQuj8/fff1Fh1MQpvN8ATvPzyy0hNTUVdXR327duHlStXYteuXTh16hR8fX0d3t/nn3+OBQsWIDIyEjNnzkSHDh2g1+tx6tQpfPPNN1i+fDlqa2shl8vd0BvP88MPP+DUqVPUi2AHe/bswUsvvYTZs2cjNDTU6f1s3boVCQkJeOedd1zXOIHx1ltv4cknn8Tw4cPx7LPPwt/fH1lZWdi8eTN++uknTJgwodF3tm7divz8fKSkpOD777/HxIkTG21DCMHcuXOxcuVK9OzZE4sXL0ZsbCzy8/Pxyy+/YPTo0di9ezcGDRrkiW7aZOPGjV79/dZGZmYmZDLv+G62bt2KAQMGYMmSJV75famiVqvx0ksvAYBooht///03PvzwQ6vGbG1tLRSKVmGWuZRWccQmTpyIPn36AADmzZuHyMhIvP766/j9998xY8YMh/a1Z88eLFiwAIMHD8aff/6JoKAgi8/ffvttvPbaay5ruztQq9Xw9/f3ahv0ej2MRiNUKpVd2xuNRmi1WqcmHmKkqKjILkPY0eMoFPR6PV555RWMHTvWqkFXVFRk9XvfffcdevXqhXvuuQfPPfccampqEBAQYLHN22+/jZUrV+LRRx/FsmXLwDCM+bPnn38e3377rSAGCyGcM6nfV4QQ1NXVwc/PDz4+Pl5rR1FRETp16tTsdnV1dVCpVF4zuMUCd926C+656mmkeh+6HSJhVqxYQQCQgwcPWrz/559/EgDk//7v/yzeHz58OOncuXOT+xw3bhxRKBTk6tWrDrVl3759ZPz48SQ4OJj4+fmRYcOGkV27dllss2TJEgKAXLhwgdxzzz0kJCSEBAcHk9mzZ5OamppG+/z2229Jr169iK+vLwkLCyO33XYbuXLlitU+HTp0iAwdOpT4+fmRRx55hBBCyK+//komTZpE4uLiiEqlIm3btiUvv/wy0ev1Ft8HYPFKTk42f15YWEjmzp1LoqOjiY+PD+nWrRtZuXKlRRsuXbpEAJA333yTvPPOO6Rt27ZEJpORo0eP2jxeAMjChQvJd999Rzp16kQUCgX55ZdfCCGEHDlyhEyYMIEEBQWRgIAAMmrUKLJ3716L72/bto0AINu2bTO/d88991i0nRBCqquryeLFi0liYiJRqVSkXbt25M033yRGo7FR+1esWGG1nUuWLCGE1J+/hq9Lly4RQggpLi4mZ8+etXouG/5Ww9e2bduaPY5btmwhQ4YMIf7+/iQkJIRMnTqVnDlzptl9cy8+7rhe+eTn5xMA5MUXX2xyOz5qtZoEBQWRN954g+Tn5xOZTEa+//77RtuEh4eTDh06WFzHjsA/zsuWLSNt2rQhvr6+ZNiwYeTkyZONtm/uuBNS/yzirgVC2Htr+PDhFtvV1taSJUuWkIyMDOLj40NiY2PJTTfdRLKysojRaCTJyclk6tSpjdpQW1tLgoODyfz585vsW1P31bVr18icOXNIdHQ0UalUpFOnTuTLL7+0+lu22shhz33VuXNnMmLEiEb7NxgMJD4+ntxyyy0W773zzjukU6dOxMfHh0RHR5P58+eTsrIyi+8mJyeTyZMnk/Xr15PevXsTHx8f8s4775g/u+eee8zbcudk165d5LHHHiORkZHE39+fTJs2jRQVFTVq05IlS0hcXBzx8/MjI0aMIKdPn260z4ZwzyFrzwTusx9//JE8//zzJD4+njAMQ65fv04IIWT16tXm53tERASZOXMmuXbtmsX+77nnHhIQEEAuX75MJk+eTAICAkh8fDz54IMPCCGEnDhxgowcOZL4+/uTNm3aNLpfbPHmm2+SgQMHkvDwcOLr60t69epF1qxZY9d3+WPOwIEDia+vL0lJSSEff/xxo23r6urICy+8QNLS0ohKpSKJiYnkySefJHV1dRbbWbtu33nnHavHlnseW7u/uGPGHweaeq5y5+inn34izz77LImJiSH+/v5kypQpjcbaHTt2kOnTp5OkpCRzXx599FGiVqstfrupZy+//Rz2jHeOXMtSxPtuCS/ALbgICwtz6HtqtRpbt27FiBEjkJiYaPf3tm7diokTJ6J3795YsmQJZDIZVqxYgVGjRmHnzp3o16+fxfYzZsxAamoqli5diiNHjuCLL75AdHQ0Xn/9dfM2r732Gv773/9ixowZmDdvHoqLi/H+++9j2LBhOHr0qIU3r7S0FBMnTsTtt9+Ou+66CzExMQBYDXFgYCAWL16MwMBAbN26FS+88AIqKyvx5ptvAmA9WBUVFbh27Zo5zB0YGAiADYOMGDECWVlZWLRoEVJTU7FmzRrMnj0b5eXleOSRRyz6tWLFCtTV1WH+/Pnw8fFBeHh4s8dt9erVWLRoESIjI5GSkoLTp09j6NChCA4OxlNPPQWlUolPP/0UI0aMwL///ov+/fvbfV4IIZg6dSq2bduGe++9Fz169MCGDRvw5JNPIjc31+Gw/s0334zz58/jxx9/xDvvvIPIyEgAQFRUFADggw8+wEsvvYRt27bZDINFRUXh22+/xWuvvYbq6mosXboUANCxY0fU1tYCsH4cN2/ejIkTJ6Jt27Z48cUXUVtbi/fffx+DBw/GkSNHkJKSYt43H51Oh8cee8zCO+iO67Uh0dHR8PPzwx9//IGHHnqo2WsBAH7//XdUV1fj9ttvR2xsLEaMGIHvv/8ed955p3mbXbt2oaysDI8++miLpT3ffPMNqqqqsHDhQtTV1eHdd9/FqFGjcPLkSfM9ZM9xtxeDwYAbbrgBW7Zswe23345HHnkEVVVV2LRpE06dOoW0tDTcddddeOONN1BWVmZxzP744w9UVlbirrvuavZ3rN1XhYWFGDBgABiGwaJFixAVFYV//vkH9957LyorK82yInvaaO99ddttt+HFF19EQUEBYmNjze3btWsX8vLycPvtt5vfu//++7Fy5UrMmTMHDz/8MC5duoQPPvgAR48exe7du6FUKs3bZmZm4o477sD999+P++67D+3bt2/yeDz00EMICwvDkiVLkJOTg+XLl2PRokVYtWqVeZtnn30Wb7zxBqZMmYLx48fj+PHjGD9+POrq6prcd8eOHfHtt9/iscceQ2JiIh5//HEA7H3OjUOvvPIKVCoVnnjiCWg0GqhUKnNf+/bti6VLl6KwsBDvvvsudu/e3ej5bjAYMHHiRAwbNgxvvPEGvv/+eyxatAgBAQF4/vnnMXPmTNx888345JNPMGvWLAwcOBCpqalNtvvdd9/F1KlTMXPmTGi1Wvz000+49dZb8eeff2Ly5MlNfhcArl+/jkmTJmHGjBm44447sHr1aixYsAAqlQpz584FwHpVp06dil27dmH+/Pno2LEjTp48iXfeeQfnz5/Hr7/+arHPhtdt9+7d8fHHH2PBggW46aabcPPNNwMAunXr1mz7rGHtucqtdXjttdfAMAyefvppFBUVYfny5RgzZgyOHTsGPz8/AMCaNWugVquxYMECRERE4MCBA3j//fdx7do1rFmzBgB7Hefl5WHTpk2NnsXWcHS8s+daliTetqTdCTdL2bx5MykuLiZXr14la9euJVFRUcTHx6eRV7U5j+zx48cJAPLoo482+qy0tJQUFxebXxqNhhBCiNFoJBkZGWT8+PEW3gi1Wk1SU1PJ2LFjze9xHq65c+da7Pumm24iERER5v9zcnKIXC4nr732msV2J0+eJAqFwuJ9zqP6ySefNGozf6bIcf/99xN/f3+LGfHkyZMbeTIJIWT58uUEAPnuu+/M72m1WjJw4EASGBhIKisrCSH1M97g4GC7Z4cAiEwmI6dPn7Z4f9q0aUSlUpGLFy+a38vLyyNBQUFk2LBh5vfs8cj++uuvBAB59dVXLX5j+vTphGEYs4fJXo8sIawnAw08bxzc+eW3yRbWrsWmjmOPHj1IdHQ0KS0tNb93/PhxIpPJyKxZs2z+zoMPPkjkcjnZunUrIcQ916stXnjhBQKABAQEkIkTJ5LXXnuNHD582Ob2N9xwAxk8eLD5/88++4woFAqLY/Huu+8SAGYvozNwx9nPz8/CA7Z//34CgDz22GPm9+w97vZ4ZL/66isCgCxbtqxRm7hzkZmZSQA08m5NnTqVpKSkWJwza9i6r+69914SFxdHSkpKLN6//fbbSUhIiPlZYU8b7b2vuL68//77Fts9+OCDJDAw0PybO3fuJAAaeRPXr1/f6P3k5GQCgKxfv75R+2x5ZMeMGWNx3B577DEil8tJeXk5IYSQgoIColAoyLRp0yz29+KLLxIATXpk+b89efJki/e4Z1Tbtm0tnsVarZZER0eTLl26kNraWvP7XCTxhRdeML/Hefj40cXr168TPz8/wjAM+emnn8zvnzt3zqrHzxoNxwatVku6dOlCRo0a1ex3uTHn7bffNr+n0WjM94pWqyWEsBFFmUxGdu7cafH9Tz75hAAgu3fvNr9n67otLi622SdHPbLWnqvcOUpISDCPZ4Sw3nIA5N133zW/Z208Xbp0KWEYhly+fNn83sKFCxtFwPj95PfF3vHO3mtZqrQKIc6YMWMQFRWFpKQkTJ8+HQEBAfj9998d8qoCQGVlJYB6jySftm3bIioqyvz6/fffAQDHjh3DhQsXcOedd6K0tBQlJSUoKSlBTU0NRo8ejR07djTS4jzwwAMW/w8dOhSlpaXm3//5559hNBoxY8YM8/5KSkoQGxuLjIwMbNu2zeL7Pj4+mDNnTqM2czNJAKiqqkJJSQmGDh0KtVqNc+fONXs8/v77b8TGxuKOO+4wv6dUKvHwww+juroa//77r8X2t9xyi9k7aQ/Dhw+30JUZDAZs3LgR06ZNQ9u2bc3vx8XF4c4778SuXbvMx8ge/v77b8jlcjz88MMW7z/++OMghDS7Kt5RXnzxRRBCWrwooeFxzM/Px7FjxzB79mwLL123bt0wduxY/P3331b388033+Cjjz7CG2+8gZEjRwJwz/Vqi5deegk//PADevbsiQ0bNuD5559H79690atXL5w9e9Zi29LSUmzYsMHiWrvlllvAMAxWr15tfo/7zYbadWeYNm0aEhISzP/369cP/fv3Nx9PZ4+7LdatW4fIyEg89NBDjT7jdL7t2rVD//798f3335s/Kysrwz///IOZM2da6IFt0fC+IoRg3bp1mDJlCgghFs+U8ePHo6KiAkeOHLG7jfbeV+3atUOPHj0svEUGgwFr167FlClTLDxdISEhGDt2rEXbevfujcDAwEbPu9TUVIwfP77Z48Axf/58i+M2dOhQGAwGXL58GQCwZcsW6PV6PPjggxbfs3YMnOGee+6xeBYfOnQIRUVFePDBBy00k5MnT0aHDh3w119/NdrHvHnzzH+Hhoaiffv2CAgIsFgD0r59e4SGhtqVVYffnuvXr6OiogJDhw41XwfNoVAocP/995v/V6lUuP/++1FUVITDhw8DYM9rx44d0aFDB4vzOmrUKABodF4bXreupqnxadasWRbPlOnTpyMuLs7iHucfs5qaGpSUlGDQoEEghODo0aMOt8eZ8a65a1mqtAppwYcffoh27dqhoqICX331FXbs2OGU8J+7kKurqxt99ttvv0Gn0+H48eN44oknzO9fuHABAPuwskVFRYWFzKFNmzYWn3OfXb9+HcHBwbhw4QIIIcjIyLC6P36YDQASEhKsLiw5ffo0/vOf/2Dr1q2NboiKigqb7eW4fPkyMjIyGi1M6Nixo/lzPs2FsxrScPvi4mKo1WqrocKOHTvCaDTi6tWr6Ny5s137v3z5MuLj4xsZPbbaLxQaHheunbaOy4YNGxotijp27BgeeOAB3HHHHVi8eLH5fXdcr01xxx134I477kBlZSX279+PlStX4ocffsCUKVMssoqsWrUKOp0OPXv2RFZWlvn7nFG3cOFCADD/XlVVVZO/aw/W7q927dqZDWdnjntTXLx4Ee3bt292IdqsWbOwaNEiXL58GcnJyVizZg10Op3dKZ2s3Vfl5eX47LPP8Nlnn1n9Drf4zp42OnJf3XbbbXjuueeQm5uLhIQEbN++HUVFRbjtttvM21y4cAEVFRWIjo5usm22+tccTV2//Pamp6dbbBceHu6wPM0ajtzPHTp0wK5duyze8/X1bWSAhYSEIDExsdHEJiQkxNyvpvjzzz/x6quv4tixY9BoNOb37ZkoAUB8fHyj675du3YAWGnfgAEDcOHCBZw9e9am8djS8+ooTe2/4bOAYRikp6db5IW+cuUKXnjhBfz++++NjrE942lDnBnvmruWpUqrMGT79etnzlowbdo0DBkyBHfeeScyMzOteldtkZ6eDoVCgVOnTjX6bPjw4QDQ6AHPea/efPNN9OjRw+p+G7bBlraPEGLeJ5dH09q2DffHnylylJeXY/jw4QgODsbLL7+MtLQ0+Pr64siRI3j66afdsmLTWjtcub27sPXwNhgMHm4JS0uPy/Xr13HLLbegXbt2+OKLLyw+c8f1ag/BwcEYO3Ysxo4dC6VSia+//hr79+8331ecB3Lw4MFWv5+dnY22bduiQ4cOAICTJ09KtojE7bffjsceewzff/89nnvuOXz33Xfo06dPs1pQjobXD3fO77rrLpsTGGd1h81x22234dlnn8WaNWvw6KOPYvXq1QgJCbFIvWY0GhEdHW3hhebT0BBy9P5wxfXbElp6P9tqv7P92rlzJ6ZOnYphw4bho48+QlxcHJRKJVasWIEffvihRW3lYzQa0bVrVyxbtszq50lJSRb/O3qcGIax2ldbz+2WnAeDwYCxY8eirKwMTz/9NDp06ICAgADk5uZi9uzZHsuA4O1r2Vu0CkOWj1wux9KlSzFy5Eh88MEHeOaZZ+z+bkBAgFlkzXkQmiMtLQ0AO1CPGTPG6XY33CchBKmpqeZZrqNs374dpaWl+PnnnzFs2DDz+5cuXWq0rS1DLjk5GSdOnIDRaLTwynKyhOTkZKfaZouoqCj4+/sjMzOz0Wfnzp2DTCZr9PBriuTkZGzevBlVVVUW3qOG7edmtQ2LHFjz2NrrsXAlXDttHZfIyEizd8RoNGLmzJkoLy/H5s2bG6Vhc8f16ih9+vTB119/jfz8fADsNblnzx4sWrTIbNhyGI1G3H333fjhhx/wn//8B0OGDEFYWBh+/PFHPPfccy1a8MV5p/mcP3/evIDLkeNuD2lpadi/fz90Ol2jqAqf8PBwTJ48Gd9//z1mzpyJ3bt3t6hgSVRUFIKCgmAwGJo95/a00d77CmC9YP369cOqVauwaNEi/Pzzz5g2bZpFxCwtLQ2bN2/G4MGDvTK55dqblZVl4bUrLS11i6eLf11xYXaOzMxMlz9XG7Ju3Tr4+vpiw4YNFudhxYoVdu8jLy+vUTTi/PnzAGC+f9LS0nD8+HGMHj3a6edmU98LCwuzKqNwJtLW8FlACEFWVpZ5gnfy5EmcP38eX3/9NWbNmmXebtOmTQ61mY+rxzsp0yo0sg0ZMWIE+vXrh+XLlze76rQhL7zwAgwGA+666y6rEoOGM5/evXsjLS0Nb731ltXti4uLHWs82NXxcrkcL730UqPfI4SgtLS02X1wAzz/+1qtFh999FGjbQMCAqyGRiZNmoSCggILjZter8f777+PwMDARkZHS5HL5Rg3bhx+++03i5BOYWEhfvjhBwwZMqTZUDafSZMmwWAw4IMPPrB4/5133gHDMOZk+8HBwYiMjMSOHTsstrN1rIDGRi8AlJSU4Ny5c1Cr1Xa30R7i4uLQo0cPfP311xa/e+rUKWzcuBGTJk0yv/fSSy9hw4YN+PHHH62G0txxvVpDrVZj7969Vj/jNJSch5HzxD311FOYPn26xWvGjBkYPny4eRt/f388/fTTOHv2LJ5++mmrnojvvvsOBw4caLaNv/76q0UFwAMHDmD//v3m68KR424Pt9xyC0pKShpdj0Dj58rdd9+NM2fO4Mknn4RcLrdY4e8ocrkct9xyC9atW2c12sQ/5/a00d77iuO2227Dvn378NVXX6GkpMRCVgCwWTEMBgNeeeWVRr+p1+tbXEWvOUaPHg2FQoGPP/7Y4n1rx8AV9OnTB9HR0fjkk08swvr//PMPzp49a1fWgJYgl8vBMIyF5zInJ6dRFoGm0Ov1+PTTT83/a7VafPrpp4iKikLv3r0BsOc1NzcXn3/+eaPv19bWoqamptnf4Sbi1q6BtLQ0nDt3zuL6PX78OHbv3m13Pzi4DCYca9euRX5+vvlatjaeEkLw7rvvNtpXU2MEH1ePd1Km1XlkOZ588knceuutWLlypcVileLiYrz66quNtk9NTcXMmTMxdOhQfPDBB3jooYeQkZFhruyl1Wpx/vx5fP/991CpVOZ0MjKZDF988QUmTpyIzp07Y86cOUhISEBubi62bduG4OBg/PHHHw61PS0tDa+++iqeffZZ5OTkYNq0aQgKCsKlS5fwyy+/YP78+RY6XWsMGjQIYWFhuOeee/Dwww+DYRh8++23Vgf+3r17Y9WqVVi8eDH69u2LwMBATJkyBfPnz8enn36K2bNn4/Dhw0hJScHatWvNHiJXLLhpyKuvvopNmzZhyJAhePDBB6FQKPDpp59Co9HgjTfecGhfU6ZMwciRI/H8888jJycH3bt3x8aNG/Hbb7/h0UcfNXsnAXYxxf/+9z/MmzcPffr0wY4dO8weBj7cQ/r555/H7bffDqVSiSlTpiAgIMCu9FvO8uabb2LixIkYOHAg7r33XnMaqJCQEHMFmZMnT+KVV17BsGHDUFRUhO+++85iH3fddZdbrldrqNVqDBo0CAMGDMCECROQlJSE8vJy/Prrr9i5cyemTZuGnj17AmAN2R49etj0PkydOhUPPfQQjhw5gl69euHJJ5/E6dOn8fbbb2Pbtm2YPn06YmNjUVBQgF9//RUHDhzAnj17mm1jeno6hgwZggULFkCj0WD58uWIiIjAU089Zd7GnuNuL7NmzcI333yDxYsX48CBAxg6dChqamqwefNmPPjgg7jxxhvN206ePBkRERFYs2YNJk6caFM/ai//+9//sG3bNvTv3x/33XcfOnXqhLKyMhw5cgSbN29GWVmZ3W105L4CWIPmiSeewBNPPIHw8PBGXuHhw4fj/vvvx9KlS3Hs2DGMGzcOSqUSFy5cwJo1a/Duu+9i+vTpLep/U8TExOCRRx7B22+/jalTp2LChAk4fvw4/vnnH0RGRro8CqNUKvH6669jzpw5GD58OO644w5z+q2UlBS3l6uePHkyli1bhgkTJuDOO+9EUVERPvzwQ6Snp+PEiRN27SM+Ph6vv/46cnJy0K5dO6xatQrHjh3DZ599Zvbk33333Vi9ejUeeOABbNu2DYMHD4bBYMC5c+ewevVqbNiwwSwJtIWfnx86deqEVatWoV27dggPD0eXLl3QpUsXzJ07F8uWLcP48eNx7733oqioCJ988gk6d+7s0KJggI2CDBkyBHPmzEFhYSGWL1+O9PR03HfffQBY7XJaWhqeeOIJ5ObmIjg4GOvWrbPqsefGiIcffhjjx49vciLqyvFO0ngsP4IXsFUQgRA2wXVaWhpJS0szJ063lvyfe40ePdri+0ePHiWzZs0ibdq0ISqVigQEBJBu3bqRxx9/3CIxOH/7m2++mURERBAfHx+SnJxMZsyYQbZs2WLehktnVFxcbLUfDVM6rVu3jgwZMoQEBASQgIAA0qFDB7Jw4UKSmZlp3qaplGK7d+8mAwYMIH5+fiQ+Pp489dRTZMOGDY1SRFVXV5M777yThIaGElgpiDBnzhwSGRlJVCoV6dq1a6M0VfyE0/YCUwJsaxw5coSMHz+eBAYGEn9/fzJy5EiyZ88ei23sLYhQVVVFHnvsMRIfH0+USiXJyMholLidEDa1yr333ktCQkJIUFAQmTFjBikqKrKa+uWVV14hCQkJRCaTWZw3V6XfsnUcN2/eTAYPHkz8/PxIcHAwmTJlikViflvJ2bkXH3dcr3x0Oh35/PPPybRp00hycjLx8fEh/v7+pGfPnuTNN980p687fPgwAUD++9//2txXTk5Oo7RYhBCydu1aMm7cOBIeHk4UCgWJi4sjt912G9m+fbvNfRFieZzffvttkpSURHx8fMjQoUPJ8ePHG23f3HG3dUyspQdSq9Xk+eefJ6mpqUSpVJLY2Fgyffp0i/Q7HA8++CABQH744Ycm+8OnqfuqsLCQLFy4kCQlJZl/e/To0eSzzz5zuI323lccgwcPJgDIvHnzbLb9s88+I7179yZ+fn4kKCiIdO3alTz11FMkLy/PvI21NFf8z6yl32o4Plh7duj1evLf//6XxMbGEj8/PzJq1Chy9uxZEhERQR544AGbbW6qXdzv2Co0sGrVKtKzZ0/i4+NDwsPDmyyI0BBbz/2mjg+fL7/80lzwokOHDmTFihXm+705rBVESE5ONhdp4KPVasnrr79OOnfuTHx8fEhYWBjp3bs3eemll0hFRYV5u6au2z179pDevXsTlUrV6Hn83XffkbZt2xKVSkV69OhBNmzY0GRBhIbwi1Y8++yzJDo6mvj5+ZHJkydbpNQihJAzZ86QMWPGkMDAQBIZGUnuu+8+c8pO/pio1+vJQw89RKKiogjDMBbH1Np4Ys9458i1LEUYQiSuAqZQKBQHyMnJQWpqKt58881mIxve5LHHHsOXX36JgoICr5ecbo2Ul5cjLCwMr776Kp5//nlvN0cwjBgxAiUlJVZlKhSKO2iVGlkKhUIRM3V1dfjuu+9wyy23UCPWA3BV9fhwC+xcLROiUCiO0Wo1shQKhSI2ioqKsHnzZqxduxalpaWNykBT3MOqVauwcuVKTJo0CYGBgdi1axd+/PFHjBs3zmZKOAqF4hmoIUuhUCgi4cyZM5g5cyaio6Px3nvv2cz1S3Et3bp1g0KhwBtvvIHKykrzAjBrC4MpFIpnoRpZCoVCoVAoFIoooRpZCoVCoVAoFIoooYYshUKhUCgUCkWUUEOWQqFQKBQKhSJKqCFLoVAoFAqFQhEl1JClUCgUCoVCoYgSashSKBQKhUKhUEQJNWQpFAqFQqFQKKKEGrIUCoVCoVAoFFFCDVkKhUKhUCgUiiihhiyFQqFQKBQKRZRQQ5ZCoVAoFAqFIkqoIUuhUCgUCoVCESXUkKVQKBQKhUKhiBKFtxsgRYxGI/Ly8hAUFASGYbzdHAqFQqFQKBTRQAhBVVUV4uPjIZM17XOlhqwbyMvLQ1JSkrebQaFQKBQKhSJarl69isTExCa3oYasGwgKCgLAnoDg4GAvt4ZCoVAaUFMDxMezf+flAQEB3m0PhUKh8KisrERSUpLZnmoKasi6AU5OEBwcTA1ZCoUiPOTy+r+Dg6khS6FQBIk98ky62ItCoVAoFAqFIkqoIUuhUCgUCoVCESXUkKVQKBQKhUKhiBJqyFIoFAqFQqFQRAk1ZCmNqNMZsHzzeRy+fN3bTaFQKBQKhUKxCTVkKY1YsTsHyzdfwJsbznm7KRQTdToD6nQGbzeDIhV8fIDVq9mXj4+3WyMJTl6rwJwVB3A2v9LbTaFQWhXUkKVYoNEbsGL3JQCAWksNJyFACMGsLw+g32ubUVmn83Zz3MaFwirsyy71djM8TlFlHV5ffw655bWe+1GFArj1VvaloFkYXcGnOy5iW2Yx/jie5+2mUCgOU6s14PbP9uJ//4jPgUUNWYoFvx3NQ1GVBgCgMxAvt4YCACdzK3AgpwyVdXrkXvegseNh7v36EO78fB+yiqq93RSP8uG2LHy8/SK+3XvZ202hOAkhBPuyywAAOoPRy62hUBxn54Vi7Msuw9rD17zdFIehhizFjNFI8NnObPP/BqM0Hsgl1RrsvSheT98vR3PNf+slPLkordbASIANpwu83RSPsv18MQBArdV77kf1emDNGval9+DvSpSLxdUoqaYOAIp42WuKhulFOO5TQ5ZiZltmkYU3TG+UxgP5xd9P447P9+GvE/neborD6A1Gi1ClGB8y9sJdbxtbkSF7ubQGl0vVADxsAGk0wIwZ7Euj8dzvSpS9Jm8sABgk8tyktC44Z49BhBMxashSzHy6g/XG9k0JAyCdB3J+RR0A4Ju9Od5tiBPsyipBSbXW/L9Uzok1uL4dv1aB/ArpSij47DB5YwHpREA41Fo97vvmEH7Yf8XbTXE7+3gRH6k4AChAbnltq8jec71Gi3MFVQAAnQifQ9SQpQAADuaU4cClMijlDOYNbQtAOmFsvUmztv9SGS4Wi0t/+StPVgBIN2xJCLEwADafKfRiazzHv+dLzH9LzQDaeLoQm84UmhePShVWH8szZKlGVjLMWXEAt3y8B1fL1N5uilvZf6n++hWjs4QashQAwPtbswAA03snIiHUD4B0wth8A+GnA+LxDtVo9NhwmjXoVAr2VhXjQ8YeGvZrYyswZLV6I/Ze5BmyEpuk7DNr7qTVr4ZcKKpGaU3riJq0Jq5dV+N8Iev4KK6Wtvxmr8gjCtSQpeD41XLsOF8MuYzBguHpUMgZANJ5IPP7sfbwNWj04kgrtvFMAWp1BqRGBiAjOhCAdCYXDWn48Nx7sRQVtdJNNQYAhy9fRw0vxZ1U7jcObvGI1FfxN0wZp5PYeeSTX1GL5ZvPo7hK2oYdAHMWCkB6k8yG8PtKiPieRdSQpZi9sTf2iEebCH8oZKwhK8aZmTX4/biu1pm9nELn5yOsrODGHvFQyNlbVaoPVP6DMzHMD3ojwfbMIi+2yP3suMDqY7n7TUoGX155rXkRm9gGRUfhvFkxwWxhCalpnfks33QByzdfwOpDV73dFLdjIReR8DktrdYgs7DK4j2x9Zcasq2cM3mV2Hy2EAwDLByZDgBQyKRlNHGatcHpEQCAH0Ww+OTadTV2ZbFh51t6JUpuctEQ/rU2qWscAOnLC7iFXn0ktrgSsNTcSfWaBdiUhfsvsd6swemRAKTz3LTGnmz2mVStkX7KNkvds3TPKeeNTY7wN78ntmcRNWRbOe9vvQAAmNw1DmlRbPhabjaaxDUrswU3kN7ZLxkyhg15Cj3p/trD10AIa3wnhfubz4nYHjD2wr/WJnaJBQBsP1ckGhmIo5RUa3A6jy1lOqJ9NAAPG3wqFbBiBftSqVy++30X+WFZaTxHrHG+qAplNVr4KeXo1YadkEjVcL92XY2rZWw2ESmfUwC4WqbGNV7xGak+d4F6g32IaSIGiG9RMTVkWzHHrpbjn1MFYBjgoVEZ5velqpFtE+6PUR1iAADf7RNuFSWjkWDNIba6yow+SQDA88hKcwDhzpGMAbonhiIm2Ac1WgP2iLiQRVP8m8l6YzvHByMuxBeAh8+tUgnMns2+lEqX735vduvwyHJpt/qkhMFPKQcg3f5aaEYl2keOhrpnKfd3rxVDVmxjPzVkWymEEPzvn7MAgJt7JqJ9bJD5M7nEwthcP+QyBrMGJgNgPZ5CDY/tzS5FbnktgnwVGN+Z9U5KXSPLLZBRyGSQyRiM7cROODaKRM/sKFvPsfrfUR2i6+83iZzb3PJaXOGlK5JKv6zBGXcD2kbwHADSnGzyjTuxGTqOwjfaAel6oIuq6pBVVA2GAQamRcD0KBJdf6kh20r59zxbV1mlkGHxuHYWnylNGlkxrl60BndTKuQMhqRHom1kAKo1eovSr0KCW0gxtXs8fE1eHoXEpQVcNRnOGBjXiTXgN50phFFifdbqjWZ97KgO0WZNukfPrV4P/PUX+3Jxidr92Q0XP0nr/HEYjQT7TFrggWkR5vMotrCsvfBTNEm1j4BlXmClXFpOnYbsNxnsHWODEeqvql8fI7L+UkO2FWI0Ery+PhMAMGtAsjlvLIfcdPMC0ghl8z2yMhmDuwawXtlv9uSAEGHdsBVqHf45xZZo5WQFgPS85A3hrjOunwPaRiDIR4GSag2OXi33Ystcz6GcMlRp9IgIUKF7Ymh91gJPnluNBrjhBvbl4hK1nMFjXvwkgWeINTILq1Cu1sFfJUfXhBBJ69ivlqmRW87XjErznALAteu1yC2vhULGoGtCCABpnlOgXlYwoC27EFqs1zA1ZFshvxzNxdn8SgT5KMyZCvhwAysgvgvaGlwfOE/zLb0T4aeU40JRdaMQkrf5+eg1aPVGtI8JQrfEEPP79Z4BaQ4gerO0gO2nSiHDyA7sIqiNZwq81i53wMkKRnaIhkzGmCeOUjEOOC/l0AzWkDUSSM6rDtQb7H1TwqGUy+rvUZGFZe2hkWZUwh5ZzrjrnhSKYD9WPy6l1Hh8OI33wDTWkOUiYmLrLzVkWxnlai3+729WG/vgyHSEBTResSyX8T2y4n9gcQ9dzmAI8VPipl4JAICv9+R4q1mNMBoJvt3LLkK7a0AbMEz9eZBLLCVaQ/RmaUH9I2lcZ1Ynu0liabg4Q3a0yVBXSujccivb5TLG7OUBpPEcacg+G94sKfaVM+4CfRQApNlHDrNx1zZC0pKuwso6ZJfUgGGAfqnhAMQrYaOGbCvj9fXnUFqjRUZ0IO4dkmp1G25gBaQxuHJeTL6n+Z6BKQCADWcKkFNS441mNWJnVgmyS2oQ6KPATb0SLT4T6wPGXgwNPLIAMLxdFJRyBtnFNYJPl2Yv2cXVyC6pgVLOYIjJYyklA4iLcHRLDEGIX302BKldt/z8sWZvlje0zh6AEGLWUnJGu9T6yMHXxw5oy9M9S7C/XD87xweb71XzomKR9Zcasq2Igzll+PEAu5DotZu6QqWwfvplMgacM1DsoWyjkYC7J/lGUvvYIIxsHwVCgC92ZXupdZZw3uHpvRPNng8OqRdE0DXQyAJAkK8Sg9JYY2/DaWnICzhvbP/UCAT5coOHdCYpfCOAfy51In+ONORsQSUqanUI9FGgS3wwAPGGZZuD04wq5QwGtGU9d1LrI8fVslrkVdRBKWfQOzmsXvYjwf7u5XmeORQizaBCDdlWgkZvwPO/nAQAzOiTaA4l2EIqHkADbzGXQmZ5uc8flgYAWHPoGkqqvVs7/HJpDbaZSrJyKcL4KCSsvwN4Oma55TmaYCqO8NeJfI+3yR3w025xSClHMGfIDuR5s4D6rBRSoV4fG2b2YknlmdkQrq/dE0MR5MtOsKXWR469psplPZJC4aeSS9qBYL5X0+oNWbEWQ6KGbCth6d/ncL6wGuEBKjw7sWOz20sltyW//fxsDAAwoG04uieGQKM34pu93i2Q8O3eyyCEDae3NVVY4yOl8LM1zDpmmeU5Gt85FgoZgzP5lbhYLG55QblaiwOmcLSlISsNjSxXDUkhM3mzeJEdqXlk9zUItQPiDcs2h7VQu9T6yNHwvEq1v/kVtcgpVUPGAH1S6p1aSpFew9SQbQX8dSIfK01h67du7WZ1gVdDlBK5gfkzS0UDI4lhGNw/nPXKfrM3B2qtdwokVGv05tyxswelWN1Gqvo7Dms6ZgAID1CZ0zj9eVzcXtlNZwqhNxJ0iA1CSmSA+X2vTFJUKuCDD9iXi0rUcgZPt8QQBJikMVL0UhqMBPsvNfZmiTUs2xSNNKMSzp5CCGkUbpfi9QvUe9m7JoQg2Ldeyy5WBxY1ZCXOpZIaPL3uBABgwYg0c4nW5pBKSiD+A6ihkQSwHr/kCH+Uq3Vm/bCn+WZvDirr9GgbFYDh7aKsblOfa1Tc58MW5vRb8sbnaEr3eADAHyfyBJf31xHWm/IDT+wSZ/G+0hsaWaUSWLiQfbmoRC3nzbIaqhTZwNgUZ/MrUVWnR5CPAp3igs3vSzFqcqVMbakZleD55LhcqkZBZR1Uchl6tgkDUD8OSq2/5skJ714FxGu4U0NWwpRUazD/m0Oo1ujRLyUcj49t1/yXTEhFG8Rvf8OwNffeAyav7EfbslDj4bK1aq0eX+y8BABYNDIdMittBHgTC4k9UDkMZmlB40fSuM4xUMllyCqqRmZhlaeb5hKq6nTYeYHV303qGmvxGXddinkBTUPPHYdUIjt8zPrY1HCLdHFSzPXMndN6zaj0zidHw74CgFKkmtHmaFgIgcO8YFFk/aWGrEQpqdbgzs/34UJRNWKCffD+nT0tHrrNIZWZN197yc/Lymd670SkRPijtEaLFbsvebJ5+H7fFZTVaJEc4Y+pJs+jNaQysbCFLWkBAAT7KjG8PeupFqu8YOu5ImgNRqRFBSAjJsjiM6/IRgwGYPt29mUwtHh3/JXtvZPDzO9LJbLDh7+gjQ83CZPSZJMz2gc0CLVL8Tm014qXUi5Bw52f67lviuWib7Few9SQlSBFlXW48/N9OF/IGrE/zR+ImGBfh/YhlZl3w9Kn1lDKZXjM5K3+dEc2ytVaj7StVmvApzvY1F8LR6Q3OdGQvka2cR5ZPjd0Y8PxYpUX/H2SNcAndY1r9JnCG+HLujpg5Ej2VVfX4t2ZqyElhsJfVZ86TirPEQ69wWhesNfImyUxI4/1spvkIlzRBwlOTICGEQX+4ifpZYvh53pumOZRKdJrmBqyVli6dCn69u2LoKAgREdHY9q0acjMzPR2s5qFEII/judh/PIdFkZsKm9hib0oJPLAqi9Pa9uQBYAp3eLRITYIVXV6fPKvZ/LK/njgCkqqNUgI9TNXGrOFlFI0WcPQhEYWAMZ0jIGvUobLpWqcuFbhyaa1mBqNHtsziwHUpxPjI4Vzu++ijVClRCI7HGfyK1Gl0SPIV4FO8cEWn0ltIZQ1zaiUqtDxySlVo7BSA5Vchl5teBEFkRp2TdHQy86Hpt+SEP/++y8WLlyIffv2YdOmTdDpdBg3bhxqaoRRAaoheoMRu7NK8MB3h/HQj0dxXa1Dx7hgp41YQELSAqP1tE4NkckYPDm+PQBg5Z5LyCuvdWu7KtQ6fLAtCwDw4Mi0RvlTGyLVRQcc+iY0sgAQ4KPA2E6sEbjuyDWPtcsVbM8shkZvRHKEv8XiIA7OE28kbAEPsWFLHwtIzxDgjID+qeGNnimS66sVzajU+sixO4vVr/dsEwpfpdz8vlgXP9mCf682lMYA4i3Oomh+k9bH+vXrLf5fuXIloqOjcfjwYQwbNqzR9hqNBhpNfUL9yspKt7cRAIqq6rB88wVsOFWA0ho2HK6QMVg4Mh0LR6bbrNxlD1K5gTkDyR598KgO0eibEoaDOdfx4u+n8dmsPm5r17JNmSir0SI9OhAz+iQ1u71S8tIC2xpZjum9E/HH8Tz8diwPz03qaDHgCJk/T+QBYL2x1nTafINIbyRQNTPpEhoNqyHxkVpo1pbBDtTfo8Q0IbG1cFMsWFvZLlZDpzk4Q3aIKdUfBzdu6CTiQOC07AoZgz4pYY0+N5fkFVl/qUfWDioq2FBmeLj1alhLly5FSEiI+ZWU1Lxh4gr8VQqsPXwNpTVahPkrcXvfJPy+aAgeG9uuRUYswLugRf7AssdA4mAYBq9O6wqFjMHGM4VuK4t6Jq8S3+5jCzC8NLVzs95YgLeyXeTnwxbNaWQBdpCJC/FFRa0Om88WeqppLaJcrcWWs2w1L1uL+fh9FqOB0LAaEh8pefD0BiMO5lwHYCMsy5PFiG3Vd0NsaUbNaQAlMjEB2Htuj8nTPjjD0pCVmx060uivuUpbkqWWnUMh0v5SQ7YZjEYjHn30UQwePBhdunSxus2zzz6LiooK8+vqVc/kIw30UeA/kzvi23v74cDzY/C/W7o10m05i9Q0svYYsgDQPjYI84e1BQAs+e00ql2cjosQgiW/n4KRAJO7xpmT/TeHVM6HLZrTyALsoHJLr0QAbFlhMfDH8TxoDUZ0iA1C5/gQq9vw+yw2bRpgvcoVh5QWKZ7Kq0S1Ro8QP6V1iYjIJyR8soqqUVipgY/CUjMqpfPJcSq3AhW1OgT5KtAtwfIeldoCvr1NyAoA8U48qSHbDAsXLsSpU6fw008/2dzGx8cHwcHBFi9PMWtgCoZmRNnl1XMEqWhkuRBJw/K0TfHw6Ay0CfdHQWUd3lx/zqXtWXPoGg7mXIefUo7nJjdfKphDKufDFrpmNLIc03uzhuzOC8XIr3CvjtkVrD2SC6C+3dZQ8PostvNrr+ZOCh48zpvVLzXcqmyAfx7FFpptyL/n2cWJ/VLDLTWjcnEaOk2xyyQrGNg2opEEzVx2WOTnE2hwr6ZZN2SVIu0vNWSbYNGiRfjzzz+xbds2JCbaHoikiFQ0svUeWfsvdV+lHK/dxHrfv957GX+dcE3u0nMFlXjh91MAWGM5IdTP7u9KMbE8H87T3Fx2iZTIAPRLCYeRAD+bjEShklVUjeNXyyGXMbixh+2sFPwue+z8KpXAG2+wrxZU9rpcqkZ+heXKdj5SeY4AwJ6L9QaPNaTkkeWKdwzLsKw0WJ+FQvwTE45dpr4OzWgcHZPS9cvdq0o5Y+Fl50M9shKCEIJFixbhl19+wdatW5GamurtJnmc1qiR5TM0I8osMXhy7XFkFrSsolS1Ro8Hvz+COp0RQzMicb9p3/Yi1geMvdibXQIAbu3DyQuuCnqVP5ddYUS7KEQF+djcjmEYz5epVamAJ59kXyqV07uxVg2Jj9mjJeDzZA+1WgP2m/LHDmtnXQ4kkzHg1vKJUSLCUaczYP8l9rwOa1AyW2rPoVqtAYcvs7pnazIvKUUUOM9zz6Qwq/cqIF4JGzVkrbBw4UJ89913+OGHHxAUFISCggIUFBSgtlb4oUxXIdYLuiEGBwykhjw1vj0Gp0dArTVg/reHUKHWOdUGQgieWXcC2cU1iA32xfLbeji8olkq58MW9dklmj8uk7rGIdBHgZxSNXaaHs5Cw2Ak+NlkyN7ShKyAQ6xlam3VbOeQiiRm36VSaPVGJIT6IS0q0OZ2UsizejCnDHU6I2KCfdAuxrKvYg092+JAThm0Bva8WktVKSWPLJfLmquSaI36xXzi6i81ZK3w8ccfo6KiAiNGjEBcXJz5tWrVKm83zWNIZQByxEBqiEIuw/t39EJCqB8ul6ox66v9KK3WNP9FHgYjwbM/n8SfJ/KhkDH4cGZPRATa9s7ZbIsEBsim0DsgAQnwUZi9sp4uKWwvu7JKUFipQYifEqM7Rje7vccX0RgMwMGD7MvJErWEEF7NdusZXaRQ7AEA/jUZAcPaRdksdQ3wV7mL9z7daQ61N+6rFPrHh0u7NTg9wkZqPGlEFDR6g1kaM7ydbUNWLtLFfNSQtQIhxOpr9uzZ3m6ax5DKTLQ+ZO3cpR4eoMLns/ogzF+J49cqMP2Tvbhaprbru1q9EQ//eBQ/HbwKGQMsvbkreidbH/CbQ2ohvYYY7CglzGf2oBQwDOtlyCqqdmfTnOLrPTkAgJt6JsBH0Xy+W48voqmrA/r1Y19Olqi1VQ2Jj1QWy+wwLX5qyggApLEYiutrQ1kBIJ2JCQdntNvKHqOUSLW2QznXodYaEBXkg85NZDYSa95nashSrCIVjay9i4iaolN8MNY8MAgJoX64VFKDmz/eg9+O5TapzzyVW4E7P9+Hv07mQyln8MGdvXCrHYUPbCG1NDANMXvO7TxPyREBGN2B9XRyRqNQyC6uxtZzRWAY4J5BKXZ9R4wGAicraFgNiY8UJsRXStXILqmBQsZgULp1CQWH2BdDFVXW4VxBFRimcXEAQPxV6PgUVdbhbD5bvMiWISuVyOT2TDaX9TArXnY+YnWYUEOWYhUuXZVBpA9kDkcWETVFenQgfn5wEDrEBqG4SoNHfjqGqR/uwu/H85BdXA2DkaC4SoN/zxdj8epjmPLBLhy6fB3+Kjm+vKcvJnWNa9HvS14ja84ja/8jae5gdhHm2sPXnNYvu4OVJsN6VPtou0tEi3HAbKpmO4cUJmD/XmA9lL2SwxDs23SGB7GHoneYPJRdE0IQHtB4EWDDKnRiZss51rjrnhSKSBtyLylMxID6dGojmtDHAuLtLy1RS7GKFAYgoGUa2YbEBPvilwcH48td2fjk32ycyq3Ewz8eBcCGZBoK5Kf1iMcT49sjMcy/xb8tdY2so4UrADYXYvuYIGQWVmHVoSuYPyzNXc2zm4paHdYeZhd5zR1if7YTsSWat6z81IQhK4HQLKePbU5WAPBDs+I4jw3hZAXWUlEB9f0DxHOt2mKLqTrgmA62NexSiEzmldfifGE1ZIzt88oh1pK81CNLsYpURP2OLCKyBz+VHItGZWDHUyNx/7C26JoQAh+FDDoDAcMAbaMCcGOPePy2cDCW397TJUYsIN6Qj71wq/Ud8ZwzDIO5Q1IAAF/svIQ6nXOLllzJ6oNXodYa0D4mCINsrOS3htgMvkslNSiq0kClkKFnm1Cb28lFPgHT6o12LZLhkItQIsKhMxixzRSCHtneunHHvz/FXIa3Tmcwp6Ma3THG5nZyCUTCuGwFPduEIdS/6VR7Yi1RSz2yFKtIJQG/wck8ss0RHqDCs5M6mn6DIK+8FuEBKgT4uOeWUng6z6iH4fqldNBzPq1nAt7bkoXc8lp8t+8y5g11LD+vK9EbjGZZwdwhKU1q0RqiEJm0gMtW0KsJfSxQr00X63V76HIZ1FoDIgN9rJalbYhYQ7MAsD+7DFV1ekQGqqwWtwAsHQIGkVyr1tidVYI6nRHxIb7oGBdkczsppFPj9LEjHJqIiau/1CNLsYpc5CEyDldpZJtCLmOQFO7vNiMWEOdiIEdwNruEj0KOh0alAwA+3n4Raq3e5W2zlzWHryG3vBYRAaomK3lZQyGyieO+bLY4QFOyAoCXH1ek1+3mM6wRMLxdlF25n8UamgWATWcKAACjO8TYfF7KeUUfxHpOAWDzWfa8ju4YI8nFTxxs2i120jnChpedj1jzBFNDlmIVsYYYGuJKjaw3kbpGllvl7Yzn/JbeiWgT7o/SGi2+3nPZ1U2zizqdAe9uvgAAeHBkepNeSmt4fMBUKoElS9iXgyVqLWq2N2PImiMJIrxuCSHYcJo17sZ3th1+5iNWjywhBJvOsJrRcc30Vax95CCEYOs5tq/N5XgWeyRsT1YpqjV6RDeTdotDrIY7NWQpVhHrBd0QV2tkvYVUzoct6rMWOG7IKuUyPDI6AwDw6Y6LqKrzfAaDb/deRkFlHeJDfDGzfxuHv6/0tBZPpQJefJF9OVii9mJxDYqrNPBRyNA9KbTJbcW8WOZUbiVyy2vhp5RbzalqDbFpnTlO51Uir6IOfkq5zVRUHGLMsMHnVG4lCis18FfJm40o1Fe6Etf55Fh/ip2ITegSa19EQaSRP3GP7hS3wYUYxDoT5XCXRtbTKEXuGWgOZ7IW8JnWMwFpUQEoV+vw4baLrmxas1TW6fDh9iwAwKNj2jnsjQX4JWqFf373mfWxYc32VS7iyM760/kA2JRF9p5TsS5u22jyPA9v13xfxb5+YrMpW8HQjMhm+yq2bCJ89AYjNprkIhM6x9r1HbFmK6KGLMUqYhpYm4Jrvzs1sp5ALnLPQHPUnyfnHklyGYNnJ7KL777YmY3MgiqXta05vtiRjXK1DmlRAbi5l2PaWA6PD5hGI3D6NPty0Mg0ywrsyMqgFHGlqw2nWYNnQhf7jABAvIbARjtlBYD4V/JzcpGmshVwiDkSduBSGa6rdQjzV6Jfqn0VJeWcA0tk4z41ZClWkYpG1tCCkLWQELNnwB7MnvMWnKcxnWIwvnMM9EaC53456ZHKQ1lFVfjk32wAwOPj2jtU0IGPx0ub1tYCXbqwr9pau7/G6mPtW+gFiNdDmVVUhayiaijlDEY2kWe0IWIMzV4pVeNcQRXkMgaj7Oir2BYm8skqqsK5giooZAzGdWrekBVryVYAWG8y2Md2irH7uaQU4fULUEOWYgMxz0T5SEYjK2LPlj3oWygt4HhxamcEqOQ4fPk6Vh266oqm2cRgJHhy7QloDUaMaB+FiQ547hpSrzsU9gBysbgaJdWcPjak2e3FujCI88YOTo9stpoXHzEuDuI8lH1Tms8zCogvVRyfP46zcpGhGZF29VWs46DRSMz62Ild7K8qKdb+int0p7gNqWlkxS4tUIrE0HEWvYskIHEhflg8rj0AYOnfZ5Fbbr+30VG+2nUJR6+UI8hHgf+7qatDeWMbIpaQ9F6TN7Z3chh8FM3rRjnDTmySmPpsBY5NTsSYXeTXY7kAgMnd4u3aXqzGDiEEf57IAwBM6W5fX8V4PgHg6NVyFFVpEOSjwKB0xwuziG3cp4YsxSpS0cia02+J3JDlzoeRwCMhc09TXxCh5Y+kewYmo3tiCCrr9Fjw3WG3VPy6WFyNtzZmAgCen9wR8aF+LdqfQiQTx30X7Uu7xSFGj+zVMjVOXKsAw7BhWUcQm7Qgq6gKp/MqoZAxmNzVPs+dxzNsuIiz+VW4WFwDlUJm93kVq2G3/hTreR7VMdquCSeHOcuIyCae1JClWEUqGtn6tE7ivtQtKuoQcT1U7UHvQs+5Qi7DB3f2Qqi/EieuVWDJb6dbvE8+5Wot7vvmEDR6I4ZmROK2vkkt3qdCBB53fv7YAXaW35WLUE/561HWQzmwbQQiA30c+q7YvJW/HWM9lMPbRSE8wL40bGJ1cnDe2JHtoxBkp1xEbBMTgDW6/zzBGrKOyp3EOPEEqCFLsYHYHsi2aGlaJ6HAXwQltoeMPbj6PCWF++P9O3pCxgCrDl3Fd/tcUyhBozfg/m8PI7u4BvEhvnjr1u4tkhRwiOF+yyqqRmmNFr5KGbolNq+PBcS3WIYQgl9MhuxNPR3PQCEmSRYhxGzI3uhAX8W48JQQgj8clBUA9Q4QMUXC9mWXIr+iDsG+CocWKgLirUxHDVmKVcQS6mwOV3r6vAm//WIL+9iDzuB6z/nQjCg8MZ7Vy/73t1P48cCVFu3PaCR4dt1J7L9UhkAfBb6a0xcxwb6uaKooDKC9Jm9sn+Rwu8OVYjDQ+Ry/VoHskhr4KmWYaGeonY+YvJVHrpTjSpka/io5xtqRiopDjLrnE9cqcLWMLW5hT2YGDv5zVyzX8Loj1wCwBrsjsgJAvB5Z9xWHp4gahYgeyE0hFY0sv/1ie8jYg7s85wuGpyG/vA7f7ruMZ38+iRqNHvOGtnV4PzUaPR5bdQwbzxRCLmPw0cxe6BDbfMlHe/G4AaRUAk88Uf+3HZhlBW3ty0kJiG9C/IvJCBjXKRaBPo4Pj2KSZP1uWuQ1vnMs/FSO6CjFZ+z8bDqvYzrFwF9l/3kV23O3RqM3ZytwJqe12CaeHNSQpVhFzBV5+EhFIytGz4AjuMtzzjAMXr6xM/x95Pj032y8+tdZZJfU4JmJHexOq3Ttuhr3fXMYZ/MroZLL8Oat3ewuWWovXilR++abdm/uaP5YDjFNiHUGI/4waQtvcrawhVwc/dUbjGYd5Y097A+1A/XPUrE8h+p0BrNc5NbeiQ59ly/p0hmN8IPjVfs8yYbTBVBrDUiO8EevNmEOf18hMikQBzVkKVYRSzqg5pCKRpZhGChkDPRGIrpUMPbAXWdKNxSuYBgGz0zogECVAm9vOo8f9l/B1rNFeHFqJ4zrZLsGeUWtDl/szMaXuy5BrTUgMtAHn97dG72THR8gmkPoIenzhdUoq9HCTylHt8RQu78npgnxjvPFKKvRIjLQB0PTI53ah1wk+tEt54pQWqNFZKAKQxzsa33OY2H3kWPD6QJU1umREOrncF8tFtmKoL8/H2EN9pt7Jjql3Rej/hmghizFBmILCdqCM5DErpEF2D7ojURUK2jtRd/CErXNwTAMHhqdgd4pYXju55PIKVXjge+OIDbYF5O7xaF/ajiC/ZTwVcpxLr8Shy5fx6Yzhaio1QEAerYJxQd39kJCC9Ns2cIrJWqvmDTDbdoAzRx3TlbQJyUMKoX950hMJWp/NnntpnaPdzqCI5b+/rCfPffTeyc53FexreT/6QBbGOXWPok2J6224G+uE3h/8ytqsftiCQDnFioCVFpAkRhirt7ChwuRiL1ELcCeEw3EP7mwhqc854PSIrH+0WF4b8sFfLvvMgoq6/Dlrkv4ctclq9u3iwnE4rHtMb5zjEuyE9jC4xGQ2logNZX9u7oaCAhocvN6faz9sgJAPCVqS6o12HjaeW0hhxgqtF0tU2PHhWIAwB39HE8dJyYnx+XSGuzNLgXDALf2cbyvDMNAKWegMxDB9/fnI7kgBOiXEo42Ef5O7UNsWUY4qCFLsYpcZLNuW0ilRC3ADSAG0c2W7cGT2SV8lXI8NaEDHhmTgX8zi/HXyXzklKpRVaeDWmNASqQ/+iSHo29qOIakR3qkTXIBDyBGI3HakBXLwqDVh65CZyDonhiCLgn2pRazhhj6++OBKyCELdOaHNH0BMYaYnJyrDaVqR6WEeV0NEUuYw1ZIffXYCRmL/uMFuS1ph5ZiqQQwwPZHqSikQXENYA4ijs1srbwUcgxrnMsxjlYhtQdCFmTfr6oCtfVOpM+1jEjz7zYS8ATYr4RcNeA5BbtS+gLoXQGI1YfYlfw39mvjVP7EIuxozcYscbU15YULVHKZKiDUdD93XquCLnltQj1V+KGbo6njeNQCvz6tYX43VQUtyD0B7K9SE0jC4jfS24Ng5s1skJHyIssuLK0fVLCHC4hLIYSnzvOF+Pa9VqE+CkdSpZvDaFXaNt0phAl1RpEBflgjIPldznqdcDC7CPHxjOFKKrSICJAhTEO5MltiFwEJXm/NRV8ua1PEnyVzmdWEIM0xhqC9sjqdDoUFBRArVYjKioK4eH25y+ktAypeP+kpJEVQ9J8Z+E8dlLwnDuDkBfQcIUQBtpZlpaPQgQaWc4ImN47sUVGACB8b+X3+9m+zuiT6PCkhEMsuuevTLr3O/u3cWiBYkOEHC0BgJySGuw4XwyGAWb2b2FEQaSRWMG5P6qqqvDxxx9j+PDhCA4ORkpKCjp27IioqCgkJyfjvvvuw8GDB73dTMkjFe+flDSyQk/R1BLMEhAJTDicoV4jK6xzazQS7L/keP5YDiEb6AC78GlbZhEAYGZ/50LtfMyhWYGdRwA4k1eJ3VmlkDHA7X2d76tSBMbO8avlOHT5OpRyBne3VC4icMOdK789ol2U04u8OMwlagV8bq0hqNF92bJlSElJwYoVKzBmzBj8+uuvOHbsGM6fP4+9e/diyZIl0Ov1GDduHCZMmIALFy54u8mSRawzs4YYJCQtkMo5sYaUJCDOoBSotCCzsArlah38VXJ0dWIRlPA9lOzCpyHpkWgbFdji/Qm5v1/sygYATOwah6Rw5w0euQh0z1/tZr2xU7rFI7qFZaSFfE5rtQasOczqgGcNTGnx/sQ6xghKWnDw4EHs2LEDnTt3tvp5v379MHfuXHzyySdYsWIFdu7ciYyMDA+3snUgGY2sQToha4VItGmOYjASENNlJgXPuTPUGwceut8UCuDBB+v/tsFekz62b0q4U6FohYA9lFV1OnOo/Z5BKS7Zp1BL1OZX1OL3Y3kAgPlOlGjmY9Y9C/CcAkBBRR3+MlUtmzsktcX7E3K1q7WHr6KiVoc24f4uqTYo5xmyhBC3phx0JYIyZH/88Ue7tvPx8cEDDzzg5ta0biSjkZVQyFos2jRH4RvmUjhPzqDw9IISHx/gww+b3czZtFscQvbw/HTgKqrq9EiLCsDoDtEu2afC0xMSO1m5Jwd6I0G/1HB0Twpt0b7MoXaB9ZHjm731fW1JKjUOoWpk9QYjPtvJetnnDU11STRLyXMk6I3Eo1lkWkLrdH9QmkXI4RRHMEhIIytko6Al8PsjBc+5MwhRh2epj3Vuoa1QtfZavdFcBGP+sLYOV3yyhZxbkCmg81it0ZvTi7XUGwsI95wCnJed7evcwS33xgLCzSjy96kCXC2rRXiACrf2dj69GB85z3AVWn+bQlAe2cWLF9u97bJly9zYEopQQ2SOIiXtpVQmFw3hL16TwnlyBo97fQgBSthyloiMBKyEEM8WVKKiVocAJ/WxgHAXP/1xPA8FlXWICvLBNCfLeVpDKcB79KcDV1BVp0fbqACMcoHnWageSoDNQFFRq0PbqACMdTK9WEO4aIlOQNICQgg+2X4RAHDPwBT4qVqWbYOD70jQGYwtzuLhKQRlyB49etTi/yNHjkCv16N9+/YAgPPnz0Mul6N3797eaF6rQipGk7TSb0ljctEQ/sxfKQHPuTPU6589dL+p1UC0yaixUaJ2Xzbrje2bGm7WujqKEJ8jhBB8toMNyc4ZnAIfhesGa6F5K+t0Bnxq6uv8oa7xPAtV96zW6vHFTtbLvmhkussmxUKMhO28UIIz+ZXwU8oxa2DLsjLw4RuyQupvcwjKkN22bZv572XLliEoKAhff/01wsLCAADXr1/HnDlzMHToUG810aUYDAbodDpvN8MqjEGHhCA5fBQy1NXVebs5ThPuy0AXJIfcqBNFP5RKJeRy6wOrVNNvcYM+w8BlIV6xIRdgBKSl+liAP/kSzjW79VwRMgurEKCStzjvZkOEVgDih/1XUFylQUKoH27uleiSfQrRsAOAHw9cRVmNFknhfpjawsIWfIQ4GfvY5I29vV8SwgJULtsv3/gXUn+bQ1CGLJ+3334bGzduNBuxABAWFoZXX30V48aNw+OPP+7F1rUMQggKCgpQXl7u7abYxGAkeHFkNBgGuHTpkreb4zQP9Q2B3hgMeU0JLpn0fkInNDQUsbGxjVaMClWr1VI4z05r1ccC9edWKJMUg5FgP1cIoQWGbP3kSxgGOiEEyzezaRvvGpiMED+lS/dffx693986nQEf/8saPAtHpreoKAAfoXmdAZPn2dTXB0ekOx1BsIbQPNB7skqwN7sUSjmDe12QlYEPwzBQyBjojUQw/bUHwRqylZWVKC4ubvR+cXExqqqqvNAi18EZsdHR0fD39xdkigudwQhDcTUYAKmxwd5ujtMYiqphMBqRHB4AXxfpiNwFIQRqtRpFRWyC9rg4y5rZHg8/ewgpLchzFqF58s7mV6KyTo9AHwU6xzt//wtt8rXlbBFO5lbAXyV3ycKnhgjJW/njgXpv7PTervHGArwStQIydNYcuoqiKg3iQnxxi4s8zxxCKupBCMHrGzIBAHf2a4PEsJYVQLCGnDNkBdBfexGsIXvTTTdhzpw5ePvtt9GvXz8AwP79+/Hkk0/i5ptv9nLrnMdgMJiN2IgI5z0d7kZhMIJRaAGw6c6EaGzbg0yhgdFI4OvnKwrhup+fHwCgqKgI0dHRFjIDoddxd5b66mvivMZcgdDOLScr6JsS1iLvFn/y5e28lIQQLN9yHgCbPD4i0MflvyGU/Nt1OoM5/PzgyDSXeWMBXhpAARjrAKuNfW9rFgBgwQjX9hXgeaAFYLhvPFOI41fL4aeUY9Eo9+TQV8gYaCCMyZi9CNaQ/eSTT/DEE0/gzjvvhE6nAyEESqUS9957L958801vN89pOE2sv7/rZ1IuhTfeEMt/RQV3K4qp/dy1odPpLAxZIWq1XAFnvMklsCDPWYR2bjlDdmBayybbDRePeHPR5ZazRTiVWwl/lRz3DXVtSJZDKPm3v917GUVVGsSH+LosNROH0HTPK3bnoLhKg6RwvxaV3rUFl3nD2/01GAneMnlj5w5JQVSQ6ydiADcZMwhG5mQPgjVk/f398dFHH+HNN9/ExYvszDItLQ0BVlbXihGhezgZiViyRISWrK1rQyGQB6qr0VNpgWAGS64N9fljW2jI8ry5eiOBCxMEOIQnvLGAMCYkFWodPtjGeigfHdPObR5KIeiAr9dozWmoHh/b3uV9BYRxTgHg16O5uFBUjRA/JeYPS3Pb7whJHmMvgjVkOS5fvoy8vDxotVrk5OSY3586dar3GtUK4JtSRMSWbL0dK8728xFy/saWYKDSAs8bBwoFcM899X/zOJtfiao6PYJ8FOgU1zJ9vEIgq6D/PlmAU7mVCHCjNxbwQoU2K3z0bxYqanVoFxOIW1yojeUQkqHz0fYsVGn06BgX7NJMBXyUAigNrtEb8M5mdiL2wPA0ly9S5COkiYq9CNaQzc7Oxk033YSTJ0+CYRgQk2uN81YZDAZvNk/y8J2CxPvPK4eYPXs2ysvL8euvv5ob7yoHuMW+PYxcYDpKVyGlohXO4nHjwMcHWLnS6kd7L7Kygn4tyB/LwT+n3qp2pTMY8dZGNiQ7b2hbt3ljAe9XaMsrr8WK3TkAgKcndHDLPSUUHXBueS2+3nsZAPDUhPZuS90nhNLgP+6/gmvXaxEd5IPZg1Lc+ltCig7Zi2BjeY888ghSU1NRVFQEf39/nDp1Cjt27ECfPn2wfft2bzevVeHuy3n27NmYNm2ay/dLCHFaI5uTkwOGYXDs2DGL9999912stGEAuBupemQ5w1wsdb3dgVCMA8A1+WM5LD2y3pmArT50FZdKahARoMJ9w1yfqYCPt8PQ72w6D63eiH4p4S6p4mUNoUyol5v62j81HCPaRbntd7ztga7R6M1SkYdHZ7isipctvH0NO4NgPbJ79+7F1q1bERkZCZlMBrlcjiFDhmDp0qV4+OGHG1UBo7gWhmHAgGFlBW66ng0Gg0u1wg33545mh4Q4V6rTFUhdI0s9sh70+hDCVvcCAH9/c8jCYCQ44CJ9LMA+R+QyBgYj8crAWKs14F1T3thFo9IR6OPeIa8+NZXnjbzMgiqsO3INAPDMpA5uW4chhAn1hcL6vj490X19Ber7q/PSRGzF7ksoqdYiOcIft/V17cI9ayi8eA07i2A9sgaDAUFBQQCAyMhI5OXlAQCSk5ORmZnp9t//8MMPkZKSAl9fX/Tv3x8HDhxw+2+ipsb2q2FVqqa2ra1tfls74J4NnF9zxIgRWLRoERYtWoSQkBBERkbiv//9r1n2odFo8MQTTyAhIQEBAQHo37+/hfd85cqVCA0Nxe+//45OnTrBx8cHc+fOxddff43ffvuNNZ4ZBtu3b8f27dvBMIxF0Yhjx46BYRizVtra/q5cuWLe/uWXXsKI7ukY1LENFj64AFqt1vzZ+vXrMWTIEISGhiIiIgI33HCDeVEhAKSmsjq6nj17gmEYjBgxAkBj77FGo8HDDz+M6Oho+Pr6YsiQITh48KD5c64fW7ZsQZ8+feDv749BgwY5dQ0LLUWTq6B5ZL3gBVGrgcBA9sUZtABO51WgSqNHkK8CnVqQP5aPNz08K/ZcQlGVBolhfrizv+tXtDfEm319Y/05GAkwsUsserUJa/4LTiKEAgFvbMiEkQDjO8e4ta8AT/fshf6Wq7XmEsOLx7Yzh/3dibc90M4g2JGjS5cuOH78OACgf//+eOONN7B79268/PLLaNvWveGhVatWYfHixViyZAmOHDmC7t27Y/z48eZE9W6DG1isvW65xXLb6Gjb206caLltSkrjbRyAfzl//fXXUCgUOHDgAN59910sW7YMX3zxBQBg0aJF2Lt3L3766SecOHECt956KyZMmIALFy6Yv69Wq/H666/jiy++wOnTp/Hee+9hxowZmDBhAvLz85Gfn49BgwbZ3baG+4s21Y/fsmULzp49iy9W/4H/ffA5fvnlF7z00kvm79XU1GDx4sU4dOgQtmzZAplMhptuuglG06ybm7hs3rwZ+fn5+Pnnn63+/lNPPYV169bh66+/xpEjR5Ceno7x48ejrMyyitjzzz+Pt99+G4cOHYJCocDcuXPt7iOHGEM+9sAtKvBmaiZvoxTAIiGgXlbQPzXcZR5ypZcmYOVqrTmX6uKx7eDjgZQJ3tIX7s8uxZZzRZDLGDwxvr1bf8vbhs7hy2XYdKYQMgZ40s19BXiLn7zQ34//vYiqOj06xAZhSjf3LGZrCKcJ9kZ/nUWw0oL//Oc/qDF5Dl9++WXccMMNGDp0KCIiIrBq1Sq3/vayZctw3333Yc6cOQDYnLZ//fUXvvrqKzzzzDONttdoNNBoNOb/Kysr3do+T8EwAIjlYq+kpCS88847YBgG7du3x8mTJ/HOO+9g/PjxWLFiBa5cuYL4ePaGe+KJJ7B+/XqsWLEC//d//weAzY360UcfoXv37uZ9+vn5QaPRIDY21uE2WtsfAKhUKnz+xZfIqdAjvX1HvPTSS3jqqafwyiuvQCaT4ZYGE4OvvvoKUVFROHPmDLp06YKoKFZzFRERYbNdNTU1+Pjjj7Fy5UpMNE0ePv/8c2zatAlffvklnnzySfO2r732GoYPHw4AeOaZZzB58mTU1dXB19fX7r6KUYRvDzRrgTAWlADAvmzXyQo4vDUB+3h7vRFwY48Ej/ymN1Z8E0Lwv/XnAAC3901CWpRjjgpH8WalK0IIXv+HjWbd2jsJ6dFBbv/N+up0nu1vYWUdVpoW7j053n2L2RoilEm1IwjWkB0/frz57/T0dJw7dw5lZWUICwtzqx5Gq9Xi8OHDePbZZ83vyWQyjBkzBnv37rX6naVLl1p4+5ymutr2Z/IG3oSmvMMNQ7S8tGWOwKasshx8BgwYYHH8Bw4ciLfffhsnT56EwWBAu3btLLbXaDQWFcxUKhW6devmVHusYWt/3bt3h5+/P1BRaW5ndXU1rl69iuTkZFy4cAEvvPAC9u/fj5KSErMn9sqVK+jSpYtdv33x4kXodDoMHjzY/J5SqUS/fv1w9uxZi235beRKzxYVFaFNG/vDnfWDpLQMWaqRFYbuUG8wulQfy+GNCVh+RS1W7skBwK5o99S15Q1v5fpTBTh6pRz+KjkeGeOeak98vFkqe+u5IhzIKYOPQoZHx7q/r4D37s33tlyARm9E7+Qwty3cs4aQKpnZiyANWZ1OhwkTJuCTTz5BRkb9xRoeHu723y4pKYHBYEBMTIzF+zExMTh37pzV7zz77LNYvHix+f/KykokJTkhynak2IO7tuVh1sjakX+ruroacrkchw8ftqhGBQCBPCmDn5+fXRMRmckY5/82VxWNT5P7M32VAdNomylTpiA5ORmff/454uPjYTQa0aVLFwsdrStRKuvz/nFtMTo4460fJMUzU7YH7oHZ0lRPYkYhgGpJp/MqUa3RI9hXgY4tzB/Lxxteync3s0ZA35QwjGzvOSPA09kn9AYj3jRVe5o3JBXRQfZHeJzFW9EDg5HgdZPnefbgFMSF+Hnkd72hCc4pqcGqg1cBAE+Nb+/RAkpCmFQ7iiANWaVSiRMnTni7GXbj4+MDHx/35Sb0NvzLef/+/Raf7du3DxkZGejZsycMBgOKioowdOhQh/avUqka5QXmQvv5+fkIC2PF/A1TYTXF8ePHoa5lF7EwDNvOwMBAJCUlobS0FJmZmfj888/Nbd21a1ejNgFN5ytOS0uDSqXC7t27kZycDIA1tg8ePIhHH33U7rbai1Q1slyIsnVLC7y7Mhqo18f2S41wqQfT017KrKJqrD7EGgHPuHlFe0M8bQSsPnQN2R5KLcah9JJGdt3hazhfyFa2enB4usd+1xte9mWbzkNvJBjRPgr9XRgdsQdzLmQRjTOCdYHcdddd+PLLLz3+u5GRkZDL5SgsLLR4v7Cw0CkNp5ip98jWv3flyhUsXrwYmZmZ+PHHH/H+++/jkUceQbt27TBz5kzMmjULP//8My5duoQDBw5g6dKl+Ouvv5r8nZSUFJw4cQKZmZkoKSmBTqdDeno6kpKS8OKLL+LChQv466+/8Pbbb9vddq1Wi/nz78PF8+ewY8tGLFmyBIsWLYJMJkNYWBgiIiLw2WefISsrC1u3brXwqANAdHQ0/Pz8sH79ehQWFqKioqLRbwQEBGDBggV48sknsX79epw5cwb33Xcf1Go17r33Xrvbai9S18i2ZmmB0hyBAIxeOr97TYbswDTXDpye9lK+ZVrRPqZjDHonuz+Kx4dv9NgTyWoJaq0ey03Vnh4alY4gX/dVe+LjjUlXnc6AZZvYvi4amY4Qf8/0FeA7EDzT3zN5lfj9OJul6Ylx7l/M1hAhVKdzFEF6ZAFAr9fjq6++wubNm9G7d28ENAiPL1u2zC2/q1Kp0Lt3b2zZssWcZsloNGLLli1YtGiRW35TqFgr6zpr1izU1taiX79+kMvleOSRRzB//nwAwIoVK/Dqq6/i8ccfR25uLiIjIzFgwADccMMNTf7Offfdh+3bt6NPnz6orq7Gtm3bMGLECPz4449YsGABunXrhr59++LVV1/FrbfealfbR48ejfS0dMydPhlarRYz77wDL774IgBWtvDTTz/h4YcfRpcuXdC+fXu899575hRbAKBQKPDee+/h5ZdfxgsvvIChQ4daLcTxv//9D0ajEXfffTeqqqrQp08fbNiwwexFdiWS1cia+uOJ1DJCRc7L2KA3EqjcbdTL5cD06ea/9QYjDpr1sa41/jyZI/fY1XKsP10AxkMr2hvCTyGnNxK3FvlYsTsHRVUaJIX74c7+yW77nYZ4QwazYncOCirrkBDqh7sHeq6vAD83sIcmYqYqdDd0i0OXBM/nLVeIcJwRrCF76tQp9OrVCwBw/vx5i8/cHSpavHgx7rnnHvTp0wf9+vXD8uXLUVNTY85i0FrgjjLfs6BUKrF8+XJ8/PHHjbZXKpV46aWXbC58mz17NmbPnt3o/aioKGzcuLHR+4MHD24kMeG3xdb+uMpbdToDbnvgcShkskY5MceMGYMzZ87Y3DcAzJs3D/PmzbO6bw5fX1+89957eO+99xq1A2Bz7zbcb48ePZzy1khWI0s9so0qYKncHSzz9QXWrDH/e+pqOWq0BoT4KdEx1nX6WMBzHi12RTuroby5ZyLax7p/RXtD+BMSg5FA6aaMX9drtPjElFrsiXHtoVJ4bhLo6TK85WotPtrOVrZaPLYdfN11UG0g92Co/VBOGbaa0qg97gVvLFDfXzFF/gRryG7bts1rv33bbbehuLgYL7zwAgoKCtCjRw+sX7++0QIwyWMuiCBOOGPRgxI5tyJGEb49GKhGtpEnz9PsvVifP9bVaX48tVhmx4US7M0uhUouw2MeWtHeEMsJifv6++G2LFRp9OgUF+yx/KIcng61f7gty5xGbVpPz6RR4+OpQjSEELyxnvXGzuiTiNRI5xZptxQxFt4RrCHrbbgKVq2Zeo+sV5vhNCJttk3kAqio4w64EBb1yLJ44/xyC71cmXaLwxOLZYxGgjdMK9rvHpiMxDB/t/1WU1ieR/cYAteuq/HN3ssA2PKsnsovyuFJrf6162p8vae+r954Rngq3dj288U4kFMGlUKGh0d7ZyIGeDe9mrMIypC9cuWKQ3k1c3NzkZDg+Rlaa6GhhMOaRlTIcAY49cgKG25AbM0aWZmMAcOw16xHPF01NeYKf/tO5GDPxRIAbjJkPTAwrj9dgNN5lQj0UWDhSM+taG+I3AMe2WWbzkNrMGJQWgSGZUS65TeawpNafa6vA9tGYES7KLf/njU8MREjhOAtUxq1ewYmeyy1mDW8XbnNGQQ1cvTt2xf333+/Ra36hlRUVODzzz9Hly5dsG7dOg+2rvVh9siK3LdpbdGaGKEaWWmj9JI27aEfjkFnIJjUNRYd41yvK3V3qNJoJHh3M1sGe+7gFIQHqNzyO/bAMIxbDYGz+ZX45WguAODpCZ5NLcbhKUOH39dnJ3mnrwCvZKsbDfeNZwpxOq8SASo5Fozw3kQM8Ex/XY2gPLJnzpzBa6+9hrFjx8LX1xe9e/dGfHw8fH19cf36dZw5cwanT59Gr1698MYbb2DSpEnebrLTuDs1i0uwkn5LTJg1sl5uh6PYujbEGPKxB87Aac0aWcBkyBs8Ly2o1ujRv300ls3o4RZjwd35j/8+lY/MwioE+Spw7xDP5FJtCrmMgd5I3FIA4s0NmSAEmNw1Dt2TQl2+f3uofw65d0L9zqbzbF+7xaFbYqhbf6sp3J2OymgkWG6aiM328kQMEGeJWkF5ZCMiIrBs2TLk5+fjgw8+QEZGBkpKSnDhAnuSZ86cicOHD2Pv3r2iNWK5Ck9qtdrLLWmeeo+sODG3W2T2EXdt8KuBAd6rqONuOANH4cZURWLAk9KRGo3e/He7mEB8NquP21aDu1NTaeAZAfOGtPVoflFbuKu/hy9fN69of8ILqcU4PJG14FRuBTaeKQTDAI+Nadf8F9yIu+/LDacLcDaflcXcN1QYEzFAXA4TQXlkOfz8/DB9+nRM5/IcSgi5XI7Q0FAUFRUBAPz9/b0WMmkOo14LotdDUydDnUw8szMOTZ0ORK+FEXLU1dV5uznNQgiBWq1GUVERQkNDG5X6FaN2yR64/vBX7rdGPJWInBCC//x6Cu+Y/v/s7j4I8XOfAejOErV/nshDVlE1gn0VmDMkxeX7dwZ3aUjf28Ia7Lf0SvDainbA0tAhhLhl/OL6OrV7PNKjA5vZ2r24M+sG3xs7d3AKQv29640F6idiYnKYCNKQlTpchTDOmBUqpdUa1OqM0JUrcd1HfJdKrc6A0motVAoZSJV4SgiHhoZarSKn8HDaG0/BVQhq7RpZT2nTPtuRjfWnCsyGbEyIr1t/z10TMKOR4P2tbH7R+cPaIthDla2awx39PXa1HP+eL4Zcxnh1MRsAiyIPBiNxeSSF7419aJT3Vu9zuNOB8M+pAkHJYgDqkaXYCcMwiIuLQ3R0NHQ6nbebY5MVv57C7osleHRMBqZ0EF92iJ3ni/DitjPoHB+C9+7o4O3m2IVSqWzkieWQqkbWYKDSAoCvTXPf+d2XXYrX15+DJ6d1nKdd5+J+bT5biKyiagT5KnDPoBSX7rsluEND+r7JQzmtRwKSI7znjQUaZ2ZQuFiR8q6AvLGA+0ryEkLMhR7mDE4VhCwGoHlkKQ4il8ttGi1CoMYgQ26VAWqDHL6+7vXauAMNFMitMiBRC1G2vyGS18i2eo+seycqlXU6PL76OIwEmNorCWTSJFY+7uZnEFftyuDCgZE1AtjKVrMGJiNIIN5YwPUa0lO5FdhyrggyBlg4Ms0l+2wJ/DR5rp50nc2vxCYBeWMB900wd2WV4HReJfyUcswW5ERMPOMMNWQpNhFjiIEPN5BIJT+pUqIaWb1ZWiCN8+Qs7vaEvPT7GeSW16JNuD9euLUXmLv+csvvNETphufI/ktlOHa1HCqFDLMHpbpsv67A1c/N97fWeyjbRgnHQwm4flL92Y5sAMCkrnGC8MYC7nMgfPIvOxG7rW+S1zMV8BFjiVpBjRxVVVV4/PHH0bFjR0RFRSE9PR2TJk3Ca6+9hnPnznm7ea0OsectlVp+UneFuLyNuSCCRM6Ts5gXlbhhAFl/qgDrjlyDjAGWzeiOAA9q3t1Rq/5jkzd2Rp9ERAUJS/+ucKEHL7u4GhvPFAKA17WxHJZleF33LMorr8Ufx/MAAPcPE4ZeFHDP2oQT18qxO6sUChmDeUOFNRET41oMQXlkZ82ahcOHD+O+++5DTEwMamtr8fTTTyM7OxsvvPACbrjhBnz88ceIj/dsbenWitg9spwBLpWQtSsHSCHBeTrkrVwj665FJddrtHj+l5MAgPuHp6FPSrhL998cru7XmbxK/Hu+GDIGmD/U+6H2hrjSs/7V7ksgBBjdIRoZMa4vVuEMDMNALmNgMBKXXqtf7boEvZFgYNsIr+aNbYg70m9x3tip3eO9Vk7ZFmZpgYgkbIIyZDdu3Ihdu3ahZ8+e5vf+85//4O+//4ZcLsdrr72Gvn37YteuXUhNFdYsRoq4M+2IJ5CaR9YT+Ru9gYFqZAG4L03VWxszUVqjRfuYIDw6xqQ7rKkBoqPZv4uKgAD3LSBy9cD4xS42/Dy5WzzaRAjLCAB492kLDZ/rNVqsPXwNAHCvwLx2nCHrqgV8FbU6/HjgCgBg/nDheGMB1zsQLpfW4J9TBQDYiaXQEGOaR0FJC2JiYmwWCkhOTsZnn32GBQsW4JFHHvFwy1onnkzQ7g6kppGVi/ABYw86syErjfPkLAo3JNI/ea0CP5gMhJdv7Awf/hJztZp9uRlXhipLqjX483g+AGDeEGEZdxyuylrw/f7LqNMZ0Tk+GAPbRriiaS7DbOy4aHLyw/4rqNEa0D4mCCPaRblkn67C1Q6Eb/deBiHA8HZRaB8rDC87H7mbsoy4E0GNHIsWLcLcuXNx/Phxm9vcdddd2Lp1qwdb1XqRU42soPBUaUhPY5aAUGkBANdNHI1Gghd+PwVCgBt7xKO/l4whV2p/Vx28Cq3BiO5JoV4r0docZklWCwwfjd6Ar/deBgDMG5oquKI5rpyc6AxGrNxzCQCbD1hofZW7sK9qrR6rD10FAEFlKuAjxhK1gpIWLF68GHl5eejVqxfGjh2LadOmwWg0WlzYP/30EyIjI73YytaD2D2yktPIivx82MKskZXIeXIWVxhAfNYeuYajV8oRoJLjuUkdXbJPZ3CVZlRvMOK7faxxd8/A5Ba3y10oXbDq+4/j+Siu0iA22BeTuwpvTYgrJydbzhaisFKDyEAVpnQXYl9dd1/+diwPlXV6tAn3x3CBeZ453FWZzp0IypAFgLfeegu33nor3nrrLTz++OOora1F9+7dERkZiYqKCtTV1WHlypXebmarQCoaWal4+rgQl6vCeUKBO0/KVi4tULrQ416nM+CtDZkAgEfGZCAm2Ht5lF21aHTz2ULkV9QhIkCFyd3iXNE0t1CfXcT5/n5rMthnDUqGSiG8+0LhwkkX19fb+iYJtK+uMdoJIfh6Tw4ANvexTKATd1dMxDyN4AxZAOjfvz/WrFkDrVaLI0eO4Pz586isrERkZCRGjRqFaG6RAsWtiFH0zafe0ye8h6MzSDX9ltQkIM7iynyV3+27jKIqDRJC/byeZ9VV2t+VJiPgjn5tLLW+AkPRwtDs6bwKHL9aDqWcwYw+Sa5smstwlbTgYnE1dmeVgmHY8ypEXDUOHsy5jnMFVfBVynBrb2GeV0Cc2YoEachyqFQqDBgwAAMGDPB2U1olrtQGeQOpVYySavotqpFlcdWAWaPRm6tePTI6w+teLoULQpXnC6uwL7sMchmDO/sL0+DhaKm38of97OK88Z1jERkorBy5HHIXVX/6fh/b19EdogWXhorDVdlEvt6bAwC4qWeCYMrRWqNeSiGecV/QhizFu4jdI2swV4yShoHkqhCX0OAMnFaftcBFnpCVe3JQVqNFSoQ/bu6VYH0jmQwYPrz+bzfiikWjqw+yC2RGd4hGfKifS9rlLlpSAKJGo8dvx9iiAHcK1EMJuCb8XKs1YO1h9rzeNUDAmmcXRBTKarTYeJpNuXX3gBRXNMttiHGcoYYsxSZcSFBMom8+Zu2lRDx9nKFDCLsiXagaK0cxUGkBANdkpais05nLfD46pp35Hm6Enx+wfbvTv+MIyhZ673QGI349lgsAgg2182lJf38/nodqjR6pkQEYmCaslFt8XOGl/ON4/cKnYRnCXPgEWIbaCSFOZVX49WgudAaCrgkh6BQf7OomuhQxpnls3S4QSpOI3SMrOY0szyCXkk5WahIQZ3FFvsqvd+egolaHjOhAwawAb6n2d9u5IpRUaxEZqMLw9sI1eDjkLcjSwMkK7uiXJLg0VHxcYexwaaju6NdG0JNyviPE2f5yhS1u7ZPokja5E1dWpvMU0hjhKW5BjKJvPlKrGMVf1S/WyYU1uAcm1ci2zDio0xnMOrxFo9IF4+FWtlDbvcZkBNzUM0EUxU2cPY+ncitwMrcCKrkM0wW8GAioD7c7OzZcLq3BocvXIWNgW/4iEPj3kTP9PZ1XgTP5lVDJZZgqkMllUyhcpH/2JMJ/KlC8RktX33obvcQ0si19oAqV+glH634ctTQrxe/H81BSrUV8iC8mdW0mPVVNDRAVxb5qapz6PXtpSRi6pFqDbeeKAAC3ikBWADifY/WXo6x8YmynGIQHqFzeLlfS0pzHPx9h+zokI8qrqeHsgf9ccua5y3ljx3aKQai/sM8rIM5S6FQjS7EJd0GLViNrkKZGFhDXQ6Y5aPotFnOaKifOLSEEX+5kqyPdMyjFPs9lSYnDv+MMLfE0/3o0F3ojQffEELSLEV45T2s4E5rVG4z4/Ti7yOumnsL2UAItq/5ECMHPR1nj7haBe2MBy0iRo/emVm80L96bLgJZASDOCpKt2wVCaRLRa2SN0tLIymQMONmcmB4yzcEN+FKZcDhLS7IW7MoqQWZhFfxVctwusNXuLVkFzXmzpovEGws4F5rdc7EUxVUahPkrMUygFZ/4tKT608Gc67haVosAlRzjOsW6umkuR87wI2GOPXe3nitCWY0W0UE+GJoujoqkYhz3pTHCU9wC1cgKDzFWXWkO6pFlaUne5i9M3tgZfZIQ4iesHJXOengyC6pwrqCK1RZ2E762kEPhxD36q0lWMLlbnNfz/tqDM33k+PkIOzmZ1DUOfirhFrbgkMkYyMwOBMf6y53Xm3ol2M4gIjBoiVqKpBC/RlZaJWoB00PG4H5pQblai5JqLUqrNQgLUCEjOtBtq6ipRpbF2bRNWUXV+Pd8MRgGmDvYu1W8rOGsnvKvE2xIdli7SEEnkG+Io4aAWqvHBlOOUTHICgDnFwTV6Qz460Q+AODmXuIItQOs7EerNzrU32qNHtsyWX33jd3FcV4B1+TN9TTUkKXYRIyibz7m1fAS8vS5Kmm+NXQGI/46kY8vdmXjVG6lxWcxwT4YlhGFWQNT0DUxxMW/K70JhzNwEhhHdXirDtZXR2oTIbzqSM547wgh+NNk8NwgIm8s4LgDYNOZQtRoDUgK90OvNmHubJrLcDZF09ZzRajS6JEQ6of+qeHuaJpbUMgYaOHYvbnlbCE0eiPaRgagY5w49N2AOCOx1JCl2ESMFzQfqWlkAfd5ybdnFuHZn08iv6LO/F6QrwIRASrkV9ShsFKDNYevYd2Ra5g3tC0eG9POZWFBc4laCU04nMGZSYpWb8Q60wrw2/sKSxvLYS5R60C/zuZXIbukBiqFDKM7RruraW7B0ZK8XPh5Wo8EQeeO5ePs2PD3SdPkpHucoHPHNqT+Grb/uctNxCZ3ixPNeQX4zyHxRGKpIUuxiTu9f55AihrZlpS/tAYhBJ/tyMb/1p8DIUBkoA/uGZiMmQOSzSmA6nQGHLhUhtWHruLPE/n4bEc2Np4uwGez+rhkJTnVyLI4oyXdcrbQvJhkhCPFAmQyoE+f+r/diDOTrz9NsoKR7aMQ5CseWQHA86zbcY+Wq7XYeYHNHnFjD/GEnxVOhJ/rdAZsNaVSm9SlmfRwAsPR/lbV6fBvZjEA1pAVEy3JnuItqCFLsYmcamQFh8JJvaE1dAYjnlp7wpy/8o5+SVgypTN8lZaeVl+lHMPaRWFYuyjc1LMQz/9yCjmlatz5+X6svn8A2kYFtqgd9WnSpOM5dwZnVguvMlVHuqV3omOLSfz8gIMHHWqfszgqUSKE4K+T4pQVAIDSAQfA5rNF0BsJOsQGIT26ZfeRJ6n3Ots/Nvx7vhhqrQEJoX7o5mJ5krtxNBfypjOF0BqMSIsKQHuRpI3jcMb77G1a98hBaRKlRDSyUvL0uUruQQjBkt9P45ejuZDLGLx8Y2f8301dGxmxDRndMQbrHx2KjnHBKKnWYOYX+3G1TN2ithioRxZAvSfP3pB0XnktdpxnvT4zBJyeytFr9lRuJS6XquGrlGFUB3HJCoB6B4A9+tH1p9hFXuM7Cz8NFR9nStT+Y5qcTOwSK6pQO1A/ObG3v3/x9N1i66uihZX4vAE1ZCk2kYpGVkqr4VuSiJzPl7su4Yf9V8AwwEcze2HWwBS7H7ih/ip8d28/pEcHIr+iDnd8vg/Xa7ROt0VPNbIAHC/luvbwNRgJ0C81HKmRAe5sWotwtF9/nmRlBaM7xCDAR3xBQ3tT5NVo9Nh5gZ2ITOgiLkNW6aDESaM3YPNZVlYwsbmqcwJE7kCWhopaHXZcEKesABDnuC+dEZ7icsQ4M+MjRU+fK3L8bT5TiNf+PgsAeH5SR6e8QRGBPvhhXn8kR/jj2vVaPP/rSRDieJuMRgLu8pLSeXIGR8KXhBCsOczKCm5zxhurVgMpKexL3TKPenM4GpbdeLoQADCxq7iMOw57DYF/zxdDozciOcIfHWLFFX6u9zrbd8/vulCCao0escG+6JkU6saWuQdH5DFbzhZCZyDIiA4UTTU6PlxfCRHP2E8NWYpNWpKgXQhwA4mUKka1JBE5ABRW1uGx1cdACHBHvza4d4jzeUejg33xwR29oJAx+Ptkgbl+uiPwB3uxJAx3F44sKDl6tRxXy2rhr5I7Z/ARAly+zL6cmIA4giPX7MXialwqqYFKLsOI9uKTFQD2L9rjZAUTOos51G7f2PD3SVNfu8SKKlsBhyMr+beYPM9ik4tw8NeUiGXsb90jB6VJlE7mtRQKUtTIOpuIHGC9eP/59RSq6vTonhiCl2/s3OIBtGtiCB4dkwEAWPL7aYf1snzjprVLCxzJEvLHcTb8PrZTDPxVwg6/O3LNbj7DemMHpEUgUISyAsA+751GX7+Cf7zIZAUAT89txznVGYzYdIY1ZCeJUFYA2K8J1uqN+NekWx/TKcbt7XIH/Ocw9chSRI85JCiSi7khUqwYpXDQE8Lnr5P52HSmEEo5gzemd3dZloAHhqehd3IYqjV6PLX2hEMSA/6MX0oTDmeor4DV9Lk1GInFYhKh40jy/M1nWUN2jMhyx/KxZ0KyJ6sU1Ro9YoJ90CMx1EMtcx2OyM4O5pShsk6PiAAVeieLo+BDQ7hnZXPSgv2X2PMaFeSDbgniyszAwX8Oi6VMrXRGeIrLEbtGVorpt5zVyF6v0WLJb6cBAA+OSEd7F2ryFHIZ3pnRAz4KGfZml5oXddgDf2Bo7em37C1RezCnDEVVGgT5KjCsXaQnmtYiOMlEc/0qrdbg8OXrANjsGGLFHo0sP1uBqEPtdjyHtpqeByPaR4t2smqv7pmLKIzuEC3K8wrUR2IB8Yz9rXvkoDSJvR4ioSLJErVO1sF+Y8M5lNZo0S4mEA+OTHN5u9pE+GOuSW/7v3/O2n3N8AcGCZ0mp7A3kT5XLGBC51j4KFxTXc2d2Gv0bMsshpEAneKCkRDq54mmuYXmCkAYjQRbM1njblwn8ckKAMc0o1xfxVahjY89UQVCiHkSL+aJmEzGgFOciWXsp4YsxSbOJGgXElKsGOVMtbWsomqsOsiucH/tpq5uM34WjEhDmL8SF4trsPrQNbu+w6++JrYFL67GHoNPbzCaF85M6S58WQFgv76Q82aJVVvIoWgmH/CZ/EoUV2kQoJKjb6o4Q+32Vhi8VFKD7OIaKGQMhmYIP3pgC3t03ucKqpBbXgsfhQxD0sXbV8Dx9GreRpxqeopH4Lx/rtbIXiyuxp/H85FVXA2FjIFSzqBDbDCm9Uwwl0V1BVLUyDrjJV+2KRNGAozpGIO+KeHuahqCfZV4eHQGXvrjDJZtOo8be8Q3mweUS8kkJfmHs9jj5dpzsRRlNVqEB6gwKC3C+R9jGKBTp/q/3Yg9q/jrdAZz7s2xIvZmAc1LsraZFnkNTo8UhUfdGuY+NuNl5xa09W8bLrpSw3zsybyxxaTvHpoRCT+VOM8rh1zGAAbxOLGoIUuxias9slvOFuLtjedxJr/S6uf/++ccxnaKwaNjMpDhgvx7UtTIOuqRPX61HH+fLADDAE+Ob+/OpgEAZvZPxso9ObhcqsZXuy7hodEZTW4vxcmGs9ijSecWeU3sEtuydGX+/sDp085/3wG4c2skbFjdmnZwX3Yp1FoDYoJ90CUh2CPtchfN3aPbTKH2kSKsWsZhbxnTredY425UB3FPTuzJhbxJArICDmdKEHsTashSbMIPCRJCnA79qrV6vPLnWfx44AoAmMNMg9IiTZ8bsPlsIU7mVuCvk/nYeq4Ir93UBTf3SmxR+6lGFnhzQyYA4KaeCS5d4GULlUKGxWPb4ZGfjmHlnhzcN6xtk2VvpSj/cJbmStQajMS8ql9MaYz451ZvJFBZOdfbM1lv7KgO0aKXmDQVNSmr0eLo1XIAwIj2UZ5slkux5zlUVafD/uwyAOziJzHTXHW6kmoNjpvOq9j7CohvoTc1ZHnk5OTglVdewdatW1FQUID4+HjcddddeP7556FSuS7kLRYa5pNzxrN5pVSNe1YcwKWSGgDAvCGpWDgyHWENJASPjMnA6bwKLP37HHZllWDx6uM4mHMdL03tDJXCOc+TFI0kRzyyey+WYldWCZRyBo+NaefuppmZ3DUOb6zPRG55LX45mos7+rWxuS0XbpZS0Qpnaa6e+5Er11Fao0WwrwL9Ut0nEXE1/HNrq2+crGB4O/EadxzKJoy8HeeLQQjQITYIcSEiXtBmh55754US6I0EbaMCkCLgEsr20FzWgl0XSgCwCxWjg3091i53Ya8GWijQeB6Pc+fOwWg04tNPP8Xp06fxzjvv4JNPPsFzzz3n7aZ5BX7o0pkLOq+8Fnd8vg+XSmoQF+KLH+b1x39u6NTIiOXoHB+Cr+f2wyOjM8AwwI8HruDpdY7lJeUjxbC1IxrZT3dcBADc1jcJSeH+bm0XH4VchjmDUwAAX+zMhrGJa4cbCKU02XCW5irpbTrDhWmjW56qTK0GOndmXx4qUQtYD0VfLVMju7gGchmDQSJfJAM0HYaWgqwAsK/qI1fhShIeSnORC+v93WEqgjBMAhMxwLH0akKAemR5TJgwARMmTDD/37ZtW2RmZuLjjz/GW2+9ZfN7Go0GGo3G/H9lpXUNqNhQNAgJOkJRZR3u/HwfcstrkRoZgFX3D0B0UPMzVbmMwWNj26FLQgge+O4wfjmai7gQXzw1oYPD7ZeiRrYpbw+f84VV2J5ZDIYB7hva1hNNs+C2vkl4d/MFXCyuwbbMIpu6MSlONpylqZXRhBCzITvWFSmbCAHOnKn/241Y5KW0MjBy3tieSaEIFvGCIA5bawsMRmKu+jRSpOV3OZoLtRNCzOdVrKWG+TR1bxqNBDtMHlkx5HW2B3vLLAsFOno0Q0VFBcLDmw7jLV26FCEhIeZXUlKSh1rnXvieFEfK1Kq1esz66gByStVIDPPD9/P622XE8hnbKQZLb+4KAPho+0V8uzfHoe8D0tTI2puY+4ud2QDYXKPJEZ4P6wX5KnF7P/Y++NzUFmtwD0opTTacpanSpheLq3GppAYquQzDRaat5OeltOaRlZw3y0YBiGNXy1Gu1iHIV4FebUK90DLX0ZyeO7OwCsVVGvgqZeiTIs4UY3yaeu6eLahESbUG/io5+iSLR/LTFLYkbJV1Om80p1moIdsEWVlZeP/993H//fc3ud2zzz6LiooK8+vq1aseaqF7sfTI2j8ze/H30zhXUIWoIB/8MG8A4p1Mbj6jTxIWj2W1nS/+cQYnrpXb/V2jkYC7B6UUtrYnMXdRZR1+PcomzZ/nBW8sx5zBqVDIGOzLLsOp3Aqr21BpQT1N5VvdcJr1xg5Kj0BgMynNhIgtL6XOYMSerFIA0tDHArbDspw3dlhGVMsyTgiA5jLa7DzPeij7p0aINsUYH2UT6bd2mPo6sG2E0+s5hIbcyjVsNBKMfHM7Rr+9HVdK3StHchRpHPVmeOaZZ8AwTJOvc+fOWXwnNzcXEyZMwK233or77ruvyf37+PggODjY4iUFGIax2wPI8duxXKw+dA0MA7x3e0+0iWiZNvOhUemY3C0OBiPB46uPo05nsOt7Bl64VOyDBh97EnN/vTcHWoMRvZPDvFrbPD7UDxO6sGHwnw5esboNvyBCa8dcz93KpLFeViDO1D62vM3HrpajSqNHmL8SXURam74htu7RXaZQu5gLA3A0F3remcUad1LoKwDI5dYnJ4D0IgqAdQnbuYIqlNZokV9Rh9gQYS1ok84I3wSPP/44zp492+Srbdt6z1VeXh5GjhyJQYMG4bPPPvNiy72PI4ZsTkkNnv/lFADgoVEZGNiShO0mGIbBqzd2QWSgDy4UVeOdzeft+h7/BpSSkdRcYu5arQHf7WONRm9oYxtye182Y8Fvx/KsTkJ0VCNrxta9VlRZh2Om1D5jRJqj0laokjMChmREScYrX++trDfyKut0OH6NjUoMkYBx19RioDqdAfuzWS+7VIw7W8VKajR6HLrMphiTitEO8BYs8vq7K4u9V/unhgvO8yy+GJUTREVFISrKvhsqNzcXI0eORO/evbFixQrIWvkAq5Ax0KJ5jazRSPDEmuOo1ujRLyUcD49Kd1kbwgJUWHpzV9z3zSF8viMb4zrFNutp5K8YlsoACfBXRFs/H3+eyENFrQ6JYX6C8N4NSotAYpgfrl2vxT+n8nFTT8vcwAaqkTVjyzjgqiN1TwpFjEhT+9TnpbQ0BMzeLEkZAY29z/sulsJgJEiNDEBimOcyiLgLRRPpmQ7lXIdGb0RMsA8yogM93TS3YKu/+7JLoTMQJIb5IVXkKcb4mPME867hXSYJ0GABZhZp3VZaA3JzczFixAi0adMGb731FoqLi1FQUICCggJvN81r2JNmBQDWHrmGQ5evw18lxzu393B5OH9spxjc3CsBRgI89/PJZlftS9cja90g4PjBVHTijn5tBGHAy2QMbu3NLvpadbCxdpxqZOuxFa7lUja5NI0RwwDJyezLAwUIrOWlvF6jxQmTdloqnjvAuvd5lynUPkSARoAzyJuQFuw0SSiGpEeJvrgFh60CATvN2Qqk01eg8TWs0Rtw4BJryA7NEN69Sg1ZHps2bUJWVha2bNmCxMRExMXFmV+tFaWNFbh8ytVa/O8fVmP86JgMJDi5uKs5XrihE0L8lMgsrMLaw00vqOO3V0pGUlMa2bP5lTh6pRwKGYNb+7SsKpormd4nEQwD7Msuw+XSGovPuH4oW3nkA7AuG9Hqjdht8oS4tBKUvz+Qk8O+/N3vIbTmbd6XXQpCgIzoQNF6mq1hbULCGbJC9GY5Q1PSgp0SS0UF2M4NzJ1XKUUUgMYOrCOXy1GnMyIy0AftYoTnZaejB4/Zs2eDEGL11VqxtnqxIW9syERZjRbtYgIxZ3Cq29oS6q/CQybJwtsbz0Ot1dvclmuvQsZIaqYsb0Ijy5UAHtc5xuF0Z+4kIdTP7Ilac+iaxWdSrL7mLHzZCPfMOXS5DNUaPSIDVegSL97FUNYmYHtNOspBLtDSC4mGWue88lpkF9dAxsAl6waEgC2tfnGVBmfy2TzqUjHaAetV94oq65BVVA2GAQa0lcZ55WiYJ3i3OaIQIcjxlBqylCZpLs3KiWvlZgPq5Ru7tLziUDPcPTAZSeF+KKrS4Iudl2xux80kpWYgKWxoZNVaPX45kgsAuLNfssfb1Ry39WXlBWsPX7O4lqhGth5+KVfuEP2bWb8iWibia9la2rg9F1lDdmCadAweoD66QAi7doArX9o9KRQhfuIv+ADYjgxxBk/n+GBEBvp4vF3uwlreXG4i1ikuGKH+0iph37C/OwUeUaCGLKVJmtLIEkKw9O9zIASY1iPeI7NSH4UcT41nq3x98u9FFFXVWd1OqmmdbC2a+fN4Pqo0eiRH+AvSwzW2UwxC/JQoqKzDgUtl5vd1BmmeJ2fgT7q4+217ppuqI9XWAn37sq/aWtfu2woNvZRFVXxvljSSyHPIeRMSndFYn4pKoEaAM9gaF/ZcFLbB4yzWnrv7JBpRACzXYlSodThpyuEu1Iwb1JClNElTGtldWSXYm10KlVyGJ8a391ibbugWh+5JoVBrDfh4+0Wr29SXp5XWJW4rjdGPB+sXeQnRc+ejkGNCZzan7B8n8szvG8zSAmmdJ2fgpyDTGwjyymuRWVgFGeMGDZ7RCBw6xL48UIayYV7KfdnsZKZjrPS8WXy9t85AsEfg3ixnMBcIaBAZ4ryUUpFQcFh77tZHFKTVV8Cyv3uzS2EkQFpUAOJC3LP+paXQ0YPSJLY0soQQvLkhEwAwc0Abj6aUYRgGj5sqfv104CpKqzWNttFL1NNnLbXPxeJqHL1SDrmMwc29ErzVtGaZ0j0eAPDPyXzzogm9RD3nzsCXV+iNxOyN7ZEUKnpjr+Fimb0mz50UvVl8z/rp3AqU1mjhr5KjZxvxl2rlqM8zWv8cunZdjatltZDLGPRNkZiXvcE4mFtei8ulakn2FeBJRwyEp48V7kSMGrKUJrGlkV1/qgAnrlXAXyXHwpGuyxlrL0MzItE1IQS1OgNW7slp9LlUNbINRfgAzNrY4e2iBLXIqyED2oYjMlCF62qd+eFoMFCNLIect4jCYCTYbkq75XJZgRdQNPDI7m0F3iygfgV/3xThJZFvCdaeQ9w57ZYYIsoyyk3RMKLA9bVrQgiCfKWhe+bDz5u7m5t0UkOWIlasaaH0BiPe2sh6Y+cNSfWKqJ9hGCwcmQYA+HpPDqrqdBafcw8cdy8+8zQNz4fRSPDLUdaQFbI3FmCNmcld2VR2vx9n5QXUI1uPTMaAOwy1OoPZ2B8pBUOWF6rMK69Fjsmb1S9Vet4s/nnk9LFSM9jrPZT144J5ciKxFfxA4+eulCdiQP39ymXcYBhgQKpw+yqtUZ7icjhPCj+U/dfJfFwsrkGovxLzhnmvDOq4TrFIiwpAZZ0e3++/YvGZVNM6NfSQ78suRW55LYJ8FaIoX8rJCzaeLkSdzsA7T/RRBNTfbwculaJGa0BEgAqd44O93KqWww/NckZAF4l6s4B6j9YJ0yIZqUkoGla6IoRIVh8LWObNJYRIeqEXUH+/chk3usSHIMRfuPcqHT0oTdJQ5G40Eny4LQsA640N9uJAJJMxWDCClTV8sfMS6nQG82dS18hyq/3XmWQFN3SLh69S7rV22UuvNmGID/FFtUaP7ZnFPM+5tM6Ts3DX67ZzrD52aEakIBfvOYqSVySAWyQjVSMAqJfKEAIE+SrQWcQ5gK3RMP3W5VI18ivqoJQz6JMsPS+7grfo+UqZGrnltZLtK1Df38zCKgDCn5xQQ5bSJPIGHsBNZwtxvrAaQT4K3D0wxYstY7mxRzwSQv1QUq0xh6uB1qGRrdHo8c+pfADA9N7ClhVwyGQMbjB5Zf84kWde/CO18+QsnCH773nOkHVjOcjISPblAfiLFDlvlhRD0Bz867l/arjkru+GeYE5b2yPpFD4qYQ/oXYUBU9awEUUeiaFSbKvQGMHkNDvVWrIUpqEfwMTUu+NnTUoWRDJvZVyGWYNZAsArNydY66IZJBo+i2+VmvD6QKotQakRPijl4hWRHM62e3niqDWsl50qXnOnYW7XitqWc33UHflbQwIAIqL2VdAgHt+gwd3fi+V1NR7s1LEc806Cv96llrVJ6D+OWQ0FX3YK9HiFhz8VfxcRGGAwL2ULYE/8ZLLGPQVuJZdWqM8xeXwNbI7L5TgxLUK+CnlmOvGUrSOclvfJPgqZTiTX4mDOdcBSHcREV+r9esx1gN9U89EQZYNtEW3xBDEhfiiRmswV66iGlkW/gDSITYI0cHCzULhCNx1u/NCfUoxf5W0Vrbz4U+gB0nQuOP3j8s1Cgjfc+csDfOqAtLtK2Ap9eqaIPwsFHT0oDQJf3ER5429o18bRAio/GCovwo39UwEAKzcw5at5TSy0gvpsbdsYVWdeVX7jT3ivdkkh2EYBuNNxRE4DRbVyLIoeder27yxXoDzaJ3IrQAgbSMAqH9uhvkr0SE2yMutcT18B8H5wioUV2mgUsjQs02o9xrlRriJdlZRNYqrNPCRcF8BS8eCGLTs1JClNAlnCB66XIb9l8qglDO4b5hwvLEc9wxi5QUbThcir7zWXEpQah5Zrvzl1bJaGIwE3ZNCkRLp/tCwqxnX2TLDgtQmHM7CL2/qVn1sbS0wYgT78kCJWm4CZlL+SDYEzcFdz/1TIySxWK8h/LzPXK7c3m3CRLHg1Bm4/nKSn97J0u0rYOlYEPpCL4AaspRm4AxBLlfp1O4JgixT1yE2GAPbRsBgJPhu32VeiVppDSINDfMbu4vLG8vRLyUcYbx0LlKbcDgLZ/CpFDL35lg1GoF//2VfHihRyz+/UvbccXD5qwelC98IcAZ+OWVOLiIGg8dZGj6fxOClbAncREwsmRmoIUtpEk4LxaV7mu/FvLHNMXtwCgDgp4NXeYuIpHWJ8z2XMga4oXucF1vjPAq5zCLvrdQW5TmLwuzJC5eUx4d/3UrZc8fRMykUQT7iyO3sDHy77pBpXYKUDdmGESMp9xWofw6JJQuFsBW8FK/Dn4mOaB+F9gLWe43uEI24EF/kV9ThrxNsWiqphaz5lcoGp0cKuiRtc0zoEos1h68BkN55chbuOEhJHws0XPwkbSMAAN6e0R1agxE+CuEbAc7AMAyUcgY6A4HWYISfUo7uiaHebpbb4D93/VVydJNwXwFW+hMbfAV3DUj2dlPsgrpBKE3CNzDmDxWuNxZgB8vb+iYBqM/DKbVFRPzzMVWksgKOwemRCDDN9qm0gGVQWiRC/ZWY1FWcnnZb8M+v1L1ZAGvoSdWI5eA/i/qkhEGlkK45we9r35RwyZU+b0jv5DDse240buwhkvzk3m4ARdhwA1CXhGBRDEC39U2yCHtJzdPnaxocVQoZxneJ9XJrWoavUo6xndjQa3iAysutEQYvTOmEI/8Zi8Qwf283xaVw92Fr8Ga1FviyLSnmyuWj5PVVDONga4NKCyhNMqpDNHZeKMFzkzqKIldpXIgfRnWIxuazRQCkp5HtGBeEeUNS0Sk+2KvlgV3FkimdMbZTLMZ0ivZ2UwSDFFe5c5GRPinhkvbctSb4C2mlLhfhO0Sk3lcxQg1ZSpOM6xyLcZ3F5fm7s38bsyErNY8swzD4zw2dvN0MlxEWoMLkbtIKo4sGf895fXu1CYNKfhm39BJHqJLSPFy0LtBHga4JIV5ujXsJ9mNNpVB/JTrHS7uvYoQashTJMbxdNBJC/ZBbXiu59FsUiksICABqajz2cxO7xmFMpxjJawtbE5yToG9KmOSzjiSG+eOd27ojMcxfcs4RKSDtq4/SKpHLGNw9kF1tGS/AnLcUSmuEGrHSgpNttRbN6E09E9E3Rfg5VVsj1CNLkSTzh7ZFl/gQ9JB44nUKhULxBvGhvsivqMXI9lTfTvEu1JClSBKZjMEQieXipFBcRl0dcMst7N/r1gG+4s1HTPEOn93dBwWVdciIEW5ucUrrgBqyFAqF0towGIC//67/m0JxkLAAFcJo2jyKAKCiJQqFQqFQKBSKKKGGLIVCoVAoFApFlFBDlkKhUCgUCoUiSqghS6FQKBQKhUIRJdSQpVAoFAqFQqGIEpq1wA0QQgAAlZWVXm4JhUKhWIFf1auykmYuoFAogoKznzh7qimoIesGqqqqAABJSUlebgmFQqE0Q3y8t1tAoVAoVqmqqkJISEiT2zDEHnOX4hBGoxF5eXkICgoCw7i3LnNlZSWSkpJw9epVBAcHu/W3xAA9HpbQ42EJPR710GNhCT0eltDjYQk9Hpa4+3gQQlBVVYX4+HjIZE2rYKlH1g3IZDIkJiZ69DeDg4PpzcWDHg9L6PGwhB6PeuixsIQeD0vo8bCEHg9L3Hk8mvPEctDFXhQKhUKhUCgUUUINWQqFQqFQKBSKKKGGrMjx8fHBkiVL4OPj4+2mCAJ6PCyhx8MSejzqocfCEno8LKHHwxJ6PCwR0vGgi70oFAqFQqFQKKKEemQpFAqFQqFQKKKEGrIUCoVCoVAoFFFCDVkKhUKhUCgUiiihhiyFQqFQKBQKRZRQQ5ZCoVAoFAqFIkqoIUuhUCgUCoVCESXUkKVQKBQKhUKhiBJqyFIoFAqFQqFQRAk1ZCkUCoVCoVAoooQashQKhUKhUCgUUUINWQqFQqFQKBSKKKGGLIVCoVAoFApFlCi83QApYjQakZeXh6CgIDAM4+3mUCgUCoVCoYgGQgiqqqoQHx8Pmaxpnys1ZN1AXl4ekpKSvN0MCoVCoVAoFNFy9epVJCYmNrkNNWTdQFBQEAD2BAQHB3u5NRQKhdKAmhogPp79Oy8PCAjwbnsoFAqFR2VlJZKSksz2VFNQQ9YNcHKC4OBgashSKBThIZfX/x0cTA1ZCoUiSOyRZ9LFXhQKhUKhUCgUUUINWQqFQqFQKBSKKKGGLIVCoVAoFApFlFCNLIVCoVDMqLV6lNVo3fob4QEq+KukMfxcr9GiRqtv9H6InxJBvkovtMj1VNXpUFGra3KbuBA/yGXSSDdZVFUHrd5o83MfhRxRQT4ebJH70BuMKKisa/S+QiZDTLCPKFKISuNJQqFQKBT78fEBVq+u/9tEUWUdRr39L6o1jQ0zVxLko8Cnd/fGoPRIt/6Ou9h7sRS/HL2GgznXcamkxuo2SjmDO/q1waKR6YgO9vVwC11HVlEVJr+3C5omDDsASI0MwCd39Ub72OZXmQuZT/+9iKX/nGt2u7sGtMErN3YRhaFnDZ3BiLWHr+G9LReQX9HYkAWADrFBmDUwBdN6xgt64skQQoi3GyE1KisrERISgoqKCpq1gEKhiIadF4px95cHAAA+Cvcoz4yEQGcgCPJVYN2CQWgXIy7DR63Vo/crm1GrM5jfa3isCGD26PkqZVg8th3mD0vzZDNdxtJ/zuLTf7MhlzFQ2PC46o0EBiOBv0qOZTO6Y0KXOA+30jVU1ukw+H9bUVWnh0ohgy0TlTPqF45Mw5PjO3iugS7ifGEV7v/2sHkSppAxjbzpOoMRRpN1GB6gwg/39UeHWM/ZM47YUcI1sSkUCoXiUdRa1jjr1SYUPz842C2/Uacz4K4v9uPQ5euYs+Igflk4CNFB4vFY7r1YilqdATHBPlh6c1f0bhOOEP/GEoI9F0vw1oZMHLlSjv/7+xy6JYZiQNsIL7TYeQgh+OtEPgDg/Tt6YlJX6wbq9RotFv5wBHsuluKB745g6c1dcUe/Np5sqkv4du9lVNXpkR4diI2PDoPMhuH+04EreObnk/hw20VEBvpgzuBUD7e0Zbyx/hwuldQgPECFhSPTMbN/G/gq5RbbVKh1WHP4Kr7ZexlXytR4cs0J/PLgICjkwltaJbwWUSgUCsW96PXAmjXsS18vI6gzeRn9VHJb32wxvko5Pp/VB6mRAcgtr8X93x6G0SiewOD2zGIAwJiOMRjVIcaqEQsAg9IisW7BINzRj63y+J9fTzWpuxQiJ3MrcO16LfyUcoxsH21zu7AAFb6Z2w/3DEwGACz9+yzK1e7VWbsatVaPL3ZmA2A9rbaMWAC4vV8bPDGuHQDg5T/PYF92qUfa6ArqdAbszmLb+83cfrh3SGojIxYAQvyVmDe0LdYuGIhgXwVO5lbgy12XPN1cu6CGLIVCobQ2NBpgxgz2pdGY3+Y8sn5K9wbrwgJUWDmnLwJ9FDh6pRxbzhW59fdcBSEE2zLZtjZl2HEwDINnJnRERIAKWUXV+NxkKImFv06y3thRHaObndwo5DK8MKUzOsQGobJOjw+3ZXmiiS7j+31XcF2tQ3KEP6Z0i292+4Uj03FLr0QQAizffN4DLXQNB3PKUKszIDrIB53jm5cKRAf54r83dAIALNt03qYm3JtQQ5ZCoVAoAIBarfs9shzJEQG42+TB+2BbFsSwXONicQ2uXa+FSi7DoHT7ZAIh/kr854aOAID3t17A1TK1O5voMviygsk2JAUNkcsYPD2R1Yx+vecyrl0XR1/rdAZ8ZppkPDgiza7wOcMweHxcOyjlDPZll+FgTpm7m+kSuIjCiPZRdi9Um947EUMzIqHRG/HMuhOCi6BQQ5ZCoVAEwp6LJXhn03kcu1ruFcOOW8DkbyXU6A7mDk6Fj0KG41fLseei8MOz203e2H6p4Q6t4p7WIwED20agTmfEGxsy3dU8l2KvrKAhI9pFYWDbCGgNRizbKA5P5cYzhSiu0iA+xBc39Uy0+3vxoX6Y3pvd/v2t4vBAc9fwCAfOKcMw+L+busJfJcehy9dxIrfCXc1zCmrIUigUipchhODzHdmY+cV+vLvlAqZ9uBtDXt+GFbs9q0nzpEcWAKKCfMyLgj4QgSHw7/l6b5YjMAxj9sr+czIfRVbydgoNzhtrj6yAD8MweHYS65X95VguzuZXuqV9rmS7SdoypUc8VA5m61gwPB1yGYMd54tx7Gq5G1rnOq6WqXGxuAZyGYPBDqa+Swr3xxvTu+H3RYPRIynUPQ10EmrIUigUihfR6o14au0JvPb3WRAC9GwTCn+VHLnltXjpjzP4x6RT9AScR9ba4g93MX9YWyhkDPZml+Lw5ese+11HqdHosT+bDR874s3i6Bwfgj7JYdAbCX48cNXVzXMphBD8fcoxWQGfbomhmNQ1FoQA3+y97OrmuRSjkdRPUNo5fl7bRPjjxh6splbokzHOG9s7OQwhfo4X67ihWzw6x4e4ulkthhqyFAqF4kWWbTqPNYevQcYAL9zQCT8vGIQj/x2LOYNTAADP/HwS+RW1HmkLt9jL30MeWYANz97cKwEA8PkO4S6G2nuxFFqDEUnhfkiLCnBqH5wm+IcDl6EzCDeDwYWialwtq4VKIXPY+8xx94AUAMDvx3JR4+YCGy3hZG4FSmu0CPRRoE9KmFP7WDgyHQwDbD5biMulwlsMxcHXx0oJashSKBSKlyioqDPLB965rQfmDkkFwzDwVcrx7MSO6JYYgopaHRavOu6RBRbm9Fse9MgCwNwhbB7OzWcLUVqtaWZr77D9vElb2C7a6WpOE7vEITLQB4WVGmw6U+jK5rmUf00Gz4C2EU5XdBrQNhypkQGo0Rrwx/E8VzbPpXBZKIZmRELpZI7UtKhADM1gjcO1h6+5rG2upE5nwO6LJQCc8zwLGWrIUigUipd4d8sFaPRG9E0Jw9Tulil/VAoZlt/WA35KOfZml+IrV+plVSpgxQr2pVKZ31ZrWc+ZpzSyHB1ig9E1IQR6I8Fvx4Rn9BBCsO1cy71ZKoXMnFf2m705rmiaW6gPtTvfV4ZhcHtftq8/HhSulMJVXspbTYu+1h2+BoPAVvUDwIFLZajTGRET7IOOceKqptcc1JClUCgUL3CppAarD7ED/FMTOlj18rWNCjTncPxo+0Wzx7TFKJXA7NnsS1mvlavVseFuT3tkAeDWPqwhIESP1sXiauSWs6H2gWktq851Z/82kMvYlE3nC6tc1ELXodbqceASqwUe3kLj7pbeiVDKGRy/Wo4zecJb9FVarcHxa+UAnNM98xnbKQbBvgrkVdRhd1aJC1rnWswGewsiCkKFGrIUCoXiBd7emAmDkWBUh2j0TQm3ud2MPolIDPNDWY0W646418irNXlkPamR5ZjaPR4quQxn8itxOk9Y6X04b2x/B9NuWSMuxA9jOrJGkxCNdk4LnBjmh7aRzmmBOSIDfTCuUywA4KeDV1zRPJey80IJCAE6xgUjJrhlZZJ9lXLc2IPVeq8R4HmtT7slLX0sQA1ZCoVC8TgXCqvwpym90RPj2je5rUIuw1xTLfcvdl5yjVZWrwf++ot98UrUmrMWeMGQDfVXYWynGADCM/A4fawj+VSb4uZerPf592N5ggtD81OMucJzx6VX++VIrusiCi6ivkqba4w7Lqqw4XQBKtQ6l+zTFVwpVSO7pAYKGYPBGY6l3RID1JClUCgUD8N5bMZ0jEEnO8pEzuibhGBfBS6V1GDzWRcsEtJogBtuYF+8ErVcHllPFURoCJdc/rdjedDqhbGqv0ZTH2p3lTdrRPsohPgpUVBZh/3ZwioEwRmyw120IGhQWgQSw/xQpdG75tp1EQZ+2i0XTVC6JoSgQ2wQtHojfj+e65J9ugJuItY7OQzBvo6n3RI61JClUCgUD6I3GPHLUXaQ4zw4zRHoo8DMAWzqpi92uq9IgqcLIjRkaEYkooN8UFajxVZTknpvszurBDoDQZtwf6S2MNTO4aOQY5IpP+uvx4Rj8FwqqcHlUjWUcqbFWmAOmYwx51n99ahw+nr8WjnK1ToE+SrQq02oS/bJMIx5MiakqMK2c45X8xIT1JClUCgUD7IzqwTFVRqE+SsdClXPHpQCpZzBgZwyt1UQqvVS+i0OhVyGaT1ZneFvAjHwtpu8diNdFGrnuMnUz39OFggm5P6vKdTeNyUcgT4t0wLzmWbSjm7PLEZZjdZl+20JXDWvYRlRUDiZdssaN/ZIgFzG4Pi1CmQXV7tsv85SpzNgr8nrL0V9LEANWQqFQvEo60yemht7JDhUDjMm2BdTurGerZ8OuGfhjNrLHlkAZu/dlnNFqKzzrs6QEGLOqepqb1af5DAkhLIhd6F4nzmjfVgL0m5ZIyMmCJ3jg6E3EvzlwUp1TbHdyXLDzREV5IOhJh3qrwJIJbfflHYrNtgXHWKllXaLgxqyFAqF4iEqanXYaEqEf0sv+2QFfG7tw+bl/OtEvsu9eEYjgUbvvfRbHJ3igpERHQit3ogNpwq81g6ArXCVW14LH4UMA9q6JtTOwQ+5/yKAkLtaq8eei6znblQH14egOa/sbwLoa3GVBieusZkxWppizBqct/3Xo7kgxLuL+eplBa6NKAgJashSKBSKh/j7ZD60eiPaxQSiS0Lzi7wa0j813OzF2+jiylC1PMO4pSmmWgLD1Bt4v3u5IhTnKR3QNsItXmpORrE9swjlau+G3HddKIFWz5bgzYgOdPn+/5+9+45vql7/AP7JbtO9F50U2tLSssuQXShLBRQHLlBRuagguLgO1PvzoiBcr9eB3iuKA0FEQQVZZUOZpS10QaF777RJs8/vjzSBQoG2JDknzfN+vc6L9OQkeRLS5sn3PN/ne8+AQPB4wJmiBpTUK8x+/11hnOQVF+QKX5c7a7vVkUn9/CAVC1Bcr0BacYPZ778rDllo5JlLKJElhBArMZYV3DeoV7dGR/h8Hu4bFNTuvszl2kRW0oWSB0u4J8HwHI/l16K6WclaHMZlZI19X82tr58LYgJcodGxf8o9JceQtE+M9rPIyJ2fqwNGtk0gY7v+2dRT1UJLtUrFQkyJNfTPZXO0/UpNCwqMbbcie17bLSNKZAkhxAoqm5Q4U9QAHu/qSFx3zGorSThyqQZVsm4meWIx8Omnhq1tiVpTxwKRAHw+u6cgQ7ykGBTiDj0D/JnBToJX06wyjaYltfW3tYRZA9mf0a/XM9jfltxNtFDSDlwtL/iNxVPuWp0eh40T+KItN0o5q+0L55+ZFay1kjOetRnR2wsuPbDtlhElsoQQYgV723poDgx2v6NVhMK9nTA41AN65g6SH5EIWLTIsLUtUWvqWMDiRK9rGVdJ2s5SecGB3GowjKE3aICbo8Ue556EIPB4wOlC9k65ny9rQk2zCk5iARLDzVsLfK0pcf6QCPm4XCNHFktL1qaXNEKm1MJdKsKAYA+LPc7I3t7wcZGgUaExnd63NuMZhckW/CLGBZTIEkKIFezJMkxcmtx2yvFOGCeKbU0rNdvI1rUjslwwPT7A0MaopJGVNkbG0axJFk4C/N0cMKJtIhlbNcEpxlZUfX261Emjq1wcRKbRbbZGoI2reY3u4wOBBc88CPg83JvA3mi7tc4ocAElsoTYmNIGBYrq5KzPhiWd19SqQWrbjPBkMySy0+MDIBbycbGqpXsjWzodcPCgYdMZElgutN66lrezBGPa2hhZu86wVa3D0XzDKJqlE1mA/VPuKW1nCybGWO+5/p7BzvK8+7LNuyztrRhLiPbmVFm9lVxKThUYBojvZdkzClxAiSwhNkKu0uKtbRdw14cHMHb1QQxfmYIXfzqH/Gr2m26TWzuYVw2tnkEfX2ezrA7l5ijCxLYWSX90ZxRPqQTGjzdsSkOdrZLlxRA6Mrtt5PnXtDLorZj0HLlUA6VGj14ejlbpvTmlvz/EQj7yq7v5xeQOVDYpkVUuA49nnZntY/v6wF0qQnWzyvTlzlryq1uQV9UMIZ+HidGWT9pjA6+2ktt13rqt5PbYSVkBQIksITbhVEE9kj8+jO9PFAEARAIeqmQq/J5Rjof/e4L1djbk1vZktX2oxJrvQ+XaFlXmSPK4NiILGEZDXRyEKGtsxcmCeqs97tVuBZaZwX89VweRqTOCtWf0X1u77e0ssfjjiYV8TG9bntfaI+1/tXWGGBXpDTep5Sc/8Xg806isNZ+rXKXF0fxaAMCkfnd+BojrKJElhONK6hWY/80plDa0IsjdET8+nYjz7yTjpwXDEeXngppmFZ5Yfwp1LSq2QyUdUGp0pnY/k834oTIuyhcuEiEq2roh3Cm2l6ftiINIgBnxhqRna5p11q7X6RlT/1hrjmZdLS8oh0ZnvVnuf7aN6Juj5KWzjMnd7qxKU222NexsW2DDmEhbg/G5niioQ3ljq1Ue8/DFGqi1eoR6SdHXz/w9gbmGEllCOIxhGLz+aybkah0Gh3pg90tjMCrSGw4iAUb09sKGJ4chyN0RV2rleHLDGat+KJDOSb1cB7laB39XB/QPcjPb/TqIBEiOMyQf5hjFa1VrAQBSDo3IAlcntv11vgKKthgt6cSVOtTJ1XBzFGFouKfFH89oXJQvvJzEqG1R4WCedWa5VzYpcarQMNI9o21ikjUMDvFALw9HtKi0phFhSyuolSOnQgYBn2eVumejIHdHJIZ7gmGsN5nv2rKCnrqa17UokSWEwzaeKsax/Do4iPj4aE4CnCXtV1zyd3PAhieHwV0qQkZJI/575ApLkZKb2ZNtGAWa1M/P7P1ZjeUFO87fea9KLo7IAsDgUA+EeEohV+uwO8vydYa/phm+FEyPD4BIYL2PSLGQj9ltvUc3ny6xymP+mVkOhgGGhHogyN16E4L4fJ5pBHrLGes8151tZQUje3vBw0lslcc0unbJWktTqLWm35MpcT2/rACgRJYQziptUOCfO3IAAK8kR990klCkrzPeuzcOAPDlocuopRIDzmAYxrRikiVa4IyI8IK3s6FXpXGWfXe1qg2JMJdqZAFDnaExwfvFzKuZXa9VrcOuC4aEZ/YdLFrRXQ8ODQZgaBFV3d3FLrrgj0zDc71ngPVGY40eHBoMHg84cqkWxXWWr/H/q+3/dZoVywqMpvYPgFjAR25lMy6UNVn0sXZnVUKh1iHUS4pBIZbrk8sllMh24J133gGPx2u3RUdHsx0WsTMf/JULuVqHIaEemDcy7JbHzugfgP5BbpCrdfhPyiXrBEhuK6tchupmFaRiARItcJpaKOCbakh/T7+z05YKjeG0PddGZAHjkr7Asfw6XLZgT9k92ZWQq3UI8ZRicKj1k4BIXxcMCnGHTs/gVwuP3hXVyZFR0gg+D5gaZ/3kLthTitF9DF0SfjpdbNHHKq5T4EKZoazAmrXARm6OItPo6PepRRZ9rK1nDe+b2QO7twy2LaJE9iZiY2NRUVFh2o4ePcp2SMSOFNcpTKfC3rs37raNu/l8HpZPNXzZ+vFkMQpr5RaPkdyecdKQsa7ZEoyjaXuyqzpfQyoSAatWGba2lb2UHOxaYBTsKTW1G7NkImAsK5g5MIi1JMA4Kvvz6RKL9pT9M9N4qt2wAhUb5g4zPNctZ0osuozr7xmG/9fhEZ7wtHJZgdHjI0IBANszytCksExP2YqmVhy7bOhWMIuFMwpsoUT2JoRCIfz9/U2bt7c32yERO/L10SvQM8DoPt7oF+jaqduMjPTGmL4+0OoZrN6TZ+EISWcYV0wyJmGWMDDYHcGejlCoddjXVsZwW2Ix8Morhk1s+GDnYvutaz0+IgwAsPVsKVpU5p/0Vd2sxJFLhvIMNpOA6fGBkIoFuFIrN0s3ipsx9h++x4qTvK43McYPPi4S1LaoTYsymJtOz+CnU4Y63NkDe1nkMTpjcKgHYgJcodToseWsZeqCt50z1DwPC/NEiJfUIo/BRZTI3sSlS5cQGBiIiIgIPPLIIyguvvmpD5VKBZlM1m4jpLsa5Gr8fMZQC/jsmN5duu3rU6LB4wE7MitoVJZlNc0qZJY2AgDGWzCR5fF4uDehbbWkO+hewNXJXkZ3RXojwtsJzSqtRXpy/p5eDj0DDAh2N8uiFd3lLBGa2kN9Z6HR5wtlTcitbIZIwM6pdiORgI8HhhiSy42nLFNecPhSDcoaW+HmKML0eOuXUBjxeDzTqOz3J4rMvsAHwzCmFnX3Dbaf0ViAEtkOJSYm4ttvv8WuXbvwxRdfoKCgAKNHj0Zzc3OHx69cuRJubm6mLTg42MoRk57khxNFaNXo0C/AFaMivbp0236BrhjX18d0P4Q9B/OqwTBAXJAr/FwdLPpYxu4Fhy7WoFGhvv0NdDrg9GnD1rZErbF1G9fabxnx+Tw81pYIfHe80Kyn3RmGMU0kM04sY9O8UWEADDPtLbHYyYbjhQAMtbHWWBjgVh4aGmKa9FVggS/fG08aEuTZg4IsVt7TWfcOCISLgxBFdQocumTeFmvny5qQX90CiZCPqSxMaGMTJbIdmDp1KubMmYP4+HgkJydj586daGxsxM8//9zh8cuXL0dTU5NpKymxTjsR0vMoNTpsSC0EADw7NqJbdXrGD/ufz5RQX1kWHWhbBGFClOVGY436+Lkg2t8FGh2Dvy50okWVUgkMG2bY2paoNY7Isv1hfyv3De4FqViAS9UtZl3e9MilWuRWNsNRJGD1VLtRbKAb7or0hk7P4OujBWa977oWFba3lRUYE2Y2BXtKMb7td+TLQ5fNet+VTUpTnfojiSFmve/ukIqFmDPYMND1XduXCXPZcNwwcDE51h+uDux+ObE2SmQ7wd3dHX379kV+fn6H10skEri6urbbCOmOPzMrUNuiRpC7Y7fbxIzt64tgT0fIlFpTHRyxLrVWj8MXDZMuJsRYp/n6vW19Obu7OILCNCIrvM2R7HF1EJlGTD8/aL6k58vDhvt6aFgw3KXsTAa63jNjIgAYvpB2apS9kzadNkysiu/lhoHB7ma73zvxt3GGEqqtaaVmXf1q8+kS6PQMhoV5ItLXxWz3eyceGxEKHg84kFdjtlZcZY2tpt/7p+4KN8t92hJKZDuhpaUFly9fRkCAfQ3XE+v7pW0SwMPDgrvdjF3A5+HRxLZTsCfMewqWdM6Zwnq0qLTwdhYj3oyred3K3QmGv08nC+pR2dT1HqRKjtfIGj07pjdEAh6O5tfieNt68nfifGkTjuXXQcDn4enREWaI0DxG9/FGTIArFGodfjxpnvpRjU5vKjmaNzKMM+2ZhoR5IjHcExodg68Om2dRF52ewea2tl5zOTAaaxTu7WRaDGKNmSbl/vfwFWj1DEb29sIAjnw5sSZKZDvw8ssv49ChQygsLMTx48cxa9YsCAQCPPzww2yHZlV6PYMjl2qwdu9F7O1Kax/SLSX1Cpy4Ug8eD5g16M5m1z4wJBhiIR8XymQ4V9JongBJpxm7FYyL8jX7al4308tDiqFhHmAYdGsk3jTZS8ztj4VgTynmDjMkJqv35N3xFzXjaOw9CYFWXd3qdng8Hp4ZYxhd++ZYoemLxp3Yk1WFiiYlvJ3FrE586sgLE/oAADadLjbLoi6/nStDeZMSHlIR51a4WjyxDwR8Hg7k1eBsUf0d3Vddiwqb2hL2heO6Njm4p+D2XyyWlJaW4uGHH0ZUVBQeeOABeHl54cSJE/Dx8WE7NKvQ6vT4+mgBJqw5iMe+PoVPUi5hwXdnMPC9vVi0Mc1iPfDsnXEm9ogIrzv+QPVwEuPueEOt3w8WbsBNbnSgLZGdYMFuBR0xlhdsOdv1HqSm9lsi7pYWGC2aEAkHER/nihtNK6d1x7X9mo2n8rlkRnwgAt0cUNuiwjfHCu/ovhiGMS1hPTcxFBIht0beR0V6ISHYHUqN/o7rglVaHf619yIA4LmxvTlX9x3m7YQ5gw2DFR/tvnhH97XheCGUGj36Bxnqqu0RJbId2LRpE8rLy6FSqVBaWopNmzahd2/7+KbDMAz+/tt5/OPPbBTWKeDS1gomyN0RKq0eOzIr8MjXJ8xas0UMr/uvxtYpdzgaa/TIcMOo1V8XKiG3QN9N0rGCWjmu1Moh5PMwuo91P1juTgiERMjHxaoWZJR2rf6OywsiXM/XxQHzRxlGKz/ak9ftVkZr9uZBzwBj+/ogJoB7cxtEAj6WTY4CAPxn/yVU3cGytX9kViC9pBGOIgEe5dCpdiMej4fnx0cCAL49VojShu53a/jxRDHKGlvh5yrBE7dZFZEtL0zsA7GAj9QrdTjWzRKZplYNNrQNVPxtXG/OlIpYGyWyxIRhGKz8Kxc/nykFnwesuLsfTr4xEZ89MghHXxuPrQtHwMtJjAtlMjz835Ool1Myay5nixpQWKeAVCww22mwgW39MFs1OuzO6sRMdmIWxlnSw8I94WLl2cNujiJMbXv/bD7d+e4pDMNAoeF2+63rPTsmAi4OQuRWNmP9sa6P4O3PrcL29HLwecCyyX0tEKF5zBoYhIEh7lCodfjwr9xu3YdCrcXKnTkADAmPr4XbwXVXUowvhoV5olWjw9vbs7pVNtKi0uLTA4aJ2Ysn9uXcaKxRkLsjHm5b2eyt7Re61WHm//7MRlOrBpG+zpjMYj9gtlEiS0zWHbpiKrT/4L54zB8VbprBzOPxMDjUEz89MxzezhLkVMgw75tT0Oost6ygPTE2sp4aFwAniXlO7fJ4PNMKRZZoIE86tj/XsEKRtcsKjB5oW+L0j4zym384ikTAihWGTSSCRsdA1zaqydUP/uu5S8V4bYphWeYPd+V2aQZ4i0qLN3+7AMAwyzu+l7slQjQLPp+Hd+6OBY8H/HqurFs1lesOXUFFkxK9PByxgIMlFEY8Hg//nB0HsYCP/bnV2NFW9tEV/ztyBfVyNcK9nTBnCHsreXXGkqS+8HOV4EqNHO/vzO7SbQ/kVWPL2VLweMAHs/vfdhnznowSWQIAyCxtxKrdhm/7b0yLwQNDOl7Uoa+fCzY9MxxujiJkljZ1aySEtKfU6Ezrnpt7RRbj7Nhj+bV3dFqSdE6zUoNTBYZEg61Edni4F0I8pWhRaU31nzcQi4F33jFsYnG7hNdWRmQBQ2/QSf38oNExeHHTuU5PSF21KxflTUqEeEqxdFKUhaO8cwnB7qaayje3ZXVp9K60QWHqz/rGtBjOf1GJ9HXB38YbSvne+T27S3MyMkoa8fkBw3NdOqlvtzu/WIuHkxgfzUkAAPxworjTy/TKlBos33oeAPDkqHAMCfO0WIy2gNv/y8Qq9HoGb227AIYxrDxyu2/skb7OeGNaDADgX3svWWTlGXty5FItmpVaBLg5YHh411byup0QLymGhHpAz3S/vyjpvKOXaqHRMQj3dkKEjzMrMfD5PFPSs/lM58oLjB0LhHwe5z/8r8Xj8fDhffGmUa03f7tgGlm+mV/OluL7thZUK2f3t4maYAB4JTkaHlIRcipkWLYlvVN1wQq1Fs9vPAeVVo8REV6cm71/MwvH9UZvHyfUtqiwbEsGNJ0481fXosLCH85CrdNjUj8/zOBYV4abGd3Hx9T79dVfMm9bG6zTM3jztwuolCkR5iXFy5O5/0XM0mznLxaxmM1nSpBR2gQXidCUoN7OnCG9kBhuqGV6a/sF6lV6B4yjZlPjAizSqmlWWwP5X9MokbU0Y33seCus5nUr9w/pBR4POFVQjys1LTceoNcDWVmGTa83jWTaSlJ3LU8nMf714ADTqfdnvjuDlptMblx/tAAvb8kAwxj6qI6yoVnePi4SfPnYEIgEPOw8X4mPbtODVKvT44WN55Be0gh3qQjvz4qzmclAEqEAq+5PgFjAx76cKry8JeOWX1C0Oj1e3HQO5U1KRHg7Yc0DCTbzXAHgleQoRPu7oE6uxqzPjyOztLHD45QaHf7241n8nmGo7V51f4JN/s6aGyWydq5BrsaHuwwlBS9N6tvpSQCGWqb+EAv4OJhX061aJmJoE7Mv23A6aVp/y4yWzOgfCLGAj9zKZuRUyCzyGMRwZuNAnmH99Ikx7CayAW6OGNfX0C7wu47ar7W2AnFxhq219WoPWY6fdr6Zkb298e+HBkIs5CMltxr3fX4cRy/VQqnRgWEYZJfL8Na2C3jvT0Md4tN3hWPF3f1YjrrrhoV74oPZ8QAMK5v9J+VSh6OVWp0eb/x2ASm51ZAI+fj6iaGsnSHorsGhHvj8kUEQ8nnYnl6O5b9mdvhca5pVeO6HNBzLr4NULMC6xwbb3BKtDiIBvpk/FNH+LqhpVuGBL1Ox9WypqXcwwzDIr27Go/87id1ZVRAL+Pjk4YEYFm7fJQVG3G8YSCxq7d6LaFRoEO3vgsdHhHbptr19nLFwXG/8O+US1uy5iKlxAXZdcN4dRy7Wolmlhb+rAwaFeFjkMdykIkyI9sWurEpsTy/nZJuhniCjtBG1LSo4S4QYyoGatfmjwnEgrwa/nC3Fssl9b9lBwbSqlw2P7tyTEIgQTykWfHcGeVXNePTrkxAL+PB2FqP8mpXOXp7cF4vGR9rUiN217hvcC4V1cvxnfz7W7L2IHecr8M49sYgJcIVULMBfFyrxr70XUVArB58HfDp3EAaHWuZvi6Ul9fPDvx8aiBd+SsPPZ0pxLL8Oz43rjcn9/NCgUON8aRP+uTMHDQoNRAIe1sxJQF8/bixF21UBbo7Y8twILNp4Docv1mDZlgz8/bfzGBbuicI6OUrqDUv3ujgI8d/Hh2B4hHnL0GwZJbJ2rEqmNLXoWXF3LITdqI1bMCYC3x4vREGtHDvPV+DuhEBzh9mjGcsKpsT5W3QFqBkJAdiVVYm/LlTgtSlRNvshzmV720bWx0b5QCxk/2TX6D7eiPR1Rn51C34+U3rLNdivLoZgu4ksAAwIdsfvz4/C2j0XcfhSDapkKpQ3KSER8jEuygcPDAnGxBg/tsO8Y0sn9UWwpxT/3JmD3MpmPPTViRuO8XQS4517YjGpn20/X8MKZIOw4vcslDW24q1tF/DWtgvtjokJcMWaOQnoF2jbX9JdHET4+okh+Pe+S9iaVoqKJiWOXDL0mBUL+BjR2wtvTI+x2WTdUiiRtWPrjxZArdNjaJgHRvTu3rc7Z4kQ80eF4eN9l/DZgXzMiA+gJKmTVFqdKfmx9HKRE6J94SDio6hOgaxyGeKC3Cz6ePbI+H85mSOJA4/Hw/xRYXjjtwv49ngB5o0Mu+kZk1YbWgzhdgLcHLF6TgIYhkFBrRylDa0YHOphtrZ2XMDj8QxJebQvPvgrF39klkOpMZx2d5EI8cyYCMy/KxzOPeQ5T48PwMQYX2w+XYKvDl9BWWMrPJ3EhqV2+wdi4bjenPjyaA4iAR8vJ0dh2eS+yKtqxskr9Qhwc8CoSO8e9R42J3pV7FRTqwY/njSsz/zc2DtbtWzeyDD89/AV5FY2IyWnGkkc+SDnuqOXDGUFfq4SDLZQWYGRVCzE+Chf/HWhEjvPV1Aia2aFtXJcqm6BkM/DOJYnel1r9sBeWLUrDyX1rdiXU4XkmzRNb7WxxRA6g8fjIcLH2eZqQ7vCy1mC1XMSsHpOAlRaHVqUWjg7CDm3/Kw5OIgEeGJkGB4fEQqdnunWGURbwuPxEO3vimh/2x5ltoae/U4gN/XDiSK0qLSI8nO54xnW7lIxHm2rr/30QD51MOikHRbuVnC9af0No747z1fQ/5GZGUdjEyM84ebInYkmjmIB5rYtR7r+FuvXt/aQ0gJ7JhEK4OUs6ZFJ7LV4PF6PT2JJ19C7wQ4pNTp807aQwXPjIsySRD19VwQkQj7SSxpx4krXV56xNxqdHik5hlZNU63U23FCtC8kQj4K6xTIqWi2ymPaC2MiO4mD9ZePjwiFkM/DyYJ602IN1zPVyIrpJB0hxLZQImuHfk0rQ22LGkHujpgRb57JWT4uEtzf1oT9hxMdtPsh7ZwuqEdTqwaeTmKrrcriJBFiXJShJdNNV3wiXVYvV+NM27KhXCyrCXBzxJy2lfrW7m3rPSoSAS+/bNhEomvab9FHAiHEttBfLTvDMIwp0Zw3Msysq/g8kmgoL9idVYnqZloO9Vb2tI3gTYz2tWrLMiovML+UnCroGaBfgCt6eUjZDqdDL0yIhFjAx4kr9TieX2tYonb1asN2zRK1VFpACLE1lMjamYzSJmRXyCAW8k0jqObSL9AVg0LcodUz2HKm1Kz33ZMwDHN1hvtNJt9YysQYP4iFfFyplSOvisoLzMFUVsDB0VijQHdHPDzMMCq7Zu/FG77EmEZkqbSAEGJjOJvIajQalJSUIC8vD/X1VHNpLhtPGkZjp8X5w8NJbPb7N47KbjxZfNs1z+1VVrkMZY2tcBQJMLqPdZfIdJYIMbZtxaedmVRecKfkKi0OXTSs5jU5lruJLAAsGh8JiZCPs0UNOJRbBRQWGja93uZX9iKE2C9OJbLNzc344osvMHbsWLi6uiIsLAwxMTHw8fFBaGgoFixYgNOnT7Mdps2SKTX4I8OQvMxN7NoqXp01PT4Abo4ilDW24nDbBzxpz1hWMLqPNxxYSBymt5UX7KDygjt2IK8aKq0eYV5S9OP4imm+rg54bLjh937t9gwgPNywtbaaSgt6UvstQoh94Ewiu3btWoSFheGbb75BUlIStm3bhvT0dFy8eBGpqalYsWIFtFotJk+ejClTpuDSpUtsh2xztp0rQ6tGh0hfZwwNs0zfUgeRwFSy8ONJmvTVEbbKCowmxvhCLODjco0cF6taWImhpzBOmpva3zYWAlk0PhIeUhEuVbf/fzcmsg6UyBJCbAxnCqJOnz6Nw4cPIzY2tsPrhw0bhieffBLr1q3DN998gyNHjqBPnz5WjtJ2MQyDjW0LIMwdFmLRD925iSH4+mgB9udWo7JJCX83B4s9lq0pqVcgp0IGPs8w0YsNLg4ijOnrjX051dh5vgJR/rTcYXco1FocyDWcdZgWZ9mV2czFw0mMv0+LwdsbT7XbrzAuiEClBYQQG8OZEdmffvrppknstSQSCZ577jk8+eSTVoiq5zhf1oTcymZIhHzcN8i8k7yu19vHGUNCPaBngO3pZRZ9LFtjLCsYFu5pkRrlzrq2ewHpnkN5NWjV6NDLwxFxQdwuK7jW/YN7Ych1Z2SUPWiJWkKIfeFMInut1tZWKBQK089FRUX4+OOPsXv3bhajsm3bzpUDMJzOdpNafuWh2W3J8q9pZVSHeY292ZUAgEn92CkrMErq5weRgIdL1S24RN0LumXnBcP/5XQbKSsw4vF4eOfufqafd5yvgEKjBUCJLCHE9nAykb333nvx3XffAQAaGxuRmJiINWvWYObMmfjiiy9Yjs726PQM/sg0JLL3JphnAYTbmd4/AGIhH3lVzciukFnlMbmuQa42raw0meVWTa4OIozuY+hesINGZbtMqdEhJccwuj61v22UFVyrt+/VcpK3t11AWUMrAOpaQAixPZxMZNPS0jB69GgAwC+//AI/Pz8UFRXhu+++wyeffMJydLbn+OVa1DSr4C4VYUxb6yVLc5OKTMt1/ppG5QUAkJJbDT0DxAS4ItiT/cb5VF7QfYcu1kCh1iHQzQEJvdzYDueOKNQ6NCg0ACiRJYTYHk4msgqFAi4uhhGDPXv2YPbs2eDz+Rg+fDiKimgmfFcZywqMo6TWMmtgEABge3o5tDq91R6Xq/ZkGU5Fsz0aazQpxg9CPg8Xq1pwpYa6F3TFHxmG3ylb6VZwA6EQ+Nvf0LrgWXi5O5p2U/stQoit4WQiGxkZiW3btqGkpAS7d+/G5MmTAQDV1dVwdbWdSRVcoNTosLstgZrZllhay9goH3g6iVHbosKR/FqrPjbXtKp1OHzJMMOdKytAuUlFGNHbCwCwO6uK5WhsR4tKi31tZQX3DrBOqY7ZSSTAZ5/B8at1+PcTwyHk88DngdUJiIQQ0h2cTGTffvttvPzyywgLC0NiYiJGjBgBwDA6O3DgQJajsy37cqrQotIiyN0Rg0Ms0zv2ZkQCPu5pq8m19/KCo/m1UGr0CHJ3RGwgd76MTYkzTDrb1fZlh9ze7guVUGr0iPB2Qv8g2y4rAIDBoZ7Y/Oxw/PfxIfB2lrAdDiGEdAknE9n7778fxcXFOHPmDHbt2mXaP3HiRPzrX/9iMTLbsz29bZLXgEDw+dY/BWosL9iXXWVqum6PjGUFk/r5cepUtCEeIKOkERVNrWyHYxO2Zxh/p4I49X/ZJQwD1NQYNobB4FBPTIzhxpkCQgjpCk4lsm+//TbOnj0LAPD398fAgQPB518NcdiwYYiOjmYrPJvTqFDjYF41AMOHLhvie7kh2NMRrRodDrTFYm90egYpuYbnzpX6WCNfFwcMCTWM1O+h8oLbqmlW4WhbiYjNlhUAgEIB+PoatmtaHRJCiK3hVCJbWlqKqVOnolevXli4cCH++usvqNVqtsOyWTvPV0KjYxDt78La6k08Hg/T+xs+8Hdk2ufs+DOF9aiXq+HmKMLQcE+2w7lBcttSubsuUHnB7fyZWQ49AyQEuyPM24ntcAghxO5xKpFdv349Kisr8dNPP8HFxQVLliyBt7c37rvvPnz33Xeor69nO0Sbsq1tVS1rT/K63ox4Q5unlNwqKNRaVmNhg3Ei1cQYX4gEnPqVA3A1kT1ZUId6OX1xvJVtbaU6M215NJYQQnoQzn2q8vl8jB49GqtWrUJeXh5OnjyJxMREfPnllwgMDMSYMWPw0UcfoazMvicP3U5ZYytOFdSDx4NpwhVbYgNdEeolhVKjx/5c+yovYBjG1DXCmDByTbCnFLGBrtAzhlpm0rGCWjkyShoh4PMwI54SWUII4QLOJbLXi4mJwauvvopjx46huLgYTzzxBI4cOYKffvqJ7dA47fe2kaNhYZ4IvKZPJBsM5QWGUVl7Ky/IKpehrLEVDiI+xvSxzmIU3TEllroX3M4vZ0sAAHdFesPHhWb3E0IIF3A+kb2Wr68vnnrqKWzfvh0vv/wy2+Fw2naOlBUYTW8rL9ifWw25yn7KC4yjseP6+nJ6HXtjG66jl2rRrNSwHA336PQMtp41/E49MCSY5WgIIYQYCdkOwGjp0qWdPnbt2rUWjMT25VbKkFvZDJGAh6lx3Did3S/AFeHeTiiolSMlt5r1cgdrMZUVxHGrW8H1In2dEeHthCu1chzIq7Gb/5/OOnKpBpUyJdylIiT182U7HEIIIW04k8ieO3eu3c9paWnQarWIiooCAFy8eBECgQCDBw9mIzybYuwdOy7KF+5SbqzUYywv+PRAPnZklttFonSlpgUXq1og5PMwIYrbiSyPx0NynD++OHgZu7Mq7eL/pyu2nCkFAMwcEASJkLsj650mFAJPPHH1MiGE2CjO/AU7cOCA6fLatWvh4uKCDRs2wMPD0OOyoaEB8+fPx+jRo9kK0Sbo9YypPnYmS71jb2Z6vCGRPZBXgxaVFs4Szrz9LMLYrWBEby+4SUUsR3N7U2INieyB3GooNTo4iHpAwmYGDXI19rZNgpszpBfL0ZiJRAJ8+y3bURBCyB3jZI3smjVrsHLlSlMSCwAeHh74v//7P6xZs4bFyLjvTFEDyhpb4SwRYmIMt06BRvu7IMLHCWqtHik5PX92PNe7FVwvvpcbAtwcoFDrcPRSLdvhcMb29DKodXrEBroiNtD2l6QlhJCehJOJrEwmQ01NzQ37a2pq0NzczEJEtsPYO3ZKnD/nRtR4PB5mtHUv+LOHdy+obFIivaQRPB73VvO6GR6Pd3VxBOpeAMDQPu3ntrKCHjXJi2EAudywMQzb0RBCSLdxMpGdNWsW5s+fj19//RWlpaUoLS3F1q1b8dRTT2H27Nlsh8dZaq0eO88bEkSulRUYTW/rv3kor6ZHz47fk21IBAcGu8PX1YHlaDrP2L1gX04VNDo9y9GwL7O0CdkVMoiF/J5VN6xQAM7Oho2WqCWE2DBOJrLr1q3D1KlTMXfuXISGhiIkJARz587FlClT8Pnnn7MdHmcdvliDRoUGPi4SjOjtxXY4Herr54xIX2eodXrs68HlBcaygikc6RrRWUPDPOHpJEajQoNTBbSS3o8niwAA0/sHwMOJGxMnCSGEXMXJRFYqleLzzz9HXV0dzp07h/T0dNTX1+Pzzz+HkxOtb34zxrKCu+MDIeDzWI6mY/awOEKjQo0TVwxJoK3UxxoJ+DxMijGUQuy6YN/lBU2tGvyRYXiPzk0MYTkaQgghHeFkImtUVFSE8vJyFBYWIiUlBb///jt+//13tsPipBaV1jTCOXMgt0+BGhdHOHyxFk2tPa+8YF9ONXR6BtH+Lgj1sr0vXsZR5D3ZldDr7bd+ctu5MrRqdOjr54whoR63vwEhhBCr42T/oytXrmDWrFk4f/48eDwemLbJCDyeYZRRp9OxGR4n7b5QCaVGjwhvJ/QP4vbM6r5+Lujj64xL1S3Yn1uFWQN7SEujNsaygsk2NhprNDLSC84SIapkKqSXNmJQiP0lcQzDYOPJYgDA3GEhpr89hBBCuIWTI7KLFy9GeHg4qqurIZVKceHCBRw+fBhDhgzBwYMH2Q6Pk4xlBfcOCLKJD13jqF9PO32tUGtx+KKh48YUG01kJUIBJkQbWrft7mH/P511tqgBeVXNcBDxMWtQz/qiRQghPQknE9nU1FS899578Pb2Bp/Ph0AgwF133YWVK1fixRdfZDs8zqluVuJYvqHv570DuF1WYGSsHT10sQYKtZblaMznUF4NVFo9gj0dERPgwnY43Wb6opFVaTojYk+Mo7F3xwfCzZH7i1kQQoi94mQiq9Pp4OJiSAK8vb1RXm5YqSo0NBR5eXlshsZJOzIroGeAhGB3hHnbRk1mbKArenk4QqnRm0YwewLTIgj9/G1iZPxmxvb1gVjIR1GdArmV9tW7uUGuxp9tbeweGR7KcjQWIhAA999v2ATc6jdNCCFdwclENi4uDhkZGQCAxMRErFq1CseOHcN7772HiIgIlqPjnm2mJWltYzQWMNQ7G0+995TyArVWj5TcagBAso213bqek0SIMX18APSc/5/O2ppWCrVWj34Brkjoxe16825zcAC2bDFsDrbT55gQQq7HyUT2zTffhF5vaMb+3nvvoaCgAKNHj8bOnTvxySefWCWGzz77DGFhYXBwcEBiYiJOnTpllcftqoJaOTJKGiHg8zAj3nYSWeDq6euUnGqotbbffP/ElTo0K7Xwdpb0iAlSxv+f3Xa0yhfDMNh4ylBW8MhwmuRFCCFcx8lENjk52bSCV2RkJHJzc1FbW4vq6mpMmDDB4o+/efNmLF26FCtWrEBaWhoSEhKQnJyM6upqiz92V21vm+Q1KtIbPi4SlqPpmkEhHvBxkaBZpcXxy7Vsh3PHjMu6Turnx9k+vl2RFOMLAZ+H3MpmFNbK2Q7HKk5cqceVGjmcxALcy9HV8QghhFzFuURWo9Fg4sSJuHTpUrv9np6eVhsdWbt2LRYsWID58+ejX79+WLduHaRSKdavX9/h8SqVCjKZrN1mDQzDYLsNlhUY8fk8JMcamu/b+qifXs9gb7ahj6/xOdk6d6kYIyIMK8TZ+v9PZxlX8rp3YBCcJZzsTmgecjnA4xk2uX18SSGE9EycS2RFIhEyMzNZe3y1Wo2zZ88iKSnJtI/P5yMpKQmpqakd3mblypVwc3MzbcHBwVaJtaBWjqI6ORxEfJvtWTol1rA4wp6sKuhsuPn+uZIG1DSr4CIRYmRvb7bDMZvka7oX9HS1LSpTwj53GK3kRQghtoBziSwAPProo/j6669Zeeza2lrodDr4+bUfVfPz80NlZccf5suXL0dTU5NpKykpsUaoiPBxxsm/J+GLRwfb7OhRYoQn3BxFqJOrcaawnu1wus04IWpCjC/EQk7+WnXL5H6G34NzxY2obFKyHI1l/XK2FBodg4Rebojj+KIihBBCDDiZ/Wi1Wqxfvx779u3D4MGD4eTUvqXU2rVrWYqsYxKJBBIJO/WpPi4SjI/yZeWxzUEk4CMpxg9b00qxK6sSiW2nsm0JwzDYnWUsK7DNkfGb8XN1wKAQd6QVN2JPdiUeHxHGdkgWodcz2NQ2yWtuIo3GEkKIreDk0NGFCxcwaNAguLi44OLFizh37pxpS09Pt+hje3t7QyAQoKqqqt3+qqoq+Pv3rCSFK0yz4y/YZvP93MpmFNcrIBbyMbavD9vhmF1PXYXtWqlX6lBYp4CzRIi7E2yv3pwQQuwVJ0dkDxw4wNpji8ViDB48GCkpKZg5cyYAQK/XIyUlBc8//zxrcfVko/t4QyoWoLxJifNlTYjv5c52SF1irKsc08cHTjZa4nErybH++OfOXJwsqEeDXA0PJzHbIZmdseXWzIGBkIp73v8hIYT0VJwckWXb0qVL8d///hcbNmxATk4OFi5cCLlcjvnz57MdWo/kIBKYyiNscdTPGHNP6VZwvVAvJ8QEuEKnZ7Avp+r2N7AxtS0q7DFN8uqhK3kRQkgPxZlEtri4uEvHl5WVWSgS4MEHH8RHH32Et99+GwMGDEB6ejp27dp1wwQwYj7J15y+tqXyguK2JVwFfB6SYnru+8O4CltPbMO11TjJK9gd/QJd2Q7HOgQCYNo0w0ZL1BJCbBhnEtmhQ4fi2WefxenTp296TFNTE/773/8iLi4OW7dutWg8zz//PIqKiqBSqXDy5EkkJiZa9PHs3fgoH4gFfFyplSO/uoXtcDrNmNglhnv2yFPuRslxhiT98KVatKi0LEdjPno9g5+Mk7yGWadtHic4OAA7dhg2WqKWEGLDOFMMlp2djffffx+TJk2Cg4MDBg8ejMDAQDg4OKChoQHZ2dnIysrCoEGDsGrVKkybNo3tkIkZuTiIcFcfb+zPrcauC5Xo4+fCdkidYuyv2tO6FVwvys8FYV5SFNYpcDCv2uaWQ76ZEzTJixBCbBpnRmS9vLywdu1aVFRU4NNPP0WfPn1QW1trWuHrkUcewdmzZ5GamkpJbA9lPH1tK833q5uVSCtuAABM7qH1sUY8Hq9d+UdPQZO8CCHEtnHuL7ejoyPuv/9+3H///WyHQqwsqZ8f+L8CWeUylNQrEOwpZTukW9qbXQWGARJ6uSHAzZHtcCxuSqw/vjx0BQdyq6HU6OAgsu3aymtX8nrY3lbykssB37b+09XVwHW9ugkhxFZwZkSWEE8nMRLDDQsi2MKkItMiCHE9u6zAKKGXO/xdHSBX63D8ci3b4dyxayd5xQba4UpeCoVhI4QQG0aJLOEUW2m+39SqQWpbMtfT62ON+HyeqcUY1/9/bodh7HSSFyGE9DCUyBJOMdaani1uQLVMyXI0N7cvuwoaHYM+vs7o7ePMdjhWY0za92ZXQavTsxxN9127kldPmbhGCCH2iBJZwikBbo4YEOwOhgH2ZHO3+f5fFyoAANP6B7AciXUNC/eEu1SEBoUGpwrq2Q6n2346VQLAMMmrJ67GRggh9oIziWxzczOWLVuGmJgY+Pj4IDIyEtOmTcP777+P3NxctsMjVmQsL+BqnWyzUoPDlwxlBfaWyAoFfNPCD1z+onErTQqN6b310FA7m+RFCCE9DCuJbFZWFrTa9k3VH3/8cWzZsgVz587F+++/jxdeeAH79+/H999/j9jYWNx7770oLy9nI1xiZcbT16mX69CoULMczY3251ZDrdUjwscJff3sp6zAyJjIpuRW2dQqbEZ/ZJZDrdUj2t8FsfaykhchhPRQrCSyw4cPv2FJ2j179mD79u1466238Mwzz2Dx4sUQiUTYuXMnrly5Aj8/PwwdOhQFBQVshEysKNzbCdH+LtDqGaTkVLMdzg3+Om8YzZsa5w8ej8dyNNY3uo83xEI+SupbccmGVmEz+uVsKQDg/sG97PL/DwDA5wNjxxo2PmdOzBFCSJex8hcsOzsboaGh7fb5+flBcZNWMKGhofjqq6+wcOFCLF682BohEpYlc3RxBLlKiwN5huR6apx9lRUYOUmEGNnb0CZtX45tlRfkV7cgvaQRAj4P9w4IYjsc9jg6AgcPGjbHnt8DmRDSc7GSyAYHB0MgaN9M/fnnn8eTTz6JjIyMm97u0Ucfxf79+y0dHuEAY53s4Ys1kKu0tznaeg7m1UCl1SPEU2rXp6UntpUX7LOxOtmtaYbR2HF9feDjImE5GkIIIXeKM+eUli5dirvvvhuDBg3ClClTsG7dOuj1+nan/jZt2gRvb28WoyTWEu3vglAvKVRaPQ5drGE7HJOdbd0Kpva3z7ICo6QYw6pQ50oaUduiYjmaztHpGfyWVgbAUFZACCHE9nEmkQWAjz76CMePH4eLiwuWLVuG1tZWJCQkICIiAl5eXvjHP/6B1atXsx0msQIej4cpsdxaHKFVrcOBXENZwTQ7LSswCnBzRGygKxgGpteE647l16JSpoS7VIQJbYm43ZLLAR8fwyaXsx0NIYR0G+caKCYmJmLLli1Qq9VIS0vDxYsXIZPJ4O3tjQkTJsDX184/gOxIcpw/vjx8Bftzq6HS6iARCm5/Iws6dLEGCrUOQe6OiO9lh0uaXmdijB+yymVIyanGnCHcXx3LWFZwT0Ig6+8lTqi1/WWGCSGEc4mskVgsxvDhwzF8+HC2QyEsGdDLHX6uElTJVDieX4fx0ex+iTEugmCv3QquNynGD5+kXMLhSzVQanRwEHE3OZQpNaaRfSorIISQnoNTpQWEXIvP513tXsByeYFSozO1AptqZ4sg3ExckCv8XCVQqHU4caWO7XBuaWdmBVRaPfr4OqN/EI2mE0JIT0GJLOE0Y53s3pwqaHV61uI4eqkWLSot/F0dMDDYnbU4uITH42FCdNviCBzs93st6h1LCCE9EyWyhNOGhXvCXSpCvVyN04UNrMVh7FYwJc4ffD4lQkbG7gUpOdxd5auwVo4zRQ3g84BZA+24dywhhPRAlMgSThMK+JjU1rN0N0uLI6i1euxt65c6jcoK2hkV6Q0HER/lTUpkV8jYDqdDxkleY/r6wNfVgeVoCCGEmBMlsoTzjIsj7LpQCb3e+qN+xy/XolmphY+LBINDPaz++FzmIBLgrkgfANwsL9DrGfza1jv2vkE0ycuEzweGDDFstEQtIcSG0V8wwnmjIr3hJBagUqZEZlmT1R//z0xDWUFyrB8EVFZwg2vLC7jmZEE9yhpb4eIgxKR+fmyHwx2OjsDp04aNlqglhNgwSmQJ5zmIBKbWW9buXqDU6LC77THvjg+06mPbCuPiAhmlTaiSKVmOpr0/M8sBGFqmcbk9GCGEkO6hRJbYhKvlBRVWnVR06GINmtu6FQwN87Ta49oSXxcHJLR1ctjPoVW+tDo9/jJ+CUmgLyGEENITUSJLbMK4KF+IhXwU1ilwsarFao/7e4ZhRG9GfAB1K7iFpGjulRccv1yHerkaXk5ijIjwYjscblEogLAww6ZQsB0NIYR0GyWyxCY4S4QY08cbgPXKC+QqrSkxu2cAjejdysS2zhJH82uh1OhYjsbAWFYwJc4fQgH9qWuHYYCiIsPG0bZphBDSGfTXndgM4ypfO86XW6W8YF9OFZQaPUK9pLQa1G3EBLggwM0BSo0eqZfZX+VLrdWbvvDMoNpmQgjpsSiRJTZjcqw/xAI+Lla1ILey2eKP90dbWcE9CYG0GtRtGFb5aisvyGW/vOBofg1kbS3ThoVTbTMhhPRUlMgSm+HmKML4aEPP0m3pZRZ9rCaFBocu1gCgiUKdNbGte8GB3BrWV/n6M8PQMm16/wBqmUYIIT0YJbLEpswcYFhi9I/0cosujvBHZjk0OgbR/i7o6+discfpSUZEeEMi5KOssRV5VZYfMb8ZpUaHPW0rsd2dQCuxEUJIT0aJLLEp46N94SIRorxJidOF9RZ7nF/OGpY1vX8wrQbVWY5iAUZFGibksdmG62BeDVpUWgS6OWBgMK3ERgghPRklssSmOIgEpp6y29tqWM0tv7oZ6SWNEPB5uLdtBJh0jnHhiv0sLldr7FYwnVqm3RyPB/TrZ9io/psQYsMokSU2x5hc7jxfAbVWb/b7/+Wsof52fJQPfFwkZr//nsw44SutuAENcrXVH1+h1iKlLYmmbgW3IJUCWVmGTSplOxpCCOk2SmSJzRnR2wu+LhI0XjMhy1x0ega/naOygu4KcndEtL8L9AzM/n/TGftzq9Gq0SHEU4r4XtQyjRBCejpKZInNEfB5uKetk8Dm0yVmve8jl2pQJVPBQyrChGg/s963vbjahsv65QWmbgXxAdQyjRBC7AAlssQmPTQsGACwP7cKFU2tZrtf4ySvewcEQSykX4/uMLbhOpRXDa3O/KUfN9Os1OBAniF5vpvKCm5NoQBiYw0bLVFLCLFh9ElNbFKkrwuGhXtCz5hvVLa6WYndWYbVoKisoPsGBHvAQyqCTKnF2aIGqz3uvpwqqLR6RPg4ISaAWqbdEsMA2dmGjZaoJYTYMEpkic16JDEEgCGRNcfI348niqHRMRgY4o44WpK22wR8HsZFtXUvsGJ5gbGsYEY8rcRGCCH2ghJZYrOmxPnD00mMiiYlDuTd2cQilVaHH08WAQCeHBVujvDsmrFO1lqJbJNCg8OX2lZii6dFEAghxF5QIktslkQoMJUAbGxLQrvrj4wK1Lao4e/qYOpTS7pvTF8fCPg8XKpuQUm95Wswd2dXQqNjEOXngj60EhshhNgNSmSJTXt4mKG84ODFGhTVybt1HwzD4JtjBQCAx0aEQiSgX4s75eYowpBQw6pa1hiV/TPTWFZAo7GEEGJP6BOb2LRwbyeM7esDhgE+3Z/frfs4XdiArHIZJEI+5rYlxuTOGbsXWLoNV12LCsfyawEAMxKoWwEhhNgTSmSJzVuS1AcA8Ou5MhTWdm1UlmEY/Gf/JQDA7EFB8HASmz0+e2Wskz1xuQ5yldZij7MrqxI6PYO4IFeEeztZ7HF6FB4PCA01bDQxjhBiwyiRJTZvYIgHxkf5QKdn8ElbUtpZB/NqcORSLcQCPp4b29tCEdqn3j7OCPGUQq3T48ilWos9zrXdCkgnSaVAYaFhoyVqCSE2jBJZ0iO8NKkvAGDbuTJcrmnp1G00Oj3+b0c2AGDeqDCEetFonjnxeDwkxRhWR9vT1p/X3KqblThZUAcAmN6f6mMJIcTeUCJLeoT4Xu5IivGDngHW7r3Yqdv8dKoYl2vk8HQSY9H4SAtHaJ+MHSD25VRBY4FVvnZmVkDPAAOC3RHsSSOLhBBibyiRvU5YWBh4PF677YMPPmA7LNIJL03qAx4P2JFZgV/TSm95bKNCjX+1JbwvJfWBm6PIGiHancGhHvByEkOm1OLklXqz3//2jHIAwL0DqKygS1pbgaFDDVur+ZZ4JoQQa6NEtgPvvfceKioqTNsLL7zAdkikE2ID3fDiBMPErzd+u4C8yuYOj2tV6/D0hjNoUGjQx9fZ1MKLmJ+Az8Okfobygt1mLi8orlPgXHEj+DxgOrXd6hq9HjhzxrDpzT9STggh1kKJbAdcXFzg7+9v2pycqHbSVrw4sQ9G9/FGq0aHhT+eRct1s+W1Oj2e35iGM0UNcHUQ4j9zB0JIfWMtKjnWUF6wJ7sSej1jtvv9PaMMADAq0hu+Lg5mu19CCCG2gz7BO/DBBx/Ay8sLAwcOxOrVq6HV3rp1kEqlgkwma7cRdgj4PHz84AAEuDngSo0cyf86jJ/PlECp0eHopVos/DENKbnVkAj5+HreUET7u7Idco83MtILzhIhqmQqZJQ2muU+GYbBtnRDWcE91DuWEELslpDtALjmxRdfxKBBg+Dp6Ynjx49j+fLlqKiowNq1a296m5UrV+Ldd9+1YpTkVrycJVj36GAs+O4Myhpb8eovmVj+63no2kYDBXwePp07CEPDPFmO1D5IhAKMi/LBn5kV2JVViYEhHnd8n9kVMuRXt0As5COZlhQmhBC7xWMYxnzn+jjq9ddfx4cffnjLY3JychAdHX3D/vXr1+PZZ59FS0sLJBJJh7dVqVRQqVSmn2UyGYKDg9HU1ARXVxrxY0urWocfThTh84P5aFBo4O0sxsRoP8wZ0gtDKIm1qj8zy/H8xnMI93bC/mVjwbvDJvwrd+bgy8NXMDXOH188OthMUdoRuRxwdjZcbmkBqHyKEMIhMpkMbm5uncqj7GJEdtmyZZg3b94tj4mIiOhwf2JiIrRaLQoLCxEVFdXhMRKJ5KZJLmGPo1iABWMi8MjwEJQ3tiLc2xkCPq1ixIZxUb6QCPkoqJXjfFkT4nu5d/u+9HoGv5u6FQSZKUJCCCG2yC4SWR8fH/j4+HTrtunp6eDz+fD19TVzVMRapGIhIn1d2A7DrjlLhJgc648/Msqx9WzpHSWyR/JrUdGkhKuDEOOiuvd7TQB4e7MdASGE3DGa7HWN1NRUfPzxx8jIyMCVK1fw448/4qWXXsKjjz4KD487r+sjxJ7dN8gwevp7RjnU2u63fNp4sggAMHtQLziIBGaJze44OQE1NYaNygoIITaMEtlrSCQSbNq0CWPHjkVsbCzef/99vPTSS/jqq6/YDo0Qmze6jw98XSRoUGiwP7e6W/dRJVNiX47htnMTqf8vIYTYO7soLeisQYMG4cSJE2yHQUiPJODzMGtgEL48fAVb00pNy9d2xc+nS6DTMxgS6oG+flQuQggh9o5GZAkhVnPf4F4AgAO51ahrUd3m6PZ0egabTpcAoNHYO9baCowbZ9hoiVpCiA2jRJYQYjV9/VzQP8gN2ms6D3TW4Ys1KGtshZujCNP605K0d0SvBw4dMmy0RC0hxIZRIksIsSrjpK/vTxSZFqnojO9SC9tuT5O8CCGEGFAiSwixqvsG94KbowhXauT4o5OjsmeL6nEgrwZ8HvDocCorIIQQYkCJLCHEqlwcRFgwOhwA8EnKpduOyjIMgw//ygMAPDAkGBE+zhaPkRBCiG2gRJYQYnVPjAyDu1SEK7W3H5U9mFeDU4X1kAj5WJzUx0oREkIIsQWUyBJCrM4wKmtYFvpWo7J6PYMPd+UCAOaNDEOAm6PVYiSEEMJ9lMgSQlhx7ajsl4cvd3jMt8cLkVvZDBcHIRaO623lCHs4qdSwEUKIDaNElhDCCmeJEMsm9QUArNqVh59OFbe7fvPpYrz3ZzYAYPHEPnCXiq0eY4/l5ATI5YaNlqglhNgwWtmLEMKaR4eHorSxFV8euoK//3YeKo0OUf6uyKmQ4R87DEns/FFheOqucJYjJYQQwkWUyBJCWMPj8fD6lGi0KLX48WQx3vkju931j48Ixdsz+oHH47EUISGEEC6jRJYQwioej4d/3BsHN0cR9uVUwTjva1r/ACyZ2IeSWEtQKoH77jNc3roVcHBgNx5CCOkmHsMwnV9ah3SKTCaDm5sbmpqa4OrqynY4hBDSnlwOOLf1421poTpZQgindCWPoslehBBCCCHEJlEiSwghhBBCbBIlsoQQQgghxCZRIksIIYQQQmwSJbKEEEIIIcQmUfstCzA2gpDJZCxHQgghHZDLr16WyQCdjr1YCCHkOsb8qTONtSiRtYDm5mYAQHBwMMuREELIbQQGsh0BIYR0qLm5GW5ubrc8hvrIWoBer0d5eTlcXFws3sxdJpMhODgYJSUl1LMW9Hpcj16P9uj1uIpei/bo9WiPXo/26PVoz9KvB8MwaG5uRmBgIPj8W1fB0oisBfD5fPTq1cuqj+nq6kq/XNeg16M9ej3ao9fjKnot2qPXoz16Pdqj16M9S74etxuJNaLJXoQQQgghxCZRIksIIYQQQmwSJbI2TiKRYMWKFZBIJGyHwgn0erRHr0d79HpcRa9Fe/R6tEevR3v0erTHpdeDJnsRQgghhBCbRCOyhBBCCCHEJlEiSwghhBBCbBIlsoQQQgghxCZRIksIIYQQQmwSJbKEEEIIIcQmUSJLCCGEEEJsEiWyhBBCCCHEJlEiSwghhBBCbBIlsoQQQgghxCZRIksIIYQQQmwSJbKEEEIIIcQmUSJLCCGEEEJskpDtAHoivV6P8vJyuLi4gMfjsR0OIYQQQojNYBgGzc3NCAwMBJ9/6zFXSmQtoLy8HMHBwWyHQQghhBBis0pKStCrV69bHkOJrAW4uLgAMPwHuLq6shwNIYRcRy4HAgMNl8vLAScnduMhhJBryGQyBAcHm/KpW6FE1gKM5QSurq6UyBJCuEcguHrZ1ZUSWUIIJ3WmPJMmexFCCCGEEJtEiexNfPbZZwgLC4ODgwMSExNx6tQptkMihBBCCCHXoES2A5s3b8bSpUuxYsUKpKWlISEhAcnJyaiurmY7NEIIIYQQ0oYS2Q6sXbsWCxYswPz589GvXz+sW7cOUqkU69evZzs0QgghhBDShiZ7XUetVuPs2bNYvny5aR+fz0dSUhJSU1M7vI1KpYJKpTL9LJPJLB6n0au/ZMDXxQEDgt0xIMQd3s4Sqz02IYQQQgibKJG9Tm1tLXQ6Hfz8/Nrt9/PzQ25uboe3WblyJd59911rhNdOU6sGP58pbbcv2NMRA4I9MDDYHcMjvBDt7wI+nxZlIIRcQyIBfv756mVCCLFRlMiawfLly7F06VLTz8b+Z5Ym4PPwz1n9ca64AekljcivaUFJfStK6lvxR0Y5AMDTSYwRvb2QFOOL8VG+cJeKLR4XIYTjhEJgzhy2oyCEkDtGiex1vL29IRAIUFVV1W5/VVUV/P39O7yNRCKBhIVRDWeJEHMTQzA3MQQAIFNqkFnShPSSBpwubMDpwnrUy9XYkVmBHZkVEPB5SAz3xMyBQZga5w8XB5HVYyaEEEIIMRcewzAM20FwTWJiIoYNG4b//Oc/AAC9Xo+QkBA8//zzeP311297e5lMBjc3NzQ1NbG6IIJGp0dGSSMOXazB3uwq5FY2m66TCPmYHh+AeSPDEN/LnbUYCSEs0GqB334zXJ41yzBCSwghHNGVPIoS2Q5s3rwZTzzxBL788ksMGzYMH3/8MX7++Wfk5ubeUDvbEa4kstcrqVfg94xy/JpWiss1ctP+gSHuWDQuEhNjfDu1igYhxMbJ5YCzs+FySwut7EUI4RRKZM3g008/xerVq1FZWYkBAwbgk08+QWJiYqduy9VE1ohhGJwracT3qUX4M7McGp3hLRAX5IolE/tSQktIT0eJLCGEwyiRZRnXE9lr1TSr8PXRAnyXWgiFWgcAGBbmieXTojEwxIPl6AghFkGJLCGEwyiRZZktJbJG9XI1vjp8Bd8cK4BKqwcATI8PwKvJUQj1og85QnoUSmQJIRxGiSzLbDGRNapoasWaPRexNa0UDAOIBDw8OjwUC8f1hq+LA9vhEULMgRJZQgiHUSLLMltOZI2yy2X4YFcuDl+sAQCIhXzcN6gXFowOR4SPM8vREULuCCWyhBAOo0SWZT0hkTU6fLEGH++7iLTiRtO+uyK98fCwEEzq5wexkM9ecISQ7qFElhDCYV3Jo6h5ILmlMX19MLqPN04XNuDLQ5exP68aR/NrcTS/Fm6OIkyJ9ceMhAAMj/CCSEBJLSE2QSwGvvnm6mVCCLFRNCJrAT1pRPZ6JfUKbD5dgp/PlKC6WWXa7yIRYlSkN8ZG+WBIqAd6+ziDz6cWXoQQQgjpGiotYFlPTmSNdHoGJ6/U4c/zFdh9oRJ1cnW7610chBgQ7I5BIR4YGOKO+F7u8HSikR9CCCGE3Bolsiyzh0T2Wno9g/NlTTiYV4Pjl2uRWdqEVo3uhuP8XCXoF+CKmLatX6ArwrycIKCRW0KsS6sFdu82XE5OpiVqCSGcQoksy+wtkb2eVqdHbmUzzhU3IK24EeeKG1BYp+jwWEeRAH39XdAvwBX9AlwQE+CK6ABXOEvog5UQi6HJXoQQDqNElmX2nsh2pEWlRW6FDDkVMmRXNCO7Qoa8ShmUGn2Hx4d6SRHjbxi1jQlwRUIvN/i6Uh9bQsyCEllCCIdRIssySmQ7R6dnUFgnR3a5IcE1bM2olCk7PD4mwBVj+/pgUj8/DApxB49HJQmEdAslsoQQDqNElmWUyN6ZernalNhml8sMo7dVzbj2nRrk7oi7EwLx0NBghHnThzAhXUKJLCGEwyiRZRklsuZX16LC0fxapORUIyWnCnL11clkY/v6YN7IMIyL8qFRWkI6gxJZQgiHUSLLMkpkLatVrcOBvGpsOVOCgxdrTCO1cUGuWDKxLybG+FJCS8itUCJLCOEwSmRZRoms9RTVyfF9ahE2niqGom2UdkCwO96+ux8GhXiwHB0hHEWJLCGEw8yeyM6ePbvTD/7rr792+tieihJZ66trUeG/Rwqw4XihqYftrIFBeG1KNPzdqNsBIe1oNMBXXxkuP/MMIBKxGw8hhFyjK3kUvzN36ObmZtpcXV2RkpKCM2fOmK4/e/YsUlJS4ObmdmeRE9JNXs4SvD41GodeGYf7B/cCAPx2rgzjPzqIf++7hFb1jQs0EGK3RCJg0SLDRkksIcSGdbm04LXXXkN9fT3WrVsHgUAAANDpdPjb3/4GV1dXrF692iKB2hIakWVfZmkj3vsjG2eKGgAAgW4O+Nv4SMwZ0gsSoYDl6AghhBByMxatkfXx8cHRo0cRFRXVbn9eXh5GjhyJurq6rkfcw1Aiyw0Mw+CPzAp8sDMH5U2G3rR+rhI8fVcEHhgSDDcpjUQRO6XTAUeOGC6PHg0I6MsdIYQ7zF5acC2tVovc3Nwb9ufm5kKv73iVJkLYwOPxcE9CIPa/PA7v3N0P/q4OqJKp8P7OHAz75z68siUDpwvrodfTfEdiZ5RKYPx4w6bseAESQgixBV1e0H7+/Pl46qmncPnyZQwbNgwAcPLkSXzwwQeYP3++2QMk5E45iASYNyocDyeG4Le0MmxILUJOhQxbzpZiy9lSBLg5YFr/AEyM9sXgMA8qPSCEEEJsRJdLC/R6PT766CP8+9//RkVFBQAgICAAixcvxrJly0x1s/aMSgu4jWEYpBU3YuPJYuzJqkSzSmu6TioWYFi4JxJ6uSO+lxvie7nDx0XCYrSEWAC13yKEcJjFamS1Wi02btyI5ORk+Pn5QSaTAQAla9ehRNZ2KDU6HL5Yg11ZlTh8sRa1Laobjgl0c0D/Xm6I9HVGmJcTwr2dEObtBC8nMS28QGwTJbKEEA6z6GQvqVSKnJwchIaG3lGQ5lZYWIh//OMf2L9/PyorKxEYGIhHH30Ub7zxBsRisemY8PDwG26bmpqK4cOHm37esmUL3nrrLRQWFqJPnz748MMPMW3atE7HQomsbWIYBtkVMpwpbEBGaSPOlzYhv6YFN/sNcZEIEeotRYinFMGeUoR6OiHE0/BzoLsDhIIul6ATYh2UyBJCOKwreVSXa2SHDRuGc+fOcS6RNU42+/LLLxEZGYkLFy5gwYIFkMvl+Oijj9odu2/fPsTGxpp+9vLyMl0+fvw4Hn74YaxcuRIzZszAxo0bMXPmTKSlpSEuLs5qz4dYH4/HQ2ygG2IDr/ZDblFpcaGsCRfKmlBQK0dhnRyFtQqUN7WiWaXFhTIZLpTJbrgvAZ+HIHdHhHs7oV+gK2IDXREb6IZQTyn4fBrFJYQQQsyhyyOyP//8M5YvX46XXnoJgwcPhtN13+Tj4+PNGuCdWL16Nb744gtcuXIFwNUR2XPnzmHAgAEd3ubBBx+EXC7Hn3/+ado3fPhwDBgwAOvWrevwNiqVCirV1VPSMpkMwcHBNCLbgyk1OhTXK1BUp0BxvQIl9QoU1ckNlxtaodZ23MHDWSJEvwBXDAv3xF19vDEoxANiIY3cEiujEVlCCIdZdET2oYceAgC8+OKLpn08Hg8Mw4DH40Gn484KSk1NTfD09Lxh/z333AOlUom+ffvi1VdfxT333GO6LjU1FUuXLm13fHJyMrZt23bTx1m5ciXeffdds8VNuM9BJEBfPxf09XO54Tq9nkF1swpFdXJcqm5BVrkM2eVNyKlsRotKi1OF9ThVWI9PD+TDSSxAUj8/zIgPxJi+3tQxgViHSASsWnX1MiGE2KguJ7IFBQWWiMPs8vPz8Z///KddWYGzszPWrFmDUaNGgc/nY+vWrZg5cya2bdtmSmYrKyvh5+fX7r78/PxQWVl508davnx5u+TXOCJL7BOfz4O/mwP83RyQGHG1bEWr0+NyjRwZJY04drkWx/JrUduixvb0cmxPL4eHVIQHhgbj0cRQBHtKWXwGpMcTi4FXXmE7CkIIuWNdTmStXRv7+uuv48MPP7zlMTk5OYiOjjb9XFZWhilTpmDOnDlYsGCBab+3t3e7hHPo0KEoLy/H6tWr243KdpVEIoFEQi2ayK0JBXxE+bsgyt8FDwwNhl7PIL20EX9mVGDH+XJUyVT48tAVfHX4Cqb1D8BLSX0R6evMdtiEEEIIZ3U5kTXKzs5GcXEx1Gp1u/13khB2ZNmyZZg3b94tj4mIiDBdLi8vx/jx4zFy5Eh89dVXt73/xMRE7N271/Szv78/qqqq2h1TVVUFf3//rgVOyG3w+TwMCvHAoBAPvDE9Bik5VfgutQhH82uxI7MCf52vwMyBQXglOQoBbo5sh0t6Ep0OSEszXB40iJaoJYTYrC4nsleuXMGsWbNw/vx5U20sAFM/TXPXyPr4+MDHx6dTx5aVlWH8+PEYPHgwvvnmG/D5t59Ek56ejoCAANPPI0aMQEpKCpYsWWLat3fvXowYMaLLsRPSWQI+D5Nj/TE51h/Z5TL8a99F7M2uwq9pZdh1oRIvTuyDJ0eF08QwYh5KJdC2MiNN9iKE2LIufyouXrwY4eHhqK6uhlQqRVZWFg4fPowhQ4bg4MGDFgixc8rKyjBu3DiEhITgo48+Qk1NDSorK9vVtm7YsAE//fQTcnNzkZubi3/+859Yv349XnjhBdMxixcvxq5du7BmzRrk5ubinXfewZkzZ/D888+z8bSIHeoX6Ir/Pj4E2xeNwpBQDyjUOnzwVy6m/vswjufXsh0eIYQQwhldbr/l7e2N/fv3Iz4+Hm5ubjh16hSioqKwf/9+LFu2DOfOnbNUrLf07bffYv78+R1eZ3yKGzZswIcffoiioiIIhUJER0fjlVdewf3339/u+C1btuDNN980LYiwatUqWhCBsEKvZ/DruTKs3JmDOrmhjGdGfADemB5D5Qak+6j9FiGEwyy6speHhwfS0tIQHh6O3r1743//+x/Gjx+Py5cvo3///lAoFHcUfE9AiSwxt6ZWDdbuycP3J4qgZwCJkI9HEkOxcFxv+LjQREPSRZTIEkI4rCt5VJdLC+Li4pCRkQHAMFFq1apVOHbsGN577712k64IIebj5ijCu/fG4ffn78LQMA+otHqsP1aA0av2461tF5Bf3cx2iIQQQojVdXlEdvfu3ZDL5Zg9ezby8/MxY8YMXLx4EV5eXti8eTMmTJhgqVhtBo3IEktiGAZHLtVizd6LyChpNO0fFemFWQN7ITnWDy4O1OSe3AKNyBJCOMyipQUdqa+vh4eHh6lzgb2jRJZYA8MwOH65Dt8eL0RKThX0bb/JYiEfY/r4YGxfb4zp64NQL0pSyHUokSWEcJhFl6jdv38/Ro4cCQcHB9O+jpaBJYRYFo/Hw6hIb4yK9EZJvQK/ppXh94wyXK6RY19OFfblGPoh+7s6YECwOxKC3dHH1xnhPk4I8ZRCJKBWXnZLJAJWrLh6mRBCbFSXR2SdnZ2h1WoxdOhQjBs3DmPHjsWoUaPg6EgzqI1oRJawhWEY5FQ040BeNQ5drEFaUQO0+ht/xQV8HkI8pQj3dkKQuyN8XCSGzVliuuztLKG+tYQQQqzOoqUFGo0Gp06dwqFDh3Do0CEcP34carUaQ4YMwfjx4/F///d/dxR8T0CJLOEKhVqL86VNOFfSiAtlTbhSI0dBrRytms4tXOIuFcHHWQJfVwl8XRzg25bk+rs5INhDihBPKdylIiorIoQQYjZWrZHNysrC6tWr8eOPP0Kv15t9ZS9bRIks4TKGYVApU6KgRo4rtXJUyZSoaVYZthaV6XJHI7kdcZeK0NfPBdH+LogLcsPQME+EeUkpueUyvR7IyTFcjokBOrEKIiGEWItFE9mLFy/i4MGDOHjwIA4dOgSVSoXRo0dj3LhxGDduHBISEu4o+J6AElli6/R6Bk2tGtS0qFAtU6G6WYnq5quXK5uUKGlQoEqm6vD23s5ijOnrg8n9/DC6jw+cJF0uxyeWRJO9CCEcZtFEls/nw8fHB4sXL8aMGTPQv39/Gnm5DiWyxF60qnW4UtuCvMpm5FTIcK64EZmlTVDr9KZjHER8zIgPxMPDQjAoxJ3+XnABJbKEEA6zaCK7ZMkSHD58GNnZ2Rg0aJBpJPauu+6CVCq9o8B7CkpkiT1TanRIK27Avuxq7M2pREl9q+m62EBXLJ7YB5P6+VFCyyZKZAkhHGaVGtnGxkYcOXLENOkrKysLAwcOxLFjx7oVdE9CiSwhBgzDIK24ARtPluDPzHKotIaR2rggVyyfGoNRkd4sR2inKJElhHCYRZeoNdLpdNBoNFCpVFAqlVCpVMjLy+vu3RFCeiAej4fBoZ5Y80ACUpdPxMJxvSEVC3ChTIZH/ncSizedQ3Wzku0wCSGE2KguJ7Ivvvgi4uPj4efnh2effRbl5eVYsGABzp07h5qaGkvESAjpATydxHhtSjSOvDoeT4wIBY8HbE8vx8Q1h/D9iSLoO9klgRBCCDHqcmnBnDlzMHbsWIwbNw5xcXGWisumUWkBIbeXWdqIv/92HhfKZACAAcHueH9WHGID3ViOzA5QaQEhhMOs2keW3IgSWUI6R6dn8H1qIT7acxEtKi34PGD+qHC8NKkvnKlll+Wo1cAbbxguv/8+IBazGw8hhFzD4ons999/j3Xr1qGgoACpqakIDQ3Fxx9/jPDwcNx7773dDrynoESWkK6pkinx3p/Z2JFZAQAIcHPA61OjMSM+EAI+dTcghBB7YtHJXl988QWWLl2KadOmobGx0bSSl7u7Oz7++ONuBUwIsW9+rg74bO4gfDt/KEI8pahoUmLxpnRMXHMQm04VQ9nJJXUJIYTYly6PyPbr1w///Oc/MXPmTLi4uCAjIwMRERG4cOECxo0bh9raWkvFajNoRJaQ7lNqdPjv4Sv4+lgBGhUaAICrgxAzBwZhzuBgxAW5Ug/aO6XXA8XFhsshIbRELSGEU7qSR3W5CK2goAADBw68Yb9EIoFcLu/q3RFCSDsOIgFemNgHT94Vjp9OFWP90QKUNynxXWoRvkstQpC7IyZE+2JclA8Gh3rAXUr1nV3W2gqEhxsu02QvQogN63IiGx4ejvT0dISGhrbbv2vXLsTExJgtMEKIfXOSCPH06AjMHxWOY/m12HymBCk5VShrbMX3J4rw/YkiAECkrzPiAl0R5e+KPr7OCHR3RICbA9ylIhq5JYSQHq7LiezSpUuxaNEiKJVKMAyDU6dO4aeffsLKlSvxv//9zxIxEkLsmIDPw5i+PhjT1wetah2OX67FvpxqnCyow5UaOfKrW5Bf3QKgvN3tJEI+Atwc4O/mAE8nMZwlQjhLRHB2EMJFIoSzg9Cwr+1fqVgAqVgIJ7EAUokQjiIBTTQjhBCO61bXgh9//BHvvPMOLl++DAAIDAzEu+++i6eeesrsAdoiqpElxDrq5WqkFTUgr6oZeZXNuFzTgsomJerkarPcv4OIDyexIdn1dBLDy0kCLycxPJ3F8HISo5eHFCGeUoR4SW2rXRj1kSWEcJjF2m9ptVps3LgRycnJ8PPzg0KhQEtLC3x9fe84aHMICwtDUVFRu30rV67E66+/bvo5MzMTixYtwunTp+Hj44MXXngBr776arvbbNmyBW+99RYKCwvRp08ffPjhh5g2bVqn46BElhB2KTU6VMtUqGhqRaVMiaZWDZqVWrSotGhp+9fws2G/Qq2DQq2FQqWDXK1FdxYZC/GUol+AK+KD3TCytzfiAl0hFHB0EhUlsoQQDrPYZC+hUIjnnnsOOTk5AACpVAqpVNr9SC3gvffew4IFC0w/u7i4mC7LZDJMnjwZSUlJWLduHc6fP48nn3wS7u7ueOaZZwAAx48fx8MPP4yVK1dixowZ2LhxI2bOnIm0tDRayYwQG+EgEiDEyzBS2lUMw0Cl1UOh1kGu0qJVo0NTqwZ1LWrUy9Wol6tQJ1ejplmFkoZWlNQrUC9Xo7hegeJ6BXZlVQLIg4tEiHHRvrgnIRBj+npDIhSY/4kSQoid6/K5sGHDhuHcuXM3TPbiChcXF/j7+3d43Y8//gi1Wo3169dDLBYjNjYW6enpWLt2rSmR/fe//40pU6bglVdeAQD84x//wN69e/Hpp59i3bp1VnsehBB28Hg8OIgEcBAJ4OnUuY4IDXI1cipkyCqX4XRhPU5cqYNMqcUfGeX4I6Mcbo4iPDQsGE+OCoefq4OFnwEhhNiPLtfI/vzzz1i+fDleeuklDB48GE7XnZKKj483a4BdERYWBqVSCY1Gg5CQEMydOxcvvfQShEJDvv74449DJpNh27ZtptscOHAAEyZMQH19PTw8PBASEoKlS5diyZIlpmNWrFiBbdu2ISMjo8PHValUUKlUpp9lMhmCg4OptIAQO6XTM8gobcSOzAr8mVmOKpnh74NIwMPsgb2wdHJfdhNalQpYutRwee1aQCJhLxZCCLmORfvIPvTQQwCAF1980bSPx+OBYRjweDzTSl9sePHFFzFo0CB4enri+PHjWL58OSoqKrB27VoAQGVlJcKNvRPb+Pn5ma7z8PBAZWWlad+1x1RWVt70cVeuXIl3333XzM+GEGKrBHweBoV4YFCIB/4+LQb7c6vx1eHLOF3YgM1nSvBnZjkWTYjEk6PC4SBioeRAIgE++8z6j0sIIWbWrQURrOn111/Hhx9+eMtjcnJyEB0djaXGEQYYRobFYjGeffZZrFy5EhILjjgsX7683WMbR2QJIUTA52FSPz9M6ueHs0X1+L8dOThX3IhVu/Kw9WwpPn5wIPr3cmM7TEIIsUldTmStXRu7bNkyzJs375bHREREdLg/MTERWq0WhYWFiIqKgr+/P6qqqtodY/zZWFd7s2NuVncLGFY1s2SiTAjpGQaHemLrcyPxe0Y53t+Zg8s1csz6/BgWT+yDheN6W6/LAcMAxuXEvb0BWjiCEGKjON/40MfHBz4+Pt26bXp6Ovh8vqk92IgRI/DGG29Ao9FAJBIBAPbu3YuoqCh4eHiYjklJSWlXI7t3716MGDHizp4IIYQA4PN5mDkwCGP7+uDNbRew43wF1uy9iAN51Vj7wACEeVuhFZZCARjbJlL7LUKIDeNok8OuS01Nxccff4yMjAxcuXIFP/74I1566SU8+uijpiR17ty5EIvFeOqpp5CVlYXNmzfj3//+d7uygMWLF+RbHW8AADN6SURBVGPXrl1Ys2YNcnNz8c477+DMmTN4/vnn2XpqhJAeyMNJjE/nDsS/HkyAi0SItOJGTPvkCDaeLIa+O41sCSHEDnVrZS8uSktLw9/+9jfk5uZCpVIhPDwcjz32GJYuXdrutP+1CyJ4e3vjhRdewGuvvdbuvrZs2YI333zTtCDCqlWraEEEQojFlDW2YtnP6ThxpR4AMDDEHSvujsWAYHfLPCAtiEAI4TCLrexFOocSWUJIV+n1DNYfK8DavRehUBu6v9w7IBCLxkeir5/LbW7dRZTIEkI4rCt5VLdKCxobG/G///0Py5cvR329YQQhLS0NZWVl3bk7Qgixe3w+D0+PjsCBl8fhvkG9AADb08sx+V+H8fSGMzieX0slB4QQcp0uj8hmZmYiKSkJbm5uKCwsRF5eHiIiIvDmm2+iuLgY3333naVitRk0IksIuVMXyprw2YF87MqqhPGvdJC7I2YPCkJSjB/6B7mBz+9mtwEakSWEcJhFSwuSkpIwaNAgrFq1Ci4uLsjIyEBERASOHz+OuXPnorCw8E5i7xEokSWEmEt+dQu+OVaA3zPK0azUmvZ7OYkxKtIbA4LdMSDEHTH+rnAUd3JxBUpkCSEcZtFE1s3NDWlpaejdu3e7RLaoqAhRUVFQKpV3FHxPQIksIcTclBod9mZXYUdmBY7m16JFpb3hmCB3R0T4OMHf1QG+rhL4OEvg6+oAHxcJPKQiOEmEkIqFcGK0EP5toeFGX35JS9QSQjjFokvUSiQSyGSyG/ZfvHix2/1eCSGE3JqDSIC7EwJxd0Ig1Fo9zhY14HRhPdJLGpFR0og6uRplja0oa2zt1P1Jej0Ib2cJHkktwbyRYZCKOd9WnBBCbtDlEdmnn34adXV1+Pnnn+Hp6YnMzEwIBALMnDkTY8aMwccff2yhUG0HjcgSQqytXq7G5ZoWFNTIUd2sRE2zCtXNKtO/Ta0ayFVaaDuYMObtLMEzY8Jxd0IgAtwcWYieEEKusmhpQVNTE+6//36cOXMGzc3NCAwMRGVlJUaMGIGdO3fCiWqtKJElhHCWWquHXKmBolGG04UNWHusFMUNV0dxE4LdMTXOH1Ni/a2zyhghhFzHKn1kjx49iszMTLS0tGDQoEFISkrqVrA9ESWyhBBOu2ayl6ZJhl9yG/BbWhlOF9Xj2k+EaH8X3DsgCLMHBcHP1YGlYAkh9saiiWxJSQmCg4PvKMCejhJZQgin3aRrQXWzEnuyqrA7qxLHL9dB11aGwOcBY/r64P7BvZAU4wcHUSe7IxBCSDdYNJEVCAS466678Oijj+L++++Hh4fHHQXbE1EiSwjhtE6032pUqPHXhUpsPVuKM0UNpv1ujiLMGhiEp+4KR7Cn1FoRE0LsiEUT2XPnzmHjxo3YtGkTampqMGXKFDz66KO4++67IaEWLgAokSWEcFwX+8gW1Mrxy9kS/JpWhoomQ4tFPg+Y1j8Az0+IRLQ//Z0jhJiPVWpkGYbBwYMHsXHjRmzduhV6vR6zZ8/G+vXruxV0T0KJLCGE07q5IIJOz+DIpRp8fbQARy7VAgB4PGDmgCC8lNQXIV40QksIuXNWSWSvlZaWhqeeegqZmZnQ6XR3enc2jxJZQginmWFlr+xyGT47kI8d5ysAACIBD8+MicALE/pQDS0h5I50JY/id/dBSktLsWrVKgwYMADDhg2Ds7MzPvvss+7eHSGEEBvSL9AVnz0yCL8/Pwp3RXpDo2Pw2YHLmPyvwzhyqYbt8AghdqLLS7l8+eWX2LhxI44dO4bo6Gg88sgj2L59O0JDQy0RHyGEEHMTCID77796+Q7E93LH908Nw+6sKrzzexaK6xV47OtTWDA6HK8kR0Ms7PZ4CSGE3FaXSwuCg4Px8MMP45FHHkFCQoKl4rJpVFpACLFHLSotVu/KxYbUIgCGxRU+fXggdTcghHSJRWtkGYYBj8e7owB7OkpkCSH2bE9WJV75JRNNrRq4OAix6r54TO0fwHZYhBAbYfZENjMzE3FxceDz+cjMzLzlsfHx8V2LtgeiRJYQYu9KGxR48adzSCtuBAA8PiIUf58WQxPBCCG3ZfZEls/no7KyEr6+vuDz+eDxeLj2ZsafeTwedS0AJbKEEI4zQ9eCztDo9Fiz5yLWHboMAIjwccKH98VjaJinRR6PENIzdCWP6tRkr4KCAvj4+JguE0IIIbcjEvDx+tRoDI/wxKu/ZOJKjRxz1qXi0eEhWDopCp5OYrZDJITYuE5NJw0NDTXVxRYVFSEoKAihoaHttqCgIBQVFVk0WEIIIbZnXJQv9i4di4eGBgMAfjhRjDGrDuCTlEuQq7QsR0cIsWVdnuwlEAhQUVEBX1/fdvvr6urg6+tLpQWg0gJCCMdZqbSgI8cv1+L9HTnIKpcBANwcRXhwaDAeGx5K3Q0IIQAsvCDCzboW1NXVwcmKfwwJIYTYnpG9vfHH83fhk4cHIsxLiqZWDb46fAVjVh/A3P+ewPcnilDdrGQ7TEKIjej0iOzs2bMBANu3b8eUKVMgkUhM1+l0OmRmZiIqKgq7du2yTKS3cfDgQYwfP77D606dOoWhQ4eisLAQ4eHhN1yfmpqK4cOHm37esmUL3nrrLRQWFqJPnz748MMPMW3atE7HQiOyhBBOY3FE9lo6PYMDudXYkFqII5dq210X5eeCxAhPDA71QGygK8K9nSHgU+tHQuyB2Sd7AYCbmxsAw4isi4sLHB0dTdeJxWIMHz4cCxYs6GbId27kyJGoqKhot++tt95CSkoKhgwZ0m7/vn37EBsba/rZy8vLdPn48eN4+OGHsXLlSsyYMQMbN27EzJkzkZaWhri4OMs+CUIIsSMCPg9J/fyQ1M8PJfUK/HWhAjvOVyKjpBF5Vc3Iq2rGd22LK0iEfIR6SRHk7ohAd0cEeTgiyN0RAW6O8HIWw8tJDFcHEfiU7BJiV7pcI/vuu+/i5Zdf5nwZgUajQVBQEF544QW89dZbAGAakT137hwGDBjQ4e0efPBByOVy/Pnnn6Z9w4cPx4ABA7Bu3boOb6NSqaBSqUw/y2QyBAcH04gsIYSblErgvvsMl7duBRwc2I3nOnUtKpwqqMeJK3XILGtCXmUzFOrbz78Q8nnwcDIktYbkVgJPJzG8ncXwcr562dNJAi9nMVwkQlrghxAOssiIrNGKFSu6HZg1/f7776irq8P8+fNvuO6ee+6BUqlE37598eqrr+Kee+4xXZeamoqlS5e2Oz45ORnbtm276WOtXLkS7777rtliJ4QQi3JwAHbsYDuKm/JylmBq/wDTamB6PYPiegWK6xUob2xFWWMryhoM/1bKlKhvUaNZpYVWz6CmWYWaZtVtHsFAJODB21mCcG8nRPo6o6+fCwaGuCPKzwVCQZenkBBCWNDlRBYAfvnlF/z8888oLi6GWq1ud11aWppZArtTX3/9NZKTk9GrVy/TPmdnZ6xZswajRo0Cn8/H1q1bMXPmTGzbts2UzFZWVsLPz6/dffn5+aGysvKmj7V8+fJ2ya9xRJYQQsid4/N5CPN2Qpj3zc8EqrQ61MvVqGtRo06uRr1cZbpc16JCvVyN2hY16uQq1LeoIVfroNExqGhSoqJJieOX60z3JRULMDTME5Nj/TApxg++rtwasSaEXNXlRPaTTz7BG2+8gXnz5mH79u2YP38+Ll++jNOnT2PRokVmD/D111/Hhx9+eMtjcnJyEB0dbfq5tLQUu3fvxs8//9zuOG9v73YJ59ChQ1FeXo7Vq1e3G5XtKolE0m7yGyGEEOuSCAUIcDPUzHaGUqNDnVyNKpkSl6tbkF/TguxyGdKLG9Gs0uLQxRoculiDN367gNF9vPHEiDCMj/alCWeEcEyXE9nPP/8cX331FR5++GF8++23ePXVVxEREYG3334b9fX1Zg9w2bJlmDdv3i2PiYiIaPfzN998Ay8vr04lp4mJidi7d6/pZ39/f1RVVbU7pqqqCv7+/p0PmhBCuEwuB4y9wKurWetawCYHkQBB7oYJY4NCPEz7dXoGF6uacSCvGnuyqpBe0ogjl2px5FItQjylWDa5L+5JCKTaWkI4osuJbHFxMUaOHAkAcHR0RHNzMwDgsccew/Dhw/Hpp5+aNUAfHx/T8ridwTAMvvnmGzz++OMQiUS3PT49PR0BAQGmn0eMGIGUlBQsWbLEtG/v3r0YMWJEl+ImhBBOUyjYjoCTBHweYgJcERPgir+Ni0RJvQI/nCjCptMlKK5XYPGmdHxzrBBv392vXQJMCGFHlxNZf39/1NfXIzQ0FCEhIThx4gQSEhJQUFCALjZAsIj9+/ejoKAATz/99A3XbdiwAWKxGAMHDgQA/Prrr1i/fj3+97//mY5ZvHgxxo4dizVr1mD69OnYtGkTzpw5g6+++spqz4EQQgg3BHtKsXxaDJYk9cX6YwX4/EA+0ksacd8XxzFvZBheTY6Go1jAdpiE2K0uT8ucMGECfv/9dwDA/Pnz8dJLL2HSpEl48MEHMWvWLLMH2FVff/01Ro4c2a5m9lr/+Mc/MHjwYCQmJmL79u3YvHlzu84GI0eOxMaNG/HVV18hISEBv/zyC7Zt20Y9ZAkhxI45igVYND4SB14Zh/sG9QLDAN8cK8TUfx/G2aIGtsMjxG51uY+sXq+HXq+HUGgYzN20aROOHz+OPn364Nlnn4VYLLZIoLaEVvYihHAaR1b2smUH8qqxfOt5VMqUEPJ5eHN6DJ4YGUa1s4SYQVfyqC4nsuT2KJElhHAaJbJm0dSqwRu/ncefmYZVJWcOCMQ/Z/eHVNytzpaEkDZmXxAhMzOz0w8eHx/f6WMJIYQQW+XmKMJ/Hh6IgSEe+OfOHGxLL0dGaRM+fnAAEoLd2Q6PELvQqRFZPp8PHo9328lcPB4POt3tlxHs6WhElhDCaa2twNSphst//QU4dq73Krm5k1fqsHhTuqnU4MWJffDc2N4QC2mFMEK6yuylBUVFRZ1+8NDQ0E4f21NRIksIIfanUaHGG9suYEdbqUGEjxPevScWo/t0voUkIYRqZFlHiSwhhNgnhmGwLb0M//dnDurkhiXck2J88cKEPlRuQEgnWTSR/e677255/eOPP96Vu+uRKJElhBD71tSqwcf7LuK71CLo9IaP2dF9vPHkqHCM7uMNoYBKDgi5GYsmsh4e7Vcy0Wg0UCgUEIvFkEqlFlmm1tZQIksI4TS5HAgLM1wuLKSuBRaUX92Czw/mY3t6uSmh9XWRYNbAIEzq54cBwe6U1BJyHauXFly6dAkLFy7EK6+8guTk5Du9O5tHiSwhhNOo/ZbVldQr8M2xQmxLL0N9W8kBYOh8MLK3FwYEu2NAsDui/V3hJr398uqE9GSs1MieOXMGjz76KHJzc81xdzaNEllCCKdRIssatVaP/bnV2HG+Aocv1qCpVXPDMW6OIoR5SRHi5YQwLyl6eTjC00kCTycxvJ3F8HQSw1kipMUXSI9l9j6ynSEUClFeXm6uuyOEEEJ6HLGQjylx/pgS5w+tTo+M0kacLmxAenEjMkobUdGkRFOrBhmlTcgobbr5/Qj48HASwUMqhrtUBE8nMdylYni2/ewhFbftE8HLSQI/NwkkQoEVnykh1tHlRPb3339v9zPDMKioqMCnn36KUaNGmS0wQgghpCcTCvgYHOqJwaGepn0KtRbF9QoU1SlQVCdHUZ0C5Y2tqJerUSdXo65FjVaNDmqdHlUyFapkqk49Fo8H+Lk4IMRTij5+zojyd0FckBv6B7lBRDW6xIZ1ubSAz2//hufxePDx8cGECROwZs0aBAQEmDVAW0SlBYQQTqPSApvWqtahTq5Co0KDerkaDQq16XKjQo0GhQYNCsP+BrkGdXIVlBp9h/flKBJgUKg7xkf5Ylr/AAS60+IYhH3UR5ZllMgSQjiNElm7wjAM6uVqlDa04kptCy5WtSC3QoZzJY1oVLSv0R0c6oHHR4Riev8A6qZAWEOJLMsokSWEcFprKzBmjOHy4cO0RK2d0usZ5Ne04Fh+Lf46X4nTRfUwZgRB7o54ZkwE5iaGUOkBsTqLJrIMw+CXX37BgQMHUF1dDb2+/emKX3/9tesR9zCUyBJCCLE1VTIlNp0qwXephaZVyfr4OuPde2Mxsrc3y9ERe9KVPKrLX7OWLFmCxx57DAUFBXB2doabm1u7jRBCCCG2x8/VAYuT+uDY6xPwj3tj4SEV4VJ1C+b+9yRe2pzeYaswQtjW5RFZT09P/PDDD5g2bZqlYrJ5NCJLCCHE1jUq1Fi79yJ+OFEEPQMEuDlgzZwEjIyk0VliWRYdkXVzc0NERES3gyOEEMIyhcKwRG1YmOEyIR1wl4rx3r1x+GXhSIR5SVHRpMTc/53ER7vzTMvtEsK2Liey77zzDt599120trZaIh5CCCGWxjBAUZFho/m+5DYGhXhgx4uj8fCwEADApwfy8eS3p9GoUN/mloRYXpdLC1pbWzFr1iwcO3YMYWFhEInarwmdlpZm1gBtEZUWEEI4jdpvkW7adq4Mr/+aCaVGj2BPR/zrgQEYEuZ5+xsS0gUWXaL2iSeewNmzZ/Hoo4/Cz8+P1nomhBBC7MTMgUHo4+eM5344i5L6Vsz5MhXPjI7AS5P6wkFES+AS6+vyiKyTkxN2796Nu+66y1Ix2TwakSWEcBqNyJI71NSqwT/+zMYvZ0sBAOHeTvj7tBgkxfjSABe5Yxad7BUcHMxKcvb+++9j5MiRkEqlcHd37/CY4uJiTJ8+HVKpFL6+vnjllVeg1WrbHXPw4EEMGjQIEokEkZGR+Pbbb2+4n88++wxhYWFwcHBAYmIiTp06ZYFnRAghhNgmN0cRPpqTgP89PgQ+LhIU1Mqx4LszeOR/J5FW3MB2eMSOdDmRXbNmDV599VUUFhZaIJybU6vVmDNnDhYuXNjh9TqdDtOnT4darcbx48exYcMGfPvtt3j77bdNxxQUFGD69OkYP3480tPTsWTJEjz99NPYvXu36ZjNmzdj6dKlWLFiBdLS0pCQkIDk5GRUV1db/DkSQgghtiSpnx8OvDwOfxvXG2IhH8cv12H258cxZ91x7M6qhEanv/2dEHIHulxa4OHhAYVCAa1WC6lUesNkr/r6erMGeL1vv/0WS5YsQWNjY7v9f/31F2bMmIHy8nL4+fkBANatW4fXXnsNNTU1EIvFeO2117Bjxw5cuHDBdLuHHnoIjY2N2LVrFwAgMTERQ4cOxaeffgoA0Ov1CA4OxgsvvIDXX3+9UzFSaQEhhNMUCmDoUMPl06cBqZTdeEiPUFKvwCcpl7AtvQwanSG18HISY3p8AKb3D8CgUA9a7pZ0ikUne3388cfdjcuiUlNT0b9/f1MSCwDJyclYuHAhsrKyMHDgQKSmpiIpKand7ZKTk7FkyRIAhlHfs2fPYvny5abr+Xw+kpKSkJqaetPHVqlUUKlUpp9lMpmZnhUhhFiAVApkZbEdBelhgj2lWD0nAS8nR+GbY4XYcqYEdXI1vkstwnepRXASCzA8wgtDwjzRP8gNcUGucJeK2Q6b2LhudS3gosrKynZJLADTz5WVlbc8RiaTobW1FQ0NDdDpdB0ek5ube9PHXrlyJd59911zPA1CCCHEpvm5OuD1qdF4eXJfHM2vxfb0chzMq0aDQoOU3Gqk5F4t1XOXihDsIUWwp2Pbv1L4uTrAQyqCu1QMD6kIbo4iCGkkl9xElxPZ4uLiW14fEhLS6ft6/fXX8eGHH97ymJycHERHR3f6PtmwfPlyLF261PSzTCZDcHAwixERQggh7BIK+BgX5YtxUb7Q6xlkV8hwLL8WmaVNyCxrREl9KxoVGjQqmnC+rOmW9+XqIISHk9iU3HpIxXBv+9dDKoKHkxgBbo4IcneEr4sEfD51TrAXXU5kw8LCbtlaQ6fTdfq+li1bhnnz5t3ymM4uh+vv739Dd4GqqirTdcZ/jfuuPcbV1RWOjo4QCAQQCAQdHmO8j45IJBJIJJJOxUkIIayjGlliZXw+D3FBbogLcjPta1FpUVKvMGwNrSipV6C0QYGaZhUaFBo0KNRoVho6D8mUWsiUWhTV3X5JZZGAB383BwS5OyLc2xmxga7oF+iK2EBXSITU67an6XIie+7cuXY/azQanDt3DmvXrsX777/fpfvy8fGBj49PV0Po0IgRI/D++++juroavr6+AIC9e/fC1dUV/fr1Mx2zc+fOdrfbu3cvRowYAQAQi8UYPHgwUlJSMHPmTACGyV4pKSl4/vnnzRInIYSwjmGA7OyrlwlhgbNEiJgAV8QE3Hwyj1anR2OrBo0KtSG5lavR2JbkNiiM+9Wol6tR3qhEpUwJjY5BSX0rSupbceLK1QnoDiI+hoZ5YnQfb0yPD0SQu6M1niaxsC4nsgkJCTfsGzJkCAIDA7F69WrMnj3bLIFdr7i4GPX19SguLoZOp0N6ejoAIDIyEs7Ozpg8eTL69euHxx57DKtWrUJlZSXefPNNLFq0yDRa+txzz+HTTz/Fq6++iieffBL79+/Hzz//jB07dpgeZ+nSpXjiiScwZMgQDBs2DB9//DHkcjnmz59vkedFCCGEkI4JBXx4O0vg7dy5s55anR7VzSqUN7aitKEVF6uakV0hw/nSJtTJ1ThyqRZHLtVi5V+5SAz3xANDgnF3QiB1U7BhXW6/dTP5+flISEiAXC43x93dYN68ediwYcMN+w8cOIBx48YBAIqKirBw4UIcPHgQTk5OeOKJJ/DBBx9AKLyarx88eBAvvfQSsrOz0atXL7z11ls3lDd8+umnWL16NSorKzFgwAB88sknSExM7HSs1H6LEMJptLIXsTMMw+BiVQuO5ddiT3Zlu5HaYE9HLBoXidmDekEspISWC7qSR3U5kb2+tRTDMKioqMA777yD3Nxc00ipPaNElhDCaZTIEjtX1tiKX8+W4tvjhaiTqwEAvX2c8H8z+2NEby+WoyMWTWT5fP4Nk70YhkFwcDA2bdpkqje1Z5TIEkI4jRJZQgAArWodfjxZhHWHLqO2xZDQzh4UhLem94OHE/W4ZYtFE9mDBw+2S2T5fD58fHwQGRnZ7hS+PaNElhDCaZTIEtJOU6sGH+3Oww8ni8AwgJ+rBGsfGIBRkd5sh2aXLJrIktujRJYQwmkKBdDWzQXZ2dR+i5A254ob8PKWDFyuMcz3eWZMBJZN7kttu6ysK3lUl6uaV65cifXr19+wf/369bdd3IAQQggHSKVAYaFhoySWEJOBIR7484XReCTRsLjTV4evYNZnx5Ff3cxyZORmupzIfvnllx2utBUbG4t169aZJShCCCGEEDY4igV4f1Z/fPXYYHhIRciukGH6J0fx/Yki0Els7ulyIltZWYmAgIAb9vv4+KCiosIsQRFCCCGEsGlyrD92LxmD0X28odLq8da2C1jw3RnUtajYDo1co8uJbHBwMI4dO3bD/mPHjiEwMNAsQRFCCLGg1lbDErVDhxouE0I65OvqgA3zh+GtGf0gFvCxL6cayR8fwR8Z5dDraXSWC7rcZmDBggVYsmQJNBoNJkyYAABISUnBq6++imXLlpk9QEIIIWam1wNnzly9TAi5KT6fh6fuCseICC8s3nQOl6pb8MJP5/DfI1fw2pRojOztdUNbUmI9Xe5awDAMXn/9dXzyySdQqw091xwcHPDaa6/h7bfftkiQtoa6FhBCOI3abxHSLUqNDusOXcZ/D1+BXK0DAMQFuWLeyHDMiA+Ag4i6G5iDVdpvtbS0ICcnB46OjujTpw8kks6tg2wPKJElhHAaJbKE3JHaFhU+3Z+Pn04VQ6U1nNVwdRBiUj9/zIgPwIjeXpTU3gHqI8sySmQJIZxGiSwhZlEvV2PT6WL8kFqE8ialab9YyMegEHckhnuhf5AbYgJdEejmQCUInUSJLMsokSWEcBolsoSYlU7P4ExhPXacr8CuC5Wobr6xs4GLRIggD0cEujsiyN0RQR6Gf72dJfB2FsPTSQx3qRgCPiW7lMiyjBJZQginUSJLiMUwDIMrtXKcuFKHM4UNyKmQIb+6BdpOdDng8wAPqSGp9XQSw8tZDC8nSYeXPZ3E8OihiW9X8qgudy0ghBDSA3jTGvKEWAKPx0NvH2f09nHGI4mhAACVVoeSegVKG1pR1tiKsrZ/yxtbUdeiRp1cjaZWDfQMUCc3/Ny5xwIC3RwR4eOE3j7O6B/khoEh7gj3drKbMgYakbUAGpElhBBCSFdodHo0KNSoa1Gjvi2ZrWtRmS7Xt6hRJ1cZLsvVaFRobnpfHlIRxkX5IinGD2OjfOAssa1xSyotYBklsoQQQgixJI1Ojwa5GsX1ClyuacHFqhZklDTifFmTqZMCADiKBJg5MAiPDg9BbKAbixF3HiWyLKNElhBCCCFs0Oj0OFfciJScKuzJrkJBrdx03eg+3vj7tBjEBHA7N6FElmWUyBJCOK21FZg61XD5r78AR0d24yGEWATDMDhVUI/vTxRh14VKaPUMeDzg/kG98NrUaHg7c3MNAEpkWUaJLCGE06hrASF2p6hOjlW787AjswKAoY72nXticU9CIOcmhnUlj+JbKSZCCCGEEMKSUC8nfDZ3EH7920jEBLiiQaHB4k3pePb7s2hUdK5LAhdRIksIIYQQYicGhXhg+6JReCmpL0QCHvZkV2HGf47ifGkT26F1CyWyhBBCCCF2RCzkY3FSH2xbNAqhXlKUNrTivnXH8ePJIthaxSklsoQQQgghdig20A2/P38XkmL8oNbq8cZvF/DcD2fR0MkFGbjAZhLZ999/HyNHjoRUKoW7u/sN12dkZODhhx9GcHAwHB0dERMTg3//+9/tjjl48CB4PN4NW2VlZbvjPvvsM4SFhcHBwQGJiYk4deqUJZ8aIYQQQggr3BxF+OqxwXhjWgxEAh52Z1Vhyr8PIyWniu3QOsVmElm1Wo05c+Zg4cKFHV5/9uxZ+Pr64ocffkBWVhbeeOMNLF++HJ9++ukNx+bl5aGiosK0+fr6mq7bvHkzli5dihUrViAtLQ0JCQlITk5GdXW1xZ4bIYRYnVRq2Aghdo/P52HBmAj89rdR6O3jhCqZCk9tOIOnN5xBSb2C7fBuyebab3377bdYsmQJGhsbb3vsokWLkJOTg/379wMwjMiOHz8eDQ0NHY7qAkBiYiKGDh1qSoD1ej2Cg4Pxwgsv4PXXX+/wNiqVCiqVyvSzTCZDcHAwtd8ihBBCiE1pVevwccpFfH2kAFo9A7GQj7nDQvDs2AgEuFmn5zS132rT1NQET0/PG/YPGDAAAQEBmDRpEo4dO2bar1arcfbsWSQlJZn28fl8JCUlITU19aaPs3LlSri5uZm24OBg8z4RQgghhBArcBQLsHxqDHYtGY2Rvb2g1urx7fFCjF11EG/8dh7VzUq2Q2ynxyayx48fx+bNm/HMM8+Y9gUEBGDdunXYunUrtm7diuDgYIwbNw5paWkAgNraWuh0Ovj5+bW7Lz8/vxvqaK+1fPlyNDU1mbaSkhLLPClCCCGEECuI9HXBj08n4senEzEs3BNqnR5bzpRCr2c7svaEbD7466+/jg8//PCWx+Tk5CA6OrpL93vhwgXce++9WLFiBSZPnmzaHxUVhaioKNPPI0eOxOXLl/Gvf/0L33//fdeCv4ZEIoFEws1l3ggh5AZKJXDffYbLW7cCDg7sxkMI4SQej4dRkd4YFemNE1fqcLGqGf5u3Pp7wWoiu2zZMsybN++Wx0RERHTpPrOzszFx4kQ888wzePPNN297/LBhw3D06FEAgLe3NwQCAaqq2s/Uq6qqgr+/f5fiIIQQztLpgJ07r14mhJDbGB7hheERXmyHcQNWE1kfHx/4+PiY7f6ysrIwYcIEPPHEE3j//fc7dZv09HQEBAQAAMRiMQYPHoyUlBTMnDkTgGGyV0pKCp5//nmzxUkIIYQQQu4cq4lsVxQXF6O+vh7FxcXQ6XRIT08HAERGRsLZ2RkXLlzAhAkTkJycjKVLl5pqWgUCgSlZ/vjjjxEeHo7Y2FgolUr873//w/79+7Fnzx7T4yxduhRPPPEEhgwZgmHDhuHjjz+GXC7H/Pnzrf6cCSGEEELIzdlMIvv2229jw4YNpp8HDhwIADhw4ADGjRuHX375BTU1Nfjhhx/www8/mI4LDQ1FYWEhAENXgmXLlqGsrAxSqRTx8fHYt28fxo8fbzr+wQcfRE1NDd5++21UVlZiwIAB2LVr1w0TwAghhBBCCLtsro+sLehK/zNCCLE6uRxwdjZcbmkBnJzYjYcQQq5BfWQJIYQQQkiPZzOlBbbEOMgtk8lYjoQQQjogl1+9LJNR5wJCCKcY86fOFA1QImsBzc3NAEArfBFCuC8wkO0ICCGkQ83NzXBzc7vlMVQjawF6vR7l5eVwcXEBj8ez6GPJZDIEBwejpKSE6nFBr8f16PVoj16Pq+i1aI9ej/bo9WiPXo/2LP16MAyD5uZmBAYGgs+/dRUsjchaAJ/PR69evaz6mK6urvTLdQ16Pdqj16M9ej2uoteiPXo92qPXoz16Pdqz5Otxu5FYI5rsRQghhBBCbBIlsoQQQgghxCZRImvjJBIJVqxYAYlEwnYonECvR3v0erRHr8dV9Fq0R69He/R6tEevR3tcej1oshchhBBCCLFJNCJLCCGEEEJsEiWyhBBCCCHEJlEiSwghhBBCbBIlsoQQQgghxCZRImvjPvvsM4SFhcHBwQGJiYk4deoU2yFZ3MqVKzF06FC4uLjA19cXM2fORF5eXrtjxo0bBx6P12577rnnWIrYst55550bnmt0dLTpeqVSiUWLFsHLywvOzs647777UFVVxWLElhUWFnbD68Hj8bBo0SIAPf+9cfjwYdx9990IDAwEj8fDtm3b2l3PMAzefvttBAQEwNHREUlJSbh06VK7Y+rr6/HII4/A1dUV7u7ueOqpp9DS0mLFZ2E+t3o9NBoNXnvtNfTv3x9OTk4IDAzE448/jvLy8nb30dF76oMPPrDyM7lzt3tvzJs374bnOWXKlHbH2Mt7A0CHf0d4PB5Wr15tOqanvDeAzn22dubzpLi4GNOnT4dUKoWvry9eeeUVaLVai8VNiawN27x5M5YuXYoVK1YgLS0NCQkJSE5ORnV1NduhWdShQ4ewaNEinDhxAnv37oVGo8HkyZMhl8vbHbdgwQJUVFSYtlWrVrEUseXFxsa2e65Hjx41XffSSy/hjz/+wJYtW3Do0CGUl5dj9uzZLEZrWadPn273WuzduxcAMGfOHNMxPfm9IZfLkZCQgM8++6zD61etWoVPPvkE69atw8mTJ+Hk5ITk5GQolUrTMY888giysrKwd+9e/Pnnnzh8+DCeeeYZaz0Fs7rV66FQKJCWloa33noLaWlp+PXXX5GXl4d77rnnhmPfe++9du+ZF154wRrhm9Xt3hsAMGXKlHbP86effmp3vb28NwC0ex0qKiqwfv168Hg83Hfffe2O6wnvDaBzn623+zzR6XSYPn061Go1jh8/jg0bNuDbb7/F22+/bbnAGWKzhg0bxixatMj0s06nYwIDA5mVK1eyGJX1VVdXMwCYQ4cOmfaNHTuWWbx4MXtBWdGKFSuYhISEDq9rbGxkRCIRs2XLFtO+nJwcBgCTmppqpQjZtXjxYqZ3796MXq9nGMa+3hsAmN9++830s16vZ/z9/ZnVq1eb9jU2NjISiYT56aefGIZhmOzsbAYAc/r0adMxf/31F8Pj8ZiysjKrxW4J178eHTl16hQDgCkqKjLtCw0NZf71r39ZNjgr6+i1eOKJJ5h77733prex9/fGvffey0yYMKHdvp743jC6/rO1M58nO3fuZPh8PlNZWWk65osvvmBcXV0ZlUplkThpRNZGqdVqnD17FklJSaZ9fD4fSUlJSE1NZTEy62tqagIAeHp6ttv/448/wtvbG3FxcVi+fDkUCgUb4VnFpUuXEBgYiIiICDzyyCMoLi4GAJw9exYajabd+yQ6OhohISF28T5Rq9X44Ycf8OSTT4LH45n229N741oFBQWorKxs935wc3NDYmKi6f2QmpoKd3d3DBkyxHRMUlIS+Hw+Tp48afWYra2pqQk8Hg/u7u7t9n/wwQfw8vLCwIEDsXr1aoueKmXTwYMH4evri6ioKCxcuBB1dXWm6+z5vVFVVYUdO3bgqaeeuuG6nvreuP6ztTOfJ6mpqejfvz/8/PxMxyQnJ0MmkyErK8sicQotcq/E4mpra6HT6dq9WQDAz88Pubm5LEVlfXq9HkuWLMGoUaMQFxdn2j937lyEhoYiMDAQmZmZeO2115CXl4dff/2VxWgtIzExEd9++y2ioqJQUVGBd999F6NHj8aFCxdQWVkJsVh8w4eyn58fKisr2QnYirZt24bGxkbMmzfPtM+e3hvXM/6fd/R3w3hdZWUlfH19210vFArh6enZ498zSqUSr732Gh5++GG4urqa9r/44osYNGgQPD09cfz4cSxfvhwVFRVYu3Yti9Ga35QpUzB79myEh4fj8uXL+Pvf/46pU6ciNTUVAoHArt8bGzZsgIuLyw1lWT31vdHRZ2tnPk8qKys7/PtivM4SKJElNm3RokW4cOFCu5pQAO1qtvr374+AgABMnDgRly9fRu/eva0dpkVNnTrVdDk+Ph6JiYkIDQ3Fzz//DEdHRxYjY9/XX3+NqVOnIjAw0LTPnt4bpPM0Gg0eeOABMAyDL774ot11S5cuNV2Oj4+HWCzGs88+i5UrV3JiiU5zeeihh0yX+/fvj/j4ePTu3RsHDx7ExIkTWYyMfevXr8cjjzwCBweHdvt76nvjZp+tXESlBTbK29sbAoHghtmCVVVV8Pf3Zykq63r++efx559/4sCBA+jVq9ctj01MTAQA5OfnWyM0Vrm7u6Nv377Iz8+Hv78/1Go1Ghsb2x1jD++ToqIi7Nu3D08//fQtj7On94bx//xWfzf8/f1vmDCq1WpRX1/fY98zxiS2qKgIe/fubTca25HExERotVoUFhZaJ0CWREREwNvb2/S7YY/vDQA4cuQI8vLybvu3BOgZ742bfbZ25vPE39+/w78vxussgRJZGyUWizF48GCkpKSY9un1eqSkpGDEiBEsRmZ5DMPg+eefx2+//Yb9+/cjPDz8trdJT08HAAQEBFg4Ova1tLTg8uXLCAgIwODBgyESidq9T/Ly8lBcXNzj3yfffPMNfH19MX369FseZ0/vjfDwcPj7+7d7P8hkMpw8edL0fhgxYgQaGxtx9uxZ0zH79++HXq83Jf09iTGJvXTpEvbt2wcvL6/b3iY9PR18Pv+G0+w9TWlpKerq6ky/G/b23jD6+uuvMXjwYCQkJNz2WFt+b9zus7UznycjRozA+fPn233hMX457Nevn8UCJzZq06ZNjEQiYb799lsmOzubeeaZZxh3d/d2swV7ooULFzJubm7MwYMHmYqKCtOmUCgYhmGY/Px85r333mPOnDnDFBQUMNu3b2ciIiKYMWPGsBy5ZSxbtow5ePAgU1BQwBw7doxJSkpivL29merqaoZhGOa5555jQkJCmP379zNnzpxhRvx/O/cWElW7x3H8N281OsM0r41OByynIC+kJDIpRJBgwvQmUyiRwJIIIqKbEonoXBJBB/AiokgCuwii8iY64qBhCoWHi0BQFA28qEgdyXP/fbF3gnTa7XfLtOr7gbmYWWs9/J+HZ9b68aw1k5VlWVlZMa56dk1NTVlKSopVVFTM+PxPmBvRaNRaWlqspaXFJNnFixetpaVl+lf4586ds4SEBKutrbX29nYrKCiwFStW2MjIyHQbeXl5tnbtWmtubrbnz59bamqqlZSUxKpL/8j3xmN8fNy2bNliS5cutdbW1hnnk8+/sG5sbLRLly5Za2urdXV1WU1NjQWDQSstLY1xz37e98YiGo3aoUOH7MWLF9bd3W1Pnz61jIwMS01NtdHR0ek2/pS58dng4KB5vV67cuXKF8f/TnPD7MfXVrMfX08mJydt9erVlpuba62trfbw4UMLBoN2+PDhWaubIOtwVVVVlpKSYm6329avX29NTU2xLmnWSfrqq7q62szMent7LScnxwKBgMXFxdnKlSutvLzcBgcHY1v4LCkuLrYlS5aY2+225ORkKy4uts7OzuntIyMjtm/fPluwYIF5vV4rLCy0/v7+GFY8+x49emSSrKOjY8bnf8LcqKur++r3Y+fOnWb277/gOnr0qC1atMji4uIsHA5/MU7v37+3kpIS8/l85vf7rayszKLRaAx68899bzy6u7u/eT6pq6szM7NXr17Zhg0b7O+//7b4+HhLS0uzysrKGeHOKb43Fh8/frTc3FwLBoM2b948C4VCtmfPni8WRv6UufHZ1atXzePx2MDAwBfH/05zw+zH11az/+560tPTY/n5+ebxeCwpKckOHjxoExMTs1a36z/FAwAAAI7CM7IAAABwJIIsAAAAHIkgCwAAAEciyAIAAMCRCLIAAABwJIIsAAAAHIkgCwAAAEciyAIAAMCRCLIAAABwJIIsAPymdu3apa1bt8a6DACYNQRZAAAAOBJBFgAc7s6dO0pPT5fH41FiYqI2bdqk8vJy3bx5U7W1tXK5XHK5XIpEIpKkvr4+bd++XQkJCQoEAiooKFBPT890e59Xck+ePKlgMCi/36+9e/dqfHw8Nh0EgG+YG+sCAAD/u/7+fpWUlOj8+fMqLCxUNBpVQ0ODSktL1dvbq6GhIVVXV0uSAoGAJiYmtHnzZmVlZamhoUFz587VmTNnlJeXp/b2drndbknSs2fPFB8fr0gkop6eHpWVlSkxMVFnz56NZXcBYAaCLAA4WH9/vyYnJ1VUVKRQKCRJSk9PlyR5PB6NjY1p8eLF0/vX1NTo06dPun79ulwulySpurpaCQkJikQiys3NlSS53W7duHFDXq9Xq1at0qlTp1ReXq7Tp0/rr7+4mQfg18DZCAAcbM2aNQqHw0pPT9e2bdt07do1ffjw4Zv7t7W1qbOzU/Pnz5fP55PP51MgENDo6Ki6urpmtOv1eqffZ2VlaXh4WH19fbPaHwD4GazIAoCDzZkzR0+ePFFjY6MeP36sqqoqHTlyRM3NzV/df3h4WOvWrdOtW7e+2BYMBme7XAD4vyLIAoDDuVwuZWdnKzs7W8eOHVMoFNK9e/fkdrs1NTU1Y9+MjAzdvn1bCxculN/v/2abbW1tGhkZkcfjkSQ1NTXJ5/Np2bJls9oXAPgZPFoAAA7W3NysyspKvXz5Ur29vbp7967evn2rtLQ0LV++XO3t7ero6NC7d+80MTGhHTt2KCkpSQUFBWpoaFB3d7cikYgOHDigN2/eTLc7Pj6u3bt36/Xr13rw4IGOHz+u/fv383wsgF8KK7IA4GB+v1/19fW6fPmyhoaGFAqFdOHCBeXn5yszM1ORSESZmZkaHh5WXV2dNm7cqPr6elVUVKioqEjRaFTJyckKh8MzVmjD4bBSU1OVk5OjsbExlZSU6MSJE7HrKAB8hcvMLNZFAAB+Hbt27dLAwIDu378f61IA4Lu4RwQAAABHIsgCAADAkXi0AAAAAI7EiiwAAAAciSALAAAARyLIAgAAwJEIsgAAAHAkgiwAAAAciSALAAAARyLIAgAAwJEIsgAAAHCkfwE3VJJWZNOx2gAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "data = X.data.reset_index(drop=True)\n", "theta = np.arctan2(data[\"sin_theta\"], data[\"cos_theta\"])\n", @@ -523,14138 +242,10 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "4059503f", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
\n", - " \n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - "
\n", - "
\n", - "\n", - "\n", - "\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "fig_anim, ax_anim = plt.subplots(figsize=(4, 4))\n", "ax_anim.axis(\"off\")\n",