From 11b8202afbba7c8ddd84cc212dc1758a789bfe64 Mon Sep 17 00:00:00 2001 From: XiangweiW <517395458@qq.com> Date: Mon, 23 Oct 2023 21:03:20 +0800 Subject: [PATCH 01/41] Implementing parallel learning on BOPTEST-gym --- README.md | 21 ++++++++ generateDockerComposeYml.py | 79 +++++++++++++++++++++++++++ parallel_BOPTESTgymTrain.py | 103 ++++++++++++++++++++++++++++++++++++ 3 files changed, 203 insertions(+) create mode 100644 generateDockerComposeYml.py create mode 100644 parallel_BOPTESTgymTrain.py diff --git a/README.md b/README.md index 40911f3..3650ece 100644 --- a/README.md +++ b/README.md @@ -75,6 +75,27 @@ Running BOPTEST locally is substantially faster 2) Run a BOPTEST case with the building emulator model to be controlled (instructions [here](https://github.com/ibpsa/project1-boptest/blob/master/README.md)). 3) Check out the `master` branch of this repository and run the example above replacing the url to be `url = 'http://127.0.0.1:5000'` and avoiding the `testcase` argument to the `BoptestGymEnv` class. +## Parallel-Start (running BOPTEST locally) + +To facilitate the training and testing process, we provide scripts that automates the deployment of multiple BOPTEST instances using Docker Compose. The deployment dynamically checks for available ports, generates a Docker Compose YAML file, and takes care of naming conflicts to ensure smooth deployment. + +### Usage + +1. Specify the BOPTEST root directory either by passing it as a command-line argument or by defining the `boptest_root` variable at the beginning of the script `generateDockerComposeYml.py`. The script prioritizes the command-line argument if provided. + +Example using command-line argument: + +```bash +python generateDockerComposeYml.py absolute_boptest_root_dir +``` + +2. Train the BOPTEST-gym environment in parallel either by passing it as a command-line argument or by defining the `boptest_root` variable at the beginning of the script `parallel_BOPTESTgymTrain.py`. The script prioritizes the command-line argument if provided. + +Example using command-line argument: + +```bash +python parallel_BOPTESTgymTrain.py absolute_boptest_root_dir +``` ## Citing the project diff --git a/generateDockerComposeYml.py b/generateDockerComposeYml.py new file mode 100644 index 0000000..07f0b33 --- /dev/null +++ b/generateDockerComposeYml.py @@ -0,0 +1,79 @@ +import os +import socket +import shutil +import yaml +import sys + + +boptest_root = "./" # You can define boptest_root_dir here when use IDLE + +# Get the argument from command line when use Linux +if len(sys.argv) >= 2: + boptest_root_dir = sys.argv[1] +else: + boptest_root_dir = boptest_root + +num_services = 15 # Total Services needed +base_port = 5000 # Start Port number + + +# Function to check if a port is available +def is_port_available(port): + with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock: + return sock.connect_ex(('localhost', port)) != 0 + + +services = {} +last_assigned_port = base_port - 1 # Initial value set to one less than the first port to be checked +for _ in range(num_services): + port = last_assigned_port + 1 # Start checking from the next port after the last assigned one + + # If the port is unavailable, continue to check the next one + while not is_port_available(port): + print(f"Port {port} is occupied.") + port += 1 + if port > base_port + num_services: + raise Exception("Too many ports are occupied.") + + last_assigned_port = port # Update the last assigned port + + service_name = f"boptest{port}" + service_config = { + "image": "boptest_base", + "build": {"context": "."}, + "volumes": [ + "./testcases/${TESTCASE}/models/wrapped.fmu:${APP_PATH}/models/wrapped.fmu", + "./testcases/${TESTCASE}/doc/:${APP_PATH}/doc/", + "./restapi.py:${APP_PATH}/restapi.py", + "./testcase.py:${APP_PATH}/testcase.py", + "./version.txt:${APP_PATH}/version.txt", + "./data:${APP_PATH}/data/", + "./forecast:${APP_PATH}/forecast/", + "./kpis:${APP_PATH}/kpis/", + ], + "ports": [f"127.0.0.1:{port}:5000"], + "networks": ["boptest-net"], + "restart": "on-failure" # restart on-failure + } + services[service_name] = service_config + +docker_compose_content = { + "version": "3.7", + "services": services, + "networks": { + "boptest-net": { + "name": "boptest-net", + "attachable": True, + } + }, +} + +# Check whether the docker-compose.yml file exists in the BOPTEST root directory +docker_compose_path = os.path.join(boptest_root_dir, 'docker-compose.yml') +if os.path.exists(docker_compose_path): + # If it exists, rename to docker-compose_origin.yml + shutil.move(docker_compose_path, os.path.join(boptest_root_dir, 'docker-compose_origin.yml')) + +# Create a new docker-compose.yml file in the BOPTEST root directory +with open(docker_compose_path, "w") as file: + yaml.dump(docker_compose_content, file, default_flow_style=False) diff --git a/parallel_BOPTESTgymTrain.py b/parallel_BOPTESTgymTrain.py new file mode 100644 index 0000000..fd6ea68 --- /dev/null +++ b/parallel_BOPTESTgymTrain.py @@ -0,0 +1,103 @@ +import os +import sys +import yaml +import torch + +from stable_baselines3 import DQN, PPO, DDPG, SAC, TD3, A2C +from stable_baselines3.common.vec_env import SubprocVecEnv +from stable_baselines3.common.callbacks import EvalCallback +from boptestGymEnv import BoptestGymEnv, NormalizedObservationWrapper, DiscretizedActionWrapper + + +boptest_root = "./" # You can define boptest_root_dir here when use IDLE + +# Get the argument from command line when use Linux +if len(sys.argv) >= 2: + boptest_root_dir = sys.argv[1] +else: + boptest_root_dir = boptest_root + +docker_compose_loc = os.path.join(boptest_root_dir, "docker-compose.yml") + +# Read the docker-compose.yml file +with open(docker_compose_loc, 'r') as stream: + try: + docker_compose_data = yaml.safe_load(stream) + services = docker_compose_data.get('services', {}) + + # Extract the port and URL of the service + urls = [] + for service, config in services.items(): + ports = config.get('ports', []) + for port in ports: + # Extract host port + host_port = port.split(':')[1] + urls.append(f'http://127.0.0.1:{host_port}') + + print(urls) # Print URLs + + except yaml.YAMLError as exc: + print(exc) + + +# Create a function to initialize the environment +def make_env(url): + def _init(): + env = BoptestGymEnv( + url=url, + actions=['oveHeaPumY_u'], + observations={ + 'time': (0, 604800), + 'reaTZon_y': (280., 310.), + 'TDryBul': (265, 303), + 'HDirNor': (0, 862), + 'InternalGainsRad[1]': (0, 219), + 'PriceElectricPowerHighlyDynamic': (-0.4, 0.4), + 'LowerSetp[1]': (280., 310.), + 'UpperSetp[1]': (280., 310.) + }, + scenario={'electricity_price': 'dynamic'}, + predictive_period=24 * 3600, + regressive_period=6 * 3600, + random_start_time=True, + excluding_periods=[(16 * 24 * 3600, 30 * 24 * 3600), (108 * 24 * 3600, 122 * 24 * 3600)], + max_episode_length=14 * 24 * 3600, + warmup_period=24 * 3600, + step_period=15 * 60 + ) + env = NormalizedObservationWrapper(env) # Add observation normalization if needed + env = DiscretizedActionWrapper(env, n_bins_act=10) # Add action discretization if needed + + return env + + return _init + + +if __name__ == '__main__': + # Use URLs obtained from docker-compose.yml + if urls: # Make sure the urls list is not empty + envs = [make_env(url) for url in urls] + + # Create a parallel environment using SubprocVecEnv + vec_env = SubprocVecEnv(envs) + + # Example: Create a DQN model + log_dir = "./vec_dqn_log/" + eval_callback = EvalCallback(vec_env, best_model_save_path=log_dir, log_path=log_dir, eval_freq=5000) + + device = 'cuda' if torch.cuda.is_available() else 'cpu' + + # Instantiate an RL agent with DQN + model = DQN('MlpPolicy', vec_env, verbose=1, gamma=0.99, learning_rate=5e-4, + batch_size=24, seed=123456, buffer_size=365 * 24, + learning_starts=24, train_freq=1, exploration_initial_eps=1.0, + exploration_final_eps=0.01, exploration_fraction=0.1, tensorboard_log=log_dir, device=device) + # Main training loop + model.learn(total_timesteps=500000, callback=eval_callback) + else: + print("No URLs found. Please check your docker-compose.yml file.") + + + + + From dbd440d32929e63a0f742bc43fa645b07fc0936d Mon Sep 17 00:00:00 2001 From: XiangweiW <86037302+XiangweiW@users.noreply.github.com> Date: Mon, 23 Oct 2023 21:13:04 +0800 Subject: [PATCH 02/41] Update README.md --- README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 3650ece..65620cc 100644 --- a/README.md +++ b/README.md @@ -77,11 +77,11 @@ Running BOPTEST locally is substantially faster ## Parallel-Start (running BOPTEST locally) -To facilitate the training and testing process, we provide scripts that automates the deployment of multiple BOPTEST instances using Docker Compose. The deployment dynamically checks for available ports, generates a Docker Compose YAML file, and takes care of naming conflicts to ensure smooth deployment. +To facilitate the training and testing process, we provide scripts that automate the deployment of multiple BOPTEST instances using Docker Compose and then train the BOPTEST-gym environment in parallel. The deployment dynamically checks for available ports, generates a Docker Compose YAML file, and takes care of naming conflicts to ensure smooth deployment. ### Usage -1. Specify the BOPTEST root directory either by passing it as a command-line argument or by defining the `boptest_root` variable at the beginning of the script `generateDockerComposeYml.py`. The script prioritizes the command-line argument if provided. +1. Specify the BOPTEST root directory either by passing it as a command-line argument or by defining the `boptest_root` variable at the beginning of the script `generateDockerComposeYml.py`. The script prioritizes the command-line argument if provided. Users are allowed to change the Start Port number and Total Services as needed. Example using command-line argument: @@ -89,7 +89,7 @@ Example using command-line argument: python generateDockerComposeYml.py absolute_boptest_root_dir ``` -2. Train the BOPTEST-gym environment in parallel either by passing it as a command-line argument or by defining the `boptest_root` variable at the beginning of the script `parallel_BOPTESTgymTrain.py`. The script prioritizes the command-line argument if provided. +2. Train the BOPTEST-gym environment in parallel either by passing it as a command-line argument or by defining the `boptest_root` variable at the beginning of the script `parallel_BOPTESTgymTrain.py`. The script prioritizes the command-line argument if provided. Users are allowed to change the initial conditions, algorithms and hyperparameters. Example using command-line argument: From aacb4786fcc03d60b509aacb20d9991ec983ce25 Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Tue, 14 Nov 2023 09:59:15 +0100 Subject: [PATCH 03/41] Remove tensorboard dependency. --- parallel_BOPTESTgymTrain.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/parallel_BOPTESTgymTrain.py b/parallel_BOPTESTgymTrain.py index fd6ea68..5235301 100644 --- a/parallel_BOPTESTgymTrain.py +++ b/parallel_BOPTESTgymTrain.py @@ -91,7 +91,7 @@ def _init(): model = DQN('MlpPolicy', vec_env, verbose=1, gamma=0.99, learning_rate=5e-4, batch_size=24, seed=123456, buffer_size=365 * 24, learning_starts=24, train_freq=1, exploration_initial_eps=1.0, - exploration_final_eps=0.01, exploration_fraction=0.1, tensorboard_log=log_dir, device=device) + exploration_final_eps=0.01, exploration_fraction=0.1, device=device) # Main training loop model.learn(total_timesteps=500000, callback=eval_callback) else: From f52585e4385933a447c1826b8b001c93f146b929 Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Tue, 14 Nov 2023 10:39:19 +0100 Subject: [PATCH 04/41] Do not import agents not used. --- parallel_BOPTESTgymTrain.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/parallel_BOPTESTgymTrain.py b/parallel_BOPTESTgymTrain.py index 5235301..43ba3a2 100644 --- a/parallel_BOPTESTgymTrain.py +++ b/parallel_BOPTESTgymTrain.py @@ -3,7 +3,7 @@ import yaml import torch -from stable_baselines3 import DQN, PPO, DDPG, SAC, TD3, A2C +from stable_baselines3 import DQN from stable_baselines3.common.vec_env import SubprocVecEnv from stable_baselines3.common.callbacks import EvalCallback from boptestGymEnv import BoptestGymEnv, NormalizedObservationWrapper, DiscretizedActionWrapper From b240c556012e50fb1da0e87f0e5cbdce814a616e Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Tue, 14 Nov 2023 10:42:13 +0100 Subject: [PATCH 05/41] Use new logging functionality. --- parallel_BOPTESTgymTrain.py | 28 +++++++++++++++++++++------- 1 file changed, 21 insertions(+), 7 deletions(-) diff --git a/parallel_BOPTESTgymTrain.py b/parallel_BOPTESTgymTrain.py index 43ba3a2..142723c 100644 --- a/parallel_BOPTESTgymTrain.py +++ b/parallel_BOPTESTgymTrain.py @@ -3,10 +3,13 @@ import yaml import torch +from testing import utilities from stable_baselines3 import DQN from stable_baselines3.common.vec_env import SubprocVecEnv from stable_baselines3.common.callbacks import EvalCallback -from boptestGymEnv import BoptestGymEnv, NormalizedObservationWrapper, DiscretizedActionWrapper +from stable_baselines3.common.vec_env.vec_monitor import VecMonitor +from stable_baselines3.common.logger import configure +from boptestGymEnv import BoptestGymEnv, NormalizedObservationWrapper, DiscretizedActionWrapper, SaveAndTestCallback boptest_root = "./" # You can define boptest_root_dir here when use IDLE @@ -39,7 +42,6 @@ except yaml.YAMLError as exc: print(exc) - # Create a function to initialize the environment def make_env(url): def _init(): @@ -81,10 +83,17 @@ def _init(): # Create a parallel environment using SubprocVecEnv vec_env = SubprocVecEnv(envs) - # Example: Create a DQN model - log_dir = "./vec_dqn_log/" - eval_callback = EvalCallback(vec_env, best_model_save_path=log_dir, log_path=log_dir, eval_freq=5000) - + # Define logging directory. Monitoring data and agent model will be stored here + log_dir = os.path.join(utilities.get_root_path(), 'examples', 'agents', 'DQN_parallel') + os.makedirs(log_dir, exist_ok=True) + + # Modify the environment to include the callback + vec_env = VecMonitor(venv=vec_env, filename=os.path.join(log_dir,'monitor.csv')) + + # Create the callback: check every 100 steps. We keep it very short for testing + eval_callback = EvalCallback(vec_env, best_model_save_path=log_dir, log_path=log_dir, eval_freq=100) + + # Try to find CUDA core since it's optimized for parallel computing tasks device = 'cuda' if torch.cuda.is_available() else 'cpu' # Instantiate an RL agent with DQN @@ -92,8 +101,13 @@ def _init(): batch_size=24, seed=123456, buffer_size=365 * 24, learning_starts=24, train_freq=1, exploration_initial_eps=1.0, exploration_final_eps=0.01, exploration_fraction=0.1, device=device) + + # set up logger + new_logger = configure(log_dir, ['csv']) + model.set_logger(new_logger) + # Main training loop - model.learn(total_timesteps=500000, callback=eval_callback) + model.learn(total_timesteps=500, callback=eval_callback) else: print("No URLs found. Please check your docker-compose.yml file.") From bd5ddb204b2763ccdb652f3957d90a4c900704e8 Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Tue, 14 Nov 2023 11:53:43 +0100 Subject: [PATCH 06/41] Reduce default number of services. --- generateDockerComposeYml.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/generateDockerComposeYml.py b/generateDockerComposeYml.py index 07f0b33..02bdef4 100644 --- a/generateDockerComposeYml.py +++ b/generateDockerComposeYml.py @@ -13,7 +13,7 @@ else: boptest_root_dir = boptest_root -num_services = 15 # Total Services needed +num_services = 2 # Total Services needed base_port = 5000 # Start Port number From 178d6b84744e7f2af0c0458a881c17d34f35e193 Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Tue, 14 Nov 2023 11:59:12 +0100 Subject: [PATCH 07/41] Rename header in README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index ae1e184..33e31cb 100644 --- a/README.md +++ b/README.md @@ -75,7 +75,7 @@ Running BOPTEST locally is substantially faster 2) Run a BOPTEST case with the building emulator model to be controlled (instructions [here](https://github.com/ibpsa/project1-boptest/blob/master/README.md)). 3) Check out the `master` branch of this repository and run the example above replacing the url to be `url = 'http://127.0.0.1:5000'` and avoiding the `testcase` argument to the `BoptestGymEnv` class. -## Parallel-Start (running BOPTEST locally) +## Quick-Start (running BOPTEST locally with parallel training) To facilitate the training and testing process, we provide scripts that automate the deployment of multiple BOPTEST instances using Docker Compose and then train the BOPTEST-gym environment in parallel. The deployment dynamically checks for available ports, generates a Docker Compose YAML file, and takes care of naming conflicts to ensure smooth deployment. From d1985eba4d136845da163ad9b63447a03ffbc057 Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Tue, 14 Nov 2023 12:01:04 +0100 Subject: [PATCH 08/41] Move parallel script to examples. --- .../parallel_BOPTESTgymTrain.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename parallel_BOPTESTgymTrain.py => examples/parallel_BOPTESTgymTrain.py (100%) diff --git a/parallel_BOPTESTgymTrain.py b/examples/parallel_BOPTESTgymTrain.py similarity index 100% rename from parallel_BOPTESTgymTrain.py rename to examples/parallel_BOPTESTgymTrain.py From 757cb610ec5d68aa6043a917f529bea900e4a965 Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Tue, 14 Nov 2023 12:01:30 +0100 Subject: [PATCH 09/41] Rename script. --- examples/{parallel_BOPTESTgymTrain.py => run_parallel.py} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename examples/{parallel_BOPTESTgymTrain.py => run_parallel.py} (100%) diff --git a/examples/parallel_BOPTESTgymTrain.py b/examples/run_parallel.py similarity index 100% rename from examples/parallel_BOPTESTgymTrain.py rename to examples/run_parallel.py From b0d11bd8bc236daf58471368a96c64883a765cc1 Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Tue, 14 Nov 2023 12:32:37 +0100 Subject: [PATCH 10/41] Fix evaluation period and add clarifying note. --- examples/run_parallel.py | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/examples/run_parallel.py b/examples/run_parallel.py index 142723c..dedbc0b 100644 --- a/examples/run_parallel.py +++ b/examples/run_parallel.py @@ -90,8 +90,12 @@ def _init(): # Modify the environment to include the callback vec_env = VecMonitor(venv=vec_env, filename=os.path.join(log_dir,'monitor.csv')) - # Create the callback: check every 100 steps. We keep it very short for testing - eval_callback = EvalCallback(vec_env, best_model_save_path=log_dir, log_path=log_dir, eval_freq=100) + # Create the callback: evaluate with one episode after 100 steps for training. We keep it very short for testing. + # When using multiple environments, each call to ``env.step()`` will effectively correspond to ``n_envs`` steps. + # To account for that, you can use ``eval_freq = eval_freq/len(envs)`` + eval_freq = 100 + eval_callback = EvalCallback(vec_env, best_model_save_path=log_dir, log_path=log_dir, + eval_freq=int(eval_freq/len(envs)), n_eval_episodes=1, deterministic=True) # Try to find CUDA core since it's optimized for parallel computing tasks device = 'cuda' if torch.cuda.is_available() else 'cpu' @@ -107,7 +111,7 @@ def _init(): model.set_logger(new_logger) # Main training loop - model.learn(total_timesteps=500, callback=eval_callback) + model.learn(total_timesteps=100, callback=eval_callback) else: print("No URLs found. Please check your docker-compose.yml file.") From 991d571fb0cb580d4316371eaa4c6360e246410c Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Tue, 14 Nov 2023 12:41:10 +0100 Subject: [PATCH 11/41] Set random seed in script. --- examples/run_parallel.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/examples/run_parallel.py b/examples/run_parallel.py index dedbc0b..7568927 100644 --- a/examples/run_parallel.py +++ b/examples/run_parallel.py @@ -2,6 +2,7 @@ import sys import yaml import torch +import random from testing import utilities from stable_baselines3 import DQN @@ -11,6 +12,10 @@ from stable_baselines3.common.logger import configure from boptestGymEnv import BoptestGymEnv, NormalizedObservationWrapper, DiscretizedActionWrapper, SaveAndTestCallback +seed = 123456 + +# Seed for random starting times of episodes +random.seed(seed) boptest_root = "./" # You can define boptest_root_dir here when use IDLE From 8c67c6bfa71d09c26c8de27afb141104408bd445 Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Tue, 14 Nov 2023 12:41:58 +0100 Subject: [PATCH 12/41] Reduce max_episode_length of example for shorter evaluation time during testing. --- examples/run_parallel.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/run_parallel.py b/examples/run_parallel.py index 7568927..4555f63 100644 --- a/examples/run_parallel.py +++ b/examples/run_parallel.py @@ -68,7 +68,7 @@ def _init(): regressive_period=6 * 3600, random_start_time=True, excluding_periods=[(16 * 24 * 3600, 30 * 24 * 3600), (108 * 24 * 3600, 122 * 24 * 3600)], - max_episode_length=14 * 24 * 3600, + max_episode_length=24 * 3600, warmup_period=24 * 3600, step_period=15 * 60 ) From 963085f73deaf44e4b6e904e59e6de7316147c9b Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Tue, 14 Nov 2023 14:41:00 +0100 Subject: [PATCH 13/41] Remove not used callback. --- examples/run_parallel.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/run_parallel.py b/examples/run_parallel.py index 4555f63..adaaa26 100644 --- a/examples/run_parallel.py +++ b/examples/run_parallel.py @@ -10,7 +10,7 @@ from stable_baselines3.common.callbacks import EvalCallback from stable_baselines3.common.vec_env.vec_monitor import VecMonitor from stable_baselines3.common.logger import configure -from boptestGymEnv import BoptestGymEnv, NormalizedObservationWrapper, DiscretizedActionWrapper, SaveAndTestCallback +from boptestGymEnv import BoptestGymEnv, NormalizedObservationWrapper, DiscretizedActionWrapper seed = 123456 From d577d83e8a39e5d1670f864df1f2bd91f1a3228c Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Tue, 14 Nov 2023 14:45:09 +0100 Subject: [PATCH 14/41] Insert functionality in generate_urls_from_yml method. --- examples/run_parallel.py | 63 ++++++++++++++++++++++++++-------------- 1 file changed, 42 insertions(+), 21 deletions(-) diff --git a/examples/run_parallel.py b/examples/run_parallel.py index adaaa26..5a37f24 100644 --- a/examples/run_parallel.py +++ b/examples/run_parallel.py @@ -25,27 +25,47 @@ else: boptest_root_dir = boptest_root -docker_compose_loc = os.path.join(boptest_root_dir, "docker-compose.yml") -# Read the docker-compose.yml file -with open(docker_compose_loc, 'r') as stream: - try: - docker_compose_data = yaml.safe_load(stream) - services = docker_compose_data.get('services', {}) - - # Extract the port and URL of the service - urls = [] - for service, config in services.items(): - ports = config.get('ports', []) - for port in ports: - # Extract host port - host_port = port.split(':')[1] - urls.append(f'http://127.0.0.1:{host_port}') - - print(urls) # Print URLs - - except yaml.YAMLError as exc: - print(exc) +def generate_urls_from_yml(boptest_root_dir=boptest_root_dir): + '''Method that returns as many urls for BOPTEST-Gym environments + as those specified at the BOPTEST `docker-compose.yml` file. + It assumes that `generateDockerComposeYml.py` has been called first. + + Parameters + ---------- + boptest_root_dir: str + String with directory to BOPTEST where the `docker-compose.yml` + file should be located. + + Returns + ------- + urls: list + List of urls where BOPTEST test cases will be allocated. + + ''' + docker_compose_loc = os.path.join(boptest_root_dir, "docker-compose.yml") + + # Read the docker-compose.yml file + with open(docker_compose_loc, 'r') as stream: + try: + docker_compose_data = yaml.safe_load(stream) + services = docker_compose_data.get('services', {}) + + # Extract the port and URL of the service + urls = [] + for service, config in services.items(): + ports = config.get('ports', []) + for port in ports: + # Extract host port + host_port = port.split(':')[1] + urls.append(f'http://127.0.0.1:{host_port}') + + print(urls) # Print URLs + + except yaml.YAMLError as exc: + print(exc) + + return urls # Create a function to initialize the environment def make_env(url): @@ -82,6 +102,7 @@ def _init(): if __name__ == '__main__': # Use URLs obtained from docker-compose.yml + urls = generate_urls_from_yml(boptest_root_dir) if urls: # Make sure the urls list is not empty envs = [make_env(url) for url in urls] @@ -89,7 +110,7 @@ def _init(): vec_env = SubprocVecEnv(envs) # Define logging directory. Monitoring data and agent model will be stored here - log_dir = os.path.join(utilities.get_root_path(), 'examples', 'agents', 'DQN_parallel') + log_dir = os.path.join(utilities.get_root_path(), 'examples', 'agents', 'DQN_vectorized') os.makedirs(log_dir, exist_ok=True) # Modify the environment to include the callback From c7b08e14d545fd9a9abf1ff57ccef82e61c4415d Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Tue, 14 Nov 2023 14:46:09 +0100 Subject: [PATCH 15/41] Rename to vectorized. --- examples/{run_parallel.py => run_vectorized.py} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename examples/{run_parallel.py => run_vectorized.py} (100%) diff --git a/examples/run_parallel.py b/examples/run_vectorized.py similarity index 100% rename from examples/run_parallel.py rename to examples/run_vectorized.py From cff2e097cf0fe94116daacfb4443685df107a2f1 Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Tue, 14 Nov 2023 14:48:57 +0100 Subject: [PATCH 16/41] Do not check for empty list. --- examples/run_vectorized.py | 69 +++++++++++++++++++------------------- 1 file changed, 34 insertions(+), 35 deletions(-) diff --git a/examples/run_vectorized.py b/examples/run_vectorized.py index 5a37f24..2f1a291 100644 --- a/examples/run_vectorized.py +++ b/examples/run_vectorized.py @@ -103,43 +103,42 @@ def _init(): if __name__ == '__main__': # Use URLs obtained from docker-compose.yml urls = generate_urls_from_yml(boptest_root_dir) - if urls: # Make sure the urls list is not empty - envs = [make_env(url) for url in urls] - # Create a parallel environment using SubprocVecEnv - vec_env = SubprocVecEnv(envs) - - # Define logging directory. Monitoring data and agent model will be stored here - log_dir = os.path.join(utilities.get_root_path(), 'examples', 'agents', 'DQN_vectorized') - os.makedirs(log_dir, exist_ok=True) + envs = [make_env(url) for url in urls] + + # Create a parallel environment using SubprocVecEnv + vec_env = SubprocVecEnv(envs) + + # Define logging directory. Monitoring data and agent model will be stored here + log_dir = os.path.join(utilities.get_root_path(), 'examples', 'agents', 'DQN_vectorized') + os.makedirs(log_dir, exist_ok=True) + + # Modify the environment to include the callback + vec_env = VecMonitor(venv=vec_env, filename=os.path.join(log_dir,'monitor.csv')) + + # Create the callback: evaluate with one episode after 100 steps for training. We keep it very short for testing. + # When using multiple environments, each call to ``env.step()`` will effectively correspond to ``n_envs`` steps. + # To account for that, you can use ``eval_freq = eval_freq/len(envs)`` + eval_freq = 100 + eval_callback = EvalCallback(vec_env, best_model_save_path=log_dir, log_path=log_dir, + eval_freq=int(eval_freq/len(envs)), n_eval_episodes=1, deterministic=True) + + # Try to find CUDA core since it's optimized for parallel computing tasks + device = 'cuda' if torch.cuda.is_available() else 'cpu' + + # Instantiate an RL agent with DQN + model = DQN('MlpPolicy', vec_env, verbose=1, gamma=0.99, learning_rate=5e-4, + batch_size=24, seed=123456, buffer_size=365 * 24, + learning_starts=24, train_freq=1, exploration_initial_eps=1.0, + exploration_final_eps=0.01, exploration_fraction=0.1, device=device) - # Modify the environment to include the callback - vec_env = VecMonitor(venv=vec_env, filename=os.path.join(log_dir,'monitor.csv')) - - # Create the callback: evaluate with one episode after 100 steps for training. We keep it very short for testing. - # When using multiple environments, each call to ``env.step()`` will effectively correspond to ``n_envs`` steps. - # To account for that, you can use ``eval_freq = eval_freq/len(envs)`` - eval_freq = 100 - eval_callback = EvalCallback(vec_env, best_model_save_path=log_dir, log_path=log_dir, - eval_freq=int(eval_freq/len(envs)), n_eval_episodes=1, deterministic=True) - - # Try to find CUDA core since it's optimized for parallel computing tasks - device = 'cuda' if torch.cuda.is_available() else 'cpu' - - # Instantiate an RL agent with DQN - model = DQN('MlpPolicy', vec_env, verbose=1, gamma=0.99, learning_rate=5e-4, - batch_size=24, seed=123456, buffer_size=365 * 24, - learning_starts=24, train_freq=1, exploration_initial_eps=1.0, - exploration_final_eps=0.01, exploration_fraction=0.1, device=device) - - # set up logger - new_logger = configure(log_dir, ['csv']) - model.set_logger(new_logger) - - # Main training loop - model.learn(total_timesteps=100, callback=eval_callback) - else: - print("No URLs found. Please check your docker-compose.yml file.") + # set up logger + new_logger = configure(log_dir, ['csv']) + model.set_logger(new_logger) + + # Main training loop + model.learn(total_timesteps=100, callback=eval_callback) + From 0c4a63b6032e56059831bc78394dfa2c2ba76f2b Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Tue, 14 Nov 2023 16:59:49 +0100 Subject: [PATCH 17/41] Move functionality inside method. --- examples/run_vectorized.py | 55 +++++++++++++++++++++----------------- 1 file changed, 30 insertions(+), 25 deletions(-) diff --git a/examples/run_vectorized.py b/examples/run_vectorized.py index 2f1a291..8509be5 100644 --- a/examples/run_vectorized.py +++ b/examples/run_vectorized.py @@ -17,16 +17,7 @@ # Seed for random starting times of episodes random.seed(seed) -boptest_root = "./" # You can define boptest_root_dir here when use IDLE - -# Get the argument from command line when use Linux -if len(sys.argv) >= 2: - boptest_root_dir = sys.argv[1] -else: - boptest_root_dir = boptest_root - - -def generate_urls_from_yml(boptest_root_dir=boptest_root_dir): +def generate_urls_from_yml(boptest_root_dir): '''Method that returns as many urls for BOPTEST-Gym environments as those specified at the BOPTEST `docker-compose.yml` file. It assumes that `generateDockerComposeYml.py` has been called first. @@ -67,8 +58,9 @@ def generate_urls_from_yml(boptest_root_dir=boptest_root_dir): return urls -# Create a function to initialize the environment def make_env(url): + ''' Function that instantiates the environment. + ''' def _init(): env = BoptestGymEnv( url=url, @@ -99,35 +91,26 @@ def _init(): return _init - -if __name__ == '__main__': - # Use URLs obtained from docker-compose.yml - urls = generate_urls_from_yml(boptest_root_dir) - - envs = [make_env(url) for url in urls] - - # Create a parallel environment using SubprocVecEnv - vec_env = SubprocVecEnv(envs) - +def train_DQN_vectorized(venv): # Define logging directory. Monitoring data and agent model will be stored here log_dir = os.path.join(utilities.get_root_path(), 'examples', 'agents', 'DQN_vectorized') os.makedirs(log_dir, exist_ok=True) # Modify the environment to include the callback - vec_env = VecMonitor(venv=vec_env, filename=os.path.join(log_dir,'monitor.csv')) + venv = VecMonitor(venv=venv, filename=os.path.join(log_dir,'monitor.csv')) # Create the callback: evaluate with one episode after 100 steps for training. We keep it very short for testing. # When using multiple environments, each call to ``env.step()`` will effectively correspond to ``n_envs`` steps. # To account for that, you can use ``eval_freq = eval_freq/len(envs)`` eval_freq = 100 - eval_callback = EvalCallback(vec_env, best_model_save_path=log_dir, log_path=log_dir, - eval_freq=int(eval_freq/len(envs)), n_eval_episodes=1, deterministic=True) + eval_callback = EvalCallback(venv, best_model_save_path=log_dir, log_path=log_dir, + eval_freq=int(eval_freq/len(envs)), n_eval_episodes=1, deterministic=True) # Try to find CUDA core since it's optimized for parallel computing tasks device = 'cuda' if torch.cuda.is_available() else 'cpu' # Instantiate an RL agent with DQN - model = DQN('MlpPolicy', vec_env, verbose=1, gamma=0.99, learning_rate=5e-4, + model = DQN('MlpPolicy', venv, verbose=1, gamma=0.99, learning_rate=5e-4, batch_size=24, seed=123456, buffer_size=365 * 24, learning_starts=24, train_freq=1, exploration_initial_eps=1.0, exploration_final_eps=0.01, exploration_fraction=0.1, device=device) @@ -139,6 +122,28 @@ def _init(): # Main training loop model.learn(total_timesteps=100, callback=eval_callback) +if __name__ == '__main__': + + boptest_root = "./" + + # Get the argument from command line when use Linux + if len(sys.argv) >= 2: + boptest_root_dir = sys.argv[1] + else: + boptest_root_dir = boptest_root + + # Use URLs obtained from docker-compose.yml + urls = generate_urls_from_yml(boptest_root_dir=boptest_root_dir) + + # Create BOPTEST-Gym environment replicas + envs = [make_env(url) for url in urls] + + # Create a vectorized environment using SubprocVecEnv + venv = SubprocVecEnv(envs) + + # Train vectorized environment + train_DQN_vectorized(venv) + From bda440514187991731175364091a23fd0afbb24a Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Tue, 14 Nov 2023 17:36:02 +0100 Subject: [PATCH 18/41] Create test for vectorized environment. --- examples/run_vectorized.py | 19 ++++++++++---- testing/test_boptestGymEnv.py | 47 +++++++++++++++++++++++++++++++++-- 2 files changed, 59 insertions(+), 7 deletions(-) diff --git a/examples/run_vectorized.py b/examples/run_vectorized.py index 8509be5..aa33988 100644 --- a/examples/run_vectorized.py +++ b/examples/run_vectorized.py @@ -91,9 +91,18 @@ def _init(): return _init -def train_DQN_vectorized(venv): - # Define logging directory. Monitoring data and agent model will be stored here - log_dir = os.path.join(utilities.get_root_path(), 'examples', 'agents', 'DQN_vectorized') +def train_DQN_vectorized(venv, + log_dir=os.path.join(utilities.get_root_path(), 'examples', 'agents', 'DQN_vectorized')): + '''Method to train DQN agent using vectorized environment. + + Parameters + ---------- + venv: stable_baselines3.common.vec_env.SubprocVecEnv + vectorized environment to be learned. + + ''' + + # Create logging directory if not exists. Monitoring data and agent model will be stored here os.makedirs(log_dir, exist_ok=True) # Modify the environment to include the callback @@ -101,10 +110,10 @@ def train_DQN_vectorized(venv): # Create the callback: evaluate with one episode after 100 steps for training. We keep it very short for testing. # When using multiple environments, each call to ``env.step()`` will effectively correspond to ``n_envs`` steps. - # To account for that, you can use ``eval_freq = eval_freq/len(envs)`` + # To account for that, you can use ``eval_freq = eval_freq/venv.num_envs`` eval_freq = 100 eval_callback = EvalCallback(venv, best_model_save_path=log_dir, log_path=log_dir, - eval_freq=int(eval_freq/len(envs)), n_eval_episodes=1, deterministic=True) + eval_freq=int(eval_freq/venv.num_envs), n_eval_episodes=1, deterministic=True) # Try to find CUDA core since it's optimized for parallel computing tasks device = 'cuda' if torch.cuda.is_available() else 'cpu' diff --git a/testing/test_boptestGymEnv.py b/testing/test_boptestGymEnv.py index b57b0ac..8aedf36 100644 --- a/testing/test_boptestGymEnv.py +++ b/testing/test_boptestGymEnv.py @@ -12,11 +12,12 @@ import shutil from testing import utilities from examples import run_baseline, run_sample, run_save_callback,\ - run_variable_episode, train_RL + run_variable_episode, run_vectorized, train_RL from collections import OrderedDict from boptestGymEnv import BoptestGymEnv from stable_baselines3.common.env_checker import check_env -from stable_baselines3 import A2C +from stable_baselines3.common.vec_env import SubprocVecEnv +from stable_baselines3 import A2C, DQN url = 'http://127.0.0.1:5000' @@ -382,6 +383,48 @@ def test_variable_episode(self): # Remove model to prove further testing shutil.rmtree(log_dir, ignore_errors=True) + + def test_vectorized(self, boptest_root = "./"): + ''' + Instantiates a vectorized environment with two BOPTEST-Gym environment replicas + and learns from them when running in parallel using DQN for 100 timesteps. + It assumes that `generateDockerComposeYml.py` is called first using + `num_services=2` and `TESTCASE=bestest_hydronic_heat_pump docker-compose up` + is invoked after to initialize the two BOPTEST test cases. + Note that this test is also using the `EvalCallback` class from + `stable_baselines3.common.callbacks` instead of the + `boptestGymEnv.SaveAndTestCallback` that we typically use because + the former was more convenient for use with vectorized environments. + + ''' + # Define logging directory. Monitoring data and agent model will be stored here + log_dir = os.path.join(utilities.get_root_path(), 'examples', 'agents', 'DQN_vectorized') + + # Use URLs obtained from docker-compose.yml + urls = run_vectorized.generate_urls_from_yml(boptest_root_dir=boptest_root) + + # Create BOPTEST-Gym environment replicas + envs = [run_vectorized.make_env(url) for url in urls] + + # Create a vectorized environment using SubprocVecEnv + venv = SubprocVecEnv(envs) + + # Perform a short training example with parallel learning + run_vectorized.train_DQN_vectorized(venv, log_dir=log_dir) + + # Load the trained agent + model = DQN.load(os.path.join(log_dir, 'best_model')) + + # Test one step with the trained model + obs = venv.reset()[0] + df = pd.DataFrame([model.predict(obs)[0]], columns=['value']) + df.index.name = 'keys' + ref_filepath = os.path.join(utilities.get_root_path(), + 'testing', 'references', 'vectorized_training.csv') + self.compare_ref_values_df(df, ref_filepath) + + # Remove model to prove further testing + shutil.rmtree(log_dir, ignore_errors=True) def check_obs_act_rew_kpi(self, obs=None, act=None, rew=None, kpi=None, label='default'): From e533cea6ea2f7845b4417dd75acdd4eed40d11a0 Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Wed, 15 Nov 2023 10:43:47 +0100 Subject: [PATCH 19/41] Move seed inside environment constructor to get consistent results. Ideally we shouldn't need to pass the seed to the boptestGymEnv and we would inherit the seed using the SubprocVecEnv.seed() method from stable baselines. --- examples/run_vectorized.py | 15 +++++++++------ testing/test_boptestGymEnv.py | 6 ++++-- 2 files changed, 13 insertions(+), 8 deletions(-) diff --git a/examples/run_vectorized.py b/examples/run_vectorized.py index aa33988..1b1c9da 100644 --- a/examples/run_vectorized.py +++ b/examples/run_vectorized.py @@ -12,11 +12,6 @@ from stable_baselines3.common.logger import configure from boptestGymEnv import BoptestGymEnv, NormalizedObservationWrapper, DiscretizedActionWrapper -seed = 123456 - -# Seed for random starting times of episodes -random.seed(seed) - def generate_urls_from_yml(boptest_root_dir): '''Method that returns as many urls for BOPTEST-Gym environments as those specified at the BOPTEST `docker-compose.yml` file. @@ -58,10 +53,18 @@ def generate_urls_from_yml(boptest_root_dir): return urls -def make_env(url): +def make_env(url, seed): ''' Function that instantiates the environment. + Parameters + ---------- + url: string + Rest API url for communication with this environment. + seed: integer + Seed for random starting times of episodes in this environment. ''' + def _init(): + random.seed(seed) env = BoptestGymEnv( url=url, actions=['oveHeaPumY_u'], diff --git a/testing/test_boptestGymEnv.py b/testing/test_boptestGymEnv.py index 8aedf36..d4e181a 100644 --- a/testing/test_boptestGymEnv.py +++ b/testing/test_boptestGymEnv.py @@ -397,14 +397,16 @@ def test_vectorized(self, boptest_root = "./"): the former was more convenient for use with vectorized environments. ''' + # Define logging directory. Monitoring data and agent model will be stored here log_dir = os.path.join(utilities.get_root_path(), 'examples', 'agents', 'DQN_vectorized') # Use URLs obtained from docker-compose.yml urls = run_vectorized.generate_urls_from_yml(boptest_root_dir=boptest_root) - # Create BOPTEST-Gym environment replicas - envs = [run_vectorized.make_env(url) for url in urls] + # Create BOPTEST-Gym environment replicas, each with its own random seed + seed = 123456 + envs = [run_vectorized.make_env(url,seed+idx) for idx,url in enumerate(urls)] # Create a vectorized environment using SubprocVecEnv venv = SubprocVecEnv(envs) From 2722e3005745d0611df82c68a7b12ebdb4fa0a6f Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Wed, 15 Nov 2023 10:57:02 +0100 Subject: [PATCH 20/41] Add reference. --- testing/references/vectorized_training.csv | 2 ++ 1 file changed, 2 insertions(+) create mode 100644 testing/references/vectorized_training.csv diff --git a/testing/references/vectorized_training.csv b/testing/references/vectorized_training.csv new file mode 100644 index 0000000..59144a1 --- /dev/null +++ b/testing/references/vectorized_training.csv @@ -0,0 +1,2 @@ +keys,value +0,0 From a272f5a79455601860166df105ec2b1ae5bca438 Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Wed, 15 Nov 2023 12:36:47 +0100 Subject: [PATCH 21/41] Have independent test for vectorized environment. --- testing/test_boptestGymEnv.py | 105 ++++++++++++++++++++-------------- 1 file changed, 62 insertions(+), 43 deletions(-) diff --git a/testing/test_boptestGymEnv.py b/testing/test_boptestGymEnv.py index d4e181a..f10d2dd 100644 --- a/testing/test_boptestGymEnv.py +++ b/testing/test_boptestGymEnv.py @@ -7,6 +7,7 @@ import unittest import os +import sys import pandas as pd import random import shutil @@ -383,8 +384,66 @@ def test_variable_episode(self): # Remove model to prove further testing shutil.rmtree(log_dir, ignore_errors=True) - - def test_vectorized(self, boptest_root = "./"): + + def check_obs_act_rew_kpi(self, obs=None, act=None, rew=None, kpi=None, + label='default'): + '''Auxiliary method to check for observations, actions, rewards, + and/or kpis of a particular test case run. + + ''' + + # Check observation values + if obs is not None: + df = pd.DataFrame(obs) + df.index.name = 'time' # utilities package requires 'time' as name for index + ref_filepath = os.path.join(utilities.get_root_path(), 'testing', 'references', 'observations_{}.csv'.format(label)) + self.compare_ref_timeseries_df(df, ref_filepath) + + # Check actions values + if act is not None: + df = pd.DataFrame(act) + df.index.name = 'time' # utilities package requires 'time' as name for index + ref_filepath = os.path.join(utilities.get_root_path(), 'testing', 'references', 'actions_{}.csv'.format(label)) + self.compare_ref_timeseries_df(df, ref_filepath) + + # Check reward values + if rew is not None: + df = pd.DataFrame(rew) + df.index.name = 'time' # utilities package requires 'time' as name for index + ref_filepath = os.path.join(utilities.get_root_path(), 'testing', 'references', 'rewards_{}.csv'.format(label)) + self.compare_ref_timeseries_df(df, ref_filepath) + + if kpi is not None: + df = pd.DataFrame(data=[kpi]).T + df.columns = ['value'] + df.index.name = 'keys' + # Time ratio is not checked since depends on the machine where tests are run + df.drop('time_rat', inplace=True) + # Drop rows with non-calculated KPIs + df.dropna(inplace=True) + ref_filepath = os.path.join(utilities.get_root_path(), 'testing', 'references', 'kpis_{}.csv'.format(label)) + self.compare_ref_values_df(df, ref_filepath) + + +class BoptestGymVecTest(unittest.TestCase, utilities.partialChecks): + '''Tests learning with a vectorized environment of BOPTEST-Gym. + + ''' + + def setUp(self): + '''Reads the location of boptest root directory which should be passed from + the terminal when invoking this test. + ''' + + boptest_root = "./" + + # Get the argument from command line when use Linux + if len(sys.argv) >= 2: + self.boptest_root_dir = sys.argv[1:][1] + else: + self.boptest_root_dir = boptest_root + + def test_vectorized(self): ''' Instantiates a vectorized environment with two BOPTEST-Gym environment replicas and learns from them when running in parallel using DQN for 100 timesteps. @@ -402,7 +461,7 @@ def test_vectorized(self, boptest_root = "./"): log_dir = os.path.join(utilities.get_root_path(), 'examples', 'agents', 'DQN_vectorized') # Use URLs obtained from docker-compose.yml - urls = run_vectorized.generate_urls_from_yml(boptest_root_dir=boptest_root) + urls = run_vectorized.generate_urls_from_yml(boptest_root_dir=self.boptest_root_dir) # Create BOPTEST-Gym environment replicas, each with its own random seed seed = 123456 @@ -427,46 +486,6 @@ def test_vectorized(self, boptest_root = "./"): # Remove model to prove further testing shutil.rmtree(log_dir, ignore_errors=True) - - def check_obs_act_rew_kpi(self, obs=None, act=None, rew=None, kpi=None, - label='default'): - '''Auxiliary method to check for observations, actions, rewards, - and/or kpis of a particular test case run. - - ''' - - # Check observation values - if obs is not None: - df = pd.DataFrame(obs) - df.index.name = 'time' # utilities package requires 'time' as name for index - ref_filepath = os.path.join(utilities.get_root_path(), 'testing', 'references', 'observations_{}.csv'.format(label)) - self.compare_ref_timeseries_df(df, ref_filepath) - - # Check actions values - if act is not None: - df = pd.DataFrame(act) - df.index.name = 'time' # utilities package requires 'time' as name for index - ref_filepath = os.path.join(utilities.get_root_path(), 'testing', 'references', 'actions_{}.csv'.format(label)) - self.compare_ref_timeseries_df(df, ref_filepath) - - # Check reward values - if rew is not None: - df = pd.DataFrame(rew) - df.index.name = 'time' # utilities package requires 'time' as name for index - ref_filepath = os.path.join(utilities.get_root_path(), 'testing', 'references', 'rewards_{}.csv'.format(label)) - self.compare_ref_timeseries_df(df, ref_filepath) - - if kpi is not None: - df = pd.DataFrame(data=[kpi]).T - df.columns = ['value'] - df.index.name = 'keys' - # Time ratio is not checked since depends on the machine where tests are run - df.drop('time_rat', inplace=True) - # Drop rows with non-calculated KPIs - df.dropna(inplace=True) - ref_filepath = os.path.join(utilities.get_root_path(), 'testing', 'references', 'kpis_{}.csv'.format(label)) - self.compare_ref_values_df(df, ref_filepath) - class BoptestGymServiceTest(unittest.TestCase, utilities.partialChecks): '''Tests the BOPTEST-Gym service. From edfcab98512ee8f7c6e73b020fe54b557f63f9fd Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Wed, 15 Nov 2023 12:37:04 +0100 Subject: [PATCH 22/41] Fix doptest typo. --- testing/Makefile | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/testing/Makefile b/testing/Makefile index 3e72400..a373fd5 100644 --- a/testing/Makefile +++ b/testing/Makefile @@ -65,17 +65,17 @@ pull-boptestgym: docker pull ${IMG_REGI}:${VERSION} docker tag ${IMG_REGI}:${VERSION} ${IMG_NAME} -make download-doptest: +make download-boptest: curl -L -o boptest.zip https://github.com/ibpsa/project1-boptest/archive/${BOPTEST_COMMIT}.zip unzip -o -q boptest.zip run-boptest-case: - make download-doptest + make download-boptest cd project1-boptest-${BOPTEST_COMMIT} && \ TESTCASE=bestest_hydronic_heat_pump docker-compose up -d --quiet-pull run-boptest-case-no-cache: - make download-doptest + make download-boptest cd project1-boptest-${BOPTEST_COMMIT} && \ TESTCASE=bestest_hydronic_heat_pump docker-compose up -d --force-recreate --build From 4180122dbf761a355ca681193699d255a77df179 Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Wed, 15 Nov 2023 12:37:24 +0100 Subject: [PATCH 23/41] Set new tag for development version. --- testing/Makefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/testing/Makefile b/testing/Makefile index a373fd5..c6b7fab 100644 --- a/testing/Makefile +++ b/testing/Makefile @@ -13,7 +13,7 @@ IMG_REGI=javierarroyo/boptestgym BOPTEST_COMMIT=12ceafe42983d42e535385dee1daa1d25673e2aa # Define current BOPTEST-Gym version (should be even with BOPTEST version defined in commit above) -VERSION = 0.5.0 +VERSION = 0.5.0-dev build-boptestgym: docker build -f ${ROOT}/testing/Dockerfile \ From 6be17865cf529ea9d8e83f994aabb0beb23f774c Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Wed, 15 Nov 2023 12:38:02 +0100 Subject: [PATCH 24/41] Install PyYAML in new environment version. --- testing/Dockerfile | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/testing/Dockerfile b/testing/Dockerfile index 64fa65b..e4ad354 100644 --- a/testing/Dockerfile +++ b/testing/Dockerfile @@ -29,7 +29,8 @@ RUN pip install \ nbconvert==7.7.3 \ gym \ shimmy \ - ipykernel==6.25.1 + ipykernel==6.25.1 \ + PyYAML # Add developer user with permissions in the working directory RUN useradd -ms /bin/bash developer From 9985038662e0c2d02bbe45a5490902c3a235eb8d Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Wed, 15 Nov 2023 12:38:34 +0100 Subject: [PATCH 25/41] Add new vectorized test to Makefile. --- testing/Makefile | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/testing/Makefile b/testing/Makefile index c6b7fab..09ed149 100644 --- a/testing/Makefile +++ b/testing/Makefile @@ -79,6 +79,12 @@ run-boptest-case-no-cache: cd project1-boptest-${BOPTEST_COMMIT} && \ TESTCASE=bestest_hydronic_heat_pump docker-compose up -d --force-recreate --build +run-boptest-vectorized: + make download-boptest && \ + cd .. && python3 generateDockerComposeYml.py testing/project1-boptest-${BOPTEST_COMMIT} && \ + cd testing/project1-boptest-${BOPTEST_COMMIT} && \ + TESTCASE=bestest_hydronic_heat_pump docker-compose up -d --quiet-pull + stop-boptest-case: cd project1-boptest-${BOPTEST_COMMIT} && docker-compose down @@ -91,6 +97,10 @@ cleanup-boptest: test-local: python3 -m unittest test_boptestGymEnv.BoptestGymEnvTest +# Vectorized needs to run separate since modifies docker-compose.yml to have multiple boptest instances +test-vectorized: + python3 -m unittest test_boptestGymEnv.BoptestGymVecTest project1-boptest-${BOPTEST_COMMIT} + # The tutorial is using boptest-gym-service and covers most of the functionality of boptest-gym test-service: python3 -m unittest test_boptestGymEnv.BoptestGymServiceTest @@ -103,6 +113,14 @@ test-local-in-container: make stop-boptest-case make cleanup-boptest +test-vectorized-in-container: + make run-boptest-vectorized + make run-boptestgym-detached + make exec-boptestgym ARGS="make test-vectorized" + make stop-boptestgym + make stop-boptest-case + make cleanup-boptest + test-service-in-container: make run-boptestgym-detached make exec-boptestgym ARGS="make test-service" From cb0936ce073a73323a1ae9917279ed9c0a30413a Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Wed, 15 Nov 2023 12:38:51 +0100 Subject: [PATCH 26/41] Add new vectorized test to github-actions.yml. --- .github/workflows/github-actions.yml | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/.github/workflows/github-actions.yml b/.github/workflows/github-actions.yml index 5ece15e..f815ce3 100644 --- a/.github/workflows/github-actions.yml +++ b/.github/workflows/github-actions.yml @@ -17,6 +17,22 @@ jobs: ls ${{ github.workspace }} - name: Test local version run: make test-local-in-container + test-vectorized: + runs-on: ubuntu-latest + defaults: + run: + working-directory: testing + steps: + - name: Check out repository code + uses: actions/checkout@v3 + - name: Pull boptestgym image from registry + run: make pull-boptestgym + - run: echo "The name of your branch is ${{ github.ref }} and your repository is ${{ github.repository }}." + - name: List of files in the repository + run: | + ls ${{ github.workspace }} + - name: Test vectorized environment + run: make test-vectorized-in-container test-service: runs-on: ubuntu-latest defaults: From 18e4e78c23024f8464cc2a80595930da45591099 Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Wed, 15 Nov 2023 12:39:42 +0100 Subject: [PATCH 27/41] Polish doc in readme. --- README.md | 13 ++++--------- 1 file changed, 4 insertions(+), 9 deletions(-) diff --git a/README.md b/README.md index 33e31cb..25da481 100644 --- a/README.md +++ b/README.md @@ -75,9 +75,10 @@ Running BOPTEST locally is substantially faster 2) Run a BOPTEST case with the building emulator model to be controlled (instructions [here](https://github.com/ibpsa/project1-boptest/blob/master/README.md)). 3) Check out the `master` branch of this repository and run the example above replacing the url to be `url = 'http://127.0.0.1:5000'` and avoiding the `testcase` argument to the `BoptestGymEnv` class. -## Quick-Start (running BOPTEST locally with parallel training) +## Quick-Start (running BOPTEST locally in a vectorized environment) -To facilitate the training and testing process, we provide scripts that automate the deployment of multiple BOPTEST instances using Docker Compose and then train the BOPTEST-gym environment in parallel. The deployment dynamically checks for available ports, generates a Docker Compose YAML file, and takes care of naming conflicts to ensure smooth deployment. +To facilitate the training and testing process, we provide scripts that automate the deployment of multiple BOPTEST instances using Docker Compose and then train an RL agent with a vectorized BOPTEST-gym environment. The deployment dynamically checks for available ports, generates a Docker Compose YAML file, and takes care of naming conflicts to ensure smooth deployment. +Running a vectorized environment allows you to deploy as many BoptestGymEnv instances as cores you have available for the agent to learn from all of them in parallel (see [here](https://stable-baselines3.readthedocs.io/en/master/guide/vec_envs.html) for more information, we specifically use [`SubprocVecEnv`](https://stable-baselines3.readthedocs.io/en/master/guide/vec_envs.html#subprocvecenv)). This substantially speeds up the training process. ### Usage @@ -89,13 +90,7 @@ Example using command-line argument: python generateDockerComposeYml.py absolute_boptest_root_dir ``` -2. Train the BOPTEST-gym environment in parallel either by passing it as a command-line argument or by defining the `boptest_root` variable at the beginning of the script `parallel_BOPTESTgymTrain.py`. The script prioritizes the command-line argument if provided. Users are allowed to change the initial conditions, algorithms and hyperparameters. - -Example using command-line argument: - -```bash -python parallel_BOPTESTgymTrain.py absolute_boptest_root_dir -``` +2. Train an RL agent with parallel learning with the vectorized BOPTEST-gym environment. See `/examples/run_vectorized.py` for an example on how to do so. ## Versioning and main dependencies From 9b48ab8d379d48e241172c8a1f3771bbc6abc983 Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Wed, 15 Nov 2023 12:40:08 +0100 Subject: [PATCH 28/41] Add entry to releasenotes. --- releasenotes.md | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/releasenotes.md b/releasenotes.md index 76553e6..ee738ff 100644 --- a/releasenotes.md +++ b/releasenotes.md @@ -2,6 +2,12 @@ BOPTEST-Gym has two main dependencies: BOPTEST and Stable-Baselines3. For simplicity, the first two digits of the version number match the same two digits of the BOPTEST version of which BOPTEST-Gym is compatible with. For example, BOPTEST-Gym v0.3.x is compatible with BOPTEST v0.3.x. The last digit is reserved for other internal edits specific to this repository only. See [here](https://github.com/ibpsa/project1-boptest/blob/master/releasenotes.md) for BOPTEST release notes. +## BOPTEST-Gym v0.5.0-dev + +Released on xx/xx/xxxx. + +- Implement functionality and example with vectorized environment for parallel learning. This is for [#133](https://github.com/ibpsa/project1-boptest-gym/issues/133). + ## BOPTEST-Gym v0.5.0 Released on 11/11/2023. From 10bc481f392c2e11b24ddcf05a1696caacd3cc54 Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Fri, 10 May 2024 15:21:58 +0200 Subject: [PATCH 29/41] Update version in notebook. --- .../Building_Control_with_RL_using_BOPTEST.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/tutorials/CCAI_Summer_School_2022/Building_Control_with_RL_using_BOPTEST.ipynb b/docs/tutorials/CCAI_Summer_School_2022/Building_Control_with_RL_using_BOPTEST.ipynb index 00790c3..0bbbe24 100644 --- a/docs/tutorials/CCAI_Summer_School_2022/Building_Control_with_RL_using_BOPTEST.ipynb +++ b/docs/tutorials/CCAI_Summer_School_2022/Building_Control_with_RL_using_BOPTEST.ipynb @@ -40,7 +40,7 @@ "- The most popular standard for representing general RL problems: OpenAI-Gym.\n", "- The BOPTEST API and its Gym interface.\n", "\n", - "📌 **Note**: This tutorial is prepared for use with BOPTEST v0.5.0.\n", + "📌 **Note**: This tutorial is prepared for use with BOPTEST v0.6.0.\n", "and uses a web-based version of BOPTEST (called \"BOPTEST-Service\") as not to require installation of any BOPTEST software on a user's own device. It is also possible to use BOPTEST on a user's own (local) device. \n", "Both the web-based and local versions have the same functionality, and will produce the same results, with only small changes in the API (changing the BOPTEST-service url to your localhost url, that is, to: `http://127.0.0.1:5000/`). The tutorial is continuously updated to work with the latest BOPTEST versions. See [the release notes](https://github.com/ibpsa/project1-boptest-gym/blob/master/releasenotes.md) for the version history.\n", "\n", From b60934bbf87e8e87ebab5f87650bee68b656784f Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Fri, 10 May 2024 15:22:45 +0200 Subject: [PATCH 30/41] New operative temperature output when using latest Service. --- .../Building_Control_with_RL_using_BOPTEST.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/tutorials/CCAI_Summer_School_2022/Building_Control_with_RL_using_BOPTEST.ipynb b/docs/tutorials/CCAI_Summer_School_2022/Building_Control_with_RL_using_BOPTEST.ipynb index 0bbbe24..2f412e0 100644 --- a/docs/tutorials/CCAI_Summer_School_2022/Building_Control_with_RL_using_BOPTEST.ipynb +++ b/docs/tutorials/CCAI_Summer_School_2022/Building_Control_with_RL_using_BOPTEST.ipynb @@ -1770,8 +1770,8 @@ "output_type": "stream", "text": [ "-------------------------------------------------------------------\n", - "Operative temperature [degC] = 21.34\n", - "Action [ - ] = 1\n", + "Operative temperature [degC] = 22.05\n", + "Action [ - ] = 0\n", "-------------------------------------------------------------------\n" ] } From cd7561d34c3239ee929142e72ff071c16db6c3da Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Fri, 10 May 2024 15:54:52 +0200 Subject: [PATCH 31/41] Reword q-function references. --- .../Building_Control_with_RL_using_BOPTEST.ipynb | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/docs/tutorials/CCAI_Summer_School_2022/Building_Control_with_RL_using_BOPTEST.ipynb b/docs/tutorials/CCAI_Summer_School_2022/Building_Control_with_RL_using_BOPTEST.ipynb index 2f412e0..1092c25 100644 --- a/docs/tutorials/CCAI_Summer_School_2022/Building_Control_with_RL_using_BOPTEST.ipynb +++ b/docs/tutorials/CCAI_Summer_School_2022/Building_Control_with_RL_using_BOPTEST.ipynb @@ -2551,8 +2551,7 @@ "id": "V0AIl-HeVyqs" }, "source": [ - "Does it sound familiar? this is actually the [q-function that we had conceptually introduced before](#qFunctionConcept), but for our specific case!\n", - "\n", + "The q-function was conceptually introduced at the beginning of Section [*Developing a basic RL algorithm*](#developingRlAlgo). A more formal definition is provided in [*Annex I*](#theoryRlFormal). \n", "We observe that the state with the highest value is the one in the middle (green bars 🟢👌, `2124`), there is more value on `a=0`, so there is a preference for the agent to turn heating off.\n", "\n", "Sometimes it is useful to know what is the value of being on a specific state, independently of the action to be taken. This is represented by the so-called state-value function, which relates to the action-value function as follows:\n", From 4862a5b25b3edac698a0ccb6fe521f94ae24db4c Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Fri, 10 May 2024 15:57:38 +0200 Subject: [PATCH 32/41] Reformat Annex I title. --- .../Building_Control_with_RL_using_BOPTEST.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/tutorials/CCAI_Summer_School_2022/Building_Control_with_RL_using_BOPTEST.ipynb b/docs/tutorials/CCAI_Summer_School_2022/Building_Control_with_RL_using_BOPTEST.ipynb index 1092c25..77e4a81 100644 --- a/docs/tutorials/CCAI_Summer_School_2022/Building_Control_with_RL_using_BOPTEST.ipynb +++ b/docs/tutorials/CCAI_Summer_School_2022/Building_Control_with_RL_using_BOPTEST.ipynb @@ -2972,7 +2972,7 @@ "id": "WNB5MoRmOWc9" }, "source": [ - "#**Annex I: Formal Reinforcement Learning theory** " + "# **Annex I: Formal Reinforcement Learning theory** " ] }, { From 234640cce0a2ec809fe802ef1e1f4d1a63ecb266 Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Fri, 10 May 2024 15:58:19 +0200 Subject: [PATCH 33/41] Other numerical differences due to new python v3.10 instead of old v3.8 --- ...ilding_Control_with_RL_using_BOPTEST.ipynb | 118 ++++++++---------- 1 file changed, 55 insertions(+), 63 deletions(-) diff --git a/docs/tutorials/CCAI_Summer_School_2022/Building_Control_with_RL_using_BOPTEST.ipynb b/docs/tutorials/CCAI_Summer_School_2022/Building_Control_with_RL_using_BOPTEST.ipynb index 77e4a81..7fe1ed1 100644 --- a/docs/tutorials/CCAI_Summer_School_2022/Building_Control_with_RL_using_BOPTEST.ipynb +++ b/docs/tutorials/CCAI_Summer_School_2022/Building_Control_with_RL_using_BOPTEST.ipynb @@ -2263,7 +2263,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAHVCAYAAAB8NLYkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACmfElEQVR4nOzdd3hTZfvA8W+60kIXhU5GGWXvXVCmynAwRV8n4BaRJa+KyJQlCDhQEZXlK4oDHD8RXIAoIJuyZLa0QEsZXXQnOb8/Dg2UjqRN0ozen+vq1SbnnOfcJ82480yNoigKQgghhBDC6bnZOwAhhBBCCGEdktgJIYQQQrgISeyEEEIIIVyEJHZCCCGEEC5CEjshhBBCCBchiZ0QQgghhIuQxE4IIYQQwkVIYieEEEII4SIksRNCCCGEcBEe9g6gsjMYDFy4cAE/Pz80Go29wxFCCCHMoigKGRkZRERE4OYm9UQOQ3Egf/75p/LII48o0dHRyrlz5xRFUZTVq1cr27Ztq/BYPvjgA6Vly5aKn5+f4ufnp0RHRysbNmwwbjcYDMq0adOU8PBwxdvbW+nRo4dy+PDhMp8nISFBAeRHfuRHfuRHfpzyJyEhwZofv8JCDlNj9+233/LYY4/xyCOPsH//fnJzcwHIyMhgzpw5bNiwoULjqVWrFvPmzSMqKgqAVatWMXDgQPbv30/z5s2ZP38+ixYtYuXKlTRq1IhZs2Zx1113cfz4cfz8/Mw+T8G+CQkJ+Pv72+RahBBCCGtLT0+ndu3aZfrME7anURRFsXcQAG3btmX8+PE8/vjj+Pn5cfDgQerXr8+BAwfo168fSUlJ9g6RoKAgFixYwBNPPEFERATjxo3jlVdeASA3N5fQ0FDefPNNnn32WbPLTE9PJyAggLS0NEnshBCiEjIYDGRlZVXY+bRaLZ6enhaXI59fjslhauyOHz9O9+7di9zv7+9PampqxQd0E71ez9dff01mZiZdunQhNjaWpKQk+vTpY9xHq9XSo0cPtm/fXmpil5uba6yNBPWFIYQQovJat24dR44cqbDz9evXj86dO1fY+UTFcpjELjw8nFOnTlG3bt1C9//111/Ur1/fLjEdOnSILl26kJOTg6+vL+vXr6dZs2Zs374dgNDQ0EL7h4aGcvbs2VLLnDt3LjNmzLBZzEIIIZxLZmYmVapUYeDAgRVyvuDg4Ao5j7APh0nsnn32WcaOHcvy5cvRaDRcuHCBHTt2MHHiRKZOnWqXmBo3bsyBAwdITU3l22+/Zfjw4WzdutW4/dZRrIqimBzZOmnSJCZMmGC8XdBHQQghROXVoEEDGjVqZO8whAtwmMTu5ZdfJi0tjV69epGTk0P37t3RarVMnDiR0aNH2yUmLy8v4+CJDh06sHv3bt555x1jv7qkpCTCw8ON+ycnJxepxbuVVqtFq9XaLmghhBBCVFoOMfGMXq9n69atvPTSS1y+fJldu3axc+dOLl26xBtvvGHv8IwURSE3N5d69eoRFhbGr7/+atyWl5fH1q1b6dq1qx0jFEIIIURlZpMau5ycHLy9vc3e393dnb59+3Ls2DGCgoLo0KGDLcIqk9dee43+/ftTu3ZtMjIy+PLLL9myZQsbN25Eo9Ewbtw45syZQ8OGDWnYsCFz5syhSpUqPPzww/YOXQghhBCVlNVq7AwGA2+88QY1a9bE19eXM2fOADBlyhQ+/fRTk8e3bNnSeIwjuHjxIo899hiNGzfmjjvu4J9//mHjxo3cddddgNp0PG7cOEaNGkWHDh04f/48v/zyi8znI4QQQgi7sVpiN2vWLFauXMn8+fPx8vIy3t+yZUs++eQTk8fPnj2biRMn8n//938kJiaSnp5e6Keiffrpp8TFxZGbm0tycjK//fabMakDdeDE9OnTSUxMJCcnh61bt9KiRYsKj1MIIYQQooDVmmJXr17NsmXLuOOOO3juueeM97dq1Yp///3X5PH9+vUDYMCAAYVGlhaMNNXr9dYKVQghhBDCJVktsTt//rxxBOnNDAYD+fn5Jo/fvHmztUIRQgghhKiUrJbYNW/enG3bthEZGVno/q+//pq2bduaPL5Hjx7WCkUIIYQQolKyWmI3bdo0HnvsMc6fP4/BYGDdunUcP36c1atX83//938mj//zzz9L3V7ccmNCCCGEEOIGqyV29913H2vXrmXOnDloNBqmTp1Ku3bt+PHHHwsNOihJz549i9x3c1876WMnhBBCCFE6q85j17dvX/r27VuuY1NSUgrdzs/PZ//+/UyZMoXZs2dbIzwhhBBCCJdmtcRu5MiRPProo/Tu3dvkeqnFCQgIKHLfXXfdhVarZfz48ezdu9caYQohhBBCuCyrzWN35coV7rnnHmrVqsVLL73E/v37rVJucHAwx48ft0pZQgghhBCuzGo1dj/88AOpqal89dVXrFmzhrfffpvGjRvz6KOP8vDDD1O3bt1Sj4+JiSl0W1EUEhMTmTdvHq1bt7ZWmEIIIYQQLkujKIpii4LPnTvHF198wfLlyzl58iQ6na7U/d3c3NBoNNwaTnR0NMuXL6dJkya2CNPu0tPTCQgIIC0tDX9/f3uHI4QQooKtWrUKPz8/hgwZYu9QykQ+vxyTVQdPFMjPz2fPnj38888/xMXFERoaavKY2NjYQrfd3NwIDg7G29vbFiEKIYQQQrgcq/WxA3X1iKeffprQ0FCGDx+On58fP/74IwkJCSaP3bp1K2FhYURGRhIZGUnt2rXx9vYmLy+P1atXWzNMIYQQQgiXZLXErlatWtx9991cunSJjz76iIsXL7JixQruvPNO3NxMn2bkyJGkpaUVuT8jI4ORI0daK0whhBBCCJdltcRu6tSpXLhwge+++45hw4aVuQlVUZRip0k5d+5csVOh2NrcuXPp2LEjfn5+hISEMGjQoCKjc0eMGIFGoyn0Ex0dXeGxCiGEEEKAFfvYPfPMM+U6rm3btsak6I477sDD40ZIer2e2NhY+vXrZ60wzbZ161ZeeOEFOnbsiE6nY/LkyfTp04ejR49StWpV4379+vVjxYoVxtteXl4VHqsQQgghBFiY2A0ZMoSVK1fi7+9vcjTPunXrir1/0KBBABw4cIC+ffvi6+tr3Obl5UXdunUZOnSoJWGWy8aNGwvdXrFiBSEhIezdu7fQurVarZawsLCKDk8IIYQQogiLEruAgABj86m/v3+5VpyYNm0aAHXr1uXBBx+0yijY/Px8kpKSyMrKIjg4mKCgIIvLLOj/d2tZW7ZsISQkhMDAQHr06MHs2bMJCQkpsZzc3Fxyc3ONt9PT0y2OTQghhBACbDiPXUW7du0an3/+OV988QW7du0qlDzVqlWLPn368Mwzz9CxY8cyl60oCgMHDiQlJYVt27YZ71+7di2+vr5ERkYSGxvLlClT0Ol07N27F61WW2xZ06dPZ8aMGUXul3mAhBCicpJ57IQ1WW3wRO/evUlNTS1yf3p6Or179zZ5vF6v56233qJTp06EhYURFBRU6Kc0ixcvpm7dunz88cf07t2bdevWceDAAY4fP86OHTuYNm0aOp2Ou+66i379+nHy5MkyXdvo0aOJiYnhiy++KHT/gw8+yD333EOLFi247777+Pnnnzlx4gQ//fRTiWVNmjSJtLQ04485U8EIIYQQQpjDaoMntmzZQl5eXpH7c3JyCtVylWTGjBl88sknTJgwgSlTpjB58mTi4uL47rvvmDp1aqnHbt++nc2bN9OyZctit3fq1IknnniCpUuX8umnn7J161YaNmxo1nW9+OKL/PDDD/z555/UqlWr1H3Dw8OJjIwsNXHUarUl1uYJIYQQQljC4sTu5jVejx49SlJSkvG2Xq9n48aN1KxZ02Q5n3/+OR9//DH33HMPM2bM4KGHHqJBgwa0atWKnTt3MmbMmBKP/frrr82KVavVMmrUKLP2VRSFF198kfXr17Nlyxbq1atn8pgrV66QkJBAeHi4WeewNkVRMBgMdjm3EEKI8nGRHlHCQVic2LVp08Y4XUlxTa4+Pj689957JstJSkoy1rj5+voaByvce++9TJkyxdIwy+yFF15gzZo1fP/99/j5+RkT1oCAAHx8fLh27RrTp09n6NChhIeHExcXx2uvvUaNGjUYPHhwhccLcPr0aT7//HO7nFsIIUT5tW7d2t4hCBdhcWIXGxuLoijUr1+fXbt2ERwcbNzm5eVFSEgI7u7uJsupVasWiYmJ1KlTh6ioKH755RfatWvH7t27zWq6/OOPPxg9ejQ7d+4s0okzLS2Nrl27snTpUrp162bWdX344YcA9OzZs9D9K1asYMSIEbi7u3Po0CFWr15Namoq4eHh9OrVi7Vr1+Ln52fWOaytYCJlIYQQziUyMtLeIQgXYXFiV/BktLQJcPDgwfz+++907tyZsWPH8tBDD/Hpp58SHx/P+PHjTR7/9ttv8/TTTxc7MicgIIBnn32WRYsWmZ3Ymaoa9/HxYdOmTWaVVVH8/f3lW58QQghRiVl9upOjR48SHx9fZCDFgAEDylTOP//8w99//01UVJRZx0ZGRrJx40aaNm1a7PZ///2XPn36EB8fX6Y4bE2GiwshhHBG8vnlmKw2KvbMmTMMHjyYQ4cOodFojDVeBZMW6/X6Eo/Nz8/nmWeeYcqUKdSvXx+Azp0707lzZ7PPf/HiRTw9PUvc7uHhwaVLl8wuTwinpRgg+SCc2wIJWyDlJOSlgbs3aAMhsD5UawxhHaFmN/CxfAJvIYQQjsFqid3YsWOpV68ev/32m7G/3ZUrV3jppZd46623Sj3W09OT9evXWzRIombNmhw6dIioqKhit8fExNhttGqlpM+Hc3+qP/nXwCcYwjpAre7gLuvpWl32VYjdAKd/gPjfICcF3LUQ0RUi7wLvaqDPhZyrkHoKDi+Hf2YDGghpCw0GQMPBUKMllGMFGSGEEI7Bak2xNWrU4I8//qBVq1YEBASwa9cuGjduzB9//MFLL73E/v37Sz1+5MiRtGzZkgkTJpTr/C+++CJbtmxh9+7dRZYly87OplOnTvTq1Yt33323XOXbiktVZedlQOxGOP09nPkJclPVhM47CLKSIDdNrTFqPhzavADVzJtLUJQg9YyayJ3+Hs5tA0Wv1sLV7Q91ekN4Z/AoZYm+tDg4txXiNqn/r7x0CKgPUQPVZDC0o1qbp7HaPOZCCBfiUp9fLsRqNXZ6vR5fX19ATfIuXLhA48aNiYyM5Pjx4yaPj4qK4o033mD79u20b9+eqlWrFtpe2jx2AK+//jrr1q2jUaNGjB49msaNG6PRaDh27Bjvv/8+er2eyZMnl/8CRVHZV+DCDrjwN5z/G5L+AX0eBLeCtmPUBCGkrVoDpChw6SAcXwuHPoF970DtXtB8hFpT5GWfkcRORTFA0p4bydzlw2rtZ5074I73of694Gd6zkijgLrqT/Ph6v8t/g84tV79H+1drO6jcQNtNTXB864BgQ2gWiP1p0YLCGoCbqZHvQshhKgYVqux69atGy+99BKDBg3i4YcfJiUlhddff51ly5axd+9eDh8+XOrxpU0ArNFoOHPmjMkYzp49y/PPP8+mTZsK9fHr27cvH3zwAXXr1i3TNVUEp/rGoyhwKUb94I/9GS4dUO+vGgYRt6nNrA3ugwATkznrcuDE13B4BSRsBjdP9dh6d6s1RTWaSy1RAV2OmnCd/h5O/wiZiWoNaP17oMFAqNvH+kmxosDV43DlsJq851xVf7KS1WbclBOQfVnd19MXQtuptXthHdXm9oD60pwrykcxqM+9i3shM0ltBXD3Up/jfnXULyJBTUqvia4o+jy4dkF9jYLa3cGnRqX6ouNUn1+ViNUSu02bNpGZmcmQIUM4c+YM9957L//++y/Vq1dn7dq1Zq0Xay0pKSmcOnUKRVFo2LAh1apVq7Bzl5VTvDDS4uDfNXDsc7hyFLyrQ73+ahJW83Y1kSvvB3n6WTVhid2gJnm6HNAGqH3DIm5Tyw/rBJ4+Vr0kq8hJgfN/QepptdlZMYCHD1QJAd+aUL0Z+NUu+2OTlaw2jZ7+AeJ+AV2WWlPWYKDaF67mbeBmtcr28sm+qib2SXvg4m5I2q3+L0Ftbg/toCZ5Bb/96kiyJ0qWeREOfwoHP4KM6zMXePmrCZ0hX+3Goc9V79e4Q/WmamtASFsIba/+roha//wsOP4VxCxTWyiUW6b50ripz/UaLSG4pRpbWCf1/cAFn/9O8flVCVl9upObXb16lWrVqhlHxpojLy+P2NhYGjRogIeHnT+8KoBDvjDyMtQP6tiNEPez2uTnUQWiBkHThyGyD7iXPAK53PKzIGmX2qx7/i+4sF3t9+Xmqb5B1uymJno1bwOf6tY/vzkyzsGJbwr3a3PXqvFo3NVryLlyY38vf6jeHEJaQ41WENxafcMv+BBSFLXM5H3qCNaEzWqtKEBEFzWRazBAraVw9A+GrMuQvFdN9pJ2w8U9cO28us27utp0W73ZTT/N1STY0a9L2IaiqK/xA++rryk3d2jyMDR5SE2GtP6F981KhrQz6usjeb/6xeLSwes1Zhr1NRLWQX2vCO0AIW3As2oJJy+jS4cg5iM49j81yYzsAw2HqF9qPXwARf2il5mk1mpfPqTGmZmoHl81XL2m8M7q77AO6hdYJ+eQn1/COomdTqfD29ubAwcO0KJFi3KVkZWVxYsvvsiqVasAOHHiBPXr12fMmDFERETw6quvWhqmQ7LLC0OfB5ePqMnE5UNqM1tumvo7M1HtlI+iNrHW7a/WztW/23pvkuYy6NWk8vxf13+23UgUarSE2j3Vfnq1eth2yo5rF9QPnuNfqf0J3b2gzp1qs3PdfuBfp3DTsT5fjfPKETX+SzFwOQau/gsGnbqPf1211i0rWU1eQf2mX6eXek31+qtJj7O7lqg2qyXvU2t7rxyFlOPqcxDUZuWgJhAYdeOn2vXf3o5b0y4soMtRu3Pse1d9XgQ2gNaj1P62ZX0dG3Tqc+ri9S8UF/eoyZ4+V31NBjVVk6jg1uoXierNwTfCvC8TuelqnIeXQ+JO9f2wxRPQ4kl1yiBzXLsAibvUL6xJu9QvPAWv96AmaqJXs5v6XuaEXRgksXNMVquxa9CgAevWrSv3ygdjx47l77//5u2336Zfv37ExMRQv359fvjhB6ZNm2ZyVK2zstkLo+Abbupp9Rtk6in176vH1GTDkK++8QU2VBMIrb/6IesTrCZNoe0dr6+bokB6nFpTlrBFnactLRbQqG/ctXuqv6uGgi4XdNlqM6Y+D7x8wdNPTRb8aoNfrZKnXVEMcHEfxG1U+xJe2KEmYXX7QuMH1Bq08nzb1uWqj/+lGPV/AGqfnOrN1AEn5Wm2dUYGnfpcvHJUTX5TTkDK9edo9k1zTXpXK5zw3Zz4+QRXjsfKlaSeUZOkmGXq/7luP2j7ItTrZ933GX2++rwqSPQu7lFvF/SF0wZcT/Ka3Uj2gpqoteiZiWoSF7sRzvyoHlO3D7R6BurfZ3lLRUEfwqRdasKXuENNRBWD+vqv0VJ9X9Lnqq8TRa++b/lUV2u9/SNvfPHxr2v3/nyS2DkmqyV2K1as4Ouvv+Z///sfQUFlrz2JjIxk7dq1REdH4+fnx8GDB6lfvz6nTp2iXbt2pKenl3isTqdj9erVKIrC448/XupExY7Gqi+Mi/vVuckKkrn8aze2+UZc/2BsqHZ2D2mrJhMVXQtnbWlxN5K8c39eT/RuoXEr2hcGjfqY+NVR3yyrhqnfpFNOqs08+dfUZtTIu9SauQYDwTvQ1lcjctOuP39v/kJy/efahRv7efqqz+eAeur/79Yf76AbiZ+iqIlE6mm1KS83TU32DTq1Gc3LT/3xCVafE1XDHbNPpzNKi1WTpH/XqLXunr5qzVzb0RDUuOLiMOjVWAq+TFw5orZaXD12o++ekUat5YsaBM0eV78E2lJOqtoace5PtVZfMajJnZun+t6Vl6F278i6BBkJ6pdyUJ+7NVpAcJvrXTxaq+/p2opLsCSxc0xWS+zatm3LqVOnyM/PJzIyssh0Jfv27Sv1+CpVqnD48GHq169fKLE7ePAg3bt3Jy0trcRjX375ZW677TZ0Oh3bt29n4cKF1rikCmHNF8bVE39x+LdPr9e8VVd/e1dXaz4qy6TA+jz1W7abh/rGWDDIQNGrb+C6bPWNNLfgJ01dlSEvQx1p5xV4PeGrrf5UohFuDk+fp/Zjyrk+Ujf7CuSmqP/PvLQbzdyg/u+1geqHZF4GGG5a4lDjpvaH1LjdqBW5lbv3jYTPs6r64+ULHlXV5MTTR/1gLfix92AWc+nz1VrvnKtqU6MhX32MNBr1mm++Lncf9bZiUEdBZ16ErOs/umz1sdNowM3reiLiBR5a9W9FURORvDRAoza3hrRVm0Zt0T+3vBSD+pzKvqw+Fp5VoUooeFap8FAaNWpEWFhY6TsZdGpyl3JKHbWefECt8bty9EbCF1APqrdQk76Cn2qN1f+NlUli55is9m40aNAgi47v2LEjP/30Ey+++CJwYymyjz/+mC5dupR6rMFgICsrCzc3NwyGW2tmKo80z5rszm4B2UAKQOb1H8daH9dxBFz/uU4P5AIZQOIlQJagc1xaIOL6D+o7mWJQkzSDXv2dpQcNahLndv1H41G4CdcdQFETkYLjFYNaRrYBMq/fxgBKBiglfcHUXE8YNYDbjb81btdvF2x3u2nfgr81agwFcRf8NtYyKzftd9OxNyeopTVlGvSgz1G/2OjzbiqvIF73649BDihZ17cXd4lu4FYd3EJvxK4AegXyrz9+BY8lgFutG0lflhvE5ULcgZLjdAjZwOUKP2tWVhZXrlxh8ODBpe/o5qEmbgH1oO5dN+7X56m1fZcOqssJXjkCRz+Da+fU7Rp3dUL4ao3VwV4tRqpN4MIl2XRUbFls376dfv368cgjj7By5UqeffZZjhw5wo4dO9i6dSvt27cv8dj8/HzWrl2Loig8+OCDeHlZXjs1d+5c1q1bx7///ouPjw9du3blzTffpHHjG80HiqIwY8YMli1bRkpKCp07d+b999+nefPmZp9HvvEI4UQMOrV2J/uKWtOTm1L4d07K9dqwm24X/F2kye86jypq4lWQyGnc1QE53tXVD3KNu1obk5ehdhfITSvczaKgDN8ItdnQt6badzMzCRL/UWvobp4rsl5/tRm0pGRQl1s4flAnpK5SwyoPoShq1apV+Pn5MWTIEOsWnJN6vfn5sNqvN+WEmui3eQEaDrK4ePn8ckxWTexSU1P55ptvOH36NP/9738JCgpi3759hIaGUrOm6RnxDx06xFtvvcXevXsxGAy0a9eOV155hZYtW1orRLP169eP//znP3Ts2BGdTsfkyZM5dOgQR48eNTYzv/nmm8yePZuVK1fSqFEjZs2axZ9//snx48fx8zNvTiV5YQhRSeRnX0+YrhZN+jx81ObKgPpqFwBTzZX5meqI48zrP9cuqCOxM86pv7Mvqf1Ga7RSVyap00tWd3FgNkvsbEw+vxyT1RK7mJgY7rzzTgICAoiLi+P48ePUr1+fKVOmcPbsWVavXm2N09jNpUuXCAkJYevWrXTv3h1FUYiIiGDcuHG88sorAOTm5hIaGsqbb77Js88+a1a58sIQQojKTRI7YU1WG2M+YcIERowYwcmTJ/H2vrHcS//+/fnzzz/NKkOv1/PNN9/wxhtvMGvWLL799lt0Op3pAytAweCNghG/sbGxJCUl0adPH+M+Wq2WHj16sH379hLLyc3NJT09vdCPEEIIIYQ1WG3wxO7du/noo4+K3F+zZk2SkpJMHn/48GEGDhxIUlKSsR/biRMnCA4O5ocffii1OTY+Pp46deqYHev58+fNahouoCgKEyZM4PbbbzdOwFxwTaGhoYX2DQ0N5ezZsyWWNXfuXGbMmGH2uYUQQgghzGW1Gjtvb+9ia5+OHz9OcHCwyeOfeuopmjdvzrlz59i3bx/79u0jISGBVq1a8cwzz5R6bMeOHXn66afZtWtXifukpaXx8ccf06JFC9atW2f6gm4yevRoYmJi+OKLL4psu3W5NEVRSl1CbdKkSaSlpRl/EhISyhSLEEIIIURJrFZjN3DgQGbOnMlXX30FqAlPfHw8r776KkOHDjV5/MGDB9mzZw/Vqt1YRqhatWrMnj2bjh07lnrssWPHmDNnDv369cPT05MOHToQERGBt7c3KSkpHD16lCNHjtChQwcWLFhA//79zb6uF198kR9++IE///yTWrVuTFRZMN9QUlIS4eHhxvuTk5OL1OLdTKvVotVafz4hIYQQQgir1di99dZbxgEG2dnZ9OjRg6ioKPz8/Jg9e7bJ4xs3bszFixeL3J+cnExUVFSpxwYFBfHWW29x4cIFPvzwQxo1asTly5c5efIkAI888gh79+7l77//NjupUxSF0aNHs27dOv744w/q1atXaHu9evUICwvj119/Nd6Xl5fH1q1b6dq1q1nnEEIIIYSwJqvV2Pn7+/PXX3/xxx9/sG/fPuN0JXfeeadZx8+ZM4cxY8Ywffp0oqOjAdi5cyczZ87kzTffLNTMW9LoG29vb4YMGWKVkUUvvPACa9as4fvvv8fPz8/Ypy4gIAAfHx80Gg3jxo1jzpw5NGzYkIYNGzJnzhyqVKnCww8/bPH5hRBCCCHKymEmKHZzu1F5WNBHrSC0m29rNBr0+mKWALKykvrJrVixghEjRhjjmTFjBh999FGhCYoLBliYQ4aLCyFE5SbTnQhrsuoCh7///juLFy/m2LFjaDQamjRpwrhx48yqtdu8ebM1Q7GYOfmuRqNh+vTpTJ8+3fYBCSGEEEKYYLXEbsmSJYwfP57777+fsWPHAmpT6t13382iRYsYPXp0qcf36NHDWqEIIYQQQlRKVkvs5s6dy+LFiwslcGPGjOG2225j9uzZJhM7gJycHGJiYkhOTsZgMBTaNmDAAGuFKoQQQgjhkqyW2KWnp9OvX78i9/fp08e45FZpNm7cyOOPP87ly5eLbKuofnVCCCGEEM7MatOdDBgwgPXr1xe5//vvv+e+++4zefzo0aMZNmwYiYmJGAyGQj+S1AkhhBBCmGa1GrumTZsye/ZstmzZQpcuXQC1j93ff//NSy+9xLvvvmvcd8yYMUWOT05OZsKECaVO7iuEEEIIIUpmtcTu008/pVq1ahw9epSjR48a7w8MDOTTTz813tZoNMUmdvfffz9btmyhQYMG1gpJCCGEEKJSsVpiFxsbC8Dly5fRaDRUr169TMcvWbKEYcOGsW3bNlq2bImnp2eh7cUlg0IIIYQQ4garJHapqalMnjyZtWvXkpKSAqjrvP7nP/9h1qxZBAYGmixjzZo1bNq0CR8fH7Zs2VJoguCSavmEEEIIIcQNFid2V69epUuXLpw/f55HHnmEpk2boigKx44dY+XKlfz+++9s376datWqlVrO66+/zsyZM3n11VcLrUIhhBBCCCHMY3FiN3PmTLy8vDh9+nSRgQ8zZ86kT58+zJw5k8WLF5daTl5eHg8++KAkdUIIIYQQ5WRxFvXdd9/x1ltvFTuaNSwsjPnz5xc7Dcqthg8fztq1ay0NRwghhBCi0rK4xi4xMZHmzZuXuL1FixYkJSWZLEev1zN//nw2bdpEq1atigyeWLRokaWhCiGEEEK4NIsTuxo1ahAXF0etWrWK3R4bG2vWCNlDhw7Rtm1bAA4fPlxo280DKYQQQgghRPEsTuz69evH5MmT+fXXX/Hy8iq0LTc3lylTphS71NitNm/ebGkoQgghhBCVmsV97GbMmMHx48dp2LAh8+fP54cffuCHH35g3rx5NGzYkGPHjjF9+nSzyzt16hSbNm0iOzsbAEVRLA2x3P7880/uu+8+IiIi0Gg0fPfdd4W2jxgxAo1GU+gnOjraPsEKIYQQotKzuMauVq1a7Nixg1GjRjFp0iRjIqbRaLjrrrtYsmQJtWvXNlnOlStXeOCBB9i8eTMajYaTJ09Sv359nnrqKQIDA1m4cKGloZZZZmYmrVu3ZuTIkQwdOrTYffr168eKFSuMt2+ttRRCCCGEqChWmaC4Xr16/Pzzz6SkpHDy5EkAoqKiCAoKMruM8ePH4+npSXx8PE2bNjXe/+CDDzJ+/Hi7JHb9+/enf//+pe6j1WoJCwszu8zc3Fxyc3ONt9PT08sdnxBCCNdw6NAhsypBrKFOnTqyLrsLs9qSYqCuNtGpU6dyHfvLL7+wadOmIoMwGjZsyNmzZ60Rnk1s2bKFkJAQAgMD6dGjB7NnzyYkJKTE/efOncuMGTMqMEIhhBCOrGAQ4qZNmyrkfH369JHEzoVZNbGzRGZmJlWqVCly/+XLl9FqtXaIyLT+/fszbNgwIiMjiY2NZcqUKfTu3Zu9e/eWGPOkSZOYMGGC8XZ6enqFfUsTQgjheO655x7uuecee4chXITDJHbdu3dn9erVvPHGG4DaR89gMLBgwQJ69epl5+iK9+CDDxr/btGiBR06dCAyMpKffvqJIUOGFHuMVqt12ERVCCGEEM7NYRK7BQsW0LNnT/bs2UNeXh4vv/wyR44c4erVq/z999/2Ds8s4eHhREZGGvsZmqNgsIn0tRNCCOFMCj637Dl7hSjKYRI7X19fDhw4wEcffYS7uzuZmZkMGTKEF154gfz8fHuHZ5YrV66QkJBAeHi42cdkZGQASHOsEEIIp5SRkUFAQIC9wxDXaRQHSbXd3d1JTEwsMvDgypUrhISEoNfrKzyma9eucerUKQDatm3LokWL6NWrF0FBQQQFBTF9+nSGDh1KeHg4cXFxvPbaa8THx3Ps2DH8/PzMOofBYODChQv4+fnZdYWNgr5+CQkJ+Pv72y0OS8g1OAa5BsfgCtcArnEdrnoNiqKQkZFBREQEbm4WT4srrMRhauxKyi+vXbuGt7d3BUej2rNnT6H+fQWDHoYPH86HH37IoUOHWL16NampqYSHh9OrVy/Wrl1rdlIH4ObmVuJybPbg7+/vtG88BeQaHINcg2NwhWsA17gOV7wGqalzPHZP7AqSJY1Gw9SpUwuNjNXr9fzzzz+0adPGLrH17Nmz1L4DFTU0XQghhBDCHHZP7Pbv3w+oNXaHDh0qtHKDl5cXrVu3ZuLEifYKTwghhBDCadg9sdu8eTMAI0eO5J133nH6ampnpdVqmTZtmlNPxSLX4BjkGhyDK1wDuMZ1yDWIiuQwgyeEEEIIIYRlZBiLEEIIIYSLkMROCCGEEMJFSGInhBBCCOEiJLETQgghhHARktgJIYQQQrgISeyEEEIIIVyEJHZCCCGEEC5CEjshhBBCCBchiZ0QQgghhIuQxE4IIYQQwkVIYieEEEII4SIksRNCCCGEcBGS2AkhhBBCuAhJ7IQQQgghXISHvQOo7AwGAxcuXMDPzw+NRmPvcIQQQgizKIpCRkYGERERuLlJPZGjkMTOQn/++ScLFixg7969JCYmsn79egYNGmT28RcuXKB27dq2C1AIIYSwoYSEBGrVqmXvMMR1kthZKDMzk9atWzNy5EiGDh1a5uP9/PwA9YXh7+9v7fCEEEIIm0hPT6d27drGzzHhGCSxs1D//v3p37+/2fvn5uaSm5trvJ2RkQGAv79/xSR2J9dD+lnLyqjXH4IaWyee8jj3J1zcV/o+9e+FalHFb8u6BP9+CYq+/DF4+UHzEeDmXvz2+M1w6WD5y7cGL39oMQI0JTSRnP0dLh8qvYyoQRBQ18qBWVHyAUjYUvo+tbpDaLsKCKYEF/epz9nS1O4FIa3LV76iwJFVkJta8j4e3tDscfCsUvz2pN1w/u/Sz1PnDghuWfy23DQ4+j8w5JsVcvEx+kDz4WqstpCTAsc+B4Ou/GV4VoFmw8FDW77jU07Bmf8rfZ/QdupztrxOroP0+NL3qd0TQtqU/xy3kG5EjqVciZ1er2f9+vUcO3YMjUZDkyZNGDRoEB4ekieaMnfuXGbMmGGfkxv08MNQcPcCN8/ylaHLUhOWfiusG1tZ/DYKUo6DewkfAPmZcPUY3PVR8duPfQ5bxoOnb/nOr+hBlw2hHUr+MP7tWUiLA/dyfgBYqiDGiC5QvWnx+/zyJFy7UHKM+ZmQkQA9F9ouTkv9PQVif1aTguLostWE5P5NFRvXzbZNgvjfS4+xXn8Y/GP5yk87A5tGqgmRppj3YMWgvm796kD9u4sv48+X4dy2UmLMggYDYeC64ref+T/4YzR4VgXK8SFfEGNgA4i8s+zHm+PUd/DHixa87q/HGNSk/InXngUQ8/H1x6kY+hyo1hhGHC5f+fo8+OF+0+/xPRZYNbETjqXMmdjhw4cZOHAgSUlJNG6s1tqcOHGC4OBgfvjhB1q2LOEbnQBg0qRJTJgwwXi7oCq7Yijqz10fqd+My+PL7pbVdFmDQQftxqlvTsVZE60msaUdrw2E0SnlO//F/fC/dqU/DgYddPwv3D67fOewVOI/6uNgKsbOr0HX6cVvX9XS/v9rUww6tVZxwDfFb/+/hyD7UoWGVISig8YPwD1rit/+w1A1uSuvghqoob9CrduLbs+8CEvDTD8Xmj0K/VYWv339faaPBxidCm7l+IKfngAf17Ht882gAzQwJqN8x6eegU8blP7eYk4M4Z3h4R3Fb98yEWJ/Kn/5yvX3+D4fQ7PHyl+OcGplfgU+9dRTNG/enD179lCtWjUAUlJSGDFiBM888ww7dpTwhL3F77//zu+//05ycjIGg6HQtuXLl5c1LKeh1WrRau1Vi6M4VjnlD8DCfawVfynl2P0xuq7UOMyI0VGuo0SWPhcqgDmPoSWPs7nHlrafpTE6xXtLBbzuTR5q69eco79eRUUoc2J38ODBQkkdQLVq1Zg9ezYdO3Y0q4wZM2Ywc+ZMOnToQHh4uLTPCyGEEEJYQZkTu8aNG3Px4kWaN29e6P7k5GSiokrorH6LpUuXsnLlSh57TKqKK1bBtzkLEmmNBvt/K1Qo/Ro0pmsXLPkyUXCsydowe35hKTi3qVoWE4+j3f/XJpj6X2pMPBcqhK0f5+vHlvQ4aMx4Llgco4XvLWbFaKEKed2bDIJSHyNL318VK7zHC6dX5sRuzpw5jBkzhunTpxMdHQ3Azp07mTlzJm+++Sbp6enGfUsa5ZmXl0fXrl3LGbJjuXbtGqdOnTLejo2N5cCBAwQFBVGnTh07RiaEEEKIyqbMid29994LwAMPPGBsQlWuf0u47777jLc1Gg16ffGdTJ966inWrFnDlClTyhW0I9mzZw+9evUy3i4YGDF8+HBWrlxpp6hKoJj4Zm8WB6gBMfnN25zaBQsfA2M5JZ3CwtoBS5lbq+jwtV2mOEGto81rFU3V0pjxXDBVe6vRqKNCSz0eC57z1qgNM6UCXvfmxGDRe5cZ5YN933uE3ZU5sdu8ebPFJ83JyWHZsmX89ttvtGrVCk/PwsOyFy1aZPE5KkrPnj2Nia0QQgghhD2VObHr0aOHxSeNiYmhTZs2gDp9ys1kIIUtVZI+dqZiNNm3zATpY+c4zKppsvc12PhxNllbZmYfO1M1SWaNsJY+diZjsOnzVfrYiXJOUJyTk0NMTEyxU5UMGDDA5PHWqPUTQgghhBCFlTmx27hxI48//jiXL18usq20fnUlOXfuHBqNhpo1a5Y1FFFWlamPnSV9y0yyRm2YjVmjj50j/K9NsnWfJSuw+Plq8gQ3yim2eCuMijWrFhwLXlfSx+7GOWRUrLBMCYtIlmz06NEMGzaMxMREDAZDoR9zkzqDwcDMmTMJCAggMjKSOnXqEBgYyBtvvFGkBlAIIYQQQpinzDV2ycnJTJgwgdDQ0HKfdPLkyXz66afMmzeP2267DUVR+Pvvv5k+fTo5OTnMnm2nZZhcnvSxM+t4U6xSG2ZrVqhVdIj/tSku0MfOWnOXmepjZ9Hcjub2sSsnZ+hjZ40au4rqYyd91Su1Mid2999/P1u2bKFBgwblPumqVav45JNPCvXHa926NTVr1mTUqFGS2AkhhBBClEOZE7slS5YwbNgwtm3bRsuWLYtMVTJmzBiTZVy9epUmTZoUub9JkyZcvXq1rCEJs1mj/4UDfBM0ax47E6zyzd1a+9mCmbULjt4/zRSL5zSsADaP0dw+dqbKMFWraMHxJlXUa8UKNfUWh1ARz1cHeJ8WdlPmxG7NmjVs2rQJHx8ftmzZUmh6Eo1GY1Zi17p1a5YsWcK7775b6P4lS5bQunXrsoYkKprdm7bMUBELlpu1xJIjc4YYhfVY+v+ugOeLzQdPWKMYayThNuIM783C5sqc2L3++uvMnDmTV199FTe3Mo+9AGD+/Pncc889/Pbbb3Tp0gWNRsP27dtJSEhgw4YN5SpTmMFao2LtztLaBUo/3uShZh7r8CtPgOP3TzPFRfrYWTw3GmbMY2eiDEtqwa01R5ytOcR7XwU8X6WPXaVW5swsLy+PBx98sNxJHaiTHJ84cYLBgweTmprK1atXGTJkCMePH6dbt27lLldUFHt/UJqjAmrTKqRW0IacIUZhPZb+vyvk+WLjwRPWKcgBYijxBDYuXziDMtfYDR8+nLVr1/Laa69ZdOKIiAgZJFHhrDUq1s6kj10Zzm1BjZ0j9E8zxVn62Nn0cZY+dhVyHuljJ5xEmRM7vV7P/Pnz2bRpU5nWeY2JiaFFixa4ubkRExNT6jlatWpV1rBEhXLwD3uQPnZmcYYYhfVIHzvrFCN97IRjK3Nid+jQIdq2bQuUbZ3XNm3akJSUREhICG3atEGj0aAU8yQsafWKtm3bmr2O7L59+8zar9JxqT52pXCEWkVHYeqN3tRj5fAfFGbUhtn9GkzUKjpKH7tS2fp5UplesxXwmpP3wEqtzIldedd5jY2NJTg42Ph3WQ0aNKhc5xU2YPcPSjD9QWDDCYqtMuGrjZnd/GZpGcJp2DrJt8rzxdY1do4wQXFpp7D0MXSE92Zhb2VO7MorMjLS+PfZs2fp2rUrHh6FT6/T6di+fXuhfQtMmzbN5jG6PhfqY1cqB4jRYVj6WDn4B4WpBNohVs9wlj52pbHx88QR3lcqiln9FS0+iRXKEM6qzIldr169Sm0S/eOPP8wqIzExkZCQkEL3p6Wl0atXL7PXnBX2Yu8PSrCoOcNqUzPYslbQUhXQ/CacjK2TNwevsbPW696mfewsfAwdojVF2FuZE7s2bdoUup2fn8+BAwc4fPgww4cPN6sMRVGKTQ6vXLlC1apVTR6v1+tZvHgxX331FfHx8eTl5RXaLqtXlED62FU+0scOu38RMadW0SrJgg372Nn8eVKZXrPSx07YVpkTu8WLFxd7//Tp07l27Vqpxw4ZMgRQB0iMGDECrVZr3KbX64mJiaFr164mY5gxYwaffPIJEyZMYMqUKUyePJm4uDi+++47pk6dWoarEeXiCB/2FjVnVEBfG+ljJxyNxTW0FfB8sfmoWAfvY2dxgusA783C7so/y/AtHn30UZYvX17qPgEBAQQEBKAoCn5+fsbbAQEBhIWF8cwzz/C///3P5Lk+//xzPv74YyZOnIiHhwcPPfQQn3zyCVOnTmXnzp3WuiQX5CJ97CqkSchVSB87+38RsXGtoqmaeOlj52Ckj52wLasNntixYwfe3t6l7rNixQoA6taty8SJE81qdi1OUlISLVu2BMDX15e0tDQA7r33XqZMmWJWGQkJCcTFxZGVlUVwcDDNmzcvVIMoSmPvD0qwuI+dNZLbUhMG6WMnHI2tm1ulj50ZQZh3jnIX7wjvzcLeypzYFTSnFlAUhcTERPbs2WN2UmXpCNdatWqRmJhInTp1iIqK4pdffqFdu3bs3r271OTs7NmzLF26lC+++IKEhIRC8+h5eXnRrVs3nnnmGYYOHWrRkmkOz+n72JniDDE6CJeoKTFVG+YATI7ctcpJynh/WYq29ePoIP+nilAhr7lK9HiKIsqcvdzcfBoQEEBQUBA9e/Zkw4YNZUrYvvnmGx544AGio6Np165doR9TBg8ezO+//w7A2LFjmTJlCg0bNuTxxx/niSeeKPaYsWPH0rJlS06ePMnMmTM5cuQIaWlp5OXlkZSUxIYNG7j99tuZMmUKrVq1Yvfu3WZfi9Ow1rc5e38rNOubt4naNKsktzasFbSU2bWKpRZi//+1SebE5wDPV2vsU/LBVtjPnOdrBfQpdfU+dmY1eVfEc0G4sjLX2BU0p1ri3XffZfLkyQwfPpzvv/+ekSNHcvr0aXbv3s0LL7xg8vh58+YZ/77//vupVasW27dvJyoqigEDBhR7jJeXF6dPnzZOknyzkJAQevfuTe/evZk2bRobNmzg7NmzdOzYsfwX6dCcvY+dCc4Qo8NwhceqImrDLFUBtYqWrDxhunArlFFa8Y7yf6oIFXCtlerxFLcqdx+7PXv2cOzYMTQaDU2bNqV9+/ZmH/vBBx+wbNkyHnroIVatWsXLL79M/fr1mTp1armmKomOjiY6OrrUfRYsWGB2eXfffXeZY3AOrvJtzhq1YRWQ3Nr1zdUKtQsOMbmvCTavDbMGG9cqWuP6LK5xs3efUjM5ejcUhxjsI5xdmRO7c+fO8dBDD/H3338TGBgIQGpqKl27duWLL76gdu3aJsuIj483Tmvi4+NDRkYGAI899hjR0dEsWbLEZBknTpxgy5YtJCcnYzAYCm2TKU9MsfTNzdHfeEzFWBFN0o7+GGH/KVmspdRrcJDrq5AYTYyKtSRhsHnCYY1mThMcoSuKzV9zVpj5QDi9Mid2TzzxBPn5+Rw7dozGjRsDcPz4cZ544gmefPJJfvnlF5NlhIWFceXKFSIjI4mMjGTnzp20bt2a2NjYQgMaSvLxxx/z/PPPU6NGDcLCwgpNdqzRaCSxK4mrfBO0xptjhXxzd4AaO4v+586QxEsfO+tcn6U1bk5SY+fw3VCc4TUnHF2ZE7tt27axfft2Y1IH0LhxY9577z1uu+02s8ro3bs3P/74I+3atePJJ59k/PjxfPPNN+zZs6fIqNvizJo1i9mzZ/PKK6+UNXwBlic1jp4gmqpdsFr8Tl5j5zQfxqY4eR87a8Voso+dAyf5VplKxJSKeN2bc6wNn5NWWV1IOLsyJ3Z16tQhPz+/yP06nY6aNWuaVcayZcuMzafPPfccQUFB/PXXX9x3330899xzJo9PSUlh2LBhZQtc4BzJhjmkj53553bk5jdrkD52DtHHzlma9aWPnagEyjzdyfz583nxxRfZs2ePsdl0z549jB07lrfeesu8k7q54eFxI6d84IEHePfddxkzZgxeXl4mjx82bJhZTb7mOHfuXJE+eq7P0qTG0d94HKCPnTO8OTvLh7EpztDHrkLm2pM+dqWqkJp6M2KQPnbCxspcYzdixAiysrLo3LmzMTnT6XR4eHjwxBNPFJpH7uYRrjExMWafo1WrVqVuj4qKYsqUKezcuZOWLVvi6elZaPuYMWPMPlezZs04cOAA9evXN/sY5+UEyYY5pI9dGc7twM1v1mDWh7UT9LGz+9xl0sfO9KHSx044hzIndm+//Xa5TtSmTRs0Go3JwREajQa9Xl/qPsuWLcPX15etW7eydevWIseXJbEzZ7CGy7E4qXHwx0z62JnJWT6MTXGCGruKWHlC+tiZ4ACjYqWPnagAZU7shg8fXq4TxcbGlus4W5dVqbhMEusq11EBLP2fO/xzxkX62Fk6hYalXP554kTksRQWKvcExWUVGRlZUacqk9dee42goCB7h+FcHOKNx8IlxazRJGOqVtAhBk+UxsT/Ub71uxZTr1tT/29LjzeLrfvY2XlJMZs/ho7w3izsrcISu5utXr261O2PP/54qdsnTJhQ7P0ajQZvb2+ioqIYOHCgWQnbpEmTTO7jOqzQsdYRPuxNJpYOEKPDsPSxcvAPClMJtEMM9jGVUFgao4nXdYUk+ZY+xpXoNWvzxxIq1eMpirBLYjd27NhCt/Pz88nKysLLy4sqVaqYTOz279/Pvn370Ov1NG7cGEVROHnyJO7u7jRp0oQPPviAl156ib/++otmzZrZ8lIqKXt/UILJNy6b1qaZ883d3v3XzDi3JMiVjK2TfAevscPC171V+gHa+DF0iNYUYW9lnu7EGlJSUgr9XLt2jePHj3P77bfzxRdfmDx+4MCB3HnnnVy4cIG9e/eyb98+zp8/z1133cVDDz3E+fPn6d69O+PHj6+Aq3EiVulY6wgf9tKEaDZbN7/Zna1rw6zAnFpFq/SxMzV4wpwySmLr50lles1WwGtO3gMrtTIndk888YRxbdebZWZmFprqpKwaNmzIvHnzitTmFWfBggW88cYb+Pv7G+/z9/dn+vTpzJ8/nypVqjB16lT27t1b7nhEKRzhw96i5owK6GsjfeyEo7F18maN54vNR8U6eB87ixNcB3hvFnZX5sRu1apVZGdnF7k/OzvbZN85U9zd3blw4YLJ/dLS0khOTi5y/6VLl0hPTwcgMDCQvLw8i+JxPS7Sx65CmoRchfSxs/8XkQrqY1fS42CNJN/WzxOHeF+pKNLHTtiW2X3s0tPTURQFRVHIyMjA29vbuE2v17NhwwZCQkLMKuuHH34odFtRFBITE1myZIlZ680OHDiQJ554goULF9KxY0c0Gg27du1i4sSJDBo0CIBdu3bRqFEj4zHx8fHUqVPHrPgAzp8/b/YSaZWPvT8owa597MzqayN97ISjsfUACQfvY1chr3uTQVDq42Rpgmv3LzHCEZid2AUGBqLRaNBoNIUSpgIajYYZM2aYVVZB8nXzscHBwfTu3ZuFCxeaPP6jjz5i/Pjx/Oc//0Gn0wHg4eHB8OHDWbx4MQBNmjThk08+MR7TsWNHBgwYwNNPP02nTp2KLTctLY2vvvqKd955h2effZYXX3zRrOtxGq7Sx04SEvNJHzvs/kXE5rWKVuhjZ2nSJ33szFcRo2IrVQ2ouJXZid3mzZtRFIXevXvz7bffFppKxMvLi8jISCIiIswqy9K1WX19ffn4449ZvHgxZ86cQVEUGjRogK+vr3GfNm3aFDrm2LFjzJkzh379+uHp6UmHDh2IiIjA29ublJQUjh49ypEjR+jQoQMLFiygf//+FsXo0hzhw1762JVO+tiJW1n8hUj62N0ox5IYzDmHrcoXlYHZiV2PHj0AddWH2rVr4+ZmlwG1hfj6+ppcV7ZAUFAQb731FrNmzWLDhg1s27aNuLg4srOzqVGjBo888gh9+/alRYsWNo7anipJHzuH6FflKCpBHztTTVt2fy7YuFbRVE28Oa9ZWyd9pjjE+0pFqYha8sr0eIpblXkeu4IVJLKysoiPjy8yQKGkRKukSYWLs2jRoiL3DRkyhJUrV+Lv78+QIUNKPX7dunUlbvP29mbIkCEmyxCOztI3ropIbh28j12FlCGchsXJlRM8X6zRx86WKlWCK2ylzIndpUuXGDlyJD///HOx2/V6fbH379+/v9DtvXv3GicYBjhx4gTu7u60b9++2OMDAgLQXH/SBwQElDVsAVbsY+cAfZZKZSJGa9XgmBw84QAsHURi99ouU0xdg4M8X03FaNM+drfuV9ZtmK75tFofOxsPnrB3OYoCbras/bRCq4xwemVO7MaNG0dKSgo7d+6kV69erF+/nosXLzJr1qxSBz5s3rzZ+PeiRYvw8/Nj1apVVKtWDVAnLR45ciTdunUr9vgVK1YY//7ggw8wGAxUrVoVgLi4OL777juaNm1K3759y3pJwhlZ+s22QgaQOHofO5OFWKEM4TwqQY2dVfrY2ZIzPIbC0ZU5sfvjjz/4/vvv6dixI25ubkRGRnLXXXfh7+/P3Llzueeee0yWsXDhQn755RdjUgdQrVo1Zs2aRZ8+fXjppZdKPX7gwIEMGTKE5557jtTUVKKjo/H09OTy5cssWrSI559/vqyXVUlY49uco/RZKoVGA4aKqE1zgho7iweROMp1lMQF+thZup6tWTXxltZim4rRSn3sbD54wt7lmPGas8YqJNKkW6mVeQREZmamcb66oKAgLl26BEDLli3Zt2+fWWWkp6dz8eLFIvcnJycXu6rFrfbt22es2fvmm28IDQ3l7NmzrF69mnfffdfcSxFOzQn62Nn1zdUK55YPh8rFrrXgFcTRp3pyhsdQOLwyJ3aNGzfm+PHjgDqlyEcffcT58+dZunQp4eHhZpUxePBgRo4cyTfffMO5c+c4d+4c33zzDU8++aRZgxqysrLw8/MD4JdffmHIkCG4ubkRHR3N2bNny3pJlYi1RsU6QJ+lUtm4dsGcOOxeS1TA0ilZHOU6SmBO/zV7X4OpkbvWWnnCoppLS0eaV6I+dpbWrtr0NSd97EQ5+9glJiYCMG3aNPr27cvnn3+Ol5cXK1euNKuMpUuXMnHiRB599FHy8/PVQDw8ePLJJ1mwYIHJ46Oiovjuu+8YPHgwmzZtYvz48YBa43fz+rHChUkfuwo4t3w4VC7Sx670Q6WPnXAOZU7sHnnkEePfbdu2JS4ujn///Zc6depQo0YNs8qoUqUKH3zwAQsWLOD06dMoikJUVJRxMIQpU6dO5eGHH2b8+PHccccddOnSBVBr79q2bVvWS6o8XGVUrN1H8JkTh70fo+ssXfbMYWoeS2JGbZjdr8HGK084Qh87Sx9jZ+pjZ8slxSwtX/rYCcqR2BXIy8sjNjaWBg0a0K5du3KVUbVqVYKCgtBoNGYndQD3338/t99+O4mJibRu3dp4/x133MHgwYPLFYsQQgghhLMrcx+7rKwsnnzySapUqULz5s2Jj48HYMyYMcybN8+sMgwGAzNnziQgIIDIyEjq1KlDYGAgb7zxhtnLjYWFhdG2bdtCK2B06tSJJk2alPWSKhEr9bGzdw2IxX2WLFxayJzaBYdZUsyCFQUcoT+lKeasw2r3a3CSPnYW1Spa+nyvqD52do7R5s9X6WMnypHYTZo0iYMHD7Jlyxa8vb2N9995552sXbvWrDImT57MkiVLmDdvHvv372ffvn3MmTOH9957jylTppQ1JCGEEEIIQTmaYr/77jvWrl1LdHS0cSUIgGbNmnH69Gmzyli1ahWffPIJAwYMMN7XunVratasyahRo5g9e3ZZwxLmcKU+dpbULlhcm2bON3dLawcsZaJW0dx+WfaunTXJ1rVhVmBOLY1D9LGz5fEmVFQfO2ssKWbTPnYV8VwQrq7MNXaXLl0yzmN3s8zMzEKJXmmuXr1abJNpkyZNuHr1allDEkIIIYQQlCOx69ixIz/99JPxdkEy9/HHHxtHp5rSunVrlixZUuT+JUuWFBoMIWzFyfvYAXbtY2eqNqxgm0P0sSuJmf2ynIHJPkuOwNTz1cbnMOd1a2ntrVUea1uPinWAPnY2fc1JHztRjqbYuXPn0q9fP44ePYpOp+Odd97hyJEj7Nixg61bt5pVxvz587nnnnv47bff6NKlCxqNhu3btxMfH8/PP/9c5osQ5nKEhMwaXOU6KoKlj5WDP9bmfMmw+xcRc85vjQ7zlnDx54lTkcdSWKbMNXZdu3bl77//JisriwYNGvDLL78QGhrKjh07aN++vVll9OjRg+PHjzNkyBBSU1O5evUqQ4YM4cSJE8alwoQNOX0fO7Con4qltWlmjTh1kD52JTG7X5YzcIJrqJBaRUv7Glo6WtMaExzbeFSsI/Sxs+VrTvrYCco5j13Lli1ZtWqVRSeuXr06AwYMIDo62jjFyZ49ewAKDaoQVmT3mgsrcZXrqAiWPlYO/1jbujbMCmxeq2iF63P554kzkcdSWMbsxC49Pd2s/cxZ0mvjxo08/vjjXLlyBeWWNwSNRoNerzc3LFEujr6sjhksrgGxRl8bU7s5ch87445WKMPenOEaKqBW0aavCTOOt+syf2afxE7HmltORZxDuDqzE7vAwMBSR70qimJ2UjZ69GiGDRvG1KlTCQ0NNTcEYTFHWFLHKgFYuE8FLClm98eoQElxmBufo1xHCaSPnfnXZ3J5OZMFWHi8OadwgiXFbN0f0t61t8LpmZ3Ybd682fi3oijcfffdfPLJJ9SsWbPMJ01OTmbChAkuk9QVrHubmJhI8+bNefvttx27r6BV5nCzN0u/9VZEraUD97Ez7uYE/dNMcYZrqJAYbVjjZvNacGscb84pHKC1wu79LYWrMzux69GjR6Hb7u7uREdHU79+/TKf9P7772fLli00aNCgzMc6mrVr1zJu3Dg++OADbrvtNj766CP69+/P0aNHqVOnjr3DK8xq34adoM9SRdSmWVwDUgFMTVBc3uMdhvSxs07tq4UxOsN7S4W87q1xbAXU3gqXVq7BE5ZasmQJw4YNY9u2bbRs2RJPT89C28eMGWOPsMpl0aJFPPnkkzz11FMAvP3222zatIkPP/yQuXPn2jm6kjjAt1ZLWfqtt0JqLZ28j53TfOt38j52FVETZHEtdgXU2EkfO+udw2Ge98Ie7JLYrVmzhk2bNuHj48OWLVsK9d3TaDROk9jl5eWxd+9eXn311UL39+nTh+3btxd7TG5uLrm5ucbb5g5KMUviP7B1Ysnb87Osc55LB+FLOzY1G/JN75O0p+QYU09B1XDL4/j7ddj3tuXl2NK2V2HPgqL3Kwbzjr/wl33/16ZkxJve59p5+15D5gXT+2ScLX+MOWau1rPvbTjxdfHbsi6ZPj71VMkxpp81LwZT9rwFxz63Tlm3SosDdy/Ly9k1F46sKN+xl2Kg/r2l76PPK/9zwVrv8cKpWZTYmbuE2K1ef/11Zs6cyauvvoqbW5mn0nMYly9fRq/XF+krGBoaSlJSUrHHzJ07lxkzZtgmII8qEGiieTs8GoItWN2j+YjyH2st1RpD3b4lb2/xROlv4IENoM4d5T+/NgA6TSr9AzuoCUTeWf5zWMonGDq+DFkXS96nejOo3avk7a2fBZ8g68dmTYFR0PiBkrc3vB+uXcCuzbGBUdBwaMnbGz8I2Zcpf4wNoN7dUDWs5F26TocrR0qJsSE0HFzy9qYPQ15aKcc3gLBOJiMtVdeZkHLcsjJKE9gAws1bHalYGo0aY5p5a6KXGEPTR0veXq8ftHgSFF35zxEeDcGtyn+8cHoa5db5RkowZMiQQrd//PFHevfuTdWqVQvdv27dOpNlBQUFsXv3bqfvY3fhwgVq1qzJ9u3bCy2nNnv2bD777DP+/fffIscUV2NXu3Zt0tLSzJoqRgghhHAE6enpBAQEyOeXgzG7xi4gIKDQ7UcfLeVbhwnDhw9n7dq1vPbaa+UuwxHUqFEDd3f3IrVzycnJJY741Wq1aLXaighPCCGEEJWM2YndihXl7FNQDL1ez/z589m0aROtWrUqMnhi0aJFVjuXLXl5edG+fXt+/fVXBg++0Yzx66+/MnDgQLPKKKgwtWpfOyGEEMLGCj63zGz4ExXELoMnDh06RNu2bQE4fPhwoW3l7bdnLxMmTOCxxx6jQ4cOdOnShWXLlhEfH89zzz1n1vEZGRkA1K5d25ZhCiGEEDaRkZFRpFVP2I/ZfexEyT744APmz59PYmIiLVq0YPHixXTv3t2sYw0GAxcuXMDPz8+uSW1BX7+EhASn7Ssh1+AY5BocgytcA7jGdbjqNSiKQkZGBhEREU49ENLV2KXGztWMGjWKUaNGletYNzc3atWqZeWIys/f399p33gKyDU4BrkGx+AK1wCucR2ueA1SU+d4JMUWQgghhHARktgJIYQQQrgISewEoE7DMm3aNKeeikWuwTHINTgGV7gGcI3rkGsQFUkGTwghhBBCuAipsRNCCCGEcBGS2AkhhBBCuAhJ7IQQQgghXIQkdkIIIYQQLkISOyGEEEIIFyGJnRBCCCGEi5DETgghhBDCRUhiJ4QQQgjhIiSxE0IIIYRwEZLYCSGEEEK4CEnshBBCCCFchCR2QgghhBAuQhI7IYQQQggX4WHvACo7g8HAhQsX8PPzQ6PR2DscIYQQwiyKopCRkUFERARublJP5CgksbPQn3/+yYIFC9i7dy+JiYmsX7+eQYMGmX38hQsXqF27tu0CFEIIIWwoISGBWrVq2TsMcZ0kdhbKzMykdevWjBw5kqFDh5b5eD8/P0B9Yfj7+1s7PCGEEMIm0tPTqV27tvFzTDgGSews1L9/f/r371/u4wuaX/39/SWxE0II4XSkG5FjkcSuguXm5pKbm2u8nZ6ebrWyd+6EsWOtVpwQAggKgvXrwdvb3pE4rsOH4bnnID/f3pEIc7z0EjzwgL2jELYiiV0Fmzt3LjNmzLBJ2X5+0Lq1TYoWolI6fx42bICkJKhb197ROK69e+Hvv+HJJ0H60Du+GjXsHYGwJUnsKtikSZOYMGGC8XZBHwVraN4cli2zSlFCCOD339XETlHsHYljK3h8li4FD/lUEcKu5CVYwbRaLVqt1t5hCCGEEMIFSaW5EEKUQPqEl408XkLYn9TYWejatWucOnXKeDs2NpYDBw4QFBREnTp17BiZEMJapCm2dPL4COE4JLGz0J49e+jVq5fxdkH/ueHDh7Ny5Uo7RSWEsAapgSobebyEsD9J7CzUs2dPFPm6KoRLk5d46eTxEcJxSB87IYQogdRAlY08XkLYnyR2QghhgtRIlU4eHyEchyR2QghRAqmBEkI4G0nshBDCBKmRKl3B4yOJsBD257SJXXZ2NllZWcbbZ8+e5e233+aXX36xY1RCCFciiYoQwtk4bWI3cOBAVq9eDUBqaiqdO3dm4cKFDBw4kA8//NDO0QkhXInU2JVOHh8hHIfTJnb79u2jW7duAHzzzTeEhoZy9uxZVq9ezbvvvmvn6IQQrkBq7IQQzsZpE7usrCz8/PwA+OWXXxgyZAhubm5ER0dz9uxZO0cnhHAlUiNVOkWRJFgIR+G0iV1UVBTfffcdCQkJbNq0iT59+gCQnJyMv7+/naMTQrgCSVaEEM7GaRO7qVOnMnHiROrWrUvnzp3p0qULoNbetW3b1s7RCSFcidTYlU5q7IRwHE67pNj999/P7bffTmJiIq1btzbef8cddzB48GA7RiaEEEIIYR9Om9gBhIWFERYWVui+Tp062SkaIYSrKaiFkhq70kmNnRCOw6kSuyFDhpi977p162wYiRBCCCGE43GqPnYBAQHGH39/f37//Xf27Nlj3L53715+//13AgIC7BilEMJVSI2deaTGTgjH4VQ1ditWrDD+/corr/DAAw+wdOlS3N3dAdDr9YwaNUpGxQohhBCiUnKqGrubLV++nIkTJxqTOgB3d3cmTJjA8uXL7RiZEMJVSI2deaTGTgjH4bSJnU6n49ixY0XuP3bsGAaDwQ4RCSGEEELYl1M1xd5s5MiRPPHEE5w6dYro6GgAdu7cybx58xg5cqSdoxNCuAKpsTOP1NgJ4TicNrF76623CAsLY/HixSQmJgIQHh7Oyy+/zEsvvWTn6IQQQgghKp5TJnY6nY7PP/+cxx9/nJdffpn09HQAGTQhhLAqqbEzjzw+QjgOp+xj5+HhwfPPP09ubi6gJnSS1AkhhP1IU6wQjsEpEzuAzp07s3//fnuHIYRwYVJjZx55fIRwHE7ZFAswatQoXnrpJc6dO0f79u2pWrVqoe2tWrWyU2RCCFH5SI2dEI7BaRO7Bx98EIAxY8YY79NoNCiKgkajQa/X2ys0IYSLkBo788jjI4TjcNrELjY21t4hCCGEuE5q7IRwDE6b2EVGRto7BCGEi5MaO/PI4yOE43DaxK7A0aNHiY+PJy8vr9D9AwYMKPW4uLg4tm3bRlxcHFlZWQQHB9O2bVu6dOmCt7e3LUMWQgiXIzV2QjgGp03szpw5w+DBgzl06JCxbx2o/eyAEvvYrVmzhnfffZddu3YREhJCzZo18fHx4erVq5w+fRpvb28eeeQRXnnlFakVFKKSkxo788jjI4TjcNrpTsaOHUu9evW4ePEiVapU4ciRI/z555906NCBLVu2FHtMu3btWLRoEY8++ihxcXEkJSWxd+9e/vrrL44ePUp6ejrff/89BoOBDh068PXXX1fsRQkhhJOSGjshHIPT1tjt2LGDP/74g+DgYNzc3HBzc+P2229n7ty5jBkzptg57t544w3uueeeEsvUarX07NmTnj17MmvWLBmgIUQlJzV25pHHRwjH4bQ1dnq9Hl9fXwBq1KjBhQsXAHVQxfHjx4s9prSk7lY1atSgY8eOlgcqhBCVgNTYCeEYnDaxa9GiBTExMYC6CsX8+fP5+++/mTlzJvXr1y9TWffccw+JiYm2CFMI4cSkxs488vgI4Tictin29ddfJzMzE4BZs2Zx77330q1bN6pXr87atWvLVNaff/5Jdna2LcIUQohKQWrshHAMTpvY9e3b1/h3/fr1OXr0KFevXqVatWrGkbFCCGEJeSsRQjgbp22K/fXXX8nKyip0X1BQULmSusjISDw9Pa0VmhDCxUhTY+kURZJgIRyF0yZ2Q4cOpVq1anTt2pVJkyaxadMmrl27Vuox8fHxxd5/+PBhateuXeT+8+fPWyVWIYRzkmRFCOFsnDaxS0lJYcuWLQwYMID9+/czbNgwgoKCiI6O5tVXXy32mI4dO/L000+za9euEstNS0vj448/pkWLFqxbt85W4QshnIjU2JVOauyEcBxO28fO3d2dLl260KVLF1599VUOHz7MW2+9xeeff87u3buZN29ekWOOHTvGnDlz6NevH56ennTo0IGIiAi8vb1JSUnh6NGjHDlyhA4dOrBgwQL69+9vhysTQjgKSVaEEM7GaRO7Y8eOsXXrVrZs2cLWrVvR6/XcfvvtLFy4kB49ehR7TFBQEG+99RazZs1iw4YNxrVis7OzqVGjBo888gh9+/alRYsWFXw1QghHJjV2pZPHRwjH4bSJXfPmzQkODmbcuHFMmTKF5s2bm32st7c3Q4YMYciQITaMUAjh7KTGznzyWAnhGJy2j92YMWOoWbMm06dP54knnuCVV17h559/NjmAQgghykpqpEonj48QjsNpE7u3336bffv2cfHiRV5//XX0ej1Tp06lRo0aREdH2zs8IYQLkFoo88ljJYRjcNrEroDBYECn05GXl0dubi75+fnExcXZOywhhAuRGqnSyeMjhONw2sRu7NixtG7dmpCQEJ599lkuXLjAM888w8GDB0lKSrJ3eEIIFyC1UOaTx0oIx+C0gyfOnz/P008/Tc+ePWUUqxDCpqRGqnTy+AjhOJw2sfvmm2/sHYIQQojrpMZOCMfgtE2xAJ999hm33XYbERERnD17FlAHVXz//fd2jkwI4QoKkhWpkSqdPD5COA6nTew+/PBDJkyYwN13301qaip6vR6AwMBA3n77bfsGJ4QQlYzU2AnhGJw2sXvvvff4+OOPmTx5Mu7u7sb7O3TowKFDh+wYmRDCVUiNnXnk8RHCcThtYhcbG0vbtm2L3K/VasnMzLRDREIIUXlJjZ0QjsFpE7t69epx4MCBIvf//PPPNG3atOIDEkK4HKmxM488PkI4DqcdFfvf//6XF154gZycHBRFYdeuXXzxxRfMmTOHTz/91N7hCSFEpSI1dkI4BqdN7EaOHIlOp+Pll18mKyuLhx9+mJo1a/Lee+/RrVs3e4cnhHABUmNnHnl8hHAcTtsUC/D0009z9uxZkpOTSUpKYteuXezfv5+oqCh7hyaEEJWK1NgJ4RicLrFLTU3lkUceITg4mIiICN59912CgoJ4//33iYqKYufOnSxfvtzeYQohXIDU2JlHHh8hHIfTNcW+9tpr/PnnnwwfPpyNGzcyfvx4Nm7cSE5ODhs2bKBHjx72DlEIIYQQwi6cLrH76aefWLFiBXfeeSejRo0iKiqKRo0ayaTEQgirkxo78yiKNMUK4Sicrin2woULNGvWDID69evj7e3NU089ZeeohBBCCCHsz+kSO4PBgKenp/G2u7s7VatWtWNEQghXJTV25pEaOyEch9M1xSqKwogRI9BqtQDk5OTw3HPPFUnu1q1bZ4/whBBCCCHsxukSu+HDhxe6/eijj9opEiGEq5MaO/NIjZ0QjsPpErsVK1bYOwQhhBBCCIfkdH3sHNEHH3xAvXr18Pb2pn379mzbts3eIQkhrEBq7MwjNXZCOA5J7Cy0du1axo0bx+TJk9m/fz/dunWjf//+xMfH2zs0IYQQQlQyTtcU62gWLVrEk08+aZxy5e2332bTpk18+OGHzJ07187RCSEsUVALlZwM587ZNxZHlp4uNXZCOApJ7CyQl5fH3r17efXVVwvd36dPH7Zv317sMbm5ueTm5hpvp6en2zRGIUT5+fiovx96yL5xOIOGDe0dgRACJLGzyOXLl9Hr9YSGhha6PzQ0lKSkpGKPmTt3LjNmzKiI8IQQFgoLg507ISXF3pE4vgYN7B2BEAIksbMKzS1tEIqiFLmvwKRJk5gwYYLxdnp6OrVr17ZpfEKI8uvc2d4RCCGE+SSxs0CNGjVwd3cvUjuXnJxcpBavgFarNU6uDGoSCNIkK4QQwrkUfG4pMmzcoUhiZwEvLy/at2/Pr7/+yuDBg433//rrrwwcONCsMjIyMgCk1k4IIYRTysjIICAgwN5hiOsksbPQhAkTeOyxx+jQoQNdunRh2bJlxMfH89xzz5l1fEREBAkJCfj5+ZXYfFsRCpqEExIS8Pf3t1sclpBrcAxyDY7BFa4BXOM6XPUaFEUhIyODiIgIO0cnbiaJnYUefPBBrly5wsyZM0lMTKRFixZs2LCByMhIs453c3OjVq1aNo7SfP7+/k77xlNArsExyDU4Ble4BnCN63DFa5CaOscjiZ0VjBo1ilGjRtk7DCGEEEJUcrLyhBBCCCGEi5DETgDqaN1p06YVGrHrbOQaHINcg2NwhWsA17gOuQZRkTSKjFMWQgghhHAJUmMnhBBCCOEiJLETQgghhHARktgJIYQQQrgISeyEEEIIIVyEJHZCCCGEEC5CEjshhBBCCBchiZ0QQgghhIuQxE4IIYQQwkVIYieEEEII4SIksRNCCCGEcBGS2AkhhBBCuAhJ7IQQQgghXIQkdkIIIYQQLkISOyGEEEIIF+Fh7wAqO51Ox/79+wkNDcXNTfJsIYQQzsFgMHDx4kXatm2Lh4ekE47Cof4T27Zt46OPPuL06dN888031KxZk88++4x69epx++232zs8m9i/fz+dOnWydxhCCCFEuezatYuOHTvaOwxxncMkdt9++y2PPfYYjzzyCPv37yc3NxeAjIwM5syZw4YNG+wcoW2EhoYC6gsjPDzcztEIIYQQ5klMTKRTp07GzzHhGBwmsZs1axZLly7l8ccf58svvzTe37VrV2bOnGnHyGyroPk1PDycWrVq2TkaKzLkgsYNNJ72jkQIIcrEYFBIvWZAb1Dw0brh6yPdZEoj3Ygci8MkdsePH6d79+5F7vf39yc1NbXiAxLlZ7gGsS3BPQQid4JGY++IhBCiRNeyDRw8mcP+f3M4cDKXhIv55OtubA8OdOf+O/y4v7cfGnk/Ew7OYRK78PBwTp06Rd26dQvd/9dff1G/fn27xPTnn3+yYMEC9u7dS2JiIuvXr2fQoEHG7YqiMGPGDJYtW0ZKSgqdO3fm/fffp3nz5naJ12Fc2wj5cepPzl7w6WDviIQQwkhRFM6cz2f7oWz+OZzNv2fzMBggNMiddo29uburL6FB7nh6aMjIMnDgRA4ffpvKxat6Rg+rZu/whSiVwyR2zz77LGPHjmX58uVoNBouXLjAjh07mDhxIlOnTrVLTJmZmbRu3ZqRI0cydOjQItvnz5/PokWLWLlyJY0aNWLWrFncddddHD9+HD8/PztE7CAyN4FnQ9AlQPZfktgJIRzCyYQ8Nu24xrYD2VxK1eOj1dChqTfj/hNE28ZaImp4FFsjd0fHqkTV8uKdtSlE1fKkXxdfO0QvhHkcJrF7+eWXSUtLo1evXuTk5NC9e3e0Wi0TJ05k9OjRdompf//+9O/fv9htiqLw9ttvM3nyZIYMGQLAqlWrCA0NZc2aNTz77LMVGapjyY0Bn66QfwJydts7GiFEJWYwKPx1MJvPN6ZxMiGfav5u9GpXhS6tqtAqSounh3lNqwN7+PHv2TyWfJ1C+ybeBFdzmI9PIQpxiGemXq/nr7/+4qWXXmLy5MkcPXoUg8FAs2bN8PV1zG9GsbGxJCUl0adPH+N9Wq2WHj16sH379hITu9zcXOOIX1BH/boUxQC5R8BvGGjc1SRPCCHsIPZCHm+uvsqJ+DzaNdYy+/lgOjXzxt29fP3kXri/GnuO5bD4i6vMfj5Y+tsJh+QQQ1nc3d3p27cvaWlpVKlShQ4dOtCpUyeHTeoAkpKSAIoM8w4NDTVuK87cuXMJCAgw/jRr1symcVa4/LOgZIK2BXg1gryToCj2jkoIUcls3ZfFc/OSyM0z8PaEEN4aG0qXlj7lTuoAfKu4Me6hauw8nMMfe7KsGK0Q1uMQNXYALVu25MyZM9SrV8/eoZTJrd/YFEUp9VvcpEmTmDBhgvH2+fPnXSu5yz+p/vZqDEoWGNJAfwk8QuwblxBORlEUcvMVNICHhwZ3N6kdMteP2zJ4+8sUerWvwsuPVcfL03qP3W2tqtCrfRXe+0ptkg30c7da2cK5/P777/z+++8kJydjMBgKbVu+fLmdonKgxG727NlMnDiRN954g/bt21O1atVC2/39/e0UWfHCwsIAtebu5omFk5OTS52sUavVotVqjbfT09NtF6Q95McDGvCsBYbr15Z/RhI7IUzIzjVw8EQuu49lc/BELucv6cjNV2u73dwgyN+dkGruNKjpRYNanjSq40XD2l4W1UCZYjAoaDRFv8A6KkVR+N/GdFb8mMbgnr68cH813GyQEI9+oBojZyby/jcpTB5Zw+rlC8c3Y8YMZs6cSYcOHQgPD3eo14jDJHb9+vUDYMCAAYUeoIIaML1eb6/QilWvXj3CwsL49ddfadu2LQB5eXls3bqVN998087R2VF+PHhEqBMTe16fcDn/PPjYNywhKlpOnoHEyzpy8xTc3DR4eWrQemrQemnw9tKgKJBwMZ+YU7nsPppDzKkc8nXqlBvtm3rTr2tVAqqqtUHZuQYup+lJuqLjyJlcftp+DYMBqvpoaNfYm3tv96VDU2+LP1xy8wwcic3jwIkcDp7I5VhcLn5V3Xj5sep0bu7YL2KDQeGDb1JYt+UaI+8L4NF+/jb7sK3m586o+6sxb9UVbmudRc92VWxyHuG4li5dysqVK3nsscfsHUoRDpPYbd682d4hFHHt2jVOnTplvB0bG8uBAwcICgqiTp06jBs3jjlz5tCwYUMaNmzInDlzqFKlCg8//LAdo7az/HjwrKP+7RYEGm/QnbNvTEJUkIwsAxv+vsa2A1kci8szq3upl6eGNo20PDMokI7NfagdUvyUGzfLy1c4EZ/H/uM5bDuQxStLLhEZ5sGQXn7c1bkq3l6mu08bDAqJl3WcPJfPyfg8jsbmcjQ2l3wd+Fd1o00jLc8ODmT3sRymfnSJD14Oo0EtL3MfigqVl68wb9UVtu7PYtx/qjGgu+2nm7qrUxX+OZzNvFVXqKLV0MnBE19hXXl5eXTt2tXeYRRLoyiW92yPj4+ndu3axfY3S0hIoE6dOpaewi62bNlCr169itw/fPhwVq5caZyg+KOPPio0QXGLFi3MPse5c+eoXbs2CQkJrrGkWHxvdcWJmteXhTvdEPwGQcgCu4YlhC2lZ+r538/p/N9f19AbFKJb+NCxmQ+RYR5U8XZDb1CTj9x8hdw8A7l5CgYFaoV4UDfcE60ZiVhJFEXh0Olcvv0jg78PZuNbxY27u1alc3MfIoLV7+6ZOQqXUnScv6Qj4WI+p8/lc/pcHpk56tt/9QB3mkR60aaRljaNvKkX4WlswszLVxj1ZhJu7rD0lTCbNG1aIuFiPnNXXeH0uTwmj6xB97YVV3uWl68wbdkl/jmSQ3QLbx7tH0CzelrTB7oIl/v8KoNXXnkFX19fpkyZYu9QirBKYufu7k5iYiIhIYX7UV25coWQkBCzmlH//PPPUrcXt9yYK3C5F8bpKPAbAiHz1dtne4JnBESssWdUQtiEXq/w41/XWPl/aeTrFIbd4ceA7n4E+dunQ33iZR3rt2SwaWcmGVmGIts93CG8hgf1a3rRsJYnUbW9iKrtZTLew6dzGbPwIq8Or06fzlVL3beiGAwKP267xkfrU6ke4M5rI6rT1A5JlcGg8NvuLNZsTCP+oo62jbU82i+ANo20DtXvyhZc7vOrDMaOHcvq1atp1aoVrVq1wtOz8LroixYtslNkVmqKLWkk6LVr1/D29jarjJ49exa57+YyHa2PnSiGYlBXm/CofeM+z1rXB1QI4Vr2/pvD+1+ncDYpn37RVXlyQCBBAfYdIRlew4NR91fj2SGBxF3I53KaHkUBXx83qvm7ERbkUa7BFi0aaLm9tQ/Lf0ylZ7sqVh1lWh4nE/JY/MVV/o3L475uvjw3JBAfrX1m73Jz09Cnc1Xu7FiFbQfUiZBfeieZZvW8eLRfAJ1bWN73UTiemJgY2rRpA8Dhw4cLbbP3/9uixK5g2g6NRsOUKVOoUuVGFbher+eff/4xXrgpKSkphW7n5+ezf/9+pkyZwuzZsy0JU1QU/SVQ8sDzpsTOoyZk77BfTEJYWb5O7aT//Z/XaNFAy4evhNGojmP1PXN309CglhcNrFiJ8uSAQJ6clciP2zIY2ts+sxQkXdHxv41pbNyeSWS4J+9MCKFllHmVB7bm5qahR7sqdG/rwz9Hcvh8YxqvfXiJqFqePNo/gNtb+zhcM7YoP0ccF1DAosRu//79wPU+HocO4eV1483Ny8uL1q1bM3HiRLPKCggIKHLfXXfdhVarZfz48ezdu9eSUEVF0CWqvz0ibtznEQr6ZPvEI4SVKYrCgs+usGVfFuMfqsa9t/va/dt5RYkM96RPdFU+35hO/66+VPG2bQ2Z3qBwOVVP0mUdFy7r2H4om52HsvGr4sZzQwMZ1MMPDxtO9VJeGo2G6BY+dG7uzcGTuXz2cxrTP75MvQhPHuvvT7e2VWROQhdz7tw5NBoNNWvWtHcogIWJXUHGOnLkSN555x2bzDUXHBzM8ePHrV6usIGCBM79pr6W7iFguAaGLHCTKQGE7WXnGkjJMOCmUQcFmLsWqDmW/5jGb7uzmPpUjUo5xcXwewL4fXcm327O4LH+Rb+Ml4XBoHA1XU/SFXUal8QrOi5e/510RU/yVR36m7oJNqrjxfNDq9G/a1W7NbuWhUajoU0jb9o08ubwaTXBm/npFSLD0ni0fwA920uC58wMBgOzZs1i4cKFXLt2DQA/Pz/j0qhubvZ7jlqlj92KFSssLiMmpvCaooqikJiYyLx582jdurXF5YsKoLuo/va4aYLmgr91yeBVt8JDEq7vWraBvcdy+OdINvv+zSE55UZ/XHc3iAzzpF0Tbzo09aZ1Q225R6D+31/X+HxjOs8ODqyUSR1AaJAH93Xz46tf0xnQzZcA39L7FGZkGTifnE/i5YLETX89cdNx8aqOfN2Nff2ruhFe3YPQ6u40qu1FWHUPwmp4EBak3mfOFC6OqkUDLW+ODuFYbC6rN6Qxe8UVVv2kJnh3dKhi00mmhW1MnjyZTz/9lHnz5nHbbbehKAp///0306dPJycnx65dyKwyKjYzM5N58+aVuLTGmTNnTJbh5uaGRqPh1nCio6NZvnw5TZo0sTRMh+RSo4quvAVXZkKjm1bTyDkIcW0g8h/w6WS30ITryM0zcORMHgdO5nDghDr3msEAdcM96djMmwa1vKgR4I7eoHDhso7jZ/PYcyyHy6l6tNfnjOvcwodOzX2IqGHed9sdh7KZ8tEl7uvmy5gHqlWa5tfipGToeWTqBe7u6svoYdUKbbuWZWD/iRz2Hsth3/EcziXfyNyq+miuJ24ehFf3UBO36u7Xf3vYvGnXkRw/m8tnP6ezPSabiGAPHunnz12dqjpk03JpXOrzq4wiIiJYunQpAwYMKHT/999/z6hRozh//rydIrNSjd1TTz3F1q1beeyxx8q9tEZsbGyh225ubgQHB5s9qlY4AH0yuN+ynFrBUmIFtXlClFFevsKRM7kcPJnD/hO5/BunTqIb4OtG64ZaxjxQjU7NfQirXvLbmaIoxCXms+uIWrP3/tcpvLs2hfAaHjSv70Xz+lpa1NdSN8KzSPPYwZM5zPzkMl1a+jB6WOVO6kBddWH43QF8tD6VkGru1Az24N+zeez7N4fjZ/MwKFAz2IN2TbwZfo+W2qGehNfwwK9K5UncTGkcqWXWc8GcTMjjfz+nseCzq3y2IY1RQ6txe5vKWRvsbK5evVpshVOTJk24evWqHSK6wSqJ3c8//8xPP/3EbbfdVu4ytm7dyoMPPlhoHVVQZ3f+8ssvefzxxy0NU9wsP17t/+ZmxcRZd7HomrDuwepvGUAhzKTXKxyJzWX/8VwOnMgptBpC64Zanh1cjbaNtUSGeZo9ylCj0VAvwot6EV48eJc/mdkG9h3P4eDJXI6cyWXzniz0BqjiraFpXS3N63vRpK6WuMR8VvyYSvP6Wl4fWV36RF33wJ1+JKfoWLouFVCT7LaNvLn7Nl/aN/EuNckWNzSs7cWMZ4I5cz6PT75PZeqyyzw1IICH+1nWf1HYXuvWrVmyZAnvvvtuofuXLFli9+5jVmmKrVevHhs2bKBp06blLsMakxw7I7tUZaf9DxIfA207qLsDNFaaqiGhH2iqQK11he8/WQOCXoLqk6xzHuGyjsXlMnflFc4l6/Cv6karKHUlhNYNtYVWQ7C2nDwDx8/mceRMLkfOqL/TMw24ucHA7r48O7ia3educ0QXr+pwc4MaAe6VvibTUoqisOqnNFZvSGfEvQE8frfjJ3eVuSl269at3HPPPdSpU4cuXbqg0WjYvn07CQkJbNiwgW7dutktNqt8rXrjjTeYOnUqq1atKjSXXVmUNMnxuXPnip0KRZSTIQeS/wvaNpC7D9LXQoCVFjHWJYNP56L3u4eo24QoxaFTObzy/iXqhnvy7kuhNKvnVWHzfnl7udG6oTetG6o12IqicOGSDt8qbiYHCFRmoUFSM2ctGo2GEfcG4umh4dMf0tBosHjksbCdHj16cOLECd5//33+/fdfFEVhyJAhjBo1ioiICNMF2JBVXpULFy7k9OnThIaGUrdu3SJLa+zbt6/EY9u2bYtGo0Gj0XDHHXfg4XEjJL1eT2xsLP369bNGmAIgcyPok6DOH3DxRUj7zHqJnf5i4alOCniEqtuEKMGlVB3TP75Mo9pezH0h2O7TWWg0GmqGeJreUQgre6RfAAYDrPgxDb1eYfg9AVIbakU6nY7Zs2fzxBNPULt2bdMHlCIiIsIhF1CwSmI3aNAgi489cOAAffv2xdfX17jNy8uLunXrMnToUAsjFEYZ34K2BWibgt9guDge9GngbuE3Q8Wg1sp5hBbdJjV2ohQGg8Ls5Vdwd9cw/ekadk/qhLC3x+4OwN0dPvk+jZw8hacHBUr/Tivx8PBgwYIFDB8+vMzHxsTE0KJFC9zc3IpM0XarVq1alTdEi1klsZs2bZrFx9atW5cHH3zQKqNg8/PzSUpKIisri+DgYIKCgiwu0yUoBri2AaqNUm9X7Q+Mhuxt4HuvZWUbUgBd0VGxoCZ2eccsK1+4rA3bM4k5lcvCsSEE+kmzpxAAD/cNQOup4cNvUzkWl8fTAwNpXt9Lau+s4M4772TLli2MGDGiTMe1adOGpKQkQkJCaNOmTbFTtIFa42/PcQFW6yCRmprKN998w+nTp/nvf/9LUFAQ+/btIzQ01KxlNsqTPd/s2rVrfP7553zxxRfs2rWL3Nxc47ZatWrRp08fnnnmGTp27GjReZxa3lEwXIUqvdTbnvXAIxyy/rY8sSuokSuuxs4jGHSXLCtfuKSr6XqWrU+hX5eqtG0sUxsJcbOhvf2Jqu3FojVXGbPwImHV3enWpgrtmnjTvJ4WX5lCplz69+/PpEmTOHz4MO3bt6dq1aqFtt86N12B2NhYgoODjX87KqskdjExMdx5550EBAQQFxfH008/TVBQEOvXr+fs2bOsXr3aZBl6vZ7Fixfz1VdfER8fT15eXqHtpc0Ls3jxYmbPnk3dunUZMGAAr776KjVr1sTHx4erV69y+PBhtm3bxl133UV0dDTvvfceDRs2tPi6nU7WNsDjxgAHjQZ8ukL2dsvLNq46UUwfO/dg0F9Saww18kYkbvjw2xTc3DQ8OzjQ3qEI4ZBaN/RmxZRw9h3PYduBbP7Yk8XXv2cAEBnmQf2aXkSGe1I33JPIME+nX6WjIjz//PMALFq0qMi20mrbIiMjjX+fPXuWrl27FhoXAGofvu3btxfatzS2aGG0SmI3YcIERowYwfz58/Hz8zPe379/fx5++GGzypgxYwaffPIJEyZMYMqUKUyePJm4uDi+++47pk6dWuqx27dvZ/PmzbRs2bLY7Z06deKJJ55g6dKlfPrpp2zdurVyJnbZ28C7Hbjd9O3Epytceh0UHWgseDoUDI4otik2GNCDIRXcpVlcqPb9m8Pvu7N4+bEgGXkqRCnc3DR0aOpDh6Y+jPuPOmL7yJlcjsbmcTYpn33Hc0i7dmPFJ18fDcHVPKgR6E5woDsRNTyIjPCkaV0tQf7yWrt1dazy6NWrV7FTtKWlpdGrV69Sm2Jt3cJolcRu9+7dfPTRR0Xur1mzJklJSWaV8fnnn/Pxxx9zzz33MGPGDB566CEaNGhAq1at2LlzJ2PGjCnx2K+//tqsc2i1WkaNGmXWvi4peyf4Dip8n7YtKNmQd1IdUFFeumTQaMHNv+g2j+uTFOsuSWInAMjXKby79iotG2jpG13V9AFCCODGiO2aIZ70ib5xf2qGnrOJ+SSn6Lmcpudyqo5LKXpOn89n6/4sMrMVPNzhrk5VeXJAIEEBkuBZoqQp2q5cuVKkafdmFdHCaJXEztvbm/T09CL3Hz9+3NgebUpSUpKxxs3X15e0tDQA7r33XqZMmWKNMCs3fSrkx6o1djfzvj5Ddu5ByxI7/UW1tq64jr3G1ScuAY3Lfw7hMr7+PZ1zl3RMfaqGdAYXwgoC/dxLHHykKAqXU/Vs2ZfF5xvTaVDLiyG9/Ird15bmzp3LunXr+Pfff/Hx8aFr1668+eabNG5843NhxIgRrFq1qtBxnTt3ZufOncbbubm5TJw4kS+++ILs7GzuuOMOPvjggzJNkpyZmcnWrVuL7fpVWkXSkCFDgOvzDo4YUWi1LL1eT0xMDF27di3x+IpoYbRKYjdw4EBmzpzJV199BagXHB8fz6uvvmr2VCW1atUiMTGROnXqEBUVxS+//EK7du3YvXt3kWXGivPHH38wevRodu7cib9/4VqjtLQ0unbtytKlS+06G7Rd5V4fmu3dpvD97kHgURtyDoD/f8pffnHLiRnPcf1+vQygEOpqBf/7OZ0hPf2oX9NKq54IIUqk0ahNs8Pu8KdvdFWqetunD97WrVt54YUX6NixIzqdjsmTJ9OnTx+OHj1aqJarX79+rFixwnjby6vw+8S4ceP48ccf+fLLL6levTovvfQS9957L3v37sXd3XRN5P79+7n77rvJysoiMzOToKAgLl++TJUqVQgJCSk1sStYMEFRFPz8/PDx8SkUZ3R0NE8//XSJx3/99ddFEsniWNTCqFhBWlqacttttymBgYGKu7u7Urt2bcXT01Pp3r27cu3aNbPKeOWVV5TZs2criqIoX3/9teLh4aFERUUpXl5eyiuvvGLy+Pvuu09ZtGhRidvfeecdZdCgQeZdUAVKSEhQACUhIcG2J7ryjqL8q1UUQ17RbfH3Kkp8P8vKTxigKPH3FL/NoFeUY26KkvKRZecQLmHqR8nK/a+eU65l6e0dihDCAgWfX0ePHlXS0tKMPzk5OWYdn5ycrADK1q1bjfcNHz5cGThwYInHpKamKp6ensqXX35pvO/8+fOKm5ubsnHjRrPO26NHD+Xpp59WdDqd4uvrq5w+fVqJj49Xunfvrnz77bdmlTF9+nSz85tbhYaGKrNmzVKuXLlSruNNsUpiV+D3339XFixYoLz55pvKr7/+alFZO3fuVBYuXKh8//33Zu1fp04d5ejRoyVuP3bsmFK7dm2LYrKFCkvsLoxUlNj2xW9LnqwoJ8IsKz+2s6JceKLk7SeCFeXSLMvOIZze7qNZSq/nzyq//lO+N0QhhOMo+Py69WfatGlmHX/y5EkFUA4dOmS8b/jw4UpAQIASHBysNGzYUHnqqaeUixcvGrf//vvvCqBcvXq1UFmtWrVSpk6datZ5AwIClH///df4d0HusHPnTqVx48ZmlWGJRYsWKfXq1VOqVq2qjBo1Sjl58qRVy7fqQn+9e/emd+/eZT4uPz+fZ555hilTplC/fn1AbVPv3LmYdUdLcPHixSJLmd3Mw8ODS5cqcVNgzoGi/esKaFury4zpkktuTjVFnwzuvUreXjDliai08nUKS75KoWWUljs6lm9NaSGE4zl69Gih+WrN6T6lKAoTJkzg9ttvp0WLFsb7+/fvz7Bhw4iMjCQ2NpYpU6bQu3dv9u7di1arJSkpCS8vL6pVq1aovNDQULMHa3p6ehr79oaGhhIfH0/Tpk0JCAggPj7erDIAvvnmmxKnaCttKdXx48czduxYvv32WxYvXkyTJk247777mDhxIrfddpvZ5y9JuRO7d999l2eeeQZvb2/efffdUvctrb0a1Ad5/fr1Fg2SqFmzJocOHSIqKqrY7TExMYSHh5e7fKem5EPeEQgYWfx27fWlT3IPgccd5TuH7mLxkxMXcA9Wkz9Raa3bnMG5ZB1TnpQBE0K4Ej8/vyJ9200ZPXo0MTEx/PXXX4Xuf/DBB41/t2jRgg4dOhAZGclPP/1kHLhQHKWEUarFadu2LXv27KFRo0b06tWLqVOncvnyZT777LMSBzXc6t1332Xy5MkMHz6c77//npEjR3L69Gl2797NCy+8YPJ4Nzc3hg0bxrBhw9i5cycLFy6kZ8+etGvXjokTJzJ06FDc3MrZF7K8VX1169ZVLl++bPy7pJ969eqZVd6IESOUhQsXljccZfTo0UqLFi2U7OzsItuysrKUFi1aKC+++GK5y7eVCmmKzY5RlGMoSuafxW836BTlX29FubK4fOXrr6nlp35e8j7n7leUs3eWr3zh9C6n6pS7x8Ur73xpmz4lQoiKV97Pr9GjRyu1atVSzpw5Y9b+UVFRyrx58xRFsU5T7O7du5U//vhDURS1n1///v0VPz8/pW3btsqBAwfMKqNx48bKmjVrFEVRjP30FEVRpkyZorzwwgtmlXGruLg4Zfz48UpAQIDZuVNxyl1jd/NyGtZYWiMqKoo33niD7du3F7vEh6lav9dff51169bRqFEjRo8eTePGjdFoNBw7doz3338fvV7P5MmTLY7TKeUeUH9rS1iUWOMO2uZqjV15GJcTK6UZ1z1YnStPVErL1qfg5alh5H2B9g5FCGEniqLw4osvsn79erZs2UK9evVMHnPlyhUSEhKMLW7t27fH09OTX3/9lQceeACAxMREDh8+zPz5882Ko0OHDsa/g4OD2bBhQ5mvJT4+3jitiY+PDxkZ6mogjz32GNHR0SxZsqTEYydPnkxaWlqxP6mpqVy7ds1YXnlYtY8dYFwQt6xNLZ988gmBgYHs3buXvXv3Ftqm0WhMJnahoaFs376d559/nkmTJhWKo2/fvnzwwQeEhpbSVOjKcg6AZ31wDyh5H23LG1OilFVBE6u7icRO+thVSodP5/LrrixeeiQIP1nbUohK64UXXmDNmjV8//33+Pn5GfvEBQQE4OPjw7Vr15g+fTpDhw4lPDycuLg4XnvtNWrUqMHgwYON+z755JO89NJLVK9enaCgICZOnEjLli258847K+xawsLCuHLlCpGRkURGRrJz505at25NbGysMf8oydy5c/H29mbEiBF06tSJgIAA/P398ff3N/5dMK1KeVgtsfv0009ZvHgxJ0+qtTINGzZk3LhxPPXUU2Ydb41av8jISDZs2EBKSgqnTp1CURQaNmxYpJNlpZN7ALRtSt9H2xLS14KiV2vwysKcGjuPYHXlCUUpfhJj4ZL0BoX3vrpKozpe9O8iK0wIUZl9+OGHAPTs2bPQ/StWrGDEiBG4u7tz6NAhVq9eTWpqKuHh4fTq1Yu1a9cWWq508eLFeHh48MADDxgnKF65cmWpc9i1bdvW7Aqn0gY+FOjduzc//vgj7dq148knn2T8+PF888037Nmzp9S+gAC//fYbixYtYvny5fznP/9h4sSJhQaQWMoqid2UKVNYvHgxL774Il26dAFgx44djB8/nri4OGbNmmV2WXl5ecTGxtKgQYMii+uaq1q1auVeY83lKIpaYxc0tvT9tC3VpcXyz4BXGdfR1V8ENOBeo+R93EOAfDCkl15zKFzKph2ZnEzI592XQnFzk4ReiMrMVE2Wj48PmzZtMlmOt7c37733Hu+9957Z5x40aJDZ+5pj2bJlxjVnn3vuOYKCgvjrr7+47777eO6550o9tmAGkePHj7No0SI6d+5Mt27d+O9//8sdd5RzAOPNyt077ybVq1c3diK82Zo1a5Tq1aubVUZmZqbyxBNPKO7u7oq7u7uxI+KLL76ozJ071xphOiSbD57IS1AHNqSbmA8wP+n6fuZNzljIpdmKcqJG6ftc+0MtP9e68/UIx5WRpVeGvJygzF5+yd6hCCFsoMLmYXVxycnJyrRp05TQ0FClTZs2yv/+9z9Fp9OVuzyrdHjR6/WFOiMWaN++PTqdzqwyJk2axMGDB9myZQve3t7G+++8807Wrl1rjTArp4KBEwVrwpbEI1TtB5dTjn52+uTS+9eB2hQL0s+uEvlsQxrZeQpPDw60dyhCCFHE3r17+d///sfnn3/O/v37Te4fExNjrKWLiYkp9acsgoODmT59OseOHWPIkCGMGTPGOKdveVilKfbRRx/lww8/ZNGiRYXuX7ZsGY888ohZZXz33XesXbuW6OjoQu3gzZo14/Tp06Ueq9PpWL16NYqi8Pjjj5c6UXGlk3MQ3ALBo47pfbUtyzcyVm/GxMbu1xM7ncxlVxnEJ+WzbnMGI+4NIDjQ6mO0hBCi3JKTk/nPf/7Dli1bCAwMRFEU0tLS6NWrF19++SXBwcHFHtemTRuSkpIICQmhTZs2aDSaYpuXNRoNer2+xPMPGjTIOAo2PT3d+Fun0xnLS01NLff1lfsdd8KECca/NRoNn3zyCb/88gvR0dEA7Ny5k4SEBB5//HGzyrt06RIhIUWTg8zMTJMdHl977TVuu+02dDodr776KgsXLizDlbi43IPqyhLmdBrVtoJrP5X9HDozauzcq6u/zaixUxSF1GsG4hPzuXBFR0amgYxMA7n56hP+1peRm0a9PPW3Rv3tdsvtgu1uGhrU9KRtY288PaTPly0YDAqL1lwltLq66LgQQjiSF198kfT0dI4cOULTpk0BdfWM4cOHM2bMGL744otij4uNjTUmfZYM+AwMDKRu3boEBgYSEBBQ6PfNf5dXuRO7W6st27dvD2CsXQsODiY4OJgjR46YVV7Hjh356aefePHFF4Eb06V8/PHHxgEZJTEYDGRlZeHm5masJhXX5R6Eqv3M21fbElLeAUMmuJVhBKP+Imiblb6PxgPcgopN7K5lGfg7JotDp3OJu5BPwkUdGVk3/o9VvTX4VXVD66kpmqAqCooCBoWbfivqb8ON2wXbdDqFzByF4EB3HrjTj3tu98XbS6bgsKYN2zOJOZXLW2ND8PKU5FkI4Vg2btzIb7/9ZkzqQG0dfP/99+nTp0+Jx0VGRhb7d1mtXLmy3Meao9yJ3ebNm60ZB3PnzqVfv34cPXoUnU7HO++8w5EjR9ixYwdbt241eezatWvR6XS8+eabVo3LqRky1UmBg141b39tS0CB3KPgU4ZRxebU2MGNKU+uS7qi49vNGWz4+xrZuQr1a3pSv6YnXVr6UDvUkzphnkTU8LBqcqAoCqfP5fPNHxl8uC6VNb+k88Ad/gzo7ouP1roJnqIopKQbOHcpn/PJOi5c0pGdp9Y3+lVxI9DXjRrV3Kkdql6nh7vzJ0GXU3V8tC6Fu7tWpV1jb9MHCCFEBTMYDMV22fL09Cy1cuiHH34w+xwDBgwo9v74+Hjq1DGja9R158+fL7QOrzk0SnENxHZy6NAh3nrrLfbu3YvBYKBdu3a88sorZq/d5ozOnTtH7dq1SUhIoFatWtYtPHsnnO0CdfeCdzvT+xuy4IQvhH0CgU+Ydw5FD8e9IOxDCHym9H3PdgPPuhzP/4Svf89gy74sqnq7MaC7L4N6+FE9oIzz51nowmUdazalsWlHJt5aDa2ivAn0dUOjuVEDqNxU46dw831guP7SMRhu3aaQnmkgPimfa9k3Xl7Bge5U8VGTx4xMPWnXDOivv4e4u0FEsAdRtb1oXMeLRnXU3z7ezlObqCgKUz+6zNG4XFZOjZDJiIVwcTb9/LKhgQMHkpqayhdffEFERASgJlCPPPII1apVY/369cUed+varbf2sbu521hJfexCQ0MZMGAATz/9NJ06dSp2n7S0NL766iveeecdnn32WWNLprms0qs5JyeH9957j82bN5OcnFwk4zVnsj+Ali1bsmrVKmuEJEAdOIE7eJloJi3gVgU8owoNoMjMNrBlXxYn4/PI0ymFkhpFAR/3y0zoZODLP7z598olY5MnSuFmUEWBR1r6oxjOMe7ri4RXd2fU0Gr071LVbslLRA0PJj5SnUf7BbBxxzWOnMkjLjEfUFt8Ndf76Gk0oEHto8dNffkK+u0V3Afg5qbBTaOhZrAHXVr6UCfMk1ohHkTU8EB7S5OvoihcTtOTcFHHuYv5nE3K52RCPjti0sjJU3Bzg8Z1vGjdUEvrRt60qK+lqk/Rx0qnV0i8rONcso5zyflcuKQDDfho3ajqrSG4mnr+2qEeBPjaLnn+6e9M/o7JZuYzNSSpE0I4rCVLljBw4EDq1q1L7dq10Wg0nD17llatWvG///2vxONuzm1+++03XnnlFebMmUOXLl3QaDRs376d119/nTlz5pRYxrFjx5gzZw79+vXD09OTDh06EBERgbe3NykpKRw9epQjR47QoUMHFixYQP/+/ct8fVapsXv44Yf59ddfuf/++wkNDS0y2GHatGlmlaPX61m/fj3Hjh1Do9HQtGlTBg4cWO6Jip2BTb/xJD4JOfuhnnmJtRrQUDCkQp3f2bIvi3e/vEp6poG64Z54azW4ud1IaDRAuP8x/ntbL5b8838kZHQ0JkEajZrk3Pgb7o2aSO2Ag8R67qBjc2/cZcLaYukNCvFJ+Rw+ncuBk7nEnMzlSpoeNw00rO1F3QhP3DRwJU3Phcs6LlzWUfB+4+2lIaKGBxo3yM5VuJZlID3zxptRRLAHzet5cVvrKkS38LFaM3d8Uj7Pzk3irs5VmfBwkFXKFEI4NmetsSvw66+/8u+//6IoCs2bNy/T5MAtWrRg6dKl3H777YXu37ZtG8888wzHjh0r9ficnBw2bNjAtm3biIuLIzs7mxo1atC2bVv69u1r0UoUVsmYfvrpJzZs2MBtt91W7jIOHz7MwIEDSUpKonHjxgCcOHGC4OBgfvjhh1KbYyuizdopZe+EKj3Kdox3K5SU91n5Yyqf/ZxO97Y+jBpajZCgEp4qmTGQAKMfagZeJvrZXaoDaZsJjfIpW0yVjLubhnoRXtSL8OK+bn4oisL5SzoOnMgl5mQOCRfzURQICnAnuoUPtUI8qBXqSe0QD2oEuhf5YpWdayDpio7YC/kcPZPLwVO5/LrrMkH+bjx4lz/3dbNsAElmtoHpH18mJMid54cGWnj1QghhG//88w9Xr1411oLdddddXLhwgWnTppGVlcWgQYN477330Gq1Jss6ffp0seu5BgQEEBcXZ/J4b29vhgwZYnL5sXIp99TGN2natKly8OBBi8ro3Lmzct999ylXr1413nf16lVlwIABSnR0dKnHhoSEKE899ZTyzz//lLhPamqqsmzZMqV58+bKu+++a1GsBaZNm3a90fHGT2hoaJnKsNnM3boUdaWH1JVlOy79W0U5hjJkwh7l842pisFgKH3/lBXqefQ5psu+8o6i/KtVFFNlCpuLvZCnvLn6snLHC2eVIa8kKN/+ka7k5pX9/6LTGZRXl1xU7p0Qr8RdyLNBpEIIR+VsK0/069dPmTdvnvF2TEyM4unpqTz11FPKwoULlbCwMGXatGlmldWtWzeld+/eyoULF4z3JSYmKnfeeafSvXt3a4deJlapsVu4cCGvvPIKS5cuLfcQ4IMHD7Jnzx6qVatmvK9atWrMnj3b5LqvFdFmXZLmzZvz22+/GW+XtghxhcrZrf72ji7TYT/vrUf/MBg9MIFe3dubPkB3QZ2jzs30Nxw8gkHJBcM1cPczvb+wmbrhnrz8WHUe7R/AZxvS+OCbFL76LZ3H7g6gb3RVs0bo6vQKs1dcYc+xHOaMCiYyXCYGF0I4rgMHDvDGG28Yb3/55Zd06tSJjz/+GIDatWszbdo0pk+fbrKs5cuXM3jwYCIjI40thvHx8TRq1IjvvvvOFuGbzSqJXYcOHcjJyaF+/fpUqVKlyDDiq1evmiyjcePGXLx4kebNmxe6Pzk5maioqFKPDQoK4q233mLWrFnFtlk/8sgjFrdZl8TDw4OwsDCrl2uxzF/UKUi8Gpp9yI5D2Sz6JpA7nvejV7PDwCDTB+nOg4eZzdruNy0rJomdQ4io4cErj1fnoT7+rPopjYWfX+WLX9IZ2N2XXu2rUKOEVSOSr+qYu+oKR87kMv3pGnRsJs3rQgjHlpKSQmhoqPH21q1b6dfvxjyvHTt2JCEhwayyoqKiiImJKdRPr1mzZtx5550mF1WwNaskdg899BDnz59nzpw5xQ6eMMecOXMYM2YM06dPL7R6xcyZM3nzzTdJT0837uvvX/xs9jZtsy7ByZMniYiIQKvV0rlzZ+bMmVPqGm+5ubnk5uYab2dkZFg/KEWB9K/Bb6i6BIMZzpzPY9byy0S39MXTvxdk/gY1Xjd9oO4CeESYF9fNiR3lXwdPWF+dME+mPFmDh/vm8dnPaXzyfSpL16XSrJ4XLeprqRPmiY9WQ+o1A4dP57LtQBb+Vd1ZMCaE1g1lvjohhOMLDQ0lNjaW2rVrk5eXx759+5gxY4Zxe0ZGRpmWJNVoNPTp06fUSY3twSqJ3fbt29mxYwetW5tYaL4U9957LwAPPPCAMTFUrg/Yve+++4y3Ta3BVpE6d+7M6tWradSoERcvXmTWrFl07dqVI0eOUL169WKPmTt3bqEnkk3k7AbdWfAbZtbuadf0vL70EhHBHrw2vDqa7Lvg4gTzVqDQXbg+sbEZCiV2whE1qOXF9KeDuZZlYNuBLP45ks0fe7K4lKq+5tzd1H2G3xPAwO5+xU6/IoQQjqhfv368+uqrvPnmm3z33XdUqVKFbt26GbfHxMTQoEEDs8vLzMxk69atxMfHk5eXV2jbmDFjrBZ3WVklsWvSpAnZ2dkWlWHtlSwqws199Vq2bEmXLl1o0KABq1atKrSW7s0mTZpUaNv58+dp1szMeebMlfGV2gxbpbtZu7+7NoWsHIXF44PVOeXc+gL5cG0D+JtIDnXnoWpf8+LyqHH9GEnsHJ1vFTf6d/Wlf1dfQO1Pl5OrUMVbnfJGCCGczaxZsxgyZAg9evTA19eXVatW4eXlZdy+fPlys2vf9u/fz913301WVhaZmZkEBQVx+fJlqlSpQkhIiPMndvPmzeOll15i9uzZtGzZskhVZklNpzfr0aOM03I4oKpVq9KyZUtOnjxZ4j5arbbQUOqbm5itQlEg/Svwux80pgdy7DqSzea9WUweWZ3QgilNvBqCd2dIW1l6YqfoQJdkflOsxgvcAqTGzgl5uGvwrSIJnRDCeQUHB7Nt2zbS0tLw9fUtMtjx66+/xtfX16yyxo8fz3333ceHH35IYGAgO3fuxNPTk0cffZSxY8faInyzWSWxK+h8eOvkfmVtOs3JySEmJqbY1StKWnfNkeTm5nLs2LFCVbsVLucf0CWA/wMmd1UUhVU/pdG8vhe9O1QpvDFgJFwcBfnnwbOEwRH55wA9eNYzPz73YEnshBBC2E1x88+BOhDTXAcOHOCjjz7C3d0dd3d3cnNzqV+/PvPnz2f48OEV2tf/VlZJ7EprRt2/f79ZZWzcuJHHH3+cy5cvF9nmSP3qbjZx4kTuu+8+6tSpQ3JyMrNmzSI9PZ3hw4fbL6j0r8A9DHxuN7nrvuO5HIvLY94LwUUHvPj/By5NhJQlEDK3+ALyz6i/vcowEMIjBHTJ5u8vhBBCOBhPT0/j52ZoaCjx8fE0bdqUgIAA4uPj7RqbVRK7W5tR09LS+Pzzz/nkk084ePAg48aNM1nG6NGjGTZsGFOnTi00HNmRnTt3joceeojLly8THBxMdHQ0O3fuLPdcfhZTDJDxzfXRsKabYT/bkEbjOl50bFbMqEb3AAh8FlI/hOqvFT89Sf5pQAOeZbheqbETQgjh5Nq2bcuePXto1KgRvXr1YurUqVy+fJnPPvus1JWyKoJVh7T98ccfPProo4SHh/Pee+9x9913s2fPHrOOTU5OZsKECU6T1IE6ueGFCxfIy8vj/PnzfPvtt9YfCFEWZWiGPXgyh5hTuTza37/k6WmqjQNDFqS8U/z2vDPgUVvtO2cuSeyEEEI4uTlz5hAeHg7AG2+8QfXq1Xn++edJTk5m2bJldo3N4hq7c+fOsXLlSpYvX05mZiYPPPAA+fn5ZU5y7r//frZs2VKmocbiFu5hUH0q+Jhes/fzjenUj/CkS8tSJpb1rAXVXoQrcyFghHr7ZnnHyzQBMqCuPpEpiZ0QQgjnpCgKwcHBxgUVgoOD2bBhg52jusGixO7uu+/mr7/+4t577+W9996jX79+uLu7s3Tp0jKXtWTJEoYNG8a2bduKHVlrz6HDTsOrHgSbniPvWFwue47lMPXJ6qanrqgxFdI/h6SnoNaGwhMe5x4AvzJ2EJUaOyGEEE5MURQaNmzIkSNHaNiwjJUbFcCixO6XX35hzJgxPP/88xZf3Jo1a9i0aRM+Pj5s2bKlUPOgRqORxM6K/vdzOrVDPejWtorpnd0DIGI1JPSD5P9CyFug0YA+BfJjQdumbCd3DwYlS23idTPj/EIIIYQDcXNzo2HDhly5csUhEzuL+tht27aNjIwMOnToQOfOnVmyZAmXLpWvNub1119n5syZpKWlERcXR2xsrPHnzJkzloQpbnIiPo8dh7J5pF8A7uZONFu1D4S8AymL4PxQyP4H0lap28ycBNnIQ+2TgO582Y4TQgghHMT8+fP573//y+HDh+0dShEWJXZdunTh448/JjExkWeffZYvv/ySmjVrYjAY+PXXX8u0DmpeXh4PPvggbm6yRJEtrfopjVohHtxx67x1pgS9CBHfQM5OOBsNyePVhM+zTtnKKZjzLj+2bMcJIYQQDuLRRx9l165dtG7dGh8fH4KCggr92JNVpjupUqUKTzzxBE888QTHjx/n008/Zd68ebz66qvcdddd/PDDDybLGD58OGvXruW1116zRkiiGMdic9lxKJvXRlTH3b0cqwj4DwW/gZCzBww54BNd9jI8awNukBcLJpahFUIIIRzR22+/be8QSmSVxO5mjRs3Zv78+cydO5cff/yR5cuXm3WcXq9n/vz5bNq0iVatWhUZPLFo0SJrh1qp6A0K76xNIaqWJ73KWlt3M41H+RI64/Geai2f1NgJIYRwQvn5+WzZsoUpU6ZQv34ZJuivIFZP7Aq4u7szaNAgBg0aZNb+hw4dom3btgBF2qxLnGdNmG3NpnROxOfx3sRQ8/vW2YpnPUnshBBCOCVPT0/Wr1/PlClT7B1KsWyW2JVVacuSifJTFIVv/shg5f+l8fjd/jSvr7V3SODZQG3OFUIIIZzQ4MGD+e6775gwYYK9QynCYRK7AqdOneL06dN0794dHx8fFEWRGrtyysw2sOTrFDbtzOQ/ffx5/O7iFz6ucN5t1VG1hlxwc4BEUwghRIX54IMPWLBgAYmJiTRv3py3336bbt262TusMomKiuKNN95g+/bttG/fnqpVC3cat+cUbQ6T2F25coUHHniAzZs3o9FoOHnyJPXr1+epp54iMDCQhQsX2jtEp6HXK/yyK5P/b+/eo6Ks8z+Av4e5McglQLkzclFCQwXUTMyA1RJrU9tfN0vRIM75qWc39WdKdkp33VO2um1iGwpoqb8y/S1W/soKT+ZlY42Niz8cNA9eVuMaIF5AZZh5fn9wZrYJiLkAz8zD+3XOnMPM8zzzfN6Px5nPfJ/be/97DTdvGbEm3Q+z7vMUu6x/c58EQA/c+T9AM1nsaoiIaJDs27cPy5cvxzvvvINp06Zh+/btmD17NqqqqqDV2niVBREVFBTgrrvuQmlpKUpLSy2miX3tXZkgCIJoa/+J9PR0NDY2oqCgAGPGjMGpU6cQFRWFoqIirFixAjqdTuwSB8QPP/yA8PBwXLlyBWFhYX0v8Avqmztx8PgNHC5pR/M1A6bHa7DkP3wR5O80/XsX4x2gOgDQJAEevxK7GiKioWXYDMA90eG3MX1/VVVVITQ01Py6Wq2GWt3z3pgpU6YgMTERubm55tfGjBmDefPm4fXXX3e4JnKiEbuioiJ8+eWX3Zqb0aNH41//+pdIVbmWplYDDhW3IXWiBx6Z5olR4SqxS+qZm7rrnrbNrwG3TopdDRHR0CL36ZfGzuTn94Vft24d1q9f322+jo4OlJaWIjs72+L1hx56CMXFxf1Wz0BZuXIlNmzYgGHDhv3isXUymUzUvYxO09i1tbXBw6P7ZTiampp67fzJ0j1RKvzP66FQKlzgmET//+p6EBGRS+tpxK4nTU1NMBgMCAwMtHg9MDAQ9fX1A1pjfygvL4derzf/3RuxzwtwmsbugQcewO7du7FhwwYAXRvGaDRi06ZNSE1NFbk61yCTyaB0mn9RIiIaCry8vODt7W31/D9vfFzlJMmfXr3Dma/k4TRtwKZNm5CSkoLvvvsOHR0dWL16NXQ6HVpaWvDNN9+IXd6AMRqNAIC6ujqRKyEiIrKe6XvL9D3Wl+HDh0Mul3cbnWtsbOw2ikf2c5rGztPTExUVFdi+fTvkcjna2trwm9/8BsuWLTMPfUpRQ0MDAODee+8VuRIiIiLbNTQ0WHVGq0qlwsSJE3H48GE89thj5tcPHz6MuXPnDmSJQ4rTnBUrl8tRV1eHgIAAi9ebm5sREBAAg8EgUmUDq7OzE+Xl5QgMDISbm5toddy4cQNjx45FVVUVvLy8RKvDEczgHJjBOUghAyCNHFLNYDQa0dDQgISEBCgU1o0T7du3DwsXLsS2bdswdepU5OXlIT8/HzqdDiNHjhzICEOG04zY9dZf3rx5E+7u7oNczeBRKBSYPFn8a7ldv34dABAaGmrTsRLOhBmcAzM4BylkAKSRQ8oZbL323FNPPYXm5mb84Q9/QF1dHeLi4nDo0CE2df1I9MbOdMqwTCbDq6++anFmrMFgwLfffov4+HiRqiMiIqL+tHTpUixdulTsMiRL9MbOdMqwIAiorKyESvXva6+pVCpMmDABq1atEqs8IiIiIpchemNnOmX4ueeew5YtW1x2mNrVqdVqrFu3zqWvGcgMzoEZnIMUMgDSyMEMNJic5uQJIiIiInKMeKdhEhEREVG/YmNHREREJBFs7IiIiIgkgo0dERERkUSwsXNRixcvxrx58wZ0HXl5eUhJSYG3tzdkMhlaW1stpl+6dAmZmZmIjIyERqNBdHQ01q1bh46ODqvenxms01cGAJgzZw60Wi3c3d0RHByMhQsXora21up1SCEHM1hnqGQwuXPnDuLj4yGTyVBRUWHV+zODdQY6A9mHjR31qr29HWlpaVi7dm2P08+ePQuj0Yjt27dDp9PhL3/5C7Zt29br/GIYChkAIDU1Ffv378f333+PwsJCnD9/Ho8//vggVtk3KeRgBudgTQaT1atXIyQkZBCqsg0z0IARyCUtWrRImDt3riAIgvD5558L06ZNE3x8fAQ/Pz/hkUceEaqrq83zXrx4UQAgFBYWCikpKYJGoxHGjx8vFBcXW7Wur7/+WgAgXL16tc95//SnPwmRkZHMIHKGTz75RJDJZEJHR8eQycEMzPBzhw4dEmJjYwWdTicAEMrLy616X2ZwjgxkH47YSUBbWxtWrlyJf/7zn/jqq6/g5uaGxx57DEaj0WK+l19+GatWrUJFRQViYmIwf/58dHZ29mst165dg5+fn83LMUP/ZWhpacH777+PpKQkKJVKm5eXQg5mYIaGhgZkZWVhz549FreqtBUzOEcGsoHYnSXZ56e/xn6usbFRACBUVlYKgvDvX2MFBQXmeUy/nM6cOdPnuqz9ZV9dXS14e3sL+fn5zCBChtWrVwseHh4CAOG+++4TmpqarMoglRzMwAwmRqNRSEtLEzZs2GCxHntGu5hBvAxkH47YScD58+fxzDPPICoqCt7e3oiMjAQAXL582WK+8ePHm/8ODg4GADQ2NvZLDbW1tUhLS8MTTzyB559/3ublmcHxDC+++CLKy8tRVFQEuVyO9PR0CHbcWEYKOZhhaGfYunUrrl+/jpdeesnu9zBhBufIQNYT/V6x5LhHH30U4eHhyM/PR0hICIxGI+Li4rqd2fnT3SgymQwAug3F26O2thapqamYOnUq8vLy7HoPZnA8w/DhwzF8+HDExMRgzJgxCA8Px8mTJzF16tQhl4MZhnaGI0eO4OTJk93uazpp0iQ8++yz2LVrFzO4WAayHhs7F9fc3IwzZ85g+/btmD59OgDg73//+6Ctv6amBqmpqZg4cSLeffdduLnZPgjMDP3PNLJy584dm5aTQg5m6H+uliEnJwd//OMfzc9ra2sxa9Ys7Nu3D1OmTLH6fZjBMf2VgWzDxs7F+fr6wt/fH3l5eQgODsbly5eRnZ3dL+9dX1+P+vp6VFdXAwAqKyvh5eUFrVYLPz8/1NbWIiUlBVqtFps3b8aPP/5oXjYoKIgZBilDSUkJSkpKcP/998PX1xcXLlzAq6++iujoaJtH66SQgxmYQavVWszv6ekJAIiOjkZYWBgzuFgGsg2PsXNRRqMRCoUCbm5u+PDDD1FaWoq4uDisWLECmzZt6pd1bNu2DQkJCcjKygIAPPDAA0hISMDBgwcBAEVFRaiursaRI0cQFhaG4OBg84MZBi+DRqPBgQMHMGPGDNx9993IyMhAXFwcjh071m0XiJRzMAMzmDI4ihmsM9AZyD4ywZ6jq0l0aWlpGDVqFN5++22xS7EbMzgPKeRgBufADM5BChnIPhyxczFXr17FZ599hqNHj2LmzJlil2MXZnAeUsjBDM6BGZyDFDKQg8S6zgrZZ968eUJoaKiwdu1awWg0il2OXZjBeUghBzM4B2ZwDlLIQI7hrlgiIiIiieCuWCIiIiKJYGNHREREJBFs7IiIiIgkgo0dERERkUSwsSMiIiKSCN5SjMgGBoMBer1e7DKIiCRFpVLZdZ9u6o6NHZEVBEFAfX09WltbxS6FiEhy3NzcEBkZCZVKJXYpLo/XsSOyQl1dHVpbWxEQEAAPDw/IZDKxSyIikgSj0Yja2loolUpotVp+vjqII3ZEfTAYDOamzt/fX+xyiIgkZ8SIEaitrUVnZyeUSqXY5bg07tAm6oPpmDoPDw+RKyEikibTLliDwSByJa6PjR2Rlbh7gIhoYPDztf+wsSMiIiKSCDZ2REREZOHy5cvw9PREZWWl2KWQjXjyBBEREVkICQlBRUUFtFqt2KWQjdjYERERkQWFQoFRo0aJXQbZgbtiiYiIiCSCjR0RERGRRLCxIyIiIrOKigo8/fTTCAoKgkqlQnR0NNavX8/7ZLsINnZERAMoJSUFy5cvF7sMSfriiy8gk8l+8fH555+LXaZL2blzJ+69914EBgbi008/xZkzZ/DKK68gJycHixcvFrs8sgIbOyIJW7x4sfkLTqFQQKvVYsmSJbh69ap5noiICLz11lviFelCfro9lUoloqKisGrVKrS1tfW6zIEDB7Bhw4ZBrHLoSE5ORl1dnfnh7++PtWvXWrz24IMPil2myzh27BiysrKQn5+PLVu2YNKkSYiOjsbixYuxadMmfPDBBzh79qzYZVIfeFYskcSlpaXh3XffRWdnJ6qqqpCRkYHW1lbs3btX7NJckml76vV6nDhxAs8//zza2tqQm5trMZ9er4dSqYSfn59IlUqfRqOBRqMBANTU1KC5uRn3338/goKCRK7MNa1YsQKzZ8/GokWLuk1LTU0FAJw6dQqxsbGDXRrZgCN2RBKnVqsRFBSEsLAwPPTQQ3jqqadQVFQkdlkuy7Q9w8PD8cwzz+DZZ5/Fxx9/jPXr1yM+Ph47d+5EVFQU1Go1BEHotiv2zp07WL16NcLDw6FWqzF69Gjs2LHDPL2qqgoPP/wwPD09ERgYiIULF6KpqUmEpK6lvLwcADBx4kSRK3FNlZWVKC8vx7Jly3qcfuvWLQBdl0Eh58Z/ISJ76NuBFhF2SfjFAkoPuxe/cOECvvjiCyiVyn4sqv9cu3YNN2/eRGhoKACgrq4OarUafn5+0Ov1qKurQ0BAANzd3XH9+nVcv34dYWFhAICGhgYoFAr4+/vDYDCgpqYGI0aMgEajwY0bN9Da2orw8HAAQGNjI9RqNXx8fByuWaPRmA8qr66uxv79+1FYWAi5XN7j/Onp6fjHP/6BnJwcTJgwARcvXjQ3bnV1dUhOTkZWVhbefPNN3Lp1C2vWrMGTTz6JI0eOOFyrLW53GHG5vnNQ1wkA2iAF3FW2jzmUlZUhNDQUAQEBA1CVg4ztQMcgf16oYgE36z8rKioqAADx8fE9Ti8rKwMATJgwwaGykpOTsWvXLkRERDj0PtQ7NnZE9mg5C/y3CCMDC0qBwESbFvn000/h6ekJg8GA27dvAwDefPPNgajOYSdOnEBxcTFee+01AMCOHTsQExODJ598ElevXsXGjRuxfPlyxMTE4Ntvv8WXX36JzZs3AwB2796N4OBgLFiwADdv3sTGjRuxZMkSjBs3DmVlZSgsLEROTg4AYO/evYiOjsavf/1rh+otKSnBBx98gBkzZgAAOjo6sGfPHowYMaLH+c+dO4f9+/fj8OHDmDlzJgAgKirKPD03NxeJiYnm/EDXwezh4eE4d+4cYmJiHKrXFpfrO/GfG+sHbX0m27KDEKNV2bxcWVkZEhNt+78xaDrOApcG+fMiohRwt357dHR0AADc3d17nP7Xv/4VSUlJPV602GAw9PpD5ucuXbrEpm6AsbEjsodfbFeTJcZ6bZSamorc3Fy0t7ejoKAA586dw29/+9sBKM5x06dPR0JCgvl5ZmYm1Go1AMDX1xfZ2dnmEZkpU6ZgzJgx5nnT09PNu4k8PT2RnZ1tbrASExMtGqj58+eb39dWpka5s7MTer0ec+fOxdatW/HOO+9g5MiRvTZ1QNeoiFwuR3Jyco/TS0tL8fXXX8PT07PbtPPnzw9qY6cNUmBb9uAfq6YNsu9rqaysDJmZmd1e37NnD95++220t7cjMjISf/vb36BS2d44OkQV29VoDfY6bTB+/HgAXSdQzJs3z2Lan//8Z1RWVuL48ePm12bPno1x48bh5MmTeO6556BQKHrczjqdDpmZmbh16xYWLVpkHjWngcPGjsgeSg+bR87EMmzYMPOv7JycHKSmpuL3v/+9U56p6ePjY7F7NDg42Py3Uqm0uG+lt7c3vL29zc8DAwPNf8vlcot5vby84OXlZX7uyO46U6OsVCoREhJisVt72LBhv7is6UD/3hiNRjz66KN44403uk376bYYDO4qN7tGzsTQ3NyMK1eu9Dhi9/DDD2PhwoUAgIyMDJw4ccI8wjpo3DxsGj0Tw+TJk5GWloZly5ZBr9dj0qRJaGhoQEFBAfbu3YsDBw5YHL94+vRppKWlmZu95ubmbts5KSkJTz/9NPbt24exY8dizpw55gaSBg5PniAaYtatW4fNmzejtrZW7FJckqlRHjlypM3HKo4bNw5GoxHHjh3rcXpiYiJ0Oh0iIiIwatQoi0dfTeNQVlraNRr288ZOEATk5eVh8uTJmDBhAj766KNedzUSUFhYiAULFuDFF1/E6NGjMXXqVNTU1ODcuXOYNWuWeb5r165BJpPhhRdeAND7dv7oo4+QkpKCsWPHAgDuvvtuNnaDgI0d0RCTkpKCe+65x+I4rpqaGlRUVFg8WlpaRKxSmiIiIrBo0SJkZGTg448/xsWLF3H06FHs378fALBs2TK0tLRg/vz5KCkpwYULF1BUVISMjAwYDAaRq3de5eXlCAgIMJ90Y/Lee++huroax48fx6lTp+Dt7W1uMqg7Dw8PvPHGG7h06RI6OzuRlZWF77//Hh4elidhnD59GklJSebnvW1nnU5n0ciVlZWxsRsEbOyIhqCVK1ciPz8fV65cAQBs3rwZCQkJFo+DBw+KXKU05ebm4vHHH8fSpUsRGxuLrKws8wWOQ0JC8M0338BgMGDWrFmIi4vDCy+8AB8fH7i58eO6N2vWrEFDQ0O313U6HZKSkqDRaLBlyxYYjUb4+vqKUKFr2rp1KzIzM81nxJqcPn0a48aNMz/vbTv7+/ujqqoKAFBUVISjR49aLEcDQyYIgiB2EUTO7Pbt27h48SIiIyO5G4fIhZw6dQpz587FyJEjkZycjO+++w6HDh0SuyyX97vf/Q4zZ87EnDlzAPS+nRsbGzF79mwIgoC4uDgUFxejurq6x/fk52z/YWNH1Ad+4BARDSx+zvYfju0TERERSQQbOyIiIiKJYGNHREREJBFs7IiIiIgkgo0dkZV4nhER0cDg52v/YWNH1AfT3QXa29tFroSISJo6OjoAdN0OkBzDe8US9UEul+Ouu+5CY2MjgK6rs8tkMpGrIiKSBqPRiB9//BEeHh5QKNiWOIpbkMgKQUFBAGBu7oiIqP+4ublBq9XyR3M/4AWKiWxgMBig1+vFLoOISFJUKhVvm9dP2NgRERERSQTbYyIiIiKJYGNHREREJBFs7IiIiIgkgo0dERERkUSwsSMiIiKSCDZ2RERERBLBxo6IiIhIIv4fnjPkkLPR+EsAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -2276,16 +2276,16 @@ "output_type": "stream", "text": [ "q(s,a) = \n", - "[[0.225 0. ]\n", - " [1.905 1.55 ]\n", - " [0. 0. ]]\n", + "[[0. 0. ]\n", + " [1.936 1.398]\n", + " [0.594 0. ]]\n", "-------------------------------------------------------------------\n", "Episode number: 2, starting day: 67.8 (from beginning of the year)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2298,16 +2298,16 @@ "output_type": "stream", "text": [ "q(s,a) = \n", - "[[0.223 0.187]\n", - " [2.656 2.396]\n", - " [1.101 0.271]]\n", + "[[0. 0.17 ]\n", + " [2.414 2.116]\n", + " [1.491 0.594]]\n", "-------------------------------------------------------------------\n", "Episode number: 3, starting day: 0.9 (from beginning of the year)\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAHVCAYAAAB8NLYkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACj9UlEQVR4nOzdd3hTZfvA8W+694K2tFDKKHvvJbJkOVgK/HAxVFSUKSqITBkKyhIRFyDv60BRUF+RIUtkKLtsAQst0FKge7fJ+f1xaKB0pW2a1ftzXbnanOQ8uU9Pk9znmRpFURSEEEIIIYTVszN3AEIIIYQQwjgksRNCCCGEsBGS2AkhhBBC2AhJ7IQQQgghbIQkdkIIIYQQNkISOyGEEEIIGyGJnRBCCCGEjZDETgghhBDCRkhiJ4QQQghhIxzMHUBFp9PpuH79Op6enmg0GnOHI4QQQhhEURSSk5MJDg7Gzk7qiSyGYkH++OMP5amnnlLat2+vXL16VVEURVm3bp2yd+9ek8eycuVKpUmTJoqnp6fi6emptG/fXtm8ebP+cZ1Op8ycOVMJCgpSXFxclC5duiinTp0q8etERUUpgNzkJje5yU1uVnmLiooy5tevKCOLqbH74YcfeOaZZ3jqqac4duwYmZmZACQnJzN//nw2b95s0niqVavGu+++S1hYGABffvkl/fv359ixYzRq1IiFCxeyePFi1q5dS926dZk7dy49e/bk/PnzeHp6Gvw6uc+NiorCy8urXI5FCCGEMLakpCRCQkJK9J0nyp9GURTF3EEAtGjRgokTJ/Lss8/i6enJiRMnqFWrFsePH6dPnz7ExMSYO0T8/PxYtGgRo0aNIjg4mAkTJvDmm28CkJmZSWBgIO+99x4vvviiwWUmJSXh7e1NYmKiJHYWRlEUUlNTzR2GMIC9vT2urq7mDsPm5eTkkJGRYe4whAGcnZ1xdHQs19eQ7y/LZDE1dufPn+fBBx/Mt93Ly4uEhATTB3QPrVbL999/T2pqKh06dCAiIoKYmBh69eqlf46zszNdunRh//79RSZ2mZmZ+tpIUN8YwjLt2LGDffv2mTsMYaCRI0dSvXp1c4dh01atWsXt27fNHYYwgJubG6+//rq5wxBmYDGJXVBQEBcvXqRGjRp5tv/555/UqlXLLDGdPHmSDh06kJGRgYeHBxs3bqRhw4bs378fgMDAwDzPDwwM5MqVK0WWuWDBAmbPnl1uMQvjya2tGzZsmJkjEUXJyMhg48aNpKWlmTsUm5eYmEj16tXp1KmTuUMRRbh06RJ///23ucMQZmIxid2LL77I+PHjWb16NRqNhuvXr3PgwAEmT57MjBkzzBJTvXr1OH78OAkJCfzwww8MHz6cPXv26B+/fxSroijFjmydOnUqkyZN0t/P7aMgLFNISAh169Y1dxiiCJLQmY6DgwN169aV94SFS0lJMXcIwowsJrF74403SExMpFu3bmRkZPDggw/i7OzM5MmTefXVV80Sk5OTk37wROvWrTl06BDLli3T96uLiYkhKChI//zY2Nh8tXj3c3Z2xtnZufyCFkIIIUSFZRETz2i1Wvbs2cNrr73GrVu3+Pvvvzl48CA3b97knXfeMXd4eoqikJmZSc2aNalSpQrbt2/XP5aVlcWePXvo2LGjGSMUQgghREVWLjV2GRkZuLi4GPx8e3t7evfuzdmzZ/Hz86N169blEVaJvPXWW/Tt25eQkBCSk5P59ttv2b17N1u2bEGj0TBhwgTmz59PnTp1qFOnDvPnz8fNzY0nn3zS3KELIYQQooIyWo2dTqfjnXfeoWrVqnh4ePDvv/8CMH36dL744oti92/SpIl+H0tw48YNnnnmGerVq0ePHj3466+/2LJlCz179gTUpuMJEyYwZswYWrduzbVr19i2bZvM5yOEEEIIszFaYjd37lzWrl3LwoULcXJy0m9v0qQJn3/+ebH7z5s3j8mTJ/O///2P6OhokpKS8txM7YsvvuDy5ctkZmYSGxvL77//rk/qQB04MWvWLKKjo8nIyGDPnj00btzY5HEKIYQQQuQyWlPsunXr+PTTT+nRowcvvfSSfnvTpk05d+5csfv36dMHgH79+uUZWZo70lSr1RorVCGEEEIIm2S0xO7atWv6EaT30ul0ZGdnF7v/rl27jBWKEEIIIUSFZLTErlGjRuzdu5fQ0NA827///ntatGhR7P5dunQxVihCCCGEEBWS0RK7mTNn8swzz3Dt2jV0Oh0//vgj58+fZ926dfzvf/8rdv8//vijyMcLWm5MCCGEEELcZbTE7rHHHmP9+vXMnz8fjUbDjBkzaNmyJb/88kueQQeF6dq1a75t9/a1kz52QgghhBBFM+o8dr1796Z3796l2jc+Pj7P/ezsbI4dO8b06dOZN2+eMcITQgghhLBpRkvsRo4cydNPP0337t2LXS+1IN7e3vm29ezZE2dnZyZOnMiRI0eMEaYQQgghhM0y2jx2t2/f5pFHHqFatWq89tprHDt2zCjl+vv7c/78eaOUJYQQQghhy4xWY/fzzz+TkJDAd999x9dff83SpUupV68eTz/9NE8++SQ1atQocv/w8PA89xVFITo6mnfffZdmzZoZK0whhBBCCJtl1D52Pj4+jB49mtGjR3P16lW++eYbVq9ezYwZM8jJySly3+bNm6PRaFAUJc/29u3bs3r1amOGKYQQQghhk4ya2OXKzs7m8OHD/PXXX1y+fJnAwMBi94mIiMhz387ODn9/f1xcXMojRCGEEEIIm2O0Pnagrh7xwgsvEBgYyPDhw/H09OSXX34hKiqq2H337NlDlSpVCA0NJTQ0lJCQEFxcXMjKymLdunXGDFMIIYQQwiYZLbGrVq0aDz/8MDdv3uSTTz7hxo0brFmzhoceegg7u+JfZuTIkSQmJubbnpyczMiRI40VphBCCCGEzTJaYjdjxgyuX7/Opk2bGDx4cImbUBVFKXCalKtXrxY4FUp5W7BgAW3atMHT05OAgAAGDBiQb3TuiBEj0Gg0eW7t27c3eaxCCCGEEGDEPnajR48u1X4tWrTQJ0U9evTAweFuSFqtloiICPr06WOsMA22Z88eXnnlFdq0aUNOTg7Tpk2jV69enDlzBnd3d/3z+vTpw5o1a/T3nZycTB6rEEIIIQSUMbEbNGgQa9euxcvLi0GDBhX53B9//LHA7QMGDADg+PHj9O7dGw8PD/1jTk5O1KhRg8cff7wsYZbKli1b8txfs2YNAQEBHDlyJM+6tc7OzlSpUsXU4QkhhBBC5FOmxM7b21vffOrl5VWqFSdmzpwJQI0aNRg6dKhRRsFmZ2cTExNDWloa/v7++Pn5lbnM3P5/95e1e/duAgIC8PHxoUuXLsybN4+AgIBCy8nMzCQzM1N/PykpqcyxCSGEEEJAGRO7e5sg165dW6ZAhg8fXqb9U1JS+Oqrr/jmm2/4+++/8yRP1apVo1evXowePZo2bdqUuGxFUZg0aRIPPPAAjRs31m/v27cvgwcPJjQ0lIiICKZPn0737t05cuQIzs7OBZa1YMECZs+eXfIDFEIIIYQohtEGT3Tv3p2EhIR825OSkujevXux+2u1Wt5//33atm1LlSpV8PPzy3MrypIlS6hRowafffYZ3bt358cff+T48eOcP3+eAwcOMHPmTHJycujZsyd9+vThwoULJTq2V199lfDwcL755ps824cOHcojjzxC48aNeeyxx/jtt9/4559/+PXXXwsta+rUqSQmJupvhkwFI4QQQghhCKMNnti9ezdZWVn5tmdkZLB3795i9589ezaff/45kyZNYvr06UybNo3Lly+zadMmZsyYUeS++/fvZ9euXTRp0qTAx9u2bcuoUaNYtWoVX3zxBXv27KFOnToGHdfYsWP5+eef+eOPP6hWrVqRzw0KCiI0NLTIxNHZ2bnQ2jwhhBBCiLIoc2J37xqvZ86cISYmRn9fq9WyZcsWqlatWmw5X331FZ999hmPPPIIs2fPZtiwYdSuXZumTZty8OBBxo0bV+i+33//vUGxOjs7M2bMGIOeqygKY8eOZePGjezevZuaNWsWu8/t27eJiooiKCjIoNcwNkVR0Ol0ZnltW3T/8nbCsmm1WrRarbnDEMJiFPZ+0Gg0Bs0vK6xTmRO73DVeNRpNgU2urq6ufPjhh8WWExMTo69x8/Dw0A9WePTRR5k+fXpZwyyxV155ha+//pqffvoJT09PfcLq7e2Nq6srKSkpzJo1i8cff5ygoCAuX77MW2+9ReXKlRk4cKDJ4wW4dOkSX331lVle21aFhoaaOwRRjNwvqA0bNpg5kopBEgLLZ29vD8DcuXMLfLxPnz60a9fOlCEJEypzYhcREYGiKNSqVYu///4bf39//WNOTk4EBATo/8mKUq1aNaKjo6levTphYWFs27aNli1bcujQIYOaLnfu3Mmrr77KwYMH8fLyyvNYYmIiHTt2ZNWqVXTu3Nmg4/r4448B6Nq1a57ta9asYcSIEdjb23Py5EnWrVtHQkICQUFBdOvWjfXr1+Pp6WnQaxhb7kTKwniCg4PNHYIohouLC0899RSpqanmDsXmaTQa6tata+4wRDEaNGiAnZ1doS048rlm2zSKhbQ3TZkyBS8vL9566y02bNjAsGHDqFGjBpGRkUycOJF33323yP379etHt27dmDhxYoGPL1++nF27drFx48byCL/UkpKS8Pb2JjExMV9CKoQQQlgq+f6yTEZP7M6cOUNkZGS+gRT9+vUrUTl//fUX+/btIywszKB9Q0ND2bJlCw0aNCjw8XPnztGrVy8iIyNLFEd5kzeGEEIIayTfX5bJaKNi//33XwYOHMjJkyfRaDT6jue5kxYX1ak5Ozub0aNHM336dGrVqgVAu3btStQH4MaNGzg6Ohb6uIODAzdv3jS4PCGEEEIIa2O0XrDjx4+nZs2a3LhxAzc3N06fPs0ff/xB69at2b17d5H7Ojo6lrmJtGrVqpw8ebLQx8PDw802WlUIIYQQwhSMltgdOHCAOXPm4O/vj52dHXZ2djzwwAMsWLCgyKlKcg0cOJBNmzaV+vUffvhhZsyYQUZGRr7H0tPTmTlzJo8++mipyxdCCCGEsHRGa4rVarV4eHgAULlyZa5fv069evUIDQ3l/Pnzxe4fFhbGO++8w/79+2nVqhXu7u55Hi8uOXz77bf58ccfqVu3Lq+++ir16tVDo9Fw9uxZPvroI7RaLdOmTSv9AQohhBBCWDijJXaNGzcmPDycWrVq0a5dOxYuXIiTkxOffvqpvt9cUT7//HN8fHw4cuQIR44cyfOYRqMpNrELDAxk//79vPzyy0ydOjVPH7/evXuzcuVKAgMDS3+AQgghhBAWzmijYrdu3UpqaiqDBg3i33//5dFHH+XcuXNUqlSJ9evXG7RerLHEx8dz8eJFFEWhTp06+Pr6muy1S0pGFQkhhLBG8v1lmcp1Hru4uDh8fX31I2MNkZWVRUREBLVr18bBwWgVihZL3hhCCCGskXx/WSajDJ7IycnBwcGBU6dO5dnu5+dncFKXlpbGc889h5ubG40aNdLPNzdu3LhiJycWQgghhBBGSuwcHBwIDQ0t0wLcU6dO5cSJE+zevRsXFxf99oceeoj169cbI0whhBBCCJtmtOlO3n77baZOnUpcXFyp9t+0aRMrVqzggQceyFPL17BhQy5dulTkvjk5OaxevZovvviC7OzsUr2+EEIIIYS1M1ontuXLl3Px4kWCg4MJDQ3NN13J0aNHi9z/5s2bBAQE5NuemppabHPuW2+9RadOncjJyWHKlCl88MEHJT8AGxAXF5evOVyUTWhoKKGhoeYOQxTj6NGjpKSkmDsMm6fRaGjWrJn0p7JwaWlpHD16FJ1OV+DjtWvXpmrVqiaOSpiK0RK7AQMGlGn/Nm3a8OuvvzJ27Fjg7lJkn332GR06dChyX51OR1paGnZ2doX+I1cEiYmJHDp0yNxh2IyMjAwuXbrEyJEjzR2KKEJ6ejq//PILgH4uTVE+UlJSsLe3p2PHjuYORRTh/Pnz7Nixo9D3g4eHhyR2Nsxoid3MmTPLtP+CBQvo06cPZ86cIScnh2XLlnH69GkOHDjAnj17it13/fr15OTk8N5775UpjnvL/PHHHzl37hyurq507NiR9957j3r16umfoygKs2fP5tNPPyU+Pp527drx0Ucf0ahRI6PEUFI1gyvx2rBOkBYLmfHg6A5uAVCpEbhWMktM1uynn37i9u3b5g5DFCN3YP/QoUOpX7++maOxbe+99x7lOJGCMJLcc/Taa6+ZORJhDkadTyQhIYENGzZw6dIlXn/9dfz8/Dh69CiBgYHFXh107NiRffv28f7771O7dm22bdtGy5YtOXDgAE2aNClyX0dHR55++mljHgp79uzhlVdeoU2bNuTk5DBt2jR69erFmTNn9M3MCxcuZPHixaxdu5a6desyd+5cevbsyfnz5/H09DRqPAa5vh9+7FvwYx7BULUzVOsCIV3ArwGUYBoaIYSF02kh5Sqk3gA7e3DyBq/qYO9k7siEECZktMQuPDychx56CG9vby5fvswLL7yAn58fGzdu5MqVK6xbt67YMpo0acKXX35prJDKZMuWLXnur1mzhoCAAI4cOcKDDz6IoigsXbqUadOmMWjQIAC+/PJLAgMD+frrr3nxxRdNH3RwR3g2XK2lc/aBnDRIuQa3TkPsUbj6B+waB7occAuEkK5QvTuEdAOfsLIneplJcDMcboXf+XlSfS1nb7V8vwYQ2AoCW4KDS/HlCSGKlpUCV7bBxZ/g318h474aZo0deIWq77sq7SCoHVRpCw7O5olXCFHujJbYTZo0iREjRrBw4cI8tVV9+/blySefNKgMrVbLxo0bOXv2LBqNhgYNGtC/f3+LmKg4MTERUOfmA4iIiCAmJoZevXrpn+Ps7EyXLl3Yv39/oYldZmYmmZmZ+vtJSUnGC9LZC/zvqd10cAYXX6jcGOoPVbdlpcD1AxC1C6J2wu8vg6IDj2p3k7zq3dUr/cLotJBw6W4Cd/OE+jPpsvq4nSNUagCVm4C9i9osfO1POLUatJnq44Et1UQ0uBNU7QTuVYz3dxDClqVch0u/wKWfIHIHaLPU7hbNXlRr5d2DQNFCRhwk/gtx5yHmEOyfqV7sObipF3U1ekNoL/CrZ5ra++w0iD4IN46otYoaO/XzybeuGr9fXXWbEKJMjJYxHTp0iE8++STf9qpVqxITE1Ps/qdOnaJ///7ExMTo+7H9888/+Pv78/PPPxfZHBsZGUn16kUkIve5du1aiTqOKorCpEmTeOCBB2jcuDGA/pjuX382MDCQK1euFFrWggULmD17tsGvbXROHlCjp3oDtZbt2l6I3Kkme2f+AyjgXUtN8Lxrq89Lv6l+ocSdhbhzaoIGakJWuSnUHQz+TdWbX/2Cm390OWoCeP2A2mx8YSMcWaI+5hOmJnjBD0DVB0z3ZSOEKSg6uLYfbh6H9Nvq+8O1kvp/71sXPKoW/v+u6CD2GFz6H/z7P7hxGDT2UK0zdH4Paj8GPrWLjyH3/Xfld7WW74/XQTtevagLfUi9Ve9h3IustFg1Cb24CSJ/h5wMcPQAjyBQFEi/BZkJ6nOdvSGo/d0LvqC24GSGLi1CWDmjJXYuLi4F1j6dP38ef3//Yvd//vnnadSoEYcPH9av7RofH8+IESMYPXo0Bw4cKHTfNm3a0K9fP1544QXatm1b4HMSExP57rvvWLZsGS+++KJ+9K0hXn31VcLDw/nzzz/zPXb/VCyKohQ5PcvUqVOZNGmS/n5SUhIhISEGx2J0zl5Q6xH1BuqXztU9ELlLTfQubAR04OqvfuAHtYPGo9QrbP8marOvoewc1Jq6wJbQ4hV1W/I1uL4Pru1Ta/XO/Ef9InOppCZ6Ve8kegEtpflIGEa5MzLeEmp/Ev6FM+vUW2KEmtC5VAJdtlqjlhurkxdUaqi+ryo3AkdPtb/cjSMQ/Zd6YeXsDaG9odUEqNEXXP1KFsu977+2b0B2qto948rvatJ1eq36vEqN1CQvpJuaZLkV//mdR/xFNZG79JP6vgb1PdxprlpDWLnR3XOjKOqx3Typ1uZd369e7O2fqT6ncmM12cu9+dWzjPMqhAUzWmLXv39/5syZw3fffQeoCU9kZCRTpkzh8ccfL3b/EydO5EnqAHx9fZk3bx5t2rQpct+zZ88yf/58+vTpg6OjI61btyY4OBgXFxfi4+M5c+YMp0+fpnXr1ixatIi+fQsZYFCAsWPH8vPPP/PHH39QrVo1/fYqVdSr2piYGIKCgvTbY2Nj89Xi3cvZ2RlnZwtOUFwrQZ1B6s0UPKtCvSHqDSArGa4fVJO86/tg/6w7zUcuENjmbqIX3BFcfEwTo7BsKdfVn3vegK071P8XNOBaWa0Z8q2vdg2o1FBNFHzrqklOeclMgn++h9NfqrXhTp5qjXafter/bm5ios2CxMsQf17tB3v7tFozd+5rtWbLzR/8m6lNrNV7qLVY9o7Gi9PRHWr2VW+gNo9G7lSTvAsb4egydbtP2J1atI5qE69y35RS6bfh6l51vyvbIf4f9f1avSf0+hxqP1r4BaBGoz4W2kO9gVp+3Dm1Zj832Qv/DFDU5LZKOzXJC2wFAS3As5rU7gtxD6N9ur3//vs8/PDDBAQEkJ6eTpcuXYiJiaFDhw7Mmzev2P3r1avHjRs38k0VEhsbS1hYWJH7+vn58f777zN37lw2b97M3r17uXz5Munp6VSuXJmnnnqK3r1765tRDaEoCmPHjmXjxo3s3r2bmjVr5nm8Zs2aVKlShe3bt9OiRQsAsrKy2LNnj9GmXKmQnDzzNhVrs9U+fLmJ3uk18PcCQKN+WQe2unNrDQHN1S8rYfuy0+HiRrXf5pUDwBtqgtBqjjpwSNGqzYAp19Qk4cRu9T6AvbM6kCe360DlJupPt8DSJwi6HLW/2+l1alw5GWqt18P/hbCB4OiWfx97J7VfmV9dtTlVX9ad5MmYSZwh3AOhwTD1piiQdOVut4noA3D2K8icrF5sXb+T3MVfVGsWQW0Orv4QdH4XavQq/XtRY3en9rIhNHlO3ZaZpPYTjD6o3k6sVJtxQa0BDWiuJnm5P33rqSODhaiAjJbYeXl58eeff7Jz5079jNctW7bkoYceMmj/+fPnM27cOGbNmkX79u0BOHjwIHPmzOG9997L08xb2KznLi4uDBo0SD9KtSxeeeUVvv76a3766Sc8PT31feq8vb1xdXVFo9EwYcIE5s+fT506dahTpw7z58/Hzc3N4MEiwgD2jlCltXprNUH9wkn8V030ov9W+xud/07t86exu2fkbWv1A75Sw5I3WQnLFXsCTn4OZ/+r9s2q9iB0Wwb/uwZtJkNR89il3YLbp+6O2L4ZDv9suFPDh1rD599U7TOam+xValhwUgZq8hVzGM6vV2vZUmPU/qXtZ0DDp9WapNKwswfMnJRoNOBdQ701GKZuy06F95eqTbQux9XEtEo79X0W1Ba8axZeXlk5e91Xq6eoSXvssTu34+q5PPy++ri9s1oz69dAvQDM/elbV0bkC5tn9PaI7t2707179xLv9+ijjwIwZMgQfR+13EkWH3vsMf19jUaDVqs1UrSF+/jjjwHo2rVrnu1r1qxhxIgRALzxxhukp6czZswY/QTF27ZtM88cdhWFRqPWDPjUhkbD1W3abLUZK+YwxB6582X7rdrUBWrfwEoNwa+h2r/Hr4G6v0dw2fvrpMWqXywZCWotkZOnWmPkFaqWX55NfpZCl6PW7Nw4ojbDpcWqtSmKVv3y966lJjz+zdRbSftsJV9Vv7TP/ld9DbdAaPqi2tfTry6kpcH/FhVfjltlcOuqjgjNpejUfnC3wtV+XrfCIeLXO82QCqAB3zp5a/XSb6m1yFG71N9d/aH+MGj4jHpRYavNgo7u6v9z9Qeg09vmjUWjURNnz2p5azsz4u+O0o87C7fPwtXdd2tr0agJaG6y51f/zq2BXAAKm2HUb50dO3awZMkS/XQl9evXZ8KECQbV2u3atcuYoZSZIbOrazQaZs2axaxZs8o/IFE4e8c7TTDNgefVbdostQnu9lm4fQbizqhNZeGr1EQE1Ct371rqyF/fMPVnbtLoVaPg18qIVzucR+5Up4u5VcTavHYO4BmivoZP2D23O69RWE2QNVAUNZk7sw4u/KAmOPbOaud2t8A7Sa0j5KTDjaNqM15OurqvR/CdJK+5+jOgufp3yW06y8lUE7ioXRCxWW0KtHeCGn2g/XSo+bDxmik1duq59w3L2680O1X9v7m3du/ocnXAg4uPOsCgyfNQ8xEIbl8xEnhr4OKrJu73Ju8A6XF3E724O7cLP6h9HLnzWe/qfzfRq3RP0ucVKgM2hFUx2qfRihUrmDhxIk888QTjx48H1KbUhx9+mMWLF/Pqq68WuX+XLl2MFYoQaiKQ24fqXtostYYm8RIkXFTn40u4pE7umhihjlYEdToJ3VNAFdg1UZ34NfbY3UTOu6baJNV2CgR1UJvx7OzVwR/ptyE5Uv3SSLqsNh1H/6UmN9n3LFTvEXxfwpeb9IWpTU8lpejUL7C0GLVZMM8tWq21yElXm611WaBxAAdXNcF0cFN/uvipfdVc/dWaNVd/dUCNk6daMxp3Tk24/v0F4i+AZ3W15qzO4+poy8ISHJ1W/XvfPKHeYo+rSWHKNfVxBzf176HNUvtsKTp1pGhIN+i7Dmr3UzvOm4qjO1Rpo97upSi2WyNny1z97oyy75R3e3Y6JFy4exEYd07ty3f2v3cvRBxc1D57lZuoXUIC26jNz46ud8vJiFf3vXVavYi8dVq9MEiPVd9jzr5qguhdQy0rsKVaRklmFRDCQEZL7BYsWMCSJUvyJHDjxo2jU6dOzJs3r9jEDtRF18PDw4mNjUWnyzvyql+/fsYKVVRk9k5Qqb56u1/ukkzxF9UkZP9lSM6Ey1vUhKdKO2g9We3XVVh/Ikf3O3P7FbBesKKoyZU+obzzOrdOqh3uM+LvPtfV/84cZ2HqhLN2jmrSpOjU5DA7VZ1sOiNOTdzSbqhlK/d1U3DyUuNxr6LWpDlWBTsn9e+gaNVJY3PS1X5mqdFq4pp+E9Ju5i8rl0c1tXP8Q5+oy9MZUpthZ6/W5vnVuzsCGtR+bzdPqPO7pd5Qa+K8aqoJeVGJorlIUmdbHF0LvgBUdJAcdTfZizt7px/fd+rFh8b+7ujqlOv3rPhxp6tIpYZq07xHsDqQJuO2Ohgl7rw64jjrTp9xj6rqVE6BLe/+LGpOQyEMYLRPzaSkJPr06ZNve69evXjzzTeL3X/Lli08++yz3Lp1K99jpupXJyo4O3v1qtorVO2kffknuH0bRi42TvkajTry0D0wf80BqLVtiZfuJpa5CeD1/WrSqctRy3D0UBNIR3e16Sm4vZq0uQXeTeA8gu4kcqVs7lV0ar/B9Jtq8piVrH6Z+dS+0zRlpC8et8p5O8ULYQlyl2LzCoWa93yvabPUi5+YQ3dr792r3J1o2q9+3pq8gig6tXXgxlF1qcfYY3D8o7ujfN0C7kv2Whn3PSdsntESu379+rFx40Zef/31PNt/+ukn/eCHorz66qsMHjyYGTNmFDkPnBA2y9VPvd3f/GcOGru78QghVPZOdyd5Li2N3d1+tvUGq9sURR0kFHv0bsJ3ag2kzlcfd/FVk7yAlupcjLmDwKy5n64oN0ZL7Bo0aMC8efPYvXs3HTp0ANQ+dvv27eO1115j+fLl+ueOGzcu3/6xsbFMmjRJkjohhBAVi0YDXiHqLaz/3e0p0XemczmqDij65zs4nDsCPHeE753VSirdufkVMeWPqBCMlth98cUX+Pr6cubMGc6cOaPf7uPjwxdffKG/r9FoCkzsnnjiCXbv3k3t2gaseSiEEELYOo8g9Vbr4bvbspLVvn+3TqnTPN0+DWf+e3eiaI0dOPQEOsAvQ9R+fl6h6kh/71pqTaGThzmORpiI0RK7iIgIAG7duoVGo6FSpUol2n/FihUMHjyYvXv30qRJExwd805nUFAyKIQQQlQoTp7qhNBB962LnpmojsS9dRpOXYB41P6xt06qAzdyR/mCOql3S/lOtVVGSewSEhKYNm0a69evJz5eHdnn6+vL//3f/zF37lx8fHyKLePrr79m69atuLq6snv3bv0kxVB4LZ8QQgghUKcDCu6g3nKOwoVfYPDv6mO5I/IT/1UHZQW2Mm+solyVObGLi4ujQ4cOXLt2jaeeeooGDRqgKApnz55l7dq17Nixg/379+Pr61tkOW+//TZz5sxhypQp2NnJZJBCCCGEUdw7Ij+4g7mjEeWszIndnDlzcHJy4tKlS/kGPsyZM4devXoxZ84clixZUmQ5WVlZDB06VJI6IYQQQohSKnMWtWnTJt5///0CR7NWqVKFhQsXsnHjxmLLGT58OOvXry9rOEIIIYQQFVaZa+yio6Np1KiAWfbvaNy4MTExMcWWo9VqWbhwIVu3bqVp06b5Bk8sXmykSWKFEEIIIWxUmRO7ypUrc/nyZapVq1bg4xEREQaNkD158iQtWrQA4NSpvAura2TGbSGEEEKIYpU5sevTpw/Tpk1j+/btODk55XksMzOT6dOnF7jU2P127dpV1lCEEEIIISq0Mvexmz17NufPn6dOnTosXLiQn3/+mZ9//pl3332XOnXqcPbsWWbNmmVweRcvXmTr1q2kp6tz7iiKUtYQS+2PP/7gscceIzg4GI1Gw6ZNm/I8PmLECDQaTZ5b+/btzROsEEIIISq8MtfYVatWjQMHDjBmzBimTp2qT8Q0Gg09e/ZkxYoVhISEFFvO7du3GTJkCLt27UKj0XDhwgVq1arF888/j4+PDx988EFZQy2x1NRUmjVrxsiRI3n88ccLfE6fPn1Ys2aN/v79tZZCCCGEEKZilAmKa9asyW+//UZ8fDwXLlwAICwsDD8/wxcQnzhxIo6OjkRGRtKgQQP99qFDhzJx4kSzJHZ9+/alb9++RT7H2dmZKlWqGFxmZmYmmZmZ+vtJSUmljk+Uv6ioKA4dOmTuMEQRsrKyzB1ChZGTk8ORI0fkAtbCRUVFmTsEYUZGW1IM1NUm2rZtW/wTC7Bt2za2bt2abxBGnTp1uHLlijHCKxe7d+8mICAAHx8funTpwrx58wgICCj0+QsWLGD27NkmjFCUVuXKlQHYunWrmSMRxXFycsLb29vcYdi84OBgIiMj5T1hBfz9/c0dgjATjWLOTmz38PT05OjRo9SpUwdPT09OnDhBrVq1OHToEH369OH27dtmjU+j0bBx40YGDBig37Z+/Xo8PDwIDQ0lIiKC6dOn669onZ2dCyynoBq7kJAQEhMT8fLyKu/DEEIIIYwiKSkJb29v+f6yMEatsSuLBx98kHXr1vHOO+8AaiKl0+lYtGgR3bp1M3N0BRs6dKj+98aNG9O6dWtCQ0P59ddfGTRoUIH7ODs7F5r0CSGEEEKUhcUkdosWLaJr164cPnyYrKws3njjDU6fPk1cXBz79u0zd3gGCQoKIjQ0VN/P0BC5FabS104IIYQ1yf3espCGP3GHxSR2Hh4eHD9+nE8++QR7e3tSU1MZNGgQr7zyCtnZ2eYOzyC3b98mKiqKoKAgg/dJTk4GMGjksBBCCGFpkpOTpY+rBbGYPnb29vZER0fnG3hw+/ZtAgIC0Gq1Jo8pJSWFixcvAtCiRQsWL15Mt27d8PPzw8/Pj1mzZvH4448TFBTE5cuXeeutt4iMjOTs2bN4enoa9Bo6nY7r16/j6elpVSts5PYNjIqKstq+FXIMlkGOwXLYwnHIMZiOoigkJycTHByMnV2Zp8UVRmIxNXaF5ZcpKSm4uLiYOBrV4cOH8/TvmzRpEgDDhw/n448/5uTJk6xbt46EhASCgoLo1q0b69evNzipA7Czsyt0OTZr4OXlZdEfPIaQY7AMcgyWwxaOQ47BNKSmzvKYPbHLTZY0Gg0zZszAzc1N/5hWq+Wvv/6iefPmZomta9euRfYdkCH/QgghhLAkZk/sjh07Bqg1didPnswz8aWTkxPNmjVj8uTJ5gpPCCGEEMJqmD2x27VrFwAjR45k2bJlFl/tLFTOzs7MnDnTqqdukWOwDHIMlsMWjkOOQVR0FjN4QgghhBBClI0MYxFCCCGEsBGS2AkhhBBC2AhJ7IQQQgghbIQkdkIIIYQQNkISOyGEEEIIGyGJnRBCCCGEjZDETgghhBDCRkhiJ4QQQghhIySxE0IIIYSwEZLYCSGEEELYCEnshBBCCCFshCR2QgghhBA2QhI7IYQQQggbIYmdEEIIIYSNcDB3ABWdTqfj+vXreHp6otFozB2OEEIIYRBFUUhOTiY4OBg7O6knshSS2JXRH3/8waJFizhy5AjR0dFs3LiRAQMGGLz/9evXCQkJKb8AhRBCiHIUFRVFtWrVzB2GuEMSuzJKTU2lWbNmjBw5kscff7zE+3t6egLqG8PLy8vY4QkhhBDlIikpiZCQEP33mLAMktiVUd++fenbt6/Bz8/MzCQzM1N/Pzk5GQAvLy/LSOyu7YOYQ2UrI7A1VHvAOPGYQ04mnPkSstMKf46TJzQaAXb2JgvL5G6ehMgdRT+naieo0qb0r3H2K0i7Wfr9NRoIGwhe1UtfRlEUBc78BzLiSl+GRgN1ngDPqgU/nhQJFzeqr1Vabv7Q4KnS71+cxMtwcVPZynALhAbDjBGN+VzYBEmXC39cYw/1/089HxWIdCOyLKVK7LRaLRs3buTs2bNoNBrq16/PgAEDcHCQPLE4CxYsYPbs2eYOo3A7x8Ktk2DvUrr9tRlQqSE8e8K4cZlSzF+w/UVwcANNAf1GFC3kpKsJbEAz08dnKvtnwqWf1L9DQXLSoVpnGLKrdOWn3oDNT4ODC2hK+dmRnQKpMdB5Qen2L07yVdgyvOwxpsdBp0Le9yc+hr/fA0f30pWv5EBOBlR/CNwDS1dGcY59CEeWlD5GXTZoM6FGb3D1M25spqIo8MvjYOcAdk4FPyc7Rf18aDXBpKEJca8Sf1KdOnWK/v37ExMTQ7169QD4559/8Pf35+eff6ZJkyZGD9KWTJ06lUmTJunv51ZlWwxdDjQbA92XlW7/XRPgyu9GDcnkdDnqzxGnwLtm/sdvHIP/tlQ/wG2ZLgdqPgIDfy748d+GQ2JE2coH6LcRavYpXRmr64GuHM+DcifGgb9C9e6lK+OzmkX/r+hywLcujDpXuvIjfoMfHy7f/0ddDlRuDMPDS7f/xZ/gpwHW/55RdNDjY2gyquDHV/hY/zEKq1fixO7555+nUaNGHD58GF9fXwDi4+MZMWIEo0eP5sCBAwaVs2PHDnbs2EFsbCw6nS7PY6tXry5pWFbD2dkZZ2dnc4dRhDI0Bxm1DDMyuEnMyo+zWApQXBNLWf4Gxvr7leN5KEvzaN6Cyv81jBZrgYVbWDnmYGDs5XoehCheiRO7EydO5EnqAHx9fZk3bx5t2hjW12b27NnMmTOH1q1bExQUJO3zQgghhBBGUOLErl69ety4cYNGjRrl2R4bG0tYWJhBZaxatYq1a9fyzDPPlPTlRXlTFLWzd6lpbOCKNTf+Qv4OuX8fqz/O4igF9zHMpSnjuc7d16L/34r5XzBEsX8nI7zncsspL8b4XMgtx1oZ9P+qwbprJYUtKHFiN3/+fMaNG8esWbNo3749AAcPHmTOnDm89957JCUl6Z9b2CjPrKwsOnbsWMqQLUtKSgoXL17U34+IiOD48eP4+flRvXo5jdQTQgghhChAiRO7Rx99FIAhQ4bom1CVO1cyjz32mP6+RqNBqy24E+nzzz/P119/zfTp00sVtCU5fPgw3bp109/PHRgxfPhw1q5da6aoysKQflVF0NjAFWuxV+YmqCGxBMXW0pT1XBupNswUfezKXFtVTI1dmf8GmKDm0ggxWvV7xoD/17LWYgthBCVO7HbtKuXUBvfIyMjg008/5ffff6dp06Y4OjrmeXzx4sVlfg1T6dq1qz6xFUIIIYQwpxIndl26dCnzi4aHh9O8eXNAnT7lXjKQwsykjx3Sxy6XATV2ZfobGKHGrtz7NJmgj52x+q+Ve82l9LEDpI+dsHilmnEzIyOD8PDwAqcq6devX7H7G6PWTwghhBBC5FXixG7Lli08++yz3Lp1K99jRfWrK8zVq1fRaDRUrVrIcjvCxIxxZW7tV6zF1dLYQn8hAxRXS1PW/m3G6L9W3n2arKGPnUn+H8tYq1hR+tjZRIuFsHZFzGVQsFdffZXBgwcTHR2NTqfLczM0qdPpdMyZMwdvb29CQ0OpXr06Pj4+vPPOO/lqAIUQQgghhGFKXGMXGxvLpEmTCAws/ZqE06ZN44svvuDdd9+lU6dOKIrCvn37mDVrFhkZGcybN6/UZYsyKmtfmoowKlb62N1hAaNipY+ddYyKrSh97Gzh809YvRIndk888QS7d++mdu3apX7RL7/8ks8//zxPf7xmzZpRtWpVxowZI4mdEEIIIUQplDixW7FiBYMHD2bv3r00adIk31Ql48aNK7aMuLg46tevn297/fr1iYuLK2lIwqiMNULPFhTXx64iKMc5u6ypj1251ipaQR87Y9Uq2gQZFSssW4kTu6+//pqtW7fi6urK7t2780xPotFoDErsmjVrxooVK1i+fHme7StWrKBZs2YlDUlYGmtubgEM/2C29uMshtWfR2F5rPl/yppjFxVJiRO7t99+mzlz5jBlyhTs7Eo89gKAhQsX8sgjj/D777/ToUMHNBoN+/fvJyoqis2bN5eqTGEsxpph3gYU18euIpA+dndephzndqxIfexsQXF97OSCSJhZiTOzrKwshg4dWuqkDtRJjv/55x8GDhxIQkICcXFxDBo0iPPnz9O5c+dSlysshZV/sBn6wWzzH+C2fnzC5Kz5PWPNsYsKpcQ1dsOHD2f9+vW89dZbZXrh4OBgGSRhiYw2C74tkD52Fb6PnUnWs5U+dtZF+tgJy1bixE6r1bJw4UK2bt1aonVew8PDady4MXZ2doSHhxf5Gk2bNi1pWMKSWP2VrfSxA2zgPArLY83/U9Ycu6hISpzYnTx5khYtWgAlW+e1efPmxMTEEBAQQPPmzdFoNCgFfHEUtnpFixYtDF5H9ujRowY9TxRE+tiJexV3Pm28j50pVp4wytyRmKjmsrQq0OeCXBAJMytxYlfadV4jIiLw9/fX/15SAwYMKNXrCnOw8g+2Yr/MbWCyVYMUd3wV6MtaYJzzbc3vGQMuROTCVliAEid2pRUaGqr//cqVK3Ts2BEHh7wvn5OTw/79+/M8N9fMmTPLPUaB9LETeRX3v2DuPnblvjanCVaeMNrckaaYz6+0KtLngjUnr8IWlDix69atW5FNojt37jSojOjoaAICAvJsT0xMpFu3bgavOSsslNXXZBXzZW4TC5obopjjk9qJisUY59uaPxsMuhCR94QwvxInds2bN89zPzs7m+PHj3Pq1CmGDx9uUBmKohSYHN6+fRt3d/di99dqtSxZsoTvvvuOyMhIsrKy8jwuq1eUhfSxE/ey8D525b02pyn62BnrPWfJfewq0ueCNSevwiaUOLFbsmRJgdtnzZpFSkpKkfsOGjQIUAdIjBgxAmdnZ/1jWq2W8PBwOnbsWGwMs2fP5vPPP2fSpElMnz6dadOmcfnyZTZt2sSMGTNKcDSifFj5B5uhfeys/TiLU+wXVAX6shZIHzvpYyesQ+lnGb7P008/zerVq4t8jre3N97e3iiKgqenp/6+t7c3VapUYfTo0fz3v/8t9rW++uorPvvsMyZPnoyDgwPDhg3j888/Z8aMGRw8eNBYh1QxSR87cS9T9LGz5FGxpuhjZ7T3nPSxswzWnLwKW2C0wRMHDhzAxcWlyOesWbMGgBo1ajB58mSDml0LEhMTQ5MmTQDw8PAgMTERgEcffZTp06cbVEZUVBSXL18mLS0Nf39/GjVqlKcGUZSB1TdFGNjHzuqPszhSYyfuJX3sAOljJyxeiRO73ObUXIqiEB0dzeHDhw1Oqso6wrVatWpER0dTvXp1wsLC2LZtGy1btuTQoUNFJmdXrlxh1apVfPPNN0RFReWZR8/JyYnOnTszevRoHn/88TItmWb9pI+dyGWC82kNKxqUey22jdeSy+eCECZT4uzl3uZTb29v/Pz86Nq1K5s3by5RwrZhwwaGDBlC+/btadmyZZ5bcQYOHMiOHTsAGD9+PNOnT6dOnTo8++yzjBo1qsB9xo8fT5MmTbhw4QJz5szh9OnTJCYmkpWVRUxMDJs3b+aBBx5g+vTpNG3alEOHDhl8LLbFGFfUVnxVDgY0EUofO8AIAxeM9Pcrz1ogo5Vd3OAJY7xEOTdJGyU5s+b3jCHN8uU9/Y4QxStxjV1uc2pZLF++nGnTpjF8+HB++uknRo4cyaVLlzh06BCvvPJKsfu/++67+t+feOIJqlWrxv79+wkLC6Nfv34F7uPk5MSlS5f0kyTfKyAggO7du9O9e3dmzpzJ5s2buXLlCm3atCn9QVoz6WMncpmkpsUa/t/KuVbRGmoty8QaYhTCNpS6j93hw4c5e/YsGo2GBg0a0KpVK4P3XblyJZ9++inDhg3jyy+/5I033qBWrVrMmDGjVFOVtG/fnvbt2xf5nEWLFhlc3sMPP1ziGGyGXG3eVdgXplV8kZqChdTYmWTwRFmLKW5JMaO8iJHKKaxs+b8Hin7/l/f0O0IYoMSJ3dWrVxk2bBj79u3Dx8cHgISEBDp27Mg333xDSEhIsWVERkbqpzVxdXUlOTkZgGeeeYb27duzYsWKYsv4559/2L17N7Gxseh0ujyPyZQnZWXJKwGYgoHxW/1xFsdEX+bWUFslfezKxhYGHFlz7KJCKXFiN2rUKLKzszl79iz16tUD4Pz584waNYrnnnuObdu2FVtGlSpVuH37NqGhoYSGhnLw4EGaNWtGREREngENhfnss894+eWXqVy5MlWqVMkz2bFGo5HErkzkw+uu4vrYVXDFLpVVDGN9UUofOyOXU1DRxupjZwuKGxUrn6HCvEqc2O3du5f9+/frkzqAevXq8eGHH9KpUyeDyujevTu//PILLVu25LnnnmPixIls2LCBw4cP5xt1W5C5c+cyb9483nzzzZKGLwxiwSsBmISh8Vv7cRbDZF/m1lBbVc4xWkOtZZnYwoAja45dVCQlTuyqV69OdnZ2vu05OTlUrVrVoDI+/fRTffPpSy+9hJ+fH3/++SePPfYYL730UrH7x8fHM3jw4JIFLgwjzQ13SR+7YkgfO8OLMUEfu3JfUkz+74Hi+9jJZ6gwsxJPd7Jw4ULGjh3L4cOH9c2mhw8fZvz48bz//vuGvaidHQ4Od3PKIUOGsHz5csaNG4eTk1Ox+w8ePNigJl9DXL16NV8fvQqvXNfFtAKGfjDb/Ae49LG754XKsKv0sZM+dkKYTolr7EaMGEFaWhrt2rXTJ2c5OTk4ODgwatSoPPPI3TvCNTw83ODXaNq0aZGPh4WFMX36dA4ePEiTJk1wdHTM8/i4ceMMfq2GDRty/PhxatWqZfA+tk0+vO6SPnZFqgh97ExSq2gFNZfSx+4e0sdOWLYSJ3ZLly4t1Qs1b94cjUZT7OAIjUaDVqst8jmffvopHh4e7Nmzhz179uTbvySJnSGDNSqeclwX0ypIHztA+tjleRkLHhVrFQmX9LETwlRKnNgNHz68VC8UERFRqv3KuyxxP/nwEiVh433sTDEqtkLVXFYAVn9hK6xdqScoLqnQ0FBTvVSJvPXWW/j5+Zk7DBtj5R9sxS32bQv9hQxS3PFZQ02RMB4jnG9rfs8Uu9QgVlJ7KmydyRK7e61bt67Ix5999tkiH580aVKB2zUaDS4uLoSFhdG/f3+DErapU6cW+5wKpczNb/LBZluKOZ/G6GNX1v83k9RUlWf3BGO95yy55rIifS5YcfIqbIJZErvx48fnuZ+dnU1aWhpOTk64ubkVm9gdO3aMo0ePotVqqVevHoqicOHCBezt7alfvz4rV67ktdde488//6Rhw4bleSiiINZ8VQ4U/2VuC/2FDFDceZTaiYrFKOfbmt8zhlyIyHtCmF+Jpzsxhvj4+Dy3lJQUzp8/zwMPPMA333xT7P79+/fnoYce4vr16xw5coSjR49y7do1evbsybBhw7h27RoPPvggEydONMHR2JoyTnEhX/Y2prjzaYw+dhY8IbaxahWLHRVrhPecJfexq0ifC1Z/YSusXYkTu1GjRunXdr1XampqnqlOSqpOnTq8++67+WrzCrJo0SLeeecdvLy89Nu8vLyYNWsWCxcuxM3NjRkzZnDkyJFSxyPKwso/2Ir9Mq8gNXbSx07kITV2KuljJyxbiRO7L7/8kvT09Hzb09PTi+07Vxx7e3uuX79e7PMSExOJjY3Nt/3mzZskJSUB4OPjQ1ZWVpniqZCkj524V3H/C5bQx84kK0+UYx87o73npI+dZbDm5FXYAoP72CUlJaEoCoqikJycjIuLi/4xrVbL5s2bCQgIMKisn3/+Oc99RVGIjo5mxYoVBq03279/f0aNGsUHH3xAmzZt0Gg0/P3330yePJkBAwYA8Pfff1O3bl39PpGRkVSvXt2g+ACuXbtm8BJp4j5W3xRRzJe5jIq9oyJ9WQuj1EZZ83vGoAsReU8I8zM4sfPx8UGj0aDRaPIkTLk0Gg2zZ882qKzc5Oveff39/enevTsffPBBsft/8sknTJw4kf/7v/8jJycHAAcHB4YPH86SJUsAqF+/Pp9//rl+nzZt2tCvXz9eeOEF2rZtW2C5iYmJfPfddyxbtowXX3yRsWPHGnQ8tkX62Il7WUEfu/JMFqSP3R3Sx85g1py8CptgcGK3a9cuFEWhe/fu/PDDD3mmEnFyciI0NJTg4GCDyirr2qweHh589tlnLFmyhH///RdFUahduzYeHh765zRv3jzPPmfPnmX+/Pn06dMHR0dHWrduTXBwMC4uLsTHx3PmzBlOnz5N69atWbRoEX379i1TjBWblX+wSR87lYyKFXlIHzuV9LETls3gxK5Lly6AuupDSEgIdnZmGVCbh4eHR7Hryuby8/Pj/fffZ+7cuWzevJm9e/dy+fJl0tPTqVy5Mk899RS9e/emcePG5Ry1hZM+duJexf4vmLnGTvrYIX3sLI01J6/CFpR4HrvcFSTS0tKIjIzMN0ChsESrsEmFC7J48eJ82wYNGsTatWvx8vJi0KBBRe7/448/FvqYi4sLgwYNKrYMIYrtY1fhyd+hYpHzDUgfO2HxSpzY3bx5k5EjR/Lbb78V+LhWqy1w+7Fjx/LcP3LkiH6CYYB//vkHe3t7WrVqVeD+3t7eaO68oby9vUsatjBYGfv7lPtKAKZgYPxWf5zFMeB/wdyjYqWPHabpGmCkPnbW/J4xNHZrPkZhE0qc2E2YMIH4+HgOHjxIt27d2LhxIzdu3GDu3LlFDnzYtWuX/vfFixfj6enJl19+ia+vL6BOWjxy5Eg6d+5c4P5r1qzR/75y5Up0Oh3u7u4AXL58mU2bNtGgQQN69+5d0kMSohDF9bGr4KTmsmKR832H1NgJy1bixG7nzp389NNPtGnTBjs7O0JDQ+nZsydeXl4sWLCARx55pNgyPvjgA7Zt26ZP6gB8fX2ZO3cuvXr14rXXXity//79+zNo0CBeeuklEhISaN++PY6Ojty6dYvFixfz8ssvl/SwRC7FGCP0rP2K1dD4rf04i2FQ3y/pY1e8cu5jZw2jYm1iwJF8LgjrUOIREKmpqfr56vz8/Lh58yYATZo04ejRowaVkZSUxI0bN/Jtj42NLXBVi/sdPXpUX7O3YcMGAgMDuXLlCuvWrWP58uWGHooQRSvsy1ZqLu6Qv0PFIucbKPr9L58NwgKUOLGrV68e58+fB9QpRT755BOuXbvGqlWrCAoKMqiMgQMHMnLkSDZs2MDVq1e5evUqGzZs4LnnnjNoUENaWhqenp4AbNu2jUGDBmFnZ0f79u25cuVKSQ9J5GGMEXpWfsUqfWnukD52d8suz1psK+hjV9a/cUXqY2ftn3/C6pWqj110dDQAM2fOpHfv3nz11Vc4OTmxdu1ag8pYtWoVkydP5umnnyY7O1sNxMGB5557jkWLFhW7f1hYGJs2bWLgwIFs3bqViRMnAmqN373rxwpRNtLHrkhSO1GxyPm+Q/rYCctW4sTuqaee0v/eokULLl++zLlz56hevTqVK1c2qAw3NzdWrlzJokWLuHTpEoqiEBYWph8MUZwZM2bw5JNPMnHiRHr06EGHDh0AtfauRYsWJT0kkYcR+thZ81U5IH1p7pA+dnfLLs9abOljZyWkJl9YhxIndrmysrKIiIigdu3atGzZslRluLu74+fnh0ajMTipA3jiiSd44IEHiI6OplmzZvrtPXr0YODAgaWKRQghhBDC2pW4j11aWhrPPfccbm5uNGrUiMjISADGjRvHu+++a1AZOp2OOXPm4O3tTWhoKNWrV8fHx4d33nnH4OXGqlSpQosWLfKsgNG2bVvq169f0kMS9zLKLPhWfsVaXN8vW+gvZJDiam/LWDtrDX3sTLKerbX0sbP0WsVyZsj/q03MCiCsXYkTu6lTp3LixAl2796Ni4uLfvtDDz3E+vXrDSpj2rRprFixgnfffZdjx45x9OhR5s+fz4cffsj06dNLGpIQQgghhKAUTbGbNm1i/fr1tG/fXr8SBEDDhg25dOmSQWV8+eWXfP755/Tr10+/rVmzZlStWpUxY8Ywb968koYljEb62BVfS2ML/YUMUFwtTZlrJ6ygj50pVp6witowK1jPttwZ8v9qC59/wtqVuMbu5s2b+nns7pWampon0StKXFxcgU2m9evXJy4urqQhCSGEEEIISpHYtWnThl9//VV/PzeZ++yzz/SjU4vTrFkzVqxYkW/7ihUr8gyGEGYifezUn4X+HWygv5BBiqulMdLUDkapCSpvRqhRK+tzCt+5DPua6nUqSI2dTAkjLECJm2IXLFhAnz59OHPmDDk5OSxbtozTp09z4MAB9uzZY1AZCxcu5JFHHuH333+nQ4cOaDQa9u/fT2RkJL/99luJD0IYkc0nK8KojDF4wpwxFF+4kYopbvCEUV7ESOUUVLR8LhhO/lbCvEpcY9exY0f27dtHWloatWvXZtu2bQQGBnLgwAFatWplUBldunTh/PnzDBo0iISEBOLi4hg0aBD//POPfqkwYU7Sx05V3JJi1n6cxTGkj50xlHNtmDGUe42ajf8NKsqoWJmgWFiAUs1j16RJE7788ssyvXClSpXo168f7du3109xcvjwYYA8gyqEqVnxB68wA2MMnjBnDMUVbYoYK1DNZUVgzcmrsAkGJ3ZJSUkGPc+QJb22bNnCs88+y+3bt1HuexNoNBq0Wq2hYYnyYBX9fUyguD52FYFJaies4f9N+thZx3kyBeljJyybwYmdj49PkaNeFUUxOCl79dVXGTx4MDNmzCAwMNDQEIQpGOVq08qvWGWxb5UhfwdL6GNniiXFylxMcdOdGOVFjFROQUVbQYzlTj4XhHUwOLHbtWuX/ndFUXj44Yf5/PPPqVq1aolfNDY2lkmTJtlMUpe77m10dDSNGjVi6dKlVt5X0Ar6+5hEcX3sKgILHxVrDf3LyruPnTXU2NnSe0b62AkLZ3Bi16VLlzz37e3tad++PbVq1Srxiz7xxBPs3r2b2rVrl3hfS7N+/XomTJjAypUr6dSpE5988gl9+/blzJkzVK9e3dzhlYIRrjatvo+JLPatMuT4LKCPXXmeB+ljl1s4RklarPk9Y2js1nyMwiaUavBEWa1YsYLBgwezd+9emjRpgqOjY57Hx40bZ46wSmXx4sU899xzPP/88wAsXbqUrVu38vHHH7NgwQIzR1dKVtHfxwSkj50B62Ia5UXMtK+JXqe8+9jZTK2ltZAaO2HZzJLYff3112zduhVXV1d2796dp++eRqOxmsQuKyuLI0eOMGXKlDzbe/Xqxf79+wvcJzMzk8zMTP19QwelGCT6L9gzuWxlZKeVPY6cdPjWipuiU2MMe96+t+Ho0nINxawSLkH1HkU/Jy229Oc6M7F0+90valf5/b9lJhinnCvbC4/x9hkIalf219gxBpy9y15OQW6fhqpG+BtvHw1OnmUvxxxy0g173sUf4VZ4+cZSVi3HQ90nzB2FKCdlSuwMXULsfm+//TZz5sxhypQp2NmVeCo9i3Hr1i20Wm2+voKBgYHExBScHCxYsIDZs2eXT0AObuBTxuZt37pQ8+HS71+zL9w8AYoVj2z2qQ2Nhhf+uLM3tJ0KqddNF5M5+NSG+sMKf7zOIEiKBHSlf43q3cG7Zun3b/YSuJdzX93QnuAZUvr9m78Cl34u/HGf2hA2qPTle9dSv6iNlYQWxKc21B1c+v1960KLsZBlxAtZc6jSFgJbFv5460kQucN08ZSWUzldAAiLoFHun2+kEIMG5f3g+eWXX+jevTvu7u55tv/444/FluXn58ehQ4esvo/d9evXqVq1Kvv378+znNq8efP4z3/+w7lz5/LtU1CNXUhICImJiQZNFSOEEEJYgqSkJLy9veX7y8IYXGPn7Z03w3/66adL/aLDhw9n/fr1vPXWW6UuwxJUrlwZe3v7fLVzsbGxhY74dXZ2xtnZ2RThCSGEEKKCMTixW7NmjdFeVKvVsnDhQrZu3UrTpk3zDZ5YvHix0V6rPDk5OdGqVSu2b9/OwIED9du3b99O//79DSojt8LUqH3thBBCiHKW+71lYMOfMBGzDJ44efIkLVq0AODUqVN5Hittvz1zmTRpEs888wytW7emQ4cOfPrpp0RGRvLSSy8ZtH9ycjIAISFl6MMjhBBCmElycnK+Vj1hPgb3sROFW7lyJQsXLiQ6OprGjRuzZMkSHnzwQYP21el0XL9+HU9PT6tKanP7BkZFRVlt3wo5Bssgx2A5bOE45BhMR1EUkpOTCQ4OtuqBkLZGEjtRKrbQaVaOwTLIMVgOWzgOOQZR0UmKLYQQQghhIySxE0IIIYSwEZLYiVJxdnZm5syZVj11ixyDZZBjsBy2cBxyDKKikz52QgghhBA2QmrshBBCCCFshCR2QgghhBA2QhI7IYQQQggbIYmdEEIIIYSNkMROCCGEEMJGSGInhBBCCGEjJLETQgghhLARktgJIYQQQtgISeyEEEIIIWyEJHZCCCGEEDZCEjshhBBCCBshiZ0QQgghhI2QxE4IIYQQwkY4mDuAik6n03H9+nU8PT3RaDTmDkcIIYQwiKIoJCcnExwcjJ2d1BNZCknsyuiPP/5g0aJFHDlyhOjoaDZu3MiAAQMM3v/69euEhISUX4BCCCFEOYqKiqJatWrmDkPcIYldGaWmptKsWTNGjhzJ448/XuL9PT09AfWN4eXlZezwhBBCiHKRlJRESEiI/ntMWAZJ7Mqob9++9O3bt9T75za/enl5SWInhBDC6kg3IssiiZ2JZWZmkpmZqb+flJRkxmhEaWi18MQTcP26uSMRGg3MmAEPP2zuSCq2U6fgpZcgO9vckQh3d/j2WwgIMHckwlwksTOxBQsWMHv2bHOHIcogORk2bYIePaBWLXNHU7GtXw+7d0tiZ25HjsC+ffDccyB96M0nIQG+/x4uXJDEriKTxM7Epk6dyqRJk/T3c/soCOvz8stQim6Vwoj27AFFMXcUIvccrFoFDvKtYjbnzqmJnbwnKjZ5C5qYs7Mzzs7O5g5DlIF8aAohhLBUUmkuRClJf2Hzk3NgWeR8mJf8/QVIjV2ZpaSkcPHiRf39iIgIjh8/jp+fH9WrVzdjZKK8SI2dZZHzYX5yDiyLnI+KTRK7Mjp8+DDdunXT38/tPzd8+HDWrl1rpqiEKcjVsfnJObAscj7MS/7+AiSxK7OuXbuiyOVRhSKn27LI+TA/OQeWRc5HxSZ97IQoJbk6Nj85B5ZFzod5yd9fgCR2QpSYXA1bFjkf5ifnwLLI+ajYJLETQlgtqaEQQoi8JLETooRyr4YlqbAMUjthfvKesAy5f395T1RsVpvYpaenk5aWpr9/5coVli5dyrZt28wYlRDClCSREEKIvKw2sevfvz/r1q0DICEhgXbt2vHBBx/Qv39/Pv74YzNHJ2yZ1E5YFqmdMD85B5ZBauwEWHFid/ToUTp37gzAhg0bCAwM5MqVK6xbt47ly5ebOTohhClIci2EEHlZbWKXlpaGp6cnANu2bWPQoEHY2dnRvn17rly5YubohC2TGjvLIrUT5qco8n6wBFJjJ8CKE7uwsDA2bdpEVFQUW7dupVevXgDExsbi5eVl5uiEEKYgyYQQQuRltYndjBkzmDx5MjVq1KBdu3Z06NABUGvvWrRoYebohC2TGjvLIrUT5ic1dpZBauwEWPGSYk888QQPPPAA0dHRNGvWTL+9R48eDBw40IyRCSGEEEKYh9UmdgBVqlShSpUqeba1bdvWTNGIikJq7CyHRiO1E5ZAauwsg9TYCbCyxG7QoEEGP/fHH38sx0iEEEIIISyPVfWx8/b21t+8vLzYsWMHhw8f1j9+5MgRduzYgbe3txmjFBWF1FCYn9TYWQapsbMMUmMnwMpq7NasWaP//c0332TIkCGsWrUKe3t7ALRaLWPGjJFRsaJcyYemEEIIS2VVNXb3Wr16NZMnT9YndQD29vZMmjSJ1atXmzEyUVFIDYX5SY2dZZAaO8sgNXYCrDixy8nJ4ezZs/m2nz17Fp1OZ4aIREUhH5pCCCEslVU1xd5r5MiRjBo1iosXL9K+fXsADh48yLvvvsvIkSPNHJ2oCKSGwvykxs4ySI2dZZAaOwFWnNi9//77VKlShSVLlhAdHQ1AUFAQb7zxBq+99pqZoxO2TD40hRBCWCqrTOxycnL46quvePbZZ3njjTdISkoCkEETQlQwUmNnGeQcWBY5HxWbVfaxc3Bw4OWXXyYzMxNQEzpJ6oSpyATFQuQn7wfzk3MgwEoTO4B27dpx7Ngxc4chhDAjqbGzDHIOLIucj4rNKptiAcaMGcNrr73G1atXadWqFe7u7nkeb9q0qZkiE7ZOauyEyE/eD+Yn50CAFSd2Q4cOBWDcuHH6bRqNBkVR0Gg0aLVac4UmhDARqbGzDHIOLIucj4rNahO7iIgIc4cgKiipsRMiP3k/mJ+cAwFWnNiFhoaaOwQhhJlJjZ1lkHNgWeR8VGxWm9jlOnPmDJGRkWRlZeXZ3q9fvyL3u3z5Mnv37uXy5cukpaXh7+9PixYt6NChAy4uLuUZsrByUmMnRH7yfjA/OQcCrDix+/fffxk4cCAnT57U960DtZ8dUGgfu6+//prly5fz999/ExAQQNWqVXF1dSUuLo5Lly7h4uLCU089xZtvvim1gkJYOKmxswxyDiyLnI+KzWqnOxk/fjw1a9bkxo0buLm5cfr0af744w9at27N7t27C9ynZcuWLF68mKeffprLly8TExPDkSNH+PPPPzlz5gxJSUn89NNP6HQ6Wrduzffff2/agxJWQWrshMhP3g/mJ+dAgBXX2B04cICdO3fi7++PnZ0ddnZ2PPDAAyxYsIBx48YVOMfdO++8wyOPPFJomc7OznTt2pWuXbsyd+5cGaAhhIWTGjvLIOfAssj5qNistsZOq9Xi4eEBQOXKlbl+/TqgDqo4f/58gfsUldTdr3LlyrRp06bsgQqbJVfHQtwl7wfzk3MgwIoTu8aNGxMeHg6oq1AsXLiQffv2MWfOHGrVqlWish555BGio6PLI0xhg+Rq2HJIjZ1lkHNgWeR8VGxW2xT79ttvk5qaCsDcuXN59NFH6dy5M5UqVWL9+vUlKuuPP/4gPT29PMIUNkyujoW4S94P5ifnQIAVJ3a9e/fW/16rVi3OnDlDXFwcvr6++pGxQpQHuRq2HPJWF0KIvKy2KXb79u2kpaXl2ebn51eqpC40NBRHR0djhSYqCEkqLIMk2uanKPJ+sAS550DeExWb1SZ2jz/+OL6+vnTs2JGpU6eydetWUlJSitwnMjKywO2nTp0iJCQk3/Zr164ZJVZhW+RD03JIMiGEEHlZbWIXHx/P7t276devH8eOHWPw4MH4+fnRvn17pkyZUuA+bdq04YUXXuDvv/8utNzExEQ+++wzGjduzI8//lhe4QsbIEmFZZBE2/ykxs4ySI2dACvuY2dvb0+HDh3o0KEDU6ZM4dSpU7z//vt89dVXHDp0iHfffTffPmfPnmX+/Pn06dMHR0dHWrduTXBwMC4uLsTHx3PmzBlOnz5N69atWbRoEX379jXDkQlLJx+alkOSCSGEyMtqE7uzZ8+yZ88edu/ezZ49e9BqtTzwwAN88MEHdOnSpcB9/Pz8eP/995k7dy6bN2/WrxWbnp5O5cqVeeqpp+jduzeNGzc28dEIIUpLEm3zk3NgWeR8VGxWm9g1atQIf39/JkyYwPTp02nUqJHB+7q4uDBo0CAGDRpUjhEKWyVLilkOOQeWQ86F+ck5EGDFfezGjRtH1apVmTVrFqNGjeLNN9/kt99+K3YAhRDCtkjthPnJObAscj4qNqtN7JYuXcrRo0e5ceMGb7/9NlqtlhkzZlC5cmXat29v7vCEDZMaO8sh58ByyLkwPzkHAqw4scul0+nIyckhKyuLzMxMsrOzuXz5srnDEkKYiNROmJ+cA8si56Nis9rEbvz48TRr1oyAgABefPFFrl+/zujRozlx4gQxMTHmDk/YMKmxsxxyDiyHnAvzk3MgwIoHT1y7do0XXniBrl27yihWISowqZ0wPzkHlkXOR8VmtYndhg0bzB2CqKCkxk6I/OT9YH5yDgRYcVMswH/+8x86depEcHAwV65cAdRBFT/99JOZIxNCmIJGI7UTlkDOgWWR81GxWW1i9/HHHzNp0iQefvhhEhIS0Gq1APj4+LB06VLzBidsmtTYCZGfvB/MT86BACtO7D788EM+++wzpk2bhr29vX5769atOXnypBkjE0KYitTYWQY5B5ZFzkfFZrWJXUREBC1atMi33dnZmdTUVDNEJCoauToW4i55P5ifnAMBVpzY1axZk+PHj+fb/ttvv9GgQQPTByQqDLkathxSY2cZ5BxYFjkfFZvVjop9/fXXeeWVV8jIyEBRFP7++2+++eYb5s+fzxdffGHu8EQFIFfHQtwl7wfzk3MgwIoTu5EjR5KTk8Mbb7xBWloaTz75JFWrVuXDDz+kc+fO5g5P2DC5GrYcUmNnGeQcWBY5HxWb1TbFArzwwgtcuXKF2NhYYmJi+Pvvvzl27BhhYWHmDk1UAHJ1LMRd8n4wPzkHAqwwsUtISOCpp57C39+f4OBgli9fjp+fHx999BFhYWEcPHiQ1atXmztMYcPkathySI2dZZBzYFnkfFRsVtcU+9Zbb/HHH38wfPhwtmzZwsSJE9myZQsZGRls3ryZLl26mDtEIYQQwuSkxk6AFSZ2v/76K2vWrOGhhx5izJgxhIWFUbduXZmUWJiMTFBsOaTGzjIoirwfLIm8Jyo2q2uKvX79Og0bNgSgVq1auLi48Pzzz5s5KiGEEEII87O6xE6n0+Ho6Ki/b29vj7u7uxkjEhWN1NhZDqmxswxSY2cZcs+BvCcqNqtrilUUhREjRuDs7AxARkYGL730Ur7k7scffzRHeEIIIYQQZmN1id3w4cPz3H/66afNFImoqKTGznJIjZ1lkBo7yyA1dgKsMLFbs2aNuUMQQgghhLBIVtfHzhKtXLmSmjVr4uLiQqtWrdi7d6+5QxLlSGrsLIfU2FkGqbGzDFJjJ0ASuzJbv349EyZMYNq0aRw7dozOnTvTt29fIiMjzR2aEEIIISoYq2uKtTSLFy/mueee00+5snTpUrZu3crHH3/MggULTBpLRgbcumXSl6yQbtxQf0oNhflpNJCWBlevmjuSii0pSd4PliD3HNy+XfR7wscHPDxMEpIwA0nsyiArK4sjR44wZcqUPNt79erF/v37C9wnMzOTzMxM/f2kpCSjxbNnD/TpY7TiRDFcXc0dgXB1hY0bISTE3JGIOnXMHYGwtwdHR5g4Ub0VZvlyGDvWdHEJ05LErgxu3bqFVqslMDAwz/bAwEBiYmIK3GfBggXMnj27XOJp1Qp++61cihb38fSE+vXNHYX46CMYPdrcUQiA2rXNHYFwcIBDhyA6uujnNWhgmniEeUhiZwSa+9ogFEXJty3X1KlTmTRpkv5+UlISIUaqbqhcWWrsRMUSFKTehBCqZs3Um6i4JLErg8qVK2Nvb5+vdi42NjZfLV4uZ2dn/eTKoCaBYNwmWSGEEKK85X5vKTIM16JIYlcGTk5OtGrViu3btzNw4ED99u3bt9O/f3+DykhOTgYwWq2dEEIIYUrJycl4e3ubOwxxhyR2ZTRp0iSeeeYZWrduTYcOHfj000+JjIzkpZdeMmj/4OBgoqKi8PT0LLT51hLlNiFHRUXh5eVl7nBKRY7BMsgxWA5bOA45BtNRFIXk5GSCg4PNHYq4hyR2ZTR06FBu377NnDlziI6OpnHjxmzevJnQ0FCD9rezs6NatWrlHGX58fLysugPHkPIMVgGOQbLYQvHIcdgGlJTZ3kksTOCMWPGMGbMGHOHIYQQQogKTlaeEEIIIYSwEZLYiVJxdnZm5syZeUb4Whs5Bssgx2A5bOE45BhERadRZJyyEEIIIYRNkBo7IYQQQggbIYmdEEIIIYSNkMROCCGEEMJGSGInhBBCCGEjJLETQgghhLARktgJIYQQQtgISeyEEEIIIWyEJHZCCCGEEDZCEjshhBBCCBshiZ0QQgghhI2QxE4IIYQQwkZIYieEEEIIYSMksRNCCCGEsBGS2AkhhBBC2AgHcwdQ0eXk5HDs2DECAwOxs5M8WwghhHXQ6XTcuHGDFi1a4OAg6YSlsKozsXfvXj755BMuXbrEhg0bqFq1Kv/5z3+oWbMmDzzwgLnDK5Vjx47Rtm1bc4chhBBClMrff/9NmzZtzB2GuMNqErsffviBZ555hqeeeopjx46RmZkJQHJyMvPnz2fz5s1mjrB0AgMDAfWNERQUZOZohBBCCMNER0fTtm1b/feYsAxWk9jNnTuXVatW8eyzz/Ltt9/qt3fs2JE5c+aYMbKyyW1+DQoKolq1amaORtgERQHtLbCvDBqNuaOxGdk5CmkZOtIzFZwcNLi5anB21KCRv7Go4KQbkWWxmsTu/PnzPPjgg/m2e3l5kZCQYPqAhLBEShZcGwwpP4NzSwj5DRwCzB1VkTKydCSm6KjkbY+DvXmSJK1OITImm3OXs7h0NYtbiVpuJ2qJT9aRmq4jLUNHdk7+/bw97KhV1ZFW9V14sIUb1QIcTR+8EELcw2oSu6CgIC5evEiNGjXybP/zzz+pVauWeYISwtLELYWUXyHgA7j9HkQPh2qbLarmLjYuh2P/ZHDyUianL2VyJUbNmNxdNAzq5slTfbxxcizfeG8m5HA2IotzV7I4F5HJ+cgs0jMVNBoICXDA39eBqv6ONKlth7urHa7Odri7anB1tsPVWUOOFlLTdVy7mcOFqCz++1sSn/+USLtGLgzt6UXzui7lGr8QQhTGahK7F198kfHjx7N69Wo0Gg3Xr1/nwIEDTJ48mRkzZpg7PCHMT5sMt+eB7xjwmwSOteHaAEjbDu69TBpKRpaO2HgtsXE5xMZpiY3P4UacllOXMrl2MweNBmoGOdI0zIUhPZ3w9bTnxD8ZfLs9iQOn0pn5XGWqGqn2Ky1Dx/krWZy9nMm5y1mcvZzF7UQtAJV97GlQw4mn+3rToIYTdas74eZS8malzCwdu4+m8f3vyUxaGkvrBi6MHuBDWIiTUY5BCCEMpVEURTF3EIaaNm0aS5YsISMjAwBnZ2cmT57MO++8Y+bISu/q1auEhIQQFRUlfexE2cR9CLEToXYEOIaofe2udAA7N6i+02gvo9UpxCVpiY3TcvNOwhYbryZwN+JzuBmvJTFFl2efSt72+PvaU6+6Ey3qudCsjjPeHvb5yr4YlcXsz2+RkKJlyvBKdGrqVrLYtAr/Xs/m3OVMzl7O4tzlLK7EZKMo4OqsoV6oEw1qOFO/hhP1azjh72Pca1tFUdh7PJ3Pf0rg2s0cerd3Z/QAH3w88x+rENZOvr8sk1Ukdlqtlj///JMmTZrg4uLCmTNn0Ol0NGzYEA8PD3OHVybyxhBGoSgQ0QicG0PV7+5uT/wvRD8Dtc6DU12Di9PpFCJv5HA2IpPrN3O4EX+35u1mvBbtPXmbq7OGQD8HAvzsCfB1IMDXngA/BwJ97fH3c6Cyt32JmlZT0nW8t+42+06k81RvL0Y85o29Xf790zJ0RN/K4XJ0NueuZHH+ShYXIrPIzFaws4NawY55krjqVRwLLKc85GgVfv0zhdW/JALwwgAfHu7ojp2JXl8IU5DvL8tkFYkdgIuLC2fPnqVmzZrmDsWo5I0hjCLjJFxuCtV+BY+H727XZcDFYNJdX+Cm41w83Ozw8bDLl2BkZOk4fzmLU/9mcupSJmciskhO02GnUZsrA/0c8Pe11ydwgb5377u7Gn9kqKIofLs9mS9+SiDQz5461Z3IyFJITdeRmq4Qn5y3VjCosgP1Q53u1Mg5Uae6Ey5O5h+pF5+s5dONCWw9mEqDGk5MGOZHHWmeFTZCvr8sk9X0sWvSpAn//vuvzSV2QhhF8ndg5wPuD+k3KYrC//Zl45nYi7DK3zFi3RhAg6MDBPo56JOyG3FaLkZlodWBm4uGhjWdeby7J41qOdOgRun6nJWVRqNhWC8vWtV34X9/phB9KwcXZw3VAhxxd9Hg7WlPUCUHgio7UC3AocBmXUvg62nPm89Wom9Hd5Z9G8/L78bwZB8vhj/sjb2ZRgALIYxjx44d7Nixg9jYWHS6vN1PVq9ebaaorCixmzdvnr4/XatWrXB3d8/zuJeXl5kiE8LMFEVN7DwHgsbpziaF5d/F89OeFEb3GkBXn/WsmhjLzbRG3IjTciMuh5jbOaSmK4RWcaRPB3ca13KmRrDpmisNUbe6E5Oe9DN3GGXWNMyFT6ZW4ZttSXz5ayIn/slk2shKBPhZzUewEOIes2fPZs6cObRu3ZqgoCCLms/Sappi750A8d4/oKIoaDQatFqtOcIqM6nKFmWWeQ4iGkC1/4HHIwB8vyOJj39IYNKTfjzayQkuBIDvOPC33sm8bcXJixnMW3Ob9EyFiU/60bVlyQaICGEpKvL3V1BQEAsXLuSZZ54xdyj5WM3l4q5du8wdghCWKXWrWlPn1g2Af69l8dmmBAb38OTRB+4MLnLvC6m/SWJnAZqEufDpW1VY/HUccz6/xf42bowd6oenm/n7BAohDJOVlUXHjh3NHUaBTJbYRUZGEhISkq+6UlEUoqKiqF69epH7d+nSpTzDE8J6pW4F185g54ZWq7Dov3FUDXDkuX4+d5/j0QeiR0LOTXDwN1uoQuXlbs/M5yvz+99pLP8ujr/PXOf/enrRu4M7vuUwNUp6po5/IrNwctRQN8RJ+vcJUUbPP/88X3/9NdOnTzd3KPmYLLGrWbMm0dHRBATkXd4oLi6OmjVrFtuU+scffxT5eEHLjQlh83SZkLYbKs8G4IddyfwTmcWHkwPzTjHi3gtQIHU7eD9pllBFXhqNhp7t3GlRz5n//JbEFz8n8PlPCVSv4khIoAMerna4utjh5qKueOHmoiEk0JGwao54uRuW/KWk6/hpTzIbdibrRxFX9Xdg8lN+NJPVMYQotYyMDD799FN+//13mjZtiqNj3gnVFy9ebKbITJjY5faFu19KSgouLsV/wHTt2jXftnvLM0cfu1mzZjF79uw82wIDA4mJiTF5LKKCSv8TlHRw70XM7RzW/JLIwK6eNKzpnPd5DkHg3BxSt0hiZ2Eq+zgwcZgfox7zZn94OuevZHH9Vg63E7NJzVBIz9CRnqmQmqEjd+BdlUr21At1pl6oE/VD86+YkZCs5YddyWzak0xWtkLfDh481tmDtAwdX/ycyOTlsbz+TCV6tXMvJCohRFHCw8Np3rw5AKdOncrzmLkHUpR7Yjdp0iRAPdDp06fj5na3o7BWq+Wvv/7S/3GKEh8fn+d+dnY2x44dY/r06cybN8+oMZdEo0aN+P333/X37e0tc9oFYaNSt4N9IIpTY5Z9cRsvdzuee8y74Oe694bEtaDoQCP9uSyNt4c9fTt60LeQbjtancLVGzlcvJrFP5HqOrfrNieScc8at/VCncjMVjhwMh17ew2PPeDBkIe8qOR993Ppg/HOfPB1HAvX3cbeDnq0keROiJKy5H7/5Z7YHTt2DFBr7E6ePImT093JOZ2cnGjWrBmTJ08uthxv7/xfVj179sTZ2ZmJEydy5MgR4wVdAg4ODlSpUsUsry0E6XvBrQt7jmfy1+kM3nmxMq6FzTvn3hvi3oPMk+DSzLRxijKzt9MQGuRIaJCjPhnT6hQiY9SVN/65ksX5yCwc7DWMfNSHvh3dC5zfz95ew+Sn/FAUWPClmtx1bSXJnTCNP/74g0WLFnHkyBGio6PZuHEjAwYM0D+uKAqzZ8/m008/JT4+nnbt2vHRRx/RqFEj/XMyMzOZPHky33zzDenp6fTo0YOVK1eabWTu1atX0Wg0VK1a1Syvf79yT+xys9qRI0eybNkyo8835+/vz/nz541aZklcuHCB4OBgnJ2dadeuHfPnz6dWrVqFPj8zM5PMzEz9/eTkZFOEKWyRLgMyDpPiMZhl38bRqZkrnZoVMXWGawfQOKt98iSxswn2dhpqBjtRM9iJvh0M38/OTsPkp/3Q6hTmrrmNRqOhi0y7IkwgNTWVZs2aMXLkSB5//PF8jy9cuJDFixezdu1a6taty9y5c+nZsyfnz5/H09MTgAkTJvDLL7/w7bffUqlSJV577TUeffRRjhw5YrJWM51Ox9y5c/nggw9ISUkBwNPTk9dee41p06blmaLN5BQrceLEiTy348ePK7/99pvSpUsXpWPHjmaJafPmzcqGDRuU8PBwZfv27UqXLl2UwMBA5datW4XuM3PmTAXId4uKijJh5MImpO5VlLMoCz/brjwx5aoSn5RT/D5XuipK1IDyj01YhRytTnnni5tKj1euKOs2JyhpGVpzhySsSFRUVJm+vwBl48aN+vs6nU6pUqWK8u677+q3ZWRkKN7e3sqqVasURVGUhIQExdHRUfn222/1z7l27ZpiZ2enbNmypXQHUgpTpkxR/P39lZUrV+pzko8++kjx9/dX3nrrLZPFURCTTVCcmprKu+++W+jyG//++2+R+9vZ2aHRaLg/3Pbt27N69Wrq169v9JhLKjU1ldq1a/PGG2/o+xbe7/4au2vXrtGwYcMKOcGjKJvsmAVob83jiS9OsuCVIJqEGTDK8dYciFsKdW5JPzsBgFarsPZ/iXyzLQmNBgL8HAj0tSfgzrrAAb4OBNy5H+hrX3hTvxXJzNJxK1HLrQQtqek63F3sqFJZPU5zd3y3JrkTFJ85cyZPM6SzszPOzs5F7KnSaDR5mmL//fdfateuzdGjR2nRooX+ef3798fHx4cvv/ySnTt30qNHD+Li4vD19dU/p1mzZgwYMCDfgMbyEhwczKpVq+jXr1+e7T/99BNjxozh2rVrJomjICYbFfv888+zZ88ennnmmVItvxEREZHnvp2dHf7+/gaNqDUVd3d3mjRpwoULFwp9zv3/8ElJSaYITdiY1HQdEed3kpXd0vCkDsCtK9yaCZnh4NK8PEMUVsLeXsNz/X14uJMHf59JJ+ZWDrEJWq7dzObY+QxuJ2rR3XM97elmR4CfPf4+9gT6OagJoO+d333tqeRtb7Z58rQ6hfgkNWG7fSdxy03gbt/zMzlNV+D+/j729GznzuPdPctlPkFb1bBhwzz3Z86cyaxZs0pcTu6MEoGBgXm2BwYGcuXKFf1znJyc8iR1uc8x5YwUcXFxBVYo1a9fn7i4OJPFURCTJXa//fYbv/76K506dSrV/nv27GHo0KH5rgKysrL49ttvefbZZ40RZplkZmZy9uxZOnfubO5QhA2LT9Yy7aMbvNfnEBnuY/E3NKkDcGkLGpc7/eyal1eIwgoFVXag/4Oe+bZrtQq3ErXExuUQG6+uMxwbpyU2PoeTlzKJPZRKSvrdzM/ODhrXcmbIQ550aOJqtBowRVGIjdcScytHjSE+fwIXn5Q3CbW3g0re9lT2URPOFvWc79x3oPKd7R6udqRm6Ii8kc3hMxn8tCeZ//2ZwpKJAdQMdio8IKFXUI1dWRS0kEFx/0eGPMeYmjVrxooVK1i+fHme7StWrKBZM/P2YTZZYufr64ufX+kX8x45ciR9+vTJN8FxcnIyI0eONEtiN3nyZB577DGqV69ObGwsc+fOJSkpieHDh5s8FlExXIvN5s2PblLZ9SyeLol4BnctWQF2LuogirTd4DehHCIUtsbeXkOgnwOBfoV/XaSm64iNz9EnXjsPp/H2qlu0buDCK0/4EhrkWOi+hcnKVjgbkcmpfzM5E5HF2YhMElLu1rR5udtR2ceeyt721K7mSLvGLvqkLTeZ8/Gww86u+C97P297QgId6dTUjeGPeDNpaSwL18Wx8s1AaZo1gKenp1EGRubOMBETE0NQUJB+e2xsrL4Wr0qVKmRlZREfH5+n1i42NtakS3wtXLiQRx55hN9//50OHTqg0WjYv38/UVFRbN682WRxFMRkid0777zDjBkz+PLLL/PMZWeowrLxq1evFjgViilcvXqVYcOGcevWLfz9/Wnfvj0HDx4kNDTULPEI23buciZvrbyJh5sds57+B1LswbVdyQty66r2s1MUkC8tYQTurnbUdHWiZrB6v9+DHhw4mc5HGxJ4bl40/Tp7MPwR7wKnXwG1CfXazRz+vZbNpagsTl7K5OzlTLJzwN1FQ/0azjza2YP6oU5U9XckwM8eV+fy6evn42nP2CG+vLYslgMn0+nYVEYLm0rNmjWpUqUK27dv1/exy8rKYs+ePbz33nsAtGrVCkdHR7Zv386QIUMAiI6O5tSpUyxcuNBksXbp0oV//vmHjz76iHPnzqEoCoMGDWLMmDEEBwebLI6CmCyx++CDD7h06RKBgYHUqFEj3/IbR48eLXC/Fi1aoNFo0Gg09OjRAweHuyFrtVoiIiLo06dPucZemG+//dYsrysqnn0n0pi35ja1qjoy72V/vJMOqE2pdh4lL8ylHejiIfsSOIUZPVYhNBoNHZu60bqBKz/uTua/vyXy2/5UWjVwwd/XHq1WrZFTm1FziLmtJTNbbUP187KjYU1nRg/woVkdF2pWdcTegFo3Y2pRz4X6NZz4ZW+KJHZGlpKSwsWLF/X3IyIiOH78OH5+flSvXp0JEyYwf/586tSpQ506dZg/fz5ubm48+aS6Yo63tzfPPfccr732GpUqVcLPz4/JkyfTpEkTHnrooWJfPycnh3nz5jFq1ChCQkLKdCzBwcFmXSChMCZL7O6dgLA0+x0/fpzevXvj4XH3i8zJyYkaNWoUOBeOELZAq1NHLH61JYkHW7gyZXglXJzs4MY+8HisdIW6tlZ/ZhySxE6UKydHDf/X04ve7d3ZeiCVw2fTOXkhBwcHDU6OGvy87AgNcqVKJXtqBTtRq6ojPhYyaOHhjh4s/SaOmwk5+PuY7KvS5h0+fJhu3brp7+fOIDF8+HDWrl3LG2+8QXp6OmPGjNFPULxt2zb9HHYAS5YswcHBgSFDhugnKF67dq1Bc9g5ODiwaNGiUnWZCg8Pp3HjxtjZ2REeHl7kc5s2bVri8o3FZNOdlNWXX37J0KFDjTYKNjs7m5iYGNLS0vD39y9T/7+yyB0uLtOdiPslp+mYt/oWh89mMKqfN8N6eandEbKvw6WqEPwdeA0uXeGXaoNHfwg030LVQliylHQdg964ykuDfBnULf+gEmG9318DBgxgwIABjBgxokT72dnZERMTQ0BAQKFTsIFaY22O9etzmfQyJCEhgQ0bNnDp0iVef/11/Pz8OHr0KIGBgcUuxWGMAQkpKSl89dVXfPPNN/z999955pOrVq0avXr1YvTo0bRp06bMryVEWVy6msWMT2+Rmq5jwSv+tGnoevfB9H3qT9fSjTAHwKW1WmMnhCiQh6sdLeq5sC88TRI7G9O3b1+mTp3KqVOnaNWqFe7ueZfUu39uulwRERH4+/vrf7dUJkvswsPDeeihh/D29uby5cu88MIL+Pn5sXHjRq5cucK6deuK3F+r1bJkyRK+++47IiMjycrKyvN4cfPGLFmyhHnz5lGjRg369evHlClTqFq1Kq6ursTFxXHq1Cn27t1Lz549ad++PR9++CF16tQp83ELURKKorDlQCoffhdPtQAH3h9XhaDK971N0/eBYy1wLEMHXZc26nx2Sg5opJlJiII80MyVZevjSUzRFjrwQ1ifl19+GYDFi/O3WBRV23bvwMgrV67QsWPHPP3+Qe3Dt3//foMHUZZH66HJphCfNGkSI0aM4MKFC3maU/v27csff/xR7P6zZ89m8eLFDBkyhMTERCZNmsSgQYOws7MzaCLE/fv3s2vXLg4fPsyMGTPo06cPTZo0ISwsjLZt2zJq1CjWrFnDjRs36NevH3v27CnL4QpRYilpOuauvs2i/8bRvbUbyycH5k/qANL/LFttHYBrG1DSIOtc2coRwoZ1auqGTgd/nc4wdyjCiHQ6XaE3Q5tQu3XrVmCFUmJiYp4+hAVJSUnhk08+oWvXrnh7e1OjRg0aNmyIv78/oaGhvPDCCxw6VPoWFZNdqh86dIhPPvkk3/aqVasaNFv0V199xWeffcYjjzzC7NmzGTZsGLVr16Zp06YcPHiQcePGFbn/999/b1Cczs7OjBkzxqDnCmEMiqKw41Aaq36MJzNbYcZzlejayr3gJ+tSIOM4+Iwu24s6twQ0kH4InBuXrSwhbJSftz1hIY4cPpNOr3aFvCdFhVTYFGy3b9/O17R7L1O0HpossXNxcSlw+azz58/r26yLEhMTQ5MmTQDw8PAgMTERgEcffZTp06cbN1ghTCApVcu+8HR+2JnMv9ey6dLSjTGP++DvW8TbMv0vQFv2Gjt7T3CqBxlHgJFlK0sIG9amgSu/7U9Bp1MMmuxYWIfU1FT27NlTYNeuoiqKBg0aBKhNtiNGjMizyoZWqyU8PLzIiZJzWw9z85n75bYgrlq1ii+++II9e/ZYbmLXv39/5syZw3fffQeof5TIyEimTJli0HQl1apVIzo6murVqxMWFsa2bdto2bIlhw4dMnj5kp07d/Lqq69y8ODBfLNkJyYm0rFjR1atWiVLggmj0+oUom7kcDEqi4tXszh/RZ2EVaeDtg1dGDvYl2Z1DRjxnb4f7HzAqUHZg3JpCZkFzx8phFC1aejCN9uSuHg1m7rVZYkxW3Ds2DEefvhh0tLSSE1Nxc/Pj1u3buHm5kZAQECRiV3uggiKouDp6Ymr692BbU5OTrRv354XXnih0P2///77fIlkQcrSemiyxO7999/n4YcfJiAggPT0dLp06UJMTAwdOnQwaIK/gQMHsmPHDtq1a8f48eMZNmwYX3zxBZGRkUycONGgGJYuXcoLL7xQ4NIn3t7evPjiiyxevFgSO1Ei8claLl3NIjFFR0qajvRMhfRM9Wdquo7L0dn8ey1bPwFrlUr2hFVzYuwQXzo1daVySebISv8bXNuCxgjdY11aQfJGGUAhRBEa1XLG1VnD4TPpktjZiIkTJ/LYY4/x8ccf4+Pjw8GDB3F0dOTpp59m/PjxRe67Zs0aAGrUqMHkyZOLbHYtTPXq1Rk7diwvv/xyuUy1ZvJ57Hbu3MnRo0fR6XS0bNnSoJmiC/LXX3+xb98+wsLCCh2afL/Q0FC2bNlCgwYF13acO3eOXr16ERkZWaqYSsNa5wGq6HQ6hd//TmXj7hTOR969+rK3AzcXO1ydNbg6a3BxtiMk0IE6IU6EVXMiLMQJT7dSJmWKAheDwOd58J9b9oNI2wORXaHmSelnJ0QR3l51k5Q0HUsnBZo7FItird9fPj4+/PXXX9SrVw8fHx8OHDhAgwYN+Ouvvxg+fDjnzpXvoLIlS5bw4YcfEhsby/Dhw5k4cSJhYcabLN7kl+ndu3ene/fuJdonOzub0aNHM336dGrVqgVAu3btaNeuZOtk3rhxI99SZvdycHDg5s2bJSpTVDyXrmbxwddxnLucRdtGLkwbWYn6NZzw87LHxUlTfouG50SB9ga4tDVOec7qWoxkHJXETogitGngworv40lN1+HuarLJJEQ5cXR01H9OBwYGEhkZSYMGDfD29i5Rxc6GDRsKnYKtsGVSQa0xHD9+PD/88ANLliyhfv36PPbYY0yePJlOncrYf5pyTuyWL1/O6NGjcXFxYfny5UU+t6g2bUdHRzZu3FjmQRJVq1bl5MmThWbG4eHhBAUFlek1hG3bvC+FZevjqBbgyLJJATQJM85KKAZJvzP83dVIE2jbe4FjHXUAhfezxilTCBvUuqELWh0c/yeDTs1k7Vhr16JFCw4fPkzdunXp1q0bM2bM4NatW/znP/8pdFDD/ZYvX860adMYPnw4P/30EyNHjuTSpUscOnSIV155pdj97ezsGDx4MIMHD+bgwYN88MEHdO3alZYtWzJ58mQef/xx7OxKdxFRrk2xNWvW5PDhw1SqVImaNWsWHoRGw7///ltkWSNHjqRJkyb6deVKY+zYsezevZtDhw7lW5osPT2dtm3b0q1bt2KTUGOy1qrsiiZHq7Ds2zh+3ZfKI53cGTvEDydHE4+QuzkNEtdC2DXjlXltmFoTGPqn8coUwgY9PfM6reu7MGGYeZaftETW+v11+PBhkpOT6datGzdv3mT48OH8+eefhIWFsWbNGpo1a1ZsGfXr12fmzJkMGzYMT09PTpw4Qa1atZgxYwZxcXGsWLGixHFduXKFZcuWsXr1avz8/IrNiwpTrjV29y65UdblN8LCwnjnnXfYv39/gUuAFDePHcDbb7/Njz/+SN26dXn11VepV68eGo2Gs2fP8tFHH6HVapk2bVqZ4hS2JzVdx+zPb3HsfAavP+1H344e5gkk8xw4NTRumS6t4NbPoGhBIzPrC1GYNg1dOHgyvdD5y4T1aN26tf53f39/Nm/eXOIyIiMj9dOauLq6kpycDMAzzzxD+/bti0zspk2bRmJiYoG3hIQEUlJS9OWVhlmGwuVWEpbkzfH555/j4+PDkSNHOHLkSJ7HNBqNQYldYGAg+/fv5+WXX2bq1Kl54ujduzcrV64kMFA6x4q7bibk8NbKm8TcyuG9VwNoWd+ETa/3yzoHbkXPaF5iLq3urEDxDzgbYQoVIWxUxyau/LQnhX+vZVO7moyOreiqVKnC7du3CQ0NJTQ0lIMHD9KsWTMiIiIoriF0wYIFuLi4MGLECNq2bYu3tzdeXl54eXnpf8+dVqU0TJrYffHFFyxZsoQLFy4AUKdOHSZMmMDzzz9f7L7GWnA3NDSUzZs3Ex8fz8WLF1EUhTp16uDr62uU8oXt+PdaFlM/uolGA8snB1Iz2Iwf5koOZF8E55eNW65L7gCKI5LYCVGE5nVdcHfR8OeJdEnsrFCLFi0MrkwqauBDru7du/PLL7/QsmVLnnvuOSZOnMiGDRs4fPiwfhLjwvz+++8sXryY1atX83//939MnjyZxo2NN4DNZInd9OnTWbJkCWPHjqVDhw4AHDhwgIkTJ3L58mXmzjVs+oasrCwiIiKoXbt2vsV3S8LX15c2bYzUCV3YnKPnMpj56U2CKjswf4x/yeaaKw/Zl0HJAqf6xi3X3gcca98ZQPG0ccsWwoY4Omho19iVfSfSGP5I6WtThHkMGDDAqOV9+umn6HQ6AF566SX8/Pz4888/eeyxx3jppZeK3Dd3dpDz58+zePFi2rVrR+fOnXn99dfp0aNH2YNTTKRSpUrK119/nW/7119/rVSqVKnY/VNTU5VRo0Yp9vb2ir29vXLp0iVFURRl7NixyoIFC4wer6lERUUpgBIVFWXuUMQdWw4kKw+9ckV548MbSmq61tzhqJJ/UZSzKEpWOfyfXB2iKJc7G79cIWzMriOpSreXryjXbmabOxSLIN9fxhEbG6vMnDlTCQwMVJo3b67897//VXJyckpdnskm5NFqtXk6LOZq1aoVOTk5xe4/depUTpw4we7du/OMaH3ooYdYv369UWMVFZOiKKzbnMh76+Lo3cGdeS/74+ZiIXNWZZ4DjTs4VDV+2S4tIfMYKDrjly2EDWnXSG2O/W1firlDEUZw5MgR/vvf//LVV19x7NixYp8fHh6ur6ULDw8v8lYS/v7+zJo1i7NnzzJo0CDGjRunn7O3NEzWvvT000/z8ccfs3jx4jzbP/30U5566qli99+0aRPr16+nffv2edrJGzZsyKVLl4rdPycnh3Xr1qEoCs8++2yRExWLiidHq7D46zi2HEhl1GPePNXHy7JGvmWdA6d6UB4xubQCXQpkXQDnesYvXwgb4epsR8927mzen8Kzj3jj6GBBnxHCYLGxsfzf//0fu3fvxsfHB0VRSExMpFu3bnz77bf4+/sXuF/z5s2JiYkhICCA5s2bo9FoChwoodFo0Gq1hb7+gAED9KNgk5KS9D9zcnL05SUkJJT6+Mo1sbt3zjmNRsPnn3/Otm3baN++PQAHDx4kKiqKZ58tfnLUmzdvEhAQkG97amqqQV/Ab731Fp06dSInJ4cpU6bwwQcflOBIhC1LTdcx67NbnLiQwdThlejZruRr/5W7rPPgbOT+dblcWqo/M45IYidEMfo96MmmPSnsOpxKr/ZmmvpIlMnYsWNJSkri9OnT+iVGz5w5w/Dhwxk3bhzffPNNgftFRETok76yDOj08fGhRo0a+Pj44O3tnefnvb+XVrkmdvdXbbZq1QpAX8Pm7++Pv78/p0+fLrasNm3a8OuvvzJ27Fjg7lQpn332mX4wRlF0Oh1paWnY2dnpq1KFiEvS8uaKWGJuq9OZtKhnxulMipJ1Dtx7lU/Z9n7gWBMyjwJPls9rCGEjagQ50qGJK99sS+Khtu7Y2UmtnbXZsmULv//+e5514xs2bMhHH31Er16Ff86GhoYW+HtJrV27ttT7GqJcE7tdu3YZrawFCxbQp08fzpw5Q05ODsuWLeP06dMcOHCAPXv2GLT/+vXrycnJ4b333jNaXMJ63UrIYfKyWFIzFJa/ZubpTIqScwu0t4w/IvZeLi3VGjshRLGG9fJi3Ac3OHAyXZYYs0I6na7A7liOjo5FVvz8/PPPBr9Gv379CtweGRlJ9erVDS7n2rVrVK1asr7VZp7DwXAdO3Zk3759vP/++9SuXZtt27bRsmVLDhw4YNDabo6Ojjz9tEznIFSxcTm8tiyW7ByFpRMDqBpgwX0us86rP53KsZnUpRXcflcdQKGxkAEjQlioxrWdaRrmzNdbk+jY1NWy+uOKYnXv3p3x48fzzTffEBwcDKgJ1MSJE4ucbuT+KVPu72N37/9BYX3s2rRpQ79+/XjhhRdo27Ztgc9JTEzku+++Y9myZbz44ov6lkpDmSyxy8jI4MMPP2TXrl3Exsbmy4oNmRCwSZMmfPnll+UVoqggYm7n8NrSG+gUWDIxkKDKFn59k3UO0IBTnfJ7DZdWoEuC7Evl+zpC2Ihhvb2Y+tFNwi9k0qyuhXbhEAVasWIF/fv3p0aNGoSEhKDRaLhy5QpNmzblv//9b6H73Zu3/P7777z55pvMnz+fDh06oNFo2L9/P2+//Tbz588vtIyzZ88yf/58+vTpg6OjI61btyY4OBgXFxfi4+M5c+YMp0+fpnXr1ixatIi+ffuW+PhM9o02atQotm/fzhNPPEHbtm1LdYWj1WrZuHEjZ8+eRaPR0KBBA/r371+miYpFxXLtZjavLYvFwV7D0vEBBPpZwf9O1jlwrAF2ruX3Gs65AyiOSmInhAHaNnShVlVHvt6WJImdlQkJCeHo0aNs376dc+fOoSgKjRo1KtHkwBMmTGDVqlU88MAD+m29e/fGzc2N0aNHc/bs2QL38/Pz4/3332fu3Lls3ryZvXv3cvnyZdLT06lcuTJPPfUUvXv3LtNKFCb7Vvv111/ZvHkznTp1KtX+p06don///sTExFCvntok9c8//+Dv78/PP/9cbHOsKdq1hWWLvJHNa0tjcXXW8MGEAPzNvZqEobLOl2//OgCHyuBQXe1n5zW0fF9LCBug0WgY1suLeWtucyEqizohFtpHV+j99ddfxMXF6WvBevbsyfXr15k5cyZpaWkMGDCADz/8EGdn52LLunTpUoHruXp7e3P58uVi93dxcWHQoEHFLj9WGibrTFO1alU8PT1Lvf/zzz9Po0aNuHr1KkePHuXo0aNERUXRtGlTRo8eXez+bdq04YUXXuDvv/8u9DmJiYl89tlnNG7cmB9//LHUsQrLczk6m0lLbuDhZsfSiYHWk9SBOjlxeSd2oDbHygAKIQzWtaUbQZUd+HZbkrlDEQaYNWtWnsmDT548yQsvvEDPnj2ZMmUKv/zyCwsWLDCorDZt2jBhwgSio6P122JiYnjttdcK7TtnKib7dvvggw948803WbVqVamGCZ84cYLDhw/j6+ur3+br68u8efMMWvPVFO3awjJduprF68tj8fOyZ9H4AHw97c0dkuF0mZD9b/kOnMjl0gri3gdFKZ+JkIWwMfb2GoY+5Mny9fGMeizbsgdhCY4fP84777yjv//tt9/Stm1bPvvsM0Btop05cyazZs0qtqzVq1czcOBAQkND9a2BkZGR1K1bl02bNpVH+AYzWWLXunVrMjIyqFWrFm5ubvmGGsfFxRW5f7169bhx4waNGjXKsz02NpawsLBiX98U7drC8py/ksmbK24S4GfPorEBeHtYUVIH6mAGtOU3OfG9XFqBLgGyL0o/OyEM1KeDB19uTuTb7Um89lQlk72uVquOxrS3l4swQ8XHxxMYGKi/v2fPHvr06aO/36ZNG6KiogwqKywsjPDw8Dz99Bo2bMhDDz1k9lHSJkvshg0bxrVr15g/fz6BgYElPvD58+czbtw4Zs2alWflijlz5vDee++RlHS3KtzLy6vQcsqzXVtYlhMXMpj28U1qBDmy4JUAPN2scBqPrHPqT1M0xbp2BBwgdYckdkIYyMlRw5AeXnz+UwIDu3pSq2r59LVTFIV/IrPYeTiNvcfTiLmtxU4DQZUdaFHPhTYNXWhd3wVXS1nf2gIFBgYSERFBSEgIWVlZHD16lNmzZ+sfT05OLtFyoxqNhl69ehU5qbE5mCyx279/PwcOHKBZs2al2v/RRx8FYMiQIfqkMHf+mMcee0x/v7g12kTFsOdoGu9+eZuGtZyY+6K/9X7YZZ4DO2+wz7+cntHZe4FrB0jdBr4vlf/rCWEjBnXzZMuBFBZ/Hcey1wKxN9JqFIqi8O+1bHYfSWPnkTSib+Xg42HHgy3cqFPdCUWBf69lceRcBv/7MwVHB2he14X2jV1pUMMJd1c7MrMU0jJ1pGUopGWoPxvVcrLcCdnLUZ8+fZgyZQrvvfcemzZtws3Njc6dO+sfDw8Pp3bt2gaXl5qayp49e4iMjCQrKyvPY+PGjTNa3CVlssSufv36pKenl3p/Y65iIWxXVrbC6l8S+O73ZLq1cuPNZyvh5GjFTRVZ58Cpgen6vLn3grhFoOSAxooGmAhhRo4OGiY+6cekJbF88VMCowf6Fr9TIbRahdMRmRw8mc7+8HQib+Tg6WZH5+auTHrSj+Z1nAtsfr12M5u/TmVw4GQ6H/8QT04R9Rtjh/hWyMRu7ty5DBo0iC5duuDh4cGXX36Jk9Pdv8Pq1asNrn07duwYDz/8MGlpaaSmpuLn58etW7dwc3MjICDArImdRrl32uRytG3bNmbPns28efNo0qRJvurOoppPbdnVq1cJCQkhKiqKatWqmTscq3b0fAbLvo0j+lYOz/f3YXAPT7P3dSizy23AuQkErTbN66X/DVfaQfU94PagaV5TCBvx/Y4kPv4hgf5dPBjxiLdBfXpvJeRwJiKLsxGZnLmcxT9XssjMVvD1tKNtI1e6tHCjVQMXHB0M/yxLTddx/VYOaRk6XJw0uDrb4eaiwc3FDhcnjdHWt7XW76/ExEQ8PDywt897fuLi4vDw8MiT7BWma9eu1K1bl48//hgfHx9OnDihX+Fq/PjxZu3uZbLEzs5ObQq7/4u2JM2nGRkZhIeHF7hyRWHrspnCypUrWbRoEdHR0TRq1IilS5fmqd4tirW+MSxFdo7CX6fS2bAzmfCLmTSq5cSkJ/1s42pUUeCCF1SaAZVeN9Fr6uBSCHg+AYHLTPOaQtgIRVHYtCeFzzYloNUptG7gSvO6zlSv4oiHqx05WoWEZB1XYrK5dDWL81eyiI1Xv/sCfO1pUNOZhjWdaFzbmXrVnYyWgJWXivz95ePjw19//UW9evXw8fHhwIEDNGjQgL/++ovhw4dz7tw5s8VmsraWoppSjx07Vuz+W7Zs4dlnn+XWrVv5HjNnv7r169czYcIEVq5cSadOnfjkk0/o27cvZ86cKdGEyKJw2Tlq35DUDIWUNB23EnKIua3ldEQmR85mkJSqo34NJ955qTIdm9jQuo0510CXYpqBE7k0duD5OCT/AAFLZN1YIUpAo9EwsKsn3Vq58fuhVPYeS2f1z4lkZuetP/Fyt6N2NUe6tnKjYU1nGtR0sq65NQWOjo7675rAwEAiIyNp0KAB3t7eREZGmjU2k9XY3S8xMZGvvvqKzz//nBMnThSbmIWFhdG7d29mzJiRZ7iyubVr146WLVvy8ccf67c1aNCAAQMGGDTRYUW+4inM7UQtu4+ksi88nSsx2cQn6fI9x94O6oU60aKuC93buNlGDd39UrdDVC+odQGcip/Sx2jS9kLkg1B9H7h1NN3rCmGDtFqFmwla0jJ0ODho8Ha3w8vdziYuQCvy91evXr0YMWIETz75JC+99BLHjh1j3Lhx/Oc//yE+Pp6//vrLbLGZ/BJh586drF69mh9//JHQ0FAef/xxvvjii2L3i42NZdKkSRaV1GVlZXHkyBGmTJmSZ3uvXr3Yv39/gftkZmaSmZmpv5+cnFyuMRpbZpaOnYfT2P5XKpeuZePgAGHVnOjYxJVurd3wci/dPHHJaTr+OJbGzsOpnPgnEzs7aN3Ahcce8CCwkgMerna4u9jh7qqhso8DPp52Rht5ZrEyz4LGGRxrmvZ1XTuBQxAkfy+JnRBlZG+voUolqY2zNfPnz9d/f7/zzjsMHz6cl19+mbCwMNasWWPW2Ezy33b16lXWrl3L6tWrSU1NZciQIWRnZ/PDDz/QsGFDg8p44okn2L17d4mGIpe3W7duodVq8yWbgYGBxMTEFLjPggUL8sybYy0URWH3kTRW/ZjArUQtrRu4MLiHJzlahTMRWXz4fTwrf4inbSNXerR2o2kdF3w9C78qVRSFG3Fajv2Twd5jaRw+m4FWBy3qOjPpST86t3CzznnnjCnrHDjVBY2JJ1XW2IHHIEjeAAEfSHOsEELcQ1EU/P399Qsm+Pv7s3nzZjNHdVe5J3YPP/wwf/75J48++igffvghffr0wd7enlWrVpWonBUrVjB48GD27t1b4Khasw4tLmRASEGmTp3KpEmT9PevXbtmcHJrLpejs1n2bRwnLmTSqakrHwzyodp9S+fEJWnZcSiVnYfSmPPFbQAc7MHV2e7OqCx1ZBYadcRWfJKW1AwFjQYa13bmxYE+dG3lTiVvK1sZojxlnTVt/7p7eQ2GhI8g4y91bjshhBCA+h1fp04dTp8+TZ06ljeZe7kndtu2bWPcuHG8/PLLZfoDfP3112zduhVXV1d2796dJ3HSaDRmSewqV66Mvb19vtq52NjYQpuMnZ2dcXZ21t+/d8UMS5OVrfDfLYl8uy2JKpUceO9Vf9o0dC3wuX5e9gzu4cXgHl5E38rhQlQWcUlaMjIV0jN1pGcqZGQp6HQKHm52eHvYUzPIkXo1nKxr7VZTURTIOAF+k4p/bnlwfQDsAyHpO0nshBDiHnZ2dtSpU4fbt29XzMRu7969rF69mtatW1O/fn2eeeYZhg4dWuJy3n77bebMmcOUKVP0U6eYm5OTE61atWL79u0MHDhQv3379u3079/fjJGVTVKqlv/tTWHjnhQSU7Q82duLJ3t7GzzRb1BlB4IqS5+SMsmJBF08uDQ3z+tr7MFrGCR9BQHvgcYGB6cIIUQpLVy4kNdff52PP/7Y4taYL/dv3w4dOtChQweWLVvGt99+y+rVq5k0aRI6nY7t27cTEhKCp6dnseVkZWUxdOhQi0nqck2aNIlnnnmG1q1b06FDBz799FMiIyN56SXrW5Lpamw2P+xMZuvBVLQ6hZ7t3Bn6kBchgYavnSeMJOPOFEDOLcwXg89zEL8Ukn8Br8fNF4cQQliYp59+mrS0NJo1a4aTkxOurnlbs+Li4swUmQlHxbq5uTFq1ChGjRrF+fPn+eKLL3j33XeZMmUKPXv25Oeffy5y/+HDh7N+/XreeustE0VsmKFDh3L79m3mzJlDdHQ0jRs3ZvPmzYSGhpo7NIMoikL4hUy+35nMgZPp+HjY8X+9vHiss4c0kZpTxjGw9weHYPPF4NwYXNpB4heS2AkhxD2WLl1q7hAKZbZ57AC0Wi2//PILq1evLjaxGzduHOvWraNZs2Y0bdo03+CJxYsXl2eo5cZc8wDlaNVRrt/vSOJCVDY1ghwZ3MOTHm3crXttVVsR9SiQAyFbzBtHwmcQ8yLUugROJp52RQhh0SrqPHbZ2dmMHj2a6dOnU6tWLXOHk49ZE7uS6NatW6GPaTQadu7cacJojMfUb4zkNB3/+zOFjbuTuZVwd9qS1g1cbGLCTJugaOFCJfCbDJXfNm8sulS4VAM8h0CVj8wbixDColTUxA7UJcWOHj1qkYmd1fRwL2pJMlG8a7HZ/LArmS0H1P5zD7Vx54kenra5YoO1yzwJukRwe9DckYCdO/hOgNvvqEmmQ5C5IxJCCLMbOHAgmzZtyjN9maWwmsQu18WLF7l06RIPPvggrq6uRc4ZV9EpisLJS5l8vyOZ/eHpeLnbMeQhT/o96Imfl/Sfs1ipW0DjCi5tzR2JyvcViF8CsW9A8H/MHY0QwsqtXLmSRYsWER0dTaNGjVi6dCmdO3c2d1glEhYWxjvvvMP+/ftp1aoV7u7ueR4369y61tIUe/v2bYYMGcKuXbvQaDRcuHCBWrVq8dxzz+Hj48MHH3xg7hBLpTyqsrNzFP44lsaGHcmcj8witIoDj3f3omdbN5ydLGtUsbiPosDllurasFW/N3c0dyWsgZhREPydOnmxEKLCK8331/r163nmmWdYufL/27v3oKjqvw/g771yFQKUq6xclMTAC2Yl1Q8YTdFKrSnL8pZk86RTXjJj7ILlTFlaJlqo4KX8peaEVlNpOJVlkllcHFw0HrxkwQbKRQXRXXbP8wcPp1YgWS57ds++XzM7A2fP2fN5H+vw2e+5vY8777wTGzduRE5ODkpLS6HT6Xq54p4TGdnxOccKhQKnT5+2YzXXrd9ZGruZM2eiuroaOTk5iI2NxbFjxxAVFYW8vDwsWrQIer1e6hK7pCcbu/Pn/xenSneg7JwRTdcE9A9UI36gFv0D1VCKo5rt/XNfN63d/ySun9ZT87S3Pjuu355ZO7Ou5krg8sdA/32Ad2o780tEEADD48ClTwC/eYA6TOqKiKirvMYA7gnd/pjWv1+lpaUIC/t7n3D9jfj/6fbbb0dCQgKysrLEabGxsZgyZQreeOONbtdETnQoNi8vD19//XWb5mfQoEH4/fffJarKsTTUl+OWm9ZgeIACGrUCqtbBudrrDlW3OXTd3qHsG83TiWV6ZD1drOWG63bg9fgtBLzGt7OchBQKIGQboIkALm5vuajCilN8PyQiAFD59khj1+r6x2JmZGRg+fLlbeYzGo0oKChAenq61fRx48YhPz+/x+rpLYsXL8aKFSvg5eX1r+fWKRQKSY8iOk1j19jYCE9PzzbTL1y40OE3A1cTMTAVpuY63q6EeodCC/R7veVFRPT/2huxa8+FCxdgNpvbPHIzKCiozaM5HVFRURFMJpP4c0ekPu/faRq7//znP/jwww+xYsUKAC0bzmKxYNWqVf96KxRXolAooOVDIoiIyI769OkDHx+fTs9/fePjLBdB/vPuHI58pw6naexWrVqF5ORk/PrrrzAajVi6dCn0ej1qa2tx+PBhqcvrMovFAgAwGAwSV0JERNR5rX+3Wv+O3Ujfvn2hUqnajM5VV1e3GcWjrnOaxs7b2xvFxcXYuHEjVCoVGhsb8eCDD2L+/Pni0KgzqqqqAgDcdpuD3NqCiIjIBlVVVZ26olWr1WLkyJE4cOAAHnjgAXH6gQMHMHny5N4s0aU4zVWxKpUKBoMBgYGBVtNramoQGBgIs9ksUWXd09zcjKKiIgQFBUGpdJ5bkVy+fBlDhgxBaWkp+vTpI3U5XcIMjoEZHIcccjCD/VgsFlRVVWHEiBFQqzs3TtR6u5MNGzZg9OjR2LRpE7Kzs6HX653mGeuOzmlG7DrqPxsaGuDu7m7nanqOWq3GqFGjpC7DZpcuXQIAhIWF2XRuhSNhBsfADI5DDjmYwb5svffcI488gpqaGrz22mswGAyIi4vDV199xaauBzl8Y9d6SbFCocArr7xidWWs2WzGzz//jOHDh0tUHREREdli3rx5mDdvntRlyJbDN3atlxQLgoCSkhJotX8/21Sr1WLYsGFYsmSJVOUREREROQyHb+xaLyl+4oknsHbtWocflnYVbm5uyMjIcOp7CDKDY2AGxyGHHMxArs5pLp4gIiIion/nPJdhEhEREdG/YmNHREREJBNs7IiIiIhkgo0dERERkUywsXMRs2fPxpQpU3p1HdeuXcMzzzyDvn37wsvLC5MmTcKff/4pvn/27FmkpaUhMjISHh4eiI6ORkZGBoxGY6c+Xw4ZAHnkYIbOuVEGAJg0aRJ0Oh3c3d0REhKCGTNmoLKyslOfzwydwwzkStjYUY9ZuHAh9u7di127duHHH39EQ0MD7rvvPvFxbydPnoTFYsHGjRuh1+uxZs0abNiwAcuWLZO48r/JIQMgjxyukAEAUlJSsHv3bvz222/Izc3FqVOn8NBDD0lYtTVmcAxyyEB2IpBLmDVrljB58mRBEARh3759wp133in4+voK/v7+wr333iuUl5eL8545c0YAIOTm5grJycmCh4eHMHToUCE/P7/Dz6+vrxc0Go2wa9cucVpFRYWgVCqF/fv3d7jcW2+9JURGRrpMBrnkYIbey/DZZ58JCoVCMBqNzMAMdstA8sEROxfU2NiIxYsX45dffsE333wDpVKJBx54ABaLxWq+F198EUuWLEFxcTFiYmIwbdo0NDc3t/uZBQUFMJlMGDdunDgtNDQUcXFxyM/P77CWixcvwt/f3yUzyCUHM/RchtraWnz00UdITEyERqNhBmaQJAM5Oak7S7KPf36jvF51dbUAQCgpKREE4e9vlDk5OeI8er1eACCcOHGi3c/46KOPBK1W22b6PffcIzz11FPtLlNeXi74+PgI2dnZLpNBLjmYoWczLF26VPD09BQACHfccYdw4cIFZmAGu2Yg+eCInQs6deoUHnvsMURFRcHHxweRkZEAgHPnzlnNN3ToUPHnkJAQAEB1dbVN6xIEAQqFos30yspKpKam4uGHH8aTTz5pawRZZADkkYMZup/h+eefR1FREfLy8qBSqTBz5kwINj4UiBmYoacykHNz+GfFUs+7//77ER4ejuzsbISGhsJisSAuLq7N1YT/HL5v3XlcfzihVXBwMIxGI+rq6uDn5ydOr66uRmJiotW8lZWVSElJwejRo7Fp0yaXzSCXHMzQ/Qx9+/ZF3759ERMTg9jYWISHh+PIkSMYPXo0MzCD3TOQc+OInYupqanBiRMn8NJLL2HMmDGIjY1FXV1dtz935MiR0Gg0OHDggDjNYDDg+PHjVjueiooKJCcnIyEhAVu3boVSaft/gnLIIJcczND9DNdrHV25du1ap9fFDB1jBtsykPPjiJ2L8fPzQ0BAADZt2oSQkBCcO3cO6enp3f5cX19fpKWl4bnnnkNAQAD8/f2xZMkSxMfHY+zYsQBaRlaSk5Oh0+mwevVqnD9/Xlw+ODjYpTLIJQczdC/D0aNHcfToUdx1113w8/PD6dOn8corryA6OtqmERZmYIaeykDOj42di7BYLFCr1VAqldi1axeeffZZxMXF4eabb0ZmZiaSk5O7vY41a9ZArVZj6tSpaGpqwpgxY7Bt2zaoVCoAQF5eHsrLy1FeXo7+/ftbLduZc0DkkEEuOZihZzJ4eHhgz549yMjIQGNjI0JCQpCamopdu3bBzc2NGZjBbhlIPhQCz6p0CampqRg4cCDWr18vdSldJocMgDxyMINjYAbHIIcMJB88x07m6urq8OWXX+LgwYPikL2zkUMGQB45mMExMINjkEMGkiF73luF7G/KlClCWFiYsGzZMsFisUhdTpfIIYMgyCMHMzgGZnAMcshA8sNDsUREREQywUOxRERERDLBxo6IiIhIJtjYEREREckEGzsiIiIimWBjR0RERCQTfPIEkQ3MZjNMJpPUZRARyYpWq+3yc7fJGhs7ok4QBAF//fUX6uvrpS6FiEh2lEolIiMjodVqpS7F6fE+dkSdYDAYUF9fj8DAQHh6ekKhUEhdEhGRLFgsFlRWVkKj0UCn03H/2k0csSO6AbPZLDZ1AQEBUpdDRCQ7/fr1Q2VlJZqbm6HRaKQux6nxgDbRDbSeU+fp6SlxJURE8tR6CNZsNktcifNjY0fUSTw8QETUO7h/7Tls7IiIiIhkgo0dERERWTl37hy8vb1RUlIidSlkI148QURERFZCQ0NRXFwMnU4ndSlkIzZ2REREZEWtVmPgwIFSl0FdwEOxRERERDLBxo6IiIhIJtjYERERkai4uBiPPvoogoODodVqER0djeXLl/M52U6CjR0RUS9KTk7GwoULpS5Dlvbv3w+FQvGvr3379kldplPZsmULbrvtNgQFBeGLL77AiRMn8PLLLyMzMxOzZ8+WujzqBDZ2RDI2e/Zs8Q+cWq2GTqfD008/jbq6OnGeiIgIvPvuu9IV6UT+uT01Gg2ioqKwZMkSNDY2drjMnj17sGLFCjtW6TqSkpJgMBjEV0BAAJYtW2Y17Z577pG6TKfx/fffY+7cucjOzsbatWtx6623Ijo6GrNnz8aqVauwY8cOnDx5Uuoy6QZ4VSyRzKWmpmLr1q1obm5GaWkp5syZg/r6euzcuVPq0pxS6/Y0mUw4dOgQnnzySTQ2NiIrK8tqPpPJBI1GA39/f4kqlT8PDw94eHgAACoqKlBTU4O77roLwcHBElfmnBYtWoQJEyZg1qxZbd5LSUkBABw7dgyDBw+2d2lkA47YEcmcm5sbgoOD0b9/f4wbNw6PPPII8vLypC7LabVuz/DwcDz22GN4/PHH8emnn2L58uUYPnw4tmzZgqioKLi5uUEQhDaHYq9du4alS5ciPDwcbm5uGDRoEDZv3iy+X1paiokTJ8Lb2xtBQUGYMWMGLly4IEFS51JUVAQAGDlypMSVOKeSkhIUFRVh/vz57b7f1NQEoOU2KOTY+C9E1BWmK0CtBIck/AcDGs8uL3769Gns378fGo2mB4vqORcvXkRDQwPCwsIAAAaDAW5ubvD394fJZILBYEBgYCDc3d1x6dIlXLp0Cf379wcAVFVVQa1WIyAgAGazGRUVFejXrx88PDxw+fJl1NfXIzw8HABQXV0NNzc3+Pr6drtmDw8P8aTy8vJy7N69G7m5uVCpVO3OP3PmTPz000/IzMzEsGHDcObMGbFxMxgMSEpKwty5c/HOO++gqakJL7zwAqZOnYpvv/2227Xa4qrRgnN/Ndt1nQCgC1bDXWv7mENhYSHCwsIQGBjYC1V1k+UKYLTz/kI7GFB2fl9RXFwMABg+fHi77xcWFgIAhg0b1q2ykpKS8MEHHyAiIqJbn0MdY2NH1BW1J4H/SjAyML0ACEqwaZEvvvgC3t7eMJvNuHr1KgDgnXfe6Y3quu3QoUPIz8/H66+/DgDYvHkzYmJiMHXqVNTV1WHlypVYuHAhYmJi8PPPP+Prr7/G6tWrAQAffvghQkJCMH36dDQ0NGDlypV4+umnER8fj8LCQuTm5iIzMxMAsHPnTkRHR+O+++7rVr1Hjx7Fjh07MGbMGACA0WjE9u3b0a9fv3bnLysrw+7du3HgwAGMHTsWABAVFSW+n5WVhYSEBDE/0HIye3h4OMrKyhATE9Otem1x7q9m/M/Kv+y2vlYb0oMRo9PavFxhYSESEmz7f8NujCeBs3beX0QUAO6d3x5GoxEA4O7u3u777733HhITE9u9abHZbO7wi8z1zp49y6aul7GxI+oK/8EtTZYU67VRSkoKsrKycOXKFeTk5KCsrAzPPPNMLxTXfXfffTdGjBgh/p6WlgY3NzcAgJ+fH9LT08URmdtvvx2xsbHivDNnzhQPE3l7eyM9PV1ssBISEqwaqGnTpomfa6vWRrm5uRkmkwmTJ0/GunXr8P7772PAgAEdNnVAy6iISqVCUlJSu+8XFBTgu+++g7e3d5v3Tp06ZdfGThesxoZ0+5+rpgvu2p+lwsJCpKWltZm+fft2rF+/HleuXEFkZCQ++eQTaLW2N47doh3c0mjZe502GDp0KICWCyimTJli9d7bb7+NkpIS/PDDD+K0CRMmID4+HkeOHMETTzwBtVrd7nbW6/VIS0tDU1MTZs2aJY6aU+9hY0fUFRpPm0fOpOLl5SV+y87MzERKSgpeffVVh7xS09fX1+rwaEhIiPizRqOxem6lj48PfHx8xN+DgoLEn1UqldW8ffr0QZ8+fcTfu3O4rrVR1mg0CA0NtTqs7eXl9a/Ltp7o3xGLxYL7778fb775Zpv3/rkt7MFdq+zSyJkUampq8Mcff7Q7Yjdx4kTMmDEDADBnzhwcOnRIHGG1G6WnTaNnUhg1ahRSU1Mxf/58mEwm3HrrraiqqkJOTg527tyJPXv2WJ2/ePz4caSmporNXk1NTZvtnJiYiEcffRQff/wxhgwZgkmTJokNJPUeXjxB5GIyMjKwevVqVFZWSl2KU2ptlAcMGGDzuYrx8fGwWCz4/vvv230/ISEBer0eERERGDhwoNXrRk2jKysoaBkNu76xEwQBmzZtwqhRozBs2DDs3bu3w0ONBOTm5mL69Ol4/vnnMWjQIIwePRoVFRUoKyvD+PHjxfkuXrwIhUKBBQsWAOh4O+/duxfJyckYMmQIAODmm29mY2cHbOyIXExycjJuueUWq/O4KioqUFxcbPWqra2VsEp5ioiIwKxZszBnzhx8+umnOHPmDA4ePIjdu3cDAObPn4/a2lpMmzYNR48exenTp5GXl4c5c+bAbDZLXL3jKioqQmBgoHjRTatt27ahvLwcP/zwA44dOwYfHx+xyaC2PD098eabb+Ls2bNobm7G3Llz8dtvv8HT0/oijOPHjyMxMVH8vaPtrNfrrRq5wsJCNnZ2wMaOyAUtXrwY2dnZ+OOPPwAAq1evxogRI6xen3/+ucRVylNWVhYeeughzJs3D4MHD8bcuXPFGxyHhobi8OHDMJvNGD9+POLi4rBgwQL4+vpCqeTuuiMvvPACqqqq2kzX6/VITEyEh4cH1q5dC4vFAj8/PwkqdE7r1q1DWlqaeEVsq+PHjyM+Pl78vaPtHBAQgNLSUgBAXl4eDh48aLUc9Q6FIAiC1EUQObKrV6/izJkziIyM5GEcIidy7NgxTJ48GQMGDEBSUhJ+/fVXfPXVV1KX5fSeffZZjB07FpMmTQLQ8Xaurq7GhAkTIAgC4uLikJ+fj/Ly8nY/k/vZnsPGjugGuMMhIupd3M/2HI7tExEREckEGzsiIiIimWBjR0RERCQTbOyIiIiIZIKNHVEn8TojIqLewf1rz2FjR3QDrU8XuHLlisSVEBHJk9FoBNDyOEDqHj4rlugGVCoVbrrpJlRXVwNouTu7QqGQuCoiInmwWCw4f/48PD09oVazLekubkGiTggODgYAsbkjIqKeo1QqodPp+KW5B/AGxUQ2MJvNMJlMUpdBRCQrWq2Wj83rIWzsiIiIiGSC7TERERGRTLCxIyIiIpIJNnZEREREMsHGjoiIiEgm2NgRERERyQQbOyIiIiKZYGNHREREJBP/BxXJrHcsIUUUAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -2320,16 +2320,16 @@ "output_type": "stream", "text": [ "q(s,a) = \n", - "[[1.825 1.018]\n", - " [2.656 2.396]\n", - " [1.101 0.271]]\n", + "[[1.594 1.141]\n", + " [2.411 2.221]\n", + " [1.491 0.594]]\n", "-------------------------------------------------------------------\n", "Episode number: 4, starting day: 29.9 (from beginning of the year)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2342,16 +2342,16 @@ "output_type": "stream", "text": [ "q(s,a) = \n", - "[[2.57 2.324]\n", - " [2.729 2.41 ]\n", - " [1.101 0.271]]\n", + "[[2.411 2.219]\n", + " [2.382 2.409]\n", + " [1.491 0.594]]\n", "-------------------------------------------------------------------\n", "Episode number: 5, starting day: 19.8 (from beginning of the year)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2364,16 +2364,16 @@ "output_type": "stream", "text": [ "q(s,a) = \n", - "[[2.57 2.493]\n", - " [3.996 3.907]\n", - " [1.451 0.844]]\n", + "[[2.411 2.219]\n", + " [2.833 2.967]\n", + " [2.287 1.918]]\n", "-------------------------------------------------------------------\n", "Episode number: 6, starting day: 11.0 (from beginning of the year)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2386,16 +2386,16 @@ "output_type": "stream", "text": [ "q(s,a) = \n", - "[[2.389 2.765]\n", - " [3.967 4.041]\n", - " [1.651 0.89 ]]\n", + "[[2.411 2.219]\n", + " [4.677 4.24 ]\n", + " [2.367 1.918]]\n", "-------------------------------------------------------------------\n", "Episode number: 7, starting day: 45.2 (from beginning of the year)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2408,16 +2408,16 @@ "output_type": "stream", "text": [ "q(s,a) = \n", - "[[2.389 2.765]\n", - " [4.987 4.762]\n", - " [1.829 1.164]]\n", + "[[2.452 3.17 ]\n", + " [4.847 4.609]\n", + " [2.432 1.997]]\n", "-------------------------------------------------------------------\n", "Episode number: 8, starting day: 362.2 (from beginning of the year)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2430,16 +2430,16 @@ "output_type": "stream", "text": [ "q(s,a) = \n", - "[[2.616 3.353]\n", - " [4.963 4.956]\n", - " [2.305 1.164]]\n", + "[[2.452 3.271]\n", + " [5.66 5.162]\n", + " [2.737 2.014]]\n", "-------------------------------------------------------------------\n", "Episode number: 9, starting day: 72.3 (from beginning of the year)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2452,16 +2452,16 @@ "output_type": "stream", "text": [ "q(s,a) = \n", - "[[2.9 3.784]\n", - " [5.506 5.361]\n", - " [2.633 1.164]]\n", + "[[2.452 3.917]\n", + " [6.03 6.114]\n", + " [2.737 2.014]]\n", "-------------------------------------------------------------------\n", "Episode number: 10, starting day: 357.8 (from beginning of the year)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2474,9 +2474,9 @@ "output_type": "stream", "text": [ "q(s,a) = \n", - "[[2.951 3.904]\n", - " [6.071 6.075]\n", - " [3.145 1.164]]\n" + "[[2.56 4.458]\n", + " [6.448 6.346]\n", + " [3.256 2.165]]\n" ] } ], @@ -2508,7 +2508,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2579,7 +2579,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi0AAAG6CAYAAADEYnYUAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAkm0lEQVR4nO3deXAUdd7H8c8QYABNBsOhQEISBE8OkSBG5FRRFhTWA0QWworF4qIrsFQpsAuKSPCG1YUV5RBXCK6Kq1waVIKFGw0SSkS5CQnhUjATiHGU5Pf8YWUeAknIRbp/5P2q6ipm0t3zHRyGt909g8cYYwQAAOBytZweAAAAoCyIFgAAYAWiBQAAWIFoAQAAViBaAACAFYgWAABgBaIFAABYgWgBAABWqO30AFWpoKBABw4cUGhoqDwej9PjAACAMjDG6Pjx42revLlq1Sr5eMp5FS0HDhxQZGSk02MAAIAKyMzMVERERIk/P6+iJTQ0VNJvTzosLMzhaQAAQFnk5OQoMjIy+Pd4Sc6raCk8JRQWFka0AABgmbNd2sGFuAAAwApECwAAsALRAgAArEC0AAAAKxAtAADACkQLAACwAtECAACsQLQAAAArEC0AAMAKRAsAALAC0QIAAKxAtAAAACsQLQAAwApECwAAsEJtpwc4VVZWlh599FGtXr1aeXl5uuyyyzR//nx16tTJ6dEAx8XOi3V6BDhs46iNTo8AOMo10fLjjz+qa9eu6tWrl1avXq2mTZtq9+7datiwodOjAQAAF3BNtDz99NOKjIzUwoULg/dFR0c7NxAAAHAV11zT8v777ys2Nlb33HOPmjZtqo4dO+rVV191eiwAAOASromWPXv2aO7cuWrTpo0+/PBDjR49Wn/5y1+0ePHiErcJBALKyckpsgAAgPOTa04PFRQUKDY2VjNmzJAkdezYUVu3btXcuXM1fPjwYrdJSEjQE088UZ1jAgAAh7jmSEuzZs101VVXFbnvyiuvVEZGRonbTJw4UX6/P7hkZmae6zEBAIBDXHOkpWvXrtq+fXuR+3bs2KGoqKgSt/F6vfJ6ved6NAAA4AKuOdIybtw4paSkaMaMGdq1a5eWLFmiefPmacyYMU6PBgAAXMA10dK5c2ctX75cS5cuVdu2bfXkk09q1qxZGjp0qNOjAQAAF3DN6SFJ6t+/v/r37+/0GAAAwIVcc6QFAACgNEQLAACwAtECAACsQLQAAAArEC0AAMAKRAsAALAC0QIAAKxAtAAAACsQLQAAwApECwAAsALRAgAArEC0AAAAKxAtAADACkQLAACwAtECAACsQLQAAAArEC0AAMAKRAsAALAC0QIAAKxAtAAAACsQLQAAwApECwAAsALRAgAArEC0AAAAKxAtAADACkQLAACwAtECAACsQLQAAAArEC0AAMAKRAsAALAC0QIAAKxAtAAAACsQLQAAwApECwAAsALRAgAArEC0AAAAKxAtAADACkQLAACwAtECAACsQLQAAAArEC0AAMAKRAsAALAC0QIAAKxAtAAAACsQLQAAwApECwAAsALRAgAArOCaaHn88cfl8XiKLJdcconTYwEAAJeo7fQAp7r66qu1du3a4O2QkBAHpwEAAG7iqmipXbs2R1cAAECxXHN6SJJ27typ5s2bKyYmRvfee6/27Nnj9EgAAMAlXHOkpUuXLlq8eLEuu+wyHT58WNOnT9cNN9ygrVu3qlGjRsVuEwgEFAgEgrdzcnKqa1wAAFDNXHOkpW/fvrrrrrvUrl073XzzzVq5cqUk6fXXXy9xm4SEBPl8vuASGRlZXeMCAIBq5ppoOd0FF1ygdu3aaefOnSWuM3HiRPn9/uCSmZlZjRMCAIDq5JrTQ6cLBAL67rvv1K1btxLX8Xq98nq91TgVAABwimuOtEyYMEHJycnau3evvvjiC919993KyclRfHy806MBAAAXcM2Rlv3792vIkCH64Ycf1KRJE11//fVKSUlRVFSU06MBAAAXcE20JCYmOj0CAABwMdecHgIAACgN0QIAAKxAtAAAACsQLQAAwApECwAAsALRAgAArEC0AAAAKxAtAADACkQLAACwAtECAACsQLQAAAArEC0AAMAKRAsAALAC0QIAAKxAtAAAACsQLQAAwApECwAAsALRAgAArEC0AAAAKxAtAADACkQLAACwAtECAACsQLQAAAArEC0AAMAKRAsAALAC0QIAAKxAtAAAACsQLQAAwApECwAAsALRAgAArEC0AAAAKxAtAADACkQLAACwAtECAACsQLQAAAArEC0AAMAKRAsAALAC0QIAAKxAtAAAACsQLQAAwApECwAAsALRAgAArEC0AAAAKxAtAADACkQLAACwAtECAACsQLQAAAAruDZaEhIS5PF4NHbsWKdHAQAALuDKaElNTdW8efPUvn17p0cBAAAu4bpoOXHihIYOHapXX31VF110kdPjAAAAl3BdtIwZM0b9+vXTzTff7PQoAADARWo7PcCpEhMTtWnTJqWmppZp/UAgoEAgELydk5NzrkYDAAAOc82RlszMTD3yyCP697//rXr16pVpm4SEBPl8vuASGRl5jqcEAABO8RhjjNNDSNJ7772n3//+9woJCQnel5+fL4/Ho1q1aikQCBT5mVT8kZbIyEj5/X6FhYVV2+xAdYidF+v0CHDYxlEbnR4BOCdycnLk8/nO+ve3a04P3XTTTdqyZUuR+/74xz/qiiuu0KOPPnpGsEiS1+uV1+utrhEBAICDXBMtoaGhatu2bZH7LrjgAjVq1OiM+wEAQM3jmmtaAAAASuOaIy3FWbdundMjBMVyOUGNt5HLCQDAURxpAQAAViBaAACAFYgWAABgBaIFAABYgWgBAABWIFoAAIAViBYAAGAFogUAAFiBaAEAAFYgWgAAgBWIFgAAYAWiBQAAWIFoAQAAViBaAACAFYgWAABgBaIFAABYgWgBAABWIFoAAIAViBYAAGAFogUAAFihdmV3kJ6eruTkZG3atEmHDx9Wdna2GjZsqCZNmqhjx47q0aOHLr300qqYFQAA1GAViha/36833nhDr776qr755puzrn/FFVdo9OjRGjZsmBo2bFiRhwQAADVcuU4P/fzzz5oxY4aioqL0yCOP6JtvvpExRpJkjDljKbx/27ZtGjt2rKKjozVjxgzl5eVV/TMBAADntXIdabn00kt16NChYJCcqkWLFgoPD1dYWJj8fr+OHTumgwcPSlJw/ZycHP3973/X3LlzlZmZWQXjAwCAmqJc0VIYIZLUunVrDRo0SL169VJsbKx8Pt8Z6/v9fqWmpurTTz/VW2+9pd27d8sYowMHDlR+cgAAUKOU6/RQSEiIBg8erC+//FI7duzQ9OnTddNNNxUbLJLk8/l0880366mnntLOnTv1xRdf6J577lGtWnxoCQAAlE+5jrRs375drVq1qvCDde7cWcuWLdOePXsqvA8AAFAzleuQR2WC5VzsBwAA1ByV/p6W4pw4cUKrVq3Svn371Lp1aw0YMIBTQgAAoFIqFS1JSUl69tlnJUkPPPCABg0apMzMTPXs2VPp6enB9bp3766PPvpIderUqdSwAACg5qrU4Y/Vq1dr7dq1+vjjjxUTEyNJmjFjhvbu3Rtcxxij9evXa968eZWbFAAA1GiVipbU1FRJUnh4uDp37ixJ+uCDD+TxeIp8wZwkvf3225V5KAAAUMNVKloyMjLk8XiCR1kOHToU/A6WadOmadeuXQoLC5MxRt9++23lpwUAADVWpaLl+++/lyQ1b95ckrRt27bgz+688061atVK119/vSQpOzu7Mg8FAABquCr5SM+xY8ckSd99950kyePxBD/WHBISIkmqV69eVTwUAACooSoVLc2aNZMxRikpKZo5c6ZefvllSVJUVFQwUrKysiRJjRs3ruSoAACgJqvUR57j4uK0d+9e5efna/LkyZJ+O8rSu3dvSVJBQYHS09OLXPcCAABQEZU60jJ27FjVrv1b9xR+WigkJERjxoyRJCUnJysnJ0eSdOONN1ZyVAAAUJNV6khLbGysVq5cqWeeeUZZWVlq3bq1HnvsMV1zzTWSpH379qlfv36SpP79+1d6WAAAUHN5zKlfpmK5nJwc+Xw++f1+hYWFVem+Y2OrdHew0MaNzj5+7DxehDXdxlEOvwiBc6Ssf3/zDwIBAAArEC0AAMAK5YqWkSNHaufOnZV6wO3bt+v++++v1D4AAEDNU64LcRcuXKjXX39d/fr109ChQ3X77berfv36Z93up59+0gcffKA333xTq1atkjFGCxYsqPDQAAAHcHEfHL64r9yfHjLGaMWKFVqxYoUaNGigzp07KzY2VldeeaXCw8MVGhqq48eP69ixY/r222+1ceNGpaamKi8vL7i9x+Op8icCAADOb+WKlueee04zZswIfm1/bm6ukpOTlZycXOp2p35AKTw8PPhFdAAAAGVVrmtaxo8fr927d2vSpElq0qSJpP//UrlTf336bUlq0qSJJk2apN27d2vcuHFV+RwAAEANUO5PD/l8Pk2fPl379+9XYmKihgwZooiICJ3+dS/GGLVo0UJDhgxRYmKi9u/fr+nTp8vn8xW737lz56p9+/YKCwtTWFiY4uLitHr16oo9KwAAcN6p8Dfi1qlTR4MGDdKgQYMkST/88IOOHDmi7OxsNWzYUE2bNi3XP5IYERGhmTNnqnXr1pKk119/XQMGDFBaWpquvvrqio4JAADOE5X6Gv9Dhw7pkksukfTbv+JcmX/J+fbbby9y+6mnntLcuXOVkpJCtAAAgMp9uVxkZKT69eunt956S7/88ktVzaT8/HwlJiYqNzdXcXFxVbZfAABgr0odacnPz9eaNWu0Zs0a+Xw+3XvvvYqPj1eXLl0qtL8tW7YoLi5OP//8sy688EItX75cV111VYnrBwIBBQKB4O3Cf1EaAACcf6rka/yNMcrOztYrr7yiG264QVdeeaWefvppHThwoFz7ufzyy7V582alpKTowQcfVHx8vL799tsS109ISJDP5wsukZGRlX0qAADApSoVLePHjz8jFIwx2rFjhyZNmqSoqCjddtttSkxMLHJEpCR169ZV69atFRsbq4SEBHXo0EGzZ88ucf2JEyfK7/cHl8zMzMo8HQAA4GKVipbnnntO6enp2rBhgx5++OHgRbmF38+Sn5+vpKQkDR06VM2aNSv3/o0xpcaO1+sNfkS6cAEAAOenKjk9FBcXp9mzZ2v//v365JNPNHr06OCXz0m/xYff7y91H5MmTdJnn32m9PR0bdmyRZMnT9a6des0dOjQqhgRAABYrlIX4p7O4/GoZ8+eaty4scLCwjR79uwyf6ro8OHDGjZsmA4ePCifz6f27dtrzZo1uuWWW6pyRAAAYKkqi5Zdu3YpMTFRiYmJ+u6778q9/fz586tqFAAAcB6qVLRkZGRo2bJlSkxM1ObNmyXpjK/zl6SuXbtqxIgRlXkoAABQw1UqWqKjo+XxeCT9FiuFv5akli1bavjw4YqPj9ell15auSkBAECNVyWnhwqPrjRo0EB33nmn4uPj1bt376rYNQAAgKQqipbu3bsrPj5egwYN0gUXXFAVuwQAACiiUtEyZcoUxcfHKyYmpqrmAQAAKFalouXxxx+vojEAAABKVyVfLgcAAHCuES0AAMAKRAsAALAC0QIAAKxAtAAAACsQLQAAwApECwAAsALRAgAArEC0AAAAKxAtAADACkQLAACwAtECAACsQLQAAAArEC0AAMAKRAsAALAC0QIAAKxAtAAAACsQLQAAwApECwAAsALRAgAArEC0AAAAKxAtAADACkQLAACwAtECAACsQLQAAAArEC0AAMAKRAsAALAC0QIAAKxAtAAAACsQLQAAwApECwAAsALRAgAArEC0AAAAKxAtAADACkQLAACwAtECAACsQLQAAAArEC0AAMAKRAsAALAC0QIAAKxAtAAAACu4JloSEhLUuXNnhYaGqmnTpho4cKC2b9/u9FgAAMAlXBMtycnJGjNmjFJSUpSUlKSTJ0+qT58+ys3NdXo0AADgArWdHqDQmjVritxeuHChmjZtqq+++krdu3d3aCoAAOAWrjnScjq/3y9JCg8Pd3gSAADgBq450nIqY4zGjx+vG2+8UW3bti1xvUAgoEAgELydk5NTHeMBAAAHuPJIy0MPPaSvv/5aS5cuLXW9hIQE+Xy+4BIZGVlNEwIAgOrmumh5+OGH9f777+vTTz9VREREqetOnDhRfr8/uGRmZlbTlAAAoLq55vSQMUYPP/ywli9frnXr1ikmJuas23i9Xnm93mqYDgAAOM010TJmzBgtWbJE//3vfxUaGqpDhw5Jknw+n+rXr+/wdAAAwGmuOT00d+5c+f1+9ezZU82aNQsuy5Ytc3o0AADgAq450mKMcXoEAADgYq450gIAAFAaogUAAFiBaAEAAFYgWgAAgBWIFgAAYAWiBQAAWIFoAQAAViBaAACAFYgWAABgBaIFAABYgWgBAABWIFoAAIAViBYAAGAFogUAAFiBaAEAAFYgWgAAgBWIFgAAYAWiBQAAWIFoAQAAViBaAACAFYgWAABgBaIFAABYgWgBAABWIFoAAIAViBYAAGAFogUAAFiBaAEAAFYgWgAAgBWIFgAAYAWiBQAAWIFoAQAAViBaAACAFYgWAABgBaIFAABYgWgBAABWIFoAAIAViBYAAGAFogUAAFiBaAEAAFYgWgAAgBWIFgAAYAWiBQAAWIFoAQAAViBaAACAFYgWAABgBaIFAABYgWgBAABWcFW0rF+/XrfffruaN28uj8ej9957z+mRAACAS7gqWnJzc9WhQwe9/PLLTo8CAABcprbTA5yqb9++6tu3r9NjAAAAF3JVtJRXIBBQIBAI3s7JyXFwGgAAcC656vRQeSUkJMjn8wWXyMhIp0cCAADniNXRMnHiRPn9/uCSmZnp9EgAAOAcsfr0kNfrldfrdXoMAABQDaw+0gIAAGoOVx1pOXHihHbt2hW8vXfvXm3evFnh4eFq2bKlg5MBAACnuSpaNm7cqF69egVvjx8/XpIUHx+vRYsWOTQVAABwA1dFS8+ePWWMcXoMAADgQlzTAgAArEC0AAAAKxAtAADACkQLAACwAtECAACsQLQAAAArEC0AAMAKRAsAALAC0QIAAKxAtAAAACsQLQAAwApECwAAsALRAgAArEC0AAAAKxAtAADACkQLAACwAtECAACsQLQAAAArEC0AAMAKRAsAALAC0QIAAKxAtAAAACsQLQAAwApECwAAsALRAgAArEC0AAAAKxAtAADACkQLAACwAtECAACsQLQAAAArEC0AAMAKRAsAALAC0QIAAKxAtAAAACsQLQAAwApECwAAsALRAgAArEC0AAAAKxAtAADACkQLAACwAtECAACsQLQAAAArEC0AAMAKRAsAALAC0QIAAKxAtAAAACsQLQAAwAqui5Y5c+YoJiZG9erVU6dOnfTZZ585PRIAAHABV0XLsmXLNHbsWE2ePFlpaWnq1q2b+vbtq4yMDKdHAwAADnNVtLzwwgsaOXKkHnjgAV155ZWaNWuWIiMjNXfuXKdHAwAADqvt9ACFfvnlF3311Vd67LHHitzfp08fff7558VuEwgEFAgEgrf9fr8kKScnp8rny8+v8l3CMufgZVUu+Xm8CGu6c/HeVi68EeIcvQYLX9vGmFLXc020/PDDD8rPz9fFF19c5P6LL75Yhw4dKnabhIQEPfHEE2fcHxkZeU5mRM3m8zk9AWo631hehHDYOX4jPH78uHylPIZroqWQx+MpctsYc8Z9hSZOnKjx48cHbxcUFOjYsWNq1KhRidugYnJychQZGanMzEyFhYU5PQ5qIF6DcBqvwXPHGKPjx4+refPmpa7nmmhp3LixQkJCzjiqcuTIkTOOvhTyer3yer1F7mvYsOG5GhGSwsLC+MMKR/EahNN4DZ4bpR1hKeSaC3Hr1q2rTp06KSkpqcj9SUlJuuGGGxyaCgAAuIVrjrRI0vjx4zVs2DDFxsYqLi5O8+bNU0ZGhkaPHu30aAAAwGGuipbBgwfr6NGjmjZtmg4ePKi2bdtq1apVioqKcnq0Gs/r9Wrq1KlnnI4DqguvQTiN16DzPOZsny8CAABwAddc0wIAAFAaogUAAFiBaAEAAFYgWgAAgBWIlvOcx+MpdRkxYkS59/nuu+/qlltuUZMmTRQWFqa4uDh9+OGHRdbZunWr7rrrLkVHR8vj8WjWrFlV84TgmISEBHXu3FmhoaFq2rSpBg4cqO3btxdZ591339Wtt96qxo0by+PxaPPmzRV+vBEjRpz19Vte6enpGjlypGJiYlS/fn1deumlmjp1qn755Zdi1z969KgiIiLk8XiUnZ1d4ecCZzn1PniqxMREeTweDRw4sOJPBETL+e7gwYPBZdasWQoLCyty3+zZs8u0n4yMjOCv169fr1tuuUWrVq3SV199pV69eun2229XWlpacJ2ffvpJrVq10syZM3XJJZdU+fNC9UtOTtaYMWOUkpKipKQknTx5Un369FFubm5wndzcXHXt2lUzZ86s8OMUvtZmz55d5LUqSQsXLjzjvrP58ccfdeLECUnStm3bVFBQoFdeeUVbt27Viy++qH/961+aNGlSsduOHDlS7du3r/BzgTuU9X3w1Pe5synL+2Chffv2acKECerWrVuVPacay6DGWLhwofH5fGVe/8iRI2bWrFmmY8eO5pprril13auuuso88cQTxf4sKirKvPjii+WYFDY4cuSIkWSSk5PP+NnevXuNJJOWllamffn9fvPaa6+Zbt26mYsuuqjYdSSZ5cuXl2l/v/76q1mxYoW55557jNfrNZs3by5x3WeeecbExMSccf+cOXNMjx49zMcff2wkmR9//LFMjw13K+19MDo62nTp0sXMmTPHHDt2rNz7Lu598OTJk6Zr167mtddeM/Hx8WbAgAEVmBqFONKCIn755RctX75cAwcOVIsWLbRgwQINHTpUq1atKnGbgoICHT9+XOHh4dU4KZzm9/slqcL/3QsKCpSUlKQ//OEPuuSSSzRz5kzddNNN2rhxY4Vn2rJliyZMmKCIiAgNHz5cjRo10qeffqoOHTqUuI3f7z/jOXz77beaNm2aFi9erFq1eJusKdavX6877rhD//jHP9SsWTMNGjRIK1eu1MmTJ8+6bUnvg9OmTVOTJk00cuTIczV2jeKqb8SFczZt2qRFixZpyZIlqlu3roYMGaKNGzeW6dD4888/r9zcXA0aNKgaJoUbGGM0fvx43XjjjWrbtm25tt2xY4cWLVqkN954I/i6SUpKUteuXSs0y9GjR/Xmm29q0aJF2rp1q/r27as5c+aof//+qlu3bqnb7t69Wy+99JKef/754H2BQEBDhgzRs88+q5YtW2rPnj0Vmgv2iYyM1KRJkzRp0iSlpqZq8eLFGjFihGrXrq2hQ4dqxIgRJb7ei3sf3LBhg+bPn1+pa7twGqcP9aD6lHZYNCoqyoSEhJjHH3/cnDx5ssz7XLJkiWnQoIFJSkoqcR1OD51//vznP5uoqCiTmZlZ7M9LOz3Uo0cPI8mMHj3a/PTTT2V+TJVwemjq1KlGkunWrZvJyMgo8/6ysrJM69atzciRI4vcP27cODN48ODg7U8//ZTTQ+eR8p4mDwQCZvz48cbj8ZgOHToUu05x74M5OTkmOjrarFq1Kngfp4cqj2ipQUr7w7p+/XozYsQIc+GFF5o2bdqYadOmmT179pS6v8TERFO/fn2zYsWKUtcjWs4vDz30kImIiCj19VFatKSlpZmHHnrINGrUyERERJhHH33UfPPNN2d93JKiJSsry0yfPt20adPGXHjhhSY+Pt6sXbvW5Ofnl7ivrKwsc9lll5lhw4adsV6HDh1MrVq1TEhIiAkJCTG1atUykkxISIiZMmXKWeeEu5U1WrZt22YmT55soqKiTMOGDc2oUaPMF198ccZ6Jb0PpqWlBV83hYvH4zEej8eEhISYXbt2VdVTqlGIlhqkLH9YT5w4YV5//XXTu3dvExISYrp162bmzZt3xv9lLlmyxNSrV69MF0YSLeeHgoICM2bMGNO8eXOzY8eOUtcty4W4gUDAvPPOO+aOO+4wderUMR07djQvvPCCOXjwYLHrlxQtp9qwYYMZNWqU8fl8JQbR/v37TZs2bcy9995b7FHFXbt2mS1btgSXBQsWGEnm888/N4cPHy718eF+pb0Pfv/99+all14y1113nQkJCTG33XabWbp0qcnLyyt2/dLeB/Py8oq8jrZs2WIGDBhgevfubbZs2WICgUAVPquag2ipQcp7WHTfvn3mySefNG3atDHXXntt8P4lS5aY2rVrm3/+85/m4MGDwSU7Ozu4TiAQMGlpaSYtLc00a9bMTJgwwaSlpZmdO3dW5VNCNXrwwQeNz+cz69atK/Lf/dRTPEePHjVpaWlm5cqVRpJJTEw0aWlpJYZIoSNHjpgXX3zRXHPNNSY8PLzYdcoSLYXy8vLM0qVLzW233WZCQkLM119/bYz5/1NCvXv3Nvv37y/yPErC6aHzS2nvg61atTJXXXWVefrpp82BAwdK3U9Z3gdPx+mhyiNaapDyRsupvvvuu+CvC69JOH2Jj48PrlP4f9qnLz169Kjck4BjivvvKcksXLgwuM7ChQuLXWfq1KllfpxTX2unP35Zo+VUWVlZxu/3lzpfaZf3ES3nl9LeB0t67RWnLO+DpyNaKs9jjDFVfnUvAABAFeMLCAAAgBWIFgAAYAWiBQAAWIFoAQAAViBaAACAFYgWAABgBaIFAABYgWgBAABWIFoAAIAViBYAAGAFogUAAFiBaAEAAFYgWgAAgBWIFgAAYAWiBQAAWIFoAQAAViBaAFSbJUuWaNasWZXax5w5c7Ro0aIqmQeAXTzGGOP0EABqhv79++ubb75Renp6hffRtm1bNW7cWOvWrauyuQDYgSMtAADACkQLgCrz/fffa9SoUYqMjJTX61WTJk3UtWtXrV27Vj179tTKlSu1b98+eTye4FLoiSeeUJcuXRQeHq6wsDBde+21mj9/vk49GBwdHa2tW7cqOTk5uH10dHTw5zk5OZowYYJiYmJUt25dtWjRQmPHjlVubm6ROf/zn/+oS5cu8vl8atCggVq1aqX777//nP/+AKic2k4PAOD8MWzYMG3atElPPfWULrvsMmVnZ2vTpk06evSo5syZo1GjRmn37t1avnz5Gdump6frT3/6k1q2bClJSklJ0cMPP6ysrCxNmTJFkrR8+XLdfffd8vl8mjNnjiTJ6/VKkn766Sf16NFD+/fv16RJk9S+fXtt3bpVU6ZM0ZYtW7R27Vp5PB7973//0+DBgzV48GA9/vjjqlevnvbt26dPPvmkmn6XAFSYAYAqcuGFF5qxY8eW+PN+/fqZqKios+4nPz/f/Prrr2batGmmUaNGpqCgIPizq6++2vTo0eOMbRISEkytWrVMampqkfvffvttI8msWrXKGGPMc889ZySZ7Ozssj0pAK7B6SEAVea6667TokWLNH36dKWkpOjXX38t87affPKJbr75Zvl8PoWEhKhOnTqaMmWKjh49qiNHjpx1+xUrVqht27a65pprdPLkyeBy6623yuPxBC/c7dy5syRp0KBBeuutt5SVlVWh5wqg+hEtAKrMsmXLFB8fr9dee01xcXEKDw/X8OHDdejQoVK3+/LLL9WnTx9J0quvvqoNGzYoNTVVkydPliTl5eWd9bEPHz6sr7/+WnXq1CmyhIaGyhijH374QZLUvXt3vffeezp58qSGDx+uiIgItW3bVkuXLq3kswdwrnFNC4Aq07hxY82aNUuzZs1SRkaG3n//fT322GM6cuSI1qxZU+J2iYmJqlOnjlasWKF69eoF73/vvffK9dj169fXggULSvx5oQEDBmjAgAEKBAJKSUlRQkKC7rvvPkVHRysuLq7MjwmgehEtAM6Jli1b6qGHHtLHH3+sDRs2SPrtotnijpp4PB7Vrl1bISEhwfvy8vL0xhtvnLFuSfvo37+/ZsyYoUaNGikmJqZMM3q9XvXo0UMNGzbUhx9+qLS0NKIFcDGiBUCV8Pv96tWrl+677z5dccUVCg0NVWpqqtasWaM777xTktSuXTu9++67mjt3rjp16qRatWopNjZW/fr10wsvvKD77rtPo0aN0tGjR/Xcc88FPxl0qnbt2ikxMVHLli1Tq1atVK9ePbVr105jx47VO++8o+7du2vcuHFq3769CgoKlJGRoY8++kh//etf1aVLF02ZMkX79+/XTTfdpIiICGVnZ2v27NmqU6eOevToUd2/bQDKw+krgQGcH37++WczevRo0759exMWFmbq169vLr/8cjN16lSTm5trjDHm2LFj5u677zYNGzY0Ho/HnPoWtGDBAnP55Zcbr9drWrVqZRISEsz8+fONJLN3797geunp6aZPnz4mNDTUSCryaaQTJ06Yv/3tb+byyy83devWNT6fz7Rr186MGzfOHDp0yBhjzIoVK0zfvn1NixYtTN26dU3Tpk3N7373O/PZZ59Vy+8TgIrja/wBAIAV+PQQAACwAtECAACsQLQAAAArEC0AAMAKRAsAALAC0QIAAKxAtAAAACsQLQAAwApECwAAsALRAgAArEC0AAAAKxAtAADACv8H8nWGeoO4UPsAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -2631,7 +2631,7 @@ "text": [ "-------------------------------------------------------------------\n", "State [Bin #] = 1\n", - "Action [ - ] = 1\n", + "Action [ - ] = 0\n", "-------------------------------------------------------------------\n" ] } @@ -2694,15 +2694,15 @@ { "data": { "text/plain": [ - "{'tdis_tot': 0.08092250218334793,\n", + "{'tdis_tot': 1.741814571742692,\n", " 'idis_tot': 0,\n", - " 'ener_tot': 0.3449562854330366,\n", - " 'cost_tot': 0.08744641835727476,\n", - " 'emis_tot': 0.05760769966731713,\n", - " 'pele_tot': 0.02087948857312455,\n", + " 'ener_tot': 0.17501251008682203,\n", + " 'cost_tot': 0.0443656713070094,\n", + " 'emis_tot': 0.02922708918449929,\n", + " 'pele_tot': 0.019907644464042158,\n", " 'pgas_tot': None,\n", " 'pdih_tot': None,\n", - " 'time_rat': 0.000427389072911175}" + " 'time_rat': 0.0004623759253589427}" ] }, "execution_count": 24, @@ -2782,14 +2782,6 @@ "outputId": "d3fdf2ca-64d5-4e1d-ac9f-b999c7a3ff09" }, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/javier/miniconda3/envs/boptestgym/lib/python3.9/site-packages/torch/cuda/__init__.py:107: UserWarning: CUDA initialization: The NVIDIA driver on your system is too old (found version 9000). 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 ../c10/cuda/CUDAFunctions.cpp:109.)\n", - " return torch._C._cuda_getDeviceCount() > 0\n" - ] - }, { "name": "stdout", "output_type": "stream", @@ -2802,15 +2794,15 @@ { "data": { "text/plain": [ - "{'tdis_tot': 8.37342768290697,\n", + "{'tdis_tot': 8.370831530559261,\n", " 'idis_tot': 0,\n", - " 'ener_tot': 0.3965270991185415,\n", - " 'cost_tot': 0.10051961962655029,\n", - " 'emis_tot': 0.06622002555279644,\n", - " 'pele_tot': 0.02104161873770755,\n", + " 'ener_tot': 0.3965284452967778,\n", + " 'cost_tot': 0.1005199608827332,\n", + " 'emis_tot': 0.06622025036456192,\n", + " 'pele_tot': 0.021041628867335238,\n", " 'pgas_tot': None,\n", " 'pdih_tot': None,\n", - " 'time_rat': 0.0009521376286391858}" + " 'time_rat': 0.0010388354819130016}" ] }, "execution_count": 45, From e3ce2783bf9aafeea5bc614347070c4f99ec38c2 Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Fri, 10 May 2024 16:03:41 +0200 Subject: [PATCH 34/41] Pin base image to linux/amd64 platform. --- testing/Dockerfile | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/testing/Dockerfile b/testing/Dockerfile index e4ad354..95aff34 100644 --- a/testing/Dockerfile +++ b/testing/Dockerfile @@ -1,5 +1,5 @@ # Start with a base Ubuntu image -FROM ubuntu:20.04 +FROM --platform=linux/x86_64 ubuntu:20.04 # This is the Focal Fossa ubuntu version MAINTAINER Javier Arroyo @@ -30,7 +30,8 @@ RUN pip install \ gym \ shimmy \ ipykernel==6.25.1 \ - PyYAML + PyYAML \ + pytest # Add developer user with permissions in the working directory RUN useradd -ms /bin/bash developer From de9e07ac7848daa5c1c464ab4260829d196196d7 Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Fri, 10 May 2024 16:06:01 +0200 Subject: [PATCH 35/41] Reword boptest_root_dir to yaml_target_dir --- generateDockerComposeYml.py | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/generateDockerComposeYml.py b/generateDockerComposeYml.py index 02bdef4..1421ce7 100644 --- a/generateDockerComposeYml.py +++ b/generateDockerComposeYml.py @@ -5,13 +5,15 @@ import sys -boptest_root = "./" # You can define boptest_root_dir here when use IDLE -# Get the argument from command line when use Linux if len(sys.argv) >= 2: - boptest_root_dir = sys.argv[1] + # Check if there is an argument when calling the script defining the yaml target directory + # This is just convenient for dropping the generated script directly in the BOPTEST root directory, + # but if not provided it can be manually moved once it's generated + yaml_target_dir = sys.argv[1] else: - boptest_root_dir = boptest_root + # Otherwise use parent directory as default + yaml_target_dir = os.path.dirname(os.path.abspath(__file__)) num_services = 2 # Total Services needed base_port = 5000 # Start Port number @@ -69,10 +71,10 @@ def is_port_available(port): } # Check whether the docker-compose.yml file exists in the BOPTEST root directory -docker_compose_path = os.path.join(boptest_root_dir, 'docker-compose.yml') +docker_compose_path = os.path.join(yaml_target_dir, 'docker-compose.yml') if os.path.exists(docker_compose_path): # If it exists, rename to docker-compose_origin.yml - shutil.move(docker_compose_path, os.path.join(boptest_root_dir, 'docker-compose_origin.yml')) + shutil.move(docker_compose_path, os.path.join(yaml_target_dir, 'docker-compose_origin.yml')) # Create a new docker-compose.yml file in the BOPTEST root directory with open(docker_compose_path, "w") as file: From a469e889854e6d44a5ab5a7641a9a7c074c02fa5 Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Fri, 10 May 2024 16:11:54 +0200 Subject: [PATCH 36/41] Update reference results for new numerical differences. --- testing/references/tutorial_output_kpis_DQN_alg.json | 2 +- testing/references/tutorial_output_kpis_Q_alg.json | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/testing/references/tutorial_output_kpis_DQN_alg.json b/testing/references/tutorial_output_kpis_DQN_alg.json index 4ab4bc9..806f735 100644 --- a/testing/references/tutorial_output_kpis_DQN_alg.json +++ b/testing/references/tutorial_output_kpis_DQN_alg.json @@ -1 +1 @@ -{"tdis_tot": 8.37342768290697, "idis_tot": 0, "ener_tot": 0.3965270991185415, "cost_tot": 0.10051961962655029, "emis_tot": 0.06622002555279644, "pele_tot": 0.02104161873770755, "pgas_tot": null, "pdih_tot": null} \ No newline at end of file +{"tdis_tot": 8.370831530559261, "idis_tot": 0, "ener_tot": 0.3965284452967778, "cost_tot": 0.1005199608827332, "emis_tot": 0.06622025036456192, "pele_tot": 0.021041628867335238, "pgas_tot": null, "pdih_tot": null} \ No newline at end of file diff --git a/testing/references/tutorial_output_kpis_Q_alg.json b/testing/references/tutorial_output_kpis_Q_alg.json index 403dc1d..d5178c4 100644 --- a/testing/references/tutorial_output_kpis_Q_alg.json +++ b/testing/references/tutorial_output_kpis_Q_alg.json @@ -1 +1 @@ -{"tdis_tot": 0.08092250218334793, "idis_tot": 0, "ener_tot": 0.3449562854330366, "cost_tot": 0.08744641835727476, "emis_tot": 0.05760769966731713, "pele_tot": 0.02087948857312455, "pgas_tot": null, "pdih_tot": null} \ No newline at end of file +{"tdis_tot": 1.741814571742692, "idis_tot": 0, "ener_tot": 0.17501251008682203, "cost_tot": 0.0443656713070094, "emis_tot": 0.02922708918449929, "pele_tot": 0.019907644464042158, "pgas_tot": null, "pdih_tot": null} \ No newline at end of file From ec61ab441c858df95ad521b3cc7cbd87c511c75f Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Fri, 10 May 2024 16:20:25 +0200 Subject: [PATCH 37/41] Update boptest commit to point to v0.6.0 --- testing/Makefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/testing/Makefile b/testing/Makefile index 09ed149..a5dd401 100644 --- a/testing/Makefile +++ b/testing/Makefile @@ -10,7 +10,7 @@ IMG_HOME=/home/developer/boptestgym IMG_REGI=javierarroyo/boptestgym # BOPTEST commit used for the tests -BOPTEST_COMMIT=12ceafe42983d42e535385dee1daa1d25673e2aa +BOPTEST_COMMIT=78665506a620fc07bc2a8f301661aef3dd6c88c2 # Define current BOPTEST-Gym version (should be even with BOPTEST version defined in commit above) VERSION = 0.5.0-dev From 1adf060bb35e6ea9a04beecb1948c587fbbfe212 Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Fri, 10 May 2024 16:21:11 +0200 Subject: [PATCH 38/41] Update version tag. --- README.md | 2 +- testing/Makefile | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 25da481..f2d2c01 100644 --- a/README.md +++ b/README.md @@ -94,7 +94,7 @@ python generateDockerComposeYml.py absolute_boptest_root_dir ## Versioning and main dependencies -Current BOPTEST-Gym version is `v0.5.0` which is compatible with BOPTEST `v0.5.0` +Current BOPTEST-Gym version is `v0.6.0` which is compatible with BOPTEST `v0.6.0` (BOPTEST-Gym version should always be even with the BOPTEST version used). The framework has been tested with `gymnasium==0.28.1` and `stable-baselines3==2.0.0`. You can see [testing/Dockerfile](testing/Dockerfile) for a full description of the testing environment. diff --git a/testing/Makefile b/testing/Makefile index a5dd401..35b65fb 100644 --- a/testing/Makefile +++ b/testing/Makefile @@ -13,7 +13,7 @@ IMG_REGI=javierarroyo/boptestgym BOPTEST_COMMIT=78665506a620fc07bc2a8f301661aef3dd6c88c2 # Define current BOPTEST-Gym version (should be even with BOPTEST version defined in commit above) -VERSION = 0.5.0-dev +VERSION = 0.6.0 build-boptestgym: docker build -f ${ROOT}/testing/Dockerfile \ From f6d7a4272048fd4722f4b37dfe97dd8d82041353 Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Fri, 10 May 2024 16:21:22 +0200 Subject: [PATCH 39/41] Update releasenotes. --- releasenotes.md | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/releasenotes.md b/releasenotes.md index ee738ff..9c696a0 100644 --- a/releasenotes.md +++ b/releasenotes.md @@ -2,10 +2,12 @@ BOPTEST-Gym has two main dependencies: BOPTEST and Stable-Baselines3. For simplicity, the first two digits of the version number match the same two digits of the BOPTEST version of which BOPTEST-Gym is compatible with. For example, BOPTEST-Gym v0.3.x is compatible with BOPTEST v0.3.x. The last digit is reserved for other internal edits specific to this repository only. See [here](https://github.com/ibpsa/project1-boptest/blob/master/releasenotes.md) for BOPTEST release notes. -## BOPTEST-Gym v0.5.0-dev +## BOPTEST-Gym v0.6.0 -Released on xx/xx/xxxx. +Released on 10/05/2024. +- Update CCAI tutorial for numeric results with new Python v3.10. +- Pin Dockerfile image to linux/x86_64. - Implement functionality and example with vectorized environment for parallel learning. This is for [#133](https://github.com/ibpsa/project1-boptest-gym/issues/133). ## BOPTEST-Gym v0.5.0 From d7bc3570e0aab1a40800ff9fa54c724abe83788c Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Fri, 10 May 2024 16:54:51 +0200 Subject: [PATCH 40/41] Add missing context to build without cache command. --- testing/Makefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/testing/Makefile b/testing/Makefile index 35b65fb..f1ff5ba 100644 --- a/testing/Makefile +++ b/testing/Makefile @@ -21,7 +21,7 @@ build-boptestgym: build-boptestgym-no-cache: docker build -f ${ROOT}/testing/Dockerfile \ - --progress=plain --no-cache --rm -t ${IMG_NAME} + --progress=plain --no-cache --rm -t ${IMG_NAME} . run-boptestgym: docker run \ From 3ca1cee83740ecaa0964e30bd78505ae97702823 Mon Sep 17 00:00:00 2001 From: Javier Arroyo Date: Fri, 10 May 2024 16:55:56 +0200 Subject: [PATCH 41/41] Take parent dir as default in vectorized environment test. --- testing/test_boptestGymEnv.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/testing/test_boptestGymEnv.py b/testing/test_boptestGymEnv.py index f10d2dd..bfed024 100644 --- a/testing/test_boptestGymEnv.py +++ b/testing/test_boptestGymEnv.py @@ -435,7 +435,8 @@ def setUp(self): the terminal when invoking this test. ''' - boptest_root = "./" + # Take parent directory as default + boptest_root = os.path.dirname(os.path.abspath(__file__)) # Get the argument from command line when use Linux if len(sys.argv) >= 2: