From 654ee784f158923b3245f80a13e3c33cf37c6c46 Mon Sep 17 00:00:00 2001 From: Felipe Montealegre-Mora Date: Wed, 28 Feb 2024 22:29:34 +0000 Subject: [PATCH 01/13] added simulatenous train script, hyperpar docs --- hyperpars/{ppo-caribou-v0-1.yml => ppo-caribou.yml} | 2 +- hyperpars/rppo-caribou.yml | 12 ++++++++++++ hyperpars/td3-caribou.yml | 10 ++++++++++ hyperpars/{tqc-caribou-v0-1.yml => tqc-caribou.yml} | 0 scripts/train_algos.sh | 10 ++++++++++ 5 files changed, 33 insertions(+), 1 deletion(-) rename hyperpars/{ppo-caribou-v0-1.yml => ppo-caribou.yml} (100%) create mode 100644 hyperpars/rppo-caribou.yml create mode 100644 hyperpars/td3-caribou.yml rename hyperpars/{tqc-caribou-v0-1.yml => tqc-caribou.yml} (100%) create mode 100644 scripts/train_algos.sh diff --git a/hyperpars/ppo-caribou-v0-1.yml b/hyperpars/ppo-caribou.yml similarity index 100% rename from hyperpars/ppo-caribou-v0-1.yml rename to hyperpars/ppo-caribou.yml index 0f13a68..c1307b4 100644 --- a/hyperpars/ppo-caribou-v0-1.yml +++ b/hyperpars/ppo-caribou.yml @@ -2,10 +2,10 @@ algo: "PPO" env_id: "Caribou-v0" +config: {} n_envs: 12 tensorboard: "/home/rstudio/logs" total_timesteps: 6000000 -config: {} use_sde: True id: "1" repo: "cboettig/rl-ecology" diff --git a/hyperpars/rppo-caribou.yml b/hyperpars/rppo-caribou.yml new file mode 100644 index 0000000..96f2e6e --- /dev/null +++ b/hyperpars/rppo-caribou.yml @@ -0,0 +1,12 @@ +# stable-baselines3 configuration template. + +algo: "RPPO" +env_id: "Caribou-v0" +n_envs: 12 +tensorboard: "/home/rstudio/logs" +total_timesteps: 1000000 +config: {} +use_sde: True +id: "1" +repo: "cboettig/rl-ecology" +save_path: "/home/rstudio/rl4greencrab/saved_agents" diff --git a/hyperpars/td3-caribou.yml b/hyperpars/td3-caribou.yml new file mode 100644 index 0000000..18767e1 --- /dev/null +++ b/hyperpars/td3-caribou.yml @@ -0,0 +1,10 @@ +# stable-baselines3 configuration + +algo: "TD3" +env_id: "Caribou-v0" +config: {} +tensorboard: "/home/rstudio/logs" +total_timesteps: 6000000 +use_sde: True +id: "1" +repo: "cboettig/rl-ecology" diff --git a/hyperpars/tqc-caribou-v0-1.yml b/hyperpars/tqc-caribou.yml similarity index 100% rename from hyperpars/tqc-caribou-v0-1.yml rename to hyperpars/tqc-caribou.yml diff --git a/scripts/train_algos.sh b/scripts/train_algos.sh new file mode 100644 index 0000000..68c3efc --- /dev/null +++ b/scripts/train_algos.sh @@ -0,0 +1,10 @@ +#!/bin/bash + +# move to script directory for normalized relative paths. +scriptdir="$(dirname "$0")" +cd "$scriptdir" + +python train.py -f ../hyperpars/ppo-caribou & +python train.py -f ../hyperpars/rppo-caribou & +python train.py -f ../hyperpars/tqc-caribou & +python train.py -f ../hyperpars/td3-caribou & From f1a5f21bb949310ea20b1951b313476c5a4e7977 Mon Sep 17 00:00:00 2001 From: Felipe Montealegre-Mora Date: Fri, 1 Mar 2024 07:23:29 +0000 Subject: [PATCH 02/13] new yamls --- hyperpars/ppo-caribou.yml | 5 +++-- hyperpars/rppo-caribou.yml | 5 +++-- hyperpars/td3-caribou.yml | 6 +++--- hyperpars/tqc-caribou.yml | 5 +++-- 4 files changed, 12 insertions(+), 9 deletions(-) diff --git a/hyperpars/ppo-caribou.yml b/hyperpars/ppo-caribou.yml index c1307b4..08dde5e 100644 --- a/hyperpars/ppo-caribou.yml +++ b/hyperpars/ppo-caribou.yml @@ -1,11 +1,12 @@ # stable-baselines3 configuration algo: "PPO" -env_id: "Caribou-v0" +env_id: "CaribouScipy" config: {} n_envs: 12 tensorboard: "/home/rstudio/logs" -total_timesteps: 6000000 +total_timesteps: 1000000 use_sde: True id: "1" repo: "cboettig/rl-ecology" +save_path: "/home/rstudio/rl4caribou/saved_agents" \ No newline at end of file diff --git a/hyperpars/rppo-caribou.yml b/hyperpars/rppo-caribou.yml index 96f2e6e..6537b52 100644 --- a/hyperpars/rppo-caribou.yml +++ b/hyperpars/rppo-caribou.yml @@ -1,7 +1,8 @@ # stable-baselines3 configuration template. algo: "RPPO" -env_id: "Caribou-v0" +policyType: "MlpLstmPolicy" +env_id: "CaribouScipy" n_envs: 12 tensorboard: "/home/rstudio/logs" total_timesteps: 1000000 @@ -9,4 +10,4 @@ config: {} use_sde: True id: "1" repo: "cboettig/rl-ecology" -save_path: "/home/rstudio/rl4greencrab/saved_agents" +save_path: "/home/rstudio/rl4caribou/saved_agents" diff --git a/hyperpars/td3-caribou.yml b/hyperpars/td3-caribou.yml index 18767e1..537e527 100644 --- a/hyperpars/td3-caribou.yml +++ b/hyperpars/td3-caribou.yml @@ -1,10 +1,10 @@ # stable-baselines3 configuration algo: "TD3" -env_id: "Caribou-v0" +env_id: "CaribouScipy" config: {} tensorboard: "/home/rstudio/logs" -total_timesteps: 6000000 -use_sde: True +total_timesteps: 1000000 id: "1" repo: "cboettig/rl-ecology" +save_path: "/home/rstudio/rl4caribou/saved_agents" \ No newline at end of file diff --git a/hyperpars/tqc-caribou.yml b/hyperpars/tqc-caribou.yml index dba7db2..1371557 100644 --- a/hyperpars/tqc-caribou.yml +++ b/hyperpars/tqc-caribou.yml @@ -1,11 +1,12 @@ # stable-baselines3 configuration algo: "TQC" -env_id: "Caribou-v0" +env_id: "CaribouScipy" n_envs: 12 tensorboard: "/home/rstudio/logs" -total_timesteps: 6000000 +total_timesteps: 1000000 config: {} use_sde: True id: "1" repo: "cboettig/rl-ecology" +save_path: "/home/rstudio/rl4caribou/saved_agents" \ No newline at end of file From c925460296d56d030f750e643fdcc23b60d68f90 Mon Sep 17 00:00:00 2001 From: Felipe Montealegre-Mora Date: Fri, 1 Mar 2024 07:23:54 +0000 Subject: [PATCH 03/13] train scripts --- scripts/train.py | 3 ++- scripts/train_algos.sh | 8 ++++---- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/scripts/train.py b/scripts/train.py index 18393a5..cad37b3 100644 --- a/scripts/train.py +++ b/scripts/train.py @@ -2,6 +2,7 @@ import argparse parser = argparse.ArgumentParser() parser.add_argument("-f", "--file", help="Path config file", type=str) +parser.add_argument("-pb", "--progress_bar", help="Use progress bar for training", type=bool) args = parser.parse_args() import rl4caribou @@ -9,7 +10,7 @@ # training # from rl4caribou.utils import sb3_train -model_save_id, train_options = sb3_train(args.file) +model_save_id, train_options = sb3_train(args.file, progress_bar=args.progress_bar) # hugging face # diff --git a/scripts/train_algos.sh b/scripts/train_algos.sh index 68c3efc..d5d358d 100644 --- a/scripts/train_algos.sh +++ b/scripts/train_algos.sh @@ -4,7 +4,7 @@ scriptdir="$(dirname "$0")" cd "$scriptdir" -python train.py -f ../hyperpars/ppo-caribou & -python train.py -f ../hyperpars/rppo-caribou & -python train.py -f ../hyperpars/tqc-caribou & -python train.py -f ../hyperpars/td3-caribou & +python train.py -f ../hyperpars/ppo-caribou.yml & +python train.py -f ../hyperpars/rppo-caribou.yml & +python train.py -f ../hyperpars/tqc-caribou.yml & +python train.py -f ../hyperpars/td3-caribou.yml & From aff466da90dfbb1bc6ef11beaec5e0e2f35cd643 Mon Sep 17 00:00:00 2001 From: Felipe Montealegre-Mora Date: Fri, 1 Mar 2024 07:24:33 +0000 Subject: [PATCH 04/13] sb3 utils, registration --- src/rl4caribou/__init__.py | 4 ++++ src/rl4caribou/utils/__init__.py | 2 ++ src/rl4caribou/utils/sb3.py | 4 ++-- 3 files changed, 8 insertions(+), 2 deletions(-) diff --git a/src/rl4caribou/__init__.py b/src/rl4caribou/__init__.py index 2c51852..997ec98 100644 --- a/src/rl4caribou/__init__.py +++ b/src/rl4caribou/__init__.py @@ -1,3 +1,7 @@ from rl4caribou.envs.caribou import Caribou +from rl4caribou.envs.caribou_ode import CaribouScipy, CaribouNumba from gymnasium.envs.registration import register + register(id="Caribou-v0", entry_point="rl4caribou.envs.caribou:Caribou") +register(id="CaribouScipy", entry_point="rl4caribou.envs.caribou_ode:CaribouScipy") +register(id="CaribouNumba", entry_point="rl4caribou.envs.caribou_ode:CaribouNumba") diff --git a/src/rl4caribou/utils/__init__.py b/src/rl4caribou/utils/__init__.py index e69de29..045531f 100644 --- a/src/rl4caribou/utils/__init__.py +++ b/src/rl4caribou/utils/__init__.py @@ -0,0 +1,2 @@ +from rl4caribou.utils.hugging_face import upload_to_hf +from rl4caribou.utils.sb3 import sb3_train \ No newline at end of file diff --git a/src/rl4caribou/utils/sb3.py b/src/rl4caribou/utils/sb3.py index 12a572a..d29f385 100644 --- a/src/rl4caribou/utils/sb3.py +++ b/src/rl4caribou/utils/sb3.py @@ -54,11 +54,11 @@ def sb3_train(config_file, **kwargs): save_id = os.path.join(options["save_path"], model_id) model = ALGO( - "MlpPolicy", + options.get("policyType", "MlpPolicy"), env, verbose=0, tensorboard_log=options["tensorboard"], - use_sde=options["use_sde"], + **{opt: options[opt] for opt in options if opt in ['use_sde']}, # oof, something nicer soon? ) progress_bar = options.get("progress_bar", False) From bc2cea991a36f2d398a570b70106728b93b0a5cb Mon Sep 17 00:00:00 2001 From: Felipe Montealegre-Mora Date: Fri, 1 Mar 2024 19:35:07 +0000 Subject: [PATCH 05/13] added caribou_ode --- src/rl4caribou/envs/caribou_ode.py | 281 +++++++++++++++++++++++++++++ 1 file changed, 281 insertions(+) create mode 100644 src/rl4caribou/envs/caribou_ode.py diff --git a/src/rl4caribou/envs/caribou_ode.py b/src/rl4caribou/envs/caribou_ode.py new file mode 100644 index 0000000..b0f8f9b --- /dev/null +++ b/src/rl4caribou/envs/caribou_ode.py @@ -0,0 +1,281 @@ +import gymnasium as gym +import numpy as np +from scipy.integrate import odeint +# import nbkode + +def dynamics_scipy(pop, effort, p, timestep, singularities): + # + # parameters of the ODE are s.t. t is in years, so lets make the time-step a tenth of a year + # (this ad hoc rule gives better convergence than if we set dt = 1 full year) + t_interval = np.float32([timestep, timestep+1./12]) + y0 = pop + timestep_randomness = ( + np.float32( + [p['sigma_M'], p['sigma_B'], p['sigma_W']] + ) * + np.random.normal(size=3) + ) + return odeint(ode_func, y0, t_interval, args=(effort, p), tcrit=singularities)[1] + timestep_randomness + +def ode_func(y, t, effort, p): + M, B, W = y + denominator = (1 + B**p['x'] * p['h_B'] * p['a_B'] + M**p['x'] * p['h_M'] * p['a_M']) + return np.float32([ + M * ( + p['r_m'] * (1 - p['alpha_mm'] * M / p['K_m']) + - M**(p['x'] - 1) * W * p['a_M'] / denominator + - p['r_m'] * p['alpha_mb'] * B / p['K_m'] + - effort[0] + ), + # + B * ( + p['r_b'] * (1 - p['alpha_bb'] * B / p['K_b']) + - B**(p['x']-1) * W * p['a_B'] / denominator + - p['r_b'] * p['alpha_bm'] * M / p['K_b'] + ), + # + W * ( + B**p['x'] * p['a_B'] / denominator + + M**p['x'] * p['a_M'] * p['u'] / denominator + - p['d'] + - effort[1] + ), + ]) + + +## +## Param vals taken from https://doi.org/10.1016/j.ecolmodel.2019.108891 +## +am = {"current": 15.32, "full_rest": 11.00} +ab = {"current": 51.45, "full_rest": 26.39} + +parameters = { + "r_m": np.float32(0.39), + "r_b": np.float32(0.30), + # + "alpha_mm": np.float32(1), + "alpha_bb": np.float32(1), + "alpha_bm": np.float32(1), + "alpha_mb": np.float32(1), + # + "a_M": am["current"], + "a_B": ab["current"], + # + "K_m": np.float32(1.1), + "K_b": np.float32(0.40), + # + "h_M": np.float32(0.112), + "h_B": np.float32(0.112), + # + "x": np.float32(2), + "u": np.float32(1), + "d": np.float32(1), + # + "sigma_M": np.float32(0.1), + "sigma_B": np.float32(0.1), + "sigma_W": np.float32(0.1), +} +# +# computed using scipy's fsolve (coordinates where d Pops / dt = 0) +singularities = [ + np.array([1.1000000238415355, 0, 0]), + np.array([0.26788470722361574, 0.022792841445996415, 0.07873609043869849]), + np.array([0, 0.4000000059610799, 0]), + np.array([0, 0.14794518267150766, 0.027967723350836204]), + np.array([0.2711216103310206, 0, 0.0796758786194987]), + np.array([0, 0, 0]), +] + +# def numba_func(y,t,effort): +# global parameters +# return ode_func(y, t, effort, parameters) + +# def dynamics_numba(t, pop, effort): +# # +# y0 = pop +# solver = nbkode.ForwardEuler(numba_func, t, y0, params=effort) +# # +# t_interval = np.float32([t, t+1]) +# ts, ys = solver.run(t_interval) +# return ys[1] + + +## +## Harvest, utility +## +def harvest(pop, effort): + q0 = 0.5 # catchability coefficients -- erradication is impossible + q2 = 0.5 + pop[0] = pop[0] * (1 - effort[0] * q0) # pop 0, moose + pop[2] = pop[2] * (1 - effort[1] * q2) # pop 2, wolves + return pop + + +def utility(pop, effort): + benefits = 5 * pop[1] # benefit from Caribou + costs = 0.01 * (effort[0] + effort[1]) # cost to culling + if np.any(pop <= [0.03, 0.07, 1e-6]): + benefits -= 1 + return benefits - costs + +class CaribouScipy(gym.Env): + """A 3-species ecosystem model with two control actions""" + + def __init__(self, config=None): + config = config or {} + + ## these parameters may be specified in config + self.Tmax = config.get("Tmax", 800) + self.max_episode_steps = self.Tmax + self.threshold = config.get("threshold", np.float32(1e-4)) + self.init_sigma = config.get("init_sigma", np.float32(1e-3)) + self.training = config.get("training", True) + self.initial_pop = config.get("initial_pop", np.float32([0.3, 0.15, 0.05])) + self.parameters = config.get("parameters", parameters) + self.singularities = config.get("singularities", None) + self.dynamics = config.get("dynamics", dynamics_scipy) + self.harvest = config.get("harvest", harvest) + self.utility = config.get("utility", utility) + self.observe = config.get( + "observe", lambda state: state + ) # default to perfectly observed case + self.bound = 2 + + self.action_space = gym.spaces.Box( + np.array([-1, -1], dtype=np.float32), + np.array([1, 1], dtype=np.float32), + dtype=np.float32, + ) + self.observation_space = gym.spaces.Box( + np.array([-1, -1, -1], dtype=np.float32), + np.array([1, 1, 1], dtype=np.float32), + dtype=np.float32, + ) + self.reset(seed=config.get("seed", None)) + + def reset(self, *, seed=None, options=None): + self.timestep = 0 + self.true_initial_pop = self.initial_pop + np.multiply( + self.initial_pop, np.float32(self.init_sigma * np.random.normal(size=3)) + ) + self.state = self.state_units(self.true_initial_pop) + info = {} + return self.observe(self.state), info + + def step(self, action): + action = np.clip(action, self.action_space.low, self.action_space.high) + pop = self.population_units() # current state in natural units + effort = (action + 1.0) / 2 + + # harvest and recruitment + nextpop = self.dynamics( + pop, effort, self.parameters, self.timestep, singularities=self.singularities + ) + ## linear approx to rewards + reward = self.utility((pop+nextpop)/2., effort) + + self.timestep += 1 + truncated = bool(self.timestep > self.Tmax) or bool(any(nextpop < 1e-7)) + + self.state = self.state_units(nextpop) # transform into [-1, 1] space + observation = self.observe(self.state) # same as self.state + return observation, reward, False, truncated, {} + + def state_units(self, pop): + self.state = 2 * pop / self.bound - 1 + self.state = np.clip( + self.state, + np.repeat(-1, self.state.__len__()), + np.repeat(1, self.state.__len__()), + ) + return np.float32(self.state) + + def population_units(self): + pop = (self.state + 1) * self.bound / 2 + return np.clip( + pop, np.repeat(0, pop.__len__()), np.repeat(np.Inf, pop.__len__()) + ) + + + +# class CaribouNumba(gym.Env): +# """A 3-species ecosystem model with two control actions""" + +# def __init__(self, config=None): +# config = config or {} + +# ## these parameters may be specified in config +# self.Tmax = config.get("Tmax", 800) +# self.max_episode_steps = self.Tmax +# self.threshold = config.get("threshold", np.float32(1e-4)) +# self.init_sigma = config.get("init_sigma", np.float32(1e-3)) +# self.training = config.get("training", True) +# self.initial_pop = config.get("initial_pop", np.ones(3, dtype=np.float32)) +# self.parameters = config.get("parameters", parameters) +# self.dynamics = config.get("dynamics", dynamics_numba) +# self.harvest = config.get("harvest", harvest) +# self.utility = config.get("utility", utility) +# self.observe = config.get( +# "observe", lambda state: state +# ) # default to perfectly observed case +# self.bound = 2 + +# self.action_space = gym.spaces.Box( +# np.array([-1, -1], dtype=np.float32), +# np.array([1, 1], dtype=np.float32), +# dtype=np.float32, +# ) +# self.observation_space = gym.spaces.Box( +# np.array([-1, -1, -1], dtype=np.float32), +# np.array([1, 1, 1], dtype=np.float32), +# dtype=np.float32, +# ) +# self.reset(seed=config.get("seed", None)) + +# def reset(self, *, seed=None, options=None): +# self.timestep = 0 +# self.initial_pop += np.multiply( +# self.initial_pop, np.float32(self.init_sigma * np.random.normal(size=3)) +# ) +# self.state = self.state_units(self.initial_pop) +# info = {} +# return self.observe(self.state), info + +# def step(self, action): +# action = np.clip(action, self.action_space.low, self.action_space.high) +# pop = self.population_units() # current state in natural units +# effort = (action + 1.0) / 2 + +# # harvest and recruitment +# nextpop = self.dynamics( +# self.timestep, pop, effort +# ) +# ## linear approx to rewards +# reward = self.utility((pop+nextpop)/2., effort) + +# self.timestep += 1 +# terminated = bool(self.timestep > self.Tmax) + +# # in training mode only: punish for population collapse +# if any(pop <= self.threshold) and self.training: +# terminated = True +# reward -= 50 / self.timestepq + +# self.state = self.state_units(nextpop) # transform into [-1, 1] space +# observation = self.observe(self.state) # same as self.state +# return observation, reward, terminated, False, {} + +# def state_units(self, pop): +# self.state = 2 * pop / self.bound - 1 +# self.state = np.clip( +# self.state, +# np.repeat(-1, self.state.__len__()), +# np.repeat(1, self.state.__len__()), +# ) +# return np.float32(self.state) + +# def population_units(self): +# pop = (self.state + 1) * self.bound / 2 +# return np.clip( +# pop, np.repeat(0, pop.__len__()), np.repeat(np.Inf, pop.__len__()) +# ) \ No newline at end of file From 6a38e95de0de2d895a88d0556bff45d0bccb5336 Mon Sep 17 00:00:00 2001 From: Felipe Montealegre-Mora Date: Fri, 1 Mar 2024 19:35:47 +0000 Subject: [PATCH 06/13] sb3 util update, loose numba env registration --- src/rl4caribou/__init__.py | 3 +-- src/rl4caribou/utils/sb3.py | 4 +++- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/src/rl4caribou/__init__.py b/src/rl4caribou/__init__.py index 997ec98..c3b6690 100644 --- a/src/rl4caribou/__init__.py +++ b/src/rl4caribou/__init__.py @@ -1,7 +1,6 @@ from rl4caribou.envs.caribou import Caribou -from rl4caribou.envs.caribou_ode import CaribouScipy, CaribouNumba +from rl4caribou.envs.caribou_ode import CaribouScipy from gymnasium.envs.registration import register register(id="Caribou-v0", entry_point="rl4caribou.envs.caribou:Caribou") register(id="CaribouScipy", entry_point="rl4caribou.envs.caribou_ode:CaribouScipy") -register(id="CaribouNumba", entry_point="rl4caribou.envs.caribou_ode:CaribouNumba") diff --git a/src/rl4caribou/utils/sb3.py b/src/rl4caribou/utils/sb3.py index d29f385..67287f1 100644 --- a/src/rl4caribou/utils/sb3.py +++ b/src/rl4caribou/utils/sb3.py @@ -50,7 +50,9 @@ def sb3_train(config_file, **kwargs): else: env = gym.make(options["env_id"]) ALGO = algorithm(options["algo"]) - model_id = options["algo"] + "-" + options["env_id"] + "-" + options["id"] + if "id" in options: + options["id"] = "-" + options["id"] + model_id = options["algo"] + "-" + options["env_id"] + options.get("id", "") save_id = os.path.join(options["save_path"], model_id) model = ALGO( From 153c3adef23379a391df28a2ed23cd7fe4afdfde Mon Sep 17 00:00:00 2001 From: Felipe Montealegre-Mora Date: Fri, 1 Mar 2024 19:36:00 +0000 Subject: [PATCH 07/13] yaml updates --- hyperpars/ppo-caribou.yml | 5 ++--- hyperpars/tqc-caribou.yml | 5 ++--- 2 files changed, 4 insertions(+), 6 deletions(-) diff --git a/hyperpars/ppo-caribou.yml b/hyperpars/ppo-caribou.yml index 08dde5e..c1f8d79 100644 --- a/hyperpars/ppo-caribou.yml +++ b/hyperpars/ppo-caribou.yml @@ -3,10 +3,9 @@ algo: "PPO" env_id: "CaribouScipy" config: {} -n_envs: 12 +# n_envs: 12 tensorboard: "/home/rstudio/logs" -total_timesteps: 1000000 +total_timesteps: 500000 use_sde: True -id: "1" repo: "cboettig/rl-ecology" save_path: "/home/rstudio/rl4caribou/saved_agents" \ No newline at end of file diff --git a/hyperpars/tqc-caribou.yml b/hyperpars/tqc-caribou.yml index 1371557..51475cc 100644 --- a/hyperpars/tqc-caribou.yml +++ b/hyperpars/tqc-caribou.yml @@ -2,11 +2,10 @@ algo: "TQC" env_id: "CaribouScipy" -n_envs: 12 +# n_envs: 12 tensorboard: "/home/rstudio/logs" -total_timesteps: 1000000 +total_timesteps: 500000 config: {} use_sde: True -id: "1" repo: "cboettig/rl-ecology" save_path: "/home/rstudio/rl4caribou/saved_agents" \ No newline at end of file From 78231eb5ea23aecf03eb1f1f11f5ba001d4739c5 Mon Sep 17 00:00:00 2001 From: Felipe Montealegre-Mora Date: Fri, 1 Mar 2024 19:37:21 +0000 Subject: [PATCH 08/13] yaml update --- hyperpars/ppo-caribou.yml | 2 +- hyperpars/rppo-caribou.yml | 2 +- hyperpars/td3-caribou.yml | 2 +- hyperpars/tqc-caribou.yml | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/hyperpars/ppo-caribou.yml b/hyperpars/ppo-caribou.yml index c1f8d79..bd6cc43 100644 --- a/hyperpars/ppo-caribou.yml +++ b/hyperpars/ppo-caribou.yml @@ -3,7 +3,7 @@ algo: "PPO" env_id: "CaribouScipy" config: {} -# n_envs: 12 +n_envs: 12 tensorboard: "/home/rstudio/logs" total_timesteps: 500000 use_sde: True diff --git a/hyperpars/rppo-caribou.yml b/hyperpars/rppo-caribou.yml index 6537b52..6dfb284 100644 --- a/hyperpars/rppo-caribou.yml +++ b/hyperpars/rppo-caribou.yml @@ -5,7 +5,7 @@ policyType: "MlpLstmPolicy" env_id: "CaribouScipy" n_envs: 12 tensorboard: "/home/rstudio/logs" -total_timesteps: 1000000 +total_timesteps: 500000 config: {} use_sde: True id: "1" diff --git a/hyperpars/td3-caribou.yml b/hyperpars/td3-caribou.yml index 537e527..5e254f6 100644 --- a/hyperpars/td3-caribou.yml +++ b/hyperpars/td3-caribou.yml @@ -4,7 +4,7 @@ algo: "TD3" env_id: "CaribouScipy" config: {} tensorboard: "/home/rstudio/logs" -total_timesteps: 1000000 +total_timesteps: 500000 id: "1" repo: "cboettig/rl-ecology" save_path: "/home/rstudio/rl4caribou/saved_agents" \ No newline at end of file diff --git a/hyperpars/tqc-caribou.yml b/hyperpars/tqc-caribou.yml index 51475cc..3896d45 100644 --- a/hyperpars/tqc-caribou.yml +++ b/hyperpars/tqc-caribou.yml @@ -2,7 +2,7 @@ algo: "TQC" env_id: "CaribouScipy" -# n_envs: 12 +n_envs: 12 tensorboard: "/home/rstudio/logs" total_timesteps: 500000 config: {} From 41428ea397dcd4a116ec1662b924e242396678fe Mon Sep 17 00:00:00 2001 From: Felipe Montealegre-Mora Date: Sat, 2 Mar 2024 00:00:15 +0000 Subject: [PATCH 09/13] rebalanced utility function --- hyperpars/ppo-caribou.yml | 3 ++- hyperpars/tqc-caribou.yml | 3 ++- src/rl4caribou/envs/caribou_ode.py | 19 ++++++++++--------- 3 files changed, 14 insertions(+), 11 deletions(-) diff --git a/hyperpars/ppo-caribou.yml b/hyperpars/ppo-caribou.yml index bd6cc43..19aeb58 100644 --- a/hyperpars/ppo-caribou.yml +++ b/hyperpars/ppo-caribou.yml @@ -8,4 +8,5 @@ tensorboard: "/home/rstudio/logs" total_timesteps: 500000 use_sde: True repo: "cboettig/rl-ecology" -save_path: "/home/rstudio/rl4caribou/saved_agents" \ No newline at end of file +save_path: "/home/rstudio/rl4caribou/saved_agents" +id: "2" \ No newline at end of file diff --git a/hyperpars/tqc-caribou.yml b/hyperpars/tqc-caribou.yml index 3896d45..e6b5011 100644 --- a/hyperpars/tqc-caribou.yml +++ b/hyperpars/tqc-caribou.yml @@ -8,4 +8,5 @@ total_timesteps: 500000 config: {} use_sde: True repo: "cboettig/rl-ecology" -save_path: "/home/rstudio/rl4caribou/saved_agents" \ No newline at end of file +save_path: "/home/rstudio/rl4caribou/saved_agents" +id: "2" \ No newline at end of file diff --git a/src/rl4caribou/envs/caribou_ode.py b/src/rl4caribou/envs/caribou_ode.py index b0f8f9b..25e2fa3 100644 --- a/src/rl4caribou/envs/caribou_ode.py +++ b/src/rl4caribou/envs/caribou_ode.py @@ -7,7 +7,8 @@ def dynamics_scipy(pop, effort, p, timestep, singularities): # # parameters of the ODE are s.t. t is in years, so lets make the time-step a tenth of a year # (this ad hoc rule gives better convergence than if we set dt = 1 full year) - t_interval = np.float32([timestep, timestep+1./12]) + dt = 1./12 + t_interval = np.float32([timestep, timestep+dt]) y0 = pop timestep_randomness = ( np.float32( @@ -15,7 +16,7 @@ def dynamics_scipy(pop, effort, p, timestep, singularities): ) * np.random.normal(size=3) ) - return odeint(ode_func, y0, t_interval, args=(effort, p), tcrit=singularities)[1] + timestep_randomness + return odeint(ode_func, y0, t_interval, args=(effort, p), tcrit=singularities)[1] + timestep_randomness * dt def ode_func(y, t, effort, p): M, B, W = y @@ -71,9 +72,9 @@ def ode_func(y, t, effort, p): "u": np.float32(1), "d": np.float32(1), # - "sigma_M": np.float32(0.1), - "sigma_B": np.float32(0.1), - "sigma_W": np.float32(0.1), + "sigma_M": np.float32(0.05), + "sigma_B": np.float32(0.05), + "sigma_W": np.float32(0.05), } # # computed using scipy's fsolve (coordinates where d Pops / dt = 0) @@ -112,9 +113,9 @@ def harvest(pop, effort): def utility(pop, effort): - benefits = 5 * pop[1] # benefit from Caribou - costs = 0.01 * (effort[0] + effort[1]) # cost to culling - if np.any(pop <= [0.03, 0.07, 1e-6]): + benefits = 1 * pop[1] # benefit from Caribou + costs = 0.1 * (effort[0] + effort[1]) # cost to culling + if np.any(pop <= [0.03, 0.07, 1e-4]): benefits -= 1 return benefits - costs @@ -175,7 +176,7 @@ def step(self, action): reward = self.utility((pop+nextpop)/2., effort) self.timestep += 1 - truncated = bool(self.timestep > self.Tmax) or bool(any(nextpop < 1e-7)) + truncated = bool(self.timestep > self.Tmax) # or bool(any(nextpop < 1e-7)) self.state = self.state_units(nextpop) # transform into [-1, 1] space observation = self.observe(self.state) # same as self.state From b218a4c97282a3b225213159471a6fb2e7ad93b8 Mon Sep 17 00:00:00 2001 From: Felipe Montealegre-Mora Date: Sat, 2 Mar 2024 00:01:42 +0000 Subject: [PATCH 10/13] added a policy evaluation notebook (model parameters just locally saved atm) --- notebooks/policy-evaluation.ipynb | 548 ++++++++++++++++++++++++++++++ 1 file changed, 548 insertions(+) create mode 100644 notebooks/policy-evaluation.ipynb diff --git a/notebooks/policy-evaluation.ipynb b/notebooks/policy-evaluation.ipynb new file mode 100644 index 0000000..9f2fb6a --- /dev/null +++ b/notebooks/policy-evaluation.ipynb @@ -0,0 +1,548 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "c60c9c5f-aa62-48e5-9d5f-d52191dd7262", + "metadata": {}, + "outputs": [], + "source": [ + "from rl4caribou import Caribou, CaribouScipy\n", + "from rl4caribou.agents import constAction\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "from skopt import gp_minimize, gbrt_minimize\n", + "import ray" + ] + }, + { + "cell_type": "markdown", + "id": "3563a58c-adaa-4f56-88cb-f69d2c1b9f1f", + "metadata": {}, + "source": [ + "# Utility fns" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "21da352f-dd36-45c7-aac1-f8c5fcb3e187", + "metadata": {}, + "outputs": [], + "source": [ + "env = CaribouScipy()\n", + "\n", + "def ep_df(mortality_vec):\n", + " agent = constAction(mortality_vec=mortality_vec)\n", + " env = CaribouScipy()\n", + " env.initial_pop = [0.3, 0.15, 0.05]\n", + " obs, _ = env.reset()\n", + " observs = []\n", + " ep_rew = 0\n", + " for t in range(800):\n", + " action, info = agent.predict(obs)\n", + " observs.append([t, *(env.bound * (obs+1))/2])\n", + " obs, rew, term, trunc, info = env.step(action)\n", + " ep_rew += rew\n", + " if term or trunc:\n", + " break\n", + " \n", + " data = pd.DataFrame(observs, columns=['t', 'M', 'B', 'W'])\n", + " data['agent'] = str(pretty_vec(mortality_vec)) + f\": rew = {ep_rew:.2f}\"\n", + " return data\n", + "\n", + "def agent_ep_df(agent, agent_id=\"agent\"):\n", + " env = CaribouScipy()\n", + " env.initial_pop = [0.3, 0.15, 0.05]\n", + " obs, _ = env.reset()\n", + " observs = []\n", + " ep_rew = 0\n", + " for t in range(800):\n", + " action, info = agent.predict(obs)\n", + " observs.append([t, *(env.bound * (obs+1))/2, *(action + 1)/2])\n", + " obs, rew, term, trunc, info = env.step(action)\n", + " ep_rew += rew\n", + " if term or trunc:\n", + " break\n", + " \n", + " data = pd.DataFrame(observs, columns=['t', 'M', 'B', 'W', 'MCull', 'WCull'])\n", + " data['agent'] = agent_id + f\": rew = {ep_rew:.2f}\"\n", + " return data\n", + "\n", + "@ray.remote\n", + "def gen_ep_rew(manager, env):\n", + " episode_reward = 0.0\n", + " observation, _ = env.reset()\n", + " for t in range(env.Tmax):\n", + " action, _ = manager.predict(observation)\n", + " observation, reward, terminated, done, info = env.step(action)\n", + " episode_reward += reward\n", + " if terminated or done:\n", + " break\n", + " return episode_reward\n", + "\n", + "def gather_stats(manager, env, N=150):\n", + " results = ray.get([gen_ep_rew.remote(manager, env) for _ in range(N)])\n", + " y = np.mean(results)\n", + " sigma = np.std(results)\n", + " ymin = y - sigma\n", + " ymax = y + sigma\n", + " return y, ymin, ymax \n", + "\n", + "def gen_ep_rew_seq(manager, env):\n", + " episode_reward = 0.0\n", + " observation, _ = env.reset()\n", + " for t in range(env.Tmax):\n", + " action, _ = manager.predict(observation)\n", + " observation, reward, terminated, done, info = env.step(action)\n", + " episode_reward += reward\n", + " if terminated or done:\n", + " break\n", + " return episode_reward\n", + "\n", + "def gather_stats_seq(manager, env, N=100):\n", + " results = [gen_ep_rew_seq(manager, env) for _ in range(N)]\n", + " y = np.mean(results)\n", + " sigma = np.std(results)\n", + " ymin = y - sigma\n", + " ymax = y + sigma\n", + " return y, ymin, ymax \n", + "\n", + "def pretty_vec(vec):\n", + " return [eval(f'{el:.3f}') for el in vec]\n", + "\n", + "def g(x):\n", + " manager = constAction(mortality_vec=x)\n", + " out = gather_stats(manager, env)\n", + " print(f\"{pretty_vec(manager.mortality_vec)}, {out[0]:.3f}\", end=27*\" \"+\"\\r\")\n", + " return - out[0]" + ] + }, + { + "cell_type": "markdown", + "id": "dd184010-e5b4-418b-beee-fe033d8b5f4d", + "metadata": {}, + "source": [ + "# Optimal constant action" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "813b9ed8-af77-4e3c-9bf4-54eb8e13c947", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-03-01 23:46:59,972\tINFO worker.py:1724 -- Started a local Ray instance.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 6min 1s, sys: 35min 52s, total: 41min 54s\n", + "Wall time: 2min 22s\n" + ] + }, + { + "data": { + "text/plain": [ + "([0.2846977692414673, 0.0], -76.8689655118643)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%time\n", + "res = gp_minimize(g, [(0.0, 1.0), (0.0, 1.0)], n_calls = 100)\n", + "opt_mortality = res.x\n", + "\n", + "res.x, - res.fun # g was negative to begin with in order to use minimize method" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "d1ee3fcd-4595-44cb-9636-49d0498bedb5", + "metadata": {}, + "outputs": [], + "source": [ + "# -->([0.27950870095934127, 0.36956662640253096], -65.08941351454096)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "852f94a4-f3a1-4415-a527-627f49f2e525", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(-100.45752996936659, -209.49536603548933, 8.580306096756132)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gather_stats(manager=constAction(res.x), env=CaribouScipy())" + ] + }, + { + "cell_type": "markdown", + "id": "2160a376-3370-4be8-af7f-f1d496b87998", + "metadata": {}, + "source": [ + "# RL Agents" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "0fe5aa6e-14b2-4296-8cb9-7b06258d2ea2", + "metadata": {}, + "outputs": [], + "source": [ + "from stable_baselines3 import PPO\n", + "from sb3_contrib import TQC\n", + "\n", + "ppoAgent = PPO.load(\"../saved_agents/PPO-CaribouScipy-2.zip\")\n", + "tqcAgent = TQC.load(\"../saved_agents/TQC-CaribouScipy-2.zip\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "6a1c532b-65c7-429f-94b3-c3219c23bcc3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(-25.84146727008485, -86.69016972646938, 35.00723518629968)" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gather_stats_seq(manager=tqcAgent, env=CaribouScipy())" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "e2efc6c0-2697-4096-af7a-b6922020eefb", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(12.992667277262091, -24.196096418426436, 50.18143097295062)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gather_stats_seq(manager=ppoAgent, env=CaribouScipy())" + ] + }, + { + "cell_type": "markdown", + "id": "e80b7516-d3b9-4fb5-84d8-3e79f0bc345c", + "metadata": {}, + "source": [ + "# Comparison episode" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "25646dc3-36b1-47d3-9aaf-9aa3fb76265a", + "metadata": {}, + "outputs": [], + "source": [ + "ppo_df = agent_ep_df(agent=ppoAgent, agent_id=\"PPO\")\n", + "tqc_df = agent_ep_df(agent=tqcAgent, agent_id=\"TQC\")\n", + "cact_df = agent_ep_df(agent=constAction(opt_mortality), agent_id=\"ConstAct\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "5927e08d-bfba-4b38-aaa2-0eb456c8fc15", + "metadata": {}, + "outputs": [], + "source": [ + "# quick n dirty\n", + "\n", + "ppo_acts = ppo_df.copy()[['t', 'MCull', 'WCull', 'agent']]\n", + "tqc_acts = tqc_df.copy()[['t', 'MCull', 'WCull', 'agent']]\n", + "cact_acts = cact_df.copy()[['t', 'MCull', 'WCull', 'agent']]\n", + "\n", + "ppo_acts['data'] = 'action'\n", + "tqc_acts['data'] = 'action'\n", + "cact_acts['data'] = 'action'\n", + "\n", + "ppo_pops = ppo_df.copy()[['t', 'M', 'B', 'W', 'agent']]\n", + "tqc_pops = tqc_df.copy()[['t', 'M', 'B', 'W', 'agent']]\n", + "cact_pops = cact_df.copy()[['t', 'M', 'B', 'W', 'agent']]\n", + "\n", + "ppo_pops['data'] = 'population'\n", + "tqc_pops['data'] = 'population'\n", + "cact_pops['data'] = 'population'" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "bc96b4d1-109b-4751-82ea-fa00c89f52c4", + "metadata": {}, + "outputs": [], + "source": [ + "df = pd.concat([ppo_acts, tqc_acts, cact_acts, ppo_pops, tqc_pops, cact_pops], ignore_index=True).melt(id_vars = ['t', 'agent', 'data'])" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "3df22322-7bde-4016-9216-8b8f7adf50f3", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/venv/lib/python3.10/site-packages/plotnine/geoms/geom_path.py:100: PlotnineWarning: geom_path: Removed 2400 rows containing missing values.\n" + ] + }, + { + "data": { + "image/png": "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" + }, + "metadata": { + "image/png": { + "height": 480, + "width": 640 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "from plotnine import ggplot, aes, geom_line, facet_wrap\n", + "ggplot(df, aes(x='t', y='value', color='variable')) + geom_line() + facet_wrap(facets=['data', 'agent'], scales=\"Free\")" + ] + }, + { + "cell_type": "markdown", + "id": "9da04426-c061-4650-aaaf-bae8de8b4134", + "metadata": {}, + "source": [ + "# Violin plots" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "52a7b7df-70ac-4204-a8a3-cac7e366d16b", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 100/100 [01:03<00:00, 1.57it/s]\n", + "100%|██████████| 100/100 [00:58<00:00, 1.70it/s]\n" + ] + } + ], + "source": [ + "from tqdm import tqdm\n", + "\n", + "tqc_rews = [gen_ep_rew_seq(tqcAgent, CaribouScipy()) for _ in tqdm(range(100))]\n", + "ppo_rews = [gen_ep_rew_seq(ppoAgent, CaribouScipy()) for _ in tqdm(range(100))]\n", + "cact_rews = ray.get([gen_ep_rew.remote(constAction([0.27950870095934127, 0.36956662640253096]), CaribouScipy()) for _ in range(100)])" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "3861113f-125f-432f-a3ae-4f8e98165c66", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
variablevalue
0PPO17.579274
1PPO45.429022
2PPO27.055361
3PPO52.908584
4PPO50.532980
\n", + "
" + ], + "text/plain": [ + " variable value\n", + "0 PPO 17.579274\n", + "1 PPO 45.429022\n", + "2 PPO 27.055361\n", + "3 PPO 52.908584\n", + "4 PPO 50.532980" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = pd.DataFrame(\n", + " {\n", + " 'PPO': ppo_rews,\n", + " 'TQC': tqc_rews,\n", + " 'ConstAct': cact_rews,\n", + " }\n", + ").melt()\n", + "df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "8753acb5-24f9-4835-a47b-29d009b8f950", + "metadata": {}, + "outputs": [], + "source": [ + "# import seaborn as sns\n", + "# sns.violinplot(df, x=\"value\", y=\"variable\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "161ee4cb-2f47-4741-ba64-98345d750f92", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABQAAAAPACAYAAABq3NR5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAB7CAAAewgFu0HU+AAEAAElEQVR4nOzdd3xV9f3H8ffNTXKzyA6QEBK2iExXwQGoKCpKrVonrqLFbW1t/VlHtW47HFhnbR2ooICCoBVEQUEQVKYsGSFACCQkZO97f39czk1CErLuveeO1/Px4NFj7hmfID1t3nw+36/F4XA4BAAAAAAAACAghZhdAAAAAAAAAADPIQAEAAAAAAAAAhgBIAAAAAAAABDACAABAAAAAACAAEYACAAAAAAAAAQwAkAAAAAAAAAggBEAAgAAAAAAAAGMABAAAAAAAAAIYASAAAAAAAAAQAAjAAQAAAAAAAACGAEgAAAAAAAAEMAIAAEAAAAAAIAAFmp2AfAP+fn5Hb42ISFBVqtVdXV1KiwsdGNV8AdWq1UJCQkqLCxUXV2d2eXABLwDwHsAvAfAeyC48Q5AW94BycnJXq4KCC50AAIAAAAAAAABjAAQAAAAAAAACGAEgAAAAAAAAEAAIwAEAAAAAAAAAhgBIAAAAAAAABDACAABAAAAAACAAEYACAAAAAAAAAQwAkAAAAAAAAAggBEAAgAAAAAAAAGMABAAAAAAAAAIYASAAAAAAAAAQAAjAAQAAAAAAAACGAEgAAAAAAAAEMAIAAEAAAAAAIAARgAIAAAAAAAABDACQAAAAAAAACCAEQACAAAAAAAAAYwAEAAAAAAAAAhgBIAAAAAAAABAAAs1uwBvKioq0syZM7Vy5UodPHhQNptNffv21fnnn6+RI0d2+L61tbWaN2+elixZopycHElSjx49NGbMGE2YMEGhoc3/Nu/fv18bN27Utm3btH37du3YsUOVlZWSpLlz5x71mfv379dNN93Uam333nuvTj311HZ+RwAAAAAAAAgUQRMAZmdn6/7771dRUZEkKTIyUmVlZVqzZo3WrFmjCy+8sE2B2pEqKir04IMPauvWrZKk8PBwSdK2bdu0bds2LVu2TH/9618VERHR5Nr3339fX375ZSe+K6fY2FiFhDTfzGnUAwAAAAAAgOAUFAFgTU2NHnvsMRUVFSkzM1O///3v1bt3b1VVVWnOnDl699139cknn6h3794aN25cu+790ksvaevWrYqOjtadd97p6iRcsWKFXnjhBW3evFkvv/yy7r777ibXWiwWpaamql+/furbt68qKio0Y8aMdn9///jHP9StW7d2XwcAAAAAAIDAFxQB4Oeff67c3FzZbDY99NBDSklJkSTZbDZddtllKigo0Keffqpp06Zp7NixLY7sHmnnzp36+uuvJUl33HGHRo0a5fps1KhRstvtevrpp7V48WJdfPHFyszMbHT97bffLqvV6vrnFStWdPZbBQAAAAAAABoJik1AFi9eLEkaPXq0K/xr6JJLLpHFYlFBQYHWr1/f5vsuWbJEDodDqampjcI/wymnnKLU1FQ5HA4tWbKkyecNwz8AAAAAAADAEwI+AKyoqNDPP/8sSTr++OObPSclJUXp6emSpLVr17b53uvWrZMkjRgxQhaLpcnnFotFI0aMaHQuAAAAAAAA4E0BPwK8Z88eORwOSWoygttQZmamdu/erd27d7fpvg6HQ3v27Gn1vhkZGZLU5vt2xDPPPKOcnBxVVVUpLi5OAwYM0Lhx43TSSSd57JkAAAAAAADwDwHfAVhQUOA6TkxMbPE847PCwsI23beiokKVlZVtvm9FRYUqKiradO/2+vnnn+VwOBQSEqKDBw9q+fLlevTRR/X000+rpqbGI88EAAAAAACAfwj4DkAjpJOcm360xPisrSFdw/Pacl/jmsjIyDbdvzXh4eE6//zzdfrpp6t3796KioqSJGVnZ2vWrFn66quvtGzZMkVHR+v2229v9X7Tpk3Te++91+LnV155pa666qoO1RoSEuL6z4SEhA7dA/7LGI+Pi4tzdeMiuPAOAO8B8B4A74HgxjsAvAMA8wV8ABioEhISdPPNNzf5ekZGhu6++27FxsZqzpw5WrhwoS666CLXGoctKSsr04EDB1r8vLy8vNObllgsFjY+CWLG//FD8OIdAN4D4D0A3gPBjXcAeAcA5gn4ADAiIsJ1XFVV5eqUO1JVVZUktblDr+F5xrVHu2977u0OV199tT777DNVV1dr1apVrQaA0dHR6tq1a4ufR0VFqa6urkO1hISEyGKxyOFwyG63d+ge8F8Wi0UhISGy2+38bV+Q4h0A3gPgPQDeA8GNdwDa8g4gHAY8K+ADwIbr8xUUFLQYABprBba1JT0yMlKRkZGqqKhotM5gS/c1zveWiIgIZWRkaNu2bdq/f3+r50+aNEmTJk1q8fP8/Pw2r494pISEBFmtVtnt9g7fA/7LarUqISFBRUVFHQ6R4d94B4D3AHgPgPdAcOMdgLa8A5KTk71cFRBcAr7/Nj093bXeQHZ2dovnGZ/17NmzTfe1WCyurjp33hcAAAAAAABwp4APACMjI9W/f39J0o8//tjsOfn5+dq9e7ckadiwYW2+99ChQyVJq1evbvGcNWvWNDrXWyorK13hY7du3bz6bAAAAAAAAPiOgA8AJWns2LGSpK+//lp5eXlNPp89e7YcDocSExM1ZMiQNt939OjRslgsysnJ0fLly5t8/u233yonJ0cWi8VVg7u0tnbK+++/r+rqalksFp100klufTYAAAAAAAD8R1AEgOPHj1f37t1VWVmpRx99VDt37pTk3KBj5syZmj9/viTnOnihoY2XRbzxxhs1ceJEPffcc03u27t3b40ePVqSNHXqVK1YsUIOh0MOh0MrVqzQiy++KMkZQGZkZDS5vra2VsXFxa5fFRUVrs8afr24uLjJtX/+85/1wQcfaOfOnY3WUMjOztbzzz+vjz76SJJ09tlnt7oBCAAAAAAAAAJXwG8CIklhYWF64IEHdP/99ysrK0t33XWXoqKiVFlZ6dqF6oILLtC4cePafe9bb71V+/bt09atW/XEE08oPDxcklRdXS1JGjhwoG655ZZmr920aZPuv//+Zj87ckOOuXPnNvrnvLw8TZs2TdOmTZPValVUVJSqq6sb7To8ZswYTZkypd3fEwAAAAAAAAJHUASAkpSRkaGpU6dq1qxZWrlypfLz8xUdHa0+ffpowoQJGjlyZIfuGxkZqaeeekrz5s3TkiVLlJOTI0nq27evxo4dqwkTJjTpKnSH66+/XmvXrtXPP/+swsJClZSUyGq1KjU1VQMHDtRZZ53l9XUHAQAAAMBfbdq0SbNmzVJcXJyuuOIKpaSkmF0SALiNxdHaYnKAnBuldFRCQoKsVqvq6upUWFjoxqrgD6xWqxISElRYWNhoXB3Bg3cAeA+A9wB4DwQ3f3gHvP322/rDH/7g+uekpCS99957Ov74402sKnC05R2QnJzs5aqA4BIUawACAAAAANCcpUuXNgr/JOngwYO67rrrdPDgQZOqAgD3IgAEAAAAAASl6upq/f73v5ckRcZG6ZHPHtf1T/5GkpSbm6u///3vZpYHAG5DAAgAAAAACEozZ87Uzp07JUmX33eFMo/L1Nirz9SIs52jv2+++aZrnXcA8GcEgAAAAACAoONwOPTiiy9KkrpmdtXpl49xfXbJn34tSaqtrdU777xjSn0A4E4EgAAAAACAoLNq1Sr9/PPPkqTxN50na6jV9Vn6MT11zMiBkqR33nmHzWsA+D0CQAAAAABA0Jk+fbokKdQWppG/PKXJ52OuGCtJ2r9/v1auXOnN0gDA7QgAAQAAAABBpba2VvPnz5ckHX/28YqOi25yzvBxxys0PFSSNHfuXK/WBwDuRgAIAAAAAAgq3333nQoKCiRJJ553UrPnRMVG6bjTh0iSFixYIIfD4bX6AMDdCAABAAAAAEHl888/l+Qc/x1yxrAWzxt2pvOz7Oxs127BAOCPCAABAAAAAEHlm2++kSQdc9IxioyJbPG8wYc7ACVp8eLFni4LADyGABAAAAAAEDQKCgq0YcMGSdLAU4496rlde3VTSs8USfWhIQD4IwJAAAAAAEDQ+Pbbb13Hx44a1Or5A34xUJK0cuVK1gEE4LcIAAEAAAAAQWPp0qWSJFuUTb2G9m71/P4nDpAkHThwQFlZWZ4sDQA8hgAQAAAAABA0li1bJkkacPIxCg0LbfX8AScNcB2vXLnSY3UBgCcRAAIAAAAAgkJeXp42b94sqW3jv5KU2i9NkbFRkqTVq1d7rDYA8CQCQAAAAABAUPjhhx9cx8eMHNimaywWi3oN7iVJWrdunSfKAgCPIwAEAAAAAASFNWvWSJKsYVZlDMps83W9hjjXCtywYYNqa2s9URoAeBQBIAAAAAAgKBgBYPoxPRVmC2vzdUYAWFFRoa1bt3qiNADwKAJAAAAAAEDAczgcWrt2rSSpdxt2/20oc3B9t+CmTZvcWhcAeAMBIAAAAAAg4O3Zs0f5+fmSpN7D+rTr2pSMrgo93DG4ZcsWt9cGAJ5GAAgAAAAACHjG+K8k9RravgDQGmpVap9USQSAAPwTASAAAAAAIOAZAWCoLUw9BvRo9/XGNZs3b3ZnWQDgFQSAAAAAAICAZwSAGYMyFBoW2u7r0wakS5KysrJUWVnpztIAwOMIAAEAAAAAAc3hcGjDhg2S6nf0ba8e/dMkSXa7Xdu2bXNbbQDgDQSAAAAAAICAduDAARUUFEiS0o/p2aF79DjcASixDiAA/0MACAAAAAAIaA3X7Us/Jv0oZ7aMnYAB+DMCQAAAAABAQNu0aZPruGEnX3uwEzAAf0YACAAAAAAIaEYHYGJqoqLjozt8H3YCBuCvCAABAAAAAAHN6ADs0cHxX0P3wx2A2dnZqqur63RdAOAtBIAAAAAAgIBlt9tdHXudDQBTMrpKkmpra5WTk9Pp2gDAWwgAAQAAAAABa/fu3SovL5ckpXdw/T9D18yuruOsrKxO3QsAvIkAEAAAAAAQsBrvANyzU/cyOgAlAkAA/oUAEAAAAAAQsIz1/ywWi1L7p3XqXnEpcQqPCJck7dq1q9O1AYC3EAACAAAAAALWzz//LElKTk+WLdLWqXtZLBZXFyAdgAD8CQEgAAAAACBgbd++XZLUvW+qW+5nrANIByAAf0IACAAAAAAISA6HQ9u2bZMkde/jngDQ6AAkAATgTwgAAQAAAAABKT8/X0VFRZKkVDd1ABoBYGFhoeveAODrCAABAAAAAAHJGP+V3NkBmOI6Zh1AAP6CABAAAAAAEJCM8V9J6t6nu1vu2TWzm+uYMWAA/oIAEAAAAAAQkIwOQFuUTQndE91yz+T0ZNcxHYAA/AUBIAAAAAAgINVvANJdFovFLfcMjwhXfNd4SdKePXvcck8A8DQCQAAAAABAQHL3DsCGxLQkSVJOTo5b7wsAnkIACAAAAAAIODU1Na4RXbcHgKnOcWICQAD+ggAQAAAAABBwsrOzVVtbK0lK7eveADCBABCAnyEABAAAAAAEnIYbdHTt1a3lEzvA6AA8ePCgKisr3XpvAPAEAkAAAAAAQMBpFABmujsATHId0wUIwB8QAAIAAAAAAs6uXbskSZGxUYqOi3brvY0OQEnat2+fW+8NAJ5AAAgAAAAACDhGB2DXjK6yWCxuvXdiWn0ASAcgAH9AAAgAAAAACDiuADCzq9vvHdc13hUq7t271+33BwB3IwAEAAAAAAQUh8PhGgF29/p/khQaFqq4lDhJdAAC8A8EgAAAAACAgHLgwAGVl5dLklIy3N8BKEmJac6NQFgDEIA/IAAEAAAAAASUxjsAeyYATDi8EQgjwAD8AQEgAAAAACCgNA4A3T8CLNXvBEwHIAB/QAAIAAAAAAgoxvp/1jCrK6hzN+O++fn5qqys9MgzAMBdCAABAAAAAAHF6ABMTk9RiNUzP/YmNAgW6QIE4OsIAAEAAAAAAcUIAD21/p8kJXRLcB3v37/fY88BAHcgAAQAAAAABJT6ANAz6/9JUlzXeNfxgQMHPPYcAHAHAkAAAAAAQMAoLS1VXl6eJCklI8Vjz4lLiXMdEwAC8HUEgAAAAACAgGFsACJ5tgMwIjpC4ZE2SQSAAHwfASAAAAAAIGAY47+SZ9cAtFgsri5AAkAAvo4AEAAAAAAQMBp2AKZkeC4AlEQACMBvEAACAAAAAAKG0QEYlxIn2+ERXU8xNgIhAATg6wgAAQAAAAABIzs7W5Lnu/8kOgAB+A8CQAAAAABAwNizZ48kKTk92ePPMgLAvLw82e12jz8PADqKABAAAAAAEBAcDod2794tSUrq4Y0AMF6SVFtbq8LCQo8/DwA6igAQAAAAABAQCgoKVF5eLsm7HYASY8AAfBsBIAAAAAAgIBjdf5KU5I0AsCsBIAD/QAAIAAAAAAgIDQPAZG+MACcTAALwDwSAAAAAAICAYGwAInmnAzCWABCAnyAABAAAAAAEhOzsbElSl6RY2SJtHn9emC1M0XHRkggAAfg2AkAAAAAAQEAwOgC9sQGIwdgIJC8vz2vPBID2IgAEAAAAAAQEYw3AJC+s/2eI6xoviQ5AAL6NABAAAAAAEBCMANCMDkACQAC+jAAQAAAAAOD3ioqKVFxcLMm7AWCXxC6SpPz8fK89EwDaiwAQAAAAAOD3jO4/ybsjwF2SYiVJBQUFstvtXnsuALQHASAAAAAAwO8ZG4BIUnLPFK89NybB2QFYV1enoqIirz0XANqDABAAAAAA4Peys7Ndx8k9krz23C5JXVzHBQUFXnsuALQHASAAAAAAwO8ZHYDRcdGK7BLltefGHh4BllgHEIDvIgAEAAAAAPg9owMwyYsbgEj1I8CSdPDgQa8+GwDaigAQAAAAAOD3jA5Ab24AIjUeASYABOCrCAABAAAAAH7P2AU42dsdgPExslgskggAAfguAkAAAAAAgF8rKytzbcDh7QAwxBqi6PhoSQSAAHwXASAAAAAAwK8Z47+S9wNASepyeCMQAkAAvooAEAAAAADg14wNQCTvrwEoSV0SnesAEgAC8FUEgAAAAAAAv9aoA7BnitefTwcgAF9HAAgAAAAA8GvGBiAR0RGKjov2+vO7JMRIIgAE4LsIAAEAAAAAfs0IAJN6JLt25PUmowPQ2IgEAHwNASAAAAAAwK8ZAaAZG4BI9WsAlpeXq7y83JQaAOBoCAABAAAAAH7N1QFoUgAYczgAlBgDBuCbCAABAAAAAH6rsrJSBw4ckGReB2Ds4RFgiTFgAL6JABAAAAAA4Lf27t3rOk7uYe4IsCTl5+ebUgMAHA0BIAAAAADAbxnjvxIjwADQEgJAAAAAAIDfahgAJqenmFJDFwJAAD6OABAAAAAA4LeMADDMFqbY5NhWzvaM8Ihw2aJskqTCwkJTagCAoyEABAAAAAD4rYY7AFssFtPqiI6PkSQdOnTItBoAoCUEgAAAAAAAv2UEgGZtAGKIjo+WRAcgAN9EAAgAAAAA8FuuANCkDUAMMXQAAvBhBIAAAAAAAL9UU1Oj3NxcSebtAGyIjnN2ABYUFJhaBwA0hwAQAAAAAOCXcnJyZLfbJUlJpo8A0wEIwHcRAAIAAAAA/JIx/itJKekpJlbCGoAAfBsBIAAAAADALzUMAJPSk0ysRIpJcHYAlpSUqKamxtRaAOBIBIAAAAAAAL9kBIDWMKviuyaYWosxAixJRUVFJlYCAE0RAAIAAAAA/JIRACamJinEau6PtzGHR4Al1gEE4HsIAAEAAAAAfmnPnj2SpGSTdwCWGncAsg4gAF9DAAgAAAAA8EtGByABIAAcHQEgAAAAAMDv1NXVae/evZKkpB7mB4ANR4AJAAH4GgJAAAAAAIDf2b9/v2prayVJSXQAAsBREQACAAAAAPxOdna269gXRoDDI8IVZguTxCYgAHwPASAAAAAAwO8YG4BIUrIPjABLUkyCswuQDkAAvoYAEAAAAADgd4wNQCwhFiWkJppcjZMxBkwHIABfQwAIAAAAAPA7RgCY0D1RoWGhJlfjFH14IxA6AAH4GgJAAAAAAIDfMQLA5B5JJldSL4YOQAA+igAQAAAAAOB3jDUAk9JTTK6kHh2AAHwVASAAAAAAwK84HA5XAOgLOwAbouPoAATgmwgAAQAAAAB+JS8vT5WVlZKkJB/ZAViq7wAsKipSXV2dydUAQD0CQAAAAACAXzG6/yTf6gCMSegiydmhWFRUZHI1AFCPABAAAAAA4Feys7Ndx74UAEbHRbuOWQcQgC8hAAQAAAAA+JWGHYCJab6zC3BUbJTruKSkxMRKAKAxAkAAAAAAgF/ZvXu3JCkuJU7hEeEmV1OvYQDICDAAX0IACAAAAADwK0YAmORD479S4xFgAkAAviTU7ALgH6xWq0/dB/7D+HfOv3tI/DkIVrwH0BB/DoIT7wEY3PVnwBgBTk5PUUiI7/S1RCfEuI6Li4v5M38Y7wDAfASAaJOEhIRO38NqtbrlPvBPsbGxZpcAk/EOAO8B8B4A74Hg5q53gMPhcAWA3Xt1V0RERKfv6S5hKWGu45qaGt55R+AdAJiHABBt0pkdrGJjY2W1WlVXV6fi4mI3VgV/YLVaFRsbq+LiYtXV1ZldDkzAOwC8B8B7ALwHgpu73wGFhYWuDTbiuyeosrKy0/d0p4joCFWWVSo3N5edgA9ryzuAsBTwLAJAtIm7/o8a/4cveNXV1fHvH/wZCHK8ByDxHgh2vAfgjn//WVlZruPEtETZ7fZO39OdomKjVFlWqcLCQv68H4F3AGAe31ksAQAAAACAVhjjv5KUkp5iYiXNM3YCpuMZgC8hAAQAAAAA+I3s7GzXsa/tAizVB4CHDh0ytxAAaIAAEAAAAADgN4wOwJiEGEVE+84GIIaouGhJdAAC8C0EgAAAAAAAv2EEgEk9fK/7T5KiYp0BYFFRkcmVAEA9AkAAAAAAgN8wRoCTfXD8V6ofASYABOBLCAABAAAAAH7D6AD02QAwjk1AAPgeAkAAAAAAgF8oLS1VYWGhJF8eAXYGgBUVFaqqqjK5GgBwIgAEAAAAAPiF3bt3u459cQdgqX4NQIkxYAC+gwAQAAAAAOAXGgaAyekpJlbSsujDI8ASY8AAfAcBIAAAAADALxjr/0lSss+OANMBCMD3EAACAAAAAPyC0QEYERPh2mzD1xhrAEoEgAB8BwEgAAAAAMAvGAFgco9kWSwWk6tpHgEgAF9EAAgAAAAA8Au7du2SJKVkdDW5kpYxAgzAFxEAAgAAAAD8QnZ2tiTfDgAju0S6jgkAAfgKAkAAAAAAgM8rLi5WQUGBJCmlp2/uACxJIdYQRR4eAyYABOArCAABAAAAAD7PGP+VfLsDUKpfB7C4uNjkSgDAiQAQAAAAAODzjPFfyX8CQDoAAfgKAkAAAAAAgM9r2AGY3DPZxEpaZwSAhw4dMrcQADiMABAAAAAA4POysrIkSXEpcbJF2swtphVRXRgBBuBbCAABAAAAAD7P6AD09fFfSYo8HACWlJSYXAkAOBEAAgAAAAB8nrEGYEqG7+4AbIiMjZREByAA30EACAAAAADwaXa7vUEA6PsdgFF0AALwMQSAAAAAAACflpubq+rqakn+EQBGxjg7AMvLy1VbW2tyNQBAAAgAAAAA8HENdwBO6ekHI8BdIl3HpaWlJlYCAE4EgAAAAAAAn9YoAPSHDsAGASDrAALwBQSAAAAAAACfZgSAoeGhSuiWYHI1rTN2AZYIAAH4BgJAAAAAAIBPMzYASU5PVojV93+MjWoQALIRCABf4PtvTgAAAABAUMvKypIkJfvB+n+SFNFgBJgAEIAvIAAEAAAAAPg0YwS4qx+s/ydJUawBCMDHEAACAAAAAHxWRUWF9u/fL8k/NgCRGq8BSAcgAF9AAAgAAAAA8Fm7d+92HfvNCHB0hOuYDkAAvoAAEAAAAADgs4z1/yT/GQEOsYYoIsYZAtIBCMAXEAACAAAAAHyWsQOw5D8jwFL9TsB0AALwBQSAAAAAAACfZWwAEh0XrajYqFbO9h0RMc6NQOgABOALCAABAAAAAD7LCAD9qftPkiusJAAE4AsIAAEAAAAAPqs+APSPDUAMkV2cHYCMAAPwBQSAAAAAAACf5HA46gPAnv7VARjJCDAAH0IACAAAAADwSQcPHlRZWZkkf+wAZAQYgO8gAAQAAAAA+CSj+0/yvzUAI2MZAQbgOwgAAQAAAAA+KTs723Xsdx2ADUaAHQ6HydUACHYEgAAAAAAAn5SVlSVJsoRYlJSWbG4x7RR1eAS4trZWFRUVJlcDINgRAAIAAAAAfJIxApyYlqTQ8FCTq2kfYxdgiTFgAOYjAAQAAAAA+CRjBDilp3+N/0qNA8DS0lITKwEAAkAAAAAAgI8yOgD9bQMQqX4XYIkOQADmIwAEAAAAAPicmpoa7dmzR5J/BoBRDQLAkpISEysBAAJAAAAAAIAP2rt3r+x2uyT/HAGOYA1AAD6EABAAAAAA4HOM8V/JXzsACQAB+A4CQAAAAACAz2kYAHbN8MMOwBg2AQHgOwgAAQAAAAA+xwgAbVE2dUmKNbma9guzhckaapVEAAjAfASAAAAAAACf49oBuGeKLBaLydW0n8ViUUR0hCQCQADmIwAEAAAAAPgcVwDoh+v/GSJiCAAB+AYCQAAAAACAz8nOzpbk3wFg5OF1AAkAAZiNABAAAAAA4FOKi4tVUFAgyTkC7K+MjUBKSkpMrgRAsCMABAAAAAD4lIY7APtzByBrAALwFQSAAAAAAACfQgAIAO5FAAgAAAAA8CnG+n+SlNwz2cRKOodNQAD4CgJAAAAAAIBPycrKkiTFpcTJFmkzt5hOYBMQAL6CABAAAAAA4FOMEWB/Hv+V2AQEgO8gAAQAAAAA+BRjBDglw393AJbq1wAsLy+X3W43uRoAwYwAEAAAAADgM+x2e4MA0N87ACNcx2VlZSZWAiDYEQACAAAAAHxGbm6uqqurJQVAABgd6TpmHUAAZiIABAAAAAD4DGP9P0lK6enfI8CRXQgAAfgGAkAAAAAAgM9oFAD6fQdg/QgwG4EAMBMBIAAAAADAZxgBYGh4qBK6JZhcTec0XAOQDkAAZiIABAAAAAD4DGMDkKQeyQqx+vePrKwBCMBX+PfbFAAAAAAQULKysiRJKRn+vf6fJEXSAQjARxAAAgAAAAB8hjEC3NXP1/+TpIgYOgAB+AYCQAAAAACAT6ioqND+/fslScl+vgOwJNmibK5jNgEBYCYCQAAAAACAT9i9e7fr2N93AJakkJAQ107AdAACMBMBIAAAAADAJxjjv5KUEgAdgJIIAAH4BAJAAAAAAIBPMHYAlqSUnv7fAShJETEEgADMRwAIAAAAAPAJRgAYGRul6Phok6txj8jDG4EQAAIwEwEgAAAAAMAnGCPAgTL+K9XvBEwACMBMBIAAAAAAAJ9gdAAGVADIGoAAfAABIAAAAADAJxgBYHIgBYCsAQjABxAAAgAAAABMV1RUpKKiIkmB1gHICDAA8xEAAgAAAABMZ6z/JwVYB+DhEeCSkhKTKwEQzAgAAQAAAACmM8Z/JSmlZ1cTK3GvyC71HYAOh8PkagAEKwJAAAAAAIDpGgaAyT2TTazEvYwOwLq6OlVWVppcDYBgRQAIAAAAADCdMQIcmxInW6TN5GrcJyIm0nXMOoAAzEIACAAAAAAwndEBGEgbgEj1HYASASAA8xAAAgAAAABMF7ABYEx9AMhGIADMQgAIAAAAADCVw+HQ7t27JQXWDsCSFMkIMAAfQAAIAAAAADDVgQMHVFFRISkQOwAJAAGYjwAQAAAAAGCqhjsAB1wA2GANwLKyMhMrARDMCAABAAAAAKZqGAAm9+xqYiXuFxnDJiAAzEcACAAAAAAw1a5duyRJlhCLEtMSTa7GvSKi60eA2QQEgFkIAAEAAAAApjI6ABPTkhQaFmpyNe4VGh6qUFuYJDoAAZiHABAAAAAAYCojAAy09f8MkYfXASQABGAWAkAAAAAAgKkCPQCMIAAEYDICQAAAAACAaWpra7Vnzx5JUnKgBoAxznUACQABmIUAEAAAAABgmpycHNXV1UkK/A5ANgEBYBYCQAAAAACAaYzxX0lK6dnVxEo8J7ILHYAAzEUACAAAAAAwTcMAMGBHgFkDEIDJCAABAAAAAKbZu3evJMkaZlVc1ziTq/GMiBgCQADmIgAEAAAAAJjG2AAkMTVJISGB+SNqRLRzBLisrMzkSgAEq8B8uwIAAAAA/ILRAZjUI8nkSjzHFm2TRAAIwDwEgAAAAAAA0xgdgElpgRsARkQ5R4DLy8tlt9tNrgZAMCIABAAAAACYwuFwuDoAEwO6AzDCdVxeXm5iJQCCFQEgAAAAAMAU+fn5qqyslCQlpSWbXI3nRETZXMdsBALADASAAAAAAABTGN1/kpScHrgBYMMOQNYBBGAGAkAAAAAAgCmM9f8kKTGQ1wAkAARgMgJAAAAAAIApGgaASWmJJlbiWcYmIBIBIABzEAACAAAAAExhjADHJMTI1iAkCzS26Po1AAkAAZiBABAAAAAAYIrdu3dLkpICeAdgiQ5AAOYjAAQAAAAAmMLoAEwM4B2AJTYBAWA+AkAAAAAAgCmMADA50DsAGQEGYDICQAAAAACA11VUVCgvL0+SlNgjsDsAwyNtslgskggAAZiDABAAAAAA4HU5OTmu46S0wO4AtFgsro1ACAABmIEAEAAAAADgdXv27HEdB/omIFL9RiAEgADMQAAIAAAAAPC6RgFggHcASvUbgRAAAjADASAAAAAAwOuMDUBCw0MVmxJncjWeF8EIMAATEQACAAAAALzO6ABMTE1USEjg/2hqYwQYgIkC/y0LAAAAAPA5RgdgUoDvAGyIYAQYgIkIAAEAAAAAXtewAzAY2KIYAQZgHgJAAAAAAIBXORwO5ebmSpISgiQApAMQgJkIAAEAAAAAXlVcXKzy8nJJUkL3BJOr8Q5jDcDS0lKTKwEQjAgAAQAAAABelZOT4zpO6B4sHYCMAAMwDwEgAAAAAMCr9u3b5zpO6BYkHYANRoAdDofJ1QAINgSAAAAAAACvahQABssagIdHgB0OhyoqKkyuBkCwCTW7AG8qKirSzJkztXLlSh08eFA2m019+/bV+eefr5EjR3b4vrW1tZo3b56WLFniamXv0aOHxowZowkTJig0tPnf5v3792vjxo3atm2btm/frh07dqiyslKSNHfuXI8+GwAAAADMYmwAYg21KjY51uRqvMPoAJScXYBRUVEmVgMg2ARNOpSdna37779fRUVFkqTIyEiVlZVpzZo1WrNmjS688ELddNNN7b5vRUWFHnzwQW3dulWSFB4eLknatm2btm3bpmXLlumvf/2rIiIimlz7/vvv68svv+zw99SZZwMAAACAWYzmhbiu8QoJCY7BtIgom+u4rKxMKSkpJlYDINgERQBYU1Ojxx57TEVFRcrMzNTvf/979e7dW1VVVZozZ47effddffLJJ+rdu7fGjRvXrnu/9NJL2rp1q6Kjo3XnnXe6OglXrFihF154QZs3b9bLL7+su+++u8m1FotFqamp6tevn/r27auKigrNmDHDK88GAAAAALMYI8DBsgOw1LQDEAC8KSgCwM8//1y5ubmy2Wx66KGHXH/TYrPZdNlll6mgoECffvqppk2bprFjx7Z5bHbnzp36+uuvJUl33HGHRo0a5fps1KhRstvtevrpp7V48WJdfPHFyszMbHT97bffLqvV6vrnFStWtPl76uyzAQAAAMAs9QFgcKz/J0kRBIAATBQUvdaLFy+WJI0ePbrZNutLLrlEFotFBQUFWr9+fZvvu2TJEjkcDqWmpjYK4AynnHKKUlNT5XA4tGTJkiafNwz/2quzzwYAAAAAswRjByABIAAzBXwAWFFRoZ9//lmSdPzxxzd7TkpKitLT0yVJa9eubfO9161bJ0kaMWKELBZLk88tFotGjBjR6Fx3MfPZAAAAANBRVVVVOnjwoKTgCgAZAQZgpoAPAPfs2SOHwyFJRx2DNT7bvXt3m+7rcDi0Z8+eVu+bkZHRrvv6+rMBAAAAoDOMHYClIBsBPmITEADwpoBfA7CgoMB1nJjY8v+4GJ8VFha26b4VFRWqrKxs830rKipUUVGhyMjINt3f28+eNm2a3nvvvRY/v/LKK3XVVVd1qF5jV6+QkBAlJATP3/DByehQjYuLc4XxCC68A8B7ALwHwHsguB35Dvjpp59cn3XP7O6Wn5H8QnL9ocPhCKr3Ie8AwHwBHwAaQZnk3PSjJcZnFRUVbbpvw/Pacl/jGncFgO5+dllZmQ4cONDi5+Xl5Z1as1ByvvQ7ew/4L+P/+CF48Q4A7wHwHgDvgeBmvAOM9f8kKSktudkljQJRww5Ad/x85Y94BwDmCfgAEG0THR2trl27tvh5VFSU6urqOnTvkJAQWSwWORwO2e32jpYIP2WxWBQSEiK73c7f9gUp3gHgPQDeA+A9ENyOfAc0XKIooVt80PyZsISEyBZlU1V5lYqLizv885U/ass7IBgDUcCbAj4AjIioX2i1qqpKUVFRzZ5XVVUlSW3u0Gt4nnHt0e7bnnub8exJkyZp0qRJLX6en5/f5vHoIyUkJMhqtcput3f4HvBfVqtVCQkJKioqCqr/k4N6vAPAewC8B8B7ILgd+Q7YsWOHJCk6PkZ1srd5CisQGAHgwYMHg+p92JZ3QHJycrNfB+AeAd9/23CNvIbrAR7J+Kyt6zBERka6QrW23Lfh+Z1l5rMBAAAAoDNycnIkBdcOwAZblLNBhU1AAHhbwAeA6enprjUlsrOzWzzP+Kxnz55tuq/FYlF6errb7+vrzwYAAACAzjDWAExMDZ4dgA0R0QSAAMwR8AFgZGSk+vfvL0n68ccfmz0nPz/ftQ7FsGHD2nzvoUOHSpJWr17d4jlr1qxpdK67mPlsAAAAAOio3NxcSVJ8t2DsAHRuBEIACMDbAj4AlKSxY8dKkr7++mvl5eU1+Xz27NlyOBxKTEzUkCFD2nzf0aNHy2KxKCcnR8uXL2/y+bfffqucnBxZLBZXDe5i5rMBAAAAoCPsdrurAzAYR4CNDsDS0lKTKwEQbIIiABw/fry6d++uyspKPfroo9q5c6ck5yYZM2fO1Pz58yU5N8IIDW28L8qNN96oiRMn6rnnnmty3969e2v06NGSpKlTp2rFihVyOBxyOBxasWKFXnzxRUnOADIjI6PJ9bW1tSouLnb9arj4bcOvFxcXu/3ZAAAAAOBt+fn5qq2tlSQldA++EWAbI8AATBLwuwBLUlhYmB544AHdf//9ysrK0l133aWoqChVVlbKbrdLki644AKNGzeu3fe+9dZbtW/fPm3dulVPPPGEwsPDJUnV1dWSpIEDB+qWW25p9tpNmzbp/vvvb/azI3fknTt3rlufDQAAAADeZnT/SUG6BiAjwABMEhQBoCRlZGRo6tSpmjVrllauXKn8/HxFR0erT58+mjBhgkaOHNmh+0ZGRuqpp57SvHnztGTJEteOVn379tXYsWM1YcKEJl2F7mLmswEAAACgvYz1/yQpvlu8eYWYhA5AAGYJqnQoPj5ekydP1uTJk9t8zb///e9WzwkNDdVFF12kiy66qF31DBkypNnOvvbo6LMBAAAAwNsOHDjgOg7GTUAioggAAZgjKNYABAAAAACYb//+/ZIka6hVMQkxJlfjfbbo+hFgh8NhcjUAggkBIAAAAADAK4wOwNjkWIWEBN+Po8YuwLW1ta612wHAG4LvjQsAAAAAMIXRARiXEm9uISYxAkCJMWAA3kUACAAAAADwClcA2DXe3EJMYiMABGASAkAAAAAAgFcYI8DxQRoAGpuASASAALyLABAAAAAA4HEOh6NBB2CcydWYw9gERCIABOBdBIAAAAAAAI87dOiQa+MLOgAJAAF4FwEgAAAAAMDj9u3b5zqOSwnWDkACQADmIAAEAAAAAHhcbm6u6ziua4KJlZjHFlU/AlxaWmpiJQCCDQEgAAAAAMDjGgWAQdoB2HAEuLy83MRKAAQbAkAAAAAAgMcRADbuACQABOBNBIAAAAAAAI8z1gCMio1SeES4ydWYIzQ8VNZQqyQCQADeRQAIAAAAAPC4/fv3SwreHYANRhcgm4AA8CYCQAAAAACAxxkdgHEEgJIIAAF4FwEgAAAAAMDjjA5AAkBnAMgIMABvIgAEAAAAAHicqwMwSDcAMRAAAjADASAAAAAAwKOqqqpUWFgoiTUAbVERkhgBBuBdBIAAAAAAAI/Kzc11HTMCTAcgAO8jAAQAAAAAeFTDADA+2EeAIwkAAXgfASAAAAAAwKOM9f8kKa5rgomVmM8WzQgwAO8jAAQAAAAAeFTjEeAg7wBkBBiACQgAAQAAAAAeZXQAhoaHKjou2uRqzMUIMAAzEAACAAAAADzK6ACMS4mTxWIxuRpz0QEIwAwEgAAAAAAAjzI6AIN9B2Cpfg3A6upq1dTUmFwNgGBBAAgAAAAA8Kj6DsB4cwvxAcYIsEQXIADvIQAEAAAAAHjUgQMHJElxybEmV2I+YwRYIgAE4D0EgAAAAAAAj3E4HK4AsAsBoCKi6wPAsrIyEysBEEwIAAEAAAAAHlNaWqqKigpJUmxSnMnVmM8WFeE6JgAE4C0EgAAAAAAAjzG6/yRGgCXWAARgDgJAAAAAAIDHNAwAGQGWbNEEgAC8jwAQAAAAAOAxDQNARoAbbwLCCDAAbyEABAAAAAB4TKMR4BQ6ABkBBmAGAkAAAAAAgMfs379fkhRiDVFUXLTJ1ZivYQcgASAAbyEABAAAAAB4TF5eniQpLjlOISH8CMouwADMwNsXAAAAAOAxxghwbDLr/0nOTsgwW5gkOgABeA8BIAAAAADAY4wR4LgUAkCDMQZMAAjAWwgAAQAAAAAe4xoBJgB0sUU7x4AZAYaZxo4dK4vFIovF4vFnXX/99a5nZWVldepeWVlZrntdf/31bqkvGBAAAgAAAAA8hhHgpoydgOkABOAtBIAAAAAAAI+oqanRwYMHJTk3AYETI8AAvC3U7AIAAAAAAIHJCP8kRoAbMgJARoBhpsWLF5tdAryIDkAAAAAAgEfk5+e7jukArGeLYg1AAN5FAAgAAAAA8AhjAxBJiusab14hPoYRYADeRgAIAAAAAPCIhh2AbAJSjwDQf9XV1SktLU0Wi0VdunRp07/D6upqJScny2KxKCkpSdXV1a7PKisrNWfOHN1555065ZRTlJKSorCwMHXp0kX9+/fXNddco4ULF7b6jIcffti1M64x2rt48WJdc8016tOnj6Kiohp9JrVtF+CSkhJNnz5dU6ZM0UknnaTExESFhYUpPj5egwYN0k033aSVK1e2Wl9zZs+erQkTJig9PV02m009evTQr3/9a3355Zcdul9L1qxZo7vuukvDhg1TYmKibDab0tLSNGHCBP3nP/9RbW2tW5/nq1gDEAAAAADgEY0CwKRY1TnqTKzGd0SwBqDfslqtuvrqq/X3v/9dpaWlmj17tiZNmnTUaz799FPXepiXX365wsPDXZ8NGjRIO3fubHJNaWmptm3bpm3btmnatGn65S9/qWnTpikmJqZNdd55552aOnVqO76zpqqrq9W1a1dVVlY2+ayoqEhFRUXatGmT/v3vf2vKlCl68cUXFRraesxUW1urK664QjNmzGj09ZycHM2cOVMzZ87UrbfeqhdffPGo4WRrqqqqdOutt+q///2vHA5Ho8/27dunffv26dNPP9U///lPzZ07V3369Onws/wBASAAAAAAwCOMEeCo2CiFR4SroqLC5Ip8Ax2A/u26667T3//+d0nSO++802oA+Pbbb7uOr7322kaflZeXKz4+XmeeeaZGjBihzMxMRUVFqbi4WOvWrdOMGTO0b98+zZkzR7/5zW/0wQcftFrfM888o88++0wpKSm67rrrNHToUEnS6tWrFRsb2+bv0263q7KyUt26ddNZZ52lYcOGKS0tTZGRkSosLNT333+vDz74QIWFhXr11VcVGxurZ555ptX73nvvvZo9e7ZSU1P1m9/8Rscdd5wqKiq0aNEiTZ8+XXa7XS+99JIiIiL0j3/8o831NlRbW6tzzz3X1fGYlpamK664QkOHDlVUVJT27Nmj2bNna+nSpfrpp580evRorV69WikpKR16nj8gAAQAAAAAeIQRALIBSGPhhzcBKS8vl8Ph6FSXE7xv8ODBGjFihFavXq1FixZp3759Sk1NbfbcgoICzZ8/X5I0YMAAjRw5stHn//3vfzVu3DiFhYU1e/3jjz+uq6++Wh9//LE+/PBDLV26VKeddtpR6/vss880atQozZ8/XwkJCa6vX3PNNe35NhUWFqZPP/1U48ePV0hI0xXkbrzxRj3++OO68MILtXz5cv3zn//UbbfdpszMzKPed/bs2Ro1apQ+/fRTxcfHu77+m9/8RjfddJMmTJig8vJyPfvss7rkkkt0yimntKtuSXrwwQdd4d9NN92kF154QREREY3Oufvuu/XCCy/orrvu0t69e3X33Xdr2rRp7X6Wv2ANQAAAAACAR7gCQDYAacQW6ewAtNvtqqqqMrkadITRyVdXV3fU0OiDDz5wrfnXXAB33nnntRj+SVJUVJTeeustRUdHS5LeeuutVmuLjo7Whx9+2Cj86wir1arzzjuv2fDPkJSU5OpwbO33whATE6OZM2c2Cv8MY8eO1ZNPPilJcjgcrk7L9jhw4ICee+45SdK4ceP02muvNQn/DHfeeaeuuuoqSdL06dO1d+/edj/PXxAAAgAAAAA8wlgDkA1AGouItrmOWQfQP1111VWu9e7eeeedFs8zwjGLxdLuDjxDbGyshgwZIklasWJFq+dffPHF6tGjR4ee1RH9+vVT9+7dJbWtvkmTJiktLa3Fz3/7298qLs75zpg3b16zaxAezYwZM1zX/PGPf2z1/Ouuu06SM8BctGhRu57lTxgBBgAAAAB4hBEAMgLcmLEGoOQcA05KSjKxGnRE165dde6552revHlav3691qxZo+HDhzc6Z9u2bVq+fLkkafTo0S2OxhYWFurdd9/V//73P23YsEEHDx5UWVlZk40rJGnPnj2t1nb66ae3/xs6ipycHL3zzjtatGiRNm7cqMLCwhbXr2xLfePGjTvq5xERETrttNM0f/581dTUaM2aNU1Gp4/m66+/dh3v379fH3/88VHPb9j1t3HjxjY/x98QAAIAAAAA3M7hcNSPAKcQADZkjABLbATiz6699lrNmzdPkrPT78gAsOE47JGbfxjmzJmjyZMnu3YJbk1xcXGr56Snp7fpXm3x6quv6ve//32b/5y2pb7+/fu365ycnJw2PduQlZXlOm7p970lBQUF7TrfnxAAAgAAAADcrqSkxLX2GQFgY7bo+vXIGAH2XxMnTlRCQoIKCwv1/vvv629/+5usVqvrc2M0OCoqSr/+9a+bXL98+XJdeumlqq2tlSQNHTpU48aNU79+/ZSQkCCbzebaIOaBBx7QTz/9JLvd3mpdkZGR7vj29OGHH+rmm292/fOoUaM0ZswY9e7dW3FxcbLZ6oPs3/72t8rLy1NdXV2r9zXWM2zrOSUlJe2q+9ChQ+06vyHjnRWICAABAAAAAG5ndP9JjAAf6cgRYPgnm82myy67TK+++qpyc3O1YMECnXfeeZKkZcuWaceOHZKkiy66SF26dGly/UMPPeQK//71r3/p1ltvbfFZjz/+uAe+g6P785//LMm5GchHH32kCy+8sMVzb7rppjbfty2hd8Nzmvu9O5qYmBjXcXFxcbuvD1RsAgIAAAAAcDtj/T+JTUCORAAYOBqOmBobfhx53NwYak1NjRYvXixJOuGEE44a/kmNx1q9YefOndq2bZskZ4B5tPCvuLi4XaOzxn3bes7RNgxpTsMR6N27d7fr2kBGAAgAAAAAcLuGa5oRADbWcA1ARoD92ymnnOJar27OnDkqKSlRVVWVPvjgA0lSampqs5te5Ofnu7r/+vXrd9RnrFq1qlGg7g25ubmu49bq+/zzz9s0mmxYuHDhUT+vqqrS0qVLJUnh4eFN1lZszZgxY1zHn332WbuuDWQEgAAAAAAAt2sUACbFmliJ72ENwMByzTXXSJIqKir04Ycfat68ea516K6++upG6wIaGq5x11pH3F/+8hf3FdtGba2vurpajz32WLvu/e6772rfvn0tfv7vf//b9ft3wQUXKCIiosVzm3PFFVe41if85z//6fXw1FcRAAIAAAAA3M4YCbRYLIqJb33R/2DCCHBgueaaa1ybdbz99tutjv9KUmxsrAYMGCBJ+uGHHzRz5swm59TV1enuu+82pYtt4MCBrrX05s6dq+XLlzc5p6KiQpMmTdK6devade+SkhJddtllze4Y/PXXX+vee++V5Hx33HPPPe2uPT09XXfeeack5w7C48ePd63H2JK1a9dqypQp7X6WP2ETEAAAAACA2xkdgDEJMQqxWuVwOEyuyHeER4TLYrHI4XAQAAaAXr16afTo0VqyZIm+/vprV8ff8OHDNWTIkBav+93vfuda+++yyy7T5ZdfrjFjxighIUHbtm3Tu+++q02bNmnw4MGy2Wz64YcfvPL9SM7R21tvvVXPPPOMampqNGbMGF1//fU6+eSTFR0drY0bN+qtt97S7t27ddZZZ2nLli3as2dPm+59ySWXaNasWTr22GM1efJkDRo0SBUVFVq0aJGmT5/u2kn47rvv1qhRozpU/xNPPKG1a9dqwYIF+vHHHzVw4EBNnDhRp59+ulJTU2W325Wfn68NGzboq6++0tatW2W1WvXqq6926Hn+gAAQAAAAAOB2RgDYhfHfJiwWi2xRNlWWVTICHCCuvfZaLVmyRA6Hw7W2X0vdf4abb75Z33//vf7zn//I4XBo+vTpmj59eqNzhgwZojlz5uiGG27wWO0tefTRR7Vu3Tr973//U01NjV5//XW9/vrrjc4ZM2aMZsyYoRNOOKHN933qqacUHh6u999/X48++miz59xyyy3629/+1uHaQ0NDNW/ePN133316/vnnVVNTo1mzZmnWrFktXtNw85BAxAgwAAAAAMDtjBHg2EQCwOaEHx4DpgMwMPz6179WVFSU659DQ0N11VVXHfUai8WiN954Q7NmzdL48eOVlJSksLAwde/eXWPGjNGLL76olStXqnfv3p4uv1nh4eGaP3++3njjDY0ePVpxcXEKDw9Xjx49dO655+qtt97Sl19+qaSkpHbdNzQ0VO+9955mzpyp888/X2lpaQoPD1dqaqouvvhiffHFF3rppZcUEtK5yCosLEx///vftW3bNj300EM6/fTT1b17d4WHhysiIkI9evTQGWecof/7v//TV1991eqYsL+zOOjDRht0ZtHMhIQEWa1W1dXVqbCw0I1VwR9YrVYlJCSosLDQ1cqN4MI7ALwHwHsAvAeC0znnnKPVq1frpPNP1h/f/j85HA5VVFSYXZbP+ONpv1de9gFNmjRJzz77rNnleFRb3gHJyclergoILnQAAgAAAADcztUByAhwsyIO7wRMByAAbyAABAAAAAC4nWsNQEaAm2XsBMwagAC8gQAQAAAAAOBWVVVVKi0tlSR1SepicjW+yRbJGoAAvIcAEAAAAADgVsb4r0QHYEvYBASANxEAAgAAAADcyhj/lVgDsCUR0YwAA/AeAkAAAAAAgFs16gAkAGwWI8AAvIkAEAAAAADgVo06ABNZA7A5NkaAAXgRASAAAAAAwK0YAW6dLTpCEiPAALyDABAAAAAA4FbGCHCoLcwVdKExYwS4oqJCdrvd5GoABDoCQAAAAACAW+Xn50uSuiTEyGKxmFyNbzJGgCXGgAF4HgEgAAAAAMCtjA5ANgBpGQEgAG8iAAQAAAAAuJUrAExgA5CW2KLqR6NZBxCApxEAAgAAAADcytgEJCYxxuRKfBcdgP7JYrH4za+FCxea/dsFH+LWAPCqq67S119/7c5bAgAAAAD8jBEAdklkBLglBIAAvCnUnTebPn26ZsyYoQEDBmjKlCm69tprlZiY6M5HAAAAAAB8mMPhqB8BTmQEuCURjAD7tSd/c72Ozcwwu4wmNu3K1n3/edPsMuCD3BoASs6X/datW/WHP/xBf/7zn3XppZfqt7/9rU477TR3PwoAAAAA4GNKSkpUU1MjiRHgowmnA9CvHZuZoZOPGWB2GUCbuXUEePHixbriiisUHh4uh8OhyspKvfvuuxozZoyOO+44TZ06VYcOHXLnIwEAAAAAPsQY/5XYBORoGAEG4E1uDQBHjx6t9957T3v27NHf/vY3DRgwQA6HQw6HQ5s3b9bvfvc79ejRQzfccIOWL1/uzkcDAAAAAHyAMf4rSV2SWAOwJQSAALzJI7sAJyUl6Q9/+IM2b96sr776SpdffrmrK7CiokJvv/22TjvtNA0dOlQvvfSSiouLPVEGAAAAAMDLGnYAxrAGYItYAxCAN3kkAGxozJgxev/997Vnzx4988wzjboCf/rpJ91xxx1KS0vTjTfeqJUrV3q6HAAAAACABzUeAWYNwJaEhofKGmqVRAcgAM/zeABoSEpK0j333KPNmzdr0aJFuvzyyxUWFiaHw6Hy8nL997//1ahRozRixAi9/vrrqqio8FZpAAAAAAA3aTgCTAfg0RkbgdABCMDTvBYANnTGGWfoqaee0vXXXy9Jslgskpw7CK9bt04333yzMjIy9Oyzz8put5tRIgAAAACgA4wOwMjYKIWGhZpcjW+LIAAE4CVeDQDtdrs+/vhjnXfeeerbt69ef/11Sc7gLyYmRmeffbarK/DgwYO65557dOaZZ9INCAAAAAB+wggAGf9tnbERCCPAADzNKwHgrl279MADD6hnz5665JJLtGDBAtntdjkcDg0ZMkQvvfSS9u7dq88//1y7d+/W448/rpSUFDkcDn3zzTf65z//6Y0yAQAAAACdZIwAswNw6wgA4Uuqqqr0n//8R5dccol69+6tmJgYRUZGKj09XRMmTNCLL77YaMTf32RlZenhhx/Www8/3K7r9u7dK6vVKovFoujoaI9tZPvcc8/p4Ycf1po1azxyf48FgHV1dfroo4907rnnqm/fvnryySe1b98+ORwOhYWF6aqrrtI333yjtWvX6uabb1ZMjPNvh1JSUnTfffdp06ZNOu644+RwOPT+++97qkwAAAAAgBsZHYAxCaz/1xpbJAEgfMPChQvVv39/TZ48WbNnz1ZWVpbsdrtsNpv27t2rTz/9VHfccYd69eqlN954w+xyOyQrK0uPPPKIHnnkkXZd9/bbb7uWpysvL9cHH3zgifL03HPP6ZFHHvGfADArK0v333+/MjIydOmll2rhwoWubr9evXrpySef1J49ezRt2jSdeuqpLd4nMTFRd911lyRp586d7i4TAAAAAOABrhHgREaAW2OLjpDEGoAw1/vvv6/zzz9fu3fvVt++ffXGG28oNzdX5eXlOnTokMrKyvTpp5/q17/+tUpLS/XJJ5+YXbJXvfXWW5KkKVOmSJLefPNNE6vpOLeuyDp+/HgtWrRIDodDDodDkhQSEqLzzz9ft956q84991zXhh9tkZ6eLkmqrKx0Z5kAAAAAAA9xjQAnMgLcGjoAYbaffvpJkydPVm1trcaPH69Zs2YpOjq60TlRUVE677zzdN5552n58uVBNaX57bffasuWLerZs6f+8Y9/6L333tOyZcu0bds29evXz+zy2sWtHYANu/26du2q++67T9u3b9cnn3yi8847r13hn+T8Q5aRkaHMzEx3lgkAAAAA8IDa2lodOnRIktQlkRHg1rAGIMz2wAMPqKKiQmlpaZo+fXqT8O9Io0aN0nPPPdfk659++qkmTpyo7t27Kzw8XN27d9cvf/lL/e9//2vxXmPHjpXFYtHDDz8su92uF198Uccff7yio6MVHx+vs88+W1999VWL1+fn5+v//u//NHToUMXExMhms6lHjx46+eSTde+992rjxo2uc3v16qUzzjjD9c8Wi6XRr5bWBTS6/a666ipFR0frkksuafT1o6msrNTUqVM1duxYJScny2azKSMjQ+PGjdNLL72koqIiSdLDDz8si8WiXbt2SZJuuOGGRrX16tWr1We1hdv3ZD/99NN1yy236JJLLlFYWFin7jV69GhlZWW5pzAAAAAAgEc13CAgJrGLHA6HKssqFRoWqtBwt//46fcYAYaZcnJyNGfOHEnSnXfeqfj4+DZdFxJS30vmcDh0yy236NVXX3V9Fhsbq7y8PM2dO1dz587VbbfdpqlTp7bYFFZbW6uJEydq/vz5CgsLk81mU1FRkb744gt99dVXmjVrln75y182uiY7O1unnHKK9u7dK0myWq2KjY3Vvn37lJOTo1WrViksLEyPPfaYJOd+E8XFxSosLJQkdevWrdH9jH0pGqqoqNCMGTMkSZMmTZIkXXPNNXrzzTf19ttv669//Wuj34uGtm7dqgsuuEA///yz6/clPj5e+/fv1+7du7Vo0SKlpaXpoosuUkxMjLp166a8vDzZ7XbFxsYqMjLSda+UlJRmn9Febu0AXL9+vZYsWaIrrrii0+EfAAAAAMC/NAwAl3+0TL878XZd1+tqXd3jct150q2a+fQM5e3OM7FC38IIMMy0ePFi1/JtEydO7NA9nn32WVf4d++99yo/P1+FhYXKy8vTH/7wB0nSv/71L02dOrXFe7z00ktavny5ZsyYodLSUpWUlGjt2rUaPHiw6urqdNttt6murq7RNY888oj27t2rvn37avHixaqurlZBQYEqKyu1ZcsWPfHEE+rdu7fr/FWrVmn27Nmuf87NzW3065577mlS1+zZs1VcXKyhQ4dq8ODBkpxdi+np6a4QrzmHDh3Sueeeq59//llpaWl6//33VVpaqoMHD6q8vFyrV6/WPffcoy5dnF3S99xzj3Jzc9WzZ09J0vPPP9+otlWrVrX676Et3BoAHnfcce68HQAAAADAjxjdLpK06duNKsorcv3z/qz9mvevT/R/Y+7R3KlzVFdb19wtggojwDCTMSJrs9k0cODAdl9fXl6uRx99VJJ0xx136KmnnlJCQoIk58auf//73/Xb3/5WkjOwq6ioaPY+hYWFmjNnji677DKFh4dLkoYOHeoas927d6+WLVvW6Jrly5dLkh577DGNGTPG1YkXHh6uAQMG6L777tPkyZPb/T019N///ldSffef5Ozku+qqqyS1PAb89NNPa+fOnYqLi9PSpUt1xRVXuDr6rFarhg8frr/97W8666yzOlVfe7k1AAwJCVFoaKjmzp3brus+//xzWa1WhYbSEg4AAAAA/mjt2rWujh9JCrNFavDJZ+q8K+/U+MtuUd/jTpIk1dXWafbfPtTfrn5KFaXNBwLBwhgBrq6uVk1NjcnVINgYO3YnJCS0e88GSVqwYIEOHTokq9WqP//5z82e89BDDykkJEQFBQVauHBhs+ecfvrpOu2005p8/YQTTnBtDrthw4ZGn8XGOjcZys3NbXfdbbF792599dVXjQI/wzXXXCNJ+uijj1RcXNzkWmPX4LvuuqtRF6LZ3BoASnK1j3bkuo5eCwAAAAAwz/fff6+JEye61tdKjB+kWx9+S5f89kGdMv4ynT7hal3/x2d188NvqHtGf0nS5uWb9PdJT6usKHjXvzNGgCW6AOF/fvjhB0nSoEGD1L1792bP6dGjh4499thG5x/ppJNOavEZPXr0kCTXu8Vw/vnnS3KOHd96661atGiRW/879NZbb8lut2vs2LGuGgyDBw/W8OHDVVFRoenTpzf6LCsrS/v27ZMkTZgwwW31uIPbA0AAAAAAQPDYsmWLrrrqKpWXlyskxKr0tDOV0XOc4pKbLlzfLb2PbvzzvzT45DMlSdt/3KZ/3fxC0I4DGyPAEgEgvC8pKUmSM1zrSENWXp5zPc8jA7IjGV18Bw4caPZzYy285kREOLtkj+yQvffee/XLX/5S1dXVevnllzVu3DjFxsbq5JNP1qOPPqr9+/e3+ftojjHe23D8tyGjC/DIMeCGz83MzOxUDe7mEwGg8aIz/sUCAAAAAHxfSUmJJk2apMLCQlksFp1+6k1KSjhO4ZE2tTRRaA0N069u/LOG/MK5/tXGZT/pw6dmeLFq30EACDMNGjRIklRVVaXNmzebXE372Gw2ffzxx1q5cqXuu+8+nXbaaQoNDdWqVav00EMPqX///i1u0tGab775Rtu3b5ck/eY3v5HFYmnyy1juYPny5dq6davbvi9P8okAcMWKFZKkrl27mlwJAAAAAKAtHA6Hfv/73ysrK0uSdNUVDyqt+zBJki0i/KjXhoRYNfH6P6lHb+fGA/977VOtWbTao/X6oojo+iaY0tJSEytBMBo7dqxr7b/27uUgSSkpzi7fvXv3HvW8PXv2SPJM5nPSSSfpiSee0DfffKNDhw7po48+0jHHHKOSkhJde+21qq2tbfc9jc0/2qphF2DDUehdu3a1+9me1OFdN9atW6c1a9Y0+9mXX36pQ4cOHfV6h8OhsrIy/fjjj5o2bZosFstR574BAAAAAL7jgw8+0McffyxJOvnE83XuOZM1c+ZMSVJ4g862loSGheuyW/+qVx65URWlxXrrvv9owBdPKyo2ypNl+xTWAISZ0tLSNHHiRM2ZM0dTp07VlClTFB8f3+p1drtdISEhOvHEEyU5dxPOzc1tdh3AnJwcbdq0SZJzUw9PioiI0EUXXaSePXvqxBNPVE5OjrZu3erqdDR2CpacmVRzG5+UlZXpww8/lCRNmzbtqOv4zZgxQzfffLPeeecdPfbYYwoJCVFmZqZSU1O1b98+zZ8/XyeffHKb6zfq89T+GB0OAD/66CP99a9/bfJ1h8OhqVOntutexm/8zTff3NFyAAAAAABecvDgQT300EOSpOSkdE2+4WlZLBZVVDh39Q1vpQPQEJuQovOuvFOzX39MhbmF+uDJ6br+yd94rG5fE84IMEz22GOP6fPPP9fevXt1xRVXaPbs2YqKajmEX758ud5//3298MILOvvss5WQkKDCwkI98cQTeuGFF5qc/8gjj8hutyspKUlnn3222+qurq5WeHjz75nIyEjXcVVVlevY2DlYkg4dOqSEhIQm186cOVOlpaWKjo7WxRdf3OheR7rssst0xx13aM+ePVq4cKHGjx8vSbr++uv15JNP6vnnn9f111/f5p2Ajfpaa6jrqE6NABs79x65g++RX2/tV7du3fT666/rzDPP7PQ3BAAAAADwrL/85S8qKCiQJN1w3eOKjo6TJFcA2LCzrTWDTz5TA4adIkla8t5Xyt7oW2NznhQRXf/7VFYWvLshwzyDBw/W66+/LqvVqs8//1zDhg3Tf//730YbdpSXl+t///ufLr/8cp166qnKzs6WJEVFRenBBx+UJE2dOlX33Xefa7fegoIC/fGPf9Rrr70myfnOOFqY1l69evXSgw8+qO+//77RBiFr1qzRTTfdJMm5OcmQIUNcnw0YMEBhYWGSWh7zNcZ5zz///FbrTUhI0BlnnNHoOkn605/+pF69eqmoqEinn366ZsyY4Xo32u12/fDDD7r11lv1xRdfNLrf4MGDJUmzZ89WUVFRa78F7dbhDsCLLrpIvXr1avS1G264QRaLRbfffruOP/74o14fEhKimJgY9e7dW0OGDJHVau1oKQAAAAAAL/nhhx80Y4Zz046RJ1+oYUPPcH3m6gCMbFsHoCRZLBadd9Ud2v7TKtXV1mjGY+/rnnfvbXY8L9AwAgxfMGnSJCUnJ+vGG2/Utm3b9JvfOLtwo6KiFBYW1iiMio+P18UXX+z659/97nfasmWLXn31VT311FN65plnFBcXp6KiItntdknSrbfeqttvv92tNe/bt0+PPfaYHnvsMVmtVsXFxam0tFTV1dWSpJiYGE2bNk2hofWxV1RUlK6++mq9+eab+sMf/qCHHnpIycnJru/jl7/8pZYsWSJJuvTSS9tUx6WXXqoFCxbo448/VlFRkeLi4hQfH6/PPvtM559/vnbu3KkrrrhCVqtV8fHxKikpcdV4zjnnNLrXjTfeqPfee09Lly5VcnKyunbtqrCwMKWnp2vp0qWd/j3rcAA4bNgwDRs2rNHXbrjhBknSWWedpYkTJ3auMgAAAACAT3E4HHrkkUckSbbwSF191UOuz2pqalydOO3pAJSk+KTu+sW4S/Tt/6brp6UbtH7JOg0dO6z1C/0cuwDDV5x77rnavn273nnnHc2fP18//vij8vLyVFlZqfT0dA0bNkwXXHCBrrzySsXFxbmus1gseuWVV3ThhRfqlVde0XfffafCwkIlJSVp5MiRuuWWW3Teeee5vd4FCxZo0aJF+uabb7R7927t379fYWFh6t+/v8455xz97ne/U0ZGRpPrXn75ZfXs2VOzZs3Sjh07XBt1HDp0SG+99ZYcDociIyOPuvZfQxdddJFuueUWVVZWavr06ZoyZYokaeDAgdqwYYNeeuklzZ49W5s2bVJpaalSU1M1YMAAXXzxxU2mYMeOHas5c+bo2Wef1Zo1a5Sbm+sKUd3B4nDj6oJvvfWWJGcAmJ6e7q7bwgfk5+d3+NqEhARZrVbV1dW52oERPKxWq2tdiLq6OrPLgQl4B4D3AHgPgPdA4FiwYIGuvvpqSdKvfnmXLvnVH1yfFRcX69VXX5UknXDeSeo5sKckKTQ0TBaL5HBItbU1TW96WGV5qV7489WqKC1WnxF99eDHDwd8F6C9zq7f9L5WkvTQQw/pjjvuMLkiz2jLO8DoxPJ1xp/Jjx95SCcfM8DkappauWWrLvqLc7+GBQsWuHXdPfi3Tq0BeKTrrrtO1113HeEfAAAAAAQYh8OhJ598UpIUG5us88+d0uhzY/xXan8HoCRFRMVo1DmXSZJ2rN6uTd9u7ES1/iHEGqIwm3NNMjoAAXiSWwNAAAAAAEBgWrRokTZs2CBJunDCrYqMjGn0eXl5fQDYnjUAGzpp7C9li4yWJH0ydU4HK/UvxhgwASAATyIABAAAAAC06vnnn5ckxUTH64wxVzb5vKKiPsAK70AHoOTsAjz5zF9JkjZ9u1E71+7o0H38iS06QhIBIADP6tAmIH369JHknH3fvn17k6931JH3AwAAAACY77vvvtOKFSskSeecfYMiIqKbnNOwA9DWwQ5ASc7NQD6fobraGn3x5gLd9OzNHb6XPzDGpcvKykyuBEAg61AAmJWVJUlNFmTNysqSxWJRR/cVCfQFXgEAAADAH73wwguSJJstSueMu6HZc4w1AEPDQmUNtXb4WdFd4jX45DO19tvP9d0nK3T5A1cpNim2w/fzdYwAA/CGDgWAGRkZzYZ1LX0dAAAAAOCftmzZogULFkiSzhx7tWJi4ps9r/JwANjR9f8aOvnMX2ntt5+rtrpWX7+/WBfcPrHT9/RVEYdHgOkABOBJneoAbOvXAQAAAAD+6b///a8kKSTEqnPH39jieeWH1wDs6Pp/DaX1OkbpfQZpz46N+urdRTr/1gsUEhKYS9iHMwIMwAsC8w0KAAAAAOi00tJSzZgxQ5J0wohzlJSY2uK5xghwZ9b/a+iEMRdKkg7uPahNyza65Z6+KCKaEWAAnkcACAAAAABo1qxZs1RaWipJOuusa456boVrBLjzHYCSNOjEMQq3RUqSvvnwa7fc0xcZawDSAQjAkwgAAQAAAABNOBwO1/hv9+59dNyxpx71fKODLTzCPR2A4bZIDTpprCTph89WqawoMAMyYxdgOgABeFKH1gDsjIqKCr3yyiv65ptvVFtbq+HDh+uWW25RamrLreQAAAAAAO9atWqVfvrpJ0nSWWdMOuqGjw6Ho34EOMo9HYCSNOLU87Rm6WeqqarRyk9W6IxJZ7nt3r7CxiYgfmnTrmyzS2iWr9YF87k1AFy9erWuu+46WSwWvfLKKxo1alSjz4uLi3X66adrw4YNrq/Nnz9fL7/8shYsWKARI0a4sxwAAAAAQAe99dZbkqSwMJtOP/XSo55bVVUlh8MhyX0dgJLUs99gJaSkqTAvR98FagAYVd8B6HA4jhq0wnfc9583zS4BaBe3jgDPnDlTGzZs0IEDBzRy5Mgmn99///1av369HA5Ho18HDx7UJZdcoqqqKneWAwAAAADogNLSUs2bN0+S9IuTL1BMTPxRzy8vr3Adu2sNQEmyWCw67qQzJElbVmzWoQOH3HZvXxER5ewAdDgcqqysNLkaAIHKrR2A3333nSwWi84+++wmf2tRUlKiN954QxaLRT179tTzzz+v3r1766WXXtJrr72mXbt2adq0aZo8ebI7SwIAAAAAtNMnn3ziWpOute4/SaqoqF+/LtxNuwAbjjtprJZ++q4cDoe+/2yVxl13tlvvb7bwBiPTZWVlioyMNLEatGbBggVml9BmgwYNMrsE+BC3BoB79+6VpGZHeT/77DNVVlbKYrHojTfe0FlnOVu3X3nlFa1YsULr16/Xxx9/TAAIAAAAACabMWOGJCkpqYeOHTiqlbPrdwCW6je1cJdu6X2V1L2nDubu1qp53wVcANhwzUQ2AvF9Z58dWH/+EDzcOgKcn58vSc1u6LFkyRLXZ0b4Z/j1r38th8OhdevWubMcAAAAAEA77d69W8uWLZMknXbKxQoJaf3HxobBlbs7AC0Wi447cawkaevKLSrMLXTr/c1mjABLBIAAPMetAWBRUZHzps38D8Ty5ctlsViahH+SlJGRIUnKy8tzZzkAAAAAgHb64IMPXMennXpJm64xOgAtFotbNwExGOsAGmPAgcR2xAgwAHiCWwPAqKgoSU2DvKKiIld33ymnnNLkuogI59941NXVubMcAAAAAEA7OBwOVwDYv98JSu3ep03XGQFgWESYLCHu38U2Ja2XklMzJUkrP1nh9vubiRFgAN7g1jUAe/XqpfXr12vp0qW67bbbXF+fN2+e7Ha7LBaLTj311CbXHTx4UJIUFxfnznLgRlar1afuA/9h/Dvn3z0k/hwEK94DaIg/B8GJ94D/+P7777Vjxw5J0umnXdqm8V9Jqqxw7l5ri7Q12RCyoaN9djTO3YDHasnct7Tth59VcrBEcSmB8fNjZEz9ph8VFRUB+d8T3gGA+dwaAJ5++ulat26d5s6dq7Vr12rYsGEqLi7WM888I0lKS0vT4MGDm1y3YcMGSVLv3r3dWQ7cKCEhodP3sFqtbrkP/FNsbKzZJcBkvAPAewC8B8B7wPd99tlnkiSrNVRjRl/qmtZqTWXV4QAwyqbQ0OZ/zLRY1OJnbXHcCaO1ZO5bcjgc2rT0J4298swO38uXxCbU//fCYrEE9HsyEN4BHQ2xzbBgwQI2LYGLWwPAm266SS+//LIqKyt18skna8SIEdq+fbsKCgpksVh00003NXvdl19+KYvFoqFDh7qzHLhRYWHHF9qNjY2V1WpVXV2diouL3VgV/IHValVsbKyKi4sZ8w9SvAPAewC8B8B7wD/Y7XZNnz5dkjT4uNMVFhqpysrKNl1bWloqSQqPCFdtbW2jz6zWUFksksMh1dXVNnd5m6T06KMu8ckqOZSvVf9bqZG/arq8lF8KrQ+UDhw40KmfvXxVW94BgRx8Ar7ArQHg0KFD9Ze//EV/+ctfVFNTo1WrVsnhcLg+++Mf/9jkmvXr12vz5s2yWCw67bTT3FkO3Mhd/0eN/8MXvOrq6vj3D/4MBDneA5B4DwQ73gO+bcWKFdq3b58k6RcnXyC73d7ma+vXAAx3/QzYnKN91hb9h/5CP349X+uXrFN1ZbVCw936I60pwmxhruOSkpKA/u9IIL0Drn/yN8o4NtPsMprI3rRLb973H7PLgA9y+9vywQcf1LBhw/T6669r27Ztio6O1jnnnKP/+7//U2RkZJPzp06dKsn5PwTjx493dzkAAAAAgDb4+OOPJUmhoeE68fj2/WxmbF5hi7S1cmbn9B8yUj9+PV+VpZXaunKzBp3WdIkpfxNmc26c4rA72ATEj2Qcm6kBJx9jdhlAm3nkr0smTpyoiRMntunc1157Ta+99ponygAAAAAAtEFdXZ3mzp0rSRo2ZKyiotq+VltdXZ2qq6slSeGR4R6pz9Dn2BNkDQ1TXW2N1n65JiACQIvFoojoCFWUVBAAAvCYtm3pBAAAAAAIWN9++63y8vIkSb/4xYXturaion6dwHAPdwCGR0Sq98ARkqQ1i9Z49FneZHROlpWVmVwJgEBFAAgAAAAAQc7o/gsPj9Dxw8e169qGXWue7gCUpP5DR0qS9u/MVe6OfR5/njfYop27LdMBCMBTCAABAAAAIIjZ7XZ9+umnkqRhQ85QRER0u643NgCRPL8GoORcB9Cw9ss1Hn+eN9ii6AAE4Fke2zJpzZo1+uyzz7RhwwYVFha2aft4i8WiRYsWeaokAAAAAMARvv/+ex04cECSdMIJ7d+YsaLCux2ACSmpSureUwdzd2vj0p80/sbzPP5MTzOCUzoAAXiK2wPAffv26YYbbtDChQvbdZ3D4ZDFYnF3OQAAAACAo5g/f74kyWoN1YhhZ7X7+vLy+g5AT68BaOhz7Ak6mLtbm1dsUm1NrULDPNbb4hW2aAJAAJ7l1hHg0tJSnXHGGVq4cKEcDke7fgEAAAAAvMvhcLjGfwcde4qio+PafQ9jBDjEGuK1IK7PoBMkSVXlVdqxertXnulJtijnGoCMAAPwFLcGgM8++6y2bt0qSUpPT9fLL7+sbdu2qbKyUna7vdVfdXV17iwHAAAAAHAUGzduVFZWliTpxOPbP/4r1Y8A2yJt8tZQV69jhsticf44+9PSDd55qAcxAgyzXH/99bJYLE1+xcTEaODAgbrpppu0du3aJtf16tWryTUhISGKj4/XiSeeqAceeEC5ubmtPv+rr77SjTfeqGOOOUaxsbGKiopS7969deWVV+qjjz7yxLcctNwaABr/crp3765Vq1ZpypQp6tOnj8LDPb8OBAAAAACgfYzuP4vFouOPP6dD9zA6AL2x/p8hIipGab2PkSRtXPqT157rKRGMAMNkYWFh6tatm+tXZWWltmzZon//+9868cQT9corrzR7XXR0tOuapKQkFRUV6YcfftDjjz+uwYMHa8WKFc1ed+jQIU2cOFFnnnmm3njjDW3dulW1tbWyWq3KysrS9OnTdfHFF2vUqFHas2ePJ7/1oOHWAHD79u2yWCy69dZb1a1bN3feGgAAAADgZsb6f/36Hq+E+I79DFcfAHpn/T9D74HHS5J2rNmuitKKVs72beHsAgyTnXLKKcrNzXX9Ki8v14IFC9SvXz/V1tbqtttua7YT8J577nFdk5eXp+LiYr3yyivq0qWLDh48qEsvvbTJprBFRUU6/fTT9cknnyg8PFz33nuvtm3bpvLycpWUlCgnJ0fPPPOMunTpohUrVmjUqFHKzs721m9FwHJrAGi32yVJxxxzjDtvCwAAAABws6ysLP30k7N77sQTzu3wfYwA0ObFDkCpfh3Auto6bflus1ef7W4Rh9cApAMQviI8PFxnn3225syZo7CwMNnt9ha7ABvq0qWLpkyZon/+85+SpL1792rOnDmNzpkyZYo2bNigiIgIffbZZ3rqqafUt29f1+epqan64x//qGXLlikpKUl79uzRlVde6cqc0DFuDQAzMzMlSSUlJe68LQAAAADAzYzxX0k68YSOrf8n1YdW3u4A7Nn3OIWGO5/p72PAtsMdgFVVVaqtrTW5GqDeoEGDdOKJJ0qSvv/++zZfN2nSJIWEhDS57ocfftCMGTMkSY888ojOPPPMFu8xZMgQ/etf/5Ikffvtt/r444/bWz4acGsAOHHiRDkcDi1btsydtwUAAAAAuJkx/pvR81h169qrw/dxjQBHeLcDMDQsXJn9h0iSNvr5RiBGACjRBQjfk56eLsk5uttWERERSkpKanLdq6++KkmKi4vT7bff3up9Lr/8cvXv37/RtegYtwaAd9xxhxISEvTuu+9q82b/bsEGAAAAgEB18OBBrVq1SpJ0Qgc3/5Ck6upq1dXVSWocYnlLr8PrAO7ZskclBf47iWY7PAIsEQDC9+zatUuSlJCQ0OZrysrKlJ+f3+S6r776SpJ0zjnnKCoqqk33+uUvfylJWrZsGR2yneDWADA1NVXTp09XaGiozj77bH399dfuvD0AAAAAwA0WLVokh8MhSRoxfFyH71NeXr/5hrc7ACUpc8BQ1/HWVVu8/nx3aRieshEIfMmqVatcI7wjR45s83WvvPKK6x1jXFdTU6Nt27ZJkoYPH97mew0bNkyS878bRhiJ9gt1583++te/SpLGjRunOXPm6IwzztDw4cM1atQoJScnu+a/j+ahhx5yZ0kAAAAAgCMsWLBAkhQXl6JemUM6fJ+KivpuNW+vAShJaZkDFBpuU211lbau3KITxp/o9RrcISK6vgOQABC+ICcnR4sWLdKf/vQn2e12hYeH67bbbjvqNXV1ddq5c6feffddPfnkk5Kkfv366YILLpAkFRQUuM41xoPbIjk52XV88ODBRhuGoO3cGgA+/PDDslgskiSLxSKHw6E1a9ZozZo1bb4HASAAAAAAeE5NTY1rDG/40DPb1KjRkkYdgCaMAFtDw5TeZ5CyNq/WVj/eCdgWyRqAMNeSJUtcec6RoqKi9Oabb2rAgAFNPnvkkUf0yCOPNHtdZmamaxdhmM+tAaAkV4tnS/98NC39YQMAAAAAuMfKlStVXFwsSRo+/KxO3cvYAESSbCaMAEtSZv+hytq8Wrt+2qWK0gpFxkSaUkdnhDMCDJOFhYUpMTFRkjObiYqKUnp6uk4//XT99re/VUZGRrPXRUdHKyYmRpIUEhKiLl26qF+/fjr33HN1/fXXq0uXLq5zjftLzk6+tjLWEjzyHmgftwaAxt8iAQAAAAB8kzH+GxoarsGDTuvUvRqPAJsUAB5eB9BeZ9f2H7dp8OiOjzSbJSKaDkCY65RTTtHixYvbfd0999yjhx9+uE3nhoWFqW/fvtq+fXu7JkXXrl0rydmJmJmZ2e4a4eTWAHDMmDHuvB0AAAAAwM0WLlwoSRp4zC8UGRnTqXsZI8BhtjCFWN26x2SbpfcZpBCrVfa6Om35brNfBoANR4DpAEQgO/PMM7V9+3YtWLBA5eXlbdoJeM6cOZKkU089lXHiTjDnDQ0AAAAA8LodO3bo559/liSN6OT4ryRVHh4BNmMHYEOYLUJpmcdIkrau9M+dgBvuAkwHIALZb3/7W0lSUVGRXnzxxVbPnzFjhuudNWXKFI/WFugIAAEAAAAgSBjdf5I0fNiZnb5f+eERYDM2AGkoo7+z62/7mu2qqaoxtZaOsEXV7wJMAIhAduKJJ+rSSy+VJP3lL3/Rl19+2eK569evd+08PGrUKP3qV7/ySo2ByuMB4J49e7RgwQJNnz5db7/9tqcfBwAAAABogREApqX1U7euvTp9P2MTkIYjrGbIHDBMklRbVaMda7abWktHhFhDFGZzjjYyAoxA9/rrr2vQoEGqrKzUeeedp/vuu087duxwfZ6bm6u//e1vOu2003Tw4EGlpqbq/fff79SO5fBgAPif//xHxx13nDIzM3Xeeefp6quv1g033NDkvMcff1znnHOOJk+e7KlSAAAAACDolZaW6ttvv5UkDR/a+fFfqb5bzawNQAw9+w12HW/74WcTK+m4iGhnFyAdgAh08fHxWrp0qc4//3xVV1frqaeeUt++fRUdHa3Y2FilpqbqT3/6k4qLi3XyySdrxYoVbP7hBm4PACsqKjRhwgTddNNN2rx5sxwOh+tXc0488UR98cUXevPNN7Vp0yZ3lwMAAAAAkLR48WLV1DjHY92x/p/UoAMwwtwOwMjoLkpOdQYE237cZmotHWWMURMAIhgkJCRo/vz5+uKLL3TDDTeoX79+slgsqq2tVWZmpi677DLNnDlTK1asUEZGhtnlBgS37gIsSddee60+++wzSVKvXr105ZVXqrCwUK+88kqz55999tlKSUlRfn6+5s2bp2OPPdbdJQEAAABA0FuwYIEkKSoqVv37ndDp+9ntdlVWVkqSwqPM7QCUpPS+g5S/b5e2r94mh8Mhi8VidkntYoxRMwIMb3rzzTf15ptvtvu6rKwstzz/rLPO0llnuecvJHB0bu0AXLRokWbNmiWLxaIrr7xSW7Zs0eOPP67x48e3XEBIiM4++2w5HA4tXbrUneUAAAAAAOQM67744gtJ0tAhYxUaGtbpexrdf5IUbvIagJKU3meQJKk4r0j5u/NMrqb9GAEG4EluDQCN1LhPnz568803FRbWtv9RGTbMuWArI8AAAAAA4H5r165VXp4zFHPH7r+SVF5eHwCavQmIVB8AStL21f43BmyLogMQgOe4NQBctmyZLBaLrr322jaHf5KUlpYmybnTCwAAAADAvYzxX4slRMOGjHXLPSsq6jvVzN4ERJJS0jIVHhElSdr2AwEgADTk1gBw//79kqRjjjmmXddFRDhbnY31IwAAAAAA7mMEgP37Ha8uXRLdck9f6wAMCbGqR++Bkvy7A5ARYACe4NYA0Gq1SnKuL9EeBQUFkpxbQQMAAAAA3Cc3N1fr1q2T5L7xX8n3OgCl+jHg7J92qbqy2uRq2ocOQACe5NYAsFu3bpKkbdva97ctP/zwgySpZ8+e7iwHAAAAAILewoULXccjho1z232NDsAQa4hCwzu/qYg7pPd1BoB1tXXatT7L3GLayRbFJiAAPMetAeApp5wih8Ohjz/+uM3XlJWV6cMPP5TFYtFpp53mznIAAAAAIOgZAWBSUg+lp7dvuaajMYIqW6RNFovbbtsp6b3rNwLZ5mdjwHQAAvAktwaAv/71ryVJq1ev1n/+8582XXPLLbeosLBQknT11Ve7sxwAAAAACGqVlZVasmSJJGnEsLNkcWNSV1np7AD0lfFfSYrqEqfEbumSpO0//GxyNe0T0aAD0OFwmFwNgEDj1gDwggsu0MiRI+VwOHTzzTfrySefVGlpabPnrl69WhMmTNC7774ri8Wi8847TyeffLI7ywEAAACAoLZs2TJXp5471/+TGncA+pL0PsdK8r+NQIwOQIfDwQaZANzOrQGgJM2YMUPdu3dXbW2tHnjgAXXt2lW/+93vXJ+fdNJJSk1N1Yknnqj//e9/cjgc6tmzp9588013lwIAAAAAQc0Y/w0Pj9CgY09x670rKg53AEb5VgCY1su5E3BhbqEOHThkbjHt0PD3kTFgAO4W6u4b9uzZU999950uv/xyrVixQpWVlcrOzna1mv/444+N2pl/8YtfaNasWUpOTnZ3KQAAAAAQtBwOhysAPG7QaQoPj+jQffbty9XevXtVWFCgOnudwsLC1a1bV1dIFR7hOyPAktTjcAAoSVnrd2r4WSNMrKbtjBFgiY1AALif2wNAyRkCfvvtt/rkk0/01ltv6euvv1Z+fr7r85iYGI0ZM0bXXXedLr30Uk+UAAAAAABBbcuWLcrOzpYkjRh+Vruuraur09q1a/XDDz/o0KFDRz/Z2sECPaRbz76yhITIYbdr59odfhMA2hp0ABIA+r7sTbvMLqFZvloXzOeRANBw4YUX6sILL5TkfIEdOnRIMTExio2N9eRjAQAAACDoLViwwHU8bGjb1//btWuXPv/8cxUVFTX6enREhMJDQ1VeVaWqmhrX1/MO5mnHjh3KzMyU1Wp+GhgWblPXHr21f/d2Za3baXY5bWZjBNivvHlf2zY+BXyFRwPAhqKiohQVFeWtxwEAAABAUDPGfzMzjlNSYmqr59vtdi1Z8rW+/36V62vJsbEa1reP+qelKdLmHPV1OKSd+/drzrfLJUmWsBDl7stVSUmJjj32WIWHmz8SnJZ5jPbv3q6d63fK4XC4dfdjT7FF0wEIwHO8FgACAAAAALyjsLBQK1eulCQNH9b6+G91dbU++eQT7dixQ5JkCwvTmCFDdGxmT4UcEZ5ZLFJEWJjrn2NjolQtu8pKy7R+3XodN/g4RUR0bL1Bd0nrfYxWL/1UxXlFKswtUGJqkqn1tIUtsv73jA5A39VwTwPAn3QoAPzrX//q7jpcHnroIY/dGwAAAACCwZdffim73S6p9fX/qqur9eGHHyonJ0eSlJqYoAknn6wuUZEtXlNRVeU67pfRQ4XVZdp3sEBVVVXa+NNGDR4yROHhYS1e72lpmce4jneu3eEXAWAEHYAAPKhDAeDDDz/ssRZqAkAAAAAA6Bxj/De2S5L69B7W4nlHhn/9e6Tp3BNPUGgra/lVVFe7jm0RYcqM7yqrNUR7DuSrsrJSmzZt1JAhQxQSEuKG76b9uqX3kTU0THW1Ndq5bqdOOPckU+poD9YABOBJHX4bOxyOVn+1dt6RnwMAAAAAOqe2tlaLFi2SJA0bekaLIZzD4dD8+fNd4d/Anuk6/6STWg3/JKn8cAegxSKF25ydfj2SktQ9MUGSVFZapp07zduAwxoapm7pfSXJbzYCCY8kAATgOR3qAPzqq6+O+vnUqVM1e/ZshYSE6JxzztFZZ52lfv36KTo6WmVlZdq2bZsWLVqkBQsWyG636+KLL9btt9/eoW8AAAAAAFBv5cqVOnTokCRp+LCWd/9dsmSJtm3bJknql5aq8SecoJCQtk16GR2AYeFhrukwiyzK7NZVFVXVKior0/7c/YqNi1Nq99Y3IPGEtF4DlJO1WTvX+cdGIGG2MIVYQ2SvszMCDMDtOhQAjhkzpsXP7r77bn300Uc69thjNX36dA0ZMqTZ837/+99rw4YNuvzyyzV79mxlZGToH//4R0fKAQAAAAAcZoz/Wq1hGjKk+Z/d1q1bp1WrnLv9dkuI17knntjm8E+SKqucAWB4RON1/iyyqF+PVK3fmaXqmlrt3LFDSYlJstm8vzNwWi/nOoBlh0qVl52nrpldvV5De1gsFtmibKooqSAABOB2bl2QYeHChXr++eeVmJioL7/8ssXwzzB48GB9+eWXSkhI0HPPPacvvvjCneUAAAAAQNBZsGCBJOnYgb9QVGSXJp/n5eW5RoS7REZq4siRCgttfey3oYpq5wiwLaLpRh9h1lD1Se0uSaqtqdX2w12G3pbWa6DrOGvdDlNqaC9blHMnYEaAfZfFYvGbX8ZfBgCSmwPAV155RRaLRZMnT1a3bt3adE23bt00efJkORwOvfrqq+4sBwAAAACCys6dO7V161ZJ0vBhTXf/ramp0SeffKLa2lpZQ0J0wS9OVkxkRLufU95CB6AhPjpGKfFxkpyBY0FBQbuf0VnJ3TNkDXXWl71xl9ef3xHGRiB0AAJwtw6NALfk+++/lyQNHz68XdeNGDFCknOtCgAAAABAxxjdf5I0YnjTAPDLRV/q4MGDkqRTjxvk2rSjvSoObwJibADSnMyuXVVYUqraujpt375dJ5zQsWd1lDU0VN3S+ygna4uyN2Z79dkdZQSAdAD6vt9c/6QyM441u4wmdmVv0n/evM/sMuCD3BoAHjhwQJJUdfh/DNrKON+4HgAAAADQfsbIX1paP3Xr2qvRZ9u3b9e69eskSb27d9Px/fp2+DnGJiBHCwBDrValpyQrK3e/ysvKtW9fjrp29e46fN169lNO1hbt2pDl1ed2VAQdgH4jM+NYHTPgZLPLANrMrSPACQnOv9FZsmRJu64zzo+Pj3dnOQAAAAAQNEpKSvTtt99KkkYcMf5bVVXl6g6Mstl0zvHHd3hX3Nq6OtXU1kqSbBFH39yjW0K8omzOUGtX1i7V1dV16Jkd1b2nM+QsyivSoQOHvPrsjggnAATgIW4NAEeOHCmHw6Fp06Zp+fLlbbpmxYoVmjZtmiwWi0aOHOnOcgAAAAAgaHz11VeqqamRJI0YPq7RZ4sXL1ZpaakkaeywoYqKsHX4Ocb6f1LLawAaLLIoo7uz66+mpkb7cnM7/NyOSM3o7zrevcn3x4DZBASAp7g1AJwyZYokqa6uTuPHj9crr7zi+h+gI9XU1OjVV1/Vueeeq9rDf3t0yy23uLMcAAAAAAgaRodfdHSc+vc7wfX17OxsrVvnHP3tm5aqAT16dOo5FQ2WfDraCLAhMaaLYiIjJUk5e/d6tQuwW3pf6XCnoz+MATMCDMBT3LoG4Pjx4zV58mS98cYbKisr02233aY///nPOvXUU9WvXz9FRUWpvLxc27Zt07Jly1RUVCSHwyFJmjx5ss455xx3lgMAAAAAQaGurk5ffPGFJGnYkDNktYa6vm6sC2gLC9OZw4apg5O/Lsb6f1LrHYCSJIvUs2uKNu3KVm1Nrfbl5iq9kyFkW4VHRCqpa7oO7t/tFxuBsAswAE9xawAoSa+99pqioqL04osvyuFw6NChQ/r000+bnGcEfxaLRXfccYeeffZZd5cCAAAAAEHhxx9/dO3uO7zB7r8//PCDCgoKJDl3/Y2JjOj0sxp2ANraEgBKSugSo5jISJVWVCg3Z5/SUtMUEtLJJLKNuvfs6wwAf8ryyvM6gxFgAJ7i1hFgyRnoPf/88/r666910UUXKTw8XA6Ho8kvm82mX/3qV/rmm2/03HPPdXgBWgAAAAAIdsb4b0iIVcOGjJEklZaWujYF6RofryG9e7nlWe3uADwsLTlJklRdXa38/Dy31NIW3Q+vA7h/535VllV67bkdQQcgAE9xeweg4dRTT9Wpp56q6upqrV27Vjk5OSotLVVMTIx69OihoUOHKjz86DtGAQAAAABaZwSAA/qfpOjoeEnOjT+MNdnPGDZUIW5qujA6AENDrbJarW2+Lim2i2zhYaqqrlFOTo66du3qlnpa0z2jnyTnFNruTdnqf+IArzy3I4wAsKqqSrW1tQoN9diP7ACCjMffJuHh4TrppJM8/RgAAAAACEq7d+/Wxo0bJUkjDo//7t2bo02bNkmSjsvMUFpSotueZ3QAtqf7T3JOi3VPTNSu3P0qLytXUVGR4uLi3FZXS7r37Oc6zt64y8cDwPoR7fLycsXGxppYDQJZZ6YwjSXdGjp06JBef/11zZ8/X1u2bFFBQYHi4uLUp08fnXvuuZoyZYpSU1PbdH+73a6ZM2dq7ty5WrFihQ4cOKCqqiolJCRoyJAhOuuss3TNNdeoh5fWEg0U/HUCAAAAAPgxo/tPkkYMcwaAS5YsliSFhYbq1OMGufV5FVUdCwAlqWtcrPYcyFOd3a79ufu9EgDGxCUqJi5RpUUF2rVhl8ef1xlGB6BEAAjP6tatW7NfLyoqUmVlpcLCwpSY2La/OPjwww918803u9YbtVgsio+PV0FBgfLy8vTdd9/p73//u5555hndeuutR73X6tWrdfXVV7v+AkOSbDaboqKidODAAX3xxRf64osv9PDDD+uBBx7QAw880MbvGG5fAxAAAAAA4D1GANitWy+lpvbVzz//rL1790qSThzQX9ERnd/4oyFjBLgjAaA1xKqkOGeodbDgoKoPjyh7mtEFuHujbweAEdH1ASAbgcCTcnNzm/11+eWXS5JOOeWUFs9p6N///rcuv/xyFRQUaPjw4Zo7d64qKipUUFCgqqoqffXVVzrjjDNUVlam2267TU888USLNS1evFinnXaaNm3apO7du+u5555TVlaWKisrVVhYqMrKSi1evFg33XSTq0sQbUcACAAAAAB+qqSkREuXLpXk7P5zOBz6+uuvJUnRERE6vl9ftz+zotoZANpsHVvTvVt8vCTJYXfowP4D7irrqIx1AHdv2aPamlqvPLMjGo4AEwDC161du1a33367HA6HLrjgAn333Xe68MILZbM5g2yr1aqxY8dq0aJFmjJliiTpwQcf1FdffdXkXkb4WF5eruOPP17r1q3TXXfdpczMTNc54eHhGjNmjF577TWtW7dOQ4YM8c43GiAIAAEAAADATy1atEjVh9fkO+H48Vq3br1rDG/ksQMV7oFNJMpdI8Adu3d0RIRiIp1B14H9+9XMcmJuZ3QA1lbVKHfHPs8/sINskY1HgAFf9sADD6iqqkqpqamaNm1aixu9WiwWTZ06VUOGDJHdbte9997b5Jynn35aBw4cUHR0tGbNmqWUlJSjPnvgwIF666233PJ9BAsCQAAAAADwU5999pkkKSYmQb0yh+rbb5dJkhK7dNHgBp0z7mK3O1R5OHC0RXSsA1CSuibES5IqKytVVHTIDZUdXfeM/q7j7J98dwzYxggw/MTevXs1f/58SdLtt9/e6nqeYWFhruBv1apV+v77712f1dTU6N///rck6ZprrlGvXr3aVENICJFWe/C7BQAAAAB+qLq6WgsXLpQkHT/ibK1Zs9YVGp123CCFhHR8l8+WlB9e/0+SwjsRACZ1iZXV6vxxdP/+/Z2uqzWJKWkKt0VKknb5cgAYRQcg/MPixYtduwFfdNFFbbpm4sSJrtBu8eLFrq+vWrVKpaWlrnPgGQSAAAAAAOCHli5dqpKSEknSsCFnujpq0pIS1Sc11SPPrGgQANo6sAmIwRoSoqTDO9wWFhSqtrau07UdjSUkRF3T+0iS9mza7dFndQZrAMJfbNy4UZJzh96BAwe26ZouXbqod+/ekqT169c3uZckDR8+3H1FohECQAAAAADwQ8b4ry08UlWV0aqsrJQkjRw4UBb3N/9JatwBaIvseAegJCUfDgDtdrsOFhzs1L3aomsPZ/Cwe4svB4B0AMI/GGuNJiQktGsUNzk5WZJ08GD9f+cbHicmJrqpQhyJABAAAAAA/IzdbncFgMcdd7rWrFkrSUpLSlJG164ee27jEeCOdwBKUpeoSNnCnPfIz8vr1L3aotvhDsDivCIVHyz2+PM6gk1AECyMzYvgPQSAAAAAAOBnfvzxR9faeQlx/VR1OJgbdaznuv8kqaKq/of2zmwCIkkWWZQU5+wCLCoq8nggYHQAStKezb7ZBRhiDXGtrcgIMHyZ0alXWFgou93e5uvy8/MlSfHx8a6vJSUluY6NzkK4HwEgAAAAAPiZTz/9VJIUEmJVYYHzx7oeyUnqmZLi0eeWVzuDxrDwUNcmHp1hjAHLIeUdDgY8pVuPPq5jXw0ApfoxYDoA4cuOPfZYSVJVVZU2b97cpmtKSkq0c+dOSdKAAQNcXx80aJDreM2aNe4rEo0QAAIAAACAH3E4HK4AMLX7saqrc7b8jTr2WI92/0n1m4B0dvzXEGWzKTrCGXh5egw4MiZWXeKd64/t8eF1AMMJAOEHxo4dK8vhF87HH3/cpmvmzp3r6hYcPXq06+snnXSSYmJiXOfAMwgAAQAAAMCP/Pzzz9q+fbskKdTaTZKUnpysninJHn92WaUzAOzs+G9DSXFxznuXlqmiosJt922OMQa8Z/Mejz6nMyIO7wTMCDB8WXp6us4//3xJ0osvvqiioqKjnl9TU6Onn35akpSamqozzjjD9VlYWJgmT54sSXrnnXeUlZXVphraM3oMAkAAAAAA8Cvz5893HUdF9pTkXPvPG4wOQJubOgAlKalLF9dxw91APaHr4Y1A9m7d47PhASPA8BePPvqowsPDtW/fPk2aNKnFdTwdDofuuOMOrV+/XpL0wAMPKCys8Tvk3nvvVUpKisrKynTJJZcor5WO4M2bN+u6665zzzcSJAgAAQAAAMCPGLv/Rkd1V3hYF6UnJyvdC91/Uv0uwO4aAZYkW1iYoiOdXW8FBz27AUC3wx2AVeVVys/2/M7DHWEEgHQAwteNGDFCL7zwgiwWi+bNm6eRI0dq3rz/Z+++49uur/2Pv7QlS97bsZM4e5FBdshgl13GbSldt/e2vb3tbcul7b3tLe399cLtuLe3g67bAreFFuhgJgRogQIBwkpCFknITpzEdrxtybZkS/r+/tCIQ5aH7K9sv5+PRx5IlvTVcRKc+J1zPmdtcilRJBJh3bp1XHbZZfzqV78C4Nprr+Wzn/3sKdcqLS3lD3/4Ax6Ph7fffps5c+bwk5/8hKqqquRzurq6ePnll/nMZz7D7Nmzk4Gi9I7d7AJERERERESkd44ePcrmzZsByPSNB2DR1ClneUXqGMaJADCVI8AAeZmZtHcGCQQChEIhXC5XSq+fkOgABDi65yhF44sH5X0GQgGgDCef+cxnyM7O5nOf+xybN2/m2muvxWq1kpOTQ2trK5FIJPncj3zkI9x7773JswPf6+KLL+bll1/mox/9KLt37+bWW2/l1ltvxe124/F4aGlpwTAMADweD7fccsuQfI4jhToARUREREREhoknn3wyeTsnaxJFOTmMLSoakvfujoQJx7+Zd3lSHwAmDOYYcGHpOCzW2LfB6boJWCPAMtx86EMfYv/+/Xzve99j5cqVFBQUnBL+/fGPf+SBBx7A7Xaf9VoLFixgx44d/OEPf+CWW25hwoQJ2O122tvbKS4u5tJLL+X73/8+Bw8e5Ktf/epgf2ojijoARUREREREhonVq1cD4Hbl43LlsnDK5EHf/JuQ6P6D1I4AA3icTjwuF52hEE2NTZSVlaX0+gl2h5P8onIaaqvSOADUEhAxz3333cd9993X59fl5uby1a9+9aRQrrq6miVLlnDkyBF+8YtfcN11150zAASw2WzcfPPN3HzzzX2uQ85MHYAiIiIiIiLDwJEjR9i0aRMAOdmTyfX5mDRmcIKy0+nsEQCmegQYIC8r1gXY5m+jq6s75ddPKCpPbAJO1wBQHYAyMpSVlfHMM8+QnZ3NunXr+NCHPnRSV6AMLQWAIiIiIiIiw8B7x3/nT56Mdaja/4COYM8AMLUdgAB5mb7YDQOamgZvDLhoTOwcwNqDtXSHBi9o7C+3Vx2AMnLMnDmTxx57DIfDwerVq/nUpz6VPMdPhpZGgEVERERERIaBNWvWAOB2F5CfU8r0sRVD+v4njQCn+AxAgAyXC5fTQairm+amZkpKSlL+HgDF8UUg0UiU6n3VjJs5blDep79cnhMdgIZhnHFhgshwcfHFF9PV1WV2GaOeOgBFRERERETS3Enjv1mTOH/SJOy2of12rqMrFgBaLBacztT3kliwkOuLdQHGFghEU/4eAEVjKpO303EMODECbBgGwWDQ5GpEZKRQACgiIiIiIpLmeo7/FuVP57zx44e8ho5grIPH5XYMWldaTjwAjEajtLa2Dsp75BaU4nDFxmzTMgD0nliSoDFgEUkVBYAiIiIiIiJp7qGHHgJi479LZszH6Rj605wSS0Ccg7AAJCErw4PVGvs2tbm5eVDew2K1UlQ2HoCju9MwAIyPAIMWgYhI6igAFBERERERSWNHjhxh9+7dAORlT2HuxAmm1JE4A9DlSf0CkASrxUqONwOA5uamQXufxCKQtOwAzFAAKCKppwBQREREREQkjf36179O3l40YyUZLtdZnj14Eh2ArkHsAIQTY8Bdoa5BG4EtjHcANtc209GWXiGby3vi11cjwCKSKgoARURERERE0lhi/NfjLmLV3KWm1dGRHAEevA5AOBEAwuCNAReWndj8W72velDeo7/UASgig0EBoIiIiIiISJp66623aGqKjcJOGrsguSV3qEUNg86uxBKQwe0AdNrteN2xRRiDFwCOT96u3ntsUN6jv9wZWgIiIqmnAFBERERERCRNffvb347fsnDVkvebVkcw1IVhGEBsC/Bgy8mMBZ1+v5/ucDjl18/KLcTpjp01mG4BoDoARWQwDP3qKBERERERETmnUCjEm2++CUBeznimjZ1kWi2J8V8Ap2dwOwABcrxejtU3gAGtLa0UFOSn9PoWi4XCsnEcO7Ar/QJArzoAh4PDVbvMLuG00rUuMZ8CQBERERERkTT0wx/+kEgkAsDSmZdgsZhXS88AcCg6AH0eNzablUgkSmtLS8oDQIDC0lgAeCzNAkCNAA8Pv77v38wuQaRPNAIsIiIiIiKSZgzD4L777gPAarFz5dJrTK2n86QAcPA7AC1YyPZ6AWhpaRmU90icA9h4tIFge3BQ3qM/7E47NocNUAAoIqmjDkAREREREZE0s27duuTyjwnlc/B5Mk2tp73nCPAQdAACZHkzaGrzEwqF6OwM4vG4z/2iPigsPbEJuGZfNZVzJqT0+gPh9npobwkQCATMLkXeI3EWpshwow5AERERERGRNPOd73wnefuyheZ2/wG0B2Mdcg6nHbvdNiTvmRPvAARoaUn9NuC03gTsjS0CUQegiKSKAkAREREREZE0sm/fPjZv3gyA05HB/GlLTa7oxBmAriFYAJLgdjhxO2Pdhq0trSm/fnZeEQ5nrKsw3c4BdMXPAVQAKCKpogBQREREREQkjdx1113J24tmrMJuG5qR27PpiHcADsX5fz0lzgFsbW1N+eilxWqloHQskIYdgL5YAKgRYBFJFQWAIiIiIiIiaaKxsZFHHnkkef/iBeaP/wK0B2MdgO4McwLASCSC3+9P+fULy2LnAB7bk2YBoDoARSTFFACKiIiIiIikifvuu49wOAxAcV4FlaVTTa4opiMU7wAcwhFgiC0CsVhitwdjG3Bh6XgAGo7UE+oMnf3JQ0gdgCKSagoARURERERE0kAoFOJXv/pV8v6F51+FJZF+mShqGHSEuoChHwG2W2143bEwrK21LeXXT3QAGoZB7f6alF+/v3QGoIikmgJAERERERGRNLB69Wqam2Pbbi0WK0vPu9TkimI6Q6Hk+XtD3QEIkBUfA/YH/EQi0ZReO9EBCOm1CMTjUwAoIqmlAFBERERERMRkhmGc1P03Z9Jicnx5JlZ0QuL8PwC3GQFgRgYARtTA709tF2BOYQl2R+xzSqdFIIkOQI0Ai0iqKAAUEREREREx2aZNm9i2bVvy/oq5V5hYzckSG4DBnA7ATI8nOQrdmuIxYKvVRkFJ+m0CdnvVASgiqaUAUERERERExGT33HNP8rbPk8WcyYtNrOZkPTsAzQgAbVYrPk/8HMC21pRfP3EOYFoFgPER4K6uLrq6ukyuRkRGAgWAIiIiIiIiJqqtrWX16tXJ+8tmX4bd5jCxopO1xzcAWywWXG5z6sqMjwEH/AEikUhKr10QPwfw+KHjdIe6U3rt/kqMAIO6AEUkNRQAioiIiIiImOj+++8/KdS6cN7VJlZzqkQHoNPtMG0rcXbiHEDDoK3Nn9JrJzcBRw1qD9am9Nr9legABJ0DKCKpoQBQRERERETEJKFQiPvuuy95f+rY2ZQVjjOvoNPoiHcAmrEAJMGX0eMcwBSPAScCQIDqPekxBuxWB6CIpJgCQBEREREREZOsXr2ahoaG5P0Lz7/GxGpOryPeAWjG+X8JNkuPcwBbUxsA5hWOwWqzA+lzDqDL60reVgAoIqmgAFBERERERMQEhmGcsvxjwfQVJlZ0eu3xLcBmBoAAWV4vAO2B9pSeA2i12SgoqQDg2J6jKbvuQHi8nuRtjQCLSCooABQRERERETHBpk2b2LJlS/L+8rlX4LCbG7KdTkco1gFo5ggwQFZGLBSLnQPYltJrF5am1yZgdQCKSKopABQRERERETFBz+4/SL/lHwDd4Qih7thmXJfb3AAw0+PBao2fA5jiMeCCsvFAbBNwuCuc0mv3h1sdgCKSYgoARUREREREhlhtbS2rV69O3p8+fh4l+eUmVnR6ie4/MH8E2Gqx4vPEgrG21lR3AI4FIBKOUFdVl9Jr94dbHYAikmIKAEVERERERIbY/ffff9I5dhfNv9bEas4scf4fmB8AAmRmZACxUCyV5wAWlIxN3q49UJOy6/aXS1uARSTFFACKiIiIiIgMoVAoxP3335+8n+XN4fypy0ys6Mx6BoBmnwEIsTFgiJ0D6PenbjQ2r7gcLLHx4pp91Sm7bn9ZbVacnlgXoEaARSQVFACKiIiIiIgModWrV1NfX5+8v2LOldhtDhMrOrOOYPqMAEMsAIzndLT5UzcG7HC6yMkvBqBmv/kBIJwYA1YHoIikggJAERERERGRIWIYxknLP6wWKxcvSM/xX4D2UKwD0GazYnfaTK4GbFYrGe7YeKw/xZuAE2PANfvNHwEGcHtjn6c6AEUkFRQAioiIiIiIDJFNmzaxZcuW5P3zpy0nP7vYvILOIbEExOVxYsFicjUxiTFgv9+PYRgpu25+IgDcV53S6/aXKx4AqgNQRFJBAaCIiIiIiMgQ6dn9B/C+xTeZVEnvJM4ATIfx34TEIpBoJJrScKygtAKAjrYO2hpS213YHx51AIpICikAFBERERERGQK1tbWsXr06eX986RQmlc80saJzS5wBmA4LQBIyMzzJ220pHANOu03A6gAUkRRSACgiIiIiIjIE7r//fiKRSPL+5YtuxGJJj7HaM0nHDkCnzY7bGavH3+ZP2XV7BoDpsAnYlaEAUERSRwGgiIiIiIjIIAuFQtx///3J+9m+PBbNvNC8gnohahjJANCd4TK5mpNlxbsAU9kB6M3KxZ3hA9JjE7DHpxFgEUkdu9kFDKXW1lYeeeQR3nrrLRobG3G5XEycOJGrrrqKJUuW9Pu64XCYtWvXsm7dOqqrY39QjBkzhlWrVnH11Vdjt5/9p/nAgQM8/vjjbN++nba2NrKzs5k1axY33ngjlZWVp33N8ePH+fSnP33O2r761a9ywQUX9P2TEhERERGRlFmzZg319fXJ+xfPvxa7zWFiRefWGQoRjS/DSKcRYABfhoe6lla6u7vp7Azi8bgHfE2LxUJ+SQXHDuxKi03A6gAUkVQaNQFgVVUVt99+O62trQB4PB7a29vZsmULW7Zs4dprr+1VoPZenZ2dfPOb32TPnj0AOOOt6Pv27WPfvn2sX7+eO+64A7f79H8grVu3jrvuuotwOAyA1+ulsbGRdevWsX79em677TZWrFhx1hqysrKwWk/fzJmoR0REREREzGEYBnfffXfyvt3m4KL515pYUe8EOoPJ2+nWAZjpyUjebmtrTUkACLEx4GMHdqXFCLBbHYAikkKjIgDs7u7mP//zP2ltbWXcuHF86UtforKyklAoxOrVq3nwwQd58sknqays5NJLL+3TtX/xi1+wZ88evF4vX/ziF5OdhG+88QY/+clPePfdd/nf//1fbrvttlNeW1VVlQz/li9fzqc+9Sny8vJoamrinnvuYf369fz4xz+msrKS8vLyM9bwgx/8gOLi4r79pIiIiIiIyJDYtGkTW7ZsSd5fMutisry55hXUS4FgzwAwvRoL3E4HDruN7nAEf5s/Zd8PJc4BbDjaQFewC6fbvM/b3aMD0DCMtD8vUkTS26g4A/Avf/kLtbW1uFwu/v3f/z05VutyufjgBz/IlVdeCcADDzyQ7MTrjYMHD/Lyyy8D8IUvfIGlS5disViwWCwsXbqUz3/+8wC89NJLHD58+JTXP/jgg4TDYSorK/nyl79MXl4eAHl5eXzlK1+hsrKS7u5uHnzwwQF9/iIiIiIiYp577733pPuXLbrRpEr6pj2NOwAtWMjMiHUBtvlTuAm4NBYAGobB8UPHU3bd/kh0ABqGQUdHh6m1iMjwNyoCwJdeegmAlStXUlhYeMrjN910ExaLhaamJrZv397r665btw7DMCgtLWXp0qWnPL5s2TJKS0sxDIN169ad9Fh7ezsbNmwA4Prrr8dms530uM1m4/rrrwfgrbfe0hd8EREREZFhqLa2lieeeCJ5f+q4OYwrmWReQX0QCHYCYLVZcbjSb3gs0xNbBBLsDNLV1Z2Sa6bTJmCX98RYs84BFJGBGvEBYGdnJ3v37gXg/PPPP+1zCgsLkyO2W7du7fW1t23bBsC8efNO245tsViYN2/eSc9N2LlzZ7Lb8Ex1JT7e3d3Nrl27el2XiIiIiIikh/vvv59IJJK8f/kw6f4DemwAdmIh/cZPM+ObgAH8AX9KrplbWIY13pxh9ibgxAgwKAAUkYFLv3/GSbGjR49ixDdXjRs37ozPGzduHEeOHOHIkSO9uq5hGBw9evSc1x07NvYvSO+9buJ+Tk4O2dnZp31tdnY22dnZtLa2UlVVxfz580/7vP/+7/+murqaUChEdnY2U6ZM4dJLL2XhwoW9+lxERERERCT1QqEQ9913X/J+YU4p86acOjmUrhJLQDxpNv6bkOFyY7VaiEYN/H4/+fEjlQbCZreTW1BG4/Ejpm8CTowAgxaBiMjAjfgOwKampuTtvLP8gZB4rLm5uVfX7ezsJBj/F7HeXLezs5POzs7kxxPvc7bX9rauvXv3YhgGVquVxsZGXn/9de68807+67/+i+7u1LTCi4iIiIhI36xZs4aGhobk/UsWvh+r1XaWV6SXRAegy5OeAaDVYsHrjm/KbUtNByBAQWkFYP4IsDoARSSVRnwHYLDH5iqX68x/cCUe6xnSnU3P5/XmuonXeOLnVCRef7bXnq0up9PJVVddxYoVK6isrCQjfgBuVVUVjz76KC+++CLr16/H6/Uml5GczQMPPMBDDz10xsdvueUWPvzhD5/zOqdjtVqT/83NTf9tZ5JaifH47OzsZDeujC76GiD6OiD6OiCj8euAYRj8+te/Tt53Oz1cvOA67HaHiVX1TWILcIbPhdWWmt6RVF0nITMjA39HJ4H2ADabDYtl4NcvLBvP7i2vUXugFrfbbdr23ez8kyfFhvPXz9H4NUAk3Yz4AHCkys3N5R//8R9P+fjYsWO57bbbyMrKYvXq1Tz33HNcf/31yTMOz6S9vZ26urozPt7R0XHKopK+slgsA76GDF+Jb/5k9NLXANHXAdHXARlNXwfeeOMNNm7cmLy/ct6VeD0+Eyvqm3AkSmcoBIA7TTsA4cQ5gNFIlPb2djIzMwd8zcLS2BFPoY4gzbVN5JcVDPia/eHxnTjjsLOzc0R8/RxNXwNE0s2IDwDd7hNt06FQKNkp916h+B9uiQ69c+n5vMRrz3bd974mcftsr+1PXQkf+chHeOaZZ+jq6mLDhg3nDAC9Xi9FRUVnfDwjI+Okw4v7wmq1YrFYMAyDaDTar2vI8GWxWLBarUSjUf1r3yilrwGirwOirwMyGr8O/OQnPznp/uWLb2I4feqBHhNI7jQ9AxBObAIGaG1tw+cbeABYUHrijPeje46SV5o/4Gv2h6vHCHBbW1u/vx9LB735GjASAk6RdDbiA8CeZ+w1NTWdMQBMnBXY27Zqj8eDx+Ohs7PzpHMGz3TdxPPfW9fZXtufuhLcbjdjx45l3759HD9+/JzP/+hHP8pHP/rRMz7e0NDQ6/MR3ys3NxebzUY0Gu33NWT4stls5Obm0traOqz/0iL9p68Boq8Doq8DMtq+DtTW1vKnP/0peX/O5MUUZJcQDg+f87lbeiydcLodRCP9D+97jv0O5DqnY7facDkchLq7aW1tobj4zE0NvZVbUJq8fXjnISYvmjLga/ZLj+/Wjx8/Pqy/fvbma0BBgTmdliKjxYjvvy0vL0+eN1BVVXXG5yUeq6io6NV1LRZLsquuP9dN3G9paaGtre20r21tbaW1tRU4sU1YRERERETS2/33339SyHH5optMrKZ/2nt2AHrTtwMQwOeJdcr5/alZBOLxZeHNjDVgmLkJ2OFyYLHGvpfVEhARGagRHwB6PB4mT54MwNtvv33a5zQ0NHDkyBEA5syZ0+trz549G4DNmzef8Tlbtmw56bkJM2bMwG63n7WuxHUdDgfTp0/vdV0QW36SCB+Li4v79FoREREREemfUCjEfffdl7w/pnA8MyrPN6+gfgr0WKbo9jhNrOTcfInjlYIhurpS02WZX2L+JmCLxYI7fg5goEdHpohIf4z4ABDgwgsvBODll1+mvr7+lMcfe+wxDMMgLy+P8847r9fXXblyJRaLherqal5//fVTHn/ttdeorq7GYrEka0jIyMhg4cKFAKxevfqUNuhIJMLq1asBWLRo0Smjy+c6O+X3v/89XV1dWCyW5PuIiIiIiMjgWrNmDQ0NDcn7ly26wbQtsgORCAAdTjt2e3qfzZZYBALgD6SmC7CgNB4A7jcvAIQT5y+qA1BEBmpUBIDve9/7KCkpIRgMcuedd3Lw4EEg9q9zjzzyCE899RQQOwcv0ZWX8KlPfYrrrruOH//4x6dct7KykpUrVwLw05/+lDfeeAPDMDAMgzfeeIOf/exnQCyAPN0I70c+8hHsdjv79+/nhz/8YfJMh+bmZn74wx+yf/9+HA4HH/nIR0557de//nX+9Kc/cfDgwZPCw6qqKu666y4ef/xxAC677LJzLgAREREREZGBMwyDu+++O3nf68lk6XmXmlhR/yVGgNN5AUhChsuNNT4qm6ox4IKS2PdvzbXNdAY6z/HswaMOQBFJlRG/BARiI7Tf+MY3uP322zl06BC33norGRkZBIPB5Ca6a665hksv7fsfzp/73Oeoqalhz549fOc738HpjLXHd3V1ATBt2jQ++9nPnva1Y8eO5dZbb+Wuu+7ilVde4dVXXyUjIyP5rzt2u51bb731tAFefX09DzzwAA888AA2m42MjAy6urpO2iq8atUqPvOZz/T5cxIRERERkb7btGlT8ggggAvnXYPL4T7zC9JYe7wD0J2R3uO/AFaLBa/bjb+jk0BbagNAgOMHahk/uzIl1+0rdQCKSKqMigAQYmHbT3/6Ux599FHeeustGhoa8Hq9TJgwgauvvpolS5b067oej4fvfe97rF27lnXr1lFdHWsRnzhxIhdeeCFXX331KV2FPa1atYqKigoee+wx3nnnHdra2pKjyDfeeCOVlaf/g+YTn/gEW7duZe/evTQ3N+P3+7HZbJSWljJt2jQuueSSU84dFBERERGRwXPvvfcmb1stVi5Z+H4TqxmYQGciAEz/DkCInQPo7+gk0B7AMIwBj10XlJ4IAKv3V5sWALq8sQBZAaCIDNSoCQABcnJy+OQnP8knP/nJXr+m5x/iZ2K327n++uu5/vrr+1XXhAkT+MpXvtKn1yxfvpzly5f36/1ERERERCS1amtreeKJJ5L3F0xfSV5WoXkFDYBhnDgDMN0XgCQkNgFHI1Ha29vx+XwDul52fjE2u4NIuNvUcwDd8QBQI8AiMlCj4gxAERERERGRwXT//fefdDb35YtvNLGagekKh+kOh4Hh0wGY6emxCCQF5wBarTbyixObgGsGfL3+SgSAHR0dptUgIiODAkAREREREZEBCIVC3Hfffcn7lWVTmThmhnkFDVCg88TSi+FwBiCA0+7A5XAAqVwEEgsAaw+YHwCm6nMSkdFLAaCIiIiIiMgArFmzhoaGhuT9yxbdOOAz6MyUWAACw6cDEE6MAacqLMuPnwNYe7CWaCSakmv2lTtTW4BFJDUUAIqIiIiIiAzAPffck7yd7c1j0YxVJlYzcP6TOgCHUwAYC8tCwRBdXd0Dvl5BfAQ4HOqm4WjDOZ49ODxeBYAikhoKAEVERERERPpp06ZNbN68OXn/ovnXYrc5TKxo4BIjwBaLZdgsAQHIzDhxDmAgMPAuwPz4CDCYNwbs9sU+p66uLkKhkCk1iMjIoABQRERERESkn3p2/9msdi6cf42J1aRGogPQ7XUNq1HmDNeJev3+gXfMFfQIAGv2mxMAejJTu9xEREYvBYAiIiIiIiL9UFtbyxNPPJG8v2jmheT48swrKEUSHYCeYTT+C2C1WPG6YzW3p2Bk1uXx4svOB8zrAPT4FACKSGooABQREREREemH+++/n0gkkrx/2cIbTKwmdfwd8QDQO7wCQDhxDqA/4McwBn49szcBu33u5G2dAygiA6EAUEREREREpI9CoRD33Xdf8v6EMdOZMGaaeQWlUGIEeDgGgF53LDCLhCMEg53nePa5Jc4BrNlXPeBr9Yc6AEUkVRQAioiIiIiI9NGaNWtoaDixGXakdP+FusOEumMbdIfbCDCAz3OiY86fgo65/Pgm4Ja6Fjr9HQO+Xl/1DADVASgiA6EAUEREREREpI96Lv/I9uaxcMZKE6tJnUT3H4Db6z7LM9OT2+nEZot9mxtIQcdcQenY5O3aA7UDvl5fubUERERSRAGgiIiIiIhIH2zatInNmzcn71+84FrsNoeJFaVOoONEl9twHAG2YMHnjoVmqeiYO2kTsAnnAPYMYdUBKCIDoQBQRERERESkD3p2/9msdi48/xoTq0mtnh2AwzEABPDGx4Db29uJRge2CSQ7vxibPRbu1uwf+nMAdQagiKSKAkAREREREZFeqq2t5YknnkjeXzzzIrJ9eeYVlGKJANBqs+J0D8+uxsQ5gEbUoL2jfUDXslpt5BWNAaB2/9B3AFptVlzxsxgVAIrIQCgAFBERERER6aXf/va3RCKR5P1LF11vXjGDIJDYAJzhwoLF5Gr6JzECDCk6BzA+BmzGGYBwogtQAaCIDIQCQBERERERkV4IhUL85je/Sd6vLJvKhLJpJlaUeokOwOE6/gvgtNtxOWLdi6k4Ny+/JLYI5PjBWqLR6ICv11duX6yjUWcAishAKAAUERERERHphTVr1tDQ0JC8f/H860ysZnD4O4Z/AAgnzgEM+FO3CKQr2EVTddOAr9dX6gAUkVRQACgiIiIiItIL9957b/J2htvHopkXmlfMIDCMEx2A7ozhHQD63LEAsLOzk3A4PKBr5ffcBGzCIhC3L3VbjUVk9FIAKCIiIiIicg6bNm3i7bffTt5fPud9uBxuEytKvWBXF+H4+YYe7/D+3HyeHucADjA4K4iPAIM5i0A8meoAFJGBUwAoIiIiIiJyDvfcc89J9y86/1qTKhk8ie4/GAEjwG43iR0m/gGOAbszfHgzcwGoOTD0AaDbqw5AERk4BYAiIiIiIiJnUVtbyxNPPJG8P338PEoLKs78gmEqcf4fDP8A0Ga1kuGKfQ7tKQjOCkrjm4DVASgiw5QCQBERERERkbP47W9/SyQ+Ggtw8fyR1/0H4O/sSN4e7iPAcOIcQH9g4MFZ4hzAWhM6AD3xLcAKAEVkIBQAioiIiIiInEEoFOK+++5L3s/25TFv6gXmFTSIEiPAdocNu9NmcjUD542fA9jd1U0oFBrQtfKLY+cANtU0EWwPDri2vui5BCQajQ7pe4vIyKEAUERERERE5AzWrFlDfX198v7KuVdht9lNrGjwBOIBoMfrwpI4QG8Y83lOdDH6B7wI5MTI91B3ASYCQMMw6OjoOMezRUROTwGgiIiIiIjIGdx7773J2xaLlQvPv9rEagZXogPQkzH8x38BMlwurNZYkBkY4PhsvokBoMeXuo3GIjJ6KQAUERERERE5jU2bNvH2228n78+dvIT87CITKxpciSUgHt/wXgCSYMES2wbMwIOz3IJSrPHOz5ohXgSSWAICOgdQRPpPAaCIiIiIiMhp3HPPPSfdv2iELv8AiEaNHiPAI6MDEMDnOXF+nmEY/b6O1WYjr2gMYG4HoAJAEekvBYAiIiIiIiLvUVtby5o1a5L387OLmTVxgYkVDS5/ZyfReECW4Rs5AWCiAzAaidIR73Dsr8Q5gEPdAejuEcgqABSR/lIAKCIiIiIi8h6//e1v6e7uTt5fOfcKrJaR++1TW4/lEp4RFAD2XAQSCAzwHMDiWABYe6B2SLfx9hwB1hmAItJfI/dPMBERERERkX4IhULcd999yfsWLCyfc4V5BQ2BngHgSOoAdDkc2O02AAKB9gFdK7EIpKszRHNt84Br6y23RoBFJAUUAIqIiIiIiPSwZs0a6uvrk/fPm7RwRC//gBMBoNVqwe1xmlxN6liw4EsuAhlYeFZQOjZ5u3YIx4C1BEREUkEBoIiIiIiISA/33nvvSfdXzr3KpEqGjj8eAHq8biwWi8nVpJY3vgiko71jQKO7BfERYICaIVwE4nQ7sdpi37orABSR/lIAKCIiIiIiErdp0ybefvvt5P0sbw5zpyw1saKh0RZfkDGSzv9LSHQAGoZBe3v/x4A9viwyfNkA1OyvTkltvWGxWJKLQHQGoIj0lwJAERERERGRuHvuueek+8tnvw+7zW5SNUMnMQKc4XWZXEnq9VwE4h9ggJY4B3AoR4DhxBiwAkAR6S8FgCIiIiIiIkBtbS2rV68+6WMr511pUjVDJ2oY+DtjHYAjaQFIgsNmx+VwANDuT1EAOIQjwACe+CIQjQCLSH8pABQREREREQHuu+8+wuFw8v7UsbMpya84yytGhvbOYPJsvJE4Agzg9aRmhLagJLYIpPFYI6HO0IDr6i23AkARGSAFgCIiIiIiMuqFQiHuv//+kz62ct7IX/4B0Bof/4XYEpCRKHEOYGdnJ+FwpN/XKSg5EQgfP1g74Lp6y+3TGYAiMjAKAEVEREREZNR74oknaGhoSN73uLwsmL7CxIqGjr9HADgSR4DhRAcgDCxEy+8RANbsG7oxYI0Ai8hAKQAUEREREZFRzTAM7r777pM+tvS8S3A5RmYY9l6JBSCxbbMjbwkIxDsALbHbgUD/Q7TcgjKsNhswtOcAJpaAKAAUkf5SACgiIiIiIqPaW2+9xbZt20762Kq5o2P8F04EgB6vC6vFYnI1g8NmteFxOoGBdQDa7HZyC8oAqBnKANCnLcAiMjAKAEVEREREZFS75557AEhkX+NKJjOudLKJFQ2tto7YBuCRugAkweeJh2gD3ARcUBrfBLx/6AJAt1cdgCIyMAoARURERERk1Dp27Bhr164FwDBiH1s1SpZ/JCQ6AEfq+X8J3vgikK6uLrq6uvp9nfzieAB4oAYj8ZtmkLnjI8DBYJDu7u4heU8RGVkUAIqIiIiIyKj1m9/8hkjkxFZYp93F4lkXm1jR0DIMI7kEJGOEnv+X4OuxCMSfgkUgwfYgLcebB1xXbyRGgEFjwCLSPwoARURERERkVOrs7OR3v/sdQPLsu4UzVuJ1+8wsa0i1B0NEolFg5I8AZ7jcWOK/zgMZAy4oGZu8XTNEY8A9A0CNAYtIfygAFBERERGRUenRRx+lqakJgGh8lHPlKB3/hZE/Amy1WPC6Y12O7SnoAISh2wTs7vFrowBQRPpDAaCIiIiIiIw6hmFw7733AuC02wEoyStnSsV5ZpY15Frb25O3R3oHIIDXc2Kbbn+P78vwZePxZgHmdABqBFhE+kMBoIiIiIiIjDqvvfYaO3bsAKArHAZi3X+JEdHRojXeAWi1WvB4R34A6IsvAgmHwwSDwX5dw2KxJLsAa/ZXp6y2s/FkagRYRAZGAaCIiIiIiIw699xzDwB2mw0Am9XG8jmXm1mSKRIdgB6vO3kO4kjm7bEIJBDof5BWkNwEXDvgmnrDrTMARWSAFACKiIiIiMioUlVVxTPPPAOQ7PibN2UZWd5cM8syRSIAzMgc+d1/AB6nE5s19m3wQEZpEx2AjUcb6Ap2paS2s8nIzEjebmtrG/T3E5GRRwGgiIiIiIiMKr/5zW+IxjffdifHf680syTTtLbHRoC9PUZMRzILlmQXYCoCQMMwOH7oeEpqO5ueI8AKAEWkPxQAioiIiIjIqNHe3s7vfvc7ALK9sa6qvKwiZk1YYGZZpghHIgQ6O4GRvwG4p8Q5gO2Bdox+bgIpKBmbvF07BItArDZrchOwAkAR6Q8FgCIiIiIiMmo88sgjtLa2Aie631bMvQKr1WZmWaZIfP4AGaOkAxBOnAMYjUZp7+g4x7NPL6+oDEt8lHioFoEkxoATv39FRPpCAaCIiIiIiIwKhmEkl39kZ8TCFAsWVs69wsyyTJM4/w/AO0rOAATweU6EnQF//8aAbXYHuQWlANQMQQcggCceAGoJiIj0hwJAEREREREZFV555RV2794NQDgaAeC8SQvJzy42syzTtPbofsvwjZ4OQKfdjsMe6/hMxTmAtQeGJgDMyFIHoIj0nwJAEREREREZFe6++24A3E4n7cEQACvnXmVmSaZKdAA6XQ4cTrvJ1QwdC5ZkF2Ag0P9uuvziEwFgf88S7AtPVqxmnQEoIv2hAFBEREREREa8gwcP8uyzzwKQn5kJQJY3l7lTlppZlqkSAWDGKBr/TfDGF4F0dHQQiUT7dY2C0tgikE5/J631g9+Vl6ERYBEZAAWAIiIiIiIy4t19993JLq3qpiYAls95H3bb6Ol8e6/EEhDvKFoAkuCLLwLBgPb2/o0BF8RHgGFoFoFoBFhEBkIBoIiIiIiIjGitra089NBDAEwoKU4GgSvnXmlmWaYyjB4dgL7R2AHYYxFIP88BTIwAA9QOwSKQxBIQjQCLSH8oABQRERERkRHtgQceoCO+8KIl3vU2bdwcSvLLzSzLVO3BIOFIbBHKaOwAdNhsuJ0OoP+bgL1Zubg8XmBoFoF4MhPnFgaIRvs3tiwio5cCQBERERERGbHC4TD33HMPAGOLCmmKn5+2at7VZpZlupM2AI/CMwDhRBdgfzsALRZLcgy4ZggCwIysWNhoGIbOARSRPlMAKCIiIiIiI9aTTz7JsWPHAMjKiI1Qet2ZzJ++wsyyTJcY/wXI8I2+DkAAb/wcwGAwSHd3uF/XKCiJLQIZihHgjKwTv04aAxaRvlIAKCIiIiIiI9avfvUrAAqys9hVdQSAZbMvxWl3mlmW6RIBoNVqweN1mVyNOZKLQBjAOYDxDsD6I/V0h7pTUteZJDoAQQGgiPSdAkARERERERmRNmzYwKZNmwCYXlFBJH5u2mgf/4WTF4BYLBaTqzGH1+WG+Kc+0ADQiBrUHTqeqtJOy9PjrEZtAhaRvlIAKCIiIiIiI9L//u//AuB2OjhYGwtnJo6ZTnlRpZllpYXW+DKUjFG4ACTBZrWS4Yp1PwYC/TtTLzECDIN/DmBGfAswoDMARaTPFACKiIiIiMiIU1VVxVNPPQXAshkzONrQAMDKeVeZWVba6NkBOJr53LHPv78dgHlFYyDeQTnY5wBmZJ8IANUBKCJ9pQBQRERERERGnHvvvZdofOQ3GOoCIMPtY8msi80sKy10hyO0B4MAeEdxByCA1xP7/Lu7ugmFQn1+vd3hJLegFBj8DkBPjw5AnQEoIn2lAFBEREREREYUv9/PAw88AMCyGdN5/d13AVgx5324HKO74w2gtaMjeTsjc3T/fCQ6AGEA5wAWx84BrNlfnZKazsSV4cJqi30LrwBQRPpKAaCIiIiIiIwoDz74YPKMtILsLAzDAOCi+deaWVbaSIz/AmT4RncHoMflwmqNjfD6B7gIpHZ/TfL32mCwWCzJLkAFgCLSVwoARURERERkxIhEItx7770ATKso59V3dgAwc8J8SvIrzCwtbfQMAL2jvAPQarHgjXcBtvv7FwAWxAPAjrYO/I2DG8wllrYoABSRvlIAKCIiIiIiI8YzzzzD4cOHATh/0kSa4qHOJQveb2ZZaSURADrdDuwOu8nVmM/bYxFIfxr4Eh2AADWDvAjEk6UOQBHpHwWAIiIiIiIyYvziF78AoDA7i11VRwHIyypizuQlZpaVVloCsQDQlzW6x38TvJ5YABiJROgMdvb59QUlY5O3awd5EUhGPADUFmAR6SsFgCIiIiIiMiK8+eabbNiwAYArFixg8/79AFw0/xpsVpuZpaWVlngH4GjfAJzgc5/4eQjEz47s0+uz83C6Y8HcoHcAxs8A9PejThEZ3RQAioiIiIjIiPDzn/8cgAyXi/ZgEACb1c7KuVeaWVZaiUSjtCkAPInb6cAW367bn03AFosleQ7gYAeAOgNQRPpLAaCIiIiIiAx7e/fu5ZlnngHghguW8vSGjQAsnL6SbF+emaWllbaODqLxg+688XHS0c6CJdkF2J8AECC/OL4JWCPAIpKmFACKiIiIiMiwl+j+s1mtZGZkEOzqAuCShVr+0VPi/D8Ar84ATEqcA9je3k402vdNIIlFIPVVdYS7wimtrSctARGR/lIAKCIiIiIiw1ptbS0PP/wwANcsWsjj618DYELZNCaVzzSztLRzUgCoEeAkXzwANKIGHR3t53j2qQpKY4tAopEodVV1Ka2tp0QHYDAYJBQKDdr7iMjIowBQRERERESGtXvuuYeueMff5PIxHG9uAeCKJR/AYrGYWFn6aWmPjbi63A4cTrvJ1aQPn9udvO3vxxhwQXwEGKBmf3VKajodb44vebulpWXQ3kdERh4FgCIiIiIiMmz5/X7uu+8+AFbMmskz8bP/8rOLmT99hYmVpaeWeLil8d+TOe0OnI5YINru73sAmFdcDvGwuXYQF4F4s73J2zoHUET6QgGgiIiIiIgMW7/73e+S56GtnDWLHYerALh80Y3YrDYzS0tLiRFgb6YWgLxXoguwP4tAHE4X2XlFwOAuAukZAKoDUET6QgGgiIiIiIgMS11dXfzyl78EYNb4cbz+7rsAeFxeVs670szS0lIkGqWtowNQB+DpeD2xn5OOzg4ikUifX18QXwRSM4gdgBkKAEWknxQAioiIiIjIsPT4449TUxMLW65ftoQXtmwFYNW8q/C4vGd76ajU1t5B1IhtuNUCkFN5E+cAGhAI9H0RSH5JbBHIYAaA3uwTnZsaARaRvlAAKCIiIiIiw45hGPzsZz8DoKKwgF1VRwCwWqxctugGM0tLWy3tPTYAqwPwFIlNwACBgL/Pr090ALa3BPA39f31vaERYBHpLwWAIiIiIiIy7Dz//PO8Gx/5vWn5BTzx2hsALD3vEvKzi80sLW019zjbTh2Ap7JbbbidTqB/5wDml5zYBDxYi0CcHhc2R+xsS3UAikhfKAAUEREREZFhxTAMfvSjHwGQ4/NS3dhEJBrFgoVrLviIydWlr9Z4B6DL7cDhtJtcTXpKdAEG+rEJuKB4bPJ2zSAtArFYLMkuQHUAikhfKAAUEREREZFh5bXXXmPDhg0AfGDFch5f/xoAi2ZeSGlBxdleOqq1xLvavFnaAHwmiUUgoVCIru7uPr02M7cAhysWIA5WByCcWASiAFBE+kIBoIiIiIiIDCuJ7r9Mj4dAZ5Du+MbWay74sJllpb3m+GILnf93Zj53z3MA+9YFaLFYKChObAKuTmldPakDUET6QwGgiIiIiIgMGxs3bmTdunUA/M2KC3hs/XoA5k9dTkXxBDNLS2uRaJS2jg5A5/+djdftwmKxAP0bA06cAzhYI8CgAFBE+kcBoIiIiIiIDBuJ7j+Py0lXOEyoOwzAtSt09t/ZtLZ3YBgGoADwbKwWKxkuF9C/TcD5JbFzAOsP1xGO/95MtcQIsJaAiEhfKAAUEREREZFhYfv27Tz77LMAvH/JEh555VUAZk9azPjSKWaWlvZaem4A1gjwWXkTi0D6sQm4IN4BGAlHaDhSn9K6EtQBKCL9oQBQRERERESGhR//+McAOO122kOhZPffTRf9vYlVDQ8t8Q3AoADwXBLnAIa7wwSDwT69NjECDFAzSItAvDnqABSRvlMAKCIiIiIiaW/Pnj08+eSTAFyxYD5PvfkWAEtmXsy4kklmljYsJDoAXR4nDofd5GrSm8/T/0Ug+cXlyduDtQgk0QHY2dlJKBQalPcQkZFHAaCIiIiIiKS9u+66C8MwsFmttLS3EzUMbFYbN174d2aXNiwkOgB1/t+5eVwurNb4IpA+BoBOl4esvCIAagdpEUjiDEDQGLCI9J4CQBERERERSWuHDh3i0UcfBWDlrJm8vP0dAFadfzVFeWVmljZsJDoANf57bhYseONjwP3ZBFxQHBsDrh2sEeAeAaDGgEWktxQAioiIiIhIWvvRj35EJBIB4GhjIwBup4frVnzMzLKGjXAkQltHJwA+BYC94vPEfp4C7YHk9uTeSpwDWHOgNuV1wckBoDoARaS3FACKiIiIiEjaOnDgAH/84x8BmDuxkr3HYueqXbfio+T48swsbdhoCbQnQyxvVobJ1QwPiQ7AaCRKR2dnn16bCAD9jW0EWvreQXguGgEWkf5QACgiIiIiImnrBz/4AZFIBAtwsLYOgOK8MVy26EZzCxtGmnqcY+fLVgDYGyctAvH7+/TagpKxyduDMQbs7fFrqBFgEektBYAiIiIiIpKW9u7dyyOPPALAxLJSWuOLLG657LM47E4zSxtWmgOxAMtisWgJSC+5HA7sNhsAgUB7n15bEO8ABKgZhEUgGgEWkf5QACgiIiIiImnpf/7nf4hGo1gtFvbXxM5Tmz1pEXMmLzG5suGlOb7IIsPnxmbTt4C9YcGS7AIMBPrWAZiVW4jd6QIGpwPQ6XFhc8TCSXUAikhv6au/iIiIiIiknV27dvH4448DkJmRgWEYOB1uPnbFF7FYLCZXN7w0JzYAZ6v7ry+88UUgHe0dRKPRXr/OYrWSX1wOQO0gdABaLJZkF6A6AEWktxQAioiIiIhI2vn+97+PYRhYLZbk6O8Nq/6WwtxSkysbXgzjRAegTwtA+sQXXwRiGAbt7X0dA46dA3hs77GU1wXgzfEB0NzcPCjXF5GRRwGgiIiIiIikle3bt/Pkk0/G7sS7/caXTuHyxTeZWNXw1BEKEeruBhQA9pW3xyIQf6Bv23wLy8YDUHfoON2h7lSWBYBPAaCI9JECQBERERERSSvf/e53AbAA0WgUm9XG313zZWxWm7mFDUPNJ20A1ghwXzhtdlwOBwDt/r4FgEXxADAaiVJ7sDbVpeHLVQAoIn2jAFBERERERNLG+vXree655wAw4h+7YdUnGFcyybyihrFm/4kFFuoA7LtEF6C/j4tACseMT94+tudoKksCTgSATU1NKb+2iIxMCgBFRERERCQtGIbBHXfccdLHplTM4qplN5tU0fCX6AC0O2y4MpwmVzP8+OKLQIKdQbq7ez/Km1c4Bps91j04GAGgVx2AItJHCgBFRERERCQtrF27lrfffjt53+3M4NPv/xpWjf72WyIA9GVlYEHbk/sq03NibNrv730XoNVmI7+4AoDqPalfBJI4A7ClpYVIJJLy64vIyKMAUERERERETNfd3c2dd9550sc+cfVt2vo7QMkNwNka/+0Pr9uFJb6Ipi8BIEBRfAx4cEaAM4FY12xLS0vKry8iI48CQBERERERMd2DDz7IwYMHk/cvW3QDS2ZdbGJFw18kGqW1vR0AX5YWgPSH1WLFlzgHsI8BYGIT8PFB2AScmedL3tYYsIj0hgJAERERERExVSAQOOnsv0nlM7n50s+YWNHI0NreTtSIrVLxagFIvyXOAQwEAhiGcY5nn5AIAI2oQe2BmtTWFO8ABC0CEZHeUQAoIiIiIiKmuv3225PdVV53Fv900zex2xwmVzX8JcZ/QSPAA5HoAIxGorS3d/T6dUXxABBSPwacOAMQ1AEoIr2jAFBEREREREyzbt06HnroIQAsFhuf/8C3yM0qNLmqkaEpcCIA9GoEuN9OXgTS1uvX5RaW9dgEnNpFIIktwKAOQBHpHQWAIiIiIiJiiqqqKj760Y8m73/48n9m+vg5JlY0srTEA0CP14Xdrk3K/eW0O3A5YkFeXzcBF5TENgEPZgegAkAR6Q0FgCIiIiIiMuQaGhq47rrrCAaDACyYeSOXLbrK5KpGliZtAE6ZxDmA/V0EkuoOQLvTjtsXG01WACgivaEAUEREREREhlQgEOCWW27h2LFYKFJWvIRPXPlJk6saeZrjHYA+LQAZMF9GLAAMBUN0dXX1+nWFZZUA1B0+Tlew96/rjcz4IhCdASgivaEAUEREREREhkxXVxef+MQn2LJlCwD5uedx/aq/TS5akNQIdnXRGQoB4NP5fwOW2eP3Z1+6AIvGjAcGaxNwbAxYHYAi0hsKAEVEREREZEhEo1E+//nPs27dOgCysyYxc9KVnD9pksmVjTxNPTYAezUCPGAZLjdWqwXoWwBYeNIm4MFZBKIOQBHpDQWAIiIiIiIy6AzD4Otf/zqPP/44AD5vOWPHXM6q2XOw2/RtSao1tp0IqTJzvCZWMjJYLRa87lgXYF8CwNzC0h6bgFO8CCQ+AqwOQBHpDf1JKyIiIiIig+473/kOd999NwAedxHjK66msqSUCaUlJlc2MjXFQyqH0447w2lyNSNDZnwRSHugnWjU6NVrrFYbBaVjgdR3ACY2ASsAFJHeUAAoIiIiIiKD6v777+cb3/gGABmefCrHXYvT4ebCObOxWEwuboRq8rcBsQ3AFvSTnAqJRSDRaJT29vZev64oPgZcnfIOwBMjwIbRu0BSREYvBYAiIiIiIjJonnrqKb785S8D4M3IZWz51TjsGSycOoW8TJ/J1Y1cjfEOwMwcnf+XKokOQAB/PGDtjcQ5gHWH61K6CdiXFxsB7u7u7lMgKSKjkwJAEREREREZFOvXr+czn/kM0WgUjyeTyrHX4nJmk+vzsXDKFLPLG7G6usP4OzoByMzW+X+p4rDZcTlj5/n1ZxGIYRjU7KtOWT2JDkDQGLCInJvd7AJkeLDZbGl1HRk+Er/m+rUX0O+D0UpfB6Qn/T4YPbZv387HPvYxQqEQDoeLC5b8A/V1se6nS+bNxWHX74XB0hw4sQHYl5NBWk0Ap1Mt/ZDp8RDq6o4HgJZejbAXjalM3q7ZV03l7AkpqSUrLyt5u7W1Na2/vurvAiLmUwAovZKbmzvga9hstpRcR4anrKyscz9JRjR9DRB9HRB9HRg9Dh06xM0334zf78dqsfKhD3yLbVtjnU+zxo9jQlmpyRWObC09xkGzczOxWtNn8CudaumPLK+XhtY2ukJdRCJh3PHNwGdTWFqB3eEk3N1F7YHaXr2mN/JL8pO3Q6HQsPj6qr8LiJhHAaD0SnNzc79fm5WVhc1mIxKJ0NbW+7MyZGSw2WxkZWXR1tZGJBIxuxwxgb4GiL4OiL4OjC7Nzc1cccUV1NbWAvCxj97Jvj2xX/cMl4vls2YSDofNLHHEq2ttBcBmt+HKcBCNRk2tp2foZ3YtA+XznAjvmpqaKCoq6tXrCkrGUntkH4d3HiYYDKakFpfPlbx96NChAX3PNth683eB4RBgigxnCgClV1L1DZu+8Ru9IpGIfv1FvwdGOX0dENDXgZEuGAxyyy23sHfvXgBuuuFLdIfyCQRiYeDFc+fgcTq1sXSQNcWD9szEBuB0+ulOp1r6weN0YrfZCMf/QaOwsLBXryssG0/tkX0cffdIykJQb48zAOvq6obF11f9XUDEPMO7/1pERERERNJCNBrlc5/7HG+99RYAq1Z+iFkzrmHHjh0ATKuoYEr5GDNLHDUa27QBeLBYsJCZEdsG3JeO5qLy2Ll/9VV1BNtT0wHocDnwZMV+jRsaGlJyTREZuRQAioiIiIjIgP2///f/ePLJJwGYfd6F3HLzN3nuuWeB2OjvpefPM7O8UaM7HKGtowMAnzYAD4pMTywA7OzopLu7u1evKS4/sfjj6O6jKaslKz92pp4CQBE5FwWAIiIiIiIyIPfffz+//OUvARg3bhZf+Nwv+OvzL9AeX0Zx8by5ZLhdZ7uEpEhzIJAcsVYH4ODIzDjx89oW77Y8l5MCwF1VKatFAaCI9JYCQBERERER6bfXX3+dr33tawDk55Xxldt+w549B9izZw8A0yrKmTKmzMwSR5XGHmOpvhx1AA4Gr9uN1WoBwN/LMeDMnAI83lhYd+TdIymrJatAAaCI9I4CQBERERER6Zdjx47xyU9+knA4jNPp5rZb7yUasfPiiy8AkO31cvHcueYWOco0BQIAWG1WvD73OZ4t/WG1WPDFx4Db/L0LAC0WS7IL8EgKOwAz1QEoIr2kAFBERERERPqss7OTj3/849TX1wPwD5/8H8rHTGPt2rV0d3djtVi4cuF8XA67yZWOLo2tPTYAWywmVzNyJcaA2wPtvd5qm1gEcuTdIynbhN2zA1DbtUXkbBQAioiIiIhIn331q19l27ZtAFx79edYsvg6XnppHXV1dQAsnTGd0rw8M0sclRriI6lZuRr/HUyJRSCGYeD3B3r1mpKKiQB0tnXQVN2YmjryYgFgZ2dn8sxNEZHTUQAoIiIiIiJ98sc//pHf//73QGzj7wdu+hd27tzJ5s1vA1BRWMCCKZPNLHFUCnWHaY2HQFm5PpOrGdkyPR4SDZZtvTwHsLh8YvL2kV2pOQcwsQQENAYsImenAFBERERERHptz549/Ou//isAeXmlfPYzd9HY2MSzzz4LxBYkXLlwAVaNnw65ngtAMtUBOKhsVisZ7tgZi71dBFJYOg6LJfYt+JF3U3MOYGIEGKCxMTVdhSIyMikAFBERERGRXuno6OBTn/oUHR0dWK02Pv/Zn+F0ZPDEE0/Ezv2zWrl68SK8bi2fMEN9a2vytkaAB1+WJ3YOoD/gJxo99/l7DpebvOIxgDoARWToKQAUEREREZFe+eY3v8muXbsA+Jsbv8LkSQt46qmnaGlpAWDlebMYk69z/8yS6AB0uh24PE6Tqxn5MjNi5wBGI1Ha23t3DmBiE/DRFG0CzuzRAZhYyCMicjoKAEVERERE5Jz+/Oc/89vf/haA82at4pqrPstLL73E/v37AZhWUc7cCRPMLHHUq29NLADxYUEj2IMtEQACtLX5e/WaxDmANQdq6Ap2DbgGX44PizX2a60OQBE5GwWAIiIiIiJyVg0NDXzpS18CIDMzj3/89A/Ztm0bGzduBKAkN5dL581Dx/6ZxzBOdABq/HdoOGx2PK5Yp2VvzwFMdAAaUYPqvccGXIPVZiUzLxNQACgiZ6cAUEREREREzsgwDL785S8nxws/+Yn/oqkpwF//+lcAsjIyuG7pYhx2m5lljnr+zg5C3d2AAsChlJkROwewzd+Gce5jAE/eBPxuas8BVAAoImejAFBERERERM7o97//PU8//TQAK5Z/gIryuaxZs4ZoNIrTbuf9S5do6UcaSIz/QmwEWIZGpic2BhzuDtPR0X7O52fnF+N0x0LDlJ0DqABQRHpBAaCIiIiIiJzWsWPHuP322wEoyC/nmitv5ZFHHqGrqwurxcLVixZSkJ11jqvIUGhoi20Atlgs+LIzTK5m9Mjynvi5bu2xhflMLBZLcgw4VZuAFQCKSG8oABQRERERkdP6t3/7NwKB2HbTj374Tp588mk6OjoAuOz88xlfUmxmedJDQ7wD0Jvlwa5x7CHjsjtwO2PnALa19u0cwCO7qjB6Mzd8DokRYG0BFpGzUQAoIiIiIiKnePrpp3nmmWcAWHHBzWx++wB+f2zT6YWzZzNjXIWZ5cl7NLRqAYhZEl2ArW2tfToH0N/kp7WuZcDvn12UDcQ6ACORyICvJyIjkwJAERERERE5SSAQ4Gtf+xoAWZn5GJFxtLS0ALB0xnTmTZpgYnXyXuFIhOZ4p6bO/xt6WfFFIJFwhPb2c58DWFIxKXm7aufAzwHMKcoBIBqNqgtQRM5IAaCIiIiIiJzku9/9LjU1NQCMKV2J398JwPzJk1g8daqZpclp1Le2JUdJ1QE49BIBIPTuHMDi8glYLLFvxQ9tPzjg988pzk3ePn78+ICvJyIjkwJAERERERFJ2rJlC/feey8AuTkTcNjHALBo6hRWzJqFxWJmdXI6dc0tyds5+ZnmFTJKOe12PK7EOYDnDgAdLjcFpWMBOPzOoQG/f6IDEBQAisiZKQAUEREREREAwuEwX/7yl4lGo1itdooLl2OxWFg6YzoXzJyh8C9N1bW2AOD2OHFnuMwtZpRKdAG2tbX1arFH6bjJABxKQQCYrQBQRHpBAaCIiIiIiABw7733sm3bNgCKCxbhcmazYtZMlkzT2G86q4ufz5it7j/TJBaBRCIRAoFznwNYOnYKAI1HGwg0+wf03r5cH7b45mcFgCJyJgoARURERESEY8eOceeddwLgduVTXHQ+71swnwVTJptcmZxNOBKhoS0WIGXnaQGIWfp6DmCiAxDg8DuHB/TeVquV7MLYJmAFgCJyJgoARURERERGuVAoxLXXXktXVxcAlWMv48YLljNjbIXJlcm5NLS2EY1GAXUAmslhs5Phio1f9+YcwJ6bgFNxDmBiDFgBoIiciQJAEREREZFRrLa2lgsvvJAjR44AUFI4l09eeTNjiwpNrkx643h8/Bcgp0ABoJkSY8Bt/jai0bOfA+jyeMkrLgdScw5gYhNwbW3tgK8lIiOTAkARERERkVHqlVde4aKLLmLfvn0AuBw+vnLL1ynIzjK5MumtxPl/Lo8Td4bT3GJGucQYcDQSJRAInPP5pWNjY8Cp3ASsDkARORMFgCIiIiIio0x3dzd33HEHN910Ew0NDcmP/901t1KQnW9iZdJXx5tbAMjJz8SC1jSbKcubQeKXoCW+mflsEgHg8YO1dPo7BvTeiQCwrq4uORIuItKTAkARERERkVFk//79XH311fz0pz/FME6MKZ43cSGLZ15kYmXSV13dYRra2gDI1fiv6exWGz63G4DWHqPZZ1I6bkrydtXOqgG9d+IMwHA4TFNT04CuJSIjkwJAEREREZFRIBwO85Of/IRVq1axefNmADyu2Mio0+7i41feisWiDrLhpLa5ORni5hZlm1yNAGR7vQAE/AHC4chZn1sy9sQikEPbDw3ofRMdgKAxYBE5PQWAIiIiIiIj3LZt27j88su58847CYVC2KxWVsyaQWcotvX3+lUfpzC31OQqpa9qmmOdXhaLFoCki0QAaBgGrefYBpzhyyY7vxgY+DmAPQNALQIRkdNRACgiIiIiMkK1tbXxrW99i8svv5zt27cDMHPcWO697Yts2rsfgPKiSi5f/Ddmlin9VNvUDEBmjheHw25yNQLg83iwWWPfZrf26hzA2BjwgAPA4pzkbXUAisjpKAAUERERERlhIpEIDzzwAEuWLOHnP/85kUgEl8POVz/4N6z+1jd58IWX6AiFsGDhE1ffht2m8Gi4MQyoiQeAuYXa2pwurBZLbBkI0BJf0HI2peNii0Cq9x0j1Bnq9/tmFWRjscZG+BUAisjp6E96EREREZERZP369Xzzm99MdvwBrJg1kzs+/lEmlpXy5w2beH7zFgAumn8tk8pnmlSpDERrezudoVhglFugADCdZHu9NPsDBINBgsEg7vhikNNJbAI2ogZHdh1h0vmTzvjcs7HarGQXZNNS10JNTU2/riEiI5sCQBERERGREWDjxo1873vfY926dcmPjS8u5psf+RCXzpuLxWLB39HJv//2AQCyfXncdPEnzSpXBqi68cSm19wiBYDpJDveAQjQ0tJKSclZAsAem4APbT/Y7wAQILc0j5a6Fqqrq/t9DREZuTQCLCIiIiIyjG3bto0Pf/jDXHnllcnwL9Pj4fZbbua57/0nl50/L7nd938eeYza5tjY6Ecu/ye8bp9pdcvAHG2oB8DpduDLyjjHs2UouZ1OXA4HAK0tLWd9ri87j8ycAgAObtk/oPfNL8sH4NixYwO6joiMTOoAFBEREREZht58801+9rOf8ec//zn5sQyXi79/32X8w1VXkOM7Odzbuv8A9z/3PACzJy1i4YxVQ1qvpNaR+gYACkpykgGvpAcLFrK9GdS1tNLS2oJhGGf9NRpTOZ13N7/Cga0HBvS+efEAUB2AInI6CgBFRERERIaJaDTKX/7yF37605+yYcOG5MddDjsfu+QSPnft1RRknzoO2h0O86//9xuihoHT7uJjV3xRodEw1treQVtHBwAFPba/SvrI8nqpa2klEo4QCATIzMw843PHVE7j3c2vULOvmo62DjL62dGZV5YHQFNTEx0dHWRkqDNURE5QACgiIiIikuaCwSCPPPIIP//5z9m3b1/y4x6Xkw+tWsVnr7mKkrzcM77+V089w66qIwDccOEnKMwtHfSaZfAcqa9P3s4vzTGvEDmjbK8XLIABLS0tZw8AJ0xP3j649QAzV8zq13vmlxUkb1dXVzNpUv/PExSRkUcBoIiIiIhImjp06BD3338/Dz30EE1NJ5Y+FGRl8Xfvu5SPXXLxKaO+77W/uoa7nlgNwPjSKVy++KZBrVkG39GG2Pivy+PEl60ur3TksNnwud0EOoM0NzdTUVFxxueWjZsCFgsYBge27u93AJjoAITYOYAKAEWkJwWAIiIiIiJpJBKJ8Ne//pVf//rXvPDCCxiGkXyssqSYT195BX+z4gLcTuc5rxWNRvnq//2GUHcYq8XK31/zFWxW22CWL4PMMOBoz/P/0Ch3usrx+Qh0BgkEAnR3d+OILwZ5L5fHS2HpOOqrD3Fgc/8XgeSV5idvaxGIiLyXAkARERERkTRQW1vLH//4R377299SVVWV/LjFYuHC2efx8Usv5sI5s7FZrb2+5kMvruOt3XsAuGrZzYwtmZjyumVoNfr9+Ds7gVgAKOkrx+eLhbUGNDc3U1RUdMbnjqmcRn31IfZv2X/OpSFnkl2Ujc1hI9IdUQAoIqdQACgiIiIiYpJQKMSf//xnfv/73/Piiy8SjUaTj+X4vNy8aiUfufgixhefOTg4k9qmZr77hz8BUJw3hutWfCxldYt5DtTUJG8Xleef5ZliNq/bhcNupzscPncAOGE6W9b/mbb6Vppqmsgv6/uvrdVqJbckj4Yj9QoAReQUCgBFRERERIaQYRhs27aN3//+9zz22GM0Nzef9PjciRP42CUXc+2SRb0a8z3Te/zLPf+X7BT7u2u+jNPhGnDtYr6DtccByM734cnQr2k6s2Ah1xfbBtzS0nLWzr4xlScWgRzYvL9fASBAflm+AkAROS0FgCIiIiIiQ+D48eM8/vjj/OEPf2DHjh0nPVaQlcWNy5fxgRXLmVpRPuD3+t3zL7Bu+zsAXDz/OqaNmzPga4r5OkNd1MSXwRSPUfffcJDj81HX0kokHKGtrY3s7OzTPq+orBK700W4K8SBLftZePWifr1fYhGIAkAReS8FgCIiIiIig6S1tZW1a9fy2GOP8eqrr5404mu32bh47mw+uHIlF805D4c9NX81P1BTy3/+/o9AbPT35kv/ISXXFfMdOn48uRSmuEIB4HCQ7fVisVgwDIPm5uYzBoA2u53SsZM5su8dDmwZ+CKQY8eO9fssQREZmRQAioiIiIikUEdHB88++yyPP/44zz//PF1dXSc9PrW8nA+uXM4NFyyjIDsrpe/dHQ5z6//+imBXF1aLlX+4/t9wOT0pfQ8xz/74+X8uj5Oc/EyTq5HesFmtZGVk0NreTnNTM+PHjz/jc8dUTuPIvnc4uO0g4e4wdkffv13Pj3eGdnR00NraSk5OTj8rF5GRRgGgiIiIiMgAdXZ2sm7dOtasWcPTTz9Ne3v7SY+XF+Rz7ZLFvH/pEqaPrRi0rpyfrn6SrQcOAnDt8o8wccz0c7xChotgVzcHamoBKB1boM6uYSQn00drezudnZ0Eg0Hcbvdpn1cxcRZvPPcIXZ0hjuysonLOhD6/V6IDEODIkSMKAEUkSQGgiIiIiEg/+P1+nn/+edauXcvzzz9PR0fHSY/nZ2VyzeJFvH/pEs6fNBGr1Tqo9azfsZO7nlgDQGXpVK5d8dFBfT8ZWnuOHiMSHyEvn1hicjXSF7k+L4fjt5uamykrLT3t8yomzUre3rtxT78CwMKKwuTtqqoqzjvvvD5fQ0RGJgWAIiIiIiK91NDQwF/+8heeeuop1q1bd8p4b6bHw/sWnM/7ly7hgpkzsNtsQ1LX8eYWvviLX2IYBm5nBp+54evYbfqr/kiy68gRAHxZHnILNf47nLgdTjwuJ52hLlqazhwAZubkk1tYRnN9NXs37uHyT17R5/cqGHsiADx8+PBZnikio43+ViAiIiIicgbRaJRt27bx/PPP8/zzz/P2228nlzAk5Gdlcvn887lywXyWzZyBM0XLPHorHInwxV/8kvrWNgD+/tqvUJI/8E3Ckj5aAu1UNzYCUD6hGAsa/x1ucnw+OkNNtLa1Eg5HsNtP/48DFZNmxgLADXv6tcTD5XGRXZhNa30rhw4dSkHlIjJSKAAUEREREemhsbGRV155heeff54XXniB+vr6U55Tlp/HFQvmc+XCBSyYMhnbII/3ns2dD/6B13e9C8AlC69n0YxVptUig2Pz/thWWIsFxkwoNrka6Y+8TB81jU0YUYPm5iYKCwtP+7yKSbPY9vpztNS10HCknsKxRX1+r6JxxQoAReQUCgBFREREZFTz+/28/vrrvPLKK7zyyivs2LHjlOdYLBbmTqjkorlzuGjObGZXjk+LJQwP/PVFfvPscwBMHDOdD136GZMrklTrCIV451BslLNkbAHeTG11Ho58Hg8Ou53ucJimxjMHgGMnnTizb+/GPf0KAAvHFrF34x4FgCJyEgWAIiIiIjKq1NfXs3HjRjZs2MDrr7/O5s2biUQipzwv2+vlwtnncdGc2ayaPYv8rCwTqj2z9Tt28u+/fQCAvKwivvjBO3DYnSZXJam25cBBwvHfn5NmjjW5GukvCxbyMn0cb26huaWZSCSKzXZq53Bh6TjcGT6CHQH2btzLshuX9/m9isbFQsMjR44QiUSwDdFZpCKS3hQAioiIiMiIFQ6H2blzJxs3bkyGfmfqinE5HCycOoVlM6azbMY0ZldWDtkSj77aeuAgn/rRTwhHIjgdbm69+U6yfXlmlyUp1hnqYsu+2PhvQUkOuYXpFUJL3+RlZnK8uYVoJEpLSzP5+fmnPMditVI+YSb73nmTvRv39Ot9El2D4XCYY8eOMXasgmMRUQAoIiIiIiNEKBTi3XffZfv27ckfO3bsoKOj47TPd9rtzJ5QyQUzZ3DBjOnMmzQRl8MxxFX33Z5jx/j4f/+A9mAQq8XKZ2+4nXElk8wuSwbBqzt2EOruBmDKnHEmVyMDlZmRgd1mIxyJ0NTYdNoAEGLnAO57502O7T5Ke2s73mxvn94n0QEIsU3ACgBFBBQAioiIiMgw5Pf72bFjB9u3b2fbtm1s376dPXv20B0PS06nNC+P8ydNZP7kSZw/eSIzx40bFoFfT3uPVfOR732f5kAAgE9e+y/Mm7rM5KpkMOyvqU2e/Vc6rpCCklyTK5KBslos5Gb6qG9ppam5iWjUwGo99SzRsZNmAWAYBvvf3sfsi+b06X16nht46NAhVqxYMbDCRWREUAAoIiIiImkrEolw8OBBduzYwc6dO5M/qqqqzvq6bK+XmePGMmv8OOZMmMD8yRMpO0O3zXCx9cBBPv7fP0iGfx953+e5YM7lJlclZxPqDtMeDBKJRslwOclwuenN7pja5hb+vGEjAE6Xg/MWq8NzpEgEgJFwhNbWFnJzTw12x1ROw2qzE42EefeNXX0OALMLs3F6XHR1hrQIRESSFACKiIiISFpoampi586dJ4V97777LsFg8KyvK83LY+a4scwcP45Z8f+Oyc9Piy29qfLy9nf4x7t+RiD+c/Hhyz/HZYtuMLkqOZ2u7jDbDh5k99Fj1Le2YhhG8jGH3U5pXh7lBfmMKSigJDfnpHMmDcNg5+EjvLRtG13hMBaLhfNXTMftcZnxqcggyPF6sVmtRKJRmhqbThsAOlxuyidMp2rvdt59Y1ef38NisVA0tpCju48qABSRJAWAIiIiIjLkWlpa2Lp1K5s3b2bLli1s2bKFY8eOnfU1TrudyWPKmFZRwfSx5UyrqGDmuLFpt503lQzD4BdPPsX3H36UqGFgtVj55LX/os6/NLWz6gjrtm0n2NV12se7w2Gq6uqoqqsDwGa1UpiTTabHQ3c4QkNbK4HOWMhrsViYu3waRWO03GUksVqs5Pi8NLb5aWpqYoIx8bRdoeOnzqVq73YObTtIZ6ATj8/Tp/cpHFukAFBETqIAUEREREQGVTQaZefOnbz00ku89NJLvP322+f8prQ0L4/pFeVMG1vB9IoKpo2tYEJJMQ776Pnra31rK//26/t4dtNmANzODP7xhq8zd8pSkyuT94pEozz/9hZ29hhNz87PpLQiH1+OF5vNSqizi7bmAI3HW2lrDmAYsdfVNjVTS/NJ18vwuZl7wTQKSnKG+DORoZCbmUljm5/u7m5a21rJyc4+5Tnjp83j5bW/IxqJsuet3cy5eG6f3qO4sgSAAwcOYBjGiOqIFpH+GT1/gxIRERGRIRGNRtm2bRuvvfYar7/+Om+++SbNzc2nfa7FYmFiaSmzJ4znvPHjmTG2gmkVFeRm+oa46vRhGAaPrX+N/3jgIVoC7QCUFYzlCx+4g9KCCpOrk/cKR6I89dZbHKipBcDjdTF76RSKxuRh4fShS3dXmKa6VhqPt+JvaSfYGcJms5Hhc1NYlkvZ+CJsNutQfhoyhHJ9PqxWC9GoQUN9w2kDwIqJM7HZHUTC3ex6fWefA8DSiaUABAIBampqKCsrS0XpIjKMKQAUERERkQFraGjgxRdf5IUXXuDFF1+ksbHxtM8bk5/P+ZMnMruykjkTKpk5bhyZGX0bbRupDMPg1R07+Z+HH2Xz/gPJj18w+3I+esUX8LgyTKxOTscwDP68cWMy/CsoyWHBhTNxus6+XdrhtFNcnk9x+fBeTCP9Y7NaycvMpKG1jcbGBiZMmHDKNmC7w0n5hBkc3rOVd1/r+zmAZZPGJG/v3btXAaCIKAAUERERkf45dOgQTz75JGvXrmXz5s0nLTtImFRWyrKZM1gyYzpLpk2jYBR39p1JZyjE2jc38NCLL7Fp777kx/Ozi/jE1V/ivIkLTaxOzubN3XvYe6wagMKyXBZeNAu73XaOV4lAXlYsAIyEI7S0NJOXd+pZj+OnzePwnq0c3nGI9tZ2vNneXl+/dFJp8vaePXtYtWpVSuoWkeFLAaCIiIiI9NqBAwdYs2YNa9asYfv27ac8np+VycrzZnHRnNlcMHMGhdnZeDweLBYLhmHQ2dlpQtXpxTAMjjU28vrOd3lhy1Ze3v4O/h4/LxluH1ctvZlLF92A26nuyHR16Hgdr++MdWZl5XoV/kmf5Hh92G02wpEIDfUNpw0AK6fNZd0aMKIGe97azbzLzu/19X25mWTmZ+FvbGPv3r2pLF1EhikFgCIiIiJyVoFAgCeeeILf//73vPXWW6c8PmvcON634HwunDOb88aPw2odvWeXRaJRmv0B6ltbqW9tpaG1Lf7fVupaW6lraWVX1RGa/P5TXpufXcyqeVdxycLr8brVKZnOgl3dPPf22wA4XHaFf9JnVouFvKxM6ppbaGpuIhKJYLOd/HtoTOV07A4n4e4u3n19Z58CQICySWXsVgAoInEKAEVERETkFIZh8Prrr/Pggw+ydu1aOjo6Tnp8dmUlVy9eyJULFzC+uMikKodeNBqlqq6enVVVHK6r51hDA0frG6htbqa+tY3GtjaipxmFPpNsXx6zJy1i4fRVzJowH6tVIdJw8NK2bQQ6gwDMXjwFb6Y6NaXv8uMBYDQSpampicLCwpMetzucVEyaxcFdb7PztZ19vn7ppDJ2v/kue/bsSVXJIjKMKQAUERERkaTOzk4effRR7r33Xnbs2HHSYxWFBfzNiuXctPwCxhYVnuEKI8++6mpe2rqdV97ZwYbdewgEg32+htedSZY3lyxfLqX55YwvncqEsmmUF1ditYzejsnh6Eh9A7uqjgBQNr6QssrR8/+CpFZWRgZOh52u7jD1dfWnBIAAldPP5+Cutzmys4qWuhZyinJ6ff2ySbHFH3V1dbS2tpJ9mm3DIjJ6KAAUEREREaqrq/n1r3/N7373O5qampIf97icXLVwIR9cuZzF06aOmvHelkCAR199jUdfXc87hw6f8Xk5vnzys4vIzSok25dHtjePbF8O2d48sny5sf96c3DYnUNYvQyWaNTgpa3bgNgm3/MWT8aC5RyvEjk9Cxbys7KoaWyipbWFUFcXLufJXysmzVrEC4/dC8COl7dzwd+s6PX1Syed2Py7d+9eFixYkJrCRWRYUgAoIiIiMort37+fn/zkJzz88MN0d3cnPz6uqIi/vfwSPrhyBVkZGSZWOLRqm5q555k/8+ALL9ERCp30WEl+BTMrz6eybCrjSiZRnF+BU8HeqLLt4EEa2toAmDpnPC63fv1lYApzsqlpbAID6uvqKC8vP+nxkvKJeLNyaW9rZvu6bX0KAMsUAIpIDwoARUREREahHTt2cNddd7F69Wqi0Wjy4yvPm8XfXX4pF82ZPWq6/QA6QyF+sfZpfrn2aUI9gtDywkoumHM5C6evoiCn2MQKxWzd4QhvvrsbgMwcL+OnlZ3jFSLnluF04fO4CXQGqTtNAGixWpk4cwHbXn+Od17eTjQSxWrr3dfmvLJ8bvn3j3LR1JWsnL9yMMoXkWFEAaCIiIjIKLJr1y6+973v8fTTTyc/ZrNauW7pYj537TVMLR9jYnXmeO7tzXzz/t9R3Xhi9HnO5CVcc8EtTCqficWiEU+BLQcOJLtCp59fOaoCchlcBTnZBDqDBDuDtPn9ZGVmnvT4pFmL2Pb6cwSaAxx65yAT5kzs1XUtFgvv+9QVLHYuIN+WPxili8gwogBQREREZBSoqqriv/7rv3j44Ycx4ltqnXY7f7NiOZ+99irGFY2eTb4J7cEg//HAQ/zhpZeTH5sy9jw+fPnnGF86xcTKJN2EusNs3LMXgJyCTIorFKZI6hRkZVF1vI5o1KD+eN0pAeCEGQvAYgHDYPtL23odAIqI9KQAUERERGQEq6ur40c/+hH3339/8ow/h83GRy6+kM9dew0lebkmV2iO3UeP8ekf/YRDx48DkJmRzUfe93kWz7xIHX9yis379xPs6gJg2txKLf6QlLJbbeT6Mmlsa6OhoYHxlZXYeoz5ejNzKBs3hepDu9n+0jbef+sNJlYrIsOVAkARERGREaijo4Of//zn/OxnP6OjowOIjYPdeMEyvnTT9VQUFppcoXme3fQ2t/7v3bQHgwDMmbyYv7/mK2T78kyuTNJRsKubt/fuAyCvKJvCMaMzNJfBVZiTTWNbG5FIhIaGeoqLTz5zdOKsRVQf2s3+zftob2nHm+M1qVIRGa4UAIqIiIiMIIZh8Pjjj3PHHXdw7Nix5Mcvnz+Pf/mbm5haUX6WV49shmHwy6ee4bt/+BMAVouVmy/7Ry5fdKO6/uSM3jl0OLkYZurc8er+k0GR7c3A7XQQ7OrmeO3xUwLASTMX8sra32FEDd55eTuLr1tiUqUiMlwpABQREREZIbZs2cLXv/51NmzYkPzYgimTuf2Wm5k/eZKJlZnPMAy+/fs/cvfTfwbA687kczd9k5kT5ptcmaSzaNRg64EDAGTnZ1JQmmNuQTJiWbBQlJNDVV09gUCAQCCAz+dLPl4+YQYeXxadgTY2P7dJAaCI9JkCQBEREZFhrq6ujjvvvJM//OEPyY+V5efx9Q99kGuXLB713W2RaJSv3vsb/vTyKwAU5pTy5Q9/j5L80dsNKb2zv6aGtvgI/YTpY9T9J4OqMCebow0NRKMGtbW1TJp04h9urDYbU2cvY8trf2bri1sJd4WxO/XtvIj0nnbXi4iIiAxT0WiU3/72tyxbtiwZ/rmdTm678Xpe/O/vct3SJaM+/Iu+J/wrL6rk9k/cpfBPemXz/v0AuDxOysaPvk3ZMrQcNjt58Q3ADQ0NhMPhkx6fOu8CADrbOnj3jV1DXp+IDG/6JwMRERGRYWjnzp185StfOWnc97oli/n6LR+kLD/fxMrSh2EYfOP+3yXDv8qyqXzlw/+F15NpcmUyHBxvbuFYQyMAlVPLTtrKKjJYinJzaGhtIxqJUldXR1lZWfKxiTMWYHe6CHeFePvZTcxaeZ6JlYrIcKM/xURERESGkY6ODu644w4uueSSZPhXWVLMQ1/7V372+c8q/IszDIP/eOAhHvjriwCMLZ6k8E/6ZMv+2Nl/VpuVsVPKzvFskdTI9HjIcLsAqK2pxTBOPOZwuZk0cyEAm5/dRDQaNaNEERmmFACKiIiIDBPPPfccK1as4Kc//SnhcBin3c6tN7yfv3znTpbPmmF2eWnlrifW8Ou/PAdAeWEl//LR/1b4J73WHgyy++hRAMZUFuH2OE2uSEYLCxZK8nIBCAaDNDU1nvT41LmxMeDm2mYObT845PWJyPClEWARERGRNFdbW8vtt9/OmjVrkh9bMm0q3/n7v2VSmTqT3uvhl1/lh48+DkBJXjn/8tH/JjMj2+SqZDjZdvAQkXh31YTpOi9ShlZBVhZH6urpDkeorq4mv0dn95Q5S7FYrBhGlLf/sokJcyaaWKmIDCfqABQRERFJU5FIhP/7v/9j2bJlyfAv1+fjB//wKf54+9cU/p3Gq+/s5Kv/9xsAsry5fPnD3yPbl2dyVTKchCNRth2IdVbll+SQneczuSIZbawWK8W5sS5Af5sfv9+ffCzDl824KbMB2Pj0Wxg9Z4RFRM5CAaCIiIhIGtq2bRtXXnklX/va15Lf/N28agUvff97fGDl8lG/3fd0dh85ymfu+inhSASnw81tH/o2hbmlZpclw8zuo0fpCIUAmDB9jMnVyGhVnJuD1Rr7Ol9TXXPSYzMWrAKg9kAth7cfGurSRGSYUgAoIiIikkYCgQDf/OY3ueyyy9i8eTMAk8pKefgb/8b3P/1JcjPVjXQ6tc3N/O3//BB/ZycWi5XP3fgNKsumml2WDDOGAVv27wcgw+empKLA5IpktHLY7BRmx44uaGhsoLMzmHxs5oKLsNpsALy++jVT6hOR4UcBoIiIiEiaeOaZZ1i+fDm//OUviUajuBx2vvI3N/LMt+9g8TSFWWcS7Ori0z/6CdWNTQB89IrPM3fKUpOrkuHoWGMjdS2tAFROG6NOWzFVaV4eWAADjh07mvx4RmY2E2csAODNNW8QjWgbsIicmwJAEREREZMdPXqUv/3bv+XjH/84x44dA2DFrJk8991v88Xrr8PlcJhcYfoyDIOv/+Z+tsbPbHvfkr/hkgXvN7kqGa4S3X92h42xkzU+LuZyO50UZGUBUF9XTzA+mg4wa/ElALQcb2b3m++aUp+IDC8KAEVERERM0t3dzc9//nMuuOACnn76aSC2/fGnn/tHHvjqVxhfUmxyhenv1395jkdeWQ/ArAkLuPmSfzC5IhmuWts72Bc/a61iUgkOp93kikSgrCAfLLF/7Dh29Fjy49PmLsfudAHw+hPrzSpPRIYRBYAiIiIiJnjrrbe49NJL+da3vkVHRwcAH77oQl74/nd5/7IlGj3shVff2cl/PvQHAIpyy/jsjd/AarWZXJUMV1sPHMAwDCyW2PivSDrIcLrIz8wEoK7uOKFQFwBOt4dpcy8AYMPTG+gOdZtWo4gMDwoARURERIZQU1MTt912G1dffTU7d+4EYMbYCp741jf43ic/QY7Xa3KFw0NVXT2f+9nPiUSjuJ0ebv3gnXg9mWaXJcNUVzjMO4cOA1BUno8vK8PkikROGFOQD4ARNTh69Ejy4+ctvhSAzrYONj/3tim1icjwoQBQREREZAgYhsEf/vAHli1bxgMPPABAhsvFv3/kFtbe+S3OnzTJ5AqHj45giE//+Ce0BNoB+PT7v8aYovHmFiXD2s7DVYS6Yx1UE6aXm1yNyMkyXG7ysuJdgMfr6OzsBGDizIV4s3IBWPfQi6bVJyLDgwJAERERkUG2efNmrr76ar7whS/Q2NgIwJUL5/PCf3+HT135Puw2ja32lmEYfPnue9lVFeuCef/KjzN/2nKTq5LhzDAMtuw/AEBmjpeC0hxzCxI5jYrCQizxswCrDlcBYLPbmbf8SgB2vPoOxw/VmlmiiKQ5BYAiIiIig6S2tpbPf/7zXH755WzYsAGAisICfvPlf+ZXt36Bsvx8kyscfn6+Zi1PvRX7uTx/6gW8f+XHTK5IhrtDx+toDgQAmDB9DBZ0/qakH4/TSVFODgCNjY34/X4Azl9xTfI56x56yYTKRGS4UAAoIiIikmLBYJAf/ehHLF68mD/+8Y8AuJ1OvnTTDTz/vW9zyby55hY4TP118xa+/8hjAJQVjOPT7/8aVov+OisDs3nffgCcLgflE7V5W9LXmIICrNZYQH34cOzMytzCUibOXADAKw+/TLgrbFp9IpLe9DcmERERkRSJRCL88Y9/5IILLuA73/lOcrvvDcuWsu773+Ofb3g/HpfL5CqHp33V1XzxF7/CMAwy3D6++ME78Li0qEEGpqHNz+G6OgDGTSnFpnF8SWNOu53SvDwA2lrbaGhoAGD+ymsB8De28fZfNppWn4ikN7vZBYiIiIgMd4ZhsHbtWv7rv/6L3bt3Jz8+d+IEvvWxD2vBxwC1dXTw6R/9BH9nJxaLlX+84XZK8rWoQQbu7b37ALBaLYyfNsbkakTOrSw/n/rWVrq6wxw6dIjc3FymzFmGLzuPQGsTf/3t8yy6donZZYpIGlIHoIiIiEg/GYbBX//6Vy677DL+/u//Phn+VRQW8ON//Aee+H/fUPg3QJFolC/+4lfsr4kdbv+Biz/J7EmLTK5KRoJAZ5B3j8SWyYypLMKToe5cSX82q5WxRUUAdIW6OHL0KDa7nfNXxs4C3P3muxzYst/MEkUkTSkAFBEREemjcDjM448/ziWXXMKHPvQhtm7dCkBRTg7f/sTHefH73+PG5cuwWvVXrYH6wSOP8cKW2M/vkpkXc+XSm02uSEaKLQcOEIlGAZgwo8LkakR6Lz8rkyxv7AiEmupqOjs7WXTxDdgdTgCe/uVTZpYnImlKI8AiIiIivRQIBHj44Yf5xS9+waFDh5Ifz/F5+dw1V/O3l12iM/5SaO2bb/GzNWsBGFcyib+79stYLNrQKgPX1R1m24GDABSW5ZKd5zO5IpHes2BhfEkx2w8cwoga7Nu3j1mzzmPuBVew8aU1bHpmA8cP1VI8vsTsUkUkjSgAFBERETmHnTt3ct999/Hwww8TCASSHy/JzeVTV17Ohy+6EJ/HY16BI9DOw1V8+e57AcjMyOYLH7gDl8NtclUyUrxz+DCh7m4AJs5U958MPxlOF6X5eVQ3NOJv81NTU83Syz7IpnVrMYwof7nnGT7+7b8zu0wRSSMKAEVEREROo76+nrVr1/Lwww+zYcOGkx6bVFbKP159FddfsBSnXX+dSrW6lhY+9aO76Ax1YbPa+Ke/+X8U5BSbXZaMEOFIhE179wKQleulsCzX5IpE+qe8IJ9mf4DOUIiqqirmzJnL9Pkr2LlxHa/86WWuu/UGcopyzC5TRNKE/sYqIiIiEnf8+HGee+45Vq9ezSuvvEIkEkk+ZrfZuHz+PD568cUsmzFN5/sNks5QiE/+8C6ONjQC8OH3/RPTxs0xuSoZSbYfOkygMwjA5PPGYUFj5TI8WS1WJpaV8M6hw0QjUfbt28uy932InRvX0R3q5smfreZjd/yt2WWKSJpQACgiIiJ91tXVRXt7O+3t7YTDYQAsFkvyh8vlwufz4UnzsVi/38+mTZt46aWXeOmll9ixY8cpz5lQUsKNy5dx86qVFOfmDH2Ro0gkGuXW/72brfGz2S5bdAOXLHi/yVXJSBKORNiwew8AmTleysYXmlyRyMD43B7K8vOTo8BZ2eVMm7ecdze/yksPvsD7PnklTDa7ShFJBwoARUREJMkwDOrr69m/fz/79+/nwIEDHD9+PPmjrq6Otra2ZOh3LlarFa/XS1ZWFhkZGeTm5lJQUEB+fn7yR8/7BQUF5OXl4Xan9qy3cDjM0aNHOXToEHv27GHLli1s2bKFffv2YRjGKc8vL8jn2iWLuXbJYmaOG6vFE0Pku3/4E3/euAmAuZOXcstlnzW5Ihlpth08RHsw1v03de54/b8tI0J5QQFt7e0EOoMcO3qUBZfczO4trxHpjvD4Dx/h2v+9yuwSRSQNKAAUEREZpaLRKPv372fr1q1s3bqVbdu28c4779DW1pbS9/D7/fj9/j69zuPxkJOTQ15eHjk5OcnbmZmZOJ1O3G43TqcTp9OJ1Wqlu7ub7u5uwuEw7e3tNDU10dzcTFNTE7W1tRw9evSsoaXTbmfh1CmsPG8WK8+byYyxCv2G2u+ef4G7n/4zAONKJvOPN96O1WozuSoZSbrDETbuSZz956N0bIHJFYmkhtViYdKYMrYfPEQkEqXJ38l5Sy5l2+vP8sYTr/Pu599l+ewLzC5TREymAFBERGSUiEajvPvuu6xfv57XXnuN119/ncbGxrO+xuNyUpaXR1FODkU5ORRmZ5Pj85LhcpHhdpHhcmG32TAMMDDAMDAMCHV3EwgG6QgGaQ+FCHZ30+IP0Oz30+j30+T309jmpyMUOu37dnZ20tnZSU1NzWD8VDAmP5/ZE8Yzu7KS2RMqWTB5Eh6Xa1DeS85t7Ztv8c37fwdAXlYRt33o27id6T0+DrGO2ZqmZg7V1dHi9xPs6sbldJDj9TKuuJiy/DysozxINgyobW7m0PHjNLS20R4MYrVYyMzwUJaXz4TSEjIzhubXeuPevT26/8Yp5JcRxe1wMqG0hL1Hq+nu6qZ02lJ2bHiRSLib//6P/+aCR57Q73mRUU4BoIiIyAjW0tLCiy++yLPPPssLL7xAU1PTaZ+X4XIxc9w4Zo0fx5TyMUwoKaaytITinJwBf8NgtVpxu90Eg0Gi0ehJjwW7umhsi4eCbW00+v00BwK0BtppDgRoCbTT0n7idqCzk65wmK7ubrp7LOhIcNhsuJ1OcjN95PpiP/KzshhXXMS4okLGFRcxvriYvMzMAX1Okjovbd3Grb/4FVHDwOPyctuHvk1OZr7ZZZ1VNGqws6qKjXv20hwInPY5b+3eQ2aGh4VTpjBr/Dhso2xpjGHA3upqNuzeQ11Ly6lPaIR3jxzlxW3bmFRWysIpUwb1jE1/R2ey+y+vKJsSdf/JCJSfmUUgL0hNUxNRnEw5/yJ2vfUs776zi2PHjlFeXm52iSJiIgWAIiIiI8z+/fv5y1/+wrPPPssbb7xx0ibbhLFFhSyZNo3F06Yyb9IEKktKTAko3E4nYwryGVPQ98AnGo3SFQ4TjRo47DbsNpu6G4aZt3bv4R/u+hndkQhOh5sv3fJdKoonmF3WWR1vbuH5zVtOCrUsFgu+7AycbgfdoW4CrR1Eowb+jk5e2LKVLfsPcPn88ynNyzWv8CHU0t7OC5u3criuLvkxiwWy8zJxe11EI1ECrR10BIIYhsHeY9Xsq65h1vhxLJ85A7fTmfKaXn7nHcKRCBYLzFo0SZt/ZcQaW1xIZ1eIlkA7JVOWYHc4+Z/vf1Phn4goABQRERkJDh06xBNPPMETTzxx2k22eZmZXDjnPFbMmsmSadP6FbilG6vVOihBgQyNLfsP8Pc/+BHBri5sVjtf/MB/MLliptllndW2g4d4aes2IvFOVm+Wh0kzKygdX4jT6Ug+r7srTE1VA/veqSLQ2kGT388f173MBTNnsGDyZEZyTn2gppY/b9xEqLsbAHeGk4kzKqiYVII7wxXrAo4fGRBo6eDQnmqq9tQQiUTZfvAQB2uPc8WC+VQUpq5Db9+xGvYcPQZAxcQScvLVASwjl4XYeYA7Dh2mEyiZspTX33yT8yen9z+uiMjgsxinW30n8h4NDQ39fm1ubi42m41IJEJzc3MKq5LhwGazkZubS3Nz82m7kGTk09eAwXP06FFWr17NE088wZYtW055fGp5OZfMm8Ol8+Yyb9JE00YQzzYCLKODx+PBYrFgGAadnZ28tXsPn/j+DwkEg1gsVj530zdZOH2l2WWeUTgS5cWtW3nn0GEArDYrU+eMZ+LMcqxn+f/KMAwOvnuMXW8fIBKO/d6fVlHOZefPw24bWQtODAPe3L2b13fuAmIdfxOmlzN1XiV2uw0ssa8FiQCwp472IDs27KfmcH38tRYWTJnM0unTBvx1qzPUxW+f/ysdoRAuj5OL3r8Qp8tx7hdKSlltJ34doxH9OTAUgt1d7DhURXc4TP2+53nyod/idrtNq6c33xMUFGg0X2QwqQNQRERkGKmvr+eJJ57g8ccfZ8OGDac8PmdCJdcuWcQVCxYwtqjQhApFzm79jp38/Q9/TGeoC6vFyj9c/29pHf51dYdZ88abHKmPhVMen5uFF87sVReZxWJhwvRyisryeOvFdwi0dvDukaO0trdz/bKlI6aDNWoY/HXzlmRA6nDaOX/ldIrH9K7TOMMb+zk9euA4297YQ7g7wobdezjW0MCVCxeS1c8lIVHD4M8bNyaXDc1eMkXhn4waboeTaWPLOVxbxxe//jVTwz8RSQ8KAEVERNJcIBDgmWee4ZFHHmHdunWn/Mv5jLEVXLtkMdcsWcS4oiKTqhQ5t79s2MQnf/AjQt3d2Kx2PnvjN1gwfYXZZZ1RZ6iLx197nePx7uWC0lzmr5qBq48hki87gxVXnc+ml3dSd6yJmqZmHn75VW5cvgzvMP+mPBKN8peNm9gdH7HNzPGy6OJZeDP7HtqVTygmtzCLt1/ZRXN9G9WNTTz4wotcPv98JpaW9Pl6r+3cxaHjsXMIKyaVUKrFHzLKeF1upo+rIDc7x+xSRCQNKAAUERFJQ93d3bz00ks8+uijPPPMM3R0dJz0+KSyUq5buoRrFy9iYlmpSVWK9N7dTz3NN35zP9Gogd3m4PMf+BZzJy8xu6wzCnQGefTV9TT5/QCMqSxi3vJpZx35PRuH087iS85j2xt7OLynhoa2Nv708qvctHwZWRkZqSx9yIQjEZ56awMHamoByC3IYvGl5w2oy86b6eGCK+by7uaD7HvnCMGuLta8/gbnT57E8pkzej0SvGHPXjbs3gNATn4ms5dM7ndNIsOZFt6ISIICQBERkTRhGAYbN27kkUceYfXq1TQ2Np70eHFuDu9fuoTrly1l5rix2ngrw0I4EuFr9/6a/3vmLwB4XF6+8IH/YEblPJMrO7O2jg4eeWU9re3tAIyfWsZ5iycP+P85i8XC7KVTsNtt7N95lJZAgD+9/Ao3XXABuZm+VJQ+ZLrCYda8fmI0Or8kh8UXz8LuGPi3F1arlRnzJ5JfnMPmV9+lK9TN23v3cayhgYvnzqUkN+eMr41Eo7y2cxcb9+wFwJPhYsFFM7GNsDMXRURE+koBoIiIjHiGYdDd3Y3D4Ui70MwwDHbu3MmaNWt47LHHOHTo0EmPZ3o8XLVoAdcvW8qSAR6In9j7lW4/BzJyNfn93PqLX7Fu+zsAFOaU8M8f+jZjCsebW9hZtATaeeTVV/F3dAIwaVYF0+dPSFkXjQULMxZOxO60s3vLIfwdnTz8yivceMEFFGRnpeQ9Bluwq5snXnudmqYmAIrK81h4YepDtuLyfFZdt4C3X95J4/FWjje38IeX1jG1fAzzJk6kODc3uVHZMKCqro7Xdu6iNj6y7fG6WPa+uWR4h/eYtYiISCooABQRkWEpEolw9OhR9u/fz/79+6mqqqKuro76+nrq6+tpbGwkFAolfyQ4nU6cTidut5vs7Gzy8/MpKCggLy+P/Px8ysrKKC8vp6KigoqKCny+1HflGIbBtm3bWLNmDU8++SQHDx486XGn3c7Fc+dw/bIlXDx3zimLAkLd3dQ0NVPT2Eh1UxM1jU1UNzVR39JKa3s7bR0dyR/twRBRw0iGfwBetxufx02mx0Omx0Nxbi5l+XnxH/lMKiulsqQEl0OH5Uv/bdizl8//7H+TIdGk8pncdst38LrTt9Otsc3Po6+upz0YBGDq3PFMmTMu5SN0FixMnTMeu93Gjo37aQ+GePiVV7nhgmVn7W5LB+3BEI+vf4361lYAysYXcv6K6f0ejT4XT4aLpe+by/7tVezZfphIOMq7R47y7pGjeN0u8jKzsFgsNLa1JX/dAHILs5i/cgYZPoV/IiIiABaj53cEImfQ0NDQ79fm5uZis9mIRCI0x/9FVkYPm81Gbm4uzc3NpywukNEhFV8Durq62LVrF1u2bGHLli1s3bqV3bt309XVleJqT5WdnZ0MBMeMGUNZWdlJ/y0pKcHZi02e4XCYjRs38uc//5knn3ySqqqqkx63WCwsmTaV9y9dwtKZ0/F3dFLd0MjRxgaONTRS3djI0YZGahqbaGhrG6xPN8lmtVJZUsKU8jLOGz+e8ydNZPaEyn4tLLBarbjdboLBINFodBCqlXTSFQ7z09VP8rPVTxKJ/3qvOv9qPnH1P+OwuwiHu02u8PTqW1p5dP1rdMb/wWDG/AlMmjV20N/30O5qtr+5B8OIhf/XL1vKmILebc8dam0dnTz26nqaAwEAxk4qYc6yqb3rKrbEvhZEo1Ho53cfHYEge7cf5sj+40Qjp/9a4nDamTijnEnnjR20UFL6zmo78Wtxpl87GTzvW17O1MkTTK2hN98TFBRoUY/IYFIAKL2iAFD6SwGg9OdrQGdnJxs3buSVV17h1VdfZevWrecM+3zeHHJyisjOLiQ7q5DMzDycLg8OuxN7/Eck0k043EVXd4juriDt7a20+ZsIBJpo8zfS1tZIKNRx1vd5L4vFQmFhIWVlZeTk5JCdnZ38r9Vq5eDBg+zfv599+/YR7NGdklCYnU2uz4fdZqWto4OGNj/BPgabFouVHF8eOZn5eD1ZZLi8ZLh9eN2ZuJwerBYLlviPaDRKsKuTYFcnnaF2OoIBmtrqaWqrw9/Retb3sVosTKsoZ96kiSyeNpWl06dT3ItuJQWAo8c7hw7zlbvvZWfVEQCcdhcfv+pWLpx/DRZLbEwzHQPAqrp61r75FqHuWG3nLZ5M5bQxQ/b+R/bXsmX9bgzDwGG3cdXChUzox9bbwdTk9/PY+teSo9ETZpQzc8HE3h8pkIIAMCEU7OL40SYaa5sJdnYRjUTxZnnILchiTGVRSs4hlNRSAGguBYAiAgoApZeGQwB45MgRNm/ejMPhwG63Y7fbk7ddLheZmZn4fD58Ph9er1dnYA0RBYDmCofDtLS00NHRQTAYpLOzk2AwmLzdczT2vex2O263G7fbjcfjweVy4Xa7ycjIIDMzs9f/H/Xma0BXVxebNm1i/fr1vPrqq2zcuPGMtWVl5lNZOYfx42ZSWjqR0pIJlBSPx+vN6dXPydkYhkF7eyuNjcdoaDxGQ+NRGhqOJe83NlbT2lY/4PfpK68nk4LsYvKzi8nLKiIvq5C8rELys2O3s3352G0D/4a3qztEQ+txqusPc6z+IEfrDnG07iA1jVVnfM2kslKWTp/OspnTWTp9GnmZmac8RwHgyNfsD/A/jzzGgy+8SDT+V8sJY6bzqev+lbKCsdjtjrQNAHccruL5zVuIRqNYLBbmLJ3C2MlDv1m7+nA9b7+8k2jUwGKxsOq885g3ydxv2BMOH6/jqbc2JAPSqXPGM2VuH0ejUxgAyvCjANBcCgBFBEZZANja2sojjzzCW2+9RWNjIy6Xi4kTJ3LVVVexZMmSfl83HA6zdu1a1q1bR3V1NQBjxoxh1apVXH311djtZ/+m7MCBAzz++ONs376dtrY2srOzmTVrFjfeeCOVlZWD+t69NRwCwD/8/vd84Ytf7NVzrVYrXq+XzMxMcnNzKSwspKCgIHkWWEFBAYWFhcmunsLCQm2P6ycFgKkXDAaprq6murqao0ePcuzYMY4fP05zczMtLS3J/zY1NeH3+wetDofDQXZ29kkdbzk5OeTn5yf//ykqKmLixImUlZWRn59PR0esuy4cDrN161ZeffVVXn31Vd56663kYz1ZrTYmVM5h+rQlTJgwlwnjZ5OXV2pqgB8Od9HUXEtjYzVVR/Zy9Oh+amsP09hUQ0dHK+FIiEj8RzR6+k4+m9WGw+7EYXfh82SR6c0m05Md+29GTjzcKyY/u4j87GLcTs8Qf5Ynaw8GOFj9LvuP7mL/sV3sP7qT9uDpf29NH1vB0unTWDZjBounTSHb61UAOIK1B4P85tnn+dVTzyQ35jrsTq5f+XGuWPpBbNbYn53pGABGolFeeWcHm/ftB8BmtzF/5XRKKsz7BrSuuolN63bS3RUG4LzK8Vw4+zzsJv0dxDBgy/4DvLx9O1HDwGKBmQsnMWF6ed8vpgBwVFMAaC4FgCICoygArKqq4vbbb6c1fmCxx+MhFAolvxG59tpr+fSnP93n63Z2dvLNb36TPXv2ACTPgUqMqk2bNo077rgD9xnOTFq3bh133XUX4XDsL3per5f2+F+g2MCcngAALE5JREFU7XY7t912GytWrBiU9+6L4RAA/vZnP+XL/3HHoFzbbrdTUlJCaWlp8tyvnrfHjBlDUVGRzpo5DQWAfROJRKirq+PYsWMcPXo0GfL1/G99/dB3oKWK2+3GarUSCoVO+/vBYrFQUT6DmTOWMWvmcqZMXojHY/7CgECgnaamJpqammhsbKSu7jh1dXVnHEu226yU5OYxtriQcUVF5Gd6MQyDqBHFYXcmQ5HhKmpEOXL8ALsObWbXoc3sPrydYNdpAlyLhZnjx7FsxnQunDuHeRMqyXC5TKhYUq2htY2HXnyJ3zz7HI1tJ8Lg+VOX86HLP0thzsnjq+kWALa2d/D0hg3UNsX+XuLyOFl8yXnk5J/awTrU/C3tvPnX7XQEYkcGFGRncdXCheRnDW1tHaEQz729mQM1tQDYHTbmr5xBcXk/zydUADiqKQA0lwJAEYFREgB2d3fzT//0T9TW1jJu3Di+9KUvUVlZSSgUYvXq1Tz44IMYhsEXv/hFLr300j5d+wc/+AHr1q3D6/XyxS9+MdlJ+MYbb/CTn/yE9vZ2LrroIm677bZTXltVVcU///M/Ew6HWb58OZ/61KfIy8ujqamJe+65h/Xr1+NwOLjrrrsoLz/1X1oH8t59NRwCwJY9u6l54zXCkTDhSIRwJEo4EqE7EiHU1U17sJNAMEigsxN/Z5D2ziD+zg6aAwEa2/w0tLXR2NZGsz+QHF/qC4fDkQwEy8vLk5tEE/fHjBlD5mlG40Y6BYAnGIZBS0sLx44dS/54b7hXU1OT/AeB3rJZrRRmZ5OX6SPH5yPb6yXH5yXH643fz8DnduN2Ot/zw4Ez/k35qbXGwshgdxfBrm6CXV2EumP/7ezqoq2jg9b2Dlrb2+M/YhtnWwLtNPnbaGht6/X3d25XPj5vOT5vOV5vGXZb7B8tPB4PGRkZeL1evF4vGRkZZGR48XjcuFyuHj9i951OBzabrdfdut3d3YRCXYRCQUKhEMFgiPb2dgIBP4FAgEAggN/vp7m5+ZznDzrsdkrz8igvyGdMQQEluTmmdeyYIRKNcKhmD7sOxgLBvUd20PX/27v3+KjKA//j3zOXTDK5kEwuJJAQAgQQuQioRWyBKrssYsVirRYQ2draXbdbu/76qrp4aRcBd+uL1baLW6VqEamrwEILii5asbYoVblfKglg7uSeIZeZZGbO748wY0KuQEjI5PN+veaVM/Oc55xnIOfJnO+c8zy+trdwWy0WTRqRpeuuuELXjRurq7Oz5YwkEOwvTNPU3txcrX/nD/rd7o/U2KKvGjFkrG776rd15Yip7da9XALAQKD5Pew+ekxNZ9ufOHiQpswYpyjn5fO76PU06tM/HlVZUfPnJpvVqmvHjNbU7FGXvG8xTemvBQV6/+Ch0Ky60XFRumbWlYpLuIgvZAgABzQCwL5FAAhAGiAB4LZt2/Tcc8/J4XBozZo1Sk5OblX+3//933rjjTfkcrm0du3abt82e/LkSf3whz+UaZp66KGHNH369Fblf/rTn/Tv//7vMgxDP//5z5WZmdmqfNWqVdq9e7eysrK0evXqVietfr9fDzzwgE6ePKnrr79eDz74YI/u+3z1hwDQV1igpkP7L3o7/kBA1bW1KnefUWl1tUoqK1VcWaWiisrm5arm5eCtTucjLi6uVSh4bkiYmpoqu91+0e/hcjKQAsAzZ86ouLg4dHtuy6Av+GjvNteuJMbFKs3l0pBEl4YkJmqIy6UhSWd/JrqUEt+3YZNpmiooL9e+3JPal5urvbkndOjU5x1OZBEXnSLXoOGKjclQZORgNQVs6uk/RcEg0Gq1hia+CAQCzVfhBQIX9bvosNuVPGiQUuLjlRI/SIMT4hUfEyML44qGNPkadaLomI6d2qejp/Ypp+CIfP62oY/VYtGY9KGaNHKEJo8cockjR2rU0CGycjX1ZSMQCOjQ53na/tEebftoj/LLWn8eGJV+pW6+/lualD2t01vz+zoANE3pRHGJdh89qrKaLya7GTV+mMZOybosj1/TNJV7OF9HPz0Z6iPjo6M1/cpxyh4yRBZLz7bZNKWiykp9cOiQiioqQ68Py07V+GuzZbNd5N8ZAsABjQCwbxEAApCkATFF1nvvvSdJmjFjRpvwT5Juu+02vfnmm6qsrNTBgwc1efLkbm13165dMk1TaWlpuu6669qUT58+XWlpaSouLtauXbu0ZMmSUFldXZ3+8pe/SJJuvfXWNlesWK1W3XrrrfrP//zP0NhYTqezR/aNzlktFiXGxSkxLk5j0jueAbDe41VxZaWKKitVXFGpwooKFVVUqKiiUkUVFSqsqGwTgLjdbh05ckRHjhxpd5sWi0WDBw8OhYLBRzAsTElJUWJiYuh2b/SOxsbGs7d9lur06dOhgK+4uDgU+BUXF6u2tva8tx0dGak0l0tDE11KS3RpaGKihiS6lOZK1NAkl9JcLkVeRv/fZ+ob9FlhoT4rKNRfCwr014JC/TW/QOVud4d1hiYP1xVZV+mK4ZM1aug4DYpxtSoPmKYavI2q93hU7/WqzusNLdd7varzeFXv9aje41VDY2O3wkK/33/BIZ/FMBQdGamYqEhFR0ZpULRTCTGxSoiNkSsmRlEOR7tXTeILdluExgybqDHDJmr+jCVq8jXqZPExHcr9REdP7dOJwqPyB/zyBwI6kpevI3n5+u0fdklqPibGZqRrdPpQjUlP1+ihQzUmY6iS4uKYvKkX+Px+5RYV69OcXH1w+LD+dPioKs8ZS9RmtetLV35Vf3Pt1zU8bXQftbR7vE0+5RQWaW9ubqvgLy4hWhOvGy1X8qA+bF3nDMPQqPHDlJSWoIMfHVdVmVvVdXV6Y89fNCg6WpNHjtTo9KGKvsiraJt8fuUWF2tfbq6KK7/4ojYq2qErrxmlIZltPzsDAID+J+wDwIaGBh0/flySNGXKlHbXSU5OVnp6uvLz87V///5uB4AHDhyQJE2ePLndkxLDMDR58mQVFxeH1g06cuRI6Da/jtoVfL2pqUlHjx7V1Klf3FZzMftGz3BGOjRySJpGDml/pkDTNFVVW9siEKxQUXlzMFhcWanC8gqdrq5uFWYEAoFQqBQMiNsTFxcXmrQkOTk5NHlJ8GdcXFzoMWjQIMXFxTHzsYIzvNappqZGbre71c+amhpVVFSovLxcZWVlKi8vDz1qWpw0ng+71arU4JV7rrNX7yV+cSVfWqJLg5zOy+b/xTRNnWloUIXbreLKKhWUlSu/rEz55eXKL21eLuniKt4Ie6Sy0kYra+hYjRwyVqOHTVBi/OBOr/xpDtwc3TqJDZimGpt88jY1ydvUpMamJnmbfPL6mtTU5JM/EJDfDDT/9DcHTKYpWSyGLIYhi8Uii2HIMAzZbTY5bHY57HY57DZF2O1yOhxyRjouy6uB+rMIu0NXjpiqMcMmyTRNeRsbdDz/sHILjyi38JhOFB5VbUNziFzn8eiT4zn65HhOq20kxMRoWEqyMpKTlZ6cpIykJGUkJ2lIUqKS4wZpULSTcVjPg8/vV0F5hT4/fVqnTp9WblGxDp76XIc/z2v36l3DsGjc8Kt07ZVf1dSxX1ZMVFwftLprpim56+uVV1qmvNJSnSgpka/FlwGOSLtGjR+mrCuG9pvfl/jEWH157mTl55To2L5T8tR7VVNXp/cOHNCugweVnpSojJRkDXElKiV+kBxd3Eng8/tVXuNWSVWV8srK9Pnp0lb/RlabVaPGZ2jklRkXf9UfAAC4bIR9AFhQUBAKWDq7DTYzM1P5+fnKz8/v1nZN01RBQUGX2x02bJgktdlu8Hlw5sz2BGfXrKmpUV5eXigAvNh9o3cYhiFXbKxcsbEaP7z9/6cmn08lZ28pDl412PIqwqKKCrnrG9rUc7vdcrvdOnHiRLfbY7FYFBsbq0GDBik2NlaxsbGKiopSVFSUIiMjFRkZ2ep5y58RERGy25vHV7Pb7bLZbKHllq8FX28ZaFmtVsXFxcntdnd4RZZpmvL5fPL7/WpqapLP55PP51NTU1PotZbLPp9PjY2NamhoCD3q6+tbPW/52pkzZ0JBX0/NQBoZEaHUhASluRKU6ko4u+xqfp6QoMGuBKUMGtTpCWawb2rvirbOrnILmKZ8fr8afT41+Xxq8vnV5D/70+drfv3sc09jo2o9zWNe1no8qvM0qM7jVZ3HI3d9vSrdZ1ThPqOKM2dU4Xa3GtOrK1GOaKWnZGlocqaGp43RiCFjNTRl+CWd4MJiGIqMsCsyIrxulR9oHBFRGj/yao0febWk5t/3supinSg8ppNFx1RQdkqFpadUXVsRqlNVW6uq2lrtP3Gy3W3arFa5YmOVFBerxLg4JcTEKCYqSrFRkYp1OkPLMVFRctibx7+MsNvksNnkiPjieYStOQy2GhZZLZbm8PhscBwMkXubaZpq8vvlO3usB8e39YVea15uaPSqtsGjOo/ni58ej87U16u8xq1yt1tlNTUqq6lReY1b/i76w/jYRF2ZNUVXZk3V+JFXKy46oZfecWum2Tw8h8/fur9raGxUnccT6s8q3G5VuM/I29T2iwZnTKRGXJGuYaPT+mWoZRiGhmWnKX3kYBWcKFXu4Xydqa6TaZrKLytvdWt2ZESE4pxOOew22aw2GYZCfzPO1Deo3utt929MlNOh4WOHKnN0miIc9LEAAISbsA8AKyu/GMPE5XJ1uF6wrLtj1DU0NMhzdmDk7mw3GEhERUW12k9ndYPlNTU1rdp1sftuz/r167Vhw4YOy7/1rW9p4cKFnba1I8GTJYvFooSES3fy8P0f/T/9at3Ll2z7562HxjQz1DND5QQCgdCVbrh4nsZGnTp75Uw4MwyrIuyxckQMkiMiTg5HvJyRSYqKSpLd1nxVaZ1fOlxg6nDBUUlHO93eZT3s0yUYEveyfr8tXF7DAafLEZ2uEVlfls/nkcdboQZPhTzeKjU2uuVtqlFjo1uBQOuQx+f3q7S6WqXV1X3T7H7OanUoKjK5+RGVImdkiiIiBqnWb+ijnDp9lLOrr5t43iKdDg1OT1TGqFQlDh502VxtfTEsVouGjxmizNFpqqmsVdHJUpUUVOhMVV3oOPY0NnY4Buu5nDGRSs1IUlpmkhJT43sl4O4vV17i0mk5HiB6R3RM9CU9D+uOYB88aNCgy+xzBzBwhH0AGAzKJMnh6Pj2smBZQ0Pbq63a03K97mw3WCcYwgXrd1a3o3Zd7L7bU1dXp9LS0g7L6+vruz2zZkcMw7jobXTGa15uJ7HA5coiwzBkGBYZhlWGYZXFsDU/t9hkCb5msZ8tb/7A1uhrUKOvQWfqivu4/RiwDIscEQmKsMfLVEBmoEmBgE+m6VfA9MsM+M8u+2SaAZlmQFLw50BmkcVibX28W5qP8dDDaP773Nh0Ro1NZ1Tjzu3jNnefYUiuhHgNG56hzOEZyhqeofETrlB6xpCwCP26o7a2Tn89lqP8/EKVFJeptLRcnoYGNTQ0fw6OcETIGRWppOREJackKSN9iMaMHSVXYt8GAgB6R2bG0Et6HnY++BIA6DthHwCie6Kjo5WSktJhudPpvPAB9S3NYUNw9s1L5foZM7T/0KELqnsxJwgXUrerOpdimxey3eD/WXD21JavSWr1esvl9vbbXlnL9hhnx2ULPoK/N+09gmXBnxfzHrtb90K3eyn+r6XWs9y2fFgsllbLNptNERERcjgcioiIkM1mu2Rt6mx7FotFpmn2aEh/KU7s2eal2Wbw2O2J34ELaadpmmpqapLX65XX65Xf7w8NNeDz+RQIBELDDASHIwj2aec+zn295fOO3nt33kNHfVnwy7Nzj+32ftrtdjkcjtDx7nA4ZLfbOz3Z6q3fpYv9HYiIiFB0dHTo4XQ65XK5lJqaquTkZNm7GPduIJj5lWl93YROBf8WdPZ5AeGrt84H0LELPZfrKd3pAy6XkBIIV2EfAEZGRoaWvV5vq5l0W/J6vZLU6VVyLbVcL1i3s+2eWye43Fndjtp1sftuz+LFi7V48eIOy8vLy7t9e/S5EhISZLVaFQgELngb3TF//nzNnz//km0fF8ZqtSohIUFVVVV9/sEDfSPYB/j9/kvaB+DyRT+AS9kPXMgM7Oh9wX6gpqaGfmAA6q3zAVy+utMHJCUl9XKrgIEl7K+/bTlGXsvxAM8VLOvu2AjByRK6u92W67dsV2d1O2rXxe4bAAAAAAAAA0fYB4Dp6emhW1Hy8vI6XC9YlpGR0a3tGoah9PT0C95u8Hl1dbXcbne7dVtO2BCc0bcn9g0AAAAAAICBI+wDwKioKGVnZ0uSPv3003bXKS8vV35+viRp0qRJ3d72xIkTJUl79+7tcJ19+/a1Wjdo3LhxstlsnbYruF273a4rrriix/YNAAAAAACAgSPsA0BJmjVrliTp/fffV1lZWZvyzZs3yzRNuVwuTZgwodvbnTFjhgzDUFFRkXbv3t2m/M9//rOKiopkGEaoDUFOp1PXXHONJGnr1q1txkHw+/3aunWrJOnaa69tM3bhxewbAAAAAAAAA8eACADnzJmj1NRUeTweLV++XCdPnpTUPEnGxo0btX37dknNE2EEr8oL+s53vqNbbrlFTz/9dJvtZmVlacaMGZKkX/ziF/rwww9Ds9t9+OGH+uUvfympOYBseQtv0KJFi2Sz2ZSbm6vVq1eHBsStqqrS6tWrlZubK7vdrkWLFvX4vgEAAAAAADAwhP0swFLzLbSPPPKIli1bplOnTun++++X0+mUx+MJTUN/8803a/bs2ee97fvuu0/FxcX67LPPtHLlSkVEREiSGhsbJUljx47VP/7jP7Zbd9iwYbr//vv1zDPP6I9//KM++OADOZ1O1dXVSZJsNpvuv//+0Hh/PblvAAAAAAAADAwDIgCUmsO2X/ziF9q0aZP27Nmj8vJyRUdHa8SIEZo3b56mTZt2QduNiorSk08+qW3btmnXrl0qKiqSJI0cOVKzZs3SvHnz2lxV2NLMmTOVkZGhzZs369ChQ3K73aFbkRcsWKCsrKxLtm8AAAAAAACEP8M0TbOvG4HLX3l5+QXXTUhIkNVqld/vD93mjIHDarUqISFBVVVVbca6xMBAHwD6AdAPgH5gYKMPQHf6gKSkpF5uFTCwDIgxAAEAAAAAAICBigAQAAAAAAAACGMEgAAAAAAAAEAYIwAEAAAAAAAAwhgBIAAAAAAAABDGCAABAAAAAACAMEYACAAAAAAAAIQxAkAAAAAAAAAgjBEAAgAAAAAAAGGMABAAAAAAAAAIYwSAAAAAAAAAQBgjAAQAAAAAAADCGAEgAAAAAAAAEMYIAAEAAAAAAIAwRgAIAAAAAAAAhDECQAAAAAAAACCMEQACAAAAAAAAYYwAEAAAAAAAAAhjBIAAAAAAAABAGCMABAAAAAAAAMIYASAAAAAAAAAQxggAAQAAAAAAgDBGAAgAAAAAAACEMQJAAAAAAAAAIIwRAAIAAAAAAABhjAAQAAAAAAAACGMEgAAAAAAAAEAYIwAEAAAAAAAAwphhmqbZ141AeFu/fr3q6uoUHR2txYsX93VzAPQy+gAA9APAwEYfAAB9jwAQl9xNN92k0tJSpaSk6I033ujr5gDoZfQBAOgHgIGNPgAA+h63AAMAAAAAAABhjAAQAAAAAAAACGMEgAAAAAAAAEAYIwAEAAAAAAAAwhgBIAAAAAAAABDGCAABAAAAAACAMGbr6wYg/C1cuFB1dXWKjo7u66YA6AP0AQDoB4CBjT4AAPqeYZqm2deNAAAAAAAAAHBpcAswAAAAAAAAEMYIAAEAAAAAAIAwRgAIAAAAAAAAhDECQAAAAAAAACCMMQswuq2kpETbt2/Xp59+qvLycklSQkKCsrOzdf3112vatGnt1jNNUzt37tTOnTuVl5cnn8+nwYMHa/r06VqwYIEiIyO73O+mTZu0d+9eVVVVKTo6WmPHjtUtt9yi8ePH9/j7BNA1v9+vH/3oR8rNzZUk3XnnnVq4cGGH69MPAP1XQUGBPvzwQx08eFCff/653G637Ha70tLSNHXqVN18881KSEjodBv0AcDAVFNTo40bN2rPnj2qqKiQw+HQyJEjddNNN3V47gAAuDSYBRjdsmPHDq1du1aNjY2SJIfDIUnyer2SpEmTJmn58uVt6vn9fq1atUp79uyRJNlsNtlsNnk8HknS0KFDtXLlyg5PHA4cOKAVK1aooaFBkuR0OtXQ0CDTNGUYhpYuXaqvf/3rPftmAXTpf//3f/Xiiy+GnncWANIPAP3XkSNH9NBDD7V6LTo6Wg0NDQoEApKk2NhYPfzwwx0GcfQBwMCUl5enZcuWqaamRpIUFRUlr9cb6ju+9rWv6bvf/W5fNhEABhSuAESX3nnnHa1Zs0aGYWj+/PmaN2+eUlNTJUlut1sHDx5UaWlpu3U3bNigPXv2yG63695779WNN94om82mQ4cOafXq1SosLNR//Md/aNWqVW3qVldXa9WqVWpoaNCECRP0/e9/X2lpaaqtrdWGDRu0bds2vfTSSxoxYoQmTZp0Sf8NAHyhpKREGzZsUEpKihobG1VdXd3p+vQDQP/l9/tltVo1bdo0zZo1SxMmTJDT6VRTU5P27t2r5557TqWlpVqxYoXWrFnTbohHHwAMPE1NTXriiSdUU1OjzMxMPfDAA8rKypLX69XWrVv1yiuv6Pe//72ysrI0e/bsvm4uAAwIjAGITpWVlem5556TJH3ve9/TPffcEwr/JCkuLk7XX399u9+8V1dXa+vWrZKkxYsXa86cObLZmjPn8ePH6+GHH5ZhGDp8+LA+/vjjNvU3bdqkuro6uVwuLVu2TGlpaZKkmJgY3Xvvvbr66qtlmqbWrVvX4+8bQMeeffZZeb1efe9731NERESn69IPAP1bWlqa1qxZowcffFBf+tKX5HQ6JUl2u13XXnutHn/8cUVERKiurk5vvfVWm/r0AcDA9NZbb6mkpEQOh0OPPfaYsrKyJDXfRfTNb35Tc+fOlSStX79ePp+vL5sKAAMGASA69fvf/14NDQ3Kzs7WTTfddF51//znP6uxsVFOp7PdutnZ2Zo4caIk6b333mtVZpqm3n//fUnS3LlzQyccLX3jG9+QJB0/flyFhYXn1TYAF+a9997T3r17dd111+maa67pcn36AaB/S0pKCoVu7cnIyNDo0aMlSTk5OW3K6QOAgSl4PM+YMUPJycltym+77TYZhqHKykodPHiwl1sHAAMTASA61fKP9/k6cOCAJGncuHGhMQPPNXnyZEnS/v37W72en5+vqqoqSdKUKVParTtmzJjQycC59QH0PLfbrV//+teKiorq9pg99ANA+IuLi5Ok0LheLdEHAANPQ0ODjh8/LqnjYzc5OVnp6emSOHYBoLcwBiA6VFJSEhrba+TIkfrss8/0+uuv68iRI/J4PEpMTNSUKVN02223tfvNXn5+viQpMzOzw30Ey2pqauR2u0MnEXl5eaF1hg0b1m5dq9Wq9PR0ffbZZ6F9Abh0XnjhBdXU1Oiee+5RUlJSt+rQDwDhze/36+jRo5LaP07pA4CBp6CgQMF5Jrs69vPz8zl2AaCXcAUgOlRUVBRaPnTokB588EF99NFH8vl8slqtKikp0RtvvKEf/OAHOnz4cJv6wW/tXS5Xh/toWRZcv+VyTExMh1cMtKzfsi6Anrd//369++67ysrK0s0339ztevQDQHjbtm2bqqqqZLFYdMMNN7Qppw8ABp7KysrQcneOfY5dAOgdXAGIDtXW1oaWX331VaWlpemf//mfNW7cOJmmqcOHD+vnP/+5SkpK9OSTT+rZZ59VTExMqI7H45GkTj+0tyxraGhos9xZ3ZblLesC6FmNjY1as2aNLBaL7rvvPlmt1m7XpR8Awldubq5efvllSdK8efPavUqPPgAYeILHvdS9Y59jFwB6B1cAokPBS/eD/vVf/1Xjxo2TJBmGEZq9z2KxqKamRm+//XZfNBPAJfbb3/5WxcXF+tu//VuNGTOmr5sD4DJQVlamFStWqLGxUaNHj9bSpUv7ukkAAADoBFcADmArV67UsWPH2rz+la98Rd/97ncVFRUVem3KlCnKyMhos25WVpYmTpyoffv2af/+/VqwYEGoLDIyUrW1tfJ6vR22oWVZy/0Flzur27K8ZV0A3ddVP3Dy5Elt2bJF8fHxWrJkyXlvn34AuLx11Qe0p7KyUo8++qjKy8s1bNgwPfbYY7Lb7e2uSx8ADDyRkZGhZa/X2+4M3sEyiWMXAHoLAeAAVltbG5rko6W6ujpJrcfsGDp0aIfbSU9P1759+1ReXt7qdZfLpdra2lbjgJyrZVlCQkKrusE2er3eDm8fCNZvWRdA93XVDzz//PPy+/1auHChrFZrm9t0glcK+3y+UFnLD/L0A8Dlras+4FzV1dV69NFHVVRUpLS0NC1fvjw0aUd76AOAgaflOURlZWWHASDHLgD0LgLAAWzlypWdlmdkZMhisSgQCFzQ9jMyMpSXl9dqFr9zBcsGDRrU6gSi5dWG+fn5GjVqVJu6gUBABQUFbdYH0H1d9QOlpaWSpDVr1mjNmjUdrrdx40Zt3LhRkrRhw4bQeKD0A8Dlras+oCW3261HH31U+fn5SklJ0RNPPNHliTt9ADDwpKenyzAMmaapvLw8paent7te8Njn2AWA3sEYgOiQw+HQ2LFjJUmFhYUdrhf84D148OBWr0+cOFGSdPjw4Q5v3/n0008lSZMmTWr1ekZGRujbw+A65zp27Jjq6+vbrQ/g8kA/AISH2tpaPfbYY/r888/lcrn0xBNPKDk5uct69AHAwBMVFaXs7GxJHR+75eXlys/Pl8SxCwC9hQAQnbrhhhskNf/xbu/b+xMnTujAgQOSpKuvvrpV2XXXXaeIiAjV19drx44dberm5OSE6s6aNatVmWEY+spXviJJ2rFjR+jDfUubN2+WJGVnZ3d6izKAC7d27Vr97ne/6/CRkpIiSbrzzjtDr7WcDZx+AOj/6uvr9fjjj+vEiROKj4/XE088odTU1G7VpQ8ABqbg8fz++++rrKysTfnmzZtlmqZcLpcmTJjQy60DgIGJABCduvHGG5WZmalAIKBVq1bp6NGjobLDhw/rySefVCAQUGpqqm688cZWdePj4zV//nxJ0rp16/T222/L7/dLkg4dOqSVK1fKNE1deeWVbcJDSbrtttsUHR2t8vJyrVixQiUlJZKaxyV6/vnntWfPHhmGcUETEwDoHfQDQP/m8Xj0b//2bzp+/Lji4uK0fPnyDm/naw99ADAwzZkzR6mpqfJ4PFq+fLlOnjwpqXnij40bN2r79u2SpMWLF8tmY1QqAOgNhhkcwR3owOnTp7Vs2bLQWGBRUVEyTVMej0eSlJSUpJ/85CcaNmxYm7p+v1+rVq3Snj17JEk2m002my1Ud+jQoVq5cmWHYwgdOHBAK1asCE0uEB0drYaGBgUCARmGoaVLl+rrX/96j79nAN3zne98R6Wlpbrzzju1cOHCdtehHwD6r3fffVdPP/20pOahQTqbrTMpKUmrV69u8zp9ADAw5eXladmyZaqpqZEkOZ1OeTye0PjiN998s+69996+bCIADCgEgOiW+vp6bdmyRbt379bp06dlmqZSU1M1bdo0zZ8/v9Utf+cyTVM7d+7Uzp07lZeXJ5/Pp8GDB2v69OlasGCBIiMjO913SUmJNm7cqL1796qqqkrR0dEaO3as5s+fr/Hjx/f0WwVwHroTAEr0A0B/9c477+iZZ57p1ropKSlau3Ztu2X0AcDAVF1drU2bNmnPnj0qLy9XZGSkRowYoXnz5mnatGl93TwAGFAIAAEAAAAAAIAwxhiAAAAAAAAAQBgjAAQAAAAAAADCGAEgAAAAAAAAEMYIAAEAAAAAAIAwRgAIAAAAAAAAhDECQAAAAAAAACCMEQACAAAAAAAAYYwAEAAAAAAAAAhjBIAAAAAAAABAGCMABAAAAAAAAMIYASAAAAAAAAAQxggAAQAAAAAAgDBGAAgAAAAAAACEMQJAAAAAAAAAIIwRAAIAAAAAAABhjAAQAAAAAAAACGMEgAAAAAAAAEAYIwAEAADoIS+99JIMw5BhGHrppZf6ujkAAACAJAJAAAAAAAAAIKwRAAIAAAAAAABhjAAQAAAAAAAACGMEgAAAAAAAAEAYIwAEAAAAAAAAwhgBIAAA6Hf8fr+GDBkiwzAUGxur+vr6Lus0NjYqKSlJhmEoMTFRjY2NoTKPx6OtW7fqBz/4gaZPn67k5GTZ7XbFxsYqOztbd911l/7v//7vott96tSp0CzBS5cu7XL94cOHyzAMDR8+vMt1c3Nz9dBDD+maa65RcnKyIiIiNHjwYN1www165plnuvVvBAAAgPBk6+sGAAAAnC+r1apFixbpqaeeUm1trTZv3qzFixd3WueNN95QRUWFJOmOO+5QREREqGzcuHE6efJkmzq1tbXKyclRTk6O1q9fr/nz52v9+vWKiYnp2Td0EQKBgB555BH97Gc/k8/na1VWWlqq0tJS/eEPf9BTTz2lLVu2aOrUqX3UUgAAAPQVAkAAANAv3X333XrqqackSS+//HKXAeC6detCy0uWLGlVVl9fr/j4eN1www2aPHmyMjMz5XQ65Xa7deDAAf3P//yPiouLtXXrVn3729/Wa6+91vNv6ALdfffdWr9+vSTJ5XLpjjvu0NSpUxUXF6fS0lJt375db775pgoKCvTVr35VH3/8sUaPHt3HrQYAAEBvIgAEAAD90vjx4zV58mTt3btX77zzjoqLi5WWltbuupWVldq+fbskafTo0Zo2bVqr8hdffFGzZ8+W3W5vt/6KFSu0aNEibdmyRa+//ro++OADffnLX+7ZN3QBfvWrX4XCv6997Wtat26d4uPjW63zT//0T9q8ebPuuOMOnTlzRt/+9rf1wQcf9EFrAQAA0FcYAxAAAPRbwSv5/H5/KAhrz2uvvRYa8++uu+5qUz537twOwz9Jcjqd+s1vfqPo6GhJ0m9+85uLaXaP8Hq9+ulPfypJuuKKK7Rx48Y24V/QggUL9OMf/1iS9Kc//UkfffRRbzUTAAAAlwECQAAA0G8tXLhQNlvzDQ0vv/xyh+sFb/81DKPdALA74uLiNGHCBEnShx9+eEHb6Elvv/22iouLJUk//OEPW41p2J677747tPzWW29d0rYBAADg8sItwAAAoN9KSUnR3/3d32nbtm06ePCg9u3bp6uuuqrVOjk5Odq9e7ckacaMGcrMzGx3W1VVVXrllVe0Y8cOHTp0SBUVFaqrq5Npmm3WLSgo6PH3cr7ef//90PKZM2e0ZcuWTtdvamoKLR85cuRSNQsAAACXIQJAAADQry1ZskTbtm2T1Hyl37kBYMtbg8+d/CNo69atuueee0KzBHfF7XZfWGN70KlTp0LLP/rRj86rbmVlZQ+3BgAAAJczAkAAANCv3XLLLUpISFBVVZV++9vf6mc/+5msVmuoPHhrsNPp1O23396m/u7du/WNb3xDPp9PkjRx4kTNnj1bo0aNUkJCghwOhwzDkCQ98sgjOnz4sAKBQC+8s85VV1dfcN3geIgAAAAYGAgAAQBAv+ZwOPTNb35Tv/rVr1RSUqK3335bc+fOldQ84cWJEyckSbfeeqtiY2Pb1H/sscdC4d9//dd/6b777utwXytWrLgE76Bjfr+/w7KYmJjQ8oEDB0LjEwIAAADnYhIQAADQ77W8tTc44ce5y+3d/tvU1KT33ntPkjR16tROwz+p9W23F8LhcISWu7oKzzTNTm/VTU9PDy3n5+dfVLsAAAAQ3ggAAQBAvzd9+nRlZ2dLah7P78yZM/J6vXrttdckSWlpaZo9e3abeuXl5aGr/0aNGtXpPv7yl7+ovLz8otoZHx8fWi4sLOx03X379qm+vr7D8pkzZ4aW33zzzYtqFwAAAMIbASAAAAgLd911lySpoaFBr7/+urZt2xYaJ2/RokWtxgUMio6ODi3n5OR0uv3HH3/8otsYFRWlESNGSJL27NnT6WQiq1ev7nRbc+fOVXJysiTphRde6LL9AAAAGLgIAAEAQFi46667QpN1rFu3rsvbfyUpLi5Oo0ePliR98skn2rhxY5t1/H6//uVf/qXHrrILjk/o8Xj08MMPt7vO008/3Wr24vZER0frJz/5iSSpvr5ec+bM0d69ezutk5OTowceeEClpaXn33AAAAD0W4ZpmmZfNwIAAKAnzJo1S7t27ZJhGLJarfL5fLrqqqs6DcaeffbZ0Nh/hmHojjvu0MyZM5WQkKCcnBy98sorOnr0qMaPHy+Hw6FPPvlEUvMYfed66aWX9Pd///eSpBdffFFLly5ts87x48c1ceJEeTweSdLs2bN1++23KyEhQfn5+dq4caN2796tmTNnKicnR4WFhcrMzOxw/MF77rlHL7zwQqj9c+bM0Y033qj09HQZhqHKykodPXpUf/zjH7Vv3z5JzWMGthxDEAAAAOGNWYABAEDYWLJkiXbt2iXTNENj+3V09V/QP/zDP+jjjz/WCy+8INM09eqrr+rVV19ttc6ECRO0devWULh3MbKzs/X8889r6dKl8vv92rlzp3bu3NlqnRkzZmjz5s2aMmVKl9tbu3atxowZo5/+9Keqr6/Xjh07tGPHjg7XT0pKUmRk5EW/DwAAAPQf3AIMAADCxu233y6n0xl6brPZtHDhwk7rGIahX//619q0aZPmzJmjxMRE2e12paamaubMmfrlL3+pPXv2KCsrq8fauXjxYn3yySdavHixMjIyFBERoaSkJM2YMUNr167Vu+++K5fL1a1tGYahH//4xzp16pSefPJJzZ49W0OGDJHD4ZDD4dDgwYN1/fXX6/7779e2bdtUVFSkpKSkHnsvAAAAuPxxCzAAAAAAAAAQxrgCEAAAAAAAAAhjBIAAAAAAAABAGCMABAAAAAAAAMIYASAAAAAAAAAQxggAAQAAAAAAgDBGAAgAAAAAAACEMQJAAAAAAAAAIIwRAAIAAAAAAABhjAAQAAAAAAAACGMEgAAAAAAAAEAYIwAEAAAAAAAAwhgBIAAAAAAAABDGCAABAAAAAACAMEYACAAAAAAAAIQxAkAAAAAAAAAgjBEAAgAAAAAAAGGMABAAAAAAAAAIYwSAAAAAAAAAQBj7/3iBRVr8VUNkAAAAAElFTkSuQmCC" + }, + "metadata": { + "image/png": { + "height": 480, + "width": 640 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "from plotnine import ggplot, aes, geom_density\n", + "(\n", + " ggplot(df, aes(x=\"value\", fill=\"variable\")) +# geom_bar(stat=\"bin\", binwidth=1, alpha=0.5) + \n", + " geom_density(alpha=0.5) \n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f826c987-9131-48c5-8549-f18917728c88", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f5531352-d246-465e-843e-728ac5d951a9", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 6b7a52a1746fcd704280fddd6ae385bbf9215fb1 Mon Sep 17 00:00:00 2001 From: Felipe Montealegre-Mora Date: Mon, 4 Mar 2024 17:13:39 +0000 Subject: [PATCH 11/13] imports --- pyproject.toml | 2 +- tests/test_caribou.py | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 5b4f5df..52e8493 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -8,4 +8,4 @@ dependencies = ["gymnasium", "typing"] [project.optional-dependencies] -tests = ["pytest", "pytest-cov", "stable_baselines3"] +tests = ["pytest", "pytest-cov", "stable_baselines3", "scipy"] diff --git a/tests/test_caribou.py b/tests/test_caribou.py index 6deb5da..2efac69 100644 --- a/tests/test_caribou.py +++ b/tests/test_caribou.py @@ -1,11 +1,12 @@ # Confirm environment is correctly defined: from stable_baselines3.common.env_checker import check_env import numpy as np -from rl4caribou import Caribou +from rl4caribou import Caribou, CaribouScipy from rl4caribou.agents import constAction, constEsc def test_Caribou(): check_env(Caribou(), warn=True) + check_env(CaribouScipy(), warn=True) def test_constAction(): ca1 = constAction(mortality_vec = [0,0]) From f4cb4f21ed2746eba7b3070cec048be4087640ad Mon Sep 17 00:00:00 2001 From: Felipe Montealegre-Mora Date: Fri, 8 Mar 2024 17:27:24 +0000 Subject: [PATCH 12/13] relative paths --- hyperpars/ppo-caribou.yml | 2 +- hyperpars/tqc-caribou.yml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/hyperpars/ppo-caribou.yml b/hyperpars/ppo-caribou.yml index 19aeb58..1420371 100644 --- a/hyperpars/ppo-caribou.yml +++ b/hyperpars/ppo-caribou.yml @@ -8,5 +8,5 @@ tensorboard: "/home/rstudio/logs" total_timesteps: 500000 use_sde: True repo: "cboettig/rl-ecology" -save_path: "/home/rstudio/rl4caribou/saved_agents" +save_path: "../saved_agents" id: "2" \ No newline at end of file diff --git a/hyperpars/tqc-caribou.yml b/hyperpars/tqc-caribou.yml index e6b5011..b7c558e 100644 --- a/hyperpars/tqc-caribou.yml +++ b/hyperpars/tqc-caribou.yml @@ -8,5 +8,5 @@ total_timesteps: 500000 config: {} use_sde: True repo: "cboettig/rl-ecology" -save_path: "/home/rstudio/rl4caribou/saved_agents" +save_path: "../saved_agents" id: "2" \ No newline at end of file From 08ef3484242eee4f48011e1d51cc9dad100c6788 Mon Sep 17 00:00:00 2001 From: Felipe Montealegre-Mora Date: Fri, 8 Mar 2024 19:43:48 +0000 Subject: [PATCH 13/13] yaml changes --- hyperpars/ppo-caribou.yml | 2 +- hyperpars/rppo-caribou.yml | 2 +- hyperpars/td3-caribou.yml | 2 +- hyperpars/tqc-caribou.yml | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/hyperpars/ppo-caribou.yml b/hyperpars/ppo-caribou.yml index 1420371..b3aa2a7 100644 --- a/hyperpars/ppo-caribou.yml +++ b/hyperpars/ppo-caribou.yml @@ -7,6 +7,6 @@ n_envs: 12 tensorboard: "/home/rstudio/logs" total_timesteps: 500000 use_sde: True -repo: "cboettig/rl-ecology" +repo: "boettiger-lab/rl4eco" save_path: "../saved_agents" id: "2" \ No newline at end of file diff --git a/hyperpars/rppo-caribou.yml b/hyperpars/rppo-caribou.yml index 6dfb284..5478c47 100644 --- a/hyperpars/rppo-caribou.yml +++ b/hyperpars/rppo-caribou.yml @@ -9,5 +9,5 @@ total_timesteps: 500000 config: {} use_sde: True id: "1" -repo: "cboettig/rl-ecology" +repo: "boettiger-lab/rl4eco" save_path: "/home/rstudio/rl4caribou/saved_agents" diff --git a/hyperpars/td3-caribou.yml b/hyperpars/td3-caribou.yml index 5e254f6..1e673f5 100644 --- a/hyperpars/td3-caribou.yml +++ b/hyperpars/td3-caribou.yml @@ -6,5 +6,5 @@ config: {} tensorboard: "/home/rstudio/logs" total_timesteps: 500000 id: "1" -repo: "cboettig/rl-ecology" +repo: "boettiger-lab/rl4eco" save_path: "/home/rstudio/rl4caribou/saved_agents" \ No newline at end of file diff --git a/hyperpars/tqc-caribou.yml b/hyperpars/tqc-caribou.yml index b7c558e..bacbc98 100644 --- a/hyperpars/tqc-caribou.yml +++ b/hyperpars/tqc-caribou.yml @@ -7,6 +7,6 @@ tensorboard: "/home/rstudio/logs" total_timesteps: 500000 config: {} use_sde: True -repo: "cboettig/rl-ecology" +repo: "boettiger-lab/rl4eco" save_path: "../saved_agents" id: "2" \ No newline at end of file