From f599471544eb036b608ff49473f5a08e3633b7e2 Mon Sep 17 00:00:00 2001 From: pbrunzema Date: Thu, 13 Feb 2025 16:45:00 +0100 Subject: [PATCH 1/6] add vbll surrogate and notebook --- .../acquisition/bll_thompson_sampling.py | 253 +++++++ botorch_community/models/vblls.py | 487 ++++++++++++ botorch_community/posteriors/__init__.py | 4 + botorch_community/posteriors/bll_posterior.py | 54 ++ .../vbll_thompson_sampling.ipynb | 712 ++++++++++++++++++ 5 files changed, 1510 insertions(+) create mode 100644 botorch_community/acquisition/bll_thompson_sampling.py create mode 100644 botorch_community/models/vblls.py create mode 100644 botorch_community/posteriors/__init__.py create mode 100644 botorch_community/posteriors/bll_posterior.py create mode 100644 notebooks_community/vbll_thompson_sampling.ipynb diff --git a/botorch_community/acquisition/bll_thompson_sampling.py b/botorch_community/acquisition/bll_thompson_sampling.py new file mode 100644 index 0000000000..0af6d8cba3 --- /dev/null +++ b/botorch_community/acquisition/bll_thompson_sampling.py @@ -0,0 +1,253 @@ +from typing import Optional + +import numpy as np + +import scipy + +import torch +from torch.func import grad + +from botorch_community.models.vblls import AbstractBLLModel + +torch.set_default_dtype(torch.float64) + + +class BLLMaxPosteriorSampling: + """ + Implements Maximum Posterior Sampling for Bayesian Linear Last (VBLL) models. + + This class provides functionality to sample from the posterior distribution of a BLL model, + with optional optimization to refine the sampling process. + + Args: + model (AbstractBLLModel): + The VBLL model from which posterior samples are drawn. Must be an instance of `AbstractBLLModel`. + num_restarts (int, optional): + Number of restarts for optimization-based sampling. Defaults to 10. + bounds (torch.Tensor, optional): + Tensor of shape (2, num_inputs) specifying the lower and upper bounds for sampling. + If None, defaults to [(0, 1)] for each input dimension. + discrete (bool, optional): + If True, assumes the input space is discrete. Defaults to False. + + Raises: + ValueError: + If the provided `model` is not an instance of `AbstractBLLModel`. + + Notes: + - If `bounds` is not provided, the default range [0,1] is assumed for each input dimension. + - The lower (`lb`) and upper (`ub`) bounds are stored as CPU tensors for compatibility + with initial condition generation and `scipy.optimize.minimize`. + """ + + def __init__( + self, + model, + num_restarts: int = 10, + bounds: Optional[torch.Tensor] = None, + discrete: bool = False, + ): + if not isinstance(model, AbstractBLLModel): + raise ValueError("Model must be an instance of AbstractBLLModel") + + self.model = model + self.device = model.device + self.discrete = discrete + self.num_restarts = num_restarts + + if bounds is None: + # Default bounds [0,1] for each input dimension + self.bounds = [(0, 1)] * self.model.num_inputs + self.lb = torch.zeros(self.model.num_inputs).cpu() + self.ub = torch.ones(self.model.num_inputs).cpu() + else: + # Ensure bounds are on CPU for compatibility with scipy.optimize.minimize + self.lb = bounds[0, :].cpu() + self.ub = bounds[1, :].cpu() + self.bounds = [tuple(bound) for bound in bounds.T.cpu().tolist()] + + def __call__(self, X_cand: torch.Tensor = None, num_samples: int = 1): + if self.discrete and X_cand is None: + raise ValueError("X_cand must be provided if `discrete` is True.") + + sampled_functions = [self.model.sample() for _ in range(num_samples)] + X_next = torch.empty(num_samples, self.model.num_inputs, device=self.device) + + # get max of sampled functions at candidate points for each function + for i, f in enumerate(sampled_functions): + # Note that optimization overwrites sampling-based approach + if not self.discrete: + X_cand = torch.empty( + self.num_restarts, self.model.num_inputs, device=self.device + ) + Y_cand = torch.empty( + self.num_restarts, self.model.num_outputs, device=self.device + ) + + # create numpy wrapper around the sampled function, note we aim to maximize + def func(x): + return ( + -f(torch.from_numpy(x).to(self.device)).detach().cpu().numpy() + ) + + grad_f = grad(lambda x: f(x).mean()) + + def grad_func(x): + return ( + -grad_f(torch.from_numpy(x).to(self.device)) + .detach() + .cpu() + .numpy() + ) + + for j in range(self.num_restarts): + # generate initial condition from within the bounds, necessary for TuRBO + x0 = np.random.rand(self.model.num_inputs) + x0 = self.lb + (self.ub - self.lb) * x0 + + # optimize sample path + res = scipy.optimize.minimize( + func, + x0, + jac=grad_func, + bounds=self.bounds, + method="L-BFGS-B", + ) + + if not res.success: + print(f"Optimization failed with message: {res.message}") + + # store the candidate + X_cand[j, :] = torch.from_numpy(res.x) + Y_cand[j] = torch.tensor([-res.fun]) + + # select the best candidate + X_next[i, :] = X_cand[Y_cand.argmax()] + else: + # sampling based approach on candidate points + Y_cand = f(X_cand) + X_next[i, :] = X_cand[Y_cand.argmax()] + + # ensure that the next point is within the bounds, scipy minimize can sometimes return points outside the bounds + X_next = torch.clamp(X_next, self.lb.to(self.device), self.ub.to(self.device)) + return X_next + + +# class NeuralNetworkProblemWrapper(Problem): +# def __init__(self, net, input_size=4, output_size=2, maximize=True): +# super().__init__( +# n_var=input_size, n_obj=output_size, xl=0, xu=1 +# ) # Define bounds for inputs +# self.net = net +# self.maximize = maximize + +# def _evaluate(self, X, out, *args, **kwargs): +# # Convert the input 'X' (a population of solutions) from numpy to torch tensor +# X_tensor = torch.Tensor(X) + +# # Perform forward pass through the neural network +# outputs = self.net(X_tensor).detach().numpy() + +# if self.maximize: +# # maximize the objective +# outputs = -outputs + +# # Objective functions can be based on the network's output +# out["F"] = outputs + + +# class MultiObjectiveVBLLParetoSampling: +# def __init__( +# self, +# model, +# Y, +# ref_point, +# Y_stats, +# bounds: torch.Tensor = None, +# batch_size: int = 1, +# plot_result: bool = False, +# ): +# self.model = model +# self.device = model.device +# self.maximize = True +# self.plot_result = plot_result + +# # need current Y for hypervolume calculation +# self.Y = Y +# self.Y_mean = Y_stats["mean"].detach().numpy() +# self.Y_std = Y_stats["std"].detach().numpy() + +# # need reference point for hypervolume calculation +# self.ref_point = ref_point + +# self.batch_size = batch_size +# if bounds is None: +# self.bounds = [(0, 1)] * self.model.num_inputs +# self.lb = torch.zeros(self.model.num_inputs).cpu() +# self.ub = torch.ones(self.model.num_inputs).cpu() +# else: +# # need bounds on the cpu for generation of initial conditions and scipy minimize +# print("WARNING: Bounds are not used in this implementation") +# # TODO: Add bounds +# self.lb = bounds[0, :].cpu() +# self.ub = bounds[1, :].cpu() +# self.bounds = [tuple(bound) for bound in bounds.T.cpu().tolist()] + +# def __call__(self, X_cand: torch.Tensor = None, num_samples: int = 1): +# sampled_functions = [self.model.sample() for _ in range(num_samples)] +# X_next = torch.empty(num_samples, self.model.num_inputs, device=self.device) + +# # get max of sampled functions at candidate points for each function +# for i, f in enumerate(sampled_functions): +# # create pymoo problem +# problem = NeuralNetworkProblemWrapper( +# net=f, +# input_size=self.model.num_inputs, +# output_size=self.model.num_outputs, +# maximize=self.maximize, +# ) + +# # Define the algorithm +# algorithm = NSGA2(pop_size=100) + +# # Run the optimization +# res = minimize(problem, algorithm, ("n_gen", 200), seed=1, verbose=False) + +# # if we are maximizing, then re-flip the sign of the objective +# if self.maximize: +# res.F = -res.F + +# # iterate over the pareto front and compute the hypervolume for each candidate +# hv_volume = torch.zeros(len(res.F)) +# for j, candidate in enumerate(res.F): +# # stack candidate with current Y +# Y_augmented_pareto = torch.cat( +# [self.Y, torch.tensor(candidate).unsqueeze(0)], dim=0 +# ) + +# # create dominated partitioning +# bd = DominatedPartitioning( +# ref_point=self.ref_point, Y=Y_augmented_pareto +# ) + +# # compute hypervolume for candidate +# hv_volume[j] = bd.compute_hypervolume().item() + +# # if the hypervolume is the same for all candidates, then select a random candidate of the approximate front +# if hv_volume.unique().shape[0] == 1: +# index = np.random.randint(0, len(res.X)) +# print( +# "All candidates have the same hypervolume, selecting a random candidate" +# ) +# else: +# # select the best candidate that maximizes the hypervolume +# index = hv_volume.argmax().item() +# print( +# "Selecting the candidate that maximizes the hypervolume, predicted hypervolume: ", +# hv_volume.max().item(), +# ) +# X_next[i, :] = torch.tensor(res.X[index]) + +# # ensure that the next point is within the bounds +# X_next = torch.clamp(X_next, self.lb.to(self.device), self.ub.to(self.device)) +# return X_next diff --git a/botorch_community/models/vblls.py b/botorch_community/models/vblls.py new file mode 100644 index 0000000000..dbcfa734e2 --- /dev/null +++ b/botorch_community/models/vblls.py @@ -0,0 +1,487 @@ +#!/usr/bin/env python3 +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +""" +This file contains an implemenation of a Variational Bayesian Last Layer (VBLL) model that can be used within BoTorch. + +References: + +[1] P. Brunzema, M. Jordahn, J. Willes, S. Trimpe, J. Snoek, J. Harrison. + Bayesian Optimization via Contrinual Variational Last Layer Training. + International Conference on Learning Representations, 2025. + +Contributor: brunzema +""" + +import os +from typing import Optional, Dict +from abc import ABC, abstractmethod + +import random + +import torch +import torch.nn as nn +from torch import Tensor +from torch.utils.data import DataLoader + +from gpytorch.distributions import MultivariateNormal + +from botorch.posteriors import Posterior +from botorch.models.model import Model +from botorch.posteriors.gpytorch import GPyTorchPosterior + +from botorch_community.posteriors.bll_posterior import BLLPosterior + +import vbll + + +torch.set_default_dtype(torch.float64) + + +class VBLLNetwork(nn.Module): + """ + A model with a Variational Bayesian Linear Last (VBLL) layer. + + Args: + in_features (int, optional): + Number of input features. Defaults to 2. + hidden_features (int, optional): + Number of hidden units per layer. Defaults to 50. + out_features (int, optional): + Number of output features. Defaults to 1. + num_layers (int, optional): + Number of hidden layers in the MLP. Defaults to 3. + prior_scale (float, optional): + Scaling factor for the prior distribution in the Bayesian last layer. Defaults to 1.0. + wishart_scale (float, optional): + Scaling factor for the Wishart prior in the Bayesian last layer. Defaults to 0.01. + kl_scale (float, optional): + Weighting factor for the Kullback-Leibler (KL) divergence term in the loss. Defaults to 1.0. + backbone (nn.Module, optional): + A predefined feature extractor to be used before the MLP layers. If None, + a default MLP structure is used. Defaults to None. + activation (nn.Module, optional): + Activation function applied between hidden layers. Defaults to `nn.ELU()`. + + Notes: + - If a `backbone` module is provided, it is applied before the fully connected layers. If not, we use a default MLP structure. + """ + + def __init__( + self, + in_features: int = 2, + hidden_features: int = 50, + out_features: int = 1, + num_layers: int = 3, + prior_scale: float = 1.0, + wishart_scale: float = 0.01, + kl_scale: float = 1.0, + backbone: nn.Module = None, + activation: nn.Module = nn.ELU(), + device=None, + ): + super(VBLLNetwork, self).__init__() + self.num_inputs = in_features + self.num_outputs = out_features + + if device is None: + self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu") + else: + self.device = device + + self.activation = activation + self.kl_scale = kl_scale + + if backbone is None: + self.backbone = nn.Sequential( + nn.Linear(in_features, hidden_features), + self.activation, + *[ + nn.Sequential( + nn.Linear(hidden_features, hidden_features), self.activation + ) + for _ in range(num_layers) + ], + ) + else: + self.backbone = backbone + + # could be changed to other regression layers in vbll package + self.head = vbll.Regression( + hidden_features, + out_features, + regularization_weight=1.0, # will be adjusted dynamically at each iteration based on the number of data points + prior_scale=prior_scale, + wishart_scale=wishart_scale, + parameterization="dense_precision", + ) + + def forward(self, x: Tensor) -> Tensor: + x = self.backbone(x) + return self.head(x) + + def sample_posterior_function(self, sample_shape: Optional[torch.Size] = None): + """ + Samples a posterior function by drawing parameters from the model's learned distribution. + + Args: + sample_shape (Optional[torch.Size], optional): + The desired shape for the sampled parameters. If None, a single sample is drawn. + Defaults to None. + + Returns: + Callable[[Tensor], Tensor]: + A function that takes an input tensor `x` and returns the corresponding + model output tensor. The function applies the backbone transformation + and computes the final output using the sampled parameters. + + Notes: + - If `sample_shape` is None, a single set of parameters is sampled. + - If `sample_shape` is provided, multiple parameter samples are drawn, and the function + will return a batched output where the first dimension corresponds to different samples. + """ + if sample_shape is None: + sampled_params = self.head.W().rsample().to(self.device) + else: + sampled_params = self.head.W().rsample(sample_shape).to(self.device) + + def sampled_parametric_function(x: Tensor) -> Tensor: + x = self.backbone(x) + + if sample_shape is None: + return (sampled_params @ x[..., None]).squeeze(-1) + + x_expanded = x.unsqueeze(0).expand(sampled_params.shape[0], -1, -1) + output = torch.matmul(sampled_params, x_expanded.transpose(-1, -2)) + return output + + return sampled_parametric_function + + +class AbstractBLLModel(Model, ABC): + def __init__(self): + super().__init__() + self.model = None + self.old_model = None # Used for continual learning + + @property + def num_outputs(self) -> int: + return self.model.num_outputs + + @property + def num_inputs(self): + return self.model.num_inputs + + @property + def device(self): + return self.model.device + + @staticmethod + def sigmoid_retrain_schedule( + time_horizon, epoch, transition_window_ratio, location + ): + # Compute stretch dynamically + transition_window = time_horizon * transition_window_ratio + stretch = ( + 2 * torch.log(torch.tensor(9.0)) / transition_window + ) # Ensures 10%-90% transition within the transition_window, see [1] + + # Sigmoid function + probability = 1 / (1 + torch.exp(-stretch * (location - epoch))) + return torch.rand(1).item() < probability + + def fit( + self, + train_X: Tensor, + train_y: Tensor, + optimization_settings: Dict = None, + continual_learning_settings: Dict = None, + old_model_params: Dict = None, + ): + """ + Fits the model to the given training data. Note that for continual learning, we assume that the last point in the training data is the new point. + + Args: + train_X (Tensor): + The input training data, expected to be a PyTorch tensor of shape (num_samples, num_features). + + train_y (Tensor): + The target values for training, expected to be a PyTorch tensor of shape (num_samples, num_outputs). + + optimization_settings (dict, optional): + A dictionary containing optimization-related settings. If a key is missing, default values will be used. + Available settings: + - "num_epochs" (int, default=100): The maximum number of training epochs. + - "patience" (int, default=10): Number of epochs to wait before early stopping. + - "freeze_backbone" (bool, default=False): If True, the backbone of the model is frozen. + - "batch_size" (int, default=32): Batch size for the training. + - "optimizer" (torch.optim.Optimizer, default=torch.optim.AdamW): Optimizer for training. + - "wd" (float, default=1e-4): Weight decay (L2 regularization) coefficient. + - "clip_val" (float, default=1.0): Gradient clipping threshold. + + continual_learning_settings (dict, optional): + A dictionary specifying continual learning (CL) configurations. If a key is missing, default values will be used. + Available settings: + - "use_cl" (bool or str, default=False): If False, CL is disabled. Can be set to: + - `"event_trigger"`: Enables CL based on an event-triggering mechanism. + - `"sigmoid_schedule"`: Enables CL using a sigmoid-based schedule. + - "event_trigger" (dict, required if `use_cl == "event_trigger"`): + - "test_threshold" (float, default=0.0): Threshold on the log likelihood of the new point. + - "sigmoid_schedule" (dict, required if `use_cl == "sigmoid_schedule"`): + - "transition_window_ratio" (float, default=0.5): Ratio of transition window to time horizon. + - "location" (float or None, default=None): Center of the transition window. Defaults to `time_horizon / 2` if None. + - "time_horizon" (int, default=100): Total time horizon for the sigmoid schedule. + - "current_iteration" (int, default=0): Current iteration of the optimization. + + Returns: + None: The function trains the model in place and does not return a value. + + Notes: + - If continual learning (CL) is enabled, the function dynamically determines whether to retrain the model + based on the specified method (`event_trigger` or `sigmoid_schedule`). TODO: Add full functionality. + """ + + # Default settings + default_opt_settings = { + "num_epochs": 10_000, + "freeze_backbone": False, + "patience": 100, + "batch_size": 32, + "optimizer": torch.optim.AdamW, + "lr": 1e-3, + "wd": 1e-4, + "clip_val": 1.0, + } + + default_cont_learning_settings = { + "use_cl": False, # Can be False, "event_trigger", or "sigmoid_schedule" + "event_trigger": { + "test_threshold": 0.0, # Threshold on the log-likelihood for event triggering + }, + "sigmoid_schedule": { + "transition_window_ratio": 0.5, # Ratio of the transition window to time horizon + "location": None, # Defaults to time_horizon / 2 if None + "time_horizon": 100, # Total time horizon for the optimization + "current_iteration": 0, # Current iteration of the optimization + }, + } + + # Merge defaults with provided settings + if optimization_settings is None: + optimization_settings = default_opt_settings + else: + optimization_settings = {**default_opt_settings, **optimization_settings} + + # Merge defaults with provided settings + if continual_learning_settings is None: + cl_settings = default_cont_learning_settings + else: + cl_settings = { + **default_cont_learning_settings, + **continual_learning_settings, + } + + # Make dataloader based on train_X, train_y + device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") + dataset = [[train_X[i], train_y[i]] for i, _ in enumerate(train_X)] + + dataloader = DataLoader( + dataset, shuffle=True, batch_size=optimization_settings["batch_size"] + ) + + # default is to always fully train + full_training = True + + """ + # renormalize the data based on the mean and std of the data expext the last point + mean = train_y[:-1].mean(dim=0) + if len(train_y) > 2: + std = train_y[:-1].std(dim=0) + else: + std = torch.ones_like(mean) + + # renorm^2 suuper ugly + x_new = train_X[-1] + y_new = (train_y[-1] * train_y.std(dim=0) + train_y.mean(dim=0) - mean) / std + out = self.old_model(x_new.to(device)) + """ + log_likelihood = 0 # -out.val_loss_fn(y_new.to(device)).sum().item() + + if cl_settings["use_cl"]: + method = cl_settings["use_cl"] + + if not old_model_params: + raise ValueError( + "No old model parameters provided for continual learning." + ) + else: + self.old_model.load_state_dict(old_model_params) + + if method == "event_trigger": + full_training = ( + log_likelihood < cl_settings["event_trigger"]["test_threshold"] + ) + + elif method == "sigmoid_schedule": + # Sigmoid-based probability + transition_window_ratio = cl_settings["sigmoid_schedule"][ + "transition_window_ratio" + ] + location = cl_settings["sigmoid_schedule"]["location"] + time_horizon = cl_settings["sigmoid_schedule"]["time_horizon"] + iteration = cl_settings["sigmoid_schedule"]["iteration"] + + if location is None: + location = ( + time_horizon / 2 + ) # Default to middle of time horizon if not provided + + full_training = self.sigmoid_retrain_schedule( + time_horizon, iteration, transition_window_ratio, location + ) + + else: + raise ValueError(f"Unknown continual learning method: {method}") + + if not full_training: + self.model.to(device) + self.model.load_state_dict(self.old_model.state_dict()) + + with torch.no_grad(): + x, y = x_new.to(device), y_new.to(device) + out = self.model(x.reshape(1, -1)) + loss = out.train_loss_fn(y.reshape(1, -1), recursive_update=True) + + print("Recurive update of the last layer.") + + else: + self.model.to(device) + self.set_regularization_weight(self.model.kl_scale / len(train_y)) + param_list = [ + { + "params": self.model.head.parameters(), + "weight_decay": 0.0, + }, + ] + + # freeze backbone + if not optimization_settings["freeze_backbone"]: + param_list.append( + { + "params": self.model.backbone.parameters(), + "weight_decay": optimization_settings["wd"], + } + ) + + optimizer = optimization_settings["optimizer"]( + lr=optimization_settings["lr"], params=param_list + ) + + best_loss = float("inf") + epochs_no_improve = 0 + early_stop = False + best_model_state = None # To store the best model parameters + + for epoch in range(optimization_settings["num_epochs"] + 1): + # early stopping + if early_stop: + break + + self.model.train() + running_loss = [] + + for train_step, (x, y) in enumerate(dataloader): + x, y = x.to(device), y.to(device) + optimizer.zero_grad() + out = self.model(x) + loss = out.train_loss_fn(y) # vbll layer will calculate the loss + + loss.backward() + torch.nn.utils.clip_grad_norm_( + self.model.parameters(), optimization_settings["clip_val"] + ) + optimizer.step() + running_loss.append(loss.item()) + + # Calculate average loss over the epoch + avg_loss = sum(running_loss[-len(dataloader) :]) / len(dataloader) + + # Early stopping logic + if avg_loss < best_loss: + best_loss = avg_loss + best_model_state = self.model.state_dict() + epochs_no_improve = 0 + else: + epochs_no_improve += 1 + + if epochs_no_improve >= optimization_settings["patience"]: + early_stop = True + + # load best model + if best_model_state is not None: + self.model.load_state_dict(best_model_state) + print("Early stopping at epoch ", epoch, " with loss ", best_loss) + + def set_regularization_weight(self, new_weight: float): + self.model.head.regularization_weight = new_weight + + def posterior( + self, + X: Tensor, + output_indices=None, + observation_noise=False, + posterior_transform=None, + ) -> Posterior: + if len(X.shape) < 3: + B, D = X.shape + Q = 1 + batched = False + else: + B, Q, D = X.shape + X = X.reshape(B * Q, D) + batched = True + + K = self.num_outputs + posterior = self.model(X).predictive # + + # Extract mean and variance + mean = posterior.mean.squeeze(-1) + variance = posterior.variance.squeeze(-1) + cov = torch.diag_embed(variance) + + # TODO: may need some further reshaping for batch size > 1 + # Mean in `(batch_shape, q*k)` + # mean = mean.reshape(B, Q * K) + + # # Cov is `(batch_shape, q*k, q*k)` + # cov += 1e-4 * torch.eye(B * Q * K).to(X) + # cov = cov.reshape(B, Q, K, B, Q, K) + # cov = torch.einsum('bqkbrl->bqkrl', cov) # (B, Q, K, Q, K) + # cov = cov.reshape(B, Q * K, Q * K) + + dist = MultivariateNormal(mean, cov) + post_pred = GPyTorchPosterior(dist) + + if batched: + return BLLPosterior(post_pred, self, X, self.num_outputs) + else: + return post_pred + + @abstractmethod + def sample(self, sample_shape: Optional[torch.Size] = None): + raise NotImplementedError + + +class VBLLModel(AbstractBLLModel): + def __init__(self, *args, **kwargs): + super().__init__() + self.model = VBLLNetwork(*args, **kwargs) + self.old_model = VBLLNetwork(*args, **kwargs) # used for continual learning + + def sample(self, sample_shape: Optional[torch.Size] = None): + return self.model.sample_posterior_function(sample_shape) + + def __str__(self): + return self.model.__str__() diff --git a/botorch_community/posteriors/__init__.py b/botorch_community/posteriors/__init__.py new file mode 100644 index 0000000000..7bec24cb17 --- /dev/null +++ b/botorch_community/posteriors/__init__.py @@ -0,0 +1,4 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. diff --git a/botorch_community/posteriors/bll_posterior.py b/botorch_community/posteriors/bll_posterior.py new file mode 100644 index 0000000000..b885ee17c3 --- /dev/null +++ b/botorch_community/posteriors/bll_posterior.py @@ -0,0 +1,54 @@ +from typing import Optional + +import torch +from torch import Tensor + +from botorch.posteriors import Posterior + + +class BLLPosterior(Posterior): + def __init__(self, posterior, model, X, output_dim): + super().__init__() + self.posterior = posterior + self.model = model + self.old_model = model + self.output_dim = output_dim + self.X = X + + def rsample( + self, + sample_shape: Optional[torch.Size] = None, + ) -> Tensor: + """ + For VBLLs, we need to sample from W and then create the generalized linear model to get posterior samples. + """ + n_samples = ( + 1 if sample_shape is None else torch.tensor(sample_shape).prod().item() + ) + samples_list = [self.model.sample()(self.X) for _ in range(n_samples)] + samples = torch.stack(samples_list, dim=0) + new_shape = samples.shape[:-1] + return samples.reshape(*new_shape, -1, self.output_dim) + + @property + def mean(self) -> Tensor: + r"""The posterior mean.""" + post_mean = self.posterior.mean.squeeze(-1) + shape = post_mean.shape + return post_mean.reshape(*shape[:-1], -1, self.output_dim) + + @property + def variance(self) -> Tensor: + r"""The posterior variance.""" + post_var = self.posterior.variance.squeeze(-1) + shape = post_var.shape + return post_var.reshape(*shape[:-1], -1, self.output_dim) + + @property + def device(self) -> torch.device: + return self.posterior.device + + @property + def dtype(self) -> torch.dtype: + r"""The torch dtype of the distribution.""" + return self.posterior.dtype diff --git a/notebooks_community/vbll_thompson_sampling.ipynb b/notebooks_community/vbll_thompson_sampling.ipynb new file mode 100644 index 0000000000..934a3f0438 --- /dev/null +++ b/notebooks_community/vbll_thompson_sampling.ipynb @@ -0,0 +1,712 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "2b29ae44-3f5b-4df2-961c-631320eecf0c", + "metadata": {}, + "source": [ + "# Variational Bayesian Last Layers for Bayesian Optimization\n", + "\n", + "* Contributors: brunzema\n", + "* Last updated: Feb 13, 2025\n", + "* BoTorch version: 0.9.6(dev), commit hash: dccda59d8ef51d8074de82fdb5614bad2db0ee96 UPDATE!\n", + "\n", + "In this notebook, we will demonstrate how to use variational Bayesian last layers (VBLLs) for Bayesian optimization [1]. \n", + "\n", + "[1] P. Brunzema, M. Jordahn, J. Willes, S. Trimpe, J. Snoek, J. Harrison. Bayesian Optimization via Continual Variational Last Layer Training. International Conference on Learning Representations (ICLR), 2025.\n", + "\n", + "[2] J. Harrison, J. Willes, J. Snoek. Variational Bayesian Last Layers. International Conference on Learning Representations (ICLR), 2024." + ] + }, + { + "cell_type": "markdown", + "id": "ed18db9c", + "metadata": {}, + "source": [ + "# Introduction to the VBLL Model\n", + "\n", + "Linear model\n", + "$$\n", + " y = \\mathbf{w}^\\top \\phi_{\\theta} (\\mathbf{x}) + \\varepsilon\n", + "$$\n", + "where $\\varepsilon \\sim \\mathcal{N}(0, \\sigma^2)$\n", + "Variational Bayesian last layer models [2] use a variational posterior distribution on the weights as $\\mathbf{w} \\sim q(\\mathbf{w})$ with $q(\\mathbf{w}) = \\mathcal{N}(\\bar{\\mathbf{w}}, S)$ where $\\bar{\\mathbf{w}}$ is the mean and $S$ the full covariance of a multivariate normal distribution.\n", + "Through conjugany, we yield the posterior predictive \n", + "$$\n", + " p(y \\mid \\mathbf{x}, \\mathcal{D}_T, \\theta) = \\mathcal{N} \\big( \\bar{\\mathbf{w}}_T^\\top \\phi_{\\theta}(\\mathbf{x}), \\, \\phi_{\\theta}(\\mathbf{x})^\\top S_T \\phi_{\\theta}(\\mathbf{x}) + \\sigma^{2} \\big).\n", + "$$\n", + "\n", + "## The VBLL Model on Toy Data\n", + "\n", + "Before using the VBLL model in the context of Bayesian Optimization (BO), let's see how the interface of the model looks. The current implementation allows for passing a full backbone to the model (which could be anything). If no backbone is provided, a standard MLP is created. For training, there are also various options to include recursive updates on the last layer to speed up optimzation [1] but in the following, we will not go into detail. See the docstring of `model.fit` for the different options.\n", + "\n", + "Below, we use the model in a 1D regression example. We can see that only...\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "56e5bac6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAF2CAYAAAC8gZhoAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAOphJREFUeJzt3QmcTnX///HPGGasM4ix7yTKds+EITchRGVJEWVJVJbIFhWyRFFu1JRbhfpF+hEqaezdFFEkJYSIwYx9zzrn//h87/+5ftc1u2muOXNd83o+HsfMdc65znXOuS5z3td3OwGWZVkCAADgkBxOvTAAAIAijAAAAEcRRgAAgKMIIwAAwFGEEQAA4CjCCAAAcBRhBAAAOIowAgAAHEUYAQAAjiKMADDmzp0rAQEBcvDgQde8Jk2amCmjvPLKK+Y1AMAdYQR+46GHHpK8efPKhQsXkl2na9euEhQUJKdOnTKP9cLoPuXLl0+qV68uEyZMkMuXL3s8t0ePHpI/f/40XdB//PHHW97/8uXLe+xLWFiYNGrUSJYsWSK+RM+bho5vvvlGsgs91oSfpeQmb3N/rZw5c0rhwoUlPDxcBg4cKL/99lu6t5sd31dknpyZ+FqAV2nQ+PLLL83Fu1u3bkn+Mf3888+lVatWctttt7nm33fffa71L168KBs2bJBRo0bJzz//LAsXLszUY6hdu7YMGTLE/H706FH597//LR06dJB3331XnnnmGclsK1euvOXn6HkeO3as+T1hqcrLL78sI0aMEH9TrVo1+Z//+R+PeSNHjjTh9aWXXsr0/bE/03rrsXPnzpnP8ocffijvvPOOvP766zJ48OAMfV+Bv4swAr8qGSlQoIDMnz8/yTCiQeTSpUsmtLi7/fbb5fHHH3c91ov+tWvXZPHixXLlyhXJnTu3ZJZSpUp57IseR+XKleVf//pXsmHkxo0bEh8fb0p8MlpGb1O/qevkb4oVK+bxvqnXXntNihQpkmh+Zkj4mbb358EHHzRh94477pDWrVtn+n4ByaGaBn4jT548phRhzZo1cvz48UTLNaRoWNHQkprixYu7irmdpPuh37oPHDhgHmt7Dt2vN954Q6ZNmyaVKlWS4OBgV/H77t27pWPHjqZoXkNURESEfPHFF4m2u3PnTmnatKk5Z6VLlzbVUhpoEkqqzYgGNC2u1wuevkaJEiXMed+/f7/Zv6JFi5r19Fu0XV2g6yfVZuSuu+6Se++9N9Hr6r5oMNNjcZ+nx3znnXea19UA8PTTT8uZM2fSdC7Xrl1rqr20Kq5gwYLStm1b2bVrl8c69v7t27fPVMvpeqGhodKzZ89E1Xbp8ccff8gjjzxi3h+tUqxfv7589dVXruVaMqf7p1UqCcXExEhgYKBMmjQpXa+tpYELFiwwn+lXX33VNV+D9+jRo01Vjh6rvr6ep3Xr1rnWSe193bFjhzlfFStWNO+Nfm6ffPJJV3UokBr/+4qCbE1LPbQ4+n//93+lf//+rvmnT5+WFStWyGOPPWYuwAkvridPnjS/a8nJd999Z7bRpUsXx8PI9evX5fDhwx7VSmrOnDlmv/v06WPCiF7cNGA0bNjQXMS1KkQvKnoe2rVrJ5999pm0b9/ePDc2NtYEAC1RsdebNWtWovOSlJs3b8oDDzxgAl/nzp3NRVPb6KxatUp+/fVXad68ualSevbZZ83raUhRNWvWTHJ7nTp1Mhc03Se9gNm+/fZbU02lr2HT4KFtcjQYPPfccyagvf322/LTTz+Z9yxXrlzJ7vfq1avl/vvvNxdLfb2//vpL3nrrLXO+tm3bZtrruHv00UelQoUK5sKvy99//33ThkerONIrLi5OGjRoYEKN7r++p/o503C8aNEic760Wkd/fvrppzJ16lQTPmyffPKJqXZJWLJ3K8qWLSuNGzc2QeP8+fMSEhJifurx6f+N3r17m/fzgw8+kJYtW8qWLVtM1aEGkZTeV33/NWjpe6Pvo34W9TOlP7///nsaLSN1FuBHbty4YZUoUcKKjIz0mD9z5kxLP+4rVqzwmK/zkpratWtnXblyxWPd7t27W/ny5Uvx9efMmWOe/8MPP9zyvpcrV85q0aKFdeLECTP9/PPPVufOnc32BgwYYNY5cOCAeRwSEmIdP37c4/nNmjWzatSo4bHf8fHxVoMGDawqVaq45g0aNMhsY/Pmza55uq3Q0FAzX1/D1rhxYzPZZs+ebdaZOnVqov3X11K677rOmDFjEq2j89z/7OzZs8c8fuuttzzW69u3r5U/f37r8uXL5vGGDRvMevPmzfNYLzo6Osn5CdWuXdsKCwuzTp065Zqn5zdHjhxWt27dEu3fk08+6fH89u3bW7fddpt1K+68806Pc2efdz0W24ULF6wKFSpY5cuXt27evGnm6WdU1/v66689tlezZk2P7SVHn9uvX79klw8cONCso8dv/5+5evWqxzpnzpyxihUr5nEeUnpf7ffJ3SeffGLWX79+far7DFBNA7+i3yT12/SmTZs8uqhqFY0W6zdr1izRc7S4Xr/Z6aTtSrThYXR0tCkZ+e/f9sxtMKrfQnWqVauWaUD7xBNPJPpG/vDDD7uKze2SH62G0G/0+s1WS3p00mJy/Ya7d+9eOXLkiFl3+fLlpnqgbt26rufrttLyjVtLWLQdxIABAxItS8+3X63q0W/eWhLgXvqiJQXavsEurdHzoFUI2jDTPjadtGpBSxPcqxQSOnbsmGzfvt1UI2gJkk2/1ev29HwklLB9jlZb6LnUUoT00tfRc37PPfe45um+a+mWflbtqjYtXSpZsqTMmzfPtZ6WOmlVSEa0P7F7hNm9zvT/jN02SKvC9LOkpWZaxaelQmnhXqpmlzTqZ0yldRvI3ggj8Dv2RVUDiF3Xrj1kNKS4F3vbtM2EXgB00iLziRMnmjYU2oB12bJlmbrv9erVM6FIqxU2btxo/qh/9NFHiapQtArBnbZx0OCkvYDsMGNPY8aMMevY7Wj+/PNPqVKlSqLXrlq1aqr7p+1CdL2MrL7SqhqtZrHDknYd1X3V+TYNU9orRKtKEh6ftrNIqo2QTY83uePT9jh6jrV6LmF1hrtChQqZn2ltn5LcfiS3D+77mSNHDvMZXrp0qaudigYTbYuh7U3+Lj1fSttP2bS6SMOZvoZWH+l51bYses7TQgOMVtlp4NfPqj7f/oymdRvI3mgzAr+j35a1t4DWsb/44ovpqmu3S1DWr19vvqFnFi110FCUmoThxG58OnToUFMSkhTtlZMVaejQ0igt/Rg0aJBp56KlINoF2/34NIi4lxa4cy8lyghJhVaVWSVl2otqypQpJpBoWw4N1tpWR8/L36WlLHp8dlj4+OOPTamRti0aNmyYOc92Q1kNn2mhJXIanvX5WtKlpS/6nul7mFTDaCAhwgj8kgYPLSXQom39Q64lAXfffXean6/F1O7fIrM6bZiptBFnamGmXLlypqQhoT179qT6Otp7Z/PmzaZhbXINRm+1ukYvilp9oVU12uhYS6T0wqgNc91fV0uLtMFpWhraJjze5I5Pex9pANRGvN6m+5HcPrjvp93LqE6dOiZ8acndoUOHTIPbv0u385///EciIyNdJSNaJaafHz3v7u+dXaKW2vuqpUXaoFl72WivHFtSnzEgOVTTwC/ZpSD6x1HbC9xqDwQdPE1puw1foN9mtQuuDpKmbSQSOnHihOt3HV9CezhoTwn35cmVOiRsq6LVGtqLJblSA+2yqs6ePXtLpSO6T7Nnzzbbd6+isb95a1uS8ePHJxkcU3ot7Xqs39a1KsJ9PS0h0DY6mTXehr6OnnNtz2TT6iHtdaK9eXTkX3faVkj3T7sza9WJ9gb6O7QqRUtZ9Dy6D8RmlwK5l/po4HTfz5Te16Ser3S/gbSiZAR+Sb9tazdKbZCqUgojv//+uymqVlpHrxdFvXBptYZeENxpiYC2J0lIG0b27dvX9VgvqtoINiGtV3evq89IUVFRpnFkjRo1TBdN/bar3Un1oqLtZnQUTjV8+HAzWqgWoev+2F179Zu5liSlVn2gbVh0BE+9sGrDTr2gaqmFHr82BtaSC72wakmHNlDVc6Pf9HVKjoYNrWLSSddPWLqj3VG1a69WHWi4bNGihSmZ0W/fWr0zffp0jzFJEtIqD72Ya4lAr169XF17tdrDHivD27QbtVYZ6n5o1149Tv2caRdlbRisbUXcaQNqfa90RGHtUptS1+XkPtMaELTRrT2asJb0aZdh9yowrf7RUhHtstumTRuzPzNnzjTvoXvJYErv6z//+U+ZPHmy+f+hXcs1RNlj4wBp4nR3HsBboqKiTNfCunXrJrtOwi69gYGBVunSpa0+ffpYcXFxibr2JtcVuFKlSh5de5ObDh8+nGLX3jZt2qR4THbX3ilTpiS5fP/+/aaravHixa1cuXJZpUqVsh544AFr0aJFHuvt2LHDdBPNnTu3WWf8+PHWBx98kGrXXrsb50svvWS6pOpr6Gt17NjRvLZt48aNVnh4uBUUFOTRHTRh1153DRs2NMueeuqpZI9/1qxZZrt58uSxChQoYLoyDx8+3Dp69KiVmtWrV5vX0Odq1+gHH3zQ+u233zzWsfdPu7G6s99X93Nzq117lZ4jPVcFCxY0514/m8uWLUt2G61btzavq+czrdw/b9p1WV+rTp06pkvvzp07k+ySPXHiRPP5Cw4ONuvqPunnXee5S+59jYmJMd2f9bW0i/gjjzxi3pPkugIDCQXoP2mLLQCAzKSlFb/88ovpLQX4M9qMAEAWpG1/tHttwqpCwB/RZgQAshBta6HjrugQ7dpORNvKAP6OkhEAyEK0662Whmgo0Qau7vfsAfwVbUYAAICjKBkBAACOIowAAABHZcsGrHqvhKNHj5rBp9Jzp1EAALIry7LMXZ/17tIJB+tLr2wZRjSIlClTxundAADAZx0+fNjcOykjZMswYg/HrScyJCTE6d0BAMBn6C0G9At9Rt7aIluGEbtqRoMIYQQAgFuXkc0caMAKAAAcRRgBAACOIowAAABHZcs2IwCQHd28eVOuX7/u9G4gi8uVK5cEBgZm6msSRgAgG4wLERsbK2fPnnV6V+AjChYsaO6LlFljcRFGAMDP2UEkLCxM8ubNy2CPSDG4Xr58WY4fP24elyhRQjIDYQSAV6sFNmzYIMeOHTN/1Bo1apTpxb/Znb4HdhC57bbbnN4d+IA8efKYnxpI9HOTGf9nCSMAvGLx4sUycOBAiYmJcc3T0RqnT58uHTp0cHTfshO7jYiWiABpZX9e9POTGWGE3jQAvBJEOnbs6BFE1JEjR8x8XY7MRdUMsvLnhTACIMOrBbREROueE7LnDRo0yKwHAIowAiBDaRuRhCUiCQOJ3hdK1wMySvny5WXatGniL7755htTOpFdekARRgBkKG2smpHrARpen3zySXPL+qCgIClXrpwpfTt16pT4gyZNmpjSQncNGjQw/0dCQ0MlOyCMAMhQae0KmFldBpFxtGpNv7F/8skn5mdmVLX98ccfEhERIXv37jWvu2/fPpk5c6asWbNGIiMj5fTp0+IEPfb4+HivbT8oKChTx/lwGmEEQIbS7rvaaya5P6I6X28/ruvBd2ijY60Kuffee6VLly7mpz72dmPkfv36mQvzypUrpXHjxlK2bFm5//77ZfXq1aZB9EsvveRa98KFC/LYY49Jvnz5pFSpUhIVFeVRPfjKK6+Y5wcHB5tSlueee861/OrVqzJ06FDzPH1+vXr1TOCyzZ071wwE9sUXX0j16tXNNt5//33JnTt3oqoULbVp2rSp+V1Lb3SfdLvaQ6VGjRomVNl69Ogh//nPf0wvM/2/odPBgweTrKb57LPP5M477zSvref+zTff9HhdnTdx4kRTilSgQAFzrLNmzXItv3btmvTv3998EdD91hKmSZMmSZZgZUPnzp3TVnTmJ4CM99lnn1kBAQFm0v9r9mTP0+XIHH/99Zf122+/mZ9/9/10fy8z4/08deqU2f7EiROTXN67d2+rUKFCVnx8vFWuXDmrQIEC1qRJk6w9e/ZYM2bMsAIDA62VK1eadRcuXGiFhIRYy5cvt/78809r8+bN1qxZs1zbeuqpp6wGDRpY69evt/bt22dNmTLFCg4Otn7//XezfM6cOVauXLnMOt999521e/du6+LFi1axYsWs999/37WdGzdueMyLiYkx2/rpp5+s/fv3u/ZLX1+dPXvWioyMNMdy7NgxM+k21q1bZ87xmTNnzHo//vijlSNHDmvcuHHm+HR/8uTJY37a9BwULlzYioqKsvbu3WvOhT5H91XpfpQpU8Yc48GDB60NGzZY8+fPv+XPjTeuoYQRAF6hF6jSpUt7XLz0DyFBxLfCiF4YE76PCQOJvq+6Xkb7/vvvzWssWbIkyeVTp041y+Pi4syFuFWrVh7LO3XqZN1///3m9zfffNO6/fbbrWvXriXajoYTDQhHjhzxmN+sWTNr5MiR5ne96Otrbd++3WOdgQMHWk2bNnU9XrFihQkxdohISps2bawhQ4a4Hjdu3Nhsx13CMNKlSxfrvvvu81hn2LBhVvXq1V2P9Rw8/vjjrsca0sLCwqx3333XPB4wYIDZV52fmswOI1TTAPAKHdhMi5vXrVsn8+fPNz8PHDjAgGc+Jiv0jkqqm3hStA1Jwse7du0yvz/yyCPy119/ScWKFaV3796yZMkSuXHjhln2yy+/mDYgt99+u+TPn981afXJ/v37XdvT6qKaNWt6vEbXrl1NlcrRo0fN43nz5kmbNm1MlY7S7Y4fP95UzxQuXNhsd8WKFXLo0KFbOge7du2Shg0beszTx9qWxr3tjvv+aTWPtjuxh3bXKqHt27dL1apVTRWVVn1lFYzACsBrdORG7SkA3+Vk76jKlSubC6peiNu3b59ouc4vVKiQFC1aNNVtaTulPXv2mLYmq1atkr59+8qUKVNM4Lh48aL5rG7dujXRaKMaHtyHSU/YFuruu++WSpUqyYIFC+TZZ581IUfbl9j0NbQ9iHY71kCi7VG054y23/DWHXfd6f7aDW3/8Y9/mC8EX3/9tTkPjz76qDRv3lwWLVokTsuUkhFtRKQNa7TBjDYK2rJlS7Lr6h8uuxGP+6RJ06bpLuHyVq1aZcahAEC24mTvKL2Xzn333SfvvPOOKdVIePM/LYXo1KmTKyB8//33Huvo42rVqnmEiQcffFBmzJhhSjM2bdpkSkXq1KljShe0BEEDkPukJQup0dIR3Zcvv/xScuTI4XG9+u6776Rt27by+OOPS61atUzJzO+//+7x/KCgoFR7Julx6Lbc6WMtzbmV4dpDQkLMOXvvvffk008/NY1ineqRlKlhRA928ODBMmbMGNm2bZt5M1q2bOkqNkpIW2ZrwranX3/91ZxoLWJzp+HDfT331skAAP/oHfX222+bni563Vi/fr2pEoqOjjYhRXuovPrqqx4X58mTJ5uLvX4JXrhwoenZorS04oMPPjDXFO0u/PHHH5twoj1K9IKugaJbt27mGqSlB/qlWXuafPXVV6nuoz5Xr2+6L3q7A+3tYqtSpYopidm4caMpyXn66aclLi7O4/nly5eXzZs3m2rNkydPJtlleMiQIaY7s1b56PF9+OGH5txoD6C0mjp1qrlW7t6922xDz4+GLbtKyVGWl9WtW9fq16+f6/HNmzetkiVLmla+afGvf/3LtJDWVsu27t27W23btk33PtGAFUB2kZG9aZzqHaU9P/TvvvZS0R4t2mBWG2OePHnSo/Hm2LFjrUceecTKmzevVbx4cWv69Omu5doItl69eqZHTb58+az69etbq1evdi3Xhq2jR4+2ypcvb16jRIkSVvv27a0dO3a4GrCGhoameK3Tc7J27dpEPYL0epU/f37TmPTll1+2unXr5nEN27Nnj9kf7R2j2zhw4ECiBqxq0aJFpsGq7l/ZsmVN7xh3eg70mumuVq1a1pgxY8zv2nuodu3a5vj1PGgD3W3btmWJBqwB+o+3go7WiWm/aq2PateunWt+9+7dTd/pzz//PNVtaB2bNkJy7yut1TRLly41RVtaX6j9uSdMmJDm22OfP3/ejGp37tw5U2QFAP7qypUr5pt+hQoVTFV5Rt6FWUtEtC0EjZKz1+fmvBeuoV5twKrFTVoPVqxYMY/5+liLiVKjxWRapKZFawmraPTDrydJWzq/+OKLZhAcrf9Lqu5Mi/h0cj+RAIC007+52vZBe81o1bi2EdGqmcy4vTz8X5buTaMhREtG6tat6zG/c+fOrt91uXZl0tbM2iCpWbNmibaj9X5jx47NlH0GAH9F7yj4ZAPWIkWKmA9vwsY6+ji1FsqXLl0yXaV69eqV6uto62R9Lb1nQVJGjhxpipPsSRtAAQCAbBBGtE1HeHi4aQFs01bC9g2OUqKtfLVqRbtDpUbrMHX8/+S6lmnLZq3Xcp8AAEDW4PWuvdqtV/szazck7dakg8JoqUfPnj3Ncu1KpSUXSVXRaKPXhI1SdXCaYcOGmf7j2g1Kg43WY2p/cO36BQAAfIvX24zo4ConTpyQ0aNHm0FqateubfqI241adUhcHSTGnY6S9+233yY5VK1W++zYscOEG+2Ro3debNGihel77d63GwDwf7x5u3v4n/hM/rx4tWtvVkXXXgDZ6aKi9y/RL3I6bLpWnyc3gBlgWZYZlkMLEbQ3rA7alrDAwOe69gIAnKUXEh0GQbvj2jdzA1KjY4SVLVs2URDxFsIIAPg5LQ3RC4vepTa1e6AAgYGBkjNnzkwtQSOMAEA2oBcWvaNrwru6AllB5pS/AAAAJIMwAgAAHEUYAQAAjiKMAAAARxFGAACAowgjAADAUYQRAADgKMYZ8RM6kNGGDRvMKIt69+JGjRqZgWsAAMjqCCN+YPHixTJw4ECJiYlxzStdurRMnz5dOnTo4Oi+AQCQGqpp/CCIdOzY0SOIqCNHjpj5uhwAgKyMMOLjVTNaIpLUjZfteYMGDeJeFACALI0w4sO0jUjCEpGEgeTw4cNmPQAAsirCiA/TxqoZuR4AAE4gjPgw7TWTkesBAOAEwogP0+672mtGbw2eFJ1fpkwZsx4AAFkVYcSH6Tgi2n1XJQwk9uNp06Yx3ggAIEsjjPg4HUdk0aJFUqpUKY/5WmKi8xlnBACQ1QVYSfUL9XPnz5+X0NBQOXfunISEhIg/YARWAICvXkMZgdVPaPBo0qSJ07sBAMAto5oGAAA4ijACAAAcRRgBAACOIowAAABHEUYAAICjCCMAAMBRhBEAAOD/YSQqKkrKly8vuXPnlnr16smWLVuSXXfu3LlmKHP3SZ/nTsdpGz16tBncK0+ePNK8eXPZu3dvJhwJAADwuTDy6aefyuDBg2XMmDGybds2qVWrlrRs2VKOHz+e7HN0RDcdSdSe/vzzT4/lkydPlhkzZsjMmTNl8+bNki9fPrPNK1euePtwAACAr4WRqVOnSu/evaVnz55SvXp1EyDy5s0rs2fPTvY5WhpSvHhx11SsWDGPUhG9+dvLL78sbdu2lZo1a8pHH30kR48elaVLl3r7cAAAgC+FkWvXrsnWrVtNNYrrBXPkMI83bdqU7PMuXrwo5cqVkzJlypjAsXPnTteyAwcOSGxsrMc2dYx8rf5JaZsAACAbhpGTJ0+aG7i5l2wofayBIilVq1Y1pSaff/65fPzxxxIfHy8NGjSQmJgYs9x+3q1s8+rVq+bGPu4TAADIGrJcb5rIyEjp1q2b1K5dWxo3biyLFy+WokWLyr///e90b3PSpEmm9MSetMQFAABkgzBSpEgRczfZuLg4j/n6WNuCpEWuXLmkTp06sm/fPvPYft6tbHPkyJHmVsf2dPjw4XQeEQAA8KkwEhQUJOHh4bJmzRrXPK120cdaApIWWs3zyy+/mG68qkKFCiZ0uG9Tq120V01y2wwODjY9dNwnAACQNeT09gtot97u3btLRESE1K1b1/SEuXTpkuldo7RKplSpUqYqRY0bN07q168vlStXlrNnz8qUKVNM196nnnrK1dNm0KBBMmHCBKlSpYoJJ6NGjZKSJUtKu3btvH04AADA18JIp06d5MSJE2aQMm1gqm1BoqOjXQ1QDx06ZHrY2M6cOWO6Auu6hQoVMiUrGzduNN2CbcOHDzeBpk+fPiaw3HPPPWabCQdHAwAAWV+ApQN3ZDNaraMNWbX9CFU2AAA4ew3Ncr1pAABA9kIYAQAAjiKMAAAARxFGAACAowgjAADAUYQRAADgKMIIAABwFGEEAAA4ijACAAAcRRgBAACOIowAAABHEUYAAIB/37UXALzh5s2bsmHDBjl27JiUKFFCGjVqJIGBgU7vFoB0IIwA8DmLFy+WgQMHSkxMjGte6dKlZfr06dKhQwdH9w3AraOaBoDPBZGOHTt6BBF15MgRM1+XA/AthBEAPlU1oyUilmUlWmbPGzRokFkPgO8gjADwGdpGJGGJSMJAcvjwYbMeAN9Bm5EMRqM6wHv0/1VGrgcgayCMZCAa1QHepQE/I9cDkDVQTZNBaFQHeJ+WNGrADwgISHK5zi9TpoxZD4DvIIxkgGvXrsnTTz9NozrAy7TKU0saVcJAYj+eNm0aVaOAjyGM/E1a4qHf1E6ePJnsOjSqAzKOVnkuWrRISpUq5TFf/x/qfKpEAd9Dm5EMqJpJqkQkKTSqAzKGBo62bdvSWBzwE4QRL4x3kJy9e/d6dZ+A7ESDR5MmTZzeDQAZgGoaL413kJRXXnmFhqwAACRAGEmn9Fa50JAVAABPhJF0Ss84BjRkBQAgMcKIl8Y7SAkNWQEA+D+EES+Md5AaRocEACCTw0hUVJSUL19ecufOLfXq1ZMtW7Yku+57771nSh0KFSpkpubNmydav0ePHiYAuE+tWrWSrDLeQXIYHRIAAAfCyKeffiqDBw+WMWPGyLZt26RWrVrSsmVLOX78eJLrf/PNN/LYY4/JunXrZNOmTebi3aJFCzOsujsNH1rdYU+ffPKJOEEDycGDB83+zp8/X8aOHWvmMzokAABpE2DdykAZ6aAlIXfffbe8/fbb5nF8fLwJGAMGDJARI0ak+nzteaIlJPr8bt26uUpGzp49K0uXLk3XPp0/f15CQ0Pl3LlzEhISIplxwzw9Zg0ijA4JAPBl571wDc3h7Xu2bN261VS1uF4wRw7zWEs90uLy5cty/fp1KVy4cKISlLCwMKlatao8++yzcurUKckqEpaW6M8DBw4QRAAAyOwRWPV+LVqyUaxYMY/5+nj37t1p2sYLL7wgJUuW9Ag0WkWjF/YKFSrI/v375cUXX5T777/fBJykqkCuXr1qJvdU522MDgkAgB8MB//aa6/JggULTCmINn61de7c2fV7jRo1pGbNmlKpUiWzXrNmzRJtZ9KkSa62HAAAIGvxajVNkSJFTAlBXFycx3x9XLx48RSf+8Ybb5gwsnLlShM2UlKxYkXzWvv27Uty+ciRI03dlj3pwGMAACAbhJGgoCAJDw+XNWvWuOZpA1Z9HBkZmezzJk+eLOPHj5fo6GiJiIhI9XW0oai2GUlu/I7g4GDTyMZ9AgAA2aRrr3br1bFDPvzwQ9m1a5dpbHrp0iXp2bOnWa49ZLTkwvb666/LqFGjZPbs2WZsktjYWDNdvHjRLNefw4YNk++//940EtVgo7cSr1y5sukyDAAAfIvX24x06tRJTpw4IaNHjzahonbt2qbEw27UeujQIdPDxvbuu++aXjgdO3b02I6OU6J3vdVqnx07dphwo917tXGrjkOiJSlaAgIAAHyL18cZyYq8Pc4IAAD+6ryvjTMCAACQGsIIAABwFGEEAAA4ijACAAAcRRgBAACOIowAAABHEUYAAICjCCMAAMBRhBEAAOAowggAAHAUYQQAADiKMAIAABxFGAEAAI4ijAAAAEcRRgAAgKMIIwAAwFGEEQAA4CjCCAAAcBRhBAAAOIowAgAAHEUYAQAAjiKMAAAARxFGAACAowgjAADAUYQRAADgKMIIAABwFGEEAAA4ijACAAAcRRgBAAD+H0aioqKkfPnykjt3bqlXr55s2bIlxfUXLlwod9xxh1m/Ro0asnz5co/llmXJ6NGjpUSJEpInTx5p3ry57N2718tHAQAAfDKMfPrppzJ48GAZM2aMbNu2TWrVqiUtW7aU48ePJ7n+xo0b5bHHHpNevXrJTz/9JO3atTPTr7/+6lpn8uTJMmPGDJk5c6Zs3rxZ8uXLZ7Z55coVbx8OAADIYAGWFjN4kZaE3H333fL222+bx/Hx8VKmTBkZMGCAjBgxItH6nTp1kkuXLsmyZctc8+rXry+1a9c24UN3t2TJkjJkyBAZOnSoWX7u3DkpVqyYzJ07Vzp37pzqPp0/f15CQ0PN80JCQjL0eAEA8GfnvXAN9WrJyLVr12Tr1q2mGsX1gjlymMebNm1K8jk63319paUe9voHDhyQ2NhYj3X0pGjoSW6bAAAg68rpzY2fPHlSbt68aUot3Onj3bt3J/kcDRpJra/z7eX2vOTWSejq1atmck91AAAga8gWvWkmTZpkSk/sSauJAABANggjRYoUkcDAQImLi/OYr4+LFy+e5HN0fkrr2z9vZZsjR440dVv2dPjw4b91XAAAwEfCSFBQkISHh8uaNWtc87QBqz6OjIxM8jk63319tWrVKtf6FSpUMKHDfR2tdtFeNcltMzg42DSycZ8AAEA2aDOitFtv9+7dJSIiQurWrSvTpk0zvWV69uxplnfr1k1KlSplqlLUwIEDpXHjxvLmm29KmzZtZMGCBfLjjz/KrFmzzPKAgAAZNGiQTJgwQapUqWLCyahRo0wPG+0CDAAAfIvXw4h21T1x4oQZpEwbmGoX3ejoaFcD1EOHDpkeNrYGDRrI/Pnz5eWXX5YXX3zRBI6lS5fKXXfd5Vpn+PDhJtD06dNHzp49K/fcc4/Zpg6SBgAAfIvXxxnJihhnBACAbDLOCAAAQGoIIwAAwFGEEQAA4CjCCAAAcBRhBAAAOIowAgAAHEUYAQAAjiKMAAAARxFGAACAowgjAADAUYQRAADgKMIIAABwFGEEAAA4ijACAAAcRRgBAACOIowAAABHEUYAAICjCCMAAMBRhBEAAOAowggAAHAUYQQAADiKMAIAABxFGAEAAI4ijAAAAEcRRgAAgKMIIwAAwFGEEQAA4CjCCAAAcBRhBAAA+G8YOX36tHTt2lVCQkKkYMGC0qtXL7l48WKK6w8YMECqVq0qefLkkbJly8pzzz0n586d81gvICAg0bRgwQJvHgoAAPCSnOJFGkSOHTsmq1atkuvXr0vPnj2lT58+Mn/+/CTXP3r0qJneeOMNqV69uvz555/yzDPPmHmLFi3yWHfOnDnSqlUr12MNOwAAwPcEWJZleWPDu3btMoHihx9+kIiICDMvOjpaWrduLTExMVKyZMk0bWfhwoXy+OOPy6VLlyRnzv9mJy0JWbJkibRr1y5d+3b+/HkJDQ01JS5aagMAAJy7hnqtmmbTpk2mtMIOIqp58+aSI0cO2bx5c5q3Yx+sHURs/fr1kyJFikjdunVl9uzZ4qVMBQAAfLWaJjY2VsLCwjxfLGdOKVy4sFmWFidPnpTx48ebqh1348aNk6ZNm0revHll5cqV0rdvX9MWRduXJOXq1atmck91AADAR8PIiBEj5PXXX0+1iubv0sDQpk0bU9XzyiuveCwbNWqU6/c6deqYKpwpU6YkG0YmTZokY8eO/dv7BAAAskCbkRMnTsipU6dSXKdixYry8ccfy5AhQ+TMmTOu+Tdu3JDcuXObdiDt27dP9vkXLlyQli1bmpKPZcuWmeek5KuvvpIHHnhArly5IsHBwWkqGSlTpgxtRgAAyAJtRm65ZKRo0aJmSk1kZKScPXtWtm7dKuHh4Wbe2rVrJT4+XurVq5fiQWoQ0VDxxRdfpBpE1Pbt26VQoUJJBhGl85NbBgAA/LTNSLVq1UzX2969e8vMmTNN197+/ftL586dXT1pjhw5Is2aNZOPPvrINETVINKiRQu5fPmyKVnRx3b7Dg1AgYGB8uWXX0pcXJzUr1/fBBXtNjxx4kQZOnSotw4FAAD46jgj8+bNMwFEA4f2onn44YdlxowZruUaUPbs2WPCh9q2bZurp03lypU9tnXgwAEpX7685MqVS6KiouT55583PWh0valTp5rQAwAAfI/XxhnJyhhnBACAbDDOCAAAQFoQRgAAgKMIIwAAwFGEEQAA4CjCCAAAcBRhBAAAOIowAgAAHEUYAQAAjiKMAAAARxFGAACAowgjAADAUYQRAADgKMIIAABwFGEEAAA4ijACAAAcRRgBAACOIowAAABHEUYAAICjCCMAAMBRhBEAAOAowggAAHAUYQQAADiKMAIAABxFGAEAAI4ijAAAAEcRRgAAgKMIIwAAwFGEEQAA4CjCCAAA8N8wcvr0aenatauEhIRIwYIFpVevXnLx4sUUn9OkSRMJCAjwmJ555hmPdQ4dOiRt2rSRvHnzSlhYmAwbNkxu3LjhzUMBAABeklO8SIPIsWPHZNWqVXL9+nXp2bOn9OnTR+bPn5/i83r37i3jxo1zPdbQYbt586YJIsWLF5eNGzea7Xfr1k1y5colEydO9ObhAAAALwiwLMvyxoZ37dol1atXlx9++EEiIiLMvOjoaGndurXExMRIyZIlky0ZqV27tkybNi3J5V9//bU88MADcvToUSlWrJiZN3PmTHnhhRfkxIkTEhQUlOq+nT9/XkJDQ+XcuXOm1AYAAKSNN66hXqum2bRpk6masYOIat68ueTIkUM2b96c4nPnzZsnRYoUkbvuuktGjhwply9f9thujRo1XEFEtWzZ0pycnTt3Jrm9q1evmuXuEwAA8PNqmtjYWNOew+PFcuaUwoULm2XJ6dKli5QrV86UnOzYscOUeOzZs0cWL17s2q57EFH24+S2O2nSJBk7dmwGHBUAAHA8jIwYMUJef/31VKto0kvblNi0BKREiRLSrFkz2b9/v1SqVCld29TSlcGDB7sea8lImTJl0r2PAADAwTAyZMgQ6dGjR4rrVKxY0TQwPX78uMd87fGiPWx0WVrVq1fP/Ny3b58JI/rcLVu2eKwTFxdnfia33eDgYDMBAAA/CCNFixY1U2oiIyPl7NmzsnXrVgkPDzfz1q5dK/Hx8a6AkRbbt283P7WExN7uq6++aoKOXQ2kvXW0EY02mAUAAL7Faw1Yq1WrJq1atTLddLUk47vvvpP+/ftL586dXT1pjhw5InfccYerpEOrYsaPH28CzMGDB+WLL74w3Xb/+c9/Ss2aNc06LVq0MKHjiSeekJ9//llWrFghL7/8svTr14/SDwAAfJBXBz3TXjEaNrTNh3bpveeee2TWrFmu5Tr2iDZOtXvLaLfc1atXm8Chz9MqoYcffli+/PJL13MCAwNl2bJl5qeWkjz++OMmsLiPSwIAAHyH18YZycoYZwQAgGwwzggAAEBaEEYAAICjCCMAAMBRhBEAAOAowggAAHAUYQQAADiKMAIAABxFGAEAAI4ijAAAAEcRRgAAgKMIIwAAwFGEEQAA4CjCCAAAcBRhBAAAOIowAgAAHEUYAQAAjiKMAAAARxFGAACAowgjAADAUYQRAADgKMIIAABwFGEEAAA4ijACAAAcRRgBAACOIowAAABHEUYAAICjCCMAAMBRhBEAAOAowggAAPDfMHL69Gnp2rWrhISESMGCBaVXr15y8eLFZNc/ePCgBAQEJDktXLjQtV5SyxcsWODNQwEAAF6SU7xIg8ixY8dk1apVcv36denZs6f06dNH5s+fn+T6ZcqUMeu7mzVrlkyZMkXuv/9+j/lz5syRVq1auR5r2AEAAL7Ha2Fk165dEh0dLT/88INERESYeW+99Za0bt1a3njjDSlZsmSi5wQGBkrx4sU95i1ZskQeffRRyZ8/v8d8DR8J1wUAAL7Ha9U0mzZtMoHBDiKqefPmkiNHDtm8eXOatrF161bZvn27qd5JqF+/flKkSBGpW7euzJ49WyzLSnY7V69elfPnz3tMAADAz0tGYmNjJSwszPPFcuaUwoULm2Vp8cEHH0i1atWkQYMGHvPHjRsnTZs2lbx588rKlSulb9++pi3Kc889l+R2Jk2aJGPHjv0bRwMAALJMyciIESOSbWRqT7t37/7bO/bXX3+ZtiVJlYqMGjVKGjZsKHXq1JEXXnhBhg8fbtqVJGfkyJFy7tw513T48OG/vX8AAMChkpEhQ4ZIjx49UlynYsWKpj3H8ePHPebfuHHD9LBJS1uPRYsWyeXLl6Vbt26prluvXj0ZP368qY4JDg5OtFznJTUfAAD4YBgpWrSomVITGRkpZ8+eNe0+wsPDzby1a9dKfHy8CQ9pqaJ56KGH0vRa2q6kUKFCBA4AAHyQ19qMaFsP7Xrbu3dvmTlzpuna279/f+ncubOrJ82RI0ekWbNm8tFHH5mGqLZ9+/bJ+vXrZfny5Ym2++WXX0pcXJzUr19fcufObboNT5w4UYYOHeqtQwEAAL46zsi8efNMANHAob1oHn74YZkxY4ZruQaUPXv2mOoYd9o7pnTp0tKiRYtE28yVK5dERUXJ888/b3rQVK5cWaZOnWpCDwAA8D0BVkp9Yv2Udu0NDQ01jVl1dFgAAODcNZR70wAAAEcRRgAAgKMIIwAAwFGEEQAA4CjCCAAAcBRhBAAAOIowAgAAHEUYAQAAjiKMAAAARxFGAACAowgjAADAUYQRAADgKMIIAABwFGEEAAA4ijACAAAcRRgBAACOIowAAABH5XT25QEAgDfcvHlTNmzYIMeOHZMSJUpIo0aNJDAwULIiwggAAH5m8eLFMnDgQImJiXHNK126tEyfPl06dOggWQ3VNAAA+FkQ6dixo0cQUUeOHDHzdXlWQxgBAMCPqmYGDhwolmUlWmbPGzRokFkvKyGMAADgJzZs2JCoRCRhIDl8+LBZLyshjAAA4CeOHTuWoetlFsIIAAB+okSJEhm6XmYhjAAA4CcaNWpkes0EBAQkuVznlylTxqyXlRBGAADwE4GBgab7rkoYSOzH06ZNy3LjjRBGAADwIx06dJBFixZJqVKlPOZriYnOz4rjjARYSfX/8XPnz5+X0NBQOXfunISEhDi9OwAA+MwIrN64hjICKwAAfigwMFCaNGkivsBr1TSvvvqqNGjQQPLmzSsFCxZM03O0kGb06NEmweXJk0eaN28ue/fu9Vjn9OnT0rVrV5PGdLu9evWSixcveukoAACAz4aRa9euySOPPCLPPvtsmp8zefJkmTFjhsycOVM2b94s+fLlk5YtW8qVK1dc62gQ2blzp6xatUqWLVsm69evlz59+njpKAAAgM+3GZk7d64Zevbs2bMprqe7UbJkSRkyZIgMHTrUzNP6qGLFipltdO7cWXbt2iXVq1eXH374QSIiIsw60dHR0rp1azPinD4/LWgzAgBA+njjGppletMcOHBAYmNjTdWMTQ+2Xr16smnTJvNYf2rVjB1ElK6fI0cOU5KSnKtXr5qT5z4BAICsIcuEEQ0iSktC3Olje5n+DAsL81ieM2dOKVy4sGudpEyaNMkEG3vSAV8AAIAPhpERI0aYQVNSmnbv3i1ZzciRI01xkj3pTYIAAEDWcEtde7U9R48ePVJcp2LFiunakeLFi5ufcXFxHmPm6+PatWu71jl+/LjH827cuGF62NjPT0pwcLCZbHYzGaprAAC4Nfa1MyObnN5SGClatKiZvKFChQomUKxZs8YVPvSAtS2I3SMnMjLSNITdunWrhIeHm3lr166V+Ph407YkrS5cuGB+Ul0DAED6nDp1yjR9yNKDnh06dMiUWOhPHQVu+/btZn7lypUlf/785vc77rjDtOdo3769qeLRXjcTJkyQKlWqmHAyatQo00OmXbt2Zv1q1apJq1atpHfv3qb77/Xr16V///6mp01ae9IoXVeragoUKJDszYTw92mY1MCn55peS5mH8+4Mznvm45w7Q5s7lC1b1rTXzCheCyM6eNmHH37oelynTh3zc926da4R4fbs2WMOyjZ8+HC5dOmSGTdES0Duuece03U3d+7crnXmzZtnAkizZs1ML5qHH37YjE1yK/R5OkY/Mof+keAPRebjvDuD8575OOfO0GtpRsmW96ZB5mA8F2dw3p3Bec98nHNn+PU4IwAAIHsijMBrtAfTmDFjPHoywfs4787gvGc+zrn/nHeqaQAAgKMoGQEAAI4ijAAAAEcRRgAAgKMIIwAAwFGEEfwtUVFRUr58eTMwnQ7Jv2XLlmTXfe+996RRo0ZSqFAhMzVv3jzF9ZEx593dggULzKjD9qjG8N4514Eb+/XrZ+61pb0Obr/9dlm+fHmm7W92Pe/Tpk2TqlWrSp48eczorM8//7xcuXIl0/bX161fv14efPBBM1K5/q1YunRpqs/55ptv5B//+If5nOso63Pnzr31F9beNEB6LFiwwAoKCrJmz55t7dy50+rdu7dVsGBBKy4uLsn1u3TpYkVFRVk//fSTtWvXLqtHjx5WaGioFRMTk+n7np3Ou+3AgQNWqVKlrEaNGllt27bNtP3Njuf86tWrVkREhNW6dWvr22+/Nef+m2++sbZv357p+56dzvu8efOs4OBg81PP+YoVK6wSJUpYzz//fKbvu69avny59dJLL1mLFy/WnrbWkiVLUlz/jz/+sPLmzWsNHjzY+u2336y33nrLCgwMtKKjo2/pdQkjSLe6deta/fr1cz2+efOmVbJkSWvSpElpev6NGzesAgUKWB9++KEX99L/pOe867lu0KCB9f7771vdu3cnjHj5nL/77rtWxYoVrWvXrmXiXvqfWz3vum7Tpk095ulFsmHDhl7fV38kaQgjw4cPt+68806PeZ06dbJatmx5S69FNQ3S5dq1a+buyVrV4n6fAn28adOmNG3j8uXL5maHGXmzJX+X3vM+btw4CQsLk169emXSnmbvc/7FF1+Yu4xrNU2xYsXkrrvukokTJ5qbhsJ7571BgwbmOXZVzh9//GGqxlq3bp1p+53dbNq0yeM9Ui1btkzzdcDrN8qDfzt58qT5w6p/aN3p4927d6dpGy+88IKpl0z4QUbGnvdvv/1WPvjgA9eds+H9c64XwbVr10rXrl3NxXDfvn3St29fE7515Ep457x36dLFPE9vsqpf7G/cuCHPPPOMvPjii5m019lPbGxsku+R3r/mr7/+Mm130oKSETjitddeM40plyxZ4nFXZmSsCxcuyBNPPGEaDxcpUsTp3ck24uPjTUnUrFmzJDw8XDp16iQvvfSSzJw50+ld82vakFJLoN555x3Ztm2bLF68WL766isZP36807uGVFAygnTRC1tgYKDExcV5zNfHxYsXT/G5b7zxhgkjq1evlpo1a3p5T7P3ed+/f78cPHjQtI53v1CqnDlzyp49e6RSpUqZsOfZ67OuPWhy5cplnmerVq2a+Rap1Q9BQUFe3+/seN5HjRplwvdTTz1lHteoUUMuXbokffr0MWEwI295j//S9yKp90jv5pvWUhHFO4N00T+m+o1vzZo1Hhc5fax15cmZPHmy+ZYSHR0tERERmbS32fe833HHHfLLL7+YKhp7euihh+Tee+81v2vXR2T8Z71hw4amasYOfur33383IYUg4r3zru3QEgYOOxByGzbv0PfC/T1Sq1atSvE6kKR0NbEF/n+3O+1GN3fuXNOlq0+fPqbbXWxsrFn+xBNPWCNGjHCt/9prr5lueosWLbKOHTvmmi5cuODgUfj/eU+I3jTeP+eHDh0yPcX69+9v7dmzx1q2bJkVFhZmTZgwwcGj8P/zPmbMGHPeP/nkE9PldOXKlValSpWsRx991MGj8C0XLlwwwy/opBFh6tSp5vc///zTLNfzrec9YdfeYcOGmSEbdPgGuvYi02mf8rJly5qQod3wvv/+e9eyxo0bmwufrVy5cubDnXDSPyDw3nlPiDCSOed848aNVr169czFVLv5vvrqq6aLNbx33q9fv2698sorJoDkzp3bKlOmjNW3b1/rzJkzDu2971m3bl2Sf6ft86w/9bwnfE7t2rXNe6Sf9Tlz5tzy6wboPxlbaAMAAJB2tBkBAACOIowAAABHEUYAAICjCCMAAMBRhBEAAOAowggAAHAUYQQAADiKMAIAABxFGAEAAI4ijAAAAEcRRgAAgKMIIwAAQJz0/wBNtms2MMkGnAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import torch\n", + "from botorch_community.models.vblls import VBLLModel\n", + "\n", + "torch.set_default_dtype(torch.float64)\n", + "torch.manual_seed(42)\n", + "\n", + "\n", + "def objective(x, noise=True):\n", + " out = torch.sin(x * 5)\n", + " if noise:\n", + " out += 0.1 * torch.randn_like(x)\n", + " return out\n", + "\n", + "\n", + "X = torch.rand(7, 1)\n", + "Y = objective(X)\n", + "\n", + "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(6, 4))\n", + "ax.set_title(\"VBLL Predictive on Toy Data\")\n", + "ax.scatter(X, Y, c=\"k\", label=\"Observations\")\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "8f382fec", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "VBLLNetwork(\n", + " (activation): ELU(alpha=1.0)\n", + " (backbone): Sequential(\n", + " (0): Linear(in_features=1, out_features=50, bias=True)\n", + " (1): ELU(alpha=1.0)\n", + " (2): Sequential(\n", + " (0): Linear(in_features=50, out_features=50, bias=True)\n", + " (1): ELU(alpha=1.0)\n", + " )\n", + " (3): Sequential(\n", + " (0): Linear(in_features=50, out_features=50, bias=True)\n", + " (1): ELU(alpha=1.0)\n", + " )\n", + " (4): Sequential(\n", + " (0): Linear(in_features=50, out_features=50, bias=True)\n", + " (1): ELU(alpha=1.0)\n", + " )\n", + " )\n", + " (head): Regression()\n", + ")\n", + "Early stopping at epoch 6332 with loss 1.0455903860560616\n" + ] + } + ], + "source": [ + "model = VBLLModel(\n", + " in_features=1,\n", + " hidden_features=50,\n", + " num_layers=3,\n", + " out_features=1,\n", + ")\n", + "\n", + "# lets print the model, we can see the MLP backbone and the VBLL regression head\n", + "print(model)\n", + "\n", + "# fit the model on the data -- it is also possible to specify the optimizer throught `optimizer_settings` (see docstring)\n", + "model.fit(X, Y)" + ] + }, + { + "cell_type": "markdown", + "id": "e93bb94e", + "metadata": {}, + "source": [ + "Now we can use the model in the same way as a Gaussian process. Note, below is the exact same code as one would use with a GPyTorch model!" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "e45e2cb4-5ea1-4d72-8be7-806cacf80d01", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "test_X = torch.linspace(0, 1, 100)\n", + "with torch.no_grad():\n", + " posterior = model.posterior(test_X.view(-1, 1))\n", + "mean, std = posterior.mean.squeeze(), posterior.variance.sqrt().squeeze()\n", + "\n", + "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(6, 4))\n", + "ax.set_title(\"VBLL Predictive on Toy Data\")\n", + "ax.scatter(X, Y, c=\"k\", label=\"Observations\")\n", + "ax.plot(test_X, mean, label=\"Posterior predictive\", color=\"tab:blue\")\n", + "ax.fill_between(test_X, mean - 2 * std, mean + 2 * std, alpha=0.2, color=\"tab:blue\")\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "1e7dd3d3", + "metadata": {}, + "source": [ + "## Thompson sampling with VBLLs\n", + "\n", + "VBLLs yield a Gaussian predictive distribution, and thus most acquisition functions that are straightforward to compute for Gaussian Processes (GPs) are also straightforward for VBLLs. \n", + "Moreover, parametric VBLLs are especially well-suited for Thompson sampling. \n", + "\n", + "For a Thompson sample, we simply sample from the variational posterior of $\\mathbf{w}$ at iteration $t$ and then construct a sample from the predictive $\\hat{f}$ as a generalized linear model:\n", + "\n", + "\\begin{aligned}\n", + " &\\textcircled{1} \\quad \\hat{\\mathbf{w}} \\sim q(\\mathbf{w}) \\\\\n", + " &\\textcircled{2} \\quad \\hat{f} (\\mathbf{x}) \\coloneqq \\hat{\\mathbf{w}}^\\top \\phi_{\\theta} (\\mathbf{x}).\n", + "\\end{aligned}\n", + "\n", + "We can directly leverage this in BO to choose the next query location as $\\mathbf{x}_{t+1} = \\arg\\max_{\\mathbf{x} \\in \\mathcal{X}} \\hat{f} (\\mathbf{x})$. Compared to other standard implementation, we can numerically optimize the sample path as we can simply calculate gradients of the sample.\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "e5d36c21", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def plot_model(model, x, y, new_data=None, show_opjective=False):\n", + " x_test = torch.linspace(0, 1, 100)\n", + " with torch.no_grad():\n", + " posterior = model.posterior(x_test.view(-1, 1))\n", + " mean, std = posterior.mean.squeeze(), posterior.variance.sqrt().squeeze()\n", + "\n", + " fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(6, 4))\n", + " ax.set_title(\"VBLL Predictive on Toy Data with Thompson Samples\")\n", + " ax.scatter(x, y, c=\"k\", label=\"Observations\")\n", + "\n", + " if new_data is not None:\n", + " x_new, y_new = new_data\n", + " ax.scatter(x_new, y_new, c=\"r\", label=\"New observations\")\n", + "\n", + " if show_opjective:\n", + " ax.plot(x_test, objective(x_test, noise=False), label=\"Objective\", color=\"k\")\n", + "\n", + " ax.plot(x_test, mean, label=\"Posterior predictive\", color=\"tab:blue\")\n", + "\n", + " # Posterior samples\n", + " with torch.no_grad():\n", + " for i in range(5):\n", + " ts_sample = model.sample() # a sample is essentially a standard MLP (one can also generate multiple samples, see function)\n", + " ts_mean = ts_sample(x_test.view(-1, 1)).squeeze()\n", + " ax.plot(\n", + " x_test,\n", + " ts_mean,\n", + " color=\"tab:orange\",\n", + " alpha=0.5,\n", + " label=\"Thompson samples\" if i == 0 else None,\n", + " )\n", + "\n", + " ax.fill_between(x_test, mean - 2 * std, mean + 2 * std, alpha=0.2, color=\"tab:blue\")\n", + " ax.legend()\n", + " plt.show()\n", + "\n", + "\n", + "plot_model(model, X, Y)" + ] + }, + { + "cell_type": "markdown", + "id": "bbdbe329", + "metadata": {}, + "source": [ + "# Bayesian optimization with VBLLs" + ] + }, + { + "cell_type": "markdown", + "id": "4e99876e", + "metadata": {}, + "source": [] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "c6f36d1a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 0) \t Best Value: 0.3324226803440067\n", + "Early stopping at epoch 3499 with loss 8.285541518367179\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhAAAAF2CAYAAAA/RaFTAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAuwlJREFUeJzsnQV4G1fWho9YMrMdZm6wbdqmzMzc7paZGbbdtluGLf3lLXO7xS2kTGlTStIwx3GcmBnENP/zndEokiwndmIZ5PPmmUeRLI2uRqO53z2oUxRFIUEQBEEQhE6g78yTBUEQBEEQgAgIQRAEQRA6jQgIQRAEQRA6jQgIQRAEQRA6jQgIQRAEQRA6jQgIQRAEQRA6jQgIQRAEQRA6jQgIQRAEQRA6jQgIQRAEQRA6jQgIYbt55ZVXSKfT0YYNG8KP7bPPPrx1FXfccQe/hyB057mkPbeurq5bxpTo9xF6Nzqdjs+FvoIICCI66qijKCUlhVpbW9t9zumnn05ms5nq6+vDX3TklpqaShMnTqS7776bnE5n1GvPOussSktL69AkPH/+/E6Pf/jw4VFjKSgooD333JM++ugj6kvguOHH8+OPP1J/AZ819lxqb0s0ke9lNBopJyeHdtxxR7ryyitpxYoVSf293nvvvfTxxx8n5ffa31i6dCmdcMIJNGzYMLJarTRo0CA68MAD6YknnujpoSUdxp4eQG8A4uDTTz/lCfeMM86IewH83//+R4cccgjl5uaGH8dJqT3fbrfTzz//TP/85z9p8eLF9N5773XrZ5g2bRpde+21/P+Kigp67rnn6LjjjqNnnnmGLrroIupuvv76606/Bsf5X//6F/8/1npx66230k033UTJxoQJE+j111+Peuzmm29mwXnLLbd0+3i0cxotcpqbm/lcfvXVV+npp5+mBx54gK655pou/V57gnjnEgQEJp1jjjkmKb/X/sKvv/5K++67Lw0dOpTOP/98Kioqok2bNtHvv/9Ojz/+OF1++eU9PcSkQgREyAKRnp5Ob731VlwBAfHgcDhYaEQyduxY+tvf/ha+j4na6/XShx9+SG63m9VvdwGVHTkWfI7Ro0fTo48+2q6A8Pv9FAwG2bLS1XT1PrEixpZsFBYWRn1v4P7776e8vLw2j3cHsee0Np4jjzySBer48ePpsMMOo75Md5xLve177S/cc889lJmZSfPmzaOsrKyov9XU1PTYuJIVcWEQkc1m49X6d999F/ckg7CAwIDQ2BpQvJoJuCfBOLAKKikp4fuIT8C4/v3vf9Njjz1Go0aNIovFEjZNr1q1ildgMFtD+Oy00070ySeftNnv8uXLab/99uNjNnjwYHbZQITEEi8GAqIKpmxMUniPAQMG8HEvLi7m8eXn5/PzsFrVzLuaPzDWb73DDjvwSiMWjAViCp8l8jF85kmTJvH74uJ+4YUXUmNjY4eO5ffff88uIbipcFE6+uijaeXKlVHP0ca3bt06dlnhebiQnX322W1cWtvC+vXr6cQTT+TvB+62XXfdlT7//PPw32EBw/jgboilrKyMDAYD3Xfffdv03rC6vfPOO3xO4wKtAbF82223sZsDnxXvj+P0ww8/hJ+zte91yZIlfLxGjhzJ3w3O23POOSfsKmwPWEgwGUdaRPA947jjszY1NYUfh+UEY8cxincu4f9YIMDSoo0PY4oE+0vE9xpLR94Hwv+uu+4K/4bhwvzHP/5BHo8n6nl4/IgjjmB3Cn7P+M1Onjw57ErCQgf3cdzxHS5cuDCu6xXn3sEHH8zf78CBA+nOO+/k4x8Jzg/sA9fJjIwM3i9W/J05hyNdP//973/5XMM1BuPbf//9+be1NXAtwe88VjwAuHYjefnll/lahsdxHOGChsU2lu48jvEoLy/n3wSuWxgnPt9LL73U5nlw0eBvOLbZ2dk8VsxdCQXtvAVF+frrr/FNKk888UTU4/X19YrJZFLOOOOMqMfx3HPPPVepra3lbcOGDcqbb76ppKenK3//+9+jnnvmmWcqqampW3z/l19+mfc5b968To992LBhyuGHHx71mNfrVQoLC5WioiK+X1JSwvufOHGiMnLkSOX+++9XHn30UaW0tFRZtmyZkpmZyX974IEHlCeffFLZa6+9FJ1Op3z44YfhfVZWVir5+flKdna2cscddygPPfSQMmbMGGXKlCm8b7yHxt57782bht/vV/bff39+3imnnMLvcd999yn77bef8vHHHyt2u1155pln+O/HHnus8vrrr/O2ePFifv3tt9/Of9O48847Fb1ez2OK5KeffuLnvffee+HHzjvvPMVoNCrnn3++8uyzzyo33ngjfx8777wzH6ct8c033/Brx44dqzz44IPKv/71LyUvL4+PQeTn1cY3ffp05bjjjlOefvppfl88dsMNN3Tq+5w0aVLUsauqquLvEufWLbfcojzyyCPK1KlT+fNHfj+nn346Pw/HOhKMG98lvustgbFeeuml7f4d3x/es7m5me/jvB8wYIByzTXX8HeH9xk3bhz/XhYuXMjP2dr3+u9//1vZc889+fv8z3/+o1x55ZWKzWZTZs6cqQSDwS2O96ijjlJ23HHH8H28J94HY/zss8/Cj+O3sdNOO4Xvx55LGI/FYuFxaOP79ddfE/69RtKZ98H1BI+fcMIJylNPPcXXJtw/5phj2lwX8H3gO8LvFb/3QYMGKWlpacobb7yhDB06lK8D2PD7Hz16tBIIBKLex2q18m8c1zT8Zo844gh+r3/+859trp04PzAebJdddply4okndvoc/uGHH8LHAd8txoyxp6Sk8DmxNQ466CB+j6VLl271ufj9n3XWWfweuO7jtXhvfM6eOI4Aj+FciDxugwcPVoYMGcK/EfyWcN7jeRiHBn472jnx3HPPKY8//jjPT1dccYWSSERAhMBFFyfIbrvtFvU4Jhx8MV999VXU43gs3oYfsdvt7nYBgZNfEzO4OGOSxv4uv/zyKAGRkZGh1NTURL0eP/zJkydHjRsX71mzZvFJr3HVVVfxPv7444/wY9gXfjRbExAvvfQSPwcXjli0iQJjj/0BtXfRX716dVzBd8kll/AP2+l08v2ff/6ZnwdxF8mXX34Z9/FYpk2bphQUFLCQ1MDxxYUvUlRq4zvnnHOiXo9JMzc3V9meiUY77vgsGq2trcqIESOU4cOHhy9WOEfxvC+++CJqfxB47U1cnREQmNzxHG3yx2/G4/FEPaexsZEnisjjsKXvVfueInn77bf5+XPmzNnieCFgDQaD0tLSwvf/7//+j38LmGggEgGOTVZWlnL11Ve3ey4B/D7xO40lkd/rtrzPokWL+HkQF5Fcd911/Pj3338ffgzHAo9pYijyHIFIixSUmHTwOCbwWKGiXUO03yoEmdls5u9VOy9wXYkVrpF09BzWBMSECROizi1MiHh8a8IAYgbnBDZcyyG+8JnjLRTinXsHH3wwL7Ai6a7jCGJ/JxABmJfq6uqUSHB9x3VX+wxHH300n1/djbgwQsDsecopp9Bvv/0WlY4IExBMRzChxQJT9jfffMMb4iQQJPXll1/Saaed1iHTVFcHLcJUjG3q1KkcxPn3v/+dzbeRHH/88WGTMmhoaGAT/UknncRZKEgjwwYTMsxta9euZRMamD17NpsdZ86cGX499hUbGxKPDz74gE3O8YKYtiUSHW4QBI6+++674ccCgQC9//777K+HmRHgOMAUjOBA7bNhg6kRZsVIc3sslZWVtGjRIjZBwuyqMWXKFN4fjkcssfEmMOnjWLa0tNC2gvfBMd9jjz3Cj2HsF1xwAZ+rmhvqgAMOYNPom2++GX7esmXL2E3QFX53LZNIy1bCb0aLdYH7AOcSzOswnf71118d2qf2PWkuLnw3OMfA1vaBY4vvHIFzAEHMeAwb/q99frgF8Nj2kIjvdVveRzvnYoNZtQDqWJcAzPK77bZb+P4uu+zCtzDdI9Aw9nGY2WO57LLLon6ruA/31bfffsuPwV0AFxCug9t7DmvAdRMZR6V9f/HGFwl+l7iGw92MAOAHH3yQr2Nwa8a6ZCPPPQQM49zbe++9+T1wv7uPYyyYQ3DdxPUM/4+8fuEzYYzabwTfAVyViP3oTkRARKBNhJrfCF8ILkQQFrhYxgL/HC7a2HDCIpIbMQHwiX322WfdOnacuPgB42TEBRUn2WuvvRb1IwEjRoyIug+/Ik5OZI9oAkTbbr/9dn6OFhdSWlpKY8aMafPe48aN65BvEs/rytiQk08+mebOnRsWOPBJYqx4XAMCCD80+DljPx984lsKrMLnbe/zIb4ExxgXzkgiLyYAvkjQ0XiL9sbR3hgix6nX6/kcRjqi5jeHmIBvFr7n7UWLIYCfWwNxAxBUeA/ESuC4YhKLvQC3B0QH4jYg0nGu4vXaObq1fcyYMYP9vZpY0ATEXnvtxenQECTa3yInrm0hEd/rtrwPvmt8zwiQjgSxI5hEtHOhvf1BTIMhQ4bEfTz28+C9EJ8SK96BttC65JJL+LFDDz2Ur4nw12MhtS3ncEePw5bYeeed+RqM5/7555+8sIPoRVxUpFDBtQPXbi22CeceYkninXvdcRxjqa2tZfH7n//8p821CwILaNevG2+8kQUZRBqu0Zdeeil/vkSTfGHt2wFWpYgyf/vtt/lEwi0m146ssDU0S8WcOXNYOXYXWN3jx7A1YgWFFgB53XXXsaqNR+zFqrcAoYCLA6wMV111FQde4QeMdNvIzwfxELkqjyTSGtMVxBOaoLssUsi+eeihh1hEnHrqqSyGEQCmXdi2B6zm8fm0Cf6NN95g6wxSH6+//no+zlqwJgRjR4DlC4IXr4dFCRdBfGf4DuMF50ZiMplYOOO3BiFcVVXFAgJixOfz0R9//MECAr/p7f2eu+t77ej7dNRq197+uvLz4HuHpe6rr76iL774gjcEKOJchMDcFrpifLBgQExgw2SNSRfXCiyMcH7iWo1z45FHHmEhgOfDUoLMtdhzrzuOYyzaGGA9PPPMMykeEO+aEFu9ejUvXCHeYLlA6jWCnLUU6kQgAiIGiAWsxmH2xcUXag4nYEeBCTdytdbb0VQxLsZbEyAozIIVfSw4cbcGIsZxQceFHe8Vj866MjCRQXHDjQFzIFYdmMwQqRz5vrDK7L777m3E09bA523v8yFrBaINq5dEg3G0N4bIcWrZKdOnT2fBhNXgxo0bu6SADvbz008/sRlXs0DAXYTzB8c98rvTLFdb+16xSkPmEy5wuNBpxDvH2gOCAW46fMf4PjAh4P0QjQ7xgA0Camv0lYJO+K4xseAYaat3UF1dzavVyHOhK8B7wRyvrZbBmjVrwtkJGph8sWDChtfAKoFaNLiWYgHSmXM4EcCtprklAer+IGsFbo1I68KWXJrdcRwjgejFbw1uuo4sDnEtwqIKG1wjyHBDJgsWWYkqKSAujBg0awMuaFDVnbE+aCcmQBxCXwCrB6Rb4seu/bhizWgayP9HQRaYBSP/3t7qPjb2Aib/J598sl21DnM0iEzB2xr4sWBMSGvC/iPdF9oKFz9ApL3FE3tbei+kmWJVjFVU5POwEkfMSXfVQ8D74JjDt6sB1wlMm7j4wD8bCWJfMD6krsKtANPy9gA3A6wZOI6RRZC01VfkagsiMXKcW/pe470eYNydERCYCPAauCk0IYDHUcgJRdU6Ev+Ai29nzrueQjvnYo8RVtHg8MMP7/L3jPzN4rvCfSwCNGtrbMotzPXaylhLLe3sObytQADEW/1rsSOaGyXeuQe3BSwnieLJrRzHWDBGXDdhTcA1Z0vX5tjvAIIOxxTvg0VbohALRJxV7axZszgoEmxJQEBBwowL4HPGRIbJBoobF/FI8CUiPiIWBOdBrWtgIoz1HwL4iSN9z13JU089xRdf5DKjehtWlVjR4MeOOBAEI4EbbriBL8owL2M8uOjiAoDVAyw2WwLmTMRkIPgLFxJc1HEBwcoRnx8BqbAQ4KSHRQFKHccGK2ps7QGBAPcLNjw/VqkjKAo1H2BWhyA86KCD+EeLFRzMmchVj6wZEQvcAZiAsfI+99xzyeVy8YoeLoHuqlmPqolwp2EcV1xxBX9OnGeo8YGLCy7YkSCIF98VKqtefPHF7Vp8tnRO48KDwD2tqiosapikIt1DWNnD+nDsscfyxIXxPPvss/wdRlrgtvS9Il4BgW74fSDQDcJHq13SEfC9IK4Gq1sE5Glgv1pOf0cEBNyXOBfxGRGIiuuAFhDXm8DCBOZs/O4geHB+4/eE8wHWt3i1UbYHrFxxPcJ74njAPYEYF7h4NbfQeeedxyITAYWweiGeAb8RiG/NStLZc3hbQZA2rsU4J2GNwkocLjKcexAqWuwArgOa1QTXB5yvzz//PC+o4i2kuuM4xgPFxyCK8Bpcm/E7wrFG8CTOV/xf+zyIg4GlFS481KmBQMHvMlHzBtPteR99AOQx49BsKe84Nn0TaUPI173ggguU6urqqOdqaTzxtlGjRkWlcba3bdq0qVN1IGLR0jiR+haP4uJiTktE3Qjk8SPPGbnK77//ftTzlixZwqloyGvGc+666y7lxRdf3GoaJ0DKEXLAkbqF98B7IW8Z762BVCnkfyO9KTKlKV7qncbuu+8eN7UtEuRJY79Iu0KeONJWkeJVUVGhbI1vv/2W3wOvRbrakUceqaxYsSLqOdr4IlOyIr/XyGOzLel+OEY4VkhJxLHHuRlZ6yCWww47rE3q2daIPN+Qpor3Qj4+0vSWL1/e5vlIRbv33nv5/EMdBTwXY8L5jsciae97LSsr41RFvBfS0lA7AN9Je2mf7eXzx6YXY794DPnzscQ7l1atWsW1T/Ad429aSmeiv9fYMXXkfXw+H9cj0X5H+Iw333xzm/Tx9q4L8dJ1410ftPRznHtIE0ctBqToYqyRdQ5wjcDfke6M7xd1ES688MI2NVo6cg5raZyRdVwix4fjsSWQwoxU2PHjx3M6N8aDugxIoYy9Ln/yySec4oyxIJUUNXC0dPPI491dxxHEO+8xbrwPvmftuonUe1zTItNHcf4i5Re/Rcwr119/fbhmS6LQhQYtCEISgRUYmgp1pHqfIMQDAbKIc+kr8Vy9lbOS+DhKDIQgJBkwwcI8GutGEwRB6EokBkIQkgT4k5H7/cILL3DcA3y7giAIiUIsEIKQJCDNElYHCAkEqCGoShAEIVFIDIQgCIIgCJ1GLBCCIAiCIHQaERCCIAiCIPSuIEoUcsGmNQtBeVlUeNxSZTwUrUH5U7wGZaRRprYzFf9QMhTV51A8o6+UpxUEQRCE3gCiGtB8DAXVtlrgK5FFJlCo4/PPP1fWrFmjrF69WvnHP/7BhTCWLVsW9/lz587lgkwPPvggF+q59dZb+flb6wEfCQoubakgk2yyySabbLLJRttcvFCj24MoUcIU5YFRFjgW9DFAeePIVti77rorl0RFidyOgHrmaM26adMmysjI6NKxC4IgCEIy09LSwt1JUSp9a118u60OBBrxwD0BgYD69fFA7wX0SogELabRmrg90KxFa9gCYHoBEA8iIARBEASh83QkBCDhQZQop5uWlsYtli+66CJu8NNe57WqqipuBBIJ7uPx9kCTJKgkbYNyEgRBEAQhsSRcQKB9Krogos0vOgOiG9mKFSu6bP/odQ63hbbBdSEIgiAIQmJJuAsDLVPR3lprmTtv3jxuofzcc8+1eS4q56GNdCS4v6WKerBsYBMEQRAEIYl7YSDNMjJmIRLERnz33Xd01VVXhR/75ptv2o2Z2N6YDJ/P1+X7FYSeBIJ9q6lXgiAIvV1AwL2Amg9Dhw7l4Ma33nqLfvzxR/rqq6/472eccQYNGjSI4xjAlVdeSXvvvTc9/PDDdPjhh9M777xD8+fPp//85z9dNiYknSCmAhGmgpBsQDyMGDGChYQgCEKfFRA1NTUsEtBeGAGOU6ZMYfFw4IEH8t83btwYtVqaNWsWi4xbb72V/vGPf3AhKWRg7LDDDl02Jk08FBQUUEpKihSbEpIGrYgafm8Q7XJuC4KQSJKumRZyWCFWEFAZm8YJt8WaNWtYPOTm5vbYGAUhUeC8h4hA3BFaeguCIHTVHBpLv3KWajEPsDwIQjKiuS4glgVBEBJJvxIQGmLaFZIVObcFQegu+qWAEARBEARh+xABkWQMHz6cHnvsMUoWkLWDVbVkzQiCIPQuRED0IVBl85xzzuE2q/B1Dxs2jFNf6+vrKRnYZ599omqAaJk5WhaPIAiCQOQLBKnR4aVNDU5aUdFMDo+/fxSSShYQpPbzzz/z5DZgwADac889yWAwJOz91q9fzwW1xo4dS2+//Tbn+i9fvpyuv/56+uKLL+j333/nTqc9cRxgIUhU8SIIpS1VIhUEQUh2AkGF7B4/CwUIhyaXj1zeAPmDQdKRjgozrJRq6f7pXCwQ28CHH37IroJ9992XTjvtNL7FfTyeKC699FKeTL/++msutoU8fxTp+vbbb6m8vJxuueWW8HNRtOvUU0+l1NRULtT11FNPhf+GrN077riDX48S4LBmXHHFFeG/o0roddddx6/D63fZZRd2I2i88sor3C79k08+4aZo2McLL7xAVqu1jZsB1pH99tuP/w8rCcaE/SILZvLkySyENM466yz66aefuMw5BAm2DRs2xHVhfPDBBzRp0iR+bxx3FB6LBI/de++9bK1JT0/nzxpZjMzr9dJll13Gwg/jhiVHK2YmCILQ0yiKKhiqW9y0uqqF/lzfQPNLG2hpWTNVNbtJTzrKS7PQoCzUMurZgSYVzc3NqGvBt7G4XC5lxYoVfLutfPDBB4pOp+P3iNzwGDb8vaupr6/nfd97771x/37++ecr2dnZSjAYVIYNG6akp6cr9913n7J69Wrl//7v/xSDwaB8/fXX/Nz33ntPycjIUGbPnq2UlpYqf/zxh/Kf//wnvK/zzjtPmTVrljJnzhxl3bp1ykMPPaRYLBZlzZo1/PeXX35ZMZlM/Jy5c+cqq1atUux2u1JYWKi88MIL4f34/f6ox8rKynhfCxcuVIqLi8PjwvuDpqYmZbfdduPPUllZyRv28cMPP/DxbWxs5OfNnz9f0ev1yp133smfD+Ox2Wx8q4FjkJOTozz11FPK2rVr+VjgNRgrwDiGDBnCn3HDhg3Kzz//rLz11ltKMtAV57ggCN2Py+tXalrcSnFNq/JnSb3yw8pq5ctlFcrXy6qUn9fUKgs2NChLNjW12b5aVqnUtbq7ZQ6NRQREJ8CENnjw4DbiIVJEYGLC87qS33//nff/0Ucfxf37I488wn+vrq7myfOQQw6J+vvJJ5+sHHroofz/hx9+WBk7dqzi9Xrb7AeCApN6eXl51OP777+/cvPNN/P/MVHjvRYtWhT1nCuvvFLZb7/9wve/+uorFh7axB+Pww8/XLn22mvD9/fee2/eTySxAuK0005TDjzwwKjnXH/99crEiRPD93EM/va3v4XvQ1gVFBQozzzzDN+//PLLeax4PNkQASEIfQOvP6A02D3KxnqH8ldpg/Lj6moWA18uq1R+Wl2j/Lm+Pq5g6E0CQlwYnQAxD2VlZe3+HYIMgY54XiLoaNHQ2OZjuL9y5Ur+/4knnkgul4tGjhxJ559/Pn300Ufk96sBOEuXLuWYBsRZpKWlhTe4FoqLi8P7gysFZckjOf3009ndgCqI4M033+R+JnB3AOz3rrvuYtcFYjWwX5Q1RznzzoDPsfvuu0c9hvtr166NKp4UOT64QBBHgdLqmrsELebRah7uG7iFBEEQEkkwqFCL20cVTS5aXt5Mf5Q00PwNjbS8ooWanT6yGg0cyzAw00bZKWaymhIXU9dVSBBlJ0DAZFc+r6OgLDEmQUyexx57bJu/4/Hs7GzKz8/f6r6GDBlCq1ev5tgJdDq95JJL6KGHHmKRYLfbORB0wYIFbQJCMeFr2Gy2NgWLdt55Zxo1ahQ3QLv44otZmCBeQgPvgfgGpJhCRCC+AhkXiEdIBLFlnDFe9IoAM2bMoJKSEg4+xXE46aST6IADDqD3338/IWMRBKH/oSgKuXwBsrv91OzyUb3DS06vn3wBhYw6HaWYjZSfbiGDvu8WfxMB0QkQdNeVz+so6NuBBmRPP/00XX311TyBRzYHw2ofTcu0SR0ZGZHg/oQJE8L38fojjzySNwRnjh8/nq0P06dP51U8VurIKukssEJgLIMHD+asDFggNObOnUtHH300/e1vf+P7mMzRlwSBmJGWja2VYMbnwL4iwX1YTTqTBYMa7yeffDJvJ5xwAh1yyCHU0NDQI5ksgiAkB15/kIMfIRrqHG5qdfnJ7Q8SNILNZKQsm5lMhuQx/IuA6ASYVDE5IushnjsBEzj+vi2T79Z48sknuSbCwQcfTHfffXdUGicyG+65556oCfXBBx+kY445hq0M7733Hn3++ef8N1gFMEkjuwLZEG+88QYLCmQiQKhABECMILMBgqK2tpa+++47dglECoJ44LXI8MBYMCkjS0IDnVWxwv/111/ZWvLII49QdXV1lIBA9sQff/zB2ReweMSbzK+99lq2dsAdgsn/t99+42MDcdVR8N4Qefh8EDo4PnBxaO4WQRCEjrol7F5VMCC9shHplZ4ABRWFLEY9WxmyU/RJW2I+eaRQN4AVLszwIPaE0O7DRJ+IehCYgOfPn8+xCzC5w11wwQUXcAopJtHIyRaTLJ6LCRJiAxMmhAfAJPn8889z3ABEAUz4n376abg76csvv8wCAvtAjABEyLx58zgVsiOulpkzZ9KSJUtYTESCFu1wHWAcKBiFCRv7jgTpozh2EBVwx8SLj8A+/vvf/7KrBG3eb7vtNrrzzjs5rqGjILUTAmunnXZiMQLBMnv27ITVshAEIXlw+wJU2+qhdTWt9OcGxDE00NJyNb3SQDp2SwzMslFumoVsZkPSiod+187b7Xaz7xurd+T/byuo94AaB5EBlYgtgHg47rjjtmv8grA9dNU5LgiCij8QJIcnwAGQDQ4vxzNARACbycBWBrOx5xYflc0u2nFYNguW7m7nLS6MbQAiAf787qxEKQiCIHRf8GOr209NTi812H3k8Pq56qPFCMFgoEybifRJbFnoKCIgthGIBZjiBUEQhL7fWwJxDBANtXY3/9/lC5JRr+N0ytxUMxmTKPixqxABIQiCIPQ7K4PTu9nKgBRL9JZAzwkEP6KvRDIHP3YVIiAEQRCEfmNlQCwDgiCRbunxB0iv01Oq2cC9JfpyTYaeQASEIAiCkLRWBggFpFhGWhnglkg1GyknxSxWhu1ABIQgCIKQNBkTEAxaLEOLC1YGFHLSiZUhAYiAEARBEPossCq0un3U5PRRvd0byphQyBqKZciRWIaEIQJCEARB6FPVH1vZyqAKhiaXl9y+IBl0kjHR3YiAEARBEHo1CHaEWwJdK2vtHrYyICjSYlDrMmTbJJahJxABIXQ5KCvd1NREH3/8MSULuDihw2hs+W1BEBKbZtng8HAFSNxH2eQUkyoYkqkpVV8lod/Afffdx70G0HugoKCAL75oJb0l0OwJF+vITUryqpMyjsX9998f9TgmaVHeXQeagU2bNq3N46g4euihh/bImAShP4DsCFgYNjU4aeGmRpq3oYEWlzVSRZObDHo9FaRbaWCmjbJSRDz0CwvETz/9xO2iISL8fj/94x//oIMOOohWrFhBqamp7b4O9bcjhUavnCDRdvrnnzGzoH83WnWiPGVC3xJC6oEHHqALL7yQO1oKm/H5fGQymRK2fzT/EgQhMa4JFHOqs3s5gwKZFFajgQMgc1O7pr+DkBgSKuO+/PJLXjlPmjSJpk6dytYFdFhcsGDBFl8HwYALtrYVFhZSr+LDD9F7mmjffYlOO029xX08nkAOOOAAPh6w7GyJX375hXtzoE03mnxdccUV5HA4+G9ofY0ulrEWjGeffTbqfdA9sz2WLl1K++23H+8fXTzRFdRut7d53r/+9S/uqglBeNFFF5HX6w3/Da29J0+eHN4H3lMbI3jhhRdowoQJLJrGjx8f1a4b3TMx5nfffZf23ntvfs4zzzzD+/riiy+ixgC3AyxgTqeT79944400duxYbmWOzqb//Oc/WXwAnJ8Y8+LFi8PWLzwG8P9Il8zWjgHOe1jc/v3vf3OvFDwHYlp7L4DPhC6rGD/OcbRAF4Rkd004PH7uXLmiopnmlTTQX6WNVFzrIH9A4boMg7JSuDEUAiKF3k232oHQ3QtEtp6OBy7Ew4YN48kPTauWL19OvQaIBFzoIzpxMuXl6uMJFBHov3HvvffSE088EdUJNJLi4mI65JBD6Pjjj+e22phkISguu+wy/jsmXFiAamtrw1aivLw8+vHHH/k+Jji0B2+vzwcmebTkhgUEbb7fe+89bgmu7V/ju+++o5UrV/J+3377be5gislZcweceuqpdM4554SfgwZlWmPYN998k9t033PPPfx3fGZM9K+++mrUe9x0003cFRXPOfHEE+mII46gt956K+o52BcmcggGADEBUYBjgNbsaG3+6KOP8t9OPvlkbmMOwYsxYsNj23oMfvjhB/4+cIux4301QYJ26xB2aEUOaxvE9l577dXudy8IfTlrAh0s4ZpYtKmpjWuiMEN1TaBBlbgm+hbd1s47GAzSUUcdxcF1mNDaA5PX2rVracqUKSw4sIKbM2cOi4jBgwe3eb7H4+EtshUphEdC2nnDbQFLQzuTN8HVgjGWlHS5OyMyMHG33XajiRMn0osvvsj3jz322PDke95557HQeO6558KvxfGGcMDEZ7FY2CoAiwNWvNOnT+dJEpMpJsy5c+fSvvvuy++lTbqRYMLFKn7Tpk1hN9Ts2bPpyCOPpIqKCl5JY6yffvopP0fbB97v+uuv5+9l0aJFtOOOO7IlAUIxltGjR9Ndd93FIkPj7rvv5vf59ddf+XX4DtE+HQJCA8fi73//O1VXV/P74lzAeGCFgKiKB86vd955hyd0LQYC+8EY2wui7OgxgDCCgNC6tJ500kmk1+v5/SCozj77bBaCEDVdhbTzFnoDyJBQsya8nDWBtEs8ZuWsCSNZTVKbIRnaeXeb3IP5dtmyZXzx3BKYHM844wwOZMOkhwstJrzICTESmPPxYbUN4iFhIOahPfEAMIlv2qQ+L4EgDgIrWqy8Y4H5HavctLS08IbVMgQcJhb8aLHSxeQGkYCV+CWXXMIibNWqVWyRQMxKPPEA8J5wR0XGsOy+++68/8i4FTwnch/4XmFZwqSLv+2///7swoDlABNyY2MjPw8iB5PuueeeG/UZICDweCQ77bRT1P3DDjuM4yA++eQTvv/BBx/wDwDuEQ1YZDBeuIKwX7hq4FbrDB09BrBkRLZ4hyujpqaG/3/ggQeyeIIbBaIHlhLNzSIIfRG3L0A1rW5aU9XKrokFGxppTU0r12hA1sSgTNU1YTMbRDwkCd0iIGDa/eyzz9iUG8+KsCUwIWCVvG7durh/v/nmm1kpaRsmqISBgMmufN42AgEAUYDPHgsmaQRZYgWtbRAVsOqMGjWKnwP3BATEzz//zMcWk6wmKiAgINwSCSbVb775huMVYEmBS2bcuHEscLQ4AoiKyM8A8fn7779H7Sc2ENdsNrNVRXNj4BbWFaPRGLZunX766Sw0cD4uXLiQbrnllqjYjK4kNqgTF02IDACrw19//cXuHQgLuGwgSiDqBKGv4PSq8QzLy5vZNbGwtJFKGxy8lspPt9DAzBTKlqyJpCWh3yrM6hAPMP1+//33bFbtLIFAgAPWcJGNB0zymAAjt4TRzhi2+XnbAdI54SbApBjJjBkz2KoAN0Dshgk2Mg4Cvnst1gG38OPDhdFe/ANAYCMESWTAI14D0zxEgAae43K5wvcx+WPFr1mIMJli1Y64CEzkGBvOE5j/Bw4cSOvXr28z/o6cPxAIiCeAywvnHO5rwP2BVT9EA6wXCGAsLS2Nej3GgXNuS3T0GGwNCBtYRx588EGOV4FrBmMWhN4KrumoAFne5KLFiGcoUeMZICJMej0VZdqoKMNGGTaT9JxIMLqAl0ytmyirdj5RYHNwdtKkccJtgVXg//73P15xVVVV8eNwNSB6HcBdMWjQoHBmAYLKdt11V54wsBp76KGH+CIP336Pg1RNWFAQMBkvdESLgcDzEgzM/5gc/+///i/qcfjmcfwg3HDMsEqHWMCKHxkYAPElCADEd4OVOIBouO6668ITe3vgPW+//XY688wzOV4AwZiXX345m+Ejs2WwqocbAi4CTIx4DcaESfaPP/7gIEuk9KI+CO5jP5iYAUQFAgxxniB2Ae4VxCjAzXHNNdds8bjAkgL3BMYJwbHLLruE/wbBAHcF3Ghw03z++ecsWiIZPnw4W0Jg9YC1DOctROq2HIMtgeMOkYTx4rtADAWsE50RIILQXfUZtDbY1S1uFhBev0Jm9JowG9nCIC6JBKMopPe2kMlRSWZHBZnsFWR01REpQTJ5/KS3jyfKHE1JZYFAah3cCpicYEHQNvihNXBBR/CeBiaJ888/nycTmJoR0IGVI0zdPQ782Y8/rv4/9gej3X/ssYTXg9CA2NJM4hoQB3BDrFmzhlM54aKAeRyr+s1D1fHfcLvHHnuEXwfrDVbmW6rRgbiGr776ihoaGngShssA8QyaONHAY5iwMUHCjYAAWky2AO+DwFh8v0iphMh4+OGHw4WaIHyQxvnyyy+zUILFBHEdHbFA4DMh+BIWgkjrA8AYrr76ahYyiLHBeYXsjkiQvQLRgkBSxN7AxbCtx2BLZGVlcXwPUkFxriPIFO+FuAlB6GlQiwHVH0tq7eyamFfaQMsrWsjhCVC61UQDs2zc2VLiGRJEMEBGRxXZav6ijPWfUd7S5ylv2YuUWTKbbDWLyOisYfEQNKeTPWM0kd6Y3FkY3cWWIki7LEIdqZqI/o8MqIRpHuLhuOO2Y/SCsH1IFoawrXj9QbYyoKhTbYta1ClIQbKZjJRmMUocQwLR+V1sVTA5KsjsqGTxoAv6Y56kJ19KAflSB5AvdSD50gZQ0JzRo1kY0gtjW4BIOProbq9EKQiC0NWVIFGjodGhVoJEkSeAVMu8NOlqmRAUhQyeJhYLJns5me0VZHA3tHla0GgNCwW+TS0i0ieu2u62IAJiW4FY2EKwoSAIQm9Nt2xx+agOTapCogEFndDVEv0mJPgxAe4IVw2Z7eVhK4Pe1zZlO2DNIW/awJBoGEgBS3ZbV3kvQwSEIAhCkuPyqpaGeruHGpxqZ0u9TseuCWRO4P9C16Dzu8nkqCKTQxMMlW3dEXoD+VKK2B3hTRvEgkExqokFfQkREIIgCElaowGioQ6iweHlgk6GkGgYkGGS4McuQu9tZaFgZsFQHsqOUNq6IyAUQtYFX0phjwU+diV9/xMIgiAIUaKhpsXDwZBuf4CMej2LBlSDFNHQFfELjWSyl3HsAgSDwaP2eIokYMliocDWhdSB7J7o7e6IbUEEhCAIQh8GMQwQDbWtIdHgC3DwI4sGqdGwfShBTplU4xfUTe/fXCCP0enIb8sPuSJUwRA0p1F/QASEIAhCX7c0iGjoGoJ+NX6BsyPK1PiFQHSpe0VvVFMp0xDwCNEwgBRD16RQbhNKMH5hw25ABIQgCEIfQERDgspBh9Mpy1kwIGsiEsVoIS8LBcQvDOZaDD0Zv6DzOcnkRJBmJW/Wuo2kK7yYKL2o28ciAkIQBKGXZ0/U2t0cCIn7KOgkomE7MiQ0sQALQ6iiYyRBU2rIHTGYRYPflsdFnHouBbQ2lNVRyb0v1DRQBxl8TtL7HZTqdpChbl+ifBEQwnaCXg5XXXUVb9vznO0Fpaexf+kuKQidA5YFLaaBRYPPL4GQ21Hh0dxaFhINm+JmSAQsGSwWNNGAAMieCnjUe+1hy4K5pZTMLSUcpKkPiQW93w2bCAWNKRxngWyOVpuNsqyZPTJeERB9CLQqRxMndJusq6vjviLHHHMM97rIzc3t8H7mzZu3xX4XnSWeIEH/C/S6EAShgxUhnWpxp3ou7oTsCR2lW42UZbOJaOiEeR+xCxy/0FqmCoYYAtbskFgYQt70QVwOumetC5Vkbl5PlqZ1ZHJUs1Aw+BykC3jCMRdBUzoFbHnkNaVxRUoEavpTCjh4s8yfQVPzhvbIRxAB0UdA58bddtuNm0+h6RJ6HaBl9fXXX09ffPEFt8vOycnp0L7QJCrRoNuq1nFVEIT4vSe04k6o1YBsCnSrTbcYaWCm1GnouGDYFLIyQDDUt3kOXBDIjvCyS2JQj2VI6His5WRuKiZr81oyN5eSwdvC7ghdUAvU1LF1AVaQgDmdx+vJGB4SCwUcf6GYUqI/X7Or5ywmPfKuwja1RjebzfT1119zd8qhQ4dy98pvv/2WysvL6ZZbbgk/t7W1lTtSwsqAVulPPfVUG4vBY2j8FQJuBnTAhLBA8xR0iEQ3y0g+/fRT7jyJBk15eXl07LHH8uPotIp26+hyiQuedtGDCwMdJwE6g+LxVatWRe3z0UcfpVGjRoXvL1u2jD9TWloat8VGe2xYWgQhmbpcQjCsrW7lLpcLNzbSpkYnGXR6rghZlGGlVItRxMMWJmFL4xpK3/gd5ax4lfKXPEuZ6z8nW+3isHjAqtxZMJ2aRx5BtVMuooaJZ1Dr0P3JkzOu+8SDEiSjo5pSK+ZS7rKXaMDcW2nIj1fSgN9up7zlL1Ja2Rwyt5aS3teqxlykDyP7wN2pYcLfqGbGFVS1801UuevtVDvtMmoZeQQ5i2aSN3N4G/HQ0/R7CwSakTqdbeuSdwdoC92RCwXaRqN99D333NNmVV9UVMRtq9Ei/emnn+bHHnroIfrHP/5B//rXv/h1V155JVsuDjzwwLj7P/HEE3m/sGSgC9tzzz3H7akx8cOq8fnnn7NggEh57bXXyOv10uzZs/m1aEk9depUuuCCC7gNezzw3mgT/uabb9Jdd90Vfhz3TzvttLCIgXCBkIGwcLlcdOONN9JJJ51E33//fSeOqiD0LoJBhbtcomFVdauHWt1+CioKpZmN0nuigzEMsDK055LgGgzpsC4M5tueKAmt87vJ0rSWrPWryNK8jsytGzl2QRf0RT6LgkYb+a255MsYQu7MUeTNHMkuCQ7U7GWNsjpCvxcQEA9Y8fYEdru9Q7EIa9euZaEzYcKEuH/H442NjVRbW8v3d999d7rpppvCk/fcuXN5Uo4nIH755Rf6888/qaamhiwWNZf53//+N3388cf0/vvvszCAcDnllFNYkGhANAAIDIPBQOnp6Sxm2gMi58knnwwLCIiTBQsW0BtvvMH38bfp06fTvffeG37NSy+9REOGDOHn4nMIQl8Bv9dWFHhy+rjdcovLTwElSCkmI+WnWUQ0bC1LohVuCQQ9qte0SDDZetOH9JxgCMK6UEG2uuVkbVpD5pYNoX4XvpgPYwg1yBpEnsyR5M4eR770ISGxkBxTb3J8in50UeoIiJWIvR/psogErgoImdggTFgAiouL+f+LFi1q17rQUSBArrvuOo7V2HXXXdn6MGPGDBo/fnx4HD/88ENcMYdxiIAQ+gKIY2jiWg1uanR6Oc4BoiEn1czpl0KcOgzoI9G6kUywMnBaZfR1zm/L5YkXMQzYutuMj14X1voVZG1czfELltaNpPfZ2zwP1gUUlvJkjiBP9lgWDP6U/KQRC/FI3k/WCTcCJtCeeu+OMHr0aHZ1rFy5Mhx7EAkez87O3qbgSHx2ZHP8+OOPbf6mxTB0RTAkrBNwUbz11lssIHB78cUXR43jyCOPpAceeKDNazE+QejtaZfVEA1oWuUPksWgpwyriSxGQ08PrxdWeqwMWxi4cFNMHQbOkmDBMIR86YM5RqA7LSAYl6VhJVkb13IapYlTP6OLS6EuhC+lkLyZI9gV4c6dRN6MYUktFuLRvz5tHDAxd2VKYyKAdQDuB8Q4IFgxckKvqqri1fwZZ5wRjqfAKj8S3G/P/QErAPZhNBo5uDIeU6ZMoe+++47OPvvsuH9HcGcgEPMDa8eNccMNN3CAJ7JKYJWIHMcHH3zAY8BYBKE34wsEqcmpZlDUcgZFgEx6HaVZYW3owbLGvbWXROtGVTDYK9qY+lGHwZs+NJRWOZiC5vTuGVvQRyZnLZmbS8jauJIsTetZ0CArArUWNqPjVE+IGnfWaHLnTCBX7gQiY+8KaOwJ5ErdR0CMwKxZs+jggw+mu+++OyqNE5kWiFPQQMzDgw8+yDUivvnmG3rvvfc4EDIeBxxwALs48Fy8Bq6CioqKcOAkgh9RewJBlciYwKTv9/s5iBJBjgCT/pw5c/hviKNAlkY8jjvuOLY6YNt3331p4MCBUVkmzz//PIsLiAzEVqxbt47eeecdeuGFFzjOQhB6QzAk6jSgnHSrx8fZc2kWk6RdxnSrNLdAMGzk4EedX61noKFmHQwJb0EUbkr4uIKcpWF0VJKluZisjWtY0HCgY8AdPT6DlV0P3oyR5M4ZS67cHcifOiApu2luLyIg+ghjxoyh+fPn82SOzARkZsAtgIkfj0XWgLj22mv5uQh6RFrmI488wsIjHrjoQQwgwwIWBgRiYr977bUXp1JqqZoQIQiAvP/++3mf+LvGnXfeSRdeeCELDI/H026sBgIt4ab473//ywGSkUBMQPhAlBx00EG8n2HDhtEhhxzCufGC0FPYPX52TVS1uNlVEQgGKdVskgyKiOqJqoVhIwuH2PgA7iXB1gV1C1hzEzsZKwrpvS1qvwh7JWdHWJrXk9HdyPEMm2suoEiTeXOgY9YYcuVMJG/WyO6zgvRxdEpHI/P6CC0tLZyK2NzczBNdJG63m0pKSnj1jnoG/RXEFEAMIGVSSC7kHO+6uAa4KDbHNQTIZjJyZcj+HgyJColIqdREQ2zxJq1bpTdjKNc3QBGkRPaSQNyC0Vkd7qJpbV7HNRhQpMngbQ3HLyg6AwVNaRSwZHK8git7PHmzRnO/C8XYd38rlc0u2nFYNuWmWRI+h8YiFoh+lrKKVX51dTVNmjSpp4cjCL2uyBMsDKgKiT4UdsQ1GHQcDNlVF+c+STDAq3nVLVHKE3VU4KNOpwYUsoUBsQwDE1fTgF0RdRyrANGgBmOi5kILWxcMvtbQ2HQUNKWQz5bHQZmeLGRFjCYfxpdS2O+CHROFHMV+xH/+8x+2PKBnRWyqpyD053oNDXYPVSGuwa0G+KWZ+3FcQziOoTQc/Ih0y0hQalm1MKhbolbwCGhkscANpqq4qJTB08CCAdYF1V2icNwCrAtcH8JWwGmUsDKgFHSPdtNMckRA9CMS3YFTEPqSiwJ1Gqqb3dTA9RoUSjUbKD+tf8Y1qBUfN4Y6QG5k839sjQO2MGQMY8EQtGQmqLlUTbgbJQsHV4PaL4LdEegb4SRFp2ex4LdkUjBtIDeWQjolGmMhk6Mnu2n2N0RACILQb1wUKPJU16qlXvq5TkO/rNcAtwTXY4BgKCWTszq6gJPeQF5MzCHB4IfZv4snZbV1dcVmseCsIb3fFRIMrapbwu9k8cKNpVKKKADhkFrE1g+tBXdCxIzQIURACIKQ9C4KBEJWNrs3uyg49bJ/tck2uJtCgmFDXLcEl4hmwYBtUNfGMUS0rmbRYK9koYCaEGqwYwvpPep9DnQ0p/FYAqZU8qcWhrppDunRbppCNwuI++67j5stoQsjih+hjgEqDY4bN26Lr0PK4D//+U/asGEDpy/iNYcddlgihyoIQhLh8Qeo0aFmUTQ4PORBSWmzsV+5KLhMNKoqQjC0lJLB09TWLQHBoLklujB1ES4RFI2CWDBzDEM1iwNd0B/lkgABUzpbFrwpRaSEajCgAiWsC7AydGclSqEXCYiffvqJCwShDTSKD6FDJHL8V6xY0W71x19//ZWLCUF8HHHEEVzyGLUO/vrrL9phhx0SOVxBEPp4oSdkUaA6ZBWyKNz+cBZFXlo/cFEoCmcosIUBm6OCV/5R5ZfTBpInZGXoMrcEgi7dDWF3hNleTgZ3o/qWEYJB73Px+8G64Ldks0UBrhJYPlTB0DO9LoQ+UgcCRYoKCgpYWEQWIork5JNPJofDQZ999ln4MfROmDZtGj377LNbfQ+pAyH0Z/rjOe70+qkRXS+bXFy7IRBUuF5DqsVI+iR3Uai9G9Q4BkvzhjZFnNSaB8PJkzGcJ2nFYOmifhZVIVeEamXQ+9VqjjolEIpfaCad4ud0SlgXEMMA6wIEhAiGLgDCzNPExbGaGqpo1JTdKTc7O7nrQGBAILJqYiy//fYbXXPNNVGPoYoi2kvHAxULsUV+eEEQkhuIBGRR1La6qbbVSy5fgBtYJX3XS1gZUP8AgoHbSFdEBT8qelMoW2I4bwFrVpe5I2BZYNGAgEvNsqEEufYC949QFKxIOW7BG1ELgis9QjCEGmSJYOggSpAtN0Z3E6fVGj2NbNnB/9UCWer3bvD4Se8cT9RFAqIzdJuACAaDnEK4++67b9EVgcZOWgllDdzH4/GAqwMlm4Xewx133MGCD23A+zKIwcFKfuHChWwBQ8dS9PBobGwMdyrtLF2xj/6MVla6osnFfSlAusVEWbbkrdmgWRlgYYBrQm32FN3uOmxlSEPwo3E7y0A3kxmWhZBgiK40qZDBayfiAEwIhiAFjSmcIaHVWmCrB+oxhMpXS9BjByppulHbAgKhga0KsC5ggwuoPRSDmbyWHNqkmCi9h/Ihuu1dEQuxbNky+uWXX7p0vzfffHOUxQIWiCFDhlCycdZZZ9Grr77K/zeZTDR06FDuwIm4ku3tXtnVk9p1111Hl19+OSUbCAKurKxk815HQA8RCI/HHntsm/chqOmXcFHUtLi5SiSsDSkmI+WlWsiYjNaGcCzDehYNsS2veeJAAaeMYSwatiuNMfReqjuijIUDXBCRoPYC6RRuUIk+EkGDjRRTWjh+QivgtLk5lpzbbQgGyOBtVoVCyIrAQsHdwKmr7YIYEXMmteoyqNKfQpvcNtrgNNO6VgsVNwU51gfWuDcmpVIBJamAuOyyyzimAR0bBw8evMXnopETSi1Hgvt4PB7o/oitP4DGUi+//DK7bNAAC6IMYgIiqjeAcBq09U5LS+Nte/D5fPzZuoKu2hfalrd3HnbnPvqTtQEBkUi/bHGh8yUCIpOzXTYyJriQU3MJuyZiJ3HVyjCCPJnDyZcKK4Nhu4o1oaKjZmHQ4hfCYwl6SdEZw30vggZTREpnKgWNVrUGA4uYoRSwZEvhpgh3jyYSNKuCetscXf47BmTAeMxZVONPoXJPCm1wWam41UzrWvS0qdnN7eI3g/87w/cQKFzviE7J7S70iZ5QIB4++ugj+v7779kcvDVQYvm7776LegwtqaX0siqWMPmgSyVaYqMV9yeffMJ/g/UAFons7GxKSUmhQw89lNauXRt+bWlpKXfCxN+RAYNeGBAhMNPD+gDwN1ykYe3Q3E5wEeF7Qxru1KlT6f3334+yXOD5X3zxBe244448PliY4MLAylsD+0HHTohHPAd/+/LLL8N/xxiwn3fffZf23ntvDv5788034x4DPO+ZZ57hz4cxjRw5MmpMW9oX2oJPmDCBHxs/fjw9/fTTUfv+888/afr06fx3tDGH6yIS7fM2NW1Oh0NvEVgacMxx/BCvg+8CxxDBwo8//ji/BhvGFrkPWMvwGXD8IsHvBZ1L0bsEbNq0iTuwwjqE+KGjjz6a95Ws1oaaVjctK2+m+RsaaGVlC3n9Qe58WZRh5VTMZKrLYKtZSFlrP6D8Jc9QZvEnZKtbyuIBsQyerFHUOnR/qtvhXGqYeCbZB+/FvRw6JR6CPk7lTK38nbLWvk/5i5+mnFVvU1r5z9yhksWDTkdBg4U3WCTQdIrdETo9KUYbKcYUdpHYB+1JDRNOp7opF1HzqKPIVTCN4xv6nXhA3AdqajSvp5Tq+ZRe+jVlr36X8hY/Q/mLn+H/Z5R+zX+zNBWrGSlKkC1HvpQCakgbQ8vNU+iL4C70VOuedGX5fnTcoum037cD6KQfMunqX030+MIAfbbORatqHCwecIQL0i00Y2gWHTFlAF2010i66+gd6MUzd6InTp1Oe4zO65FDkdBfI1bISMP83//+xxdELY4B5ltcOAEmvUGDBvFEBa688kq+8D/88MN0+OGH0zvvvMOtqdHHIVEiBybRnsBmMmyX3xbHsL5e9U9iwoJggKBA5CzaYqN2BlJmsfrGd+H1etkKBAGBx2ElgLvngw8+oOOPP55Wr17Nr9W+G3wnb7zxBme/oB4HXvu3v/2N8vPz+TvSuOmmm+jf//43T+aYRDFJRoJJFN/nc889xxM0WnkfddRRtHz5ct5v5H7wPG0Sbw/UCEFbcez39ddfp1NOOYWWLl3K4qC9fUFE3HbbbfTkk0/yYxAH559/Ph+LM888k+x2O6cNH3jggfyZkcmAc3FLIMZj//33p3POOYfHAlfSDz/8wFYY3F+zZg3H+0A8ARy3yIkfx1pLVYYg0sBYkboMUQLrCUQJBPTPP//M73H33XezNWrJkiVs0UhWa0Mmmlglk7WBqz9WkAVWhub1bL6OBLEDnsyRbGlA0OG2xDJw7Qd2R5SrVgZnVXQqJ4YBsWCyqS6JgJcMfifpA6FAdFyPdCbyodoj97kYwp01+2XzqaAv2prA8QkNW41NCJgzyGfJprpAKpV5U2iD00Lr7BZa20RU3uTmwmYqCILEcd+cBJBiNtCgLBsNyrbRYL5N4fsDs6ztVktFN86eIqFnBVaKACu0SGCG11a5GzduJL1eH+UjxgX11ltvZf8+JhgE5CWqBgTEw8TbvqKeYMWdB2/TigqiB1aar776imMNNOGA1TCOnzYJQRzg2J144ol8nCESJk+ezH/HZK+hZcUgxVaLgYCb5N5776Vvv/02bP3Ba2BhgBCIFBCYIDHxtgfEBQQNJnqAwmCYaBEb8NRTT4WfhyDb4447bqufH59Ha0WO5mCwUD3xxBNRFoXYfd1+++0sKLTHYFWBiMJngYDAOQdLyYsvvsiCAxaasrIytvS0x4MPPsiWisj3jexyiskdImBLLovTTz+d/v73v7O1Ac+FVeLzzz9nKwSAJQXjgvVEE5v4/eB7glBDXZW+HtuATIqaVg+3zEZsA6wNyVLsiQMgWzaQpbmYXRM6/+bJAit8FEtCHwcIh21xBXBrbXslmeybQoKhuo2pHIWYMKlhGavze9mcjsj+Ni6SUGOsLkv37FNBjPVhgaCKhfqoTIdY0LI8YMkmlymTqnyptNFto/UOC61pNdGGJj8H+fqD2msR7Ovb/H5YTKRbaHB2Cg2GUIgQC9kpfSsYOKECoiMlJmJXq9oEgU2IBnEksBpgVYpJ5bTTTmN3AcQEVqa77LJL+Lm5ublc8XPlypV8/4orruDJ8Ouvv2bXB8TElClT2n2vdevW8aQWKwxgxcAKPhJMou2BCbGiooKzbyLB/cWLF3d4P5HEurNwPzbjI3JfqCtSXFxM5557LlsdNFDcTAtmxHHC8Yi0fGzNbYb33N7zFFYiWIggACGwYA2CZQLfEcAxwncBC15svQd8pr5at6HejtLSLi78pCMd121IFmsDJiKYri0tJZz+GDmhc/VHFgywMgzrdBdLVTBUcClqBD2anDVtBEPAkkF+KzpQ6nilbHSqJaRjRYUWiKlmSnRdFcpeCbJLfA7u5IkGXZsFQ70aJNoOiPcIWHPJbsikclgTXFZaZ7fS2mYdbWxECrGH7QhE+A5gCdhsDTAb9GxJGMIiYbNYGJhlS5reK/3QLtXWjQBLQE+9d2dArAKsOljZDhw4sFPZF1ixwxSO1S1EBNwTWJG3ly0Bkz7A8+FiiiQ2aLW9qqKdpav2E7sv7bM8//zzUSILGAzb/kPWXD3bA77LE044gS0gEBC4RTE17bvF2BFfEi8mBC6RvlQlEo2skElR3eomlzdIKSZDcmRSKEF2GcAtobom1CqMGn5bvioYMkeya6AzraXZJcEplbAwbGpHMGRy4yu4GVgwuOp4HFFD1JvUfhJacyxucd13VrqdEwqtESKhPmRVqI+2/sQACw2qY7boM6jMk0LrXTZa22qm4maFNjU42VKmgmDF6IDFdKuRhoQEAt/mqIIBMQvJXsis3wsImIv6SmAWJsXRo0e3eRy+f6ym//jjj7ALA7ERiGmYOHFi+HlwaVx00UW8IXMDEyoEhOZHh+9eA6+DUIDrI9Jd0VmwmobYgXslcj+4P3PmzG3a5++//86xM5H3Y60isXVEMIb169ezyyAeOIaIp8DKXrNCYL9bAhYLWH/aq0OC4xp5TNsDY4KlBzEhCDZGjIPGjBkz2I0B99LWqsL11rbZDdzIysW9KYKKwqWlszPNfcpUG88SoFZ/XM/BdFGZDOhkmTaYPJmjWDh0Kq0RQY9ctKlMFQyOqviCIW0wV3fUhwSDtWltG7+8P6VALVudMYxbXidVHENYKNRvtiaE/h/bJCwMymhbsshnyaFmXQZtdKfQeqeVVreaaUOTjzY2OKnVjWMImwKsEtGWibw0MwsDWBSG5OA2hW8zbV3YdKyPkURnVP8FcSKIzId5Hj59mLsRRAjLAR7XYgIQqDd27FjOEkAMghZ0iKwOXMzhIoFJHStr7AP1HK6++mp2l+yxxx5cSRQTPyYyxA10lOuvv55jEEaNGsUZGPDhw/zfXqbF1kCzNbgoMCbsA9kTiF3YEpjk4caBywIBiIjxQHAujgXqiMAddMstt/AxhLhCsCNiN7YEnoeYkksuuYRFGQQDjivcGnl5eTR8+HAWddgXXE/tVWBFWXfESUBIIDYj0kqCxx566CH+HrVMFmTUoEndDTfcsNW06J4ArssWt5/bZle2IAXNRxaDoc9XiUR2BFsZmorJbN8UFZy42TWBIMhhHY8hQGCls0oVC62b2vavCLkkUJQJEfyY3NjC0FLaJtWT6zFwbQjVypAUFR9ZKNgjhEJ9B4SCnvzWbPJbcqgpJBSKnVZa02ymDY0eFgoI2o2NTeCXYsGRYWVrwrBcWBVSaGiOal3oKwvN7kSOSJKASRlZA4jqR5wCJiWkaWr1D7ASRiYGAgMhADCJPvroo/w3CA1MsBAdZ599Nq/uX3nlFQ5QhJkc7g6s3hG4hxUxgls7AyZuiI9rr72Wampq2LoBn39kBkZnwFiRnYOJe8CAAfT2229HWVrac+EgSBGTMQQNrDmY/CGsACb4Tz/9lIUArBnYH4I9ESvSHhBjcAfheMCaAuGFyR/N4AAEGIQW9uVyuTizIx4Qb3gNgjKRKRIJxozsFwShIgC0tbWVvy9kf/Q2iwSCIhucXqpqVgs+If0SVSKLMmx905TLTaLq1XiG5nVkckTXpwlYs1UrQ9YoNVOhI64JLtxUQ+aWjaE4hnLuUhlJuDATOlEaLWRyN7C1w9qwMrqglN4YdkugoBR89X3ZLaHzOcnorlMFgquORcIWXQ+aULDmUos+k4XCOoeVVjcbqXSDhzbWO0MZD9GZDgAxukgLhgUBAkG7RcaDtZOu5f5MtzbT6g6kmVZyg8kWGQpIcxTa0hPnuMsbYMFQjvLSLh8ZUPDJZuqbF2LEMzgqVdHQtC66BbZOx0IBVgZP1mi1BsJW96fwPrhIVOtGtjLEFm5i6wXSJbFZ88joaQ41yNrQpkqhmi0Bt8Rw8qajoJSpT7p/IBIMMWKh3WDGkFDA8bYbs2mTB0LBRmtajLShwU2lDU5uohb3pShOmGllcaBtsCwMykohs7HvWsMigXtwx2HZlJtmSe5mWoIgJAdYdyCDoqbFQ1UtbnJ6A5zD3idTMIN+tgZYmtaqxZUiJjKs8uEOgJUBQZDIXtgaiPZndwREQ8tGbmcdCZeiThvMggFpnBAtSPG01i+ndE7DVNqUrUYFSgiHPlUmGlUvOTahjsWCCbcQDjHHIwy3+s7goFO3OYfKfalU7LDSmhYTlVR4qLTeyem+8eITQGGGJSQSUlkkaK6HZMl46I2IgBAEocP44KZwqG6KWrtahx9BkQMz+1b+uhoEuYGtDCjsFOlPV4wW8mTAyjCKV/qYxLeeKVEeFgxGV230ExBUmTowVGNhCPnNGWSBwGgpoZSqP9taGVLy2SWBglJqEadePgFyAy50jYQ1oVa1KHCcQkO75ZuRNgrXg8+aSzXBdCpx2WhVq5XWl6tCAdasQBBNw6IbhwHUShiWm0rDc1NoWE4qDc1VAxpt5l5+nJIQERBCnyLJPG59rnYDLuzNTi+nXmbbzH3KDIw+BZprApN9ZNYC4g4gGNxZo7nPwxYnba2lNrsZNsYNfEQGRLgwU+oAMnibWKiklf2kVoeMtDIYLaqVARUo0RyrF3ev1NwPm4UC3A917cYp4LOhJgVcL62GbNrgTqU1dgutqw/QhnonldY7yOmNb1FINRtoqCYUclNpWMgFAfeY0DsQASEIQvvZFC4/Vbe42U2BWAes8gozbH3GTaH32tUqkE1ruVJj5IoYQZAQDIhn8HM76vY/E1bYauCjKhpirQbIlFAFg1qYCQIEz7M0raGM0q/atuBmK4MqGHxpAztVG6Jb4NiN5gihgNtatSlUe10jLTlqjIYljyr8abTOaaM1jTraUOakkjoH1bRGF1rSMOp1oawH1fUwgm9TOW2yL1m1+iMiIARBiJtNUdnkpjqHh/x+hVd9WX3ETYHJHlYGa+Na7gsRudrniTtrDAuHLWYtBH1kbi1nNwdEA1bdkYRbaoeqOaK+AIIlEUORuWE2me3lUVaJqFiGjBG9qvIj98Nw13ORqs1ioa7dNElYa1CIClurMZuKXSm0usVMJVVuKql3sAvC44/u86EBUTCcrQqqWMAtqjX25fTe/owICEEQwkWf0Ba4vFGNakc2RWaKqU8Eoek9TSwYYGng4ksRcOZE9hjyZEI0qL1e4qdsNnAwI0SDml7pj87ASClSKzmiMBMsFmil7CgnW92SuBUo1TTPkRzPgHTLHi/kFCrnrAqEGrXENVsVmuL2fOB+D1ZYFfI5VqEqmElrHDZa1xik9WV2tipUt8Ai0dYqAdcWXA4j8lSxMDwvlS0LaVaZcpIJ+TYFoZ+DojooMV3R7CaH20fWPtLQCi2V4SJQRUN19GSfNojcWWPYPdHeap8bXYWCGeMWZjKnhys5an0r8BrEMthqF7VtjsUVKAeFO2pCQPRsy+lGFguqZUF1QbSXKonsEggFWBVcljwq9aTSKlgV6ly0vtbOlgWHJ7oORqRVAUJhRF5aSDCk0IDMvuPmErYdERCC0E/jG2BlqGpxUXWLh9zeAKVbTXzh781uCk00WBvXkBF9ITR0OrV8dPZYVTTES7fkIk61avYFWxkq4hRmGhxRmCmH94uJ2Fa/jK0M8ZtjjVR7XXSmAmVXEipnDauCyVnLx4VdEDEFqhidjvwhqwK2VlMOrXOk0JpGhdZvtNP6WgdtbGgkf7AhbqwCCi6pYiG05aZKUGM/RgSEIPTT+AakYaLJFWr59+ZOmKp7Ip5o0JM3fTC5IRoyR8ct3aymayK9soQszRu4LHIkEAlqymREYSZujlVBtvKfOQCzK5tjbS+IS2BrghNiAW6IGk6fjJcuiQZaiPlgF0RKPjXqsml1KzIgvLR+k52Ka+xU2VwZ6iYZTarFQCNDFoWRIbEA8SCxCkIkIiCSBLRFR7dO9HZAyWmh97LPPvtwT5DHHnus297T4w+E0zAbHV6Ob8hO6b1pmAiEhGCwNK6OcU9ANAwhN2IassaQYrS1E8tQQubmEjWYMcrKYFLLRKNvRQYKM2WFJ2YIjM3NsVxd0xxrO4C7RHVBVIcFg8HTGDdeAZYQVSwUcM+MWsriks7rap1UvM5OxbUOqrOXxn2f3FQzjcxPpZH5aTQKgiE/jTtJ9mZLVL9CUVgIG7zNZPC28m8DtyjIxQHDLQ2kyzuTKG1Itw9NBEQfYGs/ZDSqwqQkCPHqN9S2eqi80UWtoaZWvTW+gVMum9aSFaIBroJI9wSLhrHxRQNXkiwjSwsm/5I2qYYczIiUSWRAcI0H9bKHgEJr3VK1OVZsXQijleMYPFkjQ8WkLN0gFmpYLGm3UWW0Iz+uKY18qYWqZcGWT9VKNq1uJFpX52CrQnFtMzU66+K+dmCmlQUCBMMoCIb8tH7dTbJXoCik9ztDwqCFDB71FjE5fN/b0n7jMLj1/H7Sedqp7plgRED0ASorK8P/R2tnNFxCq24NNIJCZ0lB0LB7fLSp2UeVzSgz7ae0XtrUSi3utJasDau5hXV4dR0R04BgyFj3BMSG6pYo4UZTUf7+sMVAC2bcbJGDO0KtPlnMPS8iV/Nok434CbyOsyYS5JrgYkxsUYBloXqLYgH1JVSrQiH5UwqpJphBq5sUWguhUGOndTUN1ORqG9wIfYhOkqNCloXRIdEgHSV7LvvFELIYsCUhJBI0i0JsK/Z4BE0pXOobwb241f5f4TFTVuYw6gnkbOoDoNWzBpqcwCIR+VgkCxYs4M6NK1asCLfOHjduXPjvzzzzDLep3rRpEzdcuvXWW+nvf/97+O/Y97PPPsudKb///ntu9f3SSy9xV050tJw3bx5NnTqVXn/9dW7PDe644w76+OOP6eKLL6a7776b6uvruSvo888/z+PVXCxoP718+XLuEDpp0iR66623eP8dHRf29/nnn9NXX33FHSkffvhhOuqoo9o9bk8//TR3HMU+MY4999yT3n//ff7bl19+yWNdtmwZGQwG2m233ejxxx8Pfya04MY4INieeOIJFmg77LADtw9Hkxl81lWrVvE+X3vtNT4+4KyzzqKmpibu6Pnkk09y23C0Cv+///s/bvcdDzwHrcTRVRSvxfugE6hmVUL77ssuu4x++eUX7rSKNuHoKorW67GBkYhxQLnpFeUt5AzqKdNmpoG9LDASE6ilaT1ZG1fx5B/pYkBRJXf2OLY0RFVkDHWxxOvMLevbdMbkSpKhdtooFx0uP43XOarCoiG2ngNW8oifQBXKhHSzDPpCgY0QClUsGtpzQ7BYSCkMiYUCqtfl0Op6P4uFdSshFmqowVkWVyygQiOsCaMLVLGAtMk+2cysD1sQDJ7mOAJB3WIrlbZBp+NzWBMGAYgESwYFTRl8i/vtNU7zNruIDD1jRRIBgR9yIH4nt4SDL72LL1iYiDCxYkJDa+pzzjmH5s6dy39DF0u0/Ibv/YADDqDPPvuM23cPHjyY4yc00Mb7kUce4Q1iBBPgyJEj6eabb6ahQ4fyPjGhffHFF+HXrFu3jv773/+y8EA3t3PPPZfbbWPC9fv93D3z/PPP50kSk+Cff/4ZntQ6Oi608UbLa0yemNRPP/10nlxzctp2RcSEjzbiEDqzZs2ihoYG+vnnn8N/dzgcdM0119CUKVPIbrezVefYY4+lRYsWkV6vj3IPYVza58axSE9PZ7GBVtsnnXQSvxYCSOO7777jTpgQTRAi+Cy5ubl0zz33xP3OcCwh+NCifODAgXw80G596dKl3PIcbdhxzNDWG23I8VxYnaKEQ1Bh4YBaDvi/1WKgbFuMqb8nCfo588HSsIrjDCJXXPDdu7PHs4siKr5Aa3KFSpLNJW3SLBHAiLgEuCawSg//lhAE2YoqkMVkbVoX/bpQDIVmaejSgk5KUM2GcFaFxQILljgBjtw0KqVAdUWkFFKzIZfWNAZobbWd1q5upbU1tVSLyplxxAL6PkAojClIo1EFaqBjX6jV0bdjENwsEKLEgac5bFXYqgUBjcJMEAWZFNQEglkTBxAKEAh97zuUdt5+L9HPD/fMYPe8lsi45UY9sbzyyit01VVX8Uo1XhDlt99+S/vvvz8/Nnv2bDr88MPJ5XLx591999155f+f//wn/DpMgJhMsbIHmNSx+oeIAL///juvzl988UWeQAEmOkyK2K9mgcBqHpM5LAPaCh/vXV5ezitvTKAY4957793mM23LuPA3TKIQMZhsY/nwww95jGVlZTzhb426ujoWXZi0YQHQLBAvvPACiyHtc5966qksEPbbbz9+7P777+fvBNYIzQIBEQWrBwQGgEXn+uuv53MS4iQyiHLjxo0sznAL8aABITVz5ky69957WeQcf/zxLGYi0YSD1x/kplbA7/PQptJS0qUXkK6T51aXw9kMZWRtWEXWprVRNRO4jDREQ864qLbY7NJoXq/GJcS4JjgAEimWcE0gmDEyVZPFBkTDOn5tZBAkV4HMGMauEI5nMFq7qIFUM1tCTCHBALdEvNRJjJOtCqlFfOuy5FNxs0JrqltDm52DW2OBHEKVRgiF0QXpfAuxIJaFBBD0hYRBc1gYbBYMzVuMQYgUCMGQIAhvfD+TrQuJEgjSzlvoMjDZaAwYMIBva2pqeAW9cuVKuuCCC9pM3lhNt7ePwsJCvp08eXLUYxBjONG0Ewz718QDgOgIBoMcqwHRgIn14IMPpgMPPJAnRwgEbXzbMi6sxPHe+GzxwPvAPYLJGQIDGywM2qS+du1athz88ccfLB4wVoCJHAKiM8cidgxw8Wjvox0LWDkgKjSXjQYESyAQoLFjx7Zxa0B0AVhS4DL5+uuv+dgde9xxNHHSZLY4+INB0pGOgyKxAO8pY1psrQUWDY2ro1b/uIhCMMBFgVW3ZjHg2g7N60J1FpA1oUQXc+I6CyNDPSY2X7JwUec4iDgdNZGVALcEWygyhrZr/u1MkCNbFRyVLBjgFonth8Ef32Bmy4jqhigiT0oBlTmMtKbGTmvW2GlNdTOV1FWw8IsFmQ9jCtNpbIR1QWIWugglyCm8UeIgQiDE9iqJB4QgLAiqMAjdhv7fVy0I24ucnXAjwBLQU+/dxSC+QENzEWiT4/bsY3v3i1gMTISwTCCuANaEb775hnbddddtGpc2jvbGAKvDX3/9xVYPTLwQC7CUIIYDaa5HHnkkT+aIq8DKH/uBcICroLPHorPHNxIIC8RgIHYFt5FobgrEnkB8ffrpZ/T1N1/TfffdR3ff/wBdfMllZIK7pReEN+g9zRzTAOEQGWeAbozurLHkzhm/OTAx1M1SbXKFuITojAHuV8FxCSOjXROhiRxigZtjoRJkZOYExEZkR81tDYIMBsLpkywYHJVtakGoH9rAWRCqZaGIhUNDMI3FwupNrbS6Gq6IFeTwtPV/Z1iNNLZQtSrwbWG6ZEN0RU+PCFGAwNTw/Q7EIUD8qcIgk3ubRAkFS8Z2i9BkRAQELk49bertJiZMmMDxEGeeeWb4MdyfOHHidu8bK/eKioqwGR6uD5jrIwM4EViIDbEUWJUjiBICIlHjMhqNvGLHBvM/hAMCQ2ERgWUE4gFBkAABil3F4sWL2b1jC8Ug4FhADAwZ0jZPG8cDFghYMbSxxAL3REHRQPr7OefR6WefR3fedgu99vJLdNlll1NPwpN501qyNawkU4S/HhUd4WJw50zgIk1sNdDcGZqLoU1cglZnYWSbOguqaCgmC3pdtJZGTQS40COeAXUhttZRsz2Q0aEJBdW6UB3XFQG3iyoUBrBYcJlzqKTBQ6urWmn1Srgi1nPWSyxmg56tCeMKVbGATeosbE+wYlNbgeBpardMdxidfrMoCAsF1cWA84hTdeU76RQiIPoR8MPDdYBJC5MqfPWIFUDcxPaCGAsIAGRSwLUBawPeC9kiiDtBfAMyJiAwMHnDhXDGGWckbFwIxFy/fj3ttddelJ2dzfEgsBRA0OA+3AMYE9woED833XQTdRWwYiBuAlYWxFJAvCBQMjI4UwOuCwSD4lgg+BXHoLa2luMsJu0wmQ465FC65uqr6YCDDuLnNjc30c9zfqLx4ydQjxAMcHdKa/2K6GDIUNoli4as0WqcAeISWkpZNJibEZfgbhOXwJaGzBFt4hLU9E61oyZiGyIDEdEymoMgs8ZwLYROXfQ16wILhgrVuhAnhx6WE18KhIK2FVGdW0erqlpp1ZpWWl1VTetqi8kXaOuKQGtqiIRxIbGA3hBGqeDYcVdDyMVgjCMUthaLgPodqkCABSEzSixwwGxva5vexxEB0Y9AJgTiCjDJI+sBQYJwLXRFEarRo0fTcccdx6mFyHhAGifSKAHiARBk+Oqrr3KKJyZtZBZceOGFCRsXrA0QIXBbIF4D2QzIAEGwphYQCZEDtwVEBdIsu6oYF4JY8X4QL4hlQOAlxtEe+KwIQr322ms56DQvL492nrkL7XvgweTxBSgYCND1V19F5eVllJ6RQQcedBA98FA3Bv6GXA7WhpVqXEPESg/Nl+CewIbo8nBcAqwFcDHEi0vIGh2KZzDFrwnBomFTjGjI546aCIQM2NTYkI6AfaIoFcSC2VEZ37rA/SHy1NiFtIFq905jJq2vd6qCYWkLrapaygW5Ykm3GGlcUTpvmnUhzSKX1S0SDITiEJrCmyoWmrbuakCwImcwhESCJhBCgqFLAmSF3pGFgbQzpNzBv4tiSEhPw2TRHlomQSx4bXt1D7Y7C0PYbrQ6EEiB7O9odSBwPDoLAiJ9fmRWBCmIksw6PcUxWmwRj9tNG7soCwOmfRYNDSui4hoQTKaJBsQocF0HzpxYG8qciI5LQEwCREO84kybLQ1r2ooGTu9E9cmxHetsiWPmaeRATFgWzPYKLmsdb5XqTx1A3lSIhSKOYWj26lksrKxsoZVVLVx7AdktUcdDRzQsN5XGF6XzNq4wgwZmWcUV0a5IUK0HRndjlFhgkbClaUdvIH/YgpAVIRTUuIT+GKzYL7MwkGqHiHSk/2F12lFg4o4ceEFBQYJGKAg9C/Q7YhyQUQFzOC6ryKgw9VSpadRraComW/1ydlVoF3rENXCAYs5Edj2oxaCKKa3iV9XFEBOXoPWqiMy2iI1p4OqTse6JlILQa5HemdUBd0QN97tgK4O9PG5mBNJEvWxZGMgWBr85iyqaPSwWVqxsoRUVy+KmUcKSwGJhQAbfji1IJ5tZJq+2loTGtkJhKyIBKbmRwsBv1YRClpryKK6GPkFCBcShhx7KW2eBYJCGUEJ/Ew5ol9wji9mQiwKiAZkUkfUaYDVw5SKuAWmmClsLstZ9FMfFkBcRl5DXVjSEqk+iFTdcG5GCY7OlYcuiAfsw2RG7EBIMjso2BXwgdGBR8CJuIW0QuyO8Ogu3qV6xqZlWVFbRysq11OzyxY1dmFCUQRMGwMKQwTUYelvp754pw9zKWSjsZuBbTSg0xy2S1SarAQLBkh1hTYBISJWAxSSgVzrrUGQHvmP4p2EeR00AofeC72hLPv7+BIpK9RXhwM2k4KKoXx7looCZ2J07gdw5k9jcD9dEZsnnceMS1Il/dPy4hKCPUy4RN4EmV1HVJyE40OciG+6JtpVENfeGal3AVsbdKGNXtYir4LgFFgsDuROly49gxxZavqqFVlaso1XVrW3cESaDjsYUpNOEARk0MSQYMvpxGiWOtWpBaNwsEtwQCY1brLIYtiRYIRIgDjYLBREJyU+vEhAIrkPVvp122okFBKoAIrANxX5mzJgR9zV4HrZI/40g9DZ6jXBAFkXLBrY2IG5BEwSYCCAEXLkTOa4BnS3Ty35o06tiq3EJnKWxkUUDrBWRQZRq9UkUkhpLAVgp4qVT2su5qRZuY+tD8D4sGVzjQXVJDGLx0eL204rKFlq+toWWVyyj4lo7xdZpQrDjxIEQC+qGtEpTf8uMgMuBAxYhDhpCbocGFgzxXD9R6Y+WTPJbc8LiwG+FUMgOuRtEJPRXepWAQDR8ZN0A9DAoLi7mhkjoaRAPFNVBj4TOkGTVu4U+JByAVjWyO8EkYatbyhaHyKp7MPG78iaRN30EuwZSahdtwcXQjmhQFJ7w4f5A9kXkZARrBlsacsa1KQqFWhBoww3rAkRDvGJNSNmEdQEporhFUGaj00vLyptp+fImWlZeSqUNbfP/89MtNAliYWAGTRqYye6JfuGOQN8GWBNCIoGtCrhlt8OWXQ44tmxFCIkDVTDg/xkSkyD0fgERD/QD2FKRHxQlQlOkSAtEvII9kRUEnU5nuMiPICSTcPD5Qit+RKoHfZwSaatfFlXoCW2BEQzpyh5HRl8rN7hK3/RTVHoj11rQrAXxXAwRJastjWvUoLmI/avuifEsULQPrVoYytgVgq1NC2ukU9ryw2IBxaUUo43q7R5aVtFCSxdX07LyNXEDHodk21goTIKVYWAGFaQneZaVElR7N7jrVSuCpzFkTWiIqrfR5mUGc9h6gO+VYxM4gDF7cwdTQUgWAYHUQK1nQjwsFgtvHQGlghGcqfUuQH0CScESuhq01OYtuDmrAmfZVhr6doloaairI1IClF72I9kiAyJ1OvJkjCB37kRSdAbOgshZ9350gytkT4R6VcRzMWyxZLXBzAGUeL03fSivWHU+JwdNhgVDrIVBp+OYBV/aEBYLiGFAHn+Dw0tLyppo2cIyWlreTBUx1R1xLNFUCmJhh0GZ7JLISknSyS/oC1kRIBDqN1sVthSboNVKsOSoYgFCgUVDjsQlCH1HQKDOP9o8a6AGAwQB2i+j+RKsByic89prr/Hf0Z0QNRpQ7Ac1GxADgdLD6GXQVWj1JNprwiQI20owZHUIhIQDTObdd6lW2IKg89opv+oXMgTVSRe+a1fOJPKn5LG7IH3TD1EuDK7TELI0xEu51NIuEdMA0cDNrjT0BlWU5IznEtSY0PD3tLI5LBhgoeiIYGhyelkoLClTBUOshQEZrSPz0miHQRk0mQVDJqVZe/3ap1Mgw0QTCRBmqlBo4FoK7aVDIuME7gbV1QCRkBO6ny19G4RuIaG/wvnz50cVhtJcDSh5jGh1FIhCGeHIEsBaNT5YB9AJEeWM4xWX2lZgcYBFA6miPl9Pty4UkgGHx0fVzR42tXuDQY7m766WywZXnVqEqbmE9GgmFHCSTq9XLQFpw9i1YGtcSYbKzat/ZFaEXQxc3EkXvx5E83rVRdFSsjkmIrJkdcZwMnoayNyykVKqF3AfidjJjl0S6UPIl47AR7gkrGT3+FXBsLiclpQ108aYGAaMZmR+Kk0elMWCAZaG1CSp7ggxproaVNeDJhYiXUBxyzNbNYGA21wWCUFzplgThOStRNkTdKaKliBsDw6PnyqaXLy5fAHKTjF3S/tlZDZYGldRSu0SMiK1MQQmF1c26jUYOIsCdRI01CwLFIIaT970YfGr+SEY0lHBfS6sTWui3BtqICUqT+bypIdMC9RiiC0LjRUwBANvaUNIQTyEP0ArKlpocVkzLS5rovVxsiTQL2LKYFUw7DCw71sYVIsCBEJdSCiot1FNxGJARgO7GmwQCLlhwRA0pohQEPpfJUpBSEZc3gCLBpjand4AZdlMlJPaNT/eLWF01pKtbglnUoTTI/UGcmeOpIA5i83faVV/bo60h7UgfZjqYkCDq3aC5JDvr5Ws5kj9SPdG+lCe2IzeZkqpWdCm4yF86oh58GYMZdGAfhhw4SCVctHielpcVswVH2ObTg3KstGUwZk0dXAWxzH02VbWHKOgWhJUkVBPBlgVtmRRQLaDZkmwQSSogkH6OAh9DREQgtBB3L4AVbe4aVODk83wmVYzDcpKcPBe0K9mUtQt5hV/ZMAjCighYJKbVvnXRpWDRj0HZFFw0Fy7rbjXkK1+ZVRcAwIs1VWvlcVCSv3yqNdxF03UYWDBMJQnPwgVrIIWrWmiRZtUtwSOTyR5aWa2MEAwTB2c2WWrpe7NemhSRQKLhVpVLCCTpB0jLlsUbBAKeSGhkMfCQYSCkCyIgBCErYAqhjWtbtpY7+SiRShKNDDTltAMHr2niV0UqBIZrqug03MBpaDBSibEPtSviFrVurjB1cT2u1UqQY5XsDYs5z4WHMWPugEBNykGKwWNFnZJRAU/cuBjIfe/gDWD0zL1BhYIyJRYtKmYFm5soqqW6EyJVLOBJg/OpGlDslkwwOLQVzKekD3CLb9ZLNSRwa2KhvayHrg5ly1fjU+w5YUsC3kiFISkRwSEILQDUjFr7R4qrXdypkCqGcIhgd0XFUWtElm7WA1cDK1sUVcBefowl6O0c7jBFadOqtUjkdnQnp8cvngIEVgb9D47WzVgYtcpQY7k13zsCMLk9zOnkweCgUXDUK7FALfE2ppWWriynBZubKTV1a1RcQxIVUXDqelDsmjqkCwuE43HejVB/+b4BN5q+TYySyUSxJGwRYHFAkQCtnyJURD6LSIgBCGGYFChOruHswNwazMZqSjDlrAJEe4ElJaGcIgsruS3ZHI6HuISIt0MiDVAPQfUXWgvriHsoqhbrgY7cnXCJtL7HaTozTz5BVCGOJQOyIWbMoZzZgUXjtLpOKtk4ZomWrCxlBZtamrjloBVYfrQLJo+JJtTLLsjgHRbgShggeBURYLqgmiIX5mR6yhkqtYEW37oNo9TYqUioyBspvf+4gWhm+FCTA4vlTW62GVh0OkTKhyQgplSs5BTJcPZDOg7YEohHVpVRwQ0opwwmlvB2hDERBb/A5DJvolFg6VxtZoiCL+9t5ndHsik8KQWhXobZJEncwSLBtRkgFCBxWVlVSstKN1AC0obaUO9s41bAtaFGUOzWTj0ymqPWqwCC4UaMvFtbftWBaOFfLYCdvv4WCyorgipyigIW0cEhCAQcXvn8kanWvVQIcpNtSSm2ZIS5PoKtpqFandL9UGufhA0mEnv95DBa9+cepk9hly5k7iBVHtmcqQGIh4CtRjMraVqpUJvCwUNFp4Q8Xq1a+XgkGgYEW6bDSvDglX1NH9DI6dYIqtEA+82pjCNBQO2sYW9zC0BFwRbEzYLBdyPbOAVZVVA4GlIJLBVISWfgqZ0cT8IwjYiAkLo1zi9fipvdPHmCQQpJ8WckCJQqptiGdlqF3EPA34s6GWRwLEIpFdjEBC0GGpwheZV7QbiBQMcCJla+SundnKNAayydQaeHLmrZkoRebJGcpVIuD1gZeBYhupWml9aSvNKG2h9bfTKHOmUsC7syFaG7F6TXglRoLogIBZq+BZZEPFcEGqsgioQ/BGCQawKgtC1iIAQ+iUoblTV7OY4B4fbT9mpZso1d31qIcoTp9QuZAsBr4wVJRSHYAqtfHWcOolIfm5wlbdDu30oeH/OGkrf9COlVv1BJmc1FywC8NkjJkJN3xxD3oyRPGniPVDwauH6JppX0kDzSxs4k0QDI4BlAYVosI0uSOvxrpVcrRFZEM7qsGBA74d46ZKwrKhCoYDLZKsuiGyJVRCEbkAEhNCvgJ+/plUNkGxy+jglc1B2Ste+CWIRWjdyfAPcFQCpklzZUacLNTRSrRyop+DKncxVIkkf/+eI/hbpZT9RWsVcMjevJ52iuhkQDIlMCWfBjuTKm8yWBlR+BKjL8OeaCvpzQwMtr2hhy0NkLAOsCzsPV10TPdmICgJIFQmaWKiO29Zbyw5RRUIBiwb8X1wQgtBziIAQ+k2AZJ3dSxsbHHxrMxpoQKa1a1fbXPRpNaVU/xWqpaBwQB9cFEG9ias0agIClgJ37uRwLEIsaH2NmIa0ijmhypNayWjVxeEonEmOgbuxgIDwQCOvNVWt9EfJBvpjQwMXu4pkcLaNdh6ew9uEonQyJiK+Y2sEfWqsgrOaTI4qVSy0Y1lA0KhqVSjkJl8QC5o4EgShdyACQkh6mp0+2tToZJcF9EJhurVLgwGRImmrXUIptYs4DoH99UgR1BH5zZlcRwFgslctBbA2GOIWj0JGRlrFr1y3IbIcMioYOgt3ptYh+5AXr0d7bn+AFpc20x8l9WxpgEUlvC8dcU+JnUfk0MzhOTQwSx1Dt6EE1QBHZxWZHNXcaIvbf8eJWQiYM7h6pi+1kPy2Qr7VjpkgCL0XERBCUvesKGt0coCkNxDkzAqzsetW3ughgf4QHN8Q9HHrZdRsQHwDov3ZMmC0kTt3ErnypsS1NqDIk6VpLdlqFnEtCBMsF6GKh7BYuHJ3oJYh+5E7fwqLBrvbT/PW1NLv6+vpr42N5PZtnpBTzAbaaVg2zRyRy0GQ3daQCnEd3hYWCWxZcFSxOyK20RZ/JlOqalVILQpZFwraLbctCELvRgSEkHT4AkG2NpSiZ4Xbx10yuzJA0uiopNSqeWRpVstBo+aAzu/gCR99IhDAh8JMzvypXCkyNraBK0M2riELGlg1rmVTPiZgmCywGkdcROugPclVuDMFzWmcavnHsir6bX09l4+OrACZl2ahXUfk0C4jc7ntdUJST+PGLcANURkWDPHqLCDrASLBl1rEGSGwLEjMgiAkDyIghOSqIOlQS083ODyUajZ1Xc8KLjNdQqnV88nUWsb9KbDihrUAhYiCKTC7W8idM4GtDQjyiysaGteQyV4WTkWEAEGFQwgNZ8EMdlPA1VHV6qFfl9XRb+uLaVVVdAvooTkptNvIXNp1ZC6Nyk9NbI8JBXEcjVzNUhMMRndd27gFiCZkQ7BQgHWhKFzRUhCE5EQEhJA0haDQ7ApNnYx6HRWmd1EFyWAgFBg5X22shMnUWcOpl97UgRzYh4nSmT+N3LkTSDFYomMaGtfw6yEWEFCJeAC4OpB2qbXBduVP5/TNTQ4jzV1bR78WL6LimPoM4wrTadYoVTQkMp6B4zfgirBXktlRwdYWvT+6URaApYQtC6kDOKgT4gF1JgRB6D+IgBD6fIttxDmg/DS6ZnZVnAMmUgQyIhNCbbikVjnExIl+ESjwhGBIuCl86UPDK21kT6AHhbVhNa/YVRdHNVdLRMdLdGp0Z40mb9YocuVPpeJgEc0tbqBfflobVTpaC4LcbVQuWxsS1f6aYxdYLJSzlQGfMTbQEb0yOBNCEwupA9i1IghC/0YEhNAnQV2D6hY3ldY72PqQZTOzeOiKIkbIpkCpaZSExmoclgMuCZ0zgRQzUjAns3DQelKojavWsqWBy1MjqNBn59gGpC6ikyaCIVHHAAGVJaYx9P2mAP0yv5Y21FeF3xsWkymDMmn30XlsaejyKpCKwgLB5Kjg5lwQDJGZHlHWhTQIhYEsFvDZ42WNCILQvxEBIfS5eg6NTrgrHOyuQAfIrohzQBCgreYvSqldHJpkK0nnd/IkClcDYhqcBdPJkz1eLYkc9JOlaR3XaDA3l7ClgVMX3Q38OmRieNOG8HORaVCWMpG+rM2hn+Y20vpatbiUJhqmDs6iPUar7ol0axeKhmCARQzHXNgr2MrAxazixC6wWEiDYBjIQkcQBGFriIAQ+lTfik0NLiprcnL/KdRz2N6CSDDhIzDSWruEYxuwOsdKHVkUfutY8maNZOHgTR/Gz4ewsDas4GBILTYA7g4EVZLi4xbZCkpI6w1UZxtJ37UOoc+XEq2uQYMsZ9g9AdGw55i8rhUNKNTkqCRzK6wLZRzwGJtKyZkRCHJMHUTetIEcwyA9IgRB2BZEQAh9ovw0rA2IEUAdBDS8spm3z6SOAMfUqj/JVreUYwCQUcGlodMGcwVEd95EzopAgKTe08y9J1DvAe4MDZSU5j6aSoDN/oiDcOlT6A/3UPqwKo/mVXgpqKidNWEfmTwok/YYk0ezRuV1iXsCwoXdEa1lZIZLgrNCNnfTBGoXzkHcshvWBVhDpE+EIAhdgQgIoVe7KxocXk7LRP+KNAvcFdbtclegzwLEgK12sZqa6Kxmq4E7cxSvxmFtcHHRJgPHNaRv/C6i7bYaUBg0ppAu4CK9X2HR4DdYabU7iz6vH0ifVKSRJ4DxecPZE3uNzac9RudRTqp5+y0McEXYy8jcWhZfMJjTyasJhrTBHH8hqZSCICQCERBCr60iiX4Om5qcnBRQlLF95adRhyG18g9KqfmLAwg5o8KSSa6c8eTNHEnOwh3JnTWWTK4aSiv/mdMvuXsmQItt1HnQGcjoauDAQ1geqh0B+qWlgN6tKqBST0b4vYbkpNA+Y/NZOGDc2xXDAJcE3BGtmzitMlYwcMBj+mC2nKiCIVMEgyD0UYKKwiVWYm8VUriAHBZV2m3k33sKERBCr8uuYHdFnYNaXT7KSbVsl7uChUPFb1zHAWZ+1HHQsiJQt8FZuBP5rXlkbVxJuaveiOoEGbBk8WoevS4srRs5ULLV7adVjQp9WltIcxyDyUWqQMhNNdPeY/Npn3H5NDx3G4s7cZZELZlbN5K5ZSO7J8IiJsrCMJi86UPYyhA0i2AQhO4icgIPxk7wwdD9kBBAYTvt//yc0PPxc9XmfPxy+f+sAnTc3A9/h5cRjkb1Ph7Hz1xHetKR0YDgaz0h/Mug05PJqNtul+62IgJC6DU0OVV3BVpRpyK7ImvbsyvYVVH5G6VW/s4reL23VRUOeVPYTYH4Bn3AzTEQ3HI7VPsAAYXurDEsHuC6QH8K1JcobnDSvAYrfdE0mNYqgylIerKZDHTA6Fzad1wBTRqYuU0WEgRxmltKw6KBgzEjCJpSWCzAuoBsEIxLBIMgbJ3ISRwLk9iVffT/o0VB3Ek+9H+e1EMTvI4n94gJPvQ3o17Pm57/r1M3Ayb9zSJBfZ2On6Nvs5/Nj21+bui2CxsB9moBMWfOHHrooYdowYIFVFlZSR999BEdc8wxW3zNjz/+SNdccw0tX76chgwZQrfeeiudddZZiRym0MOgq2RZg4tdFv6gsl3ZFWhwxcKh4hfORtD7HdzJ0g3RUDST3FnjyWzfRFkln7Oo0EAKoyt7PLfettUvJWvdcraErK9z0I8N2TTfP4UqKJd/wNOHZdN+4wpol5E5ZMFyoLOBj62byNJaysIh0uKhCRh2R7CFYSj5kdEhgkHoRxN+sJ0JPvLvkZM96dTVO9DBFsCzvU4V9Dqs0uNM9HodmXhS1/EqHrfqRK/+X5u4Iyd8Q3gfqkgwxEzw6nPV/fcXEiogHA4HTZ06lc455xw67rjjtvr8kpISOvzww+miiy6iN998k7777js677zzaMCAAXTwwQcncqhCD4CLQG2rhyfpRqeXsm1mSrUYtz0ds+I3Si/7kQMMdQE3WxycOePIMWA3ruOAug3Z694L93EIGq3kzpnIlSEt9jJKq/qdHK0ttLzOTmvqvPSnZwgtCs6gFkqj4bkpdO74QnZTZHcmGFJzS7RsUC0NsXEMqMOQWhQqaz2Me0hI0SahrxA5kasT/OZVfiD8WLS5P4j1fGjO32zCp6gJP2y61+vIEDLbY3JHszisLbDAwISP+9qqHC83hF6nTebq4xAJ0YKgv030iUKn4AzoBvBlbc0CceONN9Lnn39Oy5YtCz92yimnUFNTE3355Zcdep+WlhbKzMyk5uZmysjYHNgm9C4cHj9XkSxvcvNKAJMyftjbUgAqpfJ3yij9hl0V6BQJMz/cEI6iXXgytjauIoNnc8VFuARceZM59iGlbjEZa5dRWV0Lra+1U3GrgRYGR9NyZTiZLSm097h82n98YaeaVqEyJcSChUXDhjadKhHoCLHgzRjO1gaUxRaEngCm/djJX1vxh/+mCYCoiX/zqj+8IqfolTkmb22S11b4/P+QaX/zqj00+eP/ERN++Dm9zGyf7LR0Yg7tVTEQv/32Gx1wwAFRj8HycNVVV/XYmITEBEmW1NrJ7vFzO+rOugHCJaerfqfMki85VkEX9HJGgjt3CrkKppI+4KXUukXh1T5bG3InsXCAyEDxKEf5/2hZTSu3/S73Z9KC4FRapwymqUNz6eqJhTRzRA5f8KCxnQ47eTwe8no95PN4yedTgxuNRhMZDHpKCbRSlr+GMv3VZHVVR3WrZLcEuyRU0RCwZnXhERX6M5ETfKQYUP+v/l17XGln1a9N/jx5h1b8JgNRikWd7PEbMBk2r/bxGm3i5/+HJvvIx7RbIbnpVQKiqqqKCgsLox7DfSgil8tFNlvbLoS4qGPTwHOF3gl6ViC7AgIidVtLUAd9lFI1n7JKPiNz8wYWDkFTGjnzJpMneywZfHYOfNSAewBNq2CRQBaGZf1XVFW6lubV2qnB6aWSYBEtUGZQiz6HButqaEb999S4pJiefamaHmhqpOamRmppaqRAIDp9Ev26RmbraWyunsbk6CnDsvlzmMxmaglYqSaQTi3mIlKyhlJuYSMVFNXS4KF1NHzkaBoweAgZDOKqEFS0ST76tu3j+KcLSQAIAr1OrwbtRfjl4dM3G3XcVE6b+LVNHzHhQxzEm/xlxS/0SQGxLdx33330r3/9q6eHIWwBXyBI5Y1OzrDwBoKUn2bhi1mnUIJkrV1E2es+IktTMZdoRkEnV/Y48mYOJ4O3lV0G/FS9kTzZ47jhFRpBoaaDf97LtHrdGqqw+8mnGGi1MoTm+0bRpjXLyL74cXKXLqGl4Vjr+KSbiSYWmml8gZlG5RjIqFdIwYU9GORA0HX1flpbH6R1DR5q9iBAs5aI0Pfi1zb7MppMNGTYCBo5ZhyNnziZxu8whcZPmkIFRQPEN9uHUWIm/4B2P+L/2KID/7To+pD5PzSJw+wPK4DZoG6qK0CN5A9vmPQ5EDD6MREAQr8TEEVFRVRdXR31GO7DDxPP+gBuvvlmztqItEAge0PoHaCSZEmdnYMlM61mruvQKRSFLI2rKXvte2StX8UWB8VgIXfWKPKlDeNUTBNaUIeKKqGKJNwUDY1NtPHr96i1dAF5SU+KNYO8ipGWKuPoz7oUqlz0EzmWPUpBVwvlFRTShJ13paKBg8JbQeEAyszKpoJUHRXqGyk3WEs2b0PU5B6wZHARKk/GSLXyY0Ahe2sL2VtaqLW1mZobG6mmupJqqiqptrqKqivLaeOGEtpUup68Hg+VrFvD23dffBreZ05ePk3bcSZN22lXmj5zV5q4w1S2aAg9g7b6j9pCbgO/JgZA6LRgMQDfvyYEQpH+JrMqACxGbIbw49rEvznlL1ogCEJvplcJiN12241mz54d9dg333zDj7eHxWLhTeidqZmlDQ4OzirKsHX6gmhq2UjZa97lDpmIW1B0RvKia2T6YFymSR9Qaybgfn3aOPp5eTn9+d93yLPpeho3MI2yBgwlvTWLnIqF/vKNoAXFjZTpXEa7DMmhsaceSCNGX8ruhIzMiJgEJcjloi3NxWRpWk0GT/Pmv+nRubKIPFkjyZM5igLW3KgUS5OeKDsnl7ctAYtFVUUZla4vprWrltOq5Uto1fJlVLJuNTXU1dL3X33OG7BYrLTjLrNo1z33pVl770tjxk8SC0UXWAgw+Qcj/x/xmGYbwHNRsEezDKirez1ZTHARxBEDISGg3uqibuU7E5KRhGZh2O12WrduHf9/+vTp9Mgjj9C+++5LOTk5NHToULYelJeX02uvvRZO49xhhx3o0ksv5dTP77//nq644grOzOhoGqdkYfQ8dXYPldQ5qN7upewUE7fc7gwGVz1lr/kvpVXMZeGAyzlXhUwdQMFQ0ypkV5T7s+mzhRU0+4ffaPXC32nW1JE0a8oISs0t4P20KKm02DeEzJmD6OhdxtOEsaNIj9kglmCAAzHR+wLCQe9Tu2Zq7hBkTHgyR7K1IWhKpUThdrlYTCyc/wctmvc7LZr/BzU21Ec9B9aSPfc9kPY9+HDadY99yNqOZa6/oQqBoHob2Owu0MSB5jIIWwi0CR41AIy6kBjQk9UUEgShegCbhcDm+yIGhGSmpRNzaEIFBIpCQTDEcuaZZ9Irr7zCBaI2bNjAz4t8zdVXX00rVqygwYMH0z//+c9OFZISAdGzVodN9U4qbVTbbeemWjplddB5HZS97kNK3/SdmvqoBDnOQe0imc81E+qb7fTdinp65asF9NeiZZSZkUr77z6ddpkwkMy2FN5PnZJBLbnTaepOe9KOw3PjjyHo51RLa0g06PybA3GRscGuicxRLB56qt01fprr166m337+gX6b8wPN++0Xcrs2ixtbSirtvs/+tP8hR9K+Bx9GKSmJEzc92YlVcxWEb0OPafM4LmAcM4DJHpN8qLyvJghgJQgXCopIKVSrBUq8gCD0SgHRE4iA6DmrA+ooIOYhO8XcOatD0E8ZG76grOJPuF02ek6gcRX6UKAio9PpoiWr19MbP6yg/81dTb4gUd6AgXTQXjvSjiNzwhNAoz6PLKP2oJ12nEkDslLivg8CLS2Na7h8dWSfCWRyeLJGcVEplI3ujcWcEDfx17zf6cev4eKYzW4QDasthfY7+HA67JgTaLe99iOTafvbhScSzX2AAFu2GIQEAqwIXFwwNKdr1gLVEqCWD4cLwYoMA84y0IeFATIOIBZN7HYQUSAI24IICBEQ3W512NDg5EYvuWmdKAilKFzLIWfV29x1UhfwESkBtax0+ggqWb+e5vy1il7/fjmtrAnwSnPoxGl05P670sh0L+l1av8KZ8pgyp24D82YMo2sscJFszSwaCiOFg3mdE7v9GSPYStHXyoZjZ/tyqWL6bsvP6MvP/mANpWWhP+GGIwjjz+Fjjv1DM7y6Imx+WPEgS/kXtAiDCKbAmHCh8UgxWxgiwFEAWIMIoWBJhTEfSAIiUUEhAiIbqEeVgeOdfB02upgblxLuSteJWvjap7UERCJAMUa/UBavnIFzZ67lL5a0USlzah2Y6TdjjyVdps4iAZTNenYn01kyB1Fg6YdSKNHj4ueWBAI2bqJ9w0XRaR7ApkaqBfhzh5DfpSNToIJCT/hpYsW0OyP36MvP/mQAzE1pu+8KwuJg484tsviJbR4A2SdaO4ECAW1CZEqEFQ3gSoOLGYd2UxGthqYWSCoVgJYECAKkKIoFgNB6B2IgBABkVDQnXJjg4MrOGJBiWqSHbU66F0NlLvyVUqr/J10PhcXfvJbc2mtK4sWLF5KX85bR79sDFC1Q6H8IaNorxPPo2FpLhrs38STEyac1IETaMSOB1HugOHRPSec1WRtWMXCIbJ8NNwT7uyxLBx8qQOSQjS0h9/vp7k/fksfvPUq/fz91+ECWFnZOXT8aWfRyWeeS0UDBm1xHxACsB5oAoFv4VoIWQ+0GgVsHdCrrYRhPUCsAeIOIq0GIg4EoW8hAkIERMJodHhpPdd16GSGhd9D2Wvfp8wNX5De00IGbwv5jKm0rNFKvy9aST+urGHh0Ogm2uWg42jsXkdQtms9DVc28ctTTAbKGTaZhu90MFmyBoR3q/c0kQ2ioWEVGdwNUYGQnqwx5M4ZT760QRyA2d9A/Yn/vfcWffDWK1RRph5HVL884NCj6NRzLqIJU3cKCYUg+cLZCkiQxeSvIyNiDCDYLBAIRrKErAcWg4FdDlp1Q0EQkgcRECIguhysRMsanbShzskpch3OsFAUSiv7ibJXvUUmRxULh4CipyX1Bvp+wRr6tcRBczf6yW9Kp4NOv5Syxs8kW+1fNJrK2eKQlWKhwpFTafC0/YnSCsN9MJByaWtYSabWzYGEXIESgZDZ47nnRG8MhOzu7wyVP91eP8359gt6/7Xnacm8zVUxp86cRWdccAXte8BBlGY1hjIW1PgDLQ5BBIIg9C9aRECIgOhKWtw+Wl9j5x4WmTYzpXWw5TbiHPKWv0zW+mXcDTPg99GKeqIvFpTS76Vu+mWjnzKLhtMBZ15NvtwRlFY9n8bpVFdFUYaVBo6ZTrmT9qMgUjgVhcytpWStX8FtuZGpweh03KjKnTOBPFmjuUplf0LLZMAG1xLcDUEKsmtJtSCoIgBWBHxvxatX0MvPPUXvv/s2+Xw+3sfUqVPppptuohNPPFH6cwhCP6dFBIQIiK4AJu3KFjcV19jJ7QtwDwv4t7eG3t1EuStfo/RNP3BaZtDrpOKGAH2yoIJ+KfWyxaFo1CQ68NybqUaXTdl1f9IE3UbS6xQampNCg8dOp7Sx+3DtB3ZR1K9g4QDrhYbflsuiARuyKfqLNQEiAbcIWoTQQjMluBXMBgPHIqRZcWvk2AOumBgqnxybvYACbo8++ig999xzXPANTJgwgW677TYREoLQj2kRASECYntxev1cTbKswUmpFhNl2kwdq+dQMptyVr9LJkcFkddB5c0++nxxNX291ktzSv00YvJM2ufMG6jYbaOCxgW0g24DN6UamZdKQ8dOIdOovTmoEg2zbHVLuEKkhmK0sGBw5Uwkf0phUgZDRgkFWBSCQZ784S5i94JBT+lWI6VZTCwQtHLKcDdsS++ExsZGeuqpp7hKLP4PJk6cSLfffjudcMIJ8St3CoKQtIiAEAGxzeB0qEV6Zo2DGl1eKkiz8uS0lReRtW4p5S19nmwNK4i8dmpocdH3qxrovWVuFg5DJs6k/c69hVa0mqioeSFN0a0nq0GhMQVpNHT0JKIRe5GiN5OtfhlbG/R+V4SLYii5cnfg+AbS96r2LdvletCsCailgSwHznAICQVs6VYTux1UoaDGJ8SzJnTV7+bxxx9nIdHU1BQuP//AAw/QgQce2OXvJwhC70QEhAiI7UrPRKAk0iVzUs1bnawMrgbKW/YipW/6lrMr7A4HzS9potf+ctJXxQEqHDOd9j3vVlput1FR6xKarltLqcYgjS1Mp+Ejx1NgyCzuqBlrbYBbwpU7ibegJZP6MohP8PiD5PEF2KKAZAdkOphRbtlkoHSLkcWCFULBhGJKqqWhJ4omQTxASDz88MPU2oqW5EQHHHAA3X///bTjjjt2+3gEQeheRECIgOg0zS4fxzpUt7hZOGwtPRPFn9JLZlPeytfI6Kgit9NJ66qa6fW/7PTeCj+Z8kfTIZfeRSu9OZTbvIx21q+mTKOPxhel07Dhoyg4YAYZPI1kq1++uXmVTsdNq9COm7Mo+ljqJX5KCGKERQGCAYIMaZGomQALQopZzy3NUywGshrVqosQC72xumJdXR3dc8897N7Qgi1PP/10uu+++2jIkCE9PTxBEBKECAgREJ0OlFxX08oTXn6adcu+dEUhS8NKKvjrcXZX+D1Oqqpvpk+WtdITf3qp2ZhPh19+N5WYhlNGyxraVb+Cco1uGl+UQSOHDqFg7mgyepq5rDQ3PQgVenLl7cDCoS8FROJ4QSy4fYhVCHDmg9rmGcGMRsqymVkgWM0G7uHQF1Mi0SEXgZVvvvkmCySbzUY33ngjXX/99ZSSEqffiCAIfRoRECIgOgQyK0rq7LSpwcUWh60FSuo9zZS75D+UVfoFkcdOTS0t9FtxM93/s4cW15vpsEtup4bCnUnftJ521y+jIqOdJhSl06hBBaRLH8BZFMaIYk9Iv3TlT2OrQ2+v2YDgRnfIDeEJqD04kP1gjRALyILgLdQSOplYsGABd8n9+eef+T465SI+4tRTT+2VFhRBELYNERAiILYKumbC6oBblKLGqrldggFK3/AV5S97notBORx2WlvZTI/NddJ/V/hp1okXk3HHY8nZUEl7GpbSMEMDuyrGFmWQMSWLdH4X6UNNrNAaG5kUzvxpFLDlUm8EPwm4ICCwIBpQ2hnlm2FNQPZDVoqRUixGFgrYOpLamgzguLz//vtsfSgtLeXH9t57b3ZzTJo0qaeHJwhCFyACQgTEFl0WqCi5vtbBmQB56VvuY2Fq2kCFf/2bUmoXkc/topr6Jnp3cSs9MNdLhTMOoiFHXEF1La20u345jTeW09iCdJqUbyKTNUV1UYTiGAKWTHIWTCd3zkRSjFbqTeA4sFhg60KAdBzgqLaORjwILAwpJiNbF7aakdIPcLvdHGSJGAmXy0VGo5GuuuoqdnWkp/cdF5QgCG0RASECIi6YINfX2mljg5MyrCaO/G8PNLrKWfEqZa/9gHSeFmpuaabfi5vp1u89tNE0gqadfSdV+620q34lTdWvp7H5KTQ1j8hiNpBisLGlIeymKJiuuil6SVAk3BEuX4A3ZEgYdHqymVXrQnaq2t8DlRshIMQ83z4bNmxgt8bHH3/M9wcNGkRPPvkkHXPMMT09NEEQthERECIg2ndZ2L2Un77l2g4pFb9RwaInydxSQm6ng0qqmuixXx305hobTfn7P6k1dxxNUdbSTP1qGpNjop3y/ZRqCFDAmk1BYwoLBXS/dBbuqBZ86i2CwRsgf8gdAWtCps1IWSlmSjXDJaF2kxQ6z+zZs+mKK66g4uJivn/sscfSE088wYJCEIS+hQgIERBRLovyJicVw2UR2LLLAjUd8hc9QellP5LicVBdYxN9tqyZ/vVLkKyzziLLjCNpWLCc9tAvo3EZPtol30dZBjf5bQXsooDVAZkUcFUEzRk96pKAYEA1TdRdMLKFwUBZNhNlwSUREgx9MSuitwJXxt13300PPvggtxTHbw8pnxdddJFUsxSEPoQICBEQDFIM2WVR72TzfEZ7WRbBIGWUfE65K17mIEmnvZWWbGym++Y46DfL7jTg8MspW++kvQxLaJKtkXYt8HOGhS+lkPy2fAoabeQsmEGu/Kk9Et+AUxiplBAMCH6EQLJZVAtDdoqZ0i0mEQzdxJIlS+iCCy6gP/74g+/vueee9OKLL9KYMWN6emiCIHQAERAiILgwFFwWNS0eyk9vP8vC1LqJ8v96jFJr/iLFY6eKumZ6568merJkKNkOuoZSs/NoD/1SmmHeRLMKvDTE1MJuCV/qAApYsshZuBO58iYR6TvQK6MLQeyC04s4Bj9bWVBrAT0i8lKtHPSIEtAS8NgzBAIBevrpp+nmm28mh8PBtSNgnbjyyiulSZcg9HJEQPRjAYGvs7rFQ2trWkMdNNspDBXwU9ba9yhn9TtkdNWRw95Kvxc30kPz9LRy3PmUPmEP2km/mnYzrKbdcx002tZCii2HvGlDyJ9SQI6imZyO2V31G/C5VLeEmilh1CPo0Ui5qWbKTDGxlQFuCqF3BVmed9559N133/H93XbbjV5++WUaN25cTw9NEIR2EAHRTwUEggU31Ku9LLD6hvk+HubGNVSw8CmyNiwjcrfSxtpmem1+E72jHESBmWfReFM17alfRHtlNdKk1FYyWlPJkzGcfOlDyFG0C7lzxnVLRgViGeCWgGgIoGGXSc8Fm3LTVLcELA3JVrAp2cDl5fnnn6frrruOe2tYrVaOk7j00kslNkIQeiEiIPqhgECGAawOFU0uFg7xelno/B7KXv0OZRZ/TCZXLTkdDvp5dT09UzKQlk++mgqzU2g/w0LaJ6WUZmTaKcViIm/GMPJkjiL7wFnkyR6bcOEA14TDo4oGzC/4HLAyoB4D0k7FytA32bhxI1sjvvnmm3CDrpdeekn6aghCL0MERD8TEI0OL4uHBoePCtItcYMF2eqwCFaHFaRzt1BpnZ3eWeKkD7POJO+IPbj09EHmpTQzq5VybTrypQ1mF4Vj4Cxy54xPqHCAaLC7/eT0BbjxFFwT+WkWykpRAz8l+DE5CAaD9Mwzz3AlS2Rt4HeKKpZo0iUIQu9ABEQ/ERD46qpa3LSmupV8foWDJWNTNHUBD2WteY+y1n1CRlcVeVxOmrO6gd5smkILxlxIE8zVdJThd5qVWU+DUxUKpuaTO3citQ7eh6tGJirGAaKh1e3nIEiTUc+FrSB+0I8DlgZxTSQvq1evpjPOOIP+/PNPvn/aaadx0CV+t4Ig9CwiIPqBgEC8Q2m9k0rqHGQx6rkgUiym5vVUsPgZstYvJ4O7id0b76/006dFF5AvYygdY/iF9k7ZQGMygmRKSSd39jhqHXYgOfOnJiSrItLSYDLqWDQUZVjZypBuMZJeREO/AbUi7r33Xrrzzjs5a2PYsGHc8XP33Xfv6aEJQr+mpRNzaLfYhmGmHD58OAdQ7bLLLuGVRzxeeeUVLh8cueF1wmaQXbGqqpXW1bZy6mIb8RD0Uea6j2jgr7dRSvUCUhwN9EtxMz1cNpHeGXsvzciy07+sb9LfctfSpDwjUf44qtvhPKqZcTWnZXaleEAgJFJKK5qdXA3TatbThAHptNPQHNpxaDYNyUlhq4OIh/4F+megdwa6e44YMYKbc+211150++23s7gQBKH30zbSrot599136ZprrqFnn32WxcNjjz1GBx98MJsxCwoK4r4Gqgd/15B+BJtpcftoTVUr1dk9VJBubRMfYLRXUN6y5ymlZiGnZzY6/PRxsUJf515AlJ1K1xv+SzPSm6ko3UyBtMHUMOwgsg/Zl4LmrmuCBKOWwxsgu8fH95ExMTo/Xc2eEPeEEAFSOxctWkSXXXYZvf7662yR+P777+mtt96SAEtB6OUk3IUB0bDzzjtzkx0tkAoXhssvv5xuuummuBYIdPZramrapvdLZhdGbauH4x2Q2timvoMSpNSyOZS78k0y2TeRzttKy6u99Ll9Av2ZeQAdbJhPu5rX04hsM1lSM8g+aE9qHnkk13ToSssI4hp8wQBnTyAQEqWzYWGQQEhha7z99tt04YUXcrpnTk4O14w46qijenpYgtCvaOktLgyv10sLFizglK3wG+r1fP+3335r93V2u519ohAaRx99NC1fvrzd53o8Hv7AkVuyAY2HFtzLypvI5w9SUYYtSjzoPU2Ut+RZyl/8LFma15HP5aBPSwz0qv4oas0eTVcb36ejsjbQhKI0ooHTqXLmLVQ/6ZwuEQ+ai6K8ycUWB1gZpgzOop2H59D4ARmUlxY/K0QQYjn11FNp4cKFtNNOO1FDQwP/9rGYwG9cEITeR0Kv7HV1dRwgVVgY3ZER96uqquK+BlXqkB/+v//9j9544w22WMyaNYvKysriPh8Ne6CWtC3ZzJ4IliyutdPKyhYyGwyUm2aJ+ru1bhkN+ONeytjwNZkcFVTe4qfXKgfT3MxDaQ/TajrdMpdmFJkos2g41U67lKpm3kze7DHwC2133YnqFjfVtLrJqNfR+KI02nF4Dk0ZnEkDMm1kNUm9BqHzjBo1iubOncttwsHjjz9Oe+yxB5WUlPT00ARB6E4XRkVFBbf0/fXXX9nXqXHDDTfQTz/9FG64syV8Ph9NmDCBVyd33XVXm79jdRK5QoEFAiIiGVwYcAmsq7Gz9SEnxRJVREkX8FJGyWzKKv6EjI5KIp+Tfq8x0nz9FErTe2myrpiGZBgpJzubWoYdRM1jjqOgKXW7rQ12j58tDRAIsC4UZFi4cJVYGYSu5rPPPqMzzzyTrRFZWVn06quviktDEHqRCyOhQZR5eXncPKe6ujrqcdwvKirq0D5MJhNNnz6d1q1bF/fvFouFt2QD1RhXV7XyCj82WNLorKHsVW9SauWfZHTVkN0TpK/r8qnZXEDTdCWUp2+hEYW5FCiYRBWTziZfxrDtGovXH6Qml5etIRlWM40vQkCkhQMiBSFRHHHEEezSOOmkk3ixAZcGilDdc889fF0QBKFnSeiy0Ww204477hhupgPgksD9SIvEloALZOnSpTRgwADqLzQ5vbS0vJmDJhHvEBYPikK2mkVUsODflFY2h4zOaipu1tPs5qGUZtHTNFpDI21OGjliDDXNuIQqd/nndokHiJiKZhc1urxsbZg2NJt2HJ5Nw/PSRDwI3cLQoUNpzpw5HAsBHnroIdpvv/2osrKyp4cmCP2ehKdxIoUTZkgERs2cOZPTONHi9+yzz+a/oyId3ByIZQBI49p1111p9OjRnImBCwZyxFFHvz9Q0+Km1dWt5PEFaUCmNZzCqrksMktmk9FRQUGPg35pSCWnLoVGG6rJ6HfSiKI8Cozal8onnElBy7a5b4KKwpkUcFPAZTI8N4UKM6ycSSHptEJPgIXIo48+yrEQ55xzDv3yyy9slfzvf//LtSMEQUhSAXHyySdTbW0tF41B4OS0adPoyy+/DAdWoslOZFe+xsZGOv/88/m52dnZbMFADMXEiRMpmVEzLVzc08Kg0/OkrWFw1XPb7dSK38joqqUml4/mteZQvt5OGUod2RQvDZowgxonn0uuvCnbFCAJ9wSyKdAqG3UbJgzI4NLY8ZpyCUJPcPzxx9OUKVPouOOOo2XLlrEl4oEHHuBFiohbQeh+pJR1LwDBiRvqHLS+zk6pZmOUe8DSsJpyVr1F1oaVpHM10voWoga/mXKolVp9QSpMTyXLzn+jprEnkmK0blN56Uanl8eQnWqmQVk2TsW0GCWLQuidwIKJehEofQ1OOOEEztxKT++6YmiC0F9pkV4YfUdAYAIvrrHThnonZVoNtHr5Ek5/zc/Npj3yWyln/adkat1IPmcrrW7WUyq5KEg6cjmdVDR2R/LMupa8aLPdSTz+ADU51UqReWlmGphto9xUi1SJFPoEuGyhARfSPZGpBQvlxx9/TGPGjOnpoQlCn0YERB8REEjTRGXJ8kYXrfjrd3rskX9TTXU1pRgVOnm0m44eq6Opw/MoqNNTlVNHWTo7NfnMFPR5KW+/S8k56RRSDJZOvycyKmDyRffLgVk2ykkxSy8KoU+CgnRwbSCoEr97WCUOP/zwnh6WIPRZek0lSmHLGQ4rKlqoAuJhwa/0jxuvZ/FQlBKgy6c46diRHso3e6m+xUl2l5uydXaqcwTJa8qmjDPfJMeUMzslHiAcqlpc1OLxcaEnNLKaPCiTsytEPAh9FWRzodotunjignfkkUdyvRhkewmCkFhEQPQACFZcXtHMNR6Wz59Lt97yD358Uo6frpnqpH0Geqkgw0zpWdmUYQ6STkHrbjf5Rx9KGee8Rz5UkuyEqyJSOMwYkk2TBmZwvIMEngnJAFK80YDrkksuYdcGArYRF4GeGoIgJA5xYXQzaGm9qrKFnN4ALZv/K914w/Xw6LJoOGWMh0ZlBignM43S0eKagtTkM9Jf6+uJ9rqeZhx9cadiK/BeoCjTysGRWSmSiikkN2jAddFFF3EfnkmTJnFJfJTHFgShY4gLoxfXeFhW3kwuX4ByU4308MP/JpNeoZNGe+jsCW4al6PQwLwMyrbpSUcKlbfq6PXfauiauelUax3R4XRMWDbqHV5Ow5w+NEssDkK/AfVlUCYfVgk04UMn4G+//banhyUISYkIiG4ARh50q4TbAvYelKZevGgRuRoq6dwJLjp+pIdG5xppaF4KB1D6FD0tqvDSbV830OMrc8juN3JZ8K0VgILFAeIBvSmmDcniGAeUnBbhIPQnUIhu/vz5tMsuu3BdmYMPPpgL2CWZsVUQehwREAkmGFSotN5BKytayGQwUE6qmR93Va+jSya76JChXhpTYKEhWSYy6HQsFj5a3ExXf+2ln+pziVBUqrCIpk2fHnf/uCgipqKy2UUWk56mDMmiqUOy2PogwZFCf2XgwIH0448/0llnncUBlUj3RDVbaQ0uCF2HCIgEguJM62vttKbaTmkWI5eDBuamYtrd/yvtN9hP44pSqCBFRwGdniqdBnrou2q6408blXk3F8W59rpryaA3xG2pXdHs5hiKiQMy2F2BQEmp5SAIRFarlQtMoQw2qt3i//vvv3+b5n6CIGwbIiASBIIY11S30LpaO2XZzJRqUUtC22oWUu6K12ioZy2NKbRyloWbTLS8VqFrPq6iV0tyyU1qeqbeYOBSvfvtu1+bfVe3uMnu9dHIvFSaMSybhuamSvVIQYgB7js04po9ezYHhs2dO5fjIhYtWtTTQxOEPo8IiASAmgsrK1uotN5F+WlWbkpFSpDSNv1AOaveJuOGH8ndVE5WfZCaA1b6YZ2LLv64iX5tLSKdfnPviXvvuYf23/+AKHdFo8NLta1uNUBySDaNLUqXfhWCsBUQB4GW4GPHjqVNmzZx3QhUrhQEYdsRAdHFOL1+Fg8VTS6u9Gg26omCPsos/pSyV79LupKfyGuvJ6MSoApvKr27oIH++buNNgXzw8GOiHl48KGH6IADDozaL1prY3+Ic9hhUCZnVgiC0DHGjRtHv//+Ox144IHkdDrp2GOPpfvvv1+CKwVhG5E6EF353m4f13hAc6rCdDUWQed3UdbaDyij+FPy1hST4ndRgAxU6jDR+3810qRLXqFpu+xOixYu5B4YyLZAwKQW84A4inqHhxtsDslOoSE5KWQ1iatCELYVv9/PQZVPPvkk3//73/9Ozz//PFksnSsLLwjJiPTC6AEBgRTK1VUtZPf4OU1Tr9ORwd1E2Stfp7T1s8nZWE3GoJtayUYbGnz09godHXPX/2jwsOHtfxaXj+McsL9huanhDA5BELYfNOO64oorKBAI0KxZs+ijjz6igoKCnh6WIPQoUkiqm0FA49LyJq4uWRgSD0Z7JeX/9TClrfmQ7I2VLB5qlXRaWeGgN0oH0plPzmlXPCBIEmmZfiVIE4oyuJ6DiAdB6FpQ+vrLL7+krKws+vXXX7luxLJly3p6WILQZxABsR3AeLOpwUnLKppJp6C7pZXjGCwNK2nA7/8ic8mP1NrSSIagn8r8mbS8pJa+0u9Hlz7xGaVnZMbdJ2o6oBhUYYaVpg9VsyuMBvmaBCERHHDAARwXMXr0aNqwYQNbIiAqBEHYOjIzbVeNBwetqmohm9EQDmhM2/gdDfj9LgpWLiGHowUqgzZ6U2nxmnJaM/4qOve2p8loNMa1OiBIUiGFAySxZVjVuhGCICQ+uHLvvffmBlxoB67FRwiC0D4iILYBr1+t8bC2xs6TfDom+oCfcpc+T/mLniJ3zXpyupzkIwOVOYw0b1UV+Y96mo4464q4+2t1w+rgoaIMK5egHpydIsWgBKEbyc3Npa+//jpcufLyyy/nDQGXgiDERwREJ0H1R63GQ16amWswGFwNNOCPOyl9/Wxy1JVx4KOPjFTR7Kdfi1to8KX/o533OyKuFQPxE7A+TByQzk2vWIwIgtDtmM1mrlaJ1E4AK8RRRx3FQWWCILRFBEQn0zQR7wBXQ2G6hSs/WmuX0cDfbiNT9WJqrSujZr+OgoqeNtU56I8qE8247ScaPmFaXCFS1eKm7FQT966QWAdB6HkQw3TjjTfS+++/Tzabjb744gvaY489aOPGjT09NEHodciM1UGanF5aWtbMtwMzbWQiH9d2KFj4GCmNpdRUX0VNfjPpgwHaUNVEyzxDaM87f6DsgoFt9oVqkhAjo/JTafKgLMpKkQwLQehNHH/88dwWvKioiJYuXUozZ86kefPm9fSwBKFXIQKig/Ck7/JxmqbZWU25y16i7HUfkLe5imrrG6glYCJT0E1rNtVRZc6utMdtn5E5NTqH1h8KlNQbdBwkObogTa1UKQhCrwM9M1D+evLkydyAC0GWqBUhCIKKzF6dwKAjSq2eR7nLX6bUil/J3txI1Y0t5FF0ZPE7aEVpLQV2OImmXvoy6QzmNi6L6lY3B0pOHZxJRZlqyqcgCL2XoUOH0i+//EKHHnoouVwutkz8+9//lvLXgiACouPovHYaWPoxZWz4imx1S6mmxUO1jU0UJIUsvhZaUtpIWftcRsNPvo8ooiEWgNuj2e2j0flpNFECJQWhT4FqfJ988gldeumlLByuv/56uvjii8nn8/X00AShRxEB0RHq1lLGstcovXEFWRpW0ZoWE9mbalAInMyuRlpS7qIRx95COQddix7c4ZcFFTXLAmuVHQZl0KiCNDJJoKQg9DlQu+WJJ56gxx57jC2Hzz33HB1xxBFc7lcQ+ivdMps99dRTNHz4cLJarVwu9s8//9zi89977z0aP348Px/+x9mzZ1OPUrOSDK1lZLVvpL+abGRs3kA6XZBMjlpaVq+nSafdSeZdzokSD1o56qwUE00dnEUDMm3ishCEPgx+v1deeSW3AU9JSeG6EZKhIfRnEi4g3n33Xbrmmmvo9ttvp7/++oumTp1KBx98MNXU1MR9PmrSn3rqqXTuuefSwoUL6ZhjjuGtR2vUpxVQwOOg+fVmyrGvZbeFsaWK1nlyacbp/yL/pJOixANab9fa3VwQCsGSmSnishCEZAG1IebMmUMDBgzg6xIWRfPnz+/pYQlCt5Pwbpz4cSGaWSsNiypvQ4YM4SpvN910U5vnn3zyyeRwOOizzz4LP7brrrvStGnT6Nlnn+2RbpwNiz6nXz99iYZ6iymgBMnQXEE1aeNpzCEXUcuIw6LEA3pZuHwBGpmXSsNyU6S2gyAkKZs2beKy10jzRM2It956ixc7gtCX6TXdOL1eLy1YsIAb1oTfUK/n+7/99lvc1+DxyOcDWCzae3538Mj3JVToLSV/MEDUWE6OAbvR2EMujBIP0GFoghUIBrmi5Mh8KQwlCMkMFkLI0DjkkEM4Q+O4446jRx55RDI0hH5DQme4uro6CgQCVFhYGPU47ldVVcV9DR7vzPM9Hg8rpsitq5m25hnSe+1EjRWkH38oDdr9RGoecXhYPCBYElUlU81Gmjw4iwZmSbyDIPQHsEL79NNP6aKLLmLhcO2119Jll10mPTSEfkGfXyLfd999bG7RNqwKupppZ9xPzuZG0k05jrInHxglHlAcqrLZTTmpZpo0KINvBUHoXxkaTz/9NNeHwMIB/0ecBDp7CkIyk1ABkZeXRwaDgau4RYL7KBEbDzzemefffPPN7KvRNvglu5rRaW7a4YiLyTh0J2oeeUS4zgO6cla3emhAppWDJaW+gyD0TyAcYH344IMPonpolJWV9fTQBKFvCgh0t9txxx3pu+++Cz+GIErc32233eK+Bo9HPh9888037T7fYrGwGTFy63ImHk3uQbtS1ZDDw+IBlSVr7R4almujCQMyyGraHEgpCEL/5Nhjj+UeGnC7LlmyhIPIkX0mCMlIwl0YSOF8/vnn6dVXX6WVK1dyBTdkWZx99tn89zPOOIOtCBrIs/7yyy/p4YcfplWrVtEdd9zBKVLwK/YYRjO5B+9BSkg8ODx+anJ5aXRBKo0tzJB+FoIgtOmhMWnSJKqoqKC99tqL4yQEIdlI+MyHtEz4Bm+77TZOxVy0aBELBC1QEkVYKisrw8+fNWsWp0P95z//4ZoRaKuLwi077LAD9QZa3T5q9fhpbGEajcxLI4NegiUFQYhm2LBhNHfuXDrwwAN5wYT0zv/7v//r6WEJQt+qA9HdJKIOBCiptdPS8mZKtRppXGE6DZJMC0EQtgL6ZaCHBqywAJbURx99lAMvBaE30mvqQCQbGTYTTRyQwRUmRTwIgrA1TCYT98148MEH+T4K6h199NGSoSEkBSIgOkh2qpkmD8rknhaCIAgdBYsNdPCEOxb9fdDbZ88990xIxpggdCciIDpIVoqZctMsPT0MQRD6KMcff3w4Q2Px4sWcoYFKvYLQVxEBIQiC0E3MnDkznKGB4HFkaCBIXBD6IiIgBEEQeiBDAz1+nE4n99B46KGHpIeG0OcQASEIgtDNIModHYeRoQHhcMMNN9D555/PDQgFoa8gAkIQBKEHQConsjJQHwJdil988UXu7NnQ0NDTQxOEDiECQhAEoQe5/PLLuVJlWloa/fDDD7TrrrvSmjVrenpYgrBVREAIgiD0MIcddhj9+uuvHB+xdu1aFhHff/99Tw9LELaICAhBEIRewOTJkzlDA40DGxsbOcgSJf0FobciAkIQBKGXgBoRsDycfvrp5Pf76cILL6SrrrqK/y8IvQ0REIIgCL0IVKt8/fXX6e677+b7jz/+OB1++OHU1NTU00MThChEQAiCIPTC8te33HILl79OSUmhr7/+muMiEB8hCL0FERCCIAi9uPz1L7/8QkOGDKHVq1dz+etvv/22p4clCIwICEEQhF7M9OnT6c8//2QLBIIrUSsCtSOkcqXQ04iAEARB6OUUFRVxjYgzzjiDAoEAXXnllVy50uPx9PTQhH6MCAhBEIQ+Elz5yiuv0MMPPxyuXLnffvtRVVVVTw9N6KeIgBAEQehDwZXXXHMNzZ49m/tpoPjUzjvvTPPnz+/poQn9EBEQgiAIfQwUmUJcxPjx46msrIz22GMPeu2113p6WEI/QwSEIAhCH2Ts2LH0+++/05FHHsmxEGeeeSbHRvh8vp4emtBPEAEhCILQR4Eb4+OPP6bbb7+d7yM748ADD6SampqeHprQDxABIQiC0IdBQOUdd9xBH330EXf0/Omnn2jHHXdkF4cgJBIREIIgCEnAMcccw6Jh3LhxHBex5557cjMuqRchJAoREIIgCEnChAkTWEQce+yx5PV6uRnXeeedR263u6eHJiQhIiAEQRCSiIyMDPrggw/o/vvvZ/fGSy+9RLNmzaL169f39NCEJCOhAqKhoYHb0uKEzsrKonPPPZfsdvsWX7PPPvtwrnPkdtFFFyVymIIgCEkFrps33ngjffXVV5SXl0cLFy7kuIhPPvmkp4cmJBEJFRAQD8uXL6dvvvmGPvvsM5ozZw5dcMEFW30dSrRWVlaGtwcffDCRwxQEQUhKDjjgAPrrr79ot91243bgRx99NN10003k9/t7emhCEpAwAbFy5Ur68ssv6YUXXuAOcih08sQTT9A777xDFRUVW3wt2tei9ru2wYIhCIIgdB508vzxxx/pqquu4vsPPPAA7b///lReXt7TQxP6OAkTEL/99hu7LXbaaacoNQyf3B9//LHF17755ptsdtthhx3o5ptvJqfTmahhCoIgJD1ms5keffRReu+99yg9PZ2twdOmTeNFniD0OgGBBi8FBQVRjxmNRsrJydli85fTTjuN3njjDe48B/Hw+uuv09/+9rd2n48KbC0tLVGbIAiC0JYTTjiBFixYwOKhrq6ODj30UL7OiktD6BYBAf9ZbJBj7LZq1SraVhAjgTrvkydP5hgK1HdHgZTi4uK4z7/vvvu4Gpu2wVwnCIIgxGfMmDFsIb7kkkv4PrI1ELxeWlra00MT+hg6pZNVRmpra6m+vn6Lzxk5ciRbEa699lpqbGwMPw6Vi5a0MKMhT7kjOBwOrq4GUxuERTwLBDYNWCAgIpqbmyV2QhAEYQvgWow6EbhuwuX8/PPPs5VC6L+0tLTwYrwjc6ixszvPz8/nbWtoUb8wlyF9CHz//fcUDAY5qLKjLFq0iG8HDBgQ9+8Wi4U3QRAEoXOceOKJfH2G6xixabgPQfHYY49RampqTw9P6K8xEKiIdsghh3BKJiqjzZ07ly677DI65ZRTaODAgfwcRAGjHa1Wsx1uirvuuotFx4YNGzhn+YwzzqC99tqLpkyZkqihCoIg9FtgMf755585FgIuaGTOIfgdtSMEocfqQCCbAgIBKUOHHXYYp3KiNrsG2s6uXr06nGWBSOFvv/2WDjroIH4dXCDHH388ffrpp4kcpiAIQr/GZDLRvffey9dfWHsRxwZLMeIjAoFATw9PSJYYiGTy3wiCIAjRIDsDwewIXgdoyoVg9uHDh/f00IReNodKLwxBEAQhDGrwoJcGemgggB3uDbiQX3nlFensKUQhAkIQBEGIArEQZ599Ni1evJh23313am1t5ftHHXUUtxcQBCACQhAEQWg3wPKnn37iejuIUUNPo0mTJtFbb70l1ghBBIQgCILQPgaDgQsIain5qO2DIn/HHXecWCP6OSIgBEEQhK2C3kSoYIlUe2RtfPzxx5yuj7RPsUb0T0RACIIgCB0CwuHWW2+l+fPn084778yR+qj1g1T9devW9fTwhG5GBIQgCILQKZCVAWvEww8/TDabjZsfon8RYiW8Xm9PD0/oJkRACIIgCNsUG3HNNdfQ0qVL2QLhdrvpH//4B3f6ROClkPyIgBAEQRC2mVGjRtE333xDr7/+OvdJWrlyJXf3PPPMM6mmpqanhyckEBEQgiAIwnbXjfjb3/7GrQkuuugivo/qlWPHjuXGXGhbICQfIiAEQRCELiE7O5ueeeYZ+vXXX2n69OkcZHn11VfT1KlT2UohJBciIARBEIQuZdddd6V58+Zx80SUxoZbA00Sjz76aG7UJSQHIiAEQRCEhARZIsVzzZo1dOWVV/L9Tz75hOtJXHLJJRIfkQSIgBAEQRAS6tZAHMSyZcu4lwbag8PNgeDLu+++m+x2e08PUdhGREAIgiAICWf8+PH0v//9j3788UfaaaedWDj885//5H4bjz76KKeBCn0LERCCIAhCt7H33nvTH3/8wQ25Ro8eTbW1tVxPAv9/9tlnyePx9PQQ+waBANGPPxK9/bZ6i/vdjAgIQRAEoVvR6/V06qmn0ooVK7iXxpAhQ6i8vJwuvvhiFhJPPPEEuVyunh5m7+XDD4mGDyfad1+i005Tb3Efj3cjIiAEQRCEHuutce6559LatWvp//7v/2jgwIFUVlZGV1xxBQ0fPpweeOABamlp6elh9i4+/JDohBOIysqiHy8vVx/vRhGhU5KsjRpOtszMTM4/zsjI6OnhCIIgCB0E7otXXnmF7r//ftqwYQM/lp6eztkcEBXDhg2jfk0goFoaYsWDhk5HNHgwUUkJ0mASPoeKBUIQBEHoFVgsFrrwwgs59fPVV1/lduGtra30yCOPcNbGySefzE28kmzd23F+/rl98QBwXDZtUp/XDYiAEARBEHqda+OMM87g1M/Zs2fTAQccwOmf//3vf2nWrFlc5fK5557rfymglZVd+7ztRASEIAiC0GuDLQ899FAug71o0SI666yzyGq10uLFi7nnBmImEHiJrI5+YZUYMKBrn7edSAyEIAiC0GdoaGhg9wZSPuHqiKwzAasFmnohqyOpYyDKy1V3RQ/HQIiAEARBEPocmLp++OEHeumll+jDDz8Mp32iE+juu+9OJ5xwAh1//PE0GBNqMmZhgMjpG+IBvP8+0XHH0bYiAkIEhCAIQr8B1/3333+fW4j/9NNPUX/bbbfd6JhjjqHDDjuMJk2axAIjKUTElVdGB1TC6vLYY9slHoAICBEQgiAI/ZJNmzaxReK9996juXPnRv0Nrg0IiUMOOYT22msvysnJoT7tzvj5ZzVgEjEPe+65zW6LXicg7rnnHvr888858MVsNlNTU9NWX4Oh3H777fT888/z82GGQtOVMWPGdPh9RUAIgiAIANUtP/74Y56L4O6I7bcxZcoULq2NbebMmezu6O0WimAwyO3Rkc6qbd9++y0HlHYFvUJAQAhkZWVxVbEXX3yxQwICVcfuu+8+DpAZMWIEN1pZunQplztF5G1HEAEhCIIgxOJ0OrmRF9JCv//+e56EYyksLKSdd96Zm31NnjyZJk6cyPUnkFbaU4W1Vq5cSUuWLOEN2Sfz5s3j+S2SDz74gI7bTtdFrxIQGqgqdtVVV21VQGAYUFDXXnstXXfddfwYPgC+UOzjlFNO6dD7iYAQBEEQtkZ1dTXNmTOHYybg6sBiFbUmYoF4GDt2LPfoQCVMbRs0aBDl5eVRfn4+zzWdtVxgzsO8WFVVxVtlZSVbTIqLi8NbaWkpWxxiSUlJYaGDmhiI8dhzzz15wd4VdGYONVIvoaSkhA8iCoZo4EPssssubKJpT0BAoUV2b5O66YIgCMLWwOL0xBNP5A0giwMud6zw//rrL7Z8Y3M4HLR8+XLe2sNoNHI8hc1m4w0Wc2wQFRAlEAHYYAVBZU1t68j6HcJg6tSp7G7BNmPGDL7Fe/Y0PT+CEBAP2pcaCe5rf4sHXB7/+te/Ej4+QRAEIXnBxI/VPDYNTPoIyoSQwCIXFgFtq6yspPr6eq6G6ff7qaamZpveFwKhqKiItwEDBrDLJHLDY701LqNTAuKmm27iOIUtAX8NCnp0FzfffDP3ko+0QCRtERFBEAShWythai6L9nC73SwkUOAKVozIDRO/wWDg/WCDSEFzMLgGcAvx0NH4vj4vIBCfgFKiW2LkyJHbNBCoL80vBcWlgfvTpk3bYvMVbIIgCILQ3VitVo6HwNbf6JSAQLAItkSArAuIiO+++y4sGGBNQI1z1DoXBEEQBKH3kLBmWhs3buSAFNwiiAT/xxbZPQ2ujo8++oj/D1MPsjXuvvtu+uSTTzgiFnXNkZmBKmKCIAiCIPQeEhZEedttt3E9Bw20XwUo5rHPPvvw/1evXh2Vz3rDDTdwxOsFF1zA6S177LEHffnll33aRyQIgiAIyYiUshYEQRAEodNzaMJcGIIgCIIgJC8iIARBEARB6DQiIARBEARB6DQiIARBEARB6DQiIARBEARB6DQiIARBEARB6LvNtLoKLStVunIKgiAIQufQ5s6OVHhIOgGBFqlAGmoJgiAIwrbPpagH0a8KSaH9akVFBXc666oWqFqHT7R1leJUXYMc065HjmnXIsez65Fj2vuPJyQBxAPaSKCDaL+yQOADDx48OCH7xhckJ33XIse065Fj2rXI8ex65Jj27uO5NcuDhgRRCoIgCILQaURACIIgCILQaURAdACLxUK333473wpdgxzTrkeOadcix7PrkWOaXMcz6YIoBUEQBEFIPGKBEARBEASh04iAEARBEASh04iAEARBEASh04iAEARBEASh04iACPHUU0/R8OHDyWq10i677EJ//vnnFp//3nvv0fjx4/n5kydPptmzZ3fbWJPxmD7//PO05557UnZ2Nm8HHHDAVr+D/khnz1ONd955hyuzHnPMMQkfYzIfz6amJrr00ktpwIABHPk+duxY+e1v5zF97LHHaNy4cWSz2biq4tVXX01ut7vbxtubmTNnDh155JFcFRK/348//nirr/nxxx9pxowZfH6OHj2aXnnllcQNEFkY/Z133nlHMZvNyksvvaQsX75cOf/885WsrCyluro67vPnzp2rGAwG5cEHH1RWrFih3HrrrYrJZFKWLl3a7WNPlmN62mmnKU899ZSycOFCZeXKlcpZZ52lZGZmKmVlZd0+9mQ5pholJSXKoEGDlD333FM5+uiju228yXY8PR6PstNOOymHHXaY8ssvv/Bx/fHHH5VFixZ1+9iT5Zi++eabisVi4Vscz6+++koZMGCAcvXVV3f72Hsjs2fPVm655Rblww8/RLak8tFHH23x+evXr1dSUlKUa665huemJ554gueqL7/8MiHjEwGhKMrMmTOVSy+9NHw/EAgoAwcOVO677764zz/ppJOUww8/POqxXXbZRbnwwgsTPtZkPaax+P1+JT09XXn11VcTOMrkP6Y4jrNmzVJeeOEF5cwzzxQBsR3H85lnnlFGjhypeL3ebhxlch9TPHe//faLegyT3+67757wsfY1qAMC4oYbblAmTZoU9djJJ5+sHHzwwQkZU793YXi9XlqwYAGbzCP7aeD+b7/9Fvc1eDzy+eDggw9u9/n9jW05prE4nU7y+XyUk5OTwJEm/zG98847qaCggM4999xuGmnyHs9PPvmEdtttN3ZhFBb+f3v38wrdFwdw/JQhf4B8bbCYUkpSrFCytbBVNDtNmmxFJMqPJk2WkhI7JbExJT838lhJ2RghbIxSFpKFH/fb51PzNKZRz7keM49736+6mXvn3jo+7pzzmXvPx/3P1NTUmMnJSfP29pbDlnsrpo2NjXpM6jbH5eWl3hJqa2vLWbu95FeOxybPPUzL1v39vXYA0iGkk/XT09OsxySTyaz7y3a4i2mm/v5+ve+X+WHwKzcx3d/fN/Pz8+b4+DhHrfR2PGVw293dNV1dXTrInZ+fm0gkoomu/DdAv3MT087OTj2uublZnwL5+vpqenp6zODgYI5a7S3JT8YmeWrn8/OzzjP5m3x/BQL/nmg0qpP+1tbWdCIW7MnjeEOhkE5OLSkpyXdzPOH9/V2v5szNzZn6+nrT0dFhhoaGzOzsbL6b9mPJhD+5ijMzM2OOjo7M6uqqicfjZmxsLN9Nwx/w/RUI6VwLCgrM3d3dh+2yXlZWlvUY2W6zv9+4iWlKLBbTBGJ7e9vU1tZ+c0u9G9OLiwtzdXWlM7jTB0ARCARMIpEwwWDQ+JWbc1QqLwoLC/W4lOrqav3WJ5fvi4qKjJ+5ienw8LAmut3d3bouFW1PT08mHA5rcia3QPDnPhub5FHff/vqg/D9X0c+9PJtYmdn50NHK+tyvzMb2Z6+v9ja2vp0f79xE1MxNTWl3zw2NjZMQ0NDjlrrzZhKifHJyYnevkgt7e3tprW1VV9LuZyfuTlHm5qa9LZFKhETZ2dnmlj4PXlwG1OZ65SZJKQSNB7TZC/nY9O3TM38gaVHUkq0uLiopS/hcFhLj5LJpL4fCoWcgYGBD2WcgUDAicViWnI4MjJCGecXYxqNRrX8a2Vlxbm9vf29PD4+5vG3+NkxzUQVxtfieXNzo5VBvb29TiKRcNbX153S0lJnfHw8j7/Fz46p9J0S06WlJS1B3NzcdILBoFa6wdH+T0rbZZHhenp6Wl9fX1/r+xJLiWlmGWdfX5+OTVIaTxlnDki9bEVFhQ5iUop0eHj4+72WlhbtfNMtLy87VVVVur+UzcTj8Ty02jsxrays1A9I5iIdDNyfp+lIIL4ez4ODAy3ZlkFSSjonJia0VBbuYvry8uKMjo5q0lBcXOyUl5c7kUjEeXh4yFPr/y17e3tZ+8VUDOWnxDTzmLq6Oo2/nKMLCwvf1j4e5w0AAKz5fg4EAACwRwIBAACskUAAAABrJBAAAMAaCQQAALBGAgEAAKyRQAAAAGskEAAAwBoJBAAAsEYCAQAArJFAAAAAayQQAADA2PofOz/xQ56Kdh8AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 1) \t Best Value: 0.3324226803440067\n", + "Early stopping at epoch 7389 with loss 5.121181297492753\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 2) \t Best Value: 0.8926797760383713\n", + "Early stopping at epoch 6599 with loss 3.4750899036796015\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 3) \t Best Value: 0.9538915741567119\n", + "Early stopping at epoch 10000 with loss 2.4829863769911618\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 4) \t Best Value: 0.9538915741567119\n", + "Early stopping at epoch 7999 with loss 1.7124188780350311\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhAAAAF2CAYAAAA/RaFTAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAA5O9JREFUeJzsnQWYVXX6x7+3O6Z7mKAbQZAUEEXA7u5Y9W+surq2ruuaa69r1+q6diOKCooISndMMN11u+/5P+97ucPMMIkzQ/0+PPfhzrnn3HPuyff3xveVSZIkQSAQCAQCgaAHyHsys0AgEAgEAgEhDAiBQCAQCAQ9RhgQAoFAIBAIeowwIAQCgUAgEPQYYUAIBAKBQCDoMcKAEAgEAoFA0GOEASEQCAQCgaDHCANCIBAIBAJBjxEGhEAgEAgEgh4jDAjBH+bNN9+ETCZDUVFR87SZM2fyq7e4//77eR0CQX+eS9F56+rq+mWb+no9ggMbmUzG58LBgjAgAJx00knQ6/VwOBwdznP++edDrVajvr6++UC3fBkMBgwfPhx///vf4Xa7Wy17ySWXwGg0dushvHr16h5vf1ZWVqttSUxMxPTp0/Hpp5/iYIL2G108S5cuxeEC/da251JHr76m5bqUSiViY2Mxfvx43Hjjjdi6deshfVz/8Y9/4LPPPjskj+vhxqZNm3DGGWdgwIAB0Gq1SEtLw7HHHovnnntuf2/aIYdyf2/AgQAZB19++SU/cC+66KJ2b4Cff/45jj/+eMTFxTVPp5MyOr/T6cSyZctwzz33YMOGDfjwww/79TeMHTsWt9xyC7+vqKjASy+9hNNOOw3//ve/8ac//Qn9zXfffdfjZWg/P/DAA/y+rffi7rvvxl//+lccagwbNgz/+c9/Wk2744472OC86667+n17ouc0tcix2Wx8Lr/11lt44YUX8Oijj+Lmm2/u1eO6P2jvXCIDgh46p5xyyiF5XA8Xfv31V8yaNQuZmZm48sorkZycjNLSUqxcuRLPPPMMrr/++v29iYcUwoDY7YEwmUz473//264BQcaDy+ViQ6MlgwcPxgUXXND8Nz2o/X4/PvnkE3i9XrZ++wuysltuC/2OgQMH4qmnnurQgAgGgwiHw+xZ6W16+ztpREyvQ42kpKRWx4145JFHEB8fv9f0/qDtOR3dnhNPPJEN1KFDh2L+/Pk4mOmPc+lAO66HCw899BAsFgtWrVoFq9Xa6rOampr9tl2HKiKEAUCn0/Fo/Ycffmj3JCPDggwMMjS6gizeqAt4f0LbQaOgXbt28d+Un0Db9cQTT+Dpp59Gbm4uNBpNs2t6+/btPAIjtzUZPhMmTMAXX3yx1/du2bIFs2fP5n2Wnp7OIRsyQtrSXg4EGVXkyqaHFK0jJSWF93tBQQFvX0JCAs9Ho9WoezcaD2wbtx45ciSPNNpC20LGFP2WltPoN48YMYLXSzf3q6++Go2Njd3alz/++COHhChMRTelk08+Gdu2bWs1T3T78vPzOWRF89GN7NJLL90rpLUvFBYW4swzz+TjQ+G2o446Cl9//XXz5+QBo+2jcENbysrKoFAo8PDDD+/Tusnr9r///Y/PabpBRyFj+d577+UwB/1WWj/tpyVLljTP09Vx3bhxI++vnJwcPjZ03l522WXNocKOIA8JPYxbekToONN+p9/a1NTUPJ08J7TttI/aO5foPQ0QyNMS3T7appbQ9/XFcW1Ld9ZDhv+DDz7YfA1TCPPOO++Ez+drNR9NP+GEEzicQtczXbOjRo1qDiXRQIf+pv1Ox3DdunXthl7p3Js7dy4f39TUVPztb3/j/d8SOj/oO+g+aTab+XtpxN+Tc7hl6OeDDz7gc43uMbR9xxxzDF9bXUH3ErrO2xoPBIV2W/LGG2/wvYym036kEDR5bNvSn/uxPcrLy/maoPsWbSf9vtdff32v+ShEQ5/Rvo2JieFtpWdXn0LtvAWS9N1339GRlJ577rlW0+vr6yWVSiVddNFFrabTvJdffrlUW1vLr6KiIundd9+VTCaTdOGFF7aa9+KLL5YMBkOn63/jjTf4O1etWtXjbR8wYIC0YMGCVtP8fr+UlJQkJScn89+7du3i7x8+fLiUk5MjPfLII9JTTz0lFRcXS5s3b5YsFgt/9uijj0rPP/+8NGPGDEkmk0mffPJJ83dWVlZKCQkJUkxMjHT//fdLjz/+uDRo0CBp9OjR/N20jihHH300v6IEg0HpmGOO4fnOOeccXsfDDz8szZ49W/rss88kp9Mp/fvf/+bPTz31VOk///kPvzZs2MDL33ffffxZlL/97W+SXC7nbWrJTz/9xPN9+OGHzdOuuOIKSalUSldeeaX04osvSrfffjsfjyOPPJL3U2csXryYlx08eLD02GOPSQ888IAUHx/P+6Dl741u37hx46TTTjtNeuGFF3i9NO22227r0fEcMWJEq31XVVXFx5LOrbvuukt68sknpTFjxvDvb3l8zj//fJ6P9nVLaLvpWNKx7gza1uuuu67Dz+n40TptNhv/Ted9SkqKdPPNN/Oxo/UMGTKEr5d169bxPF0d1yeeeEKaPn06H8+XX35ZuvHGGyWdTidNnDhRCofDnW7vSSedJI0fP775b1onrYe28auvvmqeTtfGhAkTmv9uey7R9mg0Gt6O6Pb9+uuvfX5cW9KT9dD9hKafccYZ0r/+9S++N9Hfp5xyyl73BToedIzoeqXrPS0tTTIajdI777wjZWZm8n2AXnT9Dxw4UAqFQq3Wo9Vq+RqnexpdsyeccAKv65577tnr3knnB20Pvf7v//5POvPMM3t8Di9ZsqR5P9CxpW2mbdfr9XxOdMVxxx3H69i0aVOX89L1f8kll/A66L5Py9K66Xfuj/1I0DQ6F1rut/T0dCkjI4OvEbqW6Lyn+Wg7otC1Ez0nXnrpJemZZ57h59MNN9wg9SXCgNgN3XTpBJk8eXKr6fTAoQPz7bfftppO09p70UXs9Xr73YCgkz9qzNDNmR7S9H3XX399KwPCbDZLNTU1rZanC3/UqFGttptu3lOmTOGTPspNN93E3/Hbb781T6PvooumKwPi9ddf53noxtGW6IOCtr3tBdTRTX/Hjh3tGnzXXnstX9hut5v/XrZsGc9Hxl1LFi1a1O70towdO1ZKTExkQzIK7V+68bU0KqPbd9lll7Vanh6acXFx0h950ET3O/2WKA6HQ8rOzpaysrKab1Z0jtJ833zzTavvIwOvowdXTwwIerjTPNGHP10zPp+v1TyNjY38oGi5Hzo7rtHj1JL33nuP5//555873V4yYBUKhWS32/nvZ599lq8FetCQkUjQvrFardKf//znDs8lgq5Puk7b0pfHdV/Ws379ep6PjIuW3HrrrTz9xx9/bJ5G+4KmRY2hlucIGWktDUp66NB0eoC3NVSi95DotUoGmVqt5uMaPS/ovtLWcG1Jd8/hqAExbNiwVucWPRBpeleGARkzdE7Qi+7lZHzRb25voNDeuTd37lweYLWkv/Yj0fY6ISOAnkt1dXVSS+j+Tvfd6G84+eST+fzqb0QIYzfk9jznnHOwYsWKVuWI5AIi1xG50NpCruzFixfzi/IkKElq0aJFOO+887rlmurtpEVyFdNrzJgxnMR54YUXsvu2JaeffnqzS5loaGhgF/1ZZ53FVShURkYvciGTuy0vL49daMTChQvZ7Thx4sTm5em72uaGtMfHH3/MLuf2kpj2JROdwiCUOPr+++83TwuFQvjoo484Xk9uRoL2A7mCKTkw+tvoRa5Gciu2dLe3pbKyEuvXr2cXJLldo4wePZq/j/ZHW9rmm5BLn/al3W7HvkLroX0+bdq05mm07VdddRWfq9Ew1Jw5c9g1+u677zbPt3nzZg4T9EbcPVpJFK1WomsmmutC4QM6l8i9Tq7TtWvXdus7o8cpGuKiY0PnGNHVd9C+pWNOiXMEJTHTNHrR++jvp7AATfsj9MVx3Zf1RM+5tsms0QTqtiEBcstPnjy5+e9Jkybx/+S6p0TDttPJzd6W//u//2t1rdLfFL76/vvveRqFCygERPfBP3oOR6HQTcs8qujxa2/7WkLXJd3DKdxMCcCPPfYY38corNk2JNvy3KOEYTr3jj76aF4H/d3f+7Et9Ayh+ybdz+h9y/sX/Sbaxug1QseAQpWU+9GfCAOiBdEHYTRuRAeEbkRkWNDNsi0Un6ObNr3ohKVMbsoJoJjYV1991a/bTicuXcB0MtINlU6yt99+u9VFQmRnZ7f6m+KKdHJS9UjUAIm+7rvvPp4nmhdSXFyMQYMG7bXuIUOGdCs2SfP1Zm7I2WefjeXLlzcbOBSTpG2l6VHIAKILjeKcbX8fxcQ7S6yi39vR76P8EtrHdONsScubCUGxSKK7+RYdbUdH29ByO+VyOZ/DVI4YjZuTMUGxWYo9/1GiOQQU545CeQNkUNE6KFeC9is9xNregDuCjA7K2yAjnc5VWj56jnb1HUcccQTHe6PGQtSAmDFjBpdDk0ES/azlg2tf6Ivjui/roWNNx5kSpFtCuSP0EImeCx19HxnTREZGRrvT2/4eWhflp7Q13onoQOvaa6/lafPmzeN7IsXraSC1L+dwd/dDZxx55JF8D6Z5f//9dx7YkdFLeVEtDRW6d9C9O5rbROce5ZK0d+71x35sS21tLRu/L7/88l73LjKwiOj96/bbb2eDjIw0ukdfd911/Pv6mkMvrf0PQKNSyjJ/7733+ESi/+nh2p0RdpSop+Lnn39my7G/oNE9XQxd0dagiCZA3nrrrWzVtkfbm9WBAhkKdHMgL8NNN93EiVd0AVO5bcvfR8ZDy1F5S1p6Y3qD9gxNor88UlR98/jjj7MRce6557IxTAlg0RvbH4FG8/T7og/4d955h70zVPr4l7/8hfdzNFmTDMbuQJ4vMnhpefIo0U2Qjhkdw/aSc1uiUqnYcKZrjQzhqqoqNiDIGAkEAvjtt9/YgKBr+o8e5/46rt1dT3e9dh19X2/+Hjru5Kn79ttv8c033/CLEhTpXCQDc1/oje0jDwYZE/SihzU9dOleQQMjOj/pXk3nxpNPPsmGAM1PnhKqXGt77vXHfmxLdBvIe3jxxRejPch4jxpiO3bs4IErGW/kuaDSa0pyjpZQ9wXCgGgDGQs0Gie3L918yZqjE7C7kAu35WjtQCdqFdPNuCsDhIRZaETfFjpxu4IyxumGTjd2Wld79DSUQQ8ysrgpjEHuQBp10MOMMpVbrpe8MlOnTt3LeOoK+r0d/T6qWiGjjUYvfQ1tR0fb0HI7o9Up48aNY4OJRoMlJSW9IqBD3/PTTz+xGzfqgaBwEZ0/tN9bHruo56qr40qjNKp8ohsc3eiitHeOdQQZDBSmo2NMx4MeCLQ+ykYn44FeZEB1xcEi6ETHmh4stI+io3eiurqaR6stz4XegNZF7vjoaJnYuXNnc3VCFHr40oCJXrQMeSVIi4bupTQA6ck53BdQWC0aliRI94eqViis0dK70FlIsz/2Y0vI6KVrjcJ03Rkc0r2IBlX0otAIVbhRJQsNsvpKUkCEMNoQ9TbQDY2s6p54H6InJkF5CAcDNHqgcku62KMXV1s3WhSq/ydBFnILtvy8o9F929wLcvk///zzHVrr5I4mWpbgdQVdLLRNVNZE398yfBEd4dIFSGVv7Rl7na2LykxpVEyjqJbz0Uicck76Sw+B1kP7nGK7USh0Qq5NuvlQfLYllPtC20elqxRWINfyH4HCDOTNoP3YUgQpOvpqOdoiI7HldnZ2XNtbnqDt7okBQQ8CWobCFFFDgKaTkBOJqnUn/4Fuvj057/YX0XOu7T6iUTSxYMGCXl9ny2uWjhX9TYOAqLe1bcktueujI+NoaWlPz+F9hQyA9kb/0dyRaBilvXOPwhbkOekrnu9iP7aFtpHum+RNoHtOZ/fmtseADDrap7QeGrT1FcID0c6odsqUKZwUSXRmQJAFSW5cgmLO9CCjhw1Z3HQTbwkdRMqPaAsl55G1HoUehG3jhwTFiVvGnnuTf/3rX3zzpVpmUm+jUSWNaOhipzwQSkYibrvtNr4pk3uZtoduunQDoNEDeWw6g9yZlJNByV90I6GbOt1AaORIv58SUslDQCc9eRTIUqd9QyNqenUEGQgUfqEXzd/WUqekKNJ8ILc6GYTHHXccX7Q0giN3JtWqt9SMaAuFA+gBTCPvyy+/HB6Ph0f0FBLoL816Uk2kcBptxw033MC/k84z0vigmwvdsFtCSbx0rEhZ9ZprrunQ49PZOU03Hkrci6qqkkeNHlItw0M0sifvw6mnnsoPLtqeF198kY9hSw9cZ8eV8hUo0Y2uD0p0I8Mnql3SHei4UF4NjW4pIS8KfW+0pr87BgSFL+lcpN9Iiah0H4gmxB1I0MCE3Nl03ZHBQ+c3XU90PpD3rT1tlD8CjVzpfkTrpP1B4QnKcaEQbzQsdMUVV7CRSQmF5PWifAa6Rsj4jnpJenoO7yuUpE33YjonyRtFI3EKkdG5R4ZKNHeA7gNRrwndH+h8feWVV3hA1d5Aqj/2Y3uQ+BgZRbQM3ZvpOqJ9TcmTdL7S++jvoTwY8rRSCI90ashAoeuyr54bTL/XfRwEUB0z7ZrO6o7blm9S2RDV61511VVSdXV1q3mjZTztvXJzc1uVcXb0Ki0t7ZEORFuiZZxU+tYeBQUFXJZIuhFUx091zlSr/NFHH7Wab+PGjVyKRnXNNM+DDz4ovfbaa12WcRJUckQ14FS6ReugdVHdMq07CpVKUf03lTe1LGlqr/QuytSpU9stbWsJ1UnT91LZFdWJU9kqlXhVVFRIXfH999/zOmhZKlc78cQTpa1bt7aaJ7p9LUuyWh7XlvtmX8r9aB/RvqKSRNr3dG621Dpoy/z58/cqPeuKlucblanSuqgen8r0tmzZstf8VIr2j3/8g88/0lGgeWmb6HynaS3p6LiWlZVxqSKti8rSSDuAjklHZZ8d1fO3LS+m76VpVD/flvbOpe3bt7P2CR1j+ixa0tnXx7XtNnVnPYFAgPVIotcR/cY77rhjr/Lxju4L7ZXrtnd/iJaf07lHZeKkxUAlurStLXUO6B5Bn1O5Mx1f0kW4+uqr99Jo6c45HC3jbKnj0nL7aH90BpUwUyns0KFDuZybtod0GaiEsu19+YsvvuASZ9oWKiUlDZxouXnL/d1f+5Fo77yn7ab10HGO3jep9J7uaS3LR+n8pZJfuhbpufKXv/ylWbOlr5Dt3miBQHAIQSMwairUHfU+gaA9KEGW8lwOlnyuA5VLDuH9KHIgBIJDDHLBknu0bRhNIBAIehORAyEQHCJQPJlqv1999VXOe6DYrkAgEPQVwgMhEBwiUJkleR3IkKAENUqqEggEgr5C5EAIBAKBQCDoMcIDIRAIBAKBoMcIA0IgEAgEAkGPOeSSKEkylNTnSDzjYJGnFQgEAoHgQICyGqj5GAmqdSXwdcgZEGQ8tO2QJhAIBAKBoPuUlpaysuhhZUBEZTvpx5vN5v29OQKBQCAQHDSQhD0NwrsjgX3IGRDRsAUZD8KAEAgEAoGg53QnBUAkUQoEAoFAIOgxwoAQCAQCgUDQY4QBIRAIBAKBoMcIA0IgEAgEAkGPEQaEQCAQCASCHiMMCIFAIBAIBD1GGBACgUAgEAh6jDAgBAKBQCAQ9BhhQAgEAoFAIOgxwoAQCAQCgUDQY4QBIRAIBAKBoMcccr0wBIIDhXBYgj8Uhi8YRiAUhj8YRjBE00IIhCSeFgyH91pOKZdDpZBDrYj8r1TIoFZG3muUkelyuWhVLxAI9i/CgBAIeslYcPmD8ARC8PrDsHv9cHhDzcZCKBSm7jQ8rxwy0PNfIZdxw5qWpoBELymIUFhCWALCPIUnQsEGhQxquQImnQJmrRpatRw6lQIGtVIYFQKBoF8RBoRAsA9IkgSnLwiXLwS7J4AGtx8efxD+EJsAUMkV7C3Qq5RQamRQKv54tDDIHguJPRk1dj/KmzxkV/B6dGol4gxqmHUqGDRKGNSKbnXTEwgEgn1FGBACQTchr4DTG4TNE0CNwwuHN8AhCjnoAR7xCFCooa8gI0SpALQqRavpZFCQ56Oozo0wwhziMGlVSDRpYdGpYNQq2dshEAgEvYkwIASCLjwNDl8QDU4fquw+9jpQHgOFDeghraEn+n6GjBZ6kbFA+IIh9oxsddo5f8KoUSLZrEGMQQOzVik8EwKBoFcQBoRA0A70EG50BVBt96LB5YMvEIZeo0SsXs3JjAcyZNREDRtK1HT5gthe5YRa6UKMXo1ki5b/b+vJEAgEgp4gDAiBoAVufxA1di/KmyhEEeSkRbNWhXjjwfmwJWPHqlfDqo8YRU3uSPjFoFayIZFo1vLvEwgEgp4iDAiBAIjkNdi9qLR54Q4EYVSrkGLRQn4IufvZM2FUNCeA5tc4UdbgQYJJ0+yVEJUcAoGguwgDQnBYQ4mQ5Y0eVNm88IVCnAiZptfjUIZyICh/g14ef4iNJnqRIZEWo+MwjTAkBAJBVwgDQnBYQnkBlTYPGw/eYAhWnRpxag0ON6h6hF6UK1Hr8KHG4UOiMCQEAkE3EAaE4LCC8gAqmzwobfTA5Q1yfkCsoY8NB0mCPOCEwtsARcANedANWZD+90AW8kNGYlEk6MCiUTKElVpICg2/wkodQmozQhoLQmoLIFf0Wa5EklnbbEjQK9GsQWasnveRQCAQ9KsB8fPPP+Pxxx/HmjVrUFlZiU8//RSnnHJKp8ssXboUN998M7Zs2YKMjAzcfffduOSSS/pyMwWHiYYDVVSUNLg5kZDKGdNi+iBUIYWh9NRB5ayAyl0NhbceSm8DGwp/GJkMIbUJQV0CAvpkBAzJCOqTICm16AtDgvZXndOHVIsOGbF6FqgSCASCKH16R3C5XBgzZgwuu+wynHbaaV3Ov2vXLixYsAB/+tOf8O677+KHH37AFVdcgZSUFMydO7cvN1VwiEIJg/UuP0ob3PxAJGXIXk2OlCQ2GNT2QqgdpVC5qto3FmTy3V4EE8JKfeSl0kGS0+hexsYB+x8kCbKwD/KgD7IQ/e+BwmeDwtcEWTgAhc/OL01TQfNXk0HhNw+Az5KNgCG1V7wUZEgkm3WcI1FU7+LQRmasDqlWfZ+KZQkEgoMHmUR32P5YkUzWpQfi9ttvx9dff43Nmzc3TzvnnHPQ1NSERYsWdWs9drsdFosFNpsNZrO5V7ZdcPDmOZQ0uLgkUyYBsQZ1r0hKk5dB5SiF1lYAta2QH+itPlaoETCk8MM8qI1FWK6CPByA0tcIud8BecAFedAFhd8FWdjPRogMYSAcYkMizOELLcLKyP8Rw8PKoQ2CjAqlp4aNFTIu2q6bjAlvzFA2KCBX9lqyqd0bQJxRg6w4A+KNaiFIJRAcgvTkGXpA+SRXrFiBOXPmtJpGnoebbrqpw2V8Ph+/Wv54weENud+pqqK43sUqkvEGzT6JJgUCAVRXlqO8tBhV5WUIO6oR4y1BYqAcypCTPQdKpRJQqGCTx8GlS4U2MRuJcVYMgBNx9t+h8tZAHnCz90Ae8gHhAGThYPOLjJFIk63Iw1iSySHJVWwI8Eu++3+FerdhoUFYZeTwhTd2KIJqK2RSCGpnOdT2IjYuNI15/CKDwxczGN7YYRHPxB944FPFhl6tRIPLjw2lTUiL0SIz1iDCGgLBYcwBdfVXVVUhKSmp1TT6m4wCj8cDnU631zIPP/wwHnjggX7cSsGBDD3gdtU5OXZvUKuQZtF1a6RcX1eLrRvXYfOGtdiycR3yt29FVUU5pHAYwxLkmJSmQKZFjnqaF4A3KGFbXRjFTWGY1MCENAWGxSuQZJbBrJHBq1ahVqOCVqOBWq1mI0OSKRGWKxGU5AhKMgQgR1iKbpsM9Jb8I0oZvSQo6H85uAtnpMU3oJJJUKo0kLQWhFUmhFV6hNVGeGKGwJV8JCdcql1V0DZs58RNXe1GflGYw510BHsm9jXEQf00qNTTGwihuN6Neqcf2QlGpJi1olpDIDgMOaAMiH3hjjvu4KTLKGRsUPKl4PCCHmqU51Da6OZBfZJJ12kDKY/HjdUrfsEvSxZj+dIfUFJU2OpzenCPT5ZjerYeGYkWmExmqDU62ORmBJUmxGhlOE5ZhwQ0QiMPQMEPfAkKSAjKlfBAC4ekRw10cEELf0iFAJQIQoGApIAHGvighh9KMiPY/0D/KxGCHj5+KWUhKGVBaBCEGgFoEOD/1TIXDHIbdAoJamrvrVTAXLEKMn0chzv8pky4Uo5CQJ8Arb2IvRFKTy3MRd/CWL4c7sQx8MSP2efkS/LmpFn1aHL7sbmsCQ1WPbITDNxzQyAQHD4cUFd8cnIyqqurW02jvykO0573gdBoNPwSHJ5QCg+VHBbWufiBRmqK5GpvD5fTgR8WfYVvPv8Yq1Ysg79F6Iu8FNkDB2PU6NGYOzIBWYpqaBUSrFYrUpKTENZa2UugasxHsC4fkqsOUsALKRyEX1KiUTKiVrKgDhbUhSyolsUjqImBJ6SEzeVDVW09dhUWobqmAkGfF2G/B5Lfg9jYWEyfdRymzT4OuUOGcbtuN7cJD8LrdcPrdsJtb4TX2YCgqwFhdyNiA5VIC9XDEPRAL/PBCicsTjsMjfXQKGRQqDbDWvITFMYEeONGwJU8CZJcCX3dJvZKkBFhqF4NV9KRcCeOA+T7JmVN5Z0Uwqho8sDmiXgjks1a0flTIDhMOKAMiMmTJ2PhwoWtpi1evJinCwRtiVQIOFHW6IVKLkOKRbdXdUUoFMKvP/+Irz/5AD8u+gper6f5s5S0dEybdSymzZyDIydPRby/FJXL3sbqX77FFp8TeqUEX1AGvdmCSYMSEYMmhIJu9iB4JQ1qkIByKR5FylzIYnNgTBwAa2I6hiUkYaZZC1WIEiUdnDip8Nv5/+qSfBRu34jinZtRWVSOcLASWLsFeWufQn1sHIaNHoexE6fBFJcESauGZNAglGpAWJWBsHoYQiojGysljT5U1VTCXlcKb10J9I5dSAvXwBJyIcVfj3h3DdSNVZBV5sOYvxhKazo86dPgTRgDtaMMSm89jOW/QF+zHs7UyWxoUKXIvlRrpFp1LAVO3ojGGD1yEgwdGnECgeDQoU+rMJxOJ/Lz8/n9uHHj8OSTT2LWrFk86srMzOTwQ3l5Od5+++3mMs6RI0fiuuuu49LPH3/8ETfccANXZnS3jFNUYRz60ClLZYW7al1o8gS4IqBtW22H3YbP3n8H/33zZZSXFDdPH5CdixNOOxtz5p+EnEFD2PNAlRTG8mUo3fo7Ni5fDKsmjKagGgpTPIbHSUhVeyigAC/UsEl6lCsHoDHxKBgzxyAtcyDizTqo3dVcGUElnUoPaT/Ud6n9QMZNaVEh8nZsQ1FhPoKBQAtvyCCMHHME0jIGtLssJVIGdbEIauMQ1MXDqU5EfkMQNWX5sFfuhK5hOzKkSmTIapAoa+LwClR6yA1xUKSMRigmFwq/LZLIyaWgcXBkHIOAKf0PJa9Soy5qK56bYOR8CVGpIRAcXPTkGdqnBgSJQpHB0JaLL74Yb775JgtEFRUV8Xwtl/nzn/+MrVu3Ij09Hffcc0+PhKSEAXH4eB3UCjli9KpWD6mykiK889q/8dn778LtokoJwGKNwYJTz8SCU8/GyLFHNM9PHgFT6RJo67dA6arCuuWLUeHTQWdNwCCjGzpZAF6o4JbUKPNo8UudBfOu/htSUtKhcZXzSF7lighGcQlme9oPaiPCpCSpMrIGxJ7yTA0kOb0iho/H68HKn5fi2y8/xrb1q6BRAGoFkJs9AKeechImTRgHVcgd8WgEXO3um0j5KAlMpcGhT0VelQM1RVsQrtiAHP92ZMlqYJR5EObtskJKHA5TfCrkQS8nY0KmgCd+JJxpM/Y5P4JuJ5TISqGYAXF6ZMbp9zLuBALBgcsBY0DsD4QBcWhCp2md04+CWieaXH7WI2hZmllVUYaXn32CvQ7BYGRUnTt4KM6//Bo2HnS6FqqTUhi62g0wlXwPja0IMnctdjbJUd7kQYbawYmKHpkGPn8IW+pkeG+jB1sq3RhklfDIzZdgSLyyeeQeJawysPYDeQNoNB/UxiOkse5TxUP+jm3431uv4suP/wePO2IsZGbl4Mrrb8GC086GilIxfY27PR0NULqrIwJW4UDrbVJqIwJTxkyUOCSU71gDc8UvSAsWIUbm5ORMu9wKb9wwZJiV3LqclC1DWisc6TPhixmyz6WfZOjVuyN9NQYmmGDRi5bhAsHBgDAghAFxSOEPhlkQqqjeDaVMxoJQUS9CbXUVXvvXk/jw3TcR8EdCBkdNn4lLrr4Bk2fM2suFrvDUw5r/CfQ16wBXLSpdQJkzBHXYR7USCEthOF1erC714v3NAfYCjIkPIdMU8TAcM3s2cnMHcrmk35yJgDGdNRao+uGP6Cy0B4VhPnznDbz10nNobKDiUSA9MwvX3nIH5p9yJuRy+d4S2q5KFrnSOIohC+5JEiVDxmfOgteUjfK6BoQ2fw6zbQsMkpsrPhphhseci0FGL9R6E/z6FHgSx8KROWefvREkH07ltKRcmZsoyj0FgoMBYUAIA+KQgSoryOtQ66AKi4iYEeHzevH2K//CK8/9E16Pm6dNOGoqrrv1LoyfNGXvL5LCnOdgzfsIMkclf1+5C/CGFVDLgrAo/KiqbcT2CgeWlsmhVwJDYkJQ7X5G01VS7pLj5Cv/iuwj57GnobcNho6gUMz7/3kdb774LBrr63jaqHETcNv9D2PMEUd2rJbpqmRxKU1TIZdxNn+kUMNrHQQ3tHBv/hrK6k2QhdzQwYdKKQ5KfSwGGdxQmxPhiR2KZb4hKLED8fHxGDtuHBQ99KpQgqXbH+TGXFTuKUIaAsGBizAghAFx0BMOS6iweVBQ40QgJCHeqOHyQDpdf/p+ER5/4E6UFu9qfphef9s9mDR1RrtJe0pHBRI2vwJV3RbU2d2ocwVQFzbBDQ2y1XbEx1igS8rF0+8u4lLPBF24edl6jxwb6pXY3KiEzpqCL778oscP0N7C7Xbh3ddexGv/eqo5v4M8ETfdcR+SUztPflR46lhcStu4vZX0dsCYhqDaiOD2b+GrKYDP52bZ73qYYFEEEGgoR0m9G+/lafFtiRoJScm49dZbMXvW7B7rdNS7fHwcByWKkIZAcKAiDAhhQBzU0MOmsM6JsgYPexwoqz+aIPmPu//C4k9EQmIybr77b/wQbWk4hMIhrF+3Dg01lZgk34QRwU1osrvQ5HSiIWxAsZSIHK0bORZAl5DNja0ktQG7dhVy2XAwLMOmegXW1SlR4ZI3lzc+9thjPX5w9gUUtnn+8b/jsw/eZYNKpzfg+tvuxrmXXAWFogvjRpKgcpZDV7cB2sa8iJQ27TOVESB57fLVsDfUwOb2wQ01lAhD7rMh4GjE6sowHl1ngM0v36d90TKkMSgpohkhqjQEggMLYUAIA+KgpdHlR36tE/XOyGiV3N3hcBjvv/0qnn74AU4qVKpUuPiq/8MV/3czDEZTq+V/XPIjnnjicWSGy3HNSA+yEvTQmGK4oVWelAaNRoeJVjuMcWkRw0Am51JIbmKl0mN5WRh3vvgFiiv2uPyTkpJxy623HBDGQ0u2blqPR+/7K9atWtnsiXng8ecwcMiwbi0v9zuhq9sIHQtMuZp7cSjcNdjw81fQGQxwaJKgQJiTLn0eNxrqm/D8RjW2B9Px+Zdf7pM3hsJS3mAY2XF6DIg3sJaEQCA4MBAGhDAgDtqQRX6NE8GQxBoCJApVvKsA9936f1j7+wqej/Ib7nvsWWTlDNzrO8h4eO5vt+DsXA9mZilgtMZCp1KgQorDDn8sJlmdGJqeAEmpg9Jvg9+YynoKlBDpSpkIb+xw7l4Z9WDU1dXtc9y/vyDj6qN338RT/7iPwy9kXJFhdeX1t0Kl6maYIByErm4zDFW/s1JlZUU5fvvxC8RrJcTolQiakuHQJiNbVoOABHgcNizJc2PkpU9i6OR5+1yl0eD2sfjXwESjaMolEBwgCANCGBAHFb5giEWhShrcMKiVMOtU7Jp//61X8eRD97J6JLnp/3znAzjrwstaVx/sRvLZ8dx18zA9vhG5yRZodToEoMCmUAbcNWUwO4uhUmtx4oxxkNQm+MwDuAkVyTx74kf1Wtvr/UVVZTkeuvMWzg8hSITqkedeRWZ2Tve/ZLchUfbT21j2w0LEasJINYS4T4fFoEWFYSgG6FzQgTwIEmTmNKTMvByu1KmcmNlTgiw85eMQ1cAkI3ucBALB/kUYEMKAOGiwewPIr3aygmHc7rbbTY0N7HVY8t3C5rLM+x59pn1Vxt2aDrbf/4uKTT8jKcbAnosaWLGdKh9rdsIALxJ0EiwaCaljj0FM1mjuA+FJHLdPD74DFbqUF33xCR666xbYbU1sdN3xt0dx8lnn9yjXYO3qlXjr/isxLTUAo1LC0BgqYZWgUwLViiTExMcjUeGKCFKZByB16ER4c49HwJS5T9tc76LyW4nVK9Nj9KLUUyDYjwgDQhgQBwU1di921ji5eVSiKdKEafXK5bjjhqtQXVkOlVqNm+/6G8679Or2qytcVTCXLIancgdqC9ZCHg5Aggw7PSaUFZch7GnCQHMIyQYJdr8MWxsUGDz3cgxe8H+QSHnxEIVEte688Wrel8RxJ5yCex95GmYLNQTrGgrhnHjiifA0VmF2mh+j4wIYaAlxdYonKIMzpIIiPguZxiAkyNGgSEBq9nBYB06EM/3ofTLKnN4g7F4/MuL0yIk3thIJEwgE/YcwIIQBcUBD2filDS7k17qgkstZGIpi+S8/+zhefOpRfj8gZyAe+9drGDZyzF7LU48JQ+UKqCpWo7QoD2ikck6JNR02V3qxq6QKWaYQhseSjoOEYqcCP5Sq8H2ZBg898wrGj5+w3353WJJYUyL6v4Q9l5+MgwUARWjIixJ5RXpj9HhdoRDe+PczeOGf/2BlzowB2Xjqlf9g8LCR3Vqe8kluu+02fp+uD2L+AB/GJQSRawnD6QcGjhgHpSUZtoo8uEJyNMEIKXYQRg8ZCM/AExHUJ+yTYFit0xsp9UwyNVffCASC/kMYEMKAOKDzHUjbobTRA4tWxclzpLhII+Zo/P7kM8/DHQ8+Br3BuNfyalsRTKXfo66mCtW7NkEXtEOBEOTGBPyyoRDF1TbMTvMhRishEJJhRbUK/92pRaFDiaTEpD7VcaBmUpGX1Py+JWwQkHFApgLZBLLINCJ6FZJBETUwwuHdhkaL71DIZFDKZVy5QOWQ9H9n7bM3rVuDv1x3KSpKS6DV6nDfY89gwalndev3RCpankBNdTXkMgnTUwI4Z4QSx45IhDUmhtU3A0ojmsrzUOEMoUkyok6djsmDU6Aeciw88aN7LLYVLfXUqOScXClKPQWC/kUYEMKAOCBxeAPYWe1ArcOHBKOWH4C78nfixivOR1FBHtQaDe75x5Mcs2+LLOiFsfxnKKs3YnNxDWQNedDDC50CMKcOhj7rSFRsWQHP1kV0VrMA1MtbtfipQk1KBr2u40CjZU8gxP8HuJEWPdRl3OBLqZBDr1bAqFHyb1TKaVrkwU8P+6h3gZ6LMrISlv8CVFZBSk4Gpk5FWC7f7a2IVKcEwmGuTKGXNxCEJxCG2xeCPxRiYyUUcWXwujT8UvD7KJRT8tfrr8SvP/3Af5932dW45e6/d6tKo21FyoQhaYgr+BTGil/5mAS1sQhpYxGszUNRgwfFwVhUyeIxJj0GA4aNh3PAsdw4rKc0uv3wUalnvB4D4kSpp0DQXwgDQhgQBxw0qtxZ5YCzRb7Dkm+/xp03/YnLD5NS0vDUy//hbpltITlmU/H3qKurwebCEsQGqmGWuRFj1MOSPQ7B+OEwly7hdtpNTU34aF0DHlwehjMo7zUdBzIUSI7ZGwiD/tEDTadUwqRTwKJT84iZSkbp4U2GRLdGzZ98Atx4I1BWtmdaejrwzDPAaad1uigZFvSApe0irw5tm80T5P1Lf5NhQY4JrVLB+QRKmYQXn3qEG45Fy2GfeuUdWGNie74zwiGYir9D3Pb/QhbyRvqCGNOgrtuO0kY3VnlS0CgZkWbVYsKwQfANPY0bdPUUUeopEPQ/woAQBsQBA51e1OWSKi3oRIszRBLs3nzpOTz10L3ND7Mn/v0m4hIS98p1oP4V6ur12FDahMqaSgxADWJUfiTGx0OeNZV9/6bKFfwgI02HuuEXwZ42o1d0HEgR0+ULwhsKscFgUCt5+00celGwSmZn4YMujYczztgTu2j+0bu/76OPujQiOiqNJM+I2x9ij0+9088PYl8ozF6PtcsW4+9/uRZOh4M7fD7/1gftamp0B23dJiStfRpyvx1hBXX+zIK2cQcaXD4sakpFbdiMRE0IU4amQzHqtH2q0oiWepp1SgxMNLE+iEAg6DuEASEMiAMCuvkX1buwq84FnSoiSU0JfQ/fcxs+fOd1nufsi67gplBt3elUYWEp+gaOhmqsKKhD2GPDIHkZkgwKxCUPgCf1KGib8vmBxQmUMYNRO/oaBI2pf2ibaURPD15vMMQjd9pmSuojbQqTRtk7JYahEJCV1drz0NaIIE/Erl1AV9LUXUCXNxkT5JlocPn5tW3rFtx97YWoLi/lyoynX3kHEyZP26fvV7iqkPLbQ1C5qyDJFNykS9e4nT013zUmYasvHkkKByZmxyNu7AnwJIzZp99A2x2iUs94AzJiDftuuAkEgk4RBoQwIPY75EYnVcmyRjesOjWP1ilUcdt1l2PZj9+xi//Wex/CBZdf09rdL4Whr14NQ8Wv2FFpw++lLqRI1Riiqka6VQdV8jD4zdnQNW7jttXkPnemT0fj4LNZYXJfoERFhzcIlz8AhVzOXT+TLTpYddT9U9H7SXxLlwKzZnU935IlwMyZvbrqqIGUX1SOyy84C1s2rIFSqcLtDz2JM8+9oDmpsyfI/E4kr36Um3VJcur0mQtdww7On/jJnoIf7GnIlldhWLIZA8cdDXfm7H3qZEpGEHX2TI/RsWaEjnqtCwSC/fYMFUFFQa9D8XjKd6iyeznfgdz/1ADquovPxPYtm7ga4OFnX8Yx805stZzc74C5aBHQWIxlhfXY1KjARHkhsvUepMWY4U8ai6BSDX3tWii8jfCZs2HPOh7OjJnNDa96AiUq0gPJGwzCqFFhYIIJcUY1zFpV34oZVVb27nw9gJIr44waxI3Mwa+//IQLL7oYX3z6MR66/XpUVFbgwqtuhEWv7lHSoqQ2omriXUhc80/oazdAayuEJ2YwtE15mG2pglGnwztVOZAqd8Hm+R7j/G54c+cDPQwrUVIqJYmWNXr4HKOQBpUACwSC/YNIbRb0KjZ3AJvLbah2eJFs1vGDqKy4CBefdjwbD7HxCXjtg6/2Mh7Utl2I3fYObJX5+HJLLdY2anCMYh1GxwSQkRgDf/J4NhL0dVsgCwXgSRiLhuEXwMmj2Z6dxlReScqX9NKp5RiVZsWErBjkJhph1av7XgkxJaV359tHzEYDPv3oA9x+++389xtPP4zXnvwb6hxeVNoiD+nuIim1qD3iJriTxkMWDkLrKEbAkApJocJEbTGuy63DBgxGWZMPK1Ysg2rbx5zj0lPofEqxaOHwBLGxrIk9XJRQKhAI+h8RwhD0GlSeuaPaAa8/1NwMa+e2LbjmgtNRW1PFYkYvvfsp0gdk7VlICnO4gho5bau04/tSCRrJj/maDRgQo4XKYIEvdig/bGhE69cnc7KeLfckBEzpPTYcqNsnqTMkGNVItep4BEtll/1KNAeivHzvJMpezoHoLk899RRuvvlmfn/2eRfgroefRr0nxImkFILqbgUEtf6O2/w6DNWr2XgIKfVQ+B2QSSGU6ofhmfwEDAzkw6oBjho7CrLRZ+1z6MnuCcDlDyIjVoecBCNXwAgEgj+GyIEQBkS/QyPWHVUO1iMgFzmxYe0qXHfRmdyXYdDQ4XjxnU+QkJTcqp20pWgh0FSCFYX1WNIQi1GyQswylCLVokZYHwefdRAUAQdUrir4zFlsNDTlnoywxtozw8Ht51yHBKMGaTF6rqbYrz0XolUYRMtL8A9WYfwR3n77bVx22WWsYnnCCSfgtbffhc0v4y6pHl+IQxsURugKhbcBsVvfhr56DaBQc88M8krIpRBqTMPwdF4i0jw7YFYGMWnkUGgnnI+wyrDPuTZUIkwGK4U0hHqlQPDHEAaEMCD6DTp9Shvc3NNCo5BzCIBYuWwpbrj8PHg9bowZPxH/evMDmK17HvqUAGnZ9TXsNht+zG/Cb54UnKD4HZOsDsToFAgYkuG35kLpruGHD7nD/ZYBsGWfwO7y7uY4NLn98IfC/IBJPxAMh650IDIygKef7nfjIcpXX32FM888E16vF7Nnz8YXX3wBSalBlc3D5bjkkYjVR5qedYbSXc0hKWp0FlbqIQv6IMnlnJDaZBqC53clwty0HVa5F0cOHwTTpIu4O+q+QMeZJLBpmwYlmpBk1gj1SoFgHxEGhDAg+gWKPVOJZmGdE0a1CkZtZHS6fOkPuPGK8+D3+TBlxmw8+cp/oNfvHmFKEvQ1a1nfoajOgYW7QigLWnCudgXGxAShV0rNngalp571BejB4okfCUfGMd1KvKNT2u4lUaUAhyhIyZBKMQ/I0j8KZyxbFkmYpJyH6dP7LWzREcuWLcP8+fPhdDoxY8YMfP311zAajVy9QTkH5U1e7toR00WypbqpADF5H0FbvxVhtQlyXxOk3cfTbcjAq8VJkNduhVnuwRFDchA75RKeb18hLxNVmWQJ9UqBYJ8RBoQwIPpF46GwNmI80IOEyjSJX5Z8j5uuPJ+Nh5nHzmOBKJKoJiiPwVSyGJr6HVhX2oivKs3QwIdzDBswxBKEQh6GL3Y4gto4yIMehEkCWa6EM20a3ElHdqv0jxL/6EFi1KowIFaPJHNEMlvQM1auXIm5c+fy9TR16lQsXLiQrye6XTS6Ayipd6HaTkmoSi537WjEr6tZC1PxYugatiOkMrBRGNKYEdIlwK+JwTvlSfBUbINZ5sKo3Cwkz7gUYY1ln7dbqFcKBH8MYUAIA6JPoZyCvBoHSurdiDPscWcvW7IYf77yAjYeZh03n40HaslNKLxNsBR+gZCjBssK6vFNYwaGy4twWswuZGj97N72xo+OSB7zGSmxt8E24Hj4Yod0y6Cpd/m5WVVGjJ7DFUIn4I+xatUqHHfccSwPftRRR2HRokV8bUXDBmRAFNa54PQGmnub7AUphZb+CF31mojol0wBecCFgD6BjYiQUof3q1LQWLIFVpkTQ7MykDHrij9kRNC5QFVAlPw5MMnI3ieBQNA9hAEhDIg+g1zE1BCLXNktHxokDnXTlRcg4PfjmONPwGP/er3ZeFDZiyP5DnY7FuU5sdyTiVmqzTghthJxSg/CSh0rFAZ0CZCHg5CFfBx3b8qhSouMTreHTt8mT4A9D9S5kVzXMUIboNdYu3Yt5syZg8bGRkyaNAmLFy+GybQnzEBS38X1LtZmoL4bVn073ggpDGv+Z1A35nEljUwK8jS/KZMNBVKw/KwhAxX5GxEjcyA3Iw3Zx1wJaR/6ZzSvUpLYoCRDlCo0yKg8YHJfBIIDmJ48Q4VvV9BtKIFue5WdjQcSiIoaD5Qw+eerLmTjYc78k/DYC29EjAdJgq5mHWLyP0V5TQPe3hrA755UnKpfjzMTKhAndyKotsCdeARLUcvCITYeSF2yYfDZXRoPlIFfYfNybsOodCu/hPHQuxxxxBH48ccfERMTg99++42rM9xud/PnFCIYmmzG6HQrVEoZKu0e9gC0QiaHLWcBQoYk+Ky5CCu1fKzVznKujCFOiS1F1rAJaJRMKCgtR97ilyHzNu3zdpMRQ54HrVLJ5cF03tL5KxAIeg9hQAi6Bd18qUyzosmDpN3qksS6VSu52oLCFrPnLsCjz78W6WtBHRtLvoepdAm2lDfitTwtGkM6nG/ZjAUxFdBLLgQNyfAkTYAreSJU7hrIQ14EdQloHHI2Qrr4zkeXTh/H4jPjdBiXaUWaVXdgJkkeAowdOxbfffcdj0Z+/vlnnHLKKVylEYVG9skWLRsRJB5G4YO2IlTU0rsp5wRueOY3ZnAbcAplkOR1UBPD88w3FWDQiIlsRBSXV2D7opcAn+0PbTsl9pKnrKTBzQJnpDwqEAh6B2FACLplPNAortIWUZeMCi9t3bQe1118FpdqTjn6mEjYQqWCLOiBNf8TqGs2YnlBA14rSYZF5sL5CbtwtKEESimAgDEdztQp/NLXb+YES6q8aBx8ZqeZ+LQtpEugVSswJt3C/RWiCZyCvmPChAmcSGkwGDiMcdZZZyEQaP0wJm/EiFQzl1I6fEE28lpGSMkotA84joWjgvoENhYVATv3PvFZIh1BjzXkYejYqbBJRpRVVWLLwn9D8v4xI4I8ZXTeUnLtprImzt04xCK3AsF+QRgQgi6z2sl4oL4WlGMQHeUX7NyOP51/GpwOO46YOBlPvfIfrragHhWxO/6HcEMRFm1vwDu12RiuKMX5KVUYp8hnd7bfkgVbznyWozZW/sreCp91IBoHntahxkPU60AjyOx4I8ZmWJFo1op6/36EqjFIF0Kr1eLLL7/EhRdeyKJTLSHjkiTBR6db+MFdafdywmUUSoilkBV5IkjrI6QyQeWpgb56FTwJo3me2ZptGDp+Jmwwoqq6Chu/JiPC/oe2nc5bMiLCYWBTmY0riFpul0Ag6DnCgBB0aTzQiC3FvCdEUFZShKvOPQVNjQ0YMXocnn/zfeh0eqgcZYjZ8R6cjTX4eKsTC+3ZmKnejvPTazEwlM+CQn5rDhqGnI+gPpm1IChPwhM/CracE7hks6PETfI6aFRyfjANTjJ2KWQk6BtIXOqTTz5hT9P777+PG264od3RPOXIjM6wIt6oZhEqqtyJ4kybjoAxjdUnfdYcSHIVtI3boWksiBgRkoSZys0YPuk42GFAXW0VNpAR4XP+4e2nHBmTVslVRHRui7wIgWDfEQaEoEPjYWuljRtOJbcwHhrq65p7WwwcMhz/fudjGE1maOu3ISb/Y9TUN+GdrX6s8yRhvn47zk6tQZK3iBMjfbHDUDP2BsjDXhgqV/D3uVKOgiNzTocNscjjUOf0clnmGOF1OCCYN28e3nnnHT4OL7zwAh588MF25yPZ6xGpFqTG6Pg8an5YU3lu9gI2ICSlHp64EZT2CFPpD9RbHd7YYVylMR3rMeyoeXDCgPraSqz78gVIPtcf3n4KeZGBUybyIgSCP4QwIAQdGg/UHKul8eB2OfF/F5+F4l0FSElLx4vvfAyrNQb6qt9gLvoGBdU2vLZThZqgHvMsRTgtvhRmbyVCGivcyUei+oibeaSpq1nP3+fImAVX6pR2BaKiOgOUpT8y3YrhKSLX4UCCciCee+45fn/ffffhxRdfbHc+8hQNSzFz2Kne5eOyT4LUKG1Zx/OxJ3VKb+xQLrmM2/YmvJYcDmmRhPl0aR2GTD4RLujRWFeBNV++gFAvGBHc1dOqQ5M7wF096VwTCAQ9QxgQgnZLNdsaD5Qwd+s1l2LzhrWwxsRyY6zEpCQWCTKWL8fGMhteLbRCFfZjflwNTjLthDpoR0gbA0fWsagdcx1M5T9D27A9UtaXPR+exHEdbkOV3YMYgwpj0iMVFqKG/8Djuuuuwz333MPvr732Wnz88ccdPqwHJRoxNDmSXOn0RoyIgHkAXLsVRoO6OPgNaZxMm7T2KThSp3DXVVk4gOlYg8FTT4UHOtjqyrHmy38j7Pf84e2nbrGkVCpRXkS5DUV1TpEXIRD0AGFACFobD5zz0Np4oBj3/bddj1+WLIZWq8Nzb76P7JxsWAq/gqZmPVbsasBbZUlIk9XhxFQH5qg3cfvmsNqChqHnoX7ohSwkpbYXcbybumlSi+72oOZXTR4/cuKNGJlmgUUvuiseyDzwwAO46qqr+Bw577zzuMyzPcgAJJGvIUlGbsEdNSJcKZMRMKayLoQ3bhhCahOU3nokrX8Otqy5nCtBjbimSWuRO+1seKGFo64Mq758EeGAr1d+A+VFGNVK7Kh2Yke1nfVFBAJB1wgDQsDQTZN0HqpsrastiOcffwhffvQ/KBQKPPHimxg7ehRi8j6Boj4PS/Ma8L/qDIxQFOOUDA8mhdexkUAKg9XjbuD8BmqopHJWRNQlB50OvyW7w5AFdWkiw2FQkhEapUiUPNCJ5kGceuqp8Pv9/P+OHTs6nDcjVs9JsGREUHMuzofImsfnhiLggiN1eiSpsn4rYrf/D005J3K5J2lGTMMa5Ew/GwGo4awtxu9fvoxQkNQm/zhUghpv0LA8+9YKO5y7Qy0CgaBjhAEh4CoHMh4qbR526bY0Hj57/x288twT/P7eR57GzBnTELPzQ4QaS/DNjkZ83pCJicp8nJrpx3DfeoSUeq73r5x0D7xxwxGz430oPbWcMNc46Cwebba3fgpZkAwyiRFRIySRKHnwQIYlJVWS1HVDQwN38qytre3UiBiSbILbH2IjgoxNe+Zx/LnK18hVGhTmoqRKY/kvaBp4KkIaCxQ+G6bKNiN96jkIQgVXTQF+/+o1hEO987CP6kXUOHzYXGbjsmGBQNAxwoA4zCHZ4fwaB8p3K0xGRaKI35b/hL/99SZ+f+X1t+L0U09kg8DbVIkvttmwxJ6G6Zo8nJbpxgDPJq60CBpTUT7lQY5px+74AApfE9/8GwefzeJBbSFXNlVZZMbpIyELnQhZHIzo9XrWiMjOzkZhYSFOOukkeDyeDo2I9BhdsxFB54AvZhD3Q4nijh/D+Q8xeR9CbStE46DT2QglY3S6Og+pU85FEEq4q3Zg5ddvIBzunbADGc8pZi1vF+VFkPKqEJ0SCNpHGBCHMRQ2yK9xssxvW+OhMG8Hbr7qQgSDQRx/0um48bqr2CBwNtXik61OrPckYKY2H6el2pDkzkNIbeU+B2VT/8Gjx5idH0AecCKoi2fjgbtstoBuynVOH7zBIGfpD00yC22Hg5zExERWq6S+GdQOnISmwqTc1EU4w+mPNENzpM/g84VauftNGfCZstgAjdv+DhR+O5pYaEwDlbMc0wxlSJ58DsKQw1OxBSu/eQdSB+vqKbRtCSYNlHI5hzN21QnRKYGgPYQBcZgSDkvYVetEUb2bmw5Fe1sQ9XW1uO6Ss+Cw2zF2wiQ88uA9iM3/CA2N9fhgmwdFfhNm6EtxWnINrN4y9jzQ6LHyqAeg9Ns450Ee9LLSYESa2thq3XQzJoVCrUqOkWlWZMYZRJXFIcLQoUPx6aefstAUVWXceeednc5PRkRugpGTZ72hSHWOJFdC5amFO2kCGxRqezHnQ9D0ppyT+X9NUz6mWRuRMPFshCU5PKXrsGLxB71mRBDkDSPRqZ0iuVIgaBdhQByG0OifWjAX1DoRq1e3Slakplg3XXE+ykuKkTEgG/9+9gkklXyF6vomvL/dj/qAGtNMVTg5rhQ6fwNnzVPMuvrI26FyVXDbZirFoxFk06AzuO9BS+gmTPkOiSYNd8+kkZ7g0OLoo4/G66+/zu8fffRRzo/obLSfFWdgnYgGtw8eVSycaTP4M7W7Es7koxBSGaCt3wJr/sdsUNiz5nHpp65uE6amSIgbfwrP79m1EiuXfNGrv4W0RxKMkeTKbRX2vZqECQSHM8KAOAyhdtz5tU5Y9Wro1IpWhsWDd/wZG9b8DpPFgtdefBZZ9T+hrLYJH+wMwheWYbqlHgssxVCF3Gw8kBhQ7djroGkqgLXwSxb/IREgSnyTFK1ba1NmO4UtBsTpMTzVzEqFgkOTCy64AHfccQe/v+KKKzik0RHkfcpJMCAzVo9apw/22FEcDiOBBnk4AE/cGC4L1tdsgKXwS/gsOXBkzOZlDRW/YkqOFZZRC/hvd95S/LZsUa/+lmhyJXUZZeVKt1CuFAgIYUAcZlCZ5s4aJwxq5V7Kju+8+gI+//C/kMvleOmpRzAqsA5F1Y34OD8MhRTE0TGNONZUCEXYz5nzTYNOQ8OIS6Cr3wJz8SK+4VPlRXt9LRpdfi7do3yHIUlmUaJ5GPD3v/8dJ598Mnw+H7cALy0t7XBeyr8ZmGhi0bAaatWecSw33KLch6AhAd6YIVB4aqGr3cjiZZ740XClTOJlzSU/YMrIXJiGHcN/O7cswuqVS3v1t0Sbcdk9QWwqb2KhNYHgcEcYEIcRNPrfUWWHSi6HSdu62mH50h/wz79HVAUfuefPmB1fg4KqJnxaIEEHL46Os2GGrhByKczqkg2Dz0bToDO5FbOp5IdIU6zEsbAPmNuqrwVJUZO+A00alWZhMSGR73B4QIYohS9Gjx6N6upqNiZcro5lqFmxMsnIYa0qjww2OpdouqsKPusgfmlsBdBXr4Gudj1cKVPgiR/J555l10JMGT8BxoFTeZmmdZ9j/brfe/f37FauDIYkbC5v4solUaEhOJwRBsRhArldt1c5qFcRYvStQwu7CvJw23WXcsb8dReegguPMGF7RRO+2AWYZS7MjLNjsnoXGwYUg24YdiHs2QtgqFjOdfqEK3kiHOmzWvW1oBJR0pYw65RsPNDNV3B4YTQaubwzISEB69atwyWXXNLpQ5cqcYYkmzmBsVyWBHfSeJ6u8DXAbxmAgCGVjQhT6VKoHcVwZBwDv3kA591YC7/AUVPnQJ85DjKZhJrf3sfmLZt6/TfFGTVQKxRcoVFU5+KEZIHgcEQYEIcBlHuwrcoOrz/EFRctcdhtuOGyc7ni4pSZ43DHqaOwtbwJi4qBGJkDx8TbMV5TzJnvQX0S6kZczvFnU/lSGKoiIzxKonSlTWtlPFCyZLXDx6JQpO9A+RaCw5MBAwY0twD/6KOP8Nhjj3U6P+XGDEkyQaWUo9RyZESJMuhFWK6B35jOSpUqVyXLo1OIg0JmUbXKmF1f4Kg5Z0CXPAwKhFC+7G3szNvZ67/JrFPBrCX5awfyapxsLAsEhxvCgDgM+ltQ2II8EFT50BLyONx1059QXJiPqcNS8M+r5mBbpR0/loURI7PjuEQ7RqvL+IZNPQnqRl0Bd+pRMJd8F+moKZPBkXkMd9psCWWq17v8GBCn45wH0UVTMG3aNDz77LP8npIrv/322y77U1DzraBMjorUOc2lnaRkSkmUCl8jFN4mWAs+4xBG08BTEKY+Gp56xBQtxKT5F0ETnw0lAihc8joKS4p7/TfReR1n0GBXnZO9e6LMU3C4IQyIQ15l0skJXxQ+aCsP/cqzT2Dp4m8wMkWLF246CQUNfvxSHoIVDhyf0IQhikqE5WruikjGgydhLDfQoj4FFM6wDzi+lXogYfME4PAGMTjRiMFJZs5gFwiIq6++GpdffjmHMM4991xWrOyMRLOWu3g2yqxoSJrC08jzENQlwmfJhcpRCoWngT0RpFLZlHsKV/6oHaWIKV+Ko068EmprKlRhL7Z/+yrKq2t6/TdRyCXRpOXKJgppiDJPweGEuLsfolBctrDWxTc2usG17G9BLPvxO7zw5MPIjZHh2f+bj0q/BisqAjDDiXkJjchV1vLNmEoy60deCV/sMFgLPmcBH26AlHMCd09sm6RJRguVaGbFG/Zap+DwhgzYf/3rX9wzo7GxkRtvdZZUSaRZ9awTUaIbBo9pAJdzysJ+LiEmrxhpj5DQlLF8GUulcwWQTA5twzZYGjZi0knXQGWMhybkwPqvXkRdo63Xfxclf0Z6aHixpcIOOzUJEwgOA4QBcYhS2uhm1yq5WFuqTBIluwrx1xuuxAAL8OD5R8FnSseaSh8bD/MT6pGlaoCk0HDL7fqRV8BnyYY1/1O+UZNR0Zh7ChsWbSstKGY9Mt2CVKtohiVoH41GwwqVSUlJ2LhxI2tEdJZUSRU72QkGpMbokRczAyGlLlLaqYtnr0N4999UmUGeMfKW2TP3aESYvOWYcOKfoNKZoQ004NfPX4Ld5e713xUt8yRFza3ldi5bFggOdYQBcYhqPVBil1mn3qu/hNvtwp+vugBWyY6b52YjZtB4bKpywSRzs/GQobJDUmjhiR+BupGXw29M292OuzzSjnvgaQiYB7SSpSZlyWilRdskTYGgLWlpafjwww+hVCrxv//9D88991yn83N5Z6IJ1phYFMVN52lqVwX8hhSEtLFAOMACZqaS76F0VcEbP5plsAlz8XewKPwYs+BqqNQ6GLwVWPLZq3D7ev8Bz2WeJi1cviA2V9iEVoTgkEcYEIcYNPIh3X61Qr6X0iON9P5+581wlW/DlZNjkDPpOGyvdkIn82JeXB3SVU6EyXhIGI36kZfxKC925wdQumsQVunROOjMVu24A6FIG24KkYhOmoKeMH36dDzxRKRN/C233IIVK1Z0Oj8ppg5ONCEUNxh1xiGcOKn021nmOqSJhSzkYyPCWvAF5H4nnGnT2EtG0ywFnyPGZMCI4y6FQqmC0VGIxZ+9jUAfJD2S541yN0IhCVsqbFzGLBAcqggD4hCCRj5UVhYMSntpPRAfv/c2fl/0AS4ao8HImSehsM4FlSyA4+PqkKJ2IaTQwZM4BvUjLkNYZUbMzveh8DZwdnvj4LMQ1Ce2qu6gmG96jF5UWgj2iRtuuAFnnXUWd3yl/2trazud36JXYXCSCdVJ0+BRGLlskxRRIZcjrCDPl8QdYC2FX7Aqqj3reD5nqbsn5e/EpwzA0JnnQyGXw9i4Gd98/TGH3/oC0opQyGTYWmnnPCQhOCU4FBEGxCEClZDlVTu4XLO9BlVbN63HS/+4DReOVmHE0QtQ5fBDIQvi+NgapKg9CCsNcCcfETEeFGpux63w2RHSWNEw+KyIq3g3lGne4PZzAyQqtRNtuAX7Olp/9dVXMWTIEJSVleH8889HKNS5V4CqibKTYlGcMAshCVA5KxDQp7B0ugQZJ1CSciXJW1P5MVVmkCQ2lXeSWmVy7mjkTD6N122o/BWLf+i8nPSPwL1mlApsq3Rw8zphRAgONYQBcQhAeQiFtU5U2b3tlmvabU247/qLcM5QCQMnTIdXUrJS39yYWiRrfAirTHAnT0DD8Et5fjIeaCRH4jyNQ86OjPJ24/QGOct8YIKRS+yoh4FAsK+YTCZOqtTr9Vi8eDH+9re/dbkMtX+PSx+EcuMoSLtVKkNqC5kPCKpNZJpw905d7QZuJd+UexIbE2rbLq7WyBw1DRlj5/B3yfO+w08rfu2736dVwaSJtASnqiihWik4lBB3/4McGtWU1LtQ0uBBgnHvck3Oe7j1ahwTW4nM4WOgNccgLAOOtVYjRetHWG1mGer6EZdCFvJwwiSp/gUMKWgcfCZnukehDHNXIMgqgdQ9UfS0EPQGI0aMwMsvv8zvH3zwwS5FpugcH5hoBHJmsEYEna9UNUTeB6XPBv/uPB1T2VLWiggakmHPOo6ncbVG3SYMmjgfyYMnQi4Lw7P+E6za2PuS11EMGiXnB1EHXNJlIYNfIDgU6BcDgmq/s7KyoNVquQb89987bnLz5ptv8gi65YuWE7RPtd2HgloXLFpVu6JN7778NNJrfkRG7mAkpGYgCDlmWWqQrA0gpDbDmTIJ9SMuhtLbgJj8T7mngN+ciaZBp0NS7tnv9U4fQpKEEalmHgGKMk1Bb0Lhiz/96U9s8F544YWoqKjodH4Kmw1OjkHTgLnwBAGlp4YrhgiVuwY+UwbnQZDIlNxvhy9mCFwpk/lzc+mPXFU0/OizEJsxDCpZELW/voNtBUV99vsoRyhWr8aueid2VtuF9LXgkKDPDYj3338fN998M+677z6sXbsWY8aMwdy5c1FT07EqnNlsRmVlZfOruLj3ZWgPBcgjkFfjYMOBRjlt2bT2N9R8/Qiyc7KRkTsIAcgxw1SNVF2QcxucKZPRMPxiqJ0VrDCJcIgz16OKfgTd0ClZUqGQYUSqhXtbCAR9wVNPPcX3B0qm7E4+BCVVZmVloy7+SK4IUrmrENTFQRYOQB4O7u6P4ebKDCr1dKUcBW/MYD7PLYVfQhF0YezcS2BOyIAGPuT/8DpKqzpP5PwjkNFDuizF9W7srHbwNgsEBzN9bkA8+eSTuPLKK3HppZdi+PDhePHFFzne+frrr3e4DI1uk5OTm18kOiNojccfYq0HXyDcbsWFvakRSx6/GAOz05AzZAh7HqYYa5CuD0WMh7RpbDyQsqS5aBGP1rxxIyJKfnJlC+PBB71agZGplnaTMwWC3oI8jR988AF38Fy6dGm38iGSzVpYh05HkyoBUtDPiZTRZlvUpZOEpqgMmZIqCXvW3D2VGYVfQCaX44gFV0FnjoM+bMeaha+g3u7ss9+oUUakrynkuKPKAX9QGBGCg5c+NSD8fj/WrFmDOXPm7FmhXM5/d1b37XQ6uYNfRkYGTj75ZGzZsqUvN/Ogg9yf5Hmod/rbfajTg/+rhy7EgDg1Bg4dhiAUmGioRaYhjKA2Bs70GWgYegF0dRu4LTLhTjwC9gHHcRyZoPK2SrsXRq0Sw1Mt3NxIIOhrBg8ejJdeeqk5H+KHHyIP/s4GGwPiTcDQE+EMyKDy1CFgSObPdLXr4UydGpG2rt/Kf4MrM05iXROlu5aFphQaI8bNvwoarQEmfw1+/vy1PhGaaimMRY3tqLxzO3XJDYgmXIKDkz41IOrq6tgN2daDQH9XVVW1uwyVdJF34vPPP8c777zDHSOnTJnCZV7t4fP5YLfbW70OZcg4KKp3oaKJBJw0rH7XlhVvPQC9swCDho/gm+c4fR0GGCPGgyNjFhqGng9j1QoYKn/j+Z1pU+FMP7q5HTcleZEATpxBLQSiBP3Oeeed19x0i0IZHd0rWj6QszIz4MmYzp65SMOtBBaR0tVvihgRnFT5E1SOMk4ctmVHe2bsgL56FXTWJIycezlUKjXMrl347vN3EezD7pq0zaRaSdcxeSKEESE4GDngqjAmT56Miy66CGPHjsXRRx+NTz75BAkJCc2jkrY8/PDDsFgszS/yWhzKVNq82FXnRqx+7x4X/Pnvn6Put/9h4MgxUMmB4dp6ZBlDCGpj4ciczYJQptIfoavd2KId96Rm4yG4W12SXMOU89BWzVIg6A+o9ffIkSNRXV2Niy++mAcSnUHnafLwqXAZ0xAM+AEpxHk8Klc1GxLe2CG7kyq/gtzvQMCUzsY0L1uxHGpbIawpORhy9LksNGVq2IBF337Rp9oNVAJN/TMqmzzYXik8EYKDjz41IOLj46FQKPgm0BL6m3IbuoNKpcK4ceOQn5/f7ud33HEHbDZb86u0tBSHskw1hS50KgVL+7YlVLMDm/73ALKGj4VBGUauuhHZpjBCunjYBxyLpkFnwFK8CNrGnZGOmtnzW7XjpqSuaoeXm2ENTTG3uw6BoD+gPClKwNbpdPjuu+84wbIrEs06GEedBHdYAbmnHgF95B5jqPoN7vgxzUmVkYThIJ/7JNtOstgkMkWqq0kDxyF74omsKaEt+Rk/LV/Wp7+Tm3BZdNy/RhgRgoONPjUg1Go1xo8f3yqOSSMJ+ps8Dd2BQiCbNm1CSkpKh939qGqj5evQTZp0IBCU2g0pKDz12PD6LUgcMBCxaj/SFTbkmsOQdHGcONaUezJL/KrtJTwyo7+ptK2lkmVUmnposlmoSwr2O5R0HTUcaKBA+VRdkZaSAtnAY1jWnUo1A/ok9jyYS5fAlj2PG8JRiMNUuoTnd6TPYm8ElS9TZQb11BgwZiZSRkxjsTXfps+xdvPm/jEi7D5sq7TztS4QHAz0eQiDSjhfeeUVvPXWW9i2bRuuueYauFwursogKFxBN4colHlNI47CwkIu+7zgggu4jJPa/h7uSZMNrvZlqqknQMXnD0JSq5Gi8SJe7sAgCxkP8VxVYcuah9j8T9idS1npjYPO4LbHUWjUU+/yYUCcHkOSTe3qSQgE+4OrrroKp512GgKBAM4991xOsO4qLJA27CggNhden59LOrkSw1MLbcN22LIWcLhOV7cJ2rrNuz1xC5rlrimpkhg27TTEZAyHUhZC1fJ3kF/St57NSDtwLartXmFECA4a+vxJcfbZZ3PXvXvvvZfzGtavX49FixY1J1aWlJSw1kOUxsZGLvscNmwY5s+fz0mRv/76K49GDkcoBkt145TU2F7SJI2cwqteR0lZEbIMfphlLgyxhAF9ApoGnsxx3ti8j6HwNiKkMaNxyDmszBeFblTc1yLOiMFJ5nbzKgSC/QVVWdAAJD09HXl5ebj++uu7XEavUcE67mQEFWpIrrrmJnCG6lUIK7XNglKUC6R0V7PaalPuiWxMaBrzOKmSEizHHncxDLFp0EhebPvuNVQ3NPaDEaHjMKKozhAcDMikQ6zDCxkclExJ+RCHQjiDYqOby20waZV7d7yUwjDmfY6fv/oPsg1e6CQvBlskyM3JaBp0GktUW3d9BVnQx625mwaexr0BWjbFIjGq3EQjN8ZqK4MtEBwo/Pzzz5g1axaHQP/73/+yN6IryrauhHfTF9BrNQgZkqF2VbDQVMOQ81ihUmMrZKOaqpIkpQ7auo0wF3/PHoqmgaeyl87vtuG3j5+C39UEly4Ns8+6AUZd3+qhUBUU9bVJNms4F0mEEwUH6jNUDDcPYKizZlRpsr122cbyX7D6h4+Qa/BADw+y9T7ITUlsPHjiRyOm4DM2HijGS9UXLY0Hpy8ImyfA7ZFzhPEgOMCZMWMG7rrrLn5PYdDuqNMmDz4SqqTBcHv9kAfdu0MZ9TBWruBW3ySoRh1nLbu+iQipxY+GJ34kJ1Wady2E3NcEtd6CsfOuglKthcFTjqVfvoVQHytIRsMZlBMhEisFBzLCgDhAoZsGGQ8dKU1S/Db/5/8hRV4PI9xIVTigjSVD4QyWo7YULWyWpm4ceFqrvhbUUZMMCMp3yIoXTbEEBwcUBj3qqKN4ZES5U11JXSuVCsQdcTKUWj0CTqrKiIRN9TVruPeLLefESJdOexEMlSv5M0fGbBaiogZd1t3VGqb4VAyZdSHkMgV0DVvxw+LP+/y3NhsRojpDcAAjDIgDuD13ndPXbtIkieE0rXoPGscuWOGCNdwEc3I2GgafiaAhKZJhLklcptZSmpqwewJw+amjphGZsXrRFEtw0KBUKllcjqSuKaTx+OOPd7mM0RwD08jjuY223FYMPzfZkmAu/hZBrRWOzIhKLhkQpAVB1wpdM1EJbMqTIJKzRyBj0sn8XlH0E1au/KWPf23L6gwvdlQ7uFJKIDiQEAbEAUhpw5723G2TJsmtGlz3X7hK1iFRZoM+0AArGw9nQVIZYKhaxfOR+h6NpqLS1ASFLDzBEIammJAhjAfBQUhubi6LTBH33HNPt0o7Y7PHQZc6FF5fAPC7EFYaOKnYWPErvHHD4Ekcy/NRTxi6viJKlfN3V2tsjlRrABg4dgbih07j9/b1n2Lbju3oDyOCFCtJbGpnlVP0zhAcUAgD4gCDtBgK6lys9dC2nJJq1BUb30Pd9mVIlTVAHbBDZ02Gc9jZkbbnDdvYYKCeFu6UPeqSUePBFwphWIqZtR6E8SA4WLnkkktw+umnIxgMstS12+3udH5qmBU37iRo9XoE7DUIGKKhjLVQOSvgSJuBgCGlVdgiYB4AZ8qUVtUaxOgZp0KfMhQKhFDy01uo7EJmuzeg0lRqwFXe5IlowYgunoIDBGFAHEA4vAHkVTuhgGxvCWlJgnr756jZ8B3SUQ1NyIWATIvQuItYqnePQNQp8FIiWAsa3X4EQiEMTzEjzSracQsObsj4JWn71NRU7NixA7feemuXy6gNFphHzeN8H6mhsFUoA5Bgy1nQImwREZlyJ0+Ez5LD1xepV8qCXsjkChw57xIozclQhj3YsOgVOLrQpujNBlylDW42IkgbRiDY3wgD4gCB4ptkPFByY2w7nS81Zb+gdvXHyAiXQRv2os7uh/6oSyAPB1gkh2rZGwefCb9lj0BU1Hig+O+wFAtSLMJ4EBwaxMXF4c033+T3//73v7Fw4cIulzEPGAdT2lAWpZJahTJWcNjCnj1vj8hU/RZ+H6nWsEDhs+1uey9xRcb4E64C1CaovPX49as32BvSH0YEhTVL6t0orHVxrpRAsD8RBsQBQHh30iSFLyje2Ta8oG7YicZlLyPVVwit5ENZvRO6sadCJZOg8NsR0saigQSidmeZt+ydwcZDqhnJlj1VGALBocCxxx6LG2+8kd9T9876+vrOF5DJYB17Iidh+mzV8O8WVKOqDAplkO5Ds8hUyQ/sjaDqJUqqlORK1o3QV6/mz43mWIw49lLI5Eoomwrwy3cfoj+gsGacQYPCOhd21Tn5+hYI9hfCgDgAKGt086gi3qjZS49B4amDc+lTSHBuhx5elNa74Usci7j4JJbpJVcsGQ9hjWVv4wER4yHJLIwHwaEJdeMl1Vpq+U36EF3p4il0FlhGHc8N6cL1BfCbMveEMsIBuJInwW/JbhW2IMPckTGzuXMn9dggkjNykDb5LH4fKvkNa1ZGKjb6GhKWitWr2QtR0uDq046hAkFnCANiP1Pr8KGg1gmzVg2NsrXiHN28Aj/9EzF1q2GGG2W2AMp9BgwZS6MkCd7YYayY11LjgWjYbTxQzoMwHgSHMtSt8z//+Q+XeH744Yd47733ul4mYxzMqYMhhYII+tytQhnkpbBR2EJthsLXBHPJYjYwvHGj+HrjluCFX0MWiCRuDhk1EeZhx/D7xvVfoWBn3zbeav4NagXMWhXyapycFyEQ7A+EAbEfoXyH/BoHmQowavdOmsTKf8NU+gMscKHSLceuahdGzziBE7lcKUdxfLalxkPU8yDtNh4ShfEgOAygjr9U0klcd911KCsr63wBmQymMSfAbDQgZK+E15i6R2DKVcWy1pRUGe2Noatdx8s4Mo/hcKE84ISlKKJeSUyYvgCKlJGQIYxdP7+Dutq+r8wgDBoljGoVdlY7UdHk6Zd1CgQtEQbEfk2adMDuDSJud9JkKBzCmjWr8e23i1C26CkYt/8PFsmJBr8KReX1SBk1E8aYBC7TdKVOaVWm2TJsIYwHweHGnXfeiYkTJ6KpqYk7/VLPjM6Q6WJgHjGHJeJDtfnwNYcyvuMyzqAhhcs7CVPZz5wjwVVOnA9B6pXFMFT9HvkuuRyT512IsDGFvYYbv3kFXk//eAVo4EEhjR1VdtTYvf2yToEgijAg9gOUPV1Q4+TWvdGkyR+X/IgTTzwRV199NT5//q/I3fUuTJIDrrAKxZX1cBszkTNmMhoHnb5XmWZztYVE1RbCeBAcflAI4+233+aQxvfff8+VGV2hzjwSlpQcKKUgAn7f7l4Zdc2GgSdhLLwxgyNhi11fQxb0IKSLhyNzNn9uqFwBlSPS5luj1uDIBVcgpDJCctfj969fRzjcP8qRpBkjl8mxvcrB4UuBoL8QBsR+oKR+j9IkJU2S8XDbbbehproaWaYA/n2cDDEqHwJhGYqrmrCjUY4jjj8fjUPPRYDq19tAHTVD4TB37hM5D4LDlSFDhuCxxx7j93Q95efnd76ATAbD6JNgMWoh2cvgMUSuLTIgqAKDwxYDjkVIGwO537G76RblQ4xobrpF06L5ENaYOAyefSlCUCJQl4+1Sz5Bf0Gl3yQwta3SzqJxAkF/IAyIfoaa4xTUumDdrTRJYYsnnniCb0bx2iDePVGOBG2QR0XF9V5srvRhm9sK97hL+UbWFrpZBHYbD6JUU3C4c+2113Lbb1KnJMXKrhpuQR8L07DZMGpUCHJVBglMhXdXZYQgKTSwZUfDFkXQV0e8E870mdwaPJIPEdGHILKycxE/4XR+b8tbjp3rl6G/ILVKjz/ERgTlVwkEfY0wIPoR8hTsrI6056YEKOL1119nz0OsJoS354WRZgxDL/lQZJdha7kL35Yo8doWJdZt2t6ucqWXelskm4VIlEBANzS5nK8pk8mE5cuX4+mnn+5yGWXmUbAkpkMj+eEOhBFWaqF01zZrPgT1CXBkzOL31D+DwhaUD2HLXtDCsIj0oCGOmDAZ8uxI/kTZ75+hujQP/QWpVdKggnIiRAdPQV8jDIh+wuULcoyS3IzR9twUunjpxReRoA3jmZl+DE8AzDIPSj1abC9rxItrQ1hYHYewJENdXV2r76MRhtsfwpAkE1KFPLVA0ExWVhaefPJJfn/XXXdh27ZtnS8gl0M38iRYKaTYVAS3KZsnG6tWQuGJiFNR2MIbN7w5bCEPuCL5EM36EL8260MQM+acAl/MYEjhELZ//xY89gb0B5RPRXlVtQ4/d/AUzbcEfYkwIPqp4oI8D+SBSDBG2nNHQxcp+hDuOtKDqRlyNh6qAzpsLq7DvUt8WOuMY6U7Ij4+vvn73P4gnL4ABiUZkR4jjAeBoC2kTDlv3jz4fD5cfPHFXUtNm5JgHDgNZp0KgboC+IxpHMKI6ECEI/kQGbObwxbm3WWc3riR8MYO3Z1ouZATLQmFQo5pCy6GVx2PoM+Jtd+8ilCwfxIcIx08Nahs8iK/1iEkrwV9hjAg+hhqepO/u+Ii2axrlqlev24dNK4KXDvSjfkDFbAqfLCHtVhbZMPNizwodBsh1xh43qSkZIwdN47fU4yTXJQDE4zIFC25BYJ2oevilVdegdVqxapVq/Doo492uYwiexoscUnQS164QkoOU1D5pq52PX8eCVtE8yFKItUazfoQkURLLgPdnQ9BOhOjjr8MPpkO3sYKbPz+3ebP+qODJw1WSGRKSF4L+gphQPQhJDG7q87FFzElOLWUqQ5UbcNlQ904fagccWo/PJIKK0tDuOFLO8pdCihMcc3z3nLrLVDIFezJaHD7kZNgwIA4gzAeBIJOSEtLw3PPPcfvH3jgAWzatKnzBRRKaEacgBiDCuqmAjjMA3mysXw55L4mfh/SxbHBsKeMs2R3ouX8iPBUUwF0tRuavzIzNRUpk89FWJKjoWgD8ld/h/6Ccq1idBqWvC5tFGqVgt5HGBB9SMT6d3HzG+qkF0XTlI8jQ2tw+hAgQRdGAAqsrNXj5s+rUOmUoDQnsNokcfWf/oTZs2Zz7kSd04esOD2y443cllggEHTO+eefj5NOOok7cFJVBv3fKdZMGLImwqxVIlhfBL8+hXvOmEu+b/YeUC5EyzJOyofgfhlR4anynyJloLsZN3o0ZIOP4/ela79FTVH/yF1HJa9NuyWvqQJMIOhNhAHRR5C0LEnMmjQqVoqLomnYjpht/0WOdwMSDXKEIccaRzzu/6oERU0S5Doz5Bo9z5uYlITLLruMY5jUqTM9Ro/cRONeDbcEAkH7kJfuxRdfRExMDNauXYvHH3+8y2XkuTNhjYmFUXLCJjNxJ04KWWjr9zz4qSojqItn4yGaD0HCUz5rLudOsPBUaE/Ow6xZc+GMHY2wFMaOJe/C01SN/sKoUUKjkHNlRr3T12/rFRz6CAOiDyBJWbpYyXBo2eNCW7sBcVteh6FiOYL2ekgyGbb5EvHcD+VYU+bnvhYKY1xEolomw6233gqZTI4quwfJZi0nTbb0ZAgEgq5JSUnBs88+y+/vv/9+bN7chQdApYVq6DyultI1bofdMpQnm8p/htzvjMwjV7Uo4yyBvmoVX7MkMx9Wm7g5l6l0SfNXktE/+4Tz4NCkwO/zYOOi1xD291//CqtejVAY2FFF8vlCaErQO4inUS9DYYZtVXYoZHKWmI2ir1yJhA0vQlu/FW5HI4JSGBVIRL5yCL7c2MjzREIXciQlJrGi3qyZszj5ktp8D0k279WtUyAQdD+UQVLx0VBGl1UZCYNhSBsOs1YOf2M5AroEyII+mEr3tOyO5ENEZK2Nlbv1IagRV9Y8Nia09Vugrd9TQmrSa3HEvEvhlhngbKrBlh/+09yQqz+IN6rh8gfZiKBkbIHgjyIMiF6EyjS3V9pBfXxidjfI4gY9uxYiYcMLULor4XU54fEH0SCZ4U+bigffWwWKrB597Hw8/MRTeOmll/DFl19w3kOt08cte4ckmziWKRAI9j2UQdcWVWWsWbOmWfK602UGHweryQxrqB71ykTqmsX5S9ShM0pEH2JEK1nrgCkdruSj+HPqpqvwRhIwiczkRCRPPg9BSYGa4q0oXv1NH/3idn6PTMbJ3DTIobJyoREh+KMIA6KXsLkD2F7pgDcQZo8BEw4jdssbiNv6FsdK/UGg1hWAH0q4LYPx6mon8gqLkJyajoefeRFz5x6P8eMncMUFGSNKhQyDk02cBCUQCHovlEFVGVu2bOl8AY0JqkGzOJRhaNgKWzSUUfojd91snQ/RWtbalTKJDQnKgzAXLeS8iChHjh6B0KDj+X3Ruh+4OqO/kMtkSDZpUcmS+kIjQvDHEAZELxkPUf15kpIlSFAmafUjsFCCVTgEnyYOBU0haOGDTZWEksQ5ePHV//C89z36DIwmcyvVSl8wjCFJZm6SIxAIeocLLrgAJ5xwAvx+fyRBuateGanjoE/MglUDeB0NCGqsPBgwlv/cPMseWWvlblnr1eytsGUdD0mpgcpVBUPlr62+du7sOWiIGYdgOIztS9+Dv6kS/QVpRFA4gxr6UWM/KjcXCPYFYUD0svFAbkKlowypy++CvmYd30jcSeOxvT6MxGAFmuRWKMedg5vuf5ov3FPOOh9TZ0bqygnSr7d5/BiYaBDNsQSCPqrKMJvN+P3337vulSGTQTZkPiwGLWL9FajVDuDJurrNrAERpbWs9XIoXZUIq82wZx7L0wzVq6GyF7dKqjz2hLPRqE6Fx+vFpu/egBTov6RKyqeihn7U2I+8EQLBviAMiN40HiDBUP4LUlf+DerdCVWNg85Aab0TyY6NsMEAZfZ0PLNwB4oL85GQmIxb732olWplvcuHrHhSmYyoUAoEgt4XmIr2yrj77ruRl9dFsytDHFTZUziUoW/YU5VhLv4eCO+paPDGjYI3dshuWeuvOcxB/TA88aMiORJF3za3/iasBi3Gzb0EDhjR1FCDnUve6dekSr1ayZViedUOUd4p2CeEAdFLxoMi4EDM9vcQv+UNKHyNCOiTUD3uenjqy6AqW44AlEBMFrZZ5uDNl57n77j74Sdhtlj5PXkjapxe7qpJSpNCKEog6DsofDFnzhx4vV7umxGmzOfOyJwCvTUBMSofd8ENqYxQ+JpgrFixZx6WtZ6DkMYChc/eLGtNnonmHhotpK6J3LRExE06BwFJibLCLahctwj9CVWKUXknJVXS7xIIeoIwIPaBBpcfmytsXBKVaFRD17AN8Ztf58Y7soCLleqqj7gV6rqtqN3+CwySGz51DGTTbsadf/0L36zmn3ImZh03v/k765x+WHRqofUgEPRjrwyDwYBly5bhhRde6HwBhRKyIfNg1amR6M5DjTHihdDXrIXSvUcUKiJrvWC3rHV+RNZaroKdSjtpmq0QurqNrb56+riRcGXP5ff5a76Hs6T/kioJyodweINsRIgW4IKeIJ5UPaTW4cOWChtfaEnaMKy7voKl4HO+kdDudKUchdrR10HXuA3FW35HaqAENrkFmiPOwwvvfYP8HVsRExeP2x94pPk77Z4AyOEwKNHIbkWBQNA/bb+jTbb++te/YteuXZ0vEDMAqvSxLMqkacqD05zDIQdz8e6OnbsJGpLhSJvO7ynZkmStg/rEPdPKfoLCU9fqq0869hhUWsbCHwpjy9L/IWSr7PfyTrq3UeM/UZkh6C7CgOgBpCVPxkMoJCEjWIq4bW9DV7cJuoatLDTjTJ2MhuEXQ+WuRMPOFUhsWotGGKFNH4stilF49bl/8vfc+eDjiImNNMsiQ4Q8GSRRHRct/xQIBP3CNddcgxkzZsDlcuHqq6/uuiIhZxYMRhPiZTY0hPQIK7RsIOir17SazZMwDj5LDmThYKTNd8jP0/zmrN3TqDprj5gVeR2PP+FsVCvT4XR7sHXxG4Dfhf6CkjrJiChvcqOoTlRmCLqHMCC6CfWi2FppgzLkQ3btj7AUfsk3Dirb8loHw5MwGo1DzoEs7IeiYDHCJSs470FlTkJo6i249y83sPrd7LkLcNwJp/B3kqVf5/JxW+40q25//0SB4LBDLpdzKEOr1WLx4sV46623Ol9ArYds4BwOZSQ5tqDaNLK5M2dLwSiWtc6aizDlSngbYCxb2mKaHkpPLVdrtCTepMOY4y5Ck2RCTV0Nin5+t5V+RF9DRgz9rsI6UZkh6B7CgOgmLm8Q6oZ85Ba9B23DNsj9Dij8dnhjhsBnzUHj4LNYF99c8BVKd6yFSXLCrzRDM/X/8Ma7H2DrpvUwWSy466F/NrfhrnV6ucdFToLorikQ7C8GDx7MwlLEn//8Z1RWdhE+SBoBVXwOYnUKKJzlcOvT2KtgKqFQxp6RO8taZ0dkranskxrphVUG7pdBkNeCBiAtGZGZCNOEc+CXVCgs2IaGDQvRn1AIVadScD6EqMwQdIUwILpDwAN9wUKklC1kERmKd5JoTMCQCr95AJoGnQFJoeUM69KCLUjy7YJNZoRh2BzsDCTjhSf+wV/zl3seQkJSMr+3eQJci03Gg1opDoNAsD+5+eabMX78eDQ1NeH//u//Op+ZBgCD50Kv1SApVIkadQokmYJLt6n/RUsCpoxmWWtqCU5eCr8lB57EsZFpbUo7iWMnDEdd5vEsib9tzVL4S1ajvyszaN151U4WtRMIOkI8ubrDls+grt8GCTIuzyRxKBpdUOvepoGncuY1JVF6SjdAU70OTuigT8iBf9xleOD2G+HzeXHU9Jk4+azz+etIg969O++hZcMtgUCwf1AqlXjttdf4/08++QQff/xx5wvoYyHPmsoJlYlNm1BjHducNMmDjBa0lrX+msMSlFDZ3A68TWkneSjPPG4mCk1HwBsMYctPH0Fm2yNa1V+VGTTIIY0I0TND0BHCgOgOOTMR0sfDHjMCKk8NT6JSTVvOidyCm1TntCU/obZgDRQIQa6LgXry1fjwo0+weuVyaHV63PvI03xjoOSkWocX6TE6pJiF0qRAcKAwZswYrsYgrrvuOjQ0NHS+QOZRUJsTEacOIuixw6eNhzzojeQ7tIRlrechrNRC5aqO5D7sLu0kT2Z7pZ0k8HTSCWegWJGFBpcXO354C3KfDf0F3auSzFpU2b0orHUiLCozBO0gDIjuYEqGP2YILI2beaRA7kf7gLl8YyC1OVKdK8rfBlOoET6FAeZR81EUSsSTD93Li99w+z1Iz8zi9/UuP6wGNbLjRd6DQHCgQcqUw4YNQ3V1NW655ZbOZ5YrOJRh1CiR5s1DuX5IpI13ww6oba1LQsNqExzNuQ+robYVIahPgDNtWoelnclWHcbNOQ81UgxKa+pRsew/kIV8/VqZQY0Bi+tdKG1sHWYRCAhhQHSHwiXQlUcypknnwZE+KxIHlSSYSr5HfXkhNPZCeKGGOWMkPENPx9/vugUupwOjjzgS515yFS9LYYswJAxMNIr23ALBAYhGo+FQBo3A33zzTa7M6BRrJuSppA2hQrxtM2oto3iyqeQHDlm0xGcduCf3oXgRhy86K+0kxmUnwjD+bLgkLbYVFMC5/tNW4Y6+hvK0zDo18mudqLGLygxBa4QB0R1Ukb4UdcnT4EqdEjEeyM1Yvwmy6s1wlG4AXdJqczIU487Dwm9/wM/ffwulSoX7H3sWCoWCSzYb3X5kxRr2tPsWCAQHHJMnT25OpLzqqqtYI6JTcmdBozchUe6EKyRHQGXiCi1DResOnIQjbQaCugTIA26YqVMvCcm1LO0s/2WvZU48cgiqMuYjEJZhw7pVCBfu6QTaH5CHRQEZdtY4YRdy14IWCAOiO2ROgmPEBbDFjWueRO5GU8kSlOdvhiwU4PKs2JHHoVKZiUfuu53nueqGWzFwyDB+T02yyHDIiNXvt58hEAi6xz/+8Q9kZmaiqKgI99xzT+czq3RA7jEwaZXIdG5CmTniZdDXruP8qFbIlbBlz+eSb7W9BPrqVa1LO2vW7hX+IG/IhcdNxWbTVHiCIWz6dSEUtVvRn5DIndsX5KRKX1DIXQsiCAOim4QMSXv+CAc476Gmohghdz07JGKzx8CVOx+P/e1ONNbXIXfwMFx+7Z+bQxeQAdnxBlGyKRAcBBiNRrz00kv8nlp+//bbb50vkDQC8thsxGjlsDgL0WQczKGGSMfO1g/ckC6uRevvX9nIaFXaWfwt5H5nq2Uo5HnOCfOxWT6Mxefylr0PpasK/QnLXTt9KBBJlYLdiKfZPmAq+wmBhlLYKnZyC29NXBYUQ+bj59/W46uP3+cRw/2PPwuVWo2wFAldZMbohVS1QHAQcfzxx+OCCy7gyqkrrrgCfn/rnIb2tCG0Gg1SQpVoUMYjpNBxWEJfs7eOgzdu5F6tv1uFN4oX7ZXrkGrVYeqxp2NXOAW7amyoWv4OC9r1Z1JlgkGLknq3SKoUMMKA6CGaxjxoazagqnAjvJICco0BCYOPQq1pGB684yae57zLrsaYI47k941UdaFXi9CFQHAQ8tRTTyE+Ph6bN2/GI4/saYDXLvpYYMAUmHQqZDjWodQSCXkaKn+DwtvYel5q/Z1xzJ7W36RiKVPsFd5oy4TseMROOAP1khmbdpXDve4D9oj2F+RBpa7B5IUgeX/B4Y0wIHqAMuBgudrqsnw0egIwyvxIzhkDZ9ZxeO6fj6CirBSp6Rm4/i93NzfKCoYl5MQbuK5bIBAcXJDx8Oyzz/L7hx56CNu2bet8gYxJUBgTWBtC62+AU5+xW+b6+708CpJSG2n9LZPzwIS0INoLb7Tl1CNzUJV5AlxhNdZs2gr5jq/7tTKDkirlkLFSpUMkVR7WCAOiu0hhJJYvhq+pCvU1ldAiAG3SIMgGTMaa/Cr89/VIvPTeR56B3mBktydpPqTFaJFgEqELgeBg5ZxzzsGCBQs4hHHllVciTDrPHaFQciiD+klkeHagQjcIYbmyXZnraOvvlloQSndtJLwRM3h3eGMhhzdaQiHSK48dj/WmmXAHJKxd/SvU5SvQn8Qa1HD6giiocQqlysMYYUB0E23l79A6ilG1awsckhpqnQlJWcPRmDAJ9//lBjYYTjj9bEw5ejbPb/cGYdQoMCDO0Nw8SyAQHHzQ9fvCCy9wYuXy5cubkys7xJoJpIyGeXcoo8I6vkOZa8KdOB5+SzZ7KsxFCyELB+DInIOQxgyFzwZT6Q97eRgoqfLyE2dihXICD1S2r/ga6oYd6FelShMpVfpE++/DGGFAdAdbGbTlK2CvyEOpV4tYmRupuaPgzJiF1199Gfk7tiImLh633fcwz06aD05fgI0H6m4nEAgObqik8+GHI9f37bffjrKyss4XyJkFJeVHyR3ssfBoEtqXuSZkMtgGRFp/Kz31MJX+yP11ouENUrZsK3VNpFh0OHHuPKwPD8KuehcqVn7Ur5UZlFQZZ1CjiNYt2n8flggDojvsWgZnQyUqG50wy1wwpg6DMnEIttcDLz3zGM9CxoM1JpbfN7j8rPmQbBG9LgSCQ4VrrrmGRaYcDgeuvfbazkfdaj0w8Bjo1QpkOdeh1DSWm/G1J3NNSCp9c+tvbf1WaOs3I2hIaRPeiPThacm4zBjkTj4Ju8LJ2FhSC9fa9/cqAe1LKLeLBkn51Q5OGBccXggDohv4c+ZgY3ENbJIOOoMFKanpsKXPwgN/vQkBvx/TZh2L+aecEZk3GEZIkpAZp4dKIXavQHCoQIqyr7zyClQqFb788kt89NFHnS+QNBKymCxYNXKkuHegxtyxzHW09beTlG5pntIlbDBQeMNnydktdf11u70wTh6bDs/AE1AnmfH79mJgy0f9WplBHYWDIQl5NQ54/EJk6nBCPOG6weKv3kehR48EuQuZucPhSj0KH3z8Odb+vgI6vQF3/+OfzXkOJPKSYtEi3iASJwWCQ40RI0bgzjvv5Pckd91px07WhjgeKpUayaEKOFVW+JUdy1wT7qSJzfkQbDCE/RGpa7WJS0HJ+GibD0H3nqtnD8fWuLmwBVX4fcMWaPMX9mtlRrxJgwZXgMs7KYQrODwQBkQ3qLGOQSycMKUMgsqSjF3hVDz1j/uaO22mpmfye5cvCI1SzpoPotOmQHBocscdd3DHzpqaGvzlL3/phjbEZBjUCmQ71qA4ZmILmeuq9vMhso5HSG1mg8Fc/B0kBZV7zt+dD7Gde/C0p89w/fwJ+EU9Aw2eENavXQk9tQ3vJ+QyGRJNGpQ1elDa0EXvEMEhgzAgusGlU7IwfexwJMTFwp4+G/+453Y4HXaMHDse51x8Jc9D8dAmjx8ZMXp26QkEgkO3Y+err77KI//XX38dP/74Y+cLZBwFmSEecaoAYn0VaGiWuV68l8w1ISl1sOUs4HbhrA9Ruw4BY1qL8MZSKN3Vey1HSreXnTADP2E8yps8KFj9HedT9BcUsqV7X2GdC7WO/ms7Lth/CAOiOxQvZ3U5u3UYvvllLZZ8txBKpbK50yZh8wRg0qqQFqPb31srEAj6mClTpnBSZbRjp8fj6VwbYsjxUCvkSPfuRJ0+C0GFdrfM9Zp2F6EESpK2JkxlP0PlKIM76cg9+RCFX+6lD0EMTjLh2NnH4vfwUGyttKN+7WdQOcvR3yJTpA9BHlnBoU2/GBD/+te/kJWVBa1Wi0mTJuH333/vdP4PP/wQQ4cO5flHjRqFhQsXYr8y/BT4kiegRD8KD99zG0+67NqbMHjYCH5P/S6oYVZmrF4oTgoEhwlU1pmWloaCggI88MAD3dKGoAdstn0Niq2RUIahcuXeMte78SSMhTd2aHO/DNKQsFN4Iyp/XbR3vwxi5pBEpIyZi/xwGn4vrEVgw4eQ+5rQnyJTNq8f+TVOBENCZOpQps8NiPfffx8333wz7rvvPqxduxZjxozB3LlzOX7YHr/++ivOPfdcXH755Vi3bh1OOeUUfpEW/X5DpYUn82i8/OwTqKupRlbuIFx5/a3NH9vcAVj0aiSZRdmmQHC4YDabWWCKeOKJJ/h+1Sm5s7l3TrzcDn3YA7uuY5nr5n4ZmXN2N9hywbLrK+6TYcs5AZJcCY2tEPqq9gdjF07OQn3GsagMW/HrtlKotn7crseiL6DQTqJRi0qbhzUihMjUoUufGxBPPvkky79eeumlGD58OF588UXo9XqOHbbHM888w13wKDmJEpUefPBBHHHEEXj++eexP/nt11+w8MN3+P29jzwNjTZiLFDGsTsQYu+DaNUtEBxenHTSSTjzzDMRCoW4Y2cw2InbXqUDco+BVqnAANd6lJtHISzrWOaakBRq2HJOhKTUQOWsgKlsKYL6JDgyIoq3xspfobYXtSvydNPckVhrnoOagBorN+2APv+LdnMu+gKlQo4YvRpFdW6RD3EI06dPPNKOX7NmDebMmbNnhXI5/71iRfva7TS95fwEeSw6mr8/8Hq9uPOW6/n9GedfgglHTW3+rMntR5xRLfpdCASHKdRsy2q1soeVBkCdkjQCiMmCWSPHANcmlFkiMtem8p/albkmQlorbFlUhSGDrnYDGxve+JHwxI+MJGPu+gZyn22v5Ujg6dYTxuMH1dGocoWxfsN6GEt/7LfyTlo/JVbm1Ti5b4bg0KNPDYi6ujq2zJOSklpNp7+rqtqXXKXpPZnf5/PBbre3evU2f//737GrIB+xCUm46Y77m6dTfM8XDHHlhRCNEggOT5KTkzmEQdxzzz0oLCzsQhtiLhQKFZJDVQir9XBpEiAL+mAsXdLhYqQN4UqZzO9JC4JKQMkLETAkQR70wFr4ZbviUaSGe/W8yfhOOgrFDR4Ubvilw8TNviBGr2puuhUQ+RCHHPJDIZHJYrE0vzIyMnp9HSaTCWq1Gtfd+RDMFmvz9EZ3gAVUhPdBIDi8ueyyyzBz5kyuxvjTn/7UedyftSGmcMfOXPvvKLVOhEQaD407oW4q6HAxV/Ik+KwDOW/CWvAF99ag8EZYpWfVSnNx+7kUI9MsmDdzGn4Oj8amChvqN37L5aH9lw+h4XyIYpEPccjRpwZEfHw8lzlWV7euWaa/yWpvD5rek/lJ1MVmszW/SktL0dtQ85wlv2/EtGMXNE8jazokhVk0iuKNAoHg8IUelC+//DJrRCxevBj/+c9/Ol8g8yjAEA+rMoAUXyGqzKN5srn0x3blqnevhFUpg7p4yANOWAq/QFipb9F0axv0NWvbXfS44ckYMPpobAjn4rfCOvg3f95vjbda5kPUiHyIQ4o+NSBo1D5+/Hj88MMPzdOoMx39TU1p2oOmt5yfoAuyo/npgqVs6JavviAlNa3V39Q4JtEkJKsFAkGEQYMG4f77IyHOP//5zx1WmjFyBTBkHpRyOdK8eXDpUuBVmSH3O2As/6XDxbhLZ85JCCu1ULmqYC75AQFjOhzpR/PnxvJlUDlK2l32kqnZcKbPREEoCb/sqIRy68ft5k70dT6Ew9t/fToEB3kIg0o4qQHNW2+9hW3btrH4isvl4qoM4qKLLmIvQpQbb7wRixYtwj//+U9s376dL8jVq1ez7vyBAnkfKJqXatUJyWqBQNDMLbfcwqXq1CODjIhOsaQDaUdwx86B9t9QZI0kZ1OipMrRsSeVkyqjXof6Lex1YM2IuOERzYjCr9s1DMhTeuvxw7DZMgtlASN+3VoMw45P+628k/IhSFyqsNYl8iEOEfrcgDj77LM5wejee+/F2LFjsX79ejYQoomSJSUlqKysbKXw9t///pfdgXQhUse7zz77DCNHjsSBQsT7oEGcQb2/N0UgEBxAUKdOGjBRtRndx7755pvOF8g+GjKNCbEyJ+LDNag1DePJEZnrjkfqAfMAONIjSpXG8p+5lNOeecyepMqCL9rt+EmegDtOHIOlqqNR6lZg1ZYdMBV81S/lnSIf4tBDJh1iR5GqMCiZkvIhejOcsavWye63eKMG9S4/xmZYRfKkQCDo0PP61FNPITMzE1u2bIHRaOx45todwOZP4PCHsTZmHnJqf4A66IQ7aQKcu42EdpEkmEoWQ1e3mfUiGoacw//Hbn+PS0Ip4ZKSLLnyow3bq+x46tOfcQqWYnSyHkOPmAZH5rHtztvbkGqvwxvE6HQLEoX43kH9DD3oqzD2h/chwagW3geBQNAhJIBH8v3kYb377rs7nzl+MBA/CEaVDAMdq1AUG8n3onLLThMdSaky4xj4TRnsbbAWfAZJpowYDdSIqykfhsr224YPTTbj/GMm4ZvwJGyrcqBi20roqztvMdBbkBdEKZcJfYhDAGFA9IBgSOLch7QY0a5bIBB0jMFgYNXdqNDUb7/91vHMNOofdBxkSjUSpDqYZH7UGwZ22rGzGbmCpa1DGiv3x7AWfoGAPhH2zIgYn6HyN2gadrS76IzBCZh85CQsDY/BquJGOLf9AE3DdvRXvwynN6IPIfplHLwIA6IH+IJh4X0QCATdghR0L7zwQo71k5w/KfN2iNYM5Mzijp059t9RbRnV3LHT0EG/i5btv5sGntIsd20u/g7e2OEcAiHo7448GeccmYGYQZOxJjQQv+TXQdr2JXf+7Jd8CFM0H8Ld5+sT9A3CgOgBBo1CeB8EAkGPegGRHs6mTZvw+OOPdz5z2hFcmWFShjHQvR5F1kgow1D1G5Tu1to4bQlpY9GUfcJuPYjtMFSugDNtGvzmLMjCgYjwlN/R7oP8hmMGoT5xKrYFUvDzjmqod3wKhbcB/aUPsavehRpH/1SCCHoXYUD0AFF5IRAIegIZD9H+GJQXsWNH++GE5lDGkPmQKZRICpRDq1ag0ZDDpZnmom+BcOf5AlSZQZUY0Tbh2vqtsGXPR1AXx8JT1oLP263MIH2GOxeMwHrjdOT7LFi+rRTGHZ9AFnD3Tz6ETIb8aieXeAoOLoQB0U1Isjo30Si8DwKBoEece+653GGY+vZQKIPE9DrEEAcMmMqhjFzbSpRbxyOg0EHpqWOjoCu88aPgSp7I780l30PlrkJT7skIK3URueuiRe3KXZt1Ktxz0hgsUU5HoVOFVdsLYcn/rF2Doy/yIezeAPJFPsRBhzAguolJq+KXQCAQ9AQKE1BCJSVWLlu2jHUiupS5NibArAgg17MRRXHTebKhehWUrj2aOR3hSp0Kb+zQ3aJSX0EeCsCWe9KeyoyK9pUuSRjv5gXj8JU0DXkNQWzZsR3mom/4e/p6/ySZtCIf4iBEGBACgUDQxwwYMAD/+Mc/+P1tt92G8vLyLmSuF7AYVYq3EFq1Cg3GQew5sHAoowspaOqZMeC4VuWdIbUZ9szj+GND1Spo6za3u+iIVAsuOmY8vghNweZKF0p2boCpbGmftwBv7pfRIPIhDiaEASEQCAT9wHXXXYdJkyaxUA+971TDz5wCpB8JjVKBQU2/oCJmPAJKAyc3Giva13ZohTyiB8H5D34HrPmfwsctwSftCW900DNj5pBEzJ50BBaFj8Tq4kY07FwBffVq9Ec+hAIyLu0U+RAHB8KAEAgEgn6AOhO/9tprLHf9+eefs0x/p2TP4NbfZpkXAz2bsGt3KENfvQYqe3GX65OUWjTlnoKwysg5FJbCL+FKmghv7BAOS1gLv4TCU9/usmdNyED20PH4OTQKywvq4N9JGhGdJID2Zj6EJyjyIQ4ShAEhEAgE/cSIESOamwdSg0BqutUhClWkKoNCGZ486NRK1JqH80eW4u+61QQrrLFENCIUaqgdpbAUL4I981gEjGmQBX2wFnzKstft5SVcOzMX4fSJWB0ciJ921kKx46tOm3z1hT7EIdZp4ZBDGBACgUDQj9x5550YNmwYt/u+9dZbO5/ZmgGkT+CqjMFNy1AdMw4+tZXDEqaS77uVmxDUJ6IpmkTZmAdTxS9oyjkRIW0Mq1daCtqvtqC8hDvmDUWJdRI2+VPw044q6HZ8BqW7Fv2iD1HnQq3D16frEvwxhAEhEAgE/YhGo8Grr77Ko+033ngD33//fecLZB/NoQwTvBjsWof8+FmQSDCqcSe0DVu7tc6AKRO2rOM5wVJXsx66+k1oyj2VyztVruoOqy0oL+Hek0ZhlXYqtnksWL69DKa8T9sVpepNRL+MgwNhQAgEAkE/M2XKFE6kJEgbwuXaO4zQKpQxdAGHMpI9+YhVBFBpjchUm0qXQO5r6tY6fTFD4Eg/mt8by5dD5SyFLfdkSHIlNE0F/F3teTSoA/HdJ43GYvl0bHeosWpHMSx5n3QrhNIb/TLyqx0IiHyIAxJhQAgEAsF+gMo6qd13UVFR1x07LelclUGqkblNy9BoGQaXNoVDDxYWh+reA9aTeARcyUc2V2JQ/oM9a17EM1G7ocOOnNnxBtw6fwy+kKZja30IW/IKOCmzK3XMP6wPYdaiyu5FUZ1L5EMcgAgDQiAQCPYDJpMJL730Er8nueuVK1d2oyojDkaZF8OcK1EYPxMhuZobaFHvi+7iSp0GT/zI3boSCxFWauBIn9XsmdDWb2l3uTEZVlw6eww+C03Dhko3ivO3wlz8bZ9qRCjkMsTqNSiqd7MhITiwEAaEQCAQ7CdI4vqiiy7i0fXll1/OctedhjKGnwSZTIEE7y6kyOpQHD+DP6KOnd0p7WRkMjgy58BnHcitwqnRVsCQ3KJ752KobUXtLjp7aBLmHjUGX4UnY1WJDXUF62EsX4a+RKdWQKOUc2mnzdOFiJagXxEGhEAgEOznjp2JiYnYunUrHn744c5nNiUD2dOhlMuR0/grQoYUNFJpJ3sTFrVbktkuMjk32vKbMyNqlfmfwhM7HN7YYREJ7F1fddgC/Kzx6Rg2fAy+DU3ArwV1cBcsZ22KvoSqMnyBMPJrHPAFQ326LkH3EQaEQCAQ7Efi4uLw3HPPNedFUOvvTsk4CrCkQScPYajtJxTHToJPQx03XR02y+pMrTJgSII86EFM/idwJk/cY1QUfAaFt7Hd3IRrjs6FecBYLA2OZI2IcP73fS40RcmcVNZZWOtEOCzyIQ4EhAEhEAgE+5kzzzwTJ598MgKBAC677DIEg50kJ8rlwLATOaQRG6hGTiAP+fGzuZpCbS/ukey0pNCgaeBpzS2/Ywo+43wI0o6QB9yw5n8Mud/Zbm7CX+YOgTNhPH4P5GDpjlqo8r7uUB67N6B1khFRUu9GeZNounUgIAwIgUAg2M/QqP6FF16AxWLB6tWr8dRTT3W+gC4GGDgHcpkMA2xrYFLLUR4/jT8yVlCJZkW31y0pdWgaeDpCGgsUPhuHL0gzIqSxstAUhTfaK9nUqhS458QRyDNOxHpvMn7eXgXDThKaqkFfQb1BqCtyQY0L9U4hMrW/EQaEQCAQHACkpqY2Gw733nsvdu7c2fkCKWOAhMFQyyUMbfwRTYZc2M0Dd+cwfA1ZoPuj9LDaiMZBpyOsNkHpqed8iqbsBQirDFB6amEt/KLdLqAWnQr3nzwaK9VTsNltxi/bKyJCUz4b+goyICiCQSJTbr8QmdqfCANCIBAIDhAuueQSHHfccfB6vVyVEQ53ou8gk3GvDGjNMIbtGO5eicLYGQhoYlgpkko0u6sPQYQ11ogRodSxF8FctgS27BO4j4bKUQbLrvbVKpMtWhaa+k4+HVvsmojQVD4JTXnQV8Qb1bB5/GxECJGp/YdMOsTUOahVLrkBbTYbzGZzh/OFQiGONwoEhxJqtRpyipELDlpIWGrkyJGsTvn88883K1Z2SFMJsP6/CIXDyIs5GlVhK4ZWfApZOMDtu12pU3u0fjIeYvI+5GZbflMGXEkTuHOnLByEN24E7AOOixgvbVhX0ognv1qN02U/YkKyEiOHDUfT4DMAuQp9AXXrrHF4kZtoRG6CkcNAgv57hh6WBgT93KqqKjQ1dU/+VSA4mCDjITs7mw0JwcHLv/71L+7WaTQasXnzZgwYMKDzBYp+AXYtg1dSYF3iKVC5a5BRuZg/ahp4KvyW7B6tn0o4Y/I+4moMv3kA3PGjYN0V8Wi4E4+AkySx23lgL91RgzcXr8JZip8wKUOPnGHjuNKDykb7AgphOLxBjEgzI8Wi65N1HG7YhQHR8Y+vrKxk44HqrvV6vbBaBYcM5O6uqKiASqViiWRxbh/cx3LmzJlYtmwZjj32WHz77bedH08KdWx4j70RNmUsVsWcgIyGFbA2bkJYqUXD0PO5tXdPUDnLIwmUIT981lz4zDkwl0SMElfKZLhSJ7e73GfryvHN8lU4TbEM03KsSB46CY7MY9s1OHqDJrcf9BAbnW6BVS8M5z+KMCA6+PEUtqDEJDIeqPZaIDjUoPOejIiBAweyISE4eMnLy8Po0aM5H+KVV17BFVdc0fkCXjuw+nVIATcqDMOxWTsew6q/gsZdxWWZDUPO7nE4gcoyrfmfcfiClCv9hlSYyn/mzxwZs+BJHNfucq/9sgubNvyOExUrcfSgeFiGzYIrdQr6imq7Fxa9CqPSLFwdIugfA+KwCpZGcx7I8yAQHIpEQxdkLAsObgYNGoSHHnqI399yyy0oLS3tfAGtmfUhZJAh2bkVA8KlyIufsycpsnhxj/tWcBvwnJMAuQKapnyo3FWcV0FQ905t3eZ2l7t0ahYyBo/FD6Fx+KWgDp68n7hZV1+RYNKg3ulnuWvKjRD0D4eVARFFuHYFhyri3D60uPHGGzF58mQeFV511VVdd6SMywUGTIFCJkN2wzKYVCEUJ1HSoxzahu3Q1/RcctpvyUIT5THIFdA27mR1SnfiWP6MQhqaxr0VKEmf4sbZg6DOHI/lwWGsVhna8S00jXnoC2h9iSYNC0wV17tF585+4rA0IAQCgeBgQKFQ4PXXX4dGo8GiRYvw1ltvdb1Q1nQgJgsaWRjD6r+HS5uAmqTp/BE1vlLb22+U1Rl+Sw6ask9oNiLkAS88cSMiPTh2fQO1bddeyygVcvz1+KFojJ+INYEBWLqjGoodX0Ll6MKTso9Qq3OrTo1ddS5U24XIVH8gDIhDjKysLDz99NM4VFi6dCmPqkXVjOBwZejQofjb3/7G72+66SaUl5d3vgCV8Q4/CdCYYAo7MMq+DOW6IXDGRJpumXcthMLb8+vJb82FLXtBxJvRuB0yKQRvzJCIcFVh+4YB5SPcS2qV5inY7EvC0m2V0G7/tM/UKvVqJdRKOfJqHLC5RZl+XyMMiIMIioGSTj4p1lGsm0q7yMVZX1+PQwHKOqcbZEumTJnClTOU1CMQHK7cfPPNOPLIIzmx7eqrr+7aRa82ACNOZY9BvLcIg4I7kG+ZAr8hGfKgF5bCz9uVp+4KSqSkLp7RkAhVVvgs2ZxkaS34HEpX5V7LmHerVf6um47tXgt+3lYG/Y6PIfc19Wnnzp01Dnj8IheoLxEGxD5CSWo0On7vvff4/75OWissLMSECRM4M5vWmZ+fjxdffBE//PADx0gbGhqwP6Df3ala3h+EDKXk5GQR2xcc1iiVSrzxxht8PXz99dd4++23u17IkgbkHsP5AZmNK5Eqq0N+wnEIq4wRuerdug49xRczuJURIclULDhF5Z7U0VPprm43yfH+U8ZgiWoGdrp0+HVrMUw7Pu6R3Pa+JFWSJ0IkVfYdwoDYBz755BMOFcyaNQvnnXce/09/0/S+gtTo6Obx3Xff4eijj+Y6/3nz5uH7779nl+Zdd93VPK/D4cC5554Lg8GAtLQ0FqWJQiOX+++/n5enuCp5M2644Ybmz30+H2699VZejpafNGkSG0hR3nzzTVitVnzxxRcYPnw4f8err74KrVa7V5iBvCOzZ8/m9+QloW2i76UqmFGjRrEh1FLC96effsIzzzzDxgK9SJGvvRDGxx9/jBEjRvC6ab//85//bLVemkZtkclbYzKZ+Le+/PLLzZ/7/X4W6UlJSeHtJk/Oww8/3AtHSSDoO+icj4Yy6NoqKyvreqG0I4DkUVDJZRhY/yN0ijCKU+ZBkqs4F8JUtufa3mcjomknwgoNAsZUVq+05n0Mpbt2r2XSY/S466Qj8I38aOTZFfhtaz4seaQz4euzpMqKJg+K6l0iqbKPEAZEDyEj4Ywzztjr4qWHOE3vCyOCvAskJHPttddCp2uttkaj8/PPPx/vv/9+80Xy+OOPY8yYMVi3bh3++te/8s1m8eLFzQ9fatjz0ksvsTfjs88+44d5FHqwrlixAv/73/+wceNGbjN8/PHH87xR3G43Hn30UTYctmzZwusno4K+u6VngraJPiOoln38+PE8eiJlPcoov/DCC/H777/z52Q4kCflyiuv5JAFvTIyMvbaF2vWrMFZZ52Fc845B5s2bWJj6J577mHDpiVkVJDHhvYB7bdrrrkGO3ZEssWfffZZNoA++OADnvbuu++y0SEQHOhQOScZ9RTKoGulywcjee4GHw+YU6GDH8MbFsOlsqAqLSLspKtZz699NyJ250Q05SOk1CKwO0RCbcAV3r29ogMTjbhlwRH4EtOR3xjG2i1bYS6gRl3BPkmqjNVrOKmywtbzcI2ga4QB0QPooUgP4/Yu2ug0iuH3djiDHt70/cOGDWv3c5re2NiI2tqI1T916lQ2HAYPHozrr7+eDZtol7+SkhI2OubMmcMj84kTJ/KNKPoZuUk//PBDTJ8+Hbm5ueyNmDZtGk9vqadBrYcpP2HIkCHsqaAH+n//+9/meSi0Ql6D008/nf8mzwN919ixY5GTk8PbRYYJPcQJynEgDwt5J2j76EUZ6G158sknccwxx7DRQL+PPBdk9JDR1JL58+ez4UCCSrfffjvi4+OxZMmS5t9JNfb0u8j7QP+Td0QgOBhCGWQsR6syqEKjSxRKYORpnFRpDtkw2v4TqlSZaEyK9MgwlS1pt4qiO/hiBsGWs7s6o6kQYYUWQV0C5AE3YnZ+1G6y5qh0K66aeyQ+D0/DjjofNm/eCHPh1/sUTukKnVoBnUqJ/GqHaP/dBwgDogeQrGxnbkN6yFOiI83XF3TXDUcj+bZ/b9u2jd+TR8Hj8fBDnAyHTz/9FMFgxPqnET0ZP/RgJg3+6ItCCwUFBc3fRw96UshrCXkaKNxAKogEjeoXLFjAngmCvvfBBx9kb0dsbCx/L3lV6GHeE+h3kIHUEvqbjKyWhlvL7aMQCBkkNTWRzG8yOtavX8/GD4VvKCwkEBxMVRlRgak///nP3buGNKaIESFXIs5bgqG+dSjSj4ArNlqK+fU+V0ZQYmW0xFNjL2Lp7KA2BvKAE9a8j9pNljwqJw7nHjMRX4SnYGu1Gzu3roWp5PseC111B2o5HgxLyKt2wukT7b97E2FA9AByq/fmfN2FRtH0EIwaAW2h6TExMUhISOjyuygsQG578iBQOIRG6TNmzGCvgtPp5FE/hQnoARt90fdTiCEKLdc2qZEyxMljQaEPMlDIMImGLwjyENB3kDeAPAH0vXPnzuV8hL6grYwzbW802fOII47Arl272KChbaWQCHlpBIKDBfJ0kgeQ8p2o7Xe3BhfmVGDIPM4PyLCtR1ZwF/JipsBvTOcESJKslvvt+7Q9VOLZlHMyJLkSakcpJIUWIY0FCr+dm3LJfba9lpk9NAknTD8K34QnYnO5HUWbfmWdir4wIhKMGtg8AeRVO+ALisqM3kIYED2Aku56c77uQn07qKEOPfTpgdcS6ixKo/2zzz67+aG+cuXKVvPQ3y3DH2QAnHjiiZwLQF4Dynkg78O4ceN4FE8jdTJaWr5oBN8VZDDQtnz55ZfcFZI8EFGWL1+Ok08+GRdccAHnZ5AHhPqStIQ8G12Ff+h30He1hP4mr0l7IY+OII132mfUY4ByNSh/Y39VsggEPYXOdQor0rVMidT//ve/u7dg8khgwGQo5DLkNC5DYrge+UlzEdTFRzwG1DxrH8o7mxUrc8mIUEHlquTEypDaDIVvtxHRjnGyYHQqph41BYvD47G+rAkVm5ZCXxXJi+pN6N6YZNZyz4yCWidCYZFU2RsIA6IHUF5Aenp6hyWFNJ1G+DRfb/P8889zhQSN2n/++WcOlVAMlAwLyi+IujSjD9THHnuMH9BUgUE5DZS7QVD89LXXXuNERioNfeedd/gmRLkA9BAmI+Ciiy7iZFAapVOSI1UoUPJjV9Cya9eu5W2hET3FaaNQzgElcv7666/s0aBa9urq1uVelMj422+/cfVFXV1du+WhlERG+RXkPaDfR8p8tG8ov6K7UB4FVYBs376dv4P2DxlI0XCLQHAwQNcrJTMTf/nLX7i0u1tkHw0kDoNaJmFo3XfQSW4UpSxAWG3i8k5r4b4nNQbMA7h9uKRQc0txMiZCKiMUPhvnRMj9jr2WOXN8BoaPm4afQ6OxqrgBdZu+g65mHXobMpoSjFqU1HtQIiozegVhQPTQ6o+68tsaEdG/SQWyJyPh7kIP4NWrV/PInVzuFC6gSgYqISUPAuUVtHzI0rzkUfj73//OD0wyPAh6SNKom/IGKE+ARi/kMYh2J6VRDRkQ9B2UI3DKKadg1apVnHDZFeSpoKRMqt5oGb4g7r77bg4d0HaQYBQ9sOm7W0JGAO07Kg+lcEx7sV36Dkq8pFDJyJEjce+993JpG+U1dBcq7SQDi6o0KPRCBsvChQvZayIQHExQeTeVSlNlFF233UrgpnvV0BNYJ0InC2J4/Xfwy2QoTz8h8uB3lMFctGifQwkBUzoaB50OSamB0lsPSa5AWKWHwte02xOxtxFx0eQBSBl5NFaGh2NlYT0aN3zdYaOuPwKpVFp1KhTUulBlF5UZf5TDqp03lRLSqDo7O5vr//cVGp23rcMmzwMZD6eddtof2n6B4I/QW+e44OCBDG1KTqZ7H3kLqQKrW/jdwNq3AU8j6hVxWBszDwnhBqSUfA6EQ/AkjoUjfVbE4NgHKCnTmv8JV2SEVHrIwmHIQ16ENFY0Dj6TPR4tCUsSnv8hD76dizFekY9pAxNgOuJ0+Eguu5dpcvt5fVQREmuIdLAVRBDtvPsYMhJo1ErJgFS6SP/TTVsYDwKBoL8h72DUM0oeOfIAdgu1Hhh9FqDSIjZUh1G2JaiSx6M2fY9GhKFyxT5vV1CfiMbBZ7HypYIVJyWEFeqIJ2Lnh3vlRFBy53WzB0Geeww2hrKwPL8WrnWfQG0rRG9j/f/2zgM8qjJ9+3emJJNMekISCAGESJFepIqIgCAI2FHsqKxr17Uu6+L+176Wdf0su3ZdBRVFFOzSBEFUQHoJPSG9l0md8133Eyc7CQGSmfQ8v+s612TamTNv5pz3fp8a4CuZGXtS8jUzwwtUQHgITe00xbN+AG8bw22hKIpSF6655hrMmDFDsqnoyqhzdlNAOND/EviYrYgqTUS//DVItHRDTqez5Gl78noEpNa/BbiLCls4snpdKhkZpooSmrwlLuJ4IoJxCndO6oWSbhOxoyIOa/amwbF5kUcdROuUmVFcht0peSgu08wMT1ABoSiK0sphDBbLtbNg2m+//Yb58+fX/c0hnYHTLoDJZEbH4n3oWbgBB3x7Iq9jZb2VwMRVXsUjOMVlcSnK/SPg4yyTAE3Dx/R7YOVHx6R4UkT8aXIfZMdNwu6KTvhhdzKKN33Y4G3AJTMjyIb0/BIkpBVozwwPUAGhKIrSBoiOjpYS9YTZGfUqaBcZD/SeCjMbbxVuQ7firdjv3x8FUUPl6eDD38Ivu3radX1gvANFBEtd+8CAj7NCgjRdIsJcnF3t9RazCfdP7Yu0zpOxtzwGq0VEfABrwUlamdcTipWoIBsSs4twMEMzM+qLCghFUZQ2AuOwmJHEiZC9ZhgQV2di+gPxE2AxmdA97xd0Lt6FfUGnwxHR7/dqlV/AN+d/FWnri2HxR86pF6E0uIvEWPigQoSEFJuiiHBkHtPL4v6p/XA09lzsL4/CD7uSULJxYa0twxuiZ8b+jEIcyWqc7qBtFRUQiqIobQgGVLKmyqFDh6p12q0TccOBLiPhazYhPmctYhx7kRB2BorDe0uvitADSz3um0EMsx9yepwv5a8NHwsMWiMqSqSIVdjej44pp820ywen9UNi7Lk4WN4BP+xKROnG92EpTEFD98wI8rNib3qBFJtS6oYKCEVRlDYEU+/effddqWvCQmuLFi2q3w66nwV0HgY/ixk9c35ARNE+JEScheKwnpLeGbL/c++CGk0WacDliOwnfzMewlReJOme7J1RUxxQRDwwbQAOdzoXhyoi8MPORJT8+l6Di4hAmwVWHxN2p+Qju7BxSuy3NVRAKIqitDHYYZZ9Zwirvrqa3NUJ1n2Inwh0GgybxYRe2asQWrgfByLPFsuBj7McIfs+gzXvkOcH6GNCfpdJKOw4AjBZ4TRVpneayh1SbMqaf/gYEXH/eQOkYqaIiF2JKP6l4UVEmN0XZeVOERGa3nlyVEAoiqK0QR5++GGp3MoeL4yLqK00/AlFRM/JQMcBCLCa0Dt7JewFB3AgahJKQnuIiAjd95l3lggfHxR2GoP8LhMAM0teB8FSnCW9OMISFsMvp3ppblpEHjhvII7EnofDFRFYsysRRT//t8FFRIcgTe+sKyoglAaHF6uaZapbO0z5+vTTT5v7MBSlzrA5navXDfvQsFJuvRARcS4Q3Rd2qwl9slcgIC8BBykiQrpLSiYtEd4WenJ0GIjcU6YBFl+U+4VJ+Wuf8hKE7F8KW+aO6t/JYsJ90wbgaNx5OOyMwNrdSSjY0LAi4n/pnaViiSgt1/TO46ECohVNyvxhP/HEE9Ue56R2vOZeimertkGDBtXaov3cc89tlmNSFE9h91r2wiEscb1pUz2bVLE/DPtmxPRDoK8JfXJWIiB3Nw5Gn1Plzgjd/zn8svd6dZwlYT2RHX8hDKs/ym2RIiIYE8GeHP5pG4/JmvjTuQOQ0mU6jjgjsG5PEvLWvwNrQT3cNHVI74wO8kNybjES0vO1e+dxUAHhKWxas3IlsGBB5W1dmth4CXsbML87O7t6zrQCqcDXmLD5l3t3UUVpLTAGYubMmXKOzJ49WxpveSQiOg1CoK8ZvXN+gD1rOw5GT/pfYOWBZfDL2u3VcZYFxSGr5yypWlnmHwUTYyLKChB0ZCUCE1dXa+5FEXH3lP5IP2UmDjsjsX7vUWSte0cagTUUrEXBapWHM4twIKNAa0TUggoIT/jkE/aeBsaPB2bPrrzlfT7eiEycOFEmMjbMORFr1qyRluI0XbLJF1O5CgsL5Tm2vmYXy5oWjFdeeaXa57B75vHYunWrdADk/tnFk11BCwoKjnnd3/72N+mqyajwm266qVp5XUaGswGQax/8TNcxktdee01WTxRNvXv3xksvvVT1HPuQ8Jg/+OADjBs3Tl7z8ssvy76+/PLLasewePFi6b7pumgysIxtkAMCAqSz6UMPPVQlPtjqnMfMSn7cPzc+VpsL42Rj4HLjPP300+jYsaO8hp0T3YUOvxO7rPL4WQSILdAVpaHhb5fnE3+HbGF/9913e7IToOcUyc4I9LOgV/462DM24VD0RBRHnCYpniEHv4AtY6tXx1rhH4nsXpeh3B6N8oBomMoKJS4iIPUXBB/6WsSK+wR/5zn9kBd/AQ45o7BhXwrSf6SIOLaLr6fQZSI1ItK1RkRtqICoLxQJvNC7deIUkpIqH29EEcF+G4899hheeOGFap1A3dm3bx+mTJmCiy66SJrqcJKloLj11lvleU64O3bsQHp6utxftWqVlL9dSSvK7yt5tgdnf4/a4CTPltxhYWHS5vujjz6SluCu/bv4/vvvsXPnTtnvggULpIMpJ2eXO4A9RObMmVP1GhbAcSn89957T5oCPfroo/I8vzMneqakuUOTLLui8jWXXHIJzjvvPGlu5g73xYmcgoFQTFAUcAyYL8/W5s8995w8N2vWLGlj3rdvXzlGbnzM0zFgkzX+P3jLY+fnugQJ261T2LEV+e7du/HVV1/hzDPPPO7/XlG8gef4O++8I3+zWqVH8Tyu7IyuoypFRMEvCElei4MRZ8ER2V8sBMGHvkVAys9eHavTN1CqVpaGdhcRwdLX1sJkiYcI3bcEPhWl1VwNt0zsg9LTLsJBZwx+PZCGlB/egW/uwQavEbEntQBHcxwNtt+2QKMKCEb/XnHFFbICDQ0NxfXXX1/rStUdTlyu1Z9r4+q1RUA3xR13VDOlVeF67M47G9WdccEFF4iP/ni17mmd4JjfeeedsrodPXo0/vWvf8nFg62eaX0IDw8X4UA4eXPSdN3fsGGDiAi+rzY4QXM/3B/3xVU4rRrMO09NTa0WwPXGG2/IZDxt2jSZKHkcjATnxFxeXi6igQVvaIm4+eabERgYKO/ld3vmmWfkebal5u1dd91VVabXBb+j6zVcXfF788LosjawCt+yZcvkcRe0rPC78XOnT5+Oe+65Bx9++KE8R2sCj8FisYilhxsf83QMKDD4OC0oFDccBworVwtmu90uj3ft2hWDBw+uf9EfRakHtPLx9054LT7eIuSkIoJ1IrqfJSIivng7Io5+i4Oho1EUPUxeEpj0wzEuh/pimH2R02MmiqIGS1dPp9kG37wDErAZuvcjsUy4d/GcO64nLAMuwn5nR2w+nIHDq9+Brxelt2urEWGzmqV7Z1q+FppqEgHBC/f27dslAnjp0qVYvXq1mHpPxo033li1AuT21FNPoUXA2vInOul4whw5Uvm6RoRxEFzRcuVdE5rfucrlROjauFrmxM2W4xRkXOlSOOTk5MhKnJN3SUmJmDcpJE4//fSqFXtN+JkDBw6Uyc/FmDFjZP9cSbvga9z3MWrUKBGPR44ckecmTJggwoGWA1oBXHEdXN1z1c4LnPt3eOSRR+Rxd4YNq7xguZg6dSqsVis+++wzuf/xxx+LeOWF0wUtMjxeigPul4KCk3l9qOsYUDy5d2mlyElLq6y0N2nSJBEOdKOw5DAtJfX2TStKPaFVz5XayXgICnmP6DoK6D0NdpsvTik/gJjEZTgYOBgFsWPlabocgg5/K64Nj/ExoSBuvKR5VvhHSHAlUzt98xMRtntBtdLXvK5dPSYeQUMvxV5nZ2xPysK+le/BN/PYa6SnhPhb5ZaZGVlaaKpxBQQvsjTL0vc2YsQIKWxC0/vChQtPWtSEE49rBciNk0CLIDm5YV/nIRQAFAUPPvjgMc9xkmbQ1ObNm6s2ioq9e/eiR48eVVYeCgg22+HKl+PrEhUUEHRzNCacVCkqGa9w2mmnye+iV69eInBcFiqKCvfvsG3bNqxfv77aftwncJfVg3EELjcGb+mCoEWB0DVDUUuhQUHLiPR58+bVvfVxPaGYcYcXOVcuPl0pGzduFPcOhQVdNhQlFHWK0ljwHOE1mOKZ5//f//53z3fWcQDQ/2LY/W3oghR0PrwYR6zdkdtlklgq/DO2SdVKd5eDp2meOfHni4goDeoiIsJakIzwPQurxTvw/LpsxCnoNHoWdji7Yk9qLnaueA++aVvQUEQE+kla567kPOQ6Gjdwu10LCF6s6bZwXyVyJcjyqj/99NMJ38vVGH12NA9zkjzRyowrZ5qq3bdGo2PHhn2dFzCd8/PPP5dxdoerC1oV4uPjj9l48XCPg6Dv3hXrwFv68deuXXvc+AfCwEYKEveAR76H/1eKABd8jcPxP38hJ39etBjU6TrZuWpnXAQnch4bAx4ZTNipUyfs37//mOOnq+JkUCBQuNLytXz58mruix9//FFW/RQN/F3SxcN+Ae7wOCpO4oKq6xicDAobnhO0sDFehcGhPGZFaUz4u3e5AykgGKPjMRE9gEFXIMAehM6WXHQ7vAjJzhBknzINhskCv5x9Up7a3eXgCaXB3ZDV63KU22NQHBoP3/wjkrbJglM1a0XMGBSHvuMvx1ajBw5mFGDL8gWwHvUuLsMdZmYUlVaIiGjv1SobTUCkpKQgKirqmAsm/e987njQrMbiJ/xRUzzQr3zllVce9/X0+YeEhFRtrgmqURg7FujcudIPWBt8nJ/P1zUyNP9zcmRcgTvMMuBEyYA+rtxpeViyZEm1AL8BAwaIf54rdHcBwfgBCjJO7MeDn8msgWuuuUasAvw/3XbbbWKG5+Tvgqt6uiEoVL744guJa+AxuAQkAyMZSEj3AQMsGdTJiZlQVPD/yu+2Z88eyXh48803q/LZTwQtKbRa8TgpOGj9cr9w8vO4AqM7hPunaHGHsRG0hHDsMjIyZDw8HYMTQQsIP5+fQxHDeApaJ+ojQBTFU3idve666yRwmddXV1C1RwR3AoZcDf+QKHS0laJ74mJk5Jcis8eFcFr8YS1MQdjuhTAXZ3l1zLRAZPWejdLQeEkfpQuDwZKsFWE/+mO1mIuz+8Rg1OTLsRm9kJTjwMYVH8N86Aev4jJccPETFeSHnKIyERGO0vZbrbLeAoKR7zWDHGtu9KV7CmMkaJ53TZC8sPIiX9P/7YIiIzc3t2qjj73RoD/7+ecr/64pIlz3We3Nze/dmDAwsWZ5WooDuiE48TKVky4Kmse5qv/fofrIc7yla8n1ProyuDKv6Rqo6V76+uuvxYfKWAm6DBjPwGBBd/gYJ2xO6HQjzJgxQ4o0EX4O42HoSmBKJeMQGDTpKtR0ww03iOuLooG/A1pMGNdRFwsEvxMzPGghcLc+EB4DgzEpZBiISqHF7A53mL3CLJbx48dLCipdDJ6OwYmgdY7CiQGYFE5Mo+VnMW5CUZoCug4Z4EuXcr1LXdckIFxEhF9UPKLtZnRP+xr5qQeQ3uMSqetgLskVEeFtnQbDYkNO/AUoihmOktBTRRDYsnYhMGkNgg8sA5z/cyuM6B6JSdMuwy8+AyTw8eeVnwMJ3zaYiIgJsSGjoAS72nHJax+jntUxqFQzM6v3ba8JA8NoRWB0v3vRIwbscOVG0zmzCeoCzcQ0fdMsTWFxMujCoCWCYqJm7AQj57m65ETE4/AYpmoyG8M9oJKWB4qHCy/0fL+K4iUN9htX2gV0nQ0fPlwsbXSl3Xvvvd7tkCIk4TuUH/kZGQWlSPbrBp9uZyEy8WtJxYTJjLwurB3hvVC2Ze6UQE26MrhvCoqS0O7I7T5DUkFdJKQVYNFnSzCs7BcE+ZkxdMRYWPqcJ8fiLRVOAym5DnQM9UfvjkHSr6O1c6I5tCaV0WX1gKsybieDUfcMCPv1118xdOhQeYz+Xapcd7PyyaCJlzDQrMVAkTBzZmW2BQMmeWx0WzSR5UFRFKUhoOWR9VCYKk9rLq/bLqukR7BqZc9zYLFHIHL3tzAXHkT6rk+QFn8uIrM2Ssnr4INfw+LIREHsGZJp4SnFEX1QbgtDyIGlcFpssGXvkrbg5rJC5HSfLvESJD4qEFdffCHe+dSGoY61+GndagwtccA26CLpBOp1yetgG5JzHfJ3r5ggqZLZXqi3BaI+0CTNvHiaZ1lbgD43mshdUfJJSUli+qWbgiqYbgo+R9M2K/dRHdPk3Llz56o6BS3CAqEoLRT9jSv1hVOAK5WYrk4u2uqySDwpOUfg3L4YOdlZyCzxQUHXSQhx5sKeXJlNVRpyCnJPmQrD7F2JeJ9yB0IOfAm/rF2wZe+G0y8YxSE9kNdtCkrCe1e9LruwFK8t+QYDclfAZjYwuH8/hJw+W9wi3lJW4URafgm6hPujZ3SQVMlsDxaIRv2W/EHSx0aRQFFAZfuf//yn6nmKCubNu7IsGAHPTIBzzjlH3kcXCH3SzDZQFEVRGh5XKXtXPASDKk+WiVQnQuNgGjYHYbHxiPL3QeiBZSgoKkJutymSoeGbe6BBgisNi7+keRbEnQVHRF/p5BmQ/htCExb/XtCqMrYjzO6LWy6egp1RU1FYYcEvW7YibfVrMJXme/1Vra6+GVlF2JuWj/KK9tHBs1EtEM2BWiCU9oz+xhVPYeozLcFc0DFAu2aAsVdxEftXoDDhR2QWlqDQtwN8uoxCSNIqaZbFqpNiLQiN9/qjWKky+MCXsOXshbUoFcUh8XBEDa60dPxuaaC14M1vNiD64BIE+jjQs0ssuo6fA6d/hNefX1ruRHpBMbpF2HFqdJC4NVobLcYCoSiKorQOmAHkaqrHtGtagxsExkXET4B96Cx0CA9DcHkmTHu+QG6HISgL6iyFpkL2fQZ70hrvKleKW6Q7svpcicKY4SgOPkWERGDiKoTv/C8sRelV1oIbpoxAcb/ZyDaCsOdwEnZ9+TJM+UcbpPlWZKAfDmYWYl9aQZtvA64CQlEURREYC8E0ahqmmQ5d3zLvJ6RDT/iPuhEd4k5FiK8By/7v4fAJgCOisjuwPWWDuB18yrwr6e70C0F2z1nI73qOuDQsxZkIPPojwne8KXESrv4Zs8b2R/DIa5FqhONIWgZ+W/oSnOne98/ws5gRYffD/oxC7E9v2yJCBYSiKIpSBQucsaItC6kxBo1usQbDFgzfIVcgov9EhNn9YErfAWfWARRGDYZhssI37xAidv7X63oRTNFkTARbgxdGD4NhMsOeuhERO95F4JGVVW3BzxncAz0mzcURn05Iyy3Axi9fR8nhX7z/mlaKCF/sS2/blggVEIqiKEoV7EDLRnSsGsxqsayy2qCYTLB0H4vwM+YgokMMTKV5wJGfURIUhwrfEImLCNv7EQKSf/K66FNJ2KnI7Hsd8uPGo8weA7+cPbLvsD0fwFRa2XdnRHwMRs+ci4PWeOQWleDXbxcgb8d3Xn+27XcRQUtEWxURKiAURVGUY0q6szIqMzRYFZZbQ+MTGofQsX9AZM+R8LOaUJa6BxXOCpTZo2XyDjy6FqEJn3jdR0NcGr0uQ3bPS1Ac3ltKYIcc/AqRW16uasbVMyYU5118PfbZB8NRVoFNa5Yh7eePqywVnmJr4yJCBUQbPPH/yYqYXr7GW1h6muWaFUVpnTCd/pFHHpG/b7nlFvz8c8M1pKrC4ovAAechYtTVsAeHoqQgG0ZeihSIMuAjLo3wne9KdoVX+JhQ2GkMMvrPRWHMSNm3PeVnRG36FwKOrhPBEh3ij9mXXoFDkeNQWuGDbRvX4MDy14Gy/zUF9E5EFEhVzLaU4qkCohXBPh9z5syRYi+smcHOknfcccdJS4vXhBcC9hxpKGoTJOx/wX4ciqK0Xtj7aObMmdIc78ILLzxhI0RvsMWciqizb0FQt6Eoq6hAaV6G9BfiRG8qK0JowqcIOvx9tV4XnlAWFIeMgTdJP41y/w4iUDpsew1hu96T4M1APwuuvmAmMrvPQIlhwf6EHdi27EUYRdkNICL8cCCjQOpEMJW0LaACopXA9tas4snumjQtJiQkSMrV999/L+Vn2diprrDKHBtCNbYftWY3VkVRWhfsnvv2229LkanExEQJqqytQ21DYPYLQPSIixAy8ir4+IegwFECw1kubgSmevqn/4bwXe/DUpTq1eewHkRuj5lIH3SzuDQYcxG6fymif3ka1rzDUkVy1jnjYBl6NQoMf6SmJOLXT59HSVaS1yKiQ6ANhzKLsDslX2pGtHZUQLQSaEKk1eGbb76R7pRdunSRUuHM1WZJ8Hnz5lW9Nj8/X1Kw2FUzNjYWL7744gktBuxZwtQtCgsWDmGHSHazdIfVQNl5ksWJIiMjq5qhsQ0421Gz5LirG2tNFwYtEbV1aX3uuefQo0ePqvtsjc3vxOZpbIvNlDJGgiuK0nywqNCSJUvklh1seS1qzPqDEXG9ETXhFpi6jkBBGVBq+MDHKJeOnpaiDITvWlBZDtub+AQfH2nolTr0T9Lcy2n2hX/mVsRseBSBR1aAto9Jwwegy8SbkGMKRW5eDn5d8gKyD231uk5EVJANidlFbaKLZ7sXEDwR2PGzOba6noS0LrB99M033ywre3diYmKkbfUHH3xQtb9//OMfGDhwIDZt2iQmSLo5vv322+Pu/5JLLkFaWhq+/PJLaX7GFC6WH3dZNZYtWyaCgeXIuU9aPVixjrAlNXuVsHJdcnKybDVhy25aT1ja3B3enz17dpWIoXBh+3FGfrP7KvuoXHrppXUaI0VRGg+ewwsXLhSLxOuvv37MoqShCfAPQNfhM2Abfi0K/Togv8IXFdYAWB2pMJXkwc66DrsXwOzwboHh9AtFZr/rkT7gDyi3R8NSnIXIra+iw+YXpcT14FO7YtjM25Hp2xmOkmJs/eZNHPltuVcZGlazCdFBNhzNcWBXch4cpa1XRNS7G2dbg2VbueJtDgoKCsRKcDLotqA46NOnT63P83G2TWerdTJmzBgRDq4Tf+3atbLanzRp0jHvXbNmDTZs2CACws+vsqnN008/jU8//RSLFi2SWIlHH30Ul112Gf72t79VvY8ChTDVy2w2IygoSMTM8aDI+X//7//h73//e5VVgmKFbd8Jn6N4eOyxx6re88YbbyAuLk5ey++hKErzMWXKFDz55JPS8vvOO+/EaaedJqK/sWAZ6Lhu8ciKnIvkXetRdnAVAv2iYCvNgjk/S9waEbveQ0HHkSiKGuZ5e24fE4o6jUFpaE+E73gLAam/IjBpNfxyE5De70Z0je6H4Fm34rvP3kN47lbsXfcZ8rNS0efMS+Bj9mwKpZskJtgfKXnFKHfmonfHYIm/aG20ewtEa6KuFgvGRNS8v3PnzlpfS1cFhQy7n1JIuTb2U2B3VMLufLRIeAMFyMGDB7F+/foq6wMtHfStuo5jxYoV1Y7B9ZzrOBRFaV7Y4NDVbIuWSy5uGpvwQBt6DBwLDP8D0oN6ocAShvKAGPjmH5aYhcDEHxC++31YCr0L8CwP6IC0IXcjs++1cFqDYC04io4bHkP4jrcRZjPh/EuvQ1Hc2XAaPkje/RN++exllBUXeiWQOobYkFlYim1Jucgt8i5AtDlofZKngWEwISfQ5vrsuhAfHy8xBBQBrtgDd/h4WFiYRy14+d07duyIlStXHvOcK4ahptvEE2id4GqF7dpHjhwpt3/84x+rHcf06dNlhVMTHp+iKM0Pr0PsqEyrIC2X5513HtatWyeWyMaEAYg946KRGnIxjhxKgP+h5YgItsK3JAO2zO0oK85CeFE6iqKHoaDTKMBk9eyDTGbkd5sCR0R/dNj6H9iydiBk/1L4p29B+uDbcN7U6VizIQpFmxYhL3Uf1i96FgOmXI+QyE6efZyPDzoG25BeUIKtSTliiWAvjdZCuxcQPCHq4kZoTmgdoPvhpZdekmBF9wmdaVVczV999dVVAYyuVb4L3j+e+4NWAO7DYrFIcGVtDBgwQOIerrvuulqfZ3BnXdr/0o1x3333SYAns0polXA/Dla/4zHwWBRFaZnw+sOgyhEjRoiQYGYGY7R4HWhMeH2LCbEhqFdvHAjvjP0HN6NT1nrY/ULhm3cQvoXJMJXkwi9nL/LjJqA0pPbrWV0oD4pF8si/ImTfEoQlfCLWjk5r5yGn+wyMPf1i7AyPxIGVbwMFmdi45F/oMe5KdInv5/H3YmBlZkGJWCJ6xQQhJthWdT1vyagLo5XAGAGmT02ePBmrV6+WmhAMNKSwYKYF4xRcMObhqaeekpObwU4fffSRBFLWxsSJE8XFcf7550uGB90MjLRmVgeDGV2d+Zg6yltaO7Zu3VrNUsBJn8fEbJATZU0wj5wZIrQ8jB8/XupZuGBkN4M2KS5Yp4JuC16UKFrqIk4URWk6aFFcunSpxD7RennTTTc1amaGO3Y/C07rFIJu/UYgqedVOBg6CoVhp6E0qDNsuftgT/5Jik+F7P+8sky2p5jMyD31QiSNeRSlwd0k5iJs7yLErn0QA6J9MezCu1AcEAtnWTESvnsdm9d941VwZUSgH8w+PtielIeDGYVwtoKqlSogWgmnnnqqTOjdu3eXzASmPzLAkRNxTRMi/ZR8LYMSWUnu2WefFeFRG1S5X3zxBc4880yZrBmsSMsAUzOZSulK1aQI+eyzzzBo0CBxRdB86YIZGBQePKYTuVF4saGbgvEOtEa4QzFB4UOxwAp4/fv3l0AtulEY+a0oSsuC5yizv3h+vvnmm7W6HxsLk8kHsaH+GNgtCrZTx2Jnl8uRGjUWRVGD4LT4wz9jK4L3L0Pkb68gIOVnr1I+y4K7IumMJ5B96sWVDb9yDyB2zYPomfk9Jlx8C5zRA2DAQOZvX2DV0rel6JanhAb4SjDlnrQC7E7Na/G1InyMppKNTUReXp7kK+fm5kpNA3fYVY7BgaeccorUM2ivMKaA2RCs/aC0LfQ3rjQ1tHLeeuut8jctle6uyaaA/SWYzXAgvQCl+enomrcJwRmb4Zd3QFIxy/0jpWV43ilTvXJrEGvuIUT99oJUsCS0TKT1m4sftiWgcMc3DHVHhb0Thkydg8iISHhKSXkFMgpKJcjy1OhABPhaWsQcWhNd2rWzlFXWg2B9hb59+zb34SiK0gag+/H222+Xv6+55hrJpmpKzL9bIwZ1CUNUdCz2dZiAhPg5yO4+HSWhPWAuyUFQ4kpE//IUwna8C3Ox52Wpy0JojXgS2adeBMPsK7EXsevnY2pkGrqNvUKqXJoLj+KXT57Drj3VC+fVBz+LWeIgknMd2JKYi6xCz60ajYkKiHYEo6e5OqBroGaqp6IoiqfQTXrxxReL+Z7xVIyTampo+j+tYzD6dw6BEdgBOyPOwZH+tyGnx/kos3eExZGB0P2fSzBkSMIS+JQXe/ZBJjNyel2GpDGPoyQ0Hj7OMsnUGJf+HsadOREmeySsFYU4/P2rWLX6ezg9NPJXpnn6o7C4HFsTc6R6ZUtzGKgLQ1HaEPobV5rzt8f4pR9++EFimhibxZL7zQGrOx7KLERijgPMZYj2yUFo4goEHVkBc0mlBYKujdxTpiGv62TA7GHap7NCgjVDExbDVF4Ew+SLvA5DsDzJB5kpla3CCyMH4qxzL0ew3fPzMddRhqLScnSLsKNbpF1KYrcEF4YKCEVpQ+hvXGlOWBH3jDPOwI4dO6RSJSvdskZNc8CpjUWamNGQUVCCYJsVoUauWAvo0jCVVRaBKvePQO4p038XEh5WlsxPROT21+GfuRMwKlBui8S2is747WAaygwf5Pl1xIBzrkGP2ONX6z0Z7JvB7xMT7IfuUYHyfRoDFRAqIJR2iv7GleaGKeZ0kTKtm7dMD2+udgGEmQxHc4pwKKsIxaVOKdRkK89F6L4lCDqyHKZyh7yuwi8MeV3PQV63KXD6enC8znLZX+jexbAUZ0jGRpY5Ej8lleBoqT8c8EfwsFkYO3SgxzUeGDCall8Mf18z4qMCG6VehAoIFRBKO0V/40pLgJ11mRpOiwRrzbBmhKvXTnORX1wmrbQZmGg1mRBm94W5rABhez9GUOIKmMqK5HUVvsHI7zwOBXETUBbYSTp31gdLYQrCdy9EQNpG+JQ7UGoKwO6scmwrCEKeEYCcTmdi2uRpsHthQcgpKkVxeQXiwgLEpcFKnQ2FCggVEEo7RX/jSkvhp59+kh467DzMEvwffvhhs1eZZXEmujMOZBQiu6hU3ABBNit8SgsRsv8zBB9ZLlkb8lrfYBRF9kdB53EoDu8jGRZ1/6AKaTlOKwerWBqGE+mFZdieY8VhIwqHbb0xasoV6BET5qVLo0QKUPXrFCJWiYZABYQKCKWdor9xpSWxfPlyTJ06VaroXnXVVXjrrbdaRGE41llIznHgcJYDjrJyhAf4ySqecRFBB79GcOJyWIrSAcMJp28QSoK7oSh6OByR/VAWGFtnq4TZkSkxF/aUn2ApSoOjtAxHsouRUN4BO9AdwadfjolDenvshmCGR0puMYZ1CxMh0RCogFABobRT9DeutDRYwZZl7Fll9uabb5ay/C2lzwPdGkeyinA0p1iyNcLtvtJqmwWo7Ed/lGBLduVkhoXTGijioSSkOxwRfVEc0UesFCfFMOCfsQXBB76ALXsPUJSJ9Nx8JJUEYI/RGTs6XoCLJ08QS4gn0CUztGvzCIjml4JKm+Phhx+WktetHZbn5oWO7cwJa/7zfk5OpYnTExpiH4rSmpgxYwbefvtt+d2zISD78rSUdSsn7T4dgzGoSyhC7VakFZQgu7AUFdZA5HebjJTh85B52rUo6jAQTksAfHMSRFQwbTNyy6sI3fMRbBlbTlxTwscHjg4DkT7oVuTEX4CyDv0QFRmFXvYCDDPtwbkpr2DZ+//CjqQstDZUQLQSrr32WjkBubHrHVt8swdFeXm51/tu6Entnnvuke6dbY3Ro0cjOTlZ1HldYA8RFu3yZh+K0hZg75vXXntN/n7hhRekq3BLERG89jEzY2DnUPSPDZEaC0dzHSgoLpdsjIIu45E25G5k9b4chZ1Go9TeCRZHOgLSN0mcQ8iBr9Bh678Rsu8z+GXtlqZbtUFXSG6PGcjsNwcFcWfBN3YIuoWY0cOchvPLv0TZ53/Csh82SKZFa0H7JrcipkyZIk1r6E9kAyyWkLVarXjwwQfREuAFgWZKpmx5m7ZVVlYm360haKh9UbixC2Fz70NRWiNz5syRawR78Dz//PMycbOCZUtxZ9B10SnUX9wYR3McOJJdhKO5pb/HRwSgMPYMFMWcDv/0LQhI2wRzcaZUt/TL3g2n1Q5TaSH8chJgmCzSI6M4rJf03jDM1V0LrF5ZGhQH+9F1sAfGIDx9G+ype+BfloAuOx7GiiMTMOjcOYhspvoZ9UEtEK0IpkFx8unatau0xGZ6FP2LhOlSV199tRRtCQgIwLnnnou9e/dWvZfdNdkJk8/b7XbphUERQjM9O3oSPseTmdYO4nQ68fjjj4s/3d/fHwMHDsSiRYuOsVx8+eWXGDp0qBwfC8fUdGFwP7SWdO7cWV7D59iKvKargJ39xo0bJ7779957r9Yx4Otefvll+X48JnYndT+mE+2LK6A+ffrIY7179xZzqjvsMMoOpnx+2LBh2LRp00ktNewgSksDx5zjx66n/F9wDFetWlV1oeTGY3PfB32N/A4cP3cWL14snUvZu8SVV88OrOxMyq6rM2fOlH0pSmvj+uuvl5L65J///Kd0Dm4plggXDKbs3iEQQ7qEoUt4APJKypCaV4yyCqeIAYqIjH5zxJrg6DAIxRF9Ue7fQawS1oIjlaIiJwEhB5Yhcsu/EZLwKWwZW+Hze5oo4X5ohcjsex0KekyD+dRJiAr0RRdTBsblL0PmojuRsOGr41ozWgrt3gLBH6+jzPNWr97gbzV7pb45+WRmZsrfnLAoGCgoGPhy//33S/QzK8Jx9U1rBevUr169WgQEH6eVIC4uDh9//DEuuugi7N69W97L/RKKh//+97945ZVXpJ0433vllVdKy25Ozi4eeOABPP300zKZcxLlJOkOJ9FnnnkG//73v2WCfuONN8Qvun37dtmv+374OtckfjweeughPPHEE7Lfd999V/p7sPY+xcHx9kUR8de//lUCuPgYxcGNN94oY8EGQAUFBTjvvPMwadIk+c4MRKSv9kQwNoJpalxZ8ViYosZGQrTC8P6ePXvQr18/EU+E4+Y+8XOs+Znvv/++CCIXPFb2E6AoofWEooQFeVgimJ/BFu20Rm3ZskUsGorSmuB5x+vuH/7wBzz33HNwOBzS0bMlZGfUjI/oHROMmGB/HM4qkgJOFtaPCPCF2WQR4VAcfhqs+YdhT/1VGmsxYJIBlyyXzUJShtkGv9z9ssHnO5TZO6Ek5BSUBp8ipbTLA6KQ3XMWbBF9ERgYg4Ckn2FJ2QV7xR4kbnoRe46sQ69R58MZM0B6cLQ02r2AoHg47a9fN8tn7/i/yR61aeXJxxiDr7/+GrfddluVcOBqmD521yREcfDpp5/ikksuweHDh0Uk9O/fX57nZO+Cq1oSFRUlq1xCN8ljjz2G7777rqrxFt9DCwOFgLuA4ATJifd4UFxQ0Lja/D755JMy0XIFwguHC8YLMFr7ZPD7uFqRsy05O4zSr+puUai5r/nz54ugcD1GqwpFFL8LBQQncVpKXn/9dREctNAkJiaKped4PPXUU2KpcP9c9y6nnNwpAk7ksqBvmOlttDbwtbRKLFu2TKwQhJYUHhetJy6xSTcW/08Uauw9oCitjblz54pg4C0XKPn5+fK7bii3ZUPBc44Fp0L8rcgosImQYOvwAKsZIQFWmHx8UBbcFTnBXWEuzoJ/+m/wz9xeaTkwDGm05TT7Aj5mqXhpLUiSDUlrpGBVqYiJrigJ6ymujcCwXrAHr0DFoV/RvSgFeRkrsePLo4jvMxj23mejJKxXvQtbNSbtXkC0JljNjVYDrko5qcyePVvcBRQTXJmOGDGi6rURERHo1asXdu7cKffZbpeTIcvK0vVBMTFgwIDjflZCQoJMajWFAa0YXMG7w0n0eHBCPHr0KMaMGVPtcd7/7bff6rwfd2p2EuV9V6ZEbftiIZt9+/aJ+ZSrHxcMQHUFM3KcOB7ulo+TdSzlZ1LMeAOtRLxoUgBSYNEaRMsE/0eEY8T/BV0aNdM1+Z0UpbXCRQCvZxTQXPDQCrhw4cIWmX5sMvkgKtgm8RFp+SU4LBUtixHkZ0GQzSJCo8IWjoK48RJoacvaJWKC7gzT726ICt8gVPiFirCwFqXAXJpXKTjSfwN8TFL1soRipPdlsIeeAmPfSvhmJGJwxRbs35qOzPRk9IqPR1HsGSgN6d4ihES7FxB0I9AS0FyfXR8Yq0D/P1e27HZXn6puPFlpCufqliKC7gmuyGnBqA2ezISvj42NrfZczZK0dAM0BA21n5r7cn2XV199tZrIImaz52ZBl6vHG/i/ZBtkWkAoIHg7a9asqv8tj53xJbXFhNAloiitGf7mKSJ4DixZskRcerSaNmfvjLoEWkYE+koBJ6khketAqL8v7H6WqvgGpm06IgfAWnhUgi79cvbCXJovG4MsS+jCsIXCXF4ilSpZ/dKanyhb5T58YXQdgWg/K7LSjiK2JANlKavxS3YG+uekIiwiDoWdRqE0qGvzjgfaOVSOnrgRmgNOikzfrAl9/1xNs3Ssy4XB2AjGNLAjngu6NG666SbZmLnBCZUCwuVHp+/eBd9HoUDXh7u7or5wNU2xQ/eK+354f/jw4R7tc/369RIw6n6/plXEnejoaDmG/fv3i8ugNjiGjKfgyt61AuJ+TwQtFrT+/O1vf6v1eY6r+5geDx4TLT2MCWHlPsY4uBgyZIi4MeheOllRF0VpjVA0MJCYQd48n3id4MKlJWcr+VnM6BphR4cgP8nYSMp2IMdRigh7ZUVLge6NwFjZfMrPgi1rJ/wztolVwpZTGeBON0ZxeO/K1NCyfPjmHYJvwRH4lJdIYauyyNPQweQDZ/oeZDuKMaDkVyRtOwxz58HoUZiM8sBYZAcNYQh8s4xD65g5lRPCQERG5tM8T58+zd0MIqTlgI+7YgIYqNezZ0/JEmAMgivokFkdFFJ0kdCkzpU198F6DszXpruELXpZmYwTPycyxg3UlXvvvVdiEHr06CEZGPR10vx/vEyLk/HRRx+Ji4LHxH0we4KxCyeCkzzdOHRZMACRMR6//PKLjMXdd98t7qB58+bJGFJcMdiRsRsngq9jTAmr61GUUTBwXOnWiIyMRLdu3UTUcV9cUbliTWrCpkO8WFJIMDbD3UrCx/7xj3/I/9GVycKMmk8++QT33Xef3FeU1g6tqxTP06ZNw8aNGzFy5EgRFe6B0S2RAF8L4qOCxL2RlF3p1qCQYOon60m4MCz+cEQNgaPDYFiKUiVOwpa9S9wY9pQNoL20zB4tPTfy48ZLSW1aJnzzj8CwBsAcFIfIoz/DkZuGHs4klCWmID0tCpaACFjLv8COw5Mx+oK5XllUPaFlhb0qHsNJmaZuqnn67hloyTRNV1ASV8LMxOAJyQmUQsIV/EehwQmWooOr9VtvvbUqQJEZD3R3uN7HlQEnufrAiZuTNFO2OOEyhZM+f/cMjPrAY6WvlBaAd955BwsWLKhmaTmeC4eBiBwnHgNXOazL7/ounOA///xzyeagNYNigsGeJ4JjSHcQ4xRoTeG40wzrcj9QgPGE5rHR3UBrTm1QvF1++eWyn5oWEgZWMvulS5cuEgDK/wNjOWgpUYuE0pbgObRu3TqxslIkM06KmUetgeDfMzYGx4UhOtiGrKJSpOUVo7zCWf2FPj4ot8cgv8sEpPefi9zu06Q0NmMgrIWpCDqyEpHbXkNg0g9wWmzIPWUq0gf8ERkDb0b6mIdh6nUO/PwDYTE5EVyWBmfOPvik/IY773lAFixcWDQl2gtDaVVwsmWGAtMclWPR37jS2klPT5c0b7oQ6Ual6KfAbi04nQYyC0uRmF0kIoLujlBJ/Tx+0CNrRLBPBt0c1sJktydMKA3qguKwUyVLg5aMn79eCOfyxzGkix0BVsBh+OLPG0Lx9ber5C2si1OXbLbjob0wFEVRlFYJrXWMhWALcLoa6V6ku7Au8UQtJWOjQ5AfBnQOxcC4MAT4mZGa70BOUelxi2bRTeGIGoTs3pdLkaqC2DNQHtBBuoGyvkTwoW/RYcu/Ebz7Q3z8zr/x17U+eH5NHrZkWpBXYYXjyLaqfdNd3VRjpQJCURRFaVHQdcdYJ9aPISwcR6sEV8WtBbPJBzEhNgzuEoa+nULkvqvHxolw+oWiKGY4svpchcy+16Kg05gqMZG9dwNGBiXjj/2KEWCpwHfbMvDlthz8eKgyVZQigpVrm8r1owJCaVXwBFH3haK0fRg/ROHA1Ga64xjTxQBjZpe1JqxmEzqHBWBI1zD0ig5CmdOJpJwiOEpPbiVgbYmijiN+FxNzsMPZDYkFldN2J7uBuCAngizl6BtZ/X1s2NcUqIBQFEVRWiyMf2AFXGYcUTycfvrpEkTd2rBZzTiFPTa6hqFbhB0FpWVIyXNIj426UGELRWnsSLy1yx///M0fyw76IiHXjHLDhP01DDMdO3ZEU6ACQlEURWnRMMOMaddMeWbZa4oK9tJgH43WRqCfBb07BkuzLmZsMOAyPb+kTm28Bw0ejKjoaBSUm7Epw4qFe214ZnsECkr/F2TOej9jx45t/C+iAkJRFEVpDTDFnMGVf/nLX2SiZFdPujR27dqF1khogC/6dQrBwLgQBPtbThpoScwms6SHC7+Xsi43Km9dvXLYY6ip6kGogFAURVFaBayxwvo0bCTI6qys20LrBJvyseBda8PEHhtBNgyMC5VAS9PvgZZFpccPtDx7/NnSyI/f3x26eLxN4awvWgdCUdoQ+htX2gspKSm48sorxSpBzj77bKlIy4JKrRVHaYXUj+DG0Ag272IQZm1UOCuwedMmJCRnYnj3Dpg24cwGsTxoHQhFURSlTcPy76wE+8ILL0jaJ0ths8osXRutdV3s72vGqdFBkvrJWhIZBSXIKiyFs5bvQ3fG0KHDcObYMzFm9OgmL2NNVEC0EVauXCk+sJycnOY+FOUknHXWWVLsRVEU7zCZTFJ6n2Xg2RuH3WsZXMlgS7o3WiuhjI+IDZFiVH5WE5JP4tZoLlRAtAIoDE60Pfzww819iIqiKM0G+2dwEfXss8+KNYJpn+xpw2aANMm3Rsy/F6IaFBeK+KhAERCptfXXaEZUQLQCWBTEtTHCln4p98eqonIVRVHaKTThUzDs3LkTF110kZRz5vWyV69e0k+jtZTCrq1+BDt+DooLQ2SgL1LzS5DrKENLQAVEK/H1uTYGt9Dq4P4YO0m6+PXXX6XVNVX46NGjj6na9vLLL0tbbbae5on17rvvVnue+2ZLcHb15D7Y/ZEd8hISEsT0brfbZb/79u2reg8tIGzTzfcxB5nvu/TSS6uVneXqgN32+P7Q0FDptMeOe/U5LnbTZH187p+dPNnR80Sw2yhfx2BCpoBdfPHFVc+xIyhNnjyWiIgI+b7u34ktuPmZH374oeRUs8U5C9js2bMHP//8s4wxx50t0tn8x8W1114rlTLZMZQ1/Sn22Oq7tPT3RO1aYL1/ikB2ReX4MDWN4+WC4zR9+nSEhYXJ83379pWqfIqiHAs71zIbgec4z38GW86ZM0fiI9itsrXGR4TZK90a/WKDYcDA0Zy6F6FqNIw2Rm5uLn8dclsTh8Nh7NixQ26rcDoNo6ykeTZ+dj158803jZCQkGMeX7FihXzvESNGGCtXrjS2b99ujB071hg9enTVaz755BPDarUaL774orF7927jmWeeMcxms7F8+fKq13AfsbGxxgcffCCvOf/8841u3boZZ599tvHVV1/J+I0cOdKYMmVK1Xvmz59v2O12ec2mTZuMVatWGfHx8cbs2bPl+bKyMjnme+65x0hISJB9vPXWW8ahQ4fqdVydO3c23n//fWPv3r3G7bffbgQGBhqZmZm1jtPPP/8s++DrDx48aGzcuNF4/vnnq55ftGiR8fHHH8u+eMzTp083+vfvb1RUVMjzBw4ckM/s3bt3te89dOhQ46yzzjLWrFkj++T3vOmmm6r2e80118hxzZo1y9i2bZuxdOlSo0OHDsaf//znqteMGzfOuOOOO6ru33DDDfJ/Wr16tYzPP/7xD8PPz8/Ys2ePPD9t2jRj0qRJxpYtW4x9+/YZn3/+uYxxbdT6G1eUdkpxcbGcT+Hh4XI+czv99NPlnHZ6cP1tKeQXlxlbE3OMr7clG19tTTYy8oubZA6tiQoITuTLH2uejZ/dwALiu+++q3ps2bJl8pjr+3KSuvHGG6u975JLLjGmTp1adZ+v/8tf/lJ1f926dfLY66+/XvXYggULDJvNVk1AcLJOTEyseuzLL780TCaTkZycLJM890FhUxueHFdBQYE8xs+pDYqD4OBgIy8vz6gL6enpsr+tW7dWExCvvfZate/Nx77//vuqxx5//HGjV69e1QQEL1aFhYVVj7388ssiKlzixF1AUERx7JKSkqodz4QJE4wHH3xQ/qawefjhh+v0PVRAKMqx5OTkyPWDCx2XkBgwYIDxzjvvGCUl9b8OtwQqKpxGQlK68eRLbxo5haXNIiDUhdHGGDBgwDH10NPS0uSWvkG6DtzhfT5+vH3Q9E9o/nN/jPUG3IOTaDakCd7FqFGjpLALXSjh4eFi2p88ebKY4p9//vlqzV48OS6a8ukecH23mkyaNAldu3ZF9+7dcdVVV+G9995DUVFR1fN79+6Vcrh8nvtx5Y4fPny43mNR8xgGDhwobhb3sWB0OLvk1YSR4vTN9uzZU1wirm3VqlVVLpXbb78djzzyiIzJ/PnzsWXLllq/s6IotUPXLwtQ7d+/X+IkeP3geXT11VdLzZQnn3xSXB2tha1bt+L222/DkD49cP/N12HfrubJOLGgvWO2AmP/1Hyf3cBYrf/bp6u0aX0rtNW2D2/3yyAmToT0S37wwQdSjvbbb7/FyJEjPTou13Ec7xiCgoKwceNGiSVgrvhf//pXidVg/ALjHihkKDBeffVVdOrUSfbTr1+/Y2IV6jIW3lTAo7Bg8BdjV2rmcbtiW2644QYRX8uWLZPv8vjjj+OZZ57Bbbfd5vHnKkp7hNUbmanx0EMPSczWv/71Lxw9ehQPPPAA5s2bh6lTp8pihzFRjMdqSeTk5GDJkiVyzVq7dm21DJTMzMxmOaZGs0A8+uijEmzHlRgv2HWBlmpe6LlyZtDaxIkTZaXYqHBSsPg2z/b7hNRUMCDS/YdHeP+0007zet9cufNEdLF+/XrJ0WZApAumVT344IP48ccfZbJmm97GPC6WveVviGVfudpgYCSLzfBko2WEImbChAny+dnZ2WgomJPu3uSHY0ExwADTmnBMaIGgFYMXAveNAbIu+F4GYzII7E9/+pNcRBRF8QwGJFM0sGorFzdcyPA8/PzzzyWDg4uK6667Ts43ivzmIisrS45v2rRpIn4obnht5LWNQeHfffedXMtocW1TFgiu5C655BIx37K8aF3ghZ6K8O233xazElUiV147duzQsrwNwL333ivZEZy0OLHyZOEJwh+ht/D/c8011+Dpp58W1watDfwsToI8SVkdbsaMGXJi8gdPYUjzYWMd19KlS8VcyYIyvFgwa4GWAgoa3mfmBY+JYpXihxeThvztX3/99SJQKFrodmCxGwqqmtB1ccUVV8hY0KrAMWBWB8vz0n3CCweLTjHbg6+l0FmxYoWIHkVRvMPPz08mZW50mXLueeedd8TF+tZbb8lGS8T48eNlscH5jL03uMBtDNhplDUsaDnleU7LpLuFkxlYl112mVxfmqpld7MICKaxEf4D6mp9YM4uL7ozZ86Ux/iPpI/5008/lUFTvIPphYw/4CR/xx13iEijumV6prdwxcwmLjQBUjXTBMg0SkIrFDvm8eTk6p8//FtuuUUqxjXWcdHqRRFCtwXjNZjOtWDBAjkBycKFC0Xk0BJCUUHh2hDjQHih4edRvDBFk7EWJyr2xe/KGAdaFpKSkhAZGSkrIo4h4cqI45WYmCjxGlOmTMFzzz3XIMeqKEolFOVPPPGEnIurV6+WhQw3xiKxeRc3wtU/09aHDBki5zk3Xv8YT1UXYUFBkJGRITEXXOQwnmHbtm2ycXFVs14FFxK0NnBraQuHRm+mRQHBFdTJSixzIFkHYNOmTfLPcTFu3Di5zwmmNniB5uaCq1+ae7WZVtPByZEib/PmzWjvcCXD3zrHoznQ37iiNBycHjmpM/6IrlfWxHEPAK8JzzkuXrgxcJOUl5dXbbQgpqamnrCoFc9dWjy4oOFWm+uzMalPM60WE0TpioB1Rbq74P0TRccyoMxl7VAURVGUhoJB0r1795aNFkIKCro8KSS2b98urlgW2eMtJ14KeM5XdcnoYKE5igNaQbkxu4ubezZbS6deAoJ+Yqa7nAj6kTjYTQWD8u6+++5jLBCKoiiK0tCCgtlb3NyhsODcQwsDLZDcuILn6+ny4MYsK1om6MKleKiZVdYaqZeAoAKjifZE0A/kCa6Ic5p33INDeN/dpVFbEAw3pXldGNrQC/WK+VEUpe3g4+MjZn+X26K9UC8BQdXErTGg34cigtHnLsFARffTTz/hj3/8Y6N8pqIoiqIoLawOBP1EDKrjLQNG+Dc395xaujoWL15cpeAYbMkIWDZJYmQqU9uY9scofUVRFEVRWg6NFkTJglBM23PB/HbC3FZXuhyjW907Nt53330oLCzE3LlzxYfEbomsXNjQ0eTeVA5UlJZMa+00qChK66PR0zibmhOloFA4MFqWwSx0xbBAiKs8saK0dngqswgVe34wN71maWxFUZQ2mcbZFLASIGMtmMfrXnZZUdoKFMSdO3dW8aAoSqPTrgQEodWBnSNZ1ONExTwUpTXC1DAVD4qiNAXtTkC4Vmm80LaFPFxFURRFaVNZGIqiKIqitF1UQCiKoiiKUm9UQCiKoiiKUm/aXAyEKyuVqSiKoiiKotQd19xZlwoPbU5A5Ofny6021FIURVEUz+fSk/X2aHOFpFgsijUegoKCGqxIlKvD55EjR05aWEOpGzqmDY+OacOi49nw6Ji2/PGkJKB4YBsJ1k5qVxYIfmEW0mkM+A/SH33DomPa8OiYNiw6ng2PjmnLHs+6dhXVIEpFURRFUeqNCghFURRFUeqNCog64Ofnh/nz58ut0jDomDY8OqYNi45nw6Nj2rbGs80FUSqKoiiK0vioBUJRFEVRlHqjAkJRFEVRlHqjAkJRFEVRlHqjAkJRFEVRlHqjAuJ3XnzxRXTr1g02mw0jRozAhg0bTvj6jz76CL1795bX9+/fH1988UWTHWtbHNNXX30VY8eORVhYmGwTJ0486f+gPVLf36mLhQsXSmXW888/v9GPsS2PZ05ODm655RZ07NhRIt979uyp576XY/rPf/4TvXr1gr+/v1RVvOuuu1BcXNxkx9uSWb16NaZPny5VIXn+fvrppyd9z8qVKzFkyBD5fcbHx+Ott95qvANkFkZ7Z+HChYavr6/xxhtvGNu3bzduvPFGIzQ01EhNTa319WvXrjXMZrPx1FNPGTt27DD+8pe/GFar1di6dWuTH3tbGdPZs2cbL774orFp0yZj586dxrXXXmuEhIQYiYmJTX7sbWVMXRw4cMCIjY01xo4da8ycObPJjretjWdJSYkxbNgwY+rUqcaaNWtkXFeuXGls3ry5yY+9rYzpe++9Z/j5+cktx/Prr782OnbsaNx1111NfuwtkS+++MKYN2+e8cknnzBb0li8ePEJX79//34jICDAuPvuu2VueuGFF2Su+uqrrxrl+FRAGIYxfPhw45Zbbqm6X1FRYXTq1Ml4/PHHa339pZdeakybNq3aYyNGjDD+8Ic/NPqxttUxrUl5ebkRFBRkvP322414lG1/TDmOo0ePNl577TXjmmuuUQHhxXi+/PLLRvfu3Y3S0tImPMq2PaZ87dlnn13tMU5+Y8aMafRjbW2gDgLivvvuM/r27VvtsVmzZhmTJ09ulGNq9y6M0tJS/Prrr2Iyd++nwfvr1q2r9T183P31ZPLkycd9fXvDkzGtSVFREcrKyhAeHt6IR9r2x/T//u//EBUVheuvv76JjrTtjudnn32GUaNGiQsjOjoa/fr1w2OPPYaKioomPPK2NaajR4+W97jcHPv37xeX0NSpU5vsuNsS65p4bmpzzbTqS0ZGhlwAeEFwh/d37dpV63tSUlJqfT0fVzwb05rcf//94vereTK0VzwZ0zVr1uD111/H5s2bm+go2/Z4cnJbvnw5rrjiCpnkEhIScPPNN4vQZTXA9o4nYzp79mx53xlnnCFdIMvLy3HTTTfhz3/+cxMdddsi5ThzE7t2OhwOiTNpSNq9BUJpeTzxxBMS9Ld48WIJxFLqD9vxXnXVVRKcGhkZ2dyH0yZwOp1izfnPf/6DoUOHYtasWZg3bx5eeeWV5j60VgsD/mjFeemll7Bx40Z88sknWLZsGf7+978396EpdaDdWyB4cTWbzUhNTa32OO/HxMTU+h4+Xp/Xtzc8GVMXTz/9tAiI7777DgMGDGjkI227Y7pv3z4cPHhQIrjdJ0BisViwe/du9OjRA+0VT36jzLywWq3yPhd9+vSRVR/N976+vmjPeDKmDz30kAjdG264Qe4zo62wsBBz584VcUYXiFJ3jjc3sdV3Q1sfSLv/7/Ck52ri+++/r3ah5X36O2uDj7u/nnz77bfHfX17w5MxJU899ZSsPL766isMGzasiY62bY4pU4y3bt0q7gvXNmPGDIwfP17+Zrpce8aT3+iYMWPEbeESYmTPnj0iLNq7ePB0TBnrVFMkuASatmmqP00+NzVKaGYrTD1iKtFbb70lqS9z586V1KOUlBR5/qqrrjIeeOCBammcFovFePrppyXlcP78+ZrG6eWYPvHEE5L+tWjRIiM5Oblqy8/Pb8Zv0brHtCaaheHdeB4+fFgyg2699VZj9+7dxtKlS42oqCjjkUceacZv0brHlNdOjumCBQskBfGbb74xevToIZluiiHXP6a2c+N0/eyzz8rfhw4dkuc5lhzTmmmc9957r8xNTI3XNM4mgPmyXbp0kUmMqUjr16+vem7cuHFy8XXnww8/NHr27CmvZ9rMsmXLmuGo286Ydu3aVU6QmhsvMIrnv1N3VEB4P54//vijpGxzkmRK56OPPiqpsopnY1pWVmY8/PDDIhpsNpsRFxdn3HzzzUZ2dnYzHX3LYsWKFbVeF11jyFuOac33DBo0SMafv9E333yz0Y5P23kriqIoilJv2n0MhKIoiqIo9UcFhKIoiqIo9UYFhKIoiqIo9UYFhKIoiqIo9UYFhKIoiqIo9UYFhKIoiqIo9UYFhKIoiqIo9UYFhKIoiqIo9UYFhKIoiqIo9UYFhKIoiqIo9UYFhKIoiqIo9UYFhKIoiqIoqC//H/nwXFQpzwm5AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 5) \t Best Value: 0.9538915741567119\n", + "Early stopping at epoch 8152 with loss 1.155492580065923\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 6) \t Best Value: 0.9538915741567119\n", + "Early stopping at epoch 6525 with loss 0.7314200558434392\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 7) \t Best Value: 0.9844725089729858\n", + "Early stopping at epoch 6479 with loss 0.6798152420784924\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 8) \t Best Value: 0.9844725089729858\n", + "Early stopping at epoch 6802 with loss 0.2123743140449812\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 9) \t Best Value: 0.9844725089729858\n", + "Early stopping at epoch 1684 with loss 5628.575479705238\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 10) \t Best Value: 0.9844725089729858\n", + "Early stopping at epoch 5111 with loss 0.04339227997413797\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 11) \t Best Value: 1.0413360979829451\n", + "Early stopping at epoch 9677 with loss -0.07003120007894692\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 12) \t Best Value: 1.0413360979829451\n", + "Early stopping at epoch 10000 with loss 0.11074134634137334\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 13) \t Best Value: 1.0779572447975334\n", + "Early stopping at epoch 4994 with loss -0.022944017572688047\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhAAAAF2CAYAAAA/RaFTAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAA1chJREFUeJzsnQV4U2ffxu+4p67QFtfhsAFzNqbv3L53xtzdnbkbk3fuPuYuzNmY4O60tNQt7jnfdT8lXVpaqEPb57cro0lOjuXkPPfzV5WiKAokEolEIpFIWoG6NQtLJBKJRCKRECkgJBKJRCKRtBopICQSiUQikbQaKSAkEolEIpG0GikgJBKJRCKRtBopICQSiUQikbQaKSAkEolEIpG0GikgJBKJRCKRtBopICQSiUQikbQaKSAk7ebVV1+FSqVCfn5+/Wv77befeHQUt99+u9iGRNKV11Js2crKyi7Zp87ejmTXRqVSiWuhuyAFBIAjjzwSZrMZLper2WVOOeUU6PV6VFVV1X/R8Q+LxYIRI0bg7rvvhtfrbfDZM844A1artUWD8Pz581u9//369WuwL+np6dh7773x8ccfozvB88Yfz88//4zeAo+18bXU3KOzid+WVqtFcnIyJkyYgMsvvxwrV67s0d/rvffei08++aRHfq+9jWXLluH4449HXl4ejEYj+vTpg+nTp+PJJ5/c2bvW49Du7B3YFaA4+Pzzz8WAe/rppzd5A/z0009xyCGHICUlpf51XpSx5d1uN3777TfceuutWLJkCWbPnt2lxzB27FhcffXV4u/i4mI899xzOPbYY/HMM8/gggsuQFfz3XfftfozPM933HGH+Lux9eKWW27BDTfcgJ7G8OHD8cYbbzR47cYbbxSC8+abb+7y/Yld02yR43A4xLX82muv4X//+x8eeOABXHXVVR36ve4MmrqWKCA46Bx99NE98nvtLfzxxx/Yf//9kZubi3PPPReZmZkoLCzEn3/+iVmzZuHSSy/d2bvYo5ACYqsFwmaz4e23325SQFA8eDweITTiGTJkCE499dT65xyog8EgPvroI/j9fqF+uwqq7Ph94XEMGjQIjz32WLMCIhwOIxqNCstKR9PR6+SMmI+eRkZGRoPvjdx///1ITU3d5vWuoPE1HdufI444QgjUYcOG4bDDDkN3piuupV3te+0t3HPPPUhISMA///yDxMTEBu+Vl5fvtP3qqUgXBgCTySRm6z/88EOTFxmFBQUGhcaOoOKNmYB3JtwPzoI2bdoknjM+gfv18MMP4/HHH8fAgQNhMBjqTdOrV68WMzCarSl8Jk6ciM8++2yb9a5YsQLTpk0T56xv377CZUMR0pimYiAoqmjK5iDFbWRlZYnzvmHDBrF/aWlpYjnOVmPm3Zg/sLHferfddhMzjcZwXyimeCzxr/GYR44cKbbLm/v555+PmpqaFp3LH3/8UbiE6KbiTemoo47CqlWrGiwT27/169cLlxWX443szDPP3Mal1RY2btyIE044QXw/dLdNnjwZX375Zf37tIBx/+huaExRURE0Gg3uu+++Nm2bVrd3331XXNO8QcegWL7tttuEm4PHyu3zPP3000/1y+zoe126dKk4XwMGDBDfDa/bs846q95V2By0kHAwjreI8Hvmeeex1tbW1r9Oywn3neeoqWuJf3OCQEtLbP+4T/FwfZ3xvTamJduh8L/rrrvqf8N0Yd50000IBAINluPr//nPf4Q7hb9n/mZHjRpV70riRIfPed75HS5atKhJ1yuvvYMPPlh8v9nZ2bjzzjvF+Y+H1wfXwfuk3W4X6+WMvzXXcLzr5/333xfXGu8x3L8DDjhA/LZ2BO8l/J03Fg+Ert14XnnlFXEv4+s8j3RB02LbmK48j02xZcsW8ZvgfYv7yeN7+eWXt1mOLhq+x3OblJQk9pVjV6fCdt4SRfnuu+/4TSpPPvlkg9erqqoUnU6nnH766Q1e57Jnn322UlFRIR75+fnKW2+9pdhsNuW0005rsOyMGTMUi8Wy3e2/8sorYp3//PNPq/c9Ly9POfzwwxu8FgwGlYyMDCUzM1M837Rpk1j/iBEjlAEDBij333+/8thjjykFBQXK8uXLlYSEBPHeAw88oDz11FPKPvvso6hUKuWjjz6qX2dJSYmSlpamJCUlKbfffrvy0EMPKYMHD1ZGjx4t1s1txNh3333FI0Y4HFYOOOAAsdz//d//iW3cd999yrRp05RPPvlEcbvdyjPPPCPeP+aYY5Q33nhDPJYsWSI+P3PmTPFejDvvvFNRq9Vin+L55ZdfxHKzZ8+uf+2cc85RtFqtcu655yrPPvuscv3114vvY9KkSeI8bY/vv/9efHbIkCHKgw8+qNxxxx1KamqqOAfxxxvbv3HjxinHHnus8r///U9sl69dd911rfo+R44c2eDclZaWiu+S19bNN9+sPProo8qYMWPE8cd/P6eccopYjuc6Hu43v0t+19uD+3rxxRc3+z6/P27T4XCI57zus7KylKuuukp8d9zO0KFDxe9l0aJFYpkdfa8PP/ywsvfee4vv8/nnn1cuv/xyxWQyKbvvvrsSjUa3u79HHnmkMmHChPrn3Ca3w3384osv6l/nb2PixIn1zxtfS9wfg8Eg9iO2f3/88Uenf6/xtGY7vJ/w9eOPP155+umnxb2Jz48++uht7gv8Pvgd8ffK33ufPn0Uq9WqvPnmm0pubq64D/DB3/+gQYOUSCTSYDtGo1H8xnlP42/2P//5j9jWrbfeus29k9cH94ePSy65RDnhhBNafQ3/9NNP9eeB3y33mftuNpvFNbEjDjroILGNZcuW7XBZ/v7POOMMsQ3e9/lZbpvHuTPOI+FrvBbiz1vfvn2VnJwc8Rvhb4nXPZfjfsTgbyd2TTz33HPKrFmzxPh02WWXKZ2JFBBb4U2XF8iUKVMavM4Bh1/Mt99+2+B1vtbUgz9iv9/f5QKCF39MzPDmzEGa67v00ksbCAi73a6Ul5c3+Dx/+KNGjWqw37x5T506VVz0Ma644gqxjr/++qv+Na6LP5odCYiXX35ZLMMbR2NiAwX3vfEPqLmb/po1a5oUfBdddJH4YXu9XvH8t99+E8tR3MXzzTffNPl6Y8aOHaukp6cLIRmD55c3vnhRGdu/s846q8HnOWimpKQo7RloYuedxxLD5XIp/fv3V/r161d/s+I1yuW+/vrrBuujwGtu4GqNgODgzmVigz9/M4FAoMEyNTU1YqCIPw/b+15j31M877zzjlj+119/3e7+UsBqNBrF6XSK50888YT4LXCgoUgkPDeJiYnKlVde2ey1RPj75O+0MZ35vbZlO4sXLxbLUVzEc80114jXf/zxx/rXeC74WkwMxV8jFGnxgpKDDl/nAN5YqMTuIbHfKgWZXq8X32vsuuB9pbFwjael13BMQAwfPrzBtcUBka/vSBhQzPCa4IP3coovHnNTE4Wmrr2DDz5YTLDi6arzSBr/TigCOC5VVlYq8fD+zvtu7BiOOuoocX11NdKFsRWaPf/v//4P8+bNa5COSBMQTUc0oTWGpuzvv/9ePBgnwSCpb775BieffHKLTFMdHbRIUzEfY8aMEUGcp512mjDfxnPcccfVm5RJdXW1MNGfeOKJIguFaWR80IRMc9u6deuECY189dVXwuy4++6713+e62ocG9IUH374oTA5NxXE1JZIdLpBGDj63nvv1b8WiUTwwQcfCH89zYyE54GmYAYHxo6ND5oaaVaMN7c3pqSkBIsXLxYmSJpdY4wePVqsj+ejMY3jTWjS57l0Op1oK9wOz/lee+1V/xr3/bzzzhPXaswNdeCBBwrT6FtvvVW/3PLly4WboCP87rFMoli2En8zsVgXug94LdG8TtPpwoULW7TO2PcUc3Hxu+E1Rna0Dp5bfucMnCMMYuZrfPDv2PHTLcDX2kNnfK9t2U7smmsczBoLoG7sEqBZfsqUKfXP99hjD/EvTfcMNGz8Os3sjbnkkksa/Fb5nO6rOXPmiNfoLqALiPfB9l7DMei6iY+jin1/Te1fPPxd8h5OdzMDgB988EFxH6Nbs7FLNv7aY8Awr719991XbIPPu/o8NoZjCO+bvJ/x7/j7F4+J+xj7jfA7oKuSsR9diRQQccQGwpjfiF8Ib0QUFrxZNob+Od60+eAFy0huxgTQJ/bFF1906b7zwuUPmBcjb6i8yF5//fUGPxLSv3//Bs/pV+TFyeyRmACJPWbOnCmWicWFFBQUYPDgwdtse+jQoS3yTXK5jowNOemkk/D777/XCxz6JLmvfD0GBRB/aPRzNj4++sS3F1jF423u+BhfwnPMG2c88TcTQl8kaWm8RXP70dw+xO+nWq0W1zDTEWN+c4oJ+mbpe24vsRgC+rljMG6AgorbYKwEzysHscY34Oag6GDcBkU6r1V+PnaN7mgd48ePF/7emFiICYh99tlHpENTkMTeix+42kJnfK9t2Q6/a37PDJCOh7EjHERi10Jz66OYJjk5OU2+3vh4uC3GpzQW7yQ20brooovEa4ceeqi4J9Jfz4lUW67hlp6H7TFp0iRxD+ayf//9t5jYUfQyLipeqPDewXt3LLaJ1x5jSZq69rriPDamoqJCiN/nn39+m3sXBRaJ3b+uv/56Icgo0niPvvjii8XxdTY9L6y9HXBWyijzd955R1xI/JeDa0tm2DFilopff/1VKMeugrN7/hh2RGNBEQuAvOaaa4SqbYrGN6tdBQoF3hxoZbjiiitE4BV/wEy3jT8+iof4WXk88daYjqApoUm6yiLF7JuHHnpIiIj//ve/QgwzACx2Y2sPnM3z+GID/JtvvimsM0x9vPbaa8V5jgVrUjC2BFq+KHj5eVqUeBPkd8bvsKng3Hh0Op0QzvytUQiXlpYKAUExEgqF8NdffwkBwd90e7/nrvpeW7qdllrtmltfRx4Pv3da6r799lt8/fXX4sEARV6LFJhtoSP2jxYMigk+OFhz0OW9ghMjXp+8V/PaePTRR4UQ4PK0lDBzrfG11xXnsTGxfaD1cMaMGWgKiveYEFuzZo2YuFK80XLB1GsGOcdSqDsDKSAaQbHA2TjNvrz5Us3xAmwpNOHGz9Z2dWKqmDfjHQkQFmbhjL4xvHB3BCPGeUPnjZ3baorWujI4kFFx041BcyBnHRzMGKkcv11aZfbcc89txNOO4PE2d3zMWqFo4+yls+F+NLcP8fsZy04ZN26cEEycDW7evLlDCuhwPb/88osw48YsEHQX8frheY//7mKWqx19r5ylMfOJNzje6GI0dY01BwUD3XT8jvl9cEDg9hiNTvHABwXUjuguBZ34XXNg4TmKzd5JWVmZmK3GXwsdAbdFc3xstkzWrl1bn50Qg4MvJ0x88DO0SrAWDe+lnIC05hruDOhWi7klCev+MGuFbo1468L2XJpdcR7joejlb41uupZMDnkv4qSKD7pGmOHGTBZOsjqrpIB0YTQiZm3gDY2qujXWh9iFSRiH0B3g7IHplvyxx35cjc1oMZj/z4IsNAvGv9/c7L5x7AVN/k899VSzap3maBKfgrcj+GPhPjGtieuPd1/EZrj8ATLtrSmxt71tMc2Us2LOouKX40ycMSddVQ+B2+E5p283Bl0nNG3y5kP/bDyMfeH+MXWVbgWaltsD3Qy0ZvA8xhdBis2+4mdbFInx+7m977WpzxPud2sEBAcCfoZuipgQ4Oss5MSiai2Jf+DNtzXX3c4ids01PkecRZPDDz+8w7cZ/5vld8XnnATErK2NU25pro/NjGOppa29htsKBUBTs/9Y7EjMjdLUtUe3BS0nncVTOziPjeE+8r5JawLvOdu7Nzf+DijoeE65HU7aOgtpgWhiVjt16lQRFEm2JyCoIGnGJfQ5cyDjYEPFzZt4PPwSGR/RGAbnUa3H4EDY2H9I6CeO9z13JE8//bS4+TKXmdXbOKvkjIY/dsaBMBiJXHfddeKmTPMy94c3Xd4AOHugxWZ70JzJmAwGf/FGwps6byCcOfL4GZBKCwEveloUqNR5bjij5qM5KBDofuGDyzdW6gyKYs0HmtUpCA866CDxo+UMjuZM5qrH14xoDN0BHIA58z777LPh8/nEjJ4uga6qWc+qiXSncT8uu+wycZy8zljjgzcX3rDjYRAvvytWVr3wwgubtfhs75rmjYeBe7GqqrSocZCKdw9xZk/rwzHHHCMGLu7Ps88+K77DeAvc9r5Xxisw0I2/Dwa6UfjEape0BH4vjKvh7JYBeTG43lhOf0sEBN2XvBZ5jAxE5X0gFhC3K8GJCc3Z/N1R8PD65u+J1wOtb03VRmkPnLnyfsRt8nzQPcEYF7p4Y26hc845R4hMBhTS6sV4Bv5GKL5jVpLWXsNthUHavBfzmqQ1ijNxush47VGoxGIHeB+IWU14f+D1+sILL4gJVVMTqa44j03B4mMURfwM7838HfFcM3iS1yv/jh0P42BoaaULj3VqKFD4u+yscUPQ5Xkf3QDmMfPUbC/vuHH6JtOGmK973nnnKWVlZQ2WjaXxNPUYOHBggzTO5h6FhYWtqgPRmFgaJ1PfmmLDhg0iLZF1I5jHzzxn5ip/8MEHDZZbunSpSEVjXjOXueuuu5SXXnpph2mchClHzAFn6ha3wW0xb5nbjsFUKeZ/M70pPqWpqdS7GHvuuWeTqW3xME+a62XaFfPEmbbKFK/i4mJlR8yZM0dsg59lutoRRxyhrFy5ssEysf2LT8mK/17jz01b0v14jniumJLIc89rM77WQWMOO+ywbVLPdkT89cY0VW6L+fhM01uxYsU2yzMV7d577xXXH+socFnuE693vhZPc99rUVGRSFXktpiWxtoB/E6aS/tsLp+/cXox18vXmD/fmKaupdWrV4vaJ/yO+V4spbOzv9fG+9SS7YRCIVGPJPY74jHeeOON26SPN3dfaCpdt6n7Qyz9nNce08RZi4EputzX+DoHvEfwfaY78/tlXYTzzz9/mxotLbmGY2mc8XVc4veP52N7MIWZqbDDhg0T6dzcH9ZlYApl4/vyZ599JlKcuS9MJWUNnFi6efz57qrzSJq67rnf3A6/59h9k6n3vKfFp4/y+mXKL3+LHFeuvfba+potnYVq605LJJIeBGdgbCrUkup9EklTMECWcS7dJZ5rV+WMHnweZQyERNLDoAmW5tHGbjSJRCLpSGQMhETSQ6A/mbnfL774ooh7oG9XIpFIOgtpgZBIeghMs6TVgUKCAWoMqpJIJJLOQsZASCQSiUQiaTXSAiGRSCQSiaTVSAEhkUgkEomk1fS4IEqWDGX1ORbP6C7laSUSiUQi2RVgVAObj7Gg2o4KfPU4AUHx0LhDmkQikUgkkpZTWFgoKov2KgERK9vJg7fb7Tt7dyQSiUQi6TawhD0n4S0pgd3jBETMbUHxIAWERCKRSCStpyUhADKIUiKRSCQSSauRAkIikUgkEkmrkQJCIpFIJBJJq+lxMRASiUTSUUQiEYRCoZ29GxJJh6LX63eYotkSpICQSCSSJnLhS0tLUVtbu7N3RSLpcCge+vfvL4REe5ACQiKRSBoREw/p6ekwm82yKJ2kxxVbLCkpQW5ubruubSkgJBKJpJHbIiYeUlJSdvbuSCQdTlpamhAR4XAYOp2uzeuRQZQSiUQSRyzmgZYHiaQnot/quqBYbg9SQEgkEkkTSLeFpKei6qBrWwoIiUQikUgkrUYKCIlEIull9OvXD48//jh6Cj///LOYVcusma5FCghJr6faE8SaEif8ofb5AyWSXQE2EjzrrLNEO2b6uvPy8nD55ZejqqoKPYH99tsPV1xxRYPXpk6dKrIKEhISdtp+9UZkFoak10LBsLnKi8JaL4KhKOxmHbISTDt7tyQ9CAap/fbbb2Jwy8rKwt577w2NRtNp29u4cSOmTJmCIUOG4J133hG5/itWrMC1116Lr7/+Gn/++SeSk5OxM84DLQQdUbyoKSiUMjMzO2XdkuaRFghJryMaVVDi8GHx5lpsrHTDqtdCr1Wj3BkQBYQkko7go48+Eq6C/fffHyeffLL4l8/5emdx8cUXi8H0u+++w7777ivy/A899FDMmTMHW7Zswc0331y/rMvlwn//+19YLBb06dMHTz/9dP17/B3cfvvt4vMGg0FYMy677LL69wOBAK655hrxOX5+jz32EG6EGK+++ioSExPx2WefYcSIEWIdL774IoxG4zZuBlpHpk2bJv6mlYT7xPUyC2bUqFFCCMU444wz8Msvv2DWrFlCkPCRn5/fpAvjww8/xMiRI8W2ed4feeSRBtvla/fee6+w1rB1NY/1+eefr38/GAzikksuEcKP+01Lzn333dcB31IPQulhOBwOjgDiX4mkKcqcPuX7FaXKL6vLlSWba5SlhbXK3xurlJ9WlSkuf2hn755kJ+Pz+ZSVK1eKf9vKhx9+qKhUKnEvin/wNT74fkdTVVUl1n3vvfc2+f65556rJCUlKdFoVMnLy1NsNpty3333KWvWrFGeeOIJRaPRKN99951Ydvbs2Yrdble++uorpaCgQPnrr7+U559/vn5d55xzjjJ16lTl119/VdavX6889NBDisFgUNauXSvef+WVVxSdTieW+f3335XVq1crbrdbycjIUF588cX69YTD4QavFRUViXUtWrRI2bBhQ/1+cfuktrZWmTJlijiWkpIS8eA6fvrpJ3F+a2pqxHLz589X1Gq1cuedd4rj4/6YTCbxbwyeg+TkZOXpp59W1q1bJ84FP8N9JdyPnJwccYz5+fnKb7/9prz99ttKT7/GHa0YQ6WAkPQ61pQ4hYCgcIh/fL2sWNlc5dnZuyfp5gKCA1rfvn23EQ/xIoIDE5frSP7880+x/o8//rjJ9x999FHxfllZmRg8DznkkAbvn3TSScqhhx4q/n7kkUeUIUOGKMFgcJv1UFBwUN+yZUuD1w844ADlxhtvFH9zoOa2Fi9e3GCZyy+/XJk2bVr982+//VYIj9jA3xSHH364cvXVV9c/33fffcV64mksIE4++WRl+vTpDZa59tprlREjRtQ/5zk49dRT659TWKWnpyvPPPOMeH7ppZeKfeXrPQ1fBwkI6cKQ9CpCkSgq3QGYdNv6oY1aDcqcfuHikEjaCmMeioqKmn2fEzcGOnK5zqClbjjGSjR+vmrVKvH3CSecAJ/PhwEDBuDcc8/Fxx9/LKoWkmXLlomYBsZZWK3W+gddCxs2bKhfH10po0ePbrCNU045RbgbWAWRvPXWWzj88MOFu4NwvXfddZdwXTBWg+v99ttvsXnz5ladAx7Hnnvu2eA1Pl+3bl2D4knx+0cXCOMoysvL690lixcvxtChQ4X7hm4hSUOkgJD0Klz+MLzBCCyGbeOH7SYdan0hsYxE0lYYMNmRy7WUQYMGiUEwJgIaw9eTkpJEGeMdkZOTgzVr1uB///sfTCYTLrroIuyzzz6iSqfb7RaBoAsWLBADbOzB9TM2IQY/17hg0aRJkzBw4EC8++67QqBQmFBUxHjooYfEOq6//nr89NNPYr0HH3ywiEfoDBqXceb+slcEGT9+PDZt2iQEDff1xBNPxPHHH98p+9FdkVkYkl6F0xdERIlCo962EptOo0Y4EkW1J4AEc9vrw0t6Nwy668jlWgr7dkyfPl0M+ldeeaUYwOObg3G2f/rpp9cP6szIiIfPhw8fXv+cnz/iiCPEg8GZw4YNE9aHcePGiVk8Z+rMKmktFAzcl759+4qsDFogYvz+++846qijcOqpp4rnHMzXrl0rAjHjLRs7KsHM4+C64uFzWk1akwVjt9tx0kkniQfFwyGHHILq6uqdksmyKyIFhKTXQNdEhTsIk7bhZR+JRrB40SJUVlbClJACu2E0cpLN0GqkgU7SejiocnBk1kNT7gQO4Hy/LYPvjnjqqadETQTO2u++++4GaZzMbLjnnnsaDKgPPvggjj76aHz//feYPXs2vvzyy/osCg7SzK5gNsSbb74pBAUzEShUKAIoRpjZQEFRUVGBH374QbgE4gVBU/CzzPDgvnBQZpZEjMGDB+ODDz7AH3/8Iawljz76KMrKyhoICGZP/PXXXyL7gi6Opgbzq6++Wlg7aD3g4D9v3jxxbiiuWgq3TZHH46PQ4fmhiyPmbpHILAxJL8LhCyo/rCpV/tlUVR84+fjrHyk5o6co5qwBij5joKLPHKz03eNQ5bV3Oz5KXtL7sjAaZ2J0ZhZGDGYMzJgxQ2Q3MBOCAZsMCKysrGwQQHjHHXcoJ5xwgmI2m5XMzExl1qxZ9e8zEHOPPfYQmRgWi0WZPHmyMmfOnPr3GVx52223Kf369RPbyMrKUo455hhl6dKl9UGUCQkJze7j7rvvLs7Hjz/+uE0myVFHHaVYrVYR0HjLLbcop59+ungtBrMquD/MquA6Nm3atE0QJfnggw9E0CT3Lzc3V2RVxMNz8NhjjzV4bcyYMcrMmTPF38w6GTt2rDh+ngcGiS5cuFDpCfg6KIhSxf+hB+F0OkU1MofDIcxPEkmMLbU+LC9yIDuxzrT7448/4I0HrsJBOUEEI8BzK0wIRlXQ2NMQrinGu889hmOPPXZn77aki/H7/cL3zdk78//bCus9sMZBfEAlYwtYQlpeV5Jd9RpvzRgqXRiSXkOlKyDiHIjir8GG92/FcQP8GJQQQVgBBhXpsLJGh6jfDY0lCVdcdY3wx3Zm5UBJz4UigddPV1ailEi6EikgJL0CXzCCWl8QFoMGxsqlcP/5BibbyzEyOQKjVoFBDRzQNygEhBL0Q21LRnFJrbj5s/a+RNIWKBbk9SPpqcgoMUmvwOUPwc9+F/4SpKx4HRlVf2NsagTuMFAdMUOl1eKgnBB06q3uakWBymgTgWE7iviWSCSS3ogUEJJe03FTo1LBWjIX5vKFMKuD2Ow34G/DVMyxHQm10YZ+icDQxJBYPhr0CTfG3ffe3+n9CyQSiaQ7IgWEpFdUn6zyBGHWa2Ar/AWqkA9btH3wTvIFWGsZh0S1GxpEYTZocdzAOgGhhPxQ641QGy0iHY/pZlJESCQSyb9IASHpHdUnAxFYFTd0NetR5Q3i65ocDNOUYKBrIbwlG1GspECv02C/7CC0dGPU9YmB2mCtz+W/4oorpDtDIpFItiIFhKTH4/AGEUUU9rK/EfS5oIqGkaX34eAhdkwY2h+LNvuwKpwlIoqz7GpMTPvXCkE3BlTqTu9fIJFIJN0NmYUh6dGwNHWZKwCzTgtr0a+IBv0IQIe+2dlIHL4/bDobHho0EOt//xhuGGHQR/F/gwP4s0wPZWschNpgQdTv6pT+BRKJRNJd6VQLxK+//irqqGdnZ4vyrZ988skOP8NObWxiwvKmbA7DkqoSSVtx+sNw+8OwagF9+RKaFVCsJCM9sy+M1Sth3/w99IFapNhtqFTsMGjUmJIZhlYVBZQooFaLOIjO6l8gkUgk3ZVOFRAejwdjxozB008/3aLlWRmLddT3339/0YWNPudzzjlHtHOVSNpCjSeISFSBrWYpIp5qqJUorJooUgNF0OSvRnRjIYLVCjLyhsIT0UAFBckWDQ7ODf4bTGlJgkqlFlUEO6N/gUTSG2G7bPbh6EmoWjhR7il0qgvj0EMPFY+W8uyzz4rSmmzQEuuoNnfuXDz22GOiOYxE0trsi3JnQLTutq3/FUrQiwg0MKp1CL/7OTzrAvBVasHmhKlT1bANS4ELZhh1XpwwMIAvC4winZMpntCbRAni3lBFkE3HwlEF/E+Ff7uWsoGpbDC26w/Kr732Gu677z7ccMMN9a9zUDvmmGOabO4laT1sBvbJJ5+IiW48dHGyCVhvYZeKgWDHtAMPPLDBaxQOtEQ0RyAQEI/4Ot4SCXH6QnAHQ0iz6GEs+wfhaEjEPxg3FcO9GvBX1bXs5i3VVxBAqr4Y1QMSYdd4MTYtAnOoBk5XFCp1BZRwQFyHV111Fdxut3iwQx9dbawlzwfrxtNdx06L7HxIi8Vuu+0mHhbLv26QXUFY+UMRBMNRBCNR8a8nEEYwrCAYiYCJJmx53nioUatU0KpVMOo0MOnUMOm1MOk1sOi1MOrU9W2iJXHwZDLwlrEzdH/RgtXJIpTX4gMPPIDzzz+/Vw1mLSEUCkGnq/vddwaZmZnoTexS0wn2rM/IyGjwGp9TFPh8viY/Q6XNxh+xB2/aEkmseBQnXEZXPqKOYmgRhjeqh7Haj0BN3U3cHY3iJ78Hj21w4ruyargDESiKCnajBsfmOhH11iLirgYiYZGFUVBQgKqqKiFaeU3W1taK65athZcuXYpvvvkGL774Iu644w7hfps8eTJsNhuGDBmCE044QVgxuFw0Gu2Sc0D3jdMfQpnTj00VbizeXIu/NlXjn/xqLCiowdIiB1aXulDi8KPWG0QgROGgQKtWQ69p+KCAoNigW2hztQ8rSxxiHX9vqsL8ghqsL3eJc04LhkR002LvaWD//YGTT677l887uZ4IJ2EcyHhv3B607tIlxzbdvG9edtllwu1M2PqawjcGZ9sUiLQSx2/nlltuaXb9y5Ytw7Rp08T62QL8vPPOE8K7MfytpKWlCQF+wQUXIBiscx8StvYeNWpU/Tq4zdg+Ev7WaKmmaBo2bFiDdt38TXKf33vvPey7775imWeeeUas6+uvv26wDx9//LH4nXq9XvH8+uuvF79ZtjIfMGAAbr31ViE+COPyuM9LliwR6+cjFqvX2IWxo3MQc+M8/PDDIr6Ky1x88cX12yI8JrY55/5zPGRNml2FXcoC0RZuvPFGMSuMQbEhRYSEA125KyBmx9aNc6EEXEIYwKdgdbGC95w1mBf0YWnIj1hlh5NKtUio9iIn2wCTXsFhQ414da0GKp0RaoMZoeot+N8Tj2OfffaptyhQSLCzHf+trq4WRadij40bNwqxUF5ejnXr1okHb4gkNTVVxPoccsgh4gaSnJzcYYLBHQgLi4LDF0KtJwRvOCyyUQCVCBI1aDVINOmFNaG9VgOaxFkinL1GKB7yK71INOtEx9NkWn50Pd/l0yQUCbzRN3YZbNlS9zqvg07qyEk327333ouTTz5ZiAJaxBqzYcMGce3dfffdePnll1FRUYFLLrlEPF555RUx4PKzfJ2D+y+//CKuWQa5c5DnAEeLcbybJB4O8rQeT5kyBf/884/4DVBQc/3xgfEsFc+BkevlgH/mmWeKQfSee+4R7oD//ve/ePDBB4X7xeVyiTTqmBvmrbfewm233SbEzrhx47Bo0SKce+654rc5Y8aM+m1wH+kW5zLcFtfx9ttvN3Cvc138HVIwEIoJ7ictihQBXC9fu+6663DSSSdh+fLlYrIwZ84csTwnr209Bz/99JMQD/x3/fr1Yv1jx44V25w/f774Ht544w1MnTpV3GN2qVRypYvgpthjfnvsvffeyuWXX97gtZdffln0Ym8prellLum5lDv9yrfLS5RF+VVK9csnKZW39VHKbu2rfHJ6lpKXoNra8KLukafRKceb7Moj2anKimMylFU3D1Vqb8tQVl6RpmTk9lP0GQMV0+DJisaWqrz99tut3pfS0lLl22+/Ve677z7l4IMPVsxmc4Pta7Va8fqLL76oVFZWtnr93kBYKXP6lLWlTmXehkplzqpS5ZtlJcr3K0qVuWsrlAX51crSwtoueXBbP60qU75eVqz8trZcya90K6FwROlO+Hw+ZeXKleLfNhEOK0rfvrzpNf1QqRQlJ6duuQ5mxowZylFHHSX+njx5snLWWWeJv3nvjb/dn3322cp5553X4LO//fabolarxXFHo1ElJSVFmT17tnhv7Nix4vrNzMwUz+fOnavodDrF4/E0uR/PP/+8kpSUpLjd7vrXvvzyS7F+/h5i+5qcnNxgHc8884xitVqVSCSiLFiwQOxzfn5+k9sYOHDgNr/Hu+66S5kyZYr4e9OmTeLzjz/+eINleC64jdh2OVYYjUbl66+/bva8PvTQQ8qECRPqn8+cOVMZM2bMdse5lp6DvLw8JRx3LZxwwgnKSSedJP7+8MMPxfjndDqVrrrGWzOG7lIuDCo1KtJ4vv/+e/G6RNIaqj0BeFwOfPXKgyhc8gt0CMOtGLC8qAblTuBAgwW32dLwdWouPk/NxW32NEyP2GGv0aDKrxVDe6JJjQP7bs3GCAehsadh1dr1rd4Xmh0POuggMRPirKWmpkbMImbOnInRo0cjHA6LTCPOTjgT4ayLM77mAt74OpuDban1YUlhLf7Or8LCghrkV3kQjihIMumFBSDDboTdpKtvYd4VcFspVgOyE0wiAHNViRMrS5zCKtJr4AyxqKj59/m9FhbWLdeJMA6CAZWrVq3a5j2a3zkLtlqt9Q/OlulaYzYcLVO0tNEyQDfdypUrcdFFFwlL2+rVq8X1OWnSpPoZe2O4TWbgxcf+7LnnnmL9a9asqX+Ny8Svg/d6mvjpLuR7BxxwgHBh0P33wgsviN9ObHZPK8rZZ5/d4BhoUeHr8UycOLHB88MOO0zEQXz22Wfi+YcffijcJ/Hxd3R7cH/pCuJ66arZvHlzq87/qhaeg5EjRzYIzuY9gNYKMn36dOTl5Qk3ymmnnSYsJTE3y65Ap95ZeCEwSjUWqcoLk3/Hvgi6H04//fT65Wkao9mXZiJepPT9vP/++7jyyis7czclPYwFixbj+isvw8nTxmPR+48g0cBsAgWuiB5DPBn4Ob0/Hk3MxPFmO/po/g2oikKFwjIdNjvCCEILvVaFw/MoIBREvU5oTAl44JnXMPvD9vmw9Xo99tprLxHJzRs5bya88VFM0DT87rvvihbQI0aMwKxZs4TplnEFdEkUVntF3MH8/Gos3+JAlTsIo1YjBuxMuwkJXSwYmoMDEMVLus2Iklq/EDqMw+gVWQAtLTbWyUXJKAAoCnifberezCDL2P2ZD16LdLMNHDhQLMNrkAKCYpfmfw6yMVFBAUE3R2fCQZUTSMYr8Lfw5JNPYujQoWIcicURUFTEHwNdC3/++WeD9TQOYObvj3EEdGMQ/ku3gVZb59Gna+aUU04RQuOLL74QrpGbb765QWxGR6JrFNTJ304sRopuk4ULF+Kdd94RwoIuG4oSirpdgU6909B/wwuPD8JYBf7Nk0Do44pXdUzh/PLLL8VFw5NEvxWDZGQKp6QlMCiMM/2J48fh03dfQ9DvxYnjU2AxahBRNDBnDcHIC+6CSaXmr7T+cxzSPFqD+PuuGg02lrnhVkzQq6IYmqJCppk/ZkXUkaAV4urb7hNWg46CwVq8QfEGvmDBgno/LkU0Mz9ycvNw/lU34IfF67Gi2FFXGMugE6IhzWaAWa/dZTMgKGayEozCMrKsyIENFe6eLyJaWmysC4qS3X///fj888/FoBgPi/XRqsBifY0fHGAJBQKXmT17thAThP/S7//777/Xv9YUDGzk9Rwf8MjPMHOJIiAGl4kPkOfgzxl/LI6N1zVn7Qxa5EDOfWPAI616jE/ghLPx/nMc2REUCLQGrlixAj/++KN4HuOPP/4Qs37+Jmm9YAAjg6fj4X5EdtAXp6XnYEdQ2NA6wlgQxlQxVoT73OMFBC8w3iwaP2IBJPyXarbxZ3ih0FRGUxSjVCWS7cFriJHOjCin+OTMZe/ph2P2689h2uSR0CFSV6a67xhEDjwSePBBID1dfNarM6DYnobKtCxcozfjB0WFn4tUKA/ohNUi3aLBpK29MRCNCEtEZUCFz+b82inHMmbsODz4+FOYt2wtrrvzQeT0HwRHbQ1enPUgTj1wEt596j7A5+hWwYkcBBhQaTNqsanSg1KnHz0apmoycLE5UcfXOUB2QVEymv85OD7xxBMNXmeWAQdKBvRx5k7Lw6effiqex6BFjGmgnKHHCwhmGfD+zIG9ObhNBiwymJFWAQYIXnrppcIMH59px1k93RAUKl999ZVw63EfOMj+9ddfIhiUE1FONNkNl0GdHJgJRQUzTXhsa9euFcGODAB99NFHd3heaEmhe4L7ScGxxx571L9HwcDt0RLIMYjrp2iJp1+/fvUW9crKygalBFp7DrYHLSDcPrdDEfP6668L60RrBEhnsvNtnRJJG+FsnZkMfPDHSVPgWWefi7e+/RMPPvMaJvbRAc4SqBFFUGtDMHfrjGn/aQh+/ClKHn8GvltmYtCjd6Nm5nWYa6jzxS6t1KHIGUVI0cCoAw7LCwoxQVgPgvEQywoqRTpjR2WMVLkD2FDuFumV8/NrUOxR4/CTzsCHc+bh4WdexbCRo+DzevDac0/isL3G4dnHH4DX++/MprOIRCNYsGA+vv32G/Evn7cVWkqYAbK+3C1SS3ss9GfPmlX3d2MREXv++OOdXg8ixp133rlN2jDFAd0QHHgpvGOWYc7q/91VlXiP/9LlFvscXRmcmW+vtgnjGhjXw6wBxkrQZcB4BmZMxMPXOGBzQKcb4cgjjxSuPcLtsB0CXQm00jEOgVbpWPYEY4ZooaZooFCixYST0pZYIHhMjDWihSDe+kC4D3SbU8gwG4JCi2mc8Rx33HEii4X3Hmap0MXQ1nOwPRITE4Vw4gSJwolptNwW4yZ2BVSMpEQPgmmcTKlxOBziApT0PJgiSfMi1TgvX5oTOYthkKLalooVxU5kmxVk/3kn1Gu+EN03y5InInTMS1A0BniDdSmOmQlG5CVbkGDW4bV3P8AFNz+IqM8hLA3XTQzh3HEaJKk9WFIOnDXHjALXvzf8+2c9g0kTxqFvolEEDdqoNFoIUy09wbpUyxpvENWeEHzBMFg+wazTiMqZjeMYeJxzf/oezzz2AJYvXiBeS0vPxEXX3ISjTzylbRUyoxFogg5oArVQhzxQRSNQRUNQKRER6PfXkpV45tW3UVBSBWdQDW9YhfSMDFxzzTWYtv80tJVSpw+pVgNGZidAr9315jBMy+XskgMRZ5DtSuW8/PKGAZW0PFA8dFIKp0TS3mu8NWOoFBCSbnXR0w/I6PJYJDJnDzRz5ubmioF54eYauHxBeBd9gmGbXkF6sABuxQj/+PPgmXhx/QCWk2TGkAwb1GqV8GX269cf5YoVap0RUZ8T41JDeP4/Bgww1KLcr8V1P6vxeYFRzCAz0jPw6WefwhNU4PaHhDsh1WZAut0g/taoVNCoVaLwEveJFoZApK7yo8sfjqvNoIhlLVsrOvIzO4I/1++++ASz7r8DRZvzxWuDh43Arfc9hrET92juQ1AHHDA4N0HvzIfetRkafw00IXedaIgEhXBgqCljPWhtKa+oxN+LliEQBaKKSjzKvCosrdJhVa0W59/0IPabdlCbvkeeE7oxBqZZMCjdusvFb3SYgNhJlSglkq4SEN2+kJSkd0AXBaPG6aslLKpCX2e875KVFL/+4Re88OSjOCJpA4ZPUkFtisIR0uLvykSM56RbUURGQ7JVL8QDYZR5UVEhNPZ0aDIGAj4nlldrscmpQV6qGna9gv36hPDVZgMiUOHqa66GVqNFggki64FFlFjJkWmVFAEaVV3ZZ/7NwTIUURAR8T8QxZtMOo1ItWxLtgQH24OPOAb7H3QY3nvjJTw/6yGsW70Spx9zMI47+XRcfdXVSNEHofVVQu/YAEPtOhhcRVAHXUA0DFU0CPVWwUDLTF3HUQ0UFQc1lRBIlBCRknyMTw8LSRGJqsD6lP6ICvv2CSEYUSH421VItZ0O18AjEUga2ry/vwl4XpLNeuRXeYXlhpagHgvFwnaCDSWS7owUEJJdGvoPr732WlEtjzCVicKB/tLGM9d3PvkK9z/wAJKC5Rg1KIwkgxoRqLGkSovzXn0UDxqysPvUfYSLwB7ncmA2EKHlgd03VVoDQuEA/twcxO6pRljUPgxOUjCmjxn/d/md25jvaT3gg9YBCga6IoRQURQYtCohFFpiXWgNeoMBp511Po47dD98+uxd2PDP98jZ9C6W3f0p9po0GlmpdqjCXqgjAagiASEaoFIjorMgYkhEVGeGojZAUWsR1eihaGldUYt9Lykrxz9lpbBqI6KBlgZR6NQKkvRhkRJLJRSKeqBa/wOyy+YjaM+DK+cAeDInImJKbdH+83yxHwezMli5sjsFhUokkjqkgJDssjDymbVBYkVV+DfT0poqG+vyBfDArP8h6nNjVHoYA5K10KvDcClGfLaawY4aPPLwI3jhrT2Qk2xpMGBRlBCKh4jXAa0tBRF3AN9sCOOM0VrYdQpyEnV4+PyDYd+3+ch5ChotzQ+dhaLUWRZcm8VD594CVTiAKw8bDudooHj139CGfXBuXIDi6gRk9clB1JqBsDkdYWMKFK0JQY0JlUEdqnwKavwRONwhuH0+RIJeRENBESCqgxWqAQfCze0hDD3CMKmCCCselIf9iIRCMES8sHsDsGhrYVAi0DsLkLDpSzjzpsPVd19EDdt+R42hcCh2+FDlCaJPoqnzzptEIukUpICQ7HKwcBLrH8SsDow+fv755+sjwZvi259/R5XDA4R8GJ0SwpDkOvdAdUCPrzZGxeBbVlaKZctXYuxhDdfDSHP2C2BwJms9aO1pwiS/skaLjS4dspLVSDMpSEmIwl8wB85+h7TKZN8eGJ+gcxXC4NgIgzO/zhVBoiHovBXQ+KugjoZgtADpo0djS2kZFq0uwF9F1VCv82PE1AFQK0morAjC4XbA4w9s02WTUE4JSbX1sJRoXTfOoEqLkEoHD0yoVNlh1gWQrHfBCi3Kw2FsqtYhTeOCzaCF1R9AYvADGKtWwpM9FZ7M3essG80dm0olimCV1PqQZTfWu5QkEkn3QAoIyS4FC96ceuqpokAMBxjmqzOti22zm4Nug3VFFcKC0M8WRR9rFMn6qHBf/Fhqgi9cV6iGrgmPo7qB+4Iwg4EVH5lmpfjdiAY8UOvN4t+fNgMTk3RidNW6imA02BCyZMKXXlccrTOgSBCCwbFRiAcRqxALhgz7hKjQ+ivrXBNhvwh6DBsSETFlQmvsh3TbGPhLKxAx2LDFFYTBtQZaVQRpiCCD0QxaAzR6CzQGC3RmG4xmG3SWRGjNydDYUqG2JOO0869EYVkVdCoFOjVg1KuRlmBBRpIZ6QkG5CWbsVtuMiy+YhFoGfSG4PO6EHEEkOLywBp0wVi1XIitYMKAZo+V1SrZhItZMUmWugJGEomkeyAFhGSXgJkQ7MDHnHX+zawKdqBjfviOYPCkwZ6CqN+NUXlhDEvVQqsKiuyLdxb/W+VOZTAjJyNF+N8bc+yxx4pOmZdffjlKXVXQpeYBAQ/+qbTCq4ogEW54HGXQJuTCVvQLwqY0hGzbdjlsu2uiHAbHJhH4qPOUNTw3Oiug1kLnLobWWwatv1oEQypqPXzQo9ofhau6GjX+KKLRCMwIYrg1hIjihjuig4N9QUIRDBwyAtnZfWE2NJVy6gRCTqA6H6gGnj11GD748gfkOzXId6mR7wQ208JTWJf98uADD2DIpKFA6XL4N/4GVdU6BDw1sEVqUVEdQMi5FLaUSiSF/HD3mw5/6qgmD53xIQwwrXAFpICQSLoZUkBIdjqs5MZ0zO+++048pwWCxVaainVoinKXX9TKz81KwYjkAgxPZl8LNYr8Jiwsi9RnF6RlZGL63s2kOm4VEUcddRS++fFX/L2hAn3Tk0WtB8f7p8HqWoKwswzG2gKEUoYIf3/1sFMQ1VvbdMyqsB96dxH0jk1COKhD7rg3VQhZshAyZ0Djr4a5bCH0ni1QB5l2GYQvpMATCKLWr8AfVsAu5TxGk6KFV21F2JIOgz0JScmZUBxuzH71DRSVVSL8/QqceNYl2O+wI0XApIoZGKz5wLMV9kMTdEITcIh/+/dX4/jD68r6jtlaireQQiKaif+ceyP2n3YARCkoW19oBh4IQ816pK1+D/6CBbB4q6CJlKGiLIAqpxt5YdabcMOTNblJ1w8tQmUuP3JTzDKYUiLpRkgBIdmpsFwtO+2x+57JZBKV1uIbrO0IFmMqF7NXA+694GgUfvkokvSKEBCf5pugwCMGLZVWj/POOQtJ1u2nDNKdcdiB+yF7aC2q3X5RQjZVkwedqgCpUSdcpWthM5gRUmmQvPpt+FKGw588vMnsA1ZtXLxoESorKpCZbMX4IdkweoqhdxVC5y0TlgdmbpSWlojaFdGkAcgcvT+gM8Ja9CuSCn8WQZMs8hT0ueELheAIa+CNauGHHlFFAyfMgCkFSB4Ie5/h6JfdD1FLOiKGJES0RlCCzZh8EW658kL8+sO3+OGmh3H4P5tx632PwmxpXvzQTZI0qBhH7n48ylb+ATiKYDGbkJmZBUW/Ab4tRvjSxiCqtwvrSCBlGAJTboE19xekrXwbvsrNyPFWoNrnw/LlKgwMRWELueDKPVCIl3gseg1KHCyoFRRdRCUSSfdACgjJToEDJ7utsmQsO1CynC3b6rIkbWsod/pFHYZkkw575mjhmdQPqtAm+BUd3lzIgEO1KPx0/uVXC2HAwWpHMPZiwe8/4Y4nXkb5ptXItkRwy1QVDuyvhzFYA2/xaphyLQizCFTpP+IRNqchaMurX8fiJYvx6UfvQ+evQZopCp9WQbnFIupX9O9XV2p3VWEFXv5sLubnu7DZDeyZ+RNOHPEqpu+WjiSjgojPgVAoAE9EixrFBB+s8CkG1KoS4UscAkPueOQO2g365L6Aus4t0VRx7cSkZDzx8jt49bkn8eQDd+LLj9/H6hVL8cRL7yBn675s8/1o9Aja+wH2frDn7CusH6aq5VAql4kYDR6zuXwRvBkT4cmcVLd9tQbunGnwpE9C6spXYFj/FTSOcqgjBVi6Uo3+/hDSFAXOfgdvc75Z4rrE4UOmDKbsEtjLgYHKfLRnmfbC0tNc/67SXVLSOqSAkHQ5bKDDOvNsxRurK8+Mi9ZWDqVwYPEmmsANtRuE+T1FqRTWh3JtNi664UqkpqVh7LhxKHUFROfKllQ9ZO358888Dfo+wwGNDsUe4PlFIRjNVkzLCEPrLYW/fB1C4/eCOhoRFR613grxIJvyN2H5999jIMf0reEGLCJVWOXDI+/+jKPPngCnLg1X3PMWBtrCOLJ/APtmh5BnV5Bg0sDs3gSP14AaWOFECpyKBSWabPgzxiNx0BT0HzQMOl3r4gXYnOisCy/HmPGTcN1FZ2HD2tU4+YhpePjZV7HHnjtuy0xXDV0QzKxgcKe5fCF0riJYSv4UWRfuvvsgkDi4rhCVwYaKcZchwdYXSUueh6a2AqrwBizaoIYnGEFWwgAEkgZvG0zplcGUHQGteWxKxW6TdA8yTfnoo48WvS5SUlJavJ5//vlnu/0uWktTgoT1XNjrQtI9kQJC0qVUVVWJbAd20ORgztLUV199dZvKGTP2wR0Ii7bWps2LoXKVQBv2ivRD59DjcfCedU13WEJar1GLQWpHMICTgZTRgBdRP7MxTIj6QlhcqcM7C1xI2isRE+y1UKo3wrr0NSgZo+DInQ5FZ4I2UCuCGJ986mPU1OgQiQKVfjUqfGpUBVQIR1WgAaTq1dcxMdmDdw50YGSqggSjGiatGlGVBm6YsBk2lCnJKNAORKDPHsgasRdG9s3qkGJUE/aYine+/AlXnHMKli9ZiAtOORbX3/EATjr97JZ9Byo1AomDEEgYKKpc0tXCmImEjV+IglLMuojq6gYdx6BjEdVakb7gEWhd1TAGVmJeoQoJK76Edo/zoOjqmpfVB1NGFFS6ZTBle2D20pQpU0TzKTZdYqlitqxmMbavv/5atMtOTk5u0brYJKqzoduSD0n3ZNfrZCPpsaxatUqUnqZ4sNls+Pzzz0VjpraIB1YxLKrxwWrQQeuvEnEFquKFIiDQrbLCPu74BnESLJls1e9YL9eVta5rfhT11ECl+zd9dE6RDh8trsH6QCLUSgQ1ZYWoXTcPiX89iNTlL4ksiY3r12NdsQMrqzRYVKmFPwKMSA7hpEF+3LW7C18e4cLLU4tw/ehqHNBfjUy7FtCZUKJKwe/KCLzqmowrV4zE8R9FoB3zf9j3kBMxJDe7QytZpmdm4eXZX+LwY04UguneW67B3TddJVxJLUalQiBpCKpGzhCWCVa0ZDEpxoUwUySGq99BKJl8K0z2JCToIthHvRSLVm+CbtOcpoMpnX7x3UraxsUXXyyayzEgmd0pmc3E7pVz5sypb0IXX2+FHSlpZejTpw+efvrpbSwGj7Px11boZmAHTAoLWgvZIZLdLOPhb5qdJ9lfITU1Fcccc0x9G3C2o6bLkr/32G+eLgx2nCTsDMrXV69e3WCdjz32GAYOHFj/nK2xeUxWq1W0xWZ7bFpaJF2PtEBIuoQff/xR3EzYqIWzIt5o2tOSlml/tD6wAJG5cLFoFqX1VYg+DmWJ46Az/zvL8oYiyEs1t8i3HitrTSJ+N7SRsPDts3Ml1/3eWj0GJtbCOCZT9JOweqvh8EURrHHAVJqPHJ8Xj7DStRKGRqUgwaDAqgNMmij0osEWRD+NkKJFtWLBykgOfq1Jx5yNIazbkI+Iq6CBtaazMJpMuHfWcxg8fCRm3Xc7Zr/5Ckq2FOHhZ17ZbnDlNqh1omiUP3kYEjd8JrJGkta8D2feQQgkDxWLePvshS1T70P2r1cj4qzF2MgSrFxswYiUIQimDKtflcWgQYkzhFovO6VqdrmYnVgDt66GbaFbIrJZ9p3to5kO3XhWn5mZKTKd3nvvPRF7RB566CHcdNNNuOOOO8TnaHmj5WL69OlNrp/BzlwvLRnMkHruuedEe2oO/LRqfPnll+I3HuuUS1flV199Ve8WHDNmDM477zyce+65Ta6f22ab8Lfeegt33XVX/et8fvLJJ9eLGAoXChkKC5/PJ2rFnHjiieIeI+lapICQdDrvvvuuyKzgDJfVJHkzaY95NBCOYEuNT7S+Zq8HY9UqoHw1NEoAAUUPZdyM+mXpvtBpVUg0t8wsHitrTRS6MWJFpfx1FSCDURUeX6jF4dOHIwXVcDpq4PT7kRx2Ai4H7AghNSkCLWWCitkgKkQUjSgI7YIWZZEELPBm4btiM/7Y5EFNcQGU0KYm94UzuM6EgxLjIvoPHIzrLz5btAs/64T/4OnX3kdKWnqr1hUxJqN66P8hIf9rkZrKNFePrwKe7D2FtcKXOQG1fH/ZK8j2VmFj9SZULPoMSfvm1Ls8uD/sTlrtDexyDbYoHjjj3Rm43e4WxSKw0RyFDiu3NgVfr6mpQUVFXazOnnvuiRtuuKF+8P7999/FoNyUgJg7dy7+/vtvUVY+VtTt4YcfxieffCLqp1AYULj83//9nxAkMSgaCAUGM5xoeaSYaQ6KHKZwxwQExcmCBQvw5ptviud8b9y4caIDbwzGT+Xk5IhleRySrkO6MCSdCm9INJNSPHCWQFNqe32rle4gan1BEdNgqloBTaAWqtpNwkJQo8+Evv/U+mVd/hASjDpRarklxMpa1834lDo3hj5uMGPGQFI2ov95BK5p98M89Vz0GTwWKnsf+IwZqNb3wbpQKlaHMrAmmI7f3Ll4pXQgrlsxGIfOycU+bwRx9w+1+GvlFlRvXgclFNh2J9gyPCNTBH92Bezs+eL7nyMpOQUrly3GqUdPR/7G9a1eD8tW1w48SmRmEEvp37AV/lgXQUqLyujzEEkdCr3egD3Uq7BiYyEiq79usA6LXotqd1CIREnboIhoCYyVaPycbsamoKuCQoZBmBRSsQdbQm/YsEEsw5RnWiTaAwVIfn6+iNWIWR/Gjx+PYcOG1e8HO/PG70Psvdh+SLoOaYGQdArRaFSYFjlLIZdddpkQE8wGaA+hSBSF1V6YdVqoocBUsRhax2Yg7EYYWjhzDoCBLoet+CMRDLRbW5waGF/WmiKC1S2VSGRr7YK6GzPbeWs0OlGJUlSjHHQ0NO5i6D3F0GjNWDN/MWbe8xBcIRU8oTiz91YzNOM+yHXXXVf3WvwNf+syYhtxx9HZjB43Ea9/8h0uOu14FBZswulHH4SnX5uNUeMmtG5FKrXIyAibUmAv+A6miiWI6K3wZu4h3tsy9W70+3YGwuFaTIkswZLFZkwYuA8i5jqLB6uElrtCcPnDMFh3HTcG3QgcQHfWtlvCoEGDxDVLERCLPYiHryclJbVJwPPYaZ1j/FJjYjEMHREMSesEXRRvv/02Jk+eLP698MILG+zHEUccgQceeGC71kNJ1yAtEJIOJxwO46yzzqoXD/yxMxirveKBsGgUfeS0Phhq1kLrKUWoeiM0SgR+lRGG3c+sX5bBeAaNWnR9bA2xstYMLBPZGEGfyMZgPQlmjTRu500i1mz4MiYikDICEw4+GVfd8QgsyQ1NtfGf54N/p6c3dBVsbxudOWOlMMvo2w/Pvf8Vho8eh9qaapzz3yPFgEErjtsfhjcYFsu1ZIbrTxkJV9/9xN/WLb+LVE8StueiauSZsJoNyFZVwe7JR9mav+o/x2BRZWt58l0JDsx0I+yMR0uDjGkdoPuBMQ6MDYintLRUzOaZNhlbX2yWH4PPm3N/0ArAdWi1WiFU4h8xV9vo0aPxww8/NLt/DO5k0O6OiMVqsC8Os0polYjfD2aVMMCz8X50ZMqppGWolJbau7oJDNJjgI/D4Wh1XQFJ+2HgFEtRz549W8zm6Z9sTWXJ7UFBsKCgBtGogkSTFikrX4e59G/48/+GLupFsX0ccNJb9cszJZDiYWxOYpsyPXizY1bGkk1lCJuTccCUCa2yCtRXoqysFDdZuiQaf74ly3QUUUVBIBRFMBIVLoJwtO6nzzOj0dTFH3AA93s9uOmiGZj/x6/QG4y496lXMGW/A0XPCgqIUISfU6CGGma9BhaDttksEaZ5msvmC+tD7aCj64pTRaPI/eF8RAv/QSgSwc/2ozD8hJn1xbBYC4Jt0Sf1S+7Q7JOW4vf7hWmewb7MJuhOMA6CxcooBO6+++4GaZyBQKA+jZMDMOMhGPDIGhHff/+9CKJkIOTBBx+8Td0GDhPsS8PMDQpcxhoUFxfXB04y+JFiky6MW265RQz6nEgwiJKWSHLQQQcJKwUFDuMoeL03VUiK22B2BbfBZej2jMFtjh07VmSY0ILHY1m/fr2Is3rxxRfFPUfSvmu8NWOodGFIOvSipOmfNxXONjiL4M2poyiq9orZMOs+GKtXQ+vegoirHIaIBz6VHsqIY2PdqAUcKNPtxjaJB8KbEdPPRk8KCuHSWoMdhcCECRPbvUxboUjwh6LwhSJCPKihgl6rgkGnQbLFKAZ+vVYtamTwX61aDRqJtOpU/PbDtyJmhdkyN1x4Gt588y0cfdxxIig1EI6Kf2mVoEircPupCcT6rI3EhLvP3qLPB78v1oqoGXICwuYMbJlyN3IqToDKU4602iUIFq+Cvu9o8RmKEpa15nfd0uBXSR2s6Dp//nxRSIrfHzMz6Bbg75CvxdeAYP0VLsugRw4Ujz76aL14aAx/QxQDFBxnnnmmCMTkeikqONgT/lY4cWAA5P333y/WGd8Mj43yzj//fJGSSTHT3NyVgZZ0U7z//vtiAhJPdna2CPakKKEg4Xry8vJwyCGHdIiFU9I6pAVC0iF4PB7RiIomTCpaRmc3dzNqCw5vCIs21wgfuVmnRsrK12Au+ROO0o2w+rbArU2F8/QfROXIWJVKbygsZrEc2NoDZ93/bKoWoQotKUa1s+CgTjdDnWAADFoVTHotksw6UQfDpNOIZlVGnbpFooqBrzNmzBAFiXhzfumll3DGGWc0XCYShdNXl3rJ1FoGt1r0WiSYdP9uIxpG4vqPRa2OiCERVSNOE9aGrLk3Qb36c/gVDeblnI8hh/zr62aF0ZHZduQkt8z/35F0ZwtER8KYAooBpkxKehb+DrJASMkmaTc0OXIGQPHAqGiW0O1I8UCXRUG1B6FoFGa9Vsxmdc7NUAecoohUADq4MibViwexT4EQksz6douHWJVElsHmOnclIlFFWAFYfKm41guHPwidVo0BaRaMz03EpP4p2L1fMoZm2kWTKlZ4pABrqUVGp9OJlurM22dQLONaXnvttYbLaNRIsRowMN2K8XlJ2K1PgghYLXb4xL4J1Fo4BhyBqN4mMmasxfPEy5WjzhMpshb4YCn6DfBW16+XYofH1cPmN90CpqzSpVFWVtauWi2Sno8UEJJ2Wx4OP/xwkSdO1cobD/2THUmFO4BShx8pFgOgRGEpnge9qwBlPhX00SAUlRaaCf/WfuCgE47SffFvFcn2wroEVqMOVe4m0i67EM74a7xBFNf6hOuA5a2yk4wYnZMorC0UDIPSbcJ1Q3dCextT0Y3DgkEXXXSROK80XzcWETHoBumbZMaEvCQMybAhGI2IBll0nzDF05lTFxjKPhqsVhlK6Ido5hhEoMGQ6DoUrawTFmIZvUYIEPbOkHQtzz//vIhhYGxC41RPiSQeKSAk7Zqp/Oc//xGBhjR1UTww9aqj/fibKj3CT8/ZrrF6FfSOjVCH/UBtIYIqLfzWXIQz6vznhCZ8muoTTR3nP6cLYEiGVQzYrIDZlTB4lMJlS60XNb4gDFq12JfxuUlCMIzISkBWgknsY2d0sqTFggV84kUEKw02B8/9gDQrxuUmIdmiF9YIWkuCiQPhTxoiRKC94Hvxb83IGVBpDUhRuRBe862o+BlbR2Cre0TStVA4sAoqYyIkku0hBYSkTTBN7Mgj69L8GPTEUrisgd/RlNT6REqfaLBUb33YjLKgEdaoU1zC0bGnNvgMawjQWkFzfUeSbjNiUJoVTl/nFjoSZZODYdEsjIMve3nYzVqMzE7AxLxkYWnon2YVrgPO+ruCmIhgTj73j7EQdG9sD/a24D4z6LXU6RPWE3fO/ohqjdB6y2EuWwBv9lREEweI1M0BnoVwbfm3kJFWrRJBmhKJZNdECghJmwJwGNUdH/PQ0ZYHwkh8Wh8STHqoVSqYKpeJ2g8qJQJfdSEiKjXCplT4Bx9V/xmay5luyJiFziAnyYzcFLMY2Dir7uh4hlLGMzj88IcjSLUaMKpPAib2T8a4nCQRUMjgxM6wMrRVRLBexvagiBueZUduslkIIi+McPetc3FZSuaJFuze4SdCUemQpapC6ZJv6z9LFwyDM2VzLYlk10QKCEmrYG43S1Oz2x8Lt7CxDvPOOxoOGuvLXSKbgAOJKsxAu1+gdxehMmqHLcy0ShXCw44ENP8GSnK2zsDJ1haPaikcvGmez7AbRZAfMx/ac4yN4xn6JBkxLjcRu/dLwZicRBH8KI6/jamoHQ2zMSgiGJnPwEo2OaKA3B60kjAmYkCqFVWeAFwJwxC050IVDcO2+XtRHyJiSYMWUeSVfouot6Y+kJKWGOnGkEh2TaSAkLQYDhhnn322SNFkIZjPPvtMNMfq+O0o2FTpFhYIzsKJdctcGGvWQVHrUVFVAa0qAuht8I06rcFnmSmRaTfAoO28gjJc9+AMGzLsBtT6gyh21NWnoPVjexYGppbSHUNzPtMUKXaYUtk4noHipKPdLx0tIp599llR1ZCpnqzc+euvv273M1qNWmRqZCWaUOEOwpl7YF0LcFchdL5yhAb/BxGVBjnRYhSu+EN8hqKJtSkosiQSya6HLCQlaRE0WV955ZUieI6R+Szywpr1nQHN+IXVPiEe6LpguWqau3XeMpQb+sHiXyekb7j/flAMCfWfozVAo1bXi47OhFYBWgicvrCwHpQ6A2K/Rb8MRSXKO4p2XHy61Z/PrqBGrQZZiUYRH2A2aOs6iu4kl0R74DXAGAhm4XzxxRcimJbtlFmRsNnP0HqTaoHLF0J1xAxLykjRK8NSNh81I05DxvJ3YAw5YVv/MTDp8HorRJU7KOInGEQrkUh2HaSAkLQIVqt74oknxN8sP8sAys7A6Q9hQ4VbDBzCiqBEhZnbULtBxDusK3NjhMoHtc6EwJh/UzcJrQDJFp0YnLsCzpATzDrxYPoiTe2hqCIsKBQOtEhw0GTWBI/FoOO/LSvi1B1gnQgKSabxskMia4EwI6e5fgqEmSJ0AS3f4kBtyjiYKpeK9t+q7L3gTh2LpJJfketeBkfAA43BItI5qzxBER8iAmklEskug5T0kh3y5JNPCgER+5u9LjoDZjZsLHcLU3+shLGxajnM5YugjgRQacxFgms9VCoF4cxxCCYMaGAhYeBhpt20U2b0TDtk7YU+iSYR7MhAy36pFvE3X6fI4DI9RTzEYG+DTz/9FLvvvrtI/aOI2LJly3Y/k2k3om+SCaUhE/yJg8Vr7JcRHnmCcGMkwony5T/Xuz5Y04PCUtKzuP3220Vfi+5Ofn6++F2znTlhZhqfx/f3aC0dsY6uQAoIyXZhlD2b7BCKiEsuuaRTtkMTNa0LJQ6/SJckDJy05X8HvXsLgrZczCvyI1NVDbXGgPDoUxp8ngWHGDzJugOSroVpvOx/wuZHmzdvxqGHHrrdGx8FHsVVokmHLba6+h3GmjUIpI9FSGuHBlHY135Yv7xJpxVlsmVVyh3DzBgOPHywHw27VLIHBYOf20tHD2psa7+97p3dlalTp6KkpEQU1msJ7CHC2hvtWcfOQgoISbMwMI7WBt64mbp36623dsp2GGDIjIvCaq8IIIw1Y7IV/gxT9SpENSZs0PRH39p/RPCkKm0IPFmTt3FfZNiMYpYv6XrYNZG1QNhgadmyZSLNl+m+zcGS5Cy57TGkw2vJEa4qU/VKOFPqZqTZnmWIhutqQMiqlK2DViAOPuzMyYZZnOk/9NBD2FUQlWLDYZECzhbk7YFBvB1FR61Lr9eL30F7rI0dsY6uQAoISZOwBTCbY7HbHQcDui4642JmvMDGCjc2V3uF5SEWKGeoXg1r4U/QBF3CzL1wfRH6q8qg1lsQGHWKaA8db71gsGVqJ9V+kLQMtn9mSierkv7yyy847bTTREv05mCtjnSbASUJY8Rz1vlQRh6LKNSwKW44ln8vXqcopHuKIlGyY5ghxcGHXSop/A888ECRMUXYwvv0009HUlISzGazsBZRaMQoKCgQnTD5PtO02QuDXThppt9///3FMnyP94JYYzVmZ913332iMRNdWmPGjGlQHyRmuWDK94QJE8T+sfR9YxcG10NrSd++fcUyfC8+RTjmKmCXX5bLZxOot956q8lzwOWeeeYZcXzcpwEDBjTYp+2ti23BGcfD14YNGybaj8fz999/Y9y4ceJ9Bg0vWrRoh5YadhClpYHnnOePvYL4XfAc8rcya9asessR9y1+HWxuxWPg+Yvn448/FtY/VgQmhYWFogNrYmKi6LrK+zfX1ZlIASHZhqKiIjGL4cVLU9rbb78tou47YybCQlEMmkw2/1tVUR1wIHHDJzC4ChCy9sH8UC5G+edDq4pCmzUSrtwDt6k8KYIZd+FOmb0FDh5M8+UMijdszoCbgzdI9hhxGvsgaEqDKhqCxmCET5so3BjmNf+6MXRq9U6tShmrDrozHu113XDwCQbrUmE5YLGFNwXFvHnzxLoPO+yw+tn3xRdfLCYNtD7SkvTAAw8IS0FOTg4+/LDu+1izZo2wcHDQIxQPzM5iai8nHszWouWSA2M8N9xwg2jzvWrVKowe/W/p+Rhc3yOPPIKHH34YS5cuFYMsg7XjBU5sPXSrcj3ba9pHi+lxxx2HJUuW4JRTThH9PfiZ7a2LIuK2227DPffcI1679957xXpi/V/cbrfIOBoxYgQWLFggRBBdMduDsREHHHCA+AzPOcUTRRrFNY+Z/UbYsI7nlA+e63goyLlN3ofj4b5yckdRwu+P+09BwUBmChZ+b7yPx777zkBmYUi26azJqHqKCKpv3mh4A+oMtwVrPWys8IiumfWuByWKhI2fw1i1ElGdBdUZk1H0+zzspqqExpQI98jTAfW/YoY3QPa+GJhuqXd9SHYunKlyQOENmzfIgQMH4tJLL21yWcasJJoNKE8ci76+72GqXAFHyhhYyn5CpmsZqiMhqDQ6Ed8Sq0q5M9xUvMZG3PZvlcyuZOWdBwuXT2vhb4MxBnQt8fxzIObvmYNLrPgbByEOWBR9J5xwgohh4aA7atQo8T5n7jE4qyXp6elilksoNjjIzpkzp77xFj/DQZJN2OIb69G6MH369Gb3l8Lh+uuvF9cNoXhhds/jjz+Op59+un45xguw9siO4PHEWpGzLTl79dCSGm9RaLyumTNnChETe41WlZUrV4pjYWt7DuK0lLC1vdFoFBYa3itp6WmOBx98UFgq4rcb3+WUYpsigFaj5qAAokWP1gYuS6sE445ohSC0pHC/aD2JWYpfeeUV8T3RmnHQQQehM5AWCEk99EuyOBDVf0ZGhjCZtddH2RSs17CmzIn15SxTrWtwc7QU/wnrlt+hjgThTRuHn7boMC66TATeafuOhye7YXdAbzACk14tgyd3MXgdcWYau0mzVkRT0GXFuhgVpv6IGOxQh33QDtwbEUUNi+KBd0WdCZuFtfhd09ok2T4815x9coCjCZ/fBWfKnFFrtVrsscce9cvy9z106ND6mflll12Gu+++G3vuuacYTHkv2B7r168XgxqFAbcZe1BAbtiwocGy26sRwgGxuLhYbDcePm9sNdjeeuJp3EmUz7e3LtY04T6zWF78sfB8xI4lZj3huY2xo46lMQtEe6CViGnTMVcUrUG0TNA9RWhl4XdBC0Rsvyn4GIfU+HvoSKQFQlLPVVddJUQDLQ6ff/658Gl3NEzRXFvmEtkWaY2aQencW5Cw8VNo/ZXwJw1FQcaB0P39KDJUNdBb01A74rQGsQ/E4QuhfyrrBchLeVeDs0ne1Dhb46ySplX6jhvDwl8mvQ41CSORWj4PRrUCjy4J9nAVzKs/BEYfIWJcOK9y+IKd1udke7AuCS0BOwNuu7UWIPr/ObPNzs4WoqGlcMZOUzhntyxXTxHIGXlzFiSa9AmX79OnT4P3GMcQD2MqOoKOWk/jdcWO5YUXXmggskh7XLimDrDg8rs8/vjjhQWEvyX+S2EY+26574wvaSomJC0tDZ2FtEBIBDTt8UFYYbAzOmsyl39FsUN0mMywNRQP6qATSWveg8GZj7ApDbUDj8If837DGNVaqDV6qPKmwJ/W0G9KczarOzJzQ7LrEQtk4yyJszv6cWnubQzdE2l2A8rMg4RA1HnL4UisM/GmuZYBkTofLkVipTvYoU3MWnMs3P7OeLQ2eJmDItM3c3NzG4gHBgbSyvjXX3/Vv8baHYxpoH8+Bl0aF1xwAT766CMRw8IBNTaIkfjAWH6OQoGuD24z/tHYl789OJum2KF7JR4+j9+31vDnn39u83x7Rc5odeU+bNy4cZtjoSuD8PO0ysRnGP3ZaDuNocVie+mqPK/bCzaOd2MwqJRxJqz6yucxxo8fL1xUdC813vfOTAWVAkIioqxjecgMcqIPtCOhL5aNp5YWOUR/C7Z3ZoGgGKqwH0mr34W5fCGiGiNcudPwZ1EQfSp+RQpcMCZloHoYMy9U21gfmLlhN0nrw64Kza4MpuQgQBM1g8coJhrDAmBRnQ1ea554bsidKNwYxqgXkdVf/ZvOGQiLlE5J6xk8eLCIzGfAHmMUaPZmsCMtB3yd8D7AmIlNmzZh4cKFIgYhNugyq4Nihi6SiooKMeulyZxBhAycZKAhzeX8HCcjscDDlnLttdeKuAf68ylqGOBI83+sDk1rmT17Nl5++WWsXbtWuGOYPbGjOjasdUOrC6vu8nMMJGUswaOPPireZ/M4ngOew5UrV4p7J2M3tseNN96If/75BxdddJEQH6tXrxbCurKyUrxPSy9FHTMm+BpjGZpin332EXESFA4UNPFWEr7GVGp+j7T08ftj7ANdUk2J9o5CCoheDtUsTWGxRlnXXXddh64/HImKQMllRQ5EIwqyEkzCHF1PNIzEdR/BWvy7aBzB+g6bEiajZuEHGK3eCK05AZHcvRBMqqtYGJ+6SbISjLt8rnRvhzMg3mhpSuWAwGC0xjdJFpVKsuhQYR0qnls0YTg1SSIbQ7fqo/p4CV5Psipl2+FgSFM3rUH03VPc87uh0COcCTMTg6KBEfwsDhYL/qPQ4ADLgZ2z9dhgzABFZipw4I19ji6N2Ky9pXCwoxuVVg8GcXK2TZ8/hU9b4L6+++67wgLAmIx33nlnh9YMunAYiMjzxH1gEChL98eOhbEFdO9SWIwbNw4333yzED3bg+eQ7iAKNlZs5Xln9daYdYgCjC4S7ht/I7TmNAXvc+yEHMsqiYeBlcycodWJAaD8Hng/p6WE1p3OQqX0sPJuDMbhDcvhcHTqiesJ0HzJC5omO+Yoc+YRM1N2BExBW1/uFu2qmWmxTZyCosC+8XMkrf8E6rAXnszdUT78THz/ySvY3fU9+mlrYOszDMV73Y+wtWGEcrnLLwInx/RN7JbNqHojNEfTP8+UM6bKxcqjxyhx+LC0sAqjCt6EJuxD5aYlyKn5Ex61HVUz5kLRGlDlDoiU3bE5iZ0mHHnT5QyOg0Z8sJyk+8BrgxkKTHOUtO4ab80YKi0QvRTexJnmRPHAi4hm5o4SD9Sk5XRZFDqEeKCboakgR2vRL0jc+DnUITd8qaNQNWIG/pr/J/o6FyJHXQFLciZqhv53G/FAHzgf7DshxUP3gRH1zz//fH1KHxtxxUNBaDUaUWOrs0IYM4chAjWMETeQX1dTgNcRm5YxrVIikexcpIDopdBUSP8mTXI0E3ZUuiYbYrGnBeMdGOTIeIdt2jArCixFv4igSU2gFv7kYajc7SxsrnQhuPJLjFFvhMGShHD2JLjyGhaNisU+JJp1MnWzG8JCRrz2Yn/TXx6DHUszGEy51Y1hNergUVmhUUWhWlHnxjDq1PCFojKdUyLZBZACohfCWeBTTz0lzHxM+9ltt906ZL0MkKRw2FjpFvUdUqyGbc3MbM9d8C1SVr0l0jXZUbNqt7NQE7Vi5ZzXMU61DhadCsbUPFTudk6DolGELbL94TD6JJkbBGJKug8srEM/uc/nE0FfZWVl9e/R1RUxJiNgyRIZGV5z37rXq5cALCqlUomCYTWezquuJ+n+0Aoq3Redj7wD9zIYfc0gKcICKSwV2xFWBzbDWlJYA6c3JAIlm6wWGI0gYcOnSFr7fp3lIWkIKkedC5chE39+9iz6BVYhW1MDa0pWnevCkrHNKjjztBl0SLVK60N3hQFjDG5jpVNGiLN+f6yUst2kg0WvRbVtmHiuTemHCFQwhh3Ql84Xr1n0GlR5gvWBtBKJZOcgBUQvYsuWLaIYCXPBedNmelG7Yx1cfiwprBXBkvRPp9uNDbMsYkRDSFz7PhLXfwxNyANf6khUjrkIHms//PrpS0h3rcAozWbYkzIRzJoEd85+265CUeAOhNA3ySTM3ZLuC4O0WD6ZaYCMHo/1zKC7i4WiKkwDoGj0sCSmw68yQosIlKV1vRh4nXkDEZnOKZHsZKSA6CWwZj3FA83FTE9ifnR7otg9gTBWlzpFoKQnEBFWh+aqQaqDbqQsfxGJG7+oK1GdPg4VYy5GwJyFX754EynVCzBBvR7JSUlASn9UjThjG9cFYS+ERLMemQkd35tD0vWwhPKbb74p/o6vG5DE2BatHt6EwYDWAJ8+VbxuLf9bWLHowogoMp1TItnZSAHRS2CBGFZMY3MVpje1tRws+1hsrvJg0eYaFFT5RKwDSxE3aXWgCdpbhvSFj8NeyCh6Be7sKagYcxHCxhT8+v3HsJf+jgmqdUhNsEGTnIeK0Rc26bpg/r8/FEZeirlBBUtJ94YuNBb5Ieeff77ocMhrykI3xtZgSlVCDqJQwRSqhrGirjeDSadFhSvQ7k6VEomk7cg7cS+A1ga22qXFgTXU2R2xtUSjdamZS4pqsbLEydu6SKPcXmdEQ/UaZPz9AEyVSxDVGODsdxgqR52PoNqC7798H8ZN32G8aq1we+hSckXQZCC5zvfdmGpvEKk2g0gJlfQsWBOCFSppJTvmmGNQW10l3BjVunTRYMuUNgBBRQetEkJ0xaf/VqX0h+EJynROiaRHCwi2YmW5ThasYPlNlhRtDlb94kAX/5DFXNpOrIRqLPee3flaA2d4jHhfXuzAkiKHuGmz7DBnidv5kKjxkDH/IejdhYgYEkWNh+rhJ8MdUuGbj15CUtEcjFetQ5ZNC0NKnihV7UvfttFSzOrB9ge5ybJld09ErVaL/ius2FdYWCjKBduNGlG63Js0HCqDBX5dgmimZS6eKzJ5KFwZvOuSbgyJpOcKCNY1Z943zZTM+R4zZozo9lZeXt7sZ1j9qqSkpP5RUFDQ2bvZYytNMu6BMzumy910002t+jzrLawqdWJhYQ3KnQEkm/XCXbG9QVwV9iFl+UtIXfYCNEEHgrYclE24Bu7caahwuPH97P8hr/p3TFCvQ26iXqRr1gw+Bp4+eze7zmpvQNQHSJF1H3p0UGXMtTZnzhzMevBe0WSrylJXxjhs7QM6K8z+ChiqV4vXtGo1qt0ynbM1sD8CJ2W1tbU7e1ckO4DVgWM9inqtgGATEjYeOfPMM0Wtb5rSWbebZvXm4AXOpiGxB+uuS1oHew2cdtpp9V3yGKDGmV5L4KxuXZlLxDkUVvlgN+hEx8sdxR5o3VuQ+dc9sBd8B1U0LIIlS3e/CYHkoVhXWIq5HzyB3Xx/Ybx2E3KSzdCl9IdjwJFw9Tt0m0ZZ8e2/KVhyk82y6mQPh/eHWOfH++69Byv+/AkOlQ0hSxYMGYMRhgbaaADqdbHmWlrUeIPCQiWpu29u73H77bfv7F2U9DA6VUAEg0ERFMV2vvUbVKvF83nz5jX7OXZ5Y+c3toPlzJkNnySt45577sHXX38t3D8ffvhhi1q6UjisLXVhYUENNlS4YdJpkL2DOAeBosBc/Duy/7wDxpo1ULRG1A46BuUTrkHImII5fy7A+i8fwR6RBRitLUJWcgKQOgzVw/4Lx8CjRMGgplerCOsDq1ky+0LS82GzoFiTpusuPQ+lRZvhSRoOrSUZAbUFKpUCw6YfxTVn0mtESWvpxqgj3mr7+OOPb2PJZdMmiaTbCAi2JmV3t8YWBD4vLS1tNrWL1gl2K2OKF2fSU6dObbYlKc3zbP4R/+jt0AQci2xn21h2o2sODtJ0VVA4LCioEVUkKRj6JJqbTcuMRx3yIHXJM0hf/DQ0/hqEzekom3AVaoaeBEcAeIdm6UXPY0/VMowwVCItNR2hzHGoGnUOPH33adbyEEvbtBl1yE0xt/FMSLojjzzyiIiVctTW4p6rz0WpNluk9frN2SKTx+gtgc5ZICxTbOrJ3hgSNLDacsLQ2JLLsvUxOLGbOHGisAbz/sr22fHwvsFga/bH4T2ZMSrxcN3PPfec6OrJdbD7IyeF69evF6Z3uqK4Xrb3jkELyNixY8XnODnk51iPhk2b4l0sbPDHzzNjjP1T4l3YLdkvdtNkMC7Xz06eLNW/PdhtlMtxssWxiW7fGOwIutdee4l9Ybl/Hm/8MeXn54ttsq/L3nvvDZPJhEmTJolW4Iw/4znmeWfsGVugx2AZd1bKZEM5duCk2LvgggvEpLs5ONZRBLIrKs8PfyM8XzF4nhiMnJSUJN4fOXKk6LTaq7Iw2Or09NNPFxcaW6l+9NFH4gTzomsKtpDljyX24IXZm6HQ4iyOwoCtaXmhNpdVwdLTK4qdWFhQjU1VdRaHlgoHYqxagey5N8NW9BNUSkS4LIqn3Alf2lisLKrEp+88g4kVH2KyZg2GWP1ISM+Dr89UVI6+AP6U7bfVZYBcIBLBwDRri/dH0jPg4DB79mykpqZi7YqlePCeOxGw94c2bZBorqWL+qDP/1EsSytEhTsgrudOhemi4eDOeXRCqirbUFOozZ8/X7SVPuuss+rfYyzK5ZdfLop7LV++XKTX0gXN3jnxsI0379Vs0c6qogx+5bIsUMf18h4UsybFoMDgYMuW2BycFy1aVB/kzQJ3HFR531+6dKkQJOedd159vZqW7hcHZQoTruOwww4Tra+rq6ubPA/cT7YRZ4A5RRT3aZ999ql/3+PxiBg+LvfDDz8ICzrFSeN29DNnzsQtt9wi4vx4PnkurrvuOsyaNQu//fabOG5mG8XD9a1atUqIALYa51jXuENtPDyXPCes4spjYzNEloRft26deJ8VhikyWJiN7cbZZjxeNHa7dt5UU1SB7PQYX5d8xowZIoiHVoaWwBPFL4UnuTE8YXzEoAWCIqI3tvNmOWCq/z/++EMIMP5LRdxgmUhUZFWwS2bl1gA0ZlTs0E0RhyoSEFUlE/K/FX9HdRZUDzkJrryD4I8An81dCPPqDzBJvQoDNFVItluAlEFwZ+8Jx8AjENVv/3vhJVns8CMvxYRhmfZOa9ss2bX5/vvvRcA1r4dnH7sbR/cLQL34dRgUP2qSx8F53Lsi/sHhD2Jiv2TYjdvJDGpvq2MO5L89gp3C3leLwlqtgdlsDMBrHCzJwYot1WmlPOCAA8RrnKUefvjhojcJj5ezfs5eY51TCQdkDqZffvmleM7fJAdMigjCGjOc/L300kv1YoQDHQd4rjdmgWD5fM6UOYsmHLC5bVbJpXDkLJ/7SBHRmLbsF9/jIEp3LgfbxnDQ5j5y4sWqqC2xqnNCywF6t912ExYIXie0epx99tn1x81JHAXCtGnTxGv333+/+E5Wr64LAObEjiKKWUccIwnjA6+99loxdlGo8F7O+zjdUYxlGzBggPg3O5uWuDoYDkCLzb333isszccdd1y99bnbt/PmBTFhwgRxImNQufE5L7aWQBcIv6ysrKwm3zcYDOIg4x+9Ff5wKBp4Dija4sWDNxgWBaDopmBwJHsJsJslgyNbIx4MVSuRPfcmJG74DKpIEP6kodgy9W64+h+KVaUuvPLWGxix5ilMV8/HSEMlUtPSEOkzCdUjTkfNsP/uUDwQWkYSTTr0S7FK8dCLmT59Om7Ymjl0za33ocrpgVufDhUUmJwboPZVisDeUFiR3TlbSbxbM3ZvjWXGcVbMwToePufrza0j5qZmldv41zhQxbuVc3Nz68UD4TjAMYGz/+TkZDGwUjTSFM/ZO2M3YrRlv2jK5/2wuaw/XmOMt+PgzKBzNhf0er3173N2TzHA97keliMgHMhbey4a7wMzEmPiIXYuGP9HUdEYjoEcC5nqTEEUe/zyyy/1LhVaUijQeE4oImil6Gw63TZM8w8tDvQFUSlRTVEVUvURmsB4QdEVQWhKmjx5ssgcoHp+6KGHhGKlOV7SPJxFsMshYQwJ/YSRqIJab1BU7Ctz+UVGA90BGXZTq+spqIIeJK95G7bCn6CKhhDVmuAYcARqBx0Nb1iFT35ZAtPK93C8ehlytNVINWuhSRkCT8YEOAYdh5D1X9W8PdgCPBxVMCDNIszTkt7NXXfcgTk//YJ//piLx1/7BNcdNxFKWQF0EQ/MRb/DPfgo0T+j0hUQhc06DY2uzhKwM+C2Oxid7t91xkR6Y7N8W9bR3vW+8sorYiCkZYIlADgpoiWKY0Jb9iu2H83tA60OdDvQ6vHdd98JNwMtJYxfYNwDhQwFBrODOPPnemh5aByroGvBuWjt+Y2HwoJN6Bi7wn/jibkpOEZSfNEaw2PhmEo31aWXXopuKyBOOukkETzCL4aBkzTJ8OKIqTQqufj0wpqaGpH2yWUZDEILBmfVTPGSNA3NbxRiMT/YoUcchaIaL0ocfji8IdGEiubd5ERD61fODIvSv5Cy8g1ofVTQKviTh6Fi1LkIWXMwd105Fv32BaaHfsJg9RZk6X2wJKYhmDoCjpxpcPfdV2RltAQKnipPAP1SLKISoUTCm+WLr7yOfafsjq/+2YTpI1NwYKIWGkZDrP0aGHwULAaNCASm+GyNNa1VcFBopRuhu8KAyN9//11M/GLweUfcg3m/Ly4urjfD0/XB+z8DImOMGzdOPBhLwVk5q+dSQHTWftE9TlcAH5y5Uzj8+OOPwo1CywjFAwMkY92MO4olS5YI907MUsxzQTHQVBwfzwctELRixPalKfhZBmPywfPHfe/WAiIW/NE4mCZGfBQpeeyxx8RD0jIYeEQTG4tGjR47DmddeSv+ya+GLxgVQZF0U3CG1ha07mKkrnhVlKJm9b+ozorqISfAlXcwihwBzP7oZ0yo+BBnqtYhU+tCskkDVdpIuGl16H84Qva8Fm+Lfm5aSSgc+qUyXU+6LiR1DO6Xi1se+R+uPesk/PbXEkw4dADSlSqYqpbCFfLBpDMKSxuba3WagOhF0A/P2AIOWhxU6atnrADjJtoL/e0UAA8//LBwbdDawG0xS4Q+ecY3sD8KBQYHb7oQYpOjztivL774Ahs3bhSBk5yw0pJLSwEFDZ8zJoP7RDcPxc8NN9yAjiIYDIq4CVpZGEtB8cJxsql6PXRdMBiU54JWBZ4DTswZDkD3CeNIGPPCbA8uy4k4g0spujoTGd7ejWGDqetuvEWoYrPFiivufRpVAYgywEkmfZsHYVXYj4T1HyMh/2uowz5ApYE3YxIqR56JalUiPvxlDQyrP8Kp6r+Qqa5FhiEEfWIWAqmj4Mo7AJ6sKaIVc2sodwVEMOfQTLscBCQNoCtr+oHTceoFV2LZ17OwdIsPB2YD2qAT5rL58PTdWxQZo7VN9kppPwx4Z/wBB3lmPTDQjq4FBvW1F7qmjz32WJEdwcwIpkUyjZIwHoBBhix6xwkRB21aVJlt0Vn7RWsDRQjdFozXYDong/UZrBkLiKTIoduCouKJJ57okPNAGMTK7VG8MBGAE8HtFfvisTLGgVkoDDpllhItMzyHhBYKni9apBmvwaDRzp6Md2oWxs6gNRGk3RGa+Vk4h5kUn3/zHa6YcbyYvd/x+As48pjj29crQonCsmUuktbOhs5bV6cjZO2DKgZAJo7GF4uLULX4Uxwa/Q191JXI0PpgtdoQyhgNb8ZEuHKmIWzJbPVmK90B6LRqjMpOQIK54/29ku4Ps4YWF1Th0UuPx0HmlTh/D7PojVE7+Hg49rtHuDA0KhUm9U+Cto0Wt5ZEqEvaDgfHTz75RKR99nbOOOMMEePH87Ez6KgsDGmB6CaWBkaZ00xb5gqIhlZVleW44+oLhXg44dQzccxxJ7RrG+ycmbzqDRhr1opiPVGtGY4B/0FlvyPw3epqrP/8NRwamoP+6lKk6NjGWwuk7gZ3+ni4c6aJuIjtFYVqDh4TNc+wTJsUD5JmsZt0MBv1uOL+FzDn+n1QGTQgQ++DvuhPIBqGRa8RmUXuQFhWLZVIuggpIHZRmN9Ony4HWNZroGiIKFGYdVokmrS4feZVqK4ox8Ahw3Htbfe2eTta1xYkr30P5rJ/RP8KRa2FJ3Myygb/H77eFEb+m29hWvAnHKguRrLWhyQDoE4dBF/qGHiyp8CbuXur3RUxOGsMRqMYmZUgmnRJJM1BgSA6wCZnYOop12L90ueRlaZA6y+HsXoV/KmjRPaO0ycFhETSVUgBsYtAS0JdXf+wyESo9oTgDYRFB0KLXis6UcZMs68//xR+/3kODAYjHnz6JRgbFYtqCRpfFZLWfSBcFuqIX/SjoBWheODJ+LLYjJLZH2Hf4G+Yri5FktaHZH0U6uR+8KeNgTdrdyEyonprm4+VooiHMzzTjswEaSaWbB/G8zDAloG2Iw8+AxvXf4EINkAXDSC87GNg/1EiaLjc5UdOskkG4e6iLgzZ0KsOFpXqCUgBsZNdEzS5UjQwDoA1/X2hqIhjsOq1IiCscUzDyqWL8fj9deVOr515LwYPa10KkzpQi4SNX8JeOAfqoFukZYasfbE592h8usUG32efYXJkIQ5RlyNR60OiHtAk5cKfNgq+jAnwZE1FxJjY5mNmSilv8ha9FkMzbUiRlgdJK9wYeo0afpUeI6efDufc+5Co9sK3+COo974JZr1GWOo8wQisBnlrk0g6G/kr60I48/YGI0I00DVR7Q7BEwwjHI3CqNWIIk9JZnWzsyeP24XrLj4L4VAIBxzyHxH70BrhYM//BvbNP0ITqBGvhU1pWJdyAL4pMUD/3VfYXbUWWapqJGr9sBk00CT1RyBtJJwZk+DJnISIMbndgokxHKlWPYZk2jqs9LCkd0BRzeZqnkAY9swxcBqykRxaJ2IhXn7uLhx98R2o9gREkHFHCIgeFl8ukXT4tS0FRCfD4jYUDG5/qC6WIRCGn1YGlUqkp8W7JnbE/bddj835G5GZ3Re3P/hki8y07JBp2zwH9s1zoPHXNZQJ6ROxQjsCv5bqkL7uO0xVlSBTXY1ETRAmowma5OEIJA+Fk66KjImIGnbcCnxH8KZf6wuK9uBDMmwyVVPSapiqmW4zYJXbhUDiQGgzRyJauAEWnYKyb57D8j2PQvqAEah2B5GV0PaqlLEKgixp3LiXjETSEwhuraTZuKpla5ECooNhF0lPgI+w6OkQq5BHwcdB06LXInk7Vobm+Pbzj/Hp7LdFkZF7Zz2HhKSk7S6v9ZbBWjAHti2/QeuvEq95YcSKUBaWl6qQFl6EaapSJKtdsOsU6M02qFN2E3EQ3qzJ8KaOhqJrfxvtWLwDVAqGZtiQk2xud5qdpPfCQEqtWoUgdDAP3Afewm9hVvlx2EgLLrz0HLz0yQ+o8arF79CgbdvNkTdV1geI9S5gfQIZUyHpKUSjUVGEitc1q3C2Bykg2gnFAd0SMcFA8ymrQEYUBQatWvhledNTt+MGVLKlEHfeeIX4++yLr8LEyQ0bytSjKNC5C2ErmANL6V/Q+quhRMKoDQLrfDbke/VIVeVjX1UZ7FofjHojjPYMKAn94EsbJQpA+ZOGAGpth2WSsNVyolmHQelWmWkhaTd0YViNWvGbs6TtBqcuA7bQJozIMMBTtglP3nMzLp75iIgrMljbPrtiZUTSXBMmiaQ7w4koG5u1VxhLAdGGTAlaGNjdssYTgitAwRBBVIEQDIwET7Pp2lTQKRKNYPGiRaJlLKuMjR03jiUZcPMVF8DlcGC3sRNwwZXXb/vBaATGmjWwFv4Ic8VSaHwVCPo8qAhEsSlgRWXEij6qcuylroVRp4bBZIXBnoNwQh5q++wNX9pYhM0Zbarj0Nx5qt1qeclNNqF/qlU2xpJ0CPxdMYZmQ4UHCfZ+CCYPQ7SsAMlGBdP6azF79tvYbY99MfC0k9slWHljZSXE9PR0hEKhDj0GiWRnw07ZTZXMbi1SQLQQZg4UVHlFamUgHIUCBQaNRgyMtjYKhnh+/OlHUaK1vKys/rX0jAyMGdof8//8XZSqvv+JFxp2eAt5YapYClvhzzBWr4DiKkXA54UjpEJhpM7FkYFK9NOWwWAww2zLgtqSBl/qaFT02Rv+lGFQNB1rFaBoYEEfm1GLUX0TkGEzCt+1RNJRsM6DCh6204Jx8EHwl/0IoxLCZUeMweyV8/HEHddi0h57oF/q6Hb/LunOaK+fWCLpqUgB0UI8/jAqnAGRi769TIm2iofrrrtOuCDiKd2yGUVL/xB/33jnA8jtP0D8rfWUwlz6D2ybf4Cqeh2i7iq4QhHURg3wKCYYEEKOqhJ6gwkmSwpMJjOCCf1Rm7MffBnMpth+/ERb0zNZXjsUVZCbYhIdNZlVIpF0NMzeMRu0wvJnzJkEpyYF5kgxhib4sPvEcfh7/iLMvOpC7PPDj0iWvTEkkk5D3uFbgVaj6vDsAbotaHloLB4UJYpwbZ01wpSQgsOPORbmkr9g3fwj1CULAecWBIIB+KMqMROLKFpoVVGkGKIwme2wmYwIWzLgydwD1X33QciW22EuisYw7oNVMzkzHJFa14pbBp1JOgu9Vo1Uix6FNT5YbVnwJwxHRnUJjIFqPHbzHTjwlCux9J95eOTRR3DPzJt39u5KJD0WKSB2Mi+//HIDt0WMiKsK6mgIY7K1OHyUFpb3/wtD1IFQwCVeV6BCFBQPekBngcVsE4V2FGOCiGkoyT0QgTb2p2iduyIgLA3Ds+oqSrY18l0iaQ1JFj0Kqr2iUmtk8KEI/vUbdEoIA3xLcN3t9+GO6y7Dg/fcgeOPPEy0PpZIJB2PFBA7Ebounnv22QavJeijGGR2Y8/BYUwd1AfZKSYkG1WwezZADQVhqBGCDlGdGVpTItIsRqgMNvhSdkN5n32EeICmc79WpsjVekOsfo28FDNyki2y8p+ky90YDAhmULN10L5w/m1DmlIFTeE8HHfirfjpu6/w65xvcMqpp2HB/H9kPQeJpBOQd/2dRMx1oVEpyLNFMdAewZhMDUb3MSLHZkCKKRl2lQ9GeBCEFiGVFiqtETqTHSZrEmBKRiBhACqzpwrR0BE1G1qSllnjrStAkm43oG+SGUlmnXRXSLocBi8nmvSocgdhtqWg3DIcae65MPrLYKxZhzsffgrHHDAFq1auwI033ojHH398Z++yRNLjkAJiJ6Dx16Lg76+xv60AgwebMTjdhn72KFL0IVjhgxYR4aIIKGo4wiox488YPAZRSwZClj6oyZgAf8oIhM1pXbK/3H4NLQ6AiG/om2RCskUvhYNkp5JqM6DU6Rd/uwccitDSP6GNBmDL/wbJk67FNXc/hpsvPBWzZs3CYYcdhoMOOmhn77JE0qOQAqIriIagd22B3rkJ6ur1cJZsgH3LOly2bypSNR5o4GLYpBAO7BcRCAXhDUZR7FKwwaHGqL0Ph3HEIfAlD0fIliM6Z3YFrHXBeg4MHs2wG0QZ6mQz84elcJDsfOxGLfQalYjFSRh1CFxLHkAKnNDm/wxMuArTph+Co08+E5+8/QrOPPNMLF++HEk7qOAqkUhajhQQnQSbVxkc+TDUrEGkZBlc1eVwuSphClTACj/MDILUqEW2BSIBkZLm83pR7Qljk0uL4qAJ6xxaDDvgv7AffR2cGn2X7DfTMdnR0BUICx8zC0GxrwCraUqLg2RXgnE3dc21Iki2JKHYNATJ/vkwuDdD5yyEKSEPZ1xxM5b9PRcb1q/DxRdfjLfffntn77ZE0mOQAqKjiEagcxXCXLkE+vJl8Ffmw+eqhcvnhjrig56hjwoQVGngU5uRqIuitqYKTq8f7pCCSlcIWxwhLKvUYIU/AatqdLCmZOLKs26Eou78zIZQJCraiQcibIWsw+B0q4hz4A1aItkVoaDNsBuxotgpnlfkHorI2kXQRnywFc5BKPEcmC0W3P/Ec/i/I6bjnXfewVFHHYWTTjppZ++6RNIjkAKirSiKaFhlLl8AU+UKoGod/M5KuH1BuINhaKIhqFQKtEoUTpUJWl0qMo1BZGoj0Gk1ULR6hLUWLFqyActLg/hjow/LyqNwW3Kg0tZZG26/5hpoOlE8sOQ0Z2/OQEh0B02y6DA00SbiG2Q6pqQ7wIqndLFRACeNORzuNY8iAR4EFryDBYExGDB8FLIHj8KNN96Eu+++CxdeeCH22msv9OnTZ2fvukTS7ZECooWoQj6YXPmwV+fDWLUC+tp1CDkrRNOeYn8I/jA7brJLoBYBxYigNhUmayJyTEHkqaqhiwagqHVQ1EZEdFYE7P0QGb0n8kPLcf+7dwhBorGnQaPRISM9A1dfczWm7T+tU46FPmPudygaEd1BB6RakGI1IJFNv2R8g6S7Ndcy1DXXWrBoOQKBNOxh9MDsLsDtV52DiD0H5156FS69+np8/fVXWLBgAc4++2x8/fXX0iUnkbQTKSBawoLXkLr6R5hqyxEK+FHtD8MdCCEcBcqVRNQgHUFFK7pOpiQkYoA1iPRQMTTBQnaxRlRtQFRnRcicDk/mZHiypyJoz0UwGMLrb88U4mHs7lNw8rmXIS0tTTTR6mjLA2doFA2+UFg0/aJgoIsiyazv8OqaEklXwV4XaVYD3vzse9x763U4b78cTBqihk0fxYF9Q3hjXSnuf/BBZBgVvPHGGxg/fjy+/fZbPPPMM7jooot29u5LJN0alUI7dg/C6XQiISEBDocDdru9Q9a55O1bodrwI6qDGtQqFmxQsoRw0Oi0GJ/gR98EPbKsaiT4CqH1VUId8SPKJlUqNaI6i2he5co5AP6U4VDigiFn3X8HXnr6MSQlp+CjOfOQkpaOjhYN7kBYZFNoNWoRCJlpNwqhw1mbnIFJegJlDi8mHnwCygvWom9GAv48qgw2ePFzoRpHfZUAtcmOtCQ7Nvw1B//739O44oorYDabsWTJEgwaNGhn775E0m3HUGmBaAF/6PbAIp8aNYoNg2wR7JVUjYNtKqRadND5aqH3bIK6ohZQ60XAI0VDIKE/3H32gzt7T0QNtm3WuXj+X3jlmVni79vuf7zDxEMD0aBWw2rUIjfZJvpUsHqfdFFIehrLFvyFipItUOmMKCqtwbpgKsbrN2N0GpBsiKI66EWFQ43vf/4Nl156KT777DP8+OOPmDFjBn799VfZbVMiaSNSQLSAgwfbMMKnQYq6UhRSUgdD0LmKoHNWAUq0LrZBa0LEkARP1mQ48g5C2Na32fV5vR7ccuWFiEajOOL4/8MBhx7R7kJPDIZkWV8GlNG6EBMN9BG3t6WxRLIrU1FWiqjPAa09DZGgD5+VpmNsbiHs+ij27xPAhxvVUKl1yC8ug1qtFv1nRo0ahT/++AOPPPJIXSdciUTSaqSAaAEDbBEkJQbhqyiEyeeAJuiCojYIa4OiNsGXNgrOnAPgSx8PtCB2YdZ9t2Nz/kZkZPXB9bff3+r9odeJYoGBYywvrdOqhHVhQJpF/EurgxQNkt5CVlYWoj4nkJApnn+3zo9rco2wqH34v8F+fLjRBCUShD4hTfx28vLyRHXKs846C7feequoUrnbbrvt7MOQSLodUkC0hC2LYCyeByUMqJmCqTEiaMuFu+/eIrYhqre2eFV/zv0F77z6gvj7joeehD0hsUWfi0QV4ZbwBCPib5NeLdItWc6XqWw2GdMg6aXsvffeyEpJRGUkKFKg12wqRkE4FbtpCzEuXQWLToE10Y4BQ0cK0W0xaHHGGWfgo48+whdffIHTTz8df/75J/T6rinWJpH0FLqmJnJ3R2ugckBYnwBn7nQU7fMQtuz7MBwDj2qVeHA5HZh5zcXi7xNPOxtT9522w3gGNq8qrvWhwu0XrYtzkkwYl5uI3fulYExOIvokmoTVQYoHSW+FMQyzHn0Iit8NlcGMcETBN1VZot19giGKaX0CuPrKyxCKKHD6Q+Iz/L288MILSE5OxqJFi3DPPffs7MOQSLodMgujJTiKULxxJZZrRyAraduAyJYy85pL8PF7b6Jvbj988N1cmC0NxQe/Cn8oCk8wLCpC6jRqWPVapNsMsJt0Ip5Br5WaTyJpihff+Qh3PPEyyjetxpQx/fHh5JUwKX5ssY6G/+RPUO7yi9TlUX3+tfq9//77ojIlRQitEBMnTtypxyCR7GxkFkZHk9AXgb6JQLm7zav49YdvhXjgzOeuR/9XLx7ojmAfDIqGiKLAqK1zTaRY6wIg6ZqQmRMSyY458Zgj0G/0FGxauwK1ZUUoKn4MQ1VF6KMUY2PYL4KLazwhUUgtVvvkxBNPxMcff4x3331XZGWw0JTRaNzZhyKRdAvkdLYLcNTU4I7rLhd/n3bORRgzcTIcvhCKHT4xK2Lz7uwkI8bmJGJS/2ThmuibZBZ1G6R4kEhaBq11drMeQ0eMwSH/OQbrzeOhQAWV3wlr4U8w6TQi+Jg9X+J56qmnkJGRgZUrV2LmzJk7bf8lku6GFBBdwAO3X4+K8lLk9h+EY8+7ClWeILRqFQamWTA+LwmT+iVhRFaCaAxk1kujkETSFii26e7zhcPiuT9nb3hhgEoJI2HDZ8L6p1apUO0JNvhcSkoKnnvuOfH3ww8/jHnz5u2U/ZdIuhtSQHQiNJV++snH+OKj90X++cxHnsKYfumYkJeEif2SMCjdhlSrQTaukkg6CLtJDzXUwjXYd+gElERTRK0WY/liIOwTVopKT1CkP8fDLp2nnXaaqM3CDA2v17vTjkEi6S5IAdEJoqHKHRCZE1tKS/HYHXVFai678iqccdRB6JdqRZJFL0pLSySSjoUpzRaDBp5AGMkZeVivG1Lnxgg4YS+YA5NeA28gXJ+NEQ9rQ2RnZ2Pt2rW4+eabd8r+SyTdCTmKdZBoqHQHsKXWJ25cCWYdRvax441Hb0d1ZQVGjhyJ+++5W8YzSCSdDDOXaNXzhsLM1YQ7a4pwYyASRMKmL0WBNaad1XobujFIUlISXnzxxXoxwTLXEomkeaSA6ABLA0UDG1SN6puAif2TRTDkvDlf4qMPZov0sFdffRUGg2Fn77JE0itItOgQjSqIKgpSB01EWTRJuDEMFcugDjhFC/tKVxDhSEM3Bjn00ENFu2+mVJ955pnweDw74xAkkm6BFBCtgH5VBmBtcXhFO++YpSEmGljUialiFRUV9a2Cb7zxRplbLpF0ISysZtJrhcjP6jccGzV5oFRQBRywbv4BFr1GNJxje/umYH+Mvn37YuPGjeL3K5FImkYKiFag16mFf3VkVgIm9KsTDUy3bNwa++KLL0ZlZaVo2MNa+xKJpOtgjQdaBCkS1DoDHCnj4KMbIxxEQv7XIv4ookSbdGMQFtF56aWXxN9PPvkkfvnlly4+AomkeyAFRAvJTDBhYl4yxucmISfZ3Gz5aFa2++CDD+pdF7K+vkTS9TAOIhytK7Jr6b8HKpREKIjCWL0aWk8ZTDotylwBYVVsioMOOgjnnnuu+JtNt6QrQyLZFikgWgijt3dU2Km8vFxYH8hNN92E8ePHd+EeSiSS+GwMvUYlWt3nDB6NAmSBWkHld4iiUrQa0kLhbsaNEasJkZubK1wZN9xwQ5fuv0TSHZACooNg0BXjHui6GD16NG655ZadvUsSSa+FAoGl4D2BCPSWRNTYhws3RjTsh33zHOjUEE23an1NuzEI+wDEsjJYrfLnn3/uwiOQSHZ9pIDoIOi6+PDDD6HVaqXrQiLZydC9mGYziEBKosndHdWKTWRj6B3roXfkw6zToNwVEBkbzTF9+nScd9554m/pypBIGiIFRAfQ2HUxbty4nb1LEkmvh3FKrPvAdM2coeNRoGQgGgXUvlpYiufCYtDC5Q/BFWjejRHvyti0aZN0ZUgkcUgB0QFQPFRVVQnXhaxgJ5HsQlUp9Vp4ghFYkvvAYc6DT6WHEg7CVvQLDAgiGIlu01xrm/XYbPVZGXRlyKwMiaQOKSDayezZs0XWBV0Xr732mnRdSCS7CEzXTLXp4dtalTKcvTtqFSui0TD0zgIYatfBqKEbwy9imLbHgQceKF0ZEkkjpIBoB/EFo+i6GDt27M7eJYlEEgeLvVEbsCpl1uBx2KKkIqIAGl8VLMXzhBuDFghmZOyIhx56CDk5ObLAlESyFSkg2sEll1xSXzBKui4kkl21KqUGvmAESX0Go1qXBT90iISDsJT+CXPUhWBYgXM76ZxNZWXIAlMSiRQQbYZuC2ZeyIJREsmuX5XSEwxDpdHDnz4GTsWCaDQCvasIpurV0GvVqHQFdujGILLAlETyL1JAtAFaHeJ7XciCURLJrkuKxVDfOCt54ESUKMmiAqXGVw1zyV+w6DSo8QbhDdalfO4IZmXEXBnS8ijpzUgB0QYuvfRSEf+w2267yYJREskujt2kg0GrqWuuNWAUqjRpCGx1Y5grl8IeKhPvOXaQjVG/PrsdL7zwgvj7iSeewNy5czv5CCSSXRMpIFrJxx9/jHfffVe4Ll555RXZplsi2cVh902rUSssDCqDFYGkoXApZkQiYehcRTBWrYReo0FFC90Y5OCDDxYuDC7Pf71eb6cfh0TSKwXE008/jX79+sFoNGKPPfbA33//vcPUyGHDhonlGaD41VdfYVeAtR4uvPBC8fd1110n23RLJN2kKmWG3Qjf1qqUpv67o1xJRERRoPFXwVy+EHa9ItwYrBnRUtj2u0+fPli3bp3suivplXS6gHjvvfdw1VVXYebMmVi4cCHGjBkj1DurNzbFH3/8gf/+9784++yzsWjRIhx99NHisXz5cuxsLr/8cpSVlWHEiBHieCQSSfcpKqXdWpWy76AxKFelIBDVIBIOw1CzFnZvAfyhaIvdGCQxMRHPP/+8+Puxxx4T9y6JpDfR6QLi0UcfFVHLZ555phh4n332WZjNZrz88stNLj9r1iwccsghuPbaazF8+HDcddddIkiRFeB2Jp999hneeustqNVq6bqQSLoZbKzFBlu0MGht6Qja8+CGCeEIszG2wFi1CgatGuXOHReViuewww7DjBkz6l0ZPp+vU49DIuk1AiIYDGLBggWiilv9BtVq8XzevHlNfoavxy9PaLFobvmuoLq6Gueff774+5prrsHuu+++0/ZFIpG0HvbEYFVKb7CuKqU2ZxKqlAREolFoAlUwVi2HXR2Aw9uyolLx0PqQlZWFNWvW4Pbbb++0Y5BIepWAYLpjJBJBRkZGg9f5vLS0tMnP8PXWLB8IBOB0Ohs8Oporr7xSbH/o0KG44447Onz9Eomk80kw1dVqYVXKPkPGoQxJCETViEYUGBybkOhcg0C4dW4MkpSUhOeee64+xfOvv/7qlP2XSHY1un0Wxn333YeEhIT6B/OzO5pjjjkG2dnZwnXBwE6JRNI94yBYlZLZGMaUPITMmfDAhOBWN4apagUMGhXKWunGIEcccQROPfVURKNR4crw+/2ddhwSSa8QEKmpqSLdkYGH8fB5ZmZmk5/h661ZnoWcHA5H/aOwsBAdDYM4WTRmypQpHb5uiUTSdVUpk816eOmiUGsQyZ6AGsUqAinVgVroXIVIilaI3hg7avHdXPwWraUrV67EnXfe2SnHIJH0GgHB8s4TJkzADz/8UP8aFTqfNzcY8/X45cn333/f7PIMZmRhl/hHZyCDJiWS7k+yVY9wtK4qZfbg8SgXbgwVoio19M5NSKhdhUAkKmIhWr3u5GQRJE4efPBBzJ8/v8P3XyLpVS4MpnCyahtbXa9atUrUUWD9eGZlkNNPP71BZzumSn7zzTcix3r16tUiKIk/RDaukkgkkvZmY8SqUtqzhyBoSIIHRgRDobpsjJq1MCEi3BjRaOvcGDFrJdPQGfvFexxjtCSSnkqnC4iTTjpJBBbddtttot314sWLhUCIBUpu3rwZJSUl9ctPnToVb7/9tsivZs0INq365JNPRNloiUQiaW9VSptJC08gDEVrRDh9dJ0bIxSEOuSG1luBNH8+nP62uTFi5a3T09NF7RqmoUskPRWV0tpooV0cZmEwmJLxEJ3lzpBIJN2XwmovVhQ70SfRhKo1vyP480MYoS5Aqt2GYEI/OPsfjuUZR2BYpg39Uq1t2saHH36I448/XsSAsfKubLgn6YljaLfPwpBIJJK2VKUMRaJIzRsJrzYRXsWAQCgEnbsYOvcWJMKN4lo/guG6eInWctxxx+HEE08UrowzzjhD1MSRSHoaUkBIJJLeV5Vya3MtxZiIaOowOGBBJOSHKhqC1leJNPcaOP1hVHnaHsPA6rnMRFu2bBnuueeeDj0GiWRXQAoIiUTS+6pSWrdWpWRPiwET4VCscIU1UFQa6J35MFevgkEDFNf62hRMSdLS0kQjQXLvvfeK3j4SSU9CCgiJRNIrq1IqW6tSpvcfBbeGbgw9AoGgCKRUB11IDxWhxhMSXTrbygknnCDcGeFwWGRlSFeGpCchBYREIul12E1akZEh3BiWdCB5AFwwIxxiMywFWm8ZEioWQFGiIqWzPa3EaYVISUnBkiVLhCVCIukpSAEhkUh6HawFkRSrSqlSwdZ/IlyKGc6IlvIBetdmEVCZFi5BuSsAl7/1haViMGU91k2YsRBMZZdIegJSQEgkkl5blTKi1GVZZA4cA5cmAd6IHqGAB+qQFyolgtTKf+APhFHpCrS7Hg576tCVwayMUKjtgkQi2VWQAkIikfRK7EYd9FurUkZt2VAn5sGjMiIUCkBRqaH1lNZbIYodfrFce1wZzzzzjHRlSHoUUkBIJJJeiVmvEbEQrEoJlRrmfhPgUYyoCeugjgah8deI5dJr5sPlC6La074AyHhXxt133y1dGZJujxQQEomkV0KrQJrVCH+4zrKQNXAMnOoEOCIGBP1ekYmhCdRC7y5GYqAYRTXeNheWindlHHvssdKVIekRSAEhkUh6tRtDq1GLqpTRhDxoEvogrNLCFVZBhWi9FSK7dgGq3YF2ZWTERMv//vc/6cqQ9AikgJBIJL0WVqS0Gra6MdQaGHPGw6cYsCVghjocgMZXCVXYD4OnGCmhUhRUe+ELtj0WIubKiBWYkq4MSXdGCgiJRNJrqa9KuTVAMmvQaNSq7AhEAF8EUCthqEOeuveq5sHt82NLrbfd22WfjFiBqRkzZsgCU5JuiRQQEomkV5No1kMFIMKS1ckDoU7oCz3CKA6agGgIOm+JqBWh85Yjx7UMRTU+OHyhDnFlsFfG0qVLhSVCIuluSAEhkUjQ27tzmg1a4ZpQNHok5Y1GLazY7NFAUQBN0IWIxiSWTa36B4q7AkXVXih8sx2kp6cLEUEYC7FgwYIOOR6JpKuQAkIikaC3V6VMtujg2dpcK33IRLh0qbBGXSgPmUAVYapehaAtB4hG0L/qZ5TUelHVzrTOWK+MWNtvujICgfYVrJJIuhIpICQSSa8nxWJAOKoIq0IocSCSMvqJ19e79VApUei8pQgZkqBoDTD5ypFYtQiF1V6EI+1L6yQMqKQ1YsWKFbjjjjs64Ggkkq5BCgiJRNLrYTqnSa+Gj8GUai0yh05CBZIQCbjhVFkAJYqEwh/gzpwils+umY+ayhJRG6K9MA7i2WefFX8/8MAD+Pvvv9u9TomkK5ACQiKR9HpMeg0STXp4mH7B7Iw+Y6FPzEIiPFjvMQEqDfSOTdB6yxG094MGEeSV/4z8cke7K1QS9sk4+eSTEY1GhSvD52NXUIlk10YKCIlEIqElwGZAKFrnkoiYUpGeNxw1sKLc6YPPmC6aayXkfwVPxgQRbGkNlCG56AdsKHe1q09GjCeffBKZmZlYvXo1brnllg44Iomkc5ECQiKRSIQbQwuDRl0vBpIHToJHl4YUpQYbfRZE9AnQeUphK/wZjv7/Ef0z0n0bEM2fi81V7c/KSE5Oxosvvij+fuyxx/Drr792yHFJJJ2FFBASiUTCqpQGrahMKapSAggmD0VqZo74u7DSAV/SMFEPwlo8F0AUztxpon5E39oFqNq4EOXtbPlNDj/8cJx99tlCjLBXhtvtbvc6JZLOQgoIiUQi2VrcKcP+b3MtuimyhoxHhSoZhkAFygI6hMxZosFW4rqP4E8eCW/GRGjVKmSW/IjCjWvg3io+2sOjjz6K3NxcbNq0Cdddd10HHJlE0jlIASGRSCRNNNcSZI2FMTEbCfCioLgY3vSxUNR6mCqXwVz2D9x99kYgcRDMWsC+/lNs3Lih3fEQdrsdL7/8svj7mWeewXfffdcRhyaRdDhSQEgkEklTzbUAhM0Z6Js3EGVKErzVJXB6vEIwqMNeJG74XFgjHP0PRciSCbs2AuOKd5C/fvW/AqSNHHDAAbjkkkvE32eddRZqauq6gkokuxJSQEgkEklcc60MmwHeWMdNlQq2/hOhTshGisqJ1ZuK4E0bKwIq9c6NwpUBqFA76FiE7X1h00ahXv4eitYtQ5S9NdrB/fffj8GDB2PLli247LLLOuYAJZIORAoIiUQiiSPBrIdapaprrgXAnzICw/KyUaNY4a4pgbO6DJ6syeI9S8k8WLfMhaI1ombQMQglDYJFC0SWzkbJ2r/blZlhsVjw+uuvQ61W480338QHH3zQYccokXQEUkBIJBJJo+ZaFoOm3o2haAww9p8CbWIfpKtqsWZTAXwpI+BPGgZN0IGETV+IIlNQ60R6ZzhtJIxaFQJLP0Pl8h+ArbUl2sLkyZNxww03iL8vuOAClJaWdthxSiTtRQoIiUQiiUOnUSPNZoB7a3Mt4ksbg+G5WahVrPDUlsGzeQkcA49AyJIFvasQies+hDroBtQaOPMORih7kgjGdK3+CVXzXocSaHs65syZMzFmzBhUVVXhvPPOa3e9CYmko5ACQiKRSBqRYjVADVV9syy6KAz9docxuS/SVA6s3lgARaWFq+9+iGpNIivDvulL0TODcRPuvvsiMOhQaLR6OLasQ+2vz0GpKWjTvuj1erzxxhvi388//7w+Q0Mi2dlIASGRSCSNSDDpkGDWwuX/1wrhTR+P4TnpcMICn7MC3nW/wpl7gLBOqCMBEQthLfpFtP8m/pSR8Ox2KmBJRXVNNWrnvQZl06+iJXhrGTVqFO6++27x9xVXXIGNGzd24NFKJG1DCgiJRCJpIhsjK8EEb+hfAUErhDZ3EszJfZACJ1ZtKoS5cilqBx6DQMJA0fLbXvA9zOUL6z/Dnhre3U4VcRHV7gBqVvyE6D8vA44trd6nq666CnvvvbeoTnn66acjEml//w2JpD1IASGRSCRNkGTRw6jTwBdL6YyzQtSo7PC7qlC5ai4iehuc/Q5G0J4Hg2MD7Bs/h6F6Tf1nWNEyOOgweAYejvKABlVlRQjNfw1YNwcIt7yTp0ajEVkZNpsNv//+Ox588MEOP2aJpDVIASGRSCRNwIJSKVY9nP5Q/WuKzgxN3wnIzOoLA0JYlF8B/cbv4M7eC+4++yBkzoCxZg0SN3wMnavw35WpVFBljIR3zFkoNAxEhcuPQP6fwN/PA6XL690eO6Jfv3544oknxN+33XYbFi1a1PEHLpG0ECkgJBKJpBkybEZEolFE4wZ4b8YEjOiTgrAhEfqQE6tXr4CxZpWoSMn6EFG9HcbKFUha9wG03ooG69MZLVAPPxIbsv6DLQEDPK4aYNXnwIJXgdrNLdqnGTNm4Nhjj0U4HMYpp5wCn8/X4cctkbQEKSAkEomkGRLNeliNOrjjgimjOgv8ffbA2P6ZUKsUbKpwwLPyO6iiYdQOPBqejAmARg9j5TIkrnkPWm/ZNvEVCdlDUDjgZKwxj0dNAIg6S4BFbwHLPwQ8lTts+vXcc88hMzMTq1atwo033thpxy+RbA8pICQSiaQZ9Fo1Mu1GuIP/ujGIN30CUtIykZyaARt8WLihGKbCX4WLo3bw8fCmjoZKUWCuXIKkNe9B5y7eRgQk260IZE/GgqwTkG8YikBEASrWAv+8CKz8FPBUNbtfqamp9emcs2bNkg23JDsFKSAkEolkOzAOQqNWIxiOqyipZg2I/TE2JxlqrR4hvwv5y/6AzlmAiDEZtYOPgy+NIiIKU8VSJK6d3TAmIj7OIjEF6xL2xOLMY1Fr6Q+FtSTKVgL/vACs/KxZi8Shhx6Kiy++uN6tUVm5fcuFRNLRSAEhkUgkO2jxnWTWwRUXTEmCCf2gpA7B8LxsaBHFihIHIis+hyrkRcjWFzWDT4AvdRR7bcFUWSciRMnrRrBiZXaiCQFdCv6x7od1uScgkDiwLrCybAXw9wvAsg+A2sJtgi0feughDB8+XJS4Puecc2SVSkmXIgWERCKRbAe1WoXMBBMC4UiDYEri6rsvclJsSEhIgioawZ+rC2Dc8LUY6CkiqoeeBF/qGEClgalquSh5bSpf3GTWBdNGE016bPTZMN82DaVD/oto6hCRwYHKdcCiN4GFrwPlq+v7a5hMJrz99tvQ6XT49NNP8eKLL3bZeZFIpICQSCSSHZBiqQumjK9MSaKGBHiz9sDuA9JEqWmmfC5dsgDG8rr0yrAlCzVDToA3bQwUjXFryeuvYCtkk61tC0Gx7kR2AjM/FCytNWJ50gFwjT4DyB4r+mzAWQys+Bj46xmgYB4Q9GLs2LG477776qtUrlnzbw0KiaQzkQJCIpFIdgAH9r5JJrgDoW3cBJ6MidBakrHXoFQEVAZsrvGiZOFX0HrLxfthSyZqh5wgYiLCpjSYqlfAsmUuEtd/BFXYv822GGCZZNYj1WpAicOPhRVqbEzeG/6J5wN5UwGdCfA7gY0/A/OeBlZ/iSvPPgkHHDANXq9XpHYGgy0vUCWRtBUpICQSiaQFpNuMsBi0cG9t812PWisqUabajJiaY4JPMWDx5ioEln4EVaRuIA+b01E97GT40scgYB8AY81amMsWIHn129ukecZ3Bc1OMEGv1WBtmQuLS8MoSdkdkckXA8MOB2wZQDQMlCyFetEbmH3D4Zg2LAnLFi/Arbfe2hWnRNLLkQJCIpFIWoBJT/eCCU5fw2BKErL2gSdzDwzNtGNQshb+qBp/r1wP3fpv6uMdWGCqZshJ8GbtDn/yCOjdRTBVLBYiorm4iFimBvtyMAtkSWEtlha7UWEdiui4M4BxpwIZI4WISdIE8NRl/8HVU/RY9cmj+O3L91pc4VIiaQvaNn1KIpFIeiEZCUYU1XjhCYSFNSIeVqHUOwswpX8Upd5auP0eLPjnd0ywpCLYd2p9XwxH//8gbEwVf7N3BtM8mbmhd22GM+8g0bSrMWq6NSx62CJaVLuDqHQHkWE3oG9SBpKGHwHVoAOBsuUYbk7G1A0boJ+/AH89cxHGmrbANmhPIHM3QG/psvMk6R2olB6W9+N0OpGQkACHwwG73b6zd0cikfQw1pa6sKnKjewE8zbvafy1SF79JhwuD95YFUJqtBI5SWaMPHAGQilDGyxrqF0PW/53MDjzoXcXImDLE+mbzn6HIGTL2e4+0BpR4w2KFFEGXTINlC3IVQB8pWtx/emHwhbYghFDB+Pkk0+GSqUBUgYCmaOAlEF1AZkSSTvHUCkgJBKJpBU4fCEsKqiBWa8Vbo3GGKtWwp7/DUpdQby6SoU8VQkGZiRi4PTzEbFmNVhWHXSJZY3Vq2CsWYeIzoKAvb9wc3iy9xRWiu3hD0WEkNBoVMi01QmJRLMOy5cvx16TJ2FwQgj3X3EyDpw04t8PMQgzfUSdVcKWVZcmKpFsRQoIKSAkEkknsrLYgaIan4hN2AZFgT3/Kxir12C9Q8Gnq73IVldhWG42cg68EFG9rdHyUZjL5sO65VcYHPnQ+KsQFNaIwSI4k/UkdgSFRK0vKGpWZGwVEm+/8jwuvfRSkV46/5dvMCpta2GqgPvfD5pT6mIo+DAldsSpkXRzpICQAkIikXQitd4gFmyugd2gEymejVFFAqIHhtZXiYVVWszbUIFklQu7DR6EzH3PhqLdVnhoPaWwb/4ehpp1MDg2IqoxCJeGN3MPuGmNaCI2oikhQQsJSbXqccOFp+Pbr77AkCFDMH/+fNgsFqBmk4iXQOVaIBKXUZLQF8gYAaQNB/TbumckvQOnFBBSQEgkks6Dt83VpU5srvY2GQtB1AHGQ7wDddiHH8uM2FhQAIsqgOGDh6DPvmc1LQiiEZjLF8K6ZS4MjvVCgIQsWfAnDoI7Zxr8ycNb5HIIRepiJGqqq3DxCdNRXlKM//vvyXj7rTdFnQlBOABUrKmzStQW/JuxoVIDyQPqxETKYEC7fTeKpGchBYQUEBKJpJNhPYiFBTXQqlWwGXVNLqNzFSFp/YdCGHxamoyqzatgUgUwcNAw9N//rGZjHCg+7Jt/hKlyCQzsnxENI2jLgTd9PFy5ByBiSm3RPoYjUcydOxdXzDgG0UgED876Hy48/1yRGtoAFqYqXwWUrwBccXUpNNo6EUEXB0WFDL7s8TilgJACQiKRdD75lW6sLnUjK8EoUi2bwli5HPaCunbbH1blwbXhLxhUQeQMGIEhB54lajg0iaKINE9r0S8iMFPv3iLcGkF7P7j77FXn1tC1zNXw/JMP46kH74bBaMSzH3yH3cePFrESiWZ2Gm203+z+SasEBYWv5t/XtQYgbSiQPhxI7McmIS09TZJuhBQQUkBI/r+984CPuj7/+Of2SnLZCwIJYYsgSxTBbbEoraP/WjfWirP9122LLY46sGgddddZrf5ri4qguEBRUXGAICMQEkb2vNzl9vj9X89zuZAJueQSMp736/V7XW7md1/CfT/3jM8jCH0ADdjauM8Grz+EZEvnoX4SAeQ8qajUeNs2Cg0F66BXBZCeOwmTTrsUKk3HEQwmFORIRPz+T2CsL4DGU4eQLh5eax7sI0+DK2M6oD7I8+klQiFcfdG5+PKztRg1Zjwefm0VTCYLd2xkJZp41ke7Wg7aGhzl4dHi1dtbF19SjURqk5iw5oiYGKJ7aK/+q9fV1bEvO51EYmIiLr/8cjQ2tvgj7IATTzyRc3Qtj6uuuqo3T1MQBKFbGLQajEwxw+MPcN1BZzQOmwtP8jiolBB+nrQHqRNPQEDRoGrPj/hqxdMI+NrPxGhGrYE7fRqqp1yDuvEXwp02hXZ3HhGetvkZpH/3Nxirt3A3R6cvoVbj3keeRmp6Bop27cALy+5gwdPoCeDHEhu+3VOHXZUO1Dt9CIUitRAqICEbGHMqQPbZR10AZE8Nt4H6XEDZRmDTv4Av/w7s/ACw7RPnyyFGr0YgfvrTn6K8vBxPP/00/H4/LrvsMsycOZPHzx5MQFDF8F133dV8m9ls7nI0QSIQgiD0JTQ5c0uJrckd8iCdEqEgrMWr2EBKUevwsXsMyjd/BC0CUCUMw8wFVyE+vk2LZweo/U6YK77hiZ5UH0EdHyGdBZ6kcbCN/jm8SZ0XWn79xadYdP5ZXAT6l789iZ/94nz+2ekNwu71Q6NSNUclks36Dn0ueJS4bU94rHhNAeBvIX4MceHIBKU6JDIxIOkXKYzt27dj4sSJ+OabbzBjxgy+bfXq1Zg/fz5KSkqQnZ3dqYCg8bQPP/xwt36vCAhBEPqaOqcPG/d33tbZTCiAxN0roLfv4QLKbzRHYdeXK6EOeeA3pGDyGVciOz29S7+ThUT5V0jY+yHbYKtCfigaA3dq2Eaf3WnHxlMPL8UTD94Ho9GEV1Z8hLETjmi+j6IoNOvDEwiyUVZqvB5pcVQroePhXu3fTxCoJzGxPdwWSp0dEcg6Oy0iJkaImBgg9AsB8fzzz+PGG29Eff2BIpxAIACj0Yg33ngDZ599dqcCYuvWrayKMzMzsWDBAp4sR1GIriACQhCEvoY+r3ZVNqKohgoqTZ0WVDIhPxIL34LesR+K1oBdcUfj+3UroHgdcGvikXPCZZgydlSXfzeNBDdXfgNr8XvsHwElCEWlgdeaj4b8BXBlHh1uzYz8+lAI11z8C6xftwa5+WPw2so1sMTFt3s/Ll+QO01CZIxl1PHsjWSLAfFGLRtWRSUmKO1BQiJ1LJBEBZjSzdFf6RcC4t5778VLL72EgoKCVrenp6fjzjvvxNVXX93h85555hmMHDmSIxSbN2/GrbfeiqOPPhrLly/v8PFer5ePlm8+JydHBIQgCH0KmTht2m+D2xdEapzhoI+lMd+JhW9C11gKRa1FeepsfL3uPXgctfAoegQmnI0zjz+mfYfEwQgFYKraiMSilVxsSUIiMimUhnTZc04Jd1JQxKS2Br88/XhUVZTh9AXnYOnjzx3wh+ggRUNCotHrh1ajRqKJxISRh3tZ9JqOnxcRE+Qz0TbNQeeQOgZIGw8k5YVbRYWhISBuu+02LF269JDpC9rwuyMg2rJmzRqccsopKCwsRH5+frv777jjDn69toiAEAShr6l2ePFDiY1TGR3WD7Qk5Ie1aFU4aqBSw5Y5G99+9xWqS4sQVNTYkzIX586fj5RDiJF2KAr0tkJOlZirvoUqFHabDOniuP2zIW8+ApYsbPr2a/z6f87gyPAf7/4rfrXwikO+dCTF4Q2EYNCpkWTWIy3ewCkOSnl0/D6D4QLLiJigAswI1H1CQ76oboIumwSOMEgFRHV1NWpraw/6mFGjRuGVV17pVgqjLU6nE3FxcVw/MW/evHb3SwRCEIT+An2cFlY1Ynd1F1IZRCiIhH0fwVi7la82Zh+LwuK92PXjBgRCIWzXTsSxp/4C03OTu3U+Glc1EotWsLOl2h/ugKOIhydlIuwjTsPzK7/CvXfdAa1Ohxf/+x4mTw3Xq3U14uLwUPdJEEa9hrs6qF6CpoJ2Kp6oANNeAlTvBKp3AF7HgfsorUHpDUpz0MRQKsgUhnYRJfmvT58+nW/74IMPcPrppx+0iLItX3zxBebMmYMffvgBkydPPuTjpQZCEITD7Q2xuaSBv6mnxxu7FDGIK/2MB2oR7tTJqPaosPWr93lAVnEoE6FxC3Dx3PGHjmp0RtDHXRsJez5gQypqA6Woh9+Uhpc+3o6n392IBl0G/rXqU6Skda2I88DpK3D7g9wSGlAUmHRhMUFpnIOKiYjPBEcmdgKuugP3cQvpsLCYoHSHuXsCShigAiLSxllZWYmnnnqquY2TOjIibZylpaWcnnj55Ze5zmH37t18H3VqpKSkcA3E9ddfj+HDh+PTTz/t0u8UASEIwuGmpjGcyojTazsP7beBjKZoIidtrFy3EJ+Pog0rUVhhg12xYIN5Li467VgckW3t/okpIRhrtsDaNEKcOjmCwSC+/n4zfixxoMI0BgvvegHBxO7ZVrcUE/6QArNegySLjsUEFWJa2lpoH3gi4Ko9ICYcFa3vt6QeEBMygnxoCAgykrruuuvwzjvvsJHJueeei0cffZRTEsSePXuQl5eHtWvXcvfF/v37cdFFF/Ese0pdUCqCUh233367+EAIgjCgKKxycDqDLKOp+LAr6BuKYC1+l4ssg/oEOLNno2H7Wny/sxgObwjrQlMw8sg5uOiY3O5HI1pM/4zbvxZxFRvgr92DHZu/hcsbhDl7HMbOOQuelAnwJo6GL55aMLXdFxPesMkWRSbIOjs1nsSEludxdFa4CU8DUFMYrpmw7W9tkkWpDZrPQWIicaQUYQ5WAXE4EAEhCEJ/gDbNbWV2VNjdyEowdb5ZtoGsqhN3vw2Np54Np6jwUanfi+1bvuU20YJQDn4wHYPLThiPY0al9Pg81T47TFU/oObzF7Fr/btIs6gwfvx4JAwfj4A5HQFTKrzWUTxanOZwkNdEtNA24/GH4PQF4AuEoNeGB5BRASalOUhMdCqy/G6gdnc4MlFXBATD48qbizCT88I1E3SQ94TQI0RAiIAQBKEf4PIFuB6CvtnTZhmNtwNFIshwiiBTqIAxEfbtn+DbPbWo8OrxfmgmhueNw6K5+VG9dqeEAvjvgzeg/PPXcGSWAT87/WQk6YNcdBkwZ7CQIN8KX1wOiwmaxRHSJ3S7ToTcLylCQdNMLU2mVVazjlMdnZpxBQPh0eO1FJ3Y1boIkwQapTcoMkFiwpImqY5uIAJCBIQgCP2E2kYvtpQ0sJNjgungQ69aoYRgqdgAS/mXXCMQNCbBmTED+rKvUVC0D9sqHPg2NBYbNZNw9vRcnHVUNs/m6AlUD3H1xedi36ZPMW9yFv78u0thUXmg9dRB42tASGvmqASlV4iAKQ1eay58CXnwx2W3MqzqKjRy3OkjMRHgORwmvZajEpTqINMqqiPp0LiKizArwmKidlfrMeSEMQFIzg+LiSRKdUSx9kMYuwgIERCCIPQf9te5sL3czr4JB7W67gCdowTWPe9B7XNwYWNj5ixovHb4SjZiw5467HAY8X5wBhCfictm52LO6NQup0s6wlZfh/PPPAml+/bi+BOOxzN/XYK4+m3QuquhCrih9dRDFfRA0RoRMKayJTfB0Yn4EfAmjORUR3eiE+R6Se2hFJ2gFJBW2xSdiNOz+Io/mL+Gxw7UUaqjMDyrg6IVEaiGg0QEC4pRgCmpu8sz6LGLgBABIQhC/4G+We+sdGBPrQsZ8YYuF1VGoI2bZl7QIC6CujQ8iaM5QrG/shbflzTgM88ofB2agDGZSVh4XB4mZnX/82/n9q24+KyfwO1y4qLLr8YtS+6F1lUJU80WdrmkIk8ywtL67FBUWihqDUcnWkYggsbksJiIH8HnS4IjWkhEOL0BTnXQVkV+E4kmPbeJUt0EdXXotR2sJdVJkHkVRycKw+KiJeYUIHlUuH5CCjFbIQJCBIQgCP0MKh6kKER5gweZCcbobKoJ8lio2cyeEbSBU22CM306tJ5aaOt2YUeFHevLFKz2T0Up0jAzNwkXH5OLvNTuFRZ+9N4K3LDoEv757gcfx89/eSH/TL/bUL8TprptHB2JnJtK8SGojecoiTrobd05QZ4T5gz4EkbAFzc8nO5Q67rV1UFW4Z5AiCeHmgwaJJl0SCRBoSdBoWkvzmiLc9aEoxNUjNlQ0vrcSDyQiCBBQdba5DkxhGsn7CIgREAIgtD/oPD81rIG1Dh8yLIau5VqUHsbkLDvQ+jt+/g6bcbUJWGu2gSvswFbShuwojoNnwUnwQsDThibhvOPHoHsRFPUv+uJh+7DU39bCp1ej+ffWIUp02a2ul/jscFYtw3G2m3Q+A58yw/qLByBoC4SrbeeO0pavwkN/JYsLsj0xQ/jn6MVFDSjg8QEFaoGQgo0GhXM1Cpq0XGUgqITNKujnaCguRxciLk73NXRshCTMFrDkQkSFCQsdNFHTgYyIiBEQAiC0E+hkDxt8mS2REOpugWF82u3IL5kXTidoFLDnXIEEPLBVFcAu8eP70o9eKU6Dz8qeWypTULilzNyMDypa5ONI5M7b7zyEny8eiU7VP7rnY+RNSynw/PRNe6HsW4HjPU7w+fUhN+SAX9cDkIaI0dL9I0l4XqOtoLCnAlf3DBOd5CgiDblQekOEhQUpQgqCkd4WFCYdbCaw4O/yNSrVcqDoxPVYSFRVww07A/P7mjliJkdjkyQzTb9PMgnidpFQIiAEASh/9Lg9uPH0gZ4/aEetWCSh0N8yacw1O9qHpjlTpkAg60YWk8N6pw+fFquxQvVY1GJZFC8Y+6YVBYSI1O6ltpwORtx6Tmno2DbjxgzfiJefvP9duO/WxHyw2DbDVPddujtew+kC1QqTl94E8ewhbbWWwu9o4SttdsJCpWK20ZJTPgs2SwouCgziogNCQqK+JCoIIttSnkYdWr2n6AaCirGtOi1fFtzJCjgC4uIiKAgd8yWaPXhqASJicSRYYfMQZbuEAEhAkIQhAHQ3rm1zM4FllFP3GyDvmEP4vevgcZra05r+E2pMNXt4GgACYl3q5LxQkUuGhGOQMwYmYRzpg3HpOyEQ6ZSKspKcMGCU1BTVYnjT5mHR577FzSaQ38TV/ldMNp2cWSCRpcfuEMNX3wOPElj4bXmQxXyNYsJelzkfbSExJE/Lgv+JkHhN6dH5ZDJKQ9/kEUF1aPQWzZo1TAbtEgyk5lVuMOD7Lep5bbZEZOERD0de8OmVi3RW8LdHRFBYUrEQEcEhAgIQRAGyMwMcqukzY3mRfSIUACWim94KJcqFHZr9CbkgcIOhoZivl7nDuG/NcPwckkWfAhvvmMz4nDO1OHsanmwws4fN32Py34xH16vBxdefhVuveP+qGs3KL1hsO2EzlnZsZhIHA1Fa+IZHSQkdI1l0DnLoHNVtS585BfUcCSDxETAnAm/JRNBQ2KXIwLUMkoRIE8gyMZWtBOS3wS12cYbyIsiPMeERAXZcJPhFRorgfo9TemOEl7zVpCASBwRFhN0SV4UAwwRECIgBEEYQJGIbeV2+ANKTBwlKa0RV7aeCxsJ6tbwJuRC43NA5wpv3LaAHm/W5+KFYiu8wfCGS7/7zCOzcNrEDA7zd8QHq97GTVddyj8vvudBnHfJ5d06Ryq+NNQXsKAgf4nWYiKc5qDIREjfNNI75GfRoXOWQuesgM5ZDrXf1e51Q+RNYc5gMcGX5swDr9FFUyvq8PD6SVSEWHzpNCo26IprISoMOg1MGgV6Z3lYUFBRpr28vcghvwkWFHTkhAs0+zkiIERACIIwgKAUw7ayBt60ujQCvIvDsuJL1zW3WpLhE22oGk8tNH4n39aojsfb9tF4cZcRdk+4eJCKDE8al44zjsxEXmr7zffZxx7EYw/czSkMSmVQSqMnUIcGRSVYTLhaigkVRxcoKuG1jkbQ2CI9oChQ+xqaxEQFdK4KaF1VULWNCERSH5aMJkFBl+kI6SxR1VJEIhW+YFggaJtEhUmnZtdMEhVGVQAmdxn0jlJoGvaGoxVtt1eKUFhzwmKCLklg9LMaChEQIiAEQRiIIqLczt9+0+IMPXKTbEZReMInRSQi3/RDGgOChiSuM1AHPXybx5CKtZ5xeGmXDsW1B77Zj8uIx08nZWLOmNRmm2zaMpbcdB3e+verMJrMeOGNVThiytSen2skMmHbxYZZFGVoCQ/14hkc+SwG2m28oSC/R4qykOkVCQvq+mi3idND9fFcQxEwpYcvWVTEdXkzJ1Hho0hFIHwZgsIFqiS+DBoNzAYNrNoAzN4KGBtLYXCWQuushKbty1MNhXV4WEzQZVwG5VFwOBEBIQJCEIQBiM3lw44KB3dp0BjwqM2mOkNR2Pwprnx9sycDeTQEdXE840LVFHqnzXSTehJeKzLgq+I6rs0gKHx/4rg0/GRiBkcl/H4/frvwPKxftwbJqWl45a0PMXxkLmIJdWZQN4ehoZALLFumByiC0DwhND6nUw8JKiClyITWXRVOgbgqofHWdywqdOYmQZHWNIU0PeqaCl+ToGCBESRZwVkQ6DVq6FV+WP2VSPBUwuIph56iJgjxvzEd1GrL8zqoVTRhWFhQ0M+66P07eoIICBEQgiAMUBq9ARRU2FFt9yI9wXigIyAWKCEY67azBXazkFCp2aNBEzgQeaANtMw6De+UxmH1tkpUObzN9+WnWXDahAzMGGbCby/8GXZs3YKRefl4+a0PkJTc8/HinU0npUJQFhP2va18JkgIkYjwWfO6NCFUFfRC664JRylIXNDRSaSC0j4U+aD1oK4WEhUBU0pUplchRWFBQTUuJCroZxJmKiUAk6cacd5ymN0VsLjLYVD5WWxQEILaTqmoU21JhcY6DJrEYWFhQVNGezFKIQJCBIQgCAMYajWk2Rml9W4ubuzplM12KCGOSJCQoM206Uaea0EbbKQ9ktwkHekz8JUzEx/sqMHXRbXs+khQV8KULDO++teDKPtmNaYcNQ3PvPYWTKauG1V1i1CAzagMDUXQ24paOWC2nhCayy2fXTJ+orke7poDgsJdzdc7qqlgjwpjclhYmNKajtSoUiARSEiQoAgEFfgDQcBF51AGo6sCRlc5DH4bRybCB9VeqKHVGaBKyAqPLrdmQZ0wHNbE5I4nlnYDERAiIARBGODQxrK7qhF7ap2wGvWIM/bCwCdKbdgKufUzUnNAmyZtCuqQnyMTtCnS+G5XxjRUmsfik912fLitggeDRQh5HHBu/wyjTW48/tBSGPThCZ29jqLwRq+3F3GEgt9Diy2NIgi+hJHchUKXUU0IVUIcpQnXVURERXWH3R9ESGtqISpSm49ovCraEvQ6oXaUQdNYDm1jOReLKgEvv8WIVqH0R9KM/4E1dwpigQgIERCCIAwCyGRqf70Lu6sboYaKHRRjUlzZkRW1swzmyu9gaNjdNBwryFNAVaEg10rQN3ka2e1OORKu9KnYbVdjbUEVPt1ZzQWgEbR+J+bPGI0TxqZjTHpc75xvJ9D5UoqDxITevgfqQGvjJ0o/+OLD48ZpBke08ze4+8PvbBYT2qZIBY04b9fC2S5akcrjzzlaEaWrZmtRU9fceUKCyW2rQPKJ1yI5LQuxQASECAhBEAYR1Q4vCqscsNP8jFgWV3YAfes2V29kHwmuNaBNy2vjQsug1gxFFx7b7Ukax0LCa8rA5hIb/v3pJmyu9EFtPNAimR5vwOz8FMzOT8W4zPhwoWBfoYQ4HcFiwrG3XXSCBBHZZPOE0PiRXOfQchx5VIQoBVIbFhN8NEUrAp6OT41rK1pHKgLGlG6NPK+ob8C03HSkxKj9VwSECAhBEAZhcWVhpQMVdi+SzeFZDr0JFS7SpE2a8hmxliZxoQ66uXCRNjwe023JhDttKjxJY7DireW457F/wDLheCRMmIug6sA5UvTk2FEpmJWXjEnDrLEtDu3i+9E79nFkgiaZtq2doOhKeDooCYocrv/okUeDEolWRARFk7jw1rUe2NUCShW1EhWmVG65PVgdR3mDG9NHJvXYDj2CCAgREIIgDEKoRXBvrRN7a11cxNhrKY22XhL2vTDVbObCRfpmr/Y3Quup48JLCsuHtGZ2fKSJoP98/1vcseQOqLQGnP+Hh6DLnYGvi+t4DkUEmow5fWQyjhmVjKkjkrhNtE+h4VpeW5Og2At9436oAgc6TSKtotzdET8c/rgRCBqssTF9CgV57UhMaDw10DUJi3YDxSKoNQgYWqRBmo5I0aYIiBgiAkIQhMEMfWRTSoPqIsgvgpwr++rbPG1yptqtMNb8yN/gaeYGpQk0/kb+9uw3pvLEylWfb8YDz7+NnbUhLL73IZx9wUJs2m/DV0W12FBcB5vbf+A1VcAR2VYe7jUzNxnDk0x9WjfRMt1BqQ6KTlC6o20HBplP0TRRqp2g8eTBKDwiuhohaY5SeCKpkJpWLautzkdrRNCUiqpQAnKPnI3kjA7GrHcDERAiIARBGOS4fAEUVTtRanPzWGqyVO4zlBBvtMa6rTDaCoFgAFpvPW/CBHkmfPHtZqxbvwE/VAQx7+p7cfr5Vzb7IuyscOCr4lps2FOP/XWtuxqobmLaiCRMG5mEKcOtbBPd54QCLCL0jv3cMsr1E23SDiGKUMSRmKAIRTbXNMTclpotu+3thUWLok1KbSXPvhRJw8fG5FeKgBABIQjCEIB8BMpsbm71dHmD7BlxOGoLaFw31UtQdwAVDpJJE3ULbNtVjA1bdsHmAabNvxjjfnJZeOKm5kC4vcLuwbd76vDNnjpsLmlo9pkgqFiU7LSPyknE1JxEjMmI79UC0k7hYV7lTSPHS3jOiKpNhIJqKMh3ggozeZy6JTP6Lo8un0+gOQ3SUFuGvKmnICUpNqPERUCIgBAEYQjh8PhRXONEuc3N39gpGtHnaQAusqxjp0s6NJ4Gvr7724/RULkXNS5g7MyTMXziLHiTxsCdMhF+sqFu0flABlo/ljbgu331+H5vPcoaWncxmPUaHDnMysfk4VaMTLH0bWdHqwhFBY8cj0Qo2qUaqMCUHCxZUGTxJaVBYo3UQMQQERCCIAxVzwj6Nl9U42RBkWoxwKjr3U6NQ/lKGOsLoK8rwJer34B93zZkxqsxbvwEJI2YgKAxhTdVT8p4eJLHs0102xRARYOHayc27a/HDyUNHK5vSbxRi0nZVu7qmJSdwILisEQolHANBQmJsKgo40LTDod4WTJ5yigf1DrawyiFCIgYIgJCEIShXhuxr9aFEpsbKgW8sRyWTTUC+Ug07MXbf7sJtoLPkGFR47Q5M5CbQd/GVdymGDAmsbmTJ+UIeJLHhVsoO0jXFFU3YnNpA6c6tpU3wONvbd5kMWgwMSsBE7IS+HJMejxPyOxzlHDtAqc9nGXQNZaFLcPbmk2p1NxRwaLCTMIis6l9tOvnLAIihoiAEARhqEMf6+QOSbUR1LERZ9Ahwag9LGmNCKFQCPcuvhHfrnoRE9M0+O2FCzB93DBo2BuhngdiU2cDCQqqk/CkHgFP0tgOxQQRCIZQWNWILWUN+LHUju3l9latogS1uo5Oj8P4zHiMz0zgy1httNESngxKY8bLw+kPZzn7RHRoMkWpD3MGiwr6+WAdHyIgYogICEEQhAObLKU1yDeC0hpWk77vPRdaQNvNA3f+Aa8+9xSPub7nzzfjV6fP5iJM8mQgN8eIaVVQH98kJvLhTp3MdRMH63SIRCi2lofFBB31rgPtohFS4/RcmDk2I56LMmm66GHp9FDIaMrRJCYqmqaDVnbYtkmiggRFZMw4pT6CxiSOVIiAiCEiIARBEFrj9gW5W6PE5uJCxWTz4auPoC3nkfvvxPNPPMzXF/3uJlx74x+hc5Pt9G4Y6wpgsO1qISYUHupF38LJdtqVPg3epHHc6XCwUD/9HhJPJCR2VDhQUOHgiEyLJg+G5EhOshmj0+KQnx7HEYtRqZbDsz5KeIAXz7lwVULrrGQXy46mgrIbqDkNVUqi+EDEChEQgiAIHUNRiJJ6F8obPDxCOsmsPywbJW07zz66DH9fdg9f/8WFC7H4ngeh0YTPRe1t4BkWxvodMNVsCbs2kpigGgKVJmxaZU5nC2136pHwWUe2ag09mJCimSI7qxp5XPquqkZO8bSFSkaGJZqQlxrHEYpRaXHIS7X0rddGywJNnrNRFRYVrmou2CQTL0J8IGKICAhBEITOoY98crAsrXejwuHh7g0SEgZt3wuJN155AfcsvpHrI045/Uzc/9g/YDC2HgpFIX1Kbxjqd8FUtZHbJjXe+uZv5RydMCZxvYQ7fRo8ydThkdTlc6h3+lhIkLPnrioHdlc5Uefq2P2RZpDkplqQl2pGboqFuz7IObOvvTciA85ISDiq9yN32qniAxELREAIgiAcGvrot7n87GRJoX66nmjq+4jER++twK3X/QZ+nw8zjjkOD//jVSRYEzufYeGp5egEiQlT3XZoPbU8xjuMqtkh0pN6JJxpU+G35nINQTRQASrVU+yucfIlOX7SGnWEuilaMYIERbKZ0yE5SSZkJ/aNsJAaiBgiAkIQBCF6IUEbUaXdA19AQaJZ16eFhRvWr8P/Xn4hnI0O5I0ei7+/8H/Iyc075PMoOqFrLOHR4+bqTTxpU0NDqSLtkio1D8HyWKkQ80i4045CgBwiuzG2m9pjqRiV6ijItGtvrYsHmzl9wU6FRZbVxBEKPhLNGNYkLGLZESMCIoaIgBAEQegelNqobPDwpkQtkdT+SWZNfeH2WLBtC65b+CtUlpciMSmZIxHTjj426mFfBlshTNWbeOiXzkldDQciB4pKg4ApBV5Kd6SQoJjMhlbdnWGhKApqnb5mMVFS78a+OhcfbVtK2/pVUNQi22pCltWIrEQTshKMyLQau+wiGgwFsWnjRhSW1+LoUWk445Tjm2tIeoIICBEQgiAI3YYK86rtHraSbvT6YdBoeGPT9nJIvqqiHL/79fnYtmUTdHo97vzrYzjznPO692KU7nDXwlS3lQsxDXUF0LmrASXYWlCY0+FNJGvtI+BOnYKgiYyceiaYlCZhQXUmVLRKwoKMvShd1FHRZktMOg0yEgzIIEGRYORLuk5TV9MTDBwZWrN2DZYtW4aqykpo4lPhLd2O7JQEPPLIIzjnnHN6dO4iIERACIIg9BhvIIjaRh9vfJTmoG2VIhK9md5wuZxY/Pur8PF77/D1y6+9HtfdfHvPv10rCnstmKp/gKnmx3CrqPfAVEuGIxSp8FjJyGoC3CmTm1IeqpiuaUWDh0VFeVO0J3zpQU3jwcUFYVAraKwpQ7CxDkFnPZSAD/bvViJQtZvv/89//tMjESECQgSEIAhCzCCTpnqXD1UOD6rtXg7Pk4iIN2h7JSpBXRmPLr2r2SvimLknYunfn0NSckps2yOdFU3pjm2c+mgnKJrcMb3WPLbY5pbRhFGAuncKTX2BEK8xFWxSKokuqxxeVNm9qHR44PC094Mgqt68F+6d6zn1MXz4cBQXF3dbcImAEAEhCILQKzi9Ae5SoKgEbWi0hcQbdbDoNTG3yn7v7f9iyc2/hcftQtaw4Xjo6X/iiClT0StQyoMjFJthqiNBsZvNrdrOrwhpTfDH5YQdMlMmwpM8ESFD3+w16zd8gxv+eAc0lmRo4pKgsSRBm5iJuo+egb+6uPlxa9euxYknntjre+jh8zQVBEEQBhwWg5YPKv6jokvK6Vc3elFu90Gn1nCKI1atoD/9+bkYPW4Cblh0MfYW78Yl58zDH+56AOdecGns53qoVAhaMtFIR+5P+Ca1x8b1E1SQSS6ZNGlTHXDDYNvJR8Ke9zjt4TelhoeBJY2FN3kCvNbcHk/Z7AhHfS0Ctgo+IlANRLCxttXjysvL0ReIgBAEQRCihlIX1DpIR64/GE5x2L1szFTr9MKoJTGh6/E0zDHjJ+JfK9dwXcQnH76Hu277PdavW4Ml9z8Ca1LXDaO6Q8iYCOfwuXwQqoAXhvqCsKCw7YTevo/bRskhkg5Lxdf8OEVjhC8uGz5KfSSOYXOrgDmjx6mP1NTULj0uKysLfYGkMARBEISYQNsJ+SLYXD4uFLR7/JzXJzERZ9T2yO2S6iJefPox/P2BuxEIBJCRNQz3PvIUZh4b3twPC4oCrbMcxtqtMNYXwGDfw1M22w/EUvFwMJrf0RypSBwdHg6m7vr3eGrdXLBgAaqqKLUS3rojXRght11qIHqKCAhBEITDD1lkO7wB2Mlbwt4kJoIhGDUaToF0N82x9YeNuO23v+GUBm2Yv77melx9/a3QGw7PmO62qAIe6BuK2CVTbyuEgaaMeuqANgOxqIU0RKLCkhUWFYmj+ZLaShVtazvvllAL5y233NL0IkqzgFA8Dr5JujB6gAgIQRCE/gVtMyQmGlx+blWk2gmvPwitWs1iwqTXRGVW5XI2YumS2/Dm/73C1/PHTsCdyx7D5Kkz0O9QFKh9dhjrd8JAR0Mxu2dqfA3tpmzShE2y4qbIhC9+BDzWPPjjRyBoSkXAmNycAunIB2JYqhUPP/yw+ED0BBEQgiAI/Rfacly+IEckSEyQvwRNyaSNyKwLRye6OkPiw3ffxj2Lb0JdTTVHIy66/Gpce/NimM0W9GsUmrBZw5EKY/0utuDWOcu4nkIV9HYgKuIQ1MfBHzcM3oSRCFiGwWtMxqZdpdhW5cXM/AxxoowFIiAEQRAGDh5/kNtBKdVB3RxOXwCBgAKtRsVeE+TMqKHBEp1gq6/DA3f+ASv/+398ffiIXNx211Icf8o8DChCgbCooMmjDUXQNzSJCr8Tar+ztYOmWs+RiqDOAgdMSJh9OZJGTYvJaYiAEAEhCIIwIA2rSEA0eshrIhKdCCGkKDBo1ZzqoNqJjtIdn639EHffdj0qykr4+pyTTsPNf76Hh3MNWEJ+FhU6ZwVHKTj94SxnQUHtpHT4/H6oT70dieO75/vQFhEQIiAEQRAGPGT77PTSEWBLbUp7UMRCgcLzOUhMGFtEKGia59OP/BWvPPckAn4/tFotLrjsSiz635s7HxE+UEWFq4qdND1VhUif+2skp2XG5OVFQIiAEARBGHSQeCAxQaKC3DAdXj88FKGAAq1axekOEhSle4uw7O7FWPfR+/y8eKsVl15xHS749ZWIix9c+0K5jPOOHSIgBEEQhl6Ewub2we4O8JyOYDAEtUqNTV9+gicfWILiXQX8eGtiEhZe9Tucv/AKmC1xGAyUi4CIHSIgBEEQhiaBYIiNrKirg8aQ17v8cLi9+GjlW3j5iWUo3VPEj6N0xi8uXIhfLbwCmVnDMJDZXrwfp0wdIwIiFoiAEARBEAja3ryBULht1OXB66+/hscfXIqSveHBU2qNBsf/5Ez88tJFmD5zFgydFGj2N3xeL9t6L3/tZWxY/xk2bt2BSWNHxeS1RUCIgBAEQRA6wO8PYPnbK/DYo4/gi8/WNd+ek5uPkxeci5PO/AWyh4+AQaPmOR50dNWXojehrbqwYDve/vereOe/r6O+7sAArSeeeQ5XX/HrwSMg7rnnHqxatQqbNm2CXq+HzWY75HPoVJYsWYJnn32WH3/cccfhySefxJgxY7r8e0VACIIgCF2B9qdHH30Ur7/+Otxud/Pt02cdi7mnzseMOScjY+QoBII0rJMKNdU8z0PfJC40B/GniAU0/+PHH77HmtUr8fHqldhbVNh8X3pGFs4670IcN/9/cMZxUwZXCoOEQGJiIkpKSvDcc891SUAsXboU9913H1566SXk5eXhT3/6E7Zs2YJt27bBaOzcG7wlIiAEQRCEaHA4HFi+fDn++c9/Ys2aNfxlNsKIkbk45bR5mDl7LsZMmgJLcibP9PAHFISUEBRFxREKjlb0UFjQ7y0u3Invvl7PxzfrP0N11YHR3Tq9HnNOPBXnnH8JjjvxVG5THdRFlC+++CJ+//vfH1JA0GlkZ2fjxhtvxE033cS30RvIyMjg1/jVr37Vpd8nAkIQBEHoLvSllwZSvffee/jkk0/g87WerJmZmYkZM2biiMlTkJM7Clk5I5GaPQI6S2KzsAjytqpAq1JD10JYUKspWW7TNNH62hqU7t+Lwp07sHvndhTtLMCObVv49pZQt8jxJ/8EJ59+JuacdGq7NtTDKSC6Pke0l6HxoxUVFTj11FObb6M3MWvWLHz55ZedCgiv18tHyzcvCIIgCN2BxmHTl146GhsbsXbtWqxevZr3oc2bN/M+tXLlO3y0xGw2IzEpCdYEK/tOWOLiEQgp8Pn88AcCXHvhsNtQX1sNe31dqyhHSwwGIyZPn4nps2Zj2tGzMXXGLBi6GIHva/qNgKB/FIIiDi2h65H7OoJSHnfeeWevn58gCIIwtIiLi8OCBQv4IFwuFzZu3Iivv/6aU+u7d+/mg6IWdB8dZaWlXXpttVqNlLQM5I4ZhxH545AzaixGjh6HMROPhMVo5LQIHVrt4S/gjImAuO2227hO4WBs374d48ePR1/xhz/8ATfccEOrCEROTk6f/X5BEARhaEBRBirup6MlHo8HpaWlnKqn0H/kkkQCTcikWgW6pLpA+lJMR2pqKlQqNac9qNXUF6DLILttNnrCXhbuQAB2TyQlAqhB9RbhmovwoaJp4QNDQFB9wsKFCw/6mFGjuteLSnklorKyEllZWc230/Wjjjqq0+cZDAY+BEEQBOFwYDQakZ+f373nqsP2220JUfqDxIU/BG8wyAIjbOUdhMvbJC68Cgw6NddV9HsBkZaWxkdvQF0XJCI+/vjjZsFA0QQKFV199dW98jsFQRAEoT+iVqtaiAtdx+IiEGL3zQTj4alG6LXkyr59+7jHli6DwSD/TAcVpUSgVMebb77JP5OCoqKVv/zlL1ixYgW3b15yySXcmXHWWWf11mkKgiAIwsATFzoNrCYdd19oD5PRVa/Jlj//+c/s5xBh6tSpfEkVrSeeGJ5bXlBQwHmiCLfccgucTicWLVrEOaQ5c+Zw9WtXPSAEQRAEQegbxMpaEARBEISo99D+2x8iCIIgCEK/RQSEIAiCIAhRIwJCEARBEISoEQEhCIIgCELUiIAQBEEQBCFqREAIgiAIghA1IiAEQRAEQYgaERCCIAiCIAzccd6xIuKLRWYYgiAIgiB0ncje2RWPyUEnIBwOB1/KSG9BEARB6P5eSo6UQ8rKOhQKoaysDPHx8TEbcUqKjATJ/v37xR47Rsiaxh5Z09gi6xl7ZE37/3qSJCDxQIMs1Wr10IpA0BsePnx4r7w2/QPJH31skTWNPbKmsUXWM/bImvbv9TxU5CGCFFEKgiAIghA1IiAEQRAEQYgaERBdwGAwYMmSJXwpxAZZ09gjaxpbZD1jj6zp4FrPQVdEKQiCIAhC7yMRCEEQBEEQokYEhCAIgiAIUSMCQhAEQRCEqBEBIQiCIAhC1IiAaOLxxx9Hbm4ujEYjZs2ahQ0bNhz08W+88QbGjx/Pjz/yyCPx7rvv9tm5DsY1ffbZZzF37lwkJSXxceqppx7y32AoEu3faYTXX3+dnVnPOuusXj/HwbyeNpsN1157LbKysrjyfezYsfJ/v4dr+vDDD2PcuHEwmUzsqnj99dfD4/H02fn2Z9atW4cFCxawKyT9/33rrbcO+ZxPPvkE06ZN47/P0aNH48UXX+y9E6QujKHO66+/ruj1euX5559Xtm7dqlxxxRVKYmKiUllZ2eHjv/jiC0Wj0SgPPPCAsm3bNuX2229XdDqdsmXLlj4/98GyphdccIHy+OOPKxs3blS2b9+uLFy4ULFarUpJSUmfn/tgWdMIxcXFyrBhw5S5c+cqP//5z/vsfAfbenq9XmXGjBnK/Pnzlc8//5zX9ZNPPlE2bdrU5+c+WNb01VdfVQwGA1/Ser7//vtKVlaWcv311/f5ufdH3n33XWXx4sXK8uXLqVtSefPNNw/6+KKiIsVsNis33HAD702PPfYY71WrV6/ulfMTAaEoytFHH61ce+21zdeDwaCSnZ2t3HfffR0+/pe//KVyxhlntLpt1qxZypVXXtnr5zpY17QtgUBAiY+PV1566aVePMvBv6a0jrNnz1b+8Y9/KJdeeqkIiB6s55NPPqmMGjVK8fl8fXiWg3tN6bEnn3xyq9to8zvuuON6/VwHGuiCgLjllluUI444otVt5513njJv3rxeOachn8Lw+Xz47rvvOGTecp4GXf/yyy87fA7d3vLxxLx58zp9/FCjO2vaFpfLBb/fj+Tk5F4808G/pnfddRfS09Nx+eWX99GZDt71XLFiBY499lhOYWRkZGDSpEm49957EQwG+/DMB9eazp49m58TSXMUFRVxSmj+/Pl9dt6DiS/7eG8adMO0oqWmpoY/AOgDoSV0fceOHR0+p6KiosPH0+1C99a0Lbfeeivn/dr+ZxiqdGdNP//8czz33HPYtGlTH53l4F5P2tzWrFmDCy+8kDe5wsJCXHPNNSx0yQ1wqNOdNb3gggv4eXPmzOEpkIFAAFdddRX++Mc/9tFZDy4qOtmbaGqn2+3mOpNYMuQjEEL/4/777+eivzfffJMLsYTooXG8F198MRenpqamHu7TGRSEQiGO5jzzzDOYPn06zjvvPCxevBhPPfXU4T61AQsV/FEU54knnsD333+P5cuXY9WqVbj77rsP96kJXWDIRyDow1Wj0aCysrLV7XQ9MzOzw+fQ7dE8fqjRnTWNsGzZMhYQH330ESZPntzLZzp413T37t3Ys2cPV3C33AAJrVaLgoIC5OfnY6jSnb9R6rzQ6XT8vAgTJkzgb30Uvtfr9RjKdGdN//SnP7HQ/c1vfsPXqaPN6XRi0aJFLM4oBSJ0nc72Jhr1HevoAzHk/3XoPz19m/j4449bfdDSdcp3dgTd3vLxxIcfftjp44ca3VlT4oEHHuBvHqtXr8aMGTP66GwH55pSi/GWLVs4fRE5fvazn+Gkk07in6ldbijTnb/R4447jtMWESFG7Ny5k4XFUBcP3V1TqnVqKxIiAk3GNEVPn+9NvVKaOQBbj6iV6MUXX+TWl0WLFnHrUUVFBd9/8cUXK7fddlurNk6tVqssW7aMWw6XLFkibZw9XNP777+f27/+85//KOXl5c2Hw+E4jO9iYK9pW6QLo2fruW/fPu4Muu6665SCggJl5cqVSnp6uvKXv/zlML6Lgb2m9NlJa/raa69xC+IHH3yg5Ofnc6eboPDnH7W200Hb9UMPPcQ/7927l++ntaQ1bdvGefPNN/PeRK3x0sbZB1C/7IgRI3gTo1akr776qvm+E044gT98W/Lvf/9bGTt2LD+e2mZWrVp1GM568KzpyJEj+T9I24M+YITu/522RAREz9dz/fr13LJNmyS1dN5zzz3cKit0b039fr9yxx13sGgwGo1KTk6Ocs011yj19fWH6ez7F2vXru3wczGyhnRJa9r2OUcddRSvP/2NvvDCC712fjLOWxAEQRCEqBnyNRCCIAiCIESPCAhBEARBEKJGBIQgCIIgCFEjAkIQBEEQhKgRASEIgiAIQtSIgBAEQRAEIWpEQAiCIAiCEDUiIARBEARBiBoREIIgCIIgRI0ICEEQBEEQokYEhCAIgiAIUSMCQhAEQRAERMv/A+obCssnB+goAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 14) \t Best Value: 1.0779572447975334\n", + "Early stopping at epoch 5647 with loss -0.04839443149730904\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 15) \t Best Value: 1.0779572447975334\n", + "Early stopping at epoch 6767 with loss -0.0955379474696385\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 16) \t Best Value: 1.0779572447975334\n", + "Early stopping at epoch 5970 with loss -0.22222854543641746\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 17) \t Best Value: 1.1935042208215094\n", + "Early stopping at epoch 9089 with loss -0.15552467146204463\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhAAAAF2CAYAAAA/RaFTAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAA5UVJREFUeJzsnQV4U2ffxu+4p260tBR3GUyAbczYmLvLO3d3eefuyvzdvrm7GwwYAzZsuJeWujeN2/mu+ynp0jYtLbS0lOfHlYsmOTk5Ofbcz19ViqIokEgkEolEIukA6o4sLJFIJBKJREKkgJBIJBKJRNJhpICQSCQSiUTSYaSAkEgkEolE0mGkgJBIJBKJRNJhpICQSCQSiUTSYaSAkEgkEolE0mGkgJBIJBKJRNJhpICQSCQSiUTSYaSAkOww//d//weVSoXNmzc3vnbAAQeIR2dxzz33iO+QSHbmuRRZtrKycqdsU1d/j6Rno1KpxLmwqyAFBIBjjjkGZrMZ9fX1rS5z5plnQq/Xo6qqqvFARz8sFguGDx+OBx54AG63u8lnzz33XFit1nYNwgsXLuzw9vfr16/JtqSmpmK//fbDF198gV0J7jdePL///jt2F/hbm59LrT26mujv0mq1SExMxPjx43HNNddg1apVvfq4PvTQQ/jyyy975XHd3Vi+fDlOOukk5OTkwGg0IjMzE1OnTsXzzz/f3ZvW69B29wb0BCgOvvnmGzHgnnPOOTFvgF999RWmTZuGpKSkxtd5UkaWdzqdmDNnDu688078888/+OSTT3bqbxg7dixuuOEG8XdxcTFeeeUVnHDCCXjppZdw6aWXYmfz888/d/gz3M/33nuv+Lu59eK///0vbr31VvQ2hg0bhnfeeafJa7fddpsQnHfcccdO357IOc0WOXV1deJcfuutt/Diiy/i0UcfxfXXX9+px7U7iHUuUUBw0DnuuON65XHdXfjzzz9x4IEHIjs7GxdddBHS09OxZcsWzJ8/H88++yyuuuqq7t7EXoUUEFstEDabDe+//35MAUHx4HK5hNCIZvDgwTjrrLMan3Og9vv9+Pzzz+H1eoX63VlQZUdvC3/HwIED8fTTT7cqIILBIMLhsLCsdDadvU7OiPnobaSlpTU5buSRRx5BcnJyi9d3Bs3P6cj2HH300UKgDh06FEcccQR2ZXbGudTTjuvuwoMPPoi4uDj8/fffiI+Pb/JeeXl5t21Xb0W6MACYTCYxW//tt99inmQUFhQYFBrbgoo3YgLuTrgdnAXl5eWJ54xP4HY98cQTeOaZZzBgwAAYDIZG0/SaNWvEDIxmawqfCRMm4Ouvv26x3pUrV+Kggw4S+ywrK0u4bChCmhMrBoKiiqZsDlL8joyMDLHfN27cKLYvJSVFLMfZasS8G/EHNvdbjxw5Usw0msNtoZjib4l+jb95xIgR4nt5c7/kkktQU1PTrn05Y8YM4RKim4o3pWOPPRarV69uskxk+zZs2CBcVlyON7LzzjuvhUtre9i0aRNOPvlkcXzobttnn33w3XffNb5PCxi3j+6G5hQWFkKj0eDhhx/eru+m1e3DDz8U5zRv0BEolu+66y7h5uBv5fdzP82cObNxmW0d12XLlon91b9/f3FseN6ef/75ja7C1qCFhINxtEWEx5n7nb+1tra28XVaTrjt3EexziX+zQkCLS2R7eM2RcP1dcVxbU57vofC//7772+8hunCvP322+Hz+Zosx9ePOuoo4U7h9cxrdtSoUY2uJE50+Jz7ncdwyZIlMV2vPPcOO+wwcXz79OmD++67T+z/aHh+cB28T9rtdrFezvg7cg5Hu34+/vhjca7xHsPtO/jgg8W1tS14L+F13lw8ELp2o3nzzTfFvYyvcz/SBU2LbXN25n6MRVFRkbgmeN/idvL3vfHGGy2Wo4uG73HfJiQkiG3l2NWlsJ23RFF+/vlnHknl+eefb/J6VVWVotPplHPOOafJ61z2ggsuUCoqKsRj8+bNynvvvafYbDbl7LPPbrLsf/7zH8VisbT5/W+++aZY599//93hbc/JyVGOPPLIJq/5/X4lLS1NSU9PF8/z8vLE+ocPH670799feeSRR5Snn35ayc/PV1asWKHExcWJ9x599FHlhRdeUPbff39FpVIpn3/+eeM6S0pKlJSUFCUhIUG55557lMcff1wZNGiQMnr0aLFufkeEKVOmiEeEYDCoHHzwwWK50047TXzHww8/rBx00EHKl19+qTidTuWll14S7x9//PHKO++8Ix7//POP+Pzdd98t3otw3333KWq1WmxTNLNmzRLLffLJJ42vXXjhhYpWq1Uuuugi5eWXX1ZuueUWcTz23HNPsZ/a4pdffhGfHTx4sPLYY48p9957r5KcnCz2QfTvjWzfuHHjlBNOOEF58cUXxffytZtvvrlDx3PEiBFN9l1paak4ljy37rjjDuWpp55SxowZI35/9PE588wzxXLc19Fwu3kseazbgtt6xRVXtPo+jx+/s66uTjzneZ+RkaFcf/314tjxe4YMGSKulyVLlohltnVcn3jiCWW//fYTx/PVV19VrrnmGsVkMil77bWXEg6H29zeY445Rhk/fnzjc34nv4fb+O233za+zmtjwoQJjc+bn0vcHoPBILYjsn1//vlnlx/XaDryPbyf8PWTTjpJmT59urg38flxxx3X4r7A48FjxOuV13tmZqZitVqVd999V8nOzhb3AT54/Q8cOFAJhUJNvsdoNIprnPc0XrNHHXWU+K4777yzxb2T5we3h48rr7xSOfnkkzt8Ds+cObNxP/DYcpu57WazWZwT2+LQQw8V37F8+fJtLsvr/9xzzxXfwfs+P8vv5u/sjv1I+BrPhej9lpWVpfTt21dcI7yWeN5zOW5HBF47kXPilVdeUZ599lkxPl199dVKVyIFxFZ40+UJMnHixCavc8Dhgfnpp5+avM7XYj14EXu93p0uIHjyR8QMb84cpLm+q666qomAsNvtSnl5eZPP88IfNWpUk+3mzXvSpEnipI9w7bXXinUsWLCg8TWuixfNtgTEG2+8IZbhjaM5kYGC2978Amrtpr927dqYgu/yyy8XF7bb7RbP58yZI5ajuIvmxx9/jPl6c8aOHaukpqYKIRmB+5c3vmhRGdm+888/v8nnOWgmJSUpOzLQRPY7f0uE+vp6JTc3V+nXr1/jzYrnKJf74YcfmqyPAq+1gasjAoKDO5eJDP68Znw+X5NlampqxEARvR/aOq6R4xTNBx98IJafPXt2m9tLAavRaBSHwyGeP/fcc+Ja4EBDkUi4b+Lj45Xrrruu1XOJ8Prkddqcrjyu2/M9S5cuFctRXERz4403itdnzJjR+Br3BV+LiKHoc4QiLVpQctDh6xzAmwuVyD0kcq1SkOn1enFcI+cF7yvNhWs07T2HIwJi2LBhTc4tDoh8fVvCgGKG5wQfvJdTfPE3x5ooxDr3DjvsMDHBimZn7UfS/DqhCOC4VFlZqUTD+zvvu5HfcOyxx4rza2cjXRhbodnztNNOw7x585qkI9IERNMRTWjNoSn7l19+EQ/GSTBI6scff8QZZ5zRLtNUZwct0lTMx5gxY0QQ59lnny3Mt9GceOKJjSZlUl1dLUz0p5xyishCYRoZHzQh09y2fv16YUIj33//vTA77rXXXo2f57qax4bE4rPPPhMm51hBTNsTiU43CANHP/roo8bXQqEQPv30U+Gvp5mRcD/QFMzgwMhv44OmRpoVo83tzSkpKcHSpUuFCZJm1wijR48W6+P+aE7zeBOa9LkvHQ4Hthd+D/f5vvvu2/gat/3iiy8W52rEDXXIIYcI0+h7773XuNyKFSuEm6Az/O6RTKJIthKvmUisC90HPJdoXqfpdPHixe1aZ+Q4RVxcPDY8x8i21sF9y2POwDnCIGa+xgf/jvx+ugX42o7QFcd1e74ncs41D2aNBFA3dwnQLD9x4sTG53vvvbf4n6Z7Bho2f51m9uZceeWVTa5VPqf76tdffxWv0V1AFxDvgzt6Dkeg6yY6jipy/GJtXzS8LnkPp7uZAcCPPfaYuI/RrdncJRt97jFgmOfelClTxHfw+c7ej83hGML7Ju9n/Dv6/sXfxG2MXCM8BnRVMvZjZyIFRBSRgTDiN+IB4Y2IwoI3y+bQP8ebNh88YRnJzZgA+sS+/fbbnbrtPHF5AfNk5A2VJ9nbb7/d5CIhubm5TZ7Tr8iTk9kjEQESedx9991imUhcSH5+PgYNGtTiu4cMGdIu3ySX68zYkFNPPRVz585tFDj0SXJb+XoECiBeaPRzNv999Im3FVjF39va72N8Cfcxb5zRRN9MCH2RpL3xFq1tR2vbEL2darVanMNMR4z4zSkm6Jul73lHicQQ0M8dgXEDFFT8DsZKcL9yEGt+A24Nig7GbVCk81zl5yPn6LbWscceewh/b0QsRATE/vvvL9KhKUgi70UPXNtDVxzX7fkeHmseZwZIR8PYEQ4ikXOhtfVRTJO+ffvGfL357+F3MT6luXgnkYnW5ZdfLl47/PDDxT2R/npOpLbnHG7vfmiLPffcU9yDuexff/0lJnYUvYyLihYqvHfw3h2JbeK5x1iSWOfeztiPzamoqBDi99VXX21x76LAIpH71y233CIEGUUa79FXXHGF+H1dTe8La98BOCtllPkHH3wgTiT+z8G1PTPsCBFLxezZs4Vy3Flwds+LYVs0FxSRAMgbb7xRqNpYNL9Z9RQoFHhzoJXh2muvFYFXvICZbhv9+ygeomfl0URbYzqDWEKT7CyLFLNvHn/8cSEiTj/9dCGGGQAWubHtCJzN8/dFBvh3331XWGeY+njTTTeJ/RwJ1qRgbA+0fFHw8vO0KPEmyGPGYxgrODcanU4nhDOvNQrh0tJSISAoRgKBABYsWCAEBK/pHT3OO+u4tvd72mu1a219nfl7eNxpqfvpp5/www8/iAcDFHkuUmBuD52xfbRgUEzwwcGagy7vFZwY8fzkvZrnxlNPPSWEAJenpYSZa83PvZ2xH5sT2QZaD//zn/8gFhTvESG2du1aMXGleKPlgqnXDHKOpFB3BVJANINigbNxmn1586Wa4wnYXmjCjZ6t9XQiqpg3420JEBZm4Yy+OTxxtwUjxnlD542d3xWLjroyOJBRcdONQXMgZx0czBipHP29tMpMnjy5hXjaFvy9rf0+Zq1QtHH20tVwO1rbhujtjGSnjBs3TggmzgYLCgo6pYAO1zNr1ixhxo1YIOgu4vnD/R597CKWq20dV87SmPnEGxxvdBFinWOtQcFANx2PMY8HBwR+H6PRKR74oIDaFrtKQSceaw4s3EeR2TspKysTs9Xoc6Ez4HfRHB+ZLZN169Y1ZidE4ODLCRMf/AytEqxFw3spJyAdOYe7ArrVIm5Jwro/zFqhWyPautCWS3Nn7MdoKHp5rdFN157JIe9FnFTxQdcIM9yYycJJVleVFJAujGZErA28oVFVd8T6EDkxCeMQdgU4e2C6JS/2yMXV3IwWgfn/LMhCs2D0+63N7pvHXtDk/8ILL7Sq1mmOJtEpeNuCFwu3iWlNXH+0+yIyw+UFyLS3WGKvre9imilnxZxFRS/HmThjTnZWPQR+D/c5fbsR6DqhaZM3H/pno2HsC7ePqat0K9C0vCPQzUBrBvdjdBGkyOwrerZFkRi9nW0d11ifJ9zujggIDgT8DN0UESHA11nIiUXV2hP/wJtvR8677iJyzjXfR5xFkyOPPLLTvzP6muWx4nNOAiLW1uYptzTXR2bGkdTSjp7D2wsFQKzZfyR2JOJGiXXu0W1By0lX8cI29mNzuI28b9KawHtOW/fm5seAgo77lN/DSVtXIS0QMWa1kyZNEkGRpC0BQQVJMy6hz5kDGQcbKm7exKPhQWR8RHMYnEe1HoEDYXP/IaGfONr33JlMnz5d3HyZy8zqbZxVckbDi51xIAxGIjfffLO4KdO8zO3hTZc3AM4eaLFpC5ozGZPB4C/eSHhT5w2EM0f+fgak0kLAk54WBSp17hvOqPloDQoEul/44PLNlTqDoljzgWZ1CsJDDz1UXLScwdGcyVz16JoRzaE7gAMwZ94XXHABPB6PmNHTJbCzatazaiLdadyOq6++WvxOnmes8cGbC2/Y0TCIl8eKlVUvu+yyVi0+bZ3TvPEwcC9SVZUWNQ5S0e4hzuxpfTj++OPFwMXtefnll8UxjLbAtXVcGa/AQDdeHwx0o/CJ1C5pDzwujKvh7JYBeRG43khOf3sEBN2XPBf5GxmIyvtAJCCuJ8GJCc3ZvO4oeHh+83ri+UDrW6zaKDsCZ668H/E7uT/onmCMC128EbfQhRdeKEQmAwpp9WI8A68Riu+IlaSj5/D2wiBt3ot5TtIaxZk4XWQ89yhUIrEDvA9ErCa8P/B8fe2118SEKtZEamfsx1iw+BhFET/DezOvI+5rBk/yfOXfkd/DOBhaWunCY50aChRel101bgh2et7HLgDzmLlr2so7bp6+ybQh5utefPHFSllZWZNlI2k8sR4DBgxoksbZ2mPLli0dqgPRnEgaJ1PfYrFx40aRlsi6EczjZ54zc5U//fTTJsstW7ZMpKIxr5nL3H///cr//ve/baZxEqYcMQecqVv8Dn4X85b53RGYKsX8b6Y3Rac0xUq9izB58uSYqW3RME+a62XaFfPEmbbKFK/i4mJlW/z666/iO/hZpqsdffTRyqpVq5osE9m+6JSs6OMavW+2J92P+4j7iimJ3Pc8N6NrHTTniCOOaJF6ti2izzemqfK7mI/PNL2VK1e2WJ6paA899JA4/1hHgctym3i+87VoWjuuhYWFIlWR38W0NNYO4DFpLe2ztXz+5unFXC9fY/58c2KdS2vWrBG1T3iM+V4kpbOrj2vzbWrP9wQCAVGPJHId8TfedtttLdLHW7svxErXjXV/iKSf89xjmjhrMTBFl9saXeeA9wi+z3RnHl/WRbjkkkta1GhpzzkcSeOMruMSvX3cH23BFGamwg4dOlSkc3N7WJeBKZTN78tff/21SHHmtjCVlDVwIunm0ft7Z+1HEuu853bze3icI/dNpt7znhadPsrzlym/vBY5rtx0002NNVu6CtXWjZZIJL0IzsDYVKg91fskklgwQJZxLrtKPFdP5dxevB9lDIRE0sugCZbm0eZuNIlEIulMZAyERNJLoD+Zud+vv/66iHugb1cikUi6CmmBkEh6CUyzpNWBQoIBagyqkkgkkq5CxkBIJBKJRCLpMNICIZFIJBKJpMNIASGRSCQSiaTD9LogSpYMZfU5Fs/YVcrTSiQSiUTSE2BUA5uPsaDatgp89ToBQfHQvEOaRCKRSCSS9rNlyxZRWXS3EhCRsp388Xa7vbs3RyKRSCSSXQaWsOckvD0lsHudgIi4LSgepICQSCQSiaTjtCcEQAZRSiQSiUQi6TBSQEgkEolEIukwUkBIJBKJRCLpML0uBkIikUg6i1AohEAg0N2bIZF0Knq9fpspmu1BCgiJRCKJkQtfWlqK2tra7t4UiaTToXjIzc0VQmJHkAJCIpFImhERD6mpqTCbzbIonaTXFVssKSlBdnb2Dp3bUkBIJFtN1XPmzBEXVUZGBvbbbz9oNJru3ixJN50LEfGQlJTU3ZsjkXQ6KSkpQkQEg0HodLrtXo8UEJLdns8//xzXXHMNCgsLG19jBbZnn30WJ5xwQrdum2TnE4l5oOVBIumN6Le6LiiWd0RAyCwMCXZ38XDSSSc1EQ+kqKhIvM73Jbsn0m0h6a2oOunclgJCsttC9U3LAwPmmhN57dprrxXLSSQSiaQpUkBIdlsY89Dc8tBcRLCnCpeTSHoT/fr1wzPPPIPewu+//y5m1TJrZuciBYRkt4UBk525nETSE6DoPf/880U7Zvq6c3JyhKWtqqoKvYEDDjhAWAajmTRpkrhO4+Lium27dkekgJDstjDbojOXk0iaQ/cXZ8cffPCB+L+r3WGbNm3ChAkTsH79evGdGzZswMsvv4zffvsNEydORHV1NboD/m6mD3YVFErp6ekybmUnIwWEZLeFqZrMtmjtpsPX2daWy0kkHYUBuHQVHHjggTjjjDPE/3zelYG5V1xxhRhMf/75Z0yZMkXk+R9++OH49ddfRWDwHXfc0bhsfX09Tj/9dFgsFmRmZmL69OlN3Hf33HOP+LzBYBDWjKuvvrrxfZ/PhxtvvFF8jp/fe++9hUCK8H//93+Ij4/H119/jeHDh4t1vP766zAajS3cDLSOHHTQQeJvWkm4TVwvs2BGjRolhFCEc889F7NmzRIZUrw++di8eXNMF8Znn32GESNGiO/mfn/yySebfC9fe+ihh4S1hq2r+VtfffXVxvf9fj+uvPJKMYHgdtOS8/DDD3fCUepFKL2Muro6Rr+J/yWSbfHZZ58pKpVKPHjeRB6R1/i+ZPfC4/Eoq1atEv/v6HkVfU519XlVVVUl1v3QQw/FfP+iiy5SEhISlHA4rOTk5Cg2m015+OGHlbVr1yrPPfecotFolJ9//lks+8knnyh2u135/vvvlfz8fGXBggXKq6++2riuCy+8UJk0aZIye/ZsZcOGDcrjjz+uGAwGZd26deL9N998U9HpdGKZuXPnKmvWrFGcTqeSlpamvP76643rCQaDTV4rLCwU61qyZImycePGxu3i95Pa2lpl4sSJ4reUlJSIB9cxc+ZMsX9ramrEcgsXLlTUarVy3333id/H7TGZTOL/CNwHiYmJyvTp05X169eLfcHPcFsJt6Nv377iN27evFmZM2eO8v777yu9/Ryv68AYKgWEZLeHN/OsrCwFUClQqcWjb3a2FA+7KTsqIDigNZxPTcVDtIjgwMTlOpP58+eL9X/xxRcx33/qqafE+2VlZWLwnDZtWpP3Tz31VOXwww8Xfz/55JPK4MGDFb/f32I9FBQc1IuKipq8fvDBByu33Xab+JsDNb9r6dKlTZa55pprlIMOOqjx+U8//SSER2Tgj8WRRx6p3HDDDY3Pp0yZItYTTXMBccYZZyhTp05tssxNN92kDB8+vPE598FZZ53V+JzCKjU1VXnppZfE86uuukpsK1/vbXg6SUBIF4Zkt+fIY47FF7OXYPonv+D+l9/H9I9/xge//o39Dz2yuzdNsgvS3dk9sdKSY8GYiObPV69eLf4++eST4fF40L9/f1x00UX44osvRNVCsnz5chHTMHjwYFit1sYHXQsbN25sXB9dKaNHj27yHWeeeaZwN7AKInnvvfdw5JFHCncH4Xrvv/9+4bpITEwU6/3pp59QUFDQoX3A3zF58uQmr/E5Y0Oi41Cit48uEMZRlJeXN7pLli5diiFDhgj3Dd1CkqbISpSS3Z46TwBVrgDGjh0DFRriIWo9frh9IcDa3Vsn2dXoruyegQMHikGQg+fxxx/f4n2+npCQIMoYbwvG/qxdu1bETvzyyy+4/PLL8fjjjwuR4HQ6RZn3RYsWtSj3zgE/gslkahFftOeee2LAgAH48MMPcdlllwlhwniJCPwOxjcwxZQigvEVzLhgPEJX0LwKI7c3Euy5xx57IC8vDz/88IPYD6eccgoOOeQQfPrpp12yLbsiUkBIdnuqnX5o1GrYjP/eTDyBEBxe3rRkOWPJrpHdw74dU6dOxYsvvojrrrtODODRzcE42z/nnHMaB/X58+c3+TyfDxs2rPE5P3/00UeLB4Mzhw4dKqwP48aNE7N4ztS3J8CYVghuCwOY2RWSFogIc+fOxbHHHouzzjpLPOdgvm7dOhGIGW3Z2FY2C38H1xUNn9Nq0pEeN3a7Haeeeqp4sDLttGnTRCYLrSMSmYUh2c3xBUOodPpg0TfV0nqtGvVepp61zxwskfSE7J4XXnhBZEgcdthhmD17tnCV/Pjjj0JYMLPhwQcfbDKgPvbYY2KAZgbGJ598IjIiCK0C//vf/7BixQqRGvruu+8KQcFMBA7CFAEUI8wo4Sz9r7/+EhkK33333Ta3kZ9dvHix2BYOysySiDBo0CBh8fjzzz+FxeSSSy5BWVlZi+yJBQsWiOyLysrKmOmhN9xwg0hdpTuEv++tt94S+4aZI+3lqaeeEhkga9asEevg/qGLI+JukUgBIdnNofvC5QvCbGg6KzFo1fAHQ/AFuy53XdI74QyXZnjSXEREntNE3xXdXjkAL1y4UMQu0OROd8HFF18sUkjnzZvXZObMQZbL0qLwwAMPiAGTwoNwkHzttddE3ADjBGjC/+abbxq7k7755ptCQHAdjBE47rjj8Pfff4tUyPa4Wvbaay8sW7ZMiIlo/vvf/wrXAbeDBaM4YHPd0VAEcN/RKkF3TKz4CK7j448/Fq6SkSNH4q677sJ9990n4hraC1M7KbBYV4OuFwqW77//XlhNJA2oGEmJXoTD4RDVyOrq6oT5SSJpizUlDuRXOlGyabWYzSQnJ2PsuHFQqdQod/gwoV8CEiwNneskuwder1fMqnNzc0X+f2d2eaXlgeJBdnmV9NRzvCNjqIyBkOzW7osvf/wN0194AeVF+Y2vp6aliVnO0D0mwhuUjbQk2wdFAv35zLZgwCRjHui26ArLg0TSHUgBIdlt+eDTr3Dfw48j5Khs8jqDw26++Wbc8cBjGHj01G7bPsmuD8UCTfESSW9EOnMkuyWM4r7zgUcZ5r21vk8UW716r7/yCmrdvu7ZQIlEIunhSAEh2S2ZMWs2Kup9CPvdsRdQFJSXFmHBwqUIhmQgpUQikTRHujAkuyV5hWVQ640I1VdhRGIQOdYQ/GEVWDuK/9f5VFhT78ffS5bgzCP2RZz531QziUQikUgLhGQ3xRSfIqwMRk0Yl43w4OSBPhyc5ceUzACm9vXjpIE+DLL68NHHn2Hk6HFd2kFRIpFIdkWkBULSo/H4WYshhGBYQTCkIBgOixAFrUYFnUYtHnqNGkadutXCPc3h+rKHjERSnBX9raUYnBCEL6QSkRCVHjVcQYD1o9LMYWxyAaUVVaLgDUvY7m7pd8zydvqCol4GXTms1mk1amHQykwCiWR3RwoISY+CgxQHrHpvUFSIdHgDCAQVhMJhIRBEfKPoktwgFjQqCgkVzAYtki16WDnAGbQw6VsOcKwqWe32o6jGA7c/jBuuuRLVH1wh3ityqlHg1ECtAvpaQ8gwh7G+VgvUhwBtg/uCNfmZltfb0/C4n+p9QTg8AZTXe8X//qAC/lOrVGLfxpt1SLIYkG43Qs2dJpFIdjukgJD0CLyBkAhqLKr1wOkNIqQoMGjUYrCKM2qgaWWQCoUVBEJheHwhrHM5haww6NSiNHUiBYVBK8QFLRnFtR6U1/vEMml2I7IOOACm0iGoyF+DL/O0+LNUh/EpQRyerSDXHsLQhCCUogDUBiuCUR0Ue2NaHvdjvTcgLA3cR/zbHwrDqNHAatDBaNU0LieOlcOPklqvOFb9UyzQaqQ3VCLZ3ZACQtKtsIx0mcOL4jqv+Nuk0yDJom/3gERhoVFrYNRpkMDZs9IwwLl8IVS5nGIZvUYFVqTmGrluuj2IsXIF0u06pI7ZAzkJe+PH19/GzCI94vVhjE0JINMShhIMQKXVA2otEA52egfFbrc0eIOocftQ6vAJyw/dRGYdRZte9AOJtb8tBq14cD/nVTkRUsIYmGpr3K8SSXtgWena2lp8+eWX6C2oVCrRYbR5+e3eSpde8Wzmwk5uffr0ETu2PScKe8WzjjkbrLBmenSrV0nvgXEIeRVOLMyvxrqyeuGVyLAbkWBuv3iIBU3s5q3Whz5xJvGg357CIdVubDLIWYvmNGxLwhDssedkqFUKsiwh2HRhJBgUJBvD0Cl+qLS6BhHRBR0UuyOmgW6h/CoXFhXU4O/8aqwtdcIfDCPRrEdmvEmU7o4lHppD0ZZsMWJzpRtrS+vFMZV0/6DMe+0jjzzS5HXee9sbIyTZNvfccw/Gjh3b4nVOMA4//HDsLnSpgHC5XBgzZozo9NYeWJubrV3Z+GXp0qXC53zhhRfip59+6srNlOzkAYx+9X+21GJtmRN6tQaZ8WbYTbouu8Ex4K/57DgU9MK7fhZqqquxsTaMA6x5uGdfNc4d5sWQhDAsWgUppjCS9AGo1Bqo9YYu66C4M+DgTkvPssI6LNpcjdUlDuH2oWjoQ9Fg/tcy0xEoNOgOKqxxY02JFBEtYNvp338HPvig4f9ttKHuDNjb4NFHH0VNTU2Xf9euRiAQ6NL1p6enN+ku2tvpUgFBJcYub8cff3y7ln/55ZdFc48nn3xS9HO/8sorRfT7008/3ZWbKdlJ0EXBgeufLXXCxZARZxQR/TubGTNn4JZzDsfmlX9jzcY8/PHj5/j83VeQM3g4AuY0VOkzEFDpwDhMxkKIkE2NvrGDItsHO51OIZCDwSB6soui1u3HhvJ6LNxcg6VbakVgKmMaKNpoaegMtwPXkWYzoqTOg4IqtxCJEtFNi72ngQMPBM44o+F/Pu/ilOBDDjlEDGRsr90Wf/zxhxDEbNNNcXz11VeLc5qw9TW7WDa3YPAeHf097J7ZGsuXL8dBBx0k1s8unuwKyuumOffee6/oqsnGTZdeein8fn/je8x8GjVqVOM6+J2RbSSvv/66GCsomoYOHYoXX3yx8T12z+Q2f/TRR5gyZYpY5qWXXhLr+uGHH5psA90O7L7pdjcUlrvllltE23Kz2Sw6m955552N4oNWcW7zP//8I9bPR8RS3tzSvq19QIsR3R1PPPGEsG5ymSuuuKKJ0OFvYpdVbn9aWpoYE3sKPcppyXazPEGiYVtXvt4aPp9PdA+Lfkh6oNXB0WB12FLjRoJZh2SrQbgbukM8sM/FaEOpcFlUeTVQD5wMZ5+98WToFLzd/wGsG3g2vJZM6HRa5Ghr4S9chaCzCueffz6sVqsQEbzZ8G+dTgetViv+pquObX95Q6D45Szwu+++E90Yd+agytgEBowu2VKDhfk12FjhFNW6mTGRajMK10NnQ7dTotmA/Go3qlz/DgC7LRQJvNFHdeIUFBU1vN6FIoLn50MPPYTnn3++SSfQaDZu3Ihp06bhxBNPFG21OchSUPC8JRxwV61ahYqKCvF81qxZolMtXcyEAxzvy60FFHOQ5707ISFBtPn+5JNPREvwyPoj/Pbbb1i9erVY7wcffCDqrXBwjrgDTj/9dHHdRZZhGnXkWnrvvfdEm+4HH3xQvM/fzIH+rbfeavIdt956q+iKymVOPvlkHHXUUXj//febLMN18bqlYCC8vikKuA/Ymp2tzSMT2VNPPVW0MR8xYoTYRj742vbug5kzZ4rjwf+57fzeiCBhu3UKO7YiX7t2LX788Ufsv//+6Cn0qCDK0tJSobCi4XOKAo/HI1Rcc6iyIyecpOfBDAn62+kn16pVyLCbus0XGwqHhNK3aUMYndxgOShFMtQ6Izb7E1BUUQUlXI6q+BCcdhPStBpkW3wIexsGRLa3jbneUEjcLPjgzYQXfXMSExMxevRoTJ48WcxIJk6cGPN83hHRwAyKynqfGMDd/iCMWg0STO2LZ+gMmDFT7wsgr9IF2+5cK4Juimuuaeyp0gS+xvP/2muBY4/laN8lm0CrL330d999N/73v//FvG+eeeaZwk1MOMN97rnnhHDgLJ3WB56zFA6c8XLw5qDJwZT89ddfQkRMmjQp5vdzgGbL6LfffhsWi6XRqsGYOArryH1er9fjjTfeEAM3B2QOlDfddBPuv/9+cS3RwkfRkJOTI5anNSICfxut1ZHaLLRec8B/5ZVX8J///KdxOf7G6Pot/N1nn322sDbwezm+UOjTChEh2rLSr18/0Z33ww8/FJMPXrecMGi1WmHpaY327gMKDL5O4UcrCt34FFYXXXQRCgoKxGcpeihquB/GjRuHnkKPEhDbw2233Ybrr7++8TlPBprjJN0PUwE3ljtR6vAKHzuDG7uTpUuWoKy0FJOSnUjQ+FBbH0LQmiwugrVr1qHkmwfEcpbJh6PuADOydFr0TTRBm5AMlcGMQMVmvP/O2zj44IMbbwi0gPEmwQd9zkVFRWLWx/8Z08PZ3Zo1a1BdXS1uwnxwxkQ/KW++nKHwBj1gwIAOCwamprr8QdS6A6gWoiEkRBpTV+PjukeosTYEj/eWarfIzNgtmTOnpeWhuYjYsqVhuS5MCeYgRbHKwa85NL/z3OTM+9/NUoR7juct3QKc6fJ8pVWYA/Pll1+Oxx57TJzPFBa0tkVm7M3hbJ/xb5HrhFA8c/2cSUcGTy4TvQ4Ka5r4mTLN93itUTTwOjn00EPFtcIBl2Kds/YLLrhADLQRKDji4uKabMuECROaPD/iiCOE5fDrr7/Gaaedhs8++0y4T6Kt37TIUFDxO7g9XC+X6Qir27kPKJyia8vQlUHXB5k6daoQDXSj0GLEB8Vha/t9txYQVHNlZWVNXuNzHrjWZmu8Ee9OQSu7CvS1ryutFwWJ0u2mVus47AxoIVg4/w+8Nv1ZIQLG9dfAqtVhQ70CXXYfWOFGXM1KTBycgqBaB52mHgFYoNGokRWnhdpghsaSiFBtqZh50awaIfrmQMaPH9/4N+MPRBVHpxsrVqzCP0uXYNGCuVg8fw4qy0qFyZIPmlhHjh6Lo447AcefcBL69c8Vn1fxn6ohliEgKnGGG1JU/UERQ+L1h8F/WpVapFXGx3VdIGp74XGmi6qg2o1Ei0Fkw+x2tDfVt4tTgikAOPBykkVfezQcFC+55BJhHm9Odna2+J/uiVdffVXUPuGsl/fhiKiggKC1oivhoPrLL7/gzz//xM8//yxcMnfccQcWLFjQOIDStbD33nu3+Fw0za9RWj0oRGghoIDg/3RB0KJA6JqhlYKWbe4/ChJaH2jt6Ap0Ol2T57yGKTIIrQ6LFy8W+5z7gC4bZoDQJRIfH4/upkcJCKrP77//vslrPIH4umTXgLOYkjqvSM1UtqZmdtegVlpciE/e/T98+dG7qCgvFa+NSlVjUJIWYZUWVcYMmHV65IQ3YmJcFRDHG08YKm0BUlQZ0KqAeKMCuy4EF4OltAYRSMnAs7ZKWtN9UFjtQWGtW6RHalRqpOUOxREDh+PoU85CiG6dTRvw95+zMOeX77H0r7lYsWypeDxy310Yu89+OPKUczDpwMOg1em2NhtvqL7ZUHmzoXS3zabrVmHWGrQ0scDUpgonrIb4neZC6TG0N9V3J6QEM52TrowhQ4Y0eZ2p8rQqMFW+NSgQaP6n7z4S68D/6cefO3eucGm0Bi0Y9OPTUhAZwPkZtVrdZFtoCYl2T8+fP1+4ByJWZN47OGvng4MnZ+N0NdDqzJijTZs2icG+o/AznN2vXLkSM2bMEMH+EShY+D0UKxHy8/NbiJDQNjJq2rsPtgWFDa0jfNBtQ+HAbe4JZfW7VEBQ5W7YsKHxOU1jTM+kb40ql8qYpl76iAgjcOkLop+JgTPcSR9//LHwT0l6PqxSWFDlwsYKlwjUizM1VdY7S8DQ2vDB/72GmT9913iR2+Pi8Z9jD0Sfur+RbPWixKdCMKEfElGPWqcXTr9KlLLWqRWkmQNwhXVQ2GtDr8OQuBAWewGVziBuaK2VtKaFgOb7zVVuOD0BMQM3ba3g2JzRI4eLxwUXX4bqqkrM+PFb/PTtF/hr7mwsnT9HPJJT03DCaWfj1HMuREpa677WnkiSla4Mj8jMyElqOgPs9TDVNyurIWAyVhwEBTXf3wkpwTT/c7CkOT4aZhnss88+IqCPqfIc4CgoOGHjPZgwZofuAs7Qv/3220YBQZdIZGBvDX4nBzvGInDGzGDMq666SsQeRMe5MeOCbgjGHDBrgp/hNnGQpaWBsQB0XaSmpornXA8HZkILAS0otBDQtE93IuOP6EqMdmvHgpYUWry5nYydiLZiMB6EsQe0OtBN0zw+IhIXkbd1PMvKyhKWguaW8Pbug7bgfqdI4vbyWHCCTetERwRIV9KlUwMeTJq+IkEfPKj8m0qSMEiGByoCDyQPFk9i+o5oMmKaDs1Ikp4fLLmuzIF15U4RQLezxQMvKg7Cpx4xBReccjR+/f5rIR72nLgvnnj5Lfz5+8+446Sx4gboDamxyaGBIT4FSSoHFFcNDBoFeo0Cq04RvTDSw+W0RUCv1SI3LoSwzw1tfAZUprjGktbNrQ6ssbCiqE4YC1hbIVY/jlgkJiXjpDPPxWsffIXv5y7FRVfdiKSUVFSWl+HV557A4ZPH4ME7bkTRlqazoC5DUaB1l8FYuQz2zT8gdeGTyJx1HZJW/A+qQEOa27agZYTpooU1HuF22a2gsNwabCjEQjSR588802UBlM1hYGLEJB6B4oBuiHXr1gmLWuS+zFn9v5uqEu/x/3333bfxc3RlMK6guWsgGroYWL+HsT8chOkyYDxDRJxE4GscsDlA0o1wzDHHiMGW8HtYjJAxC0yppMjgmBAp1EThw/HhzTffFEKJFhPO+DmObAv+JroiaQFpbsHgNlx33XVCyNB6Q4sEszuiYfbKtGnTRM0ipqAyg2R790Fb0NrAzBTGslA4MY2W38W4iZ6ASullSdsMoqQiZcR8R4NeJNsHzfR0WTBwLsVm2O7oe7XfAZ2zBFpvNTS+ami9NeK1hj6ZDSh8pjEipLchrLMiqDVj3qLleOmNdzF/6RrRRdNoMuPoE0/Daf+5EIOGDoeuvgDxG76EKkgzghp5mzfjj8UrYcoehvHKGhEXsaBMB0+o4eZu14dx8EAzEg0Kan0KPljmx2NLLVCb46CEgvCXbsB7//d6YywEgxlXldSJXh6dFe8R8Psx85cf8M5r0/HPor8aTZlHHHcyLrr6RuTkdizosl2EgzBWr4al9G/oHXnQeirFMYDyrwAIGhNRPexsuPpMbjk4NoO3luI6D0b0iUPfxJ4R9NUeGBDL2SUHIubebzdM1WQ2RnRAJU3zFA89wPws2X3xtnGOd2QMlQJCskOw8iDLGLPuAGsMdLQwkdrvhKF2PYw1a6FzFnfos4X5m/HnnBmo2pqrrtbq0W/cFOwx9WQY0gYiYEyBzl0GW+FM6OoLoQ554Lf1EwPf56vqEefahAHeVaisrMZPWwyYX6qFO6jCkIQg/jtJjXSrCq6gGr+td+PqOQ0ZBRpbEkLuenzz9nQcevCBXSIeYrlkXn/+KcybM7NRSJx81nm45NpbhPViR6GwMlUug7l8MfSOLdA7twAhvxBoIZ0ZW5wqlPnNGBZaiwSTRjRC9SSPQuWICxC0Zba5bgaS8pwYlxO/y6R1dpqAIHSh0VrFgEnGPNBt0cu7uUp2HwHRo4IoJbsWNE1TPNDPzUqEHelhwQHdUroA+vqCf/3EKhUC5nQETUkIGRLEbDdkiGMZyH8/qIRRtHEV3n/xUaxbOg92gwo5yWYcNmUvjB+3Bwy8GNzroVs5FzpXsZhV8/NhnRnehCEImRJRmz4ZKxf/hKNVS6AJOFHhVeOvMi3+qWpwu4QUFep9fqRbdcK1kWYKi6JTYUWFkLMGaf0GI3XQGNFTYn1ZfZeJh4ZdosKeE/cTj+VLFuHlZx7FnBk/ixiPbz77COdffi3OuuAyGLenpkQ4AHP5UphL/4bOVQJ9/RaolCAClnT4bDlYUBzCg698h2X5VSKAkz1Cbt5Hg9PHJyIBy9Fn/t0omvwIQubWRQxLlPP84D7KSth1rBCdBsVCL+zeKpEQKSAk2wVn3mtKHShzdGzwpJXBUvIn9I5/Y18C1j5icPfFD0JYb235oXAIWLIEjoJ8vPjTN/jox29EfANn4qf95yKcdc3NiIuPh8tVAlXxHzCV/g1n6UYovnpodQYYM4bAHz9AmN09SSOxpNCBjGARklALJeBDiUuHVTX/XgolbrWoraAka6GHAqtBhWSjgnIPf6OCay+7QHSv9AYbSkXvrDTVUePGY/pbH2PB3Fl48oE7sWbFMjz36H345N03cNv9j+OAqe1s4qOEYaxaCWvxPOjqaXEoFK8FLBniWLjS98YPq2txwz13bBV3Db+tPqDGnX8AH68qwwfnWpGBOqT88wJK974TUGtab26m04pYCFqodruMDImkFyMFhGS7LA8N4sHb7sFT462BbctM6B2bG15Qa+BJGgFX2gSEDW3kM8+cAeXxx/FrwSY8Ul+JCooJRoOP2xPXP/MS+vUfCK27HKaCX2CsXoPNm9aLoKeSGjf+LNGiyKVBdoYHp1xyKKaMGSM+++3s+TheVQxjoBYFHhWWVeng2xr/QDxBFQodKowLq6BThWExatHHEoLfmITbb78dBx14kHDdsPJjd9S42HvyFHz43e/4/stP8Nyj96OkqBBXn386Dp52FG6571GkZ7TiVlAU6Os2iS6kxtr10DmLoAoH4bdmIWDpA3faOLjT9hS1MB698Oh/LUNqDXRJfRF0VEDxubC8Wodrv6nBh2emw1S1CnEbv0LdoBPatEIwO4W1QRhcKpFIegdSQEi2K+ahrM6L9Lh2DJ6KAlPFUliL/oAqHBBBjJ6k4WKWG6Z7oi1mzkDpDdfjKU85Cs1eTExXY1yCEdPMVmRrCqFZ/BT0+Vqogx7h7thY5sDbX88W7oiV1SbhciAlm+qw4JY78NhjOkzadz84KouRbHJAG3Cj1K3GsqqWs+eNDg2YPGDSKtBpdRhoD+HE828Q4oHQn59q6z5fNtPcjjrhVBw07Si88sxjItjytx+/xbw5v+PKm+7A6ede3CTNVOsqFQLOXLFUuCvo2qG1wW/Lhjt1HDypeyCsa4iqX7poIcrLyqCxJsI8eJJw1+xhKYM/rMKW4kpsXr8Gv25Yh5WaYRgZXI74DV/AmzQCvsTYqWU8R0w6jejYySDbzmjgJZFIuh8pICQdyraIxDy0RzyofbWw5/8ifOvi8/Zs1Pc9BCHjtiuoKQEP5j91LVbllGJviwoTocNIWxLS49OgsQA1Jj80Jf8g6IyDolLBo3VjaaETmoxhiDNooVe54a0pB0IBIWI09hQ89c0ivLpWj4P1FUhWquEPBJBfb8DGupZCYF0NBURYXCE6nQY5Nj9SU1LQ0zCbLbju9ntx5PGn4P7brhMZG4/dcxt++e5rPPj0S8hOT4Ct4FfYCmdD5ylvcFWYM+CLz4U7dU94EwZB66uGoXYDQjqrEBGr84uReMjF0GcOQ191FY5Uz4cx7IKKlfpYpDA7GY5AGmZW2DAoJxcGRx6Sl7+Kkon3xnZBASKtl3Uhqpx+pMftYGCiRCLpEUgBIelAnYeGbAsGTG5LPBirVsG2ZQZUIT8UjR7OzP3gSR69zdQ/VciHwMY5WPDqbShPqUNq0iBY49JQbx2ApXoD0lS10KkCwisfULRY585ClWJHproK6XHVGBAHDMgFDtzDhHmhE7HMYUXI54U+paEZjyuoYDRWw+QrR5FHhUXlrPTYcps2ODTwBoKAATBqVRiSZsSYHtTEpjmDh43AW5//iM/ef0vER2xcNg8/3rwvLpk2EokpjKRWEDSlwJMwBEFLGhSNAaaqFbCUzm9cB5twLSusRYbDi+tzNPAjD3bnZjgrS7CxpBJV6kT07dsHaSmJsOsNgCsfMz3DcaiuXATDJq5+G5WjL4t5jHm+sLkXrRCpNgPUPbCCpkQi6RhSQEjaVWFyQ3n91pv/NrItlLBwV5jLGjpSBmxZqMs5tO04BxIOiTTCsrnvY+78+UBCDpT+h+AvZTA0CGGsehOSFQfiXPXQeYIoq42Do8qAnCP3RM6IUfj7nxX46I8ZGGr3Yc94B+ItfkzVLsH4BBsWhIdBUfJhq1qByWlB9CmcC0NiEFvqdfinKvYlUOLWwOH1o49NA5NGwT6jBiIY8iKs7rlVFdUI4awjJ+HMzItRPf9D+Fy1KN+4DJXlKciadDIMSdkiFkUfnS6rUqMsbMfvmz0oqaiHBSrEqRQM8PyDOM8WKKEAlnp0mFFkxMY6F7BigwiEPHD/vXFQfy0K81ZhSb/BGK9aBmvRXDj77Advyr8dE5vHQrDpF2NHEnbHHhkSSS9DCgjJNusQ5FU6kV/lQbK1bf81rQf2vB9gqNsknrsy9oYrY9I2rQ70z+vXfYfZc2agRrGgvv8hWBgejLCixrHuPzDEWYAUZzXi6xzwFWngqdRi+Nb4Blx1BjA8DQmeLfjsyR/BoXGWSsGE1CD276uG2WrBgbq5CDqrgYAHh4+ajEC9Ct6gCsurtSj3xP49DKQsdgQxKFkLnSoEU5wd1e4K+OPaJyA03moYa9aJQlgavxPqQMODM/+G+goW8X9Yb0PQmICQIR4hfVyr2Qwx93fQC42vFnpnkbD4mMoXQecqhUoJIXPkCGwoqcEHv6+Az1+CPpvewNQjjkGfrGwEzSnwxA/BSpcNH6zyYX6BU6yPRoEjBplxYtIS+DbUonB5HrwhDSzaMG4Z5xbWmtfXGOEPKTj48BNgCDvgXf87luaVIT0zDpnqasRv+BylySNjHnOeOyFFESmdUkBIJLs+UkBI2oTVJTdVuESHxbYKAal9dYjf+JWoXqiotXDkHNZqUF204DAWzsXmxb9iRVEtPLoszAmPQm3AiMtzirD3/E8Q76LfXgUfYxLcauhsYehsfvGaYo8HkmsRKlmAvXMTMLhvEtYXVok6DqwsubRSwaR0B4YnBBBnAAYlG5GalAiXuz8WrtqIvyuaDWJbBz12Kczu2xeD/b9CVfYrdGE/PF4ntB4KiH5t/6aAG9aSeTBVLocSDqG0tARut1uUtU1Pz4BaDPp1iFnoW6VCSMcKmyYoWjPC4mEUMRwUBawIqQqHoAnUC0uCECc+hyiWRSFBN4Wi1sNn7wdX2ngkD/Dh3JyV+OX7r1FRWYEHX3wPQ4++ApmHnoUv/yjB2jLWd2CSpoKp/Q24MKcCgyo+hba8ErCFoYw+APMWLkaCzokMcxj97F4c2E8DZe+LMGTyBIS0Vszx1iOwZRH+Lg4gIckLU/UaGGrWwJfY0K+gOXaDDuX1XmQnmUW/FEn3wF4O7OnCx44ss6Ow9DTXX1vL81eyqyEFhKRVSuu8WC86KmpFh8XW0HgqkbD+M6gDLjGrrh1wDIKWtps/aeuLUL3wU/yxYRO8IRVWqwdhQU08buy3DtMyHNAFHFCPtCC4VEHAqYbOGhYPUcxaDai0CtSTc6De+JUofkTXyeenWLB82SY4g2pUe4BKr1o8wlDDpgthzOiR0IQ8sGaPRoZxMMpWrGPj8cZtSktNww03/ptpYdkUAsp+g0YVhruuBubyJfCkjBExHTGLMpUthqXsbxH3kZ+3HnPm/YWqWhdY+sCgARLsZkzYax/k9B+EsJr7Uw0lHEZpSSG8LgfMJjPSM/pA43fE3mkUEEEfNP46aH11Yjlla5Esvz0H7uRRopaGwZEPw9bA1YS0TEy95lnc+vI3mKWEML9+HLQ/rwP3Sn9NJU7I9uCQFAdSvXnQ5zHFVhGBlN6EoUjPSsTRIw/ApqJKBOpKMSy0CnFmI8LaJfAs84rMi32nnog/vnOismwNCmvy0U+jQfz6z1G21+0xrRAWgwbFdX7hypApnV0De7WwidOPP/6IyspKZGRk4LjjjhO9LpKSktq9HraMbqvfRUeJJUjY/4K9LiS7JlJASGJS5fRhbZkDOrUaNmPrjbFYgyGe4oGplOYU1A44TpjlW0VRENg8D6vmf4uSOjfqFCsWulIxrm4Wft5DAzO/ygUETcnwDDoAIfMYhH+ZBZXXAY1BEQ+1zQSMGgmkpwnhwHLB6pAPGXYDTCNyxQ3UH/A3fqVGa0B2Tj9Y09PgM2cIN0HGniPx0QkHY+mSJeImm5ycjLHjxkGz1YUwY+YMfP7yk3hzXy/0BhVqHHX47d2X0He/OuQcfVOTn0ThFL/+U2g9DTP69fmF+GPGTATCQKSnGKVPlcONn36dgalTNcjtl4u8zXmiZgXb/XLgVrN5l9mKfSdPRv9+OY0WB1pquH9FGqzoBaKH35YFRWsSrg9f/AD4LZkwsThUybyG3azWojZ+JGZ4BuC3lU4syz4ZydlB5KjKMMA/E7m1f2PaXsOQmZIgAiC13irRX4SioGbAsQjYswF1w8YnDm/4DY76LTCseEMUnzJVrhDbxt9METH76//DWkcNkurykGhcAX3dRvjjB8asrElLFjMy0u1GGUzZybBz48SJE0XzKTZdYqlitqy+6aab8MMPP4h22eyG3B7YJKqrYRvvSCtvya6H7IUhaUG9N4DlhXXwBsIib7+t2AX6vGmWD1jSUDvwRCg0ubdGwI2CuR8jb90/CIXDqA/qUZ+/HMdmOjCqfwZUajVChkTUZ+0Pb+JwqIIuMZMWdQtKigG3m3mLQEYfMXCKUtfGRDFj5oDJbApui8pbibK1i6HUFSJRH0JycpIQNwF7rpip08TPz0VmyAwSLav3iL9VUGHevPl47LFHoQ84MPu4GmTZgUXeLKzbWIAqrwr9j7sFo6ed17B8wI2E9Z+IgTSstcBnSsanLz8Ej9uFKo8aa2s1qPapUONTo9bHTARgYJ9EXHzWSXj/jReRYAiLpl3xBpbL/ndXTZ06VYiM5lA8BMxp8Nv7iYeiUsNSMk/EWxBvCPgnmIPPKrMxt9AvLCMUDYNVhZgUX4Msgw9Lf/8WztpqpNm12Hfi3kjNHS72p7PvAXCnjm8zZoWxHbQwsEy43pEvKohSMOZZx2Hhrx9iCpYgPcEG5O6H8j1vaTUduMbjx4ScBMSb9b27F8ZOhp0qV6xYIbpsRg/MpaWlGDBgAM455xy89NJLwhrANtps4f3111+Lro8sknbFFVe0ajGgm4GtvL/66ivROpsdOZ9++mnROTnCN998I7p/Ll++HFarVXTzZCtsdsFl989oOPREuzC4zWxTvXr1agwdOrRxOX4HO1hu3LhRPOfvoyBiR1xaSNjum8twEiBpH7IXhqTLqkwyXbPeF0SGvfWbp9ZVgoQNnwuTOksg1w48vk3x4CjPx9rf3oKjrgrxigsuZz1SihfjjFFZSE3NEv0vHNlT4cqYCFP1KlhL5gpXQITggDHwCQHQT/RqgHABtI41t8EsGgz5UeGrFYGKkRl1c5y+IOwGveipwRLZFzx2JwK1Lij2ZJS7q9HHrhZtvtfUapFiDKHopxcxer8jodJbkbDV8sB4hSD7bKybJ8TDymotvt2sF91CtXGp0KalQWNLhiscwhK/B9d/th5OZQ+Ea50IuWqheOoQrw/BpmNbceD32lWY/vzF0KggBFJYZxMWAgZhcoCneDMUz0O4fC3KnD6UO32Y50zHt44BcMKEfqpNOERVhHHWCvRP1CM3yQIbBZfeiuycqzH7izeRn5+Pj3+ci4H7WLHHfy5DaBuNsQiFV82QU5Gw7iMRb0HLRVClwYC6+ajOSMGa4mzYHRuQVL4UOkc+AvaG9NlomMURCimiMmVPFBCx4GDHWJbugPEztNxsC7aNZvvoBx98sMWsPj09XbSt/uijj/Diiy+K1x5//HEhGu69917xuWuuuUZYLiheY3HyySeL9dKSwQHmlVdeEe2pOfDTqvHdd9/h+OOPxx133IG3334bfr8f33//vfgsW1JTaFx88cW46KKLYq6f301R8t577+H+++9vfJ3PzzjjDPE3hQZbW7OVN0WDx+PBLbfcglNOOQUzZszowF6VdAZSQEga4Ux8U4WzsTlUazctDl6MeeAAH7BmonbgcQ0DWytsWLkIhfM+hC1YjQFKHTZvKUafUBEm7j0SxoyhcCQNE5UpOYtOXPvBv9tjTIQ7ZfTWHhltuEXagDP2oDm1zWVc/iAGpFiET/73339H4foVovAUVKnYXBPCqDQtEtQu1KvtcDocyEU9nHNeQXZ2PxE0SvGgaHSiYJbL7cXPRSasSjsCCSdNgsbcerXNaEMyYyHC3nq43Q44/W5U+t24faYT2X3SEVYUBMMOBIM1iPcVok/dP7B4iuD2B0Wj843hPlgUHgGbyoOJ6lXYw1KJ/gk6ZCeaEWdKEcIjaEyGPxwQAZdWVQDTjjsFv876A4+8PxurZn2NqStUePDpl9vVlIvHoi73SCSu/QhBdQrCWhPUIS/2SAH+KNfDGdZBU1stzpHy8dfHXIfNqBX9RNhga1cIpqR44Iy6O3A6ne2KRVi/fr0QOsOGxQ5g5es1NTWo2Nq9dvLkybj11lsbB++5c+eKQTmWgPjjjz/w119/oby8HAZDw7X+xBNP4Msvv8Snn34qhAGFy2mnnSYESYSIdYICg5VRbTabEDOtQZFDa0NEQFCcLFq0CO+++654zvfGjRuHhx56qPEzb7zxBvr27SuW5e+Q7DykgJAIeOPZXOlCQXVD06PWCkVpvLWI3/ilEA9+W1/UDTg2dlCh6GQcxtxZ3wNrf8RAdTEUvwtr16wXA/LQPadBkzoQjuSRUAf9omKlQKUWPn13yhgErH23mQLaGaKJPzVh60y4hG2XuT+CDdaP1TVaTAsDVrUHg1Pi8NU/GqSawlAcJdB6aBmwwBeXK2ICFK0B8+zTkDfxYNgoQCLf4apFsK4cwfqtbcf1Jqj0JvG/2mgTIkOl0Yr/owXH4vIQFpcXIQEODFMXYJiqADZVwyzYpQBlSjyq1YkYYA/gcMtSpNn0wuVk0CY3CCfGR2hNIuCS1SIbt8dghydlLMZefy1OyXofD9x+A3757iuUl5bg+Tc/RHzCtn3kQUsGnH0mi74aDGL1xg8S/TVGp+qxoTgVI9wF0BYtgHZwUcyW3xaDFiV1XtS4/ciIkz7wzqS9XmnGSjR//swzz8Rc9p9//hFCpnkQJi0AEdfC0qVLW7UutBcKELpJGKuxzz77COvDHnvs0ejS4HbMnDkzppjjdkgBsXORAkIiYLOjvMqGdM3Waj2IYMENzLZwi1l93YBjWhUPNU4vZn77LgbXzka2uhwl1S6U52/AkL59MPSA46ExxyNgShRpf6Jpk0oFb+IwODP22XbRqU7E5QvCoteKIkeEEesRAaGEg1hapUcoHIBWrUBntuKAzHL8kK/HqeaGss/1WQcgbvMPwvXzWukAvJtnhdYOhNy1cPz1BXyFq6EEfWKdGpUCuwHITLJB8dQKdwVfCzMwUmdG2GCForcKV1CiWY1p+05AlsmNxGAF9AhChwA0jPQwWGEwmmE2MKaiRjTEogUgrAkhJNw0auFa0oXKG3+notbBlzBI9CGJFmYnnHYOsvsNwDUXniHKYJ993KF46Z1PkZXddroqcadNEFYXNkjTeqtFbElCOIC0qhJ4AzqEqysRv+krVI65PGaXTr1G3dBTxW5sl4m+O6EbgQNod313exg4cKDYj4whoCuhOXw9ISFhu4Ij+dt5bdBC1xzGT5DOCIakdYIuivfff18ICP5/2WWXNdmOo48+Go8++miLz0auXcnOQwoIiWhJzbgHg1bdaromMwHYNIk1DEKGuIaYh1bcFnlltVj27XRMDP4Nu8qNtfllqKsoRc7gkdjjgMMBLQe5kCh6RHzxA+HsMwkh084PgqL7IjfZ0iiaGPSVlZWFopJSKMEgVjjMCAarodbpoU/Khq2mDHv2M0J78K2o0hqQsP5zuH0BvLZGh/ddrOMIjE0IYNN392GC2QNLThjZ1jAGxgeRaVGgUikYPDgdG/Mq4PN5oVGpoFMDOrUTWnW5aN5l1irQazXIwGao3ApLXkDRGLfWheBNuhbwAopfL9wTwkVhSGgag6JWi0wWupj8fDDgspXjNWGfyXj7859w+TknIX/TBiEipv/fxxg+emzbO0+lQl2/aUha/U5DLIQlVaTvpmXmoCqvFiZ/LUJ5c6AacZ7IGGmO3aRFtdsPhzcoemX0ZDgwd2ZKY1dA6wDdD4xxuO6661oEUXI2zyDKiFjjLD8aPm/N/UErANeh1WpFcGUsRo8ejd9++w3nndcQYNwcvV4vYoy2Bd0YN998M04//XSRVUKrRPR2fPbZZ2IbuC2S7kW2xdvN8fgbgiYDQaX1gLZwCHGbvhEpm6w5wGyLSOfG5vy1sRTrv3oQBwbnwK44sXjlRhRsKcHAcftin/0PFuWWOWNmCiAHOAbk0ZLRHeKB7gsSXRWRftpnn31W/GYEvagLGVHr8kMJhVCnjoex3x4497Bx0Psdoi5EuL4MP66rwxeukRhoD+OtA714cdR6vHbBBJw9QsHFIzw4caAXE1IDyI0HJuQmIV3vwdi+NuTYwsi0hpFmDiHJGEacPgyDRhFxDbb4ZIT1dgRMKfDb+sEX1190zqQg8CUMFjEj7C/iTt8TntSxonw0LQL1fQ9C7cATUDH6MlQPO1s89yUMaTNGhQwYPBTvfPkLhgwfiaqKcpx38pGYN3vmNvchLScUERQTxqrVcKeMhy51EIyWBBgQhLe6WDTzigXTOf1BBTWuBguNZMdhjAAzJA477DDMnj1bpDSzHgSFRWZmpohTiMCYh8cee0zEDkyfPh2ffPKJCKSMxSGHHCJcHKwn8fPPP2Pz5s0iBZkBkwsXNpStZ+0Jpo7yf1o7mIkRbSngoM9tKioqEqnTrXHCCSegvr5eWB4OPPBA9OnTp/E9ZokwWJTignUq6LZgAChFS3vEiaRzkRJuNyYYCmNjhRPVrgAyWuuQqCiwbfkNekeBcFewzkOsbpr0u367aD3SFz6Oyep80UPhl7/Ww+sPYOqh0zBqUF+EwwFRWZEplyxz7U6d0KHSzZ0NgxDpi7c3q3PBGxgDw67570Oo8mtQ4lIjyeTEQG0eftZPRlagCLmbfwT8bsxcV4GvnaNxpHk1Lh/khcWjEmmnI9WbMGp0BtxeP3zUIqYkmDMGI6Q1wykkQhgB0xb8vXgJSms8cPhVqA+ooJgSMOWECzBuv8OFRSGsMTTM3iMm/q3unq4gNT0Db376Pa6/5BzMZ1vw807F49PfEC3D24KZFu6UsUJQmSuWiADLuJoCeNcXwhyshX/ND0D/o2N+1qLXNAZTttljRdIuBg0aJAZ0DuLMTOBgS7cAB36+Fl0D4oYbbhDLMuiR6XpPPfWUEB6xoNWCGRUUDBysGYjJ9e6///5IS0sTyzBVkyKEAZCPPPKIWCffj8D0TlZ5ZTopRU5rsRoMtKSb4uOPPxYBktFQTFD4MPOC6ZtcT05ODqZNmyZa3Et2LrIOxG4MMy5ofWDQZGtxD6byJbBtmSkGrdoBx8cs5cyZ/Pu/LsDEvGeRoaqC4vPgsz/WwWbQ4IijjsLAVIvoBEnx0JGW3l0NixnlJFowOD12hseWKic++nU+Jhf+DyO9C0Wa5ps1o+AMG7Bnugb13iD+qrEgXhfEqYM1SFKqG6pEeqpEzAEFgCdxuIg9oLUlZEjYmpIZKVNtQlClFcFnsYpZdRd+nw+3Xn0Rfv3+a2GRuf+pF3HUCae2+RlV0IPklW+I2AtHzlTR/yPw6/2iwmWVPgPKkc/AmzI65rlT4fRiXHaC6LXSE9iV60B0JowpoBhgyqSkd+GVdSAkO0KZw7u1x4W+VfHAPH5bYUPxF2fm/jHFA4sCvf/dz5ha+iriVU74nQ58MHsjshIMOO7oaeiTYEDA2kfMpLkOloLu6syK9sCBix6Mtpo6mQ06jB45EqnZp0FZ4YLRVYxTEzfip8pkbCw1QqsKo6/GhyOy1UjzVAiRoAm4RTlvb+IQVI6+dJsppJQK48dPQE9CbzDgselv4O6brsQ3n36IO669FG6XC6ecfX6rn6GVxJW+D6yFs2At/hNVw86BNWsU3BuKYPJXw7P6KyCGgIhk+1TW+3qMgNjdYcoqZ/llZWUYMWJEd2+OpAcjbT67IQ5vAOvL6oVwaC1oUu2rRVzed6JUtDdpONype8R0AXz4xac4rPQVJKhcqK2uxfuzNyA7yYTTjzoAfRIs8NtzReXE6qFnCF99TxAPkdgP4b4wta6hWZ+AmQJO+0CR9shAxHiDClPiyhEHF1QI46gMB9JUNUIoaH018MYNEHUxyva8ZZvioSfDALX7n3wRp/3nImFqfuD26/HWK8+3+Rm6MVjRktk6dGUERp0Bnz4RVpUHyua5UG8t9d0cq0GHCqdPZLJIup9XX31VBC6yQmTzVE+JJBopIHYzaDHYWO6E2x9CYiuzb5FxsfHrrSWq0+HIPqTFwF/n9uGrT97E1OoPEK92o6y8Ej8uzMPAVDPOOmIi4lMZ+Z8Dd+o4VA89vVuCJLeVfZFs0bfZYVQICK0aLkMaPCmjRHltpiqmJCZg/yQHjk6rQ6LNAp81U/St8CSOgCtzXxHEuK2gxV0B+pRvu/8xXHBFQzGoJx+4E2+/+kIbH9CIwE5iLlsEf1wuwn32hF/RwuwrhYZWiFbiIChGWRNC0v1QOFRVVYmYCImkLaSA2A2LRZU5fCLuoZWFYM//uaHCos6KOga/NSsbXV1XjxmfTMf+zh+QoHajsLgSC1YWYGCaBWdO2wumjCHwW7NQ1/9IOPse2GoJ6e6ClR3ZiyPR2nYZZZrXaaWg6OLAyNgFZkF4EwbDlt4f+rSBIgWV5vuANUtYahzMSOjmGIbOhAFSZ191C8649Drx/In7/4v/e6V1EcH9EbBlicZfdGVg3BnwaONghRfKmm+EOI0VoKdTa1DuaD2wTiKR9DykgNjNikXlV7uRZNG3WmnSVPEPDDXrxSBYO+DoFiWkq2vrMPfzFzDB+ycSNR5s2lKOFRu2IDfFgpMPGg9tH5r6c1Az5DSRPtjThAMLR5XX+2Ax6tpVe8Bu1MIfCguR4MyaIiplsiYDW2fT5x/SmoS1QVhqcqb2GBdNZ8SI1Lj8KKnzCCvNww/cj+tvvk2899QD/8VLLzwHXzCGy0GlQn1mQ+S9sWoVAqZ0eNImIKyoEOfKgyqvaUOl6NLW1S6f6MEikUh2DWQQ5W4U97Ch3CmKRbXWe4A9LmxFDTf4+sz9RLniaJgStuCr6RjhX4EkjQd5BWWir0X/ZBMO2Xc8VH0nwJswSKTxxSoc1BVpqHTF0HceUhrqJ6jA/xsGcTGWKw2WBA6InN2a9Fqk2gwibbUt90UEo561HxtgpUxj1UpRfVHRWUUJZ63fsdVSc8w2G3ztKkTcCawLMiAtHilWg3DlPPHIgzDp1KKWwEuP3iV28H8uuqxFHA2LSYl9Vb0alrIF8O9xBlwl82BRnKhe/DYwoKXQ4jlZ5fIJ0dI8rVYikfRMescdT9ImNMFvKHOKgZZNsmKhCnobgibDIWGG9qSMa/J+dVUZFn39MnJ965GmdWFLYQmKi4uQm2TAvhP3hDp7L7jS92ycpXcV/A3snsnZr1bNIFANMuKNwtVAocDAUC0Fg6IgEFLgD4TgCYTE63FmnRicOtK8yajVsDC0ECBcf332waLyIss3E9a0qB1wDML67mm01JlQYFW7/AgqCgamWpGdaBHCIdrVwLQ+/v/AAw/gpUfuhN5oxDnnXtAik4d1Pow1a2Co3QhX2p4IJY2GrXIuEhyrUVu1DuHkltYpChH2x2BNiNYsZBKJpOcgBcRuEvdAsz17DrSykKgW2FCm2g5HzqFNZog1FcVY+u1LSPNtQabOgdKiUlSXNYiHCXtNhDanoQKiO218l/wGDt713oBwP3DwZ/AnHzR7Ww3aLi1A1BBIqUIgFBb1Gdgh1JW2Fywl88T79dlTxYx7V4e/j/UYKLCGp1qF1SFWfwq+xoJAbNXMKobP3XszTBYrTj3ltCaDPvcThSjdYebKZQiMOQXeGQthVDwILPw/aKY93GLdNoMWlS6/KK2eJFM6JZIejxQQvRwKh23GPVQuE620aTlocD/8KzTqq0qw7NsXEecrRY6uFjXl5aivKERmnB6j9pwMXe5eqM09okviHTio0aRNawIHtqEZNiRaDWKg2VnNl+jyYV8KXzDcaLmgpUUddCNoTII3KXbvgF1JYNZ5AnD5Q6Kd+YAUq7DmtAX3PSsNsuDMyy+/jMdvuwpmswXHHXNMk+VoeaCAMFavgWfAcXCYc5DqWgtbyZ/w+mpbNE2jEOT2sJ28FBASSc9HBlH2YjhjZ9wDaxm0GvfgrhDFf4gzc98mcQ/umlJheTD4KpGrq4arugKeinwkWTQYusck6Afsi5pBJ3e6eKBwKHd4UeXyI9lmwNjseIzvl4B+yVYhJHZm50a1WgWbkT0bwlEvaoUrQ9S12IVhrENxnUf8xpGZdozoE7dN8RCBx4D9E8466yyEgkE8cN1F+O23GU2WoWWGlUdZS8To2ASl/8EIKhpYg9UIrfom5nptRlkTYnfhnnvuwdixu/Y1RNgXhNcDK8oSdizl89raWmwvnbGOnYEUEL0Umv3Z54Kmf7bojkk4APvmH0RzK+bsu1P/dUH46sqEeICnCrnaKoSd1fCVb4JVr0L/0RNhHnogqoecKlL2OnOby+sbhEOSVY+xfeMxKjOuzVLbOwMOahQ1vQUOzizjTQFBi8Me2QnbFXfAOhFvvvkmjj32WPj9Ptx++dlYtPDvJsu40vcS/xsrV0CTvTfqdcmiNbl+9efi/ItZE8IXFLEYko5z7rnnioGHD3a/ZItvupyCwR3PbunsQe3GG28U3Tt7G5MmTUJJSYkoB90e2EOEtTd2ZB3dhRQQvZTCGjeKa71i8G1txm4rmrO13oMFdTmHNcY9BOsrhHjwuWqQo62GKVCHQMlaGLUqZA7fG/ZRh6Fm8KmdWhyKZnQOavFmnRAOo7PikWIziNlxd0PrDdtw78owhZVisqjWjXpfAGl2o+g/MSjNBpNes0MVKz/88EMcfPDB8LhduPaC05Cft7Hx/YC1r0hxpUhVh9zwp4wQmTIWVwG0JYtbrI/nKrNjmD4a3totVdIx2FiKg8/69etFwyzO9B9//HH0FOimoqCxWq2iBfmOEAi0FKHdvS69Xi8aje2IpbQz1rEzkAKiF8LZW16FC3FGXaszd33dJpjKG0xujpzDRFtmEnbX4J/vXoKzvhaZ6jqkqNzwF66AVqNC0sDxSNrjaNGCO2RM6LTZMAc15lvShD6mBwmHJpkYKnVj++/tvWkyc4Szfv5mWjQiqaVdBdfPjBVadSjOaEMZlGrD+JxEYdlptX17B2Ezni+++EI0AqurrsIlZ54oWoILVCq40/YUf5qqV0M/6CC4VWYY4UNo0TsN3UVjWHxq3AGReizpOAaDQQw+7FLJlthsxf3111+L92pqanDOOecgISEBZrMZhx9+uBAaEfLz80UnTL5vsVhELwx24aSZnq21Cd/jwEZrBwmHw3j44YdFYyaTyYQxY8aIbrbNLRc//PADxo8fL7bvjz/+aOHC4HpoLcnKyhLL8D22Im/uKvjoo48wZcoUcd699957MfcBl3vppZfE7+M29e/fv8k2tbWu119/HcOGDROvDR06FC+++GKTdf/1118YN26ceH/ChAlYsmTJNi017C1CSwP3Ofcfu57yWHAfzpo1C88++2yj5YjbFr0OxhrxN3D/RcNrjp1L2buEsHU7O7DGx8eLrqu0DHJdXYkMouxlcJCi64KDh9XYSp+LgEtUmyTscdHYJMvvxPIfXkFtbTUS1S7kmlxwrf8bHMs1GcORPvFk1Aw8oVNSFhtTBsMKspPMoitme/3vOxuDjoGUarFvW+sdEuv3ObxB0XMjvLUyBWNRKIxoDRCPcMMgz0kGx1GmnzKQUKdRiRRVija+1p5ZCNdDUcIH4zV8oRDUKhVMOg1S7QbRqIqN0zqSwtoReCP78YcfsNc+E1GwOQ+Xn3My3vjkW1isNpGNwawMjbcaao0OTmt/pDpWwFzxD3zOIgSbucG4r1kptNLp6zSRs6PweDIduDvgMdyRmSgHH5amJhywKBgoKNhpkW2xjzjiCKxatQo6nQ5XXHGFyLCZPXu2EBB8nZaCvn374rPPPsOJJ56ItWvXis9yvYTi4d133xUBtWwnzs8yNiYlJUUMzhFuvfVWPPHEE2Iw5yDKQTIaDqJPPvkkXnnlFTFAs5X3Mcccg5UrV4r1Rq+Hy0UG8da48847RbAv1/vOO++I/h7Lly8X4qC1dVFE3HXXXXjhhRfEaxQHF110kdgX//nPf+B0OnHUUUdh6tSp4jezo+U111zT5v5nbAQtdOeff77YFlrtZs6ciVAoJJ6vW7cOI0eOFOKJcL9FD/zc1/zO999/XwiiCNxWtmmnKKH1hKKEvUvmzJkjvoOp1rRGLVu2TFg0uoKeeceWbPdNLr/SjSqnDxlxrRRyYkbD5p+gDrhFi20GTkbqQKz++TVUVpTCrPJhjM0J19r5wkTljeuHYQeeg5rBJ3dKgSgOcAyUizfp0D/V0mrKYE+BmRh8cLvbM541/D4vrEYdclPMQnRECnhRFAjhIMppNzy4PB/uQLDBQuEPwxMMIuhXEApFCmTRRrN1tq5QVESeN+w3jYriQyVECgfdeLNWzOQpIttTMKszSEtLE7OkfSfvi9Ur/sH1F5+DF/7vI+j0erjSJgjRqnOXQek7Dv6Va2EKOeBe9ikwuan/l1j1OlFyvW+ieadtf1tQPAy/66du+e5V9x3WbuHa/H7AGIOffvoJV111VaNw4GyYPvbIIERx8OWXX+Lkk09GQUGBEAmjRo0S73Owj8BZLUlNTRWzXOLz+fDQQw/h119/bWy8xc/QwkAhEC0gOEBy4G0NigsKGg705NFHHxUD7TPPPCMCdiMwXuCEE07Y5u/n74m0Imf9kl9++QXPP/98E4tC83XdfffdQlBEXqNVhSKKv4UCgoM4LSX/+9//hOCghaawsFBYelqD6c60VER/b3SXUw7uFAG0GrXGmWeeibPPPltYG7gsrRLfffedsEIQWlK4XbSeRO6ljE/icaJQO/TQQ9EVSAHRi+CgXCBSNg1i9tlaqWoWQWIBpLrcw0VGgSrkR97MN1FUmA+1EsZeCU6418yFThVGqS4NY6ZdiNpBJ3WKeGCOP2/G2Ykm5CZbd8j/vrPgBcmaEyW13m3esGvdAXiDIfRNMKNf8vZZVej7Z/nsBouCgmA43Cg6+B6tFTy8tGYI6xAD5kS6KYWOpluLMA0fOgTvfvoFTjzyMMybMxP33HI1HnjqJXgTh8Ja/IewfmkS+8GpT0ZcoAyGvJ/h2+viRhdaBAofll7n/kyz9/xzpCfx7bffCqsBZ6UcVM444wzhLqCY4Mx07733blyWMQhDhgzB6tWrxfOrr75aDIY///yzcH1QTIwe3bINe4QNGzaIQa25MKAVgzP4aDiItgYHxOLiYkyePLnJ63z+zz//tHs90TTvJMrnkUyJWOtyuVzYuHEjLrjgAmF1iMB4jUgwI/cT90e05WPiNjqW8jspZnYEWoloIaIApMCiNYiWCR4jwn3EY0FLYDRer1f8pq5CCoheAk3lmypcwuTdmpmaJmRr0WzxtzNz/4YgyHAIxX++j40b14p+BZOSPPCv/wMmTQgbvfEYf+KlqB96aosb/PZmWFAwjMyME0WtelKcw7bgbL4g7G6sSNkcvs44Ay43Kj0Oabbt/338nFGt6TJ3Q1czdf9JePSlt3DdBafhm08/RHZOf1xy7c3wJI2EpfQvqENeKCkjgKIy6D3lCOf/Dv/AI5qsgwKY53JpHQOBu99CRTcCLQHd9d0dgbEK9P9zZtunTx8hGtoLZ+w0hXN2SxFB9wRn5LRgxIImfcLlMzMzm7zHOIZo6AboDDprPc3XFfktr732WhORRTSa7b8WTVtdPTsCj+VJJ50kLCAUEPz/1FNPbTy23HbGl8SKCaFLpKuQQZS9AM5K86qcqHX5W23RTaHQmLJp7wdPyhjhzqhe8jXWrPpH5OePSw5CmzcbFpUf6+qNGH3UpXCNOFNkaewIDBoscXhEcOSYvvGiYNGuJB4It51xBPTLx7I8lDm8WzMb4oX7aFf7fZ0JA3dPO/4oXPXfhmqT0598CN998TE8KaOF6YQVT80Zg+BWWxqCKZd/FjOYkjU/ekqDLQoYuhG649FR8cRBkemb2dnZTcQDff+cTS9YsKDxNcZGMKZh+PDhja/RpXHppZfi888/F1kcHFBJxI9O330Efo5Cga4Pfmf0g+tpL5xNU+zQvRINn0dvW0eYP39+i+fR8Q+xXHDchk2bNrX4LXRlEH6eMQWc2bf2Pc2hxaKtdFXu1+h92pYbg0GljAmZMWOGeB5hjz32EC4qupeab3tXpoJKAdELKKv3orDaI4outXazsZTOh85VhrDW2Fiq2rVuFlYsngOWOBiQoEFK0SyYwk6sqtZg2GEXwL/HuTscMMn0TDZm6p9sFVkWu2qjJFoDmPLIgEr+nuauI/bZ4Pvb46vujVBsnXfBRTjlvMvF87tuvBJ/L1kBX9yAhgU0BrjtA6BVQjBWr4W+9t9MgOh97gsqqI4h2iQdh4GIjMyneZ4xCjR7M9iRlgO+HokJYMwEgwMXL14sYhAigy6zOnh/oYukoqJCzHppMmc9h+uuuw5vvfWWMJfzc4w14POOcNNNN4m4B/rzKWoY4Ejz/7aCFFvjk08+EYGYDFJkbAOzJ6688so2P3PvvfcKq8tzzz0nPsegS8YSPPXUU+J9uoO4D7gPV61aJTJUGLvRFrfddhv+/vtvXH755UJ8rFmzRliIKisrxfv9+vUToo6Bk3yNbqdY7L///iJOgsKBgibaSsLXkpOTxXFkECWPH2Mf6JJijEZXIQVEL6g2ubHCJW62rQWb6ZzFwnRMWEGRosBftBTL534r/OzxVjNG1M6CxlOF9dUK+u57CjSTLkNYb9/u7eKsnNUkGU0/IjMOg9OsTRoz7Yqw/TfTIEXAoz/YGNPB4MXBaTbRl0PSAC0wtDSdd90dOPjwoxHw+3HthWdivbch+E4ddMGSPhgBaGEIORFa/nnM9XCfsp5Jk0qgku2GgyFN3Yzqp++e1ykHQfrXCWfCzMSgaGAE/+DBgxuD/yg0OMByYOdsPTIYM0CRGQ8ceCOfo0sjMmtvLxzsrr/+emH1YBAnZ9v0+UdnYHQEbitrlNAC8Pbbb+ODDz7YpjWDLhwGInI/cRsYBPp///d/jb+FsSXffPONEBbjxo3DHXfcIURPW3Af0h1EwbbXXnuJ/f7VV181WocowOgi4bbR3UBrTiwoXE4//XSxnmjrA2FgJbNfaHViACiPA2M5aCmhdaerUCldmYjeDTAYhyaburq6Lt1xPcV1sarEIeooZNhNsZsfhfxIXP0uNL5a0WLZkXs4lOo8LPnuFdS4vFDprThaNRfe0nUocihQDTkMmac8gqA5bbu3i/EAZfUexJn0GJJmQ0JrbpVdEF4uTJNliXCrQSfcMyMy7a1nvezG8DxYXFCDqhoHbjr/JKxYugg5uf3x21MXwaryQFFrUL/sW8T7S+AwZsF76qctLF4N55JXFBeji2hnwJsuZ3AcNNpKE5T0XHgvZIYC0xwlHTvHOzKG7tpTwt0c3liLaz1ItrRebZJBkxQPIb0d9X0PhNpdgVW//J8QDz6NFccalsJduh41HgWO1PHIOvG+HRIPrJXAYEIGEY7OiutV4oFwP/dLsojZNa0/A1IsrXc53c1hsGlmvAnQGfDs/95HRmYW8vM24aHXvhBmWlU4AFXqcM5ioPNWQre5pZ9YtGhXq1FS6+nSolsSiaTjSAHRC1wXrbkG9HV5MFUsE387+jEPWMH63/4PpTV1cMOEkxI2wVmwDP6ggo2qfhh+zpMI2Pru0Daxj0VOkhnD+8T12ngAFnuiK4OWh+wkS7dnCPT0WAjGvehtiUJEGE1mvPvTX5g9i0WEVLAlpsOptkIPPyCCKcMxXUdVbr+Ip5FIJD0HKSB2UddFfpULTm9AFGOKBQtD2fN/aaw2GbBkonjue9hcVCQyLo5Jq4J3819QKSEsrrVj3AVPIZg0eLu3iTd3lk0enGrF4DT7Lh/vsC2Yjro9Dah2N3geZCaY4PQFMGT4KDz07Mvwh4C3vpuPVcuXARod3HGDRDCloXYDDGwrH2MdwWBDm2+JpD3QWiXdF11P777L9+asixoPUqxtNMraMgPqgFOUEHZmTkbtsu+wZs1KYS6emOKDruBPaIIezC/VYNRZDwLZ+2z39rDyZTAUxvA+dlE8SQ6qkuYpsLRGufwhHHL4Mbjyxjvwd3EIc2b8jNLCzbCn9RfBlLqwG8o/H8VcB60YLCwl23xLJD0HKSB2MRj9z4JRbPDU2izfULMWxuo1gEqNun7T4ClYgpULZ0EdDmBgXBgZ1X9D8dRgUUkY2UdeB/PY47drWyL1DzQaFYZn2kVcgDTnS5pD8ZARZ4TD25D+etHVN2LCISdgfVUQP373LfwBP+qMmdAhCMOWOVD76lqsw2LQCBdZrDocEomke5ACYheCA/bmSpfoUsi217FQ+52wFcwQf7vS94TP68WKWZ8hEPQjzRTGqNBa+KsLsa4qDP2Yk5E+9erGNt4dgc2gOCNkmh07O7JtuETSGql2o+jTQQsCReZ9T7yASvNgeDwezP75WyB5kCgmpfVVw7Dh+xaf52dMOi1K6pgaLIMpJZKegBQQuxD0ARfVeltvPqUosBX8CnXQg6A5Fe6E4Vj529twejxI0Xqwj7USnpI1KHQoKE8Yj6HnPA6oO16ilTfwkjqPqHrJQMKe0jFR0nNhIGSKzdgYCGk0mXDd0x/ArTIhv7gC65YtgkMdBy2CUK/8HAi3DJi0G7Wi7kbzQl4SiaR7kAJiF4Ezt02VLujUqlYLRhmrVsJQt0mIgrrsqVg/+31UVlchXVWLCakq+PL/RoUziLX+NIy/+m1A27RWfXtgrENpnUfk5LOyJHs/SCTtgW4MwuJl4nlWNiafe7cQw/kb12NLOAkaJQydIx+m0r9jZr+ooEJZXdtNzSQSyc5BCohdxHVRUOUWs6/W6iqo/Q7YCpkaBzgzJqJw9Xzk561HX5RjcKod2vw/UOHwYUWNAaOufh9aa0Nr3o7AGz8DODPiTRiWYd8lOmlKeg4Jos24Do6odMwBB5yJCftPhSsArFq6FB4YoFb8UC95p9X+GLTE0Y0nkUi6FykgdgFYW6Ggxo1EcyttuhVFpGyy6mTAkoFSjwbrl8xCX1U5UuLtSK6Yj7IqBzbWKkg+9VkkZLfeUKY1WEqY3TSZujg0w7bLdoqUdH95a18oJGJoiKLRY+i0i5A9aDg04QDWOAzQKUHoypdD78hrsQ6KVrZLl1aI7YP9EWjxqa2t7e5NkWyDAw44QPQmwe4uIKZPny4ahrBkJhuAsKlJa7DuOE/w6MfuXE6WA3depQuUDa3N+E2Vy6B35ENRa1GZOBYrZ3+KpFAl4gxaDApuQGlpCUqdYVSPuQxD9j1mu6pLVji9okDUkHRbqy4UiWRbMG7GYtDB6f23w6YndSz2n3oEzPFJWLe5FCGoRa8M3fL3Y66DJdIZTBnpRyJpoPl9s/njnnvu6e5NlPQyulxAsLMaG6SwGxq7tI0ZM0b0my8vL2/1M6y/XVJS0vjIz8/H7kphjVvUWUiyxI5XUPtqYS2aI/52pu2Fpb9/BaOnDClaN0bY3CjfsgFVHgWLjZNwwHl3blfsRZXLJ8o3s/oiWzVLJNsLLVcZdmOTFt1s2hZKGY59Dj0RJnUQmz0WaJUgtJsbGrw1x6LXCPEgC0s1Jfqe+cwzz7S4j7Jpk0TSmXT5aMA2qGx9et5554luYy+//LLoHMY2q61Btcy2pZEHO7/tjtS5AyL2gTOumMWZolwXfltfLFy9AeHqjchRVWBgig2Ozf+g0hnArKoUHHn72x2u0dAgHvzITbKKVtUMYpNIdpQUuwEGrapJUShWS7XHxWOvyVOwvLAeKihQeyph2vhdi8/zPGYjs6Iaj7COSRqIvmeyGVLz+yg7SUZYtGgRJkyYIO7FkyZNEu2zo2G76QEDBkCv12PIkCF45513mrzPdb/yyiuiqyfXwe6P8+bNw4YNG4Tp3WKxiPWyvXcEWkDGjh0rPte3b1/xuVNOOUU0bYp2sbBjJT8fHx+PyZMnN5lAtme72E3z+OOPF+tnJ0929GwLdhvlcrR0c6w56aSTGt9jR9B9991XbEtSUpL4vdG/afPmzeI7P/74Y+y3334wmUzYc889RStwtvDmPuZ+P/zww0UL9AjnnnuuqJTJjqHswEmxd+mll8Lvbz3DyOfzCRHIrqjcP7Tmc39F4H46+uijkZCQIN4fMWKE6LTalXTpiMCdwRP1kEMO+fcL1WrxnCdba7DPPHvP8yRjf/OVK1did4OpkpurXAiEw622iTZVLIG+fovwI6/xJaF+/VwMVhUiKTUNKFqMkhoX5pdoMenWT2AyWzr0/R5/g+WBzaIGpFpldUlJp2EzaEVKZ21UMGXQkiHid1IHjMGQnD4oD1pEYang0o+gCnparsOoFYGUlc6dlNLJmI2gv3seXdBEjG2on3zySSxcuFC0lT7//PMb32MXy2uuuUa01V6xYgUuueQSMQGcOXNmk3Wwjfc555yDpUuXYujQoTjjjDPEsrfddptYL4O/Iy2/I1BgcLBlS2wOzkuWLMHll18u3gsGg2JQZQvtZcuWiTHi4osvbpz4tHe7OChTmHAdRxxxhGh9XV1dHXM/cDvZRvy+++4TIorbtP/++ze+73K5hAWdy/32229i/KI4YTO4aGhh/+9//yus7Nyf3Bc333wznn32WcyZM0f87rvuuqvJZ7i+1atXCxHAVuOff/652PbW4L7kPmGLcv62k08+WbROX79+vXifbdgpMtjWm+3G2WY8WjR2BV3a7aiyslL0l29uQeDzNWvWxPwMVSWtE+zhTmX6xBNPCCVLEZGVldViee4wPqJbkfYGWGeBhZpSrbFdFxpvDaxFc8XfZbaR2DjzawxTFUBrSUJK3WqsKa7A2sowrCc9hZz+gzssHmrcPgxMtaJ/slUEv0kknQUHBKYB8xxnWnDEsuVK3wvxG7/CiNFjMe+vBUizO6FzFiG48TcEhxzVZB3qrYWlimrcSLMZut46FgoAc55Et7DfDYC2c2utPPjgg2KgJrfeeiuOPPJI0eKZs3DeczlDjgzsHEDnz58vXj/wwAMb18HBmwM1ueWWWzBx4kTceeedwkVNONhzmWj4HW+//baYRZPnn39efDfFDK0KvOdzlk8rA6FlI0J7t4vLnH766eLvhx56CM8995yIu+Ng25yCggIxW+d32mw2MXEdN25c4/snnnhik+U5NtFisGrVKowcObLxdVoGon83v58CgRYUcsEFF4j4vmj4e7k+WkpoLaCIuemmm4Qwo1Bpvp1vvvmm+L9Pnz6N30nBw9f5O/ket3fUqFHi/f79+6Or6XE2aZ6EVLU0dfEEpyrjAaPZKxYPP/ywMNdFHrRa7OqwZC8rTlr02tg3RiUMe/5Poh2y15KFP+b/icGhDdBq9Bioq8SGzVtQ4VawPOtMHHjEv+a4jogHWh2keJB0ZTAli0s5ooIp/XH9ETSnIGxKxpjhI+BSjDBoFJR99zCUUEtLAz9f6w6g2iULS3UUTtAiZGRkiP8jcWmcFUcGvgh8ztdbW0dkkhgZvCKvUTBET+qys7MbxUPkfs/ZPGf/iYmJYvDnQExTPGfvjN2IsD3bRXFA90BrMXdTp04VooGD7dlnn4333nsPbre78X3O7ikG+D7Xw2QAwsG6o/ui+TYwHpDiIXpf0Pq+ZcsWNIcWBU7GBw8eLKwKkcesWbMaXSq0pDzwwANin9AiQitFV9OlFojk5GRoNBqUlZU1eZ3P6ZNrDzqdTihCmoBiQXMZlWgEnqy7soig2U902vQFkRn/78kVjbl8MXTOYuG6mJHnxEDn3zCqghiYqEX+ug2o9wbwYeUQ3P7oIx0WD9XS8iDZCWi2pnSuKKqDougazNQqFVzpeyNu07ewWYxYr81Cbmgj+ujr8fvbD2Liefe2WAcfRbUe0Ta8S89Xja7BEtAd8Ls7Gd5XI0RcBM3N8tuzjh1dL2fTHAg5s2YAPt0Cv/zyC/bZp/3N/qK3IbIdrW0DrQ50O9CN8PPPPws3A2M1GL/AuAcKGQqM1157Tcz8uR5aHprHKujasS86un+jobDgWMqQAP4fTcRNceGFFwrx9d1334nfwsk1LTtXXXUVdkkLBE0048ePF6acCNyJfE611R6ouqi+Iiq5OQaDQSjD6EdvKFfNG2IsGJVuKf5T/L3M1wfJBT8iTuVCVqIFNcWbUFfvxv9WmXDpo++3uJDaQooHyc6G5zjje1y+fwMhffGDEDQlIWhMRkZmX/ihhVWvgmHFe1izfHHM4lRVTj+qu7q8NQcFuhG647GTG9TRbTB3boN7NAKfMwh+R+HMvbi4uPE5XRA019N1HYETRk4M//zzTzFYv//++126XYxZYFzeY489JmbtDIycMWMGqqqqhGWEIubggw8W319TU4PO4p9//hG9YKL3BcVArAkw9wnHQloxBg4c2OQRPRnnZxmMScs9Y0UofHZZCwShdeA///mPiEZldC3TixiYEvGN0V1BkxbVEqEfiGqTO4bFTh5//HERXUp11dthRHmb5aobXRdBVOnSUbX4e+SqamG3mKBxlqKktByfrgrikBteR1pGg5+sPTAavsbjx8AUKR4kOzelMz3OiI0VTliNW29FKhXcaXtB6/kBVoMa+bq+6BPIw/hsM27+739w57tzYbX9O0mIpBUzIyPRrJfnbidAPzxjGzhocWBlwCMHpF9//XWH180YC44HjFugtZjWBn4XB8G8vDy8+uqrOOaYY8Rsn4M3XQgcI7pqu7799lts2rRJBE4ye4FZC5zkUtDwOTMvuE2cwFL8MF6ks/D7/SI2ggKFooVuBwZKNo9/IHRdMBiU+4JWBe4DZnVwMk73CeNIWHSK2R5clkKHwaXRMSS7pIA49dRTxQ+laai0tFTENtA8FfET8aBE7zD+cKZ9clkeQFowqEQ7Q/32dIprPMKnG+kZ0Bxz6d/QuUoRUhvw57I1GKkUwKhRI03rxap1m7GgKITgPldi0pSDOpyqyWyL/ilSPEh2LszG2FLtFudhpLqpN3EILCXzEDQlIy7Fh1BxPhJMKhyaXov7brkGj05/o0lKMuMpyut94jxOsXW8v4ukKcyEYPwBB3kGBObm5grXAtMzdxRODE844QSRHcHMCAYvMo2SMB6AwfVvvfWWmP1z0GZmAbMtumq76KagCKHbgvEaTOdkRgSDGgkzHihyaAmhqGBAZmfsB0KrBr+P4oWJAIy1aKvYF38rYxxoWSgqKhIhApxscx8SWii4vwoLC4UlnkGjTz/9NLoSlUKney+CqpbBlIzm3ZXcGUxJW5JfA71G8+9sLAqtuxyJaz8AwiHMLtMjc8s30KvC6J+ox4b167C6uB6vlI7G9A++Fya59la5ZIXJ3GSrcF3IVE3Jzoa3n+VFdShz+JBu/1c4GyuXixon+ro8bNm0FhnhYmxxqnDm20U48frHceo5FzRZT7nDiySrHqOz4ndYBHMg4WyYA9TuXAW3s+Hg+OWXX4q0z92dc889V1jYuT+6g7bO8Y6MoT0uC2N3bpblDYRjigeKBvvmn8T/eR4Tkrb8BLUqjL52iDLVJdVOPLrQhHufe7Pd4oGNsSLlqWl9kOJB0h3QkpARZ+JVIFI6I3gThyOkt4usDHNSBsJQIdWqxemjjXj8vtuxbvWKJuthk7kKZ4MVQiKR7BykgOgB8MbH2v6tBU5aSudD66mAO6RCxZo/YFb50McYQMAXQFFxCe773YerHnoN6Rn/pkdtSzzQ5JudaBblqWWFSUl3QhdEvFmPuqjCUmxJ707fE2GdFUl2K6rUiTDAj6Mn9EEfkx83XX4+3G5Xk1gINvtm6fdwuFcZVSWSHoscOboZuhHyq9zQqlXQa1seDq2rFJbSv0UA5cp1G5ESrkCS2gur0YC8TZvw4l9+jD7uSux74L/VPtuCs7yGrpomWZ5a0qNSOtllM9qj6kkaiZAhHkFLGvT2VChQIcUMnLd3IvI2rMOjd9/awgpR6fSh0iV7ZPRUF4Z0XzTAolLd5b7oTOTo0c2wGh+bZTEdrQXhgMi6oHjIKy6H3bUJZviQatNhU14+vlztxQbjaFx103/bXR67zOEVJuNBaVbZGEvSY0iy6GE16lAfVViKVghn5mRhhUiMT0CNyg5j2IPT9xuE7Dg1vvjwHfzw1WdNrRAqlcjI4LkukUi6FjmCdCMsFlVQ7YbNoIsZg2Atngetpwru2nJUleTBCjcyTQGU1Tjxx/oavLbCgEdfeAM6/bbL3IYVBWX1HqTajbIlt2SX6NJJfPGDEbCkIWTPgtacJKwQpmANnrzkYPH+fbdei8L8zY3LU4izlgpF+Y7Sy+LLJZJOP7elgOjOwMlqlyhbbTe1LPjESpPm8kVQuauwpqAEqaoq9NG5EVIZsGhNAe6a6cPtDz6Fvv1y2/VdtDwkWgwYmmFrTJeTSHpal06jVi2KmjWiUsHZZ19hhYhLSEIdrDCGnJiYqcIR++0Bl7MeN195AQKBQKMVgo/8areI9dkeIgXYoksaSyS9Cf/WSprNq1r2uDoQktgwWry4xoski6FV14Xa70R+URHM/koka1wiT3reis24/VcvDjr2DBx5/Mnt+i4GTFKkDE23wayXh1zSM7EbdUi1G0RpapOemRkNBOw58NtzYAw4oakqguJxIlyzBU9fdgz+WLYJK5YuwotPPoxrbr2r0QpBaxtFc1ZC7HLwbcGbKusDRHoX8LqLrjshkezKhMNhUZuJ53V7s/ZaQ44m3QBnRux3wXtSLGuAtfhPaN0V8JStx5ZaH0aoq5BkVGN9URXu+60OStIA3Hb/Y+36LppzTXoNhqXbYTN2fk19iaQzSY8zobjOK4KLo4OKnZn7Qu/Ihz0hDbWeOsSFHNBULsMTD96Fi6+8Hm+8+DQmTTkQe07cT7gDzTqtCE5mZtP2WNwi5YFba8IkkezKsHgjG5vtqDCWAqIbKK3zimjxNNu/s6wIbF9sLlsEbdVaLKxQYZhqC5L0IdT5dHjilxL8VabBu1++DrNl233ea1x+0EJFy0OcWYoHSc8nwaxDitUghC9bfkcImtPgTRwKc9ANXXURwl4XQjX5OGoPD44/7WwRUHnb1Zfgs5/nIi4hQXTqLK7ziLTOgam27atPkZGB1NTURveIRNJb0OtZ9n3HIxikgNjJuP1BYX2w6GMETtJ1sfknMdNaX+VDdqgIdo0fOp0RL/2Sh49XBXH1bfdi+Oix2/wehyeAoBLGiIw4JLVSX0Ii6Wlw4GZKJ91utNRFZwo5+0yCsXY9TImZcBbXwx6sg3/zH7jzxnuweMGfyM/biHtvvQZPvvyWWE+8SS8yMhg4TPfI9kB3xo76iSWS3ooMouyGipNOXwj2GBUnzYVz4Fg/D6X56+Bw1iFZVY84oxZfL6/Fc/NcmDBpf5x7ybZbszIw0xMIYXCarcksTiLZVVI6k6160RcmmrAhHq60CVBSR8CgN4KhlsHqAmSU/IJHX/gftDodfv3+a3zx0TtieYtBK6q7Fla7ZUaFRNIFSAGxE6lxB1BU19A1sLnvaf4vn+OXF25AyfLfscmlRbaqApqgB8tL/bjtmyJozPF48OmXt2l2YlOiOnbWTLUgM76li0Qi6emwlwWtEMFwuEU9B1f6XgiaUqBN6gcPDDAFa4H8eRjTLwFXbq2H8shdtyJv4/rGKpfFtV5UyxLXEkmnIwXEToIVIDdXuljyXwQ1RjNjxm9Y+s5/kWt0QG1LQbq2XhTMKalx46bP81HoUHDP489ts0U3Tb5VLp9ojpWdaJGR45Jd2grBypK17mYDv1oHZ9b+QNpIGHR6Xk4IVG9G/IbPce7FV2KvyfvD63Hj9qsvFrELDKDkVcCAyuheGxKJZMeRAmInVpxk86rmaZuhcAjfv/4A9s/wI9FmhMFsRqLKiTqnB58s92DulhAsiWk48LAj21w/Z2oNJarN6J9ikW25Jbs0LLFOC5o32NIK4YsfBF/CQKiTB8AHHUyBWqgKFsDo2IQHnn4Jtrg4rFy2BK8+25CpxBggXnu8BiUSSechBcROqji5ucodM3Dy7TdexdSEYvSPC8NotcOi8sHjDWBlsRvPz/cCGh38GjOWLlmyzSqTbIfMEtWyv4WkN8AUzHizTrS6b4JKhfq+BwHpo6HTUZAr8FdvQcL6T5Ge3gd3PfyMWOy155/E0oULxDXHa4/XIK9FiUTSOciRpothZ0C6LhjYyNSyaGbMnIH8H6Zjn7QAEmwmONVW6MM+lFU78OgcN3whQGtPhUqtRmVlZavfwZQ3Fs8ZLEtUS3oRrAPBpm8ef1CI5GhCxkS4MiZClTIYfmhFeWulcBGMlStw2NHH46gTTxUFc2675mJRrZLXHjOgCqpcMqBSIukkpIDYKa26PUixGlu4Lt56/mGcN8yLLBtQq0uGBT6U13nw3SoXlpaGobYkQK1v+FxycnLM9bPmv1GvwZB0u6wyKel1pNgMiDPpRVpyc1wZeyOUuRfUequIcwjUFiJ+/adAOITb7nsMfbL6oqggv7FrJ92HRbVeIbglEsmOIwVEF8KMiLxKF3RqdYtW3UsXL8ZpGQUYnhiEV2eHA3a4/GEUl9XglUV+qLQGaCwJYtm0tHSMHTeuxfp5U1WgYEiarYV1QyLpDdCilplgEtaD5lYIRWOAI/cIqFOHIgANzME6hIuWwlS+GDZ7HB54+mURSPzlx+/h1x++FuvSqVXYVOmCLxjVb0MikWwXUkB0IayCxyhyRpM3x7xlNo7P9UGt0WKTNld0GXTXlOO9fzxw+lXQxqU2ZlHccOMN0KibuibYcMgdCGJQmk3M0iSS3gr7Y9AKURfDCuGPHwDfoCOhGOKhhoJgXTES1n8GhIOYsM9knH/5tWK5+265FpXlZVszOwIorJYBlRLJjiIFRBfBMtJs1c3YBHWzdEqNuxIHeL6HTqOgVJOBCiTA6CnDyi0OzMgLQWNLgkrbIDouufRSHHTgQS3SNavdTNeUtR4kvR9aDrISY8dCkLp+h0PdZzS8Kj0s4XoEi5fBUvyneO/y62/DkOEjUVtTjXtuvlq4OuJNOtEJV9aGkEh2DCkguqrmQ5UL4TBaxCVovLVIW/gY4lRuBLRWLNCMRR+lHKUlpfh2XQBulRlqk10sm5qWhvPPP7/VdM1+SbLWg2T3ioWIZYVQdGbUjz4PYWMiVHTq1Zcgfv1nUAW90On1eOjZV8X/s3/7CZ998LaoUMmSEHmVTtG0SyKRbB9SQHQBxbUeMcgzDS0ata8O8Ws/hKV8EcIqLf7RjYNd5YHWUYQVJR78WahAa08RWRdMVbvxxhtbuC64Xt5MB6bKdE3J7meFiBULQTyp46HkToFLZYIl7EL9poWo/P1lEaw8aOhwXHXTnWK5x++9HVs254lrk8GUW6rd3fBrJJLegRyBOpl6b0Dkm1ub1XxQ+x0iT91S9jdUIT+KlSSUKvHopyrDmrxS/LklBJ8pBSqNFmmpaXjsscdauC6YccHZE3tcbE+LYolkV4bCOb4VKwQF94/uEShzaxBUMaCyBo7fp+OM4w8X6dJnX3Q5xu89CR63C/+9/jJACQv3Yn61S1xXEomk40gB0ck1H1gylwGO9qisCFXAjYT1n0PrKoOhLg8+QzIWORNgUXnhrSpBoSOEQM5+ePjJZ/HKK6/g62++biEeWAAnBEUUirJtZ2dBiaS3WiEoEi6/4zG8v8yLurABJlUAw1J1OCS+EDfffDNmzZ4lqlRarDYs+Xs+3nrleeFeVMKQWRkSyXYiBUQnwhbEdF9Euy5UIR/iN34Bjbcaxpq1CBniUezVoiRkRV+lDMvWF2KDJx73P/d/OOywaRg/fkILtwX9tKzGNyDZglSb7K4p2X3h+R9v1qMuqlMn3RRPPPEE293irdU6rK7UwKfSIdUYxIkDA0gzhfDkE08iPTMLt9zzsPjMC088iHWrV4oy11VOv3RlSCTbgRQQnVjzgRUnOUtqrPkQDiJu49fQucpEQJc66EQIKiyuj4MNXpQV5cPhC2Patc/BHhcfc70MmmQd/74JJvRNtOzcHyWR9DB4bWUnmuEOhBp7ZLDMe3lZmfi7zq/BG0t8KA1YQQ/i4CQ1zh/qRllZqVju2FPOxAFTD0cwEMAd116CcDCABLMO+dVuWWBKIukgUkB0EgVVbtR6/OJmJFDCiMv7Dvr6LVA0eqgDTrG7Cz0GlIesiA9UYFNBOeJGTMWEKdNaXS/FAy0a/VOsLfpoSCS7ayxEkvXfTp3Ny7z/VqjHrAIFbkUPq1bBiYPCGBQXFMsxa+muR55BfEIi1q5agVeefUy4MtRQYWOFU7hHJBJJ+5ACohNgENaWWjcSzYaGtEpFga3gVxhqN0JRa+FOGQtj7QaEQ0EsdZhhgB8Vhfmw2uNw8GWPtLpeBotxxsViUTJoUiJpQKdRo2+CWcQtMGW6eZl3V1CFb1Z7sdydhLBKhSw7cO0YN5KTksT7yalp+O/DT4u//zf9aSxfski0D6cg2VThatH9UyKRxEYKiB0ksLXmA4OxTPqGQd5U8Q9MlStEZDhL7VoLZ4mOgSUerbA+qD21ou7DnsdcAH1i35jrZdyDyxfAgBSrLFMtkcSwQiTbDKhxB0SZd9ZM4fUW4c9SHeZsqEe1YgM9ikf2Byan/1s46tAjj8Xhx56EUCiEO667FD6vV8RXFNZ4RAVZiUSybaSA2EFKaj2odPoaAyd19VtgK/xd/O3ssy/CUMFcuQxK0IclDitUioK6LeswdvyeSNn7pJjrZLdANuFisag+cbLSpETSHLrz+iaaEQyHEVYaaqYItooIb0iFOZsD+L0yEUFFC6tBjYxFjwPhf4Mvb7//caSkpmPzxvV47tH7hGUjzqhDXoWsUimRtAcpIDqx5gMLRcVt+lbEP3gTh8KdNgGJaz9kfifKPWqUhu2ocfpgCHkwbspR8NtzY66XNy+W22Xcg1rGPUgkMUm2GJBKK4TLL9KeWTslNTW18f2/ynUornRiJXKEW1FdtR5Jy15tfD8uIQH3PP6c+Pvd/72EhfP+gNXIKpUKNpTXi8BoiUTSOrL/cyfUfOjDfhThAOI3fQN10IOgORWOnKnQ126AqXI5EPJhkSMOAUWLwJaFOHjakfD32bOJyTUCg7iCYQX9Uy2NLhGJRNISiuusRDMqnX7h8qOImDJlisi2YMAkYyMmZQJVS75BTUEZ4kNuJKx8G47cIxGI6yfWsd9Bh+KE08/B5x+8jTtvvAKf/TwXyTYLSuo82FThxJB0uwxelkhaQVogthO6GHiTEa4LRYE9/xdo3eUI68yoHXAMoNIicd3HUIVDqHCHUawkotCjxz5D0pDcJxvepOEt1smZD326/ZLNSGlWBlsikbQk0awX3TprtmZksIYKa6lEaqr4Uschu28Olun2QFBRI+x1oM+8u0V9lgg33vkAMjKzUFSQj6cevFs0v0uxGlFQ7UFBlasbf51E0rORAmI7oGkzr9IFnVotsiRMlctgrF4DqNSoyz0KYb0dhpp1MFatgCrkwV/VFvgVPQw1mzBhr0nwJI2AomkpEBgFnmjRITtRNsmSSNprhWBGhkrdcF22XEADZ9YU9B8wEJuUDBEzoS9bgvjVHwjhT6w2O+59Yrr4++N3/of5c34X1zXdiBsrXShzeHf2z5JIdgmkgNgOCqvdYrBPsOihdVdszbIAnJn7ImDLEjem+A2fQRUKoLjKiRJtOlYHUnHWxFyo1Wp4UsbGzObwh8LISbL8W4hKIpFsk3izDn3ijK0GPvrj+sOWMRCViePhCJsRCPiRtPa9xpbfZJ99p+DUcy4Uf99905Vw1jtE3xlOEtaX1cfuvyGR7ObIkaqDMGCroMYtGvFowgFRLEoVDsIX1x/u1PFiGZ0jH6aqVQh5HPi71gq3YkS6xoW0tFT443IRMia0WC9vfml2Y4sOnhKJpG1orctMMMOgU8Pli1EISqUSVohh2elYo+4Pb1gL1BUhYe1HMNByuJXrbr8HWdn9UFJUiMfvu0O8lmjRwxMICREhgyolkqZIAdEBgltrPoTDENXrbFtmih4XYb0Njn6HNQZFxm3+QZSuLiwuQYWlPxaFBuLc8Q2iwZ0ypsV6eWOiCZZpaTJgSyLpOHajDpnxpsbqlM1hYLOSPgqmzNGoUOLgCqlhKpkHe9730DmLxTJmixX3PTldCJIvPnwHc2b+Il5nPARTtTeUO8U9QCKRNCAFRAdg0CT9obQSGKtWwVi1UoiGun6HQ9E21GugS8NcthD15Vuw1pcIh2JF3yQ74nUhITT89obo72iq3T5hgm0sgy2RSDpMZoIJFqNWpFfHwpUxCf0zErHWMBJeRQe/1wNr8Z+I2/S1SMEmE/aZjDPPv1T8fe/N18BRVytEPYtMFdW6G4rGNesEKpHsrkgB0U7YTlvUfDDooPfXwLZlhnjdlTGxIe5hK9aCGQjVl6OiogwltuGYHx6GMwc1zIoYPClMDdHr9QZFmWoWjZKBkxLJ9kOrIJvOObzBmIN8WG+FJ30vDB/QH3lKBurDWqir10NbX4j4jV83ZmZcdcudyMkdgPLSYjyx1ZXBIlMJJoModc1qlRKJRAqIDvW7oIiIM6ga4h5CfvhtfeFK36txGc5irMV/oLxgHYqUFFSrEmBNyUG2qkJYKoSAiII3uTqvH9kJZtiM0vogkewo6XEm2I1a1LYS9OhO2wO2hCR4U8fBrRhQF1DDXPSnSMFm51x20DWZzI2ujC8/fg9zZvwsPsu6LFaDFuvL61FeLzMzJBIpIDpQOEqjUsFa9IdwU4S1Jjj6Hd7EomApWYCazcvg97hQZBuBheHBOKd/vXjPb8tB2BDXZJ2cKdF3m8FCVBKJZIehNS87yQxPIBi7KZZah/q+B2FEViI2aAaCIQ1eV51Iu2bnXMYvsZLsuD33wdkXXt7ElUEo9Nm5c11pPercMjNDsnsjBUQHMNfnwVy+WPzNoEmaRCOogh5o136D2uI81MCOck0qKswDMVa3RbzvSR7ZYn1Of0D4bWWnTYmk82A2U6Ll3+JSsdI6g4mDkDVgJMqUBHiCYShV66D21cNQs76hl42i4Mqb/ouc/gNRXlaCx++9vfHzSVYDvIEw1pQ5Ymd9SCS7CVJAtBOVvx6pRb+Kv92pe4ibUDSmsiXYsnQmdKoQiq3DsTg8GKcNUqANukV1Sl/cgCbL88Zj0mlk2qZE0skwXiEn0Sxqq/ARi/qsKUiJs6ImYRR8YR28Tge09QUiJdtUvhSW0gUwmky4f6sr46tP3sfs335q0g201hXAmlKHTO+U7LZIAdEewmFYNv0ATcgr0sFYMKrp+0GU/voCNN4auFVGFOmysUo1AIcmlIq3vYnDRUW8aOq8AaTZjKJYjUQi6VwozGmJaK24FN2Jroy9MaRfXxRq+sAXVsFfuhpKiBYFRRSZMlX8g7ET9sbZF10hPnPfLdfCUdvgymC5a66/ot6PtaX18AWliJDsfkgB0R4K5kHr2IKwWoe63CMBddNB37luNipX/QFmYdYljcZiZTD2z7UjwVco3vckj2qyPBv/MDWMNyCJRNJFJa4T2yhxLSyJ46G2psCeMw61ihU+nxfh4sUI6SzifVvBbzBWrsCVN96BfgMGNbgy7vvXlSGuYZtBpHevL3O2au2QSHorUkC0B4U3IBUqM6a0qCLJTIr5b96JNGMQWqMFG9AXS8IDcUpWtfCjMlOj+WdqPX7RLIsleCUSSdeQEClx7f63cVYT1BoRUNkn0Qa3PRdOmBCuzoO6Jh9+S4ZYxF7wC+Ldm1t1ZWg1alEjorDGjY3lztiBmxJJL0UKiPaQuz8cI89GfdzQFm/99sF0JLg2Is6kRjB1JP4KDUZ6YjyGYnNM6wNvMKxmlx5nlHUfJJIuhNcX66sYtRqRgh2LgK0vvEkjkN1/ODxqK+rDBvg2L4DOUwlf3MCtnXZ/wl7945u6MrZmZURiLugyYZ0YtgBnxpZEsjsgBUQ7CZtTGktVRygtKcJfHzyG7Dg14pNSsNafjEUMnhwMaPz1ULQG+OIHNvmMwxtAnFkvauxLJJKuhWmXFBF1Hn+rFSQZUKkx2WHJGY+AokHQ54SrYCk0vmp4EwaLtM64vO9x48WnN2ZlRApMRTBoNUiy6LGp0iVFhGS3QQqI7YQ3o0dvuwoTUnzITjJBHZ+F37yDENTZcGBciVjGmzCkSbwEP+P2h0TNfs5aJBJJ18NUadZbaa24lKI1oj77YCQkJkNtS0c9TEDFaoRrC6EOehquYyWM1OJf8fSDt7coMBWB6dgJJj02VDixqVKKCEnvR45i28nXn7wPz7pZyE3UIi01FRt88VgUHoJDB8fD7swTy3iSmtZ+cPlDsBhk6qZEsjPhwJ6TbBFdNVuLUaCl0Js4FAkDxsOkAWrDBtRs/EsUl1I0+gZLRDiESZYtuPGSs8Rn7m3myohUq0w0G0Q8RF4lG+9JESHpvUgBsR2UlRTj8Xtvw8QsDfYanA6Y4jGrvg/KkIiT+jpELnnQlISgOa2F+yLdbhQ3GYlEsvNgtgQDl1mSvjXq+x4IlSkepsxRMCGAoMeJwi15MFUuR8CS3igirp6agwNG54heGU8+cGeL9fD6jjfrsbFCighJ70YKiA5CN8T9t12HNK0Tew9KRnKcGSVBK2aGx2JYhh25wU1iOQZmRcdMMHCSJXBZxU4ikexcmC3BEtccyltL62RH3fq+B8OQnAubzQ5FBTjL8lDj9MBWNEdYKCgi6H586tKpGJykFm2/5/7+W8zGXnEmHTaU10t3hqTXIgVEB/n2849EGtekHD0OGJMrbjpLXUnYoGTimIE66Fwloj+GN3FYk88xCtxm0opGPxKJZOfDIMc+8UZUuVq3QvgSBsGbOATGfnshVe+DUeXDsg0FCARDiNv8I1xpewoR0adPHzx49kQMTVbjnpuvhrPeEVNEJNCdUeES1giZ4inpbewUATF9+nT069cPRqMRe++9N/766682l//kk08wdOhQsfyoUaPw/fffoydQVVGGR+6+BQlG4Owj9oYd9ahXTPjKMwZGnQ4HxpWJ5XxxuQhvLUYTweUPCjMqZ0ISiWTnw+BHFpeii8Hpbb2HBQMqg9ZMmNMGIUntRnKwGH/ke0QH3vi8b+DM3F+IjH0m748LJ6UgNVSCpx68K+a6GmIi6M5wYUO5U1giJZLeQpePZh999BGuv/563H333Vi8eDHGjBmDww47DOXl5TGX//PPP3H66afjggsuwJIlS3DccceJx4oVK9Ddrovn7rsF9XV1OGHyYIzPTYKi0mCz346FyhDsNzARcY61/5aujoIV6igcEmTqpkTS7Wmd2Uzr9AYQbiWtk1bFun6HIZgyAkk2E5JUDriqCrC6Vg2Nz4G4vO/gyD4EofSxOOjQw3H8MC02zXgb8+f83moQJ60feZVO0QpcVqyU9Ba6XEA89dRTuOiii3Deeedh+PDhePnll2E2m/HGG2/EXP7ZZ5/FtGnTcNNNN2HYsGG4//77sccee+CFF15Ad/L1559g/syfoNfrcM0Zh8NQvwVBjRnf1g+ED3ocn+2DOuASbb59zRpt1XuDwh/KVDKJRNK9ZMSbRBXYmlb6ZJCALRuujH2gpI9FptGPEap8fL4+iGq/Wrgp7QW/wpE9FQl7HIPRY8fj6ME6fPPEZXA561sVESlWI/Kr3LJ3hqTX0KUCwu/3Y9GiRTjkkEP+/UK1WjyfN29ezM/w9ejlCS0WrS2/MygtLcW9t98o/v7v1Regj9EDdciDyqAR3wXGo2+CCcPV+eJ9EfvQrHGWJxAU2Reszy+RSLoXDua5yRb42+jWSVwZk+BOHQdDQhaydPU4BAvw+PoMBBQVjNVrYSmdj/qsAzH8+Otgj4vDHrZq/PzU5aJ6ZSz02n/LXq8pqZddPCW7PF0qICorKxEKhZCW1jSdkc85KMeCr3dkeZ/PB4fD0eTR2VxxxRWoranBgKEjcfZh42Go24iw1owF3ixUIR6HD42D0RGVfREFbxIGrRpxsu+FRNJjYEony8lXtJHWyYmAI/dIeNL2QILViCHaUgx1/Y1Xihuqy1pK5sNYvQrB/lMx+LiGCUZ43c8o+flZUXgqFszgYBfekloPVpc44Pa3HoshkfR0dvmIvocffhhxcXGNj759+3b6d1x99dUYMGgwbrv3QZgcG6FzlcGjMuGj+tGiI9/hqbUiPzxoThGP5tkXzAm3ybbdEkmPgdbAfskWGLXqNgMqQ8Z41A04BoHEocg0BbGfehnWbSnBTE+DiLDn/wJdfQFypl4M78AjoUDBiq9fhHH1Z0A49noZD5UeZ0J5vRcrix2o98aukCmR7NYCIjk5GRqNBmVlDdkJEfg8PT095mf4ekeWv+2221BXV9f42LJlCzqbKVOm4Kc5f2N0ShiGuk1Q1FoU+G1YrAzCXv0SkeJaHzN4ktBMmmqXjbMkkp4GY5KyE9sOqIxc13W5R0BlTcUQkwMnaWbhqWUa5KmzhaUhPu9baDyVOO7GZzGrKhk1tbVY9v0biN/wBVSh2BYOTjzS7SYRh0ERUetuPR5DItktBYRer8f48ePx22//FloJh8Pi+cSJE2N+hq9HL09++eWXVpc3GAyw2+1NHl0BwxfsNatgcOQjpLPgG+cgsfuOGmjYWvtBJQrNROPxh8QMJ94k3RcSSU+kT4IJiZa2Ayp5bdf3O0wEVZpNJuxj2IwjVXNxw9IMOAzpUAV9iN/wJWwGNc68/UW8uyyAhYsWoXL1XCSs+xhqvzPmatUqigijsICsKKpDZVvuFIlkd3RhMIXztddew1tvvYXVq1fjsssug8vlElkZ5JxzzhFWhAjXXHMNfvzxRzz55JNYs2YN7rnnHixcuBBXXnkluhNtXR5Mznyogy7UBvX42ruH6Ki5t6WhcZbfltOi9kO9LyBSNy3SfSGR9EjYRbNfkgWBsAJ/sPWASvbDqBx5EXz2fkgxKjhavxiZ7lW4Y8NgBAzx0PgdiNv4JSZOmoTxR5yD/1sawHff/wg4ipGw9kNhoYgFLZNpdiOCIUWIiNI6bxf+WolkFxMQp556Kp544gncddddGDt2LJYuXSoEQiRQsqCgACUlDYMwmTRpEt5//328+uqrombEp59+ii+//BIjRzZtTLWzMVSsgMWxSQRP/uPPQgUScNDgFJhr1oj3PUnDW9SNCIbDIupaIpH0XFJsBmTGG1HpanvwDpmTUTXyQoRNiRhqrMUp2lnIKyzByzUTRPo2Y6NYI+KG2+8B7Jl4ckYpfp09X4iLxHUfQVffunuVJe41KhVWltRhS7Wr1dbjEklPQqX0sjOVWRgMpmQ8RKe5M3z1qPnpUejXfYOQIQFXlR6GWaHReOP4dIwo/VrMTipGXwKo/3VVMLqaGRh75iaKkrYSiaTn4vIFsaSgRmRgMui5LVIXPoW4vG/h8QfwkmMfvBE6EncdkIJDAzOgCgfgSR6JHzepcdk5J8GsU+HnF2/EwBSTyOqoy5kGX+KQVtfNgEpWre2fbBVBnoyVkEh66hi6y2dh7BRKl0NX19Ciuzhkx/zQUAxOs6J/sOE1X/ygJuKBuP0hcSOS4kEi6fnQzZibYhWD97YqRVaMuVgUizNrFJxuW4Ep6n/w0Nw6rE44UMRLmCpX4NAhFhx/6llwBxT85+HPUG/OFplatFCYSxe0WiuClTIZ3Lm+3In1ZbJqpaRnIwVEe/C7oHUUIKi1YKY7V1SePHhIEoy168TbnqRhLT8SDCPZJjtvSiS7CgxozIgzbTOYUdFZUTHmUpGy3UdThwssf6JPsBC3z/GiLG2KWMZSMg93XXkGUtP7YOOmTXjgk8Vwp40X71mL5sKe/7MQFLHgpCPZytLXLlErQhackvRUpIBoD9Z0KHo7nCorPq8fBq1ahUNT60X0dUhvR8DatPYEy9TqtSrYZOdNiWSXge6C3BQLDDr1NmszeFLHw9HvcIT1Vow1luJiw2+oq6vFXQv1qE/fWyyTUb0AT99/q/j77ddfwh+lRtGoi1YKY9VKxG/4HKqgt9XgTgZXFtd6sLK4TtSTkUh6GlJAtIf8uYASxIZAMjYpfbBXbiKSGms/DBE3hGhcvhCsRp0sHiWR7GLQfcCsDGZQtdl+W6VC9ZBT4E4ZA41KwWFxW3CG7ncs3VKDZzekiTgIuikOSqvFhWccJ4Ii77zhCtRYB6N2wPEibkpfvwWJaz+AxlvTatVK1oqodPpFhoasFSHpaUgB0R7isuCLH4yvnYMQggaHDrLBsDUmIlbxKJocU20GWTxKItkFyYw3ieypbbkywoZ41A46Gb64gTCHHTg3aTUmqVbgm+Wl+MQxUsRJqMJB3HH8KIzol478TRvwwhMPwh/XDzWDTxXWS4qHhLUfiGqWrVlFMrbWilheVIdyh0zzlPQcpIBoD2nDsVw/GvO9uaKr5kRruahAF7CkIWRKarJoMBQWFz2Xk0gkux4sNc1mW1qNqs0y14RxDc7MfRE0pSAJdbgzeTayUI6X5+RhrmFfBKyZMOlUeOXaIxBvBN55bTqWLlwg4idqhp6OgCUD6qAXCes/h6ninzZrRYTDwIpipnm6ZZqnpEcgBUR7SOyP16tHowgpmDI4BZa6huBJX0LTypPE5af7QgurdF9IJLsszKCiiHD4/GJS0GbDrX6HwZ22p3BrZBtdeCjxO2jDXjz00wasTZkmxMXAfll49Jx9YNY2uDK8Ho8oPFcz+OSGDr5KGLaC32DbMqPVRlwsXGfUakRg5cYKZ9vbJZHsBKSAaAf0Pf65sUr8Pa2/ATpncUPp6oSW+dxMA2MENWcxEolk13ZlsHNmpattVwatDK70PeFK3xvqgBPjrHX4r/1HEYh51/cbsKXvUQgZ4jDtoP1x2b7JKCtocGUI1Fo4+k2DM3OyeGoqX7o1uNLTappnvEmPDeVOrCmVLcEl3Ysc5drBN8tKEAgpyEowYYi6ULzmt/UVEdjRMOiKUQ/bKkQjkUh2EVdGihV6rRoOT9tZGc7M/RCwZcObNBLaoBNHx+XhDPPfKKr14P5ftqA893jobEk4+ZjDcOYoHT56o8GVIVCp4E7fW3T9FMGVjgIkrnm/1fLXJr1GxGgU1rhFhobs5inpLqSAaAd/5VWL/yfmJsJUvVr8LcyOzWDzLLNBK9M3JZJeAmOZckVWRrBNl4GiNaK+74Hw2/shYE6FDgFclzQf4/WbRbfNp/4oR/XA49F30AgcvM9onDpCi3tuvFy4MiL44gc2BFca4qDx1SFx7Ycw1G5oV4ZGlWzEJekGpIBoB8+dNhYvnjEOB2Qq0HirRTtvXuzNcfqDorMfc7glEknvIDPBjIw4I8q3MUj7EgaJhyd5DMJaI0zqMJ5J+wmZ6mrMXl+JN5a6UTvwBEw6cBpGZtmxtykf05+4v8k6GFxZPfQMYeFUhfyI2/g1LCXzY1aujGRoePxhLC+sExYJGVwp2ZlIAdEOGAU9LMOOdG/DbIDpWYqmaZVJXrh0YSRZZPVJiaQ3Fpgy6zWo24Yroz7rQCg6Izwp46CodUjQePG/Pt/CDA8+W1yIrzYp8Iw8DfsdcgQGJ2ng/uM1LPnrzybrULQmITQ8qWPFc0vxn4jb9A1UIV/MexObgdHdwuBKxkbI4ErJzkIKiPaihGGtayge5UtsmX3hCYRg0qul+0Ii6aUFpvqzV4Yv0GZ/CsZF1WfuL2IZvEkjENbokKWtweuZP0CDIF6ZtREzSo1ImHoDBg8fheEpasx97uL/b+88oNusrzb+aG/LlrdjO3sPsiGQQAKUQCi7ZTaMQtn9yoaWDWUW+lEKLS2Fjw1l701CJiN7OImd2Ek84m3LkrXH+517ZStO4njFdhL7/s7RiSS/kv56k/j/vHc8Fz5v455vpNbAnXM8XAN/wfcpleHYQqZTsXRqa6kWu1GPoupGbCp3cTpVEHoaERAdROsqgTbs4dBkIGHwPj+n/7D0S0aGZwlC34TSBZTOqHL720wVUCElF1nrzPClTIKi0mCCrgRPZi2CAgVPflOAH5x2jJr/F5gsNmSiGsv/fk2raQp/ynjUjTgPUb2NxQMVV+6vLoKKK1NtZH/tx4YypzhXCj2OCIgOoq/d3GLy5r41Dn4anmWV9IUg9FXUlMpIsXArpdPbRipDpeLIAUUh6HeFJ2sGoFLjRH0e/pi5BpFoFA9/sRlbtUORe/ZdLCoaNn6Nym+faVVEhC0ZXBcRsmXvrosoW9KqXwQVV1K9hssXxrpSJ8/SkLoIoacQAdERIiHo6rfut/uCco40YEvSF4LQ98d+D021IhCJtOnBQDbX7uzYZE6VoqAxkwZsKbjA+AOuTs/nab0PfJIHy5RfoWHgKYgqCjZ89Az02z5vVUSw6dSwc+BNmxxbR8UKJG59D+qQZ59j1U3OlWqouANETKeEnkIEREeo3cbKP6SzsWnM3nipfVOvEfdJQegHpCcY2BOm1hPgjb+tVEYgcShHCiLGZHjSJkGthHG15Xucn1LErrX3fJyHmVf/BUtrk+F01mPjx8/AVrqwVRFB0YzGnNloGHLq7mFcm1+HrrGs1c8nPxq7UceFlXnlLniDMtFT6F5EQHSEyjz+o9E+Yp/Jm4Q3FGGbWXGfFIS+D3U+DE6x8gZd52mjzkClgjv3RES1Jmh9tfClT+MIpjYawG2JC3FqYgmnQh7+dgd+cdM/8HF+GOvXrELdqo+aLK1bFyeBpJGc0gibktn5MqngHZgrVrR6PNVFkJtmudOH9aUN7Q4IE4TOIDteRxgxF77c4+BO3Lf7gvKLUSUq7pOC0I8w6jScyohCafPKnlIPJCIIU+1G1I04l6dx6sONuC/texxvr2AR8m6ZBTknXY2PtoSx4OvPoS1bAVvJd/sVERGjA/UjL4CfOsKoQ6xsCeyFH7VqgU0XNll2E7yBCDaUOlFc60G0rVHlgtBBREB0BIMNgYypCBkc+/woEI6ycZTUPwhC/4L8FwY6zKj3BtkDZn+QuRS1dJIYsFb8iOqxv4tN6QzW4eGsxTjOXsmOkruGnYHqxAl49edaLFu8AKbq9bAVf7NfEUFpDNegU+AaeCKb2xkaipC8+bXYrJ79+EUYtVr2i9hS4ZI5GsIBIwLiAKH6B6p9oBoIQRD6F7kOC8+laC814M6ZjYghEZqAC6b6zagZewXC5jRYfeV4dMByHGsrR40nhLRzH0Se14GH3l6J4h3bYarZiISdX+93QicP9UuZgPqR5yNiTII66EZSwdswV/zcqvCgScEpViOK67zYUNaA+rZSMILQDiIgDhB/ODZ9kxS+IAj9Cxq0RakMnUbV5sAtcq7l4keKFDgLoY76UTt6PkLmdNi8xXgkdwVmWctRH1Rh6FXPYpM/Bbc89zUCgSCMtXlI2P45EN1/xIDECNVF7E5pLEXitvegDja2uuZMuwkN3hDWlzrZAltSGkJXEAFxAMSmb6qQYJL6B0Hor9jN5FJp4Vk4bblUhs3paGxq7aQNPmTNhnP4r1lE2D078PCgNRyJCGgsyL74CSyvUOGRD9dz94WxvoDtrBENtylSYimNk9hGOzbV8zXoG7bvt9VTq1Zj0y4X8islpSF0HhEQB0Dz9E1p3xSE/k1WYmzgVnVj2y6VvpQJ8SiBfccX8KRPRcOQ01hEJHkK8dDg9TghoQywOJB+4WP4z1fr8FmplQUB1TgkbvuAW8r3C6c0xjV1aaRCHfLya6yli1oVHwkmHXeQ7az1cjSiza4SQdgLERAHAFVfJ5l0HBIUBKF/D9yiVIbNoEN9Oy6V1JVBXRRUr2Df+SXcuSfAPfAXCJnSkOTeivsH5WGefSe0tmRkXPAobnvyZWxPPi7u/UAGUqqwv831REzJqBt1Abxpk/ixuXJVbJaGr3afY6kInFIabl8Y60uc2FnrabMoVBCakZ3vAAgrCpIskr4QBKHJpTLNymmMttIBJAScQ37ZlGbYCeuu5WgYPI/TGyFLBhLdBbhzUAHOtG+FxpoI06l34Oa/vIi6YefwLB6dpxxJBf9lAdImai0ac+bAOezMJi+Kaji2vA5T9bp9CiwppZGWYGQxsbnczWkNMZ4S2kMERBcJhCPQa8S+WhCE3aTZDMh1mNmlsq2r+IgphWsVCHPlShjrt8I57Aw0Zh2DoHUA7K583DpoB35l3QCNyYbSwafi7x8uR/2Ic3mwFhlTJeX/t9WIwt4E7UNQN+ZiBBMGQRUNw1b8HXtGtGaDTV0a9B3KnF6sK3GiytV2Skbo34iAOID2TbrisMj0TUEQmqBurIEpZh6s115rZ8AxEp6M6Xyf/B5IFFC0wJN5FAK2XBYRtwyvwrnqRdDqDfi81oGPN9SgbuR5nALRBF0cidB6yttdFxlaOYedBXfOnLhnhGPTK61O9tQ1GU8FQlF2ryQrbLpgEoS9EQHRRShEmWwx8IQ+QRCEZigNMCzNCq1GBbe/jXoIAJ6sY3heBkUGEgs/hjocQMPQM+DNmIZAwmBYGvJx0xEhnN34Dgwa4LmfqvDlVg+LCEp3qMN+JBW8C72zsP2FqVTwpU2KFViaU6EO+3iyp23n11BFAvsIoWSrAQk0S6O6ERtKxTNC2BcREF2AQnp0s5kk+iAIwr6Qtf2QFAtc/hBP3mxz9PegkxE2pfBcC3vRx1BUqpiISJ+MgH0YLK5tuPYIDU6v/DfMqiD+vrAQb6yu5umcsbRECIlFH8NUtbZDa6P0Sd3IC+DJmMafT2ZVjs2vQucubXWWRmaCiWd20HhwKrCUyZ5CMyIguoA/FGUvfKq4FgRBaI0BSWauh6h2+9uc2hkzmTq9qUCyAvbtX3CagUSEL20i/IkjkYoanDMoiDNK/ookuPDGz8V4elExagadBl/KOC6KpAFc1tLF+7W+3gO1Fp4Bs1A//NeIGBLYITNp6ztN7Z6hfTpMyDPCoNGwBTaNCCdhJAgiILoAVSdTsZFRJ6dPEITWoY13SKoVDqseNe626yEixkT2gyDTKKpLoI2cujScTSLC5xiDsQMsmG6pxGmFDyMbFfhmcyUe/CIflRlzuPiyuSDTvv3TfUTA/gjZslE3en5chFC7Z/Lm16H1VLReYGk1otLlx9rimIOltHv2b2QH7AKBSISLpMS+WhCEtqBI5fA0GzTtWF0TIVsOGgaezPfNVWtgrlrFkYKGIb+EL30KfI6xmDVxJIYqxZib/xAmYBtWFztxxwcbsdM6kV0oWYDUb+UR363ZWO8vAuIeeBIXWUZ1Vmj8dXDkvwVL2dJ9zKdosid5RlDbZ15ZA/J2NaAxIO2e/RUREJ2EFDf95xH3SUEQOgJ5xZDJVGMg1G43A3VmNGYfy/cpHWGoywdUam759GZORyRrEo6aOhEDUY7peY/hJN067Khx46Z31mJdKBv1w86Op0Ic+W9C663s8DqD9sGoHXNx3CnTUvEzHFveaDUaYTfpkGozotxJ0Yh6lDl9Mk+jHyICogvdF3RVQeE8QRCEjjAg0YScZDO3drYX9vemTYE3bTLfJ6dKnbuYix0bs2dz3ULiqOOQlTsYww1OjN7yL/zWtgI+rwd//GA9vtllQP3IC+NOl0n5b8NQX9DhdSpaI1yD53HUI6ozQ+uriUUjdi3bJxrB7Z6JJqoExcZSJ9dGSDSifyECopP4QhFubaJWLUEQhI5A7d5DUqxItRlQ5W7bhjomFo5FIGk4T+Ck9k72elCp2CPCNWguRs46Ez61GTmqaowo/wJ3pP0Ie8SJJ78pwP+tcaJmxHnxDg170aewlP/YseLKJgJJI1A75hL4HSNj0Yjyn9qNRuxy+rCmuF5qI/oRIiA6CYUgafiMIAhCp+sh0m1sQFfbjskUpS0aBp2CYEIuD89K2vY+tN4q/hENy/KOPg/j55yNnQ1RqCs3YmykEA/mrMJIVTHeWVWKB78qQmnOL+ORDMuu5TzNc2+/h7ZQtCa4Bp+6VzTizVinx15Fms3RCJpOTJGIjWUN0qnRDxAB0QlIVdP4W7GvFgShK1D0cni6FVEoaPS3E+7nAsrTEbIOgCoc4CFazdbVQfsgmE+4BTkTZqGgVkHx6m8wxtqI+4cV4gTteqzaUYub3lmPPPO0mGV2U3cHD9Ty13VqzbujEaObOjVWInnza636RnA0wmrgTg2KRpBvRFsjzoXDGxEQnfR/IGMVuoIQBEHoCmk2I4alWuHyB9scuhUfvDX0DIQs6ewcmUQiwu/kn4XN6Rh5+XOI2AYgrzyADcu+xjCLD7eMceG3lmVobKjDLe+uwzf16agbcR7P0OAOiy1vdMy5cp9oxCm8llinRj2SCt7muRp7RzV0TZ0aOrUam8tdMia8DyMCopMkWXT8H0QQBKGrZCeZMTDZglpPsF1nRypsdA47O+5Wmbj13biIUFtTMPmGV7HdrcXKgnJs2bwRaap6XDxai1uSlyErXIrHv8rHv9Z4UTX8/Fg0IxJEYuFHsTZNpXPRgWDiUO7UYN8IcqqsXofkTa9A31C0z7E2ow4ZCSbUe0JYW1KPbZXudgWTcHghO2En0GlVSDRJ/YMgCN1QVJlqRabdiIp2nCqbIwDO4ee0GKL1djydMXD4WAz69YNYXhLGwqUrUe0OwRKqwdxhFtw+YCOOVa/Dx2tLcdsnRcjP+CUbUxHUpklpkdamcra9FiP7RtSP+BUiBjt3eyRu+xAJ2z/b572aXSwtei3P1Fhb4uT0hrR89g1EQHQCSl9I+6YgCN2BXqvGiHQbm9JVdmBsNk3UrBtxLsKmVI5EkIhoLqw8+6LLEB42F+9v8uOLL7+CX5cEbdCFyZkG/GGEExfrv0dVZRlueHsDFkQmomHwqZwe0btL4Nj8OnSNZZ1ef8iWy9EIb/pU7hAx1uXDsellGGs27tPxYdZrOa3hD0Y4pbGpXOyw+wIqpY8Ne3e5XLDb7WhoaEBCQkK3ve/26kZUugOYNsjBqloQBKE7oImd1LXgDUa4PqI9VGE/Ere9B52nEorWwOZRYUsm6mpr8KuTjoHBV4WHL5mJuSfOgTrkpjgAXFE9FhU68aFrJNYrQ3DO5GxceoQVjp2f8xhx6vpozJoBb/p0FgOdhdo7E4q/jQuaoC0H7twTETEm7XMsDRcjPwyjXo1ByRYWFiSmhMNvDxUB0UF21MSqiakNSxAEoTuhIsMNZU6oFBU7V3ZIRBR+xJEDiiRQqyX5PixftABX/+ZsWHTAB3+5FhMGpXDNA1RABFqsKWnAVxUWfBOdigFpKbj1xMEY2bAMxrot/L7BhIE8HZSiHZ1GicJctRqWXT+w/wQNBPNkHAlv+hTuKGlNOFEUgsaGD0w2c/eGjAc4+IiA6AEB0Vz8Q73cgiAI3Q2lMTbuaoBJq+ECxPYgYUDjv/Wu4ia761/AnzwWf33oHrz03NNISkrEd6/+BVnhkqaUQuxXfYnTj0XbPfgyeARKtQNx1azBODW1CrbSRbzxk3hoGHQyQgkDu/Q91AEnEooXQO/awY/DpmS4c07gwV2ttcbXe4MIRxWuByEh0ZHvLvQcIiB6QEAIgiD0NCV1XmypcMNm0HasXTwaQcLOr+IRBJrK2eCYiIvPPhl569dg6lHH4NV/PIbEsu9jkQiSEWotfP4AfiiswTJXKhZEJ2La8Bz8/shEZO36ig2j2PUyfSo8mUezh0SnURQY6vNhK/0e6pCXn6LOjcYBs7ggtDWDvtrGIKc1cpPMyEoyidvvQUIEhAgIQRAOQ+jXMZkvFVQ2sikTFR924EWw7FoKS8UKfuhLnYCN4YE4b94ceD2NuP6WO3HNVZezpTWLAygI6xOhDrqweVcDfi7z4bvIJNSZBuPGE4ZgJtbCVLOB3ytsTkPD4Hnc/dEVKNViLVsSf7+o1sQ23X7HmFZrLchcq8EfQqJZx/URZP0tNWe9iwgIERCCIBym0K/komoPtla5kWwxdDhtaqpaC1vpQhYUVMvw5jovbr/x99BoNHjxnc8wacoUTi0Ya/P4+LDeDhWiqK+rwQ9FtVjnS8PC6ETMnjAUV40OI2XXd1CH/VDUOrhzjoM/eXyXCiwJqtUg06mYgKEOjmy4co5HxJSyz7HU0ur0xiaXUgtojsOMJLNO6iN6CREQIiAEQTiMIZ+EwupGvlGbZ0fD+Yb6rUjY8SXXMlAHxK0vLMIb73yIzAHZePuLJbAnJbGAsJUs5JRGVKNH2JQGtbsMa4vrkFfpx9LoONQmjMWtswdgin9ZrMaC0gyJQ7mzoksFlvylIrEiy/IfeX1Ut0GzOmhAGBWC7g0VrVNxqUoNZNlJSFhgFRfgHkcEhAgIQRAOc6jAcGulGztqPUi1Gjvc6kitlPbCj9lwKhAB5t/3MhZv2Ik5J83DU/95na/kyYo6Ycfn3ApKBBIGQhP2orq8BD9tr0VhMBELo5Mx84jRuHJIDRyVP7AAoBQEiQieFNpF1IEGLtik2Rz8PfUJaMw+DoHEYa1GOKiAvdYT4HROTpIJmYkmKWbvQURAiIAQBKEPQDbXlMrYWevtVCRCFfIisegTTh1UV1Xi+kdfwqKiAG6//1Fc9NurYwdFI7DuWsbDsQhylSQhoa7Kw5rtVSiq8WGNMgwltsm4YVYapnmXQeur5mP9yWPgzp7NrpRdheZxUMpFE3Dx46B9MNzZcxAxJrZ6fLw+wqRDTrIZaTaDjBXoAURAiIAQBKGfiwgSCLaS72Cq2YiNa1fhP+9+hU8LVXj+na8x9ohJ8cN0rp2w7/yaLakpAuBNHgdNyIuanRuxYkcdqoJ6LIkegVFjJ+GawRVw1K7mOgsazuXKPZE3/i4TDcFS/hMsVat4vdQh4k2fBk/GVECta7U+osEXYtOtZKseuQ4znxMptOw+RECIgBAEoY+JiG1VjZzO6JSIUBQYazfAVrwQX3/8DlZvLMBSZwaefn8JbAn2PbolbCUL4u2g1H3hc4yBpnwVNmzbgaIaD4qjadhgmo4rZmRhVuQnToMQ5D3hzj7ugKIRNCWUPr+53oKiIRThoOFdrdHsH0F1EhSJyHaYkWzRS6FlL++hPRr/qaurw0UXXcSLSExMxOWXX47GxsY2XzN79mz+R9DydvXVTSE3QRCEfohWo8awNCu3NlI9QIenWqpU8KdMQP2o8zHz1PORk2bHKekVePP+y6BEd0/ipM3fNXgeGoaciqjWyHUUtl1LEE0bg3FHz8NxozIx2liHU/yf44sFC3DPzgmosk+IzcCozYtN5OzkiPCWUJuoc9g5sc+nseOBBnbatG/7MD55tCUUcSAhRbeaxiDWFjuRt8uFek+w3ZkiQvfRoxGIU045BeXl5fjXv/6FUCiEyy67DNOmTcMbb7zRpoAYMWIEHnjggfhzZrO5w9EEiUAIgtBXoSvvoupGviWa9R3ziWgRZXAueg4LXn4M0WgUo44/D+PmPwpFZ97jOHWwEbbib2FoGtEdsqTDk3EUtFUbsW3TKmypcMGrGLBWOw7HTRyL003roAs0RSMcI9GYPbvrnRpNDpvmCkprrG6R1pgKT8a0VtMazfM16rwBFhYZdiMGJJrZR0M4TFMYmzdvxpgxY7BixQpMnTqVn/vyyy8xb948lJaWIisra78CYuLEiXjqqae69LkiIARB6OstnmQ2ReOxLXpt56yfFQWLXrgLlQufh06rwS/PvwKWYy7nORp7H0fpDGvpQvaCIDdKmmsRNKUjUPAt1m3ZijpvEHWKDWWJ03DZOAOGhzbzPAyKYDQOOJZTG131jWg1rcHdGscikDh8v+9LkRlq/TRo1SwkyNEyQayxDz8B8eKLL+Lmm29GfX1MmRLhcBhGoxHvvPMOzjrrrP0KiLy8PA5DZWRk4LTTTsPdd9/NUYjWCAQCfGv55XNyckRACILQZ6Hfj6X1XuRXNsKgUXM0ojOv/fP15yO1fAGGZNjxq4suQ3TgTLbB3nvoFUcjSr6DoSk90TzXQuWtQdnar7C5uJLrEEqiaUgeOgXnZVbCGqppdyJnJxbL7Z7WskW7uzUScrk+ojUTqma8wTCcPhISGmTZqfXTKDM2DqcaiIqKCqSlpe3xnFarhcPh4J/tjwsvvBCvvfYaFi5ciD/+8Y949dVX8Zvf/Ga/xz/yyCP8ZZtvJB4EQRD6MlQbRsZKY7MSEFEUHo/dmdfe8Mi/8WVNNhZscWLBl5/CVLESyZtfg9ZTvsexUb0VDUNOR8PgUxHVmXn0d9LWd2AI1CJ99jWYdfxpyElOQI66CubtX+DZn2uxxDcIUZUWencJHJtfZeMoRMNd/aLsOVE75pKY4ZRayxEJWqu15HtOy7QGpXay7GaYdBoU1TRi9c569tSgCaBC99HpCMQdd9yBxx57rN30xfvvv4+XX34Z+fn5e/yMRMX999+Pa665pkOft2DBApxwwgnYtm0bhg7dtyJXIhCCIPRnSDzkV7j5qjvNZoS6g2mDLXnrMf+Mk5BrCeLxq0/GjOlTWwzRmrFPNEIV9sFWujhuhU3FjtR9ETKloWbjtyjc+BOP544qanhsg3HycAtytbECSIpCkHV1Vyd8tpz0SWtoNqEiUUORk1i6ZP/Xw55ALCJBgiJTIhIHL4VRXV2N2traNo8ZMmQIRxG6ksLYG4/HA6vVyvUTc+fObfd4qYEQBKG/QRt3QYWbOxLSbQbu2ugI77/1Cu679X9g1qvx4TN/woQ0dTxV4Rp4EsKWzH1eo3MXI2Hnt9AEYuKA6ifcNNci5Efhz5+hrCiP0xohRYPk9GzMzlbBool1fPgdo7g+giIbBwKNCreWLuKICK/XnAZ3zhyErAPafF2zkCAny4wEI7taSrHlIVxEuXLlSkyZMoWf+/rrr3HyySe3WUS5N8uWLcPMmTOxbt06TJgwod3jRUAIgtAfoQLCgko3djl9HR7CRb/+77n5Onz0zhtIciTj47dfxtBAHtQhD0cjfCkT+Ap/H48HMoCqWAFL5Yp4pwQVWXrTp8BbU4zNyz6Gs3JH7FiVBqOyHBifpuM0Ns29oHSEN3VS10aFx9cQgbl6LSzlP8RHlccEykxE9W3/7ucaCW8Ieq0K6VRsaY8JCfGRwKEhIJrbOCsrK/Hcc8/F2zipI6O5jbOsrIzTE6+88gqmT5+OwsJC/hl1aiQnJ2P9+vW48cYbkZ2djUWLFnXoM0VACILQX6Er/+3VHjacsui1SOjA1bXf58PFZ8/Flo3rMe6IyXj5rfeQXPPz7lSFzgp3zuxWux/ITIqKLHcbQCXyscGEwdhVtAEFP32OiCtW85agU3BElhUDUuxQqbVNBZlzELLlHtB3JttusuQ21W7kokuaHurNmAZP+pT9tn024wtGOCKh0ajYkIqERJJZD3U/drZ0HSoCgoykrr/+enzyySdQq9U455xz8PTTT3NKgtixYwcGDx7MBZPUfVFSUsIFkxs3buTUBdUyUKrjrrvuEh8IQRCEDrZ57mrwsXMl+UakWg3tXlmXlezE+fNmo8FZj7MvuBj3Pf50LFVR/F3ccTJgH8IeD/vMqqBOifp8rk1Qhxr3ODasT0De+hUoWf0V9ME6/lmuKYBx6UbYkzO5zoKKJN2U1jDsdsbsClpvJWwl3/P8j3jb54BZCCSNaLedlKI3ZJFNkEX2gEQTHBZ9h1NBfYlDRkAcDERACIIggP0QKKXh9FJdhLHdzXD5ogW4Zv45nNa49/Gncc4FF3P3hIVMnWjgVjumTqpIgOda0Mhu8oNg74i0KRwNCEQ1+PGnZajbtBC2qBMaRDDO2ohhqTboHQOgaE38vnRrbbR3h2ExUwBr2RKeRkpQXQQVe4YtGR2K4JBFNgmvRLMOA5Jo1oa+49bhfQARECIgBEEQONdPkQiqi0jqgHPlf575K55+7AHo9Hq89O4XGD9pyn5mVdDVfesjuGPHLoTetZMfkysl1SX4HWP4Kn/RssUIFC6BAw0wI4DJtgYMSE2CJjGbvR0as+jYUQdkQsU1GpWrYK5YAVU0FlmgTg2q5+hIAScJCFqrLxTmbo0BiUak2oywGDru/Hm4IgJCBIQgCEJ8EFdxnRfbaz1QQ9Xm0CnaDm66cj6++/JTpKVn4s3PFiI1PWNPU6fSRfGrezKLInfIsDl97zeCoaEQ1tLF8W4NssSmtAZFBHbVe/HtkiXQlv2IdFU9UlRuTLI1IDUlFbBn84TPRmoRbaeroj1owqi1bCmMdZtjy+pEfUTz9E+3P4zGQAgmvYYjOeRw2ZcLLl0iIERACIIgtKTaHUBhdSOnNMgvQreflEaj24X5Z56EwoItmDB5Gl747ycwGI37dGCYK1dCRQZRNLDLMab1q/touKlT4sd4pwRFLag2gbwhCipc+HrZj7BVrUCuqhID1PWYYHPD4UhFNGEAfGmTue1zn7qLTqL1VMBWSvURu2LL0tti/hGO0R2OdFALaIM/xPM2qK4k025EkkW/3/N4uCICQgSEIAhCqymNomoPypw+WNvo0ijeXoQLTzsergYnzvj1hXjgyWf3ueJWB12wli3b8+o+fTK8aVP2afvkTony5TDVbODoBJk+eVOPiLlLak1YW+LE50tXIKV+DUaqSjBYW43RVi8SEx2I2mPW1Z6sGXzsAddH7FoSt8Vm/wiKdNg67mBMg7uocyMcicJu1iPLbkSy1dBn0hsiIERACIIg7De/v8vpRVGNhzfDVKuRr6r35ofFC7mokiZ33nbfI/jN5dd07OqeCiIzprNA2NvNUuOrga1sCfQN2/kxe0JkTIM3bTIUlRY/FtXikx83Iq1hHaaqCjBcV4FhlhAS7QmIJOSwpbYn88gOpR/2C0VFqlbDUvFzi6jI0KaoiKNT59HlD7Eoa05vpCUYkWjSHdZtoCIgREAIgiC0SYM3hO01jahw+WE36WFt5Qr61eefxV8euBMajQb/fPU9HDVrdutv1lzzULaUiyib2ygpwuBPHrOPzbTOtRO2ssXQeqvjXhONWXTsOEQUFZZuq8EHP25BWuMmHKtehzHaMgy0KEiymRGxD0T90NPhJbvtNuyr2yMWFfmhKSoS5ffypYznNXd2HLk3GOaiS7IRp+4NcrikWpOOmHkdaoiAEAEhCILQobbF0jovG09FokCK1bBHNIK2h7tvuhYfv/smbHY7XvvoWwweOnz/b6hE2YDKWv4jFzASVOvgyTgKfsfIPTf8ppHhlvJl8ZQCRQAas2YgkDgCEQX4Pr8K767YjkR3AU5Rr8BE3XZkWdS8OVNEwjn0dO4GgbrrQoIED7V9Nk8c5ahI+jROx3Q20hGKROHyhRAIR2A2aNkum86p/TCKSoiAEAEhCILQYeo9QZ5aSYWWdqMeVuPuaETA78cV55+Odat+Rs7AwXj9k++QmNROqD8agrl6HbdRqsM+foqcJ+nqPuZo2WLDj4Y5CkCFlvFjzanczklzNkhILCqowls/F8Pk3o5fqn/AUdoCZFg0bPoUtabDNegUHjOu6LpeI6Fzl7CQ0Hkq9omKdDbSoSgKPIEIXIEQNC2iEg6zntMdhzIiIERACIIgdPrquazei521XgQjUaRYdg/lqq2pxkWnn4BdJcWYcuTR+PcbH7JXRHuQuZSJujCoYyMc2C0kMo5scohU73GsuXI1zFWr4rUJ1MbZmHU0FzlSzcGigmq8vbIEQecunKNZgpmaTci0qLiIUWVxwJ09h+2xO2Ia1SpNrprWXUt3F1rSerOOQcA+tEveFKGmqISfohJ6LVJseu6CoVqJQ9HpUgSECAhBEIQu10ZQSoNqI8w6TdzzYFv+Zlx81lxu89xfZ8b+UIX9MFetgbl6dVxIxFIb0+FPGrXHUC0aG05toiQ8uE20yW/CQ0LCOoCFxA9FtfjvimLU1VbhLM0yHKvZgBxzOJaCsTi4KLNxwDEIJI2EojF0/iRwVGR9U1TEv1vMDJjZZW8KRVHgDUbQGAhDgcIGVRkJBiRZDEgwag8ZXwkRECIgBEEQugxt0iQgttd40OgPxwsCl33/Ha675NfcmfGHO+7F5dfd2Kn3JSFhotRG1ar4xkzFllRvQKmCljbWVENBnRI8JCsa4eeCCQPhyZyBkDWLN+Sfd9ThnZWlKKuswMnqn3GcZiOGmr1Is+qgs6YgYB/M9thUHMlmV53cpFn4VK5g8dMsZrhjI+sYds08kPPr9ofgCUZ4Iii5hKZTB4dZ165baE8jAkIEhCAIwgFD3QXFtV6UOn2grZfGhL/zyn/w8N238s8fe+YFnHLGOZ1+31hqYz23U/Lo8Kb2T1/aJG7/bOn3QH4TNGPDRNNBqVsiLiSO4mgAbWEbd7nw7qpSFBaXYJZ6PWaqN2K4yY0BFsBkT+UIBtVT+FLGsXnUPuPJ24HFDHVs8BqUFuZZM9odHd4eVHBJbpfBcARGvYZTR6k2A+xm3UGZwSECQgSEIAhCt0BbRK0niJ21Hi6ytOi1+Pfj9+K1F/7JdRDPvfYeps2Y1bU3p1RBbR67WmoCDbHPU+u49ZPSEJTmaEYdcDZFJDbtFhKU2iAh0WQERU6b768uw8ZtRZim2oTpqnwMMboxzOKHNSkVYVs2T/30Jw6D3zEWwYTcThVIxjo2lrKlN6PWwJs6kbs2FJ0ZB3qefaGYmIhEo7AYdUizGuCw6jmN1FuOlyIgREAIgiB0K+S8SGkNKrJs8Abw5B3XYsEXH8OWkICX3/8Kw0aO7vqbK1EY6rfCUrkCWm9V7DmVigsXvelTELJkxdMPMSGxAqa6TfHUBkUiqDCTIhN0XKXLj4/WlmHFpq2YGN2EMaodyNa5MdbmQ0qild0tqcuCLK19jlE8aKszJlJaTzkLCb27JLZ8jZ4dOCkV06Wai1ZmcHgDEbgDIf7aFr0WaVQvYY6JiZ4svhQBIQJCEAShR/AFIyit96Koog43//Zc5K3+GRlZ2Xj1w6+Rnpl1YG+uKNA1lsJcuQqGhqL402Q5TREJP3VuNLlbqgMNLDg4rdAsJCzp8KZPj08JpTqDLzZWYNm6fAwPbMAoVTESND6MT/Aj266HPjGLazBir83gtAT5VXTIMltRoHfvZCHRLHp2u3BOODC3zL3qJajw0hMMs1GVzaDlFAfN4aDiy+4WEyIgREAIgiD0eLfGxqIyXHDGSSgp2orho8bipfc+hy3B3i3vr/HVcrElmU01FzCSQ6QvZQIXRTYP7lIHG/k4qqloHt1N0QSyyG7u8KBWyiVba7BgzRak1a/GaFUxNKowhltDGOowwJFo59QGo1Jz8SWNFA/Yh7QvBBSaUkozNpZD46/fPawr80hOk7TsMOk2MRGIiQlyD01N0CPHYe62egkRECIgBEEQehzaPlbnFWDunGNRW1OFI6bOwHOvvweL+cDqAVpCbZ3UUmmuWgd1qLHpSTX8ScPhS50YT2+QNbW5mlpF1+5uFd2rw4PWu6GsAd+uKYCq5CdObWhVESTpFYxIMyM71QG9lq7oY+kSeg0ZX1Gag+ss2qqXUMiFcxO3fjaPO48YErlrZB8Xzm4WE1MHJbEXRncgAkIEhCAIQq+xYuUqnHDC8XC7XDhy9i/wyLMvI9lm6l5vg2iEixdJIOgay+JPh02p8KVO4IgB1R9wq2jNhr06PIzwpR4Bb+qkeLFjRYMf36zdhrr8pRgR2Qa9KgytWoWcFDuGZA9AsjEKTdPr+T10Fk6hkLdEyJK5/5bQZmfNip+gDnlbuHDOaHLh7F6/h/IGH6YMFAHRLYiAEARB6H0WL16MuXPnwu/34+SzzsXv7/tfJJj0PWKSRDUHZDRlrMuPpy0oWkAiglIcVDNBG7mxbhMsFdTh4Ywdo9ZyGyd5QzR3eFCr6tLNJdixfgmyGvNgUsWiFzarHVmDR2FERgLMjTvjvhVExJDA8zpIUOzPX4LcNE3Va/Z04TSnsbNmMGFwtwkJERDdiAgIQRCEg8Mnn3yCs846C5FIBL+96jpcevO9HGK3GXSw9YCQoGgDiQRz9fr4FNDmgkjyfGAnSrUuFrmoXBmfcxHr8BjCnRPsLKlScXpjU0kN8tYshaF8BayIRQ80WgNMuZMwfsQwZCjVPHW02WqbiFBbKEcmRiBsSttHGMRcOMmie/Vui25LJjxZMxC0xbpGDgQREN2ICAhBEISDx6uvvoqLL76Y79919z24/H9uRWm9j/P1PSUkmrs3qFbCSB4NTV0ZHJVIGhlzojSlQefZxUKiZYcHd26kTYmlF5oKHmtcXqxf/QM8hcthDtXyc1FFjUjKSGSOOQZTMnQwN2yFoWF7PALSLCbofVqLTOy26F4Xf03Ilo1GctZs8rHoCiIguhEREIIgCAeXv/3tb7jhhhv4/iOPPII/3HQrKl2+uJCwGnQ9Nv+BiinJI4LqEJq7IoiwKYX9HnyO0VBHYlEBKnqMd3jobdx+SSmQ5jbOcDiCLZvXoWrTYij1O+LvVa/LhHXY0Zg0YQJyUQFjfQH0DTv2FBN6SnMM5ZbSWJQjVkRJdRk0pZTEzh6zPlhIZHf6+4qA6EZEQAiCIBx8SDj86U9/4vtPPvkkbrrpJvaQYCHh9POMDWpDpIgEtSR2O/GoxEYYnFvjmzVFGQIJg+FLHouQKQ3mujyOCjQXXLITpmMUvGmT9ph3UVO+EzvXLYS3dCOC4dh71SkkOiZh2PijcORgByyeYv4sjky0SHOQP0SzmCCxQK2hbI9NPhY1G1rM+shtmvXR8YFdIiC6EREQgiAIhwb3338/7rvvPr7/97//Hddffz3f94ciqHL5OSJBZk8mnRYJJh006p6ZSMm1EvX5MNbm7a6D4M4KMxdVUspB66/nqETcCbMpMkDzOdgPoimCEPE5UbJ+MZxFK1Db4I59H0WPQu0wJA47CrPGD8FghwEG104YnIXQNxTuUYBJAoUcM1lQ2Idw1CJm0Z3X6tCw9hAB0Y2IgBAEQTg0oO3lzjvv5GgE8dxzz+Gqq67aY5AUzdcgIdHgC8GgUfe4VbPGV8PzNIx1m+NRh+Z2UIo8UOrB6CyIzbto2h6p68KXcgQXZjanN1SRADzFa1G5aQkqKsrhDUW4TmKrMgB1SeMxccxYHDsiDQkGNUdCjA2FLCgo8hBHpWIfCxISIXMqjPVbWxka1raQEAHRjYiAEARBOHSgLeaWW27BX//6V378zDPP4LrrrtvjGHKKrG0MskV2vTcIFVQ82rpHp1FGI2xFTRs2F1U2Xf3Tph605SJgy2GBYarbAnXYF/suai13dtDE0LAlo+kLRqGt34ba/OWoLC5AmdPHsywqFAc2YBgScydgzphMTMlNYp8JrbeSP4/EhNZXvceSyHgqZE6HJlAPXctISBupDREQ3YgICEEQhENbRDTXRLTmrljnCWKX04caTwDhiIJEkw5mfWz+RU8RT3HUbYaucdfudat1CNgH8Z+0oWt9NXt0b/hSjoi5TDbZXXP6o3QlqgpXY0eVC/W+ILyKARuUIdipH4GpIwdizsg0DE21cAEpzfOgeglqDdU3lu4WMfzhUS72JBET0du5o6S1YksREN2ICAhBEIRDD9pq7rrrLjz88MP8+KGHHooXWbZ2LKU0yC2SJmvSmGvq3OixgssWaPxOFhLG+i17dHFQISR1cpAplM5fE08zKFoDfI6x3CoaMSXv7gSp2QDfzpUoLa/AjlovvCEF25QsrFeGQmXPwZxR6Zg9Mo0HY/FrIgHoXcXQu0hQbI+nV0jcUPspuWJSeoUMsKiThHwkQtYclLv8IiC6CxEQgiAIhy4PPvgg7rnnHr5/9913c6FlW+2c1PZZ4/ajjDo3AlQnoeGCS10P1kkwisLphpiYyI/bUhNRjQGKRsfPqShq0LR+igx4UybEpoHS1FCy327YBkPlGtSWFWJHjQelTh+qoglYHx2CfCUXw7OSWUgcMzQFVqN2j882uHZA37AdOm8FVCEfCwkdpz1UMQOrxOEoSjkOI46YiWSbsVu+tggIERCCIAiHLI8//jhuv/12vk/1EOQbodG0Xe9ABZdUJ0HpjXpviMddJRh1MOl7sE6iGSUKvbuYrbO5JbRFiyY4EkHphiCiGhOLCYpW+JPHxKISRkcL++11UFdvQmlNQ0xMuKPYrOSymGhQJ/JQrGOHp2LaIAeMOs0eJlR66uqgdEc9raEQOl8Vf3YwHIXuyMthm3ZBt3xVERAiIARBEA5pnn32Wfz+97/ndMW5556LV155BQZD+2F4qpOgQktqA61yB+APRmA19k56g4mGd2/kDbudKElUULumSgkhojHFh3ZRVMKXPI6nh1KtxG777XXwu6qxs9aLnbUe5HntLCS2KQOg1+nZV+LYEamYmJO4Z7SFohO+KhjqNsNWugSq6s1Qn/0cHOldd7NsiQgIERCCIAiHPP/9738xf/58hEIhnHDCCfjggw9gs9k6/HrykKhtDGCX0w93IAydOtYGGhvJ3fOoIkFOMVC9BKUbYkWQCg/vUoe9vNmHDQ4WE1Qr4U+iYV/jYjMzAOjcxSwkqCvD6QmwkMivi+AnfzY2RAejAVY225oxNBmzhqVgQnbiPl4ZlbW1mDR0gNRAdAciIARBEA4fvv32Wx7A1djYiMmTJ+Ozzz5DRkZTi2QHoTA+RSXKnT7UeoMIR6I8d8Ni6KWoBGLFjtyeWV8Ag3sniwkSGNSqqQ41Iqo1czqD/gxb0mJRCRpBrjWxNwQ5ZppqN/L9mkYSE178UG/Dj/5cFCpZlCRhcTRjSDJmDkvBuAF2FhPShdGNiIAQBEE4vFi5ciXmzZuH6upq5Obm4tNPP8X48eM7/T60nbl8YVQ3+lHhCsATCEFPRZfG3otK7BYThTDUb42LCYpKsJgIexHRJyFsciCqT4A/cRjP6CDTKIIiGuaa9dC7dkCJKqhy+7G1Poqv6tLwsz8HTsQiNCQmjhqSjNGZNlwwPQfpCTGDqwNFBIQICEEQhMOKrVu34tRTT+U/rVYrpzdIVHQVssumqAS1gtZ6gohEo7Dqddzp0FtRid1iYjsMzgIuhKQ6CfKToDoGms8RNjpiN3MmfCljWExQpII8IigiYarJ4wgG7dQVLj/WuG34tDoNa/0ZiCBWaHnhKD0enH98u4WoHUEEhAgIQRCEw466ujqcc845+P7776FWq/G///u/XGh5IFM7o1EFLn+I0wIUlaAhXjqNiqMSLTsdegMVeT007IgN3HLtYJ8JikrEHClVLCRIPNAIcn8KFV6OZAMpSo0YaSiYazvXVRRt346Fq/OxHsOR7zgWG1+5HxkWNXeznH322Qe0RhEQIiAEQRAOS4LBIK655hq8+OKL/PjKK6/E008/3aEOjfagVtB6T4jNqeo8AQTCCix6DWzGnhvktV+ioaaBW9s41UFeD1pvNac6FJUaEUMSwuYUngpKjpfBhEFQhz3Y/O1r+OndZ5CgjxlZqfVmvLe6BmuLYzM23n333QMSESIgREAIgiActtC29Je//AV33HEH358+fTpvjDk53dOqSO9JXRt1FJVoCHCEgtIa1Apq0mkOKOLR5bkcjSUsJox1WzjVQWKCBANNASUr66AlA+706Tjvtr9hw84aDElQMDE1hBGpRjy5sBqNLhevOzs7G9u3b+9yOkMEhAgIQRCEw54vv/wSF154Ierr65Gamoq33noLxx9/fLd+Bg3ycnpDqHb7Ud0YgD8U5amgveJ22RqKAp2nnMWEqXpt09CtGqiiQbgbG7Fy41Zsd2mwqEyLZRU6+I2pcJfkI+pzxd9i4cKFmD17NrqCCAgREIIgCH0CupqmkPzatWu5LoJmadx66618v7vxBsPsckntoE5fiAsvLVR4adD2foqDUBRo/HVcM2GpWAHnpgUo37YOzUvxhVUo8Njw0k91WLNzt4B44403cMEFF/T4HnoQ5JUgCIIgdIzBgwdj+fLluOSSSxCNRjmtcdJJJ2HXrt1TM7sLmvo5INGEyblJmDowCcNSbbxZUysldUB4AmFOf/QaKhUP6PJmHoXqSb/HquE34t6fLPi2RI9anxomjYKJDh+ssWGgcTIzM3tneRKBEARBEA51aKt64YUX8Ic//AFerxfJycn8+IwzzujRz6UUB7WD1rgDqGkMwhcMQ6/VcFSit7s4ItEITjvtNFRVVUGvimJ8cgjHDdLjyQXVCHl7vwZCIhCCIAjCIQ9tjldccQVWr16NSZMmoba2FmeeeSZ3bJCLZU9BdRBpNiPGZNl5yNX47EQkmnU8GbTM6UW9J8giozfQqDW45ZZb+H5QUWNVtR5/25KCiBI7P8RTTz3VLX4QHUEEhCAIgnDYMHLkSPzwww/xjfS5557DuHHj8PXXX/f4Z9Pkz6xEEw+4mjLIgdGZCTDq1ajzxKaENnDdRM8G9Y+fczxPM01Li83TaIYiDwfawtlZJIUhCIIgHJZ89913HJXYsWMHP7700kvx5JNPwuGIjdDuDSJkVOULodYTQBUZVQXC3BJKczjIY6KnWkIpnbF2zRpsK6/F9CGpOPWEY8WJ8kARASEIgtB/oPTFXXfdxWZTtJ2lp6fjiSeewEUXXdTrfg6hppZQmhBKLaGeQAQ6tYrts3vKX+JgDtOSFIYgCIJw2EJzMyjvv2zZMowePRqVlZU8IvyYY47BihUrenUtOo0aqTYDRmUmcL3EpNxEpNkNPJdjV4OP7bTpfl9BBIQgCIJw2DNjxgysWbMGjzzyCCwWC9dJkIPlZZdd1iMtn+1BHRrpCUaMH5CIaYMdmNBUfEmtoFR8SVEKGkN+OCMCQhAEQegT0LwM8okoKCjAxRdfzM+99NJLGDp0KG666SaOThwMzHpti+LLJIzNsnNao8Ef7PVOju5EBIQgCILQp8jKysLLL7+MH3/8EUcffTT8fj9P9hwyZAhuv/121NTUHJR1qXjehg45DjObVU0Z2KKTwxsTE05vEOHDREyIgBAEQRD6JEceeSSWLl3KMzUonUEGVNQCmZubi6uuugqbNm06aGtTq1Wwm3QYmGzB1IEOdr4clWGDTqtGLbWFNni5LbQ9MbGrONaBcjCQLgxBEAShz0Nb3eeff457770Xq1atij//i1/8Av/zP/+Dk08+GVqtFgebSFNbKHlLUCeH2xdGVFG4LbR5Jkej24UvPnoP77/5CjZtWItVGzZj0tiR3fL50sYpAkIQBEFoBdrylixZgr/97W/48MMPeb4GkZGRwQOoqINj4sSJvT/SuxUo+uDyh7lGorzei59+Wo6vPngLS776BH6fl4/RanX4x/Mv4HeXzkefERAPPfQQPvvsM56gptfr4XQ6230NLYXU4fPPP8/HUxvOP//5TwwfPrzDnysCQhAEQegINDPimWee4XoJssZuZuzYsTjrrLMwb948Tn30ljX03gSDQSxYsADvv/8+PvroI56B0UzukOGYe86FOOGXv8KJk4cfFB+IHhMQJAQSExNRWlrKA086IiAee+wxbsGhv0yawHb33Xdjw4YNnKcyGo0d+lwREIIgCEJnN2qqk3jttdfw8ccfIxAIxH9GrpZz587FnDlzWEyQuOipVEcgEMDKlSs5QrJ48WKu33C73fGf055KwubSy36LMROn8shxGvQ1Ij2B6yn6jIBohlpobrjhhnYFBC2DKmdvvvnmuMc5fQFyFaP3OP/88zv0eSIgBEEQhK5CexWJCKqX+Oqrr/bZu8xmM6ZMmcIDvYYNG8YtonQbNGgQt5G2B6VM6uvruaW0qKiIL5Dz8vLiN+oYaQmlVmhoGM24mD17NnQ63T57Z3emWzqzhx78ipEWoaSKigqceOKJ8efoS1AVLRmC7E9AkGJrqRbpywuCIAhCV6CrfPKQoFs4HOZWUIpO0D5EzpYUEaAIwZIlS/Z5rclk4tfTrXnzpfdovpFwoDQE3d8fqampOPbYY/k2a9YsHHHEEVCr998weTBrNQ4ZAUHigaCIQ0vocfPPWoNSHvfff3+Pr08QBEHoX1CqYubMmXxrjh5s2bIFP/30E0cOCgsL+bZt2zZuEfX5fHwrLy9v972TkpJ4gialRFreqObvUCjg7HYBQQ5fVKfQFps3b8aoUaPQW/zxj39kh7GWEYicnJxe+3xBEAShf0CRgDFjxvBt7zQCRRco3UGh/+Y/6XgSIXSjQkyKTNBFMY3ipuaCw51OCQiqT6BxqW1BTl9dgfI8BOWFMjMz48/TY2qp2R+Uc+pI3kkQBEEQegKVSsXFlr05RvywExCUm6FbT0BdFyQiaL57s2CgaAKFiq655poe+UxBEARBEA4xK+vi4mL2gKA/I5EI36cbzW5vhlIdH3zwQVzBUbfGn//8Z66ApfZNKmKhzgyqQBUEQRAE4dChx4oo77nnHvZzaIZaXoiFCxdyKwqRn5/PeaJmbrvtNng8Hlx55ZWcQ6LCFap+7agHhCAIgiAIvYNYWQuCIAiC0Ok9VKZxCoIgCILQaURACIIgCILQaURACIIgCILQaURACIIgCILQaURACIIgCILQaURACIIgCIJw+A7T6i6au1JlKqcgCIIgdI7mvbMjDg99TkDQqFVCBmoJgiAIQtf3UvKD6FdGUjRuddeuXbDZbN02ErV5wmdJSYmYU3UTck67Hzmn3Yucz+5Hzumhfz5JEpB4oDESNE20X0Ug6AvTjPWegP6C5B999yLntPuRc9q9yPnsfuScHtrns73IQzNSRCkIgiAIQqcRASEIgiAIQqcRAdEBDAYD7r33Xv5T6B7knHY/ck67Fzmf3Y+c0751PvtcEaUgCIIgCD2PRCAEQRAEQeg0IiAEQRAEQeg0IiAEQRAEQeg0IiAEQRAEQeg0IiCaePbZZzFo0CAYjUYceeSR+Pnnn9s8/p133sGoUaP4+PHjx+Pzzz/vtbX2xXP6/PPPY9asWUhKSuLbiSee2O7fQX+ks/9Om3nrrbfYmfXMM8/s8TX25fPpdDpx3XXXITMzkyvfR4wYIf/3D/CcPvXUUxg5ciRMJhO7Kt54443w+/29tt5DmcWLF+O0005jV0j6//vhhx+2+5rvv/8ekydP5n+fw4YNw0svvdRzC6QujP7OW2+9pej1euXFF19U8vLylN/97ndKYmKiUllZ2erxy5YtUzQajfL4448rmzZtUu666y5Fp9MpGzZs6PW195VzeuGFFyrPPvussmbNGmXz5s3KpZdeqtjtdqW0tLTX195Xzmkz27dvVwYMGKDMmjVLOeOMM3ptvX3tfAYCAWXq1KnKvHnzlKVLl/J5/f7775W1a9f2+tr7yjl9/fXXFYPBwH/S+fzqq6+UzMxM5cYbb+z1tR+KfP7558qdd96pvP/++9QtqXzwwQdtHl9UVKSYzWblpptu4r3p73//O+9VX375ZY+sTwSEoijTp09XrrvuuvjjSCSiZGVlKY888kirx5977rnKqaeeusdzRx55pHLVVVf1+Fr76jndm3A4rNhsNuXll1/uwVX2/XNK5/Hoo49W/vOf/yiXXHKJCIgDOJ///Oc/lSFDhijBYLAXV9m3zykde/zxx+/xHG1+xxxzTI+v9XADHRAQt912mzJ27Ng9njvvvPOUuXPn9sia+n0KIxgMYtWqVRwybzlPgx7/8MMPrb6Gnm95PDF37tz9Ht/f6Mo53Ruv14tQKASHw9GDK+375/SBBx5AWloaLr/88l5aad89nx9//DFmzJjBKYz09HSMGzcODz/8MCKRSC+uvG+d06OPPppf05zmKCoq4pTQvHnzem3dfYkfenlv6nPDtDpLTU0N/wKgXwgtocdbtmxp9TUVFRWtHk/PC107p3tz++23c95v7/8M/ZWunNOlS5fihRdewNq1a3tplX37fNLmtmDBAlx00UW8yW3btg3XXnstC11yA+zvdOWcXnjhhfy6mTNn8hTIcDiMq6++Gn/60596adV9i4r97E00tdPn83GdSXfS7yMQwqHHo48+ykV/H3zwARdiCZ2HxvHOnz+fi1NTUlIO9nL6BNFolKM5//73vzFlyhScd955uPPOO/Hcc88d7KUdtlDBH0Vx/vGPf2D16tV4//338dlnn+HBBx882EsTOkC/j0DQL1eNRoPKyso9nqfHGRkZrb6Gnu/M8f2NrpzTZp544gkWEN9++y0mTJjQwyvtu+e0sLAQO3bs4ArulhsgodVqkZ+fj6FDh6K/0pV/o9R5odPp+HXNjB49mq/6KHyv1+vRn+nKOb377rtZ6F5xxRX8mDraPB4PrrzyShZnlAIROs7+9iYa9d3d0Qei3//t0H96upr47rvv9vhFS48p39ka9HzL44lvvvlmv8f3N7pyTonHH3+crzy+/PJLTJ06tZdW2zfPKbUYb9iwgdMXzbfTTz8dc+bM4fvULtef6cq/0WOOOYbTFs1CjCgoKGBh0d/FQ1fPKdU67S0SmgWajGnqPL2+N/VIaeZh2HpErUQvvfQSt75ceeWV3HpUUVHBP58/f75yxx137NHGqdVqlSeeeIJbDu+9915p4zzAc/roo49y+9e7776rlJeXx29ut/sgfovD+5zujXRhHNj5LC4u5s6g66+/XsnPz1c+/fRTJS0tTfnzn/98EL/F4X1O6XcnndM333yTWxC//vprZejQodzpJij8+49a2+lG2/Vf//pXvr9z507+OZ1LOqd7t3HeeuutvDdRa7y0cfYC1C+bm5vLmxi1Iv3444/xnx133HH8y7clb7/9tjJixAg+ntpmPvvss4Ow6r5zTgcOHMj/Qfa+0S8Yoev/TlsiAuLAz+fy5cu5ZZs2SWrpfOihh7hVVujaOQ2FQsp9993HosFoNCo5OTnKtddeq9TX1x+k1R9aLFy4sNXfi83nkP6kc7r3ayZOnMjnn/6N/t///V+PrU/GeQuCIAiC0Gn6fQ2EIAiCIAidRwSEIAiCIAidRgSEIAiCIAidRgSEIAiCIAidRgSEIAiCIAidRgSEIAiCIAidRgSEIAiCIAidRgSEIAiCIAidRgSEIAiCIAidRgSEIAiCIAidRgSEIAiCIAidRgSEIAiCIAjoLP8PIovtEGDIhbEAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 18) \t Best Value: 1.1935042208215094\n", + "Early stopping at epoch 6128 with loss -0.11396026729265785\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 19) \t Best Value: 1.1935042208215094\n", + "Early stopping at epoch 3919 with loss -0.06498622307422375\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhAAAAF2CAYAAAA/RaFTAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAyYFJREFUeJzsnQV4U1cfxt+4p264u8sYTBjM3Y25wHxMmDB3gTHfmLv7Nx/bYIMx2HB3aal707jd73lPSZd6Ci1Szo8nD01ycy0397znrypFURRIJBKJRCKRNAN1cxaWSCQSiUQiIVJASCQSiUQiaTZSQEgkEolEImk2UkBIJBKJRCJpNlJASCQSiUQiaTZSQEgkEolEImk2UkBIJBKJRCJpNlJASCQSiUQiaTZSQEgkEolEImk2UkBIdpt33nkHKpUK27dvr37tiCOOEI+W4oEHHhDbkEj25LUUWba4uHiP7FNrb0eyb6NSqcS1sL8gBQSAU045BWazGZWVlQ0uc8EFF0Cv16OkpKT6i45+WCwW9OvXD4888gjcbneNz1566aWwWq0xDcKLFy9u9v536dKlxr6kpqbisMMOw9dff439CZ43/nj++OMPHCjwWGtfSw09WpvobWm1WiQmJmL48OGYPHky1q5d26a/18ceewzffPNNm/xeDzRWrVqFs846C507d4bRaET79u1x9NFH44UXXtjbu9bm0O7tHdgXoDj47rvvxIB78cUX13sD/N///ofjjjsOSUlJ1a/zoows73Q6MW/ePNx7771YsWIFPv/88z16DEOGDMGtt94q/s7NzcWrr76KM844AzNnzsTVV1+NPc2sWbOa/Rme5wcffFD8Xdt6cc899+DOO+9EW6Nv3754//33a7w2depUITjvvvvuPb4/kWuaLXIqKirEtfzuu+/i5ZdfxpNPPolbbrmlRb/XvUF91xIFBAed0047rU1+rwcKf//9N8aNG4dOnTph4sSJSE9Px44dO7Bw4UI899xzuOGGG/b2LrYppIDYaYGw2Wz46KOP6hUQFA8ul0sIjWh69eqFCy+8sPo5B2q/34+vvvoKXq9XqN89BVV29L7wOHr06IFnnnmmQQERDAYRDoeFZaWlael1ckbMR1sjLS2txvdGnnjiCSQnJ9d5fU9Q+5qO7M/JJ58sBGqfPn1wwgknYH9mT1xL+9r3eqDw6KOPIi4uDosWLUJ8fHyN9woLC/fafrVVpAsDgMlkErP133//vd6LjMKCAoNCoymoeCMm4L0J94OzoG3btonnjE/gfj311FN49tln0b17dxgMhmrT9Pr168UMjGZrCp8RI0bg22+/rbPeNWvWYPz48eKcdejQQbhsKEJqU18MBEUVTdkcpLiNjIwMcd63bNki9i8lJUUsx9lqxLwb8QfW9lsPGDBAzDRqw32hmOKxRL/GY+7fv7/YLm/uV111FcrKymI6l7NnzxYuIbqpeFM69dRTsW7duhrLRPZv8+bNwmXF5Xgju+yyy+q4tHaFrVu34uyzzxbfD91tBx98MH744Yfq92kB4/7R3VCb7OxsaDQaPP7447u0bVrdPvnkE3FN8wYdgWL5vvvuE24OHiu3z/M0Z86c6mWa+l5Xrlwpzle3bt3Ed8Pr9vLLL692FTYELSQcjKMtIvyeed55rOXl5dWv03LCfec5qu9a4t+cINDSEtk/7lM0XF9rfK+1iWU7FP4PP/xw9W+YLsy77roLPp+vxnJ8/aSTThLuFP6e+ZsdOHBgtSuJEx0+53nnd7hs2bJ6Xa+89o499ljx/bZr1w4PPfSQOP/R8PrgOniftNvtYr2c8TfnGo52/Xz22WfiWuM9hvt35JFHit9WU/Bewt95bfFA6NqN5u233xb3Mr7O80gXNC22tdmT57E+cnJyxG+C9y3uJ4/vrbfeqrMcXTR8j+c2ISFB7CvHrlaF7bwlijJr1ix+k8oLL7xQ4/WSkhJFp9MpF198cY3XuewVV1yhFBUVicf27duVDz/8ULHZbMpFF11UY9lLLrlEsVgsjW7/7bffFutctGhRs/e9c+fOyoknnljjNb/fr6SlpSnp6eni+bZt28T6+/Xrp3Tr1k154oknlGeeeUbJzMxUVq9ercTFxYn3nnzySeXFF19UDj/8cEWlUilfffVV9Trz8vKUlJQUJSEhQXnggQeU6dOnKz179lQGDRok1s1tRBg7dqx4RAgGg8qRRx4pljvvvPPENh5//HFl/PjxyjfffKM4nU5l5syZ4v3TTz9def/998VjxYoV4vP333+/eC/CQw89pKjVarFP0fz5559iuc8//7z6tSuvvFLRarXKxIkTlVdeeUW54447xPcxcuRIcZ4a49dffxWf7dWrlzJt2jTlwQcfVJKTk8U5iD7eyP4NHTpUOeOMM5SXX35ZbJev3X777c36Pvv371/j3OXn54vvktfW3XffrTz99NPK4MGDxfFHfz8XXHCBWI7nOhruN79LfteNwX297rrrGnyf3x+3WVFRIZ7zus/IyFBuueUW8d1xO7179xa/l2XLlollmvpen3rqKeWwww4T3+drr72mTJ48WTGZTMpBBx2khMPhRvf3lFNOUYYPH179nNvkdriP33//ffXr/G2MGDGi+nnta4n7YzAYxH5E9u/vv/9u9e81muZsh/cTvn7WWWcpL730krg38flpp51W577A74PfEX+v/L23b99esVqtygcffKB06tRJ3Af44O+/R48eSigUqrEdo9EofuO8p/E3e9JJJ4lt3XvvvXXunbw+uD98XH/99crZZ5/d7Gt4zpw51eeB3y33mftuNpvFNdEUxxxzjNjGqlWrmlyWv/9LL71UbIP3fX6W2+Zx7o3zSPgar4Xo89ahQwelY8eO4jfC3xKvey7H/YjA307kmnj11VeV5557ToxPN954o9KaSAGxE950eYGMHj26xusccPjF/PLLLzVe52v1Pfgj9nq9e1xA8OKPiBnenDlIc3033HBDDQFht9uVwsLCGp/nD3/gwIE19ps37zFjxoiLPsJNN90k1vHPP/9Uv8Z18UfTlIB46623xDK8cdQmMlBw32v/gBq66W/YsKFewXfttdeKH7bb7RbP582bJ5ajuIvm559/rvf12gwZMkRJTU0VQjICzy9vfNGiMrJ/l19+eY3Pc9BMSkpSdmegiZx3HkuEyspKpWvXrkqXLl2qb1a8RrncTz/9VGN9FHgNDVzNERAc3LlMZPDnb8bn89VYpqysTAwU0eehse818j1F8/HHH4vl586d2+j+UsBqNBrF4XCI588//7z4LXCgoUgkPDfx8fHKzTff3OC1RPj75O+0Nq35ve7KdpYvXy6Wo7iIZsqUKeL12bNnV7/Gc8HXImIo+hqhSIsWlBx0+DoH8NpCJXIPifxWKcj0er34XiPXBe8rtYVrNLFewxEB0bdv3xrXFgdEvt6UMKCY4TXBB+/lFF885vomCvVde8cee6yYYEWzp84jqf07oQjguFRcXKxEw/s777uRYzj11FPF9bWnkS6MndDsed5552HBggU10hFpAqLpiCa02tCU/euvv4oH4yQYJPXzzz9jwoQJMZmmWjpokaZiPgYPHiyCOC+66CJhvo3mzDPPrDYpk9LSUmGiP+ecc0QWCtPI+KAJmea2TZs2CRMa+fHHH4XZ8aCDDqr+PNdVOzakPr788kthcq4viGlXItHpBmHg6Kefflr9WigUwhdffCH89TQzEp4HmoIZHBg5Nj5oaqRZMdrcXpu8vDwsX75cmCBpdo0waNAgsT6ej9rUjjehSZ/n0uFwYFfhdnjODz300OrXuO+TJk0S12rEDXXUUUcJ0+iHH35Yvdzq1auFm6Al/O6RTKJIthJ/M5FYF7oPeC3RvE7T6dKlS2NaZ+R7iri4+N3wGiNNrYPnlt85A+cIg5j5Gh/8O3L8dAvwtd2hNb7XXdlO5JqrHcwaCaCu7RKgWX706NHVz0eNGiX+p+megYa1X6eZvTbXX399jd8qn9N99dtvv4nX6C6gC4j3wd29hiPQdRMdRxX5/urbv2j4u+Q9nO5mBgBPmzZN3Mfo1qztko2+9hgwzGtv7NixYht8vqfPY204hvC+yfsZ/46+f/GYuI+R3wi/A7oqGfuxJ5ECIorIQBjxG/EL4Y2IwoI3y9rQP8ebNh+8YBnJzZgA+sS+//77PbrvvHD5A+bFyBsqL7L33nuvxo+EdO3atcZz+hV5cTJ7JCJAIo/7779fLBOJC8nMzETPnj3rbLt3794x+Sa5XEvGhpx77rmYP39+tcChT5L7ytcjUADxh0Y/Z+3jo0+8scAqHm9Dx8f4Ep5j3jijib6ZEPoiSazxFg3tR0P7EL2farVaXMNMR4z4zSkm6Jul73l3icQQ0M8dgXEDFFTcBmMleF45iNW+ATcERQfjNijSea3y85FrtKl1DBs2TPh7I2IhIiAOP/xwkQ5NQRJ5L3rg2hVa43vdle3wu+b3zADpaBg7wkEkci00tD6KadKxY8d6X699PNwW41Nqi3cSmWhde+214rXjjz9e3BPpr+dEaleu4VjPQ2OMHDlS3IO57L///ismdhS9jIuKFiq8d/DeHYlt4rXHWJL6rr09cR5rU1RUJMTva6+9VufeRYFFIvevO+64QwgyijTeo6+77jpxfK1N2wtr3w04K2WU+ccffywuJP7PwTWWGXaEiKVi7ty5QjnuKTi754+hKWoLikgA5JQpU4SqrY/aN6t9BQoF3hxoZbjppptE4BV/wEy3jT4+iofoWXk00daYlqA+oUn2lEWK2TfTp08XIuL8888XYpgBYJEb2+7A2TyPLzLAf/DBB8I6w9TH2267TZznSLAmBWMs0PJFwcvP06LEmyC/M36H9QXnRqPT6YRw5m+NQjg/P18ICIqRQCCAf/75RwgI/qZ393veU99rrNuJ1WrX0Ppa8nj4vdNS98svv+Cnn34SDwYo8lqkwNwVWmL/aMGgmOCDgzUHXd4rODHi9cl7Na+Np59+WggBLk9LCTPXal97e+I81iayD7QeXnLJJagPiveIENuwYYOYuFK80XLB1GsGOUdSqFsDKSBqQbHA2TjNvrz5Us3xAowVmnCjZ2v7OhFVzJtxUwKEhVk4o68NL9ymYMQ4b+i8sXNb9dFcVwYHMipuujFoDuSsg4MZI5Wjt0urzCGHHFJHPDUFj7eh42PWCkUbZy+tDfejoX2I3s9IdsrQoUOFYOJsMCsrq0UK6HA9f/75pzDjRiwQdBfx+uF5j/7uIparpr5XztKY+cQbHG90Eeq7xhqCgoFuOn7H/D44IHB7jEaneOCDAqop9peCTvyuObDwHEVm76SgoEDMVqOvhZaA26I5PjJbJhs3bqzOTojAwZcTJj74GVolWIuG91JOQJpzDbcGdKtF3JKEdX+YtUK3RrR1oTGX5p44j9FQ9PK3RjddLJND3os4qeKDrhFmuDGThZOs1iopIF0YtYhYG3hDo6pujvUhcmESxiHsD3D2wHRL/tgjP67aZrQIzP9nQRaaBaPfb2h2Xzv2gib/F198sUG1TnM0iU7Bawr+WLhPTGvi+qPdF5EZLn+ATHurT+w1ti2mmXJWzFlU9HKciTPmZE/VQ+B2eM7p241A1wlNm7z50D8bDWNfuH9MXaVbgabl3YFuBlozeB6jiyBFZl/Rsy2KxOj9bOx7re/zhPvdHAHBgYCfoZsiIgT4Ogs5sahaLPEPvPk257rbW0SuudrniLNocuKJJ7b4NqN/s/yu+JyTgIi1tXbKLc31kZlxJLW0udfwrkIBUN/sPxI7EnGj1Hft0W1By0lr8WIT57E23EfeN2lN4D2nsXtz7e+Ago7nlNvhpK21kBaIema1Y8aMEUGRpDEBQQVJMy6hz5kDGQcbKm7exKPhl8j4iNowOI9qPQIHwtr+Q0I/cbTvuSV56aWXxM2Xucys3sZZJWc0/LEzDoTBSOT2228XN2Wal7k/vOnyBsDZAy02jUFzJmMyGPzFGwlv6ryBcObI42dAKi0EvOhpUaBS57nhjJqPhqBAoPuFDy5fW6kzKIo1H2hWpyA85phjxI+WMziaM5mrHl0zojZ0B3AA5sz7iiuugMfjETN6ugT2VM16Vk2kO437ceONN4rj5HXGGh+8ufCGHQ2DePldsbLqNddc06DFp7FrmjceBu5FqqrSosZBKto9xJk9rQ+nn366GLi4P6+88or4DqMtcI19r4xXYKAbfx8MdKPwidQuiQV+L4yr4eyWAXkRuN5ITn8sAoLuS16LPEYGovI+EAmI25fgxITmbP7uKHh4ffP3xOuB1rf6aqPsDpy58n7EbfJ80D3BGBe6eCNuoSuvvFKITAYU0urFeAb+Rii+I1aS5l7DuwqDtHkv5jVJaxRn4nSR8dqjUInEDvA+ELGa8P7A6/X1118XE6r6JlJ74jzWB4uPURTxM7w383fEc83gSV6v/DtyPIyDoaWVLjzWqaFA4e+ytcYNwR7P+9gPYB4zT01jece10zeZNsR83UmTJikFBQU1lo2k8dT36N69e400zoYeO3bsaFYdiNpE0jiZ+lYfW7ZsEWmJrBvBPH7mOTNX+Ysvvqix3MqVK0UqGvOauczDDz+svPnmm02mcRKmHDEHnKlb3Aa3xbxlbjsCU6WY/830puiUpvpS7yIccsgh9aa2RcM8aa6XaVfME2faKlO8cnNzlab47bffxDb4WaarnXzyycratWtrLBPZv+iUrOjvNfrc7Eq6H88RzxVTEnnueW1G1zqozQknnFAn9awpoq83pqlyW8zHZ5remjVr6izPVLTHHntMXH+so8BluU+83vlaNA19r9nZ2SJVkdtiWhprB/A7aSjts6F8/trpxVwvX2P+fG3qu5bWr18vap/wO+Z7kZTO1v5ea+9TLNsJBAKiHknkd8RjnDp1ap308YbuC/Wl69Z3f4ikn/PaY5o4azEwRZf7Gl3ngPcIvs90Z36/rItw1VVX1anREss1HEnjjK7jEr1/PB+NwRRmpsL26dNHpHNzf1iXgSmUte/L3377rUhx5r4wlZQ1cCLp5tHne0+dR1Lfdc/95nb4PUfum0y95z0tOn2U1y9Tfvlb5Lhy2223VddsaS1UO3daIpG0ITgDY1OhWKr3SST1wQBZxrnsL/Fc+yqXtuHzKGMgJJI2Bk2wNI/WdqNJJBJJSyJjICSSNgL9ycz9fuONN0TcA327EolE0lpIC4RE0kZgmiWtDhQSDFBjUJVEIpG0FjIGQiKRSCQSSbORFgiJRCKRSCTNRgoIiUQikUgkzabNBVGyZCirz7F4xv5SnlYikUgkkn0BRjWw+RgLqjVV4KvNCQiKh9od0iQSiUQikcTOjh07RGXRA0pARMp28uDtdvve3h2JRCKRSPYbWMKek/BYSmC3OQERcVtQPEgBIZFIJBJJ84klBEAGUUokEolEImk2UkBIJBKJRCJpNlJASCQSiUQiaTZtLgZCIpFIWopQKIRAILC3d0MiaVH0en2TKZqxIAWERCKR1JMLn5+fj/Ly8r29KxJJi0Px0LVrVyEkdgcpICQSiaQWEfGQmpoKs9ksi9JJ2lyxxby8PHTq1Gm3rm0pICSSnabqefPmiR9VRkYGDjvsMGg0mr29W5K9dC1ExENSUtLe3h2JpMVJSUkRIiIYDEKn0+3yeqSAkBzwfPXVV5g8eTKys7OrX2MFtueeew5nnHHGXt03yZ4nEvNAy4NE0hbR73RdUCzvjoCQWRgSHOji4ayzzqohHkhOTo54ne9LDkyk20LSVlG10LUtBYTkgIXqm5YHBszVJvLaTTfdJJaTSCQSSU2kgJAcsDDmobblobaIYE8VLieRtCW6dOmCZ599Fm2FP/74Q8yqZdbMnkUKCMkBCwMmW3I5iWRfgKL38ssvF+2Y6evu3LmzsLSVlJSgLXDEEUcIy2A0Y8aMEb/TuLi4vbZfByJSQEgOWJht0ZLLSSS1ofuLs+OPP/5Y/N/a7rCtW7dixIgR2LRpk9jm5s2b8corr+D333/H6NGjUVpair0Bj5vpg60FhVJ6erqMW9nDSAEhOWBhqiazLRq66fB1trXlchJJc2EALl0F48aNw4QJE8T/fN6agbnXXXedGExnzZqFsWPHijz/448/Hr/99psIDL777rurl62srMT5558Pi8WC9u3b46WXXqrhvnvggQfE5w0Gg7Bm3HjjjdXv+3w+TJkyRXyOnx81apQQSBHeeecdxMfH49tvv0W/fv3EOt544w0YjcY6bgZaR8aPHy/+ppWE+8T1Mgtm4MCBQghFuPTSS/Hnn3+KDCn+PvnYvn17vS6ML7/8Ev379xfb5nmfMWNGje3ytccee0xYa9i6msf62muvVb/v9/tx/fXXiwkE95uWnMcff7wFvqU2hNLGqKioYPSb+F8iaYovv/xSUalU4sHrJvKIvMb3JQcWHo9HWbt2rfh/d6+r6Guqta+rkpISse7HHnus3vcnTpyoJCQkKOFwWOncubNis9mUxx9/XNmwYYPy/PPPKxqNRpk1a5ZY9vPPP1fsdrvy448/KpmZmco///yjvPbaa9XruvLKK5UxY8Yoc+fOVTZv3qxMnz5dMRgMysaNG8X7b7/9tqLT6cQy8+fPV9avX684nU4lLS1NeeONN6rXEwwGa7yWnZ0t1rVs2TJly5Yt1fvF7ZPy8nJl9OjR4ljy8vLEg+uYM2eOOL9lZWViucWLFytqtVp56KGHxPFxf0wmk/g/As9BYmKi8tJLLymbNm0S54Kf4b4S7kfHjh3FMW7fvl2ZN2+e8tFHHylt/RqvaMYYKgWE5ICGN9N3P/lS6dBvhKI22atv9LxxSPFwYLK7AoIDWocOHeqIh2gRweuLy7UkCxcuFOv/+uuv633/6aefFu8XFBSIwfO4446r8f65556rHH/88eLvGTNmKL169VL8fn+d9VBQcFDPycmp8fqRRx6pTJ06VfzNgZrbWr58eY1lJk+erIwfP776+S+//CKER2Tgr48TTzxRufXWW6ufjx07VqwnmtoCYsKECcrRRx9dY5nbbrtN6devX/VznoMLL7ywxr0gNTVVmTlzpnh+ww03iH3l620NTwsJCOnCkByQUDyXufxYk+tAu4GH4JWPvsGMd77EM29+gl9+m41t27bJIlKS/TK7p7605PpgTETt5+vWrRN/n3322fB4POjWrRsmTpyIr7/+WlQtJKtWrRIxDb169YLVaq1+0LWwZcuW6vXRlTJo0KAa27jggguEu4FVEMmHH36IE088Ubg7CNf78MMPC9dFYmKiWO8vv/yCrKysZp0DHschhxxS4zU+Z2xIdBxK9P7RBcI4isLCwmp3yfLly9G7d2/hvqFbSFITWYlScsDh8gWRVepCXoUXobCCBLMeBq0RySOGoszth92kR5EzgFSbGmq1DMqS7B/ZPT169BCDIAfP008/vc77fD0hIUGUMW4Kxv5s2LBBxE78+uuvuPbaazF9+nQhEpxOpyjzvmTJkjrl3jngRzCZTHXii0aOHInu3bvjk08+wTXXXCOECeMlInAbjG9giilFBOMrmHHBeITWoHYVRu5vJNhz2LBhYiLx008/ifNwzjnn4KijjsIXX3zRKvuyPyIFhOSAorDSi62FLpR7/EiyGGDU/XcDNOu1MOk0KHMHsCqnHH0z7OiQIMsZS/aP7B727Tj66KPx8ssv4+abbxYDeHRzMM72L7744upBfeHChTU+z+d9+/atfs7Pn3zyyeLB4Mw+ffoI68PQoUPFLJ4z9V0JMKYVgvvCAGZ2haQFIsL8+fNx6qmn4sILLxTPOZhv3LhRBGJGWzaaymbhcXBd0fA5rSbN6XFjt9tx7rnnigcr0x533HEik4XWEYnMwpAcIARDYWwrcmJVTgW8gRDaxZlqiIcIvLkmWvQw6bTYXuKG219ltpVI9ofsnhdffFFkSBx77LGYO3eucJX8/PPPQlgws+HRRx+tMaBOmzZNDNDMwPj8889FRgShVeDNN9/E6tWrRWroBx98IAQFMxE4CFMEUIwwo4Sz9H///VdkKPzwww9N7iM/u3TpUrEvHJSZJRGhZ8+ewuLx999/C4vJVVddhYKCgjrZE//884/IviguLq43PfTWW28Vqat0h/D43n33XXFumDkSK08//bTIAFm/fr1YB88PXRwRd4tECgjJAQBFwNo8BzYWVsKi0yLJamgyX9xu1MLpCSC71LPH9lPSNuAMl2Z4Uvs6izynib41ur1yAF68eLGIXaDJne6CSZMmiRTSBQsW1Jg5c5DlsrQoPPLII2LApPAgHCRff/11ETfAOAGa8L/77rvq7qRvv/22EBBcB2METjvtNCxatEikQsbiajnooIOwcuVKISaiueeee4TrgPvBglEcsLnuaCgCeO5olaA7pr74CK7js88+E66SAQMG4L777sNDDz0k4hpihamdFFisq0HXCwXLjz/+KKwmkipUjKREG8LhcIhqZBUVFcL8JDmwKXf7sT6/UvyfajNCp6n14w+HEFqyBJlLlqCYN//hwzFk+HBo1BohPPgY2ikB8eaq7nWSto/X6xWz6q5du4r8/5bs8krLA8WDDNCV7KvXeHPGUBkDIWmz5Fd4sbGgEv5gWLgs6lgd5syG95FHYawoRzdAPAreeAOPx8VjzD13Y/y48aj0BpFZ4obdqJMBlZJmQZFAfz6zLRgwyZgHui1aw/IgkewNpICQtDnCYUVkWWwudEGvVSPNXs8scs5sKLfdhtp2Bcan31VRjjtuu40h4Tjs8CNQ4PCKdaTH7fpsVHJgQrFAU7xE0haRzhxJm4LWhg0FDuG2sBq0IkWzDuEQlKeeElV9av8AIs9vBfDMU09BrVKg16ixvcQFX1C29ZZIJJIIUkBI2gwefwjr8hzILPEg2WqAxdCAgW3ZMqgKChq8+Pl6OtPsCgqwfNkyJFj0KHcHkFMmAyolEokkgnRhSNoEDm8AG/MrUez0I81mgLZ2sGQ0xQyXbJpkAP8uWoQhQ4ci3qTDthIXrEatCMZsi24fbzAEbyAs0lwZPEprTjDMcvesbghoNUCcSQ+TXgOzXgOjViPjQiSSAxgpICT7PSVOHzbkV8LlDyIjzgh1Uy19kykNmoYyY9Ybb4j0NaaODR55CDYVOEWxKZuxZgW7/Q0mX3kCITi9QVR4Aihx+YVwoGiocu2ooFGz2yHAs8kAVFbtzCnzihcMWrVwEXVKNAtrjxQSEsmBhxQQkv2avAqPsDyEwkCazdhkfQfB0KFQ0tLYVaheNwbL0rAa/rKdz1lx7/bbb8eTT05D3+GjsaXQiX7t4kSA5v5mZaj0BeHwBERFTooHbzAMjv0snGXRM2ZE3aQAo/jwBcMiQ2X5jnIRYEohQVePRCI5cNi/7oASSdRgmFniEs2wOOCl2JouDlWNWgPVlCliZl27hl3k+YydrRMFO0ulPD1jBpItOuQ7fNhe7Iq5adHePk8V7oA4V0uyyrA4sxRrcitQ6QmK0t0ZzC6xmxBn0onKnE1ab3ZaI7gsLQ98FFX6sGxHGdbnOYQVQyKRHBhIASHZL8tSbylyCreFRa/dtSJP48ZDNX06/HE1y9LS8nAHszxrL68oKCjIx6oVy5Fk0YusjJzyfTOoksKGMSE7St1CNCzKLMW6vEp4fCHEG/VoH28W1TgpAmIWXQ3Awly0QFj1OnFOInU3JBJJ20e6MCT7FUylpAshq9RdpxlWsxk3HsaxY0UlytmfforP//hDuC0asyuw9j63ydk7B0vO8Nlwa2/HAFA0OH1BkS1C9wTjGjiQ0zWRaNbXrcDZwjCwMk1jRG65F1q1Cr3SbI0HskoOeFhWury8HN988w3aCiqVSnQYrV1+u63Sqr9wNnNhJ7d27dqJExvLhcJe8axjzgYrrJke3epVcmDDzIB1uQ4hHpgJsVviIYJaA83Ig5B4/vlY2oR4IMk7AzCFyV+rEfUmNhc6EWAQxl6yNGSXuYULYfH2/9wTrJxJSwMbg7W2eIhAwZBqM4jvZ0uRSwRdSvb8oMx77RNPPFHjdd57d9faJPmPBx54AEOGDKnzOiuOHn/88ThQaNU7i8vlwuDBg0Wnt1hgbW62dmXjl+XLl4s+8FdeeSV++eWX1txNyX4AB0rGO+Q7vMJnv7uDYigcwpIlizHnp6+RP/tVHJpQiG7tkzmFqP8DKhXS0tJFSmcEZmKwUNXWYhfW5jr2SOdOum/Y10PENGSWYQlFQ44DDncQVoOu2j1hYM7lXoDfCy1D24pd2FbsFBaaAxq2nf7jD+Djj6v+b6INdUvA3gZPPvkkysrKWn1b+xuBQKBV15+enl6ju2hbp1UFBJUYu7ydfvrpMS3/yiuviOYeM2bMEP3cr7/+etHu9ZlnnmnN3ZTsB2maq7IrxMCZEWcS6YW7w+w5s3Huacdj4TMXo9/CKeiy9HGov70Bnx3vxpldPdCp6xn0FAW3TrlVNNli+2C3ywm32wWtShF1J/IdHqzMrkBuuadFAwkjrgn29diQ78CibbQ0lImYBpcvJERMu3hTdUzDvgD3g26TrUUu5Fbsm3Eie4SvvmLvaWDcOGDChKr/+ZyvtyJHHXWUGMjYXrsx/vrrL9Gbg2262eTrxhtvFJM+wtbX7GJZ24LBe3T0dtg9syFWrVqF8ePHi/Wziye7gjqdzjrLPfjgg6KrJhs3XX311fD7/dXvffHFFxg4cGD1OrjNyD6SN954Q4wVFE19+vTByy+/XP0eu2dynz/99FOMHTtWLDNz5kyxrp9++qnGPtDtwO6bbrdbPL/jjjtE23Kz2Sw6m957773V4oNWce7zihUrxPr5iFjKa1vamzoHtBjR3fHUU0+JXilc5rrrrqshdHhM7LLK/U9LSxNj4r7CPhUDwXazvECiYVtXWiIawufziUd0JzFJ2yEycDYrTbMR5v32PRyfT8FHB/uQZFTYjxa+oArhYBg2TxYeHgVc0ceNV1eo8OWGEE0VUEIBKOEQ7rn+MoSCQXjc/93AIv0O9AYjzBYrElPTkZbRDl06dUSPrp0xfMggYeps3759k/vO2bo/FBYVNd2iRkNAxDTwuS8UghpqEWuwJ90Suwr30x/SikZktEjw+QEFRQJv9LUzdXJyql7/4gt222qVTfN6fOyxxzBhwgQhCjp06FBnmS1btuC4444TE7y33noLRUVFYsLGB1t1c8DlZ/k6B/c///xTuO/oYuYgzwGO9+s777yz3n3gIM979+jRo0Wbb6ZC05rM9Ue7pX///XcxMHK9HPAvu+wyMYg++uijwh1w/vnni5banIRWVlaKxmSR7KcPP/xQtOmm2GFL8mXLlmHixImwWCy45JJLqrfBfeSklMtwW1zHRx99VMPVwHVxIKdgIBQT3E+63ykCuF6+xnTuc889F6tXr8bPP/8s2pwTdq/c1XMwZ84cIR74/+bNm8X6ec/gNtlund/D+++/jzFjxqC0tFTs/77CPiUg8vPzhcKKhs8pCjwej1BxtaHKphqUtC14k2AWwcZCp+hFkWLbzRoDShjmzF8xcsmtSOntE8LBG1RjmScd35lPgVYVxlmOz9DXWILudhUePwTI0Prw/L//zQScjop6Vx0KhYSo4KOkqACb1qzAX7WWiU9IQN/+A3HQwQdjzGFHYNjIUeJmFg4DngDbhofg9YfhD4fgDyhgOSeNSiUKNrEkd5Ju/zOL2o1aYYHIKXejR6oNBwx0U0yeXFc8EL5GIclJ0amncrRvlV3ggMtB6P7778ebb75Z733zggsuqJ6ccYb7/PPPC+HAWTqtD4mJiUI4cMbLAf7WW2/Fc889J5b/999/hYjgoFYfHKDZMvq9994TAzrhQM+YOLpXIvd5vV4vBAwH7v79++Ohhx7CbbfdhocfflgIiGAwKLqadu7cWSxPa0QEHhuFQaQ1Oq3Xa9euxauvvlpDQPAYo9un87gvuugiYW3gdjm+/PDDD8IKESHastKlSxdRSO6TTz4RAoLjkNVqhVarFZaehoj1HCQkJIjXKfxoRaEbn8KKAiIrK0t89qSTThIChueBQmhfYZ8SELvC1KlTccstt1Q/58VAc5xk/4XBd/Sf0wRuM+hE+ejdQefIQsrKV6DZ9js0Oi88QeDn0g74NP4S5Cf2q17uL8PhGFT8EyYFP0O/eD+uOciI2XlmrKswQKXRAio1Hnv8cYw86GCYds5UAj4/fD4v/D4fHBXlKMjPRUFeLgrz85CVuR2b1q9B5tZNKC8rw4K/5orHc09Ng05vQL8hIzB8zBEYe+zJ6Ny1m8heMGm1iDOqd9tNsy9AiwtLX7OHSKrdKAI7Dwg4Q8zObvh9iogdO6qWa8VOnRykaD7n4Fcbmt9XrlwpZt7/7ZYi3HOMRaNb4PDDDxfCgVZhDszXXnutsAasX79eCIuRI0dWz9hrs27dOhH/Fhk4ySGHHCLWv2HDhurBk8tEr4OzdZr4d+zYId478sgjhWjgTP6YY44RYoYDLmf3tKJcccUVYqCNQMFR2xowYsSIGs9POOEE6HQ6fPvttzjvvPPw5ZdfCvdJtPWbbg8KKm6D+8P1cpnmsC7Gc0DhFN3indYIWj3I0UcfLUQD3Si0GPFBcdjQeT+gBQTVXEFBQY3X+JxfXH3WB8KAlQMpaKWtw9TDzUWVyCpxI9G8e6ZvVcgH+9YfkLD+IyglW1FZ6cBGhwHPGK/Cug6joEMQ/T1L0Sf3O6i1eixsPwHLk0/EzcoR+CB0N1I0xXjuGDVO/8kCb6jKZbBm/UYcd8LJ/23E/N/NgfQbVDcym+Jiy6b1WLd6BRYv+Av/zp+HwoI8rPh3vni89eyj6DtwMI458TQce9Lp6NC5C9oKLHed66nKFOmbbj8wMgHy8lp2uV2EAoADLydZ9LVHw0HxqquuEubx2nTq1En8zzbkr732mjCZc9bL+3BEVFBA0FrRmnBQ/fXXX/H3339j1qxZeOGFF3D33Xfjn3/+qR5AX3/9dYwaNarO56KJHsAjVg8KEVoIKCD4P90GtCgQumZopaBlm+ePgoTWB1o7WgOdrqaw5m+EIoPQ6rB06VJxznkO6LJhBghdIvHxNWvY7A32KUcq1SdNN9HwAuLrkrYPgw/ZTTOrxIMUq3G3xIPOmQvTnw9C9ftDKNv0L7ZmF+CD/M64JfFZZFsHYoz/b1yQ/RgO3jIT8Z4dsFduwbFbpuHo4o+gU6nwpPYqhHUWdIsL4d6RjHmoMkd//NFHIgizOegNBvQdMBhnnHcxHnvuNfy6aC3+98ci3PXwdIw6dCzUajXWrVqB5554ECccOgQTzz8Vs374X6tHjO8pGLPB+hBl7rZxPE2SkdGyy+0GTOdkLxcOitEwVZ5WBabK135wgCUUCFzm888/F2KC8H/6/efPn1/9Wn3QgkErR3TAIz/Da713797Vr3EZuqcjLFy4ULgHIlZkDqactXMwZ4wD942uBs7eGZ+wdevWOvtPV0ZTUCAwhmHNmjWYPXu2eB6BgoWzfooVWi/o3snMzKzxee5HqImMmljPQVNQ2NA6QusPrUaMFeE+7wu0qoCgymU6Jh+EpjH+Tb8OoTK++OKLq5dncA4vCPqZaCZj9Olnn32Gm2++uTV3U7IPwEyD1TkVyKvwiqyGXe0zoYSCyJ41E9kvnoLgovfgcxRjQ5kK03ERXsu4F/00Obig4g302/wuNOVZYG+o33fosLhQi5Dfh075s3FO1pMIqbT4XjUWUGlwSmc/Tui0M1BXpcKMp2aINNBdhTfFrt174rxLJ+L1j/+H2Us34r4nnhVigu/989efmHL1JTj24AF4cfojKCrIx/6MyA6h1b7UfWCkdR52GMDAxUZSgsEBksu1MjT/c3CkOT4aZhlwoGRAH+/JmzZtwv/+9z/xPMKgQYOEu4Az9GgBwSwDBq5zYG8IbpMxPoxFYMAhAwRvuOEGEXsQHefGjAu6IShUfvzxRxHXwH3gIEtLA4NBGUjIMeOrr74SQZ0cmAlFBWM5eGwbN24UZn8GgD799NNNnhdaUmjx5n5ScERbMSgYuD1aHejC4Pqj4yMicRHbdo5nLC4XHcjf3HPQGN9//73YPrdDEcN4ClonmiNA9lsBwS+epq9I0AdjFfg3zTCEQTIRMUH4RTKYhVYH+o5oMmKaDs1IkrYL0zMpHtgRMt1u3KUKhvxR/fXj5/jmxhFQfn8IXdT5CIQUrA13xrT0aVgffxgu1M/DJfGrENixEkWuMNaValDhV2FchwCGJAeR6VCjwqeCypGDQ1y/YR6GYJuqI/RaBbcPdaOLLVhd0nr5skirrd0nMSkZZ11wqRATP85fjok3TEFSSiqKCwvw2vNP4fhDBuPRu6cgZ0fNWdD+ZoUocHhR5Kx7o21z0IS+M9iwjoiIPH/22VYLoKwNAxMjJvFocUA3BAdepnJG7suc1f+3qyrxHv8/9NBDqz9HVwZn5rVdA9HQxcD6PcwaYKwEXQaMZ2CwYDR8jQM2B3S6EU455RRhoifcDosRMmaBKZUMbOSYEMmeYEYDxweKBgolWkyY3RCLBYLHxAwPWgiirQ+E+8BJK4UMA1EptJjGGc2ZZ54p4hFYs4hZKh+zzscunoPGoJuCwomxLBROTKPlthg3sS+gUvaHjkDNgEGU9FlVVFQ0O+hFsudh2WV20/QGwqKKYXN95Lwx/v7zd/jpjUcx1rodR3TRIsOmQciUiE1J43BPydHoocrDyXFbcGhXO+wqN7bmlmD2n3MRCNRX+EmBVgXYLEY4ux2FlUp3TPW+AIvKg+VFWkz+y4pCj0akmR177HEtdh5qE/D7MefXn/D+6y9hxZJ/q02ZJ5x2NibeOAWdu3bH/kax0webUYuhnRL26SBRRs5zdsmBiDPI3UrlZDZGdEAlLQ8UD62UwimR7O413pwxVAoIyV6DRZcoHggLITWXBXPn4OlH7kaGZwPO7qfFwR31aJcSB21aH3ztG4GZRQNxpGYZjkl1YniiByolhIC1AxSNHjtycjHzk5+wsVyDTRUaWHUKRqUF0Ds+BJVKwdDkEMrMnfFX/Ino4t+MM4I/IawoWFakxU1/WTHthTcwfHjN6O7WgD/PxQv/whsvPI0F8+ZUC4mzL7wMV910h7BetCZ01dDaQjMt6wCwEieLae0KLPdd6vJjaKf4Xfq+9zsBQegnZ7YFAyYZ80C3xR6yPEgkDSEFRANIAbHvw0uO/RI2FTiFf5x9JZrDts0bMeORe7Hoz19wdj8dju9twqG9E5GQkIhKS2c8WzQC811pOF27ACemVaCd3g2/rROCphSEjPFwpw6DK743jj7+ZFRUlNdYd4IhjEMzAjg0w4+hKWFsTTgYX6qOxsmlH2CceRPcQRU2Om3ofc88qI11i8e0JquWLcErzz6JebNniedWmx2XX3sTLrziGhgbyFLaHRgsygp5hVGZUalpaSItcPy48bu0Tlbs7JBgQt+MPXvu9pqAkEj2QaSAaAApIPaPGg9stsS6AEzzi3UWvCMrE3N/+Q5zfv4OScYwLh1iwNmHdEXfVCNUejPy9F3wYM5QhAM+nKv7C331xTCYLdB3GoFAYi8hHHxx3UQ9Bw6Ojz7yaB0BUYWCEzv7cU4PHzISzVhoPwZzA31wevYzGJvqgjW1E/TdxiDv4PugaFt+4G6Kf+b/KQTU+tUrxfOM9h0w9eHpOOLoXWviowp6ofWWQu2vhMZfAY2/EmtXLML7H3wgKoAy7pH/F3rV2OHUoNCjxpPTpu+SiGC/EG8whBGdE0WBrH0RKSAkbR1vCwmIffMXLGmT0IS9ubASmSUe0SshljRNDvTTp09HQdZWBCuLgXAIfZPVuOnozjhtVDfYlEqEDTasQ1c8ktkfR6iWYzhWIVyYjaVOBbOz9VjmdWLCdWMwvleP6nUy06feSoECFX7K0iPFGMbZJidGmRZhlaYr/k44BaM6ZKGTKguB0vXIWPgQCobdgpA5BXuSUYeMxSc//IEfv/kczz/5MPJysnHj5efjyONOwh0PPYn0jPYNf1hRoPUUQefK2/nIh8ZbWmsRBev/+Bz9EupvDuYLqbD103twXP+X4U8eKDqaxgrboJe5/cKVsa8KCIlEEhvSAiHZYzUeNhZUinoAyVZ9TN0iOdDfdustCDoKofiqmtyM627A6QMsGJgC9O+SAUNyZyz0dcKXeSk4Vfs34ry58JcXYmG+Fu9vMGGLQy0sDoR51IzUZinZaLN8Qxg0Cu4Z7sLB7QFPYm/cHZqIqV23YpxlO8xFKxA0JiKst6K4/+VwdTgcewM29Hr12Wki2JLV8tiP4/rb7sb5l06qLqhDy4LekQl9ZZZ4qAPuajGhCgfg8fpQGtCgPGRAiV+H7WV+rM4shC+sQiCkgj+kQKf4keLLQVpgB7S+qpLeJ590ElK79oez3aHwxfdoOG2xFhQQTNMd0TlhlzJuWhtpgZC0dbzShVE/UkDse9BszWBJtuJOtRljagQVDAUx/pBRKM/dKgY6nRo4a4gdR3Y3oE9CCEaNgpKQBRXdj0d2eQAHaTZA7SlBSVEpXlhlwh+5jKtQ1WzHnZqG+x+4H9dec03M+27XhzBzrBNpCWbssA/F08GzMLP/BnTTlcBQtrFqGyo1nO3GoGjQVcBecGmQjevW4OGpN1dnbBx76HA8cstl6KAtFUW11CEfVCE/EPTC7XHD4WOXzxAq/GH4QmFQarAypxYh6MDGXWH4oQXfCUEFj2JAvpKIzUp77AjY4Corwvnd/Ti8L5uEAQFrOzjbHy7+j8WNxewbZmOk2Pa9YEopICRtHa90YUj2Byq9AazPrxQtudPtsbXiLi0pxk2TLkJ5zhbx3G4x4KLhdhzaAehkDUKtUmGrywhHSn/EO7IxRluKJJMa362qwBNLbSj31yNQdtZvWLJkSbP23+HX4ImlFjx9uB8jrCW40vkTHt18OGb0D8OWfhD0FduES8CaOx+m0nVwdDoKFV2OhaJvffFKQaD2O6D1lWNIvBPfPXYxdvwTj5L1f8OqXQffD1MR7NgBJrsdrgBQGVDg9gWhFkIhDBtCSEAIGlWVQGPxHn4/SjgMZ2UF+FUpUAk5EVTUaK82o79uM2DSImDUYrOzHT5Yk4QjO2vRDrlI2PgpHJ2PhTfpv/4i9cFt8DtkXYh9UUBIJJLYkAJC0qoFoigeHJ4AMuJMYtBoCmYY3DflepQUFYrnHdMTcdFgHQ5KCyHZyB6VKmT5LDBkdEc7XQBJKifaZ7THskAX3PVPAcJKC9cXUKmwqlSH4sGXY4hqIUYHtqPSa8LT20bhrj55UBJ6IWBJg6F8q4glSNj4GeK3fAN3ylA4uhwLv72rKIkdq3m/GroXgh5oAi6oA05o/I6dQY6OqoevAhpvmXhovcXQekpE749kWwChQZ1RWloMZ0iDAo8KOUHaEAA9gkIsKGotFL0FMFqhs9iE20OlNUBRaave0+jxw2dfIOh1QqMKQ68Jw6JVkGLyINFYDINeB4PeigHmIEK+LKxfn4Y1cV0wqqMV9sxfhFXGm1RVLbAhmHlTXOkTAtN2oDTZkkjaGFJASFqtaBDFg9cfEtUlmyoQxYZTTz96Lz56+zXxvH2nLkjU+TChbxiDk4OiTgMzASo1diS06wC1OgxdsBL6tK7wjLoexTuCCCvfNrlfw4cPF70BCgsLGwmi/A+6PW6dcit6HjEOFZvaoUP4KxxSsB5ehx4v54/HtR02ix+RO20kwjoTzIVLofUUw5L/j3iEtSaE9HEIWNIRsLYXfytaIxQGHjI2QwlXWRLCARGPoAr6oA66xUPsn3iEqpYJ+XYKh1JofWXQBJziPa4nrNLCreiRH7ChwBMHjz4NZviF4OLrbq8fyYkp6NCxE8ypXRGypCNojIfXkACXIQEhvU2IB5bupthRnAfhobtvR7w+LB6ppjD6JYSQZApDBQWnjOuPrmYfSssrAE8hUJmP3DUGeLsORip+FueuMRHB9F1apfiQAkIi2T+RAkLS4hQ6vFiX7wCr56bZm/Yh5+XswK1XX4rVy6vcCxdecTXuvOxE/P3yDehmqoQaihhHw6Y46O0dYVAFUe4JYmO2EydccDc88V0xJDkkahQ0KAx2xkBQQLCOgcjCoKiJXnanyGGXwk4dO9YpnFTe4zQhDjoH/sCoovX4J0vBDM9oXN+rFJZAGTRBNyq6nQJFpYElf6GIkWCsQDCQA51uE+Kstp1hGSooah0UjU4su3Pj1fujUsJVoiEcrBIV4hEE+D+NE7QSqHXwG5NRGjIi16tFllMDX0iBCQH4oINfbUJ8XBzsWgV//PIbFq3dhpxK4JQrb8cl114IDYJClNBqoQ75hRsmIiC4T0cdOhJ4dBqemjED6woKsK4M+DNXwcBOybj7ipOQ0tEAX8AFe1I5jI5ClORnUQUiuH0BypThSMDPUFQq+BL7NPi9W406EVTbLt68y71PJLsGezncdNNN4rE7y+wuLD3N9ZeX15dOLdnXkQJC0uLVJTfkO6BRqUW2RVPM/+N3TL1xIsrLSmGPi8fjz72CE3pqYcv6EccNTMGGTQ6ICao5ES5LO+G731iuxpoNWegz4VGE4qvq3nOQb0oY0JLA5Vi/gBkZtYskRawNkfoG9VVhLOt9LpICTvTBEriLs7C92IPXnT1x/tAMpAXzYCxdJz67pFCD6R/liniOrrYwuseF0CvNiNFD+6NderqoNaFSFLBDQUlpmQhqMhl0SIq3C2uEmuYWWhconigYtEaE1Xr41CZsDyZhtdOCLaUhmBQXrCqPsDQYtGokxJvRMTUdKe26inMW1hpwxdAjkfTOi9i47G+E/5yBf/O/wTHHn9Rk8alzE7Q4Y9q52JxXgUJXGOrUXuh50DHQaLQoCflgzZ4LU/EqaFLikZLYDcENC+HzVEKb+S+coUGIw08o1xjhj6u/PTlrgBQ4PMLVlRqD0JTExo4dO0RTKnab5LWbkZGB0047TfS6SEpKink9bBndWL+L5lKfIGH/C/a6kOyfSAEhaRGYzMNuixtjrC7JHhavPjcNrzzzpPhsv4FD8PTM19HPvwqWrfOgd2ZDn5CEAd282O4Iwa1PhE/RY0O+C9kFFeh+wVMYc2TNXhSxCoPIskzpbKhMc2NVGI8ffAri6Q4xbYU5pwAqr4If/43H4IPHo7+lErnLfsWiX2fhCC4UD7gDKpT5VPh9awC/bV2Oyy88FwN6dMGW9SuxeP5saPxOGLWUABCD+qAhw9ChYxdhCQhpDMhS0rCsMg5rCn1wlBWhqyoPcapCJENBoj6MznEqJCdWVeKE1iAsCqqKDUBVtqXg8lPHYn33BMyb8ytyMrfii4/exnGnno3E9E4i5kG4LhRaPChcglXrCAeh95agXwLEA1iP8JpseBN6wZfQC5WdjoIvvifsWb+K+IyMnsOxfeMKuLxl0GUvgy/sgU1nQ0n/SwC1rt5gSq1aLbJzUnahD4qkLuxmPHr0aNF8ik2XGGXPltW33XYbfvrpJ9EuOzExMaZ1sUlUa2MymcRDsn8i0zgluw1bNGeWuLC5yAmrXgerUdtk7YK7b7oav//0nXjOvg533nU30nZ8D0vev1UBgUoQis+JrRUqlAR1yEUybCYLLB36IenwK6HR6lutf0ODhaZ2DnAUKScOSIJtxxwEnCXYtHUr1ngTRG6DJq4d/li4AshZiV5xQZh1dX9eVosVBx98MH77/bcar3uCKpQGdCjSpKH30Reg3NQRBUWFaBfYgd6qHYhTOWFS+ZGsDyHNDNhtNhhtSQgaEgBNrQFapUJIb0eI8Q3G+Kq/dTZszsrB7bfcgg1btkNrMOPRZ2fi6BNOrXsSlDA0PgZrlooqlVp3EQwVW6pSQXfC0uCVncYjaEyCLes3GMs2IhQOY/X6dYjzZCFNVQ5d+yHwDbkMrnZjGqwP4vIFMbxLwj4TC7E/p3GyUyVbR7PLZvTAnJ+fj+7du+Piiy/GzJkzhTUg0kb722+/FV0f77rrLlx33XUNWgzoZqCAZttvtq9mR85nnnlGdE6OwPgidv9ka22r1Sq6ebIVNtuAs/tnNBx6ol0Y3Ge2qV63bh369PnP9cVtsIMlW2sTHh8F0bx584SF5JhjjhHL8LcuiQ2ZxinZZ8TD1mIntha5hNWBlQYbIz8vR1RNZBlmnV6Pex97GmeeegLiN34KS/5iqP1OkXUQCIWwpRwoCFqQrWmHUT3bwdL3aLhThzeZ0UCxsKuNrig+aHmoN46Cr6lUmPHUDIz97luEDHGI2/YDevezQrNtG9aUKfBV5OKwvilwdRuHpZkOlJZVimwGlc8FVcAFlVqNsMaAn0u2weXtIuI6QpYUKNYUWOx2dLOHMEJTiE4VfyDVUQ4D/DDqQsLcb+FszZ4MtTVZBGOyAmRArUPImCAG8aApESFDoihwFTLE11shsmNib7z61R+47drLRHOuW6+6BNfccieumny7SOOsRqWuEh7GePhZ/pvQIuHIhLFsAwwVW0XcRMKGT+FN6o/K9mOF64Vprf36D8GCNXYYPUuRnLcC1sTf4U3sJ9ZVbzCla98PpuRg53bvLMC1h2Fb6FisM2wbzfbR7BRbe1afnp4u2lZ/+umnePnll8VrrPBK0fDggw+Kz02ePFlYLo4++uh613/22WeL9dKSwQHm1VdfFe2pOfDTqvHDDz/g9NNPx91334333nsPfr8fP/74o/gsW1JTaEyaNAkTJ06sd/3cNkXJhx9+iIcffrj6dT6fMGGC+JtCg62t2cqbosHj8eCOO+7AOeecg9mzZzfjrEpaAikgJLsMCwJtKXRiW4kLCaamS1OzGdTkKyeguLAACUnJePb1D3BQ346IX/MOzEXLoQ56ofGVwR3WYVtFGNuDKSjTpVcVK+p7MtwJPVv9mGi5aLRK5c56ElyOIqW013mI3/I/9O6hQ0efH/9szEOR0wuLwYjDeu30YVR/lPkLKpHFoFaFhTiwwgurqhhW7IAFXtEJVAmFEPZ7kBxngz0hBQZbssjgCNg7wk1xYKRISNpZCdPe7BRRe3w8Xnrvc8x45B58+OYrmPn0E9i8YR0efeaVxuMi1Fr447uLB1NMrTl/iRgIY8kaGCo2w5k+CqqAGzp3AYb27YF1S3NhCW2HZttfsCb1Q0XPM+tdrUWvRX6FD+0TzDEVGdsbUDxwRr03cDqdMcUibNq0SQidvn3rz37h62VlZSgqKhLPDznkENx5553Vg/f8+fPFoFyfgPjrr7/w77//iiBlg6GqdgeF9jfffIMvvvhCCAMKl/POO08IkggR6wQFBiuj2mw2IWYagiKH1oaIgKA4Ye2WDz74QDzne0OHDsVjjz1W/Zm33noLHTt2FMvyOCR7DikgJLvV14JdNRPNBjGTbIxff/wf7rrxKvh8XvTs0w/Pv/Uxuln9iF/zLkwla6oaOvnLUB4yYWtFGBvDHaE2J+HIfl3g63sGgpb0Vj0Wpy8oZvl0e8RCZLmQKQmlfc4XlgizIwt9knXY/M8sWBPTELCmwajXwqZXYNUq0KoVGBCAET4Ywl7RXlwJhxAMBOAPBFHmD6DcHcC20iA2V2gx/vyLMOLI04U1gUGULQlbgt/xwBPiu3jkrlvx6w//Q2F+Hl54+xPEM5aiCdhErLLz0fAkD4A963do3YWwZc+FO3mgSDe1+cpha9cHRTklMLqKYdnyIzwpQ4T4qA0tD6xMyRLXrFQq2T1i9UozVqL282effbbeZVesWCGETO0gTFoAIq6F5cuXN2hdiBUKELpJGKtBNx+tD8OGDat2aXA/5syZU6+Y435IAbFnkQJCsksD7qaCKvGQYjU2mYL3yTuv4/H7bhc3tsOPOhZPvvAGkj1bEb/uSxhLN0C1s+5BYcCMzRUqbFE6IC4+EQf17w1XnzOqZtmtgC8YEgM2YdwGTek6W1J1fYbGiPa3cjAt73EmtJ5C2JJXQf3bn6gsyQdK8uGl2bVqKei1WqgQhl6vFz5If0iFPLca2U4Nsp1qZLvUcPg5u6saRMe2H9mqwomccd7F6NSlu7AMsQz2Racdg5nvf4EOnerPnKhN0JKB0j4TYC5YLCwS5uJV8CT2hSHkQ+90BX8XdkNccA30+WsQv+kLFA6/pU5AZaQyZaHDt88KCLoROIDurW3HQo8ePYSrgzEEdCXUhq8nJCTsUnAkj53ZHH/88Ued9xg/QVoiGJLWCbooPvroIyEg+P81UaXnuR/sZfPkk0/W+Sz3T7JnkQJC0iz8wbBoipVd5mmyrwUFwwvTHsEbL84Qz8++8HLc9fA02IsWI27z1zCUb4I64BHR/jleIzY6jchUUtAxNQkDBw5FZbcTW3zmHTmGUrdP3GxT7Qa0izch3qRDqduPOOMQpHbpheL8HIQ9lQ3Wk2BgZu3Xg+Y0BDunwXqKgreeuA1dbCFxDlgdM8Q6FlChwqfFxMl34tWZ72BrbjF1RezbaCVGHHwI3vvqF1x78VnI3LpZiIiX3vkM/QYNiW0FKjXc6QdBUeth2zFblPT22TvD4MhEjy6dsGljGcz+bYjbPgfW9IPh7Di2zirY2p3FxyKWoH0NXistmdLYGtA6QPcDYxxuvvnmOkGUnM0ziDIST8FZfjR83pD7g1YAroOWKwZX1segQYPw+++/47LLLqv3fQrnUIipyY1DNwaDmM8//3yRVUKrRPR+fPnll2IfuC+Svcu+6XCU7JNwxr4+34HsMjdSbYZGxUMgEMD9U66vFg/XT7kb9zw6HfG5fyJ+w6eiXgLTF1nrYIvTgNVOG7YjDX06pqH/iLFw9DitVcQDaw7Q0sDS2sM7JWBg+zgkWw2iKyQF0bDOiXjgxstF23CNtZYpv1Y9iYYYN/5oXDb1aSzxdsTPWQbM2qHH79l6rA10xHm3P4ORx52Pq2+647/iUbuwjZame68+eP+bX9G73wBRRvyys0/EgrlzmrUOT+oQVHasSpWleOB3mx5nhiehL4qUOPgdRUhY/1GNTI4IjJ9hRkap09dix3QgwhgBZkgce+yxmDt3rqgJwXoQFBbt27cXcQoRGPPAjCLGDrz00kv4/PPPRSBlfRx11FHCxcF6ErNmzcL27dvx999/i4DJxYsXi2VYe4Kpo/yf1g5mYkRbCjjoc59ycnIadRWeccYZqKysFJaHcePGoV27/xq0MUuEwaIUF6xTQbcFA0ApWmIRJ5KWRQoISUzw5r4+j+24PUhrwvLg83px61UX45vPPhSR/fdPex6TbrhZxAnEb/5KRPGzpTSbNK2uMGGdNw65qhQM75aOTiNOgLPTUfVmEOyu24X7zvF5QPs49MuwI8GirxPdTiFxxfln4NVpDyApKRGqqHRRWgV4w42uJ9EQXIYpbYxU502b/3/73bfVn43UrEhNTa3xueZso6VJTc/A21/8iIMPOwIetwvXX3YuZv/8/S6IiHHib1UoIDI1Dupkxd8YCE9IBaVgDUwFVQNObZjBk1vhRZBFtCS7RM+ePcWA3q1bN5GZwNRNBjhyIF6wYEGNGhC33nqrWJZBiY888giefvppITzqg78TZlQcfvjhYrBmrAEtA5mZmUhLSxPLMFWTIoRpoUOGDBGuCAZeRmB6J4UH96kxNwoDLemmYLwDrRHRUExQ+FAsMH1z4MCBIg2UbpQaWUSSPYKsAyGJUTw4kF/hFaWpOcg2VuPh5isvFCmCBoMR02e+jXHjjxQuC3vWbyINkJkMfuiwtMKCooABpZpkjOmZAeOg0+BL7N3i+8+GTQ5vEBlxRnRLscSULsifxfq8CvwwdxEUZylSUppfTyIWdrdmRWvAviR33jgRv/34rYicf/jpl3HSGec2ax3m/EWw5syDzpUnskWWFgHxO+ags7YY+h5jkTv26TrWF2b1MINlSMe92+Z7f64D0ZIwpoDZEEyZlLQtvLIOhGRPi4f0uMbbcTsrHbjuknOxbNECmMwWvPjOJzho5EgkrP9Y+Mb1lTtEEykPdFhYbocrqEGFLhVj+3WCasBZ8Nk6tOi+UwQUO/2iLXW/DJtIE4ylnXhkxtUl2YbRI4aKgS3B3HRZ7l1hd2pWtBZ6gwHTXnoL9992Pb774hNR9MvtcuGciy6PeR3utBGiVgRdQQZnFgamdMas3G5oFy6GIXcZ9OWb4E+oGTHP74b/KCJkm++9m7LKWX5BQQH69++/t3dHsg8jbT6SpsWDw9ekeKgoK8PE804V4sFmt+O1j77GqOFDkbj2Pdi3/wy9YzvCGh0cYSP+KE2EO6iBy5iBI4b0hjL0YgRaWDzQDJ5b4YHZoMHADnHolGSJWTxE++W7Jlvg9gcPOLM6A9QenvEyzrtkohBij9x1C9599YXYV6BSwdH5aECrR0hrhdFfig7JiahQLAh4KpG48bN6P2YzalFU6RPnXLJ3eO2114R7gq6B2qmeEkk0UkBImhYPdmOjg29ZaQmuOPckrFm5TNQQeP2TbzGsfy8krXkT9sxfoHfmiIDI4qAZc0vjRFtuCobDRwyBb9BFojBSS8LBp6CSXR5NGNQhDknWXZ/N0mXDgMsSV93Av7YOfcpTH56GK667RTyf8ci9eO+1F2P+PL9XV/ooBE3J0HhL0DPVim3IQCAchi5zLjSeknrjIDz+MEoPwPO9r0DhUFJSImIiJJLGkAJCUq94WBejeKDl4aoJp2HjujVISknFW5//gEHd2yNp1euwZf4OnbsQIZ0ZOwJ2/FtqEimN2sTOOPigg+Huew4UXWw57s3Jsqj0BtEj1SoCJZsqrd0UPPbOSXR9VAmTAw26cm68415cddPt4vlTD9+D919/KebPu9JGImhOQcDSDvHebGjj2sOtGBBwlSF+01f1fsak0yCvwitcRxKJZN9FCghJvZaHghjEg6O8HJMuOA3r16xCYnIK3vz0O/TpkICkla+ImAetrxwhnRXrPQlYU6YRgZPx6V0xeNQ4OHucWtUFsoWgmb3Q4UUYCvq3t6N7irXRYM/mEG/Wo2OiGWXuwAE5qFFEXHvLVFw1+TbxfPpDd+P9N6r6KTSJWiNcGWGDHaqQD72SjcgKp4iUYMuW76AK+up1Y1S4A6jwVBX5kkgk+yZSQEhqiIcN+ZVVAZNNiIdKRwWuvvAMrFu1AgmJSXjjk2/RO92ElBUviZLGmoALQZ0FS1zJyK4MwQkzOnTqhh4HnwRXpyOrqj22EBzUGe9gMWoxqH28cDm0dGvoTokWUfuCAX4HIkJE3HoXJt04RTyf/uBd+PCtV2KuVulOGYKAJQOpwVxUGjvAr6gRdOTDlvlLneWZIhxiAGylrAkhkezLyCwMiYAzQoqHvApPkwGTLmclrrnoLKxesXRnzMP/0C9Nj+RlL8FSsEgUEPLrrPjbkYaQtxJlqgT07dYFCcPOgDupb4vvNzMtKHh6ptlgaaUqhizX3T3VCld2UPRsaK2sjD0FRRcrcvpDYVEjgw+R0M3aVlB2/r3zGlD+G9gvveEO8fT155/Ck/ffCaPJjDPPv7jJ7bkyRoueJ/rKLPRMMSNvRxIMgSLEbfgUjm4n10nptBuq+mN0SjI32WdFIpHsHaSAkNQQDywS1Zh4YJGoG6+YgJVLFyEuPgGvffwNBqZqkbzseViKlotukz6tDX+UpcEYLEWRJg2De3WHaejZ8Npj668QKy5fEBXeADonmdA9xdZkT47dhe3KGVuxOschrDX708BGseAJhMR+UzzwO9ZpVdBrNLCb9LAZtMLlo9WooFGpoFarEFYUsWwwxEdY1NJweAM4Y+ItKHd68PlbL+GhOybDYrHiuFPOaHT7DKJ1pw6DrjIbHV35WKftiI7hIqBkC4yFy+BNG1ZjeYtBgzyHX4g1WpQkEsm+hxQQBzgcWDYVOKsrTGqbKE99+3WXY9Hf82Cx2vDKB19hSJoaKcufg6l4NRS1Fm6NDbNLUxAXKkaepgNG9O8D9eBz4DdXVatryWBJXzCMXqlWdE6yiAFvT0BLh9MbxJYiV5Nunr0JB34Gfbr9IYSVsLAeGHVatE8wCSFk1muEANJr1M06dxQg7FfR47HHEfS68PVH72Dq5Ekwmc0Ye9RxjX7WnTpUNN1iPZDOyfEoLbBB53MiccNHyK0lIOgyobiJuNNa2iUlkUh2HxkDcQATackdaYzVmHgIh8O4f8p1mDPrR1Fo6Pm3PsKIDCBl6bMwFa0SBaIcmjjMKklGfKgYBfrOGDV0MDDsItFkqkWDJSu9YnbMYMkuyXtOPBAOZBQsaXaD2I99qZCr6CXh8iOn3CMaU3HP2iUYMahDAkZ0ScRBXRPRN8Ne1TzMrBcCornnjp9h75AeaTZ8+PZrOP3s8xAKBnHLVZdg3p91OzVGw66lbOkdsKShp6EcWap0hJQwtDmL6k3pZIMtNjhzeA687JcDgQceeECUvN7f2b59u7gvsJ05YcdSPi8vr+rDuyu0xDr2BFJAHKAEd4oHtuRuqjEWB8kn778D33/1mSht/NTMdzC2qx4pS58TnRfDGj1K1Yn4vTgByeESFJu6YdTwEQgMuhBhQ1Wr35aaVec7vLDotaKfRWsES8YCXSV0ZdhNur2absjvhVYGChkGkdKlQ9M/01eHd04QgqFfRhzS44yifHdLW0tMeh0+++h9nHTyKQj4fZgy6QL8vfCfRj/jShsBv7UDdGEv4uKS4VV08HtcSNj4ab3nORAMCzEkiY1LL71U/CaEBUevFy2+2YMiGNx9EdbSg9qUKVNE9862xpgxY5CXlyfKQccCe4iw9sburGNvIQXEAQgHvK1FLmSWuJFibbwxFnnl2Sfx8Tuvi5vHI8/MxAn97Ehd9jyM5RsR1hhQiAT8WWxDilKGcltPjBw5Br7+57VojQdaS/IrPEiy6oXlYXeKQ7UEHJDZyZPtwPMdHrF/e+q7c3gCKHB4RcwK3TjcB+7LiK6JQjgw8JCNwpr6XluqYuXnn32KI488UjTguvOqCVi5Zn2Dy/Oa8KQOQ8CUgt4WF3YwpTMUgnnrTzRz1VneatCJY6WrTRIbxx13nBh8Nm3aJBpmcaY/ffp07CtQ+FLQWK1W0YJ8d6BbtaVoqXXp9Xqkp6fv1uSmJdaxJ5AC4gAjHFawrdiJrcUuJFkMTQYefvnxe5j59BPi76kPPolzRmYgdfmLMFRsQ1hrQo6ShIUlZiShAu6EPhg2ahzcvc9o0RoPNM1zlt0uwYT+7eJiaoa1J2DGR792dnRKNIv0To8/1MquCbco88xMiY6JJgztVGVlGNg+XrglrAbtXrnhsBnP119/jWHDhqG8tAS3TzwXG7fvaHB5d9pwUYnUCjcCxhRRXCzkKIB1x+w6y/KY2AyNMS+S2DAYDGLw6dy5s2iJzVbc7JBJysrKcPHFFyMhIQFmsxnHH3+8EBoR2F2TnTD5vsViEb0w2IWTZnp29CR8j9cZrR0R9+bjjz8uGjOZTCYMHjwYX3zxRR3LxU8//YThw4eL/fvrr7/quDC4HlpLOnToIJbhe2xFXttV8Omnn2Ls2LHiuvvwww/rPQdcbubMmeL4uE/sThq9T42t64033kDfvn3Fa3369MHLL9esecIOo+xgajQaMWLECCxbtqxJSw17i9DSwHPO88eup/wueA7//PNPPPfcc9WWI+5b9DrY3IrHwPMXDX9z7FzK3iWErdvZgZWdSdl19dRTTxXrak2kgDiAoPLPLHFhS6ETiTt94I3x528/45GpN4u/J95wK648sgdSlr8Ag2M7QhoTtgWSsLxMB7vKhXBKfww4+Bi4up3Qoq24aZYvdfnQNdkq/Pf7WuaDQatBrzSbKFxV4fULobO7s2V+nkWUGECYW+Gudk3w+Id3qRINvdPtSLUb95nzwRsZBxreqHN3ZOKuqy9AZn7duAYS1tuEiAgaE9AjLoxiJQ7eQBDxGz6psyzdLhq1WpQm35tE3EV747G7cTYcfPz+KgHGAYstvCko2N6b6z7hhBOqZ9/XXXcdfD4f5s6di1WrVuHJJ58UloKOHTviyy+/FMts2LBBWDg46BGKh/feew+vvPIK1qxZg5tvvhkXXnihGBijufPOO/HEE09g3bp1GDRoUJ395PpmzJiBp556CitXrhSD7CmnnFJD4ETWM3nyZLGehtqPk3vvvRdnnnlmdVtw9vfgZxpbF0XEfffdh0cffVS89thjj4n1vPvuu2J5p9OJk046Cf369cOSJUuECKIrpjEYG0ELHT/Dc07xRJHGluQ8ZvYbmThxojinfPBcR8OOmNzmRx99VON17utpp50mRAm/P+4/f4fz5s0TgoXfG61Rke++NZBZGAcQO0rd2FzkFAF0bBTVGCuXLcZt11wmLvJTzjoPU885GCkrXhZ9LUJaEzb6k7DNqYIRARjaDUDn4cfDlXFwnXz+3YGDKGffvdNtopDTngyWbA4MPqWAoGWEg36xy4dgUBFBgDzPDcUe0B1B10ekHoMQHipAr1HBpNeiS7JZxFnQ0mHRa/Z5c2ZaWhp++eUX4b/duGYlHrrpCjz68vtIT7TVW+LakjMfKZ7V2KxJRqpSBnXhGmgdWQjaO9VYluexxOkX2R+0SOwNmALb7766Ra/2BGsfOnaXSrJTHDDGgN/JDTfcIAZiCgcOLvyOIoMQB6xvvvkGZ599NrKyssSgO3DgQPE+BWEEzmpJamqqmOUSig0Osr/99lt14y1+hoPkq6++Kmb3EWhdOProoxvcXwqHO+64Qwz0hOJlzpw5ePbZZ/HSS/+VT2e8wBlnNJ42THg8kVbkbEv+66+/4oUXXqhhUai9rvvvv1+ImMhrtKqsXbtWHMsll1wiBnFaSt58801hgaCFJjs7W1h6GmLatGnCUhG93egup3RXUATQatQQFEAXXXSRsDZwWVolfvjhB2GFILSkcL9oPYncJ95++23xPdGaccwxx6A1kALiAIFpmhsLnLDqmcLX+NeeuW0Lbrj0XHi9HowZOx4zrj8FKStnQu/KE+JhjTcZeW4FaqiQ0GkA0oafCndqy0ZTM3COvwPGO+wPaXzcPzbeYkAqhQ9dDQz4LHYGRcZIZA7JoxB/K1Wza9ZdMGg0IrbDbtQK4cAUS4teu88KpsZg0B4tETTXLpr/B6bfe4uIm+FxRRM2xMGdNlK0/E63h+EqN0Hn8yNp7bsoOPjeGstShJW6fShz+feagNif+P7778Xsk7NSDioTJkwQM2WKCcasjBo1qnpZxiD07t27emZ+4403isFw1qxZwvVBMVGftSDC5s2bxaBWWxhw1kszfzQcRBuCA2Jubi4OOeSQGq/zOS0Isa4nmtqdRPk8kilR37pcLhe2bNmCK664QlgEIjBeIxLMGLGeUDxEaKpjKbdJMbM70Eqk0+mEAKTAojWIlgl+R4TniN8FLRDReL1ecUythfw1HgCwR8SGfIcwd1uNjX/l7Kx57UVnif/7DRyMt+65GOlrXoPeVYCg1oQV7mSUe0MIQY923QYgfviZ8CT2abF95WBLNwBFDi0PTBncn6CQoIUn0j/DFwgjGA4LawPLM9MarRXCQV1VzIkCQtuwlWJ/hDdl3uBOPPFE/Prt50jv2AVT7rirjgh0p4+ANWcuOvo2Y6WSCEs4F7bMP4ARd4g24NGYdVoRNMpYj71xrtjgi5aAvQG33RwYq0D/P2e27dq1E6IhVjhjpymcs1uKCLonOCOnBaM+aNInXL59+/Y13mMcQzSMqWgJWmo9tdcVOZbXX3+9hsgizD7bHRfS7sLv8qyzzhIWEAoI/n/uuedWf7fcd8aX1BcTkpKSgtZCxkC0cUqcPqzLd0CjUosCQo3h9/lw05UXYkfmNrTr2BGfPHEd2m98B3pXPoIaIxa7UkUlQo/KhE49hyDuoPPha0HxwEGWgwQHX6Zp7m/ioTYUbHFmncgYYbwC0045APLvRIt+Z0EnbZsSDxE4CEVMtu+/NB2ff/pxnWWC5lRRnVKr00NnjhPBlEF3BeI3V/na6zbYCu61BlsUP/yu9sajudY3Doq0BHXq1KmGeGBgIGfT//zzX6ot23YzpoH++Qh0aVx99dX46quvRBYHB9TIIEbo1ozAz1Eo0PXBbUY/avvyG4OzaYodulei4fPofWsOCxcurPOc56AxFxz3YevWrXWOha4Mws8zPoMz+4a2UxtaLBpLV+V5jT6njbkxGFTKOJPZs2eL5xEYwEwXFd1Ltfe9NVNBpYBow7Cj4fr8SvDaZFpfU/7SB26/AcsWLYDVZseX029Ct20fVYkHtRH/OlPg83ngVNvQo88QmEdOgD/uP//o7kL/P9MhOcj2b2dvUuxI9n0mTZqE226r6uD55F034d8FNQcH4s44SAiJbhYfCpQEeINh2DZXZQxEQ4sNHUGywdau07NnTxGZT/M8YxRo9mawIy0HfD0SE8CYiW3btmHp0qUiBiEy6DKrg2KGLpKioiIx66XJnEGEDJxkoCHN5fwcYw0igYexwmuFcQ/051PUMMCR5n8GOe4Kn3/+Od566y1s3LhRxDYwe+L6669v9DMPPvigsLo8//zz4nMMJGUswdNPPy3epzuI54DncO3atcJdx9iNxpg6dSoWLVqEa6+9VoiP9evXCwtRcXGxeL9Lly5C1DFjgq/R7VQfhx9+uIiToHCgoIm2kvC15ORk8T0yiJLfH2Mf6JJijEZrIQVEG4UBZ7Q8MLUwxdb0TP6156ZXF4r6YvoNGFj8LXTufARUBvzjTEE44IVDk4g+/YdBN/xCBGyxzy6agvtY7PKKdEhmGuxKwJhk34RR92eccSYCAT9unnghtm/dXON9v60zPEn9YdVr4NfaoFLCQOlWGErq1pJgkCqzMRhYK9k1OBjS1M2ofvruOXHgIEj/OuFMmJkYFA2M4O/Vq1e1JYlCgwMsB3bO1iODMQMUmanAgTfyObo0IrP2WOFgd8sttwirB4M4Odumz5/CZ1fgvn7yySfCAsAskY8//rhJawZdOAxE5HniPjAI9J133qk+FsaWfPfdd0JYDB06FHfffbcQPY3Bc0h3EAXbQQcdJM77//73v2rrEAUY77vcN7obaM2pDwqX888/vzqrJBoGVjJzhlYnBoDye2AsBy0ltO60FiplX6rF2wIwGIcmm4qKilY9cfsyvMGuya0QXSozYghA/PGbL3DnDVXRyu8/cjVOj1+/Uzzo8Y8zDaqQFyWaVPQfOATKoPMRMiW32L6yr0SlL4BuKRaRqtkWzfkHOgyyO3zsEViyeBE6dOmGT76bDfvOKH5iLFmHlGXPobS0GIHyHNjVfuj6HIu8Qx+rsR7eqvIcHgzqUNWyvbXgTZczOA4a0cFykv0H3vOYocA0R0nzrvHmjKHSAtHGoCuAnTWLKv2iOVZT4oHpmvdNuU78/dT1p+P0hA1V4gE6LHSmQhXyoESbjoGDR0AZfFGLigd2WnQFguiTXlVHQYqHtglnRz98/x3ad+iI7O1bMeXay2qUVvYm9IIvvieSjUClYkFYCUG3YwEQ8DbYYKuNzXskkv0SKSDaYH+LqrbchiYH5IK8XNx85YUiePKWsw7GVX0roHPlw69osNCVAg0tD7r2GDx0JIKDL0DI2DJ9LXjzZ5ojfdoD2sWhU5Jln0/TlOweNHl//fU3MJrMWDhvDp56+O7/3lRr4OwwFjBYYTJbRTBlwFuJhM3/VQ6MDqak8GRrcYlEsneRAqJNlah2YUdZVX+LxjprEq/HI3zSRYX5mHBoN9w31iTqPPjDKixyJ0MT8qHE0AGDhx0E/4AJCOvtLZamST+2UacWJZjZ6ElyYDByxDA8N/MN8fdHb72KLz76L8jOkzIQflsnpFrUcCgWeIMhWDZ9V2cdTHn1BxWUuWQwpaTxSYp0X7Q+UkC0ESgcKCASzU33t+CP68E7JmP1iqU4um8cnj+zPUyePATCwGJ3MtShIEqNnTFk2Gj4+p+PsN7a8mmaHeJEKqPkwOLiCefgypvuFH8/dvetWLzgL/G3ojGgssMRMBoNIphSw2DK8u0wFK+usw4Wk8qv8O2xBmYSiaR+pIBoA3BQ3lTgFFHqsfRGePuV5/HD159hZHst3r60L2yBYiEelrqToA6HUGrqIsSDp9+5LdZRU3TTdHhEVUm6LVieWHLgweuTketjjz9VxEHcevUlyM3Oqi4sFTSniaqcbujh9QeQuO79egUE65GUu/dOTQiJRFKFFBD7OSz5zKBJUWUyhjK/8+b8iucefwADUtT44MoBSFZVIBAKYbk7UbhBSk1dMXj4GLj7ng1Fa2zRbpoiTbOdvck+HJK2TZrdhHuefB69BwwWFU9vnnSRcKnRTebMGI04MwWECWElDG32Qqj8VRUCIzC2R61SiQ6oEolk7yEFxH4Mq/JRPDAgPZbCSzu2bxPpmj0SgHcu7o7OVr+YBa7yJIDW4HJzNwyieOhzVouJB+fObprMsmDXSvqwJQc2FJDd0hNx19OvIyExCetWrcBDd04WrjVX+8MAYwIMJpvoFxLwuJCw8fN6gykZiMtulRKJZO8gBcR+Cm+cGwsqRRGmWEo+u90u3DTxAiTAgZlnpaN/mg6hgB9rvfHwhzUos3THoOGHwN3nTOGPbimBw1bU7GlBAdFUYKfkwIGNx1jZ8KHn3hBFdFjE7KO3X0XAkgFPcn8kWg1wKwb4QiGYt/7EwJ06/SF47ZdJN4ZEsteQd/T9tNYDYx7Y5yKWKpOiTPVtN6Iiax2ePTEOo7vFIRz0YZ3XDm9YK8TDwOGHwtX7jBYTD9w3ppX2a2dH56R9txW3ZO/AFuXt4kzoMWQUbrnnYfHaUw/djcUL58PR6WjojRYEtFZolSCUskwYStbU+DzTfo1a1oTwCNebRCLZ80gBsZ/BTIZIrYd0u0n4gpvi/ddfwsJZX2LaMUaM78fiUH5s9trgDRtQaukhxIO71+lQNLufFUGxUuDwijbV/dvHieZRssaDpD7S4owidueMiybipDPOEWWUb73mUmR6LfDbu8BmtSIILXyBABLW123GxaBhWiAYUCmJDfZH4O+xvLx8b++KpAmOOOII0ZsEB7qAeOmll0TDEJbMZAMQNjVpCNYd5wUe/ZDlZP8bnLcXu5BVWlXrIZbKjf/+PRevTb8fj4434vjBadCrAtjqs8AZNqC4hcWDSNN0eEXLcHbTjMU6IjlwYSZOqt2ASl8Q9z7xLPoMGISykmLces0VKG0/DnEWIzwqI6CEoM1eAFXQU+PzTFcOhcMocfr32jHsS9S+b9Z+PPDAA3t7FyVtjFYXEOysxgYp7IbGLm2DBw8WrX4LCwsb/Azrb+fl5VU/MjMzW3s39wtyK7zYWuxEglnfZK0HUpifh3tvvBz3HqbFiQMTYNcDmT4zKsMmFFl6tah4oLsi3+FFsrWqFTdrPUgkTUErmgoqaPVGPP3qe7DFxWHVssV4/O3vEbKkQmWIEzUhgm4H4rbULSxl0euExYtuvQOd6Hvms88+W+c+yqZNEsl+JSDYBpWtTy+77DLRbeyVV14RtfHZZrUhqJbZtjTyYBncAx1GnG/Kr4RZp42pW2UgEMCd112GSX0cOKmfBWk2PbJ9JjjCJuSbe2HQsENaTDyIVtyVXmTEGdG/XVxM6aQSCYk36YToZHnqDp264PHnXhOvv/PWW5ifb0Kc1QwftPCHQrCwzXetYEpea5WiJoS0QkTfM9kMqfZ9lJ0kIyxZsgQjRowQ9+IxY8aI9tnRsN109+7dodfr0bt3b7z/fs16HFz3q6++Krp6ch3s/rhgwQJs3rxZmN4tFotYL9t7R6AFZMiQIeJzHTt2FJ8755xzRNOmaBcLO1by8/Hx8TjkkENqTCBj2S920zz99NPF+tnJkx09G4PdRrkcLd0ca84666zq99gR9NBDDxX7kpSUJI43+pi2b98utvnZZ5/hsMMOg8lkwsiRI0UrcLbw5jnmeT/++ONFC/QIl156qaiUyY6h7MBJsXf11VfD72/4Ovb5fEIEsisqzw+t+TxfEXieTj75ZCQkJIj3+/fvLzqt7rcCgieDF+pRRx313wbVavGcF1tDsM88I7R5kbG/+Zo1NQOoDsh0zYJK8bc9hnRN8twTD+BQ1RKc2tcoek3kBQyoCJuQa6J4GLMzYFLfIjUe2Iq7885W3LEUspJIIjC4NiPeJCxYdIEdfuSxmHRj1Uz5uic/QFBRw6e2QacEgJIt0JfXbAdON55WrRbWr1aFwiXo3zuPVmgcxmJeM2bMwOLFi0Vb6csvv7z6PXaxnDx5smirvXr1alx11VViAjhnzpwa62Ab74svvhjLly9Hnz59MGHCBLHs1KlTxXrpco20/I5AgcHBli2xOTgvW7YM1157rXiPKeUcVNlCe+XKlWKMmDRpUnUMVaz7xUGZwoTrOOGEE0Tr69LS0nrPA/eTbcQfeughIaK4T4cffnj1+y6XS1jQudzvv/8uxi+Kk3C4psWLFvZ77rlHWNl5Pnkubr/9djz33HOYN2+eOO777ruvxme4vnXr1gkRwFbjX331ldj3huC55Dlhi3Ie29lnny1ap2/atEm8zzbsFBls681242wzHi0aW4NWnSoWFxeLwKjaFgQ+X79+fb2foaqkdYI93KlMn3rqKaFkKSI6dOhQZ3meMD6iW5G2JZiqVpWuGRTm3lj47cf/AQtfxbkj9eiZbkVRyICKkAk7jL0xcFgkVXP3xQNTNCs8fnRLsaJrskWmaUp2CZY0Z/EohyeABIse19wyVXSJXTjvD3zyxxqcPro74CyFz+9D/IZPUXjwPTU+T1Fd6vQLSwQDK1uFUACYNwN7hcNuBbQt6xJ89NFHxUBN7rzzTpx44omixTNn4bzncoYcGdg5gC5cuFC8Pm7cuOp1cPDmQE3uuOMOjB49Gvfee69wURMO9lwmGm7jvffeE7No8sILL4htU8zQqsB7Pmf5tDIQWjYixLpfXOb8888Xfz/22GN4/vnnRdwdB9vaZGVlidk6t2mz2cTEdejQodXvn3nmmTWW59hEi8HatWsxYMCA6tdpGYg+bm6fAoEWFHLFFVeI+L5oeLxcHy0ltBZQxNx2221CmFGo1N7Pt99+W/zfrl276m1S8PB1Hiff4/4OHDhQvN+tWze0NvvcHZ8XIVUtTV28wKnK+IXR7FUfjz/+uDDXRR60WrQVWP55U2GlCBJLtcUWSJq5bQsWvnwDrhymR58MKyoUIypDRmwz9MHAYWPgaaE6D7zZs0iUrPEg2V10GjXax5vgDgTFrJV1IZ544Q2kZbTHO38XoLQgBx4wmDIIbdY8qII1rQ20erH5VqlLujFihRO0CBkZGeL/SFwaZ8WRgS8Cn/P1htYRmSRGBq/IaxQM0ZO6Tp06VYuHyP2es3nO/hMTE8Xgz4GYpnjO3hm7EWFX9ovigO6BhmLujj76aCEaONhedNFF+PDDD+F2u6vf5+yeYoDvcz1MBiAcrJt7LmrvA+MBKR6izwWt7zt27EBtaFHgZLxXr17CqhB5/Pnnn9UuFVpSHnnkEXFOaBGhlaK1aVULRHJysrgZFBQU1Hidz+mTiwWdTicUIU1A9UFzGZVoBF6sbUFEiO6aRS7klrM1tzGmdE2f14uP7j4XVw0Ook+6EV6NGY6QEZv1fTFw6Bh4Wqg8dZnLj6ASFmWp28UZZZqmZLdhxg7jGShKaUVITErGUzPfxuVnnYDFG/NwyLCeSIcbYVcpbFm/wtHt5BqfZ1xQXoVXCJFWEbMaXZUlYG/AbbcwvK9GiPx+a5vld2Udu7tezqY5EHJmzQB8ugV+/fVXHHzwwbu0X5H9aGgfaHWg24FuhFmzZgk3A2M1GL/AuAcKGQqM119/Xcz8uR5aHmrHKuhiOBfNPb/RUFhwLGVIAP+PJuKmuPLKK4X4+uGHH8SxcHJNy84NN9yA1qJVp4000QwfPlyYciLwJPI51VYsUHVRfUVUcm0MBoNQhtGPtkB2mRvbS1xIshhiviF++Nh1uKhTDnqn6ACDFZVhIzZqe6PfkNHw9j+nRcQDgzkVlSKCJXmzluJB0hLQipARZ4LD+19p6sHDD8KNd96P7zYEUFqQj6CiQSAYgHXTN/WmhIpgSk8r1YTgdU43wt547OHfGN0G8+fPr/EanzMIfnfhzD03N7f6OV0QNNfTdR2BE0ZODP/++28xWH/00Uetul+MWWBc3rRp08SsnYGRs2fPRklJibCMUMQceeSRYvtlZWVoKVasWAGPx1PjXFAM1DcB5jnhWEgrRo8ePWo8oifj/CyDMWm5Z6wIhU9r0urh8rQOXHLJJSIaldG1TC9iYErEN0Z3BU1aVEuEfiCqTZ4YFjuZPn26iC6lujpQKHR4sanICZshtu6aZN7Xb+Ew54/o214Lo9WKsrABG9Q90GfIaAQGnAtFG1v8REPQtFxY6RN9DPqk25AUQ/lsiaQ5pNgN2FHqFnE/kYZrF0+6Hrf/OxdFZX8hNSkOSRoPULgBOkcWAvZONYIp+Y9N22Ip7S5pGPrhGdvAQYsDKwMeOSD99ttvu71uxlhwPGDcAq3FtDZwWxwEt23bhtdeew2nnHKKmO1z8KYLgWNEa+3X999/j61bt4rASWYvMGuBk1wKGj5n5gX3iRNYih/Gi7QUfr9fxEZQoFC00O3AQMna8Q+ErgsGg/Jc0KrAc8CsDk7G6T5hHAmLTjHbg8tS6DC4NDqGZL8UEOeee644UJqG8vPzRWwDzVMRPxG/lOgTxgNn2ieX5RdICwaVaEuo3/2BCndVxoVWpRYFmWIhZ+NKxM+9HwMzNIizWVEeNmGzuhu6DToEwYHnIayz7NY+hRVFRLmzYVffdDvizLIVt6T1CkvllnurBQQtXPc89RpmTTkIaQ4vUhLC8PvciNv8NYqHTa6/wVZSMKZUZ0n9MBOC8Qcc5BkQ2LVrV+FaYHrm7sKJ4RlnnCGyI5gZweBFplESxgMwuP7dd98Vs38O2swsYLZFa+0X3RQUIXRbMF6D6ZzMiGBQI2HGA0UOLSEUFQzIbInzQGjV4PYoXpgIwFiLxop98VgZ40DLQk5OjggR4GSb55DQQsHzlZ2dLSzxDBp95pln0JqoFE4t2xBUtQymZDTv/ubO4MxrVU45HJ6gaDYUC36XA+sfHo2hceVol2iBQ2XFZlVnpPYfD9XwixA2xO/WPjG1Lt/hEbO6Phl2WeNB0urt6ZdllSPZoq/hutu04EfYfrga/TslQKMKQ5vYFbmnfwmoa4rZnHIPBrS3o0PCf8FpzYUDCWfDHKBkFdyWg4PjN998I9I+D3QuvfRSYWHn+dgbNHaNN2cMlaHz+1DGBdM1GUkecwloJYztM89Bf2s5MhJMcKrM2IF0JPYdC/WwC3ZbPHCfKB7S7bJAlGTPwCqr8WadqH0STc/RJ0DfaQQKPWoYEECwIhfmvLol8dmlk8GUFL4SiaR1kQJiH8q4YIOsWDMuSMEXd6CTayU6JxnhUVuQjyQYehwBw7DzETIm7nZ1ScY8sBkWLQ8Rk7JE0powloHXHNMyaxtH2590B0KKCoqiQijoh3ndZ3U+TzcG3YC1BYhEIml5pIDYTzMuAss+hW3dp+iWYoRPY0EJ4hDsMg7Wgy5A0Jy229Uli5xedEo0yeqSkj1OkkUPq1EnUjqj8aQPR4few1EWNsGIANwb50LjKalTU4IxOwxElux7LgzpvqiCRaX2lvuiJZECYi/DqPHNzcy40BasQOiX+9A1UYOw1oQKmOFoPxYJB1+IgPW/Ii27GodR6vajW7IVvdJs4oYskexJ+DtItxvqtulWaxHoeiSC+nhoVWHoEEDWN4/VG4xJ6xmvZYlE0nrI0WEvQjPrxgIn1FDFnHGhceYi+NW1aG/2iw6GDphRmHIoUsZcBL+9qkra7pSmLvf40T3Fgu6psrqkZO+RYjPCoFULa1g0js7HICklHV6FghtQr/sG2du31ljGrNfA7Q+hxPVfiftdoY3Fl0skLX5tyxFiL8Eb46adPS5iramg8lfC8ONNsPtyYDbqUQkzcuKGI+3QS+BL6LVb++P0BlHpC6JXmlVYH+iLlkj2FnajVvwuascyhEyJCKUPgVsbL9wYXZP0eOPui0T32QhM/WQwJau47kowZaSCYHRJY4mkLeHfWUmzdlXL5iLD6vcC7Dy4qcCJ4kqf6EQYE+EQEv56GP6cxYi3UDyYkG3qh/TDr4Av5b+a67sCb9IUNL3TrOiYaJbVJSV7HdGKOs6I/J0ZFdGCtqLLcTBvmw+UF8Fi1GKkfjNenvE4Jt95Xw0BUuzyizbhzS0sxZsq6wNEehewPoH8TUjaCuFwWNRm4nXNKpy7gxQQe8F0xIDJnHI3Uu2xZ1wkrX4dgbXfItGshRtGZOu6IpniIWPkbu1PudsPf7iqrwVLU0sk+wqJZr3otBnp0hnBmzwACcldUFmRBbPKi/G97Hj09WcwZuw4jBx9mFiG7jf+shhMuSuVKSPlgRtqwiSR7M+weCMbm+2uMJYCYg+TW+HFtmIXEs2GmAMUbdt/hvrf1xGnC8Ov0iFHnYH4MZfB36mqHe/uNMVixHq/DLvoQyCR7EtQBFDUrsl1IF5R/rvZqdRwdxoHJXsNdL5MtEs046iuGky98Sp8OWs+4hISalSmZGyPpZk1TLgtVkJMTU2t4R6RSNoCer2+3pLZzUUKiD1IidMn4h5MOm3MdRWMxasRt3A6QkEnFLUaOUoKLCMmINDrpN1qssN94cdpeYi16qVEsqdJsuph0qtFUGS0CKjseCSS4z6DvyAHBnUIl49Oxjfv5OLBOydjxivvCgHActZlHr+41psrIKLdGbvrJ5ZI2ioyiHIPwZx2xj2woyt7StRHKBzCkiWL8csvP4v/VZW5SJ9/LwLlvEkqyFaSoOt3EoKDLhCzsN0pF6xWq6R4kOzzUASwuFqlr6YVIGywQel4EJzqOBjhx/BuieiVosdvP36Lrz99/7/P67TC6se4I4lE0rJIC8QewBesyrio8AaQ0cCAPXvObNEkprCgQDzXqcP44iQ/UlLDsKhD2IEUBNOHQzf6epEPv6vQpKvTqkSBKNm1ULI/wNLu2WUeUVo92u1X0fV4mDf+DlVlCTQhN56adCROefQnPHHfnRg6cjS6du8pakIUVHpFbZNUmxTLEklLIi0QrQwjyLcWOVHg8IqZVH1BKxQPt99+e7V4ABQ8cbAL/eL9sKiDKEACKnQZ0B/3CBStcbeKVum1KhHzIMWDZH8h3qwXHWAZTBmNP74XDOm94YIJBsWLg5K9OPSwQ+H1uHHXjZNE7AKzNzQqlcjmkHUdJJKWRQqIVmZHqQtZpVXdLOurrUC3BS0PiLq5TernwYndQ4g3qlAOK7aUq2A742mEDbveXZTR6AadBv3axcVcd0Ii2af7Y6hUcHc5Bl5dInQIAo4cPHPH5bDFxWHNymV47blpYjG6DBkH4fDWLI0tkUh2DykgWhFaHTYXuRBn1MGgrT8Q66233oqyPABHtPPhxiF+JJi08Kl02Ooy4MHZLizaXLRL+8AbLvfDqNegf4YdiVHpcBLJ/pTSyUBIV63y1M72h0GX0BEBRQNtyIWOJX/hvseeEe+9/sIMLF/8jyiN7QuGUVQp+2NIJC2JFBCtBDsCsj23Xq1uMAKcrotXX3ml+nkXWxBPHeqpznnf7InDa39XYHGxAcXFxbu0H+wJwNK+/dvZa+TSSyT7E8xaoguwdn8MRWeC0vVwONV2GOCHkrscJ44fjZPOPFcUzJk6eRJczkoRC0E3Ru3S2BKJZNeRAqIVYBOfDQUO+ALhBgftatfFToyaEN4Y70Sq3SDS0jYHk/HTyiJ8vq2qPkNycnKz94OWB954+7WzCz+yRLK/B1MynoHBlNFUdj0BYUsqVFCg8ZbAuv0XTH1oGtp16IicrEw8ef+dsBq0IhOqxFVVwlcikew+UkC0MLy5bSqsRKnLL254DbF82bIo10UYrx3hQvdkPSzqALaHkrFkYxGeXWmloxdpaekYMnRos2MeTDstD1I8SNoCjGVIsNQNpgzY2kPbYbio0MpgSt2Wn2G3mPDIM6+IoOVvPvsQv//8nai/klPm3qX+GBKJpC5SQLQgjDfYVuQSTXxobm2sTHW0S+KuYW4c0kkNmyaEAiUe63eU4olFWvjCVV/PrVNuhUataZZ4YMwDsy2keJC0FVi7hBVTfaFawZS0+nU/AV5tArQMpizdDmPRSow4+BBcfu1N4v2H7rgJfkcJyt0BIe4lEsnuIwVEC8Jcdfa5SLIYmmyFHXFJnNrVg4v7K7DpgUoYsa7Qjxf/8SHXV+W6uOrqqzF+3PhmpWoadooHGfMgaWswCNii18LlqxnL4E4fCSWpB4KKFoagA9ZN34jXr71lKnr3G4DyslI8MvUm0R8jr8IjUzolkhZACogWggWaNhdWCl8ro76bgi6Jw3rY8cDBAcSb1AgoWqwtN+LLJcVYUBYvlklNS8Pll1/erAqTBq1aigdJm4W/LVZPddSqTAla6HodC6faUhVMueNfaF350On1eOy518T/c3//BX98+4lM6ZRIWggpIFoARoYz40IFFWzG+stU10bnK8Vbx6uQZmOGhgobPDb8sSILX+UkQcWboUqFKVOmxOy64E2R+fJ9ZKqmpI0jaqrUF0zZ5TgELVVdNLWuPJTMfVMEK/fs0w833HaveP2ZR+7Btm1bZUqnRNICSAGxmzAtbGN+Jdz+YMwFmlQhHzLm3w9boAgaKMgKxOHfNdn4ZJsNXkWHtNQ0TJs2LWbXBX26bI0hy1NLDpRgyvh6KlP+tmApvlxaDLeihxE+OBd/jDNPPVGkS1808VoMHzUGHrcLz917E3JKXTKlUyLZTaSA2A3YoGdzoRPFlb7Y6+wrYSQvex6qrAVQhwMoVqxYsKEQm/V9cfX9L+DVV1/Ft999G7N4KHP7oUBB33R7o1kfEkmbCqasVZkyUg7+3eU+FPl00CKE3olAJ+SK1/+c+yceeWYmLFYbVi75F++++qJwO0okkl1HCohdhDeu7cUuZJe5kWpvPOMimrgt/4N+7ZdQh9xwwIgF21xYX6rBhEc+xbHHHofhw0fE7Lao8AQQDIfRJ90u9kEiOZAqU7JTJ9t8R5eDX1emweJ8lYgpStAFcHZPxjoomPHUDKS374A7HnhcfP79l6bhz3+W1HGDSCSS2JECYhfJKfdgW4kLiWZDjQ6BjWEqXAbLkpeh8ZXDoxiwolCF1dtLMOTK52CPT2zW9p3eoDDB9k63Iz1OigfJgQVrnKTaDKLNd82aKip8uiaIirABBlUQYzpo0N4cREFBvlju1HMuwBFHH49gIID7b74GeaXOvXwkEsn+ixQQuwBTJdme26zTihtZLOgqsxH/zzRoKrPhV7TY5jZh6YZchPqehuFHnNCs7TPewukPoFeaFe3jq9I9JZIDjSqXnQoFRTXLvM/J1WNTuRZhqNDBEsRxnQLVtVdYWOq+J55FfEIitm5Yg4cefkgWlpJIdhEpIJoJ3QYbC5wi48Juii3jQu2vROKS56EpWIVQWIXCMDMudiArlIyzb6tq/NOcMtnchx4pVnRMNO/iUUgkbaTNt0kLc1xSjdeDYRU+X+uHR9HDrA7glF4aGDVKde2V5NQ03PN41e/u7Zefxe9z5++V/ZdI9nekgGjm4M10Ta8/FHtL7HAQCWvfg2brb4ASQhlsmLU8F/mVIYy76VWYzZaYt+8LhlDq9qNbigWdkyxiNiWRHKhodlam7N6nr6iZwtTnCF9t0SLPqxf9MfolhXFMH1uNcvDHnHgqjj/1LIRDIVx15eVwu9176Sgkkv0XKSBihMFWFA+stxBztoOiwL7tZ2hWfwZtyI1KxYyFmW6UVXqgHXERBh10aLO2z0JRnZNM6JpsFZHoEsmBjqhMadDhhpunVL2wU0SU+zT4eZsaAWiQoPPj9uM6Q8Nc5yjueni6sEZs37IJU26fujd2XyLZr5ECIkbYCjiWHhfRmAqXw7DiHRg9BXApBmx1W7A5sxCbQx1w/k2PxLxt+mgZd9E+3oweqTYx85JIJIDFoBWCfthBY0TtlNTU1Or33lsZQnnICB1CaB/IhM6RVeOzcQkJeHD6C+LvmS89jz///HOP779Esj/DMoiSGGs+cOBuqsdFBF3lDlhWvg1D6VpRHKpQnYI/Fq9CrhM49cE3YDDGljkRVhTkOzxItxvRK90ac8aHRHKgwBosOWUeHH74ERg7dqzItmDAZHJSErzZLyNUNA8WfyFC239B+eBJNT572PhjcMo5F+Lbzz7ApZdehlWrVsJqZRdciUTSFHI0agUYNGlf9yF0WXMRUlQoUydg9pIt8IcU2A6/Gv0GD4u51kSBwyviLZiuadDG3pFTIjlQSBDBlDpUeoOihgprqYiaKiNGQjXsUnhVbPPtBzb8ALXfUefzdz7wGFIz2mP79m2i6JREIokNKSBamnAIcZu/gWrd99CEfahQrFhVEIKj0o0N6IoLbrgn5lUVOX2wG3Xok26LOV1UIjlQgyndgboNsrwdDoXD3AVM1LQ4tsKSt7DOMlabHXc/8bz4e+bMmfjtt9/2yH5LJPs7UkC0MNacecCar2DyF6NSMSFf0wFr1m3G1goVJtz7JnQ6XcwlqrUaFXql22Ju0CWRHMjBlCadRtRIqYFaA//A8+GDDibFDdXqL0RmVG2OGDceJ517ifj7iiuugMNR11IhkUhqIgVEC2Io3QDd2s9hKd8gKk2WmLtj7oJF8AQVpB0zGb36DYi5ymRgZ4lq2VlTIok9mJJujNoE+pwOpy5ZpHSaCpbBWLKuzjJMib7hzgfQrmMXZGVl4ZZbbtlDey6R7L9IAdFCaDwlsG74HPod8xGEGqW6NKzemAWf14f16IkJ19wWc60JluftmWJFmuxvIZHEDPvBsLEcA56jUXRmOLqegCA0sITKodv4Xb2fT0+Kx00PPS3ExJtvvomffvppD+25RLJ/IgVEC6AK+RG3+WsoG36BVvGjXBWHIiUFW7Zux7pSFS576E1otdqYaj2UeXyiUJSsMimRNI94k064++qzQmDElXCrbdAgBP2WWdC68ussQuFw8JhDcc4lVZkaEydORHl5+Z7YdYlkv0QKiN1FUWDL+h3BtT/AFCgRcQ/ulKH4e/48OP0KOp90K7r36hNzrYeOCWZ0kVUmJZJmwxRr9oapL5gyZElFScoohKGGzZ8HU+bsetfB8vTnX3cbunbvgZycHOnKkEgaQQqI3cRYshrq9d/BXLEJPkWHivgBWLpoEfw+HzZq+mDCVbfElq5Z6RU+3G4p1phrTUgkkhiDKfk7G309vCoDdEoAmtWfQxWoW76aReISbHbc8dhzQsS//fbb+PHHH/fQ3ksk+xdypNoNtO4iWDZ8BU3OP1BUQLG+PUrdCjK3b8eaUjWufPgNaDRNp18WO/2wG7XolWaDUSfTNSWS1gimDCX3Q6mlJxSoYHNshDl/UYNWiC79h2HStTeI59KVIZHUjxQQu4gq5IN981cIbJoDveIVcQ+a9sPx97w/UOlX0O2UKejao1eT62FnTbUaQjzIdE2JpPWCKdknwztsEgLQwqB4oVr5Ub0pnawrYdCoMeG629CzVy/k5ubi5ptv3nMHIJHsJ0gBsatxD5m/IbDhN5gCxXApRoQ7HYqFf84SrotN2r44f+JNTa6GZlZPIISeabbYu3tKJJImK1Oy1bejHiuE0vNYlOszREqnreBfGEvX17sOft4d0mL6868IV8Y777yDH374YQ/svUSy/yAFxC7GPWg2/gB92SYEFS0q4/siN68QWRHXxUOvN+m6EBkXbj+6JpvRLk6ma0okLVuZ0ghPICjii2qg1sDR7wKR0mkOOkQsBCcE9a3DrNMgrecgTL6pyvowadIklJWV7anDkEj2eaSAaCYaTzGs679AKGcp1KowyvTp0KX3w8K5v+90XdzWpOsivDNosl28SWZcSCStQJLFIOIhXP5Q3TeHXoRKTQLUKgWW7b9A58ypdx1xZh3K3X5cO+Uu9O7dW7gyZFaGRPIfUkA0A1XYj/hNX8KzdQEMYTcqVTZYe43FX798K1wXm3V0XUxucj3FlT4kmvXomWqTGRcSSSvA3jFpNiMc3kCd9xStEUWdT0KIKZ2BEug2fl/vOpiRYdFrUexR8Mrrb0hXhkRSCzl6NYPk3D/g3zgbBm8hPIoeaDcMGzdtxY7MbVhfpsYVDzWddcGgSdHjIk02yJJIWhNmY9AVQXdhbdSH3ACPyiIKSxnXfQq1r7zBjAz+Zrv1G1ptfaArQ2ZlSCRSQMSMvngN4rb9BJRtE2lgXntXBOO6YdHcX+AOKOh68hR07d6z0XV4AyHhl+2RZkOC7HEhkbQqbPGdZNELAVAbxZiA/NRDEYYKdm8ujFl/NmiFsBp02FHmwd33PYBeO7MypCtDIpECIjZcJTCv/RSB/HXQKX5U6pJg63U45v/0mXBdbNH1wblNZF2w0mSJyydiHmTQpETS+qjVKqTHGeELhkXcUW1Uh9xSXVhKt/RtkZpdH6zRUukNoMIPvPXWW7LAlESyEykgYmHN1yjd8i/M4Uo4VRZYuwzHmjXrkL19K7Y61Lj4vteadF0waDLdbkSXZBk0KZHsycqUNqNWdLitTTipOwqtA4RFMa5yI4y59ReW4u/VbqyyQgwZMaq6JoR0ZUgOdKSAiIH1BZXwOcvhhxb6lB5wmLtg6R/fwxdS0O74m9GtiV4XZS6/iAjvnmqFTgZNSiR7DINWI4R7pa+eBlsA/KNvqi4spV3yGhCuJ2sDEEXeXL4gdpS68fDDD6Nnz56iV8aUKVNa+Qgkkn0XOZrFwK9ZKtGEx29Khb77ofj7uw/g8/mwVdMD5068pcn23P5QGD1TrbLSpESyF0ixG2DUqkUMUh06jUaxqav4M654KUxFKxtcT6LZgNwKD3yKttqVwbbfv/zyS2vuvkSyzyIFRAxcM9wEe3wSDO0HYfnKtcjZvhnZTjXOv7fxNt2Meyh1+9Al2YxUm6w0KZHsDeh+SLYZ6g2mZHlr57BrhBXCqLihWfRqvYWlCLOmwmEgq9SNMWMOwY033ihev/LKK+FwOFr7MCSSA1NAvPTSS+jSpQuMRiNGjRqFf//9t9HlP//8c/Tp00csP3DgwL0erKRN6Ql791HINfbAyjlfIqQoSD3qenTv3TemuIfOsliURLJXYTBlvf0xqCH6nIhSQwfwFxpXsACGsg2NxlQUOLwocvrw6KOPonv37sjOzsZtt93WykcgkRyAAuLTTz8VKU/3338/li5disGDB+PYY49FYWFhvcv//fffOP/883HFFVdg2bJlOO2008Rj9erV2Gt0Hw9Hvwux/Pu34PP6kKXpirOvvqPRj7BMtUWvkXEPEsk+1B+jXiuEWgvHoMtEeWtT2Ant4jcaXA9/y3qNGpklLugMJuHCIK+99hp+++231jwEiWSfo9VHtqefflq0w73sssvQr18/vPLKKzCbzcKHWB/PPfccjjvuOKHo+/btKwKWhg0bhhdffBF7k+U/vInirE0o9alwyp2vN+q6oK/VFwwJ8SDjHiSSvQ8LSrF0vDcYqtsfg1aIAWejXJcmmmzFZf8OnSOzwXVRiJS6/Miv8GDs2LG4/vrrq10ZlZWVrXocEskBIyD8fj+WLFmCo4466r8NqtXi+YIFC+r9DF+PXp7QYtHQ8nuCoo2LsPaXt4UJ1H7oRPTqN6jBZZlvznoPHRPMwn0hkUj2DVhUymrUobK+Lp1aI8p6n1tlhQhVQr+0/glORIywuFRmqVtkZjz++OPo2rUrMjMzcccdjVsmJZK2RKsKiOLiYoRCIaSlpdV4nc/z8/Pr/Qxfb87yzIZgAFP0o6X56MnJ8Hq8yFZ3xBnX3tfossVOn/CTynoPEsm+hVGnQUYjKZ3qYRfDoUmEBmHYtv0Ijbug0SqXFA90ZVgslmpXxsyZMzFnzpxWOwaJZF9iv3fOU/3HxcVVPzp27Nji2xh64cPYGMzAQde8CJ2uYZcEbyhqFdA9xSpuVhKJZN9L6TRoVfWmdIYNcSjregqCUMMcLINpWZUoaIhkqwE55V4UVfowbtw4XHPNNeJ1xm85nc5WOwaJ5IAQEMnJyaJCY0FBTSXP5+np6fV+hq83Z/mpU6eioqKi+rFjxw60NIePOxIPf7kCXfsNaXAZRneXe/yiVHWSVaZsSiT7akpnis1YfzAlb4gjr0ClOk5YISybvoXWVb/lM1KkSqdWYVuJS8Q8Pfnkk+jcuTO2bdsm7ksSSVunVQWEXq/H8OHD8fvvv1e/Fg6HxfPRo0fX+xm+Hr08+fXXXxtc3mAwwG6313i0BozdaIxil0/EPHRMNLfK9iUSSeundAat6SjreLRo9W0OlMC09LVG18WmeAyozC71wGaz4Y03qjI4GPT955/1N+iSSNoKre7CYArn66+/jnfffRfr1q0TZj6XyyWyMsjFF19cQ61PnjwZP//8M2bMmIH169fjgQcewOLFi6sjnfdFHJ4A9Fo1uqZYoZUpmxLJPp/SyUdDVgjVQVfDoY6HFiGYN38PnaNhqya7dSaY9KLEdbnbLwLAmXUWcWW43e5WOw6JZG/T6qPdueeei6eeegr33XcfhgwZguXLlwuBEAmUzMrKQl5eXvXyY8aMwUcffSTyqlkz4osvvsA333yDAQMGYF8kEAqLoKyuSRYRWCWRSPZtmEXRPoEpnfV36QzEd0FFx6NERoaIhVj6SqPrY5+bYFjB9mKXsGrwfsdYrC1btuCuu+5qxSORSPYuKqW+pOj9GGZhMJiS8RAt6c7YVuTEpkInMuJMNV5nbXy6Lga0jxM3JolEsu/jD4axNLNMTABY16E2uvKtsH91HhJDxXBoklB2xifwx3dvcH0UDgWVPvRvZ0PHRIvoj8F6NszEmjt3Lg499NBWPiKJZM+PodLevhvQBGrSadA1xSLFg0SyH0GXY0a8ES5/sN7CUoG4rnB1OrLKChEqh3HxzAZ7ZBC6Lm0GLbYWu8R9gbVrLr/8crFu/i9dGZK2iBQQuwhnLk5fAN1SLCKyWyKR7F+k2Aww67Vw+evp0qlSITziClEXgrEQxqw/YChZ0+j67CadsGzQWkmLBOO42rdvj02bNuHee+9tvQORSPYSUkDsImymw9K4tV0aEolk/4DiISPOCIfXX+/7/rjucHceLzp1WkIVMC55FQjXX4QqQorViHyHF9llbsTHx4tYLvLMM8+IPj8SSVtCCohdzLoQrotk6bqQSPZnUu1G0RyrvsJStEKEhl2GSk2SqAthyF4Aa878RtfH+0GcSY/txW6Uufw44YQTcOmllwpXBjPPPB5P6x2MRLKHkQKimQQjWRfJZtkoSyLZz7EbtY0WlvLH94S3yzj4aYUIV0C39A2o/Y03zLLuzMrYWuwULg02FGzXrh02btwoXRmSNoUUEM2kqmCUQbouJJI2ALMk6MZQdsY11bMAgkMuRqU+DWpaIYpWwbb1+ybXyzLXhQ4fskpdwpXx6quvitcpJqQrQ9JWkAKiGdDMSXNn12RZMEoiaSuwqFSyVY9yd/1WCF9Cb4R6HgcvDDCFXVCv/AS6yuwmXRlsqkdXRmGlDyeddJIomiddGZK2hBwFmwFvCp2TzIgzS9eFRNJWUKtVIiA6EAohFK4nVVOlgmfAhXCZO0KlUmBybIZ1/aeAUo/FolaQpk6jxuZCJ5y+IJ599lnpypC0KaSAaGYN/fYJsteFRNLWSLLokWg1iHLU9RGwdwL6nQq3ygxD2Ads/BmmopVNrjfBrIPTG8SWQies9rjqrAzpypC0BaSAaEa0dp90u5hRSCSStgVdku3jq8pb12uFAFDZ+2x447oLi4TFnQ3z2o+h9jubjLFItRmQV+FBZolLZGVccskl0pUhaRPI0TBGWO+eD4lE0jZh4GO8WQeHt/5YiJA5BcqAs+FU2aBTgsC2+bBl/dZohcqIOGGcBeMhiip9oiaEdGVI2gJSQEgkEsnO8ta0QrgbKG9NKrufhGBKf4RUapgCJdCs+x8M5ZuaXHckHmJjoRMak7WGK2P+/MZrS0gk+ypSQEgkEklUeWvWd3F46684GdbbERp4LtzaRGhVIWgKVsC25Tuogt4m182sDLcviE0FlTjymONqFJiSvTIk+yNSQEgkEslOjDoN2scbRZ+bBq0QnY6CquMI+KGDMexGYNMc2LL/jGn9qTajcGNsLXLiqRlPV/fKuOeee1r4SCSS1kcKCIlEIokizW4S8U4uXz3lrQEoWiOcAy6Cz9IeaigwOjOh3/IL9BXbY0oFp4jIKnWjPKirdmUwxXPevHktfiwSSWsiBYREIpFEYdJr0C7OhApP/SmdxJM2Auoe4+FRW6BXAghl/Qv79p+hCvmaXL9uZ1DltmIXhh4yDldccUW1K8PlcrXw0UgkrYcUEBKJRFJPzRezQStqONSLSo3yvhcCyT2gqABjoAzBbX/BGqMrg0GVBq0aGwsqcc9Dj6Njx47YsmULpk6d2rIHIpG0IlJASCQSSS3owmBGRoXX32AsRMDWAYE+p8KnT4IWIWiK18GU/RcMZU1nZZB4sx7BkII8jwrPz6zqlfHCCy9gzpw5LXosEklrIQWERCKR1ENGvFEICZahboiK7qdB034wgmoddGEvfNsWwr79pyYLTEVIsRrE+tv3H4XLr7hSvEZXRmVl4x0/JZJ9ASkgJBKJpAE3A60QLCzVkBUirLOgsu8EhKztoUEYanchQtnLYM/8pckCU/9VqjSixOnD5bfci85duiAzMxO33nprKxyRRNKySAEhkUgkjcRCNGWFcGWMhrrLIfDr7DAigFDBWhjyl8JUtCymbahVKqTbTagM63D/tBfEa6+//jp+/vnnFjsOiaQ1kAJCIpFIGrFCdGjCCgG1BiX9L4M+tRcUtRrasBee7Ytgy5oDrbsopu1E0jsz+g7HRVdeLV5jdkZZWVlLHo5E0qJIASGRSCSNkB5ngtWgRWVDGRk7Ayqdvc8CrBkwIADFU4Jg7grEbf0uptTOSHon+3GcedUUdOneA7m5ubjxxhtb8EgkkpZFCgiJRCJpoi5EhwQTKhupTkkcXY+HqsNBCOpsMMEHb+EWaEs2wJb5a0zxEMSg1aBdUgJufPBZqNVqfPDBB/jqq69a8GgkkpZDCgiJRCKJwQphN+pQ4am/UydRNHqUDLgchuSuYvDXhj1wZS2HuWg5TEXLm1VO+9Axo3HWZdeK51dffTUKCwtb5DgkkpZECgiJRCKJYVDvlGSGyx9EKNywNcEf3w2VvU6D2pIKM/zwuR3wZa+Abcds6Jy5zdreDbfehS49+6KoqAgTJ05q1PohkewNpICQSCSSGEizG5FkNaDM3XCJ60htCLQfCuhtiFO5UF5aCBRtRNzW76EKxN51M85mxsPPzIRWq8O33/4Pb7/9TgschUTSckgBIZFIJDEGOXZONCMQCotHQ7DZVsmAK2BI6QK1RgOL4kRp3lboyrcgbtsPQLj+Jl31MXjwEFx1853i7xsnT8aWrdta5FgkkpZACgiJRCKJEWZJ0BJR6mrcCuFL7IOKnmfAGJcOkyoIxe+CI3stjKUbYMv+o1nbvPK6mzBo+EFwOStxwcWXwBdoOBtEItmTSAEhkUgkMaJWq9Ax0cxeWvAGGrckVHQ/Ff52o6A32RGvcqGk0g1/3mqYC5bAVBh7UKVGo8Fjz7wCo8mMf+bPw32PTYcvGLsVQyJpLaSAkEgkkmaQYNahXZwRpe7G6zswK6N40FXQpvSATqdHiqoc20ucUBWvhy17DvSO7TFvs1PXbrj1nofF388+/hC+/+NfuP3SEiHZu0gBIZFIJM2A/Ss6JJhFpkSD7b53ErRmoKTfxTAmtINRrSAxXIJt+WXQlW8V8RAab2nM2z3nostxyBFHwe/z4o4bJ2HZtqJG00olktZGCgiJRCJpJjajTgRUst13Y2mdxNlhLFydj4TFngCbygeVvxw5eXnQObIQv/mbmDMzKFweeupFxMUnYMu61XhxxhNYnVOBYmdslS4lkpZGCgiJRCLZBdrFm5Fo0TeZ1smAiZL+lyKQMgA2sxnJKidKnW5U5G+DvjIL8Vu+gSrUxDp2kpKWjvuefFb8/dmbL2LJPwuEiMgt98g6EZI9jhQQEolEsgvotWp0SbIgGFaaDGoM6+0oGno9VIldEGdQI11Vio2lIQQKN8FQsV3UiIg1vfPoE07FKWedj3A4jGl33QCf24U1uRXYUuREsJH0UomkpZECQiKRSHaRFJsB7eONKHE2bUHwx/dEab9LYYjPQII2iPaqQiwqUkNVvA6G8k2wZ86KuWfGnQ89iXYdOiInKxOvPHEv4ox6bC50Ym2eAx6/zNCQ7BmkgJBIJJJdhHEJTOtkw61Kb9MBjZWdjoSj63EiHiJR7UFqKB8LCrXQlqyHqWQ1rDnzYtqu1WbHo8++Krb/zWcfYv7vP4h24LnlXqzKKUd5U24ViaQFkAJCIpFIdjegMskMhzfQZEAlVCqU9LsU3rThiLdakKqphM1fiCVFGuhLN8KcvwjmvH9i2u7wUWNw+bU3ib8fvH0ySgvzkRFnFG3HV+woR3aZG+Gm9kci2Q2kgJBIJJLdJCPOJKpUlriazohgqevCYTchmNgDqWYN0lQVCLtKsLoEMFRsgTV3Psz5/8a03WtvmYp+A4egorwM99xyjXCB0BKhUauxNteBDQWOJgteSSS7ihQQEolE0hIBlckWQIWYCjwFLekoHHI9ENcB7c1BpKnKUFxRia3lYVFgyprzl6hY2RQ6vR6Pv/B6VZXKv/7EB2+8LF6PM+lEhkhmiRurcipQ1kTpbYlkV5ACQiKRSFoAWiA6J5hFWmc4hmBIb+pQFPe7FBpbGrqYPEhXlWBDkRu5jiD0jkxYs/+EqXBZk+vp2r0nbr//MfH3c08+hA1rV4m/DVqNsIw4PAGsyC5HZolLZmlIWhQpICQSiaSF6JhUVRsilqwMUtnlOJR3Pw0GawJ6GBxIQxkW5flQWOmHvnIHbDvmxCQizpxwCcYdcwICfj/uvGEivB6PeF2tUgmXhkGjwfp8B9bkOkSshkTSEkgBIZFIJC0EZ/1dk60IQ4ktnVKlQmm/C1HZYSysViv6G4uRjAr8lRdGidMLvTNbiAhzfuOBlczGuH/a80hOTcOWjevx1MP31HjfatQi1WpEgcOL5VlVAZZNBnxKJE0gBYREIpG0IMlWPTolmEWzrVhcGVDrUDTkBrhThiLObMBQQy4SlArMzlWh3OWHzpkDa858WJji2cj6EpOS8cjTM8Xfn73/Jmb//H2N97UatXBp0CqxJqdCFJ+S1gjJ7iAFhEQikbQgtAZ0SjIj3qxHaYzBi2G9Ffkjb4cnqR+SzFqMMGTDHq7ErGw1KrxBUfLakr8Ith2zGxURY8aOx6VX3yj+vv+2G5Cfl1NnGQZYptiMyK/wYllWmYiNCMjYCMkuIAWERCKRtDDs1Nk9xYqQosTcdjtkTkXByDvgS+iBVBNwkD4TupAbP2cBpT419I5tMBWtgH37T42Wvb7htnvQf9BQkdp5142TEArVXVa30xqhU6uxLs+BVdkVQuzIfhqS5iAFhEQikbRSmesuSVVZGbHGGwTsnVEw4g4E7F3QzhTCoYatCAWD+DkzjGK/AYaKrTCWrkP85q+gCnobTO184sU3YLZYsXjhfLz54tONFsFKt5uEeFi2owwbC5wxCx6JRAoIiUQiaSU6J1mQZjeiyFn/YF8fvsTeKBh+CwL29uhk8uIo4wb4Qwp+zgyhIGiBoXyrSPNM2PgZ1H5H/dvt2h13P/qU+HvmM09g2aKFDW5Po1aJfbTpddhW7MLSnUGWMuVT0hRSQEgkEkkrQVdBtxSryM6o8MQesOhJG4aiwTcgaM1AF6MbxxvXwhNS46dtAeSEEmAo3wydKw+J6z+B1l1Q7zpOPvM8nHTGOcKFcecNV6KirKzRbbKfR7s4I6BAtAhfvqMchZVeWQ5b0iBSQEgkEkkrwqDF7qlW4RrwB2Of1bs6HIaiIdcjZM1AV6MLp5pWwRHS48etPmwNpUJfsQ1aTxESNn4OQ9mmetdx96Mz0KlLN+TlZOO+Kdc1GePAAFDuL90aDk9VT41IJUsZHyGpjRQQEolE0spk2I3okGBCEWf0zRiInR3HoXDIdaL0dReDE+dZlqIibMT3WwNY5UuBzpkNracYcVu/gyV3QZ0MDYvVhmkvvyXiIubM+hEfvf1qTNulW4MxHEkWA4oqfVi6o0wUomqOFUXS9pECQiKRSFoZtVolXBmJVr0YkJuDs+N40TcjaElDZ70Tl9v+hV/R4qcsDf5xJEPtLYPWXQhL3gIhJFShmutns60p9z4i/p7xyL1Ys6LpypbRLhjGR9gNOmSVeLAsswwb8itjal0uaftIASGRSCR7KLWzV5oNOq2q2TN5Z6f/RER7XSWujvsHegTwY54Fc4utYJgCAyvpykjY8Ck03prxDuddMhFHHncSgoEAbrv2MlQ6Kpq97+3iTSJOYnuJE0szy7CpQAqJA51WFRClpaW44IILYLfbER8fjyuuuAJOp7PRzxxxxBHCDxf9uPrqq1tzNyUSiWSPwOJSPVJt8ASCzW6z7ex0JAqG3YyAtT1SNC5cG7cQqaoyfFnYDr9kAS5tvGgHXhVc+SEMpRuqP8v76IPTX0S7Dh2RnbUdD94xeZdiGsx6LdrFmUVQ6JYiJ5ZklmF9nnRtHKi0qoCgeFizZg1+/fVXfP/995g7dy4mTZrU5OcmTpyIvLy86se0adNaczclEolkj8FMh86JFpS4Yq8PEcHV4XDkj7wTfltHxKm9uDb+Xxyk24pPKvrhf5v8KNRmiKqVWk8J4rb9AFvW70C4qq6DPT4e015+G1qtFrO+/wafvPv6Lh+DxaBF+3gzTDqNaBm+NLMUa3OrilHJrI0DB5XSSqG169atQ79+/bBo0SKMGDFCvPbzzz/jhBNOQHZ2Ntq1a9egBWLIkCF49tlnd2m7DocDcXFxqKioEJYPiUQi2ddgNgYH3AKHDxlxRmEhaA6G0vVI/+cxGBxb4Vc0+J97IN5zj8Fh+g04sZsOXbWlUFQqYa0ImlNR0fUkhIzx4rPvv/Eypj94F7Q6Hd798mcMHDp8t4+H1hQWzGKfDfYCobuDXUnZf0Oyf9GcMbTVvt0FCxYIt0VEPJCjjjoKarUa//zTeGe5Dz/8EMnJyRgwYACmTp0Kt9vd4LI+n08ccPRDIpFI9mX0WjV6pNlEymRxjK2/o/El9kHumIfgTegNvVrBmeblmBL3O/4K9MbrG81Y4rAhpGXRqS2iGVfi+g9gLF4lsjQuvOIaHHXCKSIeYso1l6C8rHS3j4cxEiyNnWDWC8sKa0gsySoTBali6koq2S9pNQGRn5+P1NTUGq/RdJaYmCjea4gJEybggw8+wJw5c4R4eP/993HhhRc2uPzjjz8u1FLk0bFjxxY9DolEImkNrAYteqZZwUn6rsQQBOK6IOfQx+FKHQ6VRoexunV4IvF75CnxeGZHD8zKDKPS1E4EV2rdRbBn/iqyNNRBDx6c/kJ1fYi7b7oa4XC4xYRRqs0oHl5/GGtyHVicWYqN+ZUod0v3Bg50AXHnnXfWCXKs/Vi/fv0u7xBjJI499lgMHDhQxFC89957+Prrr7Fly5Z6l6fIoKkl8tixY8cub1sikUj2JElWA3qm2YQLYFd6ULABV+4hj8HRcTzCWjP6qbbh+ZQf0ElbgmdLR+HDdUHkaDpAHXBBX8ksjY1IWvc+kpQSPPXKOzAYjJg3exbefOmZFj0u1pGgC4P1L7RqNbaVuLA4swwrssuRV+FpdgCppI3EQBQVFaGkpKTRZbp16yasCLfeeivKosqnBoNBGI1GfP755zj99NNj2p7L5YLVahXxExQWTSFjICQSyf4Eb8Hbi13YWOhEkkUvMhyaTTiEpNVvImHz19D4yuHWJuAt5yi84xqFkZpNuKhjCfola6B35SJoTkdIb4M3qR8+WJCD/7d3JuBNlWnf/yc52bvvhbLvAgqiIAIiuKDwOi7juKP4qbjOKCriuIHjzqu+6Ig4Mir66cg4vuKK4IAwA6KALIoUilAopStd0uzbyXmv+w7tAIKQkpaS3r/rOlfOSc5JnjxN8/xzr488cB+7ll97bwHOGDkaLRn34fSHEFRVzubITbYgK9nMbhwSHELbIJY1VIn1ybOzs3k7EsOHD4fD4cC6deswZEg0SOfrr79mU9mwYcOO+vU2btzIt/n5+bEOVRAEoc1DVtvOmXb4wypKan3ITTbHHnyoN6B24C0IJXVgIWH1VuN2+3L0sTrwRM3ZeKykA25wbcbYLl2RFiiHPlAPaBHc2D8JFddehNnvfYZpd/4/zF+4HPkdW8YNTO6NrCQzCyZPQMWuWg9213mRYlW4WFW63YRksxJzQKmQgFkYxIUXXoiqqiq89tprCIVCuPHGGzmo8m9/+xs/XlZWhnPOOYfdFEOHDmU3BT1GmRqZmZn48ccfMWXKFBQUFOBf//rXUb2mWCAEQTgRoV/oWyqcqGjwIy/F0uxf5eaan5C37nnu2glNRbGxDx7ZezZ+CnfEheafcF1XF7okqVwvImzLRcBgx/Nz/443lu1Al36n4q0PF8JssaA1oI6frkCY3TdmRc91MnJSLGyVsJsMIibaaxZGYzZF3759WSSQKBg5ciRef/31psdJVBQVFTVlWZhMJixZsgTnn38+X0cukN/+9rf47LPPWnKYgiAIxx36hU6VKrOTTahyxtYzY38CWQNQOvpFuDsMh2Ywo3toC17P+xjXp/6ILwMDMW1bLywtN8KV1J3bgds9u3HX1Rfg/tGpSKr9Ac8+NhWtBVlaKHODakokW4xweEPcCfT7XXX4cU8Dyh0+eAKxx4YICWCBOB6IBUIQhBMZWjA3lzdwZgbFCTT7V7gaQuZmiov4hOMiVMWGVcrpeLjsTNQhGeOsW3FDlzp0SYpwqmd5nQf/+OwrVLoj6H35ozj32j/geEGpn+5AGCFV5RRRskxQvESKReHsFbFMtI01VASEIAhCG4OCDTeXNcAbUNmkfyzYy1Yie+MrMLn3cB2IantvPFU3FotdXZCLetyatw1jO2pICtdhT+FqfL2mEO6wAaNveBiZI69HxJSM4wUtT/5QBJ5gGIFwBGZFhxSrkdNEky0KWy0kADO+iIAQASEIwglOvSfIloiQqnHw4bFg8FQjd/0LsFeu5ToQQUsWliijMGP3yXBqNpxhLsFtXcrRO01D4dcfYG9VBaqCVky46mboeoyBJ+80QG/E8YbSP8lC4w9HoOh1bI3ISjaxqEixGNlaIRwbIiBEQAiCkADUuAMoLHdyASaqGXFMRFSkF73P3ToVfy2gM6AqZQCeqh2DxY58WBHA7zJ24vK8Kqz94l2kowGm5AycOu5a6JKy4e4wAv6MvoCubZSnpgBMTzBaP4OWMYvJgDSrietPkHWCxIWU0o4dERAiIARBSBD2ugKcnREXEUFZGrVbkLNhFix1RdCrAYSs2fiXZSxmlAxAdciCPF09bsouQu3SV5GseTG0XwF6nDoaIXs+Z224O45AMKUb5Z+irUDLmI+LcakIhFUuXmUjQWE3cpAmNf+ymxRxdxwFIiBEQAiCkEDEW0RADSCz8B2kbf8YSqAeml6BI/Uk/MV3Dt7akwsNOvQ1VKL/1jlIrS/EhWcNQZ+CLBYQIVsOQsmd4O44kpt1tUXIOtEoKMKRCGe4WI0KMuxGdneIoDg8IiBEQAiCkGDEXURwzYjNyNnwEiz129gaQR07i9LOwoyy07HRYYEOEfRyfo/Be97HlecMRbcMhQVHyJbHQiKY2g2e/DParJDYv8YGCQraqJihkQSFoiDVriDVauKaE1aToXlVQBMMERAiIARBSFARsbXSyQsiZSLEBTWIjK3vI237/0LxUZsCDf6U7vjafiGe/bkTqvx6GKCiT+1yTDtdj35ZCqd9KoEGhOx53C48kNr9hBASjYTIQhFUOSgzpEWg6PSwGPVIMhuRZlNgMytcbttqNLQ7K4VTBIQICEEQEpM6T5AtEbQA5iSb41YTwegsRfYPr8Be9T30IS8iBjNcmSfj3dC5eLkoCZrBxELi4pxq3NipCrl6J4yecij+uqhrw57HQsKbezqCKV3aVIzEkVAjlC4aFRSULkoiiqwRtFGpbXJ72PZZKSyKAfoEFhVOERAiIARBSFwavCFsqXRysSkqe62P12KtaUjavQRZm+fB5CqFLhKCak5FSfIQ3PxVBKWdLoBOb2AhcUVBA67OL0ce6mDylMHgr4NqyeBgSxIQntyhCKT3ajNZG7FAy2JQjXANCgrKpFRa0gwUS0GiItUarUFBaaNRUaFPmIwPERAiIARBSHCoUuPWCieneualWONqateFvEjf+jekFX8CxVdHOaBw6VLwwlel+NR2MTy9x7OFgWIkftPRg4kdKtBZV8X9NRRvNSKmJIRsJCQ6w5s7BP7M/lxW+0SGlkqyTkQ3FWGVlk6NRYVJMXDaKKWPNlopSFxQf48TzVohAkIEhCAI7QCqgbCt0oVKp59jIoxx/hWsuCuQ9dNcJJWtgCHkgd/vw/rtVXhvRzL2jJiBIl0nRHgF0TA2P4jrC/air343TJ5KGL2VbH0IkXsjqSMLCW/2KYiY05AoaJrG1ongPlFBVguaDj10MCm0GWA3G7gEt8WosKAgYUGio63GVoiAEAEhCEI7gRauHdVulNZ7uZASBf/FG0vNT8jc/BZsezfC56hCbV09dtRF0DDwRnyTczk+/9nHcQREv3QNN3Wrw3BLCSyeMrZK6MN+qJZ0zt7w5gyCL3vwCRcnEQtqhIRF1FpBtyQs6J2Sq0kx6GAyUJ0KBUkWcoEofGw26qO3iv649voQASECQhCEdgQtWDtr3NhZ44HNGA36awlsFauRWfgWPNtWIORpYOuDqeBkOE66Du/W98cnRV5OlSSyrDpM7OHHuPRyZLm3sUWCmnppehPCtmwE0npy5oYv4yRoRhvaA+o+YcGigsWFBlWLigtF0cOo17MViQI2ySVC1TVJVPDGrpKWt1yIgBABIQhCO4O+ysscPmyvcrMZPdNuaplfspEIbKXLUPH3qchUq3ixy8rJQySjO6o7T8AC7ymYv8WPGneQT6f1blwXA67oWIN+6jaYXSVQvHuh08KIGJO5noQ373R4ck9DKLlzwloljkSjsCBREd53G3WIAAadDkYDWS+iFgqacyqGRWKDRAVV24yXsBABIQJCEIR2XCtie7ULTl8YuSmWFvvFGvB68ebd52Ns0g6c0sGEgvxc6BWFUzodBWOw1HAW5v+sQ2Glq+maLmkmXNk9gLEpZch2/ACjpxL6kJuWIs72CKZ0hbvDSHhzEitWIl6WCwrcZJERiSC8z2VkNuhxcqc07gESD0RAiIAQBKGdZ2hsr6LgygBbIlqqS2VDfT2uv+w8dA0XY8robJwzMB9KJMCPhS3p8Oaehp+yJuCDPWlYuq12X40FsKg5q4sVlxW4MBhbYa/9CYqvhq0SFHipmlK5cZer4Cz4MwdAU+JUNCsBqWjwYUiX9LhVJxUBIQJCEIR2Dv1S3bnXg5I6D/eBSG2huIiy0hJcd/F5qN1bjWvOHYQXJ52BlJr1MJBlQdMQUSwIpPVCZdeLscjTB59vc+PnarI6REmzGXFBdzMmZNegt2cdLA3bYQg0cGZH1DKRBl/WALZM+LIHtom24m2JChEQ8UMEhCAIQhT6ei9v8HOWBmVrZCe1jEtjy08/4KYrLoLb5cTocy/AKy8+g6ziBUjes5wrVeoiKjQ9pXTmcROuzWnn4pNSC5b/XAunP9z0PJ3Srbigm4Lz0yrQ1bUW5vrt0Ie9TY+Tm8OX2R+e/OHw5pwKGOJjtj+RqRABET9EQAiCIBwIVawkEVHtCiDDZuJiR/Hm++++we3X/RaBgB8XXX4VnnjhVRhUH1J2LUZa8acwNezihl1ExGiDL6036rpNwCq1P77aGcDq4jpOd2ykW5Yd53cx4vyU3ejsXs/tx3Wqv+nxiMGCQEZfeHJOgyd/GCKW9hkzUSECIn6IgBAEQfgllDa4u9aDXbVeKHodB93FO0tj+T+/xJRbroOqqrjuptsxdfrT0dfQNFir1yN1x6ewV66BIeiETotA0+kRtmRwXYiKzuOx3NkBy4td2FjqaKorQXTOsOGsLjaMTy1GD98mWOsKuV9HEzo9gsmd4MscCHfeUATTe7YbV0eFCIj4IQJCEATh0NDXPWVp7NjrRoMvjKwkU9xbWH/2v/Px8D238f7t9z6I26c8eMDjukADUnctQuquL2FylnCRKR6bXuGGXO78M1CRdw6W1WXh38UObCprOEBMZCebMbRzKi7IKMdg9Sck1W/mAMz9XgGqKQWBtB5c+dKfdQo/L/SJ2aq7QgRE/BABIQiC8OtQJ8+dtW6U1ftgMhiQbjPG1Rrx7htzMHPGH3n/7gen46Y7p/zyJE2DqX4bUnZ9ieSyFTBSbYhIKPqQwYRgUj4HTlblno2Vjgx8s7MB63bXsyWlEaqJMKggFWPzfBihFCHfXQiTcxd0kWgNCn4uvZGtHNTYy5t5MoLpvfYJivhX7DweiICIIyIgBEEQjgx99Vc5A1zBkqwR8U73/OsrL+Ll5/7E+/c/+iSun3zX4U9WQ7BVrWXLBLk6lICDAy8JaitOC74nbyhqO4zBWl8HfFfiwtpddaj1/EcoEB3TrDijo5HrTAzEz0hp2MZdQhuFCT+fYuMU02Bqd/gzTkIgtRtCSR2gKVaciFSIgIgfIiAEQRBit0aU1/s5QyOeVQ3n/M+zmPPis7z/xydm4upJk494jS7kg61yDVJKFsNW8wOndP5HTBgRtmbBl3UynB1HY4uhD1ZXqFi/ux5bK10HuDroLfTJtuGs3ACG2/egt7oDNncJDAHnfhYKHQd0ksuDGn750/sgSILCnoewNfuEaEVeIQIifoiAEARBaEZshDuAXTUe1HlCXDOCejHE43lffu4JvDH7RT5+9Jn/we+uu/Gor9cFPbBXfY/k0qWw7v1hX0poNO1T0xugmpK5xgT11KjJPA1rnWlYX+rED6UOTl/dHwocHZBjwshMD063VaCnthN2bxn0QfcBqaIRxcolttlKkdINgdTuCCXlc4VNqknR1kptV4iAiB8iIARBEJoHxReU1XtRUufl/Uy7mXstHAu0xLzwxCN4Z+5sPn7oif/GVZNuifl5dGE/LHt/QHLpctj2rofRW/2fAEydDprBwk26vFmncG+N3baTsK7agI1lDfiprOEX7g6yUPTN0OPMTC8G22vRV1eK9GAZF8DiIliNQkVnQMSYxGKFBAQLipQu3MODrBTUZfR4WipEQMQRERCCIAjHXjeitM6LigY/N3KilM9jcWscLCKOGBNxJCJhmB3FsJetQFLldzC5SqEPujg1lF9Pr7AlIZjUEb7sQfBmD8Iucy9s3KvDpnInCiucHP9xMHnWCIZn+zEoxYOTjBXoFCmDOeyCga0UHqDp+U2IGO1QaTNRD4/OCCV3QnifqCA3CwWCtgYiIOKICAhBEIT4uTV213pR4w7AboqWw25utgY9359nPom/vvICH//+gUdxy+/vi8dAOY3TUvMjkspWwlq7GYq/Fvqwjx/TqAyF3sRBksGkDvBlngx/9kCUW3rhhwYri4ktFS7srPUcEENB6BHBgLQgTk3zor/dhV5KFfIj1TCrHuhDnqjrQ1P3Ey226GayI2TNZWERtucjbM2MWivYBRJfa4UIiDgiAkIQBCG+PTWqnH6U1Hrh8oeRbFaQbFGaLST+MmsmZr/wNO/fevdU3HHfQ3FNIdWpARidpbDu3YCkytUwNxTD4K+PVsE8QFBYogGZ6X3hzzwJrtQ+2BLMQeHeIIoqXdyvgyp3HowRYQxM9ePkVB962z3oqexFR+yFLRIVFFTg6oA0UoM5GlehULBmEsK2PC56FbLnQ7VksLggK0Zz61SIgIgjIiAEQRDijz+korLBhz31Pu72mWo1NTvQ8s05L2HW09N5/6obbsG0x5+FwdAyhZ70QSdMzt1soaCATNpXAvXQhX20ADZld0TdEskIphTAn9aH60bstXZDoScFRTVBLr5FW407+MvXQARdLV4MSAugj92HnmYHOuuqkKlzwRTxsaiIWkSi1orG+hTUaIxiN8gdErJlI2TLRyi5gEUGBXFSfAUJkF9DBEQcEQEhCILQcniDYZQ7fChz+OALRpqdsTF/3lw889gD7NoY91+X4qlZr8Fkjs8i+GvoAw6YXGUw12+FrXpD1EIRqOc4h6YMD52eYxhIVFADr0ByZwTTunMA5V5zZxR5U/BzvcZuj501Hp6Lg7wfjBlB9LT70S8lgF42H7qZ6tFRX4csrR5mzc+i4mBhwa+vV6LCwmBmt0c0YDOHs0GCSQVQrVk8LiqGJQIijoiAEARBaHnICkEWiXKHn0VFiiUqJGJxRyz69CM8dM+tCIdCGDZyNGbNfRf2pGS0JrqQFyZPOYzOElhqfoK1bisU314Ygg28uDfWoKC0UbZSGEyIUN0IWzTGIZjcGe6kbigJpWGb24xih8r9RkpqPaj3/qeA1f4oCKOzxY/eKSF0twXQ3dKAzvpa5KAOKZobBjUqLvZ3hfxSYETFRYM+FWlnTERa9yFxmQ8RECIgBEEQWgUPCwk/yht8vJ9kNnKMhP4ohcR3K5bjnluug9fjRr+Bp2D2vA+QlZOL40ZEZQFh9FTC5NwJS+0WmJzFUPwObgJGqaNNJbf1JCrI/WGMZmWYUzl4ktwQFOfgMOWjNGjHDrcZ2xuAUkcAexw+7kdyOEwIo1tSCD1os3rRzeRAB0M9suFAasQBEwVwUvrqPqsFpdsazpuO1D6j4vL2RUCIgBAEQWj1ipbVLj/313AFQjAbDOzeUAxHzjrY/MMG3HHD71BfW4P8jgX481t/R+9+/dFWoMBMxVsNo6cKRlcJLPU/w+QqgaFJVFDgZIitFVyTgiwEJCzIWqEksbAIm9MRtudy2WyPORflITtKfWbs8hixw6lHWUMw6hYKHejOOJgsSwTd7Cp6JXnR0+hAhlaHPmOuQb+e3ePyXkVAiIAQBEE4LgTCKmrd0cXQ4SUTvA5pVuMR+2yU7NyBu264gm9t9iT896tvYtTY89FW0alBGPy1XNDK6C6HqaGY61Gw+yPghCHk4nMorkKnhUELbZOw2FdHIkLFqUwpiJiSELJkIWTPhVOfiqqgBeV+E3Z7TdjtUbDLBZQ5Q5wFcyhuP8WM+68YE5dAVBEQIiAEQRCOK1RToc4T5BTQGlcA/nCEYyR+zb3RUF+Pe2+diLXfroRer8fU6U/jmhtvjWuaZ4uiadAHG2D01cDgrYHRvQdmdykLDEPAwRkhhqAHukggKiwovkILAzrDPnGhIGKw7hMXSVCNKdCMVqiKFao1E159MurCZqz5uRz/XLMVNREbfPYCFH35NtKVEF566SVcdtllx/QWRECIgBAEQWgzOP0hFhFU2ZKCLxWdDimHsUqEgkE8+dC9WPD3d/n48msn4cHHn2uVDI0WQ4uwgKBeHgZfHYyePZwJYvRWsLWC+3GEXPviK8hioUZLaWsqiyfOCtFF0z7JurNhyw44g4A7pEdQb8Xrq+qxpdzFL/Xhhx8ek4gQASECQhAEoc1BAX/13iAHXdZ5AgiEI7CZFC5OtX+sBC1Lb732Ml56ZgbvDxg0BC/+5W3kdShAQqFpHD9Bha4olZTiLEzuMg7gVHzV+6pdUh0JD7tDSFQUb98GLUIijJZuHRegemRZEAt+dLLYKCgowM6dO5vtzhABIQJCEAShzULLDlkiyMVBVgmXL4wINBYSdvN/XBwrly3Bg7+/Gc4GB9IzszBz9hsYNmI02gWaxlYJamdOwZoUW1FR+C2+/vj/I8caQbo5AouiwWY2YupiLzaUOJsuXbZsGc4+++wWX0OPvV+rIAiCIMQA/VJOtlC6pxEF6TZu3lXrDnDpaIqZIAFhNyk48+xzMH/hctw7eSK2bt6EW6+5FH+Y9hgm3fYHjpFIaHQ6rjfBNSeSO/Fdq7YE8cT3H/G+Ua8hzaQhMyMV22qLD7i0oqKiVYaY4H8BQRAEoS1DXT6p22ev3GSc3jUDgzqnoSDdClWLcKEqJTUPc+YvxEWXX41IJIJZz8zArddeiurK1lkk2xJZWVlN+6GIDnv9evzsMiN4UOZnfn5+q4xHBIQgCILQJjApeuQkW9A3PwWnd8vA4M7p6JRhhWKx4M7pL+CeGc/DYrVh9cp/4fLzR2DZ4i/Qnhg0eDBycnPZOnE4y06nTp0walR8ikodCREQgiAIQpvDrBiQkxIVE0O7ZmBI1wzccdtkvPXxUvTsNxCO+jrcffO1mDHtHq5i2R4w6A24//77owcHiYjGVNdZs2a1WGOygxEBIQiCILR5y0RWkpndHJefMxQrVn6DyXfezY999Ld5uHjsGfj8y0Vw+UNcfyKRGTtmLGbOnImcnJwD7qfsi2NN4YwVycIQBEEQTkiWLFmCm2++BSUlu/h4/GVX4ab7psOemgaTQQ+r0QCryXDUfTlOJNSIio0bNmB7RS2Gds/GhHPOkkqUx4oICEEQhPaD2+3GI488gpdffpnTQ3NycvHQ409h9PjL4AqEuUeHBo17c5CYoOJViSQoKo5jO29xYQiCIAgnLElJSez3/+abb9CvXz9UV1fhnttvxh1XTYCuZgcvrn3zUpBqM3LhKmr4Ve7wocYd4FoUie7yaElEQAiCIAgnPMOHD8eGDRvwzDPPwG6349tvv8WoM4fj/t/fBmOggTM6hnbLwKmd03FShxROHVU1jYUECQqqP0H1KPwhlS0ZwpERF4YgCIKQUJSXl+OPf/wj3nnnHT62WCy4/fbbMW3aNORSGuR+pbW9wTA8QRUuXwgOEhBBlTuKUpVok8EAs6Jnt4fxKNqStzcXhggIQRAEISFZvXo17r33XqxatYqPbTYb7rrrLkydOvWAokyNRCIafCEV3qDKsRMOXxBufxj+sIqQqoF6clNGCIkKs0KiQnfcO4WKgIgjIiAEQRCERmiJ++qrr/DYY49hzZo1fJ/VasXEiRNx991346STTvrV68NqhEUFCQp/KNIkKgJhlS0YZKpQ9DqYjQbO/CCBQdU1W4t1m7bgolGDRUDEAxEQgiAIwsHQUrdw4UJMnz4d69ata7r/vPPOwx/+8AdccMEFUJSjaw9FosIfjuwTFSpcgRCcvqioCIU1RDTK+yAXiL5JVNAWr+wPt8uJLz/5X3z0/jso3LSRRcTg/n3i8twiIERACIIgCIeAlrwVK1bgpZdewscff8z9NYi8vDxcffXVbJkYNGhQzK4JTdM4y4MEBVkqfMEwnP4wvAEVAXWfsIBGoRUcT0FbLBYLVVWxYe13+OSD97D484/h93n5fkUx4tW5b+CWSRORMALiqaeewhdffIGNGzfCZDLB4XAc8RoaCqnDuXPn8vkjRozAnDlz0KtXr6N+XREQgiAIwtGwc+dOvPLKK3j77bdRW1vbdH///v1x6aWXYvz48Rg6dOgxFWiKRDSOoQiEyGqhcpAm1afwBFQE9wkLygYhkwUJCRIVLDAUHaCGsXbVCixd9BmWfbUQdTV7m563e68+uOyqiTj9vItxzuBeieXCICGQlpaGPXv24I033jgqAfHcc89xCg79Mbt164ZHH30UmzZtQmFhIUfRHg0iIARBEIRYCAaDWLRoEd599118+umnCAQCTY9lZGRg3LhxGDNmDIsJEhdH6+o4krAIqhEWFuT6IOuFw+XBmrXfY+3qVdi4+ltsWr/6gD4fSSmpGH3eBFx61UScevowKAZ9YgdRzps3D/fcc88RBQQNo0OHDrjvvvuamoXQG6CUG3qOq6666qheTwSEIAiC0FxorSIRQfESixcv/sXaRZkcQ4YMweDBg9GzZ0/06NGDt65du8JsPvIiTi6T+vp6VFVVobi4mH8gb968uWnz+/0HnJ+Tm4fzL/wvnD1uAvoPGQ5VZ0BIjSCsRi0XBp0OgzunHRcBcewyKo6mpMrKSpx77rlN99GbGDZsGBcEOZyAIKW4v1qkNy8IgiAIzYEs59dffz1v4XAY3333HVsnaB1au3YtXC4Xx1CsWLHiF9dSdgddT1vj4kvP0biRcKiurub9w5GdnY2zzjqLN2rLfcopp0Cv1x8QwEmWC8oAoS0U0ZBkOT5LeZsRECQeiP2LfDQeNz52KMjl8fjjj7f4+ARBEIT2BbkqRo4cyVuj9WDr1q1cX6KwsBA7duzgbfv27fB6vfD5fLxVVFQc8bnT09O5gya5RPbfKObv1wI4yW1Bm82E405MAuLBBx/kOIVfY8uWLejbty9aC6o2RoVC9rdAdOrUqdVeXxAEQWgfkCWA6kYcXDtC0zS2LpC7g0z/jbd0PokQ2igQkywT9KOYWnFTcsGJTkwCguITJk2a9KvndO/evVkDoRQagvxC+fn5TffTMaXUHA7yOR2N30kQBEEQWgKdTsfBlrS1J2ISEOSboa0loKwLEhFLly5tEgxkTSBTEdUwFwRBEASh7dBi3UF2797NNSDolgpg0D5t1Lu9EXJ1LFiwoEnBUbbGk08+yRGwlL5JQSyUmXHJJZe01DAFQRAEQWhLQZRUd5zqOTRCKS/EsmXLcPbZZ/N+UVER+4kaeeCBB+DxeDB58mT2IVHgCkW/Hm0NCEEQBEEQWgcpZS0IgiAIQsxraNtscC4IgiAIQptGBIQgCIIgCDEjAkIQBEEQhJgRASEIgiAIQsyIgBAEQRAEIWZEQAiCIAiCcOI204oXjVmp0pVTEARBEGKjce08mgoPCScgqNUqIQ21BEEQBKH5aynVg2hXhaSo3Wp5eTmSk5N/tSVqLDR2+CwtLZXiVHFC5jT+yJzGF5nP+CNz2vbnkyQBiQdqI0HdRNuVBYLeMPVYbwnoDyQf+vgicxp/ZE7ji8xn/JE5bdvzeSTLQyMSRCkIgiAIQsyIgBAEQRAEIWZEQBwFZrMZ06dP51shPsicxh+Z0/gi8xl/ZE4Taz4TLohSEARBEISWRywQgiAIgiDEjAgIQRAEQRBiRgSEIAiCIAgxIwJCEARBEISYEQGxj9mzZ6Nr166wWCwYNmwY1qxZ86vn/+Mf/0Dfvn35/IEDB2LhwoWtNtZEnNO5c+di1KhRSE9P5+3cc8894t+gPRLr57SR+fPnc2XWSy65pMXHmMjz6XA4cOeddyI/P58j33v37i3/+8c4p7NmzUKfPn1gtVq5quKUKVPg9/tbbbxtmX//+9+46KKLuCok/f9+/PHHR7xm+fLlOPXUU/nz2bNnT8ybN6/lBkhZGO2d+fPnayaTSXvzzTe1zZs3a7fccouWlpamVVVVHfL8b775RjMYDNrMmTO1wsJC7ZFHHtGMRqO2adOmVh97oszpNddco82ePVvbsGGDtmXLFm3SpElaamqqtmfPnlYfe6LMaSM7d+7UOnbsqI0aNUq7+OKLW228iTafgUBAO+2007Tx48drK1eu5Hldvny5tnHjxlYfe6LM6XvvvaeZzWa+pflcvHixlp+fr02ZMqXVx94WWbhwofbwww9rH330EWVLagsWLPjV84uLizWbzabde++9vDb9+c9/5rVq0aJFLTI+ERCapg0dOlS78847m45VVdU6dOigPfPMM4c8/4orrtAmTJhwwH3Dhg3Tbr311hYfa6LO6cGEw2EtOTlZe/vtt1twlIk/pzSPZ555pvbXv/5Vu+GGG0RAHMN8zpkzR+vevbsWDAZbcZSJPad07tixYw+4jxa/ESNGtPhYTzRwFALigQce0Pr373/AfVdeeaU2bty4FhlTu3dhBINBrFu3jk3m+/fToONvv/32kNfQ/fufT4wbN+6w57c3mjOnB+P1ehEKhZCRkdGCI038Of3Tn/6EnJwc3HTTTa000sSdz08//RTDhw9nF0Zubi4GDBiAp59+GqqqtuLIE2tOzzzzTL6m0c1RXFzMLqHx48e32rgTiW9beW1KuGZasVJTU8NfAPSFsD90vHXr1kNeU1lZecjz6X6heXN6MNOmTWO/38H/DO2V5szpypUr8cYbb2Djxo2tNMrEnk9a3L7++mtce+21vMht374dd9xxBwtdqgbY3mnOnF5zzTV83ciRI7kLZDgcxm233YaHHnqolUadWFQeZm2irp0+n4/jTOJJu7dACG2PZ599loP+FixYwIFYQuxQO96JEydycGpWVtbxHk5CEIlE2Jrz+uuvY8iQIbjyyivx8MMP47XXXjveQzthoYA/suK8+uqrWL9+PT766CN88cUXeOKJJ4730ISjoN1bIOjL1WAwoKqq6oD76TgvL++Q19D9sZzf3mjOnDby/PPPs4BYsmQJTj755BYeaeLO6Y4dO7Br1y6O4N5/ASQURUFRURF69OiB9kpzPqOUeWE0Gvm6Rvr168e/+sh8bzKZ0J5pzpw++uijLHRvvvlmPqaMNo/Hg8mTJ7M4IxeIcPQcbm2iVt/xtj4Q7f6vQ//09Gti6dKlB3zR0jH5Ow8F3b//+cQ///nPw57f3mjOnBIzZ87kXx6LFi3Caaed1kqjTcw5pRTjTZs2sfuicfvNb36DMWPG8D6ly7VnmvMZHTFiBLstGoUYsW3bNhYW7V08NHdOKdbpYJHQKNCkTVPstPra1CKhmSdg6hGlEs2bN49TXyZPnsypR5WVlfz4xIkTtQcffPCANE5FUbTnn3+eUw6nT58uaZzHOKfPPvssp399+OGHWkVFRdPmcrmO47s4sef0YCQL49jmc/fu3ZwZdNddd2lFRUXa559/ruXk5GhPPvnkcXwXJ/ac0ncnzen777/PKYhfffWV1qNHD850EzT+/qPUdtpouX7xxRd5v6SkhB+nuaQ5PTiNc+rUqbw2UWq8pHG2ApQv27lzZ17EKBXpu+++a3ps9OjR/OW7Px988IHWu3dvPp/SZr744ovjMOrEmdMuXbrwP8jBG33BCM3/nO6PCIhjn89Vq1ZxyjYtkpTS+dRTT3GqrNC8OQ2FQtqMGTNYNFgsFq1Tp07aHXfcodXX1x+n0bctli1bdsjvxcY5pFua04OvGTRoEM8/fUbfeuutFhuftPMWBEEQBCFm2n0MhCAIgiAIsSMCQhAEQRCEmBEBIQiCIAhCzIiAEARBEAQhZkRACIIgCIIQMyIgBEEQBEGIGREQgiAIgiDEjAgIQRAEQRBiRgSEIAiCIAgxIwJCEARBEISYEQEhCIIgCELMiIAQBEEQBAGx8n9IXr/4APX11AAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from botorch_community.acquisition.bll_thompson_sampling import BLLMaxPosteriorSampling\n", + "\n", + "batch_size = 1\n", + "\n", + "torch.manual_seed(42)\n", + "X_bo = torch.rand(2, 1)\n", + "Y_bo = objective(X_bo)\n", + "\n", + "# lets define the optimizer settings\n", + "optimizer_settings = {\n", + " \"num_epochs\": 10_000, # number of epochs\n", + " \"freeze_backbone\": False, # whether to freeze the backbone / features during training\n", + " \"patience\": 100, # patience for early stopping (if no improvement for `patience` epochs, stop training)\n", + " \"batch_size\": 32, # mini-batch size\n", + " \"optimizer\": torch.optim.AdamW, # optimizer\n", + " \"wd\": 1e-4, # weight decay\n", + " \"lr\": 1e-3, # learning rate\n", + " \"clip_val\": 1.0, # gradient clipping value\n", + "}\n", + "\n", + "for iteration in range(20):\n", + " print(f\"Iteration {iteration}) \\t Best Value: {Y_bo.max().item()}\")\n", + "\n", + " # initialize the model\n", + " model = VBLLModel(\n", + " in_features=1,\n", + " hidden_features=50,\n", + " num_layers=3,\n", + " out_features=1,\n", + " )\n", + " model.fit(X_bo, Y_bo, optimization_settings=optimizer_settings)\n", + "\n", + " # Thompson sampling as acquisition function\n", + " thompson_sampling = BLLMaxPosteriorSampling(\n", + " model=model,\n", + " num_restarts=10,\n", + " )\n", + " X_next = thompson_sampling(num_samples=batch_size)\n", + "\n", + " # evaluate the objective\n", + " Y_next = objective(X_next)\n", + "\n", + " # plot the model, the thompson samples and the objective\n", + " plot_model(model, X_bo, Y_bo, new_data=(X_next, Y_next), show_opjective=True)\n", + "\n", + " # update the data\n", + " X_bo = torch.cat([X_bo, X_next])\n", + " Y_bo = torch.cat([Y_bo, Y_next])" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 6b82184e84cf3ae79c5e3c9693405ea5a4f3a9c1 Mon Sep 17 00:00:00 2001 From: pbrunzema Date: Thu, 20 Feb 2025 16:06:39 +0100 Subject: [PATCH 2/6] update notebook and base implementation --- .../acquisition/bll_thompson_sampling.py | 120 ---- botorch_community/models/vblls.py | 303 +++------- .../vbll_thompson_sampling.ipynb | 540 ++++++++++-------- 3 files changed, 391 insertions(+), 572 deletions(-) diff --git a/botorch_community/acquisition/bll_thompson_sampling.py b/botorch_community/acquisition/bll_thompson_sampling.py index 0af6d8cba3..14e78fd1ab 100644 --- a/botorch_community/acquisition/bll_thompson_sampling.py +++ b/botorch_community/acquisition/bll_thompson_sampling.py @@ -131,123 +131,3 @@ def grad_func(x): # ensure that the next point is within the bounds, scipy minimize can sometimes return points outside the bounds X_next = torch.clamp(X_next, self.lb.to(self.device), self.ub.to(self.device)) return X_next - - -# class NeuralNetworkProblemWrapper(Problem): -# def __init__(self, net, input_size=4, output_size=2, maximize=True): -# super().__init__( -# n_var=input_size, n_obj=output_size, xl=0, xu=1 -# ) # Define bounds for inputs -# self.net = net -# self.maximize = maximize - -# def _evaluate(self, X, out, *args, **kwargs): -# # Convert the input 'X' (a population of solutions) from numpy to torch tensor -# X_tensor = torch.Tensor(X) - -# # Perform forward pass through the neural network -# outputs = self.net(X_tensor).detach().numpy() - -# if self.maximize: -# # maximize the objective -# outputs = -outputs - -# # Objective functions can be based on the network's output -# out["F"] = outputs - - -# class MultiObjectiveVBLLParetoSampling: -# def __init__( -# self, -# model, -# Y, -# ref_point, -# Y_stats, -# bounds: torch.Tensor = None, -# batch_size: int = 1, -# plot_result: bool = False, -# ): -# self.model = model -# self.device = model.device -# self.maximize = True -# self.plot_result = plot_result - -# # need current Y for hypervolume calculation -# self.Y = Y -# self.Y_mean = Y_stats["mean"].detach().numpy() -# self.Y_std = Y_stats["std"].detach().numpy() - -# # need reference point for hypervolume calculation -# self.ref_point = ref_point - -# self.batch_size = batch_size -# if bounds is None: -# self.bounds = [(0, 1)] * self.model.num_inputs -# self.lb = torch.zeros(self.model.num_inputs).cpu() -# self.ub = torch.ones(self.model.num_inputs).cpu() -# else: -# # need bounds on the cpu for generation of initial conditions and scipy minimize -# print("WARNING: Bounds are not used in this implementation") -# # TODO: Add bounds -# self.lb = bounds[0, :].cpu() -# self.ub = bounds[1, :].cpu() -# self.bounds = [tuple(bound) for bound in bounds.T.cpu().tolist()] - -# def __call__(self, X_cand: torch.Tensor = None, num_samples: int = 1): -# sampled_functions = [self.model.sample() for _ in range(num_samples)] -# X_next = torch.empty(num_samples, self.model.num_inputs, device=self.device) - -# # get max of sampled functions at candidate points for each function -# for i, f in enumerate(sampled_functions): -# # create pymoo problem -# problem = NeuralNetworkProblemWrapper( -# net=f, -# input_size=self.model.num_inputs, -# output_size=self.model.num_outputs, -# maximize=self.maximize, -# ) - -# # Define the algorithm -# algorithm = NSGA2(pop_size=100) - -# # Run the optimization -# res = minimize(problem, algorithm, ("n_gen", 200), seed=1, verbose=False) - -# # if we are maximizing, then re-flip the sign of the objective -# if self.maximize: -# res.F = -res.F - -# # iterate over the pareto front and compute the hypervolume for each candidate -# hv_volume = torch.zeros(len(res.F)) -# for j, candidate in enumerate(res.F): -# # stack candidate with current Y -# Y_augmented_pareto = torch.cat( -# [self.Y, torch.tensor(candidate).unsqueeze(0)], dim=0 -# ) - -# # create dominated partitioning -# bd = DominatedPartitioning( -# ref_point=self.ref_point, Y=Y_augmented_pareto -# ) - -# # compute hypervolume for candidate -# hv_volume[j] = bd.compute_hypervolume().item() - -# # if the hypervolume is the same for all candidates, then select a random candidate of the approximate front -# if hv_volume.unique().shape[0] == 1: -# index = np.random.randint(0, len(res.X)) -# print( -# "All candidates have the same hypervolume, selecting a random candidate" -# ) -# else: -# # select the best candidate that maximizes the hypervolume -# index = hv_volume.argmax().item() -# print( -# "Selecting the candidate that maximizes the hypervolume, predicted hypervolume: ", -# hv_volume.max().item(), -# ) -# X_next[i, :] = torch.tensor(res.X[index]) - -# # ensure that the next point is within the bounds -# X_next = torch.clamp(X_next, self.lb.to(self.device), self.ub.to(self.device)) -# return X_next diff --git a/botorch_community/models/vblls.py b/botorch_community/models/vblls.py index dbcfa734e2..c5a8900f36 100644 --- a/botorch_community/models/vblls.py +++ b/botorch_community/models/vblls.py @@ -4,7 +4,8 @@ # LICENSE file in the root directory of this source tree. """ -This file contains an implemenation of a Variational Bayesian Last Layer (VBLL) model that can be used within BoTorch. +This file contains an implemenation of a Variational Bayesian Last Layer (VBLL) model that can be used within BoTorch +for Bayesian optimization. References: @@ -15,12 +16,9 @@ Contributor: brunzema """ -import os from typing import Optional, Dict from abc import ABC, abstractmethod -import random - import torch import torch.nn as nn from torch import Tensor @@ -40,6 +38,22 @@ torch.set_default_dtype(torch.float64) +class SampleModel(nn.Module): + def __init__(self, backbone: nn.Module, sampled_params: Tensor): + super().__init__() + self.backbone = backbone + self.sampled_params = sampled_params + + def forward(self, x: Tensor) -> Tensor: + x = self.backbone(x) + + if self.sampled_params.dim() == 2: + return (self.sampled_params @ x[..., None]).squeeze(-1) + + x_expanded = x.unsqueeze(0).expand(self.sampled_params.shape[0], -1, -1) + return torch.matmul(self.sampled_params, x_expanded.transpose(-1, -2)) + + class VBLLNetwork(nn.Module): """ A model with a Variational Bayesian Linear Last (VBLL) layer. @@ -122,7 +136,9 @@ def forward(self, x: Tensor) -> Tensor: x = self.backbone(x) return self.head(x) - def sample_posterior_function(self, sample_shape: Optional[torch.Size] = None): + def sample_posterior_function( + self, sample_shape: Optional[torch.Size] = None + ) -> nn.Module: """ Samples a posterior function by drawing parameters from the model's learned distribution. @@ -132,8 +148,8 @@ def sample_posterior_function(self, sample_shape: Optional[torch.Size] = None): Defaults to None. Returns: - Callable[[Tensor], Tensor]: - A function that takes an input tensor `x` and returns the corresponding + nn.Module[[Tensor], Tensor]: + A nn.Module that takes an input tensor `x` and returns the corresponding model output tensor. The function applies the backbone transformation and computes the final output using the sampled parameters. @@ -142,22 +158,12 @@ def sample_posterior_function(self, sample_shape: Optional[torch.Size] = None): - If `sample_shape` is provided, multiple parameter samples are drawn, and the function will return a batched output where the first dimension corresponds to different samples. """ - if sample_shape is None: - sampled_params = self.head.W().rsample().to(self.device) - else: - sampled_params = self.head.W().rsample(sample_shape).to(self.device) - - def sampled_parametric_function(x: Tensor) -> Tensor: - x = self.backbone(x) - - if sample_shape is None: - return (sampled_params @ x[..., None]).squeeze(-1) - - x_expanded = x.unsqueeze(0).expand(sampled_params.shape[0], -1, -1) - output = torch.matmul(sampled_params, x_expanded.transpose(-1, -2)) - return output - - return sampled_parametric_function + sampled_params = ( + self.head.W().rsample(sample_shape).to(self.device) + if sample_shape + else self.head.W().rsample().to(self.device) + ) + return SampleModel(self.backbone, sampled_params) class AbstractBLLModel(Model, ABC): @@ -178,27 +184,12 @@ def num_inputs(self): def device(self): return self.model.device - @staticmethod - def sigmoid_retrain_schedule( - time_horizon, epoch, transition_window_ratio, location - ): - # Compute stretch dynamically - transition_window = time_horizon * transition_window_ratio - stretch = ( - 2 * torch.log(torch.tensor(9.0)) / transition_window - ) # Ensures 10%-90% transition within the transition_window, see [1] - - # Sigmoid function - probability = 1 / (1 + torch.exp(-stretch * (location - epoch))) - return torch.rand(1).item() < probability - def fit( self, train_X: Tensor, train_y: Tensor, optimization_settings: Dict = None, - continual_learning_settings: Dict = None, - old_model_params: Dict = None, + initialization_params: Dict = None, ): """ Fits the model to the given training data. Note that for continual learning, we assume that the last point in the training data is the new point. @@ -221,26 +212,12 @@ def fit( - "wd" (float, default=1e-4): Weight decay (L2 regularization) coefficient. - "clip_val" (float, default=1.0): Gradient clipping threshold. - continual_learning_settings (dict, optional): - A dictionary specifying continual learning (CL) configurations. If a key is missing, default values will be used. - Available settings: - - "use_cl" (bool or str, default=False): If False, CL is disabled. Can be set to: - - `"event_trigger"`: Enables CL based on an event-triggering mechanism. - - `"sigmoid_schedule"`: Enables CL using a sigmoid-based schedule. - - "event_trigger" (dict, required if `use_cl == "event_trigger"`): - - "test_threshold" (float, default=0.0): Threshold on the log likelihood of the new point. - - "sigmoid_schedule" (dict, required if `use_cl == "sigmoid_schedule"`): - - "transition_window_ratio" (float, default=0.5): Ratio of transition window to time horizon. - - "location" (float or None, default=None): Center of the transition window. Defaults to `time_horizon / 2` if None. - - "time_horizon" (int, default=100): Total time horizon for the sigmoid schedule. - - "current_iteration" (int, default=0): Current iteration of the optimization. + initialization_params (dict, optional): + A dictionary containing the initial parameters of the model for feature reuse. + If None, the optimization will start from from the random initialization in the __init__ method. Returns: None: The function trains the model in place and does not return a value. - - Notes: - - If continual learning (CL) is enabled, the function dynamically determines whether to retrain the model - based on the specified method (`event_trigger` or `sigmoid_schedule`). TODO: Add full functionality. """ # Default settings @@ -255,34 +232,12 @@ def fit( "clip_val": 1.0, } - default_cont_learning_settings = { - "use_cl": False, # Can be False, "event_trigger", or "sigmoid_schedule" - "event_trigger": { - "test_threshold": 0.0, # Threshold on the log-likelihood for event triggering - }, - "sigmoid_schedule": { - "transition_window_ratio": 0.5, # Ratio of the transition window to time horizon - "location": None, # Defaults to time_horizon / 2 if None - "time_horizon": 100, # Total time horizon for the optimization - "current_iteration": 0, # Current iteration of the optimization - }, - } - # Merge defaults with provided settings if optimization_settings is None: optimization_settings = default_opt_settings else: optimization_settings = {**default_opt_settings, **optimization_settings} - # Merge defaults with provided settings - if continual_learning_settings is None: - cl_settings = default_cont_learning_settings - else: - cl_settings = { - **default_cont_learning_settings, - **continual_learning_settings, - } - # Make dataloader based on train_X, train_y device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") dataset = [[train_X[i], train_y[i]] for i, _ in enumerate(train_X)] @@ -291,140 +246,77 @@ def fit( dataset, shuffle=True, batch_size=optimization_settings["batch_size"] ) - # default is to always fully train - full_training = True + if initialization_params is not None: + self.model.load_state_dict(initialization_params) - """ - # renormalize the data based on the mean and std of the data expext the last point - mean = train_y[:-1].mean(dim=0) - if len(train_y) > 2: - std = train_y[:-1].std(dim=0) - else: - std = torch.ones_like(mean) - - # renorm^2 suuper ugly - x_new = train_X[-1] - y_new = (train_y[-1] * train_y.std(dim=0) + train_y.mean(dim=0) - mean) / std - out = self.old_model(x_new.to(device)) - """ - log_likelihood = 0 # -out.val_loss_fn(y_new.to(device)).sum().item() - - if cl_settings["use_cl"]: - method = cl_settings["use_cl"] - - if not old_model_params: - raise ValueError( - "No old model parameters provided for continual learning." - ) - else: - self.old_model.load_state_dict(old_model_params) - - if method == "event_trigger": - full_training = ( - log_likelihood < cl_settings["event_trigger"]["test_threshold"] - ) - - elif method == "sigmoid_schedule": - # Sigmoid-based probability - transition_window_ratio = cl_settings["sigmoid_schedule"][ - "transition_window_ratio" - ] - location = cl_settings["sigmoid_schedule"]["location"] - time_horizon = cl_settings["sigmoid_schedule"]["time_horizon"] - iteration = cl_settings["sigmoid_schedule"]["iteration"] - - if location is None: - location = ( - time_horizon / 2 - ) # Default to middle of time horizon if not provided - - full_training = self.sigmoid_retrain_schedule( - time_horizon, iteration, transition_window_ratio, location - ) - - else: - raise ValueError(f"Unknown continual learning method: {method}") - - if not full_training: - self.model.to(device) - self.model.load_state_dict(self.old_model.state_dict()) - - with torch.no_grad(): - x, y = x_new.to(device), y_new.to(device) - out = self.model(x.reshape(1, -1)) - loss = out.train_loss_fn(y.reshape(1, -1), recursive_update=True) - - print("Recurive update of the last layer.") + self.model.to(device) + self.set_reg_weight(self.model.kl_scale / len(train_y)) + param_list = [ + { + "params": self.model.head.parameters(), + "weight_decay": 0.0, + }, + ] - else: - self.model.to(device) - self.set_regularization_weight(self.model.kl_scale / len(train_y)) - param_list = [ + # freeze backbone + if not optimization_settings["freeze_backbone"]: + param_list.append( { - "params": self.model.head.parameters(), - "weight_decay": 0.0, - }, - ] - - # freeze backbone - if not optimization_settings["freeze_backbone"]: - param_list.append( - { - "params": self.model.backbone.parameters(), - "weight_decay": optimization_settings["wd"], - } - ) - - optimizer = optimization_settings["optimizer"]( - lr=optimization_settings["lr"], params=param_list + "params": self.model.backbone.parameters(), + "weight_decay": optimization_settings["wd"], + } ) - best_loss = float("inf") - epochs_no_improve = 0 - early_stop = False - best_model_state = None # To store the best model parameters + optimizer = optimization_settings["optimizer"]( + lr=optimization_settings["lr"], params=param_list + ) - for epoch in range(optimization_settings["num_epochs"] + 1): - # early stopping - if early_stop: - break + best_loss = float("inf") + epochs_no_improve = 0 + early_stop = False + best_model_state = None # To store the best model parameters - self.model.train() - running_loss = [] + for epoch in range(1, optimization_settings["num_epochs"] + 1): + # early stopping + if early_stop: + break - for train_step, (x, y) in enumerate(dataloader): - x, y = x.to(device), y.to(device) - optimizer.zero_grad() - out = self.model(x) - loss = out.train_loss_fn(y) # vbll layer will calculate the loss + self.model.train() + running_loss = [] - loss.backward() - torch.nn.utils.clip_grad_norm_( - self.model.parameters(), optimization_settings["clip_val"] - ) - optimizer.step() - running_loss.append(loss.item()) + for train_step, (x, y) in enumerate(dataloader): + x, y = x.to(device), y.to(device) + optimizer.zero_grad() + out = self.model(x) + loss = out.train_loss_fn(y) # vbll layer will calculate the loss - # Calculate average loss over the epoch - avg_loss = sum(running_loss[-len(dataloader) :]) / len(dataloader) + loss.backward() + torch.nn.utils.clip_grad_norm_( + self.model.parameters(), optimization_settings["clip_val"] + ) + optimizer.step() + running_loss.append(loss.item()) - # Early stopping logic - if avg_loss < best_loss: - best_loss = avg_loss - best_model_state = self.model.state_dict() - epochs_no_improve = 0 - else: - epochs_no_improve += 1 + # Calculate average loss over the epoch + avg_loss = sum(running_loss[-len(dataloader) :]) / len(dataloader) - if epochs_no_improve >= optimization_settings["patience"]: - early_stop = True + # Early stopping logic + if avg_loss < best_loss: + best_loss = avg_loss + best_model_state = self.model.state_dict() + epochs_no_improve = 0 + else: + epochs_no_improve += 1 - # load best model - if best_model_state is not None: - self.model.load_state_dict(best_model_state) - print("Early stopping at epoch ", epoch, " with loss ", best_loss) + if epochs_no_improve >= optimization_settings["patience"]: + early_stop = True - def set_regularization_weight(self, new_weight: float): + # load best model + if best_model_state is not None: + self.model.load_state_dict(best_model_state) + print("Early stopping at epoch ", epoch, " with loss ", best_loss) + + def set_reg_weight(self, new_weight: float): self.model.head.regularization_weight = new_weight def posterior( @@ -443,24 +335,14 @@ def posterior( X = X.reshape(B * Q, D) batched = True - K = self.num_outputs - posterior = self.model(X).predictive # + posterior = self.model(X).predictive # Extract mean and variance mean = posterior.mean.squeeze(-1) variance = posterior.variance.squeeze(-1) cov = torch.diag_embed(variance) - # TODO: may need some further reshaping for batch size > 1 - # Mean in `(batch_shape, q*k)` - # mean = mean.reshape(B, Q * K) - - # # Cov is `(batch_shape, q*k, q*k)` - # cov += 1e-4 * torch.eye(B * Q * K).to(X) - # cov = cov.reshape(B, Q, K, B, Q, K) - # cov = torch.einsum('bqkbrl->bqkrl', cov) # (B, Q, K, Q, K) - # cov = cov.reshape(B, Q * K, Q * K) - + # pass as MultivariateNormal to GPyTorchPosterior dist = MultivariateNormal(mean, cov) post_pred = GPyTorchPosterior(dist) @@ -478,7 +360,6 @@ class VBLLModel(AbstractBLLModel): def __init__(self, *args, **kwargs): super().__init__() self.model = VBLLNetwork(*args, **kwargs) - self.old_model = VBLLNetwork(*args, **kwargs) # used for continual learning def sample(self, sample_shape: Optional[torch.Size] = None): return self.model.sample_posterior_function(sample_shape) diff --git a/notebooks_community/vbll_thompson_sampling.ipynb b/notebooks_community/vbll_thompson_sampling.ipynb index 934a3f0438..ca0d7bca9e 100644 --- a/notebooks_community/vbll_thompson_sampling.ipynb +++ b/notebooks_community/vbll_thompson_sampling.ipynb @@ -7,15 +7,15 @@ "source": [ "# Variational Bayesian Last Layers for Bayesian Optimization\n", "\n", - "* Contributors: brunzema\n", - "* Last updated: Feb 13, 2025\n", - "* BoTorch version: 0.9.6(dev), commit hash: dccda59d8ef51d8074de82fdb5614bad2db0ee96 UPDATE!\n", + "- Contributors: brunzema\n", + "- Last updated: Feb 13, 2025\n", + "- BoTorch version: 0.9.6(dev), commit hash: dccda59d8ef51d8074de82fdb5614bad2db0ee96 UPDATE!\n", "\n", - "In this notebook, we will demonstrate how to use variational Bayesian last layers (VBLLs) for Bayesian optimization [1]. \n", + "In this notebook, we will demonstrate how to use variational Bayesian last layers (VBLLs) for Bayesian optimization [1, 2].\n", "\n", "[1] P. Brunzema, M. Jordahn, J. Willes, S. Trimpe, J. Snoek, J. Harrison. Bayesian Optimization via Continual Variational Last Layer Training. International Conference on Learning Representations (ICLR), 2025.\n", "\n", - "[2] J. Harrison, J. Willes, J. Snoek. Variational Bayesian Last Layers. International Conference on Learning Representations (ICLR), 2024." + "[2] J. Harrison, J. Willes, J. Snoek. Variational Bayesian Last Layers. International Conference on Learning Representations (ICLR), 2024.\n" ] }, { @@ -25,33 +25,38 @@ "source": [ "# Introduction to the VBLL Model\n", "\n", - "Linear model\n", + "Bayesian optimization (BO) relies on surrogate models that provide uncertainty-aware predictions. Usually, Gaussian processes are the goto choice due to their analytical tractability, but they can limiting for input spaces that are non-Euclidean where careful choise of the kernel is curcial. Here, Bayesian neural networks are promissing as they automatically learn the correlations. \n", + "\n", + "Variational Bayesian Last Layer (VBLL) [2] models provide a practical and scalable way to approximate Bayesian inference in neural networks. Instead of placing a prior over all network weights, VBLL only model the uncertainty on the parameters on the last layer while keeping the feature extractor deterministic. This setup allows the model to retain the expressive power of deep learning while maintaining well-calibrated uncertainty estimates.\n", + "\n", + "In VBLL, we model the output as a generalized linear model with learned features $\\phi_{\\theta}$ as:\n", "$$\n", " y = \\mathbf{w}^\\top \\phi_{\\theta} (\\mathbf{x}) + \\varepsilon\n", "$$\n", "where $\\varepsilon \\sim \\mathcal{N}(0, \\sigma^2)$\n", - "Variational Bayesian last layer models [2] use a variational posterior distribution on the weights as $\\mathbf{w} \\sim q(\\mathbf{w})$ with $q(\\mathbf{w}) = \\mathcal{N}(\\bar{\\mathbf{w}}, S)$ where $\\bar{\\mathbf{w}}$ is the mean and $S$ the full covariance of a multivariate normal distribution.\n", - "Through conjugany, we yield the posterior predictive \n", + "VBLL models use a variational posterior distribution on the weights as $\\mathbf{w} \\sim q(\\mathbf{w})$ with $q(\\mathbf{w}) = \\mathcal{N}(\\bar{\\mathbf{w}}, S)$ where $\\bar{\\mathbf{w}}$ is the mean and $S$ the full covariance of a multivariate normal distribution.\n", + "Through conjugany, we yield the posterior predictive\n", "$$\n", " p(y \\mid \\mathbf{x}, \\mathcal{D}_T, \\theta) = \\mathcal{N} \\big( \\bar{\\mathbf{w}}_T^\\top \\phi_{\\theta}(\\mathbf{x}), \\, \\phi_{\\theta}(\\mathbf{x})^\\top S_T \\phi_{\\theta}(\\mathbf{x}) + \\sigma^{2} \\big).\n", "$$\n", + "This predictive can then be used in downsteam tasks such as Bayesian optimization (BO).\n", "\n", - "## The VBLL Model on Toy Data\n", + "## The VBLLs on Toy Data\n", "\n", - "Before using the VBLL model in the context of Bayesian Optimization (BO), let's see how the interface of the model looks. The current implementation allows for passing a full backbone to the model (which could be anything). If no backbone is provided, a standard MLP is created. For training, there are also various options to include recursive updates on the last layer to speed up optimzation [1] but in the following, we will not go into detail. See the docstring of `model.fit` for the different options.\n", + "Before using the VBLL model in the context of Bayesian Optimization, let's see how the interface of the model looks. The current implementation allows for passing a full backbone to the model (which could be anything). If no backbone is provided, a standard MLP is created. For training, [1] discusses continual learning approaches which will be added to the implementation but in the following, we will not go into detail. See the docstring of `model.fit` for the different options for configuring the optimization and the training.\n", "\n", - "Below, we use the model in a 1D regression example. We can see that only...\n" + "Below, we use the model in a 1D regression example.\n" ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 1, "id": "56e5bac6", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -80,7 +85,7 @@ "Y = objective(X)\n", "\n", "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(6, 4))\n", - "ax.set_title(\"VBLL Predictive on Toy Data\")\n", + "ax.set_title(\"Some observations of a 1D function\")\n", "ax.scatter(X, Y, c=\"k\", label=\"Observations\")\n", "ax.legend()\n", "plt.show()" @@ -88,7 +93,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 2, "id": "8f382fec", "metadata": {}, "outputs": [ @@ -116,7 +121,7 @@ " )\n", " (head): Regression()\n", ")\n", - "Early stopping at epoch 6332 with loss 1.0455903860560616\n" + "Early stopping at epoch 6195 with loss 1.0684124442429037\n" ] } ], @@ -140,18 +145,18 @@ "id": "e93bb94e", "metadata": {}, "source": [ - "Now we can use the model in the same way as a Gaussian process. Note, below is the exact same code as one would use with a GPyTorch model!" + "Now we can use the model in the same way as a Gaussian process. Note, below is the exact same code as one would use with a GPyTorch model!\n" ] }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 3, "id": "e45e2cb4-5ea1-4d72-8be7-806cacf80d01", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhAAAAF2CAYAAAA/RaFTAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAfg5JREFUeJztnQd4W+XZhl9btiTLe4/E2ZNsAkmTAGGnhFFmGW0pZbWMtuzCTxktZZRSOih7t2Xv2UDC3pC997Djvbdkrf96XllCdrwj2Zb03Nd1Yuno6OjTkaLv+d4Z5Xa73UIIIYQQ0gei+3IwIYQQQgiggCCEEEJIn6GAIIQQQkifoYAghBBCSJ+hgCCEEEJIn6GAIIQQQkifoYAghBBCSJ+hgCCEEEJIn6GAIIQQQkifoYAgJAJ46qmnJCoqSnbv3u3bd/jhh+sWKG699VZ9DUJIZEABQUKCk046SSwWizQ0NHR5zE9+8hMxGo1SVVWl9zGZ+W/x8fFywAEHyJ/+9Cdpbm5u99zzzjtPEhISejUJL1++vM/jHzVqVLuxZGVlyaGHHiqvvfaahBK4bhAKH3/8sUQKeK8dv0tdbcHG/7ViYmIkLS1NZs+eLb/97W9l48aN/T5vJH6uZP+JCcA5CAk6EAdvvfWWTrjnnntupz+Ab7zxhvzwhz+U9PR03/5jjjnGd3xjY6N89tlnctNNN8maNWvkpZdeGtD3MHPmTLn66qv1dnFxsTz88MNy6qmnyoMPPii/+tWvZKB5//33+/wcXOc//OEPeruj9eL3v/+9XH/99RJuTJ48Wf7zn/+023fDDTeo4LzxxhsHfDze7zTaGNXV1el3+emnn5YHHnhA/vznP8tVV10V0M+VkK6ggCAhY4FITEyUZ599tlMBAfHQ1NSkQsOfCRMmyE9/+lPffUzUra2t8uqrr4rVahWz2SwDxbBhw9qNBe9j3Lhx8re//a1LAeFwOMTlcqllJdAE+pxYEWMLN7Kzs9t9buCuu+6SjIyMffYPBB2/097xnHjiiSpQJ02aJIsXLx7wcZHIgy4MEhLExcXpav2DDz6Q8vLyfR6HsIDAgNDoiZycHJ8JeDDBOLC63bVrl95HfALGdc8998jf//53GTt2rJhMJp9pevPmzXL66aer2RrC56CDDpI333xzn/Nu2LBBjjzySL1mw4cPV5cNREhHOouBgKiCKRuTFF4jNzdXr/uOHTt0fJmZmXocVqteUzqO7ywGYurUqXLEEUfs87oYC8QU3ov/PrznKVOm6Oti0v7lL38pNTU1vbqWH374obqE4KZKSUmRH/3oR7Jp06Z2x3jHt337dnVZ4bjk5GT5xS9+sY9Lqz/s3LlTzjjjDP184G77wQ9+IO+8847vcVjAMD64Gzqyd+9eMRgMcuedd/brtWF1e/755/U7ffvtt/v2QyzffPPN6ubAe8Xr4zp99NFHvmN6+lzXrl2r12vMmDH62eB7e/755/tchSRyCb/lAglbYF2AqfbFF1+Uyy+/3Le/urpa3nvvPTn77LN10uw4IVZWVuptWCi++OILPcc555wz6ALCbrdLYWFhO5cLePLJJ3XcF198sQoITEgQBQsWLNCJF24CTAS4DieffLK88sorcsopp+hzS0tLddKG5cJ73COPPLLPdekMp9MpJ5xwgoq0s846Syc6xJwsXbpU1q9fL0cffbS6Wy655BJ9PQgLMH369E7Pd+aZZ+okhDFh0vHy+eefqwsHr+EFYgExJpjMf/Ob36io+te//iWrVq3Szyw2NrbLcS9btkyOO+44neDwei0tLXLffffp9Vq5cqXGn/jz4x//WEaPHq2TNR5/7LHHNCYF5v/+UlZWJvPnz1chgvHjM8X3DIL25Zdf1usFlwf+vvDCC3LvvfeqYPDy3HPPqUuiowWtL4wYMUIWLlyo4qC+vl6SkpL0L94f/m9cdNFF+nk+/vjjsmjRIvn222/VrQbx0N3nis8f4gifDT5HfBfxncLfr7/+moGzkYybkBDB4XC4c3Nz3fPmzWu3/6GHHnLjq/zee++12499nW0nn3yy22q1tjv25z//uTs+Pr7b13/yySf1+d99912fxz5y5Ej3scce666oqNBtzZo17rPOOkvP9+tf/1qP2bVrl95PSkpyl5eXt3v+UUcd5Z42bVq7cbtcLvf8+fPd48eP9+274oor9BzffPONbx/OlZycrPvxGl4WLlyom5cnnnhCj7n33nv3GT9eC2DsOOaWW27Z5xjs8/9J2bJli96/77772h136aWXuhMSEtzNzc16/7PPPtPjnnnmmXbHLVmypNP9HZk5c6Y7KyvLXVVV5duH6xsdHe0+99xz9xnf+eef3+75p5xyijs9Pd3dF6ZMmdLu2nmvO96Ll4aGBvfo0aPdo0aNcjudTt2H7yiO+9///tfufNOnT293vq7Acy+77LIuH//tb3+rx+D9e//P2Gy2dsfU1NS4s7Oz212H7j5X7+fkz3PPPafHf/rppz2OmYQvdGGQkAErNqxav/rqq3bpiHBfwOR91FFH7fMcmLKxgsKGOAkEvy1ZskQtEJ7f44ENWsRqD9uMGTM0iPNnP/vZPivf0047zWdS9lpYYKLHyhkrSFhUsMGEjJXktm3bpKioSI9999131XQ+Z84c3/Nxrt6sbGHJgF//17/+9T6P9WeVCTcIVrhYcftbObAih7/eaxXBdYB5HcGB3veGDWZ3rNr9ze0dKSkpkdWrV6uJHZYaL1g943y4Hh3pGG8Ckz6uJVbr/QWvg2t+yCGH+PZh7LAi4bvqdUPBipOXlyfPPPOM7zhYd+AmCEQ8hTeTyJuthP8z3lgXuInwXYJ1Cu4vWF96g7/1ymvRw3cM9PYcJDyhgCAhhXcihGjw+o6RWQFh4W8S9oIYAPxoY4M5+Y477tCYAARRvv322wM69rlz56qQgcn9yy+/1B/if//73/u4F2Be9wc+e4gdZI94BYh3u+WWW/QYb1zInj17ZPz48fu89sSJE3scH+IccFwgXTtwY8AF4RU4SBPEWLHfCwQQsgngRuj4/hA30FnMixe8367eH+JLcI3huupo6vcnNTVV//Y23qKrcXQ1Bv9xRkdH63f49ddf98VdQEwgtgDxE/sLrhdAPJAXuFIgqPAacK3guiI2A9e8N0B0wJ0FkY7vKp7v/Y729hwkPGEMBAkpsCpFlDl8xv/3f//XL9+x11Lx6aef6kp4oMDqHkKmJzoKCm8A5DXXXKMWh85ANsdQBEIBVh9YGa644gqN24C1Aem2/u8P4sF/Ve6PvzUmEHQmNMFAWaSQffOXv/xFRQRiEyCGEXuC67K/wJqB9+ed4P/73/+qdQaxMtdee61eZ2+wJgRjb4DlC4IXz4dFCVYOfGb4DDsLziWRAwUECTkgFrAah9kXP75YcR988MG9fj5MuP6rtaEOggMBAgl7EiAjR47UFX1HtmzZ0uPrIOvjm2++0eDOroIW++rKwEQG0z7cGAh8heUHkxmCQ/1fF1YZBD32Jtiz4/vt6v0hawWiDYGkwQbj6GoM/uP0ZqfMmjVLBRMsZAUFBRr0ub/gPJ988onMmzfPZ4GAuwjfH1x3/8/Oa7nq6XOFVQZBtcjOQDaHl86+YyTyoAuDhBxeawN+0OD/7mvkOgpSAcQhhAJYNSLdEoWn4PPvSEVFhe828v8RGY8Ie//Hu1rdd4y9gMkf2Q9drc6Rnghqa2v7ZIXAmJ544gk9v7/7wrvCRWzEbbfd1qnY6+61kGaKVTHM9P7HYSWOmJOBqoeA18E1R3yOF7hOkK2ALBBUQPUHsS8YH1JX4VZAFsn+ADcDrBm4jv7FrbzWFn/rCkSi/zi7+1w7ez7AuAmhBYKEHFjVImUOQZGgOwGxdetWNeMC+JwxkWGygckfP+L+YOWN+IiOIDjv0ksv9d3HRIhAzI7AT+zvew4k999/vwboTZs2TdPxsKpE6iAmAsSBoBohuO6667RqIszLGI83jRMrYFhsejKtIyYDlQwxGSK4EJMgrAN4/whIhYUAkyEsCgiSxLXBihpbV0AgwP2CDcd3tKIg9RBpnDCrQxAee+yxagHBKheuj3/84x/takZ0BO4ATMBYeV9wwQW+NE64BLy1DIINUmbhTsM4kMaJ94nvGdJREZyK2Ad/EMSLzwqVVZE+2V2aalffaUzqCPz0VlWFRQ3pof7uIbhGYH1Aeubxxx+v43nooYf0M/S3wHX3uR522GFy99136/8PpBFD+Hhrl5AIZ7DTQAjpD/fff7+mkc2ZM6fLYzqmbxoMBvfw4cPdF198sbusrGyfNM6u0j7Hjh3bLo2zq62wsLDbNM7jjz++2/fkTeP8y1/+0unjO3bs0LTEnJwcd2xsrHvYsGHuE044wf3yyy+3O27t2rWaEmg2m/WY2267zf3444/3mMbpTdm78cYbNf0Qr4HXOv300/W1vXz55Zfu2bNnu41GY7vUv45pnP4sWLBAH7vwwgu7fP+PPPKInjcuLs6dmJioaavXXXedu7i42N0Ty5Yt09fAc5EGe+KJJ7o3btzY7hjv+JCy6I/3c/W/Nn1N4wS4RrhWKSkpeu3x3Xz77be7PMfixYv1dXE9e4v/9w1pqnitWbNmafrmhg0bOk2/veOOO/T7ZzKZ9FiMCd937POnq8917969muqK10I68BlnnKGfSVdpnyRyiMI/gy1iCCEk0oBVYN26dZplQ0gowhgIQggZYBDLglTKjm40QkIJxkAQQsgAgdgB1MVAeWnEPSD2g5BQhRYIQggZIJBmCasDhASCLP17hBASajAGghBCCCF9hhYIQgghhPQZCghCCCGE9JmwC6JEbfbi4mIt6MM+9YQQQkjvQVQDurmia2zHAmhhLyAgHvLz8wd7GIQQQkjIUlhYqL1aIkpAeEsJ480nJSUN9nAIIYSQkAHl0bEI701Z/qAKCNS2Rx12dKRDrXX0L/jzn/8sEydO7PZ5qOuObou7d+/WTot4Tm+b4njdFhAPFBCEEEJI3+lNCEB0sHOeL7vsMm1gtHTpUm3GgkY5aNDTFeg7j65yaIqzatUqbf2LDd31CCGEEBKBdSDQVhitiSEs0OGtM9DqFwLj7bff9u37wQ9+oC170UWuN+YXdOGrq6ujBYIQQgjpA32ZQwc0jRMDAmgV2xVoT9yx3e+iRYv26V9PCCGEkMEjZiDTK6+44gpZsGCB9pjvitLSUsnOzm63D/exvzNsNptu/uqJEEICgdPpVNcrIeGE0WjsMUVzSAkIxEIgjuHzzz8PeKDmH/7wh4CekxAS2cCzi0VLbW3tYA+FkIAD8TB69GgVEkNeQFx++eUa0/Dpp5/2mFeK5jJlZWXt9uF+V01nbrjhBrnqqqv2SUEhhJD+4hUPiNmyWCwsSkfCrthiSUmJjBgxYr++2zHBVvG//vWv5bXXXpOPP/5YFU9PzJs3Tz744AN1d3hBBgf2d4bJZNKNEEIC5bbwiof09PTBHg4hASczM1NFhMPh0LbyQ1JAwG3x7LPPyhtvvKFFKbxxDIjwRF0IcO6558qwYcPUFQF++9vfysKFC+Wvf/2rHH/88fL888/L8uXL5ZFHHgnmUAkhRPHGPMDyQEg4YmxzXUAs74+ACGoWxoMPPqiZF4cffrjk5ub6thdeeMF3TEFBgZpSvKDYFEQHBMOMGTPk5Zdfltdff73bwEtCCAk0dFuQcCUqQN/toLswegKujY6cccYZuhFCCCFkaMJ23oQQEmGMGjVK/v73v0u4gIUoVtXMmhlYKCAI6aU1zWp3Sl2zXcrqrbKnqkk2ldTL+qJaWbu3VlYX1MrKgmrZWFynjxXXtkhlo02abI5eWeIICRRoJHj++edrO2b4ukeOHKmxZVVVVRIOwCXuH2TvdX3DFY74OjJwhF03TkIChcvllgarQ+qtdqlotOptu8MtLrdL3O4oiTFESXRUlHi9iVgB1bjs4nS5RSWD2y2mGIMkmGMkI8EoieZY3Ywx1O2RAoLUPvvsM53cEP916KGHisFgCNrr7dy5UzPWJkyYIM8995xmvm3YsEGuvfZa+d///qd9ibqrBBzM64D/H4EoXtQZEEpdpfqT4MFfMkI60GhzyO7KRvl2d7UsL6iWDcV1Ut/sEHOMQTISTJKbbJG8lDjJSjTr/fS2LS3eqPtyk+MkD1uKReJNMdJkc8qWsgZZWVAjy3dX67lhmSDhDToRw1VwxBFHyDnnnKN/cR/7g5n5hsn0/fff12w25Pkfd9xxsmzZMikqKpIbb7zRd2xDQ4M2LoyPj9dMuPvvv9/3GKxmt956qz4fafKwZvzmN7/xPY7qv9dcc40+D8+fO3duu3i2p556SlJSUuTNN9+UAw44QM/x2GOPidls3sfNAOvIkUceqbdhJcGYcF5kwUybNk2FkJfzzjtPeyn94x//UEGCDV2bO3NhvPLKKzJlyhR9bVx3ZPb5g3133HGHWmuQJYj36p/t19raqjWMIPwwblhyvNmCxAMFBCFtP5g1Ta2yuaReVuyuls2lDdLqcElqnFGGpVhUIFiMMWKI7lv0sjnWoMIiL9kimQlmcblFzw0hgdeqbW6liyMMgUg4/fTTZe/eve32YxLH/mCIiOrqannvvffk0ksv9aXJe8Hq/Cc/+YlmwHm/b3/5y1800w1dj6+//nqdyFFzxzv5/u1vf5OHH35Ytm3bpplwmMy9YGJFfyKk2a9du1aD3n/4wx/qsV6am5vlz3/+swoHWEHw+hAVOLe/ZQJjwmPAarXK7Nmz5Z133tHKxRdffLH87Gc/k2+//VYfh3CAheWiiy5Sqw62zgoHrlixQn784x/LWWedJevWrVMxdNNNN6mw8Qei4qCDDtJrgOt2ySWXyJYtW/Sxf/7znyqAXnzxRd33zDPPqOgg30MXBol4IBwKqpulotGm7oeUuFhJiw98cTKIj+S4WN2aWx2yp7pZiutaZHiKRfLTLBJnDJ5pmwwcmBQxGXcmDLEPK2X48H/0ox8F1J2ByRvnnzx5cqePY39NTY12RQboSwThAODy+OKLL1Q0HHPMMZpeD9GBxoaoE4DV+Zw5c/RYPPbkk0/qX1gmAKwRS5Ys0f1Y1XvraTzwwAMqUrxgQkea/gUXXKD3UTQQVoPTTjtN78PygHN5QSFCiCJM4nh9xDjAwgLrRHcui3vvvVeOOuooFQ3e97dx40YVTbBieFm8eLEKB/C73/1O3/9HH30kEydO1Pc3fvx4OeSQQ/QzgwWCtIcWCBKxYBLfWtogqwprpKLBptYGuB5gaQg2eA28VoIxVnZWNKp7o6i2RQUMCW0Q89DR8uAPJnkEOuK4YNBbi1bH6r64v2nTJr0Ni0JLS4uMGTNGV/uoJoyqhQAreogkTMoJCQm+Da6FHTt2+M6HiX769OntXgOWBrgbUAURYFWPgoGwTACc97bbblNrB2I1cF4ICEzmfQHvAwLJH9yHyMJrePEfH0QCREl5ebneh9BYvXq1igm4b+AWIu2hgCARh8PpksLqZlm5p0Z2VjbpJJ6dZB6U4EZYHRBPgYDN9UV1sm5vrQZtktDFvzBeII7rLePGjdNJ0CsCOoL9qampWsa4J+AWgNkeFgS4Q7BKP+yww9Sq0NjYqJYTuAkwwXo3nB8uBi94XseCRQcffLCMHTtWXR8QKBAmXvcFgIUA54A1AJYAnHfRokUajxAMOlZhxHjRKwIceOCBsmvXLhU0GCtcInA/ke+hC4NEFA1Wu+ysaJLS+haJN8ZKXrJ50CsO4vVTLEZJcLrUjYIgzgnZiZKVZB7UcZH+gaC7QB7XW9C3A+4HTPpXXnlluzgItBHAah+tA7zfd2Rk+IP7/u4PPP/EE0/UDcGZkyZNUuvDrFmzdBWPlTqySvoKBAPGgsaKyMqABcIL3Chw7fz0pz/V+5jMt27dqoGY/pYNfytCZ+B94Fz+4D6sJn1xGyUlJcmZZ56pG8QD4jwQazIYmSxDEVogSEQAs25JXYusLqyV0nqrZCWYNRZhsMWDPzGGaMlJihOnS2RtUZ1ma9ClEXpgUsXk2NV3C/uxwu/P5NsT//rXvzRDAqt2dD+GqwSxCRAWiC+4/fbb202od999t07QyMB46aWXNHYDINjw8ccf10BGpIb+97//VUGBOABMwhABECMIBsUqHUGOyFBA8GNP4LkrV67UsWBS9m+GiJgDBHJ++eWXatH45S9/uU93ZgQyfvPNN5p9UVlZ6bMY+HP11VdrfAWsB3h/Tz/9tF4b//iKnkAcBTJANm/erOfA9YGLw+tuIRQQJAJAAajNpfWybm+doEADYg8wWQ9VkLWRYIyRzaWNsqW0XsdPQgescL2m/I4iwnsfVSCDUQ8CEzCaDyJ2ASZ3uAuQyYAUUmRN+K+cMcniWFgU/vSnP+mECeEBMEk++uijGjeAOAGkgb711lu+7qQIloSAwDkQI3DyySfLd999p8GWvXG1ICAS2Rv+7gvw+9//Xl0HGAcKRmHCxrn9gQjAtYNVAu6YzuIjcA4EXsJVgj5KN998s/zxj39sF0DZE0jthMBClgZcLxAs7777btBqWYQiUe4wyyGrr6/XSF008YL5iUQ2cFlsLWvQIMn0eJOmVYYKSCNFASvUlZiYkxhSYw9lkEqIVTWKMCH/v79gdY4VvX9AJSwPEA+nnnpqgEZLSGC/432ZQxkDQcKWqkabigdUkIRroK81HAYbBHVi3HC9YOEKEYHKliQ0gEiAP38gK1ESMpBQQJCwA0Y1xDkgRdPhcktO0uAHSvYXiJ7sRLP21kDZbARXshR26ACxAFM8IeEIBQQJO/GAZlbby5vEFBMtWYmBLwg10CBeAyWy99ZARIiMz06U2CEcw0EIiQwoIEjYgFoKu1U8NEqSOVb7UIQLEAwQQ6iYqe6M7CSJDjGXDCEkvOAyhoSNeNhV6REPSM8MJ/HgLyLQvKugqln21jQP9nAIIREOBQQJG/Gwo8IjHgaiFPVggSBKtATHe0WQKCGEDBYUECSkiSTx4AUCwu2Okm3ljdrPgxBCBgMKCBLSAZMF1ZElHrxkJBi1FThcNujtQQghAw0FBAlZSuqsmm2BFXkkiQeAtFRveueequZed2AkhJBAQQFBQhJUlkSdB1RnTAjDgMnepnemWoyyq6pJKhuD062QkGBx6623ysyZMyXU2b17twp6dA4FaFeO+7W1tf0+ZyDOMRBQQJCQA6Z79IgAcF1EMrC8REuUpq/aHOyZEemg1wMmHmzoWom+E+gB4XDsf6xMoCc19LRAw6twY/78+Vp5FOWgewMKjV1xxRX7dY7BggKChBRodb25tEGsdpekJ4R+kahAkJ5glKrGVtlb3TLYQyFDALScxuSzbds2bXaFlf5f/vIXGSrA3QZBk5CQ4GvO1V/sdnvAxhWocxmNRm0Ctj/VbwNxjoGAAoKEVHOp7WUNUtdsD4sKk4ECJa5TLbEaUFrTRFdGpIP22Jh80Hr7kksukaOPPlrefPNNfaympka7aKamporFYpHjjjtOhYaXPXv2yIknnqiPx8fHy5QpU7QDJcz06OgJ8BgmNm9nS7TTRitvNGZCy+8ZM2bIyy+/vI/l4n//+5/Mnj1bx/f555/v48LAeWAtQSt0HIPH0Iq8o6vghRdekIULF2oTqGeeeabTa4DjHnzwQX1/GBO6k/qPqbtzPfbYYzJ58mTdN2nSJHnggQfanRuty9HB1Gw2a6fOVatW9WipQet0WBpwzXH90G0UnwWu4SeffKLdW72WI4zN/xxoboX3gOvnz2uvvaYdQ5ubPTVh0LodHVjRSRVdV9GHBecKJhQQJKTSNUvrbZIdwr0tgunKcLlFdlY2ip1ZGUFZNSNldjC2/Q2QxeTT2uoRlpiw0MIbggLtvXHuxYsX+1bfl112mdhsNvn0009l3bp18uc//1ktBegi+sorr+gxW7ZsUQuHt2U5xMO///1veeihh2TDhg1y5ZVXyk9/+lOdGP25/vrr5a677pJNmzZpi/CO4Hx//etf5Z577tFW35hkTzrppHYCx3sedDnFebztxzvjpptuktNOO03WrFmjbcPPOussfU5354KIQOvv22+/Xffdcccdep6nn35aj29sbJQTTjhBW4mvWLFCRRBcMd2B2IijjjpKn4NrDvEEkeZ0OvU9z5s3Ty666CK9pthwrf1BR0y85rPPPttuP8aKVucQJfj8MH4ICjRvg2DB5wZrlPezDwaRGX1GQo7iuhb186fHG0Ouq+ZAgXblpfUtmpkxMj1+sIcTVrTYnXLAze8Nymtv/OOifmUZQRwgxuC9996TX//61zoRQzhgcoGP3TsJYcJ6/fXX5YwzzpCCggKddKdNm6aPY+XuBatakJWVpatcALGBSXbZsmU6EXqfg0ny4Ycf1tW9F1gXjjnmmC7HC+Hwu9/9Tid6APHy0Ucfafvz+++/33cc4gV60w4d7+fCCy/U27fddpssXbpU7rvvvnYWhY7nuuWWW1TEePfBqrJx40Z9Lz//+c91Eoel5PHHH1cLBCw0aNcOS09X3H333Wqp8H9dPM/fXQERAKtRV0AA/exnP1NrA46FVeKdd95RKwSAJQXjgvXEu7h68skn9XOCNePYY4+VYEABQYY81U2eegcJxhjNuiCdA2GVbDbK7somSbEYIz7ANFJ5++23dfWJVSkmlXPOOUdXyhATMTExMnfuXN+xiEGYOHGib2X+m9/8RifD999/X10fEBOdWQu8bN++XSe1jsIAq16Y+f3BJNoVmBCLi4tlwYIF7fbjPiwIvT2PP15B43/fmynR2bmamppkx44dcsEFF6hFwAviNbzBjF7rCcRDV6/TEbwmxMz+ACtRbGysCkAILFiDYJnAZwRwjfBZwALhj9Vq1fcULCggyJAGJtytZQ3idLklPZ4TYk8kmGOkuM4uhdXNkpSXRFdPgIiLNaglYLBeuy8gVgH+f6xs8/LyVDT0FqzYYQrH6hYiAu4JrMhhwegMmPQBjh82bFi7xxDH4A9iKgJBoM7T8Vze9/Loo4+2E1netuz740LaX/BZnn766WoBgYDA3zPPPNP32WLsiC/pLCYkMzNTggVjIMiQBaIBloe6llbJZMZFr4Gbp7TOKlUMqAwYEGJwIwzG1lcRiEkR6ZsjRoxoJx4QGIjV9DfffOPbV1VVpTEN8M97gUvjV7/6lbz66quaxYEJ1TuJAfjuveB5EApwfeA1/beOvvzuwGoaYgfuFX9w339sfeHrr7/e5z6uQVdkZ2frGHbu3LnPe4ErA+D5iM/Ayr6r1+kILBbdpaviuvpf0+7cGAgqRZzJhx9+qPe9HHjggeqignup49iDmQpKAUGGLOg4WVxrlcwEBk32teEWrtbe6mYVYYSA8ePHa2Q+zPOIUYDZG8GOsBxgvzcmADETu3btkpUrV2oMgnfSRVYH/h/CRVJRUaGrXpjMEUSIwEkEGsJcjuch1sAbeNhbrr32Wo17gD8fogYBjjD/I8ixP7z00kvyxBNPyNatWzW2AdkTl19+ebfP+cMf/qBWl3/+85/6PASSIpbg3nvv1cfhDsI1wDXcuHGjZqggdqM7brjhBvnuu+/k0ksvVfGxefNmtRBVVlbq46NGjVJRh4wJ7IPbqTMOO+wwjZOAcICg8beSYF9GRoZ+jgiixOeH2Ae4pBCjESwoIMiQBOmIuyqaJNkcq22sSd9IizdKeYNNK3YS4gWTIUzdiOqH7x6BlpgE4V8HWAkjEwOiARH8EyZM8AX/QWhggsXEjtW6dzJGgCIyFTDxep8Hl4Z31d5bMNldddVVavVAECdW2/D5Q/j0B4z1+eefVwsAskSee+65Hq0ZcOEgEBHXCWNAEOhTTz3ley+ILXnrrbdUWMyaNUtuvPFGFT3dgWsIdxAE25w5c/S6v/HGGz7rEAQYXCQYG9wNsOZ0BoTL2Wef7csq8QeBlcicgdUJAaD4HBDLAUsJrDvBIsodZkX0EYwDk01dXV1QLxwJHqiouHZvndZ7QMom6R9o920xGWRmfqoYYyjCegt+dLGCw6ThHyxHQgdMtshQQJoj6dt3vC9zKIMoyZACenZPZbNOfjlJ+x98tD+43G6NJdhZ2aQppBgTKj4iKwSbzenS8UKC41j0pkiJi5UUS6ykxBnVCjAq3SKjMxNkdHq8xBkHNoMEmRhI6yyrt0p+mmVAX5sQEv5QQJAhRVm9TfZUN2tNg4Gu94B4AWR8rCiokfVFdVq4qrnV2adKmXAbYOsI3kluslmmDUuWg0alyYzhKUEXFLh+CSZUqGyWzEQTU2AJIaEjIOCTQQ12VOxCha2eTEoI+vCWS/UHz+2uyAYJn5TNHRWNYjRED9hkZ7U75eudVfLNrmpZXVirvTb8iTVEaVGmMRnx6k5BhkNa24b0Ok/5WY9AaHW61O1S02LXhl+IP4AIwYaMiOI6q27vbSyTmOgomTosWeaPTZeFEzKD1o48SdM6PcWlxmQmBOU1CBlqhJlnPjIFBApzoC76+eef36vKYV4Qgevve0FqCgn///AogFRvtcuw5Ligv9am0gb5YFOZfLatUqsMekFr8FkjUmRmfopMyEqU4alx6proLbldjL2uxS7b2qwby3fXSGm9VQULtie+2CULJ2TJD6fkyLiswE7yEDhJ5lgpqm3RsQ20G4UQEr4EVUCgkQm2vuJfKpVEBjD7Y5JDvYdgpWyiR8SHm8vltVVF+lpespNMcviELDloZKqMz04MiusEVSHhusB28aFuff1vd1XL0k1lsremRd7bUKrbxOxEOWfOCBUxgboOEEWwQpTVt8ioDFohCCFhHAOBLmyosT516lQtwdqxvCkJL+BGQMpmbHS01jAIhmtkyfpSeWN1sVQ3e4ormWOjZcHYDDlqcrZMyUvSjpYDBYTB8FSLbqfMGibri+t1fF/uqJQtZQ1yy1sbNFbi5/NGycScxIC8XqIpVvbWWiUnOY6xEL2kq3x8QkIdd4BcPENKQOTm5mpHN9Qnh4BAPi5aoKLIBiptdQaOw+afgkJCz3VR29IqeQF2XcDi8OaaYnlpRaE02TxuCsQwnDxrmBx7QHbQ4g76OrlDLGCrbR4tr6zcK2+vLZF1RXVyzctrZN6YdDn/kNGSs5/prIkaC2HVjAw22uoeVAaMjo7W3gzIy8d9FjIj4fSbW1FRod9pb/2PIV8Hor95uSjkgeIY//nPfzp9HBYKFAzpCOtAhAblDVZZW1inJv5ArYzxlf5yR5U8+eUuzeoAw1Li5LQDh8nhE7OGfGEqXJPnvy2UDzaXaYtuBGtedOhoOXpy9n5NZIjDwNNnj0ylFaIH0AwKwdtoFEVIuBEFK+jw4VoYqyN9qQMx5AUEypui7Cr6qPfWAoEa7BQQoVEwak1hrVoHMgLU62JnRaM88tlO2VDssUQhW+LcH4xU4RBqbcCRfnn/R9tlY4nnvcwdnSaXHzFO6zv0B/xXRyzElLxk1oXo5fVC74je9CkgJJSA5aGrBmFhVUgKtdDh2ugKNHLp2PWNhAZ7q1s0vTEQrgu4K15cXigvrdir9RxQefHUWcPktAOHh+xqe0SaRe44ZZq8vrpI/vv1Hk013Vy6Sq44arwGY/ZHxMcbY7THSFaSKSjxJuGE18S7v2ZeQsKVoAoINFtBj3IvKJ0JQZCWlqZuCTQZKSoq0jrl4O9//7uW1pwyZYqW2kQMBLqOoY44CS9gTi+sadaKjfsbwIjaEX9ftlV2V3nMzaitcOEhY7R4UqgDqwlE0IEjUuXepVv0Pd72zka54JAxctKMvD6fLykuVkrqWrRGBYI4CSFkSAqI5cuXtysMhUYp4Oc//7k2KIGP0b9xCPyOaKQCUYHmIGiCsmzZsk6LS5HQxeVyy56qJq3ciIqT/QWWBlgdXlheqLdRNOmSw8fJIeMyJNwYnREv9/54pjz0yQ55f2OZPPrZThUCEEp9cc1ArCF4FKmjKIw11ONBCCFDFzbTIgMOMgEQ+4C4h/5OYKj0+Jf3t2jTLbBgbLr8auHYfscHhAr47/rqqiJ56svdev/gUaly7bGT+lQgCmKrrMGq5bRzktksihDSvzmUyw8y4IGTKO2MctX9FQ8IKvztC6tVPKCew9XHTJDrj5sc9uLB65eHS+P6H07Sa/jd7hq54bW10mC19/ocsFjguUW1zSomCCGkP1BAkAEPnKxttktqvLFfq+83VhfJ/722Trth5qfGyb1nzNQMi0hjwbgMuf2UqZr+uqOiSW59a4MWzOoteF51k11q2gprEUJIX6GAIAMeOInJq6+Bkw6nS+77aLs89vkuXTUfNj5D/nrGzIhOR5yUkyS3nzxVi0RtLWuUP769Uat69gav9QdNtsLMi0kIGSAoIMiAgEmqsLpZbA6X9mboC1hZI/Ng6cYyQbwgiipdc+xENoYS0aqSfzxpqliMBq19cfu7mzQ4tTekxMVKZaNN6lt6b7kghBAvFBBkQEC9h9I6q5aS7tPzGm1yw6vrZGVBrZhiouXGxZPlpBnDWFrYD3TwvPXEKRoPgu6ef16yWS02PYH6GHaHW0rrv28sRgghvYUCggQduBwKqpoFU35fihfBYnHtK2tlZ2WTrpZRVGnO6PSgjjVUmZybJDcdf4AGR367u1oe/2JXr54HdxJaizfZaIUghPQNCggyIL0dKhqsWla6t6BOxA2vrdOCR+hj8ZfTZ8iE7P3vTBnOTB+eItcsmqi30ZDrg01lPT4n3hQjLa1O/XwIIaQvUECQoKdt7qlqFnNsjMT0Mm0T3TmRaYGgyzGZ8XL3adNZr6CXoHvn2Qfn6+37P94u28oaenxOQlur794GYBJCCKCAIEEFcQ8o+pRi6V0/gV2VjfJ/r6+TeqtDxmUmyO0/mqbll0nvOWvOCJkzKk3sTrfc8b9Nev27AxU8m6x2jVMhhJDeQgFBggayJxDHkGjqXdomOmne+Pp6abA6ZHxWgtx28lRJMA/5fm9DDlzrq46ZoK6fysZWuauHoEoEpMJCVFTT3KvgS0IIARQQJGgU1bRIo9WhdQp6c+xNb3jEw4TsBPnjj6b2Od2TtI9tQMZKXKwnvfM/X+/pMZgSBb6qWViKENJLKCBIUKi32qWotkXLS/eUclnT1Co3v7ne57ZAXQOKh/0HRbauOHq83n5tVZGsK/L0DemqvLUhKkpKaq0sLEUI6RUUECQoFNe0aAAlVsI9uTlQhrm8wSa5yWa55cQDenwO6T3zx2bIMZOzBZIALc+7K3cNsVfRaFNLBCGE9AQFBAk4yJ5A8GRKXPdpm3anSysneus8/OGkKRHREGugufDQ0ZKVaFKRhjbgXWGMidZW6+iWSgghPUEBQQIKzN/o8oiS1RZj15YEl9utK2J01ISf/pYTp0huctyAjjVSwOdw5dETtJDXsk3l8vXOqm5jISAgGllYihDSAxQQJCjWh56KRr3wXaF8uq1SYqKj5IbjJmk5ZhI8pg5LlpNnDdPb//poe5epnRAbLXanVNAKQQjpAQoIElDrw96aFnE43dpnoSuwAn722wK9fdnh42TWiNQBHGXk8tO5I2VkmkVFHopMdQXSbovqWFiKENI9FBAkYCD4Dn0VUruJYyiobpZ7l27V2ydMz5WjD8gewBFGNohxuPrYCZpx8fXOavmqC1cG0m5ZWIoQ0hMUECRw7bprmgXh/l1ZH+BXv/2djWoinzYsWS5YMHrAxxnpjM5IkFNmelwZj3y6o9OsDBaWIoT0BgoIEhBqmu0a5d9VyWp05Lzn/S1SXGeVzEST/O6Hk3rdG4MEljMPzpfsJJNWqXz2G48rqbNgStTnoBWCENIV/AUnAbE+FNe2qPWhq3bdLy4vlBV7atSMjgqJmKBCAQgfpJsiHgCrdVhRGqx2qW+xayyBd6tv2/A4jsPxrQ6XPn+oAQvRrxaO1dtvrS2WHRWN+xwDN0eswaCfK1I7CSGkI6zYQ/YbTKBlDdYuRcGG4jp5/rvvgybHZg6djAtM8Ch4hcZTEAoIAEWKaVQUJs0o7SsBQ0l0W6VGiYpS1Y373gKbvsKNbk96qsPl1kkX+x1ut74GDsV9nC/WgC1aNwgqTNYDzUEj0+SQcRny+fZKzcq45/QZ+4wD1iRYKVDeOiPBNOBjJIQMbSggyH6DVaqzi8wL9MK45/2tgkXskROz5MhJWTJYYCJH/IUNm8OlIiE6yjOJY0uKM4rFaFArCu4jxTQmOloMBvz1iAnMsVF+f/2tMO42AeFq+4vXg5hAHIHDz5LRZIM1wyktDofUW72CRcRoMIg5NlpffyBExUWHjpGVBTWyvbxR/re+RE6YntfucQicqLbPNz2+55LkhJDIggKC7L/1oYvMC0yq9320TSobPWWqf7lwzMALhlanNLU69DYmZUzQqfFGXV1D8JhjDGLSSTt6vyZIPBdP90y5PQMLRavTJTa7S0VNo83jCoGwQB8RjBdjizMatNBWMCZv1Oo49wcj5aFPd8q/v9ojC8Zm6LXxB1YlfH71LQ5J7mVLdkJIZEABQfaLktoWaXW4xZywr/XhvQ1l8uWOKp24rz12YreVKQMF4g4Qh9Bid4ghKlriTAbJSzVrWe14Y4xOyLAuDDZwgZijYXEwSLJgYjbrfrhTYKGA5aaqyaZiorbFru4TpFcGWkz8cGqufLC5XLaVN8rTX+2WK46e0O5xjA8ujJK6FgoIQkg7KCBIv8HkhroPnWVe7Klq8vVdwCp3fHZi0MYB1wAm3Ga7U2JjoiTZHCujMiySaI7Vrp5DQTD0FrgvsME6MCLdohYUXOfKBptmRNS2tKpbBZaBrgJW+wLE3S8PGyvXvLxGhcRxU3NlYk77zwp9SmBlGp5mYZdUQogP/hqQflPWVq0wPb59gB3M739btlVN9LPyU3wllAMJ3CNNbZMrVudJcTEyMsOizbgSTTG6wg8H1IVhNEh2klnFhNdlVNlkE4ejVZLiYiXeuH9WCQgGxKZ8uLlcHvlsh/zl9Bka7+EFliOkdOLzTmDJcUJIGxQQpF/ATVBc19Jpx81XV+2VHRVNulqFSdx/MtpfEJBYb/W4KND2e0xGvGYIYEUeLqKhZzFh0piE8garWoCK6+x6rZPMMf0WEj+fN0q+2lElW8sa5aPN5XLU5PYVQiFU4MbIS4nTMRBCSOjYdsmQorzeKi02p07i/uytaZbn2vpcXHjI6B6bavVFOFQ02KSi0SYWk0GbQyEVEa4RBP6Fu3jwByIB8Qh477gGk3PhcnCroOtvF018TmcdnK+3n/pq9z4VKiFQcG6IFkIIARQQpM/AbYHUPsQY+IN0xH9+uF1rKhw4IjUgKZuIb8CkBeGQbImRGfkpeu7hqRauhNusEiPT42U2xFRWorQ6ndpOvT+NsE6ckSd5yWbtaYJuqR1FS4IpVpulsckWIQRQQJA+A0sAVqPICvDnnbUlsqmkXjMFLjti7H755SFGqptaNYUQq+OZ+SkyMz9VYwEGo/BSKAiJsVkJKq5Gpls0c6Oq0aaxIr0FdR9QGwK8uaZYimpa2j0OFwmqcOLzJ4QQCgjSZ4tAUW2LBtb5CwQE9v376916++fzR0lWoictsT8go6Kkzqr1GaYPT9Eti8KhV8AqNCknSWYMT9YUTPQeQWpobzloVJocNDJVC1898cWudo/h88bnDmGBdFlCSGRDAUH6RFVjq2YCJPm5L7DKvf+j7WK1u2RKXpIcNzWn3+IErpFWl1Mm5STIrBEpkpNM4dBXMNFDcMHdMyI9Ti05Nc29b4p1/iGj9Zp/u7taVhfWtnsMwap1Vo9liBAS2VBAkF6D9Ez4142G9v0bUCxqVWGt9nj4zZHj+5V1AVFS0WCVYalxaoYflZEQkDoHke7WmJSdJNOGJ/usRL1xaeSnWmRxmwh8/POd7RqC4bM1x8RosCxbfRMS2VBAkF6DVWx1k71d0ywE1D3eZuo+7cDhmubXFzAJIXsAMQ9Th6fIAblJ+wRnkv6D7JTc5DiZPjxZEswxUlLf0qsOoWfPGaGZF7urmmXpxrJ2j+Hz98SnsNU3IZFMUAXEp59+KieeeKLk5eWpWfX111/v8Tkff/yxHHjggWIymWTcuHHy1FNPBXOIpK8tu9uC7by8unKvBtVlJppUQPSFJptDu3jmJJll5ogUGZYSF1HpmAMJCmxBRGQnmlVE9BQXARF39hxPWud/v9mjn5UXWJ9gHYIVYii2KyeEhIGAaGpqkhkzZsj999/fq+N37dolxx9/vBxxxBGyevVqueKKK+TCCy+U9957L5jDJL11MTTatKyxF5jEX1lZpLcvWDC6026cXYHKho2tDpmUk6hxE/4xFSQ4IADygLxkGZVuUetBT+mYi6fmqqjDZ//SivZpnSltVghkehBCIpOgVqI87rjjdOstDz30kIwePVr++te/6v3JkyfL559/Ln/7299k0aJFQRwp6QmIBUeHplmPf75Ly1VPH5Ys88em9+o8cFXAYoGumNNykzUtkwwc6AsyITtJ+2mgWijadHcl/GIM0XL+glFy2zub5I3VxfLDKbka1Op9DOcorGmW9AQTA10JiUCGVAzEV199JUcffXS7fRAO2E8GD1QlRMlk/9gHROd/tbNKMG9cfNiYXtV8QJYFuneiiuK04SkUD4MEJvsxmQkyNjNeG3R1Z4k4eFSapoQirfOpL9undaKJmlohmmiFICQSGVICorS0VLKz29fgx/36+nppaWlf1MaLzWbTx/03EljQCRKNnLxlqxH4+Ehbp83jp+VqJcSeQN0AVJRER8dpw5LbiREydEUEhOEFh4wRyMMvdlTJ5pLv/38hFgZZGcU1LeJiLAQhEceQEhD94c4775Tk5GTflp/vCfwigUFrM9RZJd74vbdr6aYyKaxu1sqE58wd2eM5ELBX0WjV9tTo/NiXWAky+CJidEa8HN3WXAvFpfxTQVMtRqlohBWCGRmERBpDSkDk5ORIWVn7lDHcT0pKkri4ztMDb7jhBqmrq/NthYXtg73I/gETdW1zqy+1EpPM898Wtkv16w4cj6JDo9LjZUJWYrsMDjJ0RAQCK+GK6Kq2w0/mjtD4iU2lDeq68oLPE9YJZOjQCkFIZDGkfs3nzZsnH3zwQbt9S5cu1f1dgXRPCAz/jQQGrDQRs2A0GHxBcm+vLZHq5lbJSjTJoindV5yE2wPHjs1M0M6RCLwjQw98tuijgRoeZQ02DXTtCAIlT5k1TG8/9eVutUx5Qa8SBMbisyaERA5B/UVvbGzUdExs3jRN3C4oKPBZD84991zf8b/61a9k586dct1118nmzZvlgQcekBdffFGuvPLKYA6TdAG6MlY2tfriFdCj4uWVHuvDT+aO7NaaAMtDdbNNzeMQEIzSH9rgs5yQnSgZCUaNVemsYuWps4Zp+ib6lCxZX9ruudJmhehL8y5CSGgTVAGxfPlymTVrlm7gqquu0ts333yz3i8pKfGJCYAUznfeeUetDqgfgXTOxx57jCmcg5i6iUJBMF2DV1ftlSabU0amWWThhMwun4fVaXWTTcZkJOjG4lChAWJTJuQkar2IzmIasP+cuSP09nPfFWhHVv9YiPJ6m7q8CCGRQZQ7zJYMyMJAMCXiIejO2L/Uze92V4vJYNDsC0wMF/1nuWZT/P74yTJ3dOd1HyA4SutbZHiqRYtE0W0ReiBmZX1RndZ56Jgtg8/318+tlMKaFq08et78Ue0EZ1aSSbNs9qeVOyEkNOZQ/rqTXqVuPv9dgYoHiII5o9I6fQ585xAPKE09PjuB4iFEyUgwybisBBWRHUtewxV13vzRevvNNUXtunKiLkR5g01qmu0DPmZCyMDDX3jSRVvt71M3S+pa5P22hkrnzhvV5eoSvnME28EMzk6aoU1ecpzkp8WpQOgYVHnwqFQtP253uuXZb793Qepn7mYsBCGRAgUE6bRPRV3L96mbz39XqKbrA0ekqHm6M+DiiDPGaJ0H+MpJaIO4ldEZCSoI/a0MAALS67r4oK0miBe4PNAgDQG4hJDwhgKC7Ju6WWdV/zfM1fBrf7ylXB87Z07nRaNg6obVYnxWAptihVlQJT7TmOgoqW9pLwgm5STJD8akCUo//OfrPe2eg3oQRbRCEBL2UECQdtRbHVpQKKkteO6VlXt1kpiZn6LWhY7AMlHT3CqjMixaG4KEXxtw1IhotNk1Bsafn/1glPZCQWGpzaXfl7hOiTOqFQJdPAkh4QsFBGlHRYNVrQlYScItsWyTJ/bhx7OHd3o8JgoETaIfBiPvwzkewqLfDX+rwog0ixw5KctXXGr58u/kvfeWyIa1q8RudzAWgpAwh85q0q74U2m9TRJNHuvDa6uKNFBucm6STO0k9gECA1kaWKGyRHV4x0Og3HV9i0M/c8RFeIFb66PNZbKhuF4+e/pBsRVt1v1ZecPll5f9Vi4/+3i1YhBCwg/+6hMfmBwarXbtbwHz8//Wl+j+Hx80fB/rAlI8vXEP3mBLEr7AIjU6M17sLne71M51y7+QuvUf6e3E2ScixFJvl5cUyR133S3/feWdQRszISS4UEAQBYFvMDmbYwwqFt5aUyw2h0tLUc8ekdr+WLdby1TDhM24h8gBn/WwVLNUNraqa8Lpcso999wjjWuXiqu1WWLThot59EzPwW63uKz1cve/HpaaRutgD50QEgQoIIhS22LX1DsETzbZHPL22mLd/+OD8vexPiDNE2ZptOdm3EPkgM8aXVXRxh3fldWrVkl5WZm4bc3S5LVCzDxOJMrzs+K226Siulbe/vCLQR45ISQYUEAQpbzeqpYFxDK8u65EmlqdGjj3gzHtS1bDfG13uWR0RryatUlkgRofiIewOpxSWl7p29+08RNxWhslJjlb4sYe7NvvtjbIjpIqabAyI4OQcIMCgmgdB2RToIYDUvXeXOOxPpwxe7hE+1kYYLZGUaFhKXF0XUQw+OyHp8ZJTOL3Jc3dDps0rVumtxNmLhKJNvisEAnJqVJaRzcGIeEGBQTR4MmWVpdmVHyytVzdGeiHcOi4jH1qRCDAkimbkQ2yMvAdOHjWdMkaPgq+Dd3ftPlzcTbXSUxCulgmzNP92dk5Mm/2DCmua1HXGCEkfKCAiHCcbcGTcbEGtTC8vtpjfThxem67ZljIuGhqdciojHhfgy0SueA7MCYzUS781eWemAeICKddGte8r48nTD9WxBArV19ztSTFmaTF5qQVgpAwgwIiwqltRt8LhwbGrSqolYLqZhUTi6bk7GOlQMGo3OS4QRsrGVrkJJvl+KMPk9/fdpdkZXkKSjVv+0ocDVVisCTLj6++U4484kjdnxxnVCsE3GWEkPCAS8kIBx000UIR1obXVhfpvmMOyG5nZUDNh+hoT+VB9McgBCDgFq6MefPmy7FHvC6b1q2VyspKKXSlyBs7HLK6zqyCAYGX8SaDFNe1SlmdVUZnJgz20AkhAYACIoLBj3t5g6fy5O7KJlldWKu9DU6akdfuuJoWT82HFAsLRpH2ZCQYJS/FLIU1zTJ79kE+t9jyZ1dqQy0E5J518AiNmcH3rKjOKrkpcczgISQMoAsjgvEGT1qMBnm9zfowb2yGZCeZfcc02hz6Yz88lTUfyL7gO4F037jYGF+qJqxU58wZobffWF3sC55MNMdopdOKhvbtwQkhoQkFRISCVSLadiPeoabZLp9srdD9p8wc5jsGQZV1La0yPMXCctWkS/DdGJlukXqrXb9XYMG4DMlPjVMB6i1KBrEBdwYsEwjKJYSENhQQERw8Wdtk1+DJd9aViMPllsk5ie1admvapjlW8lIYOEm6B8G1afFG/V55rRBwXQDE1nitEKg1giqWqCdCCAltKCAiFDUjR7lVOPxvnadp1smzvrc+YCXZaLPLSJinjfRXk+4xxkTLiLR4aXW6xNFmXfBaIZpsTnmrzQoBYWGOiZaimhaftYIQEppQQEQgyKrwBk9+tq1CGmwOrS44d/T3ZauxkkS/C/94CEK6IzPRpBtiazpaIV73s0Ikx8XqMVVNtEIQEspQQEQg+OFusTslLjZa3m6zPhw/LdeXoomVIXpewK+NlSUhvQHfHwRUwq6Akug+K0SapZ0VAinDhqgoKam1apwNISQ04ewQocGTaNu9taxRdlY0idEQLUdPzm5nfUhLMElmAvtdkL6RHm/UAlNe6wJExdkH5+9jhYB1C240BPASQkITCogIA+KgutEq2zeukUffX6H7Dhmfrm28fdYHp8vTLMmvlDUhvQGZFvjuxBqi1FUG5o/93grhbdQGy5Zb3FJa1zLIIyaE9BfOEBHGc6+9KxdeeKFcfuW1sqXW47JY+vif5cOPPtTbdS12SbXEajMtQvoDrAvIyqhu3tcKAQHhLWedEmeUsnqrfucIIaEHBUQE8dxLr8q1t9wmFUV7xDLhBxJliJHWit1Svn2tXHfddbLsww81NgJFo1CmmJD+Mrwte6fR6vBZIdAGHnUh/re+VPehQJnN4ZIKLadOCAk1OEtECE6nU6676Y8SFWMSt8MulokLdH/zps9QMUpv/+2+hyTJFE3rA9lv0PY9P9UidbZWDZSEFeKM2cP1sddXFWmQLkg2GzUmx+vuIISEDhQQEcLHn3wq5U0OcbdaxZw/VQzxqeJsaZCW3as8B7hFKuvqpXj7emZekIAAN0aCMUYLkoGFEzI1Xbi2xS7vbyjTfWiy1Wxz0gpBSAjCmSJC2LG3TAzmBHHZmsQy+VDd17LtaxGXZ+UXbY4XV0ujtFR7ftgJ2V/gwkDwJNwWsEIgKPe0Az1WiFdX7dVy1p7y1gYprrX6Uj8JIaEBBUSEYErOFHG7JCYpU0y5E8TtcknTli/aHo2SKKNFHPXlkj8sd5BHSsIJFCJDuXRvoCTShdMsRqlsbJWPtpT7emnAKuEtQEUICQ0oICIArADzJ0yR9CSLz/pgK1wvrqYavR1lsojb1ix5qfFy6KGexwkJBAiUhBUCmRcut1vdY6e0lUx/ecVeTRtGfIQJ5a1rm8XF8taEhAwUEBFAZYNVWp1u+fVvfitxY+fovqbNn/keN5jixdlQLn+/9x4xGNj3ggSWrCSTJFuMUtdWNOqHU3O0tTeCJ1FK/fvy1napbmvGRQgZ+lBAhDlY+e2tadG+F47MSRIdaxJ3Y6W0lmzVx6NiTZKekihPPfwvOfXUUwd7uCQMMcW0WSHsDrU4wCrxo7a28S+t2KuWCaQNoypJSV0Ly1sTEiLEDPYASHBB10Pk4ucmm7VtN/jlcQdL3jEPS2VlpUQnpMkPDzlIDhiWOthDJWEMsi+87b7TE0xywrRceXXlXimobpblu6tlzuh0tUKgvHV9i0OSLZ7KqISQCLdA3H///TJq1Cgxm80yd+5c+fbbb7s89qmnntLIbP8NzxsKcQReE2yogMC1otoWSY03ytqier0dF2uQoyZny+zZB8kRRx0r06dPl9yU+MEeKglzYGGAFcLqcKoVIt4UI4un5vqsELA6wDKBzIxypnQSEhIEXUC88MILctVVV8ktt9wiK1eulBkzZsiiRYukvNwTgd0ZSUlJUlJS4tv27Nkjg01FvVVWFdTInqom/QEc6uAHuaimWWx2l1iMMfJ2WyfEoyZl6X2A1SAaZqVwtUcGAHzXYH3A9w6cNCNPe2ZsLm2QjSX1ui+prbCUt9w1ISSCBcS9994rF110kfziF7+QAw44QB566CGxWCzyxBNPdPkcWB1ycnJ8W3b2950iB9sKsamkQTaV1A/5Hzh0OSyus6rZGP0GvttdrfsXT/es+iCCHG635KaY9XoTEmxQBwLVKVGFEt8/WMa8XWCRkQHijQb9v1XZ4OmjQQiJUAHR2toqK1askKOPPvr7F4yO1vtfffVVl89rbGyUkSNHSn5+vvzoRz+SDRs2yFAAKWjw5e6taZa1e+vUXzsUQSpcYXWzVpeEWRi9B2A0mZmfoj/g/k2zkJNPyECRkWDUVvFeKwRSOqOjRJbvqZFdlU0qZuONMSwsRUikCwgE6aEHQ0cLAu6Xlnoa6nRk4sSJap1444035L///a+4XC6ZP3++7N3rWaF0xGazSX19fbst2L7cvOQ4rd2/Zm+tbC9vGHI/dJWNNrU6wPqA1d77Gz3X+vhpuT73htXukGGpFrbsJoNqhUC560PGZehjr6zc6yssVWdlYSlChjpDbvaYN2+enHvuuTJz5kxZuHChvPrqq5KZmSkPP/xwp8ffeeedkpyc7NtgtQg2WCWh4VSiKUa2lzfJ2r21Q+bHzmp3yp7qZhU62D7bWikNVodkJprk4FFpegzux5tjJT2e1gcyOFYIxELUtFkhvOWtUROitM6qhaWMBhaWIiSiBURGRoYWJiora99fAfcR29AbYmNjZdasWbJ9+/ZOH7/hhhukrq7OtxUWFspAgWDEnCSz1DbbZU1hjeyqaNQo8sHC4XTJtrJGqWqwqfUBlpHnvivwWR/wwwwarHYZlmxW9wYhg2KFSLPo/xV8Z8dkJsiBI1LVzfba6iI9BimdNU12n8gghESYgDAajTJ79mz54IMPfPvgksB9WBp6A1wg69atk9zczns0mEwmzdrw3wYSTMqo92+OjZEtZQ2yprBWXQgDXQwHr7e7sklXbVlJZomOipI31hRJeYNNLQ1e9wUC1MxGg2QksmU3GTxgwdO6EG09Mk5va/W9bGOZigZYzwAsEoSQCHVhIIXz0Ucflaefflo2bdokl1xyiTQ1NWlWBoC7AlYEL3/84x/l/fffl507d2ra509/+lNN47zwwgtlMOlJECSYYI2I0+DE1YW1sqW0QeMkBgrUeNhV1SRpFpP++OJH+KXlHp/yufNG+awN9Va7lhaGn5mQwQLC298KMTUvSSZmJ0qr0yVvr/UUPEsytxWWsoZW/RVCIoWgC4gzzzxT7rnnHrn55ps1rmH16tWyZMkSX2BlQUGB1nrwUlNTo2mfkydPlsWLF2tQ5JdffqkpoIPFur118sv/rtQVfk8/ilmJZkk2x+qxKwtqNGMj2G4NWDy2lzWKJTZGWyiDZ74pkBa7U8ZlJcjhEzN1n7ZPligVOoQMBStEeoLHCoG4otMO9JS3fmddsYpvfJdReKq8nlYIQoYiUe4wKzwPwYFgSsRDBMqd8dPHvpHPt1cKyiWcOD1Pfjp3pG+i7gpcVlgjUP8/1WKUEWnxGjwW6KwHrNC2lnkyQfCDDCBefvvCKvUp33XqNJmSl+w7NjU+VmYMT5HotngIQgYTZAvB7YciUxARlz27Uq1pFx4yWvtlIF4HvTIOGpXGmB1ChtgcOuSyMIYi/zhrphwzOUsgtd5cUyyXPbdS6/d3B34MUyxGyU6Mk2abU4MskfaJH8xAWCQgGJBCuraoVm97MyogXB7/YpeKhwVj033iASlzrU6n5KXEUTyQIQO+t95YCFjwvK2+31hTrK4NuAYbbc4hW3OFkEiGAqIXIOXs/xZPlt8eNU4LSeHH7A9vb5S7lmxW90F34EcRz4dro67ZIasLamTFbk9JbFS27A/oybGuCDUoGiXBGKOWB281yRV7ajQGIyY6Ss6bP9r3HPiRIWjwY03IUAEWueGpFmltqwtxxMQsLa2O/2Meq1+UWIwGtUoMZoYTIWRf2I2zD2A1f/85mfLstwXyxuoi+WJ7pazYUy1nHzxCTtS6/tHd/lCiFgN+JGGWRTlsmGThA06LN6kQsJgMXZ4D9R0gAmqb7Nry2O50ayyDNzUTwGXy4Cc7fH0GcpLNPqtEc6tTRmfEdztGQga7OiXENtyE//l6jxaWSmjYIxWVVWJISJcRqfMkL5WN3wgZKjAGopegxsO28katnKf3KxvlwY93yKbSBr2fnxonvzxsrMzIT+n1OREo1mCzi93lkpioaI2rSI6LEVOMQeMtYqKj9S/qTGg8RatD96GTIUy7/sCN8fvX1+l4spNM8o8zZ+lxAJYOrN5QSKqn2A1CBgOka64urFFRjP8X5z7xldhdUVL1/oPSWrxZoi0pkpEUJ3+76Uo5/bRTB3u4hIQtfZlDaYHoJ6MzEuSu06bLR5vL5ckvd0thTYv8/o31MmdUmpw3f5SmqPUEJnPvhA5/L7ImyutbNWgMss6NZhb4kFQ0GCQlLq7TxlfQgP/4YKuKBzQjuuWEKT7xAOpaWmVsZgLFAxny1SlhhVjz3RdSs+5LSZhyuCRMPVKqizeLy9ogVYYYOevc8+XFKJFTT6WIIGSwoT17P0CxpqMmZ8tDP50tJ0zP1aZA3+6ulsufWykPfLy911X0nC6nrFm9Ur785AMp2LpOMhJi1f0Aawc2uD5Q9bKrrpnPfFsgn26rVHfGDYsntxMv9S12FRO5KUzdJEM9FgLWB7vcc89fpWnjx+J2OcWUN1Fi0oeLuJxQyurKuOKKK7TAHCFkcKEFIgDAnQD3Bao9Pv3Vbvl6Z7V2wPx4S4Usnpaj6WhI5eyMDz/6UOtklPuV+87KzpZrrrlGjjziyB5f+8PNZfLCd57y3ZcePlZTNL1ovIXNLpNzk/ZxeRAy1EAwcOH2zVJZ3yyulnpp2bVSLGMPloQpR0rtp/9WK0R0fKrsLdokn332mRx++OGDPWRCIhpaIAIIoslvXHyA1l4Yn5WgLolXVhbJhU8vl0c+3bFPxsayZUvlumuvbSceQHl5uVx33XUqLroCMQ0INPvHB9t8DYmOPaB9fxGYg5F14Y3bIGQogwBfZ0OFRMWakActTes933/zqJkqHNyOVomKiRVDfGq74nOEkMGBAiJI2Rp/PWOG3HT8Ab7yvG+tLZGL/r1c/vLeZllVUCNLly2T/7vxxs5PoAEQbrVMwL3REQRwXvXianlxeaHWezjmgGw5d97IfQQGgjNHpceLMYYfMwkNxudni7OlUaJNCeKoKRZb8RaJijZI/OSF+rjL2iiGpAxJy+pdMz5CSPCgXbuXoPgSUieRCYF4hJ5AvMKc0Wly8KhUWbO3Tl74rkDWF9drrAI2Z2OLWKYdK9bdq8VRWwrVsM85YJl44okn5KILL9L7yMRYsr5Env+uUBwutySaY+Syw8fJgnEZ+zwX1g7EUXirUxISChyx8DDJio+WKleciLVRmjZ8rHEQlgnzpHHNEnHbrZI9apKMnzZ7sIdKSMRDAdFL0HETqZIoaIO0SrgGelNaF0JiZn6Kbij8tHRjibyzarcYElIlceYPdXNZm6S1fIe0lu0Ue3WRmmrdToeI0y5PvLJEyhMnSHV0srbq9sqMuaPT5LIjxnUaWwGRYzREy8i0eFadJCGFwWCQv/7pFvn51X+QaHO82Io2ib22VGJTclREILjykovPl9L6VhmW5tSUZ0LI4MA6EH09v9UuRTXNUlJn1SBFTOB9+RFbsWK5/PLSy8Q8YprEjZ0jxuyxEg2fby8ZlW7Rcr+o2NdZVgbGVFrfok20xmUl9vq8hAwlHnn2VbntvielfNcmiRv/A0lZcLa4W+rkitlxcuQRR2gxtWnDU2QYs4sICSisAxFE0GI4MSdJC94U1jRLeT0CIz0Wid5UeaysrBRxOsS6a5VuEhUtsenDVUgYc8ZpmlqUIUaiDLH6F/qutWyHnHnkQXLqYbM0V74rcGxZg1XdFgjoJCRUOfeMH8mk2Qtk/bp1Ul9TJf8pEGmSZDEOn6jp03GxMSrksxNNAW9QRwjpHRQQ/QAr/9R4o9bsr05plb01LVLeYNOI1NQehERGRod4BbdL7JUFujVt+KjL5404Zly34gGgf0ByXKxMyk1i50IS0uD7OyI9XponTZG85Dip/65QS8i/trpIDh2fod/zsvoWqWpqVfciIWTgoXTfTyGBSX3asGSNcUBfC/ygoeMm4iU6Y+asWVrnQWtU94F9hEcHqptaxRgbrVkfrPlAwoHspDgtgoZS7Iun5WpcD+KINhTXa9G0WINBimtbxIVUJELIgEMBEQAQqIhqkdOHp8isESl6G1UoISTQBMsfQ7RBi0QpvRERUVGSnZ2jwqMrUG3S5XapeIAFhJBwAKXX1frQYleLwxGTsnT/66uL9C8sgJWNrVLdy4qvhJDAQgERYCGR0WaRgJDISjJpJUiskrCK8sarosLk3XffLVlZnh/ELmkTGFdfc7UKj85Asahmu1PGZydKFk25JMzITjarkEBm0Y9m5um+b3dVaxAlXIX4H4L/X2EWC05ISEBbd5CEBFwbCKysb3FIeYNVszZK6uwSF2uQBHOMioiFCxfK6lWrNLCyoLBQXn31VakoL/edJzsrW8VDZyWtUSiqotEq8cYYmZKXJLltrbsJCSfgjkOMw57qZslPtcjskamyYk+NvI3CbIeOUStERaNNU6tpfSNkYGEa5wCBFsUo7oSVE0QF0i29bbnhzwWoOukVFIh5gNuio+UBH1dti11dI3kpcTIqI54xDySsgZVtRUGNJJtjNf7hljc3qBB/6hcHa1E3pC2jXDuEdFcN5wghvYNpnEMQmGHRJROTPny6CHpECigyJ1ziltjoaP1RnD7zQBUUSFXztzY0tzq1twZiHeJNsTJ1WLLkJJlZKIqEPYh/yIg36f+VWfkpkp+KFOoWWbqxTBvVpcQZNX15eEucpHTRtI4QEngoIAYYiAOYWrGNSLdIg9UhTTaH1La0qmWipqVVOxe71DDk1jgIPCc+NkZGpHl+IFGLAoKEkEgAVgUIb7gCYbk7cUaePPDxDnVjnDA9T1M+EbSMWAiIDVohCBkYKCAGEQSBIU4CW75Y1NKgVgaXW5tkQURgMxkMEm8ysGAOiVjwfwRVX9EPBlVY//3VHimtt8p3u6vlB2PS9THch9CgFYKQgYEz0hATFLAu4AcQP5jI6MhKNEuyJZbigUQ0sMINS40Tq8Ol3WUXTfF043xzTbH+hRXC4XQzI4OQAYSzEiEkJEiPN0lKXKzGEB0/LVcQ/rOuqE7b2wOvFQKuQEJI8KGAIISEBLA85KWYpanVKRkJRl8be38rhN3plqK65kEeKSGRAQUEISRkyEw0i0ULSznlpOmewlIfb6nQVE+QZjFKWZ1V6prtgzxSQsIfCghCSMiA7KOsRJPUW+0yMSdRxmcliMPllvc3lvmsEK2wQtQ2MxaCkCBDAUEICSlQmRJ1UiAckMYJ/re+RFM8vVaI4jqr1lohhAQPCghCSEiBWg+p8Z5gSm9rbzTV+npnlT6urezdIntr2KmTkGBCAUEICSlQfRX1HmxOp6Z3elM6317rCaYESING4SmUjyeEBAcKCEJIyIGUTZR0RxXX46bmaErn+uJ62VXZ5KupYoiKloLqZnE4XYM9XELCEgoIQkjIATdFbpJZgylRcG3eWE9K5zvrStpZIarQc6aBVghCggEFBCEkJMlINGltCHSmPWFaru77eEu5NFo9haTg3oiLMagVwuZwDvJoCQk/KCAIISFJkjlGq1MimBKtvEelW8TmcMnSTaW+Y1AGHjUiUBuCEBJYKCAIISEJum7mJpvF4XJp8zlvSue760p9KZ1I90w0xcruqmZpsLK4FCEhJyDuv/9+GTVqlJjNZpk7d658++233R7/0ksvyaRJk/T4adOmybvvvjsQwySEhBip8Whvb5RGm0MWTsiUBFOM9sNYsafad0xSXKy0tDplT1Uz0zoJCSUB8cILL8hVV10lt9xyi6xcuVJmzJghixYtkvLy8k6P//LLL+Xss8+WCy64QFatWiUnn3yybuvXrw/2UAkhIQayLXKSTdJos2tg5bEHZOv+t9Z+H0wJMhNN2qmzrIGuDEICRZQ7yPVeYXE4+OCD5V//+pfed7lckp+fL7/+9a/l+uuv3+f4M888U5qamuTtt9/27fvBD34gM2fOlIceeqjH16uvr5fk5GSpq6uTpKSkAL8bQshQA30vlhdUS4rZKDXNrXLxf5arS+P+cw6UEWkW33E1Ta0SY4iSWSNStSQ2IWT/5tCgWiBaW1tlxYoVcvTRR3//gtHRev+rr77q9DnY7388gMWiq+MJIZFNojlG23wjxgFlrueOTt+nsBRIsXiqV+6pamKfDEICQFAFRGVlpTidTsnO9pgVveB+aen3kdL+YH9fjrfZbKqY/DdCSGRVpsxJRmVKT8GoE2d4gik/3Px9Sqc36DI9waQlrlH6mhAS4VkYd955p5pbvBvcI4SQyCLVEivm2GhpbnXIVL+Uzvc3tl94IE4C9SF2VTZq/QhCyBAVEBkZGWIwGKSszNNq1wvu5+R46td3BPv7cvwNN9ygvhrvVlhYGMB3QAgJBSxGT02IBqtDLQ0ntVkhUJnSm9LpX6ESnTp3VjQyK4OQoSogjEajzJ49Wz744APfPgRR4v68efM6fQ72+x8Pli5d2uXxJpNJAz38N0JI5JGVaBKny6WC4bAJmRobgTLW3+7ydOn0gtoQmQlmKaxulqLa5kEbLyGhTtBdGEjhfPTRR+Xpp5+WTZs2ySWXXKJZFr/4xS/08XPPPVetCF5++9vfypIlS+Svf/2rbN68WW699VZZvny5XH755cEeKiEkhEmxGCXB7GmwZYoxyA/bunS+uaZ9MCVACexEc6zsqGhSawQhZAgKCKRl3nPPPXLzzTdrKubq1atVIHgDJQsKCqSk5Puc7fnz58uzzz4rjzzyiNaMePnll+X111+XqVOnBnuohJAQBqIgOwk1ITyBk4un5fp16Wzc53gICKfTLdvLGxgPQchQrAMx0LAOBCGRC2o9rNhTo3EOKDL15yWb5fPtlXLkxCy58pgJ+xzvcrulpLZFRqRbZGJOkgZYEhLJ1A+VOhCEEDKQJMfFagMtBFOCU2YN078fby3XSpQd0XiIRLN27CxgfQhC+gQFBCEkvGpCJJmlxeEREBOyE+WgkalamfKF5YVduj5SLUaNhyhm105Ceg0FBCEkrEDFSbPB4ItrOHvOCP378ZbOrRDeNFDUiNhW2iAVDbYBHS8hoQoFBCEkrEBHTnTp9LoxemOF8Lo/wJayBqlrYetvQnqCAoIQElagkFRWkklanU5fTENvrBAApa6trU7ZUlqvVS0JIV1DAUEICTtS4ozqlmhpc2O0s0J81321WrT+RlfPTSX10tLK9E5CuoICghASdqBdd0aCUer9mmn5rBBdZGT4Z2ZkJ8ZpLMTm0nrWiCCkCyggCCFhSUaiSUvno9ZDRyvE898VdPtc1IPISYqTsnqbbC6hiCCkMyggCCFh68bwlrb2co4vFqJCtpU19EJEmKWUIoKQTqGAIISEJajvgAZbDX4CYnx2ohw+IVNgk3j4050+60SPIqLOqiKCMRGEfA8FBCEkbEFWRbREicPp8u07b/4oiYs1aLrmR5vLezyHiojkOCmtt8qG4jpfrw1CIh0KCEJI2ILaDolxMe0mfYiKMw/O19tPfbW7nYujOxGRmxwnVU2tsr6oTuqaWSeCEAoIQkjY4nFBmKSpg+vhpBl5MiwlTmqb7T0GVPpnZ+QmmaXR6pD1xXVS1ciKlSSyoYAghIQ1aQkmMcdEtwuCRKfOiw4do7ffWlsihdXNvS5SlZ1kFpvdpSKipK6FDbhIxEIBQQgJaxJNMZKeaNynPPXskakyd3SaOF1ueeSznX0SAig2hdiKDUX1srOiSc9BSKRBAUEICWu8VgNkXHSc6C88ZIzEGqJkdWGtfLSl54BKf1IsRkk0x8i28gYtfc00TxJpUEAQQsKeNItRkuJipd7a3gqRk2yWsw/21IZAWmdfO3GiXHZWolkKqps1Q6Pj+QkJZyggCCFhT4whWoMmO2uQdeqBw2VidqI0tzrlHx9s7bE2REcQT4GqldVNrbKmsJZxESRioIAghEQEafFG7ZHRUUQgU+OqYyZo4ak1e+vk3XUlfT63t/Q1KlQhzXNbWaPYHHRpkPCGAoIQEhHEm+BuMHXqZshLiZPz54/S209+uVuKarputtVTXARKaO+sbGS9CBL2UEAQQiIGxCtESZTY/SpTejluWq7MzE+RVodL/rZsa78zK8yxBrVG1DTZZXVhjRRUMUuDhCcUEISQiCEVFgJLrNR3SOn0For6zZHjJd7oKXP97Le9KzDVlUsDmR+Ij9hY0qDWiAYGWJIwgwKCEBIxRKMkdUqcWB3OTgMdUd/h0sPH6e0XlxfK1zur9uv1Es2x6jZBHw2kiu6taaY1goQNFBCEkIgiPR71G5DS2XkPjMMmZMqJ03P1NlwZ/Y2H8AIrRF5ynLpOYInQ2IhOLCCEhBoUEISQiAIxCsNT46TBZu8y3fL8BaPlgNwkTe2843+bAtLGG429EINRBmtEQY3srmzsNBaDkFCBAoIQEnEgPgElrhu6sEKgbsTvfjhJUi2xWiTqvo+2BaS2A6wR6OppNBhkc2mD1o2obLSxbgQJSSggCCERR2+sEKgbcf1xkzUg8rNtlfLaqqKAvX6COUYzNeDKWF1QK5tK69u1HCckFKCAIIREJFlJZq0N0WTr2j0BN8aFh4z21Yf4bFtFwF4fwgQuDbg2CqqaZVWBJ+UTaaSEhAIUEISQiAR9LBDcWNfS2u1xx0/LlRPagirvXbpV1u2tDbg1ZFiKRbt7biyp19oRiJNwMVuDDHEoIAghEQuaacWZDN26D9DNE107549NF4fLLbe/u0n2VDUFfCxo9gW3RrPNqbER64rqtL8G4yPIUIUCghASscCFgSZbPaVVwt1w9TET1aXR1OqUW97c0OfOnb0Br5OeYJKMBJOef1VhjWwurWeXTzIkoYAghEikZ2TExUZLUw9BjGi29fvjJ0t+apxUNbXKLW9tkNrm7t0f+5OtgXElmRAf0SIr99TItrKGTruJEjJYUEAQQiIaFJUalhontS09uwtw7K0nTdFiVIXVzfL719cHtSgU4iPQ6MscY5Ad5Y2yYo+nfoTVzk6fZPChgCCERDwIYkzopjqlP8icuP3kaZJmMcoeFRHrgl5ZUl0tqRYxREVp/Yjle2o0DoNCggwmFBCEkIgnzmiQUekWaWq196pXBSwWt58yVUXE7qqBERFeCwgyR8QtsqmkQS0SSP2kkCBhJyCqq6vlJz/5iSQlJUlKSopccMEF0tjY2O1zDj/8cI169t9+9atfBXOYhBCiMQdp8Sap6WVcw/BUi4oIVKuEiLjpjfVBi4nwB7+JqB2Rl2wWeFyQ+gkhQYsECSsBAfGwYcMGWbp0qbz99tvy6aefysUXX9zj8y666CIpKSnxbXfffXcwh0kIIRq4ODLNIg6Xq9c9KjwiYpqKiF2VTXLdK2ultM4qA8H3QiJOhQQsEsvbYiQC0buDkEETEJs2bZIlS5bIY489JnPnzpVDDjlE7rvvPnn++eeluLi42+daLBbJycnxbbBgEEJIsEH6JCwRVU29T9HMT7XIXadO17bdJXVWue6VNbKzontLa7AsEnBteGIkqjXokuWxSUgKiK+++krdFgcddJBv39FHHy3R0dHyzTffdPvcZ555RjIyMmTq1Klyww03SHNzc7CGSQghPqKjo2REmkVioqP6lDKJTIm/nD5D4yhqmu1yw2vrAl6xsi8WiZioaE37XLG7WraWNmh8BgtSkUATI0GitLRUsrKy2r9YTIykpaXpY11xzjnnyMiRIyUvL0/Wrl0rv/vd72TLli3y6quvdnq8zWbTzUt9fX0A3wUhJNJIsRjVNbGjolHTKKOjonr1PDTfgiXiT+9slPXF9XLzmxvkiqMnyMIJmTLQQgLNurBBBO2qapSi2mbJTDRLbrJZUi1GFUqEDLgF4vrrr98nyLHjtnnz5n4PCDESixYtkmnTpmkMxb///W957bXXZMeOHZ0ef+edd0pycrJvy8/P7/drE0IIyE+zqJCoaWrtc7rlH06aKvPGeMpe3/P+Fvn3V7vFNUirf0+/D4skmGI1NmNVQa2s2VurvTZ6G+dBSFdEufto16qoqJCqqqpujxkzZoz897//lauvvlpqamp8+x0Oh5jNZnnppZfklFNO6dXrNTU1SUJCgsZTQFj0xgIBEVFXV8fYCUJIvymvt8ravXXqFoAloi8gFfQ/X++RV1bu1ftzRqXJ1cdO0Al9MIFoqG22i93plGSLUct4Zyaa+vz+SPiCORSL8d7MoX3+NmdmZurWE/PmzZPa2lpZsWKFzJ49W/d9+OGH4nK5NKiyt6xevVr/5uZ6uuF1xGQy6UYIIYEEE+vw1DjZXdmkMQ6wrvalp8V580dpTMQ/P9wm3+6ulmteXiu/XzxZzzWYmSZ4XxA49S122VBcL/Emg7o24OJIMsf06X2SyKbPFoi+cNxxx0lZWZk89NBDYrfb5Re/+IUGVT777LP6eFFRkRx11FHqppgzZ466KfDY4sWLJT09XWMgrrzyShk+fLh88sknAVdPhBDSHUiHRGdMm8OlMQ79YWtZg3bwRGdNi9EgvzlyvCwYlyFDAfz8N9mcUmdtFVNMtDbyQodSFMiKMbDOYCRS34c5NKjfEGRTTJo0SUUCRAFSOR955BHf4xAVCJD0ZlkYjUZZtmyZHHvssfo8uEBOO+00eeutt4I5TEII6bJC5ejMeGl1OsXm6F9thQnZiXLvGTNkcm6SNLc65a4lm+WBj7dLq2PwYxC8AZdaytsUK+X1NlldUCsrC2q01webd5FBs0AMBrRAEEICCX4iN5XUS0F1i9Za6K+J3+F0ybPfFshLKzxxEaMz4uV3iyZpWeyhhNe90Wx3qsUE9S2yksySEhfL7I0IoL4PcygFBCGE9MaVsbdW/6LY1P6A1tz3LtuqtRnMsdFy/oLR8sMpOUMu9gBTAywm9Va7prKmxsdKTnKcdiJl0GX4QgFBAUEICTCVjTZZu7dW4mJjJMG0f9kUVY02uXfpVllbVKf3Z+anaGwEAhyHIsjegFUCbhyLKUayE82SkWiiVSIMoYCggCCEBAH0mdhc2qhmfWQ07A+oDfH22hJ5+svd0up0qbvg4kPHyJGTsoacNaJd0GWbVQKtxZMtsZrBgQDTwU5RJYGBAoICghASpPiADcV1UlyLeIi+pXZ2xd6aZvn7sm2ypazBZ4249PCxkou23UMYr1XC6nBJnDFaMhNMmgqaYondb3FFBg8KCAoIQkiQQGYCCkwFIh7CX5i8umqvPPdtgdidbjEaouXMg/PllFnDhvxkjCmkxe6UBqtDrSpJ5ljJTjJpa/SkONaVCDUoICggCCFBpKLBJuuKaiUuxtNzIlDAsvHgJztkdWGtr6T2JYeNkWnDUyQUgBBCB9BGm11iY6I1RgKBl/iLMt9k6EMBQQFBCAkyBVVN2jobzakCmZWAn+RPtlbIY5/v0kwNMH9suvxiwWjJSTJLqIA6Fw1Wu9icLjHHREtaglGyEs39Kg1OBg4KCAoIQkiQcbncsr28UXZWIqjSHHBXAybf/35TIEvWl4jLjTLUUXLyzGFyxux8LXAVam6fRqtDHG63xBsN6vpB1UvGSww9KCAoIAghAxRIiCJTxbVWzUbobevvvoBeHI99vlPW7PWkfGLSPevgEbLogOyQKzeNGIlmm1MaW+2CmQfpsFlJJrXiwDIRau8nHKGAoIAghAwQVrtT1hfVSU1zq+QkBSdzAj/T3+yqlie+2CUldVbdB8Hy07kj5ZDxGUERLgMRL9GEeIlWh6CURIIx1iMm4o3a1ItiYnCggKCAIIQMIKiLsG5vndjsrqAWg4LF4/0NpfL8d4VS2xYfMSYzXs6ZM0JbhodqxoM3+BKCAmIo0Ryj1xHWFlomBhYKCAoIQsgAg+qSaI+NX9T+du7sLUghfWNNkby6skhTKL1C4uyDR8jc0aErJLw9Q1Csyism4ObITDJKigWWiVgxxlBMBBMKCAoIQsggUN5glY1F9WKIjtIJL9ggS+ON1UVa0dInJDLi5YyD8mXemHQdRyjjtUx4u4IiFTQjwdjm5mA2RzCggKCAIIQMEiV1LbKxpF7MBoMkxcUOyGt2JiQQI3HqrOFaGjscVu0QExASaPDldLm0JweCL9MTPGICpcBD2fIyVKCAoIAghAwiKE+9uaRBV8z723irL6C09Ntri1VINNg8q3bEEZwwPU87fiKeIBxANkdLm5vD4XaJKcag7w3poRATKO4V6taXwYICggKCEDKI4Ge1oLpZtpY1SoIxsNUqewMm16WbSuW1VcXaRRSgPPYREzPlxBl5MjI9XsLpWtscLhUTVodTK2DGGz2uDriREJAJgUF6BwUEBQQhZJDBTyssEVtKGyUuduDcGR0DEj/bXqnujR0VTb79aNi1eGqOzBkd+nESnWWqQEw0252Cd4aiW7DCpMebVMhB0LEFeddQQFBAEEKGCEW1LbK5tF5MBo+ZfTDAzzziMt5YXSzf7KrSypYgPd4oi6bkyLEHZGtlyHBDC1e1OjV2QpuUxURp23F0DoWgg3sp1Kp6+seE1Da3avwLOrcG6n1QQFBAEEKGWGDl5pJ6MURFawbBYFJWb5Ul60tl6aYyX68NLMgPHpUmxxyQLQeNTAs7q4R/fw4NxESgqdstZqNBYyZgnYg3GTRmZahndjS3OqS6qVULitU22cUtbpk9MjVgApACggKCEDLEwMQNS4TD6dYV8GBnDMDU/8X2Svnf+lK1TnhJtcTKUZOy5cjJWZKfapFwxduGHPEiiKGIjhYVD4mmWK3jYYGgMEJQRA/6Z9XS6lSxh3iWqiabtLS61C2G+A7so4AIEBQQhJChClaOW0sbpM5ql+xE85BZ6RdWN6tF4sPN5T6rBBiflSBHTMySwyZkhk0GR3cuAZvDIygQjIkiVqaYaHUNIF0U8ROYtCEysD8qiKLCG8eBglooUIYy6SiZHhMV7RuH9/Vh3aKACBAUEISQoQy6bG4ta5CKeptkJQW+i+f+Tlzf7a6WZZvKZMWeGl+sBITOrPwUWTghU+aOTg/ZuIG+xk+gNDnEBP66xC2GqCitqQGrRHIcak8gwyNa9yHTI8YQJTHRUb0WF94MEs/meZ3allapb3GokEGKamx0tCdWw080+EMBEUAoIAghQx2sJtEKvKimWVItpiE5ISNA79NtlfLR5nLZXtHo24/JEvESh43P0IkrklIkvVYKTPitDpc4XC6d1CEsVDwYovW2KTZK02YhDmHJwLwfJVEar4BgTgg1PN932+nSc4tb9DyWWI/rpDc9QCggAggFBCEkFECKJVp176pq1lUszORDFbg4PtlWIZ9urfB1AwWY5BB0uWBchswekTokhdBA4HR5hAD+OlxucXn/tk2v+m/bTAuvFSw6EBZIJ401eMRGfxuGUUAEEAoIQkiogJ/fsnqbbCtvUKtEZsLQiYvoaryoJ/HJ1gr5ckellDd4ilQBTIKoLzF3TJp2Bh2IXiBEKCACCQUEISQU24FvQ1xEg01TCod6KiHA1AE3zBc7qlRM+FsmIIEm5SapkDh4VKqMSLMMeiZDuFJCARE4KCAIIaEIfOu7KpqksKZFYqOjNJUwVCZdTCN7qpq1SNXXO6vbxUyAzESTHDQyVd0d04YlR6yrIxhQQAQQCghCSKiCn2O4BSAkalvsWi8iFDtpojbBN7uqZfnualm7t06DBL0gS+GA3CSZNSJVDhyRIqMy4jUegPQPCogAQgFBCAl1UG0QAZZ7a1rUnZESFxsy1oiOILYDImL5nmpNDfWPmwBJ5hiZkZ8iM4an6N/sxMEvshUsnC6nrF61SiorKyUjI0Nmzpolhuj9s8ZQQAQQCghCSDiASP6yBqvsrGiShha7ThChEBvRHZhuimutsrKgRrf1xXVitX9vnQBoyT0lL0m3qXnJMiw1LiwsFB9+9KHcc889Ul5W5tuXlZ0t11xzjRx5xJH9Pi8FRAChgCCEhBMoKLSnqkn21rZocCKCLIdypkZfQOojimqtKayVNXvrZEtZg6cegh8Wo0HGZSbIuCzPNjojXptHhdI1+PCjD+W6667T/hvtaBNGd999d48iAimhdc12qWi0abCt929hTbP88aQpMm14SkDGSgFBAUEICSPwM13V1KpuDcQXJJhi1fQfbqZ+uDu2lDbIhuI62VBcL5tLG9rFT/jHUQxPjZP8NIsMT4mTnGSzZCd5NgSfDiWLhdPllBNPPLGd5aEd0QbJHjZS/vnw41JvdWrZ6uome9vfVi1ljc8et1FbojPuP2eWHD89b8Dn0JiAvCIhhJCgAaEA0z7KJ5fWtcie6hYprmvR4lMopxwuwEWj8RD5Kb5iW1hhbytv1JRRbAXVzVoJcndVs26diQuICFwb/MWG64bGU4lmz1+UhsZrxbVtJlR97EMJ6o4FpOxtlSXRnAsuGW+TLsSybNq+U5qzp0tifpxEm+L9NotEmRM8f6Oi5YoX1/b4ehgdurlmJZo0s8UbZDsybXCantECQQghIQYmJ5TBhlsDk2maxRjy8RG9BaZ8Nd1XN6uYKKpt0U6nKMhV3mD19e/oDxARKD8N94in/DQqR3puYKaEYMDr46+zrdpkIHC7XWKJEclMTmgTP7E+EYTYhox4z1/s71ixcjBjIMJHuhJCSISAOgrjshMlM8msEymCLdGECRNOuPemwITudVccNCqt3WOY1GHyr24z/3u3eqtDm5g1tP1tbnX6rAT+IgC3HS5nv8ZliI7S0t7ejp3YYOmwNdXLiq+/EFerVdytTeKyNYvLir9tW0uDuGyN8vBDD8ns2QdKKBE0AXH77bfLO++8I6tXrxaj0Si1tbU9PgfGkFtuuUUeffRRPX7BggXy4IMPyvjx44M1TEIICVlgmk/KS5JhzXG6Ei+tt4q47ZJiiQ17IdHVJI4Op9h6C9wPsOLAXYLmVmiQhb9e4zz+oAmWt3eFoe1vTLSnhwVcCF6rRZcxEM/8ScrLy/cNogQQRFnZmtIZagStQklra6ucccYZcskll/T6OYhE/ec//ykPPfSQfPPNNxIfHy+LFi0Sq/X7EqmEEEK+B357+MWR9njgiFTJSjJJndWupm2ssEn3YPKHpQC9OxBXgAwPlN4emR6vGwpdjc5I0Nv5qRbJQ9BmklljUpLiYtXS0F1GCOo8IFVT6Rhj0Xb/6muu3u96EGEZA/HUU0/JFVdc0aMFAsPIy8uTq6++2nex4YPJzs7Wc5x11lm9ej3GQBBCIhn8ltY226WkvkXK62xidTglOc4o8UZD2GVthHodiOzsHBUPoVoHYsjEQOzatUtKS0vl6KOP9u3Dm5g7d6589dVXvRYQhBASyXgtEtiGp9qlvM4qJfVWKa6ziyXWoKvmUKqhEC4cecSRsnDhwoBXohxMhoyAgHgAsDj4g/vexzrDZrPp5q+eCCGEoEw06kXEyrBUi1Q12aS4tkUzFeDPx342tRpYDNEGmT37IAkX+hQDcf3116u67W7bvHmzDCR33nmnWiq8W35+/oC+PiGEDHUgFIanWjRGAk2sspNN0mx3SFFts9SgQFEnxZoICagFAvEJ5513XrfHjBkzRvpDTk6O/i0rK5Pc3FzfftyfOXNml8+74YYb5KqrrmpngaCIIISQfUENAS1AlGiSRptDxQN86JVNrVrfIMEYI/GmGLo4SOAFRGZmpm7BYPTo0SoiPvjgA59ggBhANkZ3mRwmk0k3QgghvQeZB9iQVVDbVjcBnTK9Lo54Y4xYTIYhVRaaREgMREFBgVRXV+tfp9Op9SDAuHHjJCEhQW9PmjRJXRCnnHKKuj+QrfGnP/1J6z5AUNx0002amXHyyScHa5iEEBLRwNqACH5sSFVEQSr026hubJWyertmGsZDTBhpmQg0LjfqTXgyZ7zpkLjCmA9D4VoHTUDcfPPN8vTTT/vuz2orkvHRRx/J4Ycfrre3bNmiqSJe0K2sqalJLr74Yk37POSQQ2TJkiViNve+KAghhJD+gaJIWYlm3WwOp9S12NXNUdnYKhWNVnG5PPEU8cYYPZZ0Lw7QH8Ph/L5fhsPt9pR+UMHgKUqloFp2W+lsCAm3y1NVE/e8qbdREiUxhrYCVm3Fq7ANJuyFQQghpFswEaIEdH2Lp5004ifsDrdOaLBMoHxzKKyYg4WjrZolNlwrl8oDjyDDJG+KidbYErQmRxwKRACul7eBl1c8iL+AaOu54RUiEHRagrvVqR1KsUGcQITMGpES2XUgCCGEDE0wEfq7ORpb0VPCIdVNNqlrcWhzK0x0mChhoUAZ7XAVFJjUMZnb7C6xOZ3icrnFYIgWc0y0JJgNkhxnVlHl6YcRreWuOzbA2h+w5od4gFhB+3OU3U4wD85UTgFBCCGk16APhK++REqcro5hkWhUQdEqDTa71Fvt6u6A8DDHeCbSQE6iA4V3skaLbpvdKQ63S6IlWtt/W0wGybOYJcEU62kLbjQMiFsHFgsINGz4DAYTCghCCCH9BpNmWoxR20+PSLfoqhim9iabV1A4pKq5VVfu0RKlky9EBZ43lKwUEAtYzat1Aa4Ip1P9CZiozUaDpCWYtSS4pU0smCOkfXp3UEAQQggJGN5W1hAU+WkWDR5stjm1cBWsFLUtaKftkLoWtzjFJYYoT4yAZxsY14fXDQHriQY6IujA7RFDGEN6glFS4owqFBC3AAsDLC+kPRQQhBBCggaCCJMt0ZIssSLJnpU+VvgaEGh3SpPVod1DERyIuAonJnNMTlHREuttld2W1ujdekqLhEBAW264UfDX4fJkQngzBnAOxCZAtKQnGiXR5OmqCcEQ6QGhfYECghBCyIABH77XSuHFKyo0MLHNhaBxFTaHx0rQFqzo9KY3tqVCIn3BcxPSIEqLXiGjAeEWhmiPiwQuk+RYT+opXBEQDh5Lg2djh9L+QwFBCCFkCImK2H1SJGFBUKuC063pjd7CS1qESdwqHDyb51zeNEm1XtCaEDQoIAghhAxZtG4C4xWHJKGXV0MIIYSQQYcCghBCCCF9hgKCEEIIIX2GAoIQQgghfYYCghBCCCF9hgKCEEIIIX2GAoIQQgghfYYCghBCCCF9hgKCEEIIIX2GAoIQQgghfSbsSll7mqqI1NfXD/ZQCCGEkJDCO3d659KIEhANDQ36Nz8/f7CHQgghhITsXJqcnNztMVHu3siMEMLlcklxcbEkJiYGrE0rFBkESWFhoSQlJQXknJEOr2ng4TUNLLyegYfXdOhfT0gCiIe8vDyJjo6OLAsE3vDw4cODcm58QPzSBxZe08DDaxpYeD0DD6/p0L6ePVkevDCIkhBCCCF9hgKCEEIIIX2GAqIXmEwmueWWW/QvCQy8poGH1zSw8HoGHl7T8LqeYRdESQghhJDgQwsEIYQQQvoMBQQhhBBC+gwFBCGEEEL6DAUEIYQQQvoMBUQb999/v4waNUrMZrPMnTtXvv32226Pf+mll2TSpEl6/LRp0+Tdd98dsLGG4zV99NFH5dBDD5XU1FTdjj766B4/g0ikr99TL88//7xWZj355JODPsZwvp61tbVy2WWXSW5urka+T5gwgf/39/Oa/v3vf5eJEydKXFycVlW88sorxWq1Dth4hzKffvqpnHjiiVoVEv9/X3/99R6f8/HHH8uBBx6o389x48bJU089FbwBIgsj0nn++efdRqPR/cQTT7g3bNjgvuiii9wpKSnusrKyTo//4osv3AaDwX333Xe7N27c6P7973/vjo2Nda9bt27Axx4u1/Scc85x33///e5Vq1a5N23a5D7vvPPcycnJ7r179w742MPlmnrZtWuXe9iwYe5DDz3U/aMf/WjAxhtu19Nms7kPOugg9+LFi92ff/65XtePP/7YvXr16gEfe7hc02eeecZtMpn0L67ne++9587NzXVfeeWVAz72oci7777rvvHGG92vvvoqsiXdr732WrfH79y5022xWNxXXXWVzk333XefzlVLliwJyvgoINxu95w5c9yXXXaZ777T6XTn5eW577zzzk6P//GPf+w+/vjj2+2bO3eu+5e//GXQxxqu17QjDofDnZiY6H766aeDOMrwv6a4jvPnz3c/9thj7p///OcUEPtxPR988EH3mDFj3K2trQM4yvC+pjj2yCOPbLcPk9+CBQuCPtZQQ3ohIK677jr3lClT2u0788wz3YsWLQrKmCLehdHa2iorVqxQk7l/Pw3c/+qrrzp9Dvb7Hw8WLVrU5fGRRn+uaUeam5vFbrdLWlpaEEca/tf0j3/8o2RlZckFF1wwQCMN3+v55ptvyrx589SFkZ2dLVOnTpU77rhDnE7nAI48vK7p/Pnz9TleN8fOnTvVJbR48eIBG3c48dUAz01h10yrr1RWVuoPAH4Q/MH9zZs3d/qc0tLSTo/HftK/a9qR3/3ud+r36/ifIVLpzzX9/PPP5fHHH5fVq1cP0CjD+3picvvwww/lJz/5iU5y27dvl0svvVSFLqoBRjr9uabnnHOOPu+QQw7RLpAOh0N+9atfyf/93/8N0KjDi9Iu5iZ07WxpadE4k0AS8RYIMvS46667NOjvtdde00As0nfQjvdnP/uZBqdmZGQM9nDCApfLpdacRx55RGbPni1nnnmm3HjjjfLQQw8N9tBCFgT8wYrzwAMPyMqVK+XVV1+Vd955R2677bbBHhrpBRFvgcCPq8FgkLKysnb7cT8nJ6fT52B/X46PNPpzTb3cc889KiCWLVsm06dPD/JIw/ea7tixQ3bv3q0R3P4TIIiJiZEtW7bI2LFjJVLpz3cUmRexsbH6PC+TJ0/WVR/M90ajUSKZ/lzTm266SYXuhRdeqPeR0dbU1CQXX3yxijO4QEjv6WpuQqvvQFsfQMR/OvhPj9XEBx980O6HFvfh7+wM7Pc/HixdurTL4yON/lxTcPfdd+vKY8mSJXLQQQcN0GjD85oixXjdunXqvvBuJ510khxxxBF6G+lykUx/vqMLFixQt4VXiIGtW7eqsIh08dDfa4pYp44iwSvQ2Kap7wz43BSU0MwQTD1CKtFTTz2lqS8XX3yxph6Vlpbq4z/72c/c119/fbs0zpiYGPc999yjKYe33HIL0zj385reddddmv718ssvu0tKSnxbQ0PDIL6L0L6mHWEWxv5dz4KCAs0Muvzyy91btmxxv/322+6srCz3n/70p0F8F6F9TfHbiWv63HPPaQri+++/7x47dqxmuhG3/v4htR0bput7771Xb+/Zs0cfx7XENe2Yxnnttdfq3ITUeKZxDgDIlx0xYoROYkhF+vrrr32PLVy4UH98/XnxxRfdEyZM0OORNvPOO+8MwqjD55qOHDlS/4N03PADQ/r/PfWHAmL/r+eXX36pKduYJJHSefvtt2uqLOnfNbXb7e5bb71VRYPZbHbn5+e7L730UndNTc0gjX5o8dFHH3X6u+i9hviLa9rxOTNnztTrj+/ok08+GbTxsZ03IYQQQvpMxMdAEEIIIaTvUEAQQgghpM9QQBBCCCGkz1BAEEIIIaTPUEAQQgghpM9QQBBCCCGkz1BAEEIIIaTPUEAQQgghpM9QQBBCCCGkz1BAEEIIIaTPUEAQQgghpM9QQBBCCCFE+sr/A6rpaA8Xs/nmAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -182,30 +187,27 @@ "source": [ "## Thompson sampling with VBLLs\n", "\n", - "VBLLs yield a Gaussian predictive distribution, and thus most acquisition functions that are straightforward to compute for Gaussian Processes (GPs) are also straightforward for VBLLs. \n", - "Moreover, parametric VBLLs are especially well-suited for Thompson sampling. \n", + "VBLLs yield a Gaussian predictive distribution, and thus most acquisition functions that are straightforward to compute for Gaussian Processes (GPs) are also straightforward for VBLLs. Moreover, parametric VBLLs are especially well-suited for Thompson sampling.\n", "\n", "For a Thompson sample, we simply sample from the variational posterior of $\\mathbf{w}$ at iteration $t$ and then construct a sample from the predictive $\\hat{f}$ as a generalized linear model:\n", "\n", "\\begin{aligned}\n", - " &\\textcircled{1} \\quad \\hat{\\mathbf{w}} \\sim q(\\mathbf{w}) \\\\\n", - " &\\textcircled{2} \\quad \\hat{f} (\\mathbf{x}) \\coloneqq \\hat{\\mathbf{w}}^\\top \\phi_{\\theta} (\\mathbf{x}).\n", + "&\\textcircled{1} \\quad \\hat{\\mathbf{w}} \\sim q(\\mathbf{w}) \\\\\n", + "&\\textcircled{2} \\quad \\hat{f} (\\mathbf{x}) \\coloneqq \\hat{\\mathbf{w}}^\\top \\phi_{\\theta} (\\mathbf{x}).\n", "\\end{aligned}\n", "\n", - "We can directly leverage this in BO to choose the next query location as $\\mathbf{x}_{t+1} = \\arg\\max_{\\mathbf{x} \\in \\mathcal{X}} \\hat{f} (\\mathbf{x})$. Compared to other standard implementation, we can numerically optimize the sample path as we can simply calculate gradients of the sample.\n", - "\n", - "\n" + "We can directly leverage this in BO to choose the next query location as $\\mathbf{x}_{t+1} = \\arg\\max_{\\mathbf{x} \\in \\mathcal{X}} \\hat{f} (\\mathbf{x})$. Since the sample is a linear model, we can numerically optimize the sample path as we can simply calculate gradients of the sample.\n" ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 4, "id": "e5d36c21", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -260,18 +262,20 @@ "id": "bbdbe329", "metadata": {}, "source": [ - "# Bayesian optimization with VBLLs" + "# Bayesian optimization with VBLLs\n" ] }, { "cell_type": "markdown", "id": "4e99876e", "metadata": {}, - "source": [] + "source": [ + "Next, lets us the VBLLs for Bayesian optimization to optimize the toy function above using Thompson sampling. Note that setting up the Thompson sampling is similar to the standard `MaxPosteriorSampling` in BoTorch." + ] }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 5, "id": "c6f36d1a", "metadata": {}, "outputs": [ @@ -280,12 +284,12 @@ "output_type": "stream", "text": [ "Iteration 0) \t Best Value: 0.3324226803440067\n", - "Early stopping at epoch 3499 with loss 8.285541518367179\n" + "Early stopping at epoch 3537 with loss 8.284433330961363\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhAAAAF2CAYAAAA/RaFTAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAuwlJREFUeJzsnQV4G1fWho9YMrMdZm6wbdqmzMzc7paZGbbdtluGLf3lLXO7xS2kTGlTStIwx3GcmBnENP/zndEokiwndmIZ5PPmmUeRLI2uRqO53z2oUxRFIUEQBEEQhE6g78yTBUEQBEEQgAgIQRAEQRA6jQgIQRAEQRA6jQgIQRAEQRA6jQgIQRAEQRA6jQgIQRAEQRA6jQgIQRAEQRA6jQgIQRAEQRA6jQgIQRAEQRA6jQgIYbt55ZVXSKfT0YYNG8KP7bPPPrx1FXfccQe/hyB057mkPbeurq5bxpTo9xF6Nzqdjs+FvoIICCI66qijKCUlhVpbW9t9zumnn05ms5nq6+vDX3TklpqaShMnTqS7776bnE5n1GvPOussSktL69AkPH/+/E6Pf/jw4VFjKSgooD333JM++ugj6kvguOHH8+OPP1J/AZ819lxqb0s0ke9lNBopJyeHdtxxR7ryyitpxYoVSf293nvvvfTxxx8n5ffa31i6dCmdcMIJNGzYMLJarTRo0CA68MAD6YknnujpoSUdxp4eQG8A4uDTTz/lCfeMM86IewH83//+R4cccgjl5uaGH8dJqT3fbrfTzz//TP/85z9p8eLF9N5773XrZ5g2bRpde+21/P+Kigp67rnn6LjjjqNnnnmGLrroIupuvv76606/Bsf5X//6F/8/1npx66230k033UTJxoQJE+j111+Peuzmm29mwXnLLbd0+3i0cxotcpqbm/lcfvXVV+npp5+mBx54gK655pou/V57gnjnEgQEJp1jjjkmKb/X/sKvv/5K++67Lw0dOpTOP/98Kioqok2bNtHvv/9Ojz/+OF1++eU9PcSkQgREyAKRnp5Ob731VlwBAfHgcDhYaEQyduxY+tvf/ha+j4na6/XShx9+SG63m9VvdwGVHTkWfI7Ro0fTo48+2q6A8Pv9FAwG2bLS1XT1PrEixpZsFBYWRn1v4P7776e8vLw2j3cHsee0Np4jjzySBer48ePpsMMOo75Md5xLve177S/cc889lJmZSfPmzaOsrKyov9XU1PTYuJIVcWEQkc1m49X6d999F/ckg7CAwIDQ2BpQvJoJuCfBOLAKKikp4fuIT8C4/v3vf9Njjz1Go0aNIovFEjZNr1q1ildgMFtD+Oy00070ySeftNnv8uXLab/99uNjNnjwYHbZQITEEi8GAqIKpmxMUniPAQMG8HEvLi7m8eXn5/PzsFrVzLuaPzDWb73DDjvwSiMWjAViCp8l8jF85kmTJvH74uJ+4YUXUmNjY4eO5ffff88uIbipcFE6+uijaeXKlVHP0ca3bt06dlnhebiQnX322W1cWtvC+vXr6cQTT+TvB+62XXfdlT7//PPw32EBw/jgboilrKyMDAYD3Xfffdv03rC6vfPOO3xO4wKtAbF82223sZsDnxXvj+P0ww8/hJ+zte91yZIlfLxGjhzJ3w3O23POOSfsKmwPWEgwGUdaRPA947jjszY1NYUfh+UEY8cxincu4f9YIMDSoo0PY4oE+0vE9xpLR94Hwv+uu+4K/4bhwvzHP/5BHo8n6nl4/IgjjmB3Cn7P+M1Onjw57ErCQgf3cdzxHS5cuDCu6xXn3sEHH8zf78CBA+nOO+/k4x8Jzg/sA9fJjIwM3i9W/J05hyNdP//973/5XMM1BuPbf//9+be1NXAtwe88VjwAuHYjefnll/lahsdxHOGChsU2lu48jvEoLy/n3wSuWxgnPt9LL73U5nlw0eBvOLbZ2dk8VsxdCQXtvAVF+frrr/FNKk888UTU4/X19YrJZFLOOOOMqMfx3HPPPVepra3lbcOGDcqbb76ppKenK3//+9+jnnvmmWcqqampW3z/l19+mfc5b968To992LBhyuGHHx71mNfrVQoLC5WioiK+X1JSwvufOHGiMnLkSOX+++9XHn30UaW0tFRZtmyZkpmZyX974IEHlCeffFLZa6+9FJ1Op3z44YfhfVZWVir5+flKdna2cscddygPPfSQMmbMGGXKlCm8b7yHxt57782bht/vV/bff39+3imnnMLvcd999yn77bef8vHHHyt2u1155pln+O/HHnus8vrrr/O2ePFifv3tt9/Of9O48847Fb1ez2OK5KeffuLnvffee+HHzjvvPMVoNCrnn3++8uyzzyo33ngjfx8777wzH6ct8c033/Brx44dqzz44IPKv/71LyUvL4+PQeTn1cY3ffp05bjjjlOefvppfl88dsMNN3Tq+5w0aVLUsauqquLvEufWLbfcojzyyCPK1KlT+fNHfj+nn346Pw/HOhKMG98lvustgbFeeuml7f4d3x/es7m5me/jvB8wYIByzTXX8HeH9xk3bhz/XhYuXMjP2dr3+u9//1vZc889+fv8z3/+o1x55ZWKzWZTZs6cqQSDwS2O96ijjlJ23HHH8H28J94HY/zss8/Cj+O3sdNOO4Xvx55LGI/FYuFxaOP79ddfE/69RtKZ98H1BI+fcMIJylNPPcXXJtw/5phj2lwX8H3gO8LvFb/3QYMGKWlpacobb7yhDB06lK8D2PD7Hz16tBIIBKLex2q18m8c1zT8Zo844gh+r3/+859trp04PzAebJdddply4okndvoc/uGHH8LHAd8txoyxp6Sk8DmxNQ466CB+j6VLl271ufj9n3XWWfweuO7jtXhvfM6eOI4Aj+FciDxugwcPVoYMGcK/EfyWcN7jeRiHBn472jnx3HPPKY8//jjPT1dccYWSSERAhMBFFyfIbrvtFvU4Jhx8MV999VXU43gs3oYfsdvt7nYBgZNfEzO4OGOSxv4uv/zyKAGRkZGh1NTURL0eP/zJkydHjRsX71mzZvFJr3HVVVfxPv7444/wY9gXfjRbExAvvfQSPwcXjli0iQJjj/0BtXfRX716dVzBd8kll/AP2+l08v2ff/6ZnwdxF8mXX34Z9/FYpk2bphQUFLCQ1MDxxYUvUlRq4zvnnHOiXo9JMzc3V9meiUY77vgsGq2trcqIESOU4cOHhy9WOEfxvC+++CJqfxB47U1cnREQmNzxHG3yx2/G4/FEPaexsZEnisjjsKXvVfueInn77bf5+XPmzNnieCFgDQaD0tLSwvf/7//+j38LmGggEgGOTVZWlnL11Ve3ey4B/D7xO40lkd/rtrzPokWL+HkQF5Fcd911/Pj3338ffgzHAo9pYijyHIFIixSUmHTwOCbwWKGiXUO03yoEmdls5u9VOy9wXYkVrpF09BzWBMSECROizi1MiHh8a8IAYgbnBDZcyyG+8JnjLRTinXsHH3wwL7Ai6a7jCGJ/JxABmJfq6uqUSHB9x3VX+wxHH300n1/djbgwQsDsecopp9Bvv/0WlY4IExBMRzChxQJT9jfffMMb4iQQJPXll1/Saaed1iHTVFcHLcJUjG3q1KkcxPn3v/+dzbeRHH/88WGTMmhoaGAT/UknncRZKEgjwwYTMsxta9euZRMamD17NpsdZ86cGX499hUbGxKPDz74gE3O8YKYtiUSHW4QBI6+++674ccCgQC9//777K+HmRHgOMAUjOBA7bNhg6kRZsVIc3sslZWVtGjRIjZBwuyqMWXKFN4fjkcssfEmMOnjWLa0tNC2gvfBMd9jjz3Cj2HsF1xwAZ+rmhvqgAMOYNPom2++GX7esmXL2E3QFX53LZNIy1bCb0aLdYH7AOcSzOswnf71118d2qf2PWkuLnw3OMfA1vaBY4vvHIFzAEHMeAwb/q99frgF8Nj2kIjvdVveRzvnYoNZtQDqWJcAzPK77bZb+P4uu+zCtzDdI9Aw9nGY2WO57LLLon6ruA/31bfffsuPwV0AFxCug9t7DmvAdRMZR6V9f/HGFwl+l7iGw92MAOAHH3yQr2Nwa8a6ZCPPPQQM49zbe++9+T1wv7uPYyyYQ3DdxPUM/4+8fuEzYYzabwTfAVyViP3oTkRARKBNhJrfCF8ILkQQFrhYxgL/HC7a2HDCIpIbMQHwiX322WfdOnacuPgB42TEBRUn2WuvvRb1IwEjRoyIug+/Ik5OZI9oAkTbbr/9dn6OFhdSWlpKY8aMafPe48aN65BvEs/rytiQk08+mebOnRsWOPBJYqx4XAMCCD80+DljPx984lsKrMLnbe/zIb4ExxgXzkgiLyYAvkjQ0XiL9sbR3hgix6nX6/kcRjqi5jeHmIBvFr7n7UWLIYCfWwNxAxBUeA/ESuC4YhKLvQC3B0QH4jYg0nGu4vXaObq1fcyYMYP9vZpY0ATEXnvtxenQECTa3yInrm0hEd/rtrwPvmt8zwiQjgSxI5hEtHOhvf1BTIMhQ4bEfTz28+C9EJ8SK96BttC65JJL+LFDDz2Ur4nw12MhtS3ncEePw5bYeeed+RqM5/7555+8sIPoRVxUpFDBtQPXbi22CeceYkninXvdcRxjqa2tZfH7n//8p821CwILaNevG2+8kQUZRBqu0Zdeeil/vkSTfGHt2wFWpYgyf/vtt/lEwi0m146ssDU0S8WcOXNYOXYXWN3jx7A1YgWFFgB53XXXsaqNR+zFqrcAoYCLA6wMV111FQde4QeMdNvIzwfxELkqjyTSGtMVxBOaoLssUsi+eeihh1hEnHrqqSyGEQCmXdi2B6zm8fm0Cf6NN95g6wxSH6+//no+zlqwJgRjR4DlC4IXr4dFCRdBfGf4DuMF50ZiMplYOOO3BiFcVVXFAgJixOfz0R9//MECAr/p7f2eu+t77ej7dNRq197+uvLz4HuHpe6rr76iL774gjcEKOJchMDcFrpifLBgQExgw2SNSRfXCiyMcH7iWo1z45FHHmEhgOfDUoLMtdhzrzuOYyzaGGA9PPPMMykeEO+aEFu9ejUvXCHeYLlA6jWCnLUU6kQgAiIGiAWsxmH2xcUXag4nYEeBCTdytdbb0VQxLsZbEyAozIIVfSw4cbcGIsZxQceFHe8Vj866MjCRQXHDjQFzIFYdmMwQqRz5vrDK7L777m3E09bA523v8yFrBaINq5dEg3G0N4bIcWrZKdOnT2fBhNXgxo0bu6SADvbz008/sRlXs0DAXYTzB8c98rvTLFdb+16xSkPmEy5wuNBpxDvH2gOCAW46fMf4PjAh4P0QjQ7xgA0Camv0lYJO+K4xseAYaat3UF1dzavVyHOhK8B7wRyvrZbBmjVrwtkJGph8sWDChtfAKoFaNLiWYgHSmXM4EcCtprklAer+IGsFbo1I68KWXJrdcRwjgejFbw1uuo4sDnEtwqIKG1wjyHBDJgsWWYkqKSAujBg0awMuaFDVnbE+aCcmQBxCXwCrB6Rb4seu/bhizWgayP9HQRaYBSP/3t7qPjb2Aib/J598sl21DnM0iEzB2xr4sWBMSGvC/iPdF9oKFz9ApL3FE3tbei+kmWJVjFVU5POwEkfMSXfVQ8D74JjDt6sB1wlMm7j4wD8bCWJfMD6krsKtANPy9gA3A6wZOI6RRZC01VfkagsiMXKcW/pe470eYNydERCYCPAauCk0IYDHUcgJRdU6Ev+Ai29nzrueQjvnYo8RVtHg8MMP7/L3jPzN4rvCfSwCNGtrbMotzPXaylhLLe3sObytQADEW/1rsSOaGyXeuQe3BSwnieLJrRzHWDBGXDdhTcA1Z0vX5tjvAIIOxxTvg0VbohALRJxV7axZszgoEmxJQEBBwowL4HPGRIbJBoobF/FI8CUiPiIWBOdBrWtgIoz1HwL4iSN9z13JU089xRdf5DKjehtWlVjR4MeOOBAEI4EbbriBL8owL2M8uOjiAoDVAyw2WwLmTMRkIPgLFxJc1HEBwcoRnx8BqbAQ4KSHRQFKHccGK2ps7QGBAPcLNjw/VqkjKAo1H2BWhyA86KCD+EeLFRzMmchVj6wZEQvcAZiAsfI+99xzyeVy8YoeLoHuqlmPqolwp2EcV1xxBX9OnGeo8YGLCy7YkSCIF98VKqtefPHF7Vp8tnRO48KDwD2tqiosapikIt1DWNnD+nDsscfyxIXxPPvss/wdRlrgtvS9Il4BgW74fSDQDcJHq13SEfC9IK4Gq1sE5Glgv1pOf0cEBNyXOBfxGRGIiuuAFhDXm8DCBOZs/O4geHB+4/eE8wHWt3i1UbYHrFxxPcJ74njAPYEYF7h4NbfQeeedxyITAYWweiGeAb8RiG/NStLZc3hbQZA2rsU4J2GNwkocLjKcexAqWuwArgOa1QTXB5yvzz//PC+o4i2kuuM4xgPFxyCK8Bpcm/E7wrFG8CTOV/xf+zyIg4GlFS481KmBQMHvMlHzBtPteR99AOQx49BsKe84Nn0TaUPI173ggguU6urqqOdqaTzxtlGjRkWlcba3bdq0qVN1IGLR0jiR+haP4uJiTktE3Qjk8SPPGbnK77//ftTzlixZwqloyGvGc+666y7lxRdf3GoaJ0DKEXLAkbqF98B7IW8Z762BVCnkfyO9KTKlKV7qncbuu+8eN7UtEuRJY79Iu0KeONJWkeJVUVGhbI1vv/2W3wOvRbrakUceqaxYsSLqOdr4IlOyIr/XyGOzLel+OEY4VkhJxLHHuRlZ6yCWww47rE3q2daIPN+Qpor3Qj4+0vSWL1/e5vlIRbv33nv5/EMdBTwXY8L5jsciae97LSsr41RFvBfS0lA7AN9Je2mf7eXzx6YXY794DPnzscQ7l1atWsW1T/Ad429aSmeiv9fYMXXkfXw+H9cj0X5H+Iw333xzm/Tx9q4L8dJ1410ftPRznHtIE0ctBqToYqyRdQ5wjcDfke6M7xd1ES688MI2NVo6cg5raZyRdVwix4fjsSWQwoxU2PHjx3M6N8aDugxIoYy9Ln/yySec4oyxIJUUNXC0dPPI491dxxHEO+8xbrwPvmftuonUe1zTItNHcf4i5Re/Rcwr119/fbhmS6LQhQYtCEISgRUYmgp1pHqfIMQDAbKIc+kr8Vy9lbOS+DhKDIQgJBkwwcI8GutGEwRB6EokBkIQkgT4k5H7/cILL3DcA3y7giAIiUIsEIKQJCDNElYHCAkEqCGoShAEIVFIDIQgCIIgCJ1GLBCCIAiCIHQaERCCIAiCIPSuIEoUcsGmNQtBeVlUeNxSZTwUrUH5U7wGZaRRprYzFf9QMhTV51A8o6+UpxUEQRCE3gCiGtB8DAXVtlrgK5FFJlCo4/PPP1fWrFmjrF69WvnHP/7BhTCWLVsW9/lz587lgkwPPvggF+q59dZb+flb6wEfCQoubakgk2yyySabbLLJRttcvFCj24MoUcIU5YFRFjgW9DFAeePIVti77rorl0RFidyOgHrmaM26adMmysjI6NKxC4IgCEIy09LSwt1JUSp9a118u60OBBrxwD0BgYD69fFA7wX0SogELabRmrg90KxFa9gCYHoBEA8iIARBEASh83QkBCDhQZQop5uWlsYtli+66CJu8NNe57WqqipuBBIJ7uPx9kCTJKgkbYNyEgRBEAQhsSRcQKB9Krogos0vOgOiG9mKFSu6bP/odQ63hbbBdSEIgiAIQmJJuAsDLVPR3lprmTtv3jxuofzcc8+1eS4q56GNdCS4v6WKerBsYBMEQRAEIYl7YSDNMjJmIRLERnz33Xd01VVXhR/75ptv2o2Z2N6YDJ/P1+X7FYSeBIJ9q6lXgiAIvV1AwL2Amg9Dhw7l4Ma33nqLfvzxR/rqq6/472eccQYNGjSI4xjAlVdeSXvvvTc9/PDDdPjhh9M777xD8+fPp//85z9dNiYknSCmAhGmgpBsQDyMGDGChYQgCEKfFRA1NTUsEtBeGAGOU6ZMYfFw4IEH8t83btwYtVqaNWsWi4xbb72V/vGPf3AhKWRg7LDDDl02Jk08FBQUUEpKihSbEpIGrYgafm8Q7XJuC4KQSJKumRZyWCFWEFAZm8YJt8WaNWtYPOTm5vbYGAUhUeC8h4hA3BFaeguCIHTVHBpLv3KWajEPsDwIQjKiuS4glgVBEBJJvxIQGmLaFZIVObcFQegu+qWAEARBEARh+xABkWQMHz6cHnvsMUoWkLWDVbVkzQiCIPQuRED0IVBl85xzzuE2q/B1Dxs2jFNf6+vrKRnYZ599omqAaJk5WhaPIAiCQOQLBKnR4aVNDU5aUdFMDo+/fxSSShYQpPbzzz/z5DZgwADac889yWAwJOz91q9fzwW1xo4dS2+//Tbn+i9fvpyuv/56+uKLL+j333/nTqc9cRxgIUhU8SIIpS1VIhUEQUh2AkGF7B4/CwUIhyaXj1zeAPmDQdKRjgozrJRq6f7pXCwQ28CHH37IroJ9992XTjvtNL7FfTyeKC699FKeTL/++msutoU8fxTp+vbbb6m8vJxuueWW8HNRtOvUU0+l1NRULtT11FNPhf+GrN077riDX48S4LBmXHHFFeG/o0roddddx6/D63fZZRd2I2i88sor3C79k08+4aZo2McLL7xAVqu1jZsB1pH99tuP/w8rCcaE/SILZvLkySyENM466yz66aefuMw5BAm2DRs2xHVhfPDBBzRp0iR+bxx3FB6LBI/de++9bK1JT0/nzxpZjMzr9dJll13Gwg/jhiVHK2YmCILQ0yiKKhiqW9y0uqqF/lzfQPNLG2hpWTNVNbtJTzrKS7PQoCzUMurZgSYVzc3NqGvBt7G4XC5lxYoVfLutfPDBB4pOp+P3iNzwGDb8vaupr6/nfd97771x/37++ecr2dnZSjAYVIYNG6akp6cr9913n7J69Wrl//7v/xSDwaB8/fXX/Nz33ntPycjIUGbPnq2UlpYqf/zxh/Kf//wnvK/zzjtPmTVrljJnzhxl3bp1ykMPPaRYLBZlzZo1/PeXX35ZMZlM/Jy5c+cqq1atUux2u1JYWKi88MIL4f34/f6ox8rKynhfCxcuVIqLi8PjwvuDpqYmZbfdduPPUllZyRv28cMPP/DxbWxs5OfNnz9f0ev1yp133smfD+Ox2Wx8q4FjkJOTozz11FPK2rVr+VjgNRgrwDiGDBnCn3HDhg3Kzz//rLz11ltKMtAV57ggCN2Py+tXalrcSnFNq/JnSb3yw8pq5ctlFcrXy6qUn9fUKgs2NChLNjW12b5aVqnUtbq7ZQ6NRQREJ8CENnjw4DbiIVJEYGLC87qS33//nff/0Ucfxf37I488wn+vrq7myfOQQw6J+vvJJ5+sHHroofz/hx9+WBk7dqzi9Xrb7AeCApN6eXl51OP777+/cvPNN/P/MVHjvRYtWhT1nCuvvFLZb7/9wve/+uorFh7axB+Pww8/XLn22mvD9/fee2/eTySxAuK0005TDjzwwKjnXH/99crEiRPD93EM/va3v4XvQ1gVFBQozzzzDN+//PLLeax4PNkQASEIfQOvP6A02D3KxnqH8ldpg/Lj6moWA18uq1R+Wl2j/Lm+Pq5g6E0CQlwYnQAxD2VlZe3+HYIMgY54XiLoaNHQ2OZjuL9y5Ur+/4knnkgul4tGjhxJ559/Pn300Ufk96sBOEuXLuWYBsRZpKWlhTe4FoqLi8P7gysFZckjOf3009ndgCqI4M033+R+JnB3AOz3rrvuYtcFYjWwX5Q1RznzzoDPsfvuu0c9hvtr166NKp4UOT64QBBHgdLqmrsELebRah7uG7iFBEEQEkkwqFCL20cVTS5aXt5Mf5Q00PwNjbS8ooWanT6yGg0cyzAw00bZKWaymhIXU9dVSBBlJ0DAZFc+r6OgLDEmQUyexx57bJu/4/Hs7GzKz8/f6r6GDBlCq1ev5tgJdDq95JJL6KGHHmKRYLfbORB0wYIFbQJCMeFr2Gy2NgWLdt55Zxo1ahQ3QLv44otZmCBeQgPvgfgGpJhCRCC+AhkXiEdIBLFlnDFe9IoAM2bMoJKSEg4+xXE46aST6IADDqD3338/IWMRBKH/oSgKuXwBsrv91OzyUb3DS06vn3wBhYw6HaWYjZSfbiGDvu8WfxMB0QkQdNeVz+so6NuBBmRPP/00XX311TyBRzYHw2ofTcu0SR0ZGZHg/oQJE8L38fojjzySNwRnjh8/nq0P06dP51U8VurIKukssEJgLIMHD+asDFggNObOnUtHH300/e1vf+P7mMzRlwSBmJGWja2VYMbnwL4iwX1YTTqTBYMa7yeffDJvJ5xwAh1yyCHU0NDQI5ksgiAkB15/kIMfIRrqHG5qdfnJ7Q8SNILNZKQsm5lMhuQx/IuA6ASYVDE5IushnjsBEzj+vi2T79Z48sknuSbCwQcfTHfffXdUGicyG+65556oCfXBBx+kY445hq0M7733Hn3++ef8N1gFMEkjuwLZEG+88QYLCmQiQKhABECMILMBgqK2tpa+++47dglECoJ44LXI8MBYMCkjS0IDnVWxwv/111/ZWvLII49QdXV1lIBA9sQff/zB2ReweMSbzK+99lq2dsAdgsn/t99+42MDcdVR8N4Qefh8EDo4PnBxaO4WQRCEjrol7F5VMCC9shHplZ4ABRWFLEY9WxmyU/RJW2I+eaRQN4AVLszwIPaE0O7DRJ+IehCYgOfPn8+xCzC5w11wwQUXcAopJtHIyRaTLJ6LCRJiAxMmhAfAJPn8889z3ABEAUz4n376abg76csvv8wCAvtAjABEyLx58zgVsiOulpkzZ9KSJUtYTESCFu1wHWAcKBiFCRv7jgTpozh2EBVwx8SLj8A+/vvf/7KrBG3eb7vtNrrzzjs5rqGjILUTAmunnXZiMQLBMnv27ITVshAEIXlw+wJU2+qhdTWt9OcGxDE00NJyNb3SQDp2SwzMslFumoVsZkPSiod+187b7Xaz7xurd+T/byuo94AaB5EBlYgtgHg47rjjtmv8grA9dNU5LgiCij8QJIcnwAGQDQ4vxzNARACbycBWBrOx5xYflc0u2nFYNguW7m7nLS6MbQAiAf787qxEKQiCIHRf8GOr209NTi812H3k8Pq56qPFCMFgoEybifRJbFnoKCIgthGIBZjiBUEQhL7fWwJxDBANtXY3/9/lC5JRr+N0ytxUMxmTKPixqxABIQiCIPQ7K4PTu9nKgBRL9JZAzwkEP6KvRDIHP3YVIiAEQRCEfmNlQCwDgiCRbunxB0iv01Oq2cC9JfpyTYaeQASEIAiCkLRWBggFpFhGWhnglkg1GyknxSxWhu1ABIQgCIKQNBkTEAxaLEOLC1YGFHLSiZUhAYiAEARBEPossCq0un3U5PRRvd0byphQyBqKZciRWIaEIQJCEARB6FPVH1vZyqAKhiaXl9y+IBl0kjHR3YiAEARBEHo1CHaEWwJdK2vtHrYyICjSYlDrMmTbJJahJxABIXQ5KCvd1NREH3/8MSULuDihw2hs+W1BEBKbZtng8HAFSNxH2eQUkyoYkqkpVV8lod/Afffdx70G0HugoKCAL75oJb0l0OwJF+vITUryqpMyjsX9998f9TgmaVHeXQeagU2bNq3N46g4euihh/bImAShP4DsCFgYNjU4aeGmRpq3oYEWlzVSRZObDHo9FaRbaWCmjbJSRDz0CwvETz/9xO2iISL8fj/94x//oIMOOohWrFhBqamp7b4O9bcjhUavnCDRdvrnnzGzoH83WnWiPGVC3xJC6oEHHqALL7yQO1oKm/H5fGQymRK2fzT/EgQhMa4JFHOqs3s5gwKZFFajgQMgc1O7pr+DkBgSKuO+/PJLXjlPmjSJpk6dytYFdFhcsGDBFl8HwYALtrYVFhZSr+LDD9F7mmjffYlOO029xX08nkAOOOAAPh6w7GyJX375hXtzoE03mnxdccUV5HA4+G9ofY0ulrEWjGeffTbqfdA9sz2WLl1K++23H+8fXTzRFdRut7d53r/+9S/uqglBeNFFF5HX6w3/Da29J0+eHN4H3lMbI3jhhRdowoQJLJrGjx8f1a4b3TMx5nfffZf23ntvfs4zzzzD+/riiy+ixgC3AyxgTqeT79944400duxYbmWOzqb//Oc/WXwAnJ8Y8+LFi8PWLzwG8P9Il8zWjgHOe1jc/v3vf3OvFDwHYlp7L4DPhC6rGD/OcbRAF4Rkd004PH7uXLmiopnmlTTQX6WNVFzrIH9A4boMg7JSuDEUAiKF3k232oHQ3QtEtp6OBy7Ew4YN48kPTauWL19OvQaIBFzoIzpxMuXl6uMJFBHov3HvvffSE088EdUJNJLi4mI65JBD6Pjjj+e22phkISguu+wy/jsmXFiAamtrw1aivLw8+vHHH/k+Jji0B2+vzwcmebTkhgUEbb7fe+89bgmu7V/ju+++o5UrV/J+3377be5gislZcweceuqpdM4554SfgwZlWmPYN998k9t033PPPfx3fGZM9K+++mrUe9x0003cFRXPOfHEE+mII46gt956K+o52BcmcggGADEBUYBjgNbsaG3+6KOP8t9OPvlkbmMOwYsxYsNj23oMfvjhB/4+cIux4301QYJ26xB2aEUOaxvE9l577dXudy8IfTlrAh0s4ZpYtKmpjWuiMEN1TaBBlbgm+hbd1s47GAzSUUcdxcF1mNDaA5PX2rVracqUKSw4sIKbM2cOi4jBgwe3eb7H4+EtshUphEdC2nnDbQFLQzuTN8HVgjGWlHS5OyMyMHG33XajiRMn0osvvsj3jz322PDke95557HQeO6558KvxfGGcMDEZ7FY2CoAiwNWvNOnT+dJEpMpJsy5c+fSvvvuy++lTbqRYMLFKn7Tpk1hN9Ts2bPpyCOPpIqKCl5JY6yffvopP0fbB97v+uuv5+9l0aJFtOOOO7IlAUIxltGjR9Ndd93FIkPj7rvv5vf59ddf+XX4DtE+HQJCA8fi73//O1VXV/P74lzAeGCFgKiKB86vd955hyd0LQYC+8EY2wui7OgxgDCCgNC6tJ500kmk1+v5/SCozj77bBaCEDVdhbTzFnoDyJBQsya8nDWBtEs8ZuWsCSNZTVKbIRnaeXeb3IP5dtmyZXzx3BKYHM844wwOZMOkhwstJrzICTESmPPxYbUN4iFhIOahPfEAMIlv2qQ+L4EgDgIrWqy8Y4H5HavctLS08IbVMgQcJhb8aLHSxeQGkYCV+CWXXMIibNWqVWyRQMxKPPEA8J5wR0XGsOy+++68/8i4FTwnch/4XmFZwqSLv+2///7swoDlABNyY2MjPw8iB5PuueeeG/UZICDweCQ77bRT1P3DDjuM4yA++eQTvv/BBx/wDwDuEQ1YZDBeuIKwX7hq4FbrDB09BrBkRLZ4hyujpqaG/3/ggQeyeIIbBaIHlhLNzSIIfRG3L0A1rW5aU9XKrokFGxppTU0r12hA1sSgTNU1YTMbRDwkCd0iIGDa/eyzz9iUG8+KsCUwIWCVvG7durh/v/nmm1kpaRsmqISBgMmufN42AgEAUYDPHgsmaQRZYgWtbRAVsOqMGjWKnwP3BATEzz//zMcWk6wmKiAgINwSCSbVb775huMVYEmBS2bcuHEscLQ4AoiKyM8A8fn7779H7Sc2ENdsNrNVRXNj4BbWFaPRGLZunX766Sw0cD4uXLiQbrnllqjYjK4kNqgTF02IDACrw19//cXuHQgLuGwgSiDqBKGv4PSq8QzLy5vZNbGwtJFKGxy8lspPt9DAzBTKlqyJpCWh3yrM6hAPMP1+//33bFbtLIFAgAPWcJGNB0zymAAjt4TRzhi2+XnbAdI54SbApBjJjBkz2KoAN0Dshgk2Mg4Cvnst1gG38OPDhdFe/ANAYCMESWTAI14D0zxEgAae43K5wvcx+WPFr1mIMJli1Y64CEzkGBvOE5j/Bw4cSOvXr28z/o6cPxAIiCeAywvnHO5rwP2BVT9EA6wXCGAsLS2Nej3GgXNuS3T0GGwNCBtYRx588EGOV4FrBmMWhN4KrumoAFne5KLFiGcoUeMZICJMej0VZdqoKMNGGTaT9JxIMLqAl0ytmyirdj5RYHNwdtKkccJtgVXg//73P15xVVVV8eNwNSB6HcBdMWjQoHBmAYLKdt11V54wsBp76KGH+CIP336Pg1RNWFAQMBkvdESLgcDzEgzM/5gc/+///i/qcfjmcfwg3HDMsEqHWMCKHxkYAPElCADEd4OVOIBouO6668ITe3vgPW+//XY688wzOV4AwZiXX345m+Ejs2WwqocbAi4CTIx4DcaESfaPP/7gIEuk9KI+CO5jP5iYAUQFAgxxniB2Ae4VxCjAzXHNNdds8bjAkgL3BMYJwbHLLruE/wbBAHcF3Ghw03z++ecsWiIZPnw4W0Jg9YC1DOctROq2HIMtgeMOkYTx4rtADAWsE50RIILQXfUZtDbY1S1uFhBev0Jm9JowG9nCIC6JBKMopPe2kMlRSWZHBZnsFWR01REpQTJ5/KS3jyfKHE1JZYFAah3cCpicYEHQNvihNXBBR/CeBiaJ888/nycTmJoR0IGVI0zdPQ782Y8/rv4/9gej3X/ssYTXg9CA2NJM4hoQB3BDrFmzhlM54aKAeRyr+s1D1fHfcLvHHnuEXwfrDVbmW6rRgbiGr776ihoaGngShssA8QyaONHAY5iwMUHCjYAAWky2AO+DwFh8v0iphMh4+OGHw4WaIHyQxvnyyy+zUILFBHEdHbFA4DMh+BIWgkjrA8AYrr76ahYyiLHBeYXsjkiQvQLRgkBSxN7AxbCtx2BLZGVlcXwPUkFxriPIFO+FuAlB6GlQiwHVH0tq7eyamFfaQMsrWsjhCVC61UQDs2zc2VLiGRJEMEBGRxXZav6ijPWfUd7S5ylv2YuUWTKbbDWLyOisYfEQNKeTPWM0kd6Y3FkY3cWWIki7LEIdqZqI/o8MqIRpHuLhuOO2Y/SCsH1IFoawrXj9QbYyoKhTbYta1ClIQbKZjJRmMUocQwLR+V1sVTA5KsjsqGTxoAv6Y56kJ19KAflSB5AvdSD50gZQ0JzRo1kY0gtjW4BIOProbq9EKQiC0NWVIFGjodGhVoJEkSeAVMu8NOlqmRAUhQyeJhYLJns5me0VZHA3tHla0GgNCwW+TS0i0ieu2u62IAJiW4FY2EKwoSAIQm9Nt2xx+agOTapCogEFndDVEv0mJPgxAe4IVw2Z7eVhK4Pe1zZlO2DNIW/awJBoGEgBS3ZbV3kvQwSEIAhCkuPyqpaGeruHGpxqZ0u9TseuCWRO4P9C16Dzu8nkqCKTQxMMlW3dEXoD+VKK2B3hTRvEgkExqokFfQkREIIgCElaowGioQ6iweHlgk6GkGgYkGGS4McuQu9tZaFgZsFQHsqOUNq6IyAUQtYFX0phjwU+diV9/xMIgiAIUaKhpsXDwZBuf4CMej2LBlSDFNHQFfELjWSyl3HsAgSDwaP2eIokYMliocDWhdSB7J7o7e6IbUEEhCAIQh8GMQwQDbWtIdHgC3DwI4sGqdGwfShBTplU4xfUTe/fXCCP0enIb8sPuSJUwRA0p1F/QASEIAhCX7c0iGjoGoJ+NX6BsyPK1PiFQHSpe0VvVFMp0xDwCNEwgBRD16RQbhNKMH5hw25ABIQgCEIfQERDgspBh9Mpy1kwIGsiEsVoIS8LBcQvDOZaDD0Zv6DzOcnkRJBmJW/Wuo2kK7yYKL2o28ciAkIQBKGXZ0/U2t0cCIn7KOgkomE7MiQ0sQALQ6iiYyRBU2rIHTGYRYPflsdFnHouBbQ2lNVRyb0v1DRQBxl8TtL7HZTqdpChbl+ifBEQwnaCXg5XXXUVb9vznO0Fpaexf+kuKQidA5YFLaaBRYPPL4GQ21Hh0dxaFhINm+JmSAQsGSwWNNGAAMieCnjUe+1hy4K5pZTMLSUcpKkPiQW93w2bCAWNKRxngWyOVpuNsqyZPTJeERB9CLQqRxMndJusq6vjviLHHHMM97rIzc3t8H7mzZu3xX4XnSWeIEH/C/S6EAShgxUhnWpxp3ou7oTsCR2lW42UZbOJaOiEeR+xCxy/0FqmCoYYAtbskFgYQt70QVwOumetC5Vkbl5PlqZ1ZHJUs1Aw+BykC3jCMRdBUzoFbHnkNaVxRUoEavpTCjh4s8yfQVPzhvbIRxAB0UdA58bddtuNm0+h6RJ6HaBl9fXXX09ffPEFt8vOycnp0L7QJCrRoNuq1nFVEIT4vSe04k6o1YBsCnSrTbcYaWCm1GnouGDYFLIyQDDUt3kOXBDIjvCyS2JQj2VI6His5WRuKiZr81oyN5eSwdvC7ghdUAvU1LF1AVaQgDmdx+vJGB4SCwUcf6GYUqI/X7Or5ywmPfKuwja1RjebzfT1119zd8qhQ4dy98pvv/2WysvL6ZZbbgk/t7W1lTtSwsqAVulPPfVUG4vBY2j8FQJuBnTAhLBA8xR0iEQ3y0g+/fRT7jyJBk15eXl07LHH8uPotIp26+hyiQuedtGDCwMdJwE6g+LxVatWRe3z0UcfpVGjRoXvL1u2jD9TWloat8VGe2xYWgQhmbpcQjCsrW7lLpcLNzbSpkYnGXR6rghZlGGlVItRxMMWJmFL4xpK3/gd5ax4lfKXPEuZ6z8nW+3isHjAqtxZMJ2aRx5BtVMuooaJZ1Dr0P3JkzOu+8SDEiSjo5pSK+ZS7rKXaMDcW2nIj1fSgN9up7zlL1Ja2Rwyt5aS3teqxlykDyP7wN2pYcLfqGbGFVS1801UuevtVDvtMmoZeQQ5i2aSN3N4G/HQ0/R7CwSakTqdbeuSdwdoC92RCwXaRqN99D333NNmVV9UVMRtq9Ei/emnn+bHHnroIfrHP/5B//rXv/h1V155JVsuDjzwwLj7P/HEE3m/sGSgC9tzzz3H7akx8cOq8fnnn7NggEh57bXXyOv10uzZs/m1aEk9depUuuCCC7gNezzw3mgT/uabb9Jdd90Vfhz3TzvttLCIgXCBkIGwcLlcdOONN9JJJ51E33//fSeOqiD0LoJBhbtcomFVdauHWt1+CioKpZmN0nuigzEMsDK055LgGgzpsC4M5tueKAmt87vJ0rSWrPWryNK8jsytGzl2QRf0RT6LgkYb+a255MsYQu7MUeTNHMkuCQ7U7GWNsjpCvxcQEA9Y8fYEdru9Q7EIa9euZaEzYcKEuH/H442NjVRbW8v3d999d7rpppvCk/fcuXN5Uo4nIH755Rf6888/qaamhiwWNZf53//+N3388cf0/vvvszCAcDnllFNYkGhANAAIDIPBQOnp6Sxm2gMi58knnwwLCIiTBQsW0BtvvMH38bfp06fTvffeG37NSy+9REOGDOHn4nMIQl8Bv9dWFHhy+rjdcovLTwElSCkmI+WnWUQ0bC1LohVuCQQ9qte0SDDZetOH9JxgCMK6UEG2uuVkbVpD5pYNoX4XvpgPYwg1yBpEnsyR5M4eR770ISGxkBxTb3J8in50UeoIiJWIvR/psogErgoImdggTFgAiouL+f+LFi1q17rQUSBArrvuOo7V2HXXXdn6MGPGDBo/fnx4HD/88ENcMYdxiIAQ+gKIY2jiWg1uanR6Oc4BoiEn1czpl0KcOgzoI9G6kUywMnBaZfR1zm/L5YkXMQzYutuMj14X1voVZG1czfELltaNpPfZ2zwP1gUUlvJkjiBP9lgWDP6U/KQRC/FI3k/WCTcCJtCeeu+OMHr0aHZ1rFy5Mhx7EAkez87O3qbgSHx2ZHP8+OOPbf6mxTB0RTAkrBNwUbz11lssIHB78cUXR43jyCOPpAceeKDNazE+QejtaZfVEA1oWuUPksWgpwyriSxGQ08PrxdWeqwMWxi4cFNMHQbOkmDBMIR86YM5RqA7LSAYl6VhJVkb13IapYlTP6OLS6EuhC+lkLyZI9gV4c6dRN6MYUktFuLRvz5tHDAxd2VKYyKAdQDuB8Q4IFgxckKvqqri1fwZZ5wRjqfAKj8S3G/P/QErAPZhNBo5uDIeU6ZMoe+++47OPvvsuH9HcGcgEPMDa8eNccMNN3CAJ7JKYJWIHMcHH3zAY8BYBKE34wsEqcmpZlDUcgZFgEx6HaVZYW3owbLGvbWXROtGVTDYK9qY+lGHwZs+NJRWOZiC5vTuGVvQRyZnLZmbS8jauJIsTetZ0CArArUWNqPjVE+IGnfWaHLnTCBX7gQiY+8KaOwJ5ErdR0CMwKxZs+jggw+mu+++OyqNE5kWiFPQQMzDgw8+yDUivvnmG3rvvfc4EDIeBxxwALs48Fy8Bq6CioqKcOAkgh9RewJBlciYwKTv9/s5iBJBjgCT/pw5c/hviKNAlkY8jjvuOLY6YNt3331p4MCBUVkmzz//PIsLiAzEVqxbt47eeecdeuGFFzjOQhB6QzAk6jSgnHSrx8fZc2kWk6RdxnSrNLdAMGzk4EedX61noKFmHQwJb0EUbkr4uIKcpWF0VJKluZisjWtY0HCgY8AdPT6DlV0P3oyR5M4ZS67cHcifOiApu2luLyIg+ghjxoyh+fPn82SOzARkZsAtgIkfj0XWgLj22mv5uQh6RFrmI488wsIjHrjoQQwgwwIWBgRiYr977bUXp1JqqZoQIQiAvP/++3mf+LvGnXfeSRdeeCELDI/H026sBgIt4ab473//ywGSkUBMQPhAlBx00EG8n2HDhtEhhxzCufGC0FPYPX52TVS1uNlVEQgGKdVskgyKiOqJqoVhIwuH2PgA7iXB1gV1C1hzEzsZKwrpvS1qvwh7JWdHWJrXk9HdyPEMm2suoEiTeXOgY9YYcuVMJG/WyO6zgvRxdEpHI/P6CC0tLZyK2NzczBNdJG63m0pKSnj1jnoG/RXEFEAMIGVSSC7kHO+6uAa4KDbHNQTIZjJyZcj+HgyJColIqdREQ2zxJq1bpTdjKNc3QBGkRPaSQNyC0Vkd7qJpbV7HNRhQpMngbQ3HLyg6AwVNaRSwZHK8git7PHmzRnO/C8XYd38rlc0u2nFYNuWmWRI+h8YiFoh+lrKKVX51dTVNmjSpp4cjCL2uyBMsDKgKiT4UdsQ1GHQcDNlVF+c+STDAq3nVLVHKE3VU4KNOpwYUsoUBsQwDE1fTgF0RdRyrANGgBmOi5kILWxcMvtbQ2HQUNKWQz5bHQZmeLGRFjCYfxpdS2O+CHROFHMV+xH/+8x+2PKBnRWyqpyD053oNDXYPVSGuwa0G+KWZ+3FcQziOoTQc/Ih0y0hQalm1MKhbolbwCGhkscANpqq4qJTB08CCAdYF1V2icNwCrAtcH8JWwGmUsDKgFHSPdtNMckRA9CMS3YFTEPqSiwJ1Gqqb3dTA9RoUSjUbKD+tf8Y1qBUfN4Y6QG5k839sjQO2MGQMY8EQtGQmqLlUTbgbJQsHV4PaL4LdEegb4SRFp2ex4LdkUjBtIDeWQjolGmMhk6Mnu2n2N0RACILQb1wUKPJU16qlXvq5TkO/rNcAtwTXY4BgKCWTszq6gJPeQF5MzCHB4IfZv4snZbV1dcVmseCsIb3fFRIMrapbwu9k8cKNpVKKKADhkFrE1g+tBXdCxIzQIURACIKQ9C4KBEJWNrs3uyg49bJ/tck2uJtCgmFDXLcEl4hmwYBtUNfGMUS0rmbRYK9koYCaEGqwYwvpPep9DnQ0p/FYAqZU8qcWhrppDunRbppCNwuI++67j5stoQsjih+hjgEqDY4bN26Lr0PK4D//+U/asGEDpy/iNYcddlgihyoIQhLh8Qeo0aFmUTQ4PORBSWmzsV+5KLhMNKoqQjC0lJLB09TWLQHBoLklujB1ES4RFI2CWDBzDEM1iwNd0B/lkgABUzpbFrwpRaSEajCgAiWsC7AydGclSqEXCYiffvqJCwShDTSKD6FDJHL8V6xY0W71x19//ZWLCUF8HHHEEVzyGLUO/vrrL9phhx0SOVxBEPp4oSdkUaA6ZBWyKNz+cBZFXlo/cFEoCmcosIUBm6OCV/5R5ZfTBpInZGXoMrcEgi7dDWF3hNleTgZ3o/qWEYJB73Px+8G64Ldks0UBrhJYPlTB0DO9LoQ+UgcCRYoKCgpYWEQWIork5JNPJofDQZ999ln4MfROmDZtGj377LNbfQ+pAyH0Z/rjOe70+qkRXS+bXFy7IRBUuF5DqsVI+iR3Uai9G9Q4BkvzhjZFnNSaB8PJkzGcJ2nFYOmifhZVIVeEamXQ+9VqjjolEIpfaCad4ud0SlgXEMMA6wIEhAiGLgDCzNPExbGaGqpo1JTdKTc7O7nrQGBAILJqYiy//fYbXXPNNVGPoYoi2kvHAxULsUV+eEEQkhuIBGRR1La6qbbVSy5fgBtYJX3XS1gZUP8AgoHbSFdEBT8qelMoW2I4bwFrVpe5I2BZYNGAgEvNsqEEufYC949QFKxIOW7BG1ELgis9QjCEGmSJYOggSpAtN0Z3E6fVGj2NbNnB/9UCWer3bvD4Se8cT9RFAqIzdJuACAaDnEK4++67b9EVgcZOWgllDdzH4/GAqwMlm4Xewx133MGCD23A+zKIwcFKfuHChWwBQ8dS9PBobGwMdyrtLF2xj/6MVla6osnFfSlAusVEWbbkrdmgWRlgYYBrQm32FN3uOmxlSEPwo3E7y0A3kxmWhZBgiK40qZDBayfiAEwIhiAFjSmcIaHVWmCrB+oxhMpXS9BjByppulHbAgKhga0KsC5ggwuoPRSDmbyWHNqkmCi9h/Ihuu1dEQuxbNky+uWXX7p0vzfffHOUxQIWiCFDhlCycdZZZ9Grr77K/zeZTDR06FDuwIm4ku3tXtnVk9p1111Hl19+OSUbCAKurKxk815HQA8RCI/HHntsm/chqOmXcFHUtLi5SiSsDSkmI+WlWsiYjNaGcCzDehYNsS2veeJAAaeMYSwatiuNMfReqjuijIUDXBCRoPYC6RRuUIk+EkGDjRRTWjh+QivgtLk5lpzbbQgGyOBtVoVCyIrAQsHdwKmr7YIYEXMmteoyqNKfQpvcNtrgNNO6VgsVNwU51gfWuDcmpVIBJamAuOyyyzimAR0bBw8evMXnopETSi1Hgvt4PB7o/oitP4DGUi+//DK7bNAAC6IMYgIiqjeAcBq09U5LS+Nte/D5fPzZuoKu2hfalrd3HnbnPvqTtQEBkUi/bHGh8yUCIpOzXTYyJriQU3MJuyZiJ3HVyjCCPJnDyZcKK4Nhu4o1oaKjZmHQ4hfCYwl6SdEZw30vggZTREpnKgWNVrUGA4uYoRSwZEvhpgh3jyYSNKuCetscXf47BmTAeMxZVONPoXJPCm1wWam41UzrWvS0qdnN7eI3g/87w/cQKFzviE7J7S70iZ5QIB4++ugj+v7779kcvDVQYvm7776LegwtqaX0siqWMPmgSyVaYqMV9yeffMJ/g/UAFons7GxKSUmhQw89lNauXRt+bWlpKXfCxN+RAYNeGBAhMNPD+gDwN1ykYe3Q3E5wEeF7Qxru1KlT6f3334+yXOD5X3zxBe244448PliY4MLAylsD+0HHTohHPAd/+/LLL8N/xxiwn3fffZf23ntvDv5788034x4DPO+ZZ57hz4cxjRw5MmpMW9oX2oJPmDCBHxs/fjw9/fTTUfv+888/afr06fx3tDGH6yIS7fM2NW1Oh0NvEVgacMxx/BCvg+8CxxDBwo8//ji/BhvGFrkPWMvwGXD8IsHvBZ1L0bsEbNq0iTuwwjqE+KGjjz6a95Ws1oaaVjctK2+m+RsaaGVlC3n9Qe58WZRh5VTMZKrLYKtZSFlrP6D8Jc9QZvEnZKtbyuIBsQyerFHUOnR/qtvhXGqYeCbZB+/FvRw6JR6CPk7lTK38nbLWvk/5i5+mnFVvU1r5z9yhksWDTkdBg4U3WCTQdIrdETo9KUYbKcYUdpHYB+1JDRNOp7opF1HzqKPIVTCN4xv6nXhA3AdqajSvp5Tq+ZRe+jVlr36X8hY/Q/mLn+H/Z5R+zX+zNBWrGSlKkC1HvpQCakgbQ8vNU+iL4C70VOuedGX5fnTcoum037cD6KQfMunqX030+MIAfbbORatqHCwecIQL0i00Y2gWHTFlAF2010i66+gd6MUzd6InTp1Oe4zO65FDkdBfI1bISMP83//+xxdELY4B5ltcOAEmvUGDBvFEBa688kq+8D/88MN0+OGH0zvvvMOtqdHHIVEiBybRnsBmMmyX3xbHsL5e9U9iwoJggKBA5CzaYqN2BlJmsfrGd+H1etkKBAGBx2ElgLvngw8+oOOPP55Wr17Nr9W+G3wnb7zxBme/oB4HXvu3v/2N8vPz+TvSuOmmm+jf//43T+aYRDFJRoJJFN/nc889xxM0WnkfddRRtHz5ct5v5H7wPG0Sbw/UCEFbcez39ddfp1NOOYWWLl3K4qC9fUFE3HbbbfTkk0/yYxAH559/Ph+LM888k+x2O6cNH3jggfyZkcmAc3FLIMZj//33p3POOYfHAlfSDz/8wFYY3F+zZg3H+0A8ARy3yIkfx1pLVYYg0sBYkboMUQLrCUQJBPTPP//M73H33XezNWrJkiVs0UhWa0Mmmlglk7WBqz9WkAVWhub1bL6OBLEDnsyRbGlA0OG2xDJw7Qd2R5SrVgZnVXQqJ4YBsWCyqS6JgJcMfifpA6FAdFyPdCbyodoj97kYwp01+2XzqaAv2prA8QkNW41NCJgzyGfJprpAKpV5U2iD00Lr7BZa20RU3uTmwmYqCILEcd+cBJBiNtCgLBsNyrbRYL5N4fsDs6ztVktFN86eIqFnBVaKACu0SGCG11a5GzduJL1eH+UjxgX11ltvZf8+JhgE5CWqBgTEw8TbvqKeYMWdB2/TigqiB1aar776imMNNOGA1TCOnzYJQRzg2J144ol8nCESJk+ezH/HZK+hZcUgxVaLgYCb5N5776Vvv/02bP3Ba2BhgBCIFBCYIDHxtgfEBQQNJnqAwmCYaBEb8NRTT4WfhyDb4447bqufH59Ha0WO5mCwUD3xxBNRFoXYfd1+++0sKLTHYFWBiMJngYDAOQdLyYsvvsiCAxaasrIytvS0x4MPPsiWisj3jexyiskdImBLLovTTz+d/v73v7O1Ac+FVeLzzz9nKwSAJQXjgvVEE5v4/eB7glBDXZW+HtuATIqaVg+3zEZsA6wNyVLsiQMgWzaQpbmYXRM6/+bJAit8FEtCHwcIh21xBXBrbXslmeybQoKhuo2pHIWYMKlhGavze9mcjsj+Ni6SUGOsLkv37FNBjPVhgaCKhfqoTIdY0LI8YMkmlymTqnyptNFto/UOC61pNdGGJj8H+fqD2msR7Ovb/H5YTKRbaHB2Cg2GUIgQC9kpfSsYOKECoiMlJmJXq9oEgU2IBnEksBpgVYpJ5bTTTmN3AcQEVqa77LJL+Lm5ublc8XPlypV8/4orruDJ8Ouvv2bXB8TElClT2n2vdevW8aQWKwxgxcAKPhJMou2BCbGiooKzbyLB/cWLF3d4P5HEurNwPzbjI3JfqCtSXFxM5557LlsdNFDcTAtmxHHC8Yi0fGzNbYb33N7zFFYiWIggACGwYA2CZQLfEcAxwncBC15svQd8pr5at6HejtLSLi78pCMd121IFmsDJiKYri0tJZz+GDmhc/VHFgywMgzrdBdLVTBUcClqBD2anDVtBEPAkkF+KzpQ6nilbHSqJaRjRYUWiKlmSnRdFcpeCbJLfA7u5IkGXZsFQ70aJNoOiPcIWHPJbsikclgTXFZaZ7fS2mYdbWxECrGH7QhE+A5gCdhsDTAb9GxJGMIiYbNYGJhlS5reK/3QLtXWjQBLQE+9d2dArAKsOljZDhw4sFPZF1ixwxSO1S1EBNwTWJG3ly0Bkz7A8+FiiiQ2aLW9qqKdpav2E7sv7bM8//zzUSILGAzb/kPWXD3bA77LE044gS0gEBC4RTE17bvF2BFfEi8mBC6RvlQlEo2skElR3eomlzdIKSZDcmRSKEF2GcAtobom1CqMGn5bvioYMkeya6AzraXZJcEplbAwbGpHMGRy4yu4GVgwuOp4HFFD1JvUfhJacyxucd13VrqdEwqtESKhPmRVqI+2/sQACw2qY7boM6jMk0LrXTZa22qm4maFNjU42VKmgmDF6IDFdKuRhoQEAt/mqIIBMQvJXsis3wsImIv6SmAWJsXRo0e3eRy+f6ym//jjj7ALA7ERiGmYOHFi+HlwaVx00UW8IXMDEyoEhOZHh+9eA6+DUIDrI9Jd0VmwmobYgXslcj+4P3PmzG3a5++//86xM5H3Y60isXVEMIb169ezyyAeOIaIp8DKXrNCYL9bAhYLWH/aq0OC4xp5TNsDY4KlBzEhCDZGjIPGjBkz2I0B99LWqsL11rbZDdzIysW9KYKKwqWlszPNfcpUG88SoFZ/XM/BdFGZDOhkmTaYPJmjWDh0Kq0RQY9ctKlMFQyOqviCIW0wV3fUhwSDtWltG7+8P6VALVudMYxbXidVHENYKNRvtiaE/h/bJCwMymhbsshnyaFmXQZtdKfQeqeVVreaaUOTjzY2OKnVjWMImwKsEtGWibw0MwsDWBSG5OA2hW8zbV3YdKyPkURnVP8FcSKIzId5Hj59mLsRRAjLAR7XYgIQqDd27FjOEkAMghZ0iKwOXMzhIoFJHStr7AP1HK6++mp2l+yxxx5cSRQTPyYyxA10lOuvv55jEEaNGsUZGPDhw/zfXqbF1kCzNbgoMCbsA9kTiF3YEpjk4caBywIBiIjxQHAujgXqiMAddMstt/AxhLhCsCNiN7YEnoeYkksuuYRFGQQDjivcGnl5eTR8+HAWddgXXE/tVWBFWXfESUBIIDYj0kqCxx566CH+HrVMFmTUoEndDTfcsNW06J4ArssWt5/bZle2IAXNRxaDoc9XiUR2BFsZmorJbN8UFZy42TWBIMhhHY8hQGCls0oVC62b2vavCLkkUJQJEfyY3NjC0FLaJtWT6zFwbQjVypAUFR9ZKNgjhEJ9B4SCnvzWbPJbcqgpJBSKnVZa02ymDY0eFgoI2o2NTeCXYsGRYWVrwrBcWBVSaGiOal3oKwvN7kSOSJKASRlZA4jqR5wCJiWkaWr1D7ASRiYGAgMhADCJPvroo/w3CA1MsBAdZ599Nq/uX3nlFQ5QhJkc7g6s3hG4hxUxgls7AyZuiI9rr72Wampq2LoBn39kBkZnwFiRnYOJe8CAAfT2229HWVrac+EgSBGTMQQNrDmY/CGsACb4Tz/9lIUArBnYH4I9ESvSHhBjcAfheMCaAuGFyR/N4AAEGIQW9uVyuTizIx4Qb3gNgjKRKRIJxozsFwShIgC0tbWVvy9kf/Q2iwSCIhucXqpqVgs+If0SVSKLMmx905TLTaLq1XiG5nVkckTXpwlYs1UrQ9YoNVOhI64JLtxUQ+aWjaE4hnLuUhlJuDATOlEaLWRyN7C1w9qwMrqglN4YdkugoBR89X3ZLaHzOcnorlMFgquORcIWXQ+aULDmUos+k4XCOoeVVjcbqXSDhzbWO0MZD9GZDgAxukgLhgUBAkG7RcaDtZOu5f5MtzbT6g6kmVZyg8kWGQpIcxTa0hPnuMsbYMFQjvLSLh8ZUPDJZuqbF2LEMzgqVdHQtC66BbZOx0IBVgZP1mi1BsJW96fwPrhIVOtGtjLEFm5i6wXSJbFZ88joaQ41yNrQpkqhmi0Bt8Rw8qajoJSpT7p/IBIMMWKh3WDGkFDA8bYbs2mTB0LBRmtajLShwU2lDU5uohb3pShOmGllcaBtsCwMykohs7HvWsMigXtwx2HZlJtmSe5mWoIgJAdYdyCDoqbFQ1UtbnJ6A5zD3idTMIN+tgZYmtaqxZUiJjKs8uEOgJUBQZDIXtgaiPZndwREQ8tGbmcdCZeiThvMggFpnBAtSPG01i+ndE7DVNqUrUYFSgiHPlUmGlUvOTahjsWCCbcQDjHHIwy3+s7goFO3OYfKfalU7LDSmhYTlVR4qLTeyem+8eITQGGGJSQSUlkkaK6HZMl46I2IgBAEocP44KZwqG6KWrtahx9BkQMz+1b+uhoEuYGtDCjsFOlPV4wW8mTAyjCKV/qYxLeeKVEeFgxGV230ExBUmTowVGNhCPnNGWSBwGgpoZSqP9taGVLy2SWBglJqEadePgFyAy50jYQ1oVa1KHCcQkO75ZuRNgrXg8+aSzXBdCpx2WhVq5XWl6tCAdasQBBNw6IbhwHUShiWm0rDc1NoWE4qDc1VAxpt5l5+nJIQERBCnyLJPG59rnYDLuzNTi+nXmbbzH3KDIw+BZprApN9ZNYC4g4gGNxZo7nPwxYnba2lNrsZNsYNfEQGRLgwU+oAMnibWKiklf2kVoeMtDIYLaqVARUo0RyrF3ev1NwPm4UC3A917cYp4LOhJgVcL62GbNrgTqU1dgutqw/QhnonldY7yOmNb1FINRtoqCYUclNpWMgFAfeY0DsQASEIQvvZFC4/Vbe42U2BWAes8gozbH3GTaH32tUqkE1ruVJj5IoYQZAQDIhn8HM76vY/E1bYauCjKhpirQbIlFAFg1qYCQIEz7M0raGM0q/atuBmK4MqGHxpAztVG6Jb4NiN5gihgNtatSlUe10jLTlqjIYljyr8abTOaaM1jTraUOakkjoH1bRGF1rSMOp1oawH1fUwgm9TOW2yL1m1+iMiIARBiJtNUdnkpjqHh/x+hVd9WX3ETYHJHlYGa+Na7gsRudrniTtrDAuHLWYtBH1kbi1nNwdEA1bdkYRbaoeqOaK+AIIlEUORuWE2me3lUVaJqFiGjBG9qvIj98Nw13ORqs1ioa7dNElYa1CIClurMZuKXSm0usVMJVVuKql3sAvC44/u86EBUTCcrQqqWMAtqjX25fTe/owICEEQwkWf0Ba4vFGNakc2RWaKqU8Eoek9TSwYYGng4ksRcOZE9hjyZEI0qL1e4qdsNnAwI0SDml7pj87ASClSKzmiMBMsFmil7CgnW92SuBUo1TTPkRzPgHTLHi/kFCrnrAqEGrXENVsVmuL2fOB+D1ZYFfI5VqEqmElrHDZa1xik9WV2tipUt8Ai0dYqAdcWXA4j8lSxMDwvlS0LaVaZcpIJ+TYFoZ+DojooMV3R7CaH20fWPtLQCi2V4SJQRUN19GSfNojcWWPYPdHeap8bXYWCGeMWZjKnhys5an0r8BrEMthqF7VtjsUVKAeFO2pCQPRsy+lGFguqZUF1QbSXKonsEggFWBVcljwq9aTSKlgV6ly0vtbOlgWHJ7oORqRVAUJhRF5aSDCk0IDMvuPmErYdERCC0E/jG2BlqGpxUXWLh9zeAKVbTXzh781uCk00WBvXkBF9ITR0OrV8dPZYVTTES7fkIk61avYFWxkq4hRmGhxRmCmH94uJ2Fa/jK0M8ZtjjVR7XXSmAmVXEipnDauCyVnLx4VdEDEFqhidjvwhqwK2VlMOrXOk0JpGhdZvtNP6WgdtbGgkf7AhbqwCCi6pYiG05aZKUGM/RgSEIPTT+AakYaLJFWr59+ZOmKp7Ip5o0JM3fTC5IRoyR8ct3aymayK9soQszRu4LHIkEAlqymREYSZujlVBtvKfOQCzK5tjbS+IS2BrghNiAW6IGk6fjJcuiQZaiPlgF0RKPjXqsml1KzIgvLR+k52Ka+xU2VwZ6iYZTarFQCNDFoWRIbEA8SCxCkIkIiCSBLRFR7dO9HZAyWmh97LPPvtwT5DHHnus297T4w+E0zAbHV6Ob8hO6b1pmAiEhGCwNK6OcU9ANAwhN2IassaQYrS1E8tQQubmEjWYMcrKYFLLRKNvRQYKM2WFJ2YIjM3NsVxd0xxrO4C7RHVBVIcFg8HTGDdeAZYQVSwUcM+MWsriks7rap1UvM5OxbUOqrOXxn2f3FQzjcxPpZH5aTQKgiE/jTtJ9mZLVL9CUVgIG7zNZPC28m8DtyjIxQHDLQ2kyzuTKG1Itw9NBEQfYGs/ZDSqwqQkCPHqN9S2eqi80UWtoaZWvTW+gVMum9aSFaIBroJI9wSLhrHxRQNXkiwjSwsm/5I2qYYczIiUSWRAcI0H9bKHgEJr3VK1OVZsXQijleMYPFkjQ8WkLN0gFmpYLGm3UWW0Iz+uKY18qYWqZcGWT9VKNq1uJFpX52CrQnFtMzU66+K+dmCmlQUCBMMoCIb8tH7dTbJXoCik9ztDwqCFDB71FjE5fN/b0n7jMLj1/H7Sedqp7plgRED0ASorK8P/R2tnNFxCq24NNIJCZ0lB0LB7fLSp2UeVzSgz7ae0XtrUSi3utJasDau5hXV4dR0R04BgyFj3BMSG6pYo4UZTUf7+sMVAC2bcbJGDO0KtPlnMPS8iV/Nok434CbyOsyYS5JrgYkxsUYBloXqLYgH1JVSrQiH5UwqpJphBq5sUWguhUGOndTUN1ORqG9wIfYhOkqNCloXRIdEgHSV7LvvFELIYsCUhJBI0i0JsK/Z4BE0pXOobwb241f5f4TFTVuYw6gnkbOoDoNWzBpqcwCIR+VgkCxYs4M6NK1asCLfOHjduXPjvzzzzDLep3rRpEzdcuvXWW+nvf/97+O/Y97PPPsudKb///ntu9f3SSy9xV050tJw3bx5NnTqVXn/9dW7PDe644w76+OOP6eKLL6a7776b6uvruSvo888/z+PVXCxoP718+XLuEDpp0iR66623eP8dHRf29/nnn9NXX33FHSkffvhhOuqoo9o9bk8//TR3HMU+MY4999yT3n//ff7bl19+yWNdtmwZGQwG2m233ejxxx8Pfya04MY4INieeOIJFmg77LADtw9Hkxl81lWrVvE+X3vtNT4+4KyzzqKmpibu6Pnkk09y23C0Cv+///s/bvcdDzwHrcTRVRSvxfugE6hmVUL77ssuu4x++eUX7rSKNuHoKorW67GBkYhxQLnpFeUt5AzqKdNmpoG9LDASE6ilaT1ZG1fx5B/pYkBRJXf2OLY0RFVkDHWxxOvMLevbdMbkSpKhdtooFx0uP43XOarCoiG2ngNW8oifQBXKhHSzDPpCgY0QClUsGtpzQ7BYSCkMiYUCqtfl0Op6P4uFdSshFmqowVkWVyygQiOsCaMLVLGAtMk+2cysD1sQDJ7mOAJB3WIrlbZBp+NzWBMGAYgESwYFTRl8i/vtNU7zNruIDD1jRRIBgR9yIH4nt4SDL72LL1iYiDCxYkJDa+pzzjmH5s6dy39DF0u0/Ibv/YADDqDPPvuM23cPHjyY4yc00Mb7kUce4Q1iBBPgyJEj6eabb6ahQ4fyPjGhffHFF+HXrFu3jv773/+y8EA3t3PPPZfbbWPC9fv93D3z/PPP50kSk+Cff/4ZntQ6Oi608UbLa0yemNRPP/10nlxzctp2RcSEjzbiEDqzZs2ihoYG+vnnn8N/dzgcdM0119CUKVPIbrezVefYY4+lRYsWkV6vj3IPYVza58axSE9PZ7GBVtsnnXQSvxYCSOO7777jTpgQTRAi+Cy5ubl0zz33xP3OcCwh+NCifODAgXw80G596dKl3PIcbdhxzNDWG23I8VxYnaKEQ1Bh4YBaDvi/1WKgbFuMqb8nCfo588HSsIrjDCJXXPDdu7PHs4siKr5Aa3KFSpLNJW3SLBHAiLgEuCawSg//lhAE2YoqkMVkbVoX/bpQDIVmaejSgk5KUM2GcFaFxQILljgBjtw0KqVAdUWkFFKzIZfWNAZobbWd1q5upbU1tVSLyplxxAL6PkAojClIo1EFaqBjX6jV0bdjENwsEKLEgac5bFXYqgUBjcJMEAWZFNQEglkTBxAKEAh97zuUdt5+L9HPD/fMYPe8lsi45UY9sbzyyit01VVX8Uo1XhDlt99+S/vvvz8/Nnv2bDr88MPJ5XLx591999155f+f//wn/DpMgJhMsbIHmNSx+oeIAL///juvzl988UWeQAEmOkyK2K9mgcBqHpM5LAPaCh/vXV5ezitvTKAY4957793mM23LuPA3TKIQMZhsY/nwww95jGVlZTzhb426ujoWXZi0YQHQLBAvvPACiyHtc5966qksEPbbbz9+7P777+fvBNYIzQIBEQWrBwQGgEXn+uuv53MS4iQyiHLjxo0sznAL8aABITVz5ky69957WeQcf/zxLGYi0YSD1x/kplbA7/PQptJS0qUXkK6T51aXw9kMZWRtWEXWprVRNRO4jDREQ864qLbY7NJoXq/GJcS4JjgAEimWcE0gmDEyVZPFBkTDOn5tZBAkV4HMGMauEI5nMFq7qIFUM1tCTCHBALdEvNRJjJOtCqlFfOuy5FNxs0JrqltDm52DW2OBHEKVRgiF0QXpfAuxIJaFBBD0hYRBc1gYbBYMzVuMQYgUCMGQIAhvfD+TrQuJEgjSzlvoMjDZaAwYMIBva2pqeAW9cuVKuuCCC9pM3lhNt7ePwsJCvp08eXLUYxBjONG0Ewz718QDgOgIBoMcqwHRgIn14IMPpgMPPJAnRwgEbXzbMi6sxPHe+GzxwPvAPYLJGQIDGywM2qS+du1athz88ccfLB4wVoCJHAKiM8cidgxw8Wjvox0LWDkgKjSXjQYESyAQoLFjx7Zxa0B0AVhS4DL5+uuv+dgde9xxNHHSZLY4+INB0pGOgyKxAO8pY1psrQUWDY2ro1b/uIhCMMBFgVW3ZjHg2g7N60J1FpA1oUQXc+I6CyNDPSY2X7JwUec4iDgdNZGVALcEWygyhrZr/u1MkCNbFRyVLBjgFonth8Ef32Bmy4jqhigiT0oBlTmMtKbGTmvW2GlNdTOV1FWw8IsFmQ9jCtNpbIR1QWIWugglyCm8UeIgQiDE9iqJB4QgLAiqMAjdhv7fVy0I24ucnXAjwBLQU+/dxSC+QENzEWiT4/bsY3v3i1gMTISwTCCuANaEb775hnbddddtGpc2jvbGAKvDX3/9xVYPTLwQC7CUIIYDaa5HHnkkT+aIq8DKH/uBcICroLPHorPHNxIIC8RgIHYFt5FobgrEnkB8ffrpZ/T1N1/TfffdR3ff/wBdfMllZIK7pReEN+g9zRzTAOEQGWeAbozurLHkzhm/OTAx1M1SbXKFuITojAHuV8FxCSOjXROhiRxigZtjoRJkZOYExEZkR81tDYIMBsLpkywYHJVtakGoH9rAWRCqZaGIhUNDMI3FwupNrbS6Gq6IFeTwtPV/Z1iNNLZQtSrwbWG6ZEN0RU+PCFGAwNTw/Q7EIUD8qcIgk3ubRAkFS8Z2i9BkRAQELk49bertJiZMmMDxEGeeeWb4MdyfOHHidu8bK/eKioqwGR6uD5jrIwM4EViIDbEUWJUjiBICIlHjMhqNvGLHBvM/hAMCQ2ERgWUE4gFBkAABil3F4sWL2b1jC8Ug4FhADAwZ0jZPG8cDFghYMbSxxAL3REHRQPr7OefR6WefR3fedgu99vJLdNlll1NPwpN501qyNawkU4S/HhUd4WJw50zgIk1sNdDcGZqLoU1cglZnYWSbOguqaCgmC3pdtJZGTQS40COeAXUhttZRsz2Q0aEJBdW6UB3XFQG3iyoUBrBYcJlzqKTBQ6urWmn1Srgi1nPWSyxmg56tCeMKVbGATeosbE+wYlNbgeBpardMdxidfrMoCAsF1cWA84hTdeU76RQiIPoR8MPDdYBJC5MqfPWIFUDcxPaCGAsIAGRSwLUBawPeC9kiiDtBfAMyJiAwMHnDhXDGGWckbFwIxFy/fj3ttddelJ2dzfEgsBRA0OA+3AMYE9woED833XQTdRWwYiBuAlYWxFJAvCBQMjI4UwOuCwSD4lgg+BXHoLa2luMsJu0wmQ465FC65uqr6YCDDuLnNjc30c9zfqLx4ydQjxAMcHdKa/2K6GDIUNoli4as0WqcAeISWkpZNJibEZfgbhOXwJaGzBFt4hLU9E61oyZiGyIDEdEymoMgs8ZwLYROXfQ16wILhgrVuhAnhx6WE18KhIK2FVGdW0erqlpp1ZpWWl1VTetqi8kXaOuKQGtqiIRxIbGA3hBGqeDYcVdDyMVgjCMUthaLgPodqkCABSEzSixwwGxva5vexxEB0Y9AJgTiCjDJI+sBQYJwLXRFEarRo0fTcccdx6mFyHhAGifSKAHiARBk+Oqrr3KKJyZtZBZceOGFCRsXrA0QIXBbIF4D2QzIAEGwphYQCZEDtwVEBdIsu6oYF4JY8X4QL4hlQOAlxtEe+KwIQr322ms56DQvL492nrkL7XvgweTxBSgYCND1V19F5eVllJ6RQQcedBA98FA3Bv6GXA7WhpVqXEPESg/Nl+CewIbo8nBcAqwFcDHEi0vIGh2KZzDFrwnBomFTjGjI546aCIQM2NTYkI6AfaIoFcSC2VEZ37rA/SHy1NiFtIFq905jJq2vd6qCYWkLrapaygW5Ykm3GGlcUTpvmnUhzSKX1S0SDITiEJrCmyoWmrbuakCwImcwhESCJhBCgqFLAmSF3pGFgbQzpNzBv4tiSEhPw2TRHlomQSx4bXt1D7Y7C0PYbrQ6EEiB7O9odSBwPDoLAiJ9fmRWBCmIksw6PcUxWmwRj9tNG7soCwOmfRYNDSui4hoQTKaJBsQocF0HzpxYG8qciI5LQEwCREO84kybLQ1r2ooGTu9E9cmxHetsiWPmaeRATFgWzPYKLmsdb5XqTx1A3lSIhSKOYWj26lksrKxsoZVVLVx7AdktUcdDRzQsN5XGF6XzNq4wgwZmWcUV0a5IUK0HRndjlFhgkbClaUdvIH/YgpAVIRTUuIT+GKzYL7MwkGqHiHSk/2F12lFg4o4ceEFBQYJGKAg9C/Q7YhyQUQFzOC6ryKgw9VSpadRraComW/1ydlVoF3rENXCAYs5Edj2oxaCKKa3iV9XFEBOXoPWqiMy2iI1p4OqTse6JlILQa5HemdUBd0QN97tgK4O9PG5mBNJEvWxZGMgWBr85iyqaPSwWVqxsoRUVy+KmUcKSwGJhQAbfji1IJ5tZJq+2loTGtkJhKyIBKbmRwsBv1YRClpryKK6GPkFCBcShhx7KW2eBYJCGUEJ/Ew5ol9wji9mQiwKiAZkUkfUaYDVw5SKuAWmmClsLstZ9FMfFkBcRl5DXVjSEqk+iFTdcG5GCY7OlYcuiAfsw2RG7EBIMjso2BXwgdGBR8CJuIW0QuyO8Ogu3qV6xqZlWVFbRysq11OzyxY1dmFCUQRMGwMKQwTUYelvp754pw9zKWSjsZuBbTSg0xy2S1SarAQLBkh1hTYBISJWAxSSgVzrrUGQHvmP4p2EeR00AofeC72hLPv7+BIpK9RXhwM2k4KKoXx7looCZ2J07gdw5k9jcD9dEZsnnceMS1Il/dPy4hKCPUy4RN4EmV1HVJyE40OciG+6JtpVENfeGal3AVsbdKGNXtYir4LgFFgsDuROly49gxxZavqqFVlaso1XVrW3cESaDjsYUpNOEARk0MSQYMvpxGiWOtWpBaNwsEtwQCY1brLIYtiRYIRIgDjYLBREJyU+vEhAIrkPVvp122okFBKoAIrANxX5mzJgR9zV4HrZI/40g9DZ6jXBAFkXLBrY2IG5BEwSYCCAEXLkTOa4BnS3Ty35o06tiq3EJnKWxkUUDrBWRQZRq9UkUkhpLAVgp4qVT2su5qRZuY+tD8D4sGVzjQXVJDGLx0eL204rKFlq+toWWVyyj4lo7xdZpQrDjxIEQC+qGtEpTf8uMgMuBAxYhDhpCbocGFgzxXD9R6Y+WTPJbc8LiwG+FUMgOuRtEJPRXepWAQDR8ZN0A9DAoLi7mhkjoaRAPFNVBj4TOkGTVu4U+JByAVjWyO8EkYatbyhaHyKp7MPG78iaRN30EuwZSahdtwcXQjmhQFJ7w4f5A9kXkZARrBlsacsa1KQqFWhBoww3rAkRDvGJNSNmEdQEporhFUGaj00vLyptp+fImWlZeSqUNbfP/89MtNAliYWAGTRqYye6JfuGOQN8GWBNCIoGtCrhlt8OWXQ44tmxFCIkDVTDg/xkSkyD0fgERD/QD2FKRHxQlQlOkSAtEvII9kRUEnU5nuMiPICSTcPD5Qit+RKoHfZwSaatfFlXoCW2BEQzpyh5HRl8rN7hK3/RTVHoj11rQrAXxXAwRJastjWvUoLmI/avuifEsULQPrVoYytgVgq1NC2ukU9ryw2IBxaUUo43q7R5aVtFCSxdX07LyNXEDHodk21goTIKVYWAGFaQneZaVElR7N7jrVSuCpzFkTWiIqrfR5mUGc9h6gO+VYxM4gDF7cwdTQUgWAYHUQK1nQjwsFgtvHQGlghGcqfUuQH0CScESuhq01OYtuDmrAmfZVhr6doloaairI1IClF72I9kiAyJ1OvJkjCB37kRSdAbOgshZ9350gytkT4R6VcRzMWyxZLXBzAGUeL03fSivWHU+JwdNhgVDrIVBp+OYBV/aEBYLiGFAHn+Dw0tLyppo2cIyWlreTBUx1R1xLNFUCmJhh0GZ7JLISknSyS/oC1kRIBDqN1sVthSboNVKsOSoYgFCgUVDjsQlCH1HQKDOP9o8a6AGAwQB2i+j+RKsByic89prr/Hf0Z0QNRpQ7Ac1GxADgdLD6GXQVWj1JNprwiQI20owZHUIhIQDTObdd6lW2IKg89opv+oXMgTVSRe+a1fOJPKn5LG7IH3TD1EuDK7TELI0xEu51NIuEdMA0cDNrjT0BlWU5IznEtSY0PD3tLI5LBhgoeiIYGhyelkoLClTBUOshQEZrSPz0miHQRk0mQVDJqVZe/3ap1Mgw0QTCRBmqlBo4FoK7aVDIuME7gbV1QCRkBO6ny19G4RuIaG/wvnz50cVhtJcDSh5jGh1FIhCGeHIEsBaNT5YB9AJEeWM4xWX2lZgcYBFA6miPl9Pty4UkgGHx0fVzR42tXuDQY7m766WywZXnVqEqbmE9GgmFHCSTq9XLQFpw9i1YGtcSYbKzat/ZFaEXQxc3EkXvx5E83rVRdFSsjkmIrJkdcZwMnoayNyykVKqF3AfidjJjl0S6UPIl47AR7gkrGT3+FXBsLiclpQ108aYGAaMZmR+Kk0elMWCAZaG1CSp7ggxproaVNeDJhYiXUBxyzNbNYGA21wWCUFzplgThOStRNkTdKaKliBsDw6PnyqaXLy5fAHKTjF3S/tlZDZYGldRSu0SMiK1MQQmF1c26jUYOIsCdRI01CwLFIIaT970YfGr+SEY0lHBfS6sTWui3BtqICUqT+bypIdMC9RiiC0LjRUwBANvaUNIQTyEP0ArKlpocVkzLS5rovVxsiTQL2LKYFUw7DCw71sYVIsCBEJdSCiot1FNxGJARgO7GmwQCLlhwRA0pohQEPpfJUpBSEZc3gCLBpjand4AZdlMlJPaNT/eLWF01pKtbglnUoTTI/UGcmeOpIA5i83faVV/bo60h7UgfZjqYkCDq3aC5JDvr5Ws5kj9SPdG+lCe2IzeZkqpWdCm4yF86oh58GYMZdGAfhhw4SCVctHielpcVswVH2ObTg3KstGUwZk0dXAWxzH02VbWHKOgWhJUkVBPBlgVtmRRQLaDZkmwQSSogkH6OAh9DREQgtBB3L4AVbe4aVODk83wmVYzDcpKcPBe0K9mUtQt5hV/ZMAjCighYJKbVvnXRpWDRj0HZFFw0Fy7rbjXkK1+ZVRcAwIs1VWvlcVCSv3yqNdxF03UYWDBMJQnPwgVrIIWrWmiRZtUtwSOTyR5aWa2MEAwTB2c2WWrpe7NemhSRQKLhVpVLCCTpB0jLlsUbBAKeSGhkMfCQYSCkCyIgBCErYAqhjWtbtpY7+SiRShKNDDTltAMHr2niV0UqBIZrqug03MBpaDBSibEPtSviFrVurjB1cT2u1UqQY5XsDYs5z4WHMWPugEBNykGKwWNFnZJRAU/cuBjIfe/gDWD0zL1BhYIyJRYtKmYFm5soqqW6EyJVLOBJg/OpGlDslkwwOLQVzKekD3CLb9ZLNSRwa2KhvayHrg5ly1fjU+w5YUsC3kiFISkRwSEILQDUjFr7R4qrXdypkCqGcIhgd0XFUWtElm7WA1cDK1sUVcBefowl6O0c7jBFadOqtUjkdnQnp8cvngIEVgb9D47WzVgYtcpQY7k13zsCMLk9zOnkweCgUXDUK7FALfE2ppWWriynBZubKTV1a1RcQxIVUXDqelDsmjqkCwuE43HejVB/+b4BN5q+TYySyUSxJGwRYHFAkQCtnyJURD6LSIgBCGGYFChOruHswNwazMZqSjDlrAJEe4ElJaGcIgsruS3ZHI6HuISIt0MiDVAPQfUXWgvriHsoqhbrgY7cnXCJtL7HaTozTz5BVCGOJQOyIWbMoZzZgUXjtLpOKtk4ZomWrCxlBZtamrjloBVYfrQLJo+JJtTLLsjgHRbgShggeBURYLqgmiIX5mR6yhkqtYEW37oNo9TYqUioyBspvf+4gWhm+FCTA4vlTW62GVh0OkTKhyQgplSs5BTJcPZDOg7YEohHVpVRwQ0opwwmlvB2hDERBb/A5DJvolFg6VxtZoiCL+9t5ndHsik8KQWhXobZJEncwSLBtRkgFCBxWVlVSstKN1AC0obaUO9s41bAtaFGUOzWTj0ymqPWqwCC4UaMvFtbftWBaOFfLYCdvv4WCyorgipyigIW0cEhCAQcXvn8kanWvVQIcpNtSSm2ZIS5PoKtpqFandL9UGufhA0mEnv95DBa9+cepk9hly5k7iBVHtmcqQGIh4CtRjMraVqpUJvCwUNFp4Q8Xq1a+XgkGgYEW6bDSvDglX1NH9DI6dYIqtEA+82pjCNBQO2sYW9zC0BFwRbEzYLBdyPbOAVZVVA4GlIJLBVISWfgqZ0cT8IwjYiAkLo1zi9fipvdPHmCQQpJ8WckCJQqptiGdlqF3EPA34s6GWRwLEIpFdjEBC0GGpwheZV7QbiBQMcCJla+SundnKNAayydQaeHLmrZkoRebJGcpVIuD1gZeBYhupWml9aSvNKG2h9bfTKHOmUsC7syFaG7F6TXglRoLogIBZq+BZZEPFcEGqsgioQ/BGCQawKgtC1iIAQ+iUoblTV7OY4B4fbT9mpZso1d31qIcoTp9QuZAsBr4wVJRSHYAqtfHWcOolIfm5wlbdDu30oeH/OGkrf9COlVv1BJmc1FywC8NkjJkJN3xxD3oyRPGniPVDwauH6JppX0kDzSxs4k0QDI4BlAYVosI0uSOvxrpVcrRFZEM7qsGBA74d46ZKwrKhCoYDLZKsuiGyJVRCEbkAEhNCvgJ+/plUNkGxy+jglc1B2Ste+CWIRWjdyfAPcFQCpklzZUacLNTRSrRyop+DKncxVIkkf/+eI/hbpZT9RWsVcMjevJ52iuhkQDIlMCWfBjuTKm8yWBlR+BKjL8OeaCvpzQwMtr2hhy0NkLAOsCzsPV10TPdmICgJIFQmaWKiO29Zbyw5RRUIBiwb8X1wQgtBziIAQ+k2AZJ3dSxsbHHxrMxpoQKa1a1fbXPRpNaVU/xWqpaBwQB9cFEG9ias0agIClgJ37uRwLEIsaH2NmIa0ijmhypNayWjVxeEonEmOgbuxgIDwQCOvNVWt9EfJBvpjQwMXu4pkcLaNdh6ew9uEonQyJiK+Y2sEfWqsgrOaTI4qVSy0Y1lA0KhqVSjkJl8QC5o4EgShdyACQkh6mp0+2tToZJcF9EJhurVLgwGRImmrXUIptYs4DoH99UgR1BH5zZlcRwFgslctBbA2GOIWj0JGRlrFr1y3IbIcMioYOgt3ptYh+5AXr0d7bn+AFpc20x8l9WxpgEUlvC8dcU+JnUfk0MzhOTQwSx1Dt6EE1QBHZxWZHNXcaIvbf8eJWQiYM7h6pi+1kPy2Qr7VjpkgCL0XERBCUvesKGt0coCkNxDkzAqzsetW3ughgf4QHN8Q9HHrZdRsQHwDov3ZMmC0kTt3ErnypsS1NqDIk6VpLdlqFnEtCBMsF6GKh7BYuHJ3oJYh+5E7fwqLBrvbT/PW1NLv6+vpr42N5PZtnpBTzAbaaVg2zRyRy0GQ3daQCnEd3hYWCWxZcFSxOyK20RZ/JlOqalVILQpZFwraLbctCELvRgSEkHT4AkG2NpSiZ4Xbx10yuzJA0uiopNSqeWRpVstBo+aAzu/gCR99IhDAh8JMzvypXCkyNraBK0M2riELGlg1rmVTPiZgmCywGkdcROugPclVuDMFzWmcavnHsir6bX09l4+OrACZl2ahXUfk0C4jc7ntdUJST+PGLcANURkWDPHqLCDrASLBl1rEGSGwLEjMgiAkDyIghOSqIOlQS083ODyUajZ1Xc8KLjNdQqnV88nUWsb9KbDihrUAhYiCKTC7W8idM4GtDQjyiysaGteQyV4WTkWEAEGFQwgNZ8EMdlPA1VHV6qFfl9XRb+uLaVVVdAvooTkptNvIXNp1ZC6Nyk9NbI8JBXEcjVzNUhMMRndd27gFiCZkQ7BQgHWhKFzRUhCE5EQEhJA0haDQ7ApNnYx6HRWmd1EFyWAgFBg5X22shMnUWcOpl97UgRzYh4nSmT+N3LkTSDFYomMaGtfw6yEWEFCJeAC4OpB2qbXBduVP5/TNTQ4jzV1bR78WL6LimPoM4wrTadYoVTQkMp6B4zfgirBXktlRwdYWvT+6URaApYQtC6kDOKgT4gF1JgRB6D+IgBD6fIttxDmg/DS6ZnZVnAMmUgQyIhNCbbikVjnExIl+ESjwhGBIuCl86UPDK21kT6AHhbVhNa/YVRdHNVdLRMdLdGp0Z40mb9YocuVPpeJgEc0tbqBfflobVTpaC4LcbVQuWxsS1f6aYxdYLJSzlQGfMTbQEb0yOBNCEwupA9i1IghC/0YEhNAnQV2D6hY3ldY72PqQZTOzeOiKIkbIpkCpaZSExmoclgMuCZ0zgRQzUjAns3DQelKojavWsqWBy1MjqNBn59gGpC6ikyaCIVHHAAGVJaYx9P2mAP0yv5Y21FeF3xsWkymDMmn30XlsaejyKpCKwgLB5Kjg5lwQDJGZHlHWhTQIhYEsFvDZ42WNCILQvxEBIfS5eg6NTrgrHOyuQAfIrohzQBCgreYvSqldHJpkK0nnd/IkClcDYhqcBdPJkz1eLYkc9JOlaR3XaDA3l7ClgVMX3Q38OmRieNOG8HORaVCWMpG+rM2hn+Y20vpatbiUJhqmDs6iPUar7ol0axeKhmCARQzHXNgr2MrAxazixC6wWEiDYBjIQkcQBGFriIAQ+lTfik0NLiprcnL/KdRz2N6CSDDhIzDSWruEYxuwOsdKHVkUfutY8maNZOHgTR/Gz4ewsDas4GBILTYA7g4EVZLi4xbZCkpI6w1UZxtJ37UOoc+XEq2uQYMsZ9g9AdGw55i8rhUNKNTkqCRzK6wLZRzwGJtKyZkRCHJMHUTetIEcwyA9IgRB2BZEQAh9ovw0rA2IEUAdBDS8spm3z6SOAMfUqj/JVreUYwCQUcGlodMGcwVEd95EzopAgKTe08y9J1DvAe4MDZSU5j6aSoDN/oiDcOlT6A/3UPqwKo/mVXgpqKidNWEfmTwok/YYk0ezRuV1iXsCwoXdEa1lZIZLgrNCNnfTBGoXzkHcshvWBVhDpE+EIAhdgQgIoVe7KxocXk7LRP+KNAvcFdbtclegzwLEgK12sZqa6Kxmq4E7cxSvxmFtcHHRJgPHNaRv/C6i7bYaUBg0ppAu4CK9X2HR4DdYabU7iz6vH0ifVKSRJ4DxecPZE3uNzac9RudRTqp5+y0McEXYy8jcWhZfMJjTyasJhrTBHH8hqZSCICQCERBCr60iiX4Om5qcnBRQlLF95adRhyG18g9KqfmLAwg5o8KSSa6c8eTNHEnOwh3JnTWWTK4aSiv/mdMvuXsmQItt1HnQGcjoauDAQ1geqh0B+qWlgN6tKqBST0b4vYbkpNA+Y/NZOGDc2xXDAJcE3BGtmzitMlYwcMBj+mC2nKiCIVMEgyD0UYKKwiVWYm8VUriAHBZV2m3k33sKERBCr8uuYHdFnYNaXT7KSbVsl7uChUPFb1zHAWZ+1HHQsiJQt8FZuBP5rXlkbVxJuaveiOoEGbBk8WoevS4srRs5ULLV7adVjQp9WltIcxyDyUWqQMhNNdPeY/Npn3H5NDx3G4s7cZZELZlbN5K5ZSO7J8IiJsrCMJi86UPYyhA0i2AQhO4icgIPxk7wwdD9kBBAYTvt//yc0PPxc9XmfPxy+f+sAnTc3A9/h5cRjkb1Ph7Hz1xHetKR0YDgaz0h/Mug05PJqNtul+62IgJC6DU0OVV3BVpRpyK7ImvbsyvYVVH5G6VW/s4reL23VRUOeVPYTYH4Bn3AzTEQ3HI7VPsAAYXurDEsHuC6QH8K1JcobnDSvAYrfdE0mNYqgylIerKZDHTA6Fzad1wBTRqYuU0WEgRxmltKw6KBgzEjCJpSWCzAuoBsEIxLBIMgbJ3ISRwLk9iVffT/o0VB3Ek+9H+e1EMTvI4n94gJPvQ3o17Pm57/r1M3Ayb9zSJBfZ2On6Nvs5/Nj21+bui2CxsB9moBMWfOHHrooYdowYIFVFlZSR999BEdc8wxW3zNjz/+SNdccw0tX76chgwZQrfeeiudddZZiRym0MOgq2RZg4tdFv6gsl3ZFWhwxcKh4hfORtD7HdzJ0g3RUDST3FnjyWzfRFkln7Oo0EAKoyt7PLfettUvJWvdcraErK9z0I8N2TTfP4UqKJd/wNOHZdN+4wpol5E5ZMFyoLOBj62byNJaysIh0uKhCRh2R7CFYSj5kdEhgkHoRxN+sJ0JPvLvkZM96dTVO9DBFsCzvU4V9Dqs0uNM9HodmXhS1/EqHrfqRK/+X5u4Iyd8Q3gfqkgwxEzw6nPV/fcXEiogHA4HTZ06lc455xw67rjjtvr8kpISOvzww+miiy6iN998k7777js677zzaMCAAXTwwQcncqhCD4CLQG2rhyfpRqeXsm1mSrUYtz0ds+I3Si/7kQMMdQE3WxycOePIMWA3ruOAug3Z694L93EIGq3kzpnIlSEt9jJKq/qdHK0ttLzOTmvqvPSnZwgtCs6gFkqj4bkpdO74QnZTZHcmGFJzS7RsUC0NsXEMqMOQWhQqaz2Me0hI0SahrxA5kasT/OZVfiD8WLS5P4j1fGjO32zCp6gJP2y61+vIEDLbY3JHszisLbDAwISP+9qqHC83hF6nTebq4xAJ0YKgv030iUKn4AzoBvBlbc0CceONN9Lnn39Oy5YtCz92yimnUFNTE3355Zcdep+WlhbKzMyk5uZmysjYHNgm9C4cHj9XkSxvcvNKAJMyftjbUgAqpfJ3yij9hl0V6BQJMz/cEI6iXXgytjauIoNnc8VFuARceZM59iGlbjEZa5dRWV0Lra+1U3GrgRYGR9NyZTiZLSm097h82n98YaeaVqEyJcSChUXDhjadKhHoCLHgzRjO1gaUxRaEngCm/djJX1vxh/+mCYCoiX/zqj+8IqfolTkmb22S11b4/P+QaX/zqj00+eP/ERN++Dm9zGyf7LR0Yg7tVTEQv/32Gx1wwAFRj8HycNVVV/XYmITEBEmW1NrJ7vFzO+rOugHCJaerfqfMki85VkEX9HJGgjt3CrkKppI+4KXUukXh1T5bG3InsXCAyEDxKEf5/2hZTSu3/S73Z9KC4FRapwymqUNz6eqJhTRzRA5f8KCxnQ47eTwe8no95PN4yedTgxuNRhMZDHpKCbRSlr+GMv3VZHVVR3WrZLcEuyRU0RCwZnXhERX6M5ETfKQYUP+v/l17XGln1a9N/jx5h1b8JgNRikWd7PEbMBk2r/bxGm3i5/+HJvvIx7RbIbnpVQKiqqqKCgsLox7DfSgil8tFNlvbLoS4qGPTwHOF3gl6ViC7AgIidVtLUAd9lFI1n7JKPiNz8wYWDkFTGjnzJpMneywZfHYOfNSAewBNq2CRQBaGZf1XVFW6lubV2qnB6aWSYBEtUGZQiz6HButqaEb999S4pJiefamaHmhqpOamRmppaqRAIDp9Ev26RmbraWyunsbk6CnDsvlzmMxmaglYqSaQTi3mIlKyhlJuYSMVFNXS4KF1NHzkaBoweAgZDOKqEFS0ST76tu3j+KcLSQAIAr1OrwbtRfjl4dM3G3XcVE6b+LVNHzHhQxzEm/xlxS/0SQGxLdx33330r3/9q6eHIWwBXyBI5Y1OzrDwBoKUn2bhi1mnUIJkrV1E2es+IktTMZdoRkEnV/Y48mYOJ4O3lV0G/FS9kTzZ47jhFRpBoaaDf97LtHrdGqqw+8mnGGi1MoTm+0bRpjXLyL74cXKXLqGl4Vjr+KSbiSYWmml8gZlG5RjIqFdIwYU9GORA0HX1flpbH6R1DR5q9iBAs5aI0Pfi1zb7MppMNGTYCBo5ZhyNnziZxu8whcZPmkIFRQPEN9uHUWIm/4B2P+L/2KID/7To+pD5PzSJw+wPK4DZoG6qK0CN5A9vmPQ5EDD6MREAQr8TEEVFRVRdXR31GO7DDxPP+gBuvvlmztqItEAge0PoHaCSZEmdnYMlM61mruvQKRSFLI2rKXvte2StX8UWB8VgIXfWKPKlDeNUTBNaUIeKKqGKJNwUDY1NtPHr96i1dAF5SU+KNYO8ipGWKuPoz7oUqlz0EzmWPUpBVwvlFRTShJ13paKBg8JbQeEAyszKpoJUHRXqGyk3WEs2b0PU5B6wZHARKk/GSLXyY0Ahe2sL2VtaqLW1mZobG6mmupJqqiqptrqKqivLaeOGEtpUup68Hg+VrFvD23dffBreZ05ePk3bcSZN22lXmj5zV5q4w1S2aAg9g7b6j9pCbgO/JgZA6LRgMQDfvyYEQpH+JrMqACxGbIbw49rEvznlL1ogCEJvplcJiN12241mz54d9dg333zDj7eHxWLhTeidqZmlDQ4OzirKsHX6gmhq2UjZa97lDpmIW1B0RvKia2T6YFymSR9Qaybgfn3aOPp5eTn9+d93yLPpeho3MI2yBgwlvTWLnIqF/vKNoAXFjZTpXEa7DMmhsaceSCNGX8ruhIzMiJgEJcjloi3NxWRpWk0GT/Pmv+nRubKIPFkjyZM5igLW3KgUS5OeKDsnl7ctAYtFVUUZla4vprWrltOq5Uto1fJlVLJuNTXU1dL3X33OG7BYrLTjLrNo1z33pVl770tjxk8SC0UXWAgw+Qcj/x/xmGYbwHNRsEezDKirez1ZTHARxBEDISGg3uqibuU7E5KRhGZh2O12WrduHf9/+vTp9Mgjj9C+++5LOTk5NHToULYelJeX02uvvRZO49xhhx3o0ksv5dTP77//nq644grOzOhoGqdkYfQ8dXYPldQ5qN7upewUE7fc7gwGVz1lr/kvpVXMZeGAyzlXhUwdQMFQ0ypkV5T7s+mzhRU0+4ffaPXC32nW1JE0a8oISs0t4P20KKm02DeEzJmD6OhdxtOEsaNIj9kglmCAAzHR+wLCQe9Tu2Zq7hBkTHgyR7K1IWhKpUThdrlYTCyc/wctmvc7LZr/BzU21Ec9B9aSPfc9kPY9+HDadY99yNqOZa6/oQqBoHob2Owu0MSB5jIIWwi0CR41AIy6kBjQk9UUEgShegCbhcDm+yIGhGSmpRNzaEIFBIpCQTDEcuaZZ9Irr7zCBaI2bNjAz4t8zdVXX00rVqygwYMH0z//+c9OFZISAdGzVodN9U4qbVTbbeemWjplddB5HZS97kNK3/SdmvqoBDnOQe0imc81E+qb7fTdinp65asF9NeiZZSZkUr77z6ddpkwkMy2FN5PnZJBLbnTaepOe9KOw3PjjyHo51RLa0g06PybA3GRscGuicxRLB56qt01fprr166m337+gX6b8wPN++0Xcrs2ixtbSirtvs/+tP8hR9K+Bx9GKSmJEzc92YlVcxWEb0OPafM4LmAcM4DJHpN8qLyvJghgJQgXCopIKVSrBUq8gCD0SgHRE4iA6DmrA+ooIOYhO8XcOatD0E8ZG76grOJPuF02ek6gcRX6UKAio9PpoiWr19MbP6yg/81dTb4gUd6AgXTQXjvSjiNzwhNAoz6PLKP2oJ12nEkDslLivg8CLS2Na7h8dWSfCWRyeLJGcVEplI3ujcWcEDfx17zf6cev4eKYzW4QDasthfY7+HA67JgTaLe99iOTafvbhScSzX2AAFu2GIQEAqwIXFwwNKdr1gLVEqCWD4cLwYoMA84y0IeFATIOIBZN7HYQUSAI24IICBEQ3W512NDg5EYvuWmdKAilKFzLIWfV29x1UhfwESkBtax0+ggqWb+e5vy1il7/fjmtrAnwSnPoxGl05P670sh0L+l1av8KZ8pgyp24D82YMo2sscJFszSwaCiOFg3mdE7v9GSPYStHXyoZjZ/tyqWL6bsvP6MvP/mANpWWhP+GGIwjjz+Fjjv1DM7y6Imx+WPEgS/kXtAiDCKbAmHCh8UgxWxgiwFEAWIMIoWBJhTEfSAIiUUEhAiIbqEeVgeOdfB02upgblxLuSteJWvjap7UERCJAMUa/UBavnIFzZ67lL5a0USlzah2Y6TdjjyVdps4iAZTNenYn01kyB1Fg6YdSKNHj4ueWBAI2bqJ9w0XRaR7ApkaqBfhzh5DfpSNToIJCT/hpYsW0OyP36MvP/mQAzE1pu+8KwuJg484tsviJbR4A2SdaO4ECAW1CZEqEFQ3gSoOLGYd2UxGthqYWSCoVgJYECAKkKIoFgNB6B2IgBABkVDQnXJjg4MrOGJBiWqSHbU66F0NlLvyVUqr/J10PhcXfvJbc2mtK4sWLF5KX85bR79sDFC1Q6H8IaNorxPPo2FpLhrs38STEyac1IETaMSOB1HugOHRPSec1WRtWMXCIbJ8NNwT7uyxLBx8qQOSQjS0h9/vp7k/fksfvPUq/fz91+ECWFnZOXT8aWfRyWeeS0UDBm1xHxACsB5oAoFv4VoIWQ+0GgVsHdCrrYRhPUCsAeIOIq0GIg4EoW8hAkIERMJodHhpPdd16GSGhd9D2Wvfp8wNX5De00IGbwv5jKm0rNFKvy9aST+urGHh0Ogm2uWg42jsXkdQtms9DVc28ctTTAbKGTaZhu90MFmyBoR3q/c0kQ2ioWEVGdwNUYGQnqwx5M4ZT760QRyA2d9A/Yn/vfcWffDWK1RRph5HVL884NCj6NRzLqIJU3cKCYUg+cLZCkiQxeSvIyNiDCDYLBAIRrKErAcWg4FdDlp1Q0EQkgcRECIguhysRMsanbShzskpch3OsFAUSiv7ibJXvUUmRxULh4CipyX1Bvp+wRr6tcRBczf6yW9Kp4NOv5Syxs8kW+1fNJrK2eKQlWKhwpFTafC0/YnSCsN9MJByaWtYSabWzYGEXIESgZDZ47nnRG8MhOzu7wyVP91eP8359gt6/7Xnacm8zVUxp86cRWdccAXte8BBlGY1hjIW1PgDLQ5BBIIg9C9aRECIgOhKWtw+Wl9j5x4WmTYzpXWw5TbiHPKWv0zW+mXcDTPg99GKeqIvFpTS76Vu+mWjnzKLhtMBZ15NvtwRlFY9n8bpVFdFUYaVBo6ZTrmT9qMgUjgVhcytpWStX8FtuZGpweh03KjKnTOBPFmjuUplf0LLZMAG1xLcDUEKsmtJtSCoIgBWBHxvxatX0MvPPUXvv/s2+Xw+3sfUqVPppptuohNPPFH6cwhCP6dFBIQIiK4AJu3KFjcV19jJ7QtwDwv4t7eG3t1EuStfo/RNP3BaZtDrpOKGAH2yoIJ+KfWyxaFo1CQ68NybqUaXTdl1f9IE3UbS6xQampNCg8dOp7Sx+3DtB3ZR1K9g4QDrhYbflsuiARuyKfqLNQEiAbcIWoTQQjMluBXMBgPHIqRZcWvk2AOumBgqnxybvYACbo8++ig999xzXPANTJgwgW677TYREoLQj2kRASECYntxev1cTbKswUmpFhNl2kwdq+dQMptyVr9LJkcFkddB5c0++nxxNX291ktzSv00YvJM2ufMG6jYbaOCxgW0g24DN6UamZdKQ8dOIdOovTmoEg2zbHVLuEKkhmK0sGBw5Uwkf0phUgZDRgkFWBSCQZ784S5i94JBT+lWI6VZTCwQtHLKcDdsS++ExsZGeuqpp7hKLP4PJk6cSLfffjudcMIJ8St3CoKQtIiAEAGxzeB0qEV6Zo2DGl1eKkiz8uS0lReRtW4p5S19nmwNK4i8dmpocdH3qxrovWVuFg5DJs6k/c69hVa0mqioeSFN0a0nq0GhMQVpNHT0JKIRe5GiN5OtfhlbG/R+V4SLYii5cnfg+AbS96r2LdvletCsCailgSwHznAICQVs6VYTux1UoaDGJ8SzJnTV7+bxxx9nIdHU1BQuP//AAw/QgQce2OXvJwhC70QEhAiI7UrPRKAk0iVzUs1bnawMrgbKW/YipW/6lrMr7A4HzS9potf+ctJXxQEqHDOd9j3vVlput1FR6xKarltLqcYgjS1Mp+Ejx1NgyCzuqBlrbYBbwpU7ibegJZP6MohP8PiD5PEF2KKAZAdkOphRbtlkoHSLkcWCFULBhGJKqqWhJ4omQTxASDz88MPU2oqW5EQHHHAA3X///bTjjjt2+3gEQeheRECIgOg0zS4fxzpUt7hZOGwtPRPFn9JLZlPeytfI6Kgit9NJ66qa6fW/7PTeCj+Z8kfTIZfeRSu9OZTbvIx21q+mTKOPxhel07Dhoyg4YAYZPI1kq1++uXmVTsdNq9COm7Mo+ljqJX5KCGKERQGCAYIMaZGomQALQopZzy3NUywGshrVqosQC72xumJdXR3dc8897N7Qgi1PP/10uu+++2jIkCE9PTxBEBKECAgREJ0OlFxX08oTXn6adcu+dEUhS8NKKvjrcXZX+D1Oqqpvpk+WtdITf3qp2ZhPh19+N5WYhlNGyxraVb+Cco1uGl+UQSOHDqFg7mgyepq5rDQ3PQgVenLl7cDCoS8FROJ4QSy4fYhVCHDmg9rmGcGMRsqymVkgWM0G7uHQF1Mi0SEXgZVvvvkmCySbzUY33ngjXX/99ZSSEqffiCAIfRoRECIgOgQyK0rq7LSpwcUWh60FSuo9zZS75D+UVfoFkcdOTS0t9FtxM93/s4cW15vpsEtup4bCnUnftJ521y+jIqOdJhSl06hBBaRLH8BZFMaIYk9Iv3TlT2OrQ2+v2YDgRnfIDeEJqD04kP1gjRALyILgLdQSOplYsGABd8n9+eef+T465SI+4tRTT+2VFhRBELYNERAiILYKumbC6oBblKLGqrldggFK3/AV5S97notBORx2WlvZTI/NddJ/V/hp1okXk3HHY8nZUEl7GpbSMEMDuyrGFmWQMSWLdH4X6UNNrNAaG5kUzvxpFLDlUm8EPwm4ICCwIBpQ2hnlm2FNQPZDVoqRUixGFgrYOpLamgzguLz//vtsfSgtLeXH9t57b3ZzTJo0qaeHJwhCFyACQgTEFl0WqCi5vtbBmQB56VvuY2Fq2kCFf/2bUmoXkc/topr6Jnp3cSs9MNdLhTMOoiFHXEF1La20u345jTeW09iCdJqUbyKTNUV1UYTiGAKWTHIWTCd3zkRSjFbqTeA4sFhg60KAdBzgqLaORjwILAwpJiNbF7aakdIPcLvdHGSJGAmXy0VGo5GuuuoqdnWkp/cdF5QgCG0RASECIi6YINfX2mljg5MyrCaO/G8PNLrKWfEqZa/9gHSeFmpuaabfi5vp1u89tNE0gqadfSdV+620q34lTdWvp7H5KTQ1j8hiNpBisLGlIeymKJiuuil6SVAk3BEuX4A3ZEgYdHqymVXrQnaq2t8DlRshIMQ83z4bNmxgt8bHH3/M9wcNGkRPPvkkHXPMMT09NEEQthERECIg2ndZ2L2Un77l2g4pFb9RwaInydxSQm6ng0qqmuixXx305hobTfn7P6k1dxxNUdbSTP1qGpNjop3y/ZRqCFDAmk1BYwoLBXS/dBbuqBZ86i2CwRsgf8gdAWtCps1IWSlmSjXDJaF2kxQ6z+zZs+mKK66g4uJivn/sscfSE088wYJCEIS+hQgIERBRLovyJicVw2UR2LLLAjUd8hc9QellP5LicVBdYxN9tqyZ/vVLkKyzziLLjCNpWLCc9tAvo3EZPtol30dZBjf5bQXsooDVAZkUcFUEzRk96pKAYEA1TdRdMLKFwUBZNhNlwSUREgx9MSuitwJXxt13300PPvggtxTHbw8pnxdddJFUsxSEPoQICBEQDFIM2WVR72TzfEZ7WRbBIGWUfE65K17mIEmnvZWWbGym++Y46DfL7jTg8MspW++kvQxLaJKtkXYt8HOGhS+lkPy2fAoabeQsmEGu/Kk9Et+AUxiplBAMCH6EQLJZVAtDdoqZ0i0mEQzdxJIlS+iCCy6gP/74g+/vueee9OKLL9KYMWN6emiCIHQAERAiILgwFFwWNS0eyk9vP8vC1LqJ8v96jFJr/iLFY6eKumZ6568merJkKNkOuoZSs/NoD/1SmmHeRLMKvDTE1MJuCV/qAApYsshZuBO58iYR6TvQK6MLQeyC04s4Bj9bWVBrAT0i8lKtHPSIEtAS8NgzBAIBevrpp+nmm28mh8PBtSNgnbjyyiulSZcg9HJEQPRjAYGvs7rFQ2trWkMdNNspDBXwU9ba9yhn9TtkdNWRw95Kvxc30kPz9LRy3PmUPmEP2km/mnYzrKbdcx002tZCii2HvGlDyJ9SQI6imZyO2V31G/C5VLeEmilh1CPo0Ui5qWbKTDGxlQFuCqF3BVmed9559N133/H93XbbjV5++WUaN25cTw9NEIR2EAHRTwUEggU31Ku9LLD6hvk+HubGNVSw8CmyNiwjcrfSxtpmem1+E72jHESBmWfReFM17alfRHtlNdKk1FYyWlPJkzGcfOlDyFG0C7lzxnVLRgViGeCWgGgIoGGXSc8Fm3LTVLcELA3JVrAp2cDl5fnnn6frrruOe2tYrVaOk7j00kslNkIQeiEiIPqhgECGAawOFU0uFg7xelno/B7KXv0OZRZ/TCZXLTkdDvp5dT09UzKQlk++mgqzU2g/w0LaJ6WUZmTaKcViIm/GMPJkjiL7wFnkyR6bcOEA14TDo4oGzC/4HLAyoB4D0k7FytA32bhxI1sjvvnmm3CDrpdeekn6aghCL0MERD8TEI0OL4uHBoePCtItcYMF2eqwCFaHFaRzt1BpnZ3eWeKkD7POJO+IPbj09EHmpTQzq5VybTrypQ1mF4Vj4Cxy54xPqHCAaLC7/eT0BbjxFFwT+WkWykpRAz8l+DE5CAaD9Mwzz3AlS2Rt4HeKKpZo0iUIQu9ABEQ/ERD46qpa3LSmupV8foWDJWNTNHUBD2WteY+y1n1CRlcVeVxOmrO6gd5smkILxlxIE8zVdJThd5qVWU+DUxUKpuaTO3citQ7eh6tGJirGAaKh1e3nIEiTUc+FrSB+0I8DlgZxTSQvq1evpjPOOIP+/PNPvn/aaadx0CV+t4Ig9CwiIPqBgEC8Q2m9k0rqHGQx6rkgUiym5vVUsPgZstYvJ4O7id0b76/006dFF5AvYygdY/iF9k7ZQGMygmRKSSd39jhqHXYgOfOnJiSrItLSYDLqWDQUZVjZypBuMZJeREO/AbUi7r33Xrrzzjs5a2PYsGHc8XP33Xfv6aEJQr+mpRNzaLfYhmGmHD58OAdQ7bLLLuGVRzxeeeUVLh8cueF1wmaQXbGqqpXW1bZy6mIb8RD0Uea6j2jgr7dRSvUCUhwN9EtxMz1cNpHeGXsvzciy07+sb9LfctfSpDwjUf44qtvhPKqZcTWnZXaleEAgJFJKK5qdXA3TatbThAHptNPQHNpxaDYNyUlhq4OIh/4F+megdwa6e44YMYKbc+211150++23s7gQBKH30zbSrot599136ZprrqFnn32WxcNjjz1GBx98MJsxCwoK4r4Gqgd/15B+BJtpcftoTVUr1dk9VJBubRMfYLRXUN6y5ymlZiGnZzY6/PRxsUJf515AlJ1K1xv+SzPSm6ko3UyBtMHUMOwgsg/Zl4LmrmuCBKOWwxsgu8fH95ExMTo/Xc2eEPeEEAFSOxctWkSXXXYZvf7662yR+P777+mtt96SAEtB6OUk3IUB0bDzzjtzkx0tkAoXhssvv5xuuummuBYIdPZramrapvdLZhdGbauH4x2Q2timvoMSpNSyOZS78k0y2TeRzttKy6u99Ll9Av2ZeQAdbJhPu5rX04hsM1lSM8g+aE9qHnkk13ToSssI4hp8wQBnTyAQEqWzYWGQQEhha7z99tt04YUXcrpnTk4O14w46qijenpYgtCvaOktLgyv10sLFizglK3wG+r1fP+3335r93V2u519ohAaRx99NC1fvrzd53o8Hv7AkVuyAY2HFtzLypvI5w9SUYYtSjzoPU2Ut+RZyl/8LFma15HP5aBPSwz0qv4oas0eTVcb36ejsjbQhKI0ooHTqXLmLVQ/6ZwuEQ+ai6K8ycUWB1gZpgzOop2H59D4ARmUlxY/K0QQYjn11FNp4cKFtNNOO1FDQwP/9rGYwG9cEITeR0Kv7HV1dRwgVVgY3ZER96uqquK+BlXqkB/+v//9j9544w22WMyaNYvKysriPh8Ne6CWtC3ZzJ4IliyutdPKyhYyGwyUm2aJ+ru1bhkN+ONeytjwNZkcFVTe4qfXKgfT3MxDaQ/TajrdMpdmFJkos2g41U67lKpm3kze7DHwC2133YnqFjfVtLrJqNfR+KI02nF4Dk0ZnEkDMm1kNUm9BqHzjBo1iubOncttwsHjjz9Oe+yxB5WUlPT00ARB6E4XRkVFBbf0/fXXX9nXqXHDDTfQTz/9FG64syV8Ph9NmDCBVyd33XVXm79jdRK5QoEFAiIiGVwYcAmsq7Gz9SEnxRJVREkX8FJGyWzKKv6EjI5KIp+Tfq8x0nz9FErTe2myrpiGZBgpJzubWoYdRM1jjqOgKXW7rQ12j58tDRAIsC4UZFi4cJVYGYSu5rPPPqMzzzyTrRFZWVn06quviktDEHqRCyOhQZR5eXncPKe6ujrqcdwvKirq0D5MJhNNnz6d1q1bF/fvFouFt2QD1RhXV7XyCj82WNLorKHsVW9SauWfZHTVkN0TpK/r8qnZXEDTdCWUp2+hEYW5FCiYRBWTziZfxrDtGovXH6Qml5etIRlWM40vQkCkhQMiBSFRHHHEEezSOOmkk3ixAZcGilDdc889fF0QBKFnSeiy0Ww204477hhupgPgksD9SIvEloALZOnSpTRgwADqLzQ5vbS0vJmDJhHvEBYPikK2mkVUsODflFY2h4zOaipu1tPs5qGUZtHTNFpDI21OGjliDDXNuIQqd/nndokHiJiKZhc1urxsbZg2NJt2HJ5Nw/PSRDwI3cLQoUNpzpw5HAsBHnroIdpvv/2osrKyp4cmCP2ehKdxIoUTZkgERs2cOZPTONHi9+yzz+a/oyId3ByIZQBI49p1111p9OjRnImBCwZyxFFHvz9Q0+Km1dWt5PEFaUCmNZzCqrksMktmk9FRQUGPg35pSCWnLoVGG6rJ6HfSiKI8Cozal8onnElBy7a5b4KKwpkUcFPAZTI8N4UKM6ycSSHptEJPgIXIo48+yrEQ55xzDv3yyy9slfzvf//LtSMEQUhSAXHyySdTbW0tF41B4OS0adPoyy+/DAdWoslOZFe+xsZGOv/88/m52dnZbMFADMXEiRMpmVEzLVzc08Kg0/OkrWFw1XPb7dSK38joqqUml4/mteZQvt5OGUod2RQvDZowgxonn0uuvCnbFCAJ9wSyKdAqG3UbJgzI4NLY8ZpyCUJPcPzxx9OUKVPouOOOo2XLlrEl4oEHHuBFiohbQeh+pJR1LwDBiRvqHLS+zk6pZmOUe8DSsJpyVr1F1oaVpHM10voWoga/mXKolVp9QSpMTyXLzn+jprEnkmK0blN56Uanl8eQnWqmQVk2TsW0GCWLQuidwIKJehEofQ1OOOEEztxKT++6YmiC0F9pkV4YfUdAYAIvrrHThnonZVoNtHr5Ek5/zc/Npj3yWyln/adkat1IPmcrrW7WUyq5KEg6cjmdVDR2R/LMupa8aLPdSTz+ADU51UqReWlmGphto9xUi1SJFPoEuGyhARfSPZGpBQvlxx9/TGPGjOnpoQlCn0YERB8REEjTRGXJ8kYXrfjrd3rskX9TTXU1pRgVOnm0m44eq6Opw/MoqNNTlVNHWTo7NfnMFPR5KW+/S8k56RRSDJZOvycyKmDyRffLgVk2ykkxSy8KoU+CgnRwbSCoEr97WCUOP/zwnh6WIPRZek0lSmHLGQ4rKlqoAuJhwa/0jxuvZ/FQlBKgy6c46diRHso3e6m+xUl2l5uydXaqcwTJa8qmjDPfJMeUMzslHiAcqlpc1OLxcaEnNLKaPCiTsytEPAh9FWRzodotunjignfkkUdyvRhkewmCkFhEQPQACFZcXtHMNR6Wz59Lt97yD358Uo6frpnqpH0Geqkgw0zpWdmUYQ6STkHrbjf5Rx9KGee8Rz5UkuyEqyJSOMwYkk2TBmZwvIMEngnJAFK80YDrkksuYdcGArYRF4GeGoIgJA5xYXQzaGm9qrKFnN4ALZv/K914w/Xw6LJoOGWMh0ZlBignM43S0eKagtTkM9Jf6+uJ9rqeZhx9cadiK/BeoCjTysGRWSmSiikkN2jAddFFF3EfnkmTJnFJfJTHFgShY4gLoxfXeFhW3kwuX4ByU4308MP/JpNeoZNGe+jsCW4al6PQwLwMyrbpSUcKlbfq6PXfauiauelUax3R4XRMWDbqHV5Ow5w+NEssDkK/AfVlUCYfVgk04UMn4G+//banhyUISYkIiG4ARh50q4TbAvYelKZevGgRuRoq6dwJLjp+pIdG5xppaF4KB1D6FD0tqvDSbV830OMrc8juN3JZ8K0VgILFAeIBvSmmDcniGAeUnBbhIPQnUIhu/vz5tMsuu3BdmYMPPpgL2CWZsVUQehwREAkmGFSotN5BKytayGQwUE6qmR93Va+jSya76JChXhpTYKEhWSYy6HQsFj5a3ExXf+2ln+pziVBUqrCIpk2fHnf/uCgipqKy2UUWk56mDMmiqUOy2PogwZFCf2XgwIH0448/0llnncUBlUj3RDVbaQ0uCF2HCIgEguJM62vttKbaTmkWI5eDBuamYtrd/yvtN9hP44pSqCBFRwGdniqdBnrou2q6408blXk3F8W59rpryaA3xG2pXdHs5hiKiQMy2F2BQEmp5SAIRFarlQtMoQw2qt3i//vvv3+b5n6CIGwbIiASBIIY11S30LpaO2XZzJRqUUtC22oWUu6K12ioZy2NKbRyloWbTLS8VqFrPq6iV0tyyU1qeqbeYOBSvfvtu1+bfVe3uMnu9dHIvFSaMSybhuamSvVIQYgB7js04po9ezYHhs2dO5fjIhYtWtTTQxOEPo8IiASAmgsrK1uotN5F+WlWbkpFSpDSNv1AOaveJuOGH8ndVE5WfZCaA1b6YZ2LLv64iX5tLSKdfnPviXvvuYf23/+AKHdFo8NLta1uNUBySDaNLUqXfhWCsBUQB4GW4GPHjqVNmzZx3QhUrhQEYdsRAdHFOL1+Fg8VTS6u9Gg26omCPsos/pSyV79LupKfyGuvJ6MSoApvKr27oIH++buNNgXzw8GOiHl48KGH6IADDozaL1prY3+Ic9hhUCZnVgiC0DHGjRtHv//+Ox144IHkdDrp2GOPpfvvv1+CKwVhG5E6EF353m4f13hAc6rCdDUWQed3UdbaDyij+FPy1hST4ndRgAxU6jDR+3810qRLXqFpu+xOixYu5B4YyLZAwKQW84A4inqHhxtsDslOoSE5KWQ1iatCELYVv9/PQZVPPvkk3//73/9Ozz//PFksnSsLLwjJiPTC6AEBgRTK1VUtZPf4OU1Tr9ORwd1E2Stfp7T1s8nZWE3GoJtayUYbGnz09godHXPX/2jwsOHtfxaXj+McsL9huanhDA5BELYfNOO64oorKBAI0KxZs+ijjz6igoKCnh6WIPQoUkiqm0FA49LyJq4uWRgSD0Z7JeX/9TClrfmQ7I2VLB5qlXRaWeGgN0oH0plPzmlXPCBIEmmZfiVIE4oyuJ6DiAdB6FpQ+vrLL7+krKws+vXXX7luxLJly3p6WILQZxABsR3AeLOpwUnLKppJp6C7pZXjGCwNK2nA7/8ic8mP1NrSSIagn8r8mbS8pJa+0u9Hlz7xGaVnZMbdJ2o6oBhUYYaVpg9VsyuMBvmaBCERHHDAARwXMXr0aNqwYQNbIiAqBEHYOjIzbVeNBwetqmohm9EQDmhM2/gdDfj9LgpWLiGHowUqgzZ6U2nxmnJaM/4qOve2p8loNMa1OiBIUiGFAySxZVjVuhGCICQ+uHLvvffmBlxoB67FRwiC0D4iILYBr1+t8bC2xs6TfDom+oCfcpc+T/mLniJ3zXpyupzkIwOVOYw0b1UV+Y96mo4464q4+2t1w+rgoaIMK5egHpydIsWgBKEbyc3Npa+//jpcufLyyy/nDQGXgiDERwREJ0H1R63GQ16amWswGFwNNOCPOyl9/Wxy1JVx4KOPjFTR7Kdfi1to8KX/o533OyKuFQPxE7A+TByQzk2vWIwIgtDtmM1mrlaJ1E4AK8RRRx3FQWWCILRFBEQn0zQR7wBXQ2G6hSs/WmuX0cDfbiNT9WJqrSujZr+OgoqeNtU56I8qE8247ScaPmFaXCFS1eKm7FQT966QWAdB6HkQw3TjjTfS+++/Tzabjb744gvaY489aOPGjT09NEHodciM1UGanF5aWtbMtwMzbWQiH9d2KFj4GCmNpdRUX0VNfjPpgwHaUNVEyzxDaM87f6DsgoFt9oVqkhAjo/JTafKgLMpKkQwLQehNHH/88dwWvKioiJYuXUozZ86kefPm9fSwBKFXIQKig/Ck7/JxmqbZWU25y16i7HUfkLe5imrrG6glYCJT0E1rNtVRZc6utMdtn5E5NTqH1h8KlNQbdBwkObogTa1UKQhCrwM9M1D+evLkydyAC0GWqBUhCIKKzF6dwKAjSq2eR7nLX6bUil/J3txI1Y0t5FF0ZPE7aEVpLQV2OImmXvoy6QzmNi6L6lY3B0pOHZxJRZlqyqcgCL2XoUOH0i+//EKHHnoouVwutkz8+9//lvLXgiACouPovHYaWPoxZWz4imx1S6mmxUO1jU0UJIUsvhZaUtpIWftcRsNPvo8ooiEWgNuj2e2j0flpNFECJQWhT4FqfJ988gldeumlLByuv/56uvjii8nn8/X00AShRxEB0RHq1lLGstcovXEFWRpW0ZoWE9mbalAInMyuRlpS7qIRx95COQddix7c4ZcFFTXLAmuVHQZl0KiCNDJJoKQg9DlQu+WJJ56gxx57jC2Hzz33HB1xxBFc7lcQ+ivdMps99dRTNHz4cLJarVwu9s8//9zi89977z0aP348Px/+x9mzZ1OPUrOSDK1lZLVvpL+abGRs3kA6XZBMjlpaVq+nSafdSeZdzokSD1o56qwUE00dnEUDMm3ishCEPgx+v1deeSW3AU9JSeG6EZKhIfRnEi4g3n33Xbrmmmvo9ttvp7/++oumTp1KBx98MNXU1MR9PmrSn3rqqXTuuefSwoUL6ZhjjuGtR2vUpxVQwOOg+fVmyrGvZbeFsaWK1nlyacbp/yL/pJOixANab9fa3VwQCsGSmSnishCEZAG1IebMmUMDBgzg6xIWRfPnz+/pYQlCt5Pwbpz4cSGaWSsNiypvQ4YM4SpvN910U5vnn3zyyeRwOOizzz4LP7brrrvStGnT6Nlnn+2RbpwNiz6nXz99iYZ6iymgBMnQXEE1aeNpzCEXUcuIw6LEA3pZuHwBGpmXSsNyU6S2gyAkKZs2beKy10jzRM2It956ixc7gtCX6TXdOL1eLy1YsIAb1oTfUK/n+7/99lvc1+DxyOcDWCzae3538Mj3JVToLSV/MEDUWE6OAbvR2EMujBIP0GFoghUIBrmi5Mh8KQwlCMkMFkLI0DjkkEM4Q+O4446jRx55RDI0hH5DQme4uro6CgQCVFhYGPU47ldVVcV9DR7vzPM9Hg8rpsitq5m25hnSe+1EjRWkH38oDdr9RGoecXhYPCBYElUlU81Gmjw4iwZmSbyDIPQHsEL79NNP6aKLLmLhcO2119Jll10mPTSEfkGfXyLfd999bG7RNqwKupppZ9xPzuZG0k05jrInHxglHlAcqrLZTTmpZpo0KINvBUHoXxkaTz/9NNeHwMIB/0ecBDp7CkIyk1ABkZeXRwaDgau4RYL7KBEbDzzemefffPPN7KvRNvglu5rRaW7a4YiLyTh0J2oeeUS4zgO6cla3emhAppWDJaW+gyD0TyAcYH344IMPonpolJWV9fTQBKFvCgh0t9txxx3pu+++Cz+GIErc32233eK+Bo9HPh9888037T7fYrGwGTFy63ImHk3uQbtS1ZDDw+IBlSVr7R4almujCQMyyGraHEgpCEL/5Nhjj+UeGnC7LlmyhIPIkX0mCMlIwl0YSOF8/vnn6dVXX6WVK1dyBTdkWZx99tn89zPOOIOtCBrIs/7yyy/p4YcfplWrVtEdd9zBKVLwK/YYRjO5B+9BSkg8ODx+anJ5aXRBKo0tzJB+FoIgtOmhMWnSJKqoqKC99tqL4yQEIdlI+MyHtEz4Bm+77TZOxVy0aBELBC1QEkVYKisrw8+fNWsWp0P95z//4ZoRaKuLwi077LAD9QZa3T5q9fhpbGEajcxLI4NegiUFQYhm2LBhNHfuXDrwwAN5wYT0zv/7v//r6WEJQt+qA9HdJKIOBCiptdPS8mZKtRppXGE6DZJMC0EQtgL6ZaCHBqywAJbURx99lAMvBaE30mvqQCQbGTYTTRyQwRUmRTwIgrA1TCYT98148MEH+T4K6h199NGSoSEkBSIgOkh2qpkmD8rknhaCIAgdBYsNdPCEOxb9fdDbZ88990xIxpggdCciIDpIVoqZctMsPT0MQRD6KMcff3w4Q2Px4sWcoYFKvYLQVxEBIQiC0E3MnDkznKGB4HFkaCBIXBD6IiIgBEEQeiBDAz1+nE4n99B46KGHpIeG0OcQASEIgtDNIModHYeRoQHhcMMNN9D555/PDQgFoa8gAkIQBKEHQConsjJQHwJdil988UXu7NnQ0NDTQxOEDiECQhAEoQe5/PLLuVJlWloa/fDDD7TrrrvSmjVrenpYgrBVREAIgiD0MIcddhj9+uuvHB+xdu1aFhHff/99Tw9LELaICAhBEIRewOTJkzlDA40DGxsbOcgSJf0FobciAkIQBKGXgBoRsDycfvrp5Pf76cILL6SrrrqK/y8IvQ0REIIgCL0IVKt8/fXX6e677+b7jz/+OB1++OHU1NTU00MThChEQAiCIPTC8te33HILl79OSUmhr7/+muMiEB8hCL0FERCCIAi9uPz1L7/8QkOGDKHVq1dz+etvv/22p4clCIwICEEQhF7M9OnT6c8//2QLBIIrUSsCtSOkcqXQ04iAEARB6OUUFRVxjYgzzjiDAoEAXXnllVy50uPx9PTQhH6MCAhBEIQ+Elz5yiuv0MMPPxyuXLnffvtRVVVVTw9N6KeIgBAEQehDwZXXXHMNzZ49m/tpoPjUzjvvTPPnz+/poQn9EBEQgiAIfQwUmUJcxPjx46msrIz22GMPeu2113p6WEI/QwSEIAhCH2Ts2LH0+++/05FHHsmxEGeeeSbHRvh8vp4emtBPEAEhCILQR4Eb4+OPP6bbb7+d7yM748ADD6SampqeHprQDxABIQiC0IdBQOUdd9xBH330EXf0/Omnn2jHHXdkF4cgJBIREIIgCEnAMcccw6Jh3LhxHBex5557cjMuqRchJAoREIIgCEnChAkTWEQce+yx5PV6uRnXeeedR263u6eHJiQhIiAEQRCSiIyMDPrggw/o/vvvZ/fGSy+9RLNmzaL169f39NCEJCOhAqKhoYHb0uKEzsrKonPPPZfsdvsWX7PPPvtwrnPkdtFFFyVymIIgCEkFrps33ngjffXVV5SXl0cLFy7kuIhPPvmkp4cmJBEJFRAQD8uXL6dvvvmGPvvsM5ozZw5dcMEFW30dSrRWVlaGtwcffDCRwxQEQUhKDjjgAPrrr79ot91243bgRx99NN10003k9/t7emhCEpAwAbFy5Ur68ssv6YUXXuAOcih08sQTT9A777xDFRUVW3wt2tei9ru2wYIhCIIgdB508vzxxx/pqquu4vsPPPAA7b///lReXt7TQxP6OAkTEL/99hu7LXbaaacoNQyf3B9//LHF17755ptsdtthhx3o5ptvJqfTmahhCoIgJD1ms5keffRReu+99yg9PZ2twdOmTeNFniD0OgGBBi8FBQVRjxmNRsrJydli85fTTjuN3njjDe48B/Hw+uuv09/+9rd2n48KbC0tLVGbIAiC0JYTTjiBFixYwOKhrq6ODj30UL7OiktD6BYBAf9ZbJBj7LZq1SraVhAjgTrvkydP5hgK1HdHgZTi4uK4z7/vvvu4Gpu2wVwnCIIgxGfMmDFsIb7kkkv4PrI1ELxeWlra00MT+hg6pZNVRmpra6m+vn6Lzxk5ciRbEa699lpqbGwMPw6Vi5a0MKMhT7kjOBwOrq4GUxuERTwLBDYNWCAgIpqbmyV2QhAEYQvgWow6EbhuwuX8/PPPs5VC6L+0tLTwYrwjc6ixszvPz8/nbWtoUb8wlyF9CHz//fcUDAY5qLKjLFq0iG8HDBgQ9+8Wi4U3QRAEoXOceOKJfH2G6xixabgPQfHYY49RampqTw9P6K8xEKiIdsghh3BKJiqjzZ07ly677DI65ZRTaODAgfwcRAGjHa1Wsx1uirvuuotFx4YNGzhn+YwzzqC99tqLpkyZkqihCoIg9FtgMf755585FgIuaGTOIfgdtSMEocfqQCCbAgIBKUOHHXYYp3KiNrsG2s6uXr06nGWBSOFvv/2WDjroIH4dXCDHH388ffrpp4kcpiAIQr/GZDLRvffey9dfWHsRxwZLMeIjAoFATw9PSJYYiGTy3wiCIAjRIDsDwewIXgdoyoVg9uHDh/f00IReNodKLwxBEAQhDGrwoJcGemgggB3uDbiQX3nlFensKUQhAkIQBEGIArEQZ599Ni1evJh23313am1t5ftHHXUUtxcQBCACQhAEQWg3wPKnn37iejuIUUNPo0mTJtFbb70l1ghBBIQgCILQPgaDgQsIain5qO2DIn/HHXecWCP6OSIgBEEQhK2C3kSoYIlUe2RtfPzxx5yuj7RPsUb0T0RACIIgCB0CwuHWW2+l+fPn084778yR+qj1g1T9devW9fTwhG5GBIQgCILQKZCVAWvEww8/TDabjZsfon8RYiW8Xm9PD0/oJkRACIIgCNsUG3HNNdfQ0qVL2QLhdrvpH//4B3f6ROClkPyIgBAEQRC2mVGjRtE333xDr7/+OvdJWrlyJXf3PPPMM6mmpqanhyckEBEQgiAIwnbXjfjb3/7GrQkuuugivo/qlWPHjuXGXGhbICQfIiAEQRCELiE7O5ueeeYZ+vXXX2n69OkcZHn11VfT1KlT2UohJBciIARBEIQuZdddd6V58+Zx80SUxoZbA00Sjz76aG7UJSQHIiAEQRCEhARZIsVzzZo1dOWVV/L9Tz75hOtJXHLJJRIfkQSIgBAEQRAS6tZAHMSyZcu4lwbag8PNgeDLu+++m+x2e08PUdhGREAIgiAICWf8+PH0v//9j3788UfaaaedWDj885//5H4bjz76KKeBCn0LERCCIAhCt7H33nvTH3/8wQ25Ro8eTbW1tVxPAv9/9tlnyePx9PQQ+waBANGPPxK9/bZ6i/vdjAgIQRAEoVvR6/V06qmn0ooVK7iXxpAhQ6i8vJwuvvhiFhJPPPEEuVyunh5m7+XDD4mGDyfad1+i005Tb3Efj3cjIiAEQRCEHuutce6559LatWvp//7v/2jgwIFUVlZGV1xxBQ0fPpweeOABamlp6elh9i4+/JDohBOIysqiHy8vVx/vRhGhU5KsjRpOtszMTM4/zsjI6OnhCIIgCB0E7otXXnmF7r//ftqwYQM/lp6eztkcEBXDhg2jfk0goFoaYsWDhk5HNHgwUUkJ0mASPoeKBUIQBEHoFVgsFrrwwgs59fPVV1/lduGtra30yCOPcNbGySefzE28kmzd23F+/rl98QBwXDZtUp/XDYiAEARBEHqda+OMM87g1M/Zs2fTAQccwOmf//3vf2nWrFlc5fK5557rfymglZVd+7ztRASEIAiC0GuDLQ899FAug71o0SI666yzyGq10uLFi7nnBmImEHiJrI5+YZUYMKBrn7edSAyEIAiC0GdoaGhg9wZSPuHqiKwzAasFmnohqyOpYyDKy1V3RQ/HQIiAEARBEPocmLp++OEHeumll+jDDz8Mp32iE+juu+9OJ5xwAh1//PE0GBNqMmZhgMjpG+IBvP8+0XHH0bYiAkIEhCAIQr8B1/3333+fW4j/9NNPUX/bbbfd6JhjjqHDDjuMJk2axAIjKUTElVdGB1TC6vLYY9slHoAICBEQgiAI/ZJNmzaxReK9996juXPnRv0Nrg0IiUMOOYT22msvysnJoT7tzvj5ZzVgEjEPe+65zW6LXicg7rnnHvr888858MVsNlNTU9NWX4Oh3H777fT888/z82GGQtOVMWPGdPh9RUAIgiAIANUtP/74Y56L4O6I7bcxZcoULq2NbebMmezu6O0WimAwyO3Rkc6qbd9++y0HlHYFvUJAQAhkZWVxVbEXX3yxQwICVcfuu+8+DpAZMWIEN1pZunQplztF5G1HEAEhCIIgxOJ0OrmRF9JCv//+e56EYyksLKSdd96Zm31NnjyZJk6cyPUnkFbaU4W1Vq5cSUuWLOEN2Sfz5s3j+S2SDz74gI7bTtdFrxIQGqgqdtVVV21VQGAYUFDXXnstXXfddfwYPgC+UOzjlFNO6dD7iYAQBEEQtkZ1dTXNmTOHYybg6sBiFbUmYoF4GDt2LPfoQCVMbRs0aBDl5eVRfn4+zzWdtVxgzsO8WFVVxVtlZSVbTIqLi8NbaWkpWxxiSUlJYaGDmhiI8dhzzz15wd4VdGYONVIvoaSkhA8iCoZo4EPssssubKJpT0BAoUV2b5O66YIgCMLWwOL0xBNP5A0giwMud6zw//rrL7Z8Y3M4HLR8+XLe2sNoNHI8hc1m4w0Wc2wQFRAlEAHYYAVBZU1t68j6HcJg6tSp7G7BNmPGDL7Fe/Y0PT+CEBAP2pcaCe5rf4sHXB7/+te/Ej4+QRAEIXnBxI/VPDYNTPoIyoSQwCIXFgFtq6yspPr6eq6G6ff7qaamZpveFwKhqKiItwEDBrDLJHLDY701LqNTAuKmm27iOIUtAX8NCnp0FzfffDP3ko+0QCRtERFBEAShWythai6L9nC73SwkUOAKVozIDRO/wWDg/WCDSEFzMLgGcAvx0NH4vj4vIBCfgFKiW2LkyJHbNBCoL80vBcWlgfvTpk3bYvMVbIIgCILQ3VitVo6HwNbf6JSAQLAItkSArAuIiO+++y4sGGBNQI1z1DoXBEEQBKH3kLBmWhs3buSAFNwiiAT/xxbZPQ2ujo8++oj/D1MPsjXuvvtu+uSTTzgiFnXNkZmBKmKCIAiCIPQeEhZEedttt3E9Bw20XwUo5rHPPvvw/1evXh2Vz3rDDTdwxOsFF1zA6S177LEHffnll33aRyQIgiAIyYiUshYEQRAEodNzaMJcGIIgCIIgJC8iIARBEARB6DQiIARBEARB6DQiIARBEARB6DQiIARBEARB6DQiIARBEARB6LvNtLoKLStVunIKgiAIQufQ5s6OVHhIOgGBFqlAGmoJgiAIwrbPpagH0a8KSaH9akVFBXc666oWqFqHT7R1leJUXYMc065HjmnXIsez65Fj2vuPJyQBxAPaSKCDaL+yQOADDx48OCH7xhckJ33XIse065Fj2rXI8ex65Jj27uO5NcuDhgRRCoIgCILQaURACIIgCILQaURAdACLxUK333473wpdgxzTrkeOadcix7PrkWOaXMcz6YIoBUEQBEFIPGKBEARBEASh04iAEARBEASh04iAEARBEASh04iAEARBEASh04iACPHUU0/R8OHDyWq10i677EJ//vnnFp//3nvv0fjx4/n5kydPptmzZ3fbWJPxmD7//PO05557UnZ2Nm8HHHDAVr+D/khnz1ONd955hyuzHnPMMQkfYzIfz6amJrr00ktpwIABHPk+duxY+e1v5zF97LHHaNy4cWSz2biq4tVXX01ut7vbxtubmTNnDh155JFcFRK/348//nirr/nxxx9pxowZfH6OHj2aXnnllcQNEFkY/Z133nlHMZvNyksvvaQsX75cOf/885WsrCyluro67vPnzp2rGAwG5cEHH1RWrFih3HrrrYrJZFKWLl3a7WNPlmN62mmnKU899ZSycOFCZeXKlcpZZ52lZGZmKmVlZd0+9mQ5pholJSXKoEGDlD333FM5+uiju228yXY8PR6PstNOOymHHXaY8ssvv/Bx/fHHH5VFixZ1+9iT5Zi++eabisVi4Vscz6+++koZMGCAcvXVV3f72Hsjs2fPVm655Rblww8/RLak8tFHH23x+evXr1dSUlKUa665huemJ554gueqL7/8MiHjEwGhKMrMmTOVSy+9NHw/EAgoAwcOVO677764zz/ppJOUww8/POqxXXbZRbnwwgsTPtZkPaax+P1+JT09XXn11VcTOMrkP6Y4jrNmzVJeeOEF5cwzzxQBsR3H85lnnlFGjhypeL3ebhxlch9TPHe//faLegyT3+67757wsfY1qAMC4oYbblAmTZoU9djJJ5+sHHzwwQkZU793YXi9XlqwYAGbzCP7aeD+b7/9Fvc1eDzy+eDggw9u9/n9jW05prE4nU7y+XyUk5OTwJEm/zG98847qaCggM4999xuGmnyHs9PPvmEdtttN3ZhFBb+f3v38wrdFwdw/JQhf4B8bbCYUkpSrFCytbBVNDtNmmxFJMqPJk2WkhI7JbExJT838lhJ2RghbIxSFpKFH/fb51PzNKZRz7keM49736+6mXvn3jo+7pzzmXvPx/3P1NTUmMnJSfP29pbDlnsrpo2NjXpM6jbH5eWl3hJqa2vLWbu95FeOxybPPUzL1v39vXYA0iGkk/XT09OsxySTyaz7y3a4i2mm/v5+ve+X+WHwKzcx3d/fN/Pz8+b4+DhHrfR2PGVw293dNV1dXTrInZ+fm0gkoomu/DdAv3MT087OTj2uublZnwL5+vpqenp6zODgYI5a7S3JT8YmeWrn8/OzzjP5m3x/BQL/nmg0qpP+1tbWdCIW7MnjeEOhkE5OLSkpyXdzPOH9/V2v5szNzZn6+nrT0dFhhoaGzOzsbL6b9mPJhD+5ijMzM2OOjo7M6uqqicfjZmxsLN9Nwx/w/RUI6VwLCgrM3d3dh+2yXlZWlvUY2W6zv9+4iWlKLBbTBGJ7e9vU1tZ+c0u9G9OLiwtzdXWlM7jTB0ARCARMIpEwwWDQ+JWbc1QqLwoLC/W4lOrqav3WJ5fvi4qKjJ+5ienw8LAmut3d3bouFW1PT08mHA5rcia3QPDnPhub5FHff/vqg/D9X0c+9PJtYmdn50NHK+tyvzMb2Z6+v9ja2vp0f79xE1MxNTWl3zw2NjZMQ0NDjlrrzZhKifHJyYnevkgt7e3tprW1VV9LuZyfuTlHm5qa9LZFKhETZ2dnmlj4PXlwG1OZ65SZJKQSNB7TZC/nY9O3TM38gaVHUkq0uLiopS/hcFhLj5LJpL4fCoWcgYGBD2WcgUDAicViWnI4MjJCGecXYxqNRrX8a2Vlxbm9vf29PD4+5vG3+NkxzUQVxtfieXNzo5VBvb29TiKRcNbX153S0lJnfHw8j7/Fz46p9J0S06WlJS1B3NzcdILBoFa6wdH+T0rbZZHhenp6Wl9fX1/r+xJLiWlmGWdfX5+OTVIaTxlnDki9bEVFhQ5iUop0eHj4+72WlhbtfNMtLy87VVVVur+UzcTj8Ty02jsxrays1A9I5iIdDNyfp+lIIL4ez4ODAy3ZlkFSSjonJia0VBbuYvry8uKMjo5q0lBcXOyUl5c7kUjEeXh4yFPr/y17e3tZ+8VUDOWnxDTzmLq6Oo2/nKMLCwvf1j4e5w0AAKz5fg4EAACwRwIBAACskUAAAABrJBAAAMAaCQQAALBGAgEAAKyRQAAAAGskEAAAwBoJBAAAsEYCAQAArJFAAAAAayQQAADA2PofOz/xQ56Kdh8AAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -298,192 +302,12 @@ "output_type": "stream", "text": [ "Iteration 1) \t Best Value: 0.3324226803440067\n", - "Early stopping at epoch 7389 with loss 5.121181297492753\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Iteration 2) \t Best Value: 0.8926797760383713\n", - "Early stopping at epoch 6599 with loss 3.4750899036796015\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Iteration 3) \t Best Value: 0.9538915741567119\n", - "Early stopping at epoch 10000 with loss 2.4829863769911618\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Iteration 4) \t Best Value: 0.9538915741567119\n", - "Early stopping at epoch 7999 with loss 1.7124188780350311\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Iteration 5) \t Best Value: 0.9538915741567119\n", - "Early stopping at epoch 8152 with loss 1.155492580065923\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhAAAAF2CAYAAAA/RaFTAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAA3GJJREFUeJzsnQV0G2fWhl8xg5nt2GFOmkLSFJMyM9OWud0y0/7Fbbtl3jJumVNMmrRpmNkhM9tiluY/98pyjLGcGGL7e87REY1Go9HMfPe78F6ZJEkSBAKBQCAQCLqAvCsLCwQCgUAgEBDCgBAIBAKBQNBlhAEhEAgEAoGgywgDQiAQCAQCQZcRBoRAIBAIBIIuIwwIgUAgEAgEXUYYEAKBQCAQCLqMMCAEAoFAIBB0GWFACAQCgUAg6DLCgBDsNm+//TZkMhm2b9/e9NohhxzCt+7igQce4O8QCHrzWIotW1tb2yvb1NPfI9izkclkfCz0F4QBAeCEE06AXq+H0+nscJlzzz0XarUadXV1TX9085vBYMCYMWPwf//3f/B4PC0+e9FFF8FoNMY1CC9ZsqTL2z9kyJAW25KamooDDzwQX375JfoTtN/o5JkzZw4GC/RbWx9LHd16mubfpVQqkZiYiClTpuCGG27AunXrBvT/+sgjj+Crr74akP/rYGP16tU47bTTkJeXB61Wi6ysLBx++OF4/vnn+3rTBhzKvt6APQEyDr799lsecC+44IJ2L4Bff/01jjrqKCQlJTW9TgdlbHmXy4V58+bh3nvvxcqVK/Hpp5/26m+YNGkSbr75Zn5cXl6OV199FaeccgpefvllXHnllehtfv755y5/hvbzgw8+yI9bey/uuece3HHHHRhojB49Gu+9916L1+688042OO++++5e357YMU0tcux2Ox/L77zzDl566SU8/vjjuOmmm7r1f+0L2juWyICgQeekk04akP/rYGH+/Pk49NBDkZubi8suuwzp6ekoKSnBggUL8Oyzz+K6667r600cUAgDotEDYTKZ8OGHH7ZrQJDx4Ha72dBozogRI3Deeec1PaeBOhAI4IsvvoDP52Prt7cgK7v5ttDvGDZsGP7zn/90aECEQiFEIhH2rHQ33b1OmhHTbaCRlpbW4n8jHnvsMSQnJ7d5vTdofUzHtuf4449nA3XUqFE45phj0J/pjWNpT/tfBwsPP/wwLBYLFi9eDKvV2uK96urqPtuugYoIYQDQ6XQ8W//tt9/aPcjIsCADgwyNziCLN+YC7ktoO2gWtG3bNn5O+Qm0XU8++SSeeeYZDB06FBqNpsk1vWHDBp6BkduaDJ+9994b33zzTZv1rl27FjNmzOB9lp2dzSEbMkJa014OBBlV5MqmQYq+IyMjg/f7li1bePtSUlJ4OZqtxty7sXhg67j1uHHjeKbRGtoWMqbotzR/jX7z2LFj+Xvp4n7FFVegoaEhrn35+++/c0iIwlR0UTrxxBOxfv36FsvEtm/z5s0csqLl6EL2j3/8o01Ia1fYunUrTj/9dP5/KNw2depUfP/9903vkweMto/CDa0pLS2FQqHAo48+ukvfTV63jz/+mI9pukDHIGP5vvvu4zAH/Vb6ftpPs2fPblqms/911apVvL8KCgr4v6Hj9uKLL24KFXYEeUhoMG7uEaH/mfY7/Vabzdb0OnlOaNtpH7V3LNFjmiCQpyW2fbRNzaH19cT/2pp4vocM/3/9619N5zCFMO+66y74/f4Wy9Hrxx13HIdT6Hymc3b8+PFNoSSa6NBz2u/0Hy5fvrzd0Csde0ceeST/v5mZmXjooYd4/zeHjg9aB10nzWYzr5dm/F05hpuHfv73v//xsUbXGNq+mTNn8rnVGXQtofO8tfFAUGi3OW+99RZfy+h12o8UgiaPbWt6cz+2R1lZGZ8TdN2i7aTf9+abb7ZZjkI09B7t24SEBN5WGrt6FGrnLZCkn3/+mf5J6fnnn2/xel1dnaRSqaQLLrigxeu07CWXXCLV1NTwbfv27dIHH3wgmUwm6fzzz2+x7IUXXigZDIadfv9bb73F61y8eHGXtz0vL0869thjW7wWCASktLQ0KT09nZ9v27aN1z9mzBipoKBAeuyxx6T//Oc/UlFRkbRmzRrJYrHwe48//rj0wgsvSAcddJAkk8mkL774ommdFRUVUkpKipSQkCA98MAD0r///W9p+PDh0oQJE3jd9B0xDj74YL7FCIVC0syZM3m5s846i7/j0UcflWbMmCF99dVXksvlkl5++WV+/+STT5bee+89vq1cuZI/f//99/N7MR566CFJLpfzNjXnjz/+4OU+/fTTptcuvfRSSalUSpdddpn0yiuvSLfffjv/H/vssw/vp53xyy+/8GdHjBghPfHEE9KDDz4oJScn8z5o/ntj2zd58mTplFNOkV566SX+Xnrttttu69L/OXbs2Bb7rrKykv9LOrbuvvtu6emnn5YmTpzIv7/5/3PuuefycrSvm0PbTf8l/dc7g7b1mmuu6fB9+v/oO+12Oz+n4z4jI0O66aab+L+j7xk5ciSfL8uXL+dlOvtfn3zySenAAw/k//O1116TbrjhBkmn00n77ruvFIlEdrq9J5xwgjRlypSm5/Sd9D20jd99913T63Ru7L333k3PWx9LtD0ajYa3I7Z98+fP7/H/tTld+R66ntDrp512mvTiiy/ytYmen3TSSW2uC/R/0H9E5yud71lZWZLRaJTef/99KTc3l68DdKPzf9iwYVI4HG7xPVqtls9xuqbROXvcccfxd917771trp10fND20O3aa6+VTj/99C4fw7Nnz27aD/Tf0jbTtuv1ej4mOuOII47g71i9enWny9L5f9FFF/F30HWfPkvfTb+zL/YjQa/RsdB8v2VnZ0s5OTl8jtC5RMc9LUfbEYPOndgx8eqrr0rPPvssj0/XX3+91JMIA6IRuujSATJt2rQWr9OAQ3/MTz/91OJ1eq29G53EPp+v1w0IOvhjxgxdnGmQpvVdd911LQwIs9ksVVdXt/g8nfjjx49vsd108d5///35oI9x44038joWLlzY9Bqti06azgyIN998k5ehC0drYgMFbXvrE6iji/7GjRvbNfiuvvpqPrE9Hg8/nzdvHi9Hxl1zZs2a1e7rrZk0aZKUmprKhmQM2r904WtuVMa27+KLL27xeRo0k5KSpN0ZaGL7nX5LDKfTKeXn50tDhgxpuljRMUrL/fjjjy3WRwZeRwNXVwwIGtxpmdjgT+eM3+9vsUxDQwMPFM33w87+19j/1JyPPvqIl587d+5Ot5cMWIVCITkcDn7+3HPP8blAAw0ZiQTtG6vVKv3zn//s8Fgi6Pyk87Q1Pfm/7sr3rFixgpcj46I5t9xyC7/++++/N71G+4JeixlDzY8RMtKaG5Q06NDrNIC3NlRi15DYuUoGmVqt5v81dlzQdaW14dqceI/hmAExevToFscWDYj0emeGARkzdEzQja7lZHzRb25votDesXfkkUfyBKs5vbUfidbnCRkBNC7V1tZKzaHrO113Y7/hxBNP5OOrtxEhjEbI7XnWWWfh77//blGOSC4gch2RC6015Mr+5Zdf+EZ5EpQkNWvWLJxzzjlxuaa6O2mRXMV0mzhxIidxnn/++ey+bc6pp57a5FIm6uvr2UV/xhlncBUKlZHRjVzI5G4rLCxkFxrxww8/sNtx3333bfo8rat1bkh7fP755+xybi+JaVcy0SkMQomjn3zySdNr4XAYn332Gcfryc1I0H4gVzAlB8Z+G93I1Uhuxebu9tZUVFRgxYoV7IIkt2uMCRMm8Ppof7Smdb4JufRpXzocDuwq9D20zw844ICm12jbL7/8cj5WY2Goww47jF2jH3zwQdNya9as4TBBd8TdY5VEsWolOmdiuS4UPqBjidzr5DpdtmxZXOuM/U+xEBf9N3SMEZ2tg/Yt/eeUOEdQEjO9Rjd6HPv9FBag13aHnvhfd+V7Ysdc62TWWAJ165AAueWnTZvW9Hy//fbje3LdU6Jh69fJzd6aa6+9tsW5Ss8pfPXrr7/yaxQuoBAQXQd39xiOQaGb5nlUsf+vve1rDp2XdA2ncDMlAD/xxBN8HaOwZuuQbPNjjxKG6dg7+OCD+TvoeW/vx9bQGELXTbqe0ePm1y/6TbSNsXOE/gMKVVLuR28iDIhmxAbCWNyI/hC6EJFhQRfL1lB8ji7adKMDljK5KSeAYmLfffddr247Hbh0AtPBSBdUOsjefffdFicJkZ+f3+I5xRXp4KTqkZgBErvdf//9vEwsL6SoqAjDhw9v890jR46MKzZJy3VnbsiZZ56Jv/76q8nAoZgkbSu9HoMMIDrRKM7Z+vdRTHxniVX0ezv6fZRfQvuYLpzNaX4xISgWScSbb9HRdnS0Dc23Uy6X8zFM5YixuDkZExSbpdjz7hLLIaA4dwzKGyCDir6DciVov9Ig1voC3BFkdFDeBhnpdKzS52PHaGfr2GuvvTjeGzMWYgbEQQcdxOXQZJDE3ms+cO0KPfG/7sr30H9N/zMlSDeHckdoEIkdCx2tj4xpIicnp93XW/8e+i7KT2ltvBOxidbVV1/Nrx199NF8TaR4PU2kduUYjnc/7Ix99tmHr8G07KJFi3hiR0Yv5UU1N1To2kHX7lhuEx17lEvS3rHXG/uxNTU1NWz8vvbaa22uXWRgEbHr1+23384GGRlpdI2+5ppr+Pf1NAMvrX03oFkpZZl/9NFHfCDRPQ2u8cywY8Q8FXPnzmXLsbeg2T2dDJ3R2qCIJUDecsstbNW2R+uL1Z4CGQp0cSAvw4033siJV3QCU7lt899HxkPzWXlzmntjuoP2DE2itzxSVH3z73//m42Is88+m41hSgCLXdh2B5rN0++LDfDvv/8+e2eo9PHWW2/l/RxL1iSDMR7I80UGL32ePEp0EaT/jP7D9pJzm6NSqdhwpnONDOHKyko2IMgYCQaDWLhwIRsQdE7v7v/cW/9rvN8Tr9euo/V15++h/508dT/99BN+/PFHvlGCIh2LZGDuCt2xfeTBIGOCbjRY06BL1wqaGNHxSddqOjaefvppNgRoefKUUOVa62OvN/Zja2LbQN7DCy+8EO1BxnvMENu4cSNPXMl4I88FlV5TknOshLonEAZEK8hYoNk4uX3p4kvWHB2A8UIu3OaztT2dmFVMF+PODBASZqEZfWvowO0MyhinCzpd2Om72qOroQwayMjipjAGuQNp1kGDGWUqN/9e8spMnz69jfHUGfR7O/p9VLVCRhvNXnoa2o6OtqH5dsaqUyZPnswGE80Gi4uLu0VAh9bzxx9/sBs35oGgcBEdP7Tfm/93Mc9VZ/8rzdKo8okucHShi9HeMdYRZDBQmI7+Y/o/aECg76NsdDIe6EYGVGf0F0En+q9pYKF9FJu9E1VVVTxbbX4sdAf0XeSOj82WiU2bNjVVJ8SgwZcmTHSjz5BXgrRo6FpKE5CuHMM9AYXVYmFJgnR/qGqFwhrNvQs7C2n2xn5sDhm9dK5RmC6eySFdi2hSRTcKjVCFG1Wy0CSrpyQFRAijFTFvA13QyKruivchdmASlIfQH6DZA5Vb0skeO7lau9FiUP0/CbKQW7D5+x3N7lvnXpDL/4UXXujQWid3NNG8BK8z6GShbaKyJlp/8/BFbIZLJyCVvbVn7O3su6jMlGbFNItqvhzNxCnnpLf0EOh7aJ9TbDcGhU7ItUkXH4rPNodyX2j7qHSVwgrkWt4dKMxA3gzaj81FkGKzr+azLTISm2/nzv7X9j5P0HZ3xYCggYA+Q2GKmCFAr5OQE4mqxZP/QBffrhx3fUXsmGu9j2gWTRx77LHd/p3Nz1n6r+g5TQJi3tbWJbfkro/NjGOlpV09hncVMgDam/3HckdiYZT2jj0KW5DnpKd4oZP92BraRrpukjeBrjk7uza3/g/IoKN9St9Dk7aeQngg2pnV7r///pwUSezMgCALkty4BMWcaSCjwYYsbrqIN4f+RMqPaA0l55G1HoMGwtbxQ4LixM1jz93Jiy++yBdfqmUm9TaaVdKMhk52ygOhZCTitttu44syuZdpe+iiSxcAmj2Qx2ZnkDuTcjIo+YsuJHRRpwsIzRzp91NCKnkI6KAnjwJZ6rRvaEZNt44gA4HCL3Sj5Vtb6pQURZoP5FYng/CII47gk5ZmcOTOpFr15poRraFwAA3ANPO+5JJL4PV6eUZPIYHe0qwn1UQKp9F2XH/99fw76TgjjQ+6uNAFuzmUxEv/FSmrXnXVVR16fHZ2TNOFhxL3Yqqq5FGjQap5eIhm9uR9OPnkk3ngou155ZVX+D9s7oHb2f9K+QqU6EbnByW6keET0y6JB/pfKK+GZreUkBeD1hur6Y/HgKDwJR2L9BspEZWuA7GEuD0JmpiQO5vOOzJ46Pim84mOB/K+taeNsjvQzJWuR/SdtD8oPEE5LhTijYWFLr30UjYyKaGQvF6Uz0DnCBnfMS9JV4/hXYWStOlaTMckeaNoJk4hMjr2yFCJ5Q7QdSDmNaHrAx2vr7/+Ok+o2ptI9cZ+bA8SHyOjiD5D12Y6j2hfU/IkHa/0OPZ7KA+GPK0UwiOdGjJQ6LzsqXGD6fW6j34A1THTrtlZ3XHr8k0qG6J63csvv1yqqqpqsWysjKe929ChQ1uUcXZ0Kykp6ZIORGtiZZxU+tYeW7Zs4bJE0o2gOn6qc6Za5c8++6zFcqtWreJSNKprpmX+9a9/Sf/97387LeMkqOSIasCpdIu+g76L6pbpu2NQqRTVf1N5U/OSpvZK72JMnz693dK25lCdNK2Xyq6oTpzKVqnEq7y8XOqMX3/9lb+DPkvlascff7y0bt26FsvEtq95SVbz/7X5vtmVcj/aR7SvqCSR9j0dm821DlpzzDHHtCk964zmxxuVqdJ3UT0+lemtXbu2zfJUivbII4/w8Uc6CrQsbRMd7/Raczr6X0tLS7lUkb6LytJIO4D+k47KPjuq529dXkzrpdeofr417R1LGzZsYO0T+o/pvVhJZ0//r623KZ7vCQaDrEcSO4/oN955551tysc7ui60V67b3vUhVn5Oxx6ViZMWA5Xo0rY21zmgawS9T+XO9P+SLsIVV1zRRqMlnmM4VsbZXMel+fbR/tgZVMJMpbCjRo3icm7aHtJloBLK1tflb775hkucaVuolJQ0cGLl5s33d2/tR6K94562m76H/ufYdZNK7+ma1rx8lI5fKvmlc5HGlVtvvbVJs6WnkDVutEAgGEDQDIyaCsWj3icQtAclyFKeS3/J59pTuWgA70eRAyEQDDDIBUvu0dZhNIFAIOhORA6EQDBAoHgy1X6/8cYbnPdAsV2BQCDoKYQHQiAYIFCZJXkdyJCgBDVKqhIIBIKeQuRACAQCgUAg6DLCAyEQCAQCgaDLCANCIBAIBAJBlxlwSZQkGUrqcySe0V/kaQUCgUAg2BOgrAZqPkaCap0JfA04A4KMh9Yd0gQCgUAgEMRPSUkJK4sOKgMiJttJP95sNvf15ggEAoFA0G8gCXuahMcjgT3gDIhY2IKMB2FACAQCgUDQdeJJARBJlAKBQCAQCLqMMCAEAoFAIBB0GWFACAQCgUAg6DLCgBAIBAKBQNBlhAEhEAgEAoGgywgDQiAQCAQCQZcRBoRAIBAIBIIuIwwIgUAgEAgEXUYYEAKBQCAQCLqMMCAEAoFAIBB0GWFACAQCgUAg6DIDrheGQCAQNCcSkRAIRxDkm4QQ3Uckfp0ex96LSNTKOHqLIAIZZJDLZFDIAblMDpVCBrVSDoVcBqVcDqVCBpVCDo1SDrVCDrm8894BAsFAQhgQAoFgQBCOSPAGw/AFw/CHIvAGQnD5wvAGwghEwvx+KCxB4qXJUpCB+gWRkRC9tW0iJEnR5SN0T4ZF43Nagu7JmGDDQq6ATq2ASauEQaOETqWAVk3GhaKvdodA0OMIA0IgEPQ7Io3GgjsQgscfgt0bgtsfgj8UZi8DDfSKRq8BeQl0SiV7DJRyMhq6z1PA3oywxB4MmyeAaqePXyeDRKOSw6BRIMmggVETNSy0KmFQCAYOwoAQCAT9wmAgY8HlD8HhDaLBE4QvEIYvFOZQA4cRlHKYtWo2GrrTSNgZSgWFMgAdWhoG5O0gY8bhCaHG6edtJOPBolMh2aThe4Na0WvbKRD0BMKAEAgEeyQUinD4gmww1LoCHJIIhCKQy+UcIjBqlUhUqPfIQZhCG3q1km8EeUTo99S5Aqh0+KBRyGHRq5Bi0iBBr2bvhEDQ3xBHrUAg2COgfAPyMDh9IdS6/LB5gmw0kIFABgN5F8jL0B+hkEZzg4KMCbsniGqHH1qVnA2JVLMWVp2KvRoCQX9AGBACgaDPjQa7N8iufhpU/eEI5ypQ3oBFp+PBd6BB4YxYPoQnEEK5zYcymxcmrQrZCTo2KEQCpmBPRxgQAoGg16FBkzwMVQ5f1GgIRTiPgVz5SYMs0TDmmaC8CQrXrCmzsyGRk6Bjr4RIvBTsqQgDQiAQ9ApUqdDgCaDG4Uet28/llTTLJk9DklEMkpQ3kWBQwyKpOIyzrsKJ4noPeyQyrDrhkRDscQgDQiAQ9GiIwukPod7lZzc9hSsop8GsVSJBt2cmQPY1FLKhKg3aR2RIbKh0odLhR16SHqkmLRsaAsGegDAgBIJmUOmd20+3EGfO08U8JjYULRNU9dtEvl73NrgDqLD7UO/2wx+S2NMgBsD4YUNLp+JqEwr3rCqxcUgjN1GPJKOmrzdPIBAGhEBAGfGUwFfvDnDZILnWpUa5wdhQF1Mf1GuUSDaokWhQ88VdxKfb5jbUOv0ot1NuQ4Aln2k/JYsQxS5Dxisdb6GwkstA6z0B5CbokZukF2ENQZ8iDAjBoIU0BSiJj+LMTl8QWmU0M95kUrU7S2ap5EAYpQ1eFNW5YWxMdEu36Aa1V4LCFFRFUWn3ocrp431ESYFpZp3wNnQjVN6ZZtaykbalxgWbN4j8ZAOShTdCMBANiLlz5+Lf//43li5dioqKCnz55Zc46aSTdvqZOXPm4KabbsLatWuRk5ODe+65BxdddFFPbqZgkEGGQMxwoFmyQaNCpkXXaTyeBkNyJ9ONwhsUn15f4eDZ9pAkA5feDaYBk/ZjnduPCpuPkyKpz4RFq0KitY8GNEmCLOSFIuCAIuiCPOiGPHYf8kEWCUAW9kMe8kMmhQEpwjd+TB+XKQC5EpJMDonuFRpEFFpISi3fR1QGhNVmRNQmhNUmRFRGijP0+s8k44wMXdLKWFlqQ16iHrmJhkFtxAoGoAHhdrsxceJEXHzxxTjllFM6XX7btm049thjceWVV+KDDz7Ab7/9hksvvRQZGRk48sgje3JTBYMESuLbWuPi2Dx5HMh7sCs6A7FEN2qeRLH+lSUNHJ+mGaFVr8ZA99zQ4EW6BfTbFbQv9Krec6dLESj8dii9NVB6a6Hw1UPpt0Hht0EWDuzyart6FEhyFcLaBIS0SQjpEhHSpSCoT4ek0qOnoeOP8knIG7G52g2XL4RhaSbOMxEIeguZRP7H3vgimaxTD8Ttt9+O77//HmvWrGl67ayzzoLNZsOsWbPi+h6HwwGLxQK73Q6z2dwt2y7o/9BhXuXwY3ONC25fiL0F1GSpO5sq1bkD3LCpINmArAT9gPNGxHJFyhq87D7XKuVsRPWociIlsgadULkroHJV8D0ZDbJIsP3lZTL2DIRVRvYYNN2UOkhyNSJKDd+ThwHkaSCvg6xx+6Vwk2eC1s+eirCPvRfykJc9GYqgE3LycARcUQ9GO4Q1FgQNmQgaMhAw5SCsTexRTwV71Jw+Nh6GpxnZsBAIdpWujKF7lLn6999/47DDDmvxGnkebrzxxg4/4/f7+db8xwsErQe+7bVulDR4uQdBhkXbabjC5/WiorwU5SXFKC8tRkVZKdwuBzxuNzweN9/TOjQaDdQaLd8bTCZYk9NhTErDqKF52G/8SIwalt/vSxWpIqXa4UOZ3cczXWoCRfuwpxQiaYBWO0ugdhRD7SqFPOBsswwZACEdzfxTECYPgMaKMN8sHIboNS+Irw4KXx2U3rpGj0gdv043bf16XpTCHgFzLgLmPARMeRwS6U7IUM0wazkJeHWZHUOTQ8hJNAw4A1aw57FHGRCVlZVIS0tr8Ro9J6PA6/VCp9O1+cyjjz6KBx98sBe3UtCfIBc7eR3qXH5uq9xe1QQZBOtXr8TalcuwdtUKrFu1HEXbtnTL95stFkyaOBGTJk3C5MmTccABB2Do0KH9wqigxFJKjKRwD7nKTZwr0rnx1WUiYahcpdDYt0Lj2A6Fr6Hl+zI5gvoUhAwZCGpTEdaYISnUkId9kJF3IOznEAZ5JhAJwOsP8vZ6AxF4AmF4gmH4Iwr46CZF7wNQI6DQI6jQISTXQqFUQqeS8/FBfTcoz8CqV3GjK/KytBmMZXIOX9ANGLbj5ZAPKk8lVO5K/k0qVznnZOhq1/ANcgX85iHwJYxEwJLPeRbdAf0nVNpJxh7pRtBvHpZiEnkRgsFjQOwKd955JyddxiBjg5IvBYMbcuuWNXiwtcbNjzOa5TpQOGPLpg34a86v+OuP37B04XwEA21j5xqNFinpGSgYPhKZWTlsDOgNRuj1Buj00Th3IBCA3+9DwO+H3daA6soKVJaXoqqiHJUVZXDY7ZxMTLcYeXl57Gmj2+GHH46kpCTsKdC+cXhDqLB7uWskeW8sOjWyrN0b16dcBbV9GzT2zdDYt7XMXZAi0RCExhRNYpSroAi6oWkohC64gmWvybix+ajxVpB1O8hgIGPBGwxzguvOoCGVfAAxP4AkyeCGFjYY4JAMsElGflwnWVAPExsLVIqaZtIi00o3HSfd5nDyYstQFXkXAuYhfGMiQaidZVA7i/h3Ur6GxraFb+RF8VsK4E2ZgKAxp1vCHCQFTqG5ojoPgiEJI9JM0KlFqadgEBgQ6enpqKqqavEaPac4THveB4Jcx3QTCGJwmVu1m5P8SM2P+goQm9avxQ9ffYofv/6MQxLNSU3LwLhJe0FrsmDR0uWwuzyIyBSo9smAagdOueBozDh0Rpe2g4ySdevXY/mK5agt2ogt61Zj0aKFKCoqwn//+1++KRQKNiLOPPNMzg+yWq3oK8OBxIrKbV6Op9PgQzNw8tp0G5EQ1I4iaBs2QGPbGs1jiITYOIAUhKTUN+YkKKAIeSALuuHyBtHgCcLmCfD2NXgD8AUBL9TwQgOvpEUASr6FoUCo8Ub5GXq1Aga1HHqVHDqFBK08DI08DK0sBI0UgDrigSpC4U8JkYiEUMSDYNiNULgSgXC0/bYnJKFeMqHGZ0WlNwFrqpIwBxZIbIYAaoUcQ5L1GJpixPBUI8ZlWZBubualkasQsAzhmyvrIPaSaGyboG3YxJ4WuqcbeTK8yRPgTRoDSdn+tS5eyOuQbtKy54gEvUamm5rOAYFgQCdR/vDDD1i9enXTa+eccw7q6+tFEqUgLqqdPmytdsPmDXAymaOhDt989hG+/+ITNiCaexf2nnYAph8yE9MPOQxDCoZh9pzZuO222zhxrwWNg8ETTzzRZSMipm5JVQs0sGQa5Vi26G/8+uuv+Pnnn1sc62q1Gscccwyuuuoq9k7I5T3vfqaBk4SJyHCodvrZkLDq1N0qkKX0VENXtwaa+g2cz6DwUxKigw0ImrGHtImc+MhJmi4/iyWVumXY5NKiOmyEXTLAAT17B5zQseGQQt4AS9QbQPuVkmJJDyHJqEaiXh1/YqcUiSZI8nbZoQhQNYe9MSRSAwRJRZM8HOGmVuMNfmBrwIpVLjM2BFJQAzL6dngPaDsmZFkwIduCKXkJ7VflSBKU3moOa1CuRMwDQ14JX/I4uNP2RkS9e9cv8sSQF4lKa8mIoD4bAkF3jqE9akC4XC5s3ryZH1P89+mnn8ahhx6KxMRE5ObmcvihrKwM7777blMZ57hx43DNNddw6efvv/+O66+/nisz4i3jFAbE4IRmWsV1Hmyrc0Mpk6F6+0Z8+OYr+PGbzzm8QChVKhw04wgce8oZOPDQI6Bt5tUKR8I4/vjjYa+txBBTGCm6CA8JdHLQGULPgro0vPjR91Ao1busPUHljqPTzXxPbNq0CZ988gk+/vhjrFu3rmn54cOH4+qrr2YNlJ7wSsSqRqiigu7pt1q7sRST9Ba09RugrV3F3galv4Fn3LJICCFdMidAeqFjo2WbW4VVDgPWOvWoRgJqJTN8iHo+KGGzIMXI5bH5SQYMSTZwc6leUQClCpCAg70GKk81VO5yrgJpGuzpGucLodqvwEZ/MhY5E/BHrRmeyA7HLkU3RmeYMTU/CVOHJrGx03ZfBaBp2AB9zSo2tqIfVMCbOBqetH0R1u76/0+Xd6qc0agVGJNhZkVLgaBfGBAkCkUGQ2suvPBCvP3223xx3L59Oy/X/DP//Oc/+WKanZ2Ne++9t0tCUsKAGHxQHJxyHcptHqxf9Ac+euNFLFnwV9P74ybuhVPOvgCHH3MiLAmU9NYSpacGRYu+x5dvPIFMQwQKmQSVnGZwjTdeKjrDPOb4k5Ayan/OqPdZh3ep5p9ONRowtWoFRqWb2igIkjfijTfe4HMjVk2k1+tx+eWXs2eE9FB2F5rlkzeEPA6UYKpSKNhw6K6SVoXPBl3VUhgr/oTKXRXVZpDCCGkSENSnojakQ6Fbh0U2ExY2GFESSW4yFoghSXqMSjfzjJluWdZd0+noMaRI1KBwlUPtLOZb8/yNoCTH1kgaFrnT8GuVCRtqd1SIESPSjDhsdBoOGp7C+Qot1y1B5SqBoWIhV6EwMhm8SePgztyfy1F3xzOnUQkjQtCPDIi+QBgQg4fYgLypyom5s3/Fxy89iTUrl/F7nFtwzIk495IrMWGvfdqtHJD77TCWz4e2bi1KN6/FmiV/wqKWQJNwr6RBJBJVKpQiEZ5t0hA7atI+yBg6gasAKLnPk7YXPGl7dymbngZwmpmOTDcj3aJt13NHQmovvPBCkyYK5fmQIUFhvqysrC7vK+rxQW20KTmSXPE6lbL96oJdgQY+ZxHMRb9AX7MSCm8dZFKIY/l+XSpKwklY7E7Fr9UmrPYmwtuUvghORJyYZcH4bAvGZVo4WXF3t6WF4mTYH30eCUIWIY2HEN/LWmk4SHR8yBRRBUpWo2xUolRqm+4pn6HdChJ3OSdIauxbWlSQ0PFRpR2CP5zZ+KVUgbUVDjZIY3kK04cm4cix6Tyotz4+yUAxVC7kRFNel0INd/q+8KTutctlqsKIEMSDMCCEATEoQhak7fDNj7/gnecfx+pli/h1rU6Psy68FOdcfAXSM9ofaKnUzlC5CLrqZVC7yiB3lKLYHsLyYhuc6hQEdUmATAmZbMepIYVDCLsbMDHLjDGpauiV0Yx7mlVHlHq4M6ZyEhy5nuOhwRNAMBLBiNTGWXY7Azmdmj/99BMeeugh1kiJ5UlQaOO+++5DQjvelNaKkZR8SEYWNbjyhSKcVEqCQ91SiilJvA8t276Dtn4TD9RESG1FkSwTv3qGYVa1GVv8CYg0Jh1SieSkHCvnBtCtS30cImEoAiTkZGep6uhjkq12QxbyQBH0QB7y8HI9AQ3iUQlrEqcysr5DWENKlKQ/kcCGBuVNaBo2RpMk/famz1LYpto4Cj/UJGHWBhtrksQYmWbCyZOzMLUgqY1Bp3KVwVg6h705BOlcuLIPht+6o3S0KwgjQtAZwoAQBsSAD1n8sWQtHn3gLsz/7cempMgzzr8YF199I5JSUjv8rNq+Febts1ikSGYvRqlTwhKHBRURK8qkZJRLySiTklATNkAml0Mlkzi/3wAf8mSVGCqvQIasDmaNEmOtIQwzeCEZ06IiRtoE2IccjZAhPe7f4fSHOC5O5YAdJbnRKUr5QKR3Mm/ePH6N8ogeeOABln1XqVQtci0oLk89KkjDgb5DQR0xtapdKuej3JAVy5ejtrYWycnJmDR5MhRSGOain9njQLNv3kbIUaNIw+zQWPyvKgObfNamSgWrTsWD47ShSRifZek0XEL9LFiYiUWa6qH0NXAohBIvO1J/bINcgYhC09jPQs3eA/YqNPa6IG9DS0h9Msw5GqxISUqU5L1o1JmI53sjKj0LW7GktY6OQQkaRxE0tsIm5UwyQjxJ47EKI/BDoQuzN1YjGI5egkmciwwJCnG02EeSxImWxvK/mkS1fIkj4cyZsUsVGzEjYnympSkXRyCIIQwIYUAMSOhQ3Vpeh4cefgQf/fclBAN+DlWcdu4/cNl1NyM1PaPjQQ/gCzDN5uS1m1Dp8GOZ04LtkWQsiIyFyzoKFngw95uPEajdjrC9MZlNoYJcpYFcZ8Kpl9+CBmUStpdXYhhKsa98AyyqAPZLCmKIKYKIMZO1C5xZB8KbMjmuun7ypJCCII1pWRYdshP1O+1nQJUbN998c1NoY9SoUfj3k09h2sEz4fAGUeX0c4iCkiSNGhWva1fDFL/P/h1PPvkkqhtLq02qMP4xWYsrD0hDmjlq7PgjcqyWhuLNhvH405XV5Gkgo+GA4ck4YFgy5zS0uw2SBIW/gXNQVJ6qpt4WJBndETT4k8cnotLxPTe6kmsgkUQ1Gwxqfs5ufpkMEvdklzXKVjcaEHxTNS6v6fx/agyLxJpzkYw1yWtzNQlVa/ga+PX2IAltMiYopKPy1nBIJdonXg5f4miUmyfgq00BfL+6gv+3mCFx/tQ83nfNPUWUa6GvXARD1RI2aMhgcebMhD9hOLoKJfRSUzgy6NrkYggGNQ5hQAgDYqBBA+2bH3yKe277J2qrKvi1/Q44GLfd/yiGjxrT4aBHDM1KxnP/mIq9ElxwVGzGSrse6yPZWBQZDX/qJJy1Tzb2SpVDEfFjyZ8/44eP30TIXQ97QA6bTwa5KRXnX3kjDpx5LA82dKFfsLUO3yzZiiznCkyWFcKsimB6QgPSklMRMmbAbx0KR96RccsWU3IjeQ3IS0BllKSASI/ppmwcfLkaRJLgCwTx3zfewOMPP4j6ujp+75CjT8KVt/8LmRlpTWJCuwPtx1hJa4Y+hFMLApiZE4RBRTNxGRLzxuBv9TS8UjcR9bA0hSfIy3DwiBRMzLa2MRpkQU+jSmO0pwWpNdKgSEmWnKtAj+lGs3W5kj0HPMjLYn0raH3kPYjTIKIdxt4EynsIRftcxO6574VEV0BeZ/S7yCjR8qBPxgmFC6KepUSEtAnchZONlnaMDtpu9pZ4q7lig4wiMojYo9Fse7i3Bv1WKYyw2gJJoYIvcQxqk/fFrC0efLq0lPUuYgmXF+2fz4N8c5TuSvYAsfJmkzdiZpcksumyTzoRySY1xmZaeqeqRdAvEAaEMCAGFNtKK3D1tddh1tef8/PMnFzceu/DmHHUcS1maM0HvRhDzWGcOdyHyely/tzaUCaWRYYjmDQapwxXYqxsO7S2TRxPp4t71IVNiYxOBINBDg8YjSZALme9Aqq88CaPhy95PPzaFMzZVIvvF63HKPciDJWXYbjWhUlpSqhShnHlgX3oCQjpOw6ptIakiElNMRCmQQ5cVkn5EXSa8q+SgJAkIRyJwOVw4ONX/4Mv3nudEz4t1gTcct/DOOG0s3crxyFa0nocjN4KHJfnx8FZAZjUEmQKFRqUqZijPQQ/KA6Bv7F6gjQPZo5Ow/5Dk1oMRJSkSjkmFMcnmWoKd3BIgMMCvsYExyAkuQZhlb6x6VW08VVnuSTsQSAvAyVFhhvDDeQloLbd4UD0Ob9G+RBkSJAvItKyhXe84RBGFvVuKHUIq0zR7pv6NARNOdGwRaOhQQZHk3FBCZaeKpa0ju2HWMUGhSLYgJJiZa3J8KROQV3S3vhiTT2+WF4KXzC6feSJuPygAjYqm4iEYKhY0OSN4PBZ/nEI6VO68D9LqLR7kZmg41LT7mwuJ+i/CANCGBADAjo0X3/nfdx+0z9ha6hjYaULr7gOV/3zjhYaDs11HHZ4HiTsnx7CKQV+jM0yIGLOQBVSUCNPxrQsJUYYvBxjj7qU6YremHlPLZpVBp7NUSyekvI4m59j2M2SKmVKBI2ZcGUdAHvaVPy4LYJlC37DvuEVMMs92C/Rg9ScEZB0CbANPQlBY9Yu/f5AOAIqBmkSNpTJuIKjuVDSulUr8MBt12HD2qgo1dQDD8FDT76A9MzsXdnp2PzXV1jw5l3YLz2IJG0EMrUe1eoc/KKZiTnSXvBDjbDHjkOHJ+L8GZObKknIw6CxbYaubi2rLdJMnEWaQl4e8Iho+IESEKlbppGfcwdNmvmrTTw4R5qMCbrXc0hCHvFDHqDwAYlQUfjAxtoS8SRM8sBPktixEAfdcyWDLGpYNOU8UG8NLxsfsXAFC0wFXI2VHUEe8FtC265r6vpJrb39lvxo3w4yMCispTY1bkiEqyu454d9K3ss6DdRKSglhZKXg7p42vOPRrlxHD5aXIqf1lZy5QaFoi6Zno+Zo1NbGIdKdwUsW7/n/ULHrjN3JnxJOzxy8Xj2KJxBapoj0joINQkGFQ5hQAgDor9TV9+ACy++FN9//QU/HzZyNB568kWWm26PpUuX4IorruDHKrmEE4b4cXR+BKOyyA1tggMGlLsVmJ4pR4axcSBTmxDSJsOTNpndyFE3dbRRUwsiwai+Qc1K6OpWQ9tQCKWvnt3g/DapKCaMQFniVLy92ofkyrmwylyYqKlCXt4waBIyYB96/I7+CD0AeUvee/1FvPz0Y9ybw2Sx4L5Hn8GRx58c3wokiZP9jKXzYF/1A6q3rAS0ZtRqc/GbcjrmRCbDAy385Rvh2fgXfMWr8fiDd+H4yZnQ1dI+2dgostRc96CxtTYZBhozAsZshPWpLTpnkhuf/oemfc55ETaenSsbm1LtrH03GQI71mXm/y9aKUEtvSlHgkIOu1ltQEYGJXb66qHwVkNNjbK4vXh51AhgoyPa8pu9GjJFtJcH/25rtBOniW45fB8LNVDJp6ZhExtcasd2NiTIcJEUWniTRqN+5DlY70/G87MLWeeEmJhtwTWHDuPeLk17OeSFZduPvA6CPGTOnEPjLveMKqUGMCrdiCHJxt3bV4J+jzAghAHRr5k9dx7OO/dclJeWcJdESpC87NqboVJ3PBD89NMs3H333bCqIzh3pA/HDVciJ1ELn1yL0kgSgg1V0PqqkTlyClKHTWa5YEpio86IXa6rp5mkswSmkt/ZhUwVA2RM0AyQBskl0kis2LQNurAdo+SVyM4dgqS0bNiHHLNLCW9dgbqI3nn95VizYik/p3DGHQ89DqPJvFPDwVA+nwcy2IpRXu/EBo8Jf2Ei5kQmoS6ghm/zAhi3z0GevAp7p4QwLimEw/ceAbOxpZAWGWZBygGxDONwD1WkxHII2t3PkVAzN385z6gpDNF+++7kpltYE8tLMHdLE6pdhQZ8Uo+kG+tB2Dbz8UCvk1eBE0LlCjaUYmEOKsH0JQzjfcRCZCRr7amCtm4dTKWzeR0USqPfTBojNSPOxeeFIXywsJg9UpRrct2MYThweLNwhRRhASpD5QJeHxkr9oLj486LoNCZKxDicFRqO2qZgsGDQxgQwoDoj4TDYdz34L/w+CP/x4+zcofgiRf+i/GTp3T6WfJAPHrLJbhzihf756mh1mi4CZItqEJDdSXKbX40+OU44IxrkT793MY2zLsPue311ctgKp3DYkKkSyDJ1XBq07GqxIYabwRWuJCaloW83Dw4hxwFX9Jo9CTkjXjt2Sfw+vNPcW4EGTCPt96PkgS1YxtXplCXy3DtZtTaXWw4rIrks+Hgc9qRXDobQ1wrMTHBhzS9xEJbpI+hVqkxftx4rjrxm/O5CZQ3aTyC5h0z7HZpzAuIqThSQmCLRMOYsaBPRVCfjqAhnR9Hcwv6QYyePCi+usach1KobZuh8tQ09tlwsJci6vlKYjlvSrYlpUnWdZArOUdCV70c1s1fcJiDV6nUwj7kWGxMnomn51ZgbXlUpfTocem49ICCFi271fbtrMtB66H1U/gsommZhNkRVA1EkbHx2VYWGRMMThzCgBAGRH+juroap55+Jv6cG5U1P+bk03HPw091PHNuTiQMU+FXqPnmXqSZlAjJNbBJBmx3yLG5qAL+kIR1DUqsD2Th7c9/gKKDBL3obLIqKsHMhkBjuR+X/KkRpLg2aTy0N5BFwtDWr4O5+NfGWWgtIjIlCwZVuUhHQI6wORujh4+Ae8RJCFjy0dNQ0667bricPTnkvbnjwcdx2rkXQe0qYQVOtW0rvJWFsNlqsdlnQnXEgu1SBjKsBoyRNqNi+W9I1oZhVEcvEaGIDM6gDMVOBUYedh6GHHweS3p3NrDL/TbWQ4i66Utatu5u1E+gHJGAMYtzACgpMV5Brj0ekr72VEV/v30b65BQKIRulGNBHhQSI6PfTaEHb/I4hHXJUZGuykVI2vABh0sI8io05B2DN8uz8eGyWs7IKUg24PajRnFTsRhUAWLd8hXnb1AoxzbsRE74jIdKh5eTNamrqKjMGJw4hAEhDIj+xIKFi3DKqadyi22dXo97Hnkax596VucflCIsQ524/gPIShbA47bDH1GhJJKIpUVueGw1KHXJ8XOJBuUeRbvdNBXeWvYgkLAUCxV1AiX7US5DwJzPyXJtZtuREIcCDGV/Qmvbwm5tu8OGSmcAKimEWnUOCsbuA+/Ys+IWnNodHHYb7r/lWvw26ztkm2W4+fQDcOoR0+CsKUawbhsagkr4JRUcMMJoScKYhAgSQDNlD+rsLqwuLEGlI4B19QosrlbCps7CpTfctvOupJwsGK28IK8M5Qm02EWk4NmYD0C3FpULAxzyUJGBSUqVZMBRqSfrQzQ2GSNjgip83Gn7IGjKZmPLWvg5G6b0WQoR+ZLHYrF6Ku5apITdFw1p3HH0KOyVu8OrRsaDdfOXbMiS8WsvOC6uHByuzHB4WdiMpNZFUuXgwyEMCGFA9Bdeff0NXH/dtdwxMzd/KJ594wMMHTGq08+pnMUwFf8GQ8lc+Cs3IBDwwSHpsU2Ri02FRaioacCvJWqsa1AgLS0DN99y845Bj5sWlUFftaTJTczIZFyqSbM1iq/LIpHGHgokIuThmbsstCNJkC7MNGv0pE5u23o5EoShcgkMFX9D5SyFrGo1qpweKCIh2BQp3JDLM+UqBNTmtqJX3Tz7VrgrsfS9+1Gx9AcMz0vDiGQ1JJkCHpkaHpkeJlMi8owRaOSkTWBmlzeVoPoTRsBjGYrF252obHDtdPtooFOT6qJ9C8+yW+QxyORcjUD5JuSxCJFK4yAxGHYGGQSkMKmrWc37jjQkSJQqojY2eiTGcf8LMlbVti1IKPyUk1Vp3/osBagzjsS/CnPxZ5WKK3OuPmQY99aIQSWzFM4g45i8aVRSHI8RQZUZJH8ukioHJw5hQAgDYk+H4vRXXXMd/vv6q/z84MOOxiPPvgKTeefxWspcN5bNY8+DsmIZvDVF8EckNEgmuJMnYtiQIXCn7435FQrU1NnaDHrkTjaVzOYMekYm4/izJ3kCewR22hSLZtbuCnZF00DJyZO8jqiqoDttb4Spj0aL7bVFE+MaCqEoXQBXXSlrODjkCZD0ybjyi2qs2G5rWj41LQ233HLLzmf4caJu2Axz8c9AxSo4a8ug8FQjBDnc0EAWDkOrMyA1PQcyvbWxGsLIgzwZDn5LQacJeGw02LexjgbF3ptXSlBpY8BSAL9lCAKmvC6JHDWHLk+hCOleSAiF6XGEH4clictbo23OGrcn+glWn2xtntBSpEvJypSsCyFjG4bKYmmWrWi8VypkrIdA4l3d0i8kvh/JXTh1tWuhq13JBid5JSiXhsJmntSJLFtNRqp524/cx4WMWWov7zXm4OOKFLxcnIsglDhtr2ycPy1vRwfTSBiWbd+z16MrRgQlVXqCIUzItnatX4mg3yMMCGFA7NHQf3PCSadg7pzf+SJ91U134vLrb2Gdhw7hGX1Uxlfud0AqXgCXnaofIqiUJcM4ZG8k5E+GI+dQRMgl3s5gR8I7+uqlfMGmiynVy5N4zy4lVHISYhH0VYvbtF52ZU5v2eabKh3sW2Aq/hWq4nlwVG6DOuJFWcSKhppqzNoSwV8VaqxvUHA7aKK9cMtOiYSj7vDGbH59+d/w15egweWDLOCASgoiACWUCiUqbR4s31QGhx846LCjUTDteC5D9VuGdj7QR4LstdHWb+SchuYJkFRKScYYrYc8Dl1JeiTpbaow8IciPAMmo4F3KXdWlfGArpRHB3aKzVPioEohg1pBQlsxfYyoRkZ7Az/LcMXas7MQl8T3fhbtavzugMQNzshIIWMl+jkqC5bz96kVcmhU8h5tL055OLqaFSxZrbFv5/+TvEUUziCJdNId0desYs8WHX9ktFG1y8JqBf5v2whUIwEHDk/GjTNH7Eiu3EUjgrrGkhLqhGwL9Gohdz1YcAgDQhgQeyrbtm3HkUcfjcKNG6DV67nK4pDDj97pZ1SOIpiLf2N9ALmnFu6ipQh6bFAigjJVPtLGHQhp2FHRTPZ2Lu400FG4I9YdkaR/XVkH84y7O6DSQ0PlYr5AE9SXwZ0+FZ6USS2SAcmlTI28jBv+h6LibUhS+lEjmeF2ebCxzI5iJ7DJpkK1Tw65IQXP/vcDQJsY/TCrJlJPhlC0RJCz+m18HzUcqqHw1ALOCjhttWggWeywEwpE4JepoFFroEnMgS5tOAIyFT746ld88stirK+N4NwrbsJ1t93TsQEnRXiwIvc5lxg2S4Kk/AU2PhKGxx2aIAPBH4zAFwpzx1CyEmj2r1HK+UaiSSTHHRu0VY33bET0oFpiJBIV7qLtowZXtG2+YIily13+MOsl0HaT4UFGBTWkovyD5lUQ3QXtYzIEDeV/QVe3jv9j8o6Rh8iRfzSXhNI5QTkOlGdDlTBbbBH8Z2sGFoeHY2JOIu4+ZvSORMhdMCJoaCi3e5Fl1WNMpsiHGCw4hAEhDIg9kb8XLMQJJ5yA2ppqJKel48W3P8HocRN3WiJpKv2D48REyFkF17al0AQbEIQKNZbxSN33DPhyD2o39EADNn+e9A1osFObWamvvQoImpHyABGKzoIjPGDHLphRpzhdQGkmRoNGexdTcj1TOSdpAvA6tQlw5B7GCYPNKf7jPSh+ewjW5GQYtCp4JTWXrVbU2LGh0o2wFF338ccdh4yMzJ3uU/qNEWcVvPVlcLi9cAQi3DlUgyACcg1Mej3MZitkyUPhS54AX8JwNrTCcg1efPIRvP78k7yew489EY888yo02kYPREyboH59NO4e9OzYVxozfAkj4U8YGa2Y2InRQJcX2p8kz039PuhiQ2ECrVLBhgJl/GtV0cGY7slQ6LXQQReg30HS0vQ7PIEQnL4Q7N4gPw6GImx86VUK6Kl3SXcaOZSUW7uaDWD6LyjRlxQvKcmSxKKMFfOh9NZD5S5jUbQKrwIfFQLfBPbB0Kx03HvcmFZGxHfQ2LZwZVHDiNM7TeSN5UOMzjAhL8nQfb9LsMciDAhhQOxxfP7l1zjvnLPh83kxbNRYvPTu/5Ce0bG8M82UyOUfG7gaGuog2/4HDJIbThjgyjscpmkXtxmcY1BsPpq57uQBjrwBbgottFIlpEGNBgI6C8g9TS5bi1YFg1bJ7nB2eTe6ux2+IOyeIA8i9FynVMKsU7U0JhorQ7j1cuO2U5Jl8+8m0asP/n077tjbzX0ItOYEjncHoEKtJ4LSBj8aHG4cMm0/jBhW0PKHSWH4/X7YHE4EnLUIeJzw+v1QIgQjvBznJ40Gi1EHk8kMb+ZUuLIOZKOhvdbP33z2ER647XqEgkHsPXU6XnjlNSQHS6GrW9+ieoJKLSk3wpcwiuPyOzMaaNCJ9fSgiwt5FWhgTTSoYWpsK06DbU96E3oDOi7cgaiHgo6LBneQn1MIRK9ScrfL7uovEdWHWAbL9lmsXkmeKCoptucfyw3KKB+HOpuSIV3lVeD7TU58GdgPiRn5uP/4MTtCEJEwrFu+Zq8c/af1I89qN+TXHPp9vsZ8iCSRDzHgcQgDQhgQexKvvfkWrr78Mp5l73/wTDz1ytswUIOqdmjtNSBXbfnWtSwPrZKF0CBPQmDvq6EZd1y7EsX0eWPZXOhq1zS52B1DjmzTi4Iuig5fgGe8KSYt93OgGTENdjubAZOXwuWjGWiQZ2YN7gBUCgWselWLwSK6HfN49th6O2Ky2/mmMM4e7sOIRAl5qWaoDGaEZdHZYliSR/0I2mQ2CrhXAyUpSiHu1aBFAHLqJNl49hpUgEmrgdFsgcKYDGf2IbAPORJox2hozdK/ZuOVOy/ECJMX+4xIx3Ennw69wciubhI6ogRRSoTsSJuBLiFkLETbiEtQKmUwqJVINqrZwKLHZEDsiZ6F7oTyOKKeiQAfG05/CMFghMMxZDh1RwiAwlemol9g3v4ja0mQJ8GbPAEBfTpU/no2NOh/q3UH8fvGOswKTkIodTweOGFsU5t4khtP2PQpe8rIS0ZGRHvGZXNqnH7oNQpMyrEKfYgBjkMYEMKA2FN4+PGncM8dt/Dj4045Ew8++QJ3uOyoNNO8/eeoHoNMBrtlNGwL3kOGOxrCqNYVQHHUI1CkjOg4V6Lol6bPe1Imw5U1HZDv+D6Ka9e6fXwRzLToWLbXrFXu0uBGA0adO4DSBg+r+FGYg2bZzQ0Jqk4wF//S5AmhSg1H+lQcf8KJLJ5lUoa54VeBJYwcqwoqUyJ0Wi17QPSK1o2bGn+DpIRaRV4SFfQaDfRGM9QGasSUDnfGVB5QOk2G5Mz/0sYQxSbUVZbg+y//B4/bA4ciASfd/AwSxxzS4XrIA+MJhNnTQAmPOrWc25AnmzQwaZUwqpXcRXSwQt4JMiBsngC3zSaDkzBpVN1iTKkcxUjY+BH0NSui3ghdKrwp46Egr5cU4SoY8lLN3liNRcECVKfsjwdPmtg0+FMTr4SNH/O5QkZtw/BTdyrpTv93hd2LIUkGjEw3DXhjcDDjEAaEMCD6GpJQvvnOe/DME4/y8/MuuYpbTbebqBcJs8s/ViFBs/Vy3Qho/3gI1nANIpIcZamHwHjMvwB1y94LBM26eLZfs3LHbD/vCM5cj0GHuY3CD6Ewsqw6DEk2NM3Idv+3SmxIlNu83B5Zp1bCqlM1XWRbe0Xogv1tiQE33vkAP5cjghlZQUxNj5VBSjj8sMNhyciH0+2FjCsQZFDKwF4YizIEhVrHYQ8ySuj3etKmwJs0ttO+HhSW0NZvYNVMhd/RooKiOJCAy255EGsKi5CQlIxXP/gCo8ZOaPF5ivmTByYYkWDQKJCojxoN5sbQhKB9Q9PmDaLW6WfPBO1Do0bFhtZuVXREwjCUzUXyhvejlUnkjUgYHa0AIu0NMihrivDrhmoUBlNRmX0Ubj92QlPoiETUEjd9wtomlAjryD92p6EpCvfR76CqjDTRL2PAIgwIYUD0KeFwBJdedS3efv1lfn7tLXfjsutvaXfWQjoJ5u3fs3w04U2ZgG21HmQveww6yYuQTI2ysVfBPPXCdi9uJAhl3v4TV2jw51MnwZV5QIvwRqzbIF2wC1IMSDNpe2R2TImY1Bp5W60bTm8QiQZNi0GVYtfmop/Z4KEZ4s+VFtzz3PtNLciHW0I4ZJgRZx+5H4bl7bwVNyUvUniBbp1VP9BskysoGjY07WeC9hENHL6ksSxcROuoq6nGVeefyq3BzRYrXv3gS4wYNxEObxD+cARapRyJRjVSTVrulyDc2V2DjAcKB1TYfDwY0/606tW7Fd5QusqRuuJFbqFOIS0SQSMNDqoGovCTvXg1/lhfjtJIIvfGuObwcU3nIjWFS9j8BRsj7sz92YO1M8jTRuWzk3KtorRzgCIMCGFA9Bn+YAgXX34VPnz7Db5I3fmvf+OsCy9td1lt3XqYSn5rHFC1rOFQvOQHDNv+Mc+0vXIz6g99AvqC/dp+OBLifg5NXgu1GY68wxGk3gzNaPAEeOaUnahj92tvXPS8gTBK6j0osXkgk2ScCxC7YJPBRJnwsUoNV/JE/F2lRmWDe4folUzGFRDUbIrKMyMKTbT9uErP9yE9dbi0xiGZvIWTUdWuUt5HjEzOapBe6kRqHdoivBPD6bDjqvNPw6pli6E3mvDo6x9j+rSpSLfo2LNCMX3B7kGhtDq3H2UNXtS5/NAoFbtnSERCLOlu2f4DucTYi0WaJBGthUN5tZuXYP7GUtRIFkTGnY6zDxzX9FHKNyIjnAxIMjB21qclVtqZnaDHmAzzoA5TDVSEASEMiD7B4w/iokuvwKfvv8UD5oP/fh4nnXle2wUjQVaDbHLpm7JRn74/an98FMPsCyCXRWDX5sB//EtQWdvOxKmDo7nopyYlSJpBO7MPbhGvJ7dxtcsPg1qBoalGpJu1vRq3pdOKwhqbq12cVJdq1O6oOiDjp2we9NXLo8uS6zllArduphK9XYK7XFayqBVJSavclS3eJmEnqqAgj0MLkat2KijI29DgsOPBay7AyiULYDQa8f33P+Cggw7ctW0TdAgdpzUuPxucNLun6g2LnqSpd+1Y1VUtQ+qK59nrJA/7WPOEQmau9P1QuvZvLN9SAodkgH7vc3HkPmOaPkdlohQCJK9F/chzd2qgxoyfsVkWDgcKBhbCgBAGRK/j9AZw/j8uwdefvM8D9b+efgknnHZ2m+WiM/BvuWMgJxVmTEOtLBHBWfciN1DIigsNyXtBdvwzkLUeTCnmW7mQFSk5UUxlYJ2FAM2km0GJfTZvABkWHYcsKAO+L13WhVUuTkBL1LcMaVApnaF8ftNgH1PHDBqyuKkSK2S2p+YoRTh/gdpGK321ULkq2MvQosulTMZhCdZ9sAzttKUzbSeVqVIiKFWUUHdH0pI449ST8fvvv0Ov1+P777/HIYcc0o17R9Bab6GkzsOhjd3x9JAeSdqSx6FyVUIedHLDMn/iaD5XNi35BYVFxfBIWgyZeTnGj2gsE46EkbDpfyzVTuGxhpFntlvlFINKn8nLMSk3odtyiQR7BsKAEAZEr2Lz+HH+hRfju88+5CTJh595BceefEab5agfBHkOOGSh0sOedxRqSwuh+ftpZEiVCEEFe/5xkM+4u03JIBkc5qJZUcOjUU2S+gM0Lz+LzfqpP0JBkgE5ifo9QmuABoeiOjfndsRi3q0lsbnpVmPb5qa35CqEdKREKYdMCvOydE/hieYS0i36T1CXS3MuAmQ0dOLNoP1FZYdULUAiTqkmDSfHkbhTzDXt9Xpx8skn46effmIj4ueff8b06dO7a9cIWkH5OqX1XvZIkKx2kkGzS1oSVPWTuvQp7q9BiqVkFHjS90F9wYlYPudLVFeWwC83YspJ1yMtNbXpM4kbPuRSUV/iKDiGHL3T3BpKGs5K0IlQxgBDGBDCgOg16l1+XHrFlfjyw7ehUCjwyLOv4egTT225kBSBsexP7n5JkEvVkTsTVYu+RMLGD5Ess8EnM8A36SJIUy5pedGSItBXLoaxcgHPkmiQJMPBnziyzSBd4/LBolVzyCLFtGcJ3tBpRuV8m6qcnOjWRpCHyiqdxdBSky5PDUsXt/AotF6fXIkwdQ7VJiGkT+FZZmeqkM2TPSlMQc2SjFoVMsxapJo1HXpqfD4fTjzxRDYeTCYTfv31V+y7775d3wmCuCFhqu117qaqHjLqugrpPSStfgOmsrl8TFG7cPL4VQ87DfO+excBZw2gS8D0026A1mBt8l4kFH7G5x0pXXpTJ3cayiCBKdJREQwMhAEhDIheocrhxQ3/vBmfvPkyhy3IeDj25NNbLBNtKfw9z7IJivN7rCNQ9vuryKr4FWaZG15VIiLT/4ngiGNbfFbhrWOPRczFT2qKJEXdemZN7ndKlsyw6jAsxbhHJ/lVO33YUOHkQXynXQ45TGHj7qOMTA6JwhkyOSIqE8tJd6VZVczIolLWYDgMi16N7AQdb0M8lRQejwfHHnss5syZA6vVitmzZ2PSpEld+n7BrlX1bK11w+0LsYeoyx61SAgJGz5kBUvqmUHt6kkVdWveGfjr69ehDDpgSszAPidfB1ljbgwpXppK5rAXsH7k2Qjpox6K9mAhNaUMk3ISRBnvAEEYEMKA6HEopn/HXffi3Zee4uf3P/EcTj37ghbL0KzHsvUbbvhE7njWZogAxb++jALHQo6x+w3ZkB9yB3xZzcrHJAn66mXcSIhc9ZTY5cyewW7V1jNsSjwjV29+kgF5SXtGyCKeLocbKhzcI4LKIXuaJrluAIkGFWfQtxa8igeXy4UjjzwS8+fPR1JSEv744w+MHTu2x7ZbEIVEqLbWuFHp8MKsVXc954CMiE2fcKUFGfLkuaKOsYtSTsWaH1+DDl7k5Q3F8CMuj/aUkSQ+b6mKh5atH3VOh/kQXJVh87KuihCYGhgIA0IYED0GHS5lNi8eevhRvP7U//Frtz/4GM69+MoO8x1IpIhyG4KVG1A6712MCKzmC42UOAyRQ+/hBK8Ycr+N1SRjLbKpYyCVZ0bUpjazM5rN6zVKjEg1sqJkf4JmbusqHFzySeGW7m4RTf+T2x+Gw091+3L2NFBiJAk/7U68ms6rww47DEuWLEF6ejr++usvFBS06tch6JFqDVI8JY0RqtJM7uIxQ+ehtfBzVkXVNGxmrQiSVv9aOhQNf78NncyPvSbtjYT9zmHPlizkRdK69yAPuuBNHg9n3uGdGqgTciy9YhAL9pwxdM+frgn2GGhQKq734OnnXm4yHq6//b6WxgN5DyoWwrL1W75okeZAw/DT4Nk0G2WzX8XowCqEZSrIMychdPijO4wHSYK2djWS1r/PxgPNeChcYRt2chvjgRLNaDaWZFSzKl5/Mx6IBIMa4zItLG5F3hwyJLproCHjpNzuQ0iKoCDZiCl5iRifZWEjYneT3ejCQgmV48ePR2VlJY444gi+F/Qs5FkbkmzExJwEljmnY4b+63ih88k2/BSuxKBSXqWvjntqHK9ZAseIkxGUlFi3Zjlkhb/wuUjJyfb8o9jjR/1cNA0bO1w3hcBIv2J7rZvPTcHgQXggBHHLNdPs572PP8W//nkpS1Vfcs0/ccMd9zdbKMTeg1j7bU/qXvCkTIRj8Ydwrv8dw1EMn9wIY/7ecE67DWF9Ci9Hsx36HIkeNSVZ5h3Zbi06yShTE6zcJD0KUowswNOfodlbcZ0HxQ0eqrVgo6ir3gjqU0Clq1RNQesw65TsbSCDoafi0hUVFVyNsW3bNs6FoNwIOu8EvVka7EOSgdqhx/8fU04SNdKiTrdqxzZWMa0efjYeWKLAZOcfyLBoMGXm6fClTeHlDWV/ctk0hRHrRp3XYTlwrFfG8FQTJzEL+i8ihCEMiG6FwgXbalz46sdfcfcVZyMQ8OPks87HA088t6PfQ9AD69ZvoHKVswuUMrgpYavqr/cRKfoLebJq+FVWmEccANveNzRdiEgLgRpokauUkrZcGftzX4fWCYJ0mFK+gwQJQ1OMHMcfKKVj9NtIantbratJTIgGBSqtbC+mTMtT/gR1wCQDhE5gEsyiEkyq7iCJ6e7o/NgZmzdvZiOCmoIdfPDBmDVrFrTa/ucN6o9QBcTWGheXB5t1XcuLiJVrGktms/hYUJeOwtwz8fh8G6ZhJXs5sqafy0nLzfUhSPCtYfjpHVb6kBFLx+Pk3AQWwxL0T4QBIQyIbjUetlS78Ntfi3HbP06Gy+nAIYcfjadfew9KpbKpQZN18xcsbkQzFVv+cZD57Nj+58cw1CxDuqwBYV0yTGMOQ/2EK6JKiCxF/Rf0VUuj36NNhD3/aIT0ae1uA+U7UHXFiDTTHlei2V2Q+7fC5mVjgi/GoagksZwqMMitHOvdDRk0Cjm3V6ZkSGpkZe6jvhTLly9ncSk676jU87PPPms6LgQ97xUsafCgsNrFx0MLfZFOIDXXhI2fcJM3SnIm0bGfDSfgxzVlmKDYjpljsqCYcj6fj5SXRKFFCkl2VtpJoUXKgxiXZekVI1bQ/QgDQhgQ3QLFWEmKeeHqjbjl/ONRW12FyftM4y6NWp2uqZmVZcvXkId8nCxpG3oiFFWrsfHvb5HuWAWLzAOlKQ26ccegfswFnOVNpYlU2hnrB+FNmQhn9kHt9mWgmRbpO9BFaXiasU9VJXsLOiV9wQjc3PkyyO2yKRGSQht0UVYqZDCold3SFro7oPDFUUcdBb/fj6uuugovvvjiHrFdgwUKHWyscPI+J4MyXihkSImVZMiD8pUs+XjecTDqK7ZhrLYOh+81As5x53M+BMlck9w1VVPVjz6/Q6lr1mNx+jAhx8pKsIL+h0iiFHSL8VBY7cSabeV48Jrz2HgYNnIMnn/zoybjgbpL0gWIjAdqHdww7FTIt/2B1XO/QLZjOQwyP3SJ2dBMPgN1Y//BxoO2bh0SN3zAxgOJQpHBQcmS7RkPNAuvdfs532FslnlQGA8EDQSUu0A5DJQ4NyzVhLxGZU3KbSBjirwxe8ogTR6IDz74gLfn5ZdfxpNPPtnXmzSooIF6TCbpgkjcmCteYroqntRoyJBEpC5LXAaXNgOlfi1WFBaxoU+aJN7kCaxyKosEYS7+eUdztlaQoatTKTmhksIZgoGNMCAE7c4iSDFxc6UNT9x6BbZt3oTU9Ey89N6nMFutTWIzdHEhnQbq6mgfchSktV9g5YKfMdy7Cmq5hIS0PGDy+ayrL5MiMG+fxTeuzjDloH70eW36WMQgYSiXP4SRaUaMTDP3+2TJgc6pp56Kp56KaoLcdttt+N///tfXmzSooEqksZkWKBQyDvfFCxkPrsxp3PabZNKNjq24KW8LNkWysanWj5rijazHQnkPpONC1RxkaOhqVnS4TuqlQmWdlBwsGNgIA0LQxngorHJyctZrD9+JxfPnQm8w4sV3PkF6RhbPPAxl86JKdZLE4Qd3+n4ILHkfa5f9idHB9ZArlEjJLIB/r4thLziOcyQoaYu8D9xAK3N/2Iaf2qY8M5bNHbsAUhyVZuAilto/uPHGG3H99dfz4wsuuAB//vlnX2/SoII8VmREUC5MtSNOI0ImY2l4ymugJm7kYcgKFOGCzFJskHKwaFs9VKUL2dtIic+urGhHVpKmp8Z47a9SxtLbpbZoh1HBwEUYEII2xgNpPXzz1gv47vOPuL/Fv19+CyPHjGdXpqn4FxgqF/PyrqwDuNOjY8G72LxuMUZHNkOu0iE9Zxhce10BV84MaOvWInHDR2xEkMFAWdzujKntyjBT2ITiuaSNQPoOQl+/f0EDx9NPP42TTjqJ8yEoqXLTpk19vVmDCsqBoOZWGpWcFU/jQq6EreA4eJPHsky8POzFvqZ6TNVXYH0gBUuLGmAu+pml5eMNZejVSn6LJiJd0asQ9C+EASFoYzws+fVbvPKfR/n1u/7vSRx46OFcNWHZ+h10tWsa3ZmH88Wm6q93Ub55OUagGEqtAelDRsK217XwpO3F0rl04aGLDSlK1o06l0vBOqpAqHL6OZ5LnoeuZJQL9hzI4KR8CGq2VV9fj+OOOw4NDY39PAS9JlI2ijtkRqXe4yGiscJecDz8CcP5uSpgw4zMMDLk9Vhaq0BZrQ2Wbd8BUqhFKENbt6bDdZLqKbUop/NaMDARBoSghfFQWbgaD91+Hb9+0ZXX4/Tz/sFd/aybv4wKPckVsA85FrKAE9vmfQxHySrkyyqg0xmRlj8O9ZOvYyOBvA7kfSBjg3T3SVGSyzfbgZMlXX4MSdJjdIaZZy+C/gu1/f7mm2+Qm5uLwsJCnH766QgGg329WYMunDE63cwVPTZPfEYE5SM5c2YiaMzmfIiUSDX2TZVDK/Pjr+1OhJ01HLqkUAZ19SSMZfNYA6Yj9UydSiESKgcwwoAY5MSqLch4CDtqccsV5yMYCGDGkcfixjsfYOU6a+EXTfLSDVSmad+OtX9+i0jVamTI6mExmZFYMBk1k65lg4GrLLy17KFgGeuM/ToUn4klS45KN7HGg1opDsmBQFpaGr799lsYDAb89ttvnBsxwCrG+0Vi5cgMEwKRCLdvjwcKS7oz9kNESca+hIkWJzK1YXiDESwtqmuUtd4ET+pkbiNPFVimsnkdrs+qU3EzsJJ6kVA5EBFX60EMCTSRzgNlSxvlYdxyxXmoq6nGiNFj8cizr0IR8SOh8DNWoYsotWgYehKUFSuwbP4vMDSsRTKcSLFaYCzYFzUTr4baWQzLlm+4yoLkqOs5ZJHT7nfTYEKJXiSOFEuWHCjKkoIoEyZMwIcffsi5Ea+88grrQwh6FwoJjkwzwRMMswR2p8jksOcfC2/yOMjDASgQwUE55IUIoqTOw0Jn1JCLlGOprwZNDMjTqGpsftdhQmWDJ25PiKD/IAyIQa4wWVTvRqJehQdvvQYb1qxCQlIynnvzIxjVMtbMZ70GlR72/OOhLJqLRQvnIsW1HlaZB5nJCdAU7I/aMRfBWDG/KbmSemCQ5yGiNnb43RUOHzcFmpBlFcmSA5gTTjgBjz32GD++4YYb8PPPP/f1Jg06sqw65CfrYfMGOFzZGZTsTPkQ1AhP6a2DVQ2MSdFAkgGriioRDvhg2fYjq1RSp07CXPwby163B4Uk6WuL6jx87gsGDsKAGKQSuKSjv7WWjAcN3nrhSfz6wzdQqlR45vX3kZ1qZf17DkPQxWTIMcDmn7Fg8UJkeTfCqPAjJzUJ8oKDYBt2CixFs6B2FHOIg2YvrpxDOFeiPegCRnK3KUYNex4o4UswsLn11ltx4YUXcgO2M888k3toCHoP8gIMSTIgy6rnEul4BnF/wgg4sw9ldVm1uxxjMkzQKxVw+SPYXFLBCrSGigVwZR7AEwyqstJXL9lpdUiVw9cljQrBno8wIAaj8VAbNR6ok99fv/6AV/7zOL93/2PPYMrEMex5ILnpsMYMe97hCK37DguXLceQQCFMihDyUpMRKZjBNeGWbT9wD4ywxor6kWfBnziyw++mRCq6gFAjLFLO60oDIEH/HsBeffVVTJs2DTabjcs8XS5XX2/WoIISGoelGrmPDJ2D8eSjOHMPZW8ipDAM3nJMLEhHQKbC1mo7nE4HDJULofA3wJV1MC9vqFjIfTM6UqgkMTjyQoiEyoGDMCAGEXTRoLrsrTVuJOjUKN++GXf/8yp+77xLrsLJJx0fNR78djYISGDGv+prLF69GgXhLTApI8hLT0Gg4HDWfzCVzG4q0awfdQ43zOoIasNNCZPUSZMSJvui8ZOg79BoNNxoKz09HWvXrsVFF10kkip7GTrnKFGZdFbq4ijvJOl5+9ATWWlW6a3BULUd1oQU2GHA5uISIByEZftP8FmHNWpDhGAqnbtThUqbJ8h5FIKBgTAgBgl0saZM6M01Lm73HPK5cMOl58LjdmGfaQfglttubWE8UOmla/kXWLZuHUZEtsGqlpCbmQ7P0KM4rKGrXcXrdafvC9uwkyApO85jaHAH4AlFKy1oFkSzIcHgIzMzE1988QVUKhU+//xzPPpoVGtE0HtQP5nhaSbIGo36zggaM+EYcix3y1U7tmL/fCu8cj0KPXrUl27i0IWx4m/u0kkJmFTqrXZsb3dd1AzOolWhuMHDlRmC/o+4kg8SymxebKpywahWQauU464brkDR1s1Iz8zGU88+h5StXzYaDxY2ChqWfYk1GzdiRGQ7rBo5sjMy4ck/HIpwIFrSKVfBXnAs3FkHtKsq2bzSgq5W4zItyE0y7DENoAR9A4UxYtUY99xzD77//vu+3qRBqRFRkGKAwx+MK6mSyjrpmkBnbqpjNfKHT4BfUmN5rQywl0JfvZQrNjwpk3h5Y+kfHSZUGrVKeANhnswID1T/RxgQg6Xdb5WTRV3oBH712Sfwx6+zoNZo8PzLr2Jo3ZwdxkPqXqhc8hU2bi7EcKkYSXoFMjOz4M6dwdr3Cr8tKkk98gz4EzrOd2heaTE+y4I0s6i0EES57LLLcOWVV/IAcu6552LLli19vUmDjqwEPVdnVMWTD0GlnaRSaR4Cpa8OM9XrUWKcgOqwAcXVdZwDZS76Ce60Kdxhlyo3dLUrO1xdkkGDcpsvrjCKYM9GGBADHEqY2ljhhFouh1mnwtzffsLLT0fL6h56+DHsrylko4CMB0/KRJQs+hZF2zdjhKwEyQYl0jJz4cnaHypfLeRhP4KGDM53oBKujuBKC7sXyUa1qLQQtMuzzz6L/fffH3a7nTt5ejxCaKg3oQZ1lI9EGg3xDOQhfSrs+ccgrLZAa9+Mc4YGsT6Sg4U2M0J1W6H01MBQvYyFqAhj+fwOFSopF4O8GeSFEH0y+jfCgBjAkA7+hgonP6beEqXF23HnDZfz8/MuvAjnTVByDDOsNsOTMBpbF3yLqtLNGC4r4zLL1Iw87tKn9DVwIy1f0hg0jDidFSY7q7TITNBxZ0BRaSFoD7VazS2/U1JSsHLlSlx99dXCpd3L6NQKzkkiMTeSk+8Mkq/2pE1hmeuR3uVIzcxHtWTFkgYDNLZC6KuWIaxJQNCQxmJyxvI/d1rWSX0y6CbovwgDYoBi9wSxvsLB3oAkowZ+nw83X3khnHY7Ju81Gf931l48ayBjwGsdjo0Lf4StYguGysqRZtYhMSMXvqRRUATdvD5X1nQ48o7kzn0dQRehercf+clG7mkhKi0EOyMrKwsff/wx5HI53nnnHbzxxht9vUmDMh8iP8kAuy8OkSm5EvahJ3DFhdJbjUsSV2MeJmGDS4caj8TaEKaS3+DKjLb81tWthdJd2XGfDC7rFH0y+jPCgBiAUIbz+koHJyulmqK5B48/cAfWr16J5KQEvHvXmdD6azle6TEPxZq/f4avZjOGyCuRbjHAnJaHgDmfy7IkumgUHAtPesf9LAi7N8g9LUammzA81ch13wJBZ8yYMQMPP/wwP7722muxZEnHYkSCniEnUY90sw41cbT/Jol6+5CjeOKR5C7EJQUOzI5MwtxaIxTuCqgdRVC7ythbSf28TaVzOmz5TWWddN0QZZ39F3GVH2CQ0bCx0sknZqpJw69989lH+OyDtznu+fG/LkGK0gNJqYHblI8VC36D1LAZebJqZFoNMKblImTM4sQpUpijkMXOkiWJOpefY5kkDpWXZBA9LQRd4vbbb8eJJ56IQCCA0047DXV1dX29SYMK8gbkpxg4yZquG53hzjoQ3uQJHKY4SrUC0CZgkT8XG/zJ0DYUwlDxN7yJY7hSS+Uq5+Zb7UEVWRatmss6afIh6H8IA2IA4Q+R8eDg1tjpZi2foJvWr8X/3XkTv//SzadiXKaeT2yXPhfLF/4BtX0zcmW1yEwww5CSi7A+nSWpQ7ok1I88GyFDRoffRzFrkqdVKuUYm2VBplUnyjQFXYaOmbfffhtDhw5FUVGREJnqA8xaFfKTDXAHQp2GMliyfugJnFip9Vbirrz1+CMyAb/XGOCDBhr7Fu6N40nbm5c3ls8DIqGdlnWWim6d/ZJeMSCo7nvIkCHQarXYb7/9sGjRog6XpQsJXVCa3+hzgp1DJ31hlQuVDh+7I0m0hUSibrnqIvh8Xtx80l44Yf/R7Flw6zOxZNGfMDg2IkdWi4xEC3RJmVxZQWENinE2jDgTEY1lp2Wa5XYvq9qNz7SwRK5AsKtYrVZ8+umnrFj53Xff4emnn+7rTRp00ASAJh7xhDJIidaZdSAkmQLjIhtxVFItvg/ug8XuJCi4jHMNIgo1l3xTmSdpRXQE9eOhawkJzgn6Fz1uQHzyySe46aabcP/992PZsmWYOHEijjzySFRXV3f4GbPZjIqKiqYbzUoEnXfWpJa5lPNAoQqawf3f3Tdj+5ZCnDgpFdeeOQMyuRwuTRoWLl6IBNcmZMkakJFohc6ajpAhExGlHr7E0dwga2fKkrGGWKTtQGWaFr2qV3+vYGAyefJkPPPMM/z4jjvuwN9//93XmzSooOtG3KEMmQzOvCPht+RDEbDjypRVaJCM+Lh6CBrUGVDbt8JUNheelMm8OHXqlTcmZLdXDRKJACUNHu7VI+g/9LgBQTMJEo75xz/+gTFjxuCVV16BXq/Hm2++2eFnyOtAmvmxW1pax5oDgx0yFLbVurC9zsMZ1bHkxa//9wG++/wT7JulxP2XHgudTg+XKhkLli1DinsjMuQNyEhKgMaahoA5hz0PpDjnGHJUh500WzfEokoLgyjTFHQjV1xxBXfsDIVCfF9fX9/XmzSo6EooI6y1wpF/LCIqEzIDRbgyoxB/RcZgVh2FQbXQ1q3nyoygIZ3zJQzlf3XarbPWLco6+xM9akBQUtTSpUtx2GGH7fhCuZyf72x2QZ368vLykJOTw8lV1HynI/x+PxwOR4vbYILEWKg5VqJezd3uiM0b1+ORe27FyCQ57r/gUGRm58CjMGP+8lXI9GxAhtzOxoPanIKAJZ+9DY68w+DOnL7TSotYmWZBsmiIJegZaPLw2muvYdiwYSgpKeE24CIfog9CGZb4Qhkkce1JnchN9U4xrkO2vB6v1o5DsTKXBeooF8Jvzt9R1ulp3/NMEx+FTI7iOk9c8tqCQWBA1NbWIhwOt/Eg0PPKyvbrg0eOHMneia+//hrvv/8+IpEIK9aVlpa2uzw15LFYLE03MjoGk0T1pmoXTBoVuwEJr9eDW6/+B5LVPtx0zAjste9UeCQN/ly5HrnedUhV2JFGxoMpBQHrUPY8kEytL3nCTr+reZmmaIgl6EkohEkiU7F8iP/85z99vUmDLpQxJMnAPXM6bbjFZd4nIGRIgyVYjRsz1qIeJrxSNQoBQwaXdeqrl8BnGcrlnNwnowODkLwQta6AEJfqR8j3xGY7F1xwASZNmoSDDz6Yu/eRWt2rr77a7vJ33nkny+HGbjRrGQxQpQWVa2oUcs5kjvHYfbfDVrIRl01NwBFHHwt/GJi3ZgvyfWQ8OJGemASVKQX+hOGIqA2wDT8VfuuwuMo0R4syTUEv5kPEDAfKhyBPpqD3oI69eUl6FpiiHKudQV5MZ9bBkOQKHKjbhimqInxXn4XlMirlVEJfvZJbg1NolBrxddStkwwXvUqBkjoPV5QJBrkBkZycDIVCgaqqqhav03PKbYgHav1LF5PNmze3+z7NUmjG0vw2GFQmN1Q62ZAnieoYs775Aj9//h7On6jCcccfD7lKhXnrSjDMvwbJChdSk5KgMKfCnzCCW3bXjziThWE6grtpOn1QKmRcpknNd0SZpqC3oIZbp5xyCoLBIM466yw4nVFZdkHvkGnVs4ptg6fz6ghn7mEImPKgDTlwQ/paaBDEo9uHs1AdJVmayubAZy7gZY1l81gavz0oIdvmDaDK7uv23yPoZwYE6d1PmTIFv/32W9NrFJKg5+RpiAcKgaxevRoZGR3rEQwmKA+BVCZ9gTAnTcagPheP3nUjzhmvwoyD9kdKSjLmbajA8MBaJCs8SEkk4yEtajywxsOZCOuSO++mqVFypYUo0xT0NmSsvv766xyWpAnENddc09ebNKhQK+XshaBrQWdy09GEyqO5kmu8qgxH6DZis0uNbyP7c38MjX07lJ5KRBQaKL210Nata3c9VH5u1KhQ3OBlfQjBIA9hUAknXQRI6379+vW46qqr4Ha7uSqDoHAFhSFiPPTQQ/j555+xdetWLvs877zzuIzz0ksvxWCHTuINlQ72QMRUJgnKWL/r+stwRLYHe43MxsSJE/DXpiqM9K9BosKDZDIeLBnwW0ew1gN5HiLqjj01oVbdNJt7OQSC3iQxMREffvghJ1+/9957fBP0HtRULzNBi7o4qiPcGVPhSxwFZcSHy1LWIREOPLPBjLrUqfy+sWIhQrrUHd06w+17NsxaJVy+IMqFxPUeT48bEFSK9eSTT+K+++7jvIYVK1Zg1qxZTYmVxcXFrPUQo6Ghgcs+R48ejWOOOYarKubPn88loIMZykzeVOVEjcPP+gvNQwmv/OcxpDQsw4QsPWYceggWbq7GiMBaWBVeJCUkQW7Ngd86vFEg6nRIKn2H30OxxyqnX3TTFOwxHHDAAXjggQf4MXXtLCws7OtNGjTQdSYv0cDXgc60ISjPwV5wHMLaROQranG6aTUnXr/t2Bt+cx6HMnS1KxFW6SAPuqCrXt7hd1p0apTahMT1no5MGmA1UmRwUDUGJVQOlHwIciFuqnKgqM7LnofmjaoW/z0PL994Eo4drsRRRx6OyqAW+cFCGBVBJCYkAQn5CFiGwG8dCnv+MYC8Y9EnTyCEBk8QeUk6DEs1iYZYgj0GCmXOnDkTf/zxB4dFaVJBIVJB75WLry23s8otJTt2iBRB8uo3uCtnRdiKy0sOQ7kiCx8dJcOwDa9AHvbDkTMDiqCLJbFrx17c4YSmzObhkvER6aae+2GC3RpDxQixh0P23fZaNxsPFFJoPqjbGxrwyj2X4ehhCkyaMBYNIQWGBjfBpAggISEJUtIwNh7IrWjPP26nxgOVa9EMY1iqASPSzMJ4EOxRUDI2lXVTSIMqMmIeCUHvQLoQlHNV35nctEwOe/5RCBoyWKzufMtKBEMhvL4tmYXqIIVZ1jqs1HEIw1i5oMNVJejVHMagkK1gz0SMEns4pQ1ebK11IUGvahKKihkWz957NWam1iMrPQWm5DTkBrfAyMZDIpA8AkFTDrzJ4zpVl6Qsa3cwxOJQQ1OMO59hCAR9RHZ2NotMEY899hh7IwS9A00ocimhUpIQCO1c6CloyoUz6yAu4TzcUobxsq34eX01NqRRA64UKH31UHlrWA9CV7MKCl9Du+vRq5XwhyPsiRhgjvIBgzAg9mBI2nVTtRMGtZJPpub88L93kFHxGxIMWowcPRKZoSIY5EFYEhIhpYzl8kxP6mQ4cw/nWcHO9CTo5ByXaUFukkGUaQr2aE499VRccsklfMyef/75nDMl6B2SDRqkmTVxJVS6cmYgYM5DgsyFixJWQhnx462VLjQMPYUbcGnrN/I9hTwMFfM7XA8p7FI1mE14IfZIhAGxh0LiTVRxoZLJYdK2DD2UbNuCLZ/cg3SzCvvtMw4ZkQro5UGYrcmQUiey9jxJzLqyD+lQmjrWilvV2IqbXJQCQX+AGm7FpK5JK0LMTnsHEpCjhEq1Qs75Up2WdeYdzmWd04w1mCpfh7mFtVil3Rv+xNGQRQLQ2jdzm28yJpSellpBMUgunxpsldm84n/eAxEGxB4I5SKQymQ4DCQYWiaKUcnmd4+chzxTBPtPGYUsWS10shBMlhRI6ZPYRejOmAZ31gEdGg+s8WD3sYIlteJurichEOzpGI1GLu1UKpUseS1KO3sPEnrKStBx6+3OBnS6DpHirVHux/mJ62CBC+8sLEXtmAtZQp+MBnnAxcsay/7aaS5Epd3Xef6FoNcRBsQeBln2Gysd3A2PkiZb8+MLtyHNvx37Tx6GIWo7NLIIjJYURDKnIKRLgitzOtyZ0zrXeDCpMV604hb0U/bZZx88+OCD/Pjaa6/Ftm3b+nqTBg1kQBh1Kjg66ZMhKXWcf0Wqt5MMDZihXIllxTascCfAkXcEL6O1b4Es6GF5a5Wz/TYEsdwv8kKIdt97FsKA2IMgDYZNlU5Oakw1tdR6IAoX/AD/0o8xddJwjNA7oZBFoLekIJy9D8LaBLiyDoCHMp07gJKfSOMho1HjQbTiFvRnbr/9dhx44IEscU2CdFTqKeh5KB8rL1EHlz/YaZ8MT8okTuTWysI43VqILNTgvQVFaBh2KldqUChD7S6PNtoq+7PDRlvkhah2+FEfh6y2oPcQBsQeJBRVWOVCpcOHNJOOJV2b47NXY/3bN2O/iUMx0Wjj8ITWkoZIzn6IaCxwZR8ET/q+O1WxrHX7kJuow+h0s2jFLRgQpZ2kcEshjT///BNPPfVUX2/SoCHNrOPumbbOBnS5Eo68oxDSp2KU3oEjlUtZT2JZhQ/1o87lBG9q8a2gygx3BTT2LR3KahNlDcILsSchDIg9ALLit1S7UNrgYc9DmzLKSBhLXrwC4/OTsY+5ASGZAmpzKpA7jSWpXdkHw5O29077Z9S7/VFRljRT08koEPR38vPz8dxzz/Hje+65BytXruzrTRoU0DUkJ1EPXyjcqReC+u+40/bh5MtjE0owUlbCXgh6zZs8nidDamdRtCKj/K8OG22RwULN/WrjqAIR9A5iJOljKBFpW60L2+s8nMzYnoBT0Q//QaqsCtMT6hCQKaE2pUKWNx0RlTHqeUib0uH6Hd4gnP4QRjZqPCiFQJRggHHRRRfhpJNO4q6d1DvH5xOdHHurT0Z84lIyOPMOQ8CYhaE6N45WLcO2ajsWbm+IKlEqNFCEvFA5tkPprYO2fn27q6FrI3lmyQvRmdEi6B3EaLIHSMRurXGzUBQ5BpYuXYKffprF9+FIGMFt8xFY/RUOTbIhKFNCaUgGhhyAiMoQzXnYieeBcin84TBGZ5iQl2TgMiyBYKBBuUIkMJWamoo1a9awJ0LQ89BkJDdRj1AkwiHYnUG6NK6s6VAoNZhhqcRE2RZ8sLAIAUMGl3tKMjk0rjIg5IehYgF7XTvKhahx+uPSohD0PCKLrg8hmdZNVS6YNCos+GsuNx2rrtpRDz0uNwF37xfGIUn1CMnkkHTJUBQcHDUeMqfvNOeBBKLIXqBkSWq+JRAMZFJSUvDf//4Xxx9/PJ5++mkcd9xxOOSQQ/p6swY8SUYN9+epcwWQ2sl1hnRpDJWLkRcqxNGq5XiybgjmFdbikBFnwlD+N1TeWujq18Gr1EBbvw4+Cm+044WgEC95IUjYSkyK+hbhgegjqh0+LtekZMZFf8/Fbbfd1sJ40CokXDXWjYMSqiHJAJ/SCuWwQ9l4oLa5HVVbNAlEKWQsECWMB8FggYwG6uRL5wCFNagpkKBnocE8O1EPCih0JnFNXTqdOYdCpjbgAGst9pWvx4cLixCSazihUpLJWOZa4a2DoWIhi0x15IWgCZLIheh7hAHRRyqT6ysdkMvkMGrk7HloWb4k4b5DdDgx1wGlLIxKjwKakYex8UAhCxJoaY8IGQ9OH7feHZclBKIEgw+qxKDEyqKiItx88819vTmDApKbTjVrOGTaGe6M/bkzcJY2iKPUK+Gy12H2xmoWvvMljGSBKV3dWij8dr7vMBcCMpSLiow+RxgQvQyVPa2vdCISiWYVv/nmmy08D2Q83DRdh/OG2qFGCJUeJX7f7ENFvQvelAlwZR3YrsIkJRWRWptFp8KYLDOsetHqWDD4MJlMeOuttzgv4o033sD333/f15s04KEwQnaCnlvuULn4zoiojXDmzICktWJfkw37y9fgk8UlCEUk1I29mMs+qeU3iUpFvRDt98Aghd4aVwB1Qp2yTxEGRC/i8AWxocIJXyDM3oHfZ/+OV195pdkSEi6eosd1Y53QyYKo8aswZ6sPtqAC24NJcObM7NB4qHBE1SUp58HcqneGQDCYOPjgg3HjjTfy40svvRR1dXV9vUkDHkoCzzBr4/JCeNL3gS9hBNL0Eg5Tr0XYUcFeiIC1AK7M/RFWGaBt2AA5eSFqV+/EC0G6EB7hhehDhAHRS7j8IWyocMDpD3LSEVVYcOiiERkknD1egzv28sAo86M+oMIfhW7U+JVY36CArQPjgaWpHV4+ecdkCHVJgYB4+OGHMWrUKFRWVrLUtaBnIY9PplUHhULWqReCyjaprDOiT8Zkkx0HyVfhY/JChCOoG30BJJWeBaY0DRthqFwEWbh9o0R4IfoeYUD0AiTktL7CgQZPsEmiesXy5U2hC7lMwhmj5bhzvxCsMg/sISX+2uJAuU+NrXYF5rvyMGmvtloPVDpFOQ904o7ONEOnFuqSAgGh0+nw7rvvslrlxx9/zE23BD0LhU/j9UJ4kyfAlzQWKXoFDlRvgtpVgt82VCOitcKWfwwiSgM0jq2Qe+uhq1nZoRdC1ljNJrwQfYMwIHoYbyDMbbkpcTLdrG2SqK6treV7hUzCWSMjuGGqBmlyJ9wRJZZtd2KrS4MytwKfbtHgn7fcAoW8pXFAGc+kykaxx1Hp5qaGMwKBYEfDrbvuuosfX3311ahqkWsk6EsvBOU6UEg2YkzDBJMTh8hX4JPFxTwpsg09BSFdMiSFDvra1dBXLenQC0F5ZKQLIXpk9A3CgOhB6CQizwMd4Onmlv0tkpOToZJLOGdkABfua0WBqh5eSYlNFU6sqpVz/sNHhVpcfPlVmHHojDZNt2pc1NdCzwqTQppaIGgfEpWaOHEi50FcddVVnbagFvSeF8KXOBKe5AlINqiwn2orLO6t+HV9FaBUo37UWYio9FC5y6F0V0BXu6rddcSUe8kLIf7b3keMPD1oPFDOQ3Wj8dC6v8Xk8WNw9d5qnLJXCsZoa+GBEuV1LswvCcEW0eGDTRqYk9Nx8cUXt1kv1UAPSTJwX4v2pK8FAkEUtVqNt99+G0qlEl9++SWHMwR7iBdCJueKjLAxE+NMbhwqX4FPG70Q7qyD4LcOY7l+fc1K9kJ0VJFh1av4OmvztP++oOcQo08PGg9UVklhi9bGgyzoQdLmz3HC3lkYb7QjBDnsdg/mbvXBAQM+KNTBFVLgllahC1ovJQxRU6zhaSbR10IgaA219J4zB/joo+h9OIxJkybh3nvv5bcpoZISKwV7hhciYCngXj5JRi32UhUjzbMRv6yr4oTxujEXsvYNiUupbVuhr2nfC0HhW/I+lAkvRK8jRqCeMh4cfqRb2noe5AEXEjb9D7b1vyM5WA45wnC7PVhY5EZdSIePN+uhtmTgiSeeaBG6iBkPQ1MMGJpqbNuxUyAY7HzxBTBkCHDoocA550Tv6fkXX+DOO+/E5MmTUV9fjyuvvFIMNHuMF0IGZ/bBCJmyMcbk4VyIL5duZy+EP3EUGxdhtQn62lXQVy7u2Auhi3bqdHjbV68U9AzCgOiBnAc2HtrxPFBdc8LGT+DePB/+2u0wyHzwB0LYWOGGR5uBvNMexAP/eQPffPtNh8ZDQYowHgSCdo2H004DSktbvl5Wxq+rvv0W77zzDlQqFb7++mt88MEHfbWlg4KueCGCphy40/eD1WTEeFUZst1r8fuGan6vbvT5CGsskAdd0Nat7VAXgloCBMMSyu2ebv8tgo4RBkQ3VluQ8VDVgfGg8NUjcdP/4C9ZhpqqYlhlLkQgR01tA1bVqbDXpU9j6nEXYMqUvduELSjDWBgPAsFOwhY33NBKDr6R2Gs33ojxY8bg/vvv56fXXXcdKioqenlDB5cXIsMSpxeCG20diJA5ByONPtaF+HrJFtaFCBkz4cw6GGG1Gbr6tTCUd9wjw6pTocruZ8E+Qe8gDIhu0nlYW27nJlbtGQ9KTw2HLcKVa1BSVgIjvFAplPDWV2P29jAyZlwG46hD26x3R86DMB4Egg6ZN6+t56G1EVFSwsvdfvvtmDJlCmw2mwhl9DCU3Jhm0sLu7XxAD+nTWIXSarFgtKoC2e41+GNTDb9XP/ocLuukUk599VLoate0uw69WglfKIxKm6/bf4ugfYQBsZs4fUE2HqidbXvVFkp3JayFnwK1hdheXIRgJAKLIgSZqxpzi4KotYzHlLPvbrNeKtWs9/iF8SAQdEa8noSKCq7GoF4ZFMr45ptv8BElWwp6NBcCcXTqJNyZ0xEy52K4wY8DZSvxzeJClumX1GbY849FRG2GxlYIQ9mfO/FCqFnWn5R/BT2PMCB2A7uHjAcHlw+lW9p6HlSuMiQUfgaFvZiNh4qgHtkKO4xhJ5aXevB3pQpH3vYmZPKWfwOdbCQ8lZcoEiYFgk7JyOjScuPHj2+qyqBQhhCY6tkeGfF26qR23+7MA2CxJmKEqgrZrpWYVxj1QtiGnYSAMRsyKQxD5YIOO3WSlL/XH0aVXXghegNhQOwi9e4Aex5cvlALhckYKkcRrIVfsAhKcfF2rPNZMVRRjXR1AFsq6vFjYQj5pz2A9KzcFp+j7OMalx85iXoME8aDQNA5Bx4IZGe32yuGoddzcqLLNXLHHXdweSdVZZBKpQhl9LwXgq5tneHKnIqwdQiGGoI4QLYa3y/ewF4IKDRoGHEqIioTNI7tMJT8DkTaz60w61SosHvjyr0Q7B7CgNgFqh0+rCmzwxsMc2MsOkmao7ZvhXXL11B6a1BeWoxFrkTkyWox1OBHbV0dvt8UwCbTVJx0TkuRKEoaispT64TOg0AQLwoF8Oyz0cetjYjY82eeiS7XCIUwKJRBIY0vvvgCn376aW9u8aAiUa9GslGNhjiaXkU0VrjIC5GQjKHKamQ5lmH+lqjsvzP3cPgShlPTYpjK/4a2fn276zBqlHD5w3ydFvQsYoTqAjGxEvI80IQl1hirOZqGTbBu+QZKXwPqqsowu8EKK1yYZLQj6LHjt00uvLNOhVsfeaHFZ8nKrnL6OXNZKEwKBF3klFOAzz4DsrJavk6eCXqd3m8FeSBivTKuueYa1NRE3eWC7kUulyErQY8IpLi8EO6M/RBOKEC+IYT9Zevw4+J1iNAFVyZH/cizEFEbOTxs3jYLkNquj66rBrUC5TZfXLkXgl1HjFJxQt3eiurcWF/ugEqh4CYurdHWrYdl2/csFuWsr8BP1SYoJAnTTLXQS24s3VqPx//047wbH0RWTl4Lw4S6aqaY1KK3hUCwq5CRsH07MHs28OGH0ftt29o1HmLcfffdnBNBze1uoFJQQY9A18tkoyYuuemI2hT1QiSlIl9RgyzbEizZXs/veTKmwZM8nh8bK/6Ctn5jh2EMuy/Asv+CnkOMVHFS4fBhY6WT3WMkktIabe0qmItmQRbywu+sxY/lOvgiSuxrqkOWvAHbqux4fJ4HiaP2xxnntwxdkI47rXNkupkFUQQCwS5CYYpDDgHOPjt63yxs0VGvDAplUNtvqsggkSlB90O5XFlWHUKRCIdqO8OTvg/CCUORawhhqmw9flq0JpqnIpOhfvT5bGQoPVUwb/22Xf0PyknTKBTsMY7n+wS7hjAg4iQQDEddYxplm/d01cthLvqV65Qljx0/lypRH9JgmN6NCcpiNHiCeG1+Pf6u1OCBJ56HvFnVBVnIWrUCo9PNbJwIBILehXQhqO8MQR07SSNC0P0kGTXsiYhHF4J6YLiyDoAlOQN5ihqk1C3CqlI7v+dLHg93+r6QQQZj2TxoGtr3Qlj10bwLSngX9AzCgNhNSJ/dVDIbMqpLDroxp0yGUp8KRpUcR+g2gozfH1ZW4/lFQVx7693IzS9o+qzNEwAVWYxKN8Gib+vVEAgEvQMpVI4cOZLVKW+++ea+3pyB64VI0MEfjkQrKzrBk7Y3pMShyNJHsK98A35ZtDL6BjXaGn0Bq1MqfbWwFn7erheCvo9u5IWgELSg+xEGxK4iSTBULGALmBJ5ZFIIyyoj2OwA6uRJOC9hLVQRP1aXOnH7Tw6Mm7w3zr3kqqaPewIh+EMRjEg3cWxQIBD0HTqdDv/973/Zy/jmm2/i559/7utNGpDQtY7CtY44vBCSUgdX5nRYkjORI6+FpepvblRIBBKGwZl1YKMX4k+obZvbXUeCXs0if/HoUAi6jjAgdtV4KP8LhvL59IQt4s31IaysCmB5ZChuSF0Fc7AGNV45bv+mFA1BFR789/McZyUoM5jCGgUpBtaQEAgEfc/06dNZWIq4/PLL4XQ6+3qTBhxUXUYaN55gKFpZ0QnUjVOWPAyZugimyAvx26JlTe9Ru++QxgKl34aEjR+164WIVbNV2H1C66MHEAZEV5Ek9joYKhfx04hSj1pXAH9vt+P38ETclLEGWcFi+OVavDy7GHOLIrji+lsxbORoXp5cdzUuH3ITdchLMrQpAxUIBH3Hww8/jCFDhqCoqIhbgAu6H9KEMGtVcPpC8XkhMqbBkpKFHFkN9GV/YVuti98LmbLgyDmMJ3DG8r+gcmxvdx3k8eBW33F8n6BrCAOiq8ZD6Rzoq5bw05AuCX6PC3M31+HH8N64KLUQk2SF7JWYt8WLF+fbMWL0WFx8zT8bPy5xw600s1ZIVAsEeyBGoxFvvPEGP37ppZfw559/9vUmDTg0SgWL5VG/CilOL4Q8eRjSdRFMlG/F7wui11+iYcx5jV4IBxLXv7+TVt8RISzVAwgDIl4kCckVc6CvXs4Wb8CUC5m7FnMLa/C9bwL2M9XjGN06KAIOlATMeOCrjXCFFHjoyRdZ9Y4gTwVZw6QySSeRQCDY85g5cyYuueQSHtwuvfRS+Hxi4OluUs1aGDWKuL0Q7oypMKfkIFtWA3XJPJTVe5q6eDryjuBrsqlsLlSO4nbXYdaqOYxBuWeC7kMYEPEQiUC/7WdYGtbwgepLGAmVswSLt9fje+dwQG3A9YkLofHVwKdJxUuz1mFxeQQXXnEdxkyY1NS1kxwOw9OMolxTINjDefLJJ5GRkYGNGzfiX//6V19vzoCDvAKkC+H0d55MGfNCqFKHIVUbwVjZdsxdvLjpvfpR5yOkNkMRcCFp3Tvtfp6UKcl4qHUKYanuRBgQ8bDpR6hr10CCDJ6UydDYNmNTlQNf1aRjLYbgmazZMAbrEFFo8MsmJ95dVI+8/KG48sbbm5ImyYCgpEmqhRYIBHs2VquVQxjE448/jhUrVvT1Jg1IL4ReTX0r4vRCpO/X5IWQbZuDWmfUMxTWJ8Mx5Gh+bCz9A0pnWZvPU66ZUaMS8tbdjDAg4sGaxzrsdalToatfixqbC58V6TAnMgHPD1mIjHAF5CEPtkYy8cxXy1DnlXD/E89Bq9NxpjElTVLmcXaCvq9/iUAgiJOTTjoJp59+OsLhMC6++GKEQsL93Z2QKF+GRQuHLxC3F0KbNhzJmgiGoxh/LVrY9F7d2AsQ1ligCLqRvPbNdj9v0iph8wZR5xZeiO5CGBDxkD4OjtFncgjD6/Hg8y3AD+F9cX32NuyD1VD47XBZR+DDH//G/JIwTj/vYuw9dTp/tMbpZ69DQYqRm8oIBIL+w/PPP4+EhAQsX76cwxqC7iXNomXJaW8gHJcXgsSlDMm5yJLVIrhlDhyN+g4RTQLs+cfwY1PpHChcle3KW2uVcpQ1eOMSshJ0jjAg4iHog2H7L5D7Hfh+ix8f+/bDPgke/EP9G+RBL4LaJMxbU4a351ciNSML/7zrAf4YSbaqlDIMTzWKHhcCQT8kLS0Nz1ArcAAPPPAANm3a1NebNKCgcs5UswY2b/xeCGP6UCSqwsiLlGLh4r+b3qsdcxF7IeRBD5LXvNH+9+lULColhKW6B2FAxMP6b6Hw1GJpRQCv2faGVqPGU6k/Qhn2QoKEIikTb3y7EBUuCfc++jSMJjP8oTAn7QxLNbEmu0Ag6J+cf/75OPLII+H3+7kqIxIRMfTuJMOiY+8sXTPj6ZHhTdsLhmTKhaiFe9MceBtzKCSNGbb84/ixuXQ25J7aDoSlZCi3eYWwVDcgDIh4yJ2KNXXA01WT4IQRbwxfCLO/EvKwD66kifh21q/4dWsQR594Gg6aeSTnPVC2b06iDhlCaVIg6NdQAt6rr74Kg8GAefPm4bXXXuvrTRpQWPUqpMTZ6pugMIYlcygSlAFkhsuwbCkpAkepG3shwmpT1AvRQS6EVafiJoZCWGr3EQZEHKx0mnDpximoQQLuGVODUa5F3DzLbynA0tUb8O78MujNibj9wcd4eer+ZjWokZ8s8h4EgoFAXl4eHnnkEX582223obS0tK83aUAZaJlWHXtzSfCpM6iVtz91EnSNuRD29bMRbExwldQm2IccxY/NRT9D5ov2zmhPWKqmsYpDsOsIAyIO/v3TRvjDMhyYGcFpga9ZaTKkTURVyISPfvwTG2ojbDwkJiVz2CICCUNTRN6DQDCQuOaaazB16lTukUFtv4ULvPugNt/xtvom3Gl7IymzAFaFH4nBcqxetsMLUTvuEoRVhsaKjP+2+3mzJiosFU/ypqBjhAERBy+dtxdOmZCGB03fQBFyQ5Jr4LUOx68/z8I363044NDDccxJp3NmLyXnDEk0IMUk9B4EgoEENcOjjp1qtRrfffcdPvnkk77epIHV6tuq5zyIeCokIhorAikToE3K5VyI+rWzudyWkDQWOHIP58eW7T9AFoyqVjbHoFHA7Q+Lks7dRBgQcWYK35mxGFb3NkgyObyJI7B29Rp8+Od2hJRGTpwkNxzF1ajPRW6S0HsQCAYiY8aMwd13382Pr7/+etTWtk3UE+waSUY1J5zH0+qbcKfvgxTyQsh9MPgrsHFVs4qMCVcgotRF1SnXvtXms3S91qsUKG3wIhRH2ETQPsKAiIeyZTBs/pYf+pLGwumL4Ntf5mBhWRg33HEfMrJyWGlSpZChINnY1EJWIBAMPO644w6MGzcONTU1uOmmm/p6cwYMdN2kJlvU6jue8FBYm4hQ6hioEnM4F6J69e+QIlEvRERrhSPnUH5s3fINEPK3W9JJxkq9KOncZcRIFw/L3oNMCsNtykNYacTc337Cl2vcmDBlP5x5waXsciNN9yHJBlj00cZZAoFgYEIhDOrYSbPY9957Dz/99FNfb9KAIdmogTHOVt+EJ21fpGXlwyLzQu2pwLa1O9QpayZejYhSyw0Ok9a/027YRCGTocLmE/ksu4gwIOLh0Lvgy5wKl3kYNm9ch28WFKLCq8IDTzwHuVzOoYtUk5abwwgEgoHPfvvthxtuuIEfX3HFFXC5XH29SQOnyZZFG3eTrZA+BVLKaCit2ciU1aJy9W9AzAuhS4Iz+2B+bN38JRBua5TQhK/W7YfDK0o691gD4sUXX8SQIUOg1Wr5xFu0aNFOl//0008xatQoXn78+PH44Ycf0KcYU+AZcjgijmr89tuv+GVLCJdfdwsKho+E2x+CUi5DfrIBShG6EAgGDdSlk8o7i4qKcM899/T15gyoJls6NSU5xjeou9P3RXp2PqzwIOKoQMWmHZ06a8ZfhYhCBaXPBuumj9t8VqNUIBSSUC1KOneJHh/xKFOZ4oT3338/li1bhokTJ7KqW3V1dbvLz58/H2effTYuueQS1p+nhjZ0W7NmDfqMgBu60j+x9K85+H6tAxkFY3Dx1Tdy6IIkWClpUqhNCgSDC6PR2CQq9dxzz2Hhwh3uc8FuNtky6+Iu6QwZ0qFIHQmZJYtzIcpW/NrkhQgb0+BOn8aPEws/BRorNVrnQoiSzj3UgHj66adx2WWX4R//+AdnML/yyivQ6/V48832VcKeffZZHHXUUbj11lsxevRotvL32msvvPDCC+gztsxG8eZ1+GvZWiytkPDAv5+DSq1GncvPMTvRZVMgGJwcccQRuOCCCziGTpOeQEAk5HUHVM1GfYR8wfgGdWr1nZGdDwvc8NoqUL91adN71ZOugSRXQOWuhnn7d20+a1Ar4AmEORQt2IMMCDqZli5disMOO2zHF8rl/Pzvv3eU3DSHXm++PEEei46W7w3c+mx8+d1P+H5TCOdcfCUmTN6bBaNo71HoQq0UoQuBYLBCk6SUlBSsXbsWjz0WVaMV7B5mnZK1dOL1QgSNmVCnDkPElIVMWR1KV+zIhQiZc+FJncyPE9d/2H5Jp1qBMpso6ewqPTryUY00iXtQR7vm0PPKyrbtVgl6vSvLU4Mbh8PR4tbd3PX0W/jXT9UImbJw7a1382yDBKNyE/TcqlsgEAxekpKSuO038X//939Yt25dX29Sv4cGdWqyRbUR8chbE+6M/ZCZPQRWuGCvLYWzaHnTe9UTroQkk0HjLIaxZE67Wj9c0ukWHqSu0O+nzo8++igsFkvTLScnp9u/Y+zYsTCYzLjh/n9DbzBy0xerTo2cRBG6EAgEwBlnnIHjjjsOwWCQQ7aiY+fuk6gneWtV3E22gsYcGNIKOCciQ1aP0ma5EIGksfAmjeXHSe002Woq6bSLks49xoBITk5m+deqqqoWr9Pz9PT0dj9Dr3dl+TvvvBN2u73pVlJSgu7m8ssvx7ylazBl+iFsDftCYeQl60WvC4FA0DRjfvnll2EymTgR/KWXXurrTer3yBvlrQPh+OStIZPBnT6VcyES4ERddRn8pSub3q4ddxl7IbQNhdBW7qjUaJ5MSdLWoqRzDzEgSHBlypQp+O2335peI8ucnk+bFs2MbQ293nx54pdffulweY1GA7PZ3OLWE1isCXxPB1iaRYs0k2jTLRAIdpCdnd2UA0ETm+Li4r7epIEjb+2LzwsRMOfBkp4Pvy4NaahFyYpfmrwQ3ox94bcM5ccpa17vsEunKOncg0IYVML5+uuv45133sH69eu5i53b7eaqDIIymOlki0HiLLNmzcJTTz2FDRs24IEHHsCSJUtw7bXXoq+hjGCSW6VmWaJNt0AgaM2VV16JAw44gIWlRMfO3YeutyTQ5w2G49uX5IXImIa0rCFIhBNVlaUIV6xqertu7EV8r6tdC3X9xna7dFY5fHFXfwx2etyAOPPMM/Hkk0/ivvvuw6RJk7BixQo2EGKJkmSlV1RUNC2///7748MPP+T6atKM+Oyzz/DVV1+x9nxfI5fJkJOgF3LVAoGgXajKjCZM5H0lAbyPPvqorzep30PVGFRq6YpTWCpgHoLkzAK4NalIlWpb5EK4cmYgYMqCTIogZdWr7XbppO8RJZ3xIZMGmIlMVRiUTEn5EN0ZzthW40KV04/JuVZWLxMIBIKOoGqMe++9l/PAyPNK94JdZ0u1C4XVrrjbBajtW+Fa+D6c2xZhk7wA0467GMiYxO9ZNn2K9KVPQ1KosOWYTxA2ZrT4LFVi6NRyTMlL5OTKwYajC2Nov6/C6C0SDGqMTDMJ40EgEHTKbbfdxjL8VMp+44039vXm9HtSzRpoVfKo/k4cBMz5SM0eCqcqBUmRWpSt3KELYR96MkLaRMjCQaSsbuuFMGuVrD8hSjo7RxgQcUKJPGRECAQCQWdQCOO///0vhzQ++OAD/Pjjj329Sf0ak1bFRkS8wlKUC+HJnIqUjCFIggOlpcVQ1DTqcyiUsBccH11v2VzI/C21g6I9jWScCzHAHPTdjjAgBAKBoAfYZ599mrwP1LHT6XT29Sb1a6g/BiWvB0LxaWwELAXIzC2AXZmMhHANylf9BkjRz9aNuQBhtRHyoBfJ7ehCWHUq1Dh9cMaZdzFYEQaEQCAQ9BAPPfQQ8vPzWZ/mrrvu6uvN6ddY9SqkGDWweeIMLchk8GVNQ1J6Hnshiou3Q1W7nt+SVHo4cmbyY/P2WZCFfG1KOv0hCTUOkUy5M4QBIRAIBD2EwWBo6tj54osvssiUYDfkra1ahCUpPmEpanVgGYrsvGGwKRJhCVWjcvUOL0Tt+EsQUWig9Nth3fRJm8+aNEpUiJLOnSIMCIFAIOhBqDngRRdd1NSx0+cTQkW7I29NuWhd8UL4c6bDmpqHZNhRXLStSf8hokuBK2MqP04o/BIItwxXGLVKuP0imXJnCANCIBAIehgSxiPtGxLHe/jhh/t6c/otlOBIpZz+cBiROBMcqSIjt2Ak6uWJMAYqUbN2NtD42drxl0GSK6HyVMG0/Yc2uj8ahQLlNm/cHo/BhjAgBAKBoIdJTEzECy+8wI9J7nrVqh3qiIKuy1ubNCo4fXEmOMpkCOZMhzklF8mUC7GtEOqGTfxW0DoUnuTx0fVu/LjJsGjeH6PBE4zf4zHIEAaEQCAQ9AKnnnoqTj75ZIRCIQ5l0L2g65AWT1aCDi5/MO4yS1KnzB06GrWyBOh8FbCt3+GFqBt7MSSZHBrHdugr/m4jpU1SUlTSKWiLMCAEAoGgl5IAKZGSVP6ov88zzzzT15vUr+Wt9Wol3IE4ExxlMkTyDoAhOeqFKNpWCI19C7/lTZsCv6WADYrkdW+3+ahJq0S10w9nnA29BhPCgBAIBIJeIiMjA08//TQ/JqnrzZs39/Um9UvIeMiwaOHwxR9aCJjykDt0DGqQALW7DI6Nf0S9EDIZ6kadE231Xbcemrp1bb6LKjHqRH+MNggDQiAQCHoR6kQ8c+ZMrsa47LLLEInEJ4wkaEmqWQu1Qh5/maVMBlnBQdAkZnNFRsmWdVA7ivgtV97hCOrTIYuEkLT2rTYfNWpUKLf54A+Jks7mCANCIBAIejmUQdoQer0ec+bMwRtvvNHXm9QvsehUSDFp45e3pqRJYw5yh09ADayQO0vhKWz0QsiVsA07BZIMMFQthtJR2iaM4fCFRElnK4QBIRAIBL1MQUFBUznnLbfcgtLSlgOWID4ojEEEw3F6cWQyqIYdAqU1J+qF2LwKKld039uGn4KwJgHykB9J699pW9KplHNJZ0SUdDYhDAiBQCDoA6677jpMnTqVe2RceeWVonHTLpCgVyPZqEZDF8osg8YsZI+YzF4Imb0Y/i3zdshb5x3Jj02lf0Dua2jj8WhwB2HrgsdjoCMMCIFAIOgDFAoFd+ykzp3ff/89Pvzww77epH4HNdfKtOpY6CkUrxeCel2MOBQwZyEJTpRvXAqlu4Jfrx91LsIqAxQBJxI3fNimpFOChEqHt9t/R39FGBACgUDQR4wZM4arMYgbbrgB1dXVfb1J/Y4kowaJBnWXciFChnRkjNwPtTBDshUhtO0vfj2sT4Yrczo/tlCTraCnxefMWhU32HKJLp2MMCAEAoGgD7n99tsxceJE1NXV4frrr+/rzel3KOQyFpbyhSJdkpw2jZ6BkDEbCXCicv18KD1R461+zAXRJlu+Olg3f9WmpNMbDKPWKYSlCGFACAQCQR+iUqnw5ptvckjjk08+wVdftRy0BJ2TbNRwu29HF7wQYV0yUkZOQx3MCDcUIVIU7ZQasBTAkzKJqzOsW76ELBxot6QzEBLlt8KAEAgEgj5mr732wq233sqPr7rqKtTX1/f1JvUrKD8hO0EHTzAUd5MtInHsTHj1WbDCiep186Dw1XOlRv2Y8yEpVFC5ymEs/rXFZ0RJ5w6EASEQCAR7APfffz9GjRqFyspK/POf/+zrzemXXgiTtgtNtrildyISRx2MesmEcN1WyIqiuRDe1MnwWYdDJkWQSE22IuE2JZ0VdlHSKQwIgUAg2APQarUcyiChqXfffRc//NCyvbRg52hVCvZCdKXJFpE2YQac2mwY4Ubt2tmQ+22ATI66kedCkiugsW+DoWJBm5LOOldg0Jd0KjFICYfDCAYH958vGHhQSaBcLuYF/ZVp06ax94H6ZVx++eVYu3YtN98SxEeqSYvieg/c/jCM2viGN0ljgXHM4bAtK4GmdgvkxQsQGX4UPNkHwG/Kgda+HYnr34c7c38Ob8RCJhEpWtJJFSCDlUFnQJBlSi5Cm83W15siEHQ7ZDzk5+ezISHon/zrX//CN998w422SKXy9ddf7+tN6jfo1ApkWnQorHLGbUAQOZNmYO3aX5AfWI+GNbNgyZuOiNrE6pRpS5+Btn49tDWr4Eud2MILUUMlnYkhGDWDbihlBt2vjhkPqamprEVP7kKBYCBATZnKy8tRUVGB3NxccWz3U+i6RAJTBx98MPfJOOOMM3D44Yf39Wb1G9IsWpTaPKzVEO/ALlPpoRt7NBzLiqCr3QJF6QJECg6HM+9oJK7/EGp3JRI3vI/ylAlNXgi9WskKmFTSadQYMRhRDrawRcx4SEpK6uvNEQi6nZSUFDYiQqEQlwcK+icHHXQQrr32Wrzwwgu49NJLsXr1apjN5r7erH4BGQ3khdhS4+6SZyB/0qFYteZHDA+uh2Pld9DnkBfCCMeQY5C07i0YqpdDbd+MgHV4m5LODKsOGqUCg41BFSyN5TyQhS8QDERioQsylgX9m0cffZTDUcXFxbjtttv6enP6FekWLXQqOdxdUIyUqzRQjT0eLkmHUN0WqEr/btlkK+hG4oaPWnzGNMhLOgeVARFDuHYFAxVxbA8cjEYjV2UQr776Kn79taUegaBjqJwzw6KDzdu1gX3k5INQohoCeSQA18ovIQv5ENYlwZEzk1t9G8vnQ+UoblHSqR3EXToHpQEhEAgE/YFDDjkE11xzDT++5JJL4HA4+nqT+g3pVi2XdnoC8XshlCo15GNPgVvSIli7DerSqC6EbcSpiKgsUAQcSNj0WYvPmBu7dHalI+hAQRgQA4whQ4bgmWeewUBhzpw5PKsWVTOCwcpjjz0mQhm7ADW+Sjdru+yFGD9lOraqhgORIDwrPmcvRNCcB1fmVO7GaSqd3dQ3I1bSSVQ5Bl9/DGFA9CNKSkpw8cUXIzMzk2PdeXl53MGPmvAMlNnWjTfe2OK1/fffn6sKRC28YLAiQhm7Dic3KhTwBuLPCVIplZDGnwGPpGEvhKZkHr9uG3EGIkojlL56WDd/2cZYqXb64fQNLm0hYUDsIpSkRrPjjz76iO97Omlt69at2HvvvVFYWMjfSTXir7zyCn777TcWn+kr7Xz63VQ+2FOQoZSeni5i+4JBjQhl7Bqk1ZBm0XQ5vLD35L2xXjkG4UgY/uX/gyzshy9xNDykAyFFYCr6CQpfQwv9CV8wghqnH4MJYUDsAl988QWHCg499FCcc845fE/P6fWegi4eNJj+/PPPXB9Odf5HH300z0bKyspw9913Ny3rdDpx9tlnw2AwICsrCy+++GILIa0HHniAP6/RaNib0byFsN/vZ/Ea+hx9fr/99mMDKcbbb78Nq9XKQjdjxozhdVCtOsnwtg4zkHdkxowZ/Ji8JLRNtF6qghk/fjwbQjEuuugi/PHHH3j22WfZWKDb9u3b2w1hfP755xg7dix/N+33p556qsX30muPPPIIe2tMJhP/1tdee63p/UAgwCVyGRkZvN3kyaGMd4FgTw9lFBQUcCjjpptu6uvN6TdkWvXcu6JrXggFpInnwCtp4KsvgbZoDus/NIw4ExGVDipPNczbfmzxGZNGiXK7D77g4KmAEgZEFyEj4bTTTkNpaWmL12kQp9d7wogg78JPP/2Eq6++GjqdrsV7NDs/99xzuQ1wTP/93//+NyZOnIjly5fjjjvu4IH8l19+aRp8//Of/7ArlLwZ1DqYBvMYNLD+/fff+Pjjj7Fq1SqcfvrpOOqoo3jZGB6PB48//jgbDiS1S99PRgWtu7lngraJ3iN8Ph+mTJmC77//HmvWrGGZ3vPPPx+LFi3i98lwIE/KZZddxiELuuXk5LTZF0uXLmVhnbPOOotr48kYuvfee9mwaQ4ZFeSxoX1A+406HG7cuJHfe+6559gA+t///sevffDBB2x0CAR7eijjrbfeYoOahKZEr4z4vRBU1tng7Zp3YP/J47FCNRGhSASBFZ9AFvJHm2wljIQsEoZl27eQB5wtSjrdviDqBlNJpzTAsNvtNIryfWu8Xq+0bt06vt8VQqGQlJ2dzetv7yaTyaScnBxerjtZsGABr//LL79s9/2nn36a36+qqpLy8vKko446qsX7Z555pnT00Ufz46eeekoaMWKEFAgE2qynqKhIUigUUllZWYvXZ86cKd155538+K233uLvWrFiRYtlbrjhBmnGjBlNz3/66SdJo9FIDQ0NHf6uY489Vrr55pubnh988MG8nubMnj2bvy+2nnPOOUc6/PDDWyxz6623SmPGjGl6TvvgvPPOa3oeiUSk1NRU6eWXX+bn1113HW8rvT7Q2N1jXLDnc+ONN/I5kZGRIdXV1fX15vQL7N6ANHtDlbRgS620qsQW9+0/X82Xfr/nQGnJ/VOlLbPf5de2/vW55H1qkuR7coJU9PtbLZafs6FaWri1VgqGwtJAHENbIzwQXWDevHltPA/NIQ8AJTrScj1BvB3maCbf+vn69ev5MXkUvF4vu0Jptv/ll1+yaiFBM3ryHIwYMYJnO7EbhRa2bNnStD4KpUyYMKHFd5CngcINpIJI0Kz+2GOPZc8EQesljX/ydiQmJvJ6yatC7tiuQL9j+vTpLV6j5+QhaZ6H0nz7aMZGnprq6uqmcMmKFSswcuRIDt9QWEgg6C9QeI7OUfLSNQ8/CjqGkhxJnbKruRAHThyFhcq9EYxEEFz5GRD2w505HX5rAWSRICxbv4Ys6Gnh7bB5gqgfJCWdwoDoAnTCdudy8TJs2DAeBGNGQGvo9YSEBJYx7gwKC5Db/qWXXuJwCLn3STaXVDpdLhcUCgWHCWiAjd1o/RRiiEGfa53UuM8++2Do0KEc+iADhQyTWPgiFlahddx+++2YPXs2r/fII4/kfISeoLWMM21vLNlzr732wrZt29igoW2lkAiFnwSC/gCdf++88w43TiNDnc41QedkWEmdUtEldUq1Ug7F5HPhlnRwNVTDWPg1JKUWtoITEVGooXFsh6l0btPyCrkMCpkMFTZfl1qK91eEAdEFKOmuO5eLF+rbQc10aNCnAa91czC6iJx55plNg/qCBS1719Pz0aNHt7gAHX/88ZwLQF4Dynkg78PkyZN5Fk8zdTJamt9oBt8ZZDDQtnz77bd8cSMPRIy//voLJ554Is477zzOzyAPyKZNm1p8njwbnVWz0O+gdTWHntOMjIyfeKG+ArTPqNMh5WpQ/kZfVbIIBF1l6tSpTZoQV1xxRZN3TbBzdcqsBFKn7Fqp5YwJBZirnMZeiNCaryALuuHKnYGgKQfykB+WLVHFyhgWvQq1bj/sXfye/ogwILrAgQceiOzs7A5LCul1muHTct0NNdWhCgmatc+dO5dDJbNmzWLDgiobHn744RYD6hNPPMEDNFVgfPrpp5xISVCyISVgUSIjlYa+//77bFBQJQINwmQEXHDBBZwMSrN0SnKkCgVKfuwM+uyyZct4W2hGT1USMYYPH86JnPPnz2ePBl30qqqqWnyeEhkXLlzI1Re1tbXtlofefPPNXLpK3gP6fTQTo31DlSPx8vTTT3MFyIYNG3gdtH/IQIqFWwSC/gAlEI8bNw41NTV8Pg2GGe/uQvLWerUCLl/XvBCGvc+GTTLCbquHacOn0Vbf+cciolBBa9sMQ/n8puWpqVYoJKHaMfBLOoUB0QVohhtz5bc2ImLPSQWyKzPheKEBeMmSJTxzJ5c7hQuokoFKSMmDQHkFzQdZWpY8Cv/3f//HAyYZHgQNkjTrprwByhOgMlDyGMS6k1KWNxkQtA7KETjppJOwePFiLoXsDPJU7Lvvvly90Tx8Qdxzzz0cOqDtoJp2GrBp3c0hI4D2HZWHUjimvfwIWgdVT1CohC6e9913Hx566CHOa4gXKu0kA4uqNCj0QgYLZbST10Qg6C+Qgf7ee+9xuI6qqd59992+3qQ9HoNGiSyrDnZfoEsG12HjcjBbdRBXZAQ3/AC5rwHOvCMQ1KdDHvTAuuUryMKBFrkQFQ5vl2S0+yMyyqTEAIIEVki10G63t2l/S6WENKsmWViq/99VaHZOM/rmCZXkeSDj4ZRTTtmt7RcIdofuOsYF/QfyEN51111sGFMokryJgo6hQX1ZUQNkkHEfi3j5aVUpRsy/CZlKB9KmHA/b5GuQtOoNJK1/BxGlDuXT7ocnc0eCd5nNg9EZZuQlGTBQxtDWiCnXLkBGAs1aKRnwww8/5Hu6aAvjQSAQ9DaUC0GS7yQgR564nlSGHQjo1UpkJ+jg9IcQ6cL8ecbYTPyunhHVhdg0G0pXORz5RyOoT4Ui6IrKW0d2eByMGhXKGrwIhAbu/yEMiF2EXO3kiid1RbrvibCFQCAQdAZdeygXiJRjKSm6ecWUoH3SLTpYdaouJTpS06y8/Y5HSSQVDU4XzOs+QNCYCVfWgZBkcuhr10JfvayFsJTDF0Kta+DmQggDQiAQCPo5lH8Uk3S/8847WSFW0DHU5jsnSc/hjHAkfi/EIaMyMFs7E6SK7d22EJqGjbAXHIegLhmKgB2WLV8DkWglmVwmg1YpR7nN26Xv6E8IA0IgEAgGAJRUTf1xqFqLyqXpXtAxqSYNkowa2Log+qRUyDFqvyOwRcpEg9MJ0/qPETDlwZO2b9QLUbMS2trVLZIpSbyqfoDKWwsDQiAQCAYAVAlGbb+Tk5NZqI0qlAQ7D0nkJuoRCEcQCsefp3DQyEzM082EN6yEq2QV9FWLYR96AkKaRO7QSRUZ1LEzZnBQsmaF3Tsgy2yFASEQCAQDBCqPpjLtmPpr8066grYkGzXsieiKh4DUJidNnYl1kTw0ON3QF36NgCkXnpSJgAzQVy+HtnZHCMmqV6HGNTCFpYQBIRAIBAMI0le59NJLecZLmi42m62vN2mPhYyB7EQ9d0PsSrXE9BFpWGI8FPaIFs6yQhjL5sE+7CSE1VYofXX4//bOBLypMt3jb9ok3Vu6sBQKlB1EFgHZKnBBEC8q6DiI4mVQcQWF0RmXcRl0BFFE3AZxQxi9AiMIjqwiiyCCOgMoSNkLFOhGS+metmm/+/zf3hOSdEvatGmS9/c850lyzsk5X76cc773e9eIpHUWLQQnlipTlJZzJVultyAChCAIgpfx5ptvcrI5ZKydMWOGu5vTpIkOMXK576wCx31G4CA5NGEEHSzvRNkFBRRwehuHcxbG9ELVQwpJ/w8FXDpm2R8RH+m5Jsp3og6HJyAChCAIgpeBardIU48QT+SqwSJQ9SUIIoPJ6O/nVObIAR2a08nI4ZRRHkGX05Io/Px3lNPhZiozRpC+KJMiktazMKHlnigqLaOLud6lhRABQnA5SGZjn6baGx4ySBcsCJ5UcOuFF17g94888ggnuxOqBgWwkFwKEROOOjvqdDpKGDqcDpZ3pEsFxaS7sI+UMYRMUd2JlJlC0n+mgMsnLPuHIbFUjolMpTUXDPQkRIDwoEEZF+yrr75qsx6DWnXFvYS6FSjq27dvlSXaESInCJ7Ec889x3VvkJ4Y9WnMZu9SobuSNpHBFBpo4ORPjtKnXRSlxSTQ+fJoupx2motq5cSPoTJjOBkKMyj89AaLFgKJpfJNpV6VWEoEiLqCstPwcF6xouK1ljLUrgC1DV577TXKzs5u8HN5GqWlpQ3u3W5dXVQQPAG9Xk+ff/451zZA0T0UnhOqJsjoT+2jgqmgpNSpxE/DE4bRYRVPGQXlVJ5xjHTkR6bIrkTlpRSS+jMZc5J4P0z0YMo4n11EpU6EjTZlRICoC2vWoPY00ciRRJMnV7ziM9Y3IKNHj+aBDMVzamL37t1cUhxlulHka+bMmVRQUMDbUPoaVSztNRjvv/++zXlQPbM6ULBn1KhRfHxU8UQCm/z8/Er7vfTSS1xVEwVZHn74YSopuRIqtXr1aurVq5flGDin1kbw8ccfU48ePVho6t69O7333nuWbahDgjb/85//pBEjRvA+ixcv5mNt2rTJpg1r167lIkOFhYX8+emnn+ay5cHBwVzZFCpeTfhAqXO0+ddff+XjY8G6qkwYtfWBZsZZsGABxcbG8j5wZrMWdPCbUGUV7W/ZsiWXQBcEV4PiWh988AG/nzt3Lu3atcvdTWqywJkyKiSATRmO0r11M8qNHUqnVUvKTjtDQZkHqSB2CJf8NhSmUvjpjRYtRHhgRfrsrHzvSCwlAoSzQEjAg96qEidz4ULF+gYUIuAQ9corr9C7775rUwnUmlOnTtGNN95It99+O5fVxiALgeLRRx/l7RhwExMT6eLFi/x5586dnHhGixfHAIeZCup7VAUGeZTkjoyM5DLfq1at4pLg2vE1tm3bRkeOHOHjrlixgiuYYnDWzAGoIXLfffdZ9kEhMs32iBkTkuDgYYft+M0Y6JHv35pnnnmGq6Jin4kTJ9LNN99cyVkMx8JADoEBQJiAUIA+QM0AxMzDYx1MmjSJy5j37NmT24gF6+raByiyhv8Dr2g7zqsJJCi3DsEOM8Jjx47R5s2bafjw4dX+94JQH3Ad33vvvVxoC6YM0WLWUO8iOriiYJYTYZ2jEobTCdWWkosMVHzxDOnKS8gU3olLfIem/UTG3LOWsNEAfz86n13oHemtVQOSlZWlJk+erMLCwlRERIS67777VF5eXo3fGTFiBHrVZnnooYccPmdOTg5/B6/2FBUVqcTERH6tE2azUnFxGOaqXnQ6pdq2rdjPxUydOlVNmDCB3w8ePJj7Eqxdu5Z/r8a0adPUgw8+aPPd77//Xvn5+fHvLi8vV9HR0WrVqlW8rW/fvmrevHmqVatW/Hn37t3KYDCogoKCKtvx4YcfqsjISJWfn29Zt2HDBj5+Wlqapa1RUVE2x1i8eLEKDQ1VZWVlat++fdzmM2fOVHmOTp06qeXLl9use/nll9WQIUP4/enTp/n7b731ls0+6AucQzsvroHAwEC1adOmavv19ddfV/3797d8nj17turTp0+l/XA+HN+ZPmjfvr0yW10LEydOVJMmTeL3X375pQoPD1e5ubnKldT7Ghe8Fjx7u3Tpwtfy7bffzs8CoTJlZeXq13PZ6pvfUtXBc5cdXp7+4Ev13nOT1YE5w1T6l8+olHVzVeHbg1TRwn4qZf08dTA5m/fbf+aS2nI4VWXkmlRTpKYx1J4G1UBA0kVRl2+//ZbWr1/PqjOoemvjgQcesMwAscyfP5+aBN9/X1nzYA3GmXPnKvZrQOAHgRktZt72QP2OWS7CuLQFs2XMPOCFDVU8ZrqY9SPBDGbi06dP57z5R48eZY3Etddea5mx24Nz9unThyv/acBJC8fHTFoD+1gfY8iQIaziR1w6tl1//fVswoDmAFoAbUaE2T1m7dOmTbP5DXPmzOH11gwYMMDm87hx48hgMNDXX3/Nn7/88ks2n8A8ogGNDNoLUxCOC1NNcnKyU/3vaB9Ak2FdpRWmjIyMDH4/ZswYVi3DjDJlyhTWlGhmFkFoCHC9QxuIewT3hrXZUriCn5+O2keFkFHvRwVO5G0YnTCUkqk1nSgKp/yM06QrN5MpvD3pykwUkrqXDHnJlvTWSHCNIluent66wQQIPGShloUte9CgQXTdddex6n3lypWUkpJS43cx8OABry0YBJoEqamu3a+OQACAUICqe/ZgkH7ooYc4F762QKg4ceIEJ5YBME9AgPj+++/pmmuu4f7VhAoIEDBzNCQYVCFUwl/hqquu4uuiW7duLOBofgQQKqx/w2+//UY//vijzXGsB3BgNBrZj0AzY+AVqls4kgGYZiDUQtCAQHvgwAH2Urf2zXAleFBbA+ENQoZmStm/fz8/0CFYwGQDoUSyBgoNSf/+/XkCAh5//HF+NghVh3UiN8TlohIqd3CQbxkRRAFdRlIKRdPFi+mkKy2g0tC2VG4IIWP+BQo/+41l32bBRrqYV0zZhZ6d3rrBBAg8rJs1a2YzS8RM0M/Pj3766acav4vZGOzycPbDINlkZmaxsa7drx4gnHPdunXcz9b069ePtQoo72u/YIC19oOA7V7zdcAr7Pg//PBDtf4PAI6NeOhYOzziO/hfIQRoYJ+ioiLLZwz+mAHBqdMSQ52QwH4RGMjRNjg8wpmwdevWlJSUVKn9HTp0qLVfICBAcIXma/v27fxZY8+ePTzrh9CA6xIOjGfPVtgmNdCOsloiahztg9qAYIN7Aho2+KvAORRtFoSG5I9//CP7C0HreMcdd1TpAC0grDOIB/rLTgzyo4cOpFS/1nSkOJpy05L4OVcSEks6cxGFpkALcY73g3ZDEdJbX3lGeiINJkCkpaVRixYtKj0wo6KieFt1TJ48mTOowfEMwsNnn33GpWmrAzcBYpytlwZj2DCiuDiMflVvx3oMkNivgYH6H4PjO++8Y7MeUQYYKOHQh5k7NA//+te/bBz8evfuzQ6AmKFbCxCIMkB/YmCvDpwTUQNTp05lrQD+p8cee4zV8Bj8NTCrhxkCgsrGjRtp9uzZ3AZNgIRjJBwJYT6AgyWcOjEwAwgViDTBbzt+/DhHPCxdupQWLlxYa79AkwKtFdoJgQPaLw0IDDgftGAwh+D4EFqsiY+PZ00I+i4zM7PKksiO9kFNQAOC8+M8EGI+/fRT1k44I4AIQl3Qoovi4uL4/kKSKU9XpTcEgQZ/io8OoWJzmcNhlxFBBmp21Wi6TGGUnJlH8JMsD4yicv9gMuado/CzWyz7NgsycnprTy6y5bQAAc93LcStugW29LoCHwmo57UBEg9WPOTt7d8aGGgQ46wt2gy3QYA9++23K97bCxHa57feqtivEYAHv6YStxYOYIbAgwGhnDBRQD2OWf2Vpup4G15hWtK+B1MGZub2pgF789I333xDly5dYl8JmAzgz4DwUGuwDgM2BnSYEcaPH89JmgDOA38YmBIQUgk/hDfeeMOSqAmFgGD6gtCA6wAaEzzwHNFA4DchwgMaAmvtA0AboLaFIINkURC0tEx9GoheQRTLyJEjOQQVJoa69kFNQDsHwQmhoBCcYI/GueA3IQgNDcKKcb3BnIgJm32Ek1ABKnW2DHeuTsbIgX0pVd+WjpXGUFbKaSoLiCRzcBRrIZBoypB/wSKgoJR4ugcX2dLBk9KZL2CmmJWVVeM+cAzDRYmQOOtwIWRBw8wNqvPbbrvNofNBTQzVN9TSECzswQzRepYIDQSEiJycnEq+EyaTiWeXGIjQjjqDUM1Zs2wdKiG4QHj43e/qflxBqCcuu8YFnwCaQJj0IBQjJBk+SYItOYWldCA5mwf8kIAKf6ra2L7vEJX//AnFGy7R4B4dKbggmYw5Z+ChSdndJlPW1ffyfqi9gdTW/dpHUligrc+Uu8AYisl4VWOoPY71hhWYlWGpDXjdwyFs37597LgDYN/FjNlarVwbUPECOJpVBbIDNnqGQAgJEyZURFvAYRJtg9mikTQPgiAIrgAaZThPw6kZ2jcIEZiwCXZ1MqKC6GRGPmerRCXO2hjWtyd9cagT+ZnKqW3qBYpv3Yb0hRmkN12ikNQ9lBs/lkpDW3NmSjhSwpTRVASIJuEDAbUsVMEIyfz555/ZyQyq4zvvvNOiTr9w4QJnGcR2ADPFyy+/zEIHHMoQjod69lCDQ8XepICwAP+Bu+6qeBXhQRAEDwM+SXBab9OmDZueYUIWf4jKxEUGs0NldkGJwwmpug4aR2XKnw5d0pGptJzKjeGk/PScVCrMyhcCfhMpl01OhYw2FRo0DwQuTAgIsA/D3g17+4cffmjZjqyHiJvXoizgAY9IgBtuuIG/BxMIpGJEGwiCIAiuBxpl5EeBPwT8IiQ/RGVgvugQE0KlTmSoHNC9A12K6Ek55UF0PC2HiiM6kPILIL+SfAplX4iKdAahAXo2ZUAL4fU+EE2dmuw3Yh8WvB25xoW6gignTNowkUP6ezgIC1coL1eUmJrLaajbNKs60Z49x8+lUdL6BRSsM9GN3aOpReFx1kCgTsal7nfTpav+wPvlmUo530T/9lFsJvEUHwiphSEIgiBwhBKc2xGCjQyxiDISbDNUxseEsCOlo6GXXdu2ouJW/aiU9PRrSgGVhEMLYSS/khwKTfmB9AWpFi1EfrGZMvI8SwshAoQgCILAIdAInUbGWuQmQRh0bUnVfA0M9PHRwZRf7HjJ74HDxlExGSk5t5TOmZtRaUgr0pWVcVRGWPI2S9+HBhi41DeiMjwFESAEQRAEBqpr1MlAmXqEzmsVdIUrxEYEOZUbIjamGfnHD4WYQPuSL5MpohMpfRD5F2dT6IXdpC+oSKwYHqinPJOZMjzIF0IECEEQBMECarJozu6IikMmW+EKKIbVPjqEcwfC+dERBl83hkx+IZRXWEgHS9pUaCHKSykgN8lOC6Gncx6khRABQhAEQbAB5QNmzpzJ75Gi3brKrEAUFWKkdlHBnMPBEVNGRGgIhfcYxe8PJyVTbnQfKjeEkb4wk0JTdlt8ITxNCyEChJeBWg5vISNmPfepL0g9jXTNgiB4JgsWLOCU93l5eexciVfhCm2jgik61OiwKWPQ4BFUbIymcrOJduW2pJKQVkSqnAKyj1NY8nYbLUSyh2ghRIDwIM6dO0f33XcfJ+JCqBUqS86aNavW1OL2INscEsa4iqoEEtS/QD0OQRA8E5Sj/+KLL/h5c+TIEbrnnnsq1d7xZQL0FbkhoH8oKql9sDca9BTXv6LeT9qZo5TecjgnlzIUZVLo+Z02Woh8k2fkhRABwkNAeWsUukJ1TSR7OXnyJCd82bZtG6cNdybkColjkPu+IYETln01VkEQPAtUtl29ejVPWFD8DT4RwhWiQ4zUPiqYLhUWcx6H2ujVqx+VhbUlUmb6NsVIxRHtSZGOgi4lUvjZK74QYR7iCyEChIcwY8YMvom3bNnC1SnbtWvH1SuRuRMpwVEQRwOqRlSkRFVNpKhdtGhRjRoD1CxBBUwIFkgcggqRqGZpDbKBIrEMkhPFxMRYiqGhDDhCvhBDrlVjtTdhQBNRVZXWN998k0PGNFAaG78JufhRFhu2V5TUFgTBfWCComWnREVdRGkIFeC5BlMG0lxfciDNtc7Pj7oPHc/vTSlH6HjMWNZC+BfnUFjytxYtRBhrIUopLaeImjI+L0AgEScqfrpjcTQJKLQLKB89ffp0ntnbzxAQr41UtNrxXn/9dfakPnDgABfLgZkDxXKqA0ljMjIyaNOmTVyHpF+/fpx+XNNqbNiwgQUGpCPHMaH1GDhwIG/DrCQuLo5Li6empvJiD0p2Q3uC1ObW4PPkyZMtQgwEF5Qf/89//sMhZOnp6XTHHXc41EeCIDQc9957L08SAOoTaUUOBeI01x2bh7AzpSMag3YdupCh5VWk0ynaeSKLCpr3IqXzp8BLRyn89DdWWoiKvBCOmEfchdPVOL0N1OFwV/W5/Px81hLUBswWEA5QoKwqsB5l01FqHSQkJLDgoA3eKGSG2f6YMWMqfRcpa1HMDAKEVtUUzlNfffUVqy7hKzF37lwugmYdEw4BBURFRXEO/bCwMBZmqgNCzt///neLChRaCQgrKPsOsA3CA8oLa3zyySdcmh374ncIguA+5s+fT4cPH2Yt6IQJE9iXSsyUFTQPDWBNxOnMfM4TUVvFzquH3UK/fHmM/HNO03/aDaVhgUfJUJRBEafXUV78DVypE1qIlJwi1kJ0aN40K6T6vAbCk3BUYwGVo/1nOEFVBUwVEGSio6NZkNIW1FNAdVSA2QY0EvUBAggqrP74448W7QM0HSiaprVjx44dNm3QtmntEATBfej1elq5ciUL88nJyfS73/2Oiosdi0DwdnQ6HbWPrjBlZOXXbsqIioml8I4D+P3+Y0mU23IwayECcs9Ss+OrLMeMCDSyLwTSXDdFfF4DAWdCDKDuOrcjdO7cmS8mCAGa74E1WB8ZGck+DM6C3x4bG0vfffddpW2aD4O92aQuQDsBE8Xy5ctp8ODB/PrII4/YtOOWW26h1157rdJ30T5BENwPnjNff/01DRo0iDWb8J369NNPLb5Pvm7K6NQ8lH49f5kTTAUbax5eeyfcTHuTf6XAkizaZepJ40LjKCDvLIWf2USXO02g0oh4Cg3U04XLhZSSXURdW4VRU8PnBQhc+I6YEdwJtAMwP7z33ntsh7Qe0NPS0ng2D7ukdhNrs3wNfK7O/AEtAI6B2QWcK6uid+/e7PcAO2hVwLnTkZz5MGM89dRT7OCJqBJoJazbAecstAFtEQShadKtWzdatWoVOzzDBIkJzuzZs93drCZBTKiR4qOC6eTFAg7z9PerXrAyBodRbK+RdG7/Jjp9Jokyewyg2IJUDuuMOfQhpV5XYc6NDDayEIH02RHBBmpKiAnDQ4CPANSFY8eOpV27dnFOCDgaQrBApAX8FDQwM4C9Er4DiMDAzQ5HyqoYPXo0mzhuvfVWtm3CzLBnzx6O6oAzI8DDAaGjeIW249ChQzaaAgz6aBOiQWqKmoDKExEi0DyMHDmS48uto0zgtAnhArZVmC3gOAqhRQr6CELTAs+dxYsXWyIzNF8mX0eHqIzoYBYksvJrN+906T+SgkMjyVheRDszQqg4sjPpyoopNO0nCk79ifeBJqO0TNG57EKHzdiNhQgQHkKXLl14QO/YsSNHJiD8EQ6OGIj37t3Lzowaf/rTn3hfOCXOmTOHFi5cyIJHdRf8xo0bafjw4TxYw74JzQBCMxFKqYVqQgiB6rJv375sioDjpQYiMCB4oE01mVHgaAkzBfwdoI2wBsIEBB8ICzfccAP16tWL/vjHP7IZxc9PLlNBaGo88MADrFEE06ZNo++//97dTWoSBOgRlRFKeGwV1OK7oPM3UqdBN/H79Iw0Oh/Ug8oMIRzWGf3bEhYmQHRIAKXlmCjLgVDRxkSnmppIU09yc3O5olxOTg7nNLDGZDKxc2CHDh04n4GvAp8CREPAfil4F3KNC40JMlNiQgPzIyYx0F7CxCEQJV3MpxPpedQyPKhGUwYpRb9+9SZlpidTYEgE3dniLIVmHCBzYDRl9rqfsrtXhLqjPkZUqJF6xzWr+XgNOIbaI1M7HwtZRT4I5Ffo2bOnu5sjCIKHA+0gnCiRFwYmyBtvvLHKXDC+SNuoYPZbyMirJSW1Tkddh44nvZ8fFefn0ElzKzIHRJJ/SS5FnN5IxpzTlgJeECIu5jWdyBcRIHwIlOiFeQKmAftQT0EQhLpGkyFTLZwpYcqEcyVmr76Owd+P8zcgOiOnqLTGfYNadqbWHXuS0hH9nFpKheEdK46Rn0KRx78gndnEZcRhHjmTVUDF5qbhFyYChA8BwQGFt+ATIQiC4CqQUApOz3iFj5PkiKggIshAnVqEUkFxKZWYay5E1nnIeAoNNFKZuZQO5oWTOaAZ+ZUWUFDmIQpL3sqmjsgQI10uLOWwzqaACBCCIAhCvYGDNxyykQRu+/btNHXqVKneSUSx4YFszriYX1xjFIUupDnF90qgMvKj41nFdDkgjpSfPxkKUigk7WcKyD7GGS4jAg2UfKmwVq1GYyAChCAIguAS+vfvz/VxkMsF9XlmzpzZ5EIPGxs/Px11iAmlZkGGWgtuteo9hlpFRlAxGejAZSOVG0KJysso4PJJCk/eRn4luZxcymQup7NZBVRe7t6+FQFCEARBcGmOiH/84x/8Hnlonn/+efJ1goz+1LFFCJmV4iyV1aEMwdT52hsQ30kXC8ooxa8VQiXJ35RN+oI0Cj/zDZsyUHsDYZ0ZbnaoFAFCEARBcCmosgvhAaBA3quvvkq+TvPQAIqPDqbswhKu3FkdAfGDqEPbNpRLIXQ4S5HZP4hIlVNAThIZ885RcMZ+dtA0+vuxQ6UjFUAbChEgBEEQBJczffp0S8bav/zlL5yK35fRccGtEA7tvJhfQ2inn546DLyFAo1Gyjf70cnSKPIvM5GurIT0piwKTdlN+sKL/+9QWULnswsb82fYNtVtZxYEQRC8GmSqRFp8LV09ckb4MgZ/P47KQDhmTU6Q5dFdqVu3HpRJEXQ2t5xMFEB+pfnkX5TFPhHhZzaSnzJTsyAjnc8uolyTexwqRYAQXA5y4yPltaeDmHbMGlDOHKBiKT5fvny5zsd0xTEEwZNA1ls4UwKky/f1uhnhgQbq3CKUfSGqzeeg01HzvjdRbEQIFSkjHSkMJ39zAeeDQGinviiLwi58TyEBeg4PLa0lRLShEAHCQ7jnnnt44MGC6pdI2oIaFGZz/evEu3pQ+/Of/8zVO72NoUOHcpY9pHl1BNQQQe6N+hxDEDwdPFvefPNNrt2DsE6Ed/q6ENGKQzuDKDO/mMqriVIxh7SiLn2HUqYuinJMZZRjNpChKIOoHNoGRUEZv5AxJ4nciQgQHoSWJvbEiRNcMAsz/ddff52aCgjXgkCDOHCUIK8PpaWuU8m56lgQ3Fq1amUpm+6uYwiCJ6a8RvVOESJsQzuRnhpCRHUYOo2krnHNKZvC6HhhMOlK8ikg7xyZAyuKFiIqw780n9yFCBAeREBAAA8+7du355LYKMWNCpkgOzub/vCHP1BkZCSnlkU6WQgaGqiuiUqY2B4SEsK1MJD0BWp6VPQE2IaBDdoOgBt93rx5XJgpKCiI+vTpQ6tXr66kudi0aRPHf6N9u3fvrmTCwHGgLYmLi+N9sA2lyO1NBYgbHzFiBBeB+vzzz6vsA+yHBxF+H9qE5DXWbarpWB9//DH16NGD13Xv3r2SUxcqjKKCKbYPGDCADhw4UKumBhVEoWlAn6P/UPUU/wX6cOfOnfT2229bNEdom/UxULQGvwH9Z83atWu5cilqlwCUbkfBIlQmRcGiCRMm8LEEwZMQIcIWpLju3CKM/HU6yjdVrUkuN4ZSu76jqSigOZWUEV006clQmE76wlQyB8WQn7mIWqRUZKl0Bz4vQGDWDFuUO5b6JljB4FNSUpGYBAMWSnhDoEB5bxx73Lhxltk3HJiQWnbXrl106NAh9o6GpqBt27ZcSQ8cO3aMNRwY9ACEBzg9vf/++3T48GF6/PHH6X/+5394YLTmmWee4TCtI0eOUO/evSu1E8d74403aMGCBXTw4EEeZMePH28j4GjHmTVrFh+nuvLj4IUXXqDbb7/dUhYc9T3wnZqOBSHir3/9K82dO5fXIbQMx9Hi1fPz8+nmm2+mq666ivbt28dCEEwxNQHfiOuvv56/gz6H8AQhDSXJ8ZtRbwQlj9GnWNDX1qDSHc65fPlym/Vo66233spCCf4/tB8CBcolQ2DB/wZtlPbfC4KnChGY9Hz00Ufkq0SFGKlD8xDKMZVSaVnVfgwlsQPo6s7xlKEiKdlkJLMpj4KyEqk4vAMpPz0F558j//RfyR3oyccpKi2jq/76jVvOnfi3sRRsdP4vgHAAHwPknn/sscd4IIbggMEFNnZtEMKA9dVXX9HEiRMpOTmZB91evXrxdszcNTCrBchjj1kugLCBQXbr1q2Wwlv4DgbJDz74gGf3GtAuIHlMdUBwePrpp3mgBxBeduzYQW+99ZYlVhzAXwA59GsDv0crRQ4HLVQYfffdd200CvbHmj17Ngsx2jpoVRITE/m3YCaEQRwPtCVLlrAGAhqa8+fPs6anOubPn8+aCuvzWlc5hbkCQgC0RtUBAWjKlCmsbcC+0Eps2LCBtRAAmhS0C9oTzeyxdOlS/p+gzbjhhhtq7S9BaIpChL+/v0WYgEbuySefJF8kLjKYIzJSc4ooNjyosnnTT08RV4+lwJQUKrucSWmFOmoTkMHhnLntb6D8zPPULKa7W9ru8wKEJ7F+/XqefWJWikEFyVowU4YwgdSxgwYNsuwLH4Ru3bpZZubwgsZguGXLFjZ9QJioSlugcfLkSR7U7AUDzHqh5rcGg2h1YEBMSUmhhIQEm/X4DA2Co8exxr6SKD5rkRJVHaugoIBOnTpF06ZNY42ABvw1NGdGTXsC4aG689iDc0KYqQ/QEhkMBhYAIWBBGwTNBP4jgD7CfwENhDUmk4l/kyB4qhCByQPuP2gvEe4JIWLOnDk+5x/k76ejTs1D2YyBVNfRoQGV9ilu1oW69+hFB39MpQCzmaIKcikwK5EFiIy4G6it/spzqzHxeQEiyODPmgB3ndsZ4KsAiR0z29atW7PQ4CiYsUMVjtkthAiYJzAjhwajKqDSB9i/TZs2Ntvgx2ANfCpcgauOY38s7bdAVWotZAHMgupjQqov+C9///vfswYEAgReJ02aZPlv0Xb4l1TlE9K8eYUjlSB4IhAU8ByCEIFEU9B4QoiANhEChi8REqDn0M6D53PYvF1JM63Tkeo8mmLPn6CScxmUbtJRu4IMiji9gXTdurir2eIDgYsYf5Y7FmclbQyKCN9s166djfAAx0DMpn/66SfLOpTthk8D7PMaMGk8/PDDXOwGURya7RGDGIDtXgPfg6AA0wfOab3Y2/JrArNpCDswr1iDz9Ztc4Yff/yx0mf0QXW0bNmS25CUlFTpt8CUAfB9+GdgZl/deeyBxqKmcFX0q3Wf1mTGgFMp/ExQxRCfNfr168cmKpiX7NsuoaCCNwB/JUyM8DyEORACdFFR0yhX3Zg0Dwug+Bikui6tMtW1ObgFtbkqgXID21BRuYHycnMoMPsYhWe5x/8B+LwA4Q106dKFPfOhnoePAtTecHaE5gDrNZ8A+EycPn2a9u/fzz4I2qCLqA7cvDCRXLx4kWe9UJnDiRCOk3A0hLoc38PsQHM8dBTYNuH3AHs+hBo8MKD+h5NjXVi1ahV98skndPz4cfZtQPTEo48+WuN3XnrpJZ7tvPPOO/w9OJLCl2DhwoW8HeYg9AH6EL4RiFCB70ZNYNb073//m1P2Qvg4evQoPwgzMzN5e3x8PAt1iJjAuupKGw8fPpz9JCA4QKCx1pJgXUxMDP+PcKLE/wffB5ik4KMhCN4AJjbQvsGch6gqmPC0+8hX0Ol01C4qhFqEBVQb2lkYl0Dxna+ifF0w5ZTqKC8jmcp+XkJ7d+90aLLiakSA8BIwGELVDa9+2O7haIlBEDckwMWFSAwIDfDg79q1q8X5D4IGBlgM7Jita4MxHBQRqYCBV/seTBrarN1RMNg98cQTrPWAEydm27D5Q/CpC2jrypUrWQOAKJEVK1bUqs2ACQeOiOgntAFOoMuWLbP8FviWrFu3jgUL+Hgg/a6Wx7860IcwB0FgGzhwIPf7v/71L4t2CAIYTCRoG8wN0OZU9+C46667LFEl1sCxEpEz0DrBART/A3w5oCmBdkcQvAWY8HA/wUF4z549fD/B/8eXMOr92B/CoNdVmepa6YMosMtIKjI0JxMZyVRUQEWnfqK5MybyhAXa5cZEp7ysWDuc9qDazcnJqfSAxUMXMzgMGtbOcoLngMEWEQoIcxQqI9e44OlAAwjnYuSugfYNQrkWXeYrnLtUSIkpOdQ8LJDrZ1izfftWOvXZE3TbtbHU2j+HTuYZ6aWvz9B/zuTxdmhwHIlmq8sYao9oIARBEIQmAzR28D+CRhVmDCRqg/bQl2jTLIjaRAZTep7JJl9QWXkZLXhjIW0+40cnU3O4yFZhSBs6WR5r2Q/m6sYyZ4gAIQiCIDQp4BMEXx+EmyNsHb5JMMG6MsV9U0913bF5CEUGGTm0U+OXAwcoIz2dzub50/ZjeZRR5EfhVEA92lRoCiBEIHMt/KUapZ2NchZBcBG4QcR8IQjeD/ySvvjiC/bFAvDZgnNlRkYG+QLBRj11bBFC5nJFRchjTWTjWLr1vJF+O5NJJ86kUP65YzbfRebbxkAECEEQBKFJgnwQzz//PDtdIzIMDsUIbW6sGba7aR4aQO2igulSYUXVTviEaOSW+NH6U0R70wyUnGv7vdjY2EZpnwgQgiAIQpMGNWYQro3suhcuXGC/CGgm3BG62NhO4+1jgjk7JUI7+15zDbVo2ZITS4HdqQZamxxOuSVX9keenmHDhjVK+0SAEARBEJo8qKCLgoEowIWcKiiOh1owjaWudxcBen/qEBNCpCMqNqsrRf5YiLiSjFBLTIgaQ/XJsOsMIkAIgiAIHuMXgUR2WJCZF5lbkQ9GqyjsrcSEBlD7qIoslSNGjORCfshOa01cXFy9QzidRfJACIIXIde44Csgqy3SXmtF+fD+73//u42fgDdRYi6nQxcu0+XCUmoRFsghnYjKOJmaRQM7Nqebrh/uEs2D5IEQBEEQvBr4QyBV/LPPPssDJ1Ll9+zZkxPNeWuWyo4xoeSv01FBsZn8/fypf/8BNHzYcEoYOrTRzBbWiADhJSBmGjYwVLMTmjZwAEOyF0EQ6gcK/s2dO5cTTyEBFUI8ocJHqDdq0HgbkSFGahsVTJeLqi641diIAOEBQDCoaXnxxRfd3URBEAS3MWDAAC72hwJ3mIkj/TXqxiBSw7rCrjcQFxVE0aG2CabchQgQHgC8jLUFHrawS1mvs3jlCoIg+LA24pVXXmGfCGj5IDggUkMza3iLu1+A3p/io0M4L4Sp1L1hrCJAeEhaV22Bcwu0Dtbr4JmssW/fPpbGUcURBWjgaGQNyk136tSJjEYj2xA/++wzm+049gcffMBVPXEMSPF79+7lqni4KeH5jOOivLcGNCB9+/bl7yEGGd+744472AnH2sSCipX4PqrtJSQkcLEcZ9qFfPi33XYbHx+VPJFcpiaQuQ77wZkQVUZ///vfW7ahIuh1113HbYmOjubfa/2boP7EOZEJDzHVQUFBdO2113IpcJTwRh+j3//7v/+bS6Br3HPPPaw+RcVQVOCEsIdSxSUl1c8WiouLWQhEVVT0D8p5o7800E+Ig4+MjOTteCCi0qogCJXB/YHoDFTpbd26NSUlJbFZA/fV1q1byRuICTVSXGQQZeUXk1vlIuVl5OTkoDv51Z6ioiKVmJjIrxbKy5UqLXbPgnM7ydKlS1VERESl9Tt27ODfPWjQIPXdd9+pw4cPq2HDhqmhQ4da9lmzZo0yGAxq0aJF6tixY+qNN95Q/v7+avv27ZZ9cIw2bdqof/7zn7zPrbfequLj49WoUaPU5s2buf8GDx6sbrzxRst3Zs+erUJCQnifAwcOqJ07d6rOnTuryZMn8/bS0lJu85///Gd18uRJPsayZcvU2bNnnWpXXFycWr58uTpx4oSaOXOmCg0NVVlZWVX207///W8+BvY/c+aM2r9/v3r77bct21evXq2+/PJLPhbafMstt6hevXqpsrIy3n769Gk+Z/fu3W1+d//+/dV//dd/qd27d/Mx8Tsffvhhy3GnTp3K7Zo0aZL67bff1Pr161Xz5s3Vs88+a9lnxIgRatasWZbP999/P/9Pu3bt4v55/fXXVUBAgDp+/Dhvv+mmm9SYMWPUwYMH1alTp9S6deu4j6uiymtcEHyU3Nxc9dxzz6ng4GC+n7GMHDmS719Pp7DYrPacvKg2H0pVmXmmRhlD7REBAgP59lfcs+DcLhYgtm7dalm3YcMGXqf9XgxSDzzwgM33Jk6cqMaNG2f5jP2ff/55y+e9e/fyuiVLlljWrVixQgUGBtoIEBisz58/b1m3adMm5efnp1JTU3mQxzEg2FRFXdqVn5/P63CeqoBwEB4ezg8QR7h48SIf79ChQzYCxMcff2zzu7Fu27ZtlnXz5s1T3bp1sxEgoqKiVEFBgWXd4sWLWajQhBNrAQJCFPruwoULNu25/vrr1V/+8hd+D8HmxRdfdOh3iAAhCJVJS0vjSYfRaLQIEkOGDOGJhNlsVp7KmfTL6vWPVrhNgBAThpeBpCr2+dC14jNHjhxh04E1+Iz11R0Dqn/Qq1cvm3WwLyJeWKNdu3asgtcYMmQIZ4uDCSUqKopV+2PHjmVV/Ntvv22TPa4u7YIqH+aB6grrjBkzhtq3b08dO3akKVOm0Oeff06FhYWW7SdOnKC77rqLt+M48fHxvD45OdnpvrBvQ58+fdjMYt0X+fn5XCXPnkOHDnE63q5du7JJRFt27txpManMnDmT5syZw30ye/ZsOnjwYJW/WRCEqsF9iucO7vv777+fTaUwzcKsiXsP2y5dukSewvHjx9ns2f+qTvTkA3fRqeOJbmmHnnwdfwPRsD+579wuxmAwVEptioG8vseo73GXLl3KAyF8DxCvjQI53377LQ0ePLhO7dLaUV0bUHgHXtnwJdiyZQs7U8FXA/4L8HuAIAMB46OPPmI7KY5z9dVXV/JVcKQvnO1fayBYwGscviv2cdyabwseeBC+NmzYwL9l3rx59MYbb9Bjjz1W5/MKgi+CiQ7ueURnIOkUfK/gI4Gw6qeeeoqfC9pkx/55427y8/Np3bp17AsGHw/rDJRZ6WluaVODaSAQmwtnO8zE8MB2BGiq8aDHzBlOayjdComxQcGgoDe6Z/n/AamxgEPkDz/8YLMOnxE/XV8wc09JSbF8Rlw2KunBIVLjmmuu4TCrPXv28GC9fPnyBm2XXq/nawhpXzFrh2MkbrysrCzWjECIuf766/n82dnZ5CrgBV5UVGTTFxAG4GBqD/oEGghoMTp37myzwEFWA9+FM+aaNWvoT3/6Ez8EBUGoG7i3oNXDc2vRokXsBI7JA1JiQ4jAoPzggw/ygG2tuWxscnJy6H//93/ZMRtO2ZMnT+ZnGCYuN910EzuSI/MsnLm9SgOBP2PixImsvl2yZIlD38GD/p133uE850jF+8ILL7AkmJiYKGl5XcCTTz7J0REYtDCw4ubAgOQKz2T8P1OnTqUFCxawaQPaBpwLNyou8A8//JDGjx/Ps30M3hAMURSnodq1fv16nlkMHz6coxcQtQBNAQQafEbkBdoEYRUPkWeeeYZcee1PmzaNBRQILTA7PProoyxQ2QP16d133819Aa0C+gBRHdu2bWPzCR4SmB3hAYF9Iejs2LGDhR5BEOoHTKHTp0/n5ZdffuGxB+ZOCPQQ0rHg2TZq1CiebEBjinLiDTUe5efn8wQLmlMs0JiazWbLdkwsYHrF8wUaVHfTYAIEwtjAsmXLHNY+IMcBHroTJkzgdZ9++inbrr766iu68847G6qpPgOkWNj6MMjPmjWLhTSYFhCeWV9wYSNUaty4cWxLRFgkwigBtFBHjx7lmxOzfwzaM2bMoIceeqjB2gWtF4QQmC3gr4FwToR1IcQLrFy5koUcaEIgVEBwdUU/ADxocD4ILwjRxA1fU7Iv/FbMhqBZQKli5PLHgwp9CKChQH+dP3+e/TVuvPFGevPNN13SVkEQKoAWAgsmspjlYxKCyQzCqDEB0UKnYdqAoN+vXz++z7Hg+edo/RlMZDIzMyktLY0nOb/99hsvhw8f5uektcAAoIm9/fbb2V8D/leaKbUp0ODFtCBAYAZVW4pldCTyABw4cID/RI0RI0bwZwwwVYEHNBYNzH6h7pViWo0HBkcIeZDgfR3YT3Gtoz/cgVzjguA6MDxiYIfwALMqzJHVOW4DmN4xecGijT8QCLQFGsT09HSeFNTkpzFy5Eie0GD8w73cmDhTTKvJOFFCGrP2dNfAZ21bVcChTNN2CIIgCIKrwGwfWkosmkABsyQiOBITE9kUiyR7WDDwwvcJi3WUWXXApwGTXRwbmlG8QsNQla9UU8UpAQJ24tdee63GfRB61717d2os4JT3xBNPVNJACIIgCIKrBQpoBOy1AkopHnugYYAGEgtm8NgfztxYEGUFzQRMuBAemlqUR4MLELDRQkVbE4irrwuaxznUO1r+Au2ztUmjqvznWAT3mjCkoBc55fMjCIL3oNPpWO2PxZdwSoCA1ISlIYBEByEC3ueawACJDvXeH3nkkQY5pyAIgiAITSwPBELj4FSHVziM4D0WhKlowNSBKmmaBAdnS3ijI7YVGfoQ2oawP3jpC4IgCILQdGgwJ0okhELYngbCXgBi2LVwOeQDsK7YiExgBQUFnMADNiRUS0TmQld7k9cnc6AgNGW8pWSxIAhNnwYP42xsagpBgeAAr1k4s8AUg3zoTSmmVhDqA25lJKFC5jzEptunxhYEQfDKMM7GAJkA4WuBEBvrtMuC4C1AIEYaXhEeBEFoaHxKgADQOiBRB5J61JTMQxA8EYSGifAgCEJj4HMChDZLw4PWG+JwBUEQBMGrojAEQRAEQfBeRIAQBEEQBMFpRIAQBEEQBMFpvM4HQotKRSiKIAiCIAiOo42djmR48DoBIi8vj1+loJYgCIIg1H0sra22h9clkkKyKOR4CAsLc1mSKK3C57lz52pNrCE4hvSp65E+dS3Sn65H+rTp9ydEAggPKCOB3Ek+pYHAD0YinYYAf5Bc9K5F+tT1SJ+6FulP1yN92rT709GqouJEKQiCIAiC04gAIQiCIAiC04gA4QABAQE0e/ZsfhVcg/Sp65E+dS3Sn65H+tS7+tPrnCgFQRAEQWh4RAMhCIIgCILTiAAhCIIgCILTiAAhCIIgCILTiAAhCIIgCILTiADx/yxatIji4+MpMDCQBg0aRD///HON+69atYq6d+/O+/fq1Ys2btzYaG31xj796KOPaNiwYRQZGcnL6NGja/0PfBFnr1ONlStXcmbWW2+9tcHb6M39efnyZZoxYwbFxsay53vXrl3l3q9nn7711lvUrVs3CgoK4qyKjz/+OJlMpkZrb1Nm165ddMstt3BWSNy/X331Va3f+e6776hfv358fXbu3JmWLVvWcA1EFIavs3LlSmU0GtUnn3yiDh8+rB544AHVrFkzlZ6eXuX+P/zwg/L391fz589XiYmJ6vnnn1cGg0EdOnSo0dvuLX06efJktWjRInXgwAF15MgRdc8996iIiAh1/vz5Rm+7t/SpxunTp1WbNm3UsGHD1IQJExqtvd7Wn8XFxWrAgAFq3Lhxavfu3dyv3333nfrll18ave3e0qeff/65CggI4Ff05zfffKNiY2PV448/3uhtb4ps3LhRPffcc2rNmjWIllRr166tcf+kpCQVHBysnnjiCR6b3n33XR6rNm/e3CDtEwFCKTVw4EA1Y8YMy+eysjLVunVrNW/evCr3v+OOO9RNN91ks27QoEHqoYceavC2emuf2mM2m1VYWJj6xz/+0YCt9P4+RT8OHTpUffzxx2rq1KkiQNSjPxcvXqw6duyoSkpKGrGV3t2n2HfUqFE26zD4JSQkNHhbPQ1yQIB46qmnVM+ePW3WTZo0SY0dO7ZB2uTzJoySkhLat28fq8yt62ng8969e6v8DtZb7w/Gjh1b7f6+Rl361J7CwkIqLS2lqKioBmyp9/fp3/72N2rRogVNmzatkVrqvf359ddf05AhQ9iE0bJlS7r66qvplVdeobKyskZsuXf16dChQ/k7mpkjKSmJTULjxo1rtHZ7E3sbeWzyumJazpKZmckPADwQrMHno0ePVvmdtLS0KvfHeqFufWrP008/zXY/+5vBV6lLn+7evZuWLFlCv/zySyO10rv7E4Pb9u3b6e677+ZB7uTJkzR9+nQWdJEN0NepS59OnjyZv3fddddxFUiz2UwPP/wwPfvss43Uau8irZqxCVU7i4qK2M/Elfi8BkJoerz66qvs9Ld27Vp2xBKcB+V4p0yZws6pMTEx7m6OV1BeXs7anA8//JD69+9PkyZNoueee47ef/99dzfNY4HDH7Q47733Hu3fv5/WrFlDGzZsoJdfftndTRMcwOc1EHi4+vv7U3p6us16fG7VqlWV38F6Z/b3NerSpxoLFixgAWLr1q3Uu3fvBm6p9/bpqVOn6MyZM+zBbT0AAr1eT8eOHaNOnTqRr1KXaxSRFwaDgb+n0aNHD571QX1vNBrJl6lLn77wwgss6N5///38GRFtBQUF9OCDD7JwBhOI4DjVjU0o9e1q7QPw+X8HNz1mE9u2bbN50OIz7J1VgfXW+4Nvv/222v19jbr0KZg/fz7PPDZv3kwDBgxopNZ6Z58ixPjQoUNsvtCW8ePH08iRI/k9wuV8mbpcowkJCWy20AQxcPz4cRYsfF14qGufwtfJXkjQBDQp0+Q8jT42NYhrpgeGHiGUaNmyZRz68uCDD3LoUVpaGm+fMmWKeuaZZ2zCOPV6vVqwYAGHHM6ePVvCOOvZp6+++iqHf61evVqlpqZalry8PDf+Cs/uU3skCqN+/ZmcnMyRQY8++qg6duyYWr9+vWrRooWaM2eOG3+FZ/cpnp3o0xUrVnAI4pYtW1SnTp040k1Q/PxDaDsWDNcLFy7k92fPnuXt6Ev0qX0Y55NPPsljE0LjJYyzEUC8bLt27XgQQyjSjz/+aNk2YsQIfvha88UXX6iuXbvy/gib2bBhgxta7T192r59e75B7Bc8YIS6X6fWiABR//7cs2cPh2xjkERI59y5czlUVqhbn5aWlqoXX3yRhYbAwEDVtm1bNX36dJWdne2m1jctduzYUeVzUetDvKJP7b/Tt29f7n9co0uXLm2w9kk5b0EQBEEQnMbnfSAEQRAEQXAeESAEQRAEQXAaESAEQRAEQXAaESAEQRAEQXAaESAEQRAEQXAaESAEQRAEQXAaESAEQRAEQXAaESAEQRAEQXAaESAEQRAEQXAaESAEQRAEQXAaESAEQRAEQXAaESAEQRAEQSBn+T/wCOr3CWjCDAAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Iteration 6) \t Best Value: 0.9538915741567119\n", - "Early stopping at epoch 6525 with loss 0.7314200558434392\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Iteration 7) \t Best Value: 0.9844725089729858\n", - "Early stopping at epoch 6479 with loss 0.6798152420784924\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhAAAAF2CAYAAAA/RaFTAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAy11JREFUeJzsnQWUE1cfxW/cs664uxVKqVB3F6h7S93dXak7la/uVGhLhXqhpYa7s8i6xj3znfuWbLNL1mCd9zsnZzfJZCyTeff9VaUoigKJRCKRSCSSZqBuzsISiUQikUgkRAoIiUQikUgkzUYKCIlEIpFIJM1GCgiJRCKRSCTNRgoIiUQikUgkzUYKCIlEIpFIJM1GCgiJRCKRSCTNRgoIiUQikUgkzUYKCIlEIpFIJM1GCgjJTvPmm29CpVIhLy+v5rX9999fPFqKe+65R2xDImnLaym2bFlZWZvsU2tvR9KxUalU4lroLEgBAeDYY4+F2WyGy+Wqd5kzzjgDer0e5eXlNV90/MNisWDo0KF44IEH4PV6a3323HPPhdVqbdIgPG/evGbvf+/evWvtS2ZmJiZOnIjPP/8cnQmeN/54fv31V+wq8FjrXkv1PVqb+G1ptVqkpqZi7NixuPrqq7FixYou/b0+9NBDmDFjRpf8Xnc1li5dikmTJqFXr14wGo3o1q0bDjnkEDz33HPtvWtdDm1770BHgOLgq6++EgPu2WefnfAG+MUXX+Dwww9HWlpazeu8KGPLu91uzJkzB3feeScWL16M6dOnt+kxjB49Gtdff734v6CgAC+//DJOPPFEvPTSS7jkkkvQ1nz//ffN/gzP87333iv+r2u9uOOOO3DLLbegqzFkyBC88847tV679dZbheC8/fbb23x/Ytc0W+Q4HA5xLb/11lt48cUX8eijj+K6665r0e+1PUh0LVFAcNA5/vjju+T3uqswd+5cHHDAAejZsyemTJmC7OxsbNmyBX/99ReeeeYZXHnlle29i10KKSC2WSBsNhvef//9hAKC4sHj8QihEc/AgQNx5pln1jznQB0MBvHZZ5/B7/cL9dtWUGXH7wuPo3///njqqafqFRDhcBjRaFRYVlqall4nZ8R8dDWysrJqfW/kkUceQXp6+navtwV1r+nY/hxzzDFCoA4ePBhHHnkkOjNtcS11tO91V+HBBx9EUlIS/v33XyQnJ9d6r6SkpN32q6siXRgATCaTmK3/9NNPCS8yCgsKDAqNxqDijZmA2xPuB2dBGzduFM8Zn8D9evzxx/H000+jX79+MBgMNabpVatWiRkYzdYUPuPGjcOXX3653XqXL1+OAw88UJyz7t27C5cNRUhdEsVAUFTRlM1BitvIyckR5339+vVi/zIyMsRynK3GzLsxf2Bdv/Xw4cPFTKMu3BeKKR5L/Gs85mHDhont8uZ+8cUXo7Kysknn8ueffxYuIbqpeFM67rjjsHLlylrLxPZv3bp1wmXF5XgjO++887Zzae0IGzZswOTJk8X3Q3fbhAkT8PXXX9e8TwsY94/uhrps3boVGo0GDz/88A5tm1a3Dz/8UFzTvEHHoFi+6667hJuDx8rt8zz98ssvNcs09r0uWbJEnK++ffuK74bX7fnnn1/jKqwPWkg4GMdbRPg987zzWKuqqmpep+WE+85zlOha4v+cINDSEts/7lM8XF9rfK91acp2KPzvv//+mt8wXZi33XYbAoFAreX4+tFHHy3cKfw98zc7YsSIGlcSJzp8zvPO73DhwoUJXa+89g477DDx/ebm5uK+++4T5z8eXh9cB++TdrtdrJcz/uZcw/Gun48//lhca7zHcP8OOugg8dtqDN5L+DuvKx4IXbvxvPHGG+Jextd5HumCpsW2Lm15HhORn58vfhO8b3E/eXyvv/76dsvRRcP3eG5TUlLEvnLsalXYzluiKN9//z2/SeW5556r9Xp5ebmi0+mUs88+u9brXPaCCy5QSktLxSMvL0957733FJvNppx11lm1lj3nnHMUi8XS4PbfeOMNsc5///232fveq1cv5aijjqr1WjAYVLKyspTs7GzxfOPGjWL9Q4cOVfr27as88sgjylNPPaVs2rRJWbZsmZKUlCTee/TRR5Xnn39e2XfffRWVSqV89tlnNessLCxUMjIylJSUFOWee+5RHnvsMWXAgAHKyJEjxbq5jRj77befeMQIh8PKQQcdJJY79dRTxTYefvhh5cADD1RmzJihuN1u5aWXXhLvn3DCCco777wjHosXLxafv/vuu8V7Me677z5FrVaLfYrnt99+E8tNnz695rULL7xQ0Wq1ypQpU5Rp06YpN998s/g+dt99d3GeGuKHH34Qnx04cKAydepU5d5771XS09PFOYg/3tj+jRkzRjnxxBOVF198UWyXr910003N+j6HDRtW69wVFRWJ75LX1u233648+eSTyqhRo8Txx38/Z5xxhliO5zoe7je/S37XDcF9vfzyy+t9n98ft+lwOMRzXvc5OTnKddddJ747bmfQoEHi97Jw4UKxTGPf6+OPP65MnDhRfJ+vvPKKcvXVVysmk0kZP368Eo1GG9zfY489Vhk7dmzNc26T2+E+zpw5s+Z1/jbGjRtX87zutcT9MRgMYj9i+zd37txW/17jac52eD/h65MmTVJeeOEFcW/i8+OPP367+wK/D35H/L3y996tWzfFarUq7777rtKzZ09xH+CDv//+/fsrkUik1naMRqP4jfOext/s0UcfLbZ15513bnfv5PXB/eHjiiuuUCZPntzsa/iXX36pOQ/8brnP3Hez2SyuicY49NBDxTaWLl3a6LL8/Z977rliG7zv87PcNo+zPc4j4Wu8FuLPW/fu3ZUePXqI3wh/S7zuuRz3IwZ/O7Fr4uWXX1aeeeYZMT5dddVVSmsiBcQ2eNPlBbLnnnvWep0DDr+YWbNm1XqdryV68Efs9/vbXEDw4o+JGd6cOUhzfVdeeWUtAWG325WSkpJan+cPf8SIEbX2mzfvvfbaS1z0Ma655hqxjr///rvmNa6LP5rGBMTrr78uluGNoy6xgYL7XvcHVN9Nf/Xq1QkF32WXXSZ+2F6vVzyfM2eOWI7iLp7vvvsu4et1GT16tJKZmSmEZAyeX9744kVlbP/OP//8Wp/noJmWlqbszEATO+88lhgul0vp06eP0rt375qbFa9RLvftt9/WWh8FXn0DV3MEBAd3LhMb/PmbCQQCtZaprKwUA0X8eWjoe419T/F88MEHYvnZs2c3uL8UsBqNRnE6neL5s88+K34LHGgoEgnPTXJysnLttdfWey0R/j75O61La36vO7KdRYsWieUoLuK54YYbxOs///xzzWs8F3wtJobirxGKtHhByUGHr3MArytUYveQ2G+Vgkyv14vvNXZd8L5SV7jG09RrOCYghgwZUuva4oDI1xsTBhQzvCb44L2c4ovHnGiikOjaO+yww8QEK562Oo+k7u+EIoDjUllZmRIP7++878aO4bjjjhPXV1sjXRjboNnz1FNPxZ9//lkrHZEmIJqOaEKrC03ZP/zwg3gwToJBUt999x1OP/30JpmmWjpokaZiPkaNGiWCOM866yxhvo3npJNOqjEpk4qKCmGiP/nkk0UWCtPI+KAJmea2tWvXChMa+eabb4TZcfz48TWf57rqxoYk4tNPPxUm50RBTDsSiU43CANHP/roo5rXIpEIPvnkE+Gvp5mR8DzQFMzgwNix8UFTI82K8eb2uhQWFmLRokXCBEmza4yRI0eK9fF81KVuvAlN+jyXTqcTOwq3w3O+zz771LzGfb/ooovEtRpzQx188MHCNPree+/VLLds2TLhJmgJv3sskyiWrcTfTCzWhe4DXks0r9N0umDBgiatM/Y9xVxc/G54jZHG1sFzy++cgXOEQcx8jQ/+Hzt+ugX42s7QGt/rjmwnds3VDWaNBVDXdQnQLL/nnnvWPN9jjz3EX5ruGWhY93Wa2etyxRVX1Pqt8jndVz/++KN4je4CuoB4H9zZazgGXTfxcVSx7y/R/sXD3yXv4XQ3MwB46tSp4j5Gt2Zdl2z8tceAYV57++23n9gGn7f1eawLxxDeN3k/4//x9y8eE/cx9hvhd0BXJWM/2hIpIOKIDYQxvxG/EN6IKCx4s6wL/XO8afPBC5aR3IwJoE9s5syZbbrvvHD5A+bFyBsqL7K333671o+E9OnTp9Zz+hV5cTJ7JCZAYo+7775bLBOLC9m0aRMGDBiw3bYHDRrUJN8kl2vJ2JBTTjkFf/zxR43AoU+S+8rXY1AA8YdGP2fd46NPvKHAKh5vfcfH+BKeY94444m/mRD6IklT4y3q24/69iF+P9VqtbiGmY4Y85tTTNA3S9/zzhKLIaCfOwbjBiiouA3GSvC8chCrewOuD4oOxm1QpPNa5edj12hj69htt92EvzcmFmICYt999xXp0BQksffiB64doTW+1x3ZDr9rfs8MkI6HsSMcRGLXQn3ro5gmPXr0SPh63ePhthifUle8k9hE67LLLhOvHXHEEeKeSH89J1I7cg039Tw0xO677y7uwVz2n3/+ERM7il7GRcULFd47eO+OxTbx2mMsSaJrry3OY11KS0uF+H3llVe2u3dRYJHY/evmm28Wgowijffoyy+/XBxfa9P1wtp3As5KGWX+wQcfiAuJfzm4NmWGHSNmqZg9e7ZQjm0FZ/f8MTRGXUERC4C84YYbhKpNRN2bVUeBQoE3B1oZrrnmGhF4xR8w023jj4/iIX5WHk+8NaYlSCQ0SVtZpJh989hjjwkRcdpppwkxzACw2I1tZ+BsnscXG+DfffddYZ1h6uONN94oznMsWJOCsSnQ8kXBy8/TosSbIL8zfoeJgnPj0el0Qjjzt0YhXFRUJAQExUgoFMLff/8tBAR/0zv7PbfV99rU7TTValff+lryePi901I3a9YsfPvtt+LBAEVeixSYO0JL7B8tGBQTfHCw5qDLewUnRrw+ea/mtfHkk08KIcDlaSlh5lrda68tzmNdYvtA6+E555yDRFC8x4TY6tWrxcSV4o2WC6ZeM8g5lkLdGkgBUQeKBc7GafblzZdqjhdgU6EJN3621tGJqWLejBsTICzMwhl9XXjhNgYjxnlD542d20pEc10ZHMiouOnGoDmQsw4OZoxUjt8urTJ77733duKpMXi89R0fs1Yo2jh7aW24H/XtQ/x+xrJTxowZIwQTZ4ObN29ukQI6XM9vv/0mzLgxCwTdRbx+eN7jv7uY5aqx75WzNGY+8QbHG12MRNdYfVAw0E3H75jfBwcEbo/R6BQPfFBANUZnKejE75oDC89RbPZOiouLxWw1/lpoCbgtmuNjs2WyZs2amuyEGBx8OWHig5+hVYK1aHgv5QSkOddwa0C3WswtSVj3h1krdGvEWxcacmm2xXmMh6KXvzW66ZoyOeS9iJMqPugaYYYbM1k4yWqtkgLShVGHmLWBNzSq6uZYH2IXJmEcQmeAswemW/LHHvtx1TWjxWD+Pwuy0CwY/359s/u6sRc0+T///PP1qnWao0l8Cl5j8MfCfWJaE9cf776IzXD5A2TaWyKx19C2mGbKWTFnUfHLcSbOmJO2qofA7fCc07cbg64TmjZ586F/Nh7GvnD/mLpKtwJNyzsD3Qy0ZvA8xhdBis2+4mdbFInx+9nQ95ro84T73RwBwYGAn6GbIiYE+DoLObGoWlPiH3jzbc51117Errm654izaHLUUUe1+Dbjf7P8rvick4CYtbVuyi3N9bGZcSy1tLnX8I5CAZBo9h+LHYm5URJde3Rb0HLSWjzfyHmsC/eR901aE3jPaejeXPc7oKDjOeV2OGlrLaQFIsGsdq+99hJBkaQhAUEFSTMuoc+ZAxkHGypu3sTj4ZfI+Ii6MDiPaj0GB8K6/kNCP3G877kleeGFF8TNl7nMrN7GWSVnNPyxMw6EwUjkpptuEjdlmpe5P7zp8gbA2QMtNg1BcyZjMhj8xRsJb+q8gXDmyONnQCotBLzoaVGgUue54Yyaj/qgQKD7hQ8uX1epMyiKNR9oVqcgPPTQQ8WPljM4mjOZqx5fM6IudAdwAObM+4ILLoDP5xMzeroE2qpmPasm0p3G/bjqqqvEcfI6Y40P3lx4w46HQbz8rlhZ9dJLL63X4tPQNc0bDwP3YlVVaVHjIBXvHuLMntaHE044QQxc3J9p06aJ7zDeAtfQ98p4BQa68ffBQDcKn1jtkqbA74VxNZzdMiAvBtcby+lvioCg+5LXIo+Rgai8D8QC4joSnJjQnM3fHQUPr2/+nng90PqWqDbKzsCZK+9H3CbPB90TjHGhizfmFrrwwguFyGRAIa1ejGfgb4TiO2Ylae41vKMwSJv3Yl6TtEZxJk4XGa89CpVY7ADvAzGrCe8PvF5fffVVMaFKNJFqi/OYCBYfoyjiZ3hv5u+I55rBk7xe+X/seBgHQ0srXXisU0OBwt9la40bgjbP++gEMI+Zp6ahvOO66ZtMG2K+7kUXXaQUFxfXWjaWxpPo0a9fv1ppnPU9tmzZ0qw6EHWJpXEy9S0R69evF2mJrBvBPH7mOTNX+ZNPPqm13JIlS0QqGvOaucz999+v/O9//2s0jZMw5Yg54Ezd4ja4LeYtc9sxmCrF/G+mN8WnNCVKvYux9957J0xti4d50lwv066YJ860VaZ4FRQUKI3x448/im3ws0xXO+aYY5QVK1bUWia2f/EpWfHfa/y52ZF0P54jniumJPLc89qMr3VQlyOPPHK71LPGiL/emKbKbTEfn2l6y5cv3255pqI99NBD4vpjHQUuy33i9c7X4qnve926datIVeS2mJbG2gH8TupL+6wvn79uejHXy9eYP1+XRNfSqlWrRO0Tfsd8L5bS2drfa919asp2QqGQqEcS+x3xGG+99dbt0sfruy8kStdNdH+IpZ/z2mOaOGsxMEWX+xpf54D3CL7PdGd+v6yLcPHFF29Xo6Up13AsjTO+jkv8/vF8NARTmJkKO3jwYJHOzf1hXQamUNa9L3/55ZcixZn7wlRS1sCJpZvHn++2Oo8k0XXP/eZ2+D3H7ptMvec9LT59lNcvU375W+S4cuONN9bUbGktVNt2WiKRdCE4A2NToaZU75NIEsEAWca5dJZ4ro7KuV34PMoYCImki0ETLM2jdd1oEolE0pLIGAiJpItAfzJzv1977TUR90DfrkQikbQW0gIhkXQRmGZJqwOFBAPUGFQlkUgkrYWMgZBIJBKJRNJspAVCIpFIJBJJs5ECQiKRSCQSSbPpckGULBnK6nMsntFZytNKJBKJRNIRYFQDm4+xoFpjBb66nICgeKjbIU0ikUgkEknT2bJli6gsuksJiFjZTh683W5v792RSCQSiaTTwBL2nIQ3pQR2lxMQMbcFxYMUEBKJRCKRNJ+mhADIIEqJRCKRSCTNRgoIiUQikUgkzUYKCIlEIpFIJM2my8VASCQSSUsRiUQQCoXaezckkhZFr9c3mqLZFKSAkEgkkgS58EVFRaiqqmrvXZFIWhyKhz59+gghsTNIASGRSCR1iImHzMxMmM1mWZRO0uWKLRYWFqJnz547dW1LASGRSCR13BYx8ZCWltbeuyORtDgZGRlCRITDYeh0uh1ejwyilEgkkjhiMQ+0PEgkXRH9NtcFxfLOIAWERCKRJEC6LSRdFVULXdtSQEgkEolEImk2UkBIJBLJLkbv3r3x9NNPo6vw66+/ilm1zJppW6SAkEjq4A9FUFDlQ16ZB2uLXVhe4MDiLVVYUeAQrzt8IUSiSnvvpkSSEDYSPP/880U7Zvq6e/Xqhauvvhrl5eXoCuy///645pprar221157iayCpKSkdtuvXRGZhSGRbMv7d/rCKHH5Uez0wxMIixmNuuYBIRq2VPig1apg1mqRbtMjJ9kEq0H+jCSJYZDanDlzxOCWk5ODiRMnQqPRtNr2NmzYgD333BMDBw7EBx98IHL9ly9fjhtvvBHffvst/vrrL6SmpqI9zoP4PbVA8aJEUChlZ2e3yrol9SMtEJJdHqc/hCVbHZi3uQIbytzQqNTISTKJR5bdiAybAWlWAzLtRuQmm5Bi0iOiKFhf6sb8TRXYWOoWVguJJJ7PPvtMuAoOOOAAnH766eIvn/P11uLyyy8Xg+n333+P/fbbT+T5H3HEEfjxxx+Rn5+P22+/vWZZl8uF0047DRaLBd26dcMLL7xQS1Dfc8894vMGg0FYM6666qqa9wOBAG644QbxOX5+jz32EG6EGG+++SaSk5Px5ZdfYujQoWIdr732GoxG43ZuBlpHDjzwQPE/rSTcJ66XWTAjRowQQijGueeei99++w3PPPOMECR85OXlJXRhfPrppxg2bJjYNs/7E088UWu7fO2hhx4S1hq2ruaxvvLKKzXvB4NBXHHFFUL4cb9pyXn44Ydb4FvqQiityG+//aYcffTRSk5ODu29yueff97oZ3755RdlzJgxil6vV/r166e88cYbzdqmw+EQ2+JfiaQhIpGosrXSq/y2ukSZtaxQ+XdjubJkS1WzHnPXlinfLi1U/lxXpuRXepVwJNrehyXZSXw+n7JixQrxd0f59NNPFZVKJe5F8Q++xgffb2nKy8vFuh966KGE70+ZMkVJSUlRotGo0qtXL8VmsykPP/ywsnr1auXZZ59VNBqN8v3334tlp0+frtjtduWbb75RNm3apPz999/KK6+8UrOuCy+8UNlrr72U2bNnK+vWrVMee+wxxWAwKGvWrBHv876t0+nEMn/88YeyatUqxe12K1lZWcprr71Ws55wOFzrta1bt4p1LVy4UFm/fn3NfnH7pKqqStlzzz3FsRQWFooH18Fxg+e3srJSLDdv3jxFrVYr9913nzg+7o/JZKo1nvAcpKamKi+88IKydu1acS74Ge4r4X706NFDHGNeXp4yZ84c5f3331e6+jXuaMYY2qoCghff7bffrnz22WdNEhAbNmxQzGazct1114mDe+6558TF89133zV5m1JASJqCLxhWludXCeEwZ01ps4VD/GPR5krlt1UlyndLC5QVBVVKMBxp78OTtKOA4IDWvXv37cRDvIjgwMTlWpK//vqrwfvsk08+Kd4vLi4Wg+fhhx9e6/1TTjlFOeKII8T/TzzxhDJw4EAlGAxutx4KCt6X8/Pza71+0EEHKbfeeqv4nwM1t7Vo0aJay1x99dXKgQceWPN81qxZQnjEBv5EHHXUUcr1119f83y//fYT64mnroA4/fTTlUMOOaTWMjfeeKMydOjQmuc8B2eeeWbNcwqrzMxM5aWXXhLPr7zySrGvfL2r4WshAdGqLgyazh544AGccMIJTVp+2rRpwmdHU9OQIUOE+WjSpEl46qmnWnM3JbsY5e4AFm2pwuZyL1IteiSZaldii0QjmD9/HmbN+k785fOGYIxEikUv3Bybyn1YUeCULo1dGMY8bN26td73OXFjoCOXaw24/qbAWIm6z1euXCn+nzx5Mnw+H/r27YspU6bg888/F1ULydKlS0VMA+MsrFZrzYOuhfXr19esj66UkSNH1trGGWecIdwNrIJI3nvvPRx11FHC3UG43vvvv1+4LhirwfXOmjULmzdvbtY54HHsvffetV7j87Vr19YqnhS/f3SBMI6ipKSkxl2yaNEiDBo0SLhv6BaS1KZDRX/9+eefOPjgg2u9dthhh20XcRsPfXF8xHA6na26j5LOSzSqYGulV8QuKIpKBEBy8I/n519+xuOPP46S4mIoShSIhGG3WXDAvhORm5MDj9sNn9cNr8cjbjh6g1H4WA1GE6x2OzIyc7AsOQOb+/bGXqMGIM3WNasZBsNRkY0SikTFg4IpEI4i02ZEps0ANaNOd1EYMNmSyzWV/v37i2uSg2eiSRtfT0lJEWWMG6NHjx5YvXq1iJ344YcfcNlll+Gxxx4TIsHtdotA0Pnz528XEMoBP4bJZNquYNHuu++Ofv364cMPP8Sll14qhAnjJWJwG4xvYIopRQTjK3j/ZzxCa1C3jDP3l70iyG677YaNGzeK4FOeh5NPPlmMT5988kmr7EtnRNvRGthkZWXVeo3PKQqohnlB1oVBLffee28b7qWkM8IBbkOpG5srvEgy6mE11r70y0tL8P47b+J/r7wEJeSHEg4C2ywPzH77JG9Vs7ep0WoxZMhQ7D5urLgZjRkzBmPHjhUBWZ2VQDiCUlcAWyt9cPpCwiZPtBwoVECRwy8CTXummWE37niN/c4Mg+5acrmmwr4dhxxyCF588UVce+21te6XvLdytn/22WfXDOrMyIiHz2n5jcHPH3PMMeLB4MzBgwcL6wOvY87iOVNnVklzoRWC+9K9e3eRlUELRIw//vgDxx13HM4880zxnIP5mjVrRCBmvGWjsRLMPA6uKx4+p9WkOVkwdrsdp5xyinjQGn744YejoqKiXTJZOiIdSkDsCLfeeiuuu+66mucUG1TPEkkMhzeENSUu4brIsBqh16oRDAQw/++5mPPz95jzyw/YtGEdNCpgSLoaY3I06GHXQK3ScEoClUoNRaVBccCArJH7o0rXDRpLtck1EPCLdfGvs6oSRQX51Y/CfIRDISxbukQ83njjjZqbMvPYDz30UGFd4025M5RMpnAocVI4eIXlwazTCmuDpo6lgdaI/Cofyj0B9E6zCDGh0+xayV4cVDk4MushkTuB3zff35HBtzGef/55UROB1xbdx/FpnMxsePDBB2sNqFOnTsXxxx8vrAzTp0/H119/Ld6jVYCDNLMrmA3x7rvvimuXmQgUKhQBFCN0N1NQlJaW4qeffhIugXhBkAh+lhke3BcOyrTgxRgwYICY4c+dO1dYS5588kkUFxfXEhDMnvj7779F9gUtHokG8+uvv15YO+gO4eBP6zbPDcVVU+G2KfJ4fBQ6PD90ccTcLZIOJiD45fBiiYfPqQITWR+IMB/HXYASSQzevIucfqwtdguTe7pJgzk/fI2Zn3+MP2f/Aq/HLZbLMKtw5AAtRmbrkGrRIt2iRppZLQbHZJUKRhXA9kob/SqMGq5DWnc7QrZu8KWPgD91iBAZdeHMqahgK/78dz7y161AwfqVmD/vX3E90yTKB6GPmSl+vKlSTHREytwBbCzzCAFm0WtFemtd108MioXcJBNc/hBWFjrFeR+QZcOuBGe4NMNzcKRYiBcRMbFIE31r1IPgADxv3jzcfffdwuTO2TLvqxQJfC1+sOUgy2VpweU9lgMmhQfhIPnII4+IyRmFBN0JX331VU13UgpiChSug0IpPT0dEyZMwNFHH90kV8v48ePxzz//bFcN84477hC1LLgfFC4XXXSR2HeHw1GzDNNHzznnHCEqaJmmm6EutPh9/PHHuOuuu4SIoBC47777RFxDU2FqJwUW4yb4XVGQfPPNN61Wy6IzomIkZZtsSKUS/i5eDPVx8803iy+IZrIYvLnyR/Ddd981aTu0QLAaGS84/igkuybhSBSbyr3CbbFx1VL8OnM6vpnxCRxVlTXLZGRmYsqRu+HEoXoYQk6UbFiCJIMKaoMJ0FigU2ugqNSIqNVCI1gjPuh0KthTUqC2piNizoInawxcvQ5H2JzYrxxVFBQ6fGLQHZRtxdpVK0UwFgPDZs+eXSt+hze9s846S9zkOsIsh1aHLRVebKrwivyBdKuhXuGQCBbj4jp265UCWydyZ/j9fjEocfa+M+4m1ntgjYP4gEpaRzlonnjiiS20txJJy17jzRlDW1VAMNhm3bp14n+agahwWUyFKphFO+h+oHp9++23xTI8oOHDhwt/G4t7/PzzzyL6lWa1mDJuDCkgJIx3WFVQhemffIIZ77yCFYsX1LyXmZWDo048GUcfcQgmqJbAWjIfGm8pHC4nCsrdCBqT4VLZ4FZMiEANNaLQIgKTKgAzAtAgCp0qDKsqiCS9AnNSJpTkXnD0PgLuHvtD0VS3yY2HFSyLnD70TDVjYJYN2m0mfY/HIwrt0B9MgRzz6zJwjDMsXvuMAG8PKjxBEWxa7g4ixayDWb9jxsr8Ki/6ZVg7lRWipQREe1SilEi6jIBgug4FQ114c6SPjTOtWBWx+M8wAGjFihXCT3jnnXc2y+wkBcSuTX5pJZ58fhree+0lFBdsEa/pDQYceNjROG7y6ZgwcX8kFcxByuoPofWVIep3osgdwcpgGqoUK6oUC/qG8tHXWwiTEoQeYegQhgoKPFoj3HozAga9sEhQXFhVAVjMJliT0hBO7oviMVchbO223X4xNoBlsjmY8lE3S4E+5I8++kikMtNnHZ8Kfdttt2GfffZp00yVDaUeIXyYmlo3zqE5dEYrREsKCImkI9IpBER7IAXErgldAY89/RyemPooqirKxGspqWk4+ewLcOo5U5CWngG1rxSZi1+GqWwxVNEw3B4nFrpSsTGaAY9iQjfPcvQNbsWwsBeIqhANA0pUBSVS/VetU6DWK1CpAW/vvvCEfPCEgTA0sGmCMFtTYE7OROmYK+DLGpfQMlLpDWJQtg290iwJj4M/R1re6EOfOXNmjf+cFjj6cumHba9MlYREw9AEndAEnFA0OoQsudvFhNAK0TfdioHZncMKIQWEpKvjlwIiMVJA7FrQRPzWW2/jrrvvRv7WaotDj159cO4lV+GYk06FkbnokSCsm39Eyprp0ITciIb82OjS4A9vLusCYri5At1Rhi2b1sMWUaFHuRaOPD0iXg2iIVX1IwroTFHorBEYUiIwHrU7DElh+Jyl8LqdcER0sKn8UBuTkJaaBkf/E1A56GQItRGHOxAWs/Jh3ewiLqIh6P5jEBcD1mJFfJhSx+h1BrW1JFXeINaWuGtlqtSH1lMIS+Hf0HmLoQ55ar0XtPeCq8eBiBhTal7zBsPwhSIY20msEFJASLo6fikgEiMFxK4D3V2XX3EFVmwz+adnZeOya2/BcSefUV0gRlFgqFqDlNXTYSxfBlU0Ak8ogt8rkrAlnAQTgjgguQS5FhUc3gBe/2U1Vqwz4LYqzrwbMdtPexHm7iokrf8S+oo18FUWwuP3QRR31ZuRkZaOQNYYlIy+ClGDbbvBms24hndLEoGJjcGodEaQv/POOyK7g1HgLOzD15jq1pKZKmwcVl+gpNZbAkvBXBgcG8RzlRIR4gxKFIpaC3XYh4ghCVBr4cnaHZ7s3QG1rtNZIaSAkHR1pICoBykguj4MSGMq1/vvvy+e25JScN5l1+DM8y4SFgeiDjph2/QjbFt+gc5bBEWlwyafFrPL7AhCg1x9APsnl8KsVyNkzkbh6Ctx2FnXoKy4GF8xQ6OeVrUK60JkZgFffQmoNVCF/bAU/oWkDV9BKVgAj9sBf1QPaPXISMtANH0gisfehIgpZbvUSJ1WjRHdkrYrpV0frAzIborsMkiYOhfrJrgjgXmMccgr84gUTYNWjWRzogDQCJbNmwt7/mz01FUiOysLem8RQj4nvIoRPq0dQRUDTlWwaELIVLuEiIjqrOJvVf8TEDGm1lghGAvR0QtMSQEh6er4pYBIjBQQXdtdwWIwzO3m98zU4CNPPhs33haX365EYSheAM+/H8DmWA2LNgJtSk8sKFVhpdvACx5jk9wYaXOBsYHezGorgaK3ijLWN910Ew5QFDy6bZvxIkKJ5fFPnQocUN1+OIY64ED6sv9Bv34WvM4yuCM6lqJEWmomkDUUpWOu3i7Vs9jph82kxdAce7NM+yzYwwwNBhoTxkW8/vrrIoOpOfEO60rcImAyxaxPmGXB8/HptAdwVGo+etojyDFHkWK3QG3LhCdaLVjCigZeGFGm2EWgqSk5B+NzNTCqwggb0xFI7o+qAdUpiwUOryguNSi7Y/8upYCQdHX8UkAkRgqIrgmLuTB7hxXlyJCRu+HyOx7CPhP2qDG5a/xVyJ/1NDb9OQO9DC74I0BJxIZo7ih4dCnCKXFEehlyjQFRWbKq/0moGjipVtBfrBfGsOJi3MBS6vE7kZUN3HD9duIhBs35yWs/gW3lh/CV58MfBYJqEzLSsxDJHIqykZciZM2tVSOCIsJu0mFIjr3JlggSCoXwwgsviOJAvObpsuH/FEB16/vXxekPYU2RS1hBWE0yUaXI2T9+jfXv3YiDuweQYlBgt5rh06cgrDUhqOiwUumBqD4Z6WqnSG/Vq0Jw+0PwKzr4tEkY2zMFfSMb4E8ZjPLh5yFk7Qa3P4yIEsXufVJh0HbcVEYpICRdHb8UEImRAqJrQZ8/B0oWGWPVOavNhinX34WjJ5+JDPu2IERFgbF8KUp/ex2r5n6NXrYo8pxqBCxZQM4wMYhHAx4clZKPbqkWYV5nuqU/c0zCbdJsv2jhQpSVlqJ3ZSUGsHAUGxCNGSPcFg2iKLBu/Q0pi16Er3g9QtEoXOoUdM9MQyh9KMqHnYdgUu+4xRWUuAKwGDRCRCRyIzQEuxpecsklokpgrBgVU6TrC7IscfqxpsQNXzAsgiXrpmiqwj5Y8r7H2vdvgwE+2M166MzJyNP0QImSjHmBHogWrcH+hlU4bOJ4ESuiioagjvgRcpVhoxPYHErCZiUTE5IqMShNB3efw1E1cHKNYBrdM1kIl46KFBCSro6/hQREhyplLZHEwxa+5513nkhrJHtN3B+X3fW4qMcfm62rg27YN/8AXeVarFz6I9KNChaVaWHK7odwen9EoYbKUYgxgfmo8GqR0f1gFI+/DeE4S0BdNGoNxo7dPg2zSahUoqAU3RXpv98FpXQDrBEHNpUb0Fu9Emkr30LFoFMRSKkuEEWXCLtXUkQsK3AKdwZbjDeV3NxcfPHFF6IYFd0aCxYsEA27Hn30UdHFMFY6mfEOWyo8WFfqgU6tRnZMfMV2OxKEqWQh7JtmIZT3N8zqACz2VOTre2MjclDs00NftARH6n6FzVRd8MpXugnWlAwoGgOihiTolCiGqoqR5q9CuseBSqcBpUoEqfZl8LgmIGTrIYw9lZ5ghxYQkraB9X2qqqowY8YMdBVUTai43JWQRb0lHRLWQBg9erQQD6yJf+dDj+OOF95D/769a8SD3rEBqSvfgaFiFQJ5f6PcFcBKpxHGXmMQTB8g/POm0uUYHfhXFH36pzCKr62nNCge6sKBl2WxmaHAv03FnzYMZRPugCk5F1p1FNZgGTZWBGEoW4mU1R/BWLak1k0ny25EIBTBsnyH6GjZHMMgP8/uhSxAdeyxxwr3BnsY8P+ysjJRyGl1kROri92il0UtgULrTdkSpC17HSlrPoapbBmcvjD8qQMxV78HNio5sFasxcHOL7CfeT1sugiqAmp8ucGA30yHoWzkJSgfejYqB0yGJ3cv+DLHINusYKg9hD7qYrjcbiiVm2AtmCu2xe2XuYPifEpaZ1Dm9cA+FvFwkO4MTds6C2wGNnr06IQB3iz+tqsgBYSkQ8HBj3581juorKzEbmPH4aPv5mCvY85Ahs1YHewXjQg3QfK6GdB6i2Fw5qEkkozSqB3mfuMRsmUjGAbSC+disLJe1Hr4aqMBN8+1oLiydt2CulAksIxzQZVPPBgnUOELiuZQ5d7q1+kG4PPGBIU/awwqJtwEkz0denUYZn8hNjrpblmJ5HVfwFz0T63lxaxcAZbmO0RaJQf+5sBSyRwo2HGQDeYowkaOGo03P/1WFIdKtxhgNfxndNR6S5Gy5iPY82aJ4lpaTzHWuE1YEUjBCnV/JAVKMLj8F/QNr4EKUax3aPH0YjPO/tGG55eZEei+Fzw5E+DJ3Rvu7vuiYug5QkSwDoTBngarJoI0lQOVFaUwli+HzrVZfH+sg8E4jF0Clidnpd0PPqj+20gb6paAJmlaoPj7kWx/f2lNsrOzd6nmjlJASDoMW7ZsEa2uH3vsMfH8siuuxPPvfwltcg6ybAYReKcOVIlBz1w8X9Ql0Aaq4E8eAJfGDmO/8YgY7fD5guhb9DN6aUsRjqrw4jIjnltqhgK1SH1MBAc1Nr3i7Nhs0IhCTwz22733tgf/75WKEd2TkJNcbX4v8wREeeqGhIS3275wjbsSZksSjAhC59qCzT49jBWrYNv0A6xbZ4vMkRgpFj2STTpsKHNj6VaHqBnRHDjLvPTSS/HH3D/Rt/8AFBbk47LTj8O3706Djv3Kt7kruN3UVe9B78iDsXI1fDDhzzI9VlcpcMCK0f756OmYD33Uiwq/Go/MN+PS32z4ZpMB/qgGWVnZGM2YkDiiOgsc/Y6Ds/dhQljYzEbROyTgjVkh/hAt0wndGF2ezz5j72mA5fxPP736L5/z9Vbk4IMPFgPZww8/3OByv//+u+jNwU7HbPJFFxj7sxBmO8Vn9cQsGCy1Hr8dds+sDzZFPPDAA8X62cWTnTXZH6ku7AaakZEh/O2M5wkG/7s22Nqb8TyxdXCbsX0kr732GoYMGSJEE7vZxrfrZpsE7jNLxO+3335imZdeekmsK9YNNwbdDuy+6fV6xXPGXA0cOFBYP9kxly0VYuKDMUbc58WLF4v188HXCP+Pd8k0dg5oMaK7g4HbnABwGfaCihc6PCZ2WeX+Z2VliS6vHQUpICQdAt7M6LufO3euCOB5+/2PcNa1d8MZUiE7ySQaUBkq1yJt5bvQuQuh8xRAUesQtPbAimIvlpVHENUa4HY4MLLyR2ToPfCE1Lj3HwtmbDSK2IREgx4HfwoHzvbZ7Gq3XsnYrWcKuqeYhak/yawTdQssBq34PzfZhKG5SRjfJxWje6Qg2axDscsvrBYMEtwOlQrOvsfAO/pCGE0WWFQ+hMs3ojBshaliJSwFfyB53WcieDGGUacRMQpV3hAWb6lCXplbCJym4vCFoM3og8ff+wZHnniqCER99tH7cPPlFyBSvAKpK9+GuXge1EGXqJGxRdUN/2wsRb5XjVSND0cmb0XfNBOCUZUQDOf9ZMPP+dtmVdvM4NffcL2IFUl0vL6MUSJoUskcBoNGhSS4qq0QFaugd+YJK0SpKyD6g3RZKBJ4o4/rxCnIz69+vRVFBGuCsD7Ic889V6sTaDzr16/H4YcfjpNOOglLliwRgyx/g1dccYV4nwMu04TZo4X89ttvQnzH+hZxgGNGFAV/IjjIs/w6C539+++/mD59On788cea9cenJK9cuVKs94MPPhAdTDk4x9wBp512mqhzEluGXUxj7j3G/TClm5VZ+T6PmQP9W2+9VWsbt9xyi+iKymUmT54sWo7HasjE4Lo4kFMwEIoJigKeA5aVf/XVV/HUU0+J90455RTRxnzYsGFiH/ngazt6Dn755RfxffAv953bjQkStlunsGPRONaBYdO9fffdFx0FmYUhaXf+97//iVkzb0r0K7781vsImtLhD0VFgCHrC3CgtRT9K3ov6PxlCBtSEFHp8NcmFzaVVYlsgGSjBt02zoBeo6DUq8Ydf1tFyerYoMey0AfGpWCyrLTDF0S23Yg+GdZmpVHGC5BSd0C0Dqe1oL6aCnS7pC96AZqlH8AfCKAEKUjpORIZqmoLSticCUffoxG2ZNf6GF0lNPeb9Bpk2YzITjKK/azrz+ZgzD4bzHIodwURjESRYTUI4fXxO6/jmftuwkG9gYOGZ+PwY0+CzWKCOhLAqvIISvPXwakYMVa/FT1tamhMNgRtPfG1bxRue+5DlBQX12yHIoziIf481kfS2s9hX/A83I5yYdXIyO2LwICjUT5gsjhnu/VMFs26ulwWBt0UtDTUM3iL67F7d7Yf5miP1gpM3HPPPTF06FDx++LzE044oWbwvfDCC4XQePnll2s+SwFB4cCBj2Z4WgVoceCMl92UOUhyMOWA+ccff4hGidxWbNCNhwMuZ/G0KrK7LPnmm2+Ea5KZQ5xJc1+ZPcRlYuvg9m688UZx/160aJGYVNCSwMDpuvTv31/0h6HIiPHAAw+I7XAiws/xO2T7dAqIGDwXZ511FoqLi8V2OWZwf2iFoKhKBC0EH374oRjQYzEQM2bMEPtYXxBlU88BhREFRKwY3MknnyyqzXJ7FFQMJKcQpKhpKWQWhqTTw/4OVPLPPvuseM7ZwUNPvYitrigQUURgoSrkRVLeN9A7N4uqj+qwFyFTFgIRBT+vrUKVyy1cE7QajFWWo0rbF7NXluC62SpUBqt/kFmZWbUGPQZGlnsC0KhUGJxtE9aGWIvt5sLPsadFmsWALRVeUdUxFFG2FyNqDcpHXYwMfyX0q75GergKhVtXQd1vLNSbF6AkYodm8xpYdj8NwYzRNaKHBab4oAViU4UX+Q6fsIiwciQf+m37XewMCKHBmhh8P02/bWBSFJx19N44NmUKfv7yQ5SWluD1N97EpBOPQ1HIBHd5PrRQcLBpLZLtSVAMdji774+KoWdhtNaErw49ozqltaxMzEBpwUloeUiAu/tEWPN/g949B0kRF5zlRUhOXQZd36MQjaqFhaUjCoidZs6c+sUD4SC+ZUv1cvXM4FsCxkHQfM6qrXWh+Z2WB868/9stRVirOLDQLcCZLgc3ug04E2f5dIrwVatWCYsEC5glEg+Es/1Ro0bVDJxk7733FuvnTJqDJ+Ey8eug6KGJn4Mu3zvooIOEC4Mz+UMPPVSIGc7oKXI46F5wwQWYMmVKrXsKB794xo2rnVF15JFHilopX375JU499VRR2ZUDJY8zBi0yvC9xG9wfrre5E9KVTTwHtGTEV5KlK4OuD3LIIYcI8UQ3CsUNHxSC9Z33tkYKCEm7QHVLwfDDDz/UKPpzLr8e60o8woTPAVjrKULShpmi2yNN/OygybLIjiDw86oy+AM+0WvhoD4m9A0sE7Ui9QMPxLCTr8IjJ65MOOixAiPFA3tQsK02Yw5aAjaf6pthEZaCtcUuERtBC0C8pYDpjmXjrkemvwr6jb8jM1KG1SsXYdmaLehh8KDEp0bo558wfN9j0eOQy2pVrqQLhQ+6WrzBCDwsyhRVRE8NzinNOo0Iwoyv66DxV8C25VfhNkjKycCx51yJD957FwZfGf5YW4wMmx5ZqiqMNFXCmJQuilyVDzkb3pwJNQJmZ1JaI6Z0uHoeiqSSlQhWFUMTqESoYhMMVetgsQ4VVoheaTsu3joshYUtu9wOQgHAgffWW28VM914OChefPHFwjxel549e4q/dE+88sormDNnjrBAcACNiQoKCForWhMOqrw/0Jrw/fffC5cMS7n//fffNQMoZ/l77LHHdp+LJ34AJ3q9XggRujEoIPiX1hWttno4pGvmjDPOEK4Unj8KEloDnnjiiVY5Tl2dwm+8Z1BkEFodmJrNc85zQJcN75V0iSQnJ6O9kQJC0ubQfMdUJ86AeCN48823MGa/w7Cm2C1m28wUMFSsFjUJKBpUEb/oahnV21DgVWP2qnwokRDUOhOO6RVGhn+lcGE4ex2K8uEXQK1SJxz0GBvAngwsp9wnw9Li1RD5w2eMBC0DzKIodPqF2yF+UI/qrSjd83aoCy+EyZ2HPtpyRAb0xMp1W5Cq9cIXduPvbz+APVyOrPEnwJOzJxTtfyZG7nNj+62KBES3THPpQuE6ofXDlzoMdk8BTj35JPy+fCPsGj8GIQ/ZKicMKf3gyRyL8uFTELZkNulYKV4oZlRQQa2GsHzwUbcwFbMyrNm/wuj6EcaIF46yfBjLlsGSOgLlHma3hFtMxHUYcnJadrmdgOmcdAsOGlRddyQGC47RqkA3QH1QILCWCH33sVgH/qUfny4MWg/rgxYM+vFpKYgN4PwMTfPx+0JLCAvEMciQ/PXXX7BarSKoM/ab4qydDw6enI3TRcA0ZdZAYaM5DvbNhZ/h7J6pz0wVp+sjBgULt0OxEmPTpk3biZBIIxk1TT0HjUFhQ+sIH6w2S+HAfWY8SHvTxaS/pKND8+dee+0lxANNeD//8iuG73OIsDwkm/Sw6jUi3iFp49dQRUJANASotGL2vrpKjV+XbxbiwWhJwsm9PMjw54my1BWDT0f58Au3a59NYhUQWUZ5WLckDMyytWopZZrlh3dnp009ipy+7YIrg4YUXDDDhVWFPhiifvTXlWJw/55wqCzwhAGTRsE/f/4BU/ECpC1/A5b8OSLlsjHYWttUws+8JYIkKR4CSX3h7H4QDFVrUVSwBXPWFCFD48Lu6jWwujdj2cZSvLUkioLR1zYqHmjipiuF55IWlkA4Cl84LEpUV/qCIjCSKa7xxxsxJsPV6xBokrJBW4kpVAZdyWLoFHYkjTY7y6RTMHFidYxDfXUX+DoHSC7XytD8z8Ey5iaMQd88B0oG9NGPz1LxLEgWH+A3cuRI4S7gDD1eQND3HwgExKBeH9wmfessP79s2TIRIHjllVeK2IOY6Z4w44JuCIoZxgdwgOQ+cJClpYGBkYw7YFE5xgMwqJMDM6GFgJkmPLY1a9YIs/8bb7yBJ598stHzQksKM1W4n4wDiLdiMOOB26PVgS4Mrp+iJZ7evXsLVw/Pnai1Egjs8DloCKZic/vcDkXM22+/LawTzREgrYkUEJI2gzcs3nT4Q+CP9JfZc2DOHYi8Mq8YbM2aiOhqydkzFKr7qGgNzVbRf5dqMH9NnqhHkJKSjsnZhbD6C4WwKBl9JRz9j094ww5ty7JgBsWo7snolmyCus4suTWgFWVoTnW7bg648bHKjCmYt7EKN84xYkWBF7poAAN1JeJGZjKb4Yuo4HZ7UFhULFpkM3iUBbNSV7wjakcw9VLnzhc1MDT+yuq6Ems/Q/rSV4TLQh1yI2JIRlXfo4TLx7b5B6zcXIy5a4swSNmACboNIm4jkDwQd/wSwBXTfsXVF58Hn686ha0uFATl7gAKnT5Rmjs3xSjKUTMTZY8+aRjfNxXje6eK1+xmXU1WSwymdEayR0Ol1sKs+OEt2wKDYz3MOi2KXQFhzehS0IT+zDPV/9e9JmPPn366xQMo64MR/DGTeLw4oBuCAy9TOemi4Ayfs/r/dlUl3uPfffbZp+ZzdGUwrqCuayAeWhZnzZqFiooKEStBlwHjGZgeGg9f472AAzrdCCx+RhM94XZmz54tYhaYUsmUUboRYoWaGAjKNE6KBgolWkw44+fvqDF4TAy+pAWkrgWD+3DttdcKIUPrDe9bzO6Ih9krhx9+uAgkZbApM0h29Bw0BK0NFE6MZaFwYpApt8W4iY6AzMKQtAlff/21+AEx+pdqf/pnX6A8zBm6X/juDREPktfP2DbTjtZoW5ai/nFzFOXFm8XznrnZOEi/CpqwB1G9HUVjb0AgrXpGUhfOlqt8IfRMNaFvhlXEVrQ1zKJYXuAUs3QGhZJZs76rMY/2s4fxyN5+DM21QNHo8W+wNyrzN6KisgoHHXAgeo7cG4rGCL0nv9od0QghSw78qUMQ1RhgK/gdUb8T/2woR0GFE/tolqC7zgez1Q539/1QOvpy/Dj7L9x8xYXw+33YbfyeeP7Nj2C12eucw6Do0cE0V6a2NnQeGWOyscyNLRU+kY0SCya1bvkVll9uhzFQCoc2E6q9rkRJ/8mo8AYxrhfTYfVdrxcGUzUZ/R8fUEnLA8VDBzA/S3Zd/DILQ9JZYDEYqn1GMh911FH439vvYYszgjK3X9Q7MPjLhHhgXYLqltkaEakeULT4ep0fgaoC0UlzWJ9u2COyCKpwECFzFop2vxVhW7eE22ShIqYyDsqyomeaZTvffFvBmA5merBENWfxdG/EF7Na79Tixt+NeGQvD4Z1V2G8fiP+7TkAKnMZLCY9dN4SUe/Cn9QfEb0FOl+FyERhAyu6eFTRoGgO5k8ZJB5samUp/EsETjKtc9Z6Hyy+UhyhWYw0I6CzZqBs+PmoosVGrcUBhx2FVz6YgcvPmYwF//yJKaceh5fe/RQWe7IINmXfjAGZNnRLMTVJgHGZQVl22E16rC9x1xyzN2ssLEk9ECkuhyHsQLRoAfT9j0ckogg3RkcSEC0GRcJxx1VnWzBgkjEPdFu0keVBImltpICQtCrvvPOOiACnCZURz8+9/D+sK/OJgEaa0Y3OTUjaOFNUR1TUGqg4y1YUuBUDZq6sgOIph0qlxp4DsjDUN1+4NujXLxp/m2jglMjcTl+8QafGiJykmll/e8LBcVC2HcsLqitLMiskMysLJSUl4ljzXFrc8LsJj+7lwoAcK/Y0rsLazG5YWxWFPT0EswGiWmTMwhCw9xaiIaozi7+agAN650ZRoZMuD4qwlcUezNikxzGqhRisy0eSUQcltR+27HEHgnUsNqPH7YFXP/wSl555EpYvWYhzTjoSD7zyIYb16yUCTun+aQ50EdFVpFOrsHhrlXAj6fQ2RHruA3XpchijAZSXboLesREmQ1/RSKxnqqVNXEttDsVCK6ZqSiTtiYyBkLQaTAFjABHFA4uhPPfy61hT4hXm/By7EebyZcLyQPEQVeuqxQNLREct+GJxsRAPGq0ehwxKxVBvtXhgs6bCPe9LKB6qq0r6xYA3sntyhxAPMTJsBgzKtlUHHoaU/3Lzt/nEt3o0uGqOGbPXe1DkCKC/uhB9/cvw84pNWFoagl9jFQGiOk8hLEX/wLblZ5HimrL6Q9jzvhVVHikeXBEN3lurx8JNZbhC8xlG6AuQajHA3+dgbDrk1e3EQ4yhI0bj9elfIy0zGxvXrsJt558IW7iq2eIhHsZ/0D3FKp3E020fRPTJ4pC1ri2iP4bVqIUrEBbZGBKJpHMhBYSkVWDONvPMGWLD2u6PPP0CVhW74QtGkGnVw1r4F+ybfhB9IOivV0erB5lN4SR8s2gz1CEndHozju2vQ0/3YlHjgU2aina/BYrWkND3zpLSuclGDM9N2qGqkq0NLS4DsqwiLmKvffYTRXkyM//LfCj3a/Dk+n5wDzwB9szesGsimBhZAG/ePHz773L8s8WDSm06AskDEEjqJ+o2RAx2hEwZWK7qh1c3ZePxeWGMd3yNydo5yDAqsKZmo2ifB1G49wNQdPUXn6GVwJDZEy9/NBO9evfGpo0bcPBBB4qCPjsKLQrdU6rT8xhU6U8ZCKT0BpM/jWEH9AXzoVNFEApHd53mWhJJF0K6MCQtDhvWxArUcKZ9/R33YWWhSxTgy7TpYdvyC0yli4X5PqozQR32izoOK/wpmLdspUjxM1nsOLabGzb3FjHzrhwwCVUDJiXMtKBFwxUIoW+6VdR30HXgwkQ9UswIhKKiWdbEffcXkeOJKj1Wli5C2qIX4CkvxBB3EQZG8rG1KB2/FeXDYLRCr9MgorMiok9CWWURMvzrcYCqALnaCpg1UVjMZvh7HYQt426Coq8/Wp6wNkalNyT2rd/A0dhjzhyRrscUNv5ltH53piXuAAy6ZPltZmZk282I9J6IcPFCGKNBlJWuh8GRB5O+l8hUodiQLaclks6DFBCSFoVpVSx5S9iW+6pb7sbKQic0KjVSzWpR34FNsWhRYPOravEA/ONKxepVS6FDBCnJqTgqrQhGbykUjQ5lw6bA3fOAhNujeZz1BGIlqTu6H537x4qVDPDcWukVQaSJil75MkajYOJUpKz9BJkFc+F1VkDjcqJ7eBECfh3CAQ1CihZBaDFO5UKyxgO9Tg+jyQaVLRsloy4TLoPGYCyKLxTBgEwreqdXB5tSLDBnneKBhXqYqsZKeN26JQ5YbQgKAgoD1o2glciTsxfUhvdg8BdA59wMTfkKWHr3FRYIujJYhlsikXQOpICQtBjsJMd2tYQV7C6/6S6sLHLBqNUgWR9F0rrPoXfRJK6IzAI1AydVavxUmoTiDUugVUWRm5mJQ63roQ04EdWaUTz2WvjZG6IOdI2UbAuWHJKVhMwOFO/QGCzdTFcG3QYsNEXXBqs41iVqTEH5iCmoHHgK7Ju+R8bWnxFxFIvPRSNh8WChLY3aDLMtG6G0QSjrWd1KG5qGB2KeP7YuZxXJYbl25CQZa83+WQkwJiLWrVsn8tD5PL5OQHOCSLn+zeU+mJL7w5baF5GCIpgiTgQK/oGh71FCUDm8ISkgJJJOhBQQkhaB1eoYKBmLebj69vuxutgNi14DuzYsCh3pPMU14kH0tVDrMHOLAd6CxaDhYEC3LEzUroA66EfEkILC8bcilLR9URgWHqLJmwF+tDx0xhRAVsJkRcxwVBG1MNgRNJGIIFGDHVUDJ8HR7xiYShZD6y2CJuSCOuiGJuhG2JiCgl6HImxrmptBnD+XH3ajVuxDfQ2t2BOBooFuFhYcYulfFvZJS0tr9vF2SzGLhl+eqAbJfQ5EpPBfGJQAnMVroHdthlHTTVgppBtDIuk8SAEh2WnYkvfss88W4oEWiGvverimr4Vd5Ufyms+g9ZWJUsaM26V4CKpN+HxdBNHyFWIdu/XOxJjIYqgiEREcWDj+DkTimknF4OybAw0zLDj4scFUZ4X7PiTHLlw8RQ6/iBWoT0QQVt305ozfqW3Gzh+zQnj++B01BHsCUESwIiHLDbMK4E8//dTs1sK0LOQmmUS30pTs8dAa0mHw5wuLlJpujB694PSFRIv1xvZJIpF0DDputJmkU8BOfexfz8YyZ555Fq6/dyrWlbhFFoQdblGbgOKBAZMqhaGSCrxqK6av8iFavk4MmPv0S8FuLBClMFJ/EPL3fjCheKAPvXqWasbQXHunFg+1S17bkca+GY7afSRaGmbAxM7fsNykJg/UrFbHroi0PLAL4PHHHy8q2TWXrCQjdFoVXJaeUNIHIgI1TBEHtPn/wKhVIRBWREyGpPVhL4enWRFzJ5fZWVh6uiN0lZTsGFJASHYYNng5+uijxWBy9NHH4JaHnsaGMh9SzAbYok6krpkuihwxVVOUp1ap4FAnY/qSCqgdm0W2wSF9TRjMVtxs1JS9Bwon3A1FZ91uW5yZsrIiW3DTbdGazbDayxJBEcFshdboDcHUUZak7r/t/DW3rDfr8H/33XfC8sBOgLHKos2BLhMKS1dIjXDfgxFW6aFHGMHCFdC5t4oupiwC1sWq67c5TL09//zzRbwKu0bSinT11VejvLy8WeuhWIzFNLUEiQQJ+1/QPSbpnEgBIdkhGFjHZjKsm77PPhNx/zOvYqszgDSLHrZwBVLWfCxKU7P4E60OUGlQqkrFZwvzofcVQa/V4pjeCnoEmJEBOHsfgZLdrksY/MfqjezJwEJMFBAMQuxqUETQqkLXAgMr45tR7QwcjFlOmuujSOmXuePnjw2UvvzySxgMBtGRkc2MmjPYM7aBridRTCtrNwSMtDIpMLhZVGqFsMbQAuEJtsyx74owa4bfE7trsukSf6dswES305577ikaOzUVNoliQ6jWhG2842uhSDoXXe9OLGl1ioqKcOihh6K4uBgjR43C46++i2JvFGkWA6yhMiSv/QTqUHW/BsJ221uUDMxcsAHGYDkseh1O6OFBerC6xkP5kLNQPvx85jhut60ydwARRcGwbnb0Suui5Y63weZTdC30TDOLQZ9Wg52Ndyhw+IS1YXi3ZPRINe90gCKzMqZPnw6NRiOybup2KWwMBrwyc8Zh6gFkDNrmxnBCu/UvGLVq4aZiLIRkx2AAM60O33//vQh+ZSAs41Z+/PFH5Ofn1zRxIy6XS1iS2FWTKbovvPBCgxaDqqoqIRopLNhkiZk57GZZNx6KnSfZoIl1TU444YSa64ZdeNnlktdg7DqMd2HQEsHXV61aVWudTz31FPr161fznK2xeUxWq1W0xWZ7bNZRkbQ9UkBImoXb7RYNsdjJrW+/fnjmzemoDOuQbjXCEigVdQtYUlm1rTgULQ/rI5n4ccFKGMNOJJt1OC63HLZQmeg+WTL6Cjj7HbvddjizZaaFTqvG8G5JItVxV4CD/eAsu7BGMLWRMQs7EhfB4lpMc+2WbMbIHknCstFSHHPMMaJMOXnwwQfx8ssvN/mzzMpJMevhCgKhvochpDJAjxBCBUtFmW69RiPcGB0NXo8ej6ddHk218tC6wPbRrMPCmX082dnZom31Rx99VLO+xx57DKNGjcLChQtxyy23CDcHY13qY/LkyaJ/y7fffov58+djt912E+2pY1YNdtylYGD7ba6TVo/x46uDftmSmvVF2Fq8sLBQPOrClt20nrz33nu1Xufz008/vUbEULiw/fi8efOEW40TGcZhSdqezh+FJmkz6PNmQ6wFCxaI2cUzb3wMv9aGTJsBZl8Rktd9BlU4ILpFKlqjsDwsDWZjwZJFMCpB5Fo1OCS1CLqwXzSBKh57PfzpwxtM0xySbd+pfgydEVpZeqRaYDHosKbYJeIirAYdbEZtg1kaJBiOilgRrVqFITnVxbVaoxMpfez0td9zzz1iwOIMlvEwjcEZZqbdII7JlzkaWlMmTN5NMLo2Q1WxEpbs/YTLitUxaZHpKHi9XjHjbS/RTitBY9BtQXHAeJVE8PXKykqUlpaK53vvvbcQDrHB+48//hCzfabr1uX333/HP//8IwQEXVjk8ccfF64sdttlrATFJO8P9957b83nKFBIamqqsFoxhoZipj4ocp5//nncf//9NVYJipV3331XPOd7FA8PPfRQzWdef/11UbeEy/I4JG2HtEBImgRvTCxPzVkGzZNP/e99aFNytomHwv/EQ8hdIx7+9WZj0eIF0CtB9EsCDksugC7qR9iUjoK97ksoHtgQq8jhEzPmEd2SdjnxULcM9OgeySJ2gRqAgy4rb/Ic1YUDLt+v9AWRbtVjZI9k4fJpzTbmd911lxASbJbGYDgOME0h2aSHSa+Bw5gLZAytdmNEXdBsnguTVi0qY8psjB2nqRYLxkTUfb5y5cqEy9JVQSHDTBwKqdiDlkiWPI8FVdMisTNQgOTl5eGvv/6qsT7Q0jF48OCa/WBacfw+xN6L7Yek7eg4El/SoaG5kz0uOIN86NlXkd53OLJsRpi8BdUdNcN+aIJORPR2QK3B7Kp0bFo9H1pVBMNTItjDUiyCKYO2nigcfzuiptSEs+dSdwC5KSZRo6C5mQJdEZ4DCgHWiGDlyPxKL8o9QeHW4DBBecCkDZNOjZ6pZhGkSDdRWxRj4jYYoFdQUCBMybRA8Mbft2/fBj9H8ZBuoRXCj9CAIxDa/CuMig+R/IXQ+Uuh0yQJN0ZHclsxmJADaHttuyn0799ffCcUAbHYg3j4ekpKiohhaC489pycHFHSvC6xGIa6bpMdgdYJuihYmG7ChAni76WXXlprP+hCe/TRR7f7LPdP0rZIASFplI8//hg333yz+P+Gux7EkAkHbS8eApWieqSi1uLH0mSUbFgoSlOPT/NjpLE6fcyfNhxFbO6kMyWsUVDhDaBXmhn9M20duiFWe8C01W7JJmTZDPAEIghHoyK4lO4eTjiZHtkedTF0Op0IqmTAHl1bvLnPnTsXSUnbt1uPhxamrVU+eNNGQG/Mhsm3UWRjRCtWwZq5t3DD8Jqg2OgIcGBuihuhPaF1gO6HF198UQQrxg/oDHzmbJ4F32LiMjbLj8Hn9bk/aAXgOrRarQiuTMTIkSNF3AMr0iaCwZ2sF9MYdGOwjw4DPJlVQqtE/H58+umnYh+4L5L2Rd6lJY3mgp9zzjni/9POvxgHTjoP2UmmOPHgg9ZfJsRDlKWpC2wo27gIGlUYB6Q7MNJYJqbJ7tyJwvKQSDywxoOoUZBpxcAsuxQPDcAUTLp1WH4602YUs/TcZFO7FtWiGZnpnaw7wGqVvOE3ViPCTsFDN4YuG9Gs4QhDDXPUWe3G0GngC0alG2MHYIxAIBDAYYcdJsqOM06F1iEKC8apME4hBmMe2FKesQPMwKAQZCBlIg4++GDh4mARMWZ40M1AocisDgYzkrvvvlukjvIvrR1Lly6tZSngoM99YjZIQ1kTJ554osgQoeWBjdzi+68wy4RBmxQXvDfRbcHAUYqWpogTScsi79SSeuEP/bjjjhOFovY58FCccdUdomeD0ZOP5HWfQxXyQucrQ9iYjojagBmbjXBvXQotwjg8vQL9DC6RplnV7ziUjrkS0Gw/yIm8/201HtiOuzV99pLWg4MTRQRnvRywrrvuukZdM+lWA9yhMEIDjkRQZRSdWJUt/0DrrxBBoExllTSPAQMGiAGdbiRmJjD9kQGOHIj//PNPEcwY4/rrrxfLMijxgQcewJNPPimERyJotfjmm2+w7777isGawYoUikzNZCplfIovr4PRo0cLV0R8XAwzMCg8uE8NuVEYaElLFuMdaI2Ih2KCwodigankI0aMEI376EZRJ0gDl7QuKqWLlX1jYSOaTx0Oh8hVlux41DlvFoyA7jtwMKa+9QX65WbCSMtDjXgoQcicjbDagM/WqxApXwcjgjgsoxIZ+pBoxV0x5Cw4+xyZcBuxAWJgtm27bpCSzgnT9U466STxP2e1sdbuiWCcw8LNleimrkLSF+cg1bceTnUKPEc8i9K08QhFo9i9d2qbx8JQMDM4kCW8GTC8q8KYAmZDsPaDpGvhb+Aab84YKiWbZDuoKTnLoHhITk3Dnc+8IcSDQaRqfg5V0AOdt0iIh6DaiE/WRIR4sKt8ODqjFBmGsMjEKBlzdULxIFpxO/3QaFQY2s0uTPBSPHQNaH6Opdgxa4cFjOqDwZ6sPlmlSYOSOxoRaGBmNsam32HWa+ANyqJS7TV5YD0I1lcYNmxYe++OpAMjBYRkOzjrYOCkVqfDHU++hjHDBsPgK0bK2k9FC2m9twAhSy78KhM+WeWHUpWHdJULR6SVItkARPU2FO5+K7w5E7ZbN7MH2ErabNBgeG6S8ONLuhasLcBgPZqZmd7JQLhEMNaFNSHcoYhwYwRURmgRATbPFRk9rHlR5pFujLaGRcLonqBroG6qp0QSjxQQklrQf8kgKHLlnY/i4AP3h95XgpR1FA8u6DwFCFm7wwsTPlnhgsq5Fd3VlTg0vRw2o6a6xsOEexFI337mwowB1ipgxsCwbklIsejb4QglrQ2tSaxOyZLGDHhj4F19KZCsSkmh4E0dCr+JaXgKTOyNUblGWCcq3MEW6wsiaRoUDmy8xZgIiaQhpICQ1MAa9Geeeab4/9jTL8A5554Hnb8cyWs/gzrghN5dgJCtB1yKGZ8ur4LGU4S+2lLsn1YJs0GHoK0H8ve6HyF7j3oLRLFOAUtT25vYSlrSOaFflfEQDLBjND5dYonCrSgmWWGzSpWMSO7uNUWlVNvcGAywldkYEknHRAoISU3gzLHHHSfSp0aMm4A7738YukCl6G2h8VdC79qCoL0nqhQzPl9WDq2vFEO1hdgn1QWjwQB/yiAU7nkvoqb0hAWiilx+USCKVRU7UoliSevB3gfM2WetCJY7fuSRRxKmpbKaqScURmTg4QiqTCIbQ503G9qwFxq1WlghJBJJx0MKCIkoRXzaGWdg7Zo1SM/KxdMvvwWT4hUxDxpfBfSuzQjae6MiasaXS0ugDZRjjG4zxqf6oNcb4M0ciyJWl9Tbtls3uyuWuv3olWrG4Gy7rC65i8F+C6xNQFgzgKmAidwYGpUaruTB8JpyRIVNk3szDJVrhRWizBMUIlQikXQspICQ4M577sU3M2dCpzfgmdfeQVayqdry4C2BwZWHYFIflEXNmLmkCPpgJSboN2JUShhavRGu7vujeNwNCQtEsT9DuScg6juwNLVeKy+3XRHWIbj44ouFC4N5/XWDKllUymrUwqGyI9x9T+HGYDaGetNsYa3ySjeGRNIhkXf0XZxPv/gKD91/n/j/zoefxKihg5Cy5hNoPcUwODcikNQPJSEzvllaAEO4Cnvr12FIigpagwlVfY9G2ahLAbU2YXVJ3vQHZNpEhUmaqiW7Ls8++6zobcB2zJMmTYLP56t5j8XDsu0GkbYZHXgEAiqTyMbQbPwF2mh1FgY7dEokko6FvKvvwixbvQ7nn1tdpnrymefhhBNPFF01tZ5CGBzrEUjqj8KAEd8tz4c57MD++jUYkKqH2mBGxaBTUTnkLFFpsr7qkoNZXTLDItpTS3Zt2AeBqcFsA79w4UJceeWVtd5PMRug06rgThoIr7m6dLHJtQmGqnWw6LWi6FQoQRdSiUTSfkgBsYtS6nCLHH1nVSWGjRyDW+68V4gHnWsLjFXrEEjuj/ygET+uyIctUoUD9KvRK9UElcGKsuEXwtH/BObrbbfeSk8QoUgEQ3Lt6JlmkQWiJDX06NFD9ErgNfG///1PPGIwE4OZOVWKBaEe+2zLxnBDnTdH9PnwBMOyqFQX45577hElrzs7eXl54ppmO3PCjqV8TmvbjtIS62gLpIDYBXH6Q7j0ymuwYvEC2JOS8cSLryJzy7fQO/JgrFwrxMMWnxE/L89HSrQSBxjWoFuqHTAmoWT0lXD3PCjhesvcAbDJ9NDcJNE5UiJJ1JSJhcpijZFojSC0UrHPii8UhjLgMFGkjG4M7frvoVVComU5O3RKGubcc88VAw8ftPqwxTd7UDTW3Kw9BrUbbrhBdO/sauy1114oLCxstCNtDPYQYe2NnVlHeyEFxC4oHp6e9gY+fad69vfw0y9iaHAR9FXrYKxcjUByP+R5DZi9Kh8ZSjn2M6xFTloyFHMKisfdCG/OHvWWptZpVKJAFGs9SCT1ceutt+Koo44SXSPZNyM2ILHLKANtnXRjmHLZxBVm9yboHRur3RjOoKgnImmYww8/XAw+a9euFQ2zONN/7LHH0FHg/YKChl1c2YJ8ZwiFWs4q1VLr0uv1yM7O3inra0usoy2QAmIXEw/fzJmPh2+7Vjy/6MrrcXSfMAwVq4V4CCb1w0aPHr+vLkC2Uop9jeuRmZaGiDkLReNvgz99eGLx4AqI0tTDcpNEh0WJpCHYNfGdd94R7Z3Z0IfNmngd2QxaUVjKGTEi2Gu//4pK5f0mqlIyMNfp3/mZdFfHYDCIwadXr16iJTatPqwwSyorK0WZ8ZSUFJjNZhxxxBFCaMRgd012wuT7FotF9MJg6i3N9OzoSfgeBzZaO2Jp4A8//LBozMRurKNGjRJ1P+paLr799luMHTtW7N/vv/++nQuD66G1hPVDuAzfY2fXuq6Cjz76CPvtt58oVvbee+8lPAdc7qWXXhLHx31id9L4fWpoXa+99hqGDBkiXhs8eDBefPHFWutmh1F2MDUajRg3blyNFa0hSw07iNLSwHPO88eup/wueA5/++03PPPMMzWWI+5b/DpYo4fHwPMXz+effy46l7J3CWHrdnZgZWdSdl1lJ2WuqzWRAmIXEg8LNhTjtivOh9/nxfi9J+KWSWNhLFsKY+Uqkaq5zmPA3LWF6Iki7G3MQ1pqOsL27ijc4w4Ek/sl7GtR6PSLFDy6LWRpaklT4U2UN28WmWKxKd6kecOk9SrAmg8DjoBPZYIGUejWfQsNIuJ6Y4xNe0CBw7Tk9njsbMNkDj7BYPV544DFFt4UFGzvzXUfeeSRNbNvupVoGZo9e7aoIProo48KSwHjV/g9kdWrVwsLBwc9QvHw9ttvY9q0aVi+fDmuvfZaUdGWA2PdHiksJrZy5UqMHDlyu/3k+p544gk8/vjjWLJkiRhkjz322FoCJ7aeq6++Wqynvvbj5M477xQWrlhbcPb34GcaWhdFxF133YUHH3xQvMbGcFzPW2+9JZZnSfajjz4aQ4cOFc0GKYLoimkIxkYcdNBB4jM85xRPFGnsFcNjZr+RKVOmiHPKB891POyIyW2+//77tV7nvrJMPEUJvz/uPwXFnDlzhGDh90ZrVOy7bw1kScBdRDysKHDi8Xtvw8Y1K5Gano5Xbj8PltJFMFWsFEWi1rj0+GdDIfqpCjDaWIyUlAwEUvqjeOyNiJjTE/a1KHL6hMVhcI5dzBAlkuYwfvx4TJ06VQw41113nbiRDhg6AgatGg59P+hM3WD1robFlYeAczMshh4odQfQO90iUj/bEl8ogqF3zUJ7sOK+w3aoeivFAWMMZs2aJbJeOBBTOHBwoY89NghxwJoxYwYmT56MzZs3i0F3xIgR4n3O3GNwVksyMzPFLJdQbHCQZdfVWOMtfoaDJPuhcHYfg9aFQw45pN79pXC4+eabxUBPKF5++eUXPP3006I1fAzGC7Dra2PweGKtyBl3ww6jzz33XC2LQt11sQ8QRUzsNVpVVqxYIY7lnHPOEYM4LSUMADYajcJCs3XrVmHpqQ9e47RUxG83vssp3RUUAbQa1QcF0FlnnSWsDVyWVomvv/5aWCEIxTj3i9aTmNvjjTfeEN8TrRmHHnooWgNpgdhFxMPMGZ/i64/fERfXW49chxzvKpgqViBo64lVLj3+XV+MwarNGEPxkJoBX/oI4bZIJB7i+1oMzZXiQbLjcPZHUytnSTS/RgNeEQvhjOoR6HNgXDbGb7DoNXD7ZTZGY8ycOVPMPjnA0YTPbCvOlDmj1mq12GOP/+KYGIMwaNCgmpk5W7A/8MADooIoB1NaAhpi3bp1YlCjMOA2Yw9aJNavX19rWQ6i9cEBsaCgQGw3Hj6vazVoaD3x1O0kyucNrcvj8Yh9vuCCC2odC89H7Fhi1hOe2xiNdSyNWSB2BlqJaK2LuaJoDaJlgu4pQisLvwtaIGL7TcHn9/u3+x5aEnnn3wXEw+o1a/HMPdVmtgevPgPjk6uEeGBL7lVOHRZuKsUI9SYMMlYhKTUL3uyxKBl9FRSdebt1Mhe/2OlHbrIJg7JtsjS1ZKegoH399deFT5k3OlasfPyl11HsDEA14HD4VrwNi+KFbs1MaEedg4gSFUWl2tpdZtJphCWgPeC2mwNjFej/58w2NzdXiIamwhk7TeGc3X7//ffCPcEZed26HTFiXVa5fLdu3Wq9xziGeBhT0RK01Hrqrit2LK+++motkUU0Gs1OuZB2Fn6XLMBGCwgtNPxLYRj7brnvjC9JFBOSkZGB1kJaILq4eCh3ujH1pkvhdrlwyoGjcd7eOdXiwZyF5U49Fm8qwyj1Ogw2VYsHd/eJKBlzTULxwH4EDJjswb4WOVI8SFoGzpRoguXNkH9nfPgOjDo1HNa+cBt7QAUFVtcG6FxbYdJpUewKCBdaWwsduhHa49HcSHwOikzf7NmzZy3xwMBAZj/8/fffNa+xbTdjGuifj0GXxiWXXCK6qTKLgwNqbBAj9N3H4OcoFOj64DbjH3V9+Q3B2TTFDt0r8fB5/L41h7/++mu75zwH9cHOsdwHllqveyx0ZRB+nlYZzuzr205daLFoKF2V5zX+nDbkxmBQKeNMfv75Z/E8xm677SZcVHQv1d331kwFbRMBQf8VI65p9qGyYxRrfbz55ps10aixR7y5SNJ08eDyh/DRi49hxdJFGNcnGQ+dsw/MlasQNqZhuUOP5VvKMEa9Fv1NHthSc+DsfShKR10KRbv9+Q6Eq5ti9UyttjwYtFI8SFoOlrmmL53cfMN1qCrIgzOsRbDvwcKNYYy6ocmbXZONwWtb0jwGDBgg3EUM2GOMAs3eDHak5YCvx2ICGDPB7JgFCxaIGITYoMusDt6P6SIpLS0Vs16azBlEyDgWBhrSisTPMdYgFnjYVG688UYR90ARSVHDAEea/+nm2hGmT58urFtr1qwR7hiOO1dccUWDn7n33nuF1YWl1/k5BpIyluDJJ58U759++uniHPAcrlixQmSoMHajsbTlf//9F5dddpkQH6tWrRIWorKyMvE+x0aKOmZM8DXGMiRi3333FXESFA4UNPFWEr7GKq/8HhlEye+PsQ90STFGo9MKCF4MDJDiF8gLiyk+NJGVlJQ0qEZjEal8MLVI0jRcceJh3YI/8M6rL6BXkgrPX3E40oObEdXbscxhwMr8CoxVr0UfcwDWtG5w9DsW5cPOB9S6hB01y9xB9E6ziKZYOtnXQtIKcLZLXzp96rdfdSE8Xg9Ugw6HX2UW2Rja1V9Ap1YhHFFkc60dhIMhTd2M6qfvnoGWHATpXyecCTMTg6KBEfwDBw6sCf6j0OAAy4Gds/XYYMwARWYqcOCNfY4ujdisvalwsONYweuAQZycbdPnT+GzI3BfP/zwQ2EBYEwGq6A2Zs2gC4eBiDxP3AcGgXJSGzsWxhZ89dVXQliMGTNGdJil6GkInkO6gyjYGDjM8/7FF1/UWIcowOgi4b7R3UBrTiIoXE477bSarJJ4GFjJzBlanRgAyu+BsRy0lHA8bS1Uys7mCDUCVdLuu+9e09KX6oqmLfrUeCHWhV8WVfCOVjtjMA5NNg6Ho1VPXEeEomF5gVMEmemCLkw+bB/ofaV45vwJOGxEJqIaI5a6LFhb4sIY9TrkmKKwpHVH5YBJcPQ/LmFfC6aR0efcL8OKPhnWNo9+l+xacMLAGz5nYiedPQU333EvMj6bhGzvKrjVSSg99VuUIhUmgwZje6a0Sp8V3nQ5g+OgIa2fnRMOtsxQYJqjpHnXeHPG0FadSjKymrmysUhRsUG1WjxnPmx90DRGcxmFBk0y9PlIGhcPKwurxUOWzYC7b7gCirsU1x/cDYcMS4ei1mGp04QNJVXYXb0aOSYFlvSeKB96Nhz9j08oHtgQizO9/plsiiXFg6T1ycnJEZMI8unbr+KHn36Gr+9hNdkYWhaVMmqFm84VkEWlJJL2pFUFBGcRNInR3BUPnxcVFSX8DFOK6Leiiefdd98VFgvmLNfnx2EeMhVT/GNXgz5hiocqb0j0E/jwrVex8PfvMWWcCaftPxhqjQZLHUZsKqV4WINMswbmjF4oHXERXL0PS9gUy7XtBs14B9lRU9KWsMw1zdlk6u1Xw5E2Dn6VURST0q78TLjQQuGoTOeUSNqZDufMpn+IpVZZxpT+J0YC0y/EQh6JoN+N5pbYozmRv11FPKwocKDSGxJ1GdauWo4XH70L547S4ewDh8BqNgnxkF/uwDj1GqRZ9DBm9kXJ6Cvg6T4x4TppdfAGI6Idd89Uc4evxy7petCvPHzECDgqynHDvY/Baar+Xdsca6DxlVdnYzj9O12lUdI14XUh3RedXEAwKpTBIcXFxbVe5/OGqm7Fw+AeBquwSEZ9Ea701cQerAe+q1keKrdZHkKBAG6/8kKcPDCKk/fIRffcbCx3GFFU4RDZFqkWI4xZA1C827XwZe+ecJ2Mdwhua8fNdE0pHiTtAf2yH334IQwGI/6Y/Svm+7ohCpXojaHJ+xUWg0a6MSSSriwgmN/KiN/4HFi6JPi8sepdMegCYcQrfaOJYA4yAz3iH7sCnm3iocITFOJBrVLh2UfuwTj9Ohw3zIxhA/tjpVOHkioHRqk3IMlihT5nKIrG3oBAgqZYhOtifv3QHNmOW9L+MCr9zvseFP/f+8pM+IQbIwrt8k9EGnEwEoXDK90YEkmXdWEwLYeFSJgTzDKgrBnOkqHnnXeeeJ/uCloR4uulM+WFxTyY9sk8ZaZxxmqaS6rFwwqKB/d/4uGv2b/A+ftrOG6QDqOHDsB6vxnlVU6MUOfBbrVB3204isbdiGBK4pSocneAOTmiNHV2kow8l3QMrrnqSozf5wCsLPJjo7v6ukx2rIQ64IBRo0GJS7oxJJL2otVLWbPcJouOsMMZAydjLVpjgZXMeWVmRgy2OGWRDi7Ljn20YMydO3eHq5F1WcsDxUNStXhwVFZi1pMX4bThOgzpm4NidToqnU4MURfAYk2GpvsYFO12LcLWxFYc3oT1WjWG5NhlO25Jh8Ji1OHhp1/ECQfvjfcWOPHgRJUoKqXdNBuWPkeKQEq68mzG7euXSCSS1qXV60C0NV25DgRrMrBIVJk7gJwkkxAP/Ppev/EkjA/9ib4ZJhh6jYHD60dvVQnMtmSoe45HyW7XImLavikWP8vS1Ea9BkNz7EiV7bglHZAihx8vvPEePrhvCv68LAs2TRD5aXvBe+K7KKjyYVg3O7qnbF96fUeRdSAkXR1/Z6gDIWlZ8UDLQ7nnP/FA/pn+LHYLzEU3uxqG3CHwej3ooyqG2ZYCVZ+JKGE77gbEA4PRhudK8SDpuCSbdTjkyGMx/ODTsNalB6/8pKrlUIW8wnJW6gpIN4ZE0g5IAdEJ8AUjQjzQ8pBl+088VK37B4a5T6Bnkga27gMRCvnRXV0Kkz0N6H9QteXBmLzd+qKKgiKnXxTkGZqbhGSzFA+SjgubtjH9+Pwb78N3eYbqbIyIC9rNc0RvDKYde4KNNyOSQPRHYGbVjlb6lbQd+++/v6jK3JGRAqITiIcVhQ4xy6J4iFWD1HiKUfruJehhjcCW3VO8lq1ywGTLQHTg4SgZfSWielu94oGzumG5diSZpO9Y0vFJtxmgN1kw4uRb4InoRDaGd85LQlwEZFEpQd0mhHUf99xzT3vvoqSLIQVEJ7A8UDxk2/8TD4xAr/zoCqSGi2HPzIZOp0W6ygmjPQORIceibOSlCdtxM0WzyOkTszlaHmTgmaSzQKFr1mvQY49jUBhNFW6MbO9qVJUWQqeudmPs6sQ3IHz66ae3a0rIpk0SSUsiBUQHhR0wVxU5RYZEvHhQhX0wzHkU4by/kJKZBZPBiBSVB4akLISHT0L58AsTtuOOiQdmWTBVk6ZfiaSzuTHcwSgCw08TbowkXQhfTr0YFr1GFEBjnNCuDIvzxR4MgqPVIf41dpKMwR5F48aNE10c2SqA7bPjYbvpfv36iVo+bC/wzjvv1Hqf62Z1YHb15DrY/ZH9jVjwj6Z3i8Ui1sv23jFoAWEWHj/HisH83MknnyyC9eJdLOxYyc8nJydj7733rtWNuSn7xW6aJ5xwglg/O3myo2dDsNsol2MwIbMDJ02aVPMeMwb32WcfsS9paWnieOOPKS8vT2zz448/xsSJE2EymUTzSLYCZwtvnmOe9yOOOEJkI8Y499xzRaVMdgxlpWWKvUsuuUT0j6oPtm2gCGRXVJ4fNqrk+YrB83TMMceI7EW+P2zYMNFptTWRAqKDigdaHoqdtS0PiIaQuuRVVMz/DGkZaTAbdLCqfNAnZSM84nSUDz0HikZfj3jwi1LXLBJl1kvxIOmcboyIosA8+jj4VQbhxtjDuAG/fPOZ+M20aotvBmmGg+3zaIUAUbahfuKJJzBv3jzRVvr888+veY9dLK+++mrRVnvZsmW4+OKLRd2eX375pdY62MabdXwWLVqEwYMH4/TTTxfLsq4P18vA1ljL7xgUGBxs2RKbg/PChQtx2WWXiffC4bAYVNnCYMmSJUKQXHTRRTXVcJu6XxyUKUy4jiOPPFK0vq6oqEh4Hrif7LvC+kMUUdynfffdt+Z91ixiLSMuxwKILDlAccKCiPHcfffduOOOO0TtIp5PnoubbroJzzzzDObMmSOOm6UM4uH6WBuJIoCtxtm2gfteHzyXPCdsUc5jmzx5smidvnbtWvE+27BTZLCtN4svshx8vGhsDWQaZ0e0PBQ6USTEg/E/8aBEkbribXj+eBWRgBtGvQ5aVQT65G4Ijj4HVf1PBNSa7dYXjkRR7PKLzA02xuJMTiLpjPC38W9eBXQqFTI/OQbdfGtQGtRjxDQvps2YjSH9emFk9+TWSXHjQD7nCbQLE68HtM0LdGZHUwbg1Q2W5GB1wAEH4Mcff8RBBx0kXuMslQ3MfD6fOF7O+jl7feWVV2o+xwGZg+nXX38tnnNQ54BJEUH++usvUV34f//7X40Y4UDHAZ7rjVkgHnjgATFT5iyacMDmtvPz84VVgbN87iNFRF12ZL/4HgfRb7/9Vgy2deGgzX1ks0abbfuYsUQNImkx4AA9fPhwYYHgdUKrxwUXXFBz3KeddpoQCAceeKB47ZFHHhHfyapVq2osEBRRbL1ASwmZNm0abrzxRjF2UajQkkOLDd1RrJfUt29f8Tc3N7dmf9jZmhabhx56CCNHjsRJJ50kxExjyDTOLkiNeHD464gHBcnrZ0C7/FMoQTesBrUQD7rk7vDvNgVVAyYlFA+hmHhIluJB0pXcGBFU9TkWnAOm6sMYlRrAc/feiApPQMQNSRqHg02MWJuAkpIS8ZezYg7W8fA5X69vHbHCgCNGjKj1Ggeq+A7JPXv2rBEPhKKDs3nO/lNTU8XAethhhwlTPGfvjN2IsSP7RVM+B8HYsdXlkEMOQa9evcTgfNZZZ+G9996D1+uteZ+ze4oBvs/19O7dW7zOgby556LuPowaNapGPMTOhdvtTtjPiYKFbR0GDhwoBFHs8dtvv9W4VGhJoUDjOaGIoJWitZG27I4oHpLi3BYArFt+hn3Vxygr2wK7XgE9vbqUnvDvfhlcvQ5N2I47Jh66bRMP7B0gkXR2GMOzpdIHw4hjEVj5PIyKH5dOzMSpb/2AmZ9+iMGXXwyTvhWudY2u2hLQHnDbLQybFMaIuQjqmuV3ZB07u9433nhDDIS0THz00UfCmvDDDz9gwoQJO7Rfsf2obx9odaDbgVYPtlCgm4GWEsYvMO6BQoYCg+0YOPPnemh5qBuroGvCuWju+Y2HwoKNKRm7wr/xxNwUbPdA8UVrDI+FnarpprryyivRWkgLRAcRD6uLXAnFg6l4PtKWvY6qgrWwa8MI8yuzdYNvwrUNigcWieqRYsbgbLsUD5Iug31bNoZTn4VKfXeRjbFfT5X4O+2Ru7B87cbW2TB/Z3QjtMejjTviMiDyjz/+qPUan7dEOwHO3AsKCmqe0/VBcz0DImOw+zLjKNjCgIP1+++/36r7xZgFugKmTp0qZu10S/z8888oLy8XlhGKGLp7uH22WmgpFi9eXOPeiZ0LigEGmNaF54QWCFox+vfvX+sR39man2UwJl0zjBWh8GlNpAWig4iHQodvO/Ggr1yN9AXPwlm4Djb44IUeXk0qtPvdBm/uXgnXFwxHUer2o2eqGQOybNBppEaUdD03Rn6VHxX9jkf2isdhV3lx2gHD8P4vy3H79Vdirx++g0kGCu8w9MMztoCDFgdW+uo5IDFuYmehv/2cc87B448/LlwbtDZwWxwE6ZNnfMOxxx4rZvscvOlCYKBma+3XzJkzReNGBk4ye4HxILQUUNDwOWMyuE9081D83HLLLWgpgsGgiJugQKFooduBgZLxvaFi0HXBYFCeC1oVeA6Y1cE4C7pPGEfCmBdme3BZCh0Gl1L0tCbyV9aOBMJx4sHO9tlRzJ+/UATq9LQpOMQ1Hd7C1bBGHHDDgAK3FqmnT4U3e1y962O1yl5pZvTPlOJB0jVJi7kxRp6AwMrnYFQCuPnofvhk7jr8PfsnvPza67jmsovaezc7LcyEYPwBB3lmPTDQjq4FBvXtLJwxn3jiiSI7gpkRTItkGiVhPACDDNm5mbN/DtrMLGC2RWvtF90UFCF0WzBeg+mczIhgsGYsIJIih5YQiopnn322Rc4DoVWD26N4YfYEYy0aKvbFY2WMAy0LDDpNT08Xrh2eQ0ILBc8XA0IZr8Gg0aeeegqticzCaCc42K8qrBYPWTYjZs/+VfwwSoqLkayP4NmJbozvbUGaxgcXTFhTEoJ50gswDz6gXktGhTeAXqkW9M+0QivFg2QXyMbI+ugI5AY3wKlNwUP+s/D0Q/fAarNjxfJlCU3BTVq/bKbVKnBwnDFjhkj73NU599xzRYYMz0d7ILMwOjGJxANzhikeDOooHtnLg917mZCh8cINI5YX+LGm/5QGxUO5J4g+aVbhtpDiQbKrZGOU9zsOnAFZwg6cf+w+GDZ6HNwuJy66+GLZYEsiaWXkSNPO4kGlUoTlgamaalUUD0zwYP++BmRpaXkwYnFBANd/78f4yVc2KB76ZVjQL9NaK4ZCIunKbgwWlTKMmoyASg81ojAsegMPPPkCdHoDvvv22+2qFEokkpZFCoh2FA+0FCxauFBYHhj/cNtuPhw7WI8snV9YHuZvDeHST8uw2peMxQnMfsx5Z3vv/hkW9M2Q4kGy6/XG8OjSUKnvJrIwUkv+Qb8Bg3DWZdU9H+gnj68jIGl/F4Z0X1TDolLt5b5oSaSAaEfxQH797Tfx99LhAZw9SossnQ8eRY+/t0RxySfF2MrGQRqtCKyMh3X/K70BEe8gxYNkV3ZjlPY+RrgxzJFKaEtW4NyLr8Sg4aOEj5llkqUrQyJpHaSAaLMiUduLh59/+RkfvP8+JvXz4brxKmTqfPAqeszZosJF0wtREDBCbawur8qI23jxwOZBzLTom26FWooHyS7sxjDudhqCdGMoUWjmvQK7xYCr73lC5Pdzljd9+vQdWr8UHpKuitJC17YUEG1Y5yFePESiERH7cGD3IB7aV40MnR8BRYuft+px8ccFKPYCWnsGVGo1srKyMXrMmBrxwKZBFA990i1SPEh2WWq5MXQ5wo2RUjIXapUKA4YMx8VXVbsymNoW3wmxMWIVBONLGkskXYngtkqadataNhdZB6KtikTFd9UEROxDt8gWTDtSQZbei6CixawCMy79MA+VPgUaWzpULGGrKLj+huuhUWtqxMOATCt6pUnxINm1ibkxCqr8KO51NLLWvgBLuAKa8rWwWPrgpAuuxG/ff41ly5aKXH7m9zcF3lRZHyDWu4D1CWLliSWSzk40GhWCmtc1rXQ7gxQQ7dDbggS3LsUHx1SLhzA0mFlgx2Uf58PhU6DSGaE2Veffnnb66TjwgAPhCYTh9FeLh97pFnlDk0jii0rtdiaCa1+BXglBM+9lmA55DK6AGk8+Pw2HHzhRFARiJb9Y0Z3GiJUHrq8Jk0TSmWG1SzY229lxRAqIVoDZEauKnCiuRzyoHPk4quwlpOm9iECNr/KTcOmMKjhdrIuuqnZdbPti999vPyEeXIEQBmZVWx6keJBIarsxfOo0VOlzkBXcjJTCOQiqVaKFRK9BI0Tlvscee0z0CFixYkWTCszxN8ZKiJmZmQiFQm1yLBJJW8HW6YlKZjcXKSBaGLoZVhY6RTOrnATiAb4KpH5+MlKjZYhCha/yU3DJ1wE4KyrE2xprClTbGuhkZWah/9ARQjzE3BZSPEgktd0YqWY9Ch1+FHc/ApkbXq52Y1RugMXUA6XuAG674y5Rrphtj2+++Wa89NJLTV4/3Rk76yeWSLoqMoiyBaGlgOKhlOKhTswDUQIuJH98PFJDhVCgwjL9GFz0XRTuqgpAiQrhoDYn13Tfu/za6+ELRTEwyybFg0RSD+k2A8JRBbrx5yIELTRKBGUz78WqZYvg9AURVutquhJOmzYNs2fPbu9dlki6BFJAtBDuOPFQN2CSKEEP7B8dh4zgVpGzvjVtH5jPfB8nT5qMqN8tltHYM4VIoOXhvoenYrfxewrxwM6aUjxIJA27Mb7/ezm2BKwiGyO3ah4uveQSXDRlCj6e8Q0OOOAATJkyRSx/4YUX1mqjLJFIdgzpwmgBXP6QEA+VnpBwWzCNrK54sHx4ArIDeSLGoSB1AvzHvwaX24uvPnxLLHPkSafigCOOF/Ue6LaIWR6keJBIGndjLPr7d9zzwMPwj7PipkFVyDEE0MOiwdairbj+9nuRYVQwdepUfP3116JF9L333otHHnmkvXddIunUyG6cOwnTKikenL4QsuzGhOLB9OEk9AisFuKhKHk3uE78ANBocd8t1+CT995Erz79MH3W7zCaTMKS4RYBk1I8SCRNgW2Mew8ZjTJYkBoux6ozHdCpInh5TTJu+lUNrTUNaXBh46olmDlzpmgLzbiGf//9F2O21VeRSCTVyG6cbYTDG8LKAifc/jCyE4gHBFwwfHSKEA+MeShJGgnXSdXiYd5ffwjxQO6e+qwUDxLJDjJnzhzkb1wLJRRAeUhf48Y4smdQ1FGJKgoKK11iueOOOw6TJk0SooMujXA43N67L5F0WqSA2EEqPUEsK3DAEwwj02bYbrBXBRzQfXwGevpXiucV9iFw0vKg1iLg9+Pem68Wr08641yMm7C3FA8SyQ7ChllKOICozwm13owvtthEnFGOwY9uljCUkB8aSzK2FlQ31nr22WfFDGv+/Pnif4lEsmNIAbEDlLkDWF7gEMWiMkVL7tqDvdpXAe30s9DLvxwqKKiwDkTV8e9D0RrF+68+9zg2bViHjMxsXHPrPSJ7Q4oHiWTHYL0GEvU6oGg0eOlvL0KKBjpVFJeN1UIJ+qDWm2BPz65ZnmXkyZ133omNGze26/5LJJ0VKSCaSYnTL8RDOKII8VAXtacEmk/ORg/fCmFGrbL0g+OYNxE1VPuS1q5agddffFr8f8v9j0JjtNbUeZDiQSJpPhMnTkT37t2hBDzCjVES0CM/aBHvHdM7wEgkEZw8aMRuNZ+54IILsN9++4l+F5deeqlsnCWR7ABSQDQD9rRYUeCESlGJErp1UbsKoP3sfHT3r4YaChyWPnAcMQ1ha3ZNDXIGTtLvesChR2LPA4+sKU8t6zxIJDsGAyKfeeYZIR4Uvwsqgxkzt1a7MXKNfuSaw7jsogtR7gkhFImKz/C39sorr8BgMGDWrFl477332vswJJJOhxQQzbA8rCh0ivoOKRb9du9rHHnQzZiCXP9qaBCF09IbroOmIpjSr2aZj9/+HxbP/wcWqw3X3vUIXIGwLE8tkbQAJ554Ij755BNk2kxQabR44W8fwooGelUUr1+yJw4/6AARr8RsqRgDBw4ULgxyzTXXoKysrB2PQCLpfEgB0UQYpxAOK0g2by8etJXroPvyUmT71wrx4LL0hnfv2+DL+s9kWlSYj2cevU/8f+kNd8CQnCEtDxJJC4uIFYvn4dEH78eUmx5AuTpVvD44tFQI/6gCVHqr2xjHuPHGGzF8+HCUl5fjhhuq239LJJKmIQVEM0g0zutLl0L/1eXI9G+AFlG4Lb3h3/1yuHseWGu5h++4ER63CyPG7I6DTjwT/TKkeJBIWhqbyYB9J4zDhH0OQGnuwcKNYQ+WQOPcCoteixJnoMaNEWsqRFcGf4dvvfUWfvrpp/bcfYmkUyEFxE5gLPoXum+uQ1pgk7A8uC29EBp1Fhz9jqmlNn769iv88v030Gi1uPzORzEgy44+6Rao6zbakkgkO02GzYBgJALNhIsQhgYaJQzNordhNWi3c2OQPffcE5dddpn4nx07ZZlriaRpSAGxg5i2zoFm1q1IDm4V4sFr6YnI0BNROfBkQK2rWc7tcuLhu24W/0867zIctPc4KR4kklbujcHy1iFrdzg06SIbyp73bb1uDPLQQw8hNzcX69atw4MPPtgu+y2RdDakgNgBLBu+g+bHu5EcLIAGCnyWHlAGHoHKwadD0ZlrLfvc1PtRUlSA3J59cMftt6NvulWKB4mkFbEYtEgx60VxtqKsicKNYQsWQ+vOT+jGICzZ+/zzz4v/H330USxbtqx9dl4i6URIAdEcFAW21Z9CM/sR2ENF4qWgpTtU/Q5A5aBTETGm1Fp88YJ/8eFbr4n/H3riGQztkSHFg0TSRi2+Q9EoVLtXuzG0ShjqhfW7McgJJ5wgSl0zzfriiy8WadcSiaR+pIBoKoqC3LUfQvXns7CEShGBGhFrLlS990blgEkI2brXWjwUCuHem64WBWqOn3wazjzxaCkeJJI2dGMYNGpEUvrAoUmrdmNs/BYaFep1YxBaIaxWK+bOnYuXX365zfdbIulMSAHRFKJRWBdMg3XpGzAFyxGCFipbDlQ9J8DR90gEUgdv95E3Xn4O61avQHJKKqY9/4zwv0okkrbBotcgyawTbozCzDg3hmtLvW4MwoqWjIcgt956q+izIZFIEiMFRBMI//oY/PPehSlchYBKD40tG+puY+Huvi+8WeO3W379hvV49Zmp4v8nn3gCWZkZ7bDXEsmuC9MyM+1GBMJRqMedv82NEYJm0Xs1bgxHAjcGYUbGuHHjRDvja6+9ts33XSLpLEgB0QR+X7IKumAlvDBCn5QDbe4IeLN3h6vHQdsVhwiEInjgtutFx8399z8A5557Trvtt0SyK2M3amHUqhFJHQCHJrXajbGp2o3B1hfsqFtfaWzWhlCr1fjoo4/w7bfftvm+SySdASkgmkDywH1QilTo7NnQZQ6EL30UHH2OAtSaWsvRJPrppx9j/h+/igI1L788TRaKkkjaCVoa6MbwBCMozthbuDEsgWLonJuq3RiuAILhxIGSY8aMEeWtCZtteTyett15iaQTIAVEExjdOx09e/SCJqUHAimDUdX/uJrW3PHiYUN+CV6derd4fvvtt4ta+xKJpH2geGdRKX84AtXYs4UbQ6eEoF7ygUj1ZHn6+twY5N5770WPHj2wadMm3HdfdRl6iUTyH1JANAWVFqrkHnDb+6NqwPGI6qtbc8eLB85mpk+bivLSEgwaNAg331xdPEoikbRzNgbdGBnD4Yy5MfK+E24MGgfrc2MQZmO88MIL4v8nnngCS5YsacM9l0g6PlJANIWUXghbc1Dc43CEzVkJxIMfZRuWYvq7b4jXmP7FNsESiaT93Rh2E7MxIihK2/M/N4Yjr9qN4a7fjUGOOeYY0aQrEongoosuEn8lEkk1UkA0hezhcI68EF5bn1ovhyNRFDv9yLBo8ejt14uaD+eeey7222+/dttViURSJxvDZoQ/EoFqtzO3uTGCUC/7AGa9Ft5G3Bjk2Wefhc1mw99//y2CKyUSSTVSQDQRRW+p9TwSVVDs8iM32YRZH/0Py5YtRVpaGh577LF220eJRLI9DKTUs6hU1ig4NSnbikrNEm4MtUqFcnegwc9369YNDzzwQE1tiKKi6iq0EsmujhQQOwDFQ5HDh5wkE4z+cjywLcDq8ccfR3p6envvnkQiicNGN4ZRB3cwiuL0/9wY+qq1wo1R5gkiEG7YNXH55Zdj7NixsjaERBKHFBA7Ih6cfmQnGTEwy4rrr71atP+l2+Kcc2TNB4mkI7oxsuxGkY2hHnWaqCTLbAzN0o9gNmjg8YcadWOwNgRjm1gb4sMPP8T333/fZvsvkXRUpIBoBuytU+T0IctuwOAcO7756gt8/fXX0Ol0mDZN1nyQSDoqDKTUa9UI54yDS5MMFRRY836EGgo0ajXKGnFjEFogrrzyypraEJw4SCS7MlJANAMGYjGvfHC2HUGfB1dddZV4/ZZbbsHgwdv3w5BIJB3MjRGKc2MEi2EoXyVqQlS4g/CHGs+wuP/++0VMxIYNG/Dggw+2yb5LJB0VKSCaCK0L3ZNNGJJjh0mvwZ133omCggL0798ft912W3vvnkQiaQB2wqUbwxcKQzNiMoLQVvfGWPYRzHqNqFbZmBuDMBuDWRlk6tSpWLFiRRvsvUTSMZECookw5mF4tySR+jV//nzR9pe89NJLMBprV6WUSCQd042h06oR6jYebk2KcF9YN/8MtRKFRqVCmatxNwY54YQTRH2IUCgkXBlM35ZIdkWkgGgiRp1GPFhI5uKLL0Y0GsXpp5+Ogw8+uL13TSKRNMON4QkBJekThBvDFCyFsXwJbEYtyj1B+IKRJlkjn3vuOZjNZsyePRtvvvlmm+y/RNLRkAKimbC0LS0QycnJePLJJ9t7dyQSSTPcGJk2A7yhCHQjTkIQum3ZGB/DpNMI90aVr/7S1vH06tUL99xzj/j/xhtvRFlZWSvvvUSyiwoIDrq9e/cWpv499tgD//zzT4PLT58+XQQlcvkRI0bgm2++QUcgPz8fd9xxh/j/kUceQVZW7bLWEomkY5Ns0kOrUSHQbY8aN4Zl62yolAi0ajVKnE1zYxB26+T9qby8HDfddFOr7rdE0hFpdQHx0Ucf4brrrsPdd9+NBQsWYNSoUTjssMNQUlKScPm5c+fitNNOwwUXXICFCxfi+OOPF49ly5ahveENw+VyYcKECZgyZUp7745EImkmdFXYjVq4QyqUZFRnY5iDZTCVzIfNoEOVNyi6dDYFpm+zNgRdGm+88YZwZ0gkuxIqpZUjgGhx2H333WuCDhk7wBa5zKdm+mNdTjnlFHg8HsycObPmNQ7Yo0ePFrUWGsPpdCIpKUlUjLPba3fN3BloBTnqqKNEQRm6MCiEJBJJ52NTuQcrC13oUfk3uv94CfQIoaj3iXAf8hgKHD4RLN0t2dTk9V1yySVCSAwZMgSLFi2CXq9v1f2XSFqT5oyhrWqBCAaDYrCNDzRkJTc+//PPPxN+hq/XDUykxaK+5dsCr9crStnGrBBSPEgkXcGNMQFu7TY3RsEfUEWComdGidPfrMyKhx9+GJmZmVi5cqUoZy+R7Cq0qoBgYBGzFurGCvB5fQ1p+Hpzlg8EAkIxxT9aGhaPycvLE5aTWOCURCLp5G6MsBpl6RMQhQrGUAVMBX+J9t8ObwjuJroxSEpKSk1ANe8V69evb8W9l0g6Dp0+C4Pqn+aW2IODfEvDBlkmk0m4YaxWa4uvXyKRtEM2RjAC/bCjEIBeFJXSLv9UpGqzZ0aVt/GiUvEwpfuggw6C3+8X1kpZG0KyK9CqAoIDL2MGiouLa73O59nZ2Qk/w9ebszzb69JXE3ts2bIFLc31118vStcee+yxLb5uiUTS9iSbq90Y/tw9hRtDAwXm4n+gCvth1GpQ7PQjGm26CGAg5YsvvijiH2bNmoWPP/64VfdfIunyAoI/Jjag+emnn2peYxAln++5554JP8PX45cnP/zwQ73LGwwGEegR/2gN6hMwEomk88GCUnRjuKI6lGfuKdwYhlAlzFt+hc2og8MfgqsZbgwycODAmrL2jJXihEYi6cq0uguDKZyvvvoq3nrrLRFkxNKvzLI477zzxPtnn322sCLEuPrqq/Hdd9/hiSeewKpVq0TMwbx583DFFVe09q5KJJJdzI3BypPGIUfAB0O1G2PF56JrZyisoNLT9JoQMZhZRiHBmK3bb7+9VfZdItllBATTMhmZfNddd4lUTKY5USDEAiU3b96MwsLCmuX32msvvP/++3jllVdEtsMnn3yCGTNmYPjw4a29qxKJZBdzY2g0Kni77QmPLk24MUylC6AOukWDrSJnAOFItFnrpEWU/XEIXRqNFc2TSDozrV4Hoq1prToQEomka8EYh3mbKuAPRZH82x3ov/VThFRaVO37ICr7n4RSdwC79UxGmtXQ7HWfddZZePfdd8Wk6d9//4VWq22VY5BIumwdCIlEIukcboxD4YMROiUMzcqZ0KhVIpOitIkdOutCFyzTO2lxZeMtiaQrIgWERCLBru7G8GTvCbc+QxSVMlYshdpXKYIpy9wB+EONd+isCwtLPfroo+L/O++8s1WywySS9kYKCIlEsssSn43hzGJRKTV0ETfsG76ERa+BJxhGpbdpHTrrwn4+e++9twgaZ3C4RNLVkAJCIpHsssS7MUyDD4EHJuiVMFRrZonaDjq1RnTo3JFQMZbtZ/8exj98/vnn+Oqrr1rlGCSS9kIKCIlEsksTc2O4sveAx5ABFbMxKldB4y4UZa8rPIFm14SIwewxFqIjTEWnNUIi6SpIASGRSHZp/nNj6OHOnoAINNBGPUhaN0OUtg6Eo6j07JgbgzCFvXfv3iJlXfbSkXQlpICQSCS7NPFuDPPAA+FWVbsx1Ou+B5QozHotCh1+RJpR2joes9mMF154Qfz/1FNPYfHixS18BBJJ+yAFhEQi2eVJMRuEG8ORPQEeQ7ZwYxgcG2EoXwGbQQuXL4yqHQymJEceeSQmT54suhNffPHF4q9E0tmRAkIikezyxFp8uyJ6BHP3QBA6aKI+2Fd/DK2GyZ0Kyt07LiDI008/LQrz/P3333j55ZdbbN8lkvZCCgiJRLLLQzdGlt0IbygC3cCD4VJZoUcYqrw/RIdOxkkUOn3w7GAwJcnNzcVDDz0k/mf/n4KCghY8Aomk7ZECQiKRSJiNYapu8e3M2B1eSw/xms5XCkv+bFgMWhEjwTbfO8Mll1yC8ePHi3LB1157bQvtuUTSPkgBIZFIJNvcGEkmHVwRLdS99oIPemgVP8yrPqt+36BDQZVvhypTxtBoNMJ9wb8ff/wxvvnmmxY8AomkbZECQiKRSOKyMejGUPodDLc6GTolAk3RYmh85UJguAMRlOykFYINtq655hrx/2WXXSZrQ0g6LVJASCQSSVxRKZ1WBUfKcASS+yGqUkEdciJp7eeiMiXLW2+t9CEQ3rksCtaD6NmzJzZt2oR77723xfZfImlLpICQSCSSbTBlkwGT7hCg67P3ttLWQeg2zAIUBXaTDk5/CGU7mZFhtVprakM8+eSTomunRNLZkAJCIpFI4twY2XYjfKEwAn0OgkeXDi1bbFVsgL5iNdQqFUw6LbZWehGKRHdqW0cffTQmTZokakJcdNFFsjaEpNMhBYREIpHEQSuDTquG29oXkbSBCEEDTdSL5DUfi/cZaMnS1jtbF4I888wzojbEv//+ixdffLEF9l4iaTukgJBIJJI6bowkujGCUej7ToSTNSGUEDSb5kDtr4JGrYJBy1gI7w6Xt46vDfHII4+I/2+77TZs3bq1hY5CIml9pICQSCSSBEWlfOEwPL32h9/I0taAyl2KlDXTxTLJJh3K3IGdrgtBWNp6zz33hNvtxpVXXtkCRyCRtA1SQEgkEkkdks06GDUauPXZ0GQNgVMxQ82aEOu+hCrkFeWtzTotNpV7dqouBFGr1XjllVeg1WoxY8YMfP755y12HBJJayIFhEQikdTBatAixaKHKxCBqu/+cOkyRE2IiKMQ9g0za0SGwxcSroydZfjw4bjxxhvF/1dccYWoVCmRdHSkgJBIJJI6sOZDpt2AYCQCV7eJMKbkwKcyQAn7kLR6OlSRgFiG5a+3Vvjg8IZ2ept33nkn+vfvL3pksFeGRNLRkQJCIpFIEkBxYNZr4VFboek7EZXqNBiUECIVm2Dd/LNYhj0ygpEoNlV4EN3JgEqTyVTTpfOll17C3LlzW+Q4JJLWQgoIiUQiSYBJr0GaRQ+nPwxn7yNhSMpEEFpEwj4kr3wfiFZ35ky3GlDk8KPUHdjpbR544IE499xzoSiKqA0RDO58qqhE0lpIASGRSCT1kGEzIBqNImDrDkOP3VChToU+GoBStg6Wwr/EMjqNGnqNWgRU7myJa/L4448jIyMDy5cvx9SpU1vgKCSS1kEKCIlEIqmHJLMOFqMOnkAYrr5HQWtNRxQahIJepKx8B4hWCwYGXFZ4QthS4RXWg50hLS1NFJgi999/P1avXt0ixyKRtDRSQEgkEkk9sGBUls0AVyAMf/pwmHMGoUKVBF00AFXxcli3/iaWY4nrFLMOeWXeFnFlnHrqqTj88MOFC4OuDFpBJJKOhhQQEolE0gCpFr0QCOEo4Ol7BFRmWiHUCPncSFv+OlTB6nbcDLjUqlXYUOKBN1gdH7GjMMODgZQWiwWzZ8/Ga6+91kJHI5G0HFJASCQSSQOw94XNqIU7EIY3ZwIsGT1QhmQoDKIs34CUbT0yYmKjyhfEhlLPTpe57t27Nx588EHxP2tE5Ofn7/SxSCQtiRQQEolE0gCsOpltN8ATjEDRGhHoczC0llSRkeH1+5C07nNo3Vv/qx9hM4riUgVVO19gikWl9thjD1FY6vLLL9/p+AqJpCWRAkIikUgaIdVqgFGrFmWr3T0ORHJ6DpzqJESjEYSdxUhf+j9g2+DOrAybQSesEFXenUvD1Gg0wn3BMtdffPEFPv300xY6Iolk55ECQiKRSBrBbtQh3WYQpasjxhR4+xwCqy0ZfhjgC/phzv8dpqJ//1vepEM4qmBNsWun4yFY5jpWmZIWicrKyp0+HomkJZACQiKRSJpATpJR/A1FonD2OgzWjF7waewIR9XwuyqRvvwNUeI6BgtMVXqDWFPkQpARmDvB7bffjsGDB6O4uBg33HDDTh+LRNISSAEhkUgkTSDFrEeKpbqBVtSQBGffo5CSnAIPTPCHwtCWrUDK6g9rlmfmRpbNhCKnH+tKXDsVVGkwGIQrgzEWr7/+On788ccWOiqJZMeRAkIikUiagFqtQrdks+h9QTHg7r4fDJn9oOht8Cs6eD1uJK/9HKaShTWf0ahVyLAasbnCh7wyz04FQe69994ikJJMmTIFbre7RY5LItlRpICQSCSSJpJm1Yu0Tpc/JDIyHP2OR3pKCjwqEyrCOkRdxUhfMg1qf1XNZ/RatSgytaHMjfwq305t/+GHH0avXr2Ql5cn3BoSSXsiBYREIpE0EWZYdEs2Vad0Kgo82bsDWUNhMtvhhQnl/gj0FWuRvuxVQPkv7oFFpsw6LVYXu3ZKRFitVrzyyivi/+eeew5//PFHixyXRLIjSAEhkUgkzYDBkRaDBp5ABFBrUdX/BGSkpUKt1aEoYofb44Zt62zYNv1Q63PMzDBoNFhZ6NwpEXHooYfivPPOEwLmggsugN/vb4GjkkiajxQQEolE0sw239l2I5yB6hoP/rRh8OWMR26KVTTa2hq0IOwuRerKd6Fzbq71Wbo/jNqdFxFPPPEEsrOzRaOt++67b6ePSSLZEaSAkEgkkmaSaTcKa4Ko8aBSo2rASdCl9kSWVQcvDCjya6B1bkXmgqdrxUPERIRpm4hgxcodISUlRfTKIGz5PX/+/BY5LomkOUgBIZFIJM2EIiA7ySjqPJCwJQdVfY9FemoqzDoV8sNJcHj9MFauQubi56EK+7dzZ1BErCp0YVO5B9EdSPE8/vjjccoppyASieDcc88VnTslkrZECgiJRCLZAbqnmoU7w+2vrjTp7j4Rvqzd0CPFDJ0KWBLIRNBdBXPRPKQtf7NWUGVMRFgMWqwqdGJdiVsUqGouDKTMyMjAsmXL8MADD7TYsUkkTUEKCIlEItkBrAYtuieb4fAHq+s7qHXClaFN7o5cm5attTDPmwnFUwbblp+QvG5GTb+M+HWkWgwixZMuDfbaaA4UDy+++KL4/6GHHsKCBQta9BglkoaQAkIikUh2kG4pJliNOji3WSFCth5w9D0K6SnJyDQpqFKMWOG1Q+0pRfLaT2Ep2D7t0qjTiA6eBZU+LC9wiBoTzWHSpEmYPHmycGUwO0O6MiRthRQQEolEsoNw8O+VaoInEEJ0m3WBFSp9maPRN8WANF0EG8Np2OTVQestQfqy12Au/DthfYnsJBPK3UEs3upAsdPfrKqVzz//PNLT07FkyRJhiZBI2gIpICQSiWQnyLKbkGTWo8pbbTlQNAZUDjgJ4dR+GJkahVUdxIJADkp9UWi9pchYMg3mon+2Ww/LXuckmRCNKFi61YH1pU2Pi8jMzMQLL7wg/n/wwQexcOF/5bQlktZCCgiJRCLZCViquleaGb5QuKZhVsjeC45+x0GTlI3RqSGYEMRPnl7CPaH1lSNj8TSYiuclXF+KRQ+bUSsCK1cUOOEONK0dON0YJ510EsLhMM455xwEAv91BpVIWgMpICQSiWQnybAaRBxDmfu/QduTvQdcPQ6AzZaEYUlhISJmOnvDGwhC4y9H5uKXYCpOXL+Bpa+zbEYUOfxYtKUKBVW+RlM92amTAZV0ZSxduhT33ntvix+nRBKPFBASiUSyk2g1avROt0CjRnVxKaJSwdHnKHiyxiE3SY9+1gg00Qi+cPSEP0gRUYHMxS/CsnX2dtkZsXXmJpuEcFia78CqIud/627AlfHyyy+L/x999FH8/ff28RYSSUshBYREIpG0AKkWPXqkmlHp/S+gUtGaRGqnP2UQBidH0NMahSoKzKzqhWAwBI2/EunLXkfS+i+AaOIUzhSzHukWAzZXeLFoc5WwSjRkjTjxxBNxxhlnIBqN4uyzz4bXu2PVLiWSxpACQiKRSFoICohUi05kU8QIW7Lh6H88gsn9MC7ZjWxTFOFIFDOresKvaKAOuZGy9hOkrnp3u4qV8XEWuUkmhBhgmV+FFYXOBtM9WWAqNzcXa9askW2/Ja2GFBASiUTSQhi0GvRJtwoLRHxRKF/6SDh7HYqwvSf2TnEizRCFLxTF12U58MMAVSQAe953SF/6CjR1emfExzjQypFqNiC/0oeFm6uwudyTMFODvTJee+018f/TTz+NX3/9tRWPWrKrIgWERCKRtCDp1mpXRrkn8F8tB5VK1Idwd98fUVsO9kt3IUmvwBWM4IviDHhUFlHq2lrwBzIWPg1D1bp61y+sEckmaFQqYYlYsrVKBG/WrRtxxBFH4MILLxT/s1eG0+ls3QOX7HJIASGRSCQtCC0FTOtMNulR4YmrCqlSw9HnCHhy94LKnIZDMp1IMarhCUXxRWEKHKokKGo9TOXLkbHwOVi3/FpvXESsl0a23STqTzA2gqWwnXXcGk8++ST69OmDTZs24eqrr27Nw5bsgkgBIZFIJK1QobJvhgXhqFI7c0KtRVW/4+DJ2h0aow2HZVYhw6QS7o4v8y0oVWcgbEiFzlMgYiJSVr8PddBV73ZYfIrpo8lmHbZU+LBgUyXWl7hr3Cc2mw1vv/22EDVvvvkmPv/887Y4fMkughQQEolE0gpk2Azonc6sjKAImoyhaI2oGngSvFm7QWsw4/DMCmRbVAiFo/hmE5CvpCJo7QF10I2kvFnIWPwijOUrEqZ6xsde0K3Bv2tLXJi3qVLERwTCEeyzzz64+eabxXIXXXQRioqK2uT4JV0fKSAkEomk1VwZFlGeuqROjEJUb0flwFPhzdwNKr0Fh6ZXoLtNDX9EhR83+LDGbUQgqR8UtQ7mkgVIW/4GkjZ8BVWo4ZRMdvdktgYUiPiIhZuqkF/lwx133Y1Ro0ahrKxMxEU0p8+GRFIfUkBIJBJJK8EmWf0yrWJgZ32IeCLGZFQMOkVYImCw4eC0MgxJU8OjGPDXVi/mFUfhSx6IoLUb9M5NSNowE+nL/gdD5ZoGrREULkkmnRAuwUgUy/KrsLTQgydefA16vR5ff/01Xn311TY4eklXp1UFREVFhShoYrfbkZycjAsuuABut7vBz+y///7iBxD/uOSSS1pzNyUSiaTVoHgYkGkV6ZZ1K0lGDcmoHHgKvJljoRiSMNFWhIm5KrijRqwq9eLXdQ64zT3gSx8hUj0thX8hdeW7ovCUOuBocLtqlUoUocqymRAMRRFO6oZLbrhDvHfttdeKGhESSYcVEBQPy5cvxw8//ICZM2di9uzZwgfXGFOmTEFhYWHNY+rUqa25mxKJRNJm8RB16zZEDUmoHDRZuDPC5kyM1m3GMX2BgMqEfGcAPyzLR1nEBG/WWITMmTBWroZ9849IX/56dVfPBjI1YoGWbNDFjI0TzroIo/bYR1SnnHTyqXC4fa185JKuTKsJiJUrV+K7774TxUz22GMPEcjD6mgffvghCgoKGvys2WxGdnZ2zYMWDIlEIums0JLaO82CbslmlDj9NV07a8VEDDoFvswxCNp7o190Eyb1U0R8RLFfjR+X52NjiQO+jJHwpo2AKuyDuXg+kjZ8LbI19I68RveBFok0qxFTn3sZtqRkLF28EJddd7PI2mioqqVE0uYC4s8//xRui3HjxtW8dvDBB0OtVjfa4OW9994THeWGDx+OW2+9tcFa7mxZywIp8Q+JRCLpaLA51oAsKzLsBhS7/NsFMkZ1FlQOPBne7N1F74zM4Bac1teH7slGlIat+HtjORasXA+vrTe8WeNFpoahai0sRf8iZc3HSF77GTS+skb3IyenG+597Fnx/wevPY9PZs7C/E2VWFHoEHUrGuv6KZG0uoBgqhA7w8Wj1WqRmpraYBrR6aefjnfffRe//PKLEA/vvPMOzjzzzHqXf/jhh5GUlFTz6NGjR4seh0QikbRkfYiBWTYkGXUojWv9HUPR6EWdCHe3feBPGwZLoBTHZFVi3+5qFEVTsa7UjV/nLUaFLwJP9jh4M0ZDUWlgKlsiLBJpK96BbfOPUIc8De7HwUccixNPO1uImCdvvwpBjxNbt9WRWLy1umFXohLZEkk8KqWZ+Ty33HKLaBPbmPvis88+w1tvvYXVq1fXeo+ign3qL7300iZt7+eff8ZBBx2EdevWoV+/fgktEHzEoAWCIsLhcEjXh0Qi6ZBwps+mWGqokGzWb7+AosBc/C9sW3+rLmsdDWGzuic+y9NCE3LBrg5iVI9U9Bo0GnpfKbSeIuhdm6BSogja+yCit8GXMQqe7N1FR9BEeL0enHLEfti0YR0OPvJYPDHtLVH4ipUtQ9GoEDk5yUakWQ0iEFSya+B0OsVkvCljaLOviuuvv17UVW+Ivn37itiFkpKSWq+Hw2GRmcH3mgrjJ0h9AsJgMIiHRCKRdBbYFIuWiOUFTrj9YViNdW7FKhW82eMRNqUjaeO30Ds2oLd3LS4Y2A+zCpOwqjyC6OZyFFb9gdHDhsKYPR5RvRUafwX0zg2I6qxQR/zCMsHgTD5YwCoes9mCR597DWcedzB+/OZLfPr+W5h0xrki4JMxGu5AWJTHptUk02ZApt2IZJNOuGIkkh2yQDQVWiGGDh2KefPmYezYseK177//Hocffji2bt0qWs02hT/++EMEYC5evBgjR45sUfUkkUgk7QmrRa4udosZfn2zfHbnTNrwJQxV64U1ImTNxVJPEmbkGZCDIli1Ckb3zkD24D2h85WJmhGaQBV0vhKEDSkis4OuEbo7hJDQmWut/41pz+KpB++CwWDE+zN/xoDBQ2u97wtGRI8NBQpsRh26JZtEVoe0SnRNmjOGtpqAiHWDKy4uxrRp0xAKhXDeeeeJoMr3339fvJ+fny/cE6zVPn78eKxfv168d+SRRyItLQ1LliwR+crdu3fHb7/91qRtSgEhkUg6C7z9bq7wYk2xC3ajDmZ94kFZFQnCtvkHmEqXwuBgp041Sg098elmIyqcXuSoK0ThqBFDhkCfMwzm0sXQ+CuFRUIbdCBsSkNEz2ZdOlFTgimhUb1NrDsajeLyc07GH7/+iH4DBwsRYTLVFhmEVgkKCdayMOk0wrWRaTeIWhMsmCXpGnQYAUF3xRVXXIGvvvpKZF+cdNJJePbZZ2G1WsX7eXl5olMcAyZZQGrLli0iYHLZsmXweDwiluGEE07AHXfc0WQxIAWERCLpTPAWnFfmwdoSt6ggWZ+IYFyEqXQxrFt/g961GTpvMXz2vpjvsOHLzVr0UQpg1kQwsmcacofvB5VGB0vxv1CFA9AEKoVLgyKC2R7sDMpMD1bBDJuzUF5WipMPm4jSkiIRXHnP1OosjfqgiHD6w2LfbQYdspMMSLUYYDdpRcqqpPPSYQREeyAFhEQi6WzwNryh1IN1JS6kmA0w6TX1Lqv1lsKe941wVdClETGkoEyXjU82W1FW5UQPdSnSLAaMHNAbpgH7Q+8thKl0iSg4pQk6ACUKRWtGdFtMRNDWQ7g25izbjItOP1Hsy6PP/w9HHHdSo/sdi5VwB0LQadUiRiI7yST+WqSLo1MiBYQUEBKJpJPB+gsbytxCSNCd0eAAHA2JDA1zyUJhjVAHnPAn9cNihxkfbzKjV3QLrCof+mdYMWDYWERzx8JcvhzGylXCkqFmUy6VGgofmuoskIghCe9+vxD3PPcu1EYbPvrmN/Ts07fJ+x8MR0VBqkAkCqNWLVwcDMikVYWBmJLOgRQQUkBIJJJOKiI2V1S7M6x63fbZGXXQV60XZa11nkLoHesRMaTCYczFzKIULCr0YKhqC4w6YET3NOQM2xfhpN4wl8yHwbFBfF4VDUFRU0Cw5oNKxEN89vGH+H5hHqpsA/HE+z/BYEqcBtqYi8PlDyOiKLDoNUi3GoSgSDbrZLxEB0cKCCkgJBJJJ4W35K2VXqwucouZO2fwDcGy1rYtv8JUvqzGGhFI6oOtITve3pQMjbsA3VVlwqoxok8uUoYeiJApA5aif2qEBAVERGflgABvVQk+efcN+Hw+5A7dAwdOuV/ES9RNA20KUa4vEIE7GBINRJm5QasE01jtJikmOiJSQEgBIZFIOjkFVT6sLnJCo1KLtMnGYDyEbfNP0HqLhTCIas3wW3tgnjMZH+WZ0De8HikqF7LtRgzt3xfGAfshorPDWvQX9I6N1StRFISNqVi3fgN+/PgVaFTAQYcfjQHDRiOQMhC+tGEIWbuJOhXNhfESHsZLBMNQqwCLXluTxSHFRMdBCggpICQSSReg2OnH6iIXQuGomLk3luGgCvthLfhdBE3SrcFH0JILryET31Vk4ue8AEZiHUyqAHqnWjCgXz9o++8vxIa5eB6MVWuFiCA//jEfX349CznJBlx8wTlITUsXr0cMyUJI+NOGiCZgO0Is+NJTR0ywKictLlJMtB9SQEgBIZFIugiVniBWF7vg8IaQZTeK9tyNwdLWti0/Qe/cAr0zD+qwD0F7L1Ro0vBhYTZWFlRijGo9DOow+qVbMKD/IKD3PiLN01wyD6aKlVAiYcz8/CMsXrURPlMObrrjXtj9+aImhUClQtDaHf7UIQikDICiMeyUmGDcBPUR01jTrXphdaHbRQZgti1SQEgBIZFIuhAcYNcUuVDi8iPTZmzaDF2JwlS2VFgkmPpJIcGAyYCtJwqRjncKslFUVIBRqg0wqCMiY6Nf335Q9fp/e2cCHmV5rv979slMJpksZGUPCTtSoFJFKyrV/9FDte2pVFutPVi14jlW6o6KVRGrtIdeFql1w9NWPZZKpUJRK9iKIloBRbZAyL7vs+/f/3qemQkzJGAmmQRInt91fdcs+Sbz5SXkvedZ7mce/KY8pLR8BlR+iD//7zNwOhwYXTIN8390P9tkG2wV0Nurj72VWguvtQiejEksVKDW9llMkJBw+YIIhkIwGbTINOm5ANNi1MKk14jPxAAjAkIEhCAIQwyPP4gjTQ7UdrhgTdGf2HCqhyJLc/1OmJp3Q+tshN5Rg4DByrUMFUounq/MgaulCjMiQmJ8thkTxo2DZsw58KaNQ+UHf8LWp++CRa9g3vyLMGPWXHgyiuFNn8CW2RStIMfLKIrWAI+1mAsv/ZZR3C7aF7gA0xeEyxtAQAnBoA0XlFJHB0UmqEOlN9EYITFEQIiAEARhCBIIhlDZ6kJ5ixN6rZoLEHsLWVun1r4PY/sh6Bz10LoaeFiXz1yIwxiFFyqz4W4ux1dUR2BUBzA2y4TiUQXQjzkb6978COvXLMc5o3T4r8VXo2Dk6PD1mHLgyp6BoDGDCzeNbYeg9ju63pNcL73WCfBklESKL9X9ElBUhOkJBHmgF3V0UKojPUXP0QlJdSQHERAiIARBGKLQn+xGmxeHm+zw+kP8iTyRT+I6ew1S6z7glAalITSeVk5Z+M35KFWNYyHhaCjDTPURmFUejLSmoKQwG3/esh1PvbYNOSOy8OqaR5CHFqhCgfA1aQ1wZ07l4kqyzDa2HYSh4zDUAU+8mMgo5uhEf8WEPxji6AQVYRKU2iCPCbLTJjGRqtdCLdGJPiECQgSEIAhDnE63H4cb7WhxeDEi1cgRiV6jKGyFTfURdKtz1HCEImDO466NI7pirKvORV3VUcxSlyJLZUO2WY+20n9h56dfoN1Sgkef24h011Gez6HxdnZ9axIHNLDLkz4eemcDDB2l3N1BMzmihHQmeNOL4LUWs5U21H2PHlCqwx0RE4GgAp1W1VWISe2hNKvjZNbgQjwiIERACIIwDKCw/tFmB6rbXDAbdF9qOtUNReFIAdVIkJDQO6pZDPhNuSwEqo0T8fu6fOwtq8Y0HMY4dQNCHie8dQeRZbXiov98EJ6sqTzYK6XlcxjIT0IJHauFyJjEUYmAMZu/N70X+VXERiboPKq1oFSHL21sl7V2XyFLbSrEdPuDHK0x6jVcM0HzQahuglIfCYmtYYZNBIQICEEQho/9dV2nG2XNDvgDSsIpjS4h0VkGU8NOGDrKoLfX8OAtrpFILUSTZSrWt4zGOwdbUOw/hCmqSuiCLmTrA5g7rQSG/Clwj5iBoM4CY9sBpLTuhcZr6/r29H08WVO45TOkMUbExBF+L7Xfeewy1Fr4LKPhtY6HL208Qvrw5Oa+QtsbCQmKUHgDIahVKqTo1Ug36bh+hMQEzRwR34ljiIAQASEIwjCDfCKONNvRbPfyp+0+FRVyaqMibHPdfgh6R204tWHMgN9cAFvmDLxlH4dnP6pHoaoZM9TlyFG1s7tlSa4FObkF8GZPgydzErSeVhhb97NQiNZKsHeEZUzYO8JaxIKBzK5ISNB51NURi9+cx6kOX/o4BFJG9MkB8/g2URIUFKHwh0LQqtSc3qDpoVaznmsnzAYNF2kOV2wiIERACIIw/PAGgqhscaGqzQWtWsUzJ/rqm6Bz1MHU+Am7WoaFRBt7QPjM+XBlT8O9L/8L73TmYeyEYpylqUCJqgbpeqBohBnjcyzQjChmoUBdHsbOIywmSCxEUdS6sHdE5iQWFVRUSQWdFAkxdByNO5cI6S0848ObPh7+1JH9TnVEu1qiEYpASIFGo0KK7pigoEFgwy1CYRMBIQJCEIThCf1Jb3Z4eSx4h9PHJkz9aXHUuFt5gqepcRenHsiUijZvj2EEnn/jfbz2WSc6ZvwA6dMvRIGvElPVFShUtaLAmoKiEanIy7TCl1nCKYyQJoXbSCnNERttCGmNkXbPY94Rap8DettRrqvQ26p4cmjXz6jWsoggQeFLG4eg0YpkECcoFAUalYprKNJTtOy9QWKCOj6GcsuoTQSECAhBEIY3VGBZ0eJEdbsbun5GIwiqVaCOC1NkiqfO1QSfz4f3du7B7moHGq1zMOOWtfjboU7U19VgiroSE1VVyNH5MC7bjPEjUmFKz4TXWsJCgdIa3KHRXhpXBxHSpnBkgs7r6tAI+bkug95XbyuPq6+IzufwpY+FN21s0qITUUHh8YdFhS8Y5MFmRn3YgyLDpOPCVUp5UNRiqDhkioAQASEIgsDRiCa7F+UUjXD7kGky9L+lMeRnnwdzwycwtu6Dr/EwSr/YhTZXkIspJ/7HvThsmIpNh934x6EGpHnrMVlVhQmqWhRYNOx0OSrTBI05mw2mqMZBFfTC2FEKQzt5R7iP69AYz4Kiq0ODIgOeNhhs5TxFlNIr0c4PRq3hwk9Ki5CtdjJqJ2JrKChNFC3KBBQYdGEBQQKNujxMOi1MBs0Zm/YQASECQhAEIS4aQa2eVe0uIAROa/TbBlpRoHPUIqVpFzp2voLaz/4Bkw4oGFuEERNmw5l3Njry5mF7swl/P9iEz6uaMRoNmKiqwQRNPcZYDRyZyEs3QjFmROyxizhVYeQOjSO96tAg8UGGWGyMZavoFp0gAyt6HYkJuu1vZ0f8EigsJGh9KVIRgsLrSikOC0cp9CzYKO1BIuNMMLcSASECQhAEoRutDi8qWp3cqZHaF9+IE6D22fHeCw+jc8dLmJStwdlnTYY1MwtBfRqnK2xjvoE6YzHeO9KBdw82oaGtE+NV9ShW1aBE34xxGQaMzTIj22KAwsWS49kbQlFrYLBVsn9ErFkV4TfnspCgOoiAKTccZaDohLc97GlBh706rnaC4NbUiJggr4tkpTvi0h4RUUFpDyjgOR7sR5GiZU8KMroiQWHUqU+71IcICBEQgiAIJ7SBru9wo7LNxbMl+tzyeRy0lTy27GfYvXkdLplgxNKrL8QII22gQSgqDfyp+XAUfh32wgtQatdj68FGvH+4BS63C2NUjSwmphpbUJSpx+hME7LMet7cOeqQNpZHjetcDZH6iwYWC7HOluGUBdVBjIGiM0W+EIDOWcdFmHp7JddtxL6O0h1k4e21jOHiTWob7Y/F9onWxReppfD6g9w+SlEKvSbcQkoiLtWoY0FBkQqD9tSKChEQIiAEQRBOCokHSmvUdLj5UzJt2P31PwgEArht8TV4f+vbGFOQjdfWrsR47z72eVAFPV1Fkp6s6egccwmcWdPwea0N/yhtxodlrfD5fRilauLoxFkpzZiUoWIxQfUF/P1NI8KFkikjoA76ImPFq6AK+o5dhErFdQ9h4TEmPHcjMl6cJpNGxQS97vh0BwuW1JHwpVF0YhRHK5JVP3G8/TbNMaF6CopWBJUQNFBDr1PBGJk6SvUUJCpIZNBzg5X+EAEhAkIQBOFLoT//bU4f+0Y02Tww6rQ8lIocG/uK02HHj/7jMhzctxdjxhVh3Z//hjyDG5bqrWyZTQZTUcgy21lwLmyjL4FLn4FPK9s5KvFJRRtvrjnowDhVA2aYWjDL6saojBROc6giPhJ+y0h4LSMBlR5qnw0GewW3mcb9jNTyac4PpywsI3lwGHd2cLqjs0tM6OzVcRbbUbFDnSAUnaDboCFjQARFtECTbLjp56a6ikAo7JxJttsGjQaWFLLk1nMXCEWMSFQMhCW3CAgREIIgCAltXk12D48K73D5uD4izajtcyi9qaEe133rEtTVVGPK9Jl4/rW/wpxq4YLHlKY9SKv6O3dwdNUnqDTckWEfOZ8FhVvR4V+V7dh+uJlvaUNNgQdjVE2YbGzBvAw7itKB3DRjVzFodLPnqIGiQMvioCpuvDiiwiO1gCMNFJ3gtAVFKOg17qZIhKKaC0SPr59gIy3LSD78qSQorAMmKPj9lKioCPGtPxSkxYJWo4JBExYSFK2grpZkeVOIgBABIQiCkDC0STV0ulHV7obD40e6Mdya2Bcqjh7BD791KdrbWvG18+fjNy/+H/QGQ9fX1Z42pFVt5YmgtFlHCWlNcI84C/ZRF8JNtthBNXZXd+DDshZ8Ut4Gp482UQXZsKFY14Tzsp2YabFjZJo2bhMlQUH22wFDGm100PjsXA8R2yYavhANRyV8qQURQVEARWsEQkGutWAxQYez/pgld5ygKGTvCRIkQWPmgAqK2DoW+reigzwq5ozN4M6aZCACQgSEIAhCnyGfg7oON2o73HD5gmztTC6MifLFnl1YvGgh3C4n/t/Cb2PlU89Co+n+SVnffhhplW/D3PivmIiBCgFjFly5s+AomAcfTeuEFl/UduKj8jbsPNqKVme49kGNEPLRhnOyHDgny4nJJjuyUtTdIg8BUw6COjNUUHi8OKVTYltFo1AUg9IeFKmgW05dKFSQWc+GViwqXA0sMmJh0UIihHwoUgvDHhT9GFXeG+o73Zg9RgREUhABIQiCkLxCSxISdHgCJCT03IKYCDv+uQ1Lrr8KAb8fV127GMtWrDpxaiTog6nhE1hqtiGl7SCnPKJ1DNSq6cydDXfObG7zDGkMONLkwMcVbVwzUdZ8TAiQoChJseOCXA++muFEsdEGI2IKLWMiCEGDheQEVEoQar+LIxXdzuNoRn7kyONrUdSaiKCohc5R02OEgtMl5ryIEAmLEY5uJBEREElEBIQgCEJysXv8qO/w8Nhw8jeIzoXoLVs2vo67b13MRZs/vOm/sHTZw19aX6Fxt8Nc9z5S63dAZ6+BuquLw4yAOQeu7JnwZE8Niwm9hT0uPqloZzHxWU1HxCkyjFqlYHa2gvNzvZhldWGMrhN6b2t8S2dMCiWk0XHaQxXydSus7Or0MGYiYMoLCwQSFXordJ5WTsfwwemS7q8NpGTFiJF8BI1Z/Up7iIBIIiIgBEEQBk5INHR6OCLh9oeQbgzPguhNseX6l1/Cw3ffxvdvuu1OLLljWe/eVAlB31kJU8MOmBt3Qetuhjrg4hQHFTFSmsCTWcKzM8ilMpCSA39Iwb46Gz6tbOMizJr2+LoHmrI5s9CE83L8mGn1oEDdDp27qZtZVfT9FTWlQ7QcpQhHRUJQNPGRBI6SpIzoilBQhwm7dbrqoHfUs6g4flw5v06jD4sQFiP5CJjz2D2zt4iASCIiIARBEAYWhzfAxZb1nR5Oc1DXhsWo/dL2z5dffAaPP3g33//vux/EDbcuTeh9VQEPT/M0Nf4Lxlaa6NkGjc/B5k9UL8G1C6mFx8Z+W0bxBk0dJnuqO7C7qoNv6fpjyU7VY0ahFbPyDZid5UWOqp1Np6gltKdNH0E/1CFv2HRKCYV9KNRajl6QkIgTB6Zcrr2g26DeArXfDZ2rHjpnAx/Hd3rwt9enIWAOi5Dw63NPmPoQAZFEREAIgiAMDi5fgG2xayJdG+QjQW2FJ5uz8cLaX2P1Y8v5/p0PrsC1P17Sp/fWeNphbNvPE0Kp9ZIsrKl1k1wvSUhQqoDcK0lEeNPHhsd+G6wIKsDRZgf21HTgs+oO7K+3wU9PxpCfbsSMwnRMH2nFjDwjclQdHPnQuZr5lr0sQjEFlJTuCHqg8TugCoWHbFHRpaLWQ9GmcA1FVFiQqGBBkZLD10nXS6kSnauRBQV/7x62Zbp2su/mCEvklkSFCIgkIgJCEARhcCHzoxaHD7Xt5CPhh0alQrpJxzMgeuK3q3+Bp3+5ku/f8cCjuO7GW/v+5pQmcNbB2HYAhraD0DkbOWpAB6VWAsawmKBNPGhIj9hdj2VTKUVj4Gs/WG/nuonPazpxuMmO0HG7YqE1BdML0zG1II1vs0zasGBxt4SFhbsFGncrND5bvKgIuFlUUKcHFVhSCoTek64lpDWGhYXGEEl/UAQlBwFDBhtl0dRTEhMkLHpMrbCoSEczrBh91kXIyB+LZCACQgSEIAjCoEODpNpcPi64bHF6EQgqPDyKag5i6yRo2/nNkyvw7FOr+pzO6JFQgO2tDe2HYGgvY3dKbVRMIIiAIZM3aq5fUKnDDpVpY9jyOjyQS80pGaqf2Fvbib21HTja7KR4QrcIxbSCdEwpSOPb3DQD/3xUH0GjxsPCopUFAEVKuoRFl6hwcrsq1XJQoSV1a1A04ZioCN+nmgqy76ZICkc1QgFo/C42vIqKCkrHZM77ETIKJ/R//URAiIAQBEE4ldC20un2o8nmRYPNw14SNNeB3C1j5208s/oJrPnlY3z/J0vvwc0/vTtpg6RoMzd0HIWx/SBP5qS6BdrIwzUNIU4tUN0ERQD4mrUG+FJHRUZ/j+6yraYNel9dJ/tPfFFrw9EWR7cIRaZZz9GJqflpLCpGZ5rj0jhhYdEOractLDAih8bXCQQD/HWKUmgCJCxIVLjCxZoqDQuJqKAIaYxcR8EGWaYcTn90uDwYNedyZGVlJ2XdRECIgBAEQThtTKlanV7u3CBRoYKKCy6jfhIvPL0aq1c+xPcXL1mK/777gaRPo6RP/YaOI1yASSZQ4UiAJ7yBU8JApeaNOSomCGoNJWvs8DGaHxMUoThQb8MXdTbsr6OUhwOB4xQFTdWclJeGKfkWTMpPw8RcS89W0zREy0uipj2cEqFoBd/vgMbdFo5UxIgKdtFUou2pKr5el6KD8bxbkD7l4qSslQgIERCCIAinXXqjg6MSHi68JAtmk07LYuKVF9biyYfDbZ2LrrsB9zz8ix4dK5MBfdInMWFoL4XeURMuWFQUfp4LHTW6SOumrlsRY1RQUGFmKNJqSb4Yhxvt2FdPgsKGgw12/tni3lMFjM9OxSQSFHlpmJxnwQgaCnYyoUTpCm9nWEz4OsOpGE87G1aRC6baG06B+D0OaC99BNbxs5KyPiIgREAIgiCcttCneJoCSh0ENneAh0a9s/73+OXP7+b0xzcuvwKPrX4GBmNyXRuPR+1zhCMTHaXheRzR7VAJhlMHWhOXHmj8tm6dEUFjZniwVuoobh0N6VPDz4cUVLY6uY7iYIMN++vtaHGEHTVjyTTpMTGPBIWFbyfkpJ6w6LQbigLF24lDuz9EY0MtxhZPx799Y0FSRJcICBEQgiAIpz202VJao8XuZa+GzW9swJP33opAwI+vnnMeVj/3R1jSqIBw4GEx0VkWH5mIEDBaEdRncIRCS9EAd3MPgiKD51/QlE4asBXSH9t/KOJCaQ8SFBShONri5J89FqqZGJdlZjFRkmvhtEeB1dhjlGLrtq1YtWoVmhobobFkw1t7AAVZafj1r3+Nb3/72/1aBxEQIiAEQRDOKCgVQC2gGze/hdt//AO4nA4UTZqKNS/9CQUFBYN6LV1pjo7DPDzrWN1BOPJAXRshnYlNoUhs9CgoDGmRKZ3haZ2xo7+pdZTmeBxqsLOgIGHR7upuKJVq0KIkNxXFOSQqUlGca8Hundtx1113db1fVEAonvAMj/Xr1/dLRIiAEAEhCIJwxrL9o4/xrW/+O1qamzEivxAPPbUO06adxaPFdTFdHINBuACzDEYWE1VxBlJBQxq81mIe5U0but5ZFx6s5WqKEx0E1UzQUC0WFJEuCnayjHStNDu8LCjoKG2083AwXzD+e/C57k54Gsvhb6niI+R1wVO5ByG3jaMVI0eORHl5eZ/TGSIgREAIgiCc0ZSVleGyyy5DaWkpTGYzHv6fZ3DWeQvYW8Kk05wiMeGB3lYBI6U5bJVxNtQkEMg+mwSF35TDIkLnrIXeUQstW1YHep6BYabR3wUI0KROjT6u6LSi1cXGViQoShsdqGqjGSDdadn0P3B+8W7X423btmH+/Pl9+hlFQIiAEARBOONpb2/Hd7/7Xbz77rv86fqhh1fg2ptuRbPDB7s3AH9AYX8JGujV6wLEZBHyw9BZEa6b6CyDKnCsUJKEQFhMFLHzJfk1hGdfkKCoY+fM2PMZmueRkt0VofCn5sfVURB/3bwFK59+Ebqs0dBlhw+tJQv1v78DvrqDXee9/PLLuPrqqwd8D01ssLsgCIIgDBIZGRn429/+httuuw1r167F8gfuQ9nhg1iz5mkE1XouwGy0e2Dz+OELeFlEmPVaGHXqpHtJdEOtgzejmA9Ka+gd1ZG6iTKuoTC2HeQDag37SHisRfBkTYMrby6nN8itklsyefx3HZtcaXmAVxOA3V1DtUhIsKAw56MwJwO+hiN8RNFmjUagvT7u0vLz8zEYSARCEARBOO35zW9+w0IiFAphxowZXCxYXFyMUEiBwxeALdLNQaLCEwhCo1KzmEjRa0463CvpKDSboz4iJo7ET/NUqVgIhKMTE7ggMwrZbuto7LeTxn/XssDoVkeh0mDVs69if70TtQ4Vqh0aeFNGcBGl1EAkAREQgiAIQxPK7X/ve99DU1MTLBYLXnzxRXznO9/p5jFh9wTQ5vKizemH2xcADcgkIUEOkYOa6lAUtq42dIbFBA36ioU7OiJiguohokWVBI0I11KEwtkQLs6MpD3KK8rxzjvvdJ3XAQs27mpEWYN0YfQbERCCIAhDl7q6OixatAjbt2/nxz/96U/x+OOPw2DoPs7aFwjB7vFzdIK6HEhc+IIKtCoVTAYt108MZnRC7bPD0HmUxQR7TcR0dFBbKIkJHwmKtDGcIulJjJCQOPDR2/h4y2swBDqh1puwdnsL1MZ0rF69Wnwg+oMICEEQhKGN3+/HsmXL8OSTT/JjSmn84Q9/wPTp00/4Gkp1OH3h6ES704d2l48tp8kF06jVRqITg1A7EdfRURkuwrSVxxdhqrXhKaERQRG1zY4lGApi76c70VxbhgnFk3D5ggvFibK/iIAQBEEYHmzcuBGLFy9GS0sL9Ho9VqxYgdtvv71XGylFJ2jSJkUoyCmSohOeQIjnVqTowtEJvXaQ2kRDQfaP4OhEZxkP2IqF0hve9CL40sfxiO+oIRVBduCzx2QgK7V7BKYviIAQASEIgjAsaGxsxA033IA333yTH19wwQV4/vnnUVRU1OvvQdsgRSMcngAXYbY6fXD5qE00BI1azWKCIhSxo8gHDEXhAkp9RExQDUQs1JlBQoKjE5ZRqLf7RUAkCxEQgiAIwwvaxkg0UD2E0+mE0WjE/fffjzvvvJMjE4kS7eygqATZa1PKw+UPIhAKQadW8xTRlEHq7qAZHXpbOUcn9LaqOPMq8pto0uRh1MyLkZE/NinvJwJCBIQgCMKwdK+86aab2HiKmDx5MvtHUFSiP5ArpNMbZFHR7vSiwx2AxxcWFHqNhsXEoBRkhvzQ26sjhZhHofY7OA2TOe9HyCickJS3EAEhAkIQBGFYQlvaK6+8wrUQ1O5JXHPNNXj00Ucxbty4pLyHnwVFgDdvKsbsPBWCglMdTXDUHcL42QuQZUlJyrcVASECQhAEAcPdBvvee+/FM888w48plbFkyRLu3sjKykrqe/kCxwRFhzteUNC8Dkp5kDvmQNRQSBFlEhEBIQiCIETZtWsXj7+OpjVof6DaCBITVqt1QN7TFwhxEWY0QmFzB+D2BRGkqIFKxREKo06TlGFgp1JADO4oM0EQBEEYRGbNmsXOjVu2bMFZZ53FGyMVWI4ePZqFBRlTJRu9Vg2rSY+RGSZML7Ti7HGZ+OrYTEwrTEe+1cjntLt9qOt0o8Hm4c4PEh2JUnH0CP74219x2uZUIBEIQRAEYVhAczSoPmLlypXYt29fV2rjBz/4AW6++WbMmTNnUIykAlRD4QtylKKTujxcfnj85JJJPhQqttumGoqejK0CgQDef/ctvPrSc9jx/jZ+7vW/bsa3/v3fknJtksIQASEIgiCcREhs3rwZv/jFL7ossaOOlmRMRYIiM/PYoKuBJhhSWEy4fEE2tmpjH4ogvH6yulZxuqO5tgLbNv8FG179X9TX1vDrSFyc/fUFWPHIz3Hx+ecMHQFBjmCbNm3Cnj17WOF1dMRMJDsBdCnLly/Hs88+y+fPmzePW3Bo4lpvEQEhCIIg9JYPPviA9xkaQuX1hu2kac9asGABrrjiCixcuHDQxmMfb2y1v7QM6197DW9s+DMOfvFZ19fTrJlYeNX3cfW1i6HLyB16RZQkBKhApaamhg0+eiMgSA1SaOmll17idpsHHngAe/fuxf79+9kYpDeIgBAEQRD60rXx8ssv47nnnuMPvrHMnTsXl1xyCc4991x87WtfG7Diy5aWFp44unXrVi76PHz4cNfXyJ77/AvmY+G3r8K8SxbCr9JxpwcN8Jw50jq0BESUdevWsTvYlwkIuoyCggL87Gc/wx133MHP0Q+Qm5vL34NGuPYGERCCIAhCf6D6iDfeeIOPjz/+OO5rlDaYMmUK10tMnDgRJSUlHCUfP348zGbzl9ZQBINB9qeor69n46vPP/+cPyjTbXl5edy5arUaX//613n6KI0tHzFiRLdOD4pUZJkNSZvbkcgeqsVpAi1cQ0MDh42i0A9Bym/Hjh0nFBAUcoqGnaI/vCAIgiD0lalTp/Jx33338UZP6fj3338fH374IY4cOcICY1+kCDMWSn1kZGRwhCIapaCiRzpogmhbWxuLB6rBOBHTpk3DxRdfjIsuuojFw4miHSQY9Fo9BiYW0jtOGwFB4oGgiEMs9Dj6tZ6glMfPf/7zAb8+QRAEYfhB9Q80rIsOggQACYm9e/eitLSU0wyHDh3iKLvP5+PhXnScDIos5OTkcCspjSCn4k066H6yTa5OGwFxzz33cJ3CyThw4AAmTZqEwYKcxpYuXRoXgRg1atSgvb8gCIIwfKCN/8orr+QjNgVvt9tZRFAtBR2UAqB0hlarhU6n4xoGik7k5eXx9+jNyPEhJSCoPuH6668/6TmUB+oLtKgEKbfYild6PHPmzBO+zmAw8CEIgiAIpwKVSsX1AnRQVGG4kJCAoAKO2CKOZEJdFyQiqPI0KhgomrBz50785Cc/GZD3FARBEAShbwyYlXVVVRW3wtAtVZ3SfTocDkfXOZTq2LBhQ5eCo24Nmpi2ceNGzi9dd9113JkRGyoSBEEQBOHUM2BFlA8++CD7OUT5yle+wrfU4zp//ny+T4UnlCeKQr7kTqcTN954I+eSzjvvPPYv760HhCAIgiAIg4NYWQuCIAiCwMg0TkEQBEEQBhQREIIgCIIgJIwICEEQBEEQEkYEhCAIgiAICSMCQhAEQRCEhBEBIQiCIAjCmTtMK1lEu1JlKqcgCIIgJEZ07+yNw8OQExA00ISQgVqCIAiC0Pe9lPwghpWRFM1Zr6urg8ViYXvsZBCd8FldXS3mVElC1jT5yJomF1nP5CNrevqvZ3SyKI2RoLHjwyoCQT/wyJEjB+R7R6etCclD1jT5yJomF1nP5CNrenqv55dFHqJIEaUgCIIgCAkjAkIQBEEQhIQRAdELDAYDli9fzrdCcpA1TT6ypslF1jP5yJoOrfUcckWUgiAIgiAMPBKBEARBEAQhYURACIIgCIKQMCIgBEEQBEFIGBEQgiAIgiAkjAiICGvWrMHYsWNhNBoxd+5cfPzxxyc9/09/+hMmTZrE50+fPh2bN28etGsdimv67LPP4vzzz0dGRgYfCxYs+NJ/g+FIor+nUV599VV2Zr3yyisH/BqH8np2dHRgyZIlyM/P58r3kpIS+b/fzzVdvXo1Jk6ciJSUFHZVvP322+HxeAbtek9n/vnPf2LhwoXsCkn/f//yl7986Wvee+89zJo1i38/J0yYgHXr1g3cBVIXxnDn1VdfVfR6vfLCCy8o+/btU3784x8rVqtVaWxs7PH8Dz74QNFoNMoTTzyh7N+/X7n//vsVnU6n7N27d9Cvfais6TXXXKOsWbNG2b17t3LgwAHl+uuvV9LT05WamppBv/ahsqZRysvLlcLCQuX8889XrrjiikG73qG2nl6vV5kzZ45y2WWXKdu3b+d1fe+995Q9e/YM+rUPlTX94x//qBgMBr6l9XzrrbeU/Px85fbbbx/0az8d2bx5s7Js2TLl9ddfp25JZcOGDSc9/+jRo4rJZFKWLl3Ke9NTTz3Fe9WWLVsG5PpEQCiKcvbZZytLlizpehwMBpWCggJl5cqVPZ5/1VVXKZdffnncc3PnzlVuuummAb/WobqmxxMIBBSLxaK89NJLA3iVQ39NaR3PPfdc5bnnnlN++MMfioDox3quXbtWGT9+vOLz+QbxKof2mtK5F110UdxztPnNmzdvwK/1TAO9EBB33XWXMnXq1LjnFi1apFx66aUDck3DPoXh8/nw6aefcsg8dp4GPd6xY0ePr6HnY88nLr300hOeP9zoy5oej8vlgt/vR2Zm5gBe6dBf04cffhg5OTlYvHjxIF3p0F3PjRs34pxzzuEURm5uLqZNm4bHHnsMwWBwEK98aK3pueeey6+JpjmOHj3KKaHLLrts0K57KLFjkPemITdMK1FaWlr4DwD9QYiFHh88eLDH1zQ0NPR4Pj0v9G1Nj+fuu+/mvN/x/xmGK31Z0+3bt+P555/Hnj17Bukqh/Z60ua2detWfP/73+dN7siRI7jllltY6JIb4HCnL2t6zTXX8OvOO+88ngIZCARw880347777hukqx5aNJxgb6KpnW63m+tMksmwj0AIpx+PP/44F/1t2LCBC7GExKFxvNdeey0Xp2ZnZ5/qyxkShEIhjub87ne/w+zZs7Fo0SIsW7YMv/3tb0/1pZ2xUMEfRXGefvpp7Nq1C6+//jo2bdqERx555FRfmtALhn0Egv64ajQaNDY2xj1Pj/Py8np8DT2fyPnDjb6saZRVq1axgPj73/+OGTNmDPCVDt01LSsrQ0VFBVdwx26AhFarxaFDh1BUVIThSl9+R6nzQqfT8euiTJ48mT/1Ufher9djONOXNX3ggQdY6N5www38mDranE4nbrzxRhZnlAIRes+J9iYa9Z3s6AMx7P916D89fZp499134/7Q0mPKd/YEPR97PvHOO++c8PzhRl/WlHjiiSf4k8eWLVswZ86cQbraobmm1GK8d+9eTl9Ej29+85u48MIL+T61yw1n+vI7Om/ePE5bRIUYUVpaysJiuIuHvq4p1TodLxKiAk3GNCXOoO9NA1KaeQa2HlEr0bp167j15cYbb+TWo4aGBv76tddeq9xzzz1xbZxarVZZtWoVtxwuX75c2jj7uaaPP/44t3+tX79eqa+v7zrsdvsp/CnO7DU9HunC6N96VlVVcWfQrbfeqhw6dEh58803lZycHOXRRx89hT/Fmb2m9LeT1vSVV17hFsS3335bKSoq4k43QeG/f9TaTgdt17/61a/4fmVlJX+d1pLW9Pg2zjvvvJP3JmqNlzbOQYD6ZUePHs2bGLUiffTRR11fu+CCC/iPbyyvvfaaUlJSwudT28ymTZtOwVUPnTUdM2YM/wc5/qA/MELff09jEQHR//X88MMPuWWbNklq6VyxYgW3ygp9W1O/36889NBDLBqMRqMyatQo5ZZbblHa29tP0dWfXmzbtq3Hv4vRNaRbWtPjXzNz5kxef/odffHFFwfs+mSctyAIgiAICTPsayAEQRAEQUgcERCCIAiCICSMCAhBEARBEBJGBIQgCIIgCAkjAkIQBEEQhIQRASEIgiAIQsKIgBAEQRAEIWFEQAiCIAiCkDAiIARBEARBSBgREIIgCIIgJIwICEEQBEEQEkYEhCAIgiAISJT/DxnIiUUjBLg1AAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Iteration 8) \t Best Value: 0.9844725089729858\n", - "Early stopping at epoch 6802 with loss 0.2123743140449812\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Iteration 9) \t Best Value: 0.9844725089729858\n", - "Early stopping at epoch 1684 with loss 5628.575479705238\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Iteration 10) \t Best Value: 0.9844725089729858\n", - "Early stopping at epoch 5111 with loss 0.04339227997413797\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Iteration 11) \t Best Value: 1.0413360979829451\n", - "Early stopping at epoch 9677 with loss -0.07003120007894692\n" + "Early stopping at epoch 2946 with loss 5.458685157415583\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -495,13 +319,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Iteration 12) \t Best Value: 1.0413360979829451\n", - "Early stopping at epoch 10000 with loss 0.11074134634137334\n" + "Iteration 2) \t Best Value: 1.0040176868451611\n", + "Early stopping at epoch 5318 with loss 3.4427417449798003\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -513,13 +337,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Iteration 13) \t Best Value: 1.0779572447975334\n", - "Early stopping at epoch 4994 with loss -0.022944017572688047\n" + "Iteration 3) \t Best Value: 1.0040176868451611\n", + "Early stopping at epoch 3298 with loss 2.7493056257019517\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -531,13 +355,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Iteration 14) \t Best Value: 1.0779572447975334\n", - "Early stopping at epoch 5647 with loss -0.04839443149730904\n" + "Iteration 4) \t Best Value: 1.0157966433570296\n", + "Early stopping at epoch 4937 with loss 1.7227881954940887\n" ] }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhAAAAF2CAYAAAA/RaFTAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAz8hJREFUeJzsnQV0FNcexr91zcYVCyG4Fygt1IDSAi1QCtTd3fX11d1dqL66K/UWaKFQ3F3jruu+73w33XRjkIQECfd3zp5kZ2dnZmdn5373r4pQKBSCRCKRSCQSSQtQtmRliUQikUgkEiIFhEQikUgkkhYjBYREIpFIJJIWIwWERCKRSCSSFiMFhEQikUgkkhYjBYREIpFIJJIWIwWERCKRSCSSFiMFhEQikUgkkhYjBYREIpFIJJIWIwWEZK/53//+B4VCgaysrNplxx13nHi0Fffdd5/Yh0SyL6+l8LplZWX75Jjaez+SAxuFQiGuhYMFKSAATJkyBUajETabrcl1zj77bGi1WpSXl9d+0ZEPk8mEfv364aGHHoLT6azz3gsuuABms7lZg/Dy5ctbfPzp6el1jiUpKQlHH300vv76axxM8Lzxx/PHH3/gUIGftf611NSjvYncl1qtRlxcHIYNG4brr78eGzdu7NDf6yOPPIJvvvmmQ36vhxrr1q3DjBkz0K1bN+j1enTq1Anjx4/Hiy++uL8PrcOh3t8HcCBAcTB79mwx4J533nmN3gC//fZbTJgwAfHx8bXLeVGG17fb7ViwYAHuvvturFmzBp9//vk+/QxDhgzBzTffLP4vKCjArFmzcOqpp+LVV1/FFVdcgX3Nr7/+2uL38Dzff//94v/61ov//ve/uOOOO9DR6Nu3L95///06y+68804hOO+66659fjzha5otcqqrq8W1/O677+KVV17B448/jptuuqlNv9f9QWPXEgUEB51TTjmlQ36vhwqLFi3CmDFj0LVrV1x66aVISUlBbm4uFi9ejOeffx7XXnvt/j7EDoUUEP9YIKKiovDRRx81KiAoHhwOhxAakfTq1QvnnHNO7XMO1F6vF1999RXcbrdQv/sKquzIY+HnyMzMxLPPPtukgPD7/QgGg8Ky0ta09TY5I+ajo5GcnFzneyOPPfYYEhISGizfF9S/psPHM3nyZCFQ+/Tpg0mTJuFgZl9cSwfa93qo8PDDDyM6OhrLli1DTExMnddKSkr223F1VKQLA4DBYBCz9Tlz5jR6kVFYUGBQaOwJKt6wCXh/wuPgLGjXrl3iOeMTeFxPPfUUnnvuOfTo0QM6na7WNL1582YxA6PZmsJn+PDh+O677xpsd8OGDRg7dqw4Z507dxYuG4qQ+jQWA0FRRVM2BynuIzU1VZz3HTt2iONLTEwU63G2Gjbvhv2B9f3WAwYMEDON+vBYKKb4WSKX8TP3799f7Jc398svvxyVlZXNOpdz584VLiG6qXhTmjp1KjZt2lRnnfDxbd++XbisuB5vZBdeeGEDl1Zr2LlzJ2bOnCm+H7rbjjjiCPzwww+1r9MCxuOju6E+eXl5UKlUePTRR1u1b1rdPvnkE3FN8wYdhmL5nnvuEW4Oflbun+dp3rx5tevs6Xtdu3atOF8ZGRniu+F1e9FFF9W6CpuCFhIOxpEWEX7PPO/8rFVVVbXLaTnhsfMcNXYt8X9OEGhpCR8fjykSbq89vtf6NGc/FP4PPvhg7W+YLsz//Oc/8Hg8ddbj8pNPPlm4U/h75m924MCBta4kTnT4nOed3+GqVasadb3y2jvxxBPF95uWloYHHnhAnP9IeH1wG7xPWiwWsV3O+FtyDUe6fj777DNxrfEew+MbN26c+G3tCd5L+DuvLx4IXbuRvPPOO+JexuU8j3RB02Jbn315HhsjPz9f/CZ43+Jx8vO9/fbbDdaji4av8dzGxsaKY+XY1a6wnbckFPr111/5TYZefPHFOsvLy8tDGo0mdN5559VZznUvvvjiUGlpqXhkZWWFPvzww1BUVFTo3HPPrbPu+eefHzKZTLvd/zvvvCO2uWzZshYfe7du3UInnXRSnWVerzeUnJwcSklJEc937doltt+vX79QRkZG6LHHHgs9++yzoezs7ND69etD0dHR4rXHH3889NJLL4WOOeaYkEKhCH311Ve12ywsLAwlJiaGYmNjQ/fdd1/oySefDPXs2TM0aNAgsW3uI8yxxx4rHmH8fn9o3LhxYr0zzjhD7OPRRx8NjR07NvTNN9+E7HZ76NVXXxWvT5s2LfT++++Lx5o1a8T77733XvFamAceeCCkVCrFMUXy559/ivU+//zz2mWXXHJJSK1Why699NLQa6+9Frr99tvF9zFixAhxnnbHb7/9Jt7bq1ev0BNPPBG6//77QwkJCeIcRH7e8PENHTo0dOqpp4ZeeeUVsV8uu+2221r0ffbv37/OuSsqKhLfJa+tu+66K/TMM8+EBg8eLD5/5Pdz9tlni/V4riPhcfO75He9O3isV199dZOv8/vjPqurq8VzXvepqamhm266SXx33E/v3r3F72XVqlVinT19r0899VTo6KOPFt/n66+/Hrr++utDBoMhdPjhh4eCweBuj3fKlCmhYcOG1T7nPrkfHuP3339fu5y/jeHDh9c+r38t8Xh0Op04jvDxLVq0qN2/10hash/eT7h8xowZoZdfflncm/j8lFNOaXBf4PfB74i/V/7eO3XqFDKbzaEPPvgg1LVrV3Ef4IO//8zMzFAgEKizH71eL37jvKfxN3vyySeLfd19990N7p28Png8fFxzzTWhmTNntvganjdvXu154HfLY+axG41GcU3siRNOOEHsY926dXtcl7//Cy64QOyD932+l/vm59wf55FwGa+FyPPWuXPnUJcuXcRvhL8lXvdcj8cRhr+d8DUxa9as0PPPPy/Gp+uuuy7UnkgB8Q+86fICOfLII+ss54DDL+aXX36ps5zLGnvwR+x2u/e5gODFHxYzvDlzkOb2rr322joCwmKxhEpKSuq8nz/8gQMH1jlu3rxHjRolLvowN9xwg9jGkiVLapdxW/zR7ElAvP3222Id3jjqEx4oeOz1f0BN3fS3bNnSqOC76qqrxA/b6XSK5wsWLBDrUdxF8vPPPze6vD5DhgwJJSUlCSEZhueXN75IURk+vosuuqjO+zloxsfHh/ZmoAmfd36WMDabLdS9e/dQenp67c2K1yjX++mnn+psjwKvqYGrJQKCgzvXCQ/+/M14PJ4661RWVoqBIvI87O57DX9PkXz88cdi/fnz5+/2eClgVSpVyGq1iucvvPCC+C1woKFIJDw3MTExoRtvvLHJa4nw98nfaX3a83ttzX5Wr14t1qO4iOSWW24Ry+fOnVu7jOeCy8JiKPIaoUiLFJQcdLicA3h9oRK+h4R/qxRkWq1WfK/h64L3lfrCNZLmXsNhAdG3b9861xYHRC7fkzCgmOE1wQfv5RRf/MyNTRQau/ZOPPFEMcGKZF+dR1L/d0IRwHGprKwsFAnv77zvhj/D1KlTxfW1r5EujH+g2fOMM87A33//XScdkSYgmo5oQqsPTdm//fabeDBOgkFSP//8M84666xmmabaOmiRpmI+Bg8eLII4zz33XGG+jWT69Om1JmVSUVEhTPSnnXaayEJhGhkfNCHT3LZt2zZhQiM//vijMDsefvjhte/nturHhjTGl19+KUzOjQUxtSYSnW4QBo5++umntcsCgQC++OIL4a+nmZHwPNAUzODA8Gfjg6ZGmhUjze31KSwsxOrVq4UJkmbXMIMGDRLb4/moT/14E5r0eS6tVitaC/fDc37UUUfVLuOxX3bZZeJaDbuhjj/+eGEa/fDDD2vXW79+vXATtIXfPZxJFM5W4m8mHOtC9wGvJZrXaTpduXJls7YZ/p7CLi5+N7zGyJ62wXPL75yBc4RBzFzGB/8Pf366Bbhsb2iP77U1+wlfc/WDWcMB1PVdAjTLH3nkkbXPR44cKf7SdM9Aw/rLaWavzzXXXFPnt8rndF/9/vvvYhndBXQB8T64t9dwGLpuIuOowt9fY8cXCX+XvIfT3cwA4CeeeELcx+jWrO+Sjbz2GDDMa+/YY48V++DzfX0e68MxhPdN3s/4f+T9i5+Jxxj+jfA7oKuSsR/7EikgIggPhGG/Eb8Q3ogoLHizrA/9c7xp88ELlpHcjAmgT+z777/fp8fOC5c/YF6MvKHyInvvvffq/EhI9+7d6zynX5EXJ7NHwgIk/Lj33nvFOuG4kOzsbPTs2bPBvnv37t0s3yTXa8vYkNNPPx0LFy6sFTj0SfJYuTwMBRB/aPRz1v989InvLrCKn7epz8f4Ep5j3jgjibyZEPoiSXPjLZo6jqaOIfI4lUqluIaZjhj2m1NM0DdL3/PeEo4hoJ87DOMGKKi4D8ZK8LxyEKt/A24Kig7GbVCk81rl+8PX6J62cdhhhwl/b1gshAXEMcccI9KhKUjCr0UOXK2hPb7X1uyH3zW/ZwZIR8LYEQ4i4Wuhqe1RTJMuXbo0urz+5+G+GJ9SX7yT8ETrqquuEssmTpwo7on013Mi1ZpruLnnYXeMGDFC3IO57tKlS8XEjqKXcVGRQoX3Dt67w7FNvPYYS9LYtbcvzmN9SktLhfh9/fXXG9y7KLBI+P51++23C0FGkcZ79NVXXy0+X3vT8cLa9wLOShll/vHHH4sLiX85uDZnhh0mbKmYP3++UI77Cs7u+WPYE/UFRTgA8pZbbhGqtjHq36wOFCgUeHOgleGGG24QgVf8ATPdNvLzUTxEzsojibTGtAWNCU2yryxSzL558sknhYg488wzhRhmAFj4xrY3cDbPzxce4D/44ANhnWHq46233irOczhYk4KxOdDyRcHL99OixJsgvzN+h40F50ai0WiEcOZvjUK4qKhICAiKEZ/PhyVLlggBwd/03n7P++p7be5+mmu1a2p7bfl5+L3TUvfLL7/gp59+Eg8GKPJapMBsDW1xfLRgUEzwwcGagy7vFZwY8frkvZrXxjPPPCOEANenpYSZa/WvvX1xHusTPgZaD88//3w0BsV7WIht2bJFTFwp3mi5YOo1g5zDKdTtgRQQ9aBY4GycZl/efKnmeAE2F5pwI2drBzphVcyb8Z4ECAuzcEZfH164e4IR47yh88bOfTVGS10ZHMiouOnGoDmQsw4OZoxUjtwvrTKjR49uIJ72BD9vU5+PWSsUbZy9tDc8jqaOIfI4w9kpQ4cOFYKJs8GcnJw2KaDD7fz555/CjBu2QNBdxOuH5z3yuwtbrvb0vXKWxswn3uB4owvT2DXWFBQMdNPxO+b3wQGB+2M0OsUDHxRQe+JgKejE75oDC89RePZOiouLxWw18lpoC7gvmuPDs2WydevW2uyEMBx8OWHig++hVYK1aHgv5QSkJddwe0C3WtgtSVj3h1krdGtEWhd259LcF+cxEope/tbopmvO5JD3Ik6q+KBrhBluzGThJKu9SgpIF0Y9wtYG3tCoqltifQhfmIRxCAcDnD0w3ZI/9vCPq74ZLQzz/1mQhWbByNebmt3Xj72gyf+ll15qUq3THE0iU/D2BH8sPCamNXH7ke6L8AyXP0CmvTUm9na3L6aZclbMWVTkepyJM+ZkX9VD4H54zunbDUPXCU2bvPnQPxsJY194fExdpVuBpuW9gW4GWjN4HiOLIIVnX5GzLYrEyOPc3ffa2PsJj7slAoIDAd9DN0VYCHA5CzmxqFpz4h94823Jdbe/CF9z9c8RZ9HkpJNOavN9Rv5m+V3xOScBYWtr/ZRbmuvDM+NwamlLr+HWQgHQ2Ow/HDsSdqM0du3RbUHLSXvx0h7OY314jLxv0prAe87u7s31vwMKOp5T7oeTtvZCWiAamdWOGjVKBEWS3QkIKkiacQl9zhzIONhQcfMmHgm/RMZH1IfBeVTrYTgQ1vcfEvqJI33PbcnLL78sbr7MZWb1Ns4qOaPhj51xIAxGIrfddpu4KdO8zOPhTZc3AM4eaLHZHTRnMiaDwV+8kfCmzhsIZ478/AxIpYWAFz0tClTqPDecUfPRFBQIdL/wwfXrK3UGRbHmA83qFIQnnHCC+NFyBkdzJnPVI2tG1IfuAA7AnHlffPHFcLlcYkZPl8C+qlnPqol0p/E4rrvuOvE5eZ2xxgdvLrxhR8IgXn5XrKx65ZVXNmnx2d01zRsPA/fCVVVpUeMgFeke4sye1odp06aJgYvH89prr4nvMNICt7vvlfEKDHTj74OBbhQ+4dolzYHfC+NqOLtlQF4Ybjec098cAUH3Ja9FfkYGovI+EA6IO5DgxITmbP7uKHh4ffP3xOuB1rfGaqPsDZy58n7EffJ80D3BGBe6eMNuoUsuuUSITAYU0urFeAb+Rii+w1aSll7DrYVB2rwX85qkNYozcbrIeO1RqIRjB3gfCFtNeH/g9frGG2+ICVVjE6l9cR4bg8XHKIr4Ht6b+TviuWbwJK9X/h/+PIyDoaWVLjzWqaFA4e+yvcYNwT7P+zgIYB4zT83u8o7rp28ybYj5updddlmouLi4zrrhNJ7GHj169KiTxtnUIzc3t0V1IOoTTuNk6ltj7NixQ6Qlsm4E8/iZ58xc5S+++KLOemvXrhWpaMxr5joPPvhg6K233tpjGidhyhFzwJm6xX1wX8xb5r7DMFWK+d9Mb4pMaWos9S7M6NGjG01ti4R50twu066YJ860VaZ4FRQUhPbE77//LvbB9zJdbfLkyaGNGzfWWSd8fJEpWZHfa+S5aU26H88RzxVTEnnueW1G1jqoz6RJkxqknu2JyOuNaarcF/Pxmaa3YcOGBuszFe2RRx4R1x/rKHBdHhOvdy6LpKnvNS8vT6Qqcl9MS2PtAH4nTaV9NpXPXz+9mNvlMubP16exa2nz5s2i9gm/Y74WTuls7++1/jE1Zz8+n0/UIwn/jvgZ77zzzgbp403dFxpL123s/hBOP+e1xzRx1mJgii6PNbLOAe8RfJ3pzvx+WRfh8ssvb1CjpTnXcDiNM7KOS+Tx8XzsDqYwMxW2T58+Ip2bx8O6DEyhrH9f/u6770SKM4+FqaSsgRNON4883/vqPJLGrnseN/fD7zl832TqPe9pkemjvH6Z8svfIseVW2+9tbZmS3uh+OegJRJJB4IzMDYVak71PomkMRggyziXgyWe60Dlgg58HmUMhETSwaAJlubR+m40iUQiaUtkDIRE0kGgP5m532+++aaIe6BvVyKRSNoLaYGQSDoITLOk1YFCggFqDKqSSCSS9kLGQEgkEolEImkx0gIhkUgkEomkxUgBIZFIJBKJpMV0uCBKlgxl9TkWzzhYytNKJBKJRHIgwKgGNh9jQbU9FfjqcAKC4qF+hzSJRCKRSCTNJzc3V1QWPaQERLhsJz+8xWLZ34cjkUgkEslBA0vYcxLenBLYHU5AhN0WFA9SQEgkEolE0nKaEwIggyglEolEIpG0GCkgJBKJRCKRtBgpICQSiUQikbSYDhcDIZFIJG1FIBCAz+fb34chkbQpWq12jymazUEKCIlEImkkF76oqAhVVVX7+1AkkjaH4qF79+5CSOwNUkBIJBJJPcLiISkpCUajURalk3S4YouFhYXo2rXrXl3bUkBIJBJJPbdFWDzEx8fv78ORSNqcxMREISL8fj80Gk2rtyODKCUSiSSCcMwDLQ8SSUdE+4/rgmJ5b5ACQiKRSBpBui0kHRVFG13bUkBIJBKJRCJpMVJASCQSySFGeno6nnvuOXQU/vjjDzGrllkz+xYZRCmR0O8dCMLjD8Lr59+A+MuHPxiCPxBEIFiznkoJqFVKaFQKaFUqaNVK6PjQ8K8KKqU0e0v2L2wkeO+99+Lnn39GWVkZUlNTccopp+Cee+7pEEGhxx13HIYMGVJHAI0aNUpkFURHR+/XYzvUkAJCckhCkeD0BGD3+FHp9MLq9sPnD8AXCCH0zzpKhQLUAzV/a4RBMBRCMBgC9QT/crECCmjUFBRKxJg0iDFoYdarYdKqpaA4xGGQ2oIFC8TgxoH86KOPhkqlarf97dy5E0ceeSR69eqFjz/+WOT6b9iwAbfeeit++uknLF68GHFxcdgf54EWgrYoXtRUUGBKSkq7bFvSNNKFITlkcPsCKLG6sbGgGst2VWB5ViU2FlpRZvNCBQUsei1SLHqkRRvEg/8nRemRYNYhzqQVD/6fZNHXrBdjQGq0AUkWnRALoRBQWOnGuvxqLMuqEI8dJXZUO32iMJHk0OKrr74SroIxY8bgrLPOEn/5nMvbi6uvvloMpr/++iuOPfZYkec/ceJE/P7778jPz8ddd91Vu67NZsOZZ54Jk8mETp064eWXX659jdfrfffdJ96v0+mQlpaG6667rvZ1j8eDW265RbyP7x85cqRwI4T53//+h5iYGHz33Xfo16+f2Mabb74JvV7fwM1w/fXXY+zYseL/8vJycUzcLrNgBg4cKIRQmAsuuAB//vknnn/+eSFI+MjKymrUhfHll1+if//+Yt88708//XSd/XLZI488gosuuki0ruZnff3112tf93q9uOaaa4Tw43F369YNjz76aBt8Sx0HKSAkHRq6H0ptHmwutGJ5VgVW5VYhv8oNlVKJxCidEAr8S4sB3RGtiU6mdUKvUcFi0AhxwW3GGrTwB0LYXmrD8hzutxIFVS4hYiQdH4qEGTNmIC8vr85yDuJc3h4ioqKiAr/88guuuuoqGAyGOq9xdn722Wfj008/rRWzTz75JAYPHoxVq1bhjjvuEAP5b7/9Vjv4Pvvss5g1axa2bduGb775RgzmYTiw/v333/jkk0+wdu1azJw5ExMmTBDrhnE6nXj88ceFcKAVhPunqOC2Iy0TPCa+RtxuN4YNG4YffvgB69evx2WXXYZzzz0XS5cuFa9TONDCcumllwqrDh9dunRpcC5WrFiB0047DWeccQbWrVsnxNDdd98thE0kFBXDhw8X54Dn7corr8SWLVvEay+88IIQQJ999plY9uGHHwrRIfkX6cKQdEhc3gDKHR4xaFe7fMLNYNKpkWLR1Loj2hONSoloAx8aEUtBK0SptQomvQZdYg1ItuiF6JB0PDgocjBuzOrEZRSpN9xwA6ZOndqm7gwO3tx+3759G32dyysrK1FaWiqejx49WggHQpfHwoULhWgYP348cnJyhOg4/vjjRaEhzs4PP/xwsS5fe+edd8RfWiYIrRGMueByzurD9TReeeUVIVLCcED/6KOPcPHFF4vnc+bMEVaD6dOni+e0PHBbYa699lohijiIc/+McaCFhdaJ3bksnnnmGYwbN06IhvDn27hxoxBNtGKEmTRpkhAO5Pbbbxeff968eejdu7f4fD179sRRRx0lvjNaICR1kRYISYfC6vZhW7ENy7MrsKHACpc3iASTTgzYZp16n4iH+tCyQdcH3R0MsNhUaMPK7ErkVjiFuJB0LBjzUN/yEAkHeQY6cr32oLnuMs7k6z/ftGmT+J8WBZfLhYyMDDHb//rrr0XVQsIZPUUSB2Wz2Vz7oGthx44dtdvjQD9o0KA6+6Clge4GVkEknNWfdNJJwjJBuN0HH3xQWDsYq8HtUkBwMG8J/BwUSJHwOUVWZPGkyOOjSKAoKSkpEc8pNFavXi3EBN03dAtJ6iIFhKRDQCsD3RQcmHeU2qFWKJFq0Yu4BWZNHAjwBkWLRGq0HoFgCBsKqrEypxIlNreMkehA0Kzelus1l8zMTHGNhUVAfbg8NjZWlDHeE3QL0GxPCwLdIZylH3PMMcKqYLfbheWEbgIOsOEHt08XQxi+r75LcMSIEejRo4dwfVCgUJiE3ReEFgJug9YAWgK43RNPPFHEI7QH9cs483jZK4Icdthh2LVrlxA0PFa6ROh+kvyLdGFIDnqLQ36lE8XVHpGGGWPUIN6kw4EMrSAxRq2Imah0eLE2txqdYw1ITzBJt0YHgEF3bblec2GKJt0PHPRvvPHGOnEQbA7G2f55551XO6gzIyMSPo90f/D9kydPFg8GZ/bp00dYH4YOHSpm8ZypM6ukpVAw8Fg6d+4ssjJogQhDNwpdO+ecc454zsF869atIhAz0rKxpxLM/BzcViR8TqtJS9xGFosFp59+unhQPDDOg7Em+yOT5UBECgjJQRvjkF/lRF6lCx5fELFGLeLNB9fgSyERb9aJwMqscgeqXD50TzAhKUonyygfxHBQ5eDIgMnGLEv8bvl6awbfPfHSSy+JmgictT/00EN10jgZX/Dwww/XGVCfeOIJUSOCwZOff/65CF4kDDbkIM3sCsYbfPDBB0JQMA6AQoUigGKEQYgUFIyrYDwDXQKRgqAx+F4GNfJYOCgzSyIMYw6++OILLFq0SFhLGMtQXFxcR0AwkHHJkiUi+4IujsYG85tvvllYO2g94ODPgE+eG4qr5sJ9U+Tx81Ho8PzQxRF2t0ikC0NykMGYgZxyB1bkVGJ7iR16tUqkUxq0B5d4iIRWB2ZuuL0BrM2rxrZiu6hTITk44Qw3bMqvLwTDz1kEqT3qQXAAXr58uYhdoMmd7gJmMjCFlINo5GDLQZbrcoCk2OCASeFBOEi+8cYbIm6AooBpoLNnz64tRMVgSQoIboMxAhQhy5YtE8GWzXG1MCCS2RuR7gvy3//+V7gOeBwsGMUBm9uOhEGWPHcUFXTHNBYfwW0w8JKukgEDBogiWg888ECdAMo9wdROCixmaVCMULD8+OOP7VbL4mBEEepgzler1Soidaurq4X5SdIx4GVaZveKmXq53QOzTgOLXt3hZuq0RjB7hKmlmUlRImZCsm9hKiF935y9M/+/tTBVk9kYkQGVjC2geDj11FPb6Gglkra9xlsyhkoXhuSAx+n1I7vcgfxKtzD7p1gMbVLhMRAMYPWqVaLcb0JCAoYMHQqVUrXfrRH8fGV2D9bkViEzySyKVillRcuDDooE+vP3ZSVKiWRfIgWE5ICFpaILrW7sKnPA7vYj3qRtsyDDufPm4qmnnkJJcXHtsqTkZGEeHTumpire/oLiiGmnzCxZn18tPnv3RJOoLSE5uKBYoCleIumIyDuS5IC1OrDM9Pq8KoSCIaRF69tUPNx22211xANhVDmX8/W2gBaOFSuW45dffhZ/+bwl0H3B4NCdZXZsKrTKKpYSieTQsUDMnz9f5PUyX5gmPOb81g+IqQ+LjNx0000icpj+QgbVtCTwRXLwxzqU2DzYWWoXM/BEs14UYmorOIjT8iAaV/y7V5jUQIIhgHh9CMvfuw9Tu1ihCvqgDLihCHjFAwoVQko+1OL/oNqIgC665qG1wK+PQ0Afz0i5NrNwUDQlR+lRUOUWaaq9U6Jg0cu4CIlE0sEFhMPhEGVM2aykOUFDDOpgCtAVV1wh8oSZFnTJJZcI32E4OljSsTMsssocyKlwCnM9MxPaOkiSMQ8lxUWI04WQbgmgW1QQ6VFBRJn1UGrNUOiMUOqM+OuvP6HR6mraeQdDovATXQtqpUIcGx8GjQpRerUI5ozSaxCtVSGk1mF1diW+feMz6B1KKKBECIo6Fg5GdrdERLAQFotPseDUurxq9EqOEkGWEolE0mEFBLvA8dFcXnvtNREVGu6axmIgf/31l6hPLgVExy8Itb3YLgZJFoJqj4JKamcpTHnzcd0QH2JjLFCZY6EyxUJljAGUKriggzukgR8qVDqVgEukKUGBEJSigTc7apCaZQpFEIoQAztD0CAAi5oWEx3ytm/EuB46BN02OHwKbKxQYX2FGvkOJaBQ4umnnhadElsSsBkOHmUGCitY9kmxICW69RkCEolE0qGCKJmnzOYtkVA4sPGMpGO7LNi/wukNtFmGRRilzwF9+QaoSjaipCgP7spypB02BhpFCG5o4YMafoSgCnqg85ZB63FA57diYPc0xEUZoQq4EPA4EPI4RWdPXzAEbyAItrDwQAOn0ggHDLBDD29AhfwqFwIJmdAnZMIQsEFfVY4jYgowIrkKVR4FVpZqsLykUFhChg0b3uLPw8JTlU4vNhZWIxAKoVNM3a6LEolEckgKCJZbTU5OrrOMz5mXylrk9VvUhvvS8xGG60oODjggs65DVpkTWmGmb7vBUO0ogr5kFaqy1mBziRUF1U7og274oIJeAXh8PoTsxVA5KhDtL0NUyA6TKgC1IohAELBv3oFChxNuj0+IBX+I9od/HgpaBNhxE9CpFIhi/IRaCZ3eAIc6GnZdEhzGNLjUJljikxCIT4XKa4OuohTjzAUYleKCIW8hFIMHIKRuuRWBgZWMD9lUYEUgEESXOGOHq4chkUgOfA4oAdEaHn30Udx///37+zAkLYQZBawkmVfpFAOiUdsGl2IoBF31DqjzlyI/exu2FtsAjxVqBGAKKaHQmZAeHw2NqwybFv+BKPihhR92jx957gDcfiAYgrAylDicsHlCsHsBdVAFk08Bk1IJg1IBo0EPQ+9e0CfGQh90QBdyiYff40KgshIqXz6i9WvQ1WKGw5CKClMGnLpoJKTooEpJRkVpKZRZf0C9oAraXmPhTBmJkErb4gwNlUKBLcU2EZ/RLd4ka0VIJJJDV0CwbCnrnkfC56yG1Zj1gdx5550iayPSAsHsDcmBi83tE4N7qc2DpCj93tc3CAWhq9wGRc5CbN+1C1mlVkQHq8ArxqsyIDE+WfSYsGiBnJ3bUbBjPSqrHfD6/MKi4PSFkGcNotqnRkznTAwYNgpDemQgubwc8R9/Ah1jHxQAszBDAQVCPgVCa4oQ+O9VCI47ScQ18BjUrlKorLl47p7rEFNdAYPNB4smG0mGbKREW2A3dUG5KR2xiSo4EcAvCxYj+N3XSE3vhdijL0Lq0BNbZEkw69VgVd1tJXbxnM24pCVCcrDA7Lqqqip888036CgoFIpmZRt2FA4oAcF+9Kw1HgmbvNTvWx8JG7FENmORHNhUOLzYWmRDtdu39/EOoSD0FZuB7IXYlpWD3NIKxIeqEAclPLp4ZKTEoWuCBbsKq7B4/hx4CjdDBx+MWgW6RoXgVhigj06CISYR07qkIz29O5RBr4ibUPq3QrH4NygGuYQ+EBpB7LPmwSzQ0IL/IKSdD58hHn5DMnzmNPjMnTBk5m249j8PoKs5hMHxPvSN9UPn8CBWtw2dY3MQSsxErqoTohPVMCTEIS8vH5ufvRAVqgRohszExNMvQXJqWrNOQdhyQxFB7UBLhBQRh/ag/O677wrL7B133FG7nIP0tGnTZNv4NoLNwL755hvRbjwSlitgE7BDhXYVEOwbv3379jppmjzhbOjCpiu0HrBj3XvvvSdeZ/omO6Yx1Y2pn3PnzhUNUcId4iQHN0XVbmwpsoq0yFSLfq8GOo01G+pdf2Drju3ILy1HfKgSsVDDa0xFv04xiDNqsWbDBmTPXYQUrQPduatYwBEyQpvSG6kZA5CQlCyCJFWeSij9HigrN9aIA2ZHVFkR8jENQ+gU8aCI4HOFKiRiIBRKB5C/DtqoqJqDUigR0JgxQ2vBYbeNwEdz1mBZTgCLivRIM4UwLtOIYQOHIzMtHs6KAmwuD2KrMxaduqrgTUqEeutGOJe8hDs/eRGxQybi9PMuwYgjj97jeaKI4LhQIyIU6CpjIg4c2HZ6wQKOLOzfzVadLE/Zrrtkb4PHH38cl19++SE1mDUHn88HjUbTrlb0Q4l2rUQZ7vTGB6Grgf+zM1pYrUV2UmMKJ8UCrQ6sH8F0zjfffFOmcB7kcNbDWIcNhdViYKPborUDHFMxo7Z+iaL57+DPpUvhLdmG6JAVPmMKBqcnYVSiB4Vr5mHR5y/CvOs3dNI5oFGroYrvDvMR56HfRS+i18nXICZjMGj/Dyk1wmrgiekBV/wAuJIGw9blOFSph6BiowHla40oXWVC8TITipeGH2bxvGSFEZW6kbB1Pg7uuL7iGPiptI5C9DFU4P6Tu+G9i/ri+6sH4YUbZ+KS/zyF+KMvgie6O3QpfTC0ZzecmOJAQG2EWx+PXoOGImPY0Ti5tw5xWT/iunOm4NTjj8S3n38kbny7w6RTiwZjW4vtyK1wypnmgcBXX7H3NDBmDHDWWTV/+ZzL2xFmsnEgoxVidzBFnr056B6m2/e6664TtXsIJ3LsYhmGs23+ZplqH7kfFvprinXr1mHs2LFi++ziya6gnFTWhzFs7KpJVzUnkV6vt/Y1tvYeOHBg7Ta4z/AxEo4PTPenaOrTp0+ddt3snslj/vTTT0XaNNd59dVXxbZ++umnOsdAtwO7bzqdTvH89ttvR69evUQrc3Y2vfvuu2t/g2x1zmNes2aN2D4fXEb4f6RLZk/ngBYjujtYdI71jrjO1VdfXef3zs/ELqs8fiYVsAX6IWGBYA343d3Iwie9/ntWrVrVnocl2cf9LHIqHNhe4hCFlyyt7C6pCHhgLFiE8i2LsDinFNHeEsSyPoMuCiMTgtCgAsvWZqEseyu6RSsQpwNcShO0GaOQMOFmqJL6QF+1DdqSlUKE1B6fxgSvpRs80enwG1PgZyVJWiAcy4H8L/Z8YN0mA0OGC5+GylMFjT0XWmsu9JVboHEUIl5bgUSvDaHgRvi3FMNnSoUrYQA8lnQYKrfCojXj+OgC7CiuxvKqWCSalRh09FhkVlvRPWE5vli3FXffdBVee+5xXHLNzZgy/QxotI0HXJp1amFBoYhgQGXnWGOrzrWkDaBI4I2+/v0vP79m+RdfsNtWu/XfeOSRR3DWWWcJUdC5c+cG6+zYsQMTJkwQbbzffvttlJaW4pprrhEPturmgMv3cjkH9z///FM0nGOlYA7yHOCYdh/pJomEgzwnfnQ/s803i6ixKCC3H3nfZ7FADozcLgf8Cy+8UAyiDz/8sJhgnnnmmaLwGt0vNptNNCYLjyksNsjJKMUOJ6YcNy699FKYTCacf/75tfvgMXIyynW4L27jo48+qlOjiNviQE7BQCgmeJxpaWlCBHC7XEbr+Omnn47169fj559/Fm3OCbtXtvYczJs3T4gH/qXFntsfMmSI2Ccn4fwe3n//fYwaNQoVFRXi+A8UZDtvSbvB7IBdZXbsKHUgWq8Rs+TWoKvajtC2X7FmWzZC1gIY4IFCrcWAGMYzaLBkayG2b96INDPg8YegieuCzsNOROKYSxEwJsNYuhqG0jUitoHQ6uCJ7QlPTCY8lm6AshFRw4jJyZNZPrLhIEBoQUlKBmZ/VyM46hMKQe0qgb58E/Rl66C150PtKoPKWy1KXvtMnYQlggWpuJwCyVGWh78LQ7D7gkhSVCEqvjO85bl44/tl+GZ1hQi/SO3UGZffcBumzjy7ya6OVpcP7kAA/VOjZbGp/dHOm24LWhoi2ng3uHY4qO/a1ebujMjARA5c/fr1w1tvvdUgBoIDGa+fWbNm1bFIUDhw4GNcGYUDLQ6c8XLw5cD2/PPPi4F94cKFGDNmjNhXeNCN5I033hCz+NzcXDGgE8a3TZ48GQUFBWImzWOdPXu2WCe8De7v1ltvFfdvuruHDRsmhEW3bt0a7CMzMxMPPvigEBlhKIi4n0WLFon38Ttk+3S2VQ/Dc3HuueeKAH3ul2MGj4dWCIqqxqCF4JNPPhED+u5iIBQRQZTNPQcUTxR04d/zaaedBqVSKfbHlvAUVWwJTwFzoLXzls20JO0mHnaU1IiHGEPrxIPSa0PU9m9R8NcHWLhqLaJs2xCjcKBvtA+jUoCdRVa8/PlcLFmxDsFgUGQ5DJx4AUZc9xbiTvovtM4iJGx4C6aCRUI8BLVRsHc6CmUDL4U1fYIQEI2KB7FzFXDLLTX/13e3hJ/fcnPj4uGfdfzGZNi7HIeyIVejbNAVqO4xBa7EIYBSDUPFBkTl/Qlt9U4E1QaEVDoYk3tgXE8LekcHkRtKRGVZIYL6KDx6y8X48J6z0Ck1CYX5ebjv1utwxqRjsWThn43umlYejVIp4k2Y6SLZx3CG2JR4IBzEc3Nr1mtHGAfBgMpNmzY1eI3md86CzWZz7YOzZf6OOLBwIDzmmGPE4EaRsHHjRlx11VWi5s7mzZuFRWLEiBGNigfCfdINHR44yejRo8X2t2zZUruM60Rug6KHJn4Ounxt3LhxwoUxc+ZMMSBXVlaK9ShyOOhefPHFdT4DBQSXRzJ8eN2CbZMmTRJxEN999514/uWXX4qBMrKIId0ePF66grhdumoi3e3NYVMzz0H//v3rTAZojaC1gowfP16IJ7pRKHpoKQm7WQ4EpICQtJt4YBfJuFbWeNBVboFi2ZtYsHA+KvM2o3soD6laL4alaGD3a/DMl4vx4jfL4PT40a1bFxx/ylkYf8m90B1/JxTBAOI3/g/m/IVQ+D3wGxJQ3X0SyvpfBGfK4c0v3sR+FU88ASQl1V1OywOXN7efhUIJb3S6EBClFBIZk+FMHoag1gxDxSYYytZB4XdBEfRBYYhF3x7dcXynIKpUMahwBbBz6zr0z0jFwtdvwT13/wdR0dHYsnE9Lj1jKq698Axk7fw3UDkMa2twnKKIqHT861OW7AMYMNmW67USCgCKAgar14eDNIMsOYMOPygqtm3bhh49etS6kykgaDKnBYKDbFhUUEDQWtGecFBlPBzjFWhJefHFF9G7d28hcMJxBBQVkZ+BroXFixfX2U7kAE60Wq2wqtCNQfiX1hW1uuY+RdfM2WefLYTG999/L1wjd911V53YjLZEUy+ok+KNIoPQ6rBy5Up8/PHHQljQZUNRQlF3IHBApXFKOoZ4YIGorHJ7q3paKPxumHLmInvjUmTl5yMjVACdKiDaeUNjwjt/bMV783egi0WJcf1iMeqYsejWbwRsXcbBE/IjdtsXUHmqa45FFwN72ih4Ynv9k0LRCigSeKNkXE5ZGZCQADAouAV9LCIJGOKF9cOeeiRMRUthLF4BrTVLiAifuTOCWqOYocalZmCCuRgrc3zIdWmh2L4aNkcvXHF4J5z807d47o2P8Ol7b+HP33/Govlzcck1N+Hiq26ENiKlmWWvS6zMfLGhXyeL7OK5r2C2RVuutxc89thjwp/OgTeSww47TFgV6AZoCgoEthH4/PPPhZgg/Eu/P10YN998c5PvZWAjLRy0FIQHcL6HpvnIY6FoiawyzMGfM/5wLR8Oppy188HBk7NxuggYkM/4hJ07d4rBvqXwPZzds+szs/1ouQhD9wf3Q9EQJjs7u4EICdBVtRuaew72BIUNrSN83HvvvYiJiRHH3JwGle2NtEBI2lQ8sKcFxUOcseXiQWPLg3b1O1i86A/Y8jZgAHYiQR9CZkosNpQC0x7/DS/+uh3jexpw7WljcOZ5lyL1yJmwpk+EsWQ5onfOFuIhqDHD1nUcyvudD09cn9aLhzAUC+xbceKEmr+tFA+RBHXRsHUbj/L+F8De+VhxnGp3GbTV2f/ETxRDa4rByJ6dMCDGj52hZFgLtmL9pi1IK56H+66/EF/9/jeOGjMePq8Xrz7zGE6beAxWLas7+2LXTpvHJ0SE0+vf6+OWNAOmajLGoalMIy7nAMn12hma/zlYvvDCC3WW0zfPgZIBfZy50/Lw7bffiudhBg0aJNJAOUOPFBD0/dOVwUG9KbhP+tYZzEirAAMEr732WmGGj2xXwFk93RAUM4wP4ADJY+Agu2TJEhEMyrgDug8YD8CgTg7MhJkQzDThZ9u6dasIdmQA6DPPPLPH80JLCt0TPE7GAYwcObL2NWY8cH+MQaA7hNunaIkkPT29tixBWVlZnXYKLT0Hu4MWEO6f+6GIYckDWidaIkDaEykgJG0qHrIrHC0XD6EQjMXLYV38LhasWo8ujrXopKxAcowZeks8bvh4C6Y88QfM6gDun94PV195GYYcdQLsPaeKt8du+wxaWy5CSjUcqSPFoOxKZJpm++bbtwV+Uwoqe5+Byp4z4Eg5HH5jInRVO6AI+KByV0EdcCIzIxPHJvuQp0iC21qEdevXQrvte/Sz2PHyu5/hiZffRlxCInZu24LzT52Ah/5zM5yOGhNvOG22wuERBbxYQlzSztCf/fzzu4+fee65dq8HEeaBBx6oNYlHigO6ITjwMpUznF7PWf2/h6oQr/HvUUcdVfs+ujIYV1DfNRAJ4xp++eUXkTXAWAm6DBjPwIyJSLiMAzYHdLoRpkyZIgIUCfczf/584UpgSiXjEJhNEc6eYCAo0zgpGiiUaDHhjJ+CYE/wMzH4khaQ+hYMHsONN94ohAytNxRaTOOMZPr06SLgkoGkDDali6G152B30NpA4cRUUAonBplyX4ybOBCQWRiSNknV3FHKgEk7Esw66NSqlqVn7voFm9cug6NkJzIV+VBp9EiNs2B+dhCXvjwXgWAQ5w6PxZlTjkdm775wx/aB15wGc9FiKH01AUXuuN6wpx0lZvZtDX8i7JFBRAGpdirSxDiIqJw5MJauFcGVilAQXmMS1D47vObOcJTlYmmBC9qAEwa1Cpl9BkHZ/Sg4UkehuqoKzzx8N77+9AOxra7pGXj0hTcwcOiwWoFXZHWJ1M7eKVF7Xz68A7PXWRiRqZyM/o8MqKTlgeLhADA/Sw5d3G2UhSEFhGSvxcOuMge2ldhaHPOgcldAs/ErLF2/BSmuLUhENUymKBiiYvGfr3fg3Tkb0TteidtOHYqxY8dAb46BI2kEtA7WWqiJiPYb4kX8gy+qYa57c/EFgmJm7guExP8cbKkR+MOo6cBZ0wtDfN5/fi6RPxq1UiG6iXJQ5uffu/LcIVGeOyp3LrS2HGhsufCa0qDyu4R1wu2wYl1WMex+wKL2oUvPITB2P1ycAx4kMzPuvulqFBXkiSC0K264HRdfc5Pwo/KzldjcSI83oWdyVJu2Te9ItJmA2E+VKCWSPSEFRBNIAbHv4KWTXe4QhYvYHbIl2Rba6iy41nyJlVuzMCCwCVplEEkx0cjyRmP643NQUmXD1AEW3HLuBPTo1Qc+YyJ8ps4wlK+DIuivdVc4k1oek+D1B0U8gNsXRJBNsNRK6NUqGLRKmLRqGDRqaNVKMcByjFUq+FdRKyACtEgEa/5yWw5PTUdP/s9tcrlaoRBiwqhVQd2K2b7Sa4Ul+1foK7ZAV7kVAU2USP9kmW13SI2tu3JQ5FEjVulEUsYQxPY8ArauxwsRYa2qwkP/uQk/z66peDh0xBF49IXXkda5qxBKFU4vMhPNyEiUfTPaXUBIJB1YQMgsDEmrYcnkbSUOEd3fEvHAok5FK2ZjV9YODFfuBNQ6pMbF4IM1Htz01jcwa4F7TumNs6dNQJQlGu7YXlB5rTCW1lQoZeVIzrgD+phm75Ozb7vbL4SDRqNElE4tiixF8dh1Khg1rRvoGxMmDm8A1S4vqh1+lDu8wqJRU2pa3exZf1BrQVXmdJiKliCo0kFXvVOICp8+DsaAVaR66rN2YJfTCOWOFQgEA0hQKGHrMhaWmBg8/vJbOHrcCXjkv7eKwMrTJx4rXBpHjTle1OVgii1FUpc4Wa1SIpG0DikgJK2ioMolLA9mrbr5RaJCIRjyFmD78t/gLtmGYYo8KHTRiImOxhWfbsdXf21FtxgVnrn8eBw5cgQUah08lq5i8BRWB5W2pu9EfP+mI9zr7C4kLANWt0+IA1pJuiUYEWPUCgHBcs9tCQdkrVqLGCPQKcYAfyAIm9svOpCyoFOp3SOOqdnWGoUCjtQj4DMmI3rXj8KdobHniZ4bek8pemRkQpe9FdttJmDXajBOLlGhhL3zccKyMHn6GcL6cNtVF2H9mpW4+vyZuOLG23H59bfBr1ELt5NOrUSSRc6yJRJJy5EuDEmLoR99Y761dlBuFkEfDNt/xOoVfyPGugkpKIcxKhZudSwmP/kndhZV4/i+sXjsqqno3KWr6GrJ6oxqd3mt1cHabbyYme8JDtxWtx8un1/M+mlpSDTT2tD2oqG58JiqXT5x7oqtHuFKiNZrYdKpmuVGYEYG01S11l3QV26F15AENS0ShgQU5mzDVpsGFoUb5q5DkDLgOJEaGhZZXo8Hj993Jz7/4G3xfPRxxwuXBgtZcZWBnaIRa2q8v8ahiHRhSDo6bunCkOwPWNWQNQVIc8UDMy1UG7/C3yuXI8O9AVEKF2JjErCuQoOpj38vBtdrTuyNG86ZCHOUBX5dtAgaVPjswupg73Q0XAmD9mh14HYqnT74gkHEGjXITI5BvEnb4noU7QHFFgs78dE51odiqxsFVW4UVHsRY6CQ2P1Pke6aij5nIDrrZ9HLg4GWfm0MNM5SpHXqBmVBNrZadQjlrBZxGqkqLRxpo8R7WVzq7kefweBhI/DgHTdi4R+/46yTx+Kl/30Kc3I38X3272QR7hyJRCJpLlJASJqNzV1TkMjLZk/NNHuzsiTWfYZlK5ehv38DmOGZFJuArzY4cM0bf4Aa5JnLjsW08aOhUitFd0z1P5Uk/cYkVHc/CQF97B6FQ5XLJ+Ic4s1adIk1ioH6QM0y4EDNR1qMAYVVbuRWOoWbhSmwu02vVGpQ3f1kBLTRgEIFXdU2hFQaqD1VSEvpBBXysIUiInctCqFAolKLRfksoFkmOimedOpp6N1vAG649Bzk5WTh3FPG44lX3kHGkFHiex3QKfqAEFsSieTgQAoISbNweQPYXGQTA11KM8UDG1j5Vn2MtWtXYHBgI5QqNZLi4/HEb/l4ZvYGpFpUePOWUzFsUF8gFEBIoa7tmOlMHg572ujdZlhwpk2LiMcfQEIUZ/ZGMQgfqMKhPoyD6JFkFsfObBZaJdgEi+6EcNZHAxQK2Dsfg4AuGlE5auiqdwABBZQ+O1KSU6BAEXZYFbDmrsPSZUvx/sJ8bKio+ZknJSfjlltuwUez5+KGS87BqmV/45rzT8Nt9z+GY6aeI0RE31SLiOWQSCSSPSHvFJJmZRdsLbah3O5BskXfLJ89O2m6lr6L9WuWYGhgA1RqLeJi43H1B5uEeBjcxYJvHjqvRjwEa0oss3BSUGNEVeapYpDcnXigNaSw2g29VoXBXWIxpEusOLaDRTxEQlfQgLRoDO4cIzJCCqtdQrDtDlbarMo8Be7Y3iKWgZUp6CpKTkxEJ40dKviRkWzG9MPi0MNSsy12+Lvtttuwas0avPHxN5g84wxRz//R/96Kd5++F3kVDuwotYmsEYlEItkTUkBIdgvrHewstYvBOjlK3/TMuJ54YFnqbeuXYUhwM5QaPUzmaJzzylJ8uTQXJw5Ow0f3nYtuXToLF4fYokIFnzkNFX3OFp0rm4LBhwXVTviDIfRJMWNo1xgRJHkwCodIGNxJt9DgLjHokWiG1eMTmRvhwlWN4Y3OQGWvmaJZWEAfJzJVKMZKCvKgdxbBrHChd3oKzhwWg06mQE0baQBPP/U0VBo1HnrmVVx/x71i2Sf/ex3P3HElthVUIqvMIbJFJB0X9nJ4jhUx93KdvYWlp1muWXJwIgWEpEk4iORUOJBV7kCCWdusOglKrx1Vf7+L3E1LMEixDSqdCRp9FGY+vwh/bK3CReP64NXbzkR8bDRUIkhSJ4pCOZOGorLnTAS1UY1ulwMpLSDMZOgaZ8Rh3WKRnmBuUdnsgwF+nswks7BGmPU11ojd9a/wm1JR2es0eGJ7wm9Mhr2qFG63B87KMmicZYhX2JCZ0QVnD4tGvD4oRERxcRFWr1olLEkXX30jnnr1f9BotZj782zcf/U5WLerAPlVrn36uSVtR25uLi666CLR14JdI9lZ8vrrr0d5eU1GU3NZtmwZLrvssjY7rsYECftfsB+H5OBECghJkxRZ3dhe4hBZAs0ZqBm/UP73uyjY/DcGKHZBrTPDrzTg1GfmY1WeE3fOGIb7r5gGk04pxENAGyWyLKq7T4K9y5gmXRYszsSBlO6KQV2i0SfFItIzOyoc2NlFc1DnGGQkmEWAaKXT2+T6LHFd2et0UXCrPBgFrYqCC/BWlUDlqkAnRTl69uyOc4aaYFLXWBYYWBnmhJNPwSvvfQ6TOQorlyzErRecisXrtotW4JKDC7a3ZqMrdtdk06Xt27eLBkxz5szBkUceKRo7NRc2iWJDqPaEbbyTkpLadR+S9kMKCEmjsPgR4x5YaKg5haLYCKrsr/+hdPNC9FNkQ603w+rTYMYzf2JLqQ+PnT8a1541EfqQC8qAGwFdDAJaCyp7n17TcrsJqwPrJti9fmHWH9IlRnSWPFTKLzMjomeyGQM6WUQGK5thNRWfwEyVyt6nwRXbCzl2JTRKwMty29XFUHiq0V1ZjJ59euPsIQZolSGRlRHJyNHH4u3Pv0d8YhK2b96A686ejLnL1qJqN8JFcuBx9dVXC6vDr7/+KrpTdu3aVXSv/P3335Gfn4+77rqrdl2bzSY6UrKrZqdOnfDyyy/v1mJQVVUlOmBSWLA+ADtEsptlJLNnzxadJ1lbgNfYtGnTatuAsx01u1zy9xv+DUe6MGiJ4PLNmzfX2eazzz6LHj161D5na2x+JrPZLNpisz12pCCW7DukgJA0OuOnePAHQqJq455gHEPJgndQtnUh+ihyodGbUWYP4ZyXFiKrKoiXrhyHc6eOhcbD2U8IAV2siHeo7HOmSNVsDJrtaXWwGDQY0jlGNH86FFMMeUNNjTYIa0ScSStERFMuDRbZMo65ATm+OGTbVNAoFfAGQlBYi6Dw2tFbXYi+A/ri4iMTMGTwoAbv7ztgMN776hd07pqOwrwcXHv2Kfhl0UrR6+NQh+48h8OxXx7NjUehdYHto6+66ioxs48kJSVFtK3+9NNPa7f35JNPYvDgwVi1ahXuuOMO4eb47bffmtz+zJkzRSDuTz/9hBUrVuCwww4T7anDVo0ffvhBCAa23+Y2afU4/PDDxWtsSd25c2fRWrywsFA86sOW3bSefPjhh3WW8/lZZ51VK2IoXNh+fPny5fj5559RXFyM0047rVnnSNK2dFw7sKRVsJbCtmK76OWQaql7E2oMRcCLkoXvo3rrAvRW5EGnN6HQFsAVb61AbnUQb98yGccfMQQaR4EY4Oi2cMf3g5WNn5SNX3401zM1k10j0xNMh6RwaDRTo1M0dpU6kFPhRJROA7O+4fljafDUU+7BhvdvFVaLruYA3P4QzNYC+C2d0VdbBHX/XlBs+wXoc3KD4lxd0rvjva9/waVnTsWOrZtx5RlToGTGxnEjD+nvwel0ihnv/sButwsrwZ6g24LioG/fvo2+zuWVlZUoLS0Vz0ePHi2EQ3jwXrhwoZjtjx8/vsF7//rrLyxdulQICJ1OJ5Y99dRT+Oabb/DFF1+IWImHH34YZ5xxBu6///7a91GgkLi4ONEdNioqSoiZpqDIeemll/Dggw/WWiUoVj74oKZNPV+jeHjkkUdq3/P222+jS5cuYl1+Dsm+Q1ogJLXw5sMIfM78k8zNcBUE/Shd/BEqN89DT0Ue9Hoj8qr9uOadFcipDuKDO6fh+CMGQ2vL/sdlEQV7p9GwdjuxUfFA83xBtUt0wORg2Tvl0LQ6NAXjUHolR6FPShRc/poeG41x9LiT0OvcJ5HtjUWunT9xBdy+EEzuEpiUPnQP5WHl4j8Qyl7Y6PsTkpLx1mffi6JTleWluOT0yfh+3iJRsEty4NNciwVjIuo/37RpU6Pr0lVBIRMfHy+EVPjBcsg7duwQ66xevVpYJPYGCpCsrCwsXry41vpAS0efPn1qj2PevHl1jiH8Wvg4JPsOaYGQ1FJQ7RYZF/Em3Z4zLkJBlC37HOXrf0dvUDwYkFfpw80frhZuiw/uPBVHDO4DnTULPlOqqFVQ3e3EJuMdaJZn58oUi04UV5JllZtO9+waX2OVoZuJxacYcFk/vfaocSchNHo0XPOeh7FyE+KVNlgMWgT9Xmyp9MDrzcbq+d9hqCEGSB7QYD9x8Ql485PZuOKcU7Fh7SpcOGMy8Nk3OPWEY/dbP5H9CYMJOYDur303h8zMTCH6KQLCsQeRcHlsbKyIYWgp/Oypqan4448/GrwWjmGo7zZpDbRO0EXx0Ucf4YgjjhB/r7zyyjrHMXnyZDz++OMN3svjk+xbpICQCDib3V5sg0Gj3vOsPxRC2cpvUbbmR/RGLgx6LXIrvfjPJ+uwoyKID/8zE4cPyIC2eqdogsXUzKqMyfBZujW6OaZmMu4iI6HGZSErIe4Z1oygRWJLsVVYjFIshga1MBT6GJjH3YjYrZ/BULYBIUchVKEAesYEoaiywuXMx7o5H2HQSVcgFN21wT6iY2Px+sff4KrzZmLNiqW48LRTYPjmB5w0djQONTgwN8eNsD+hdYDuh1deeUUEK0YO6EVFRWI2f95559VaFsOz/DB83pT7g1YAbkOtVovgysYYNGiQiHu48MILG32dwZ0sXLYn6MZgwTMGeDKrhFaJyOP48ssvxTHwWCT7F3mnloiqh+GgyeY0yCpf/ytKV3yDXqFcGHRqFFqDePCLddhUGsDHd5+Gw/unixbcFA8BfbxIMWxMPIgsC6sbgWAQ/TtFi4wDKR6aT7SxJi6CQZYMrmT8Sn0Yd1LZcwbccX1FwGpQYxBpnhkWJdKVJfBbi7Dh13egcDVeIyDKEo3XPvgSQ4aPhN1WjbOmT8HcRcv2waeTtAbGCHg8Hpx44omYP3++qAnBQEMKC2ZaME4hDGMennjiCRE7wAyMzz//XARSNsbxxx8vXBynnHKKyPCgm2HRokUiq4PBjOTee+8VqaP8S2vHunXr6lgKOOjzmJgNsrusiVNPPVVkiNDyMGbMGFHPIjLLhEGbFBesU0G3BQNHKVqaI04kbYu8Wx/iMO5gR6ldBC7SFL4nqrYuRPHiT9ET2aLscplLice+XotVRQF8/N+ZGN67ixAPnugeosgRO0iyTkFj++WgZzaoRYZBpxjDIZOe2db9NPqkRok+IHRnMPi0PkFdDCp71YiIgCFBtEo3KP3oFq0Wga/W8kJs+vUtwOdsdB+sD/Hyu59hwODDYK2qwIwpk7B4xdp98OkkLaVnz55iQM/IyBCZCUx/ZIAjB+K///5bBDOGufnmm8W6DEp86KGH8Mwzzwjh0Rj8bf7444845phjxGDNYEVaBpiayVTKcKomRch3332HIUOGCFcEAy/DMAODwoPHtDs3CgMt6aZgvAOtEZFQTFD4UCyccMIJGDhwIG644QbhRlEq5XC2r1GEOljN2pb0MpdANHHaVGhDUtQeOkEybzxnDbJ/fRm9Atth0YRQ5dPi8S9XYM4uP967/RQcQcuDLQfumF7wRXVGZeapCGmMjfbWKLW7RVOuXilRYhCU7B20PmwvsSG73CliWBpzQ6mdpYgR7ox1UDtLRBfPKr9GNN9aE+qB1O4DkTn+0iYLellZB+DMKdi8fi3ik5Lx25y5GDqgHzoabrdbBAd2795d1DM4VGFMAbMhWPtBcuhc49YWjKFSsh3CsDQ0+1zQbbEn8eAs3o6s319Hj8BORKkDsAd1eP7blZi7y4+3bzoZR/brCp01W4gHb0yGMJs3Jh4Y61Bq96BrvBH90qKleGgj+P31SraIglsVDo84z/WhJaiq53SRRsveGcyKiVG60S0qhP6KLOTu2oidi76s7ZlRH0tMDGZ9+DV69umH8pJiTDzxBGzbkbUPPp1kX6essh4E6yv0799/fx+O5ABGCohDOO5hW4kdoZBij2WhPZWF2PbTy+ju24YYlRc+pQmvzl6Bn7f78Nq1J+LoQekiVZOdIT1xvVGZOQ0htb7RYEmr24+eSWb0TpZto9saBlFSQDDVMxyYWh+/KQVVjIlIGCBERFBrQqLKhXSjTwTEZq1fhJw185rcR2xcPF7/+Fuk9+iJ4oJ8nDjhRBQUlbTzJ5PsS15//XXhnqBroH6qp0QSibyDH+JxD2yStTv8zmps+uEFdPdsQpzKBeii8fZPK/HdFh+evew4jD2sB7R0W8T2hSthAKoypgDKhoGYlQ4vvIEA+qZGISPRdNB3zzxQYYolM1ko0igiGqsiKaqAZk6DK6E//Pp4BNV6pGhcyDTY0Rkl2LHke+RvbzrGIT4hEbM+/ArJqWnYtX0rJkyahGqrrZ0/mWRfQeHAxluMiZBIdocUEIcg+ZVO5FW6RHvu3QUuhvxurP/hZXR1rEW80g6NIQbv/7oSn21w44GzDsfEkX2gtefCHdcPrsTBsHaf1Kj/vMzuQUgRQv+0aBHsJ4Ml2xeeX4qIXslm2Dw+2BsTEZZuqOoxTVgi/IZ4hFRqdNK5MVBfjOhQFbb88QFKC3Ob3Edqpy7CnREdG4d1q1bgpClThV9VIpEcOkgBcYjB5kg7yxyw6NW7j3sIBbHu57eRUrEESYpq6E3R+HTuGny42okbTx6IaccOgdaRL8SDM/kwWNNPBBR1txf6pxmWRq0U4iHZcugGpO0PEdEtniIiSgiIxkSEN6YHqnpMhSthIPz6BCgUQXTR+zFcmwO934Y1P7+Jamt1k/vI6Nkbr7z7OQxGExb+OQ8zzjhLptJJJIcQUkAcQjDFb3uJXbgwdlvpMRTChj8+Q2z+XKQqKmAyRWH2os14f6UNF43JxNkTDofeWSDSAp0ph8PWdXwD8cAaD2wHzk6eA9IsSDDvOUVU0vYiomucUVgimhIRrAxanTEZrsQaEaEMuZFu8uNw9U6oPRVY9N2bcLmb7sg5cOgwPP/mh1BrNPjh269xxTWN1xGQSCQdDykgDhFoDcgpd4oMCKb57Y7tK+dCt/VbdEYpLEYD5qzOwvvLKjF1eGdcPGU0jK4iYXlwpI6CrcvYBg2ZwuIhxqhB/zRLszp6SvaFiGg8JsKdMBDW7ifBlTgIAV0cNAEHMs0eHKbeBa09B799/+Fu+2AccfRxeOS5WeL/N197GQ899mS7fiaJRHJgIAXEIUKpzVNTI8Co220AY8GOtfAufw/piiJEG1RYtr0UHy0pwRE94nDVjONg9pbAHd8X9rRRsHc+tnHxUO0WraeZpil7Whw4IoKBlVZ349kZzuRhsKZPgitpCIKaKOgDdgww2dFbmQ9T2Rr88OuPu23SNGHKqbjprpoOivf853a899En7fqZJBLJ/kcKiEMADhjMulArFTCwjnETVJUWoGTea+iBPMRo2Nbbg0/+zkXnOAOuO2MMYgJlcMf1gaMJ8RCuLhlv1qJfqmWP6aGSfR8TEc7OaExEOFKPEJ1SnRQRaj0MQTtGmsuRoqiAMWsufl64+xLW519+DU4//xIhNC698ALM+ePPdvxEEolkfyMFRAcnGAxhZ6lDDBq0CjSFx2HD1p9eRGZgB+LUHpS5Vfho/laoFArcfOYYJKts8MRSPIyGrfOYJsUDYx36pVlE7IPkwCIsIlgrgsG0rAVSbwUhDK3dJsCVMFjEtZhDdowx5yFK4YB/3ZeYv3bHbrd/x/2P47jxE+H1ejB92jSs39h4e2iJ5L777hMlrw92srKyxLXPduaEHUv5vKqqqtXbbItt7AukgOjgMBahoMqFRHPTKZvBgB8rf3gNma61SFDZ4VGa8MGcdahyh3DDaccg3eyDJ7aXcFs0FvMQFg/MsuiXKqtLHuh1IronmETL9AqnV7RRr4NCAVu341HdfQJc8QOgCPkRAzsmmHfConCgYNGHWJXVdOEolUqFx19+CwOGDEN1VSVOPnkySkqbbpwkaVsuuOAC8Tvng90v2eKbPSj8/oYWp/09qN1yyy2ie2dHY9SoUSgsLBTloJsDe4iw9sbebGN/IQVEB4YBc0zZZF+EJqs+hkJY8duH6Fa5CMmKKqj1Fnw6dy1yqkK44uTDMCBZDU9MD+G2sHU9vknxkBSlR58Uy25dJJIDSUSYRfv0CqenYQMuhVLEQ1i7T4Q7pjdUATeSlFYcb9yJRFRg6S+fYFdp04WjDAYjXnz7Y6R06ozsXTsw9dQZ8HiazuSQtC0TJkwQg8+2bdtEwyzO9J988sAJbKWLi4LGbDaLFuR7g8/na7PjaqttabVapKSk7FW9m7bYxr5ACogO7LrYVeaAw+NDzG5adG9c8Qfisn9CJ5TBZDTju4WbsL7Yi3OOzcSRPWLhsaTDkTIS1m4nNCke2MWzb6oUDwdd2eskswiuZKGvBq3AlSpUZZ6C6oyTRFt2ld+J7upyHGnIRWZoJz6f/Z0IzG2K+MQkvPTOJzCaTFj815+48LIrEAw2nckhaTt0Op0YfLp16yZaYrMVNztkksrKSpx33nmIjY2F0WjExIkThdAIw+6a7ITJ100mk+iFwS6cNNOzoyfhaxzYaO0g/F4fffRR0ZjJYDBg8ODB+OKLLxpYLn766ScMGzZMHN9ff/3VwIXB7dBa0rlzZ7EOX2Mr8vqugk8//RTHHnusaAL14YcfNnoOuN6rr74qPh+Pid1JI49pd9t688030bdvX7GsT58+eOWVV+psmx1G2cFUr9dj+PDhWLVq1R4tNewgSksDzznPH7ue8rvgOfzzzz/x/PPP11qOeGyR22BzK34Gnr9Ivv76a9G5lL1LCFu3swMrO5Oy6+rUqVPFttoTKSAOYddFftZW+Fe8j+6KQkQb1PhzXQ4W77LjpMHJOH5IF9FR05kyEtWsMFmvzkOkeKDbQoqHg1NEZCZFCRFRYmtMRGhQ1WsmqjImw29IFCJikCYPvbUVGOpZgVe/nddobYkwvfoOwGMvvimuv4/fewcPPnHwlkbmrJmBp/vjsbcNkzn4eL01FiAOWGzhTUHB9t7c9qRJk2pn31dffTU8Hg/mz5+PdevW4fHHHxeWgi5duuDLL78U62zZskVYODjoEYqH9957D6+99ho2bNiAG2+8Eeecc44YGCO544478Nhjj2HTpk0YNGhQg+Pk9p5++mk89dRTWLt2rRhkp0yZUkfghLdz/fXXi+001X6c3H333Zg+fXptW3D29+B7drctioh77rkHDz/8sFj2yCOPiO28++67Yn273Y6TTz4Z/fr1w4oVK4QIoitmdzA2Yty4ceI9POcUTxRpLLrGz8x+I5deeqk4p3zwXEfCjpjc50cffVRnOY/1lFNOEaKE3x+Pn4JiwYIFQrDwe6M1KvzdtwfSWd0B4U2dXTYNGlWT1Sbt1krkzX0Ng5GDGE0AG/LsmLepDCMzojBlVB8EzWlwpo5EVY/JgFLdSJ0HaXnoCPD6oIjwB0NCcKZYDHXSfNkUraLvOVD6nYjb8gk0XjuO0W9HZdCIobZ5eO6HWNw+dUST1xkDKm+66wE8/dDdeOCu29GrZ0+cOX0qDjZcvgD63fPLftn3xgdObFVcEcUBYwx++eUXXHvttWIgpnDg4EIfe3gQ4oD1zTffYObMmcjJyRGD7sCBA8XrnLmH4ayWJCUliVkuodjgIPv777/XNt7iezhIzpo1S8zuw9C6MH78+CaPl8Lh9ttvFwM9oXiZN28ennvuObz88su16zFe4NRTT93j5+fnCbciZ1tydhh98cUX61gU6m/r3nvvFSImvIxWlY0bN4rPcv7554tBnJaSt956S1ggaKHJy8sTlp6meOKJJ4SlInK/kV1O6a6gCKDVqCkogM4991xhbeC6tEr88MMPwgpBaEnhcdF6Ep4wvvPOO+J7ojXjhBNOQHsgLRAd0XVR6hAioqkCTn6fD6t+eA29fZuQoHKi1KnEjyty0D1OjdOOHQCVJQWOlMNFmeP6jbF4U6J1I95cIx5kwOTBD+NjeqdEIcWiR6HVJaxLkbAte/mAi1DVfSJCKg10PhtONm1CPLt4Fv+Kl+ds2e0s+bzLrsG0M84VN7hLLzgXS1et2wef6tDl+++/F7NPDnA04Z9++ulipswZtVqtxsiRI2vXZQxC7969a2fm1113HR566CGMHj1aDKa0BOyO7du3i0GNwoD7DD9okdixo27GDgfRpuCAWFBQIPYbCZ/XtxrsbjuR1O8kyue725bD4RDHfPHFF9f5LDwf4c8Stp7w3IbZU8fSsAVib6CVSKPR1LqiaA2iZYLuKUIrC78LWiDCx03Bx/409b+HtkTe/TsYxTY3CqtrghqbYtlvn6CHdSlSlFXwq0z4duFaxOoVOOO4gTDFpcCRPAxVbMmtqluxkoMEtx9r1Ejx0MHQqVXonWJBgN+x1Y2UaD2UEa6voNaCsiHXQe2uhCVnLozecky3bMKHVQoUb/8dH0cbcdbIbo1umzOi/z78NLJ2bMeqZX/jtJnT8deiv9E5ae8C6PYltObRErC/9t0SGKtA/z9ntmlpaUI0NBfO2GkK5+z2119/Fe4JzshpwWgMmvQJ1+/UqVOd1xjHEAljKtqCttpO/W2FP8sbb7xRR2SFs4v2xoW0t/C7nDFjhrCA0ELDvxSG4e+Wx874ksZiQhITE9FeSAtEB4L+UtZ80Kubdl2sX7EA8bk/oauiBDq9CbMXbRKxkVOPzERSaic4k4aisud0Mets2BjLIypL9pFFojokdEUxkybWpBFN0OpbFQL6WBSPuFMUmgJCiPYU4pTYbAxR7sDq5X/h943FTW5bo9XimVnvIiklDdk7tuGss86BfTc9Ng40KIIomPfHo6WR+BwUmb7ZtWvXOuKBgYHMfliyZEntMrbtZkwD/fNh6NK44oor8NVXX4ksDg6o4UGMRDZM4/soFOj64D4jH/V9+buDs2mKHbpXIuHzyGNrCYsXL27wnOegKZKTk8Ux7Ny5s8FnoSuD8P20ykR2nl1cbz/1ocVid+mqPK/NaUJHNwaDShlnMnfuXPE8zGGHHSZcVHQv1T/29kwFlQKig8CbfXa5AzY3XReNZ10U5mfDu/wD9FTkIUqnxp+rd8Hq9GFM/xRk9siAM3EwqnrORFBX49+MhBH3Jp1KWB4ssjx1h4UFwCgQo3QUEQ2zLPymZBSMehje6O5QIoRO7u04NrYCY5Wr8Mkfy7Eqp3K3mRnPvfEBtDodFsz5GTff8d+GKaSSdqNnz54iMp8Be4xRoNmbwY60HHB5OCaAMRO7du3CypUrRQxCeNBlVgfFDF0kpaWlYtZLkzmDCBk4yUBDmsv5PsYahAMPm8utt94q4h7oz6eoYYAjzf8McmwNn3/+Od5++21s3bpVuGOYPXHNNdfs9j3333+/sLq88MIL4n0MJGUswTPP1AQAn3XWWeIc8Bxu3LhRZKgwdmN33HnnnVi2bBmuuuoqIT42b94sLERlZTX1UdLT04WoY8YElzWVrXTMMceIOAkKBwqaSCsJlyUkJIjvkUGU/P4Y+0CXFGM02gspIDoIbJKVX+lGvEnb6IzF5XJg229voC92IEbtx/rcSmSV2DC4axSG9O8Nd8IgVPWcAb+xobmLaX46jVKIh+jdpIRKOgYUiH1So6DXKFFubygifJYuyDv6afj08VCEghjgXY2h0U5MUizCsz+vRVaZo8ltDxhyGO557Dnx/+vPP4lX3/moYfaHpN3gYEhTN6P66bvnxIODIP3rhDNhZmJQNDCCv1evXrXBfxQaHGA5sHO2Hh6MGaDITAUOvOH30aURnrU3Fw52N910k7B6MIiTs236/Cl8WgOP9ZNPPhEWAMZkfPzxx3u0ZtCFw0BEniceA4NA//e//9V+FsYWzJ49WwiLoUOH4q677hKiZ3fwHNIdRMF2+OGHi/P+7bff1lqHKMDoIuGx0d1Aa05j8L5+5pln1maVRMLASmbO0OrEAFB+D4zloKWE1p32QhHa2xyhAwwG49BkU11d3a4n7kCCs7g1uVVweAKNts0OBYP485vXMaD0B6SrSlHtUeDX5TuQHKXFxKOGQNF1JCp7nwFPbMMfaqXDi5AihP5p0bIl9yEGrU4bCqpFOfPGAnINBX+j67xrofI5EVDr8G3wWCywp2GR4Tg8NXOwCLRtiifuuxMfvPUqDEYTPvtpLiYeNWK3Td72JbzpcgbHQSMyWE5y8MDBlhkKTHOUtOwab8kYKi0QHYDcCifKHd4me12sWjIXnUv/QBdFCUIqAxat3YlonRJjhvWEqtMQVGec3Kh4YP+MQCgo/OJSPBx6ME2X370nEITN3bBKnyvtSBQd/h+EVGqo/G5MVi/GUEMx0p1r8cAPGxv22ojgpv8+iBGjjobL6cBVF5yNdVmFIoNIIpEcPEgBcZBDCwEFRJxRWydqPkxO9g5gzaforciFXqfH32u2QaUAjhnYFebuI2DtNh6upKEN3md3+0WfBEbms8eF5NCE2Ri9k81w/FPUqD7VPU9FWb8LEFKooPFWYYZpDcbqNsFbtgtP/LK5QUpoGJpvn3jpLRFUmbtrO6676grkVDj2umiSRCLZd0gBcRDjDwRF4CRdyI2lVDqdDmTNeRMDlDsQpQbW7ciH0+PDkPQ4JPcdCXvno2HvdEzD93n9sHt96JVsRlrM3qcgSQ5uOscaRQfPysaab9HVMewmWLuMQQhKGB25mBG3C5PVy7A5Ox+z5u9oUhQwqPLp1/4HtUaDBb/MxuNPPoOC6n+j2yWS1sJrTrov2h8pIA5iim0e8WDgZGNxD0t//hD9fOuQoHSgqMqJ4nI7MhIN6D7gcDjTRqE6fWKD/haMp6hy+ZCRYEaXuLqpnJJD15+cHm8S10S5o5GS1yyLfuyzcMf1ARQqxFs3YmZSISapluKX9QX4elV+k9sePOxw3HrPw+L/N55+AF98/ytKrFJESCQHA1JAHKTQSsBmWUaNCupGaj6sXfEX0kr+QDdFCXxQY1dOIeKMSvTqPxiBrqNFo6T6Jao5MDDjolucEekJpgO+E5xk33bwzEg0CWsEa0Q0cE2o1Mg64W14TcnittK1egnOTCnAUcp1eGdRFv7a3nRL7zPOvxQnTTtNZAA8cNNl+GvttkazPyQSyYGFFBAHqXkup9wp4hQaS6ssLsqHc+Wn6K/Mglqjxbbtu8QA0KdXJrSZx9QUilLXdU1wQODAIMzVSeYDJiJecuBAodoz2SxKXhfbXKInSiQhfQyyx76KgC4KCoQw0LYAFyZuRQ9FPp75bQs2FVob3S6F6t2PPYvM3v1QUVqCB2+5Euvzq1DtbLtWzRKJ5CAVEGyEwmIZTBdh8QsW9GgK5tyG25qGHzKVqi7MuMircjVa88Hn82LDr+9gqGIzTKoQ8vNyYfcE0aNzImIGjkdV5nQEDHVLCHMg4IDAgYEDRFNVLCUSlrzulRKFOJOu0WqVvvg+yB95LwJqIxQBL0Z7F+Kq2OUwBax48IeNomFXYxiNJjw9610YTWasXrIQbzz3ODYVWRvN/pBIJAcG7T5SsKoYi4OwEhgrlLFXPGutl5SUNPke5p6GW5vywR71kn/dDCzUQ9mgb6RG/uI5X6G3awWSlVaRz1tS7UHneCNSh06ANWMyvNHpjeb7c0DgwMABQiLZHQzYZfMtk1aNMnvDctT2jEko63c+giodVF4rJqmW4PLoJXC53bhv9gaRHtwY3Xv0rC0y9dGs5zDv99+wucjWaPaHRCI5BAQES4Cy7OeFF14oKm2xZzyrZrHEaFNwVs2SneEHq55Jaiiscok4hXhTw7oM2zavgyXrZ/RW5InMjKLSCkTpVUgZcAzcPU6ES/QwqAu3xR4IvZKjZHMsSYuqVVJE0FhV5WwoIsqHXA1r17EIKbXQOotwjmExTjOuQmG1Gw//uAlef+PVJyedMgMzz7lQWDae/M+12LYrG1uKbI1mf0gkkg4sILxeL1asWFHbclTsUKkUz//+++8m38ca66y7zmYsrO3N5iFNwX70nGlHPjoqDo8f2RVOmHWaBjEKDrsN+Qs/xGHKbVCrVCgpKEAwpEBS9wFQ9zsJts7HNdgeZ4L0gHAgkCWqJS2FlSZptWKhKbaPr4NSjaIj74czoT9CSg2M9izcHLMAR2h3iFiI5+ZsbRBDEea2ex9Fn/4DUVlehqfuuBoF5XZsLbY1KTokzYf9EThBq6qq2t+HItkDxx13nOhNcsgKCDYGYWR1fQsCnxcVFTX6Hvamp3WCtcI/+OAD0Vhk1KhRTTYEYf11lt0MP1rSAe6gC5yscAgR0dhgv+zXjzHEvwZRSi9s5QWo8gRhiU9G3PBpotIklHVdEzQLc1ZHy4OsMilpLanRBvRMMotYhfpWgqAuGgWjH4U3qjOoFWJsW/BU0i/opCzHgm1l+GBx465JnV6Pp159FyZzFFYt/RtfvfWciJ3YXmITtU8kjVM/dqz+47777tvfhyjpYBxw0XJsNHLeeedhyJAhopEJW8qywcisWbOa7HTGmt3hR25uLjoiFQ4v8qvYLKvhYL9+1SKklPwpUjYDLjtKrD4YDQakjZouKgXWz7hgrQcWBeqRaEJqtAxQlewdXWKN6J5garRGhC8mA8XD74DPkAgE/UixbcSbnX6ADm58viIPv2xofCLRtXsG7nviBfH/O688i6y1S0TF1e0l9iarWx7qRMaNPffccw1iydi0SSI5aAQE24uyy1hxcXGd5XzO2IbmwC5x7Hq2ffv2Rl9nL3r+UCIfHbPipBOKUMPAyYryMlQt/wxDlDugUoRQXlkNKJRIGjoRrr4z4TcmNdgWA99YGKhbvKz1INl7mCJMAdFUjQh7l+NQ0f98+HXRUPid6OFYjTc6/UIbBV75YztWZDfeAvzEydMw/azzhfXt7huvgMJtRVa5E7vK7LJvRiNExo3RGls/loydJMPQtTx8+HARj0YLL9tnR8J20z169IBWqxVW4ffff7/O69w2J3Xs6sltsPsj3dK8T9P0bjKZxHbZ3jsMLSCcGPJ9tBTzfaeddpqY+EW6WNixku+PiYnB6NGj6wTRN+e42E1z2rRpYvvs5MmOnruD3Ua5HrP9aB2fMWNG7WvsCHrUUUeJY4mPjxefN/IzZWVliX1+9tlnOProo2EwGDBixAjRCpwtvHmOed4nTpwoWqCHueCCC0SlTHYM5QSZ49YVV1wh3P67c9dTBLIrKs8PMxp5vsLwPE2ePBmxsbHi9f79+4tOqwetgOCXzNaxc+bMqV1GlwSf09LQHOgCYevU1NRUHKoUWd0oYcXJeq4GnstVv72P4aH1MCp9sJeXwOEDDN0Og+awM+GJ7d1IuqZbWB0yEs3ixi+RtGWNCPZNKbbWS+9UKFDZ7zxY0ycgoDFD5anC4b6leDT1L3FNPv7zZiEKGuO2+x5Fj159UFZSjAdvuxYxejV2ljr2fd8M7svv3T+PdvicbEP99NNPY/ny5aIvyUUXXVT7GrtYXn/99aKt9vr163H55ZeLIPh58+bV2QbbeNNavHr1avTp0wdnnXWWWJdWYW6X30+45XcYCgwOtmyJzcF51apVuOqqq8Rrfr9fDKq0PK9du1YIkssuu6x2ktPc4+KgTGHCbUyaNEm0vq6oqGj0PPA42Ub8gQceECKKx3TMMf+W93c4HCKLkOtx3GIMH8UJ772RMMvwv//9r8g05Pnkubjtttvw/PPPY8GCBeJz33PPPXXew+1t2rRJiAC2Gqe1ncfeFDyXPCdsUc7PNnPmTNE6fdu2beJ1tmGnyGBbb46ZbDMeKRoPynbeTOM8//zzheqksqRpjRfQ5s2bhdrjBUhFxVgGwi/yiCOOQGZmpgj0efLJJ/HNN98IxbynXu4dsZ03OxquzKkUM676LZVX/v07Yte+jmGKbQg6q5BX6YFLn4TM6Xejuuc0YYmIhLPDKL0aAzpFy4wLSbvAGJ11+dWiyFn9JmwqdxU6LbgVpqKlUPjd8FjS8YLvFLxWNlDUNGEL8MbicbZt3oizTh4Lj8eNW+5+CNPPvwI2jw+9k6PQNd60b1odcyBf8DT2C0ffDKgb77S7u3o6DMCrHyzJwWrMmDH4/fffMW7cOLGMs9STTjoJLpdLfF7O+jl7ff3112vfxwGZg+kPP/wgnnNQ54BJEUEWL14sJoVvvfVWrRjhQMcBntsNWyAeeughMVPmPZ9wwOa+8/PzxYSTs3weI0VEfVpzXHyNg+hPP/0kBtv6cNDmMTLGLioqqllxfbQYcIAeMGCAsEDwOqHV4+KLL6793GeeeaYQCGPHjhXLHnvsMfGdcNwLWyAoouhyp6WEMEPx1ltvFWMXhQotObTYcMzMyclBRkaG+JuWllZ7PExI4Lj6yCOPYNCgQZg+fboQMx2mnffpp5+Op556SqgvngyqVV404cBKnhD658JUVlaKtE+axKge+WEWLVrULPHQEaHflwFq9QMny8uK4Vn3NQYpdkIV9IiunLaAFt3GnAdrxkkNxANf16qVMl1T0q6YdGr0YT0RjVLE7UQS0MegaPgdcEdniMwMnS0HVxl+xUmWXaI42v2zNzRa86Fnn37CEkGee+x+ZG1eB7NWg63F9iYLU0l2DwebMGHrbrg2D2fFHKwj4XMub2ob4fv5wIED6yzjQBWZGde1a9da8UAoOjib5+w/Li5ODKysE0RTPGfvkWNDa46LpnwOgk3VHRo/frzI+OPgfO655+LDDz+E0+msfZ2ze4oBvs7tsCBieNxq6bmofwysiRQWD+FzwQzExuL4KFhoje/Vq5cQROHHn3/+WetSoSWFAo3nhCKCVor2Zp+MJDS91DdlhYn04ZBnn31WPCQ1+fX5VU7EGutWnGSjrNW/fYAxWA+DwgtbdTVKHSEkjjgZ3kFnI6SuqyiZYucNBjEwNbqBFUMiaWt4jdE6sL6gWojfKP2/4tcb2wPFh92I1CUPQmfLg7F6O+6N/x3F3pOwvDwNj/60Gfee3K9Bf5cZZ1+AvxfMw+8/fofbrr4In/08H3qNHluKrCKlud1bzqs0NZaA/QH33cYwtixM+N5S3yzfmm3s7XbfeecdMRBykknrNa0Jv/32m7BKt+a4wsfR1DHQ6kC3A8ehX3/9VUx0aSlh/ALjHihkKDDeeOMNMfPndmh5qB+roGnGuWjp+Y2EwoLxhLTE828kYTfFJZdcIsQXrTH8LLTq00117bXX4pDJwpDUQJcFAycba9W9eulc9LYuQjKq4LdXodwVAlIHwXz0FfAb66bMMne+2uVFZqKp/W+yEsk/JLEsepJZiFe64SJxdjoaFX3Ph08XD0XQh9jK9Xiq8wL0VJdgdW4VXvmzYQtwkYb4+AtI7dQZudm78Pi9dwirnEqhxOZCq6im2q5wUKAbYX889nGgM62/CxcurLOMz9vCCsyZe0FBQe1zuj5ormdAZBgGzTOOgpZnDtYfffRRux4XYxboCnjiiSfErJ1uiblz56K8vFxYRihi6O7h/mkhbyvWrFlT694JnwuKgcZKEfCc0AJBKwbd+5GPyIQEvpfBmHTNMFaEwqc9kbbsA5RSu0cEo9X3CVeUFsG39iv0V+yCwu9CtTuAolAcBpx0A5wJA+qsy2j4Ursb3eKN6BrX9r5iiWR3MCvD7QtiR6kdSSr9vz1WWMio90xo7bmI2folVH47UqtW4OnuFly5/XD8thFC7J4+vO6N1BITg4efm4VLTp+Mbz77EEeNGY8TTj5FdO7cLCwR0YhrpLW9pGXQD8/YAg5aHFjpq+eAxLiJvYX+dsbE0a1N1watDdwXB0H65BnfMGXKFDHb5+BNFwLj5NrruL7//nvs3LlTBE4ye4HxILQUUNDwOWMyeEx081D83HHHHWgrvF6viJugQKFooduBlnoKqvrQdcFgUJ4LWhV4DpjVwTgLuk8YR8KYF2Z7cF0KHQaXUvS0J9ICcQBCqwFbdWtVyjqNrei6WPv7hxiJdTDCDbfTiR1VSvQYfymc6f9W+4wMmkyM0smMC8l+gVaDptI7QyodygZdDnunoxBU6qB2V6GnbQkey1iDBFSLIlPztjT0Ww8/YjQuvvom8f/9d1yPwvxckZ3E3wwrXMoOnnsPMyEYf8BBnkGLDICna4FBfXsLZ8ynnnqqiG874YQTxODHNErCeAAGGTIQkIMgMzCYWcBsi/Y6LropKEIY7MjBloGMzIjg9jmQMyCSbgNaQm688UYR1N9WjBs3TqSPUrwwVpDCaXfFvvhZKSBoWaDA4fmgq4VxJYQWCp4vfg4GjPIchs/tQZuFsa/pCFkY2eUOcTNklT9lhPly3ZI5SFz9IoYotiPgsmJbmR/BXhOQcNozCOpi6myDszK1WolBnaNF3wKJZH/BCpUbCqpF/ZFUi75OPI+2eidSF90NYwkDvoJwx/bBnNAw3JN7GBzKKNw/pT8Gda57bft8Ppx/6gSsX70Cw0aOwpufzq6pN2N1w6xXo3+apU7cRYuPdzcR6pLWw8GRGXUMpD/UueCCC0SGDM/H/uCgycKQtAz6jBn7wEE/UjxYq8rhXfuFcF0oA25UOgMo16cj5eQ7GogHbiOAEHolm6V4kOx3WPysd4oF0XqNcM1F4o3OQOmgq+GxcBalgL5qG4417MTNyaugCzrxyI+bkFPxb1R8ODjtsRfeEK2/VyxZhLdfqengmRSlg9XlE+Kb6aQSiaR9kQLiAILGoNwKh0hlqzODCoWwfu7HGBlaAz3ccLncWFuhRc/p/4E3tledbdCUa3X7kJloRlKUnD1JDgzMOrVovKVWKhp073SmHYnyfhfAb4gDQgGYSlZiQlIlroxdBr/XJdI766eEstT1nQ88Lv5/9ZlHsX71SmHZYOxEpaNGRNQP3pRIJG2LFBAHQb+LHRuXI6P0NySjEgG3CxtLg+h03PkI9ppYZz1W9Su1udEl1iD8zhLJgQQDHEX3Tn+wbr0HhQLWzCmoypyBoNoIRdCLmIIFmNrNj/PNS1Fpc+CB7zc0EARTZp4lgihZwfA/N1wOl8sprHYUEWX/BFbKNuAHlgtDui9qYFGp/eW+aEukgDhAYICZMNXW63fhcTlQvfg9DBSuCy9K7AE4U0Yg9vgbG3TYZCpbnFkrgibrt/uWSA4EUix60cSt0umr056bQZUVLHfd7XiEFCoofQ4kFM3H6ZkhnKZfil2lNjzxy+Y6gZi0ONz9yLNISk5F1o5tePbhmgp8vPZTLAYUV7uxpcgmmsdJJJK2RwqIAwRGqTMIjCV9I1n3x2cYGVgBA10Xbi/WWi3oedbjolVyJNUuHzQqBXomRTVouCWRHChw0Gf56W7xBpFiHCkIWKmyfNDlcCSPYMoR1K5yJFWtwNk9gzhZsxwrsssxa37dGhHRsbF48JmaSPNP3n0Df82rSekLF5cqrHZha5G9QZfQ5tDB4sslkja/tqWAOACgmTW7zAmjRl2nAl/Brs3onPMNUhTlCHo9WF0cRNcpdyCY2KfO+znDokm4R5IZsTIPXnKAw8G9R2KUsEYU21x1bmZeS7oQEe7YnlAGvdBV7UKabxfO7+HCOOUq/LS+EF+uzK+zvSOPGYOzLrxM/H/PLVejqrKmcRJ/S4wDyq9yYVuxTXSibQ7hCoKRJY0lko6E959KmvWrWrYUWUjqAID1/KtcXiRFabFixXLRsCU+LgbqjV/gROUOKIM+5Fj9cPc4EZ2POLvOezmDo7+X7bnTog377TNIJC2BfVl6JkfB7Q+KTrORVVKdycNR3u8iJK18BhpXKQyla9GtcyzOT/fDmbUB7/6tQIJZi+N6/9uq/oY778fiv/7Ezm1b8MAdN+Dp194V1g7WUWF2Bt2DjI/gPvfk3uNNlfUBwr0LWJ9Atr2XdBSCwaAoQsXrmlU49wYpIPYzzJhgw6w1yxfjpWefQklxsVh+4uE98OSQXBjggd3lxxpnMgaf/QRCyrpfGcUDq1V2TzTJYlGSg67xFntmsHtnpdMrer7UBlVmTIDaVYzEdbOg8tlhLlqK3l3G4VxPPtwFWjw/RyEKSA3sVOPK0xsMeOT5WThnyvGiX8bsLz/BlBlnitcoIvgbya5wCBFBS92eRES4PHBTTZgkkoMZFsliAaq9FcaykNR+hKee6Waf/zgXj9x9m0jXJLFRerw9IwGjtZtFG+G/sn2IO+9dmPvVtN8Nw5x3fzCIwV1iZJMsyUFLUbUb6/OrRaonRUUYpdeGxBXPIXb7F+BtzmPpDlvaaCzcWYm3y/oiS5uJJ6YPRte4fzOO3nzpGbzw+AMwR1nw1e+LkJLWuY6rsMLpFUGcGQnNq87K6n4sXCWRdCS0Wm2jJbNbOoZKC8R+hJX5WPfhzZefqxUPTMO4+NiuGKZdD3XIj6xKLz7PjsUNvY+t815GsNs9PvRLkx02JQc3KdF6uH1+bC6yQa1SQKeu8csGtVGoGHgxNM4iROX/Ca0tB/qqBByZ0RdO3wb8r1qL+2ar8eT0QcIaQS644jr88dtPWLtyGe6++WrM+vDr2hslg4tjDVrsKLFDpVAgPcG0xxkY3Rl76yeWSDoqMohyP8GocJas/vzzz1BS+G9Q2OCMRJyZmgszXHC4ffh2uwJf7tDUyZ+m5YIV/TrFGtEpRsY9SA5+2OyNcTwU1ZGZGT5zGsoGXwlXbF8oAx4YS9ZA66nAsT0TcIZpJfT2HDzw/cbauhL06T783GvQ6w1Y8tef+PS9N+vsx6BVCcG9rcQu4iI6mAFWItmnSAGxn2DK5g+/z8f7r//b7ITZl7eO0qOrshTBYAArC3x4a3ssvEGlCKwMU+7wIsaoQQ/ZJEvSQeB1zPolqdENMzPcCQNQNuhKeE2pUPmdiMr7A1q1AmN7xeM03VI4y3Lw+M+ba7MsunXvgZvuekD8z9oQWTu319mXUasWlV63FtuRV/lvO2WJRNIypIDYD3C2tLPEhjdnvSzy3cOcOaoLjjLuEq6LguoAnl9rRJ6zxj2RkJBQ+94gQkI8cDYlkXSszAwzog1akZkRib3rcTXlrrVRUHmrYcn6BXpzDMb1isUMzSJk52Tj5T+21wqP0867GEccfRzcbhfuuuEKUa0yEhFvoVWJQlNM85RIJC1HCoj9QF6FC0tXrUVJ7q7aZcnRWlzVuxzRCgdcviC+2BzCH6U1EebJySkYMnSoMO0yWj09ziTadEskHQ1aB/qkRAkxwWu9FoUSVb1moCpzOkJKDbSOIkTlzkV0XDLGZVpwqvovLN20Ex8vzRGrM+7hgadeQpTFgnWrluOdV59vsC9aIRgXwZLXLDglkUhahhQQ+5hKhxd5VU54bTXFbmoI4faxcchQlYhYytX5Xry4KRbBUI174uZbboZKqRIpmxQOXSKiziWSjgZjFHolR4lA4ciumiG1HuUDL4atMwOKQzBUboGhZBWSktNwXDcDTlX9hW+XbcOvG4vE+szAuP3+fxpuPfsYtm5a32Bf0QYNtEolthTahFtRIpE0Hykg9kO/i2AQSEuqcUmQIzOiMDUxHzr4UGoP4JEVRlT6aqrhXX7FFRg7Zizsbr/oZEjXBWdnEklHz8zITDKh2u2r08sioI9D6ZDr4UwYAEXAh6jCv6F2laJ7504YnabCqaoFeHPeRizPrhHok6efgePGT4Tf58N/b7yy0ZRMChbWh9hcaBUl5SUSSfOQI9E+hDenomqX6EpIl0RScjJUyhDuHQ3EKezwBBX4fFMQf5VHifX5+kUXXSSER7Xbi/QEo0zZlBxSmRld4wzC8haZmeGN6Y6Sw26EN6oLlH4nYnZ+i6BKh/7dUzEiwY/JyoV45uf1onw10zTveew5RMfEYvOGdXjzpacb3RdLwNP6t7nQJvYnkUj2jBQQ+7jfhV6jFpXx6JK45ZZbcNmRsRhiLIYCQWwu8ePxtbHC38tqfHyd67HpEPsGyBbdkkMtMyPcM6PIWjczw5U8AmUDLoFPHwe1uwrxG/8HT3QPDM9MxWHRDowLLMJDs9eJIlUJScm46+Ea4fDGC09h47rGW0qzlgSFCi0RFY6I+AuJRNIoUkDsI/IqnKLfRayxxjVBjhveH9f1s8IAL6q9SjyyTAtbQI3kpGQ88cQTwnVhc/ugVSnRPdFcp9GWRHIo9cyg5Y3t6mtRKFCdeQqqek5HQGOCxlmMpDWvwp0yAqN7pWKoqQJHeBfhvm/Xik61J06ehvEnTRXZGHffdBW8nsatDCx57fEHRYXYqsggTolE0gA5Iu0DeCPKrXSKWv+Rle98v9yFZGUlAiElVlrjcfRVL2DWrFn4bvZ3QjxwNsReGd0TTCLYSyI5lHtmqNWKuoM6A4sHXS6CKtkjRle9AwlrX4MrfSyO6Z2MIfoi9LH/jQdnbxCigFaI2PgEbNu8Ea8990ST+2MHT5c3IEREtVOWsZZImkIKiHaGIiC73AnWuGGKWpjgrj/RvWIRVAgiz6lByiUf4cQJEzFs2HDhtiD0xbJLYZqsNik5xGGMAjMzKATCVSdJSG1A8fDb4EwYJDIzjGXrEL/xPfh6ThDdOodpspFQ9jee+nULomPjcfejz4j3vfPqc9iwZlWT+2MHT4cngE1FViHiJRJJQ6SAaGeYGhYOnKwl4Id+zj0wKjxwBdUo6XU2NIk96ryPN0l6LFjeV7ouJBKIWAg2wqp0+kSKZ5iAMRHFI26Hx5IBRcANc8FCRO/6EYpeE3BMz0SMVG1FIGsRXvtzB8ZNmIyJU2eIJln/3Y0rg5ZCigi6EDcWWGGPSCeVSCQ1yJGpnQMns8ocMGhrAifDBBe+gLRQofh/izcFsSfeWud9wVBNwSjWe+DMSyKR1AzqXeNrMjMYWByZmeGJ74fSwVfDa0qD2lON6F0/wVC2Hoa+4zGqRzyOUq1H3sZF+GxFHu544HHEJSRix9ZNmPX8k7vdX3KUXsRQ0J0RWZNCIpFIAdGu5FY4hfkzJiJ+QekqQ+Kmd6CBH+V+PaKmPo6QSteg2BSDxmTBKImkLipmZiSZhWuP1r3IzAxb+nhU95wOnyEBalcJ4jZ/IFqCx/U9DsO6xmKcchWWLvkLK4r9+O8jNVkZb7/yLDaubTwrIywiaPmosHuFiIh0n0gkhzpSQLQTTAPLaSRw0v/lVYhWuhCAEtnxxyHY5Yg672PRHF8whIwEU21bY4lE8i/8XTAzg4HF7EobCVM77Z2OQVBjhtaWh4TVLyOgjUGXAaPRPzUKE5TL8N3cBYjpdxQmTD611pXh8zadccEiUyxsVe7wCBHBAEuJRCIFRLu16t5VZhd9siIDJ0Pb56KrfbUInMz2JyB+4p0iHS0SBk52itHLXhcSyW5gM6xeKVGiOitdDLUoVSgecRuciYMRUmmgr96B5BVPwhnbF70HHY6MBAMmKRfj3Z/+wswb7hdZGdu3bMTrLzTtyhCbFe4Mg2jyxd4ZdE9KJIc6UkC0AwVVLpGzzpzyWoI+6H+9GXpVAK6QFp7hl8MX1bnO+6wun0hZ6xZvqmO1kEgkDWFgMi0RLl+gjmshqI1C0Yg74Y7pBUUoBH3FZqQuewy2tKMwePAwdIlWY1JoAT6Yvx5X3/eseM+bLz2DTevX7NF9kmoxoLjaLbp4RpbYlkgORaSAaGMY85BV7kCUTiNuOGFs396JFJUdCoSwRdsfuoHTGgRO2jw+dIszChEhkUj2TGq0Xrj7GHRMy18YX3Q6SoZeC4+lmyh3bShbg5QVT8OeMQkjhgxGikmB431/YEm1EWNPOVO4Mu65+erdujIIf9Mp0QbRvVOKCMmhjhQQbUiQNR/KnHB7g7BEBE56yrPRNe9baJRBlIRiYDn2GgT0MQ0CJzmj4s1JIpE0D1rq0hOYmWEUvWYiMzOcaaNQ2fsMeM2doXZXwlS4GIlrZ8HV8xQcObg/knQBHO2cA93hpyMmKQ1bNq7H2688t8d9UkQwO4OWxq3FtjoppRLJoYQUEG1Isc2NgmpXg/gF5/vnIEYXQjCkxK7EsQh2ObLO65w5eQNB4bqQnTYlkpbBAT0j0SwqSPI3GJmZUdn7dNi6joHPmAyNswiW7F8RvfM7ePrNxOhBvZGg8WCEfQ6GXfEkoFRj1gtPikqVe4K1Wbi/vMoaERFp/ZBIDhXkaNVGMDKbNR/0alWdmg/Zv7+Nvpp8qBVB7EQqEo88CyG1vkHGBtPSEiNjJiQSSbPRa5iZYUa0XoMye4QbQqFE6aCr4UoaioAuFlp7PuI2fwRj0VIEB52BUf0zkKiyY6R/GYZc/DD8Pr9wZbBnxp7g7zz5HxHBzp9+KSIkhxhSQLQBnPFklztE3fzIZlkuhw0pSx+GUauAO6RFWdeJCCQNbiA8lEq2LjaK7oMSiaR1ROk1QkTw9xSZmRHSmlB82I1wx/VBUK2Hxp6PxLWvQmvNhmbo2TiiTzckKasxPrEEnSdehg1rV+G9N15u1j4pIij8cyqc2FYiRYTk0EIKiDaAGRechbAdcGT2xObXzkdGTEic5A3KTCSPmC7SzCKpcHrRKUZWnJRI2gL+BhvLzPCb01A6+AqRmUF01hwkL38CCr8dpuFnY3iPVKQpyjFjSAxiR07DK08/gl3btzZrn3Q7Jpr1oufN9hJ7nTgMiaQjIwXEXsJ88J1lDpGPTjNqmC1Lf8NI31LoNQpUhczwZExEIK5nnfeyzr5Jp0LnWBk4KZG0FWn/ZGZUuepmZriSDkNl75nwRPeAIuCBtnoXUhc/jKBKi7gjz8WgronopizGWWP7QZs5Cvfddh2CwWCzRQTTtrMrHNghRYTkEEEKiL10XeSUO0WL4UgLAhv0BL66GsnRGoSgwHplXyQPn1qnaBTfy5TPLrEGmbYpkbRDZkaX2IaZGdb0SbB1GwevpRtUPjv0lZuRuvRh+PXxSDv6XPRMiUWmMh9nTj4Km8q9+OTdN1pUITPOqBMTip2ldpGVJZF0ZKSA2AsYrMVy1bxpsFJdmDmv3oIjE11iVlIYioeiz0QELfWKRrn9MOs1Mm1TImnHzAxmRNXJzFCqUNn7LDhSRsJnSoPKUwVD8Wokr3gGPlNn9Dj2LHSNN6OfKhenTT8ZL7/zEfJzs5u9X1oh403aGhFRJkWEpGMjBUQrYQEZlqtWQgGD9l/XxbYNqzC46EtEGzXwQY2tmn5IGXZynffyZsb2wLQ+RLo9JBJJ28HfVu8US4PMjKDWjIp+58GVOBh+QyJUnnKY8+cjfsNb8MX2RN/jzhTCfqg2B5OmTcV/77u/Tmpoc/Yba9AKV8auMocUEZIOixQQe+G6YPplvPlf1wVTv1a9eDH6J6uhUSuRHUyCpv/JCBniG1gfovRqkbopkUjat2dGY5kZPnMaKvqcAXd8fwS1FqidpYjZ8R2it38Nf2J/DDzuNMToVDjCkIMuffrhw48/adF+OalgR93tJTYpIiQdFikgWgFnM9kVDV0XX7/xOCYlF8FiUMMBHbJ0fZE6+IQGJavtnprYB2l9kEj2TWZGr0YyM9wJg1DdfRLccX0RVBtEC/D4je/BlDcfwdShOGzsDGjhx7FReVifnYddufkt2i8b6VFE7Ci1izTvllgxJJKDASkgWpF1wRuCSlHXdZG1Yxuilr+MbjEqKFUqZAWToRkwGSFdVIOGWRa9BknS+iCR7IeeGb46padtXcbA3ukoeGJ7IqRQQ+0oQdKal6EvWwdFtyNx+JhpgN+D8bH5ePPTL+CKECDNFRFsO76tRIoIScdDCogWwB8/q00y64J9K8Iw1euLhy/G+HQFooxaWENG5Oh6ofPg4xtYHzgD6hJnlNYHiWS/9MwwoNQekZmhVKM6YwqcycPhic4AFCFobPlIXv4kNNYc6HqNRY++IxDyeTHGlIUX3/u4xWWrKSI4aZAiQtLRkAKiBZTYPMhlwShTXdfFN++/juNNW5FiUSGkVCM7ROvDVEBTN8OCPthogxZJFlmyWiLZH5kZPZLMIvao2PpvZgaDKqsyp4mgSq+5KxAKQmfNFlVkVe4KpI+9EP6QGgj6MMS3Cu/P/kVMBloCU7XZoZciglUrpYiQdASkgGgmtBwwt1tTr2BUYX4utn/5EA5LVcFs1KMiZEaOrifSh4yp837eMLiNznEGkS8ukUj2PfztMR6CWVKsIBvGb0qBlfEQiQPhM6cKsaCv3IbUJQ9B4XNi7GWPY/vWHVCG/OhU+Du+mruoxSKAIsKs02BrsRQRko6BFBDNhDcb9rqIdF3wBvDqfddiRq8AkqO18EGF3FASNAOmQVGvYZbtn7oPrFYnkUj2HxzIeydHiUypSue/6Z3u+H4iHoLBlUzvVPjdMJStQ8qyR6HVqDDqvHuxduVqqBUBmLZ+jZ8WrWhVVggfUkRIOgJSQDQTpmGx2VVkr4sfv/4c6ZWL0DdRBb1ej/KQBbm6nugx9NgG77d5fOgUrZexDxLJAQArx9IS4Q0ERU2WMPZOR8OVMADuhIHwG+Oh8DlgKlqGpFXPY9BhhyPY+UhsXr8BWoUfWPsZ/lixfq9ERK4UEZKDGCkgWklFeRl+eOl2TMhUISnWBE9QifxQAtQDpkOp+rcjJ6HrwqBRycwLieQAIiVaj55JZlhdXpFdJVAoUd39JBFQ6YnrJywRSq8Vltx5iF//Fq669W78vLoIO7Zuh07hhWPp+1i8bkvrRIRWjS1SREgOYqSAaCXP3HcrJnZxoHeyDhqNRlgfsrU90WvI6AbrVjl94mYle15IJAcW7JfRPcGMcoenthV3SK1HVeYp8EZ1gTemB3yGBCjdlaLQVKe8H3DXoy/ija/+QnZWLvQKD0oX/g9rtu1q8b7N+hpLBEWEdGdIDkakgGgFf/7+MzzrvsOoLmokxkbDGVCgIBQHRf9ToVLXFQmc2WjUCqRYZM8LieRAg27J7okmpMUYUGzz1GZXBPRxwhLhjeoKPx/GBKjd5Yjd/DHGd3Zh0oxzMOvTuSgrr4YRLuTMfRNbs3P3wp1hkyJCctAhBUQLsdusePX+GzC5lxp9O0eDv/eyoAU71L0w4LBRDdZn6iYb+rA6pUQiOfDQqJQiHiLBrBXdO8ODuDe6O+ydj4EnJkM03vLp4qFxlSBx/Zu4/7LJMMUl4bl3voMvoIAx5MCWX95AVkFxi/dv/ifFkyJC1omQHExIAdFCnn3kXhweXY6R6UZER0XBGQCKQ7EI9D8V6nrWBxac4a0gNdpQJ/hSIpEcWDC4uVdKlCj6VO74NzPDmXQY3PED4InpCb85FT5dDNSOIqRvewfP3XMNHJ4AHn3lU2j0UTAGrVj346soKClt8f7DdSIYWMlidbJ3huRgYJ8IiJdffhnp6ekiU2HkyJFYunTpbtf//PPP0adPH7H+wIED8eOPP+JAYN3yv7Hhl3cxuqsKPdPi4Pf7UBK0YIuqJw4bdmSj1oc4kwZxxn9TPyUSyYEJq0X2TokCtX5t4y2FAtau4+CL6gJPTCZ85k4IaKOgtedjinYpLpg2FpVWJ96fvRg6UwyM/iqsnP0qSioqWyUiwmWvZQMuycFAuwuITz/9FDfddBPuvfderFy5EoMHD8aJJ56IkpKSRtdftGgRzjzzTFx88cVYtWoVTjnlFPFYv77l6VJtidvlwkv334xJmWoc2zdJiBuHDygLRcPdZwZ0mrrWB/pSmSLWKcYo/KwSieTAh3Va6M5wRzbeUqpR1WMK/IZ4eGMyRVxEUKWH1pqNJ8Yb0L+LBUuWLkOWPQoagwUGXwWWffsKKquqW7z/cO8MdvHcWWb/t+S2RHIAogi1s8ONFocRI0bgpZdequ0b0aVLF1x77bW44447Gqx/+umnw+Fw4Pvvv69ddsQRR2DIkCF47bXX9rg/q9WK6OhoVFdXw2KxtNnnuPL6m7Hlu+dx5RFROOmwTgh63djpMWEBhmP4+Y/DqKubuskZDHXD8PQ4aNXSUySRHGw9b7aW2BFv0tZWjlW5yhG39ROo3NVQ23Khr9wCZSiAHQ4jxj6+GFV+HT78ajYKV3wLv8cOryEZo6dfC4vZ3OJjcHkDqHR50T3eJMpvswy3RLIvaMkY2q4jm9frxYoVK3D88f82lVIqleL533//3eh7uDxyfUKLRVPrezwe8YEjH20NLSefv/U8jktX4dgBaVAqVbD7gIqQBbbe0xuIB8LiNOwAKMWDRHJwwXilbvEmdIszoszurU3vDBjiRWZGUGOE39xJVK4MKZTIMLvxztldYVS48fjDD2DgpMuh0hqgdRVj0deviAlRS2GnX7o+aYXYVmyrPQaJ5ECiXUe3srIyBAIBJCcn11nO50VFRY2+h8tbsv6jjz4q1FL4QetGW3P77bfj+HQFjurfGVEGHfxeJ4qDZqxBLxx1+OEN1qf5U6dWID5Klq2WSA5G6HbkzJ+TgMj0Tq8lXbQAp4gIGBLhjB8omm8d1cOCpyaYsWn5AsybOw/9J1wuytlrHAVY+M1rcLmcrQrspEslq9whMjRa2gVUImlvDvrp8Z133ilMLeFHbm7Lc7H3xMcvP4wzxw7E0G7RgAKweRWoCplRkTlD+CvrY3X5EG/WIUoWjpJIDur0TgZVMr0zsnsnu3YyO4PBlEFDPFwJg6BVARMHJeKRsTq89th/EVLq0O/EywCVDipbrhARHo+7xcdA90miWY+cChe2FNng8f9TMVMi6egCIiEhASqVCsXFdXOj+TwlJaXR93B5S9bX6XTCTxP5aGsS3Fk4/rAe4rMEPQ4UB0xYFuqLMSOHNViXQU+BUAgpFr1M3ZRIOkh6J2s10J0RpqY+RKYQEX5jIpyJgxAXZcIJfcy4ZZgHT99zI5I7d0fvEy5FSKmFojoHf30zC17vvx1AmwvdoElROuRVOrG50PZv2W2JpCMLCK1Wi2HDhmHOnDm1yxhEyedHHtkw7ZFweeT65Lfffmty/X1C5xFQ+F3CVGn1AlUhE4q7nyqsDPWxuX0iHYzNeiQSScdJ71Qp8W/3TtEzYyJ8plQENWb4TalwJgxEp6R4jO+hwVGeuZj7w5fo3C0TmcdfjJBSA1TuwqJvZ8Hn87TKGpIcpUdhlQubC60iyFIi6fAuDKZwvvHGG3j33XexadMmXHnllSKo6MILLxSvn3feecINEeb666/Hzz//jKeffhqbN2/Gfffdh+XLl+Oaa67BfmPHPCiCfii8dhT5TVgS6o/jRw5tdFWH14/UGL34wUskko4BJwu9Uyw13Tvd4fRODap6TEVAF42g2ghfdDr8qUORlhCNCZkauL+9FdayYqRn9Eb3MRciqNAgUL4Tf387C/5WiAi1SomUaAOKrG5sKKiu00VUItkftPsox7TMp556Cvfcc49IxVy9erUQCOFAyZycHBQWFtauP2rUKHz00Ud4/fXXRc2IL774At988w0GDBiA/YaebpEQbD4lqkMm5HY5VdTOrw9nBTR5NmaZkEgkHaN7p83jq7UAhDRGVGVOQ1CtF1YGT0wvqLqNRIJZg+O7eLBz1tlQBDzo0bMfuh53AQIKDXxlO7H4u9aJCKZzsrItq2Wuz6/+t+CVRNIR60Dsa9qlDkTxJtg+uQRby934KXA4Bs28G90TTA1Xs7rFTWZAp+i22a9EIjmgYHXInaV27Cizi+DGsKVRY89HzLYvhaUypFDBt20efDnLUO4MITDoTJinPIKQSodNmzcg94//QQUfDEkZOGLy5VBqWj7h4G27xOaBUatC31SLdJlKOl4diA5D5U4UOpWwhYzYmTa1UfHA4EmmeiVb9PvlECUSyb5J70xPMIk24Gy8Fa4UyRLX1u6TROlrRSgAde/xqNJ3RpxRAd2mLxG16jVhiejbpz86HXsh/NDAVbITS2fPQrAVlggGaDOw0uULYH1BNUptLd+GRLK3SAHRDGyb5qDC5cP84CBMHNm/8XUYPGnQINbYMK1TIpF0HBiLUFMjgvEIrtoaEczKsHUZK/5XBjyIO/IcZNm1sGh88C55B3Eb3hUion/ffkg75gL4oIGjZCeWffcagl5XK0WEHoFACBvyq1FY3fJtSCR7gxQQzeA5nIMPfOOwOm4S+qQ0btJxeANIsejEzUUikXRsWJ+hpgW4rkGNCEfqEeJ/g8IP3dDTsa08CKWzFJr1nyJu43tQ+N0Y2K8/Uo+9CF5oYS/dhRWzX2mViCCMueJ9Z0O+FTmyHbhkHyJHu2bQu0silkeNxTGDezb6OvOytWoFYk0yeFIiOVRguWmmd9LyGOlCcKQeCVcCg75DyOyaiizDYGwvD8JZvAOWHd8jbuO7QkQM7tsXnY67CB7oYC3NxYrvXkbQbW/VsbCgnUmrxuYiG3aWOmQTLsk+QQqIZnDa8C744OLD0TclqtHXbW6/qFtv0cvKkxLJoUSUXoM+KVHQaZQot/8jIhQK2LoeL1wajIeYcMJY/Janw5ZiD1zF2xGd9TPiN7wDhc+JQX36oPOYS+GCAdayPKycTRHRun4+Zv2/7cDZP0OWvpa0N1JAtCB9qrHKkjQX+oIBJEfLypMSyaFIjFErqlWS2rRKUWhqErxRXWDQqjHl5JPx5SYfVmVXIVidD0v2r0JEKL12DOqdiW5jL4VTYUR1eSFWfvsSAo6KVh0L24Gz9Db7Z2wqtMqqlZJ2RQqIvYSxD/zRxhplGpVEcqjCYEaKCLc/EFFoSo3qHlPgNyahd88MDBnYH5+t82BtdjVUrjJYcuYgfuP/oPRUY2CvDHQfdzlsiihUV5Zg1Xcvwm9tvIFgc+IzeDwFlS5sLLDCIQtOSdoJKSD2ErvHh0SzThSQkkgkhy4sLtcryQy71went2bQZu2HysxTEdDHYsIJ4xBrMeLtJeXYVR2C2l2GqJy5iN/wNlSucgzI7IbeJ16BKmUMqqsrsXr2K/BXtq45oOafqpWMzVjHglNOWXBK0vZIAbEX+P/xMSbItt0SiQRAlzgjeiSaUeX01roPWK2ysud06GLTcPKJY6FTK/DsTztRrU6A2l2OqLw/hYhQO4rQN70TBk66CmXKRFTbrFj1/avwle5o1bHUVK3UC4vIuvwqUbdCImlLpIDYC2wevwiiimmkpbdEIjn0YBxUerwJ3RPMqHB64PXXTDKCWguqek5HzyFHYFi/DCiCPrzyRwHc5q5QuSthzv9LxERobLno1TkJw6dciWJVGqwOJ1b9+Do8BetbfTwsbuf/p1YEO3rKNE9JWyEFxF5AMyUVvqz9IJFIIqtVZiSahDWi1O6pzYagG6Oq5wwcdeJUdI3TIWfXDvxaFAevpTtUXitMhX8jfuO70FVtR4+UOIyeejnyNemwuTxY/cv/4N61uNXHxFoRWpVKBFbKNE9JWyFHvlZC86ROrZQ16CUSSQM4qeiZFIXOsQbhOgi7OwOGBASHX4xhR41D12glfvvhK+yKPwYeSzpUXjtMhUsQu+lD6MvWoltSNI4/9TLs0vUVnTdXzf0czs2/M/WrVcfEehVsTc40zy3F1lrriETSWqSAaCWi9oNJhyidrP0gkUgaD2TsmVxT8prVKsOzfr8xGV1nPoz4lM5IM3gx+9P3UJE5HR5Ldyj8LpiKliJ2y+cwFS4WgZnTZpyPbcZhcPoCWPnXj3Cs/RYIti49kxljDPrOKXdiY0F1bbCnRNIapIBoBeHaD0kWnaz9IJFIdptSyWqV7NLLvhlhERGwdEafC55DQKGCv2gT1i7+AxW9Zgp3BuMjTMXLEL3jO0TlzkG8WYszZ56BzdFHg2Umli+ZD+uyj0RfjdagVSuRYjGg2ObG2rxqEfApkbQGKSBagdMbgEEjaz9IJJI9wxTv3ikWJEbV9M0IN99KGXA0NEdeAW8ghI3zPoOrPB/lfc8WFSxDCgWMJStgyfoV0Tu/R7QOuHD6VGxNPAGugBIrVq9E+V81hahanaFhMYgaEUzz5HFJJC1FCohWQH9kQpRW1n6QSCTN7pvBRnxxZi2KIkTE5Mv+g6XenrA53Fj+/TtQu8pQ3vc8eKIzEVSqYShdDXPuHzUuDYUXl55yArK6nAJ7UItVmzaj6I/XRVGq1hDu5hkKQrQEzy53ICiDKyUtQAqIFkITJH/8iWb9/j4UiURyEGHSqdE31YJYo6a2g6darcaVD83CpxtD2LxlK/JW/AqtPRfl/S6AJ7YXgmo9DOXrYC5chLjNH8Hgr8Klk0ajvNcZqAxFYd3OHGT/Pgtqa3arj4uB4EaNGpsLrdhabJPBlZJmIwVEK6wPZp0aMUZZ+0EikbQM8z8ighkRjEGgiOjVdwBOOP8mfLDWh99//w3Bkq3QV21Fef8L4Y7vh4DGDF3FFpiKliB280fQOwtw/tghwNBzkR9KwJb8Umz99U1oStbu1XEx1TPrn+BKWf5a0hykgGghDq9PFGZhhLVEIpG0FBaf65dmEX9LbB4hIi695mbo0/pi1t9VmDN3LjSOQhhL16Cs3wVwJw5CQBcNrTUbpqLliN3yCQwVmzHjiF5IPuoCbA11xa4yG9b8/jE02fNbnebJgM8Ui14IG8ZFVDpkcKVk98hRsAX4AiGolEoRFS2RSCSthfUYaIngzJ8iQq3R4IGnXkaxU4k7P1qJrTuzoXaWwly0BOX9zoczZTj8uhhoHAUwFq9E9I5vYSpYhBMHdMKwE8/HSkV/FFpdWPLn91BtZpqnb++CK91+rM2rQkGVS1aulDSJFBAtgL7B6H+KsUgkEsnewHtJ37R/RUS/QUNwwRXXocQRwsXP/giHXwW1qxxRufNQ0etMONJGw69PgMpTCWPxctGIy7LrBxyebsHUU87AQvWRKHP4sfDvv4BVH7Y6Q0MEV1r0YrK0ocCKHaX22kJYEkkkUkC0ALUKwsTHUrUSiUTSZiJCXyMiLr/+NmT07I1tuaX4z6drENDFQOWpRnT2z6jOnAprt7HwGxKhDLhhLF5WU3Rq6xfoE6vApTOn4C/T8Sj3KDF/5Vq4l7wNtbN4r44tWq/B9hI7NhZa4fK2rniVpOMiBUQLoM9Slq6WSCRtLiLoztCrUeUD7n/yRSiVSnz6+VeYXRAHvzERSp8D0bt+gL3LOFR1Pxk+Y4qIdTCUrIKhdA3itnyMLupq3DxzPFYkTEWR34y/Nu5CxV9vQ1e5ba/ST5nqmV/lEh09ZVyEJBIpIFoAC0fR3CiRSCRtLSLCgZXJPQfinEuvEsvv+c+dyE4+Ab6ozlD4PYjeORuupCGo7H26WBZirYjy9dCXrUfslk+R5NqBO6YdiYLuM7ArkIxlO4uRPf8DGAr+bnVwJQPG06INsLr8WJtfJcSEjIuQECkgmkmcWYf0BNP+PgyJRNJBYWxV/zSLEBPTL70J3TIyUVJciCceuh+VmdPgiekBRdCPmF0/wGdMFrUivJZ0BFU66Kp3CCERs3M2YosX4boTBkA/9HSsCvbEhsJqrF0wG4bt30ERaJ0FQflPW3CVQinSPOnWCHcZlRy6SAHREn+gQQZPSiSS9k7xjEZqfDSuve8pEdD47ecfYf68uajufjLc8f3B0pGWnN+hCPlRNuhyUSsiqDZC7SgW7gxz/gLE7fwW54xIxZAxMzAvNBy7KtxY9PdCaNd+AKWnqtXHx3tgjEErAis3FlhlvYhDHCkgJBKJ5ACCblJaIo475mhMO/cysez+266H1WqDtdsJcKQeIZaxW6fWloPSgVfAkTwCQa1ZZF4YS1ZBX7ZOVK48MV2F06dMxk+asch1KDFv5QaElr8LjS2n1cfHEv7JUXoUVbuxLq8apbbWNfWSHPxIASGRSCQHGGy73S81GrfcdQ86dctAaUkRHr//DuZYwpE2CtZux4v/DWXra2pFDLgQti7HiYJT7ObJHhq6qm2I2/IJhhuLcdvMcZgfdRKyvBbM25AF65IPYCxe0eq4CLVKidRoPdy+gAiuzCqz13YalRw6SAEhkUgkByDMgBjaPRmPPPeqyMqY/cUn+OO3n8Rr7oRBqOoxFSGlBlprFqJ3/YSqzOmo6jEZPmOSWEdfsRm6yi0i8LKnbRnunzES29OmYr2/KxZtL8HOJd8hatePrS46RfcKy1+zM/HmIjs2FVqFoJAcOihCHSyc1mq1Ijo6GtXV1bBYLPv7cCQSiWSvC9hdfs0N+N+sFxGfmIxv5ixGdGyseE3tKELMjm9FmmdQY0ZVxmRheYjZ/jW0tlwoQkFRS8Id1wee6O6o7DYRby4pRs66BThGuRZdYnUY3r83nL1OQVAX0+pjZEBlidUtuo1mJkUhTqa7HxJjqBQQEolEcoBjszswZOhh2Ll9K06cMgNPvvxm7WtKT7UQEWwFTouEtftEIOivabxVuRXKoE909XTH9oHfmIzqjJPwU64aX8/7GxMUfyPVEMTovp0R6jMF3ujurT5Gdikus3mgUinQI9GETjFGWXSvg4+h0oUhkUgkBzhRZhPef+9d4cr45bsv8P23X9e+FtRFo7LXafBauon4B7osVD47ygZdCWfqSATURlFDgoGVWusuxG79HFPi8nDdtLH4STsRm10W/L42G64VH4v+GszyaG2qJ0tga1VM9bRic5F0aXR0pICQSCSSg4BRRx6B2267Tfz/+N03IyuvoPa1kFqPqsxpcCUOEoGR5rz5MJatRVn/i2DtdiIC+jgoQgHoqnZAV7Ud5tw/cLjzDzw8fSjWxE/CUl93/LG1BNkrfkX0tq+h8Lv2KhU1waxHToVTNOSqkNUrOyzShSGRSCQHCR6PByNGjMC6detw1LiJeODFd5AQpf93BZa3Ll2DqLw/hCXBZ05DdfokmIqXwbLzexEXAaVK1I1wx/YSZbLLukzCSyscyNm0DOOUK9E9VosRfbrClTlFvH+vXRpKBTLo0og1iv8lBzbShSGRSCQdEJ1Oh/feew8ajQZ/zfkJc3/4UgQv1s4DFQpR6roq8xSE1Dpo7AWI2/opXAkDUD7wEvE3BCWUfif05RugteYgeefnuG2AHeOOGYPPQ2OxrlKFOat3QLX2Q9H1s7WpnrUuDbUSm4psIktDNuTqWEgBIZFIJAcRQ4YMwb333iv+f+Gh/8BRUYIiq7tOHQaWuK7ofZZwXSi9NsRu+QwhhQplg66APW0UgmoDlAGvcGdoq7MQlTsXpxuX4fapw/GzbgKWO5Pxy/pCVK79GdE7v4PC794rl0aiWYe8ShfW5FXJwlMdCOnCkEgkkoMMv9+PUaNGYdmyZRg3/gQ89vpHKLN5xYyfza/CcOCPzvoJ2upd4rkzeRgcycMRvetHmPP+hMZRhJBKh6DGAE90JgKGeOQkH48HF1ihLFqNY5Vr0C/FhIE9usLW42T4TamtPmYONeUOL4IIIT3OhK7xxjrHKjkwkC4MiUQi6cCo1WrhytDr9Zjz26/4+4dPkRZrQInNXSfzQQRX9pgKR8rh4jmrT1I8VHc/CZV9z4EnrjcQCog6EvqKjdDYcpGe9w2ePcKJXkOOwieBMVhSFMIfa7dDv+5DGIuWttqlwcJTCWYdzFo1tpXYsCG/GjZ364pYSQ4MpAVCIpFIDlKee+453HjjjTAajVi2YiVUMWnYVWYXDa9MOnWddXWVW2HJ/lV05AxoLajOOBnKgBvRW78UGRtKv0tYI/yGeHjNXeCzdMHvwRF4bn4ORvmXYaC2EKMy4hHXpTes6RMQ1LS+O7GfhafsHpi0KmQkmpFi0cuaEQcIspCUFBASieQQIBgMYvz48Zg7dy5GjhyJ+fMXoMDqwfYShwhejDXWrQipcpUhZsd3ULEjp1IFW+fj4LF0R/TO7/H/9s4DSsr6auPP9Lq7s72wlSbSREBQBEVCUNGosR9b9GiI/fuMmhjLZ0mMyjGJJbbEgoldA8aCSEQMUSlKkd5ke5/dnd5n3u/cu+wGVsru7Gy/v3Pes1N3/vNnmfeZW55rqV0Nna8OMY0JikaPoG04e0x8b5uJe76KwNKyHaepv8NxwywYW5QDT/GZCKUUd2v9Dl8I/nAUBWkmlGRYeVCX0LdICkMQBGEIQMZSixYt4g/8tWvXYuHCx1CUbsH4YSlQoBzcoQEgaspA85jLELSNBGJRJFWsgLX2a7SMOh8tx1yMgG00m1GRDwS5WOrc1RhpX4EXp9ejeMxkvBGdg39XA6u2lsO4412uoyDXy3ixmfVse11u92FTpQN2jxRYDiQkAiEIgjDAee2113DllVdybcSaNWswZcoUtHhD2FXvhtMXRnay8WAPBkXhFk1rzZd8OWLKZItrTdCFlL1LYGraAk3Ii6jOwnUU1NURMaVhefQEPL7GiROi32G6vgwnDU9HRm4Be01QAWZ3PCOaPCEoqtYCy4I0M0dQhN5HUhgiIARBGELQx/jFF1+M9957D8ceeyzWr18Pk8kEbzCCPfVubvOkAkaD9uAUARVNppR+DHXYx2kLV+FchK3DkFy6FJbatdB7qhDVmQGVGuGkIkQNySg3j8Nd61MBRynmqddjcp4B4/PT4SucDX/GRPaiiBdfKIIWXwiZSQaMyLRyhELoXURAiIAQBGGI0dTUhAkTJqC2tha33HILnnrqKb49GIliX6MH5U0+pJj0sHYorlSHPEimVk9yqQTgz5gAd/4pMDds4qJLKr6kqZ7kHRHTW7nAMmBMxzO1Y/HxLifmqb/FlCQHZoxIhy5rFFxF87pVYEl+FpTK0GpUKMmgoVwmaKXds9cQASECQhCEIciyZctw5pln8uVPPvkEZ5xxBl+OxRRUtviwt9EDDVRItxoOfqISg6V2DSx1aw9KaagjASTv+wDmxs087TNqSOGH0+AuGh++OnYs7t1gwajwHpym34YZxTYMy0qHu3AugqmjuvVeqMXTFQgjN8WEkkwLko26bv0+oXOIgBABIQjCEOXWW2/F008/jezsbJ6ZkZmZ2X4fFVXubvDAH4og09qhLoJSGq5yNp7ilIZaB3fBqQimjEJS1Uqe1Glw7oOi0kHR6BA12hC25KJJnY4Hdpfg+0YPztB8g+mZEUwpTEUkazzc+adyDUV32j0bPUHuzqB5GiQmZJ5GzyICQgSEIAhDFL/fzwO3tm3bhnPOOQfvv/8+mzi1Qd/qqS6CLKVJRHQsVuSURvkynpNBUCTBVfhj6F1lLC6MTTugCToRMdi43CGUVISw1owlLcPxp53JmKbeiTnmfTh5eBpSUjPgLprLRZjdwekPwxuKIDfFyGkNsscWegYRECIgBEEYwnz33XeYNm0aQqEQXnjhBSxYsOCg+8mtcp/dgwqqizDqYTUeXBfx3y6Nrzi9QcZTZB4V1SchuexTmBvWQ+8q56me5CcRNaQibMlBWSgZ9+4ohNfnwxna9ZiVr8GxOckIZB0Hz7BZXKgZL2GKRriDMBv+az4l0YjEIwJCBIQgCEOcP/zhD7jjjjvYpXLDhg045phjDrq/rS6CUg8qqouw6A+KVBBabx1bX7PxlErFczS8OSfC3LiJB3AZWvawDTalM1SKglBSIfwqIxZVD8Pr1Zk4Sb0NP06u4nZPY3I6F1iGkwq6HY3wBMPIs5H5lEQjEo0ICBEQgiAMccilct68eVixYgUmT56M1atXQ6//YQSAvtXvbXDD5Y8gK8nwg44HVTSIpMovePw3ETFnwVl8JndmUPeG0b4VencFRyeo3TOmT0LYnIstLgMe2lMCJRLAWbqNmF1k4BM+jRv35M3sfjTCE4RJaiMSjggIERCCIAiorq7GxIkT0dzcjNtvvx2PP/74IR9HfhF7Gzyoc/rZe8Gs75DS4Fkae5BU8VnrzAy1llMS/vQJsNSvhbVqFQyO77n4MmpMBZQIRxqcUQNeKc/A+035OFG9HfPT63FCcRq0FhvXVYSTixJSG0HpjOIMC1JMEo3oLiIgREAIgiAw//znP3Heeee1t3mefvrph/1WX97kRZndB71GjVTLDyMErQWWy7mgkgglFXBagkRFctkyGJt38n0cjVBroGjMCFrysL4R+ENZCcIKcI7xO/yo2MD+DuQ5wbUR3ejUoHWTb4RBq2YRQakNGRMePyIgREAIgiC0c9NNN+HZZ59FVlYWNm/ezC2eh4JOBw3uIPY0eDgqkZ10iEJFRYGp8TtYq//DczMoFUHGU4HUY2GpW8OFlwbHPqjDHp7sqY4GEbbkoTFsxOtlVnzoGoHj1XtxflY9JhfaoDEmw104p3U+RwJ8I7KSWjs1DiWAhKMjAkIEhCAIwkGtndSVsXXrVjaX+vjjj3kQ15FOxt9TSsMV4Imeh0ppaAIOJJd/Cp2nmq9Tq6araC6nMSgaQSkPg6sMMZ2ZPSUUlRp+SwHW14Xw16oiNMOK80xbMK9Ex7M6qF3UXTCn2y6WTd4gSPPQPI38VLNM+Byo0zgp73b55ZfzImw2G6699lp4PJ4jPmf27NlcCXzgcf311/fkMgVBEAY1NBfjrbfegtFo5DTGE088ccTHU2fDuGEpGJllhTsQQbM3dNBUT4I6L1pGXwQPmUWptZy6SN/+N2j9DWgeczlcw+fDlzWJIxTaYAsLCLN7H2ak+/Hw2CqcYd6Fd33H49EdaVhX7oDavgvp2xfBaN/MUY54oGgJRSBI8FBNB0347DiRVEgcPRqBIEtV8mWnPuRwOIxrrrmGDU7eeOONIwqI0aNH46GHHmq/jdqQOhtNkAiEIAjCoXn++edxww03QKfT4auvvuLP4yNBp4fG/SkNT+DQXRqEJtDMtRE6T80BtRE/hjoaRlLFchiad8PgKmUXS5qnQZ0dPnM+RyPercvG3lgezrZsx9nFKo5G0EAvGuzV3QmfNJE0HFMwzGbkMeeWDnNAhH6awtixYwfGjh2Lb775BlOnTuXbSPnOnz8fVVVVyMvLO6yAmDRp0lEV8uEQASEIgnBo6OP+wgsvxOLFi1FSUoKNGzfy5+XR8AQj+1MafiST8dShTsRKDKbGTbBWf9VaG6HWwZs3A77M49g3wlL9FfTucui8tYgYM6BSqH7ChMpYOj4vC+IT/xiYEcTVuZWYkm9hkdPqOzENUMffXUHDxKjIktZMRZbUsSHDufp5CoN6jilt0SYeiLlz53Lebe3atUd87uuvv46MjAyMHz8ev/nNb+Dz+XpqmYIgCEMGSgm/9NJLKC4uRmlpKa677rpOhffp5DsuLxnHZCchEI6gwR3gb/gH/3I1/FmT0XzslRyBIBFhrfo3Une/zdebxv0M3ryZ3PqpjgagDvuhQIWiaAUuHRXDLTk7UKKqwx9qxuO5rWrUtHh4pDilRfTO0rjfM40wH2Yz0wKxtdqFLdVOTskI3afHBERdXR1X/B6IVqtFWloa33c4LrvsMrz22mtYuXIli4e///3vuOKKKw77+GAwyIrpwEMQBEE4NPTF7u233+bP4/fee4/TGp2BvrUXZ1hxXEEqkoxa1Dr9bIndEaqNcIy6kFMYitYAnbceaTvf5ImejuFnwzHqfPiyJiNkzYfO3wBFrYEh4sasFDuuHR3EFZa1qAgYcPeOYnxe5kfE2wLb3iVI+f4DqEPxf76TRwRFH0g8bKpswe46N/yhH65f6EEBcdddd/2gyLHjsXPnTsQLebZTnzLNtacCzL/97W9YsmQJvv/++0M+/pFHHuFwS9tRUNA9m1RBEITBDnVkPPbYY3z5tttuw6ZNmzr93DSLHhPzbShOt8DhD3GdwQ+iGCoVAhkT0DT2agTSjuH0Bs3WSN/xNy6qbBp3DTwFs+HLOA6K2gBtoAlRrQn5qMf5RUFckVODWeoteLMuH49sSUJZsx8Gx16kb3sV5rp1QCzarSJLi17Ls0A2VLSgxuHn7g2h63S5BqKxsRFNTU1HfMzw4cM5ikDOZy0tLe23RyIRrgJ+99138dOf/rRTr+f1emG1Wg9rgEIRCDraoAgEiQipgRAEQTg89NF/7rnn4sMPP8SoUaPw7bffdukzk55f7wpibyN5RoR5sufhDJz0zn1Iqvgcmv0RBPJ8cBfMhibkQVLlCuhcFdzyqYpFETGmQhN0wY4U/LtGhV3+ZGyOluAnWQ04oyDCJ/+oMY2f350pn7R+hz8M334nSyqyFO8I9K8iSvqjnDJlCt+2fPly7kE+UhFlR6hSeObMmTxdjixZj4YUUQqCIHS+1Z6K1isrK3HRRRdxaqPjQK2jQYZTNJCr1hmAVa9F8mHspFXRECy1a2Bu2MARCS6yzD0RvsxJMDVt4eJLra+eCy1juiQoaj0Q9mKbz4YN9RFsixbApUnFdUWNGJeh5VHiLETyT0XMcPRC0MMRicbQ5A2BbDHybWbkp5kO6XsxVHD1BwHR1sZZX1/POba2Nk4qqmxr4ySf9h/96EecpqCQGqUp6D7q1EhPT2fHNAqv5efn49///nenXlMEhCAIQudZs2YNZs2axRHiJ598ErfeemuXfwelAGocPuyzexEMx5BpPXS7J6Hx25Fc+Tl07qrW5+6PJlBnhrV6FYxN27lTg8QEDe5SRwIcJfiP3YpyjxqbYiNRYlPj8kIH0s1a9qDwZZ8Ab87UbnVrUD1EszcIq0mH4nQzt5MORUtsV38REKRub775Zg6RUffFBRdcgKeeeopTEkRZWRm3ElHBJLVvkgqmgklyS6PUBaUiKNVx7733ig+EIAhCD0Gfy//zP//DhZWrVq3CSSedFPdwqzK7t7Xd06CH1XiYb/KKAmPzdrbDJudKgp0oh53CaQ6a/kkOlzTlUx3xIWLKhDrYgiqvFl82GtEYMWObUoyfFIQxOzsArUaFqD6Z52oEU0dzDUY80OnQFYjAGwoj3WLgtEaG9Ydjzgczrv4iIPoCERCCIAhdg04Dl156Kd555x2O+G7YsAGZmZlxpwSqHX6U2r2IRBVkWA2HHbWtigRa0xqNm9rTGj7yfsieDFPTdlhrv4bG3wS9q5zvi+qsgNeOzU4DvnMaUaekwWEYhquGezEiqbWwkkyoKK0RseTEvR8UUaFujaiiIDfFyLbYQ2XSp0sEhAgIQRCEruB2u9mZcteuXZg3bx6WLl0KjSb+ORIOX4hFRL0rgBTjEaIR1CLqa4S16gvo3ZV8vTWaMBMhawGsdathatzcKiQ8VYgabBxhcDuasKbZjJqQCftiOcjJzMRFBU4k7z/PB9LHwpN3MmI0GTROQpEY7N7WSZ/5qSb2kzDpB/dsDZcICBEQgiAIXWXbtm1cj0bmfffdd99BIwXiHbVd3eJDWZPvqNEISmsYHLthrfpPe7dG2JoHd/5sNqkiUyqKROh89Sw4wmRzHfKjttmJtY4kOGNm7FMNw8ySFJyS5uTXaYto+LKncPtovFChKLWsWo06FKW11kfotYOzPkIEhAgIQRCEuCAn4Dbzvvfff59bPbuL0xdGqd2DencASQYdD+s6LLEwzPUbYKlbx26WRCBtDEcTSDxQ3URrNKIamrAbYVMGwm47vrf7scWXCpdiQbOpEGePNGKUyd36K3VWePJOQiB9HIuR7tRHeIJh9sIoTLMgM+kIgmiAIgJCBIQgCELcUEElFVYmJSVh3bp1GDNmTLd/J9VGkGlTaVNrpwZFI47U5aAOuWGt+Yq7Mgjutsg6nl0sTc07YKlbC3XAyWkNKFFE9Clw26uxqzmGfZE0tChWmDOKcWYxkKr2t67BlMGFluwfEWdhJNVHUHomFI3xcLH8NDPSLYOn0FIEhAgIQRCEuKG2e5pdRB0ZJB5oflGiPk9dgTBKG71shW3Ra7k48UgnX2rntFataq+PiGlN7B8RsI2CtX4d10eQ2CAhoag0CKlNsNdVYJdLh2olHQ5VCkYUFWNmVgB6pXUGBs3mICHRnULLcDTW6sIJICfFyDUSNvPAN6ISASECQhAEoVuQhw+ZAJJfz3nnnYd//OMf3I6fCOhbfJ0rgNJGD0/6pGgEDb06LIrS6mZJ6YtAc+vvMKTAkzeTWzyttV/B0LKHZ2XoPTUsMtxhoLG2HKUBC2qVNPh1GZgyugDjLG6olGh76yj9jqgxtVvTPlt8IWjVKuSmmJCXakLykVI0/RwRECIgBEEQug2lL8hkKhQKcUElFVYmEipOLG/yotoRgE6tYitp9ZFSATQy3L6FWz/VYS/fRGZTJAKoYNJa8yUbVGlCTmi9dYhpzWh0B9DcWI2qcArqkAZtcg5mjM5FjtrBwoSniKaP46hGdzo2/KEoWvzB/dM/TcizmWA51Njzfo4ICBEQgiAICYHGf9PYb4IGG1I0IpHQKajRHWQXS6otSDXrj2olTbbYpoaNsNR/w5fb0hLe3BlQRQNcO0GdGppgC3S+BgS1VlTbnfC01KM2ZkM90pCRU4hpxWmwRh2t61Br4c+cBG/OCVC0prjfjy8UQYsvDLNew2kNikoMpNZPERAiIARBEBLGLbfcgj//+c+wWCz4+uuvOzWXqKvQaPCqFh8qm32IxsCFiYezw25DFfaxiDA1fgdVLMK3BVOGczSBJnxaalZDE3RCE2ji616YUV5vR8TTjDolFc2adBQVlGB8ngX6cGvHBrV7+rKmcMGmojXG/X48gQicgRCsBi0LiZwUE4y6/i8kRECIgBAEQUgYNCeDBiGuWLECRUVF+Oabb+J2qjwaVJhIaY16dxBmneaoRZYE1T5YatfC1LSN0xwEDdry5EyD3lvDLaHqkBfagJ2jEvagHpX1jdCGnFwf4dVlYvTI4Six6aCJtFprx7RG9o/wZx4ft4eEoihc40GFo+QhUZBqYg+J/iwkRECIgBAEQUj4bKPp06dj7969XBfx2WefQa/vma6D9iJLu5e/yVM0ojMnXU2gBZba1TC27Npf36BCIHU0t37SXA1L/bdQhQPQ+u1Qh5yo9KhQ19gIc9TN9RERcy7GjixGpglQ70+NUEGmL+cE+DKPi3tYl6IocAcicAdbhUS+zdhvIxIiIERACIIgJJwdO3bgxBNP5M9Zqov4y1/+0qP+B1RPUNHkQ5XDD5UCpB/JybLDxE9r7WruzGDahETGJBjcZTA3bIQqEuS0hhJwYF9LDE0tTUhW3FwfobPlY8zwIiRpo+2pkZjO0hqRyJjYrYiEu01I7E9tZCf3rxoJERAiIARBEHqETz75BGeffTZisRgWLlyIO++8s0dfj05RNNiqrMnLxZZWgw7JRm2nhIvW18AdGwbH3vbbqHXTmzkJBlc5D/EiIUGtoRGfA7vtQbjdDqTCA7sqFdaMQowsyodeFYVqf2okpjNzjYQ/87iECAnq1MhLoRoJY7/o2hABIQJCEAShx3jyySfxv//7v3z53XffxYUXXtjjr0lOlpTWoLkaHj/ZSRs6/c2dhUTd2v9GJLhGYgR8GRPZgMpMRZgkJIIOeF1N2NXoR9jvZiHh0qQgJasIhfkF0OAAIaE1cWqEhUScxZYH1kjQe2kTEke0+u5hRECIgBAEQegx6LRx6623cmeG0WjEypUrObXRG1Bao6rZjyqHD7EYeC7FkSyxO6Y2KCJhdOxprZGg9s/kQhYSOm89zPZWIUFFmY7mRuxp8CAW9iEdbgS0yUjNKUZ2bj7UiLU/v7Vro9ViuzvtnyQknP4Q10XkJFONhLFTBaSJRgSECAhBEIQeJRqNsifERx99xB0ZZHddUlLSa6/f3q3hCsCo08Jm1h3ZhOoAKGVhqfsGxuYd7V0bYUsO1zdQFKJNSKhCHtTX16LM7gaiQWTABUVvQVpOMWzZBXQCbf+dZGTlz5gAX/ZkxPTJ3RJIDn8YWo0K2UlG5KYY2RtD3UtDu0RAiIAQBEHocTweD0455RRs3LiRZ2aQR0Rqavy20PF0azS4Ayhv8sHhCyPFqIPV2Pk6AnXQCUvDehjtW9uLJcnW2pc+AapYCGb7ZqjDPsRCPlTX1qDS7oRWCSEdLo68pGYVwZxZwOKhLbVBzpaBtGPhzZ6KKI0c74YvhtPfOo003apnZ8uuRFviRQSECAhBEIRegWZlUHsn/Zw5cyaWL18Okyn+UH68J9tahx8VLT62lE63GLrUIkmGVObGjWxIpY4E/tt1kTGe4hUwN23hgV2hUBCVVZWobXZBjyCnNpJNOqRmDoMuvYjHhpPwAFTtpla+7KkIW4fFPf2ThnaROApHo0gx67lzg2aH9FQLqAgIERCCIAi9xpYtW9gbgj53zz33XLz33nvQanu/o8AdCLOTZY0zABqT2Rk3ywNRRYMw2bfC3LCBBQNB0QWKKET1Vpiad3L6wxsIoayyEvVON6zwIw0epJs1SE3PgsaWj7A5C+posF1IUHqEWkCDtlEcoYg32uLyh+ELR7gFlCyys5INCS+4FAEhAkIQBKFXodHf8+bNQzAYxM9//nO88MILvV4AeGDbJwmJeOojmFgUBsceNp6iDg5GpUIwuQQRUzr0rkrofHVw+ULYW1UDu7O1Y8Om9iLTpEaGLRlIzkMouQhqTo20nmajhmQutgykj4OiMXSzcyMCo1bNImJ4pjVhEQkRECIgBEEQep3FixfjoosuYo+I+++/Hw888ECfrYW+sZNvBPlH0JCurvhHtKMo0HkqYalfD72ztP3miCkDoaR8aAIOGFxlLFh2VDbA4XZxfUSa2oscsxoZyUbAkolQSgkLhrY6C+rc4ILLzEmIGVK6NwHUF8LU4lQ22UoEIiBEQAiCIPQJzz//PG644Qa+/Mwzz+DGG2/s0/UEI1HUOQMckSBbbBoZfrRpn4eCUhfkYGls2g5VrLW4kbwgKMqAaBgGdznsLi+2VrawGVUKvMjVOJBjUSPTaoDaYEHQNhwRQxrU+5/PUY2UEfBlTULYWhBXnUSt048pRSIgEoIICEEQhL6FIg8PPvggX3711Vdx1VVX9fWSuD2yusWPaocfwUgMaebOzdfoiCoSgMm+BSb7d9AEXftvVCFIAkCthc5bi8bmFmyucsLpcSMJARRqGpFvARc/Uk1GMKkQEWve/tSGqj2qQUIimDqmSw6XIiASiAgIQRCEvoVOK+RU+dRTT0GtVuOdd97BBRdcgP4AtUZWt/y30DLu1kglBoNzH0wNG6F3V7bfHDWkIKpPgTrgQKO9AVuqnXB4vTAqIRRomjHCHERmEgkJFSLGdISSCgCNDoqqNSqiaA3wp41jh0tqKT0aIiASiAgIQRCEvofqIKiY8uWXX4ZOp8M///lPnHnmmegPtBVaVrX4udCSBASZNXVmUNfhHC7N9s2t6Y39UzwVtRYRYypU0Qga6muxtcaJJm8QeiWEHI0T4yweZFt1LCSiOgsipmzE9BYoGiM/l6D0CNVJUA3F4bo3REAkEBEQgiAI/cet8vLLL8fbb7/Nxks0iGv27NnoL8RiCuyeICqafbB7QjDrNEjpasdGhzZQY/NOmBo3Q+tvbL+dPCViKg3qG+3YXt0CuzcIrRJGqsqHCck+5Fui0GtUiGlMiBqTEdWlcFokarCxcIjpk7jo0p8+ji8fiAiIBCICQhAEof8QDoc5ffHhhx/CYrFg6dKl7F7Zn6BBXQ3uViERd8dGx+4Nby3XShhadrV3XxBRrQn1zU5sr2pGozcEHcIwq8IYl+RHcbICM4JQ1HpObyhqDVdIRPVJnBaBWsPmVCQmuHhTpRYBkUhEQAiCIPQvAoEAG0yRS6XZbGYRceqpp6K/EYrEUO/yo6LZz6ZUyUZdt42aVJFAa1TCTlEJ+3/vUBQ0eELYWd2EaneEJ32mwMciYniqjrs4EIsgYspETGOAJuxlAUHFlm2CgvwkyvQjcNzIQhEQiUAEhCAIQv8UETR869NPP2URQUO4TjvtNPRHyBq7zulHZYsf3kAENrMeFkM3nTUVBVpfHTtdGikqsb9Wgqyvmzxh7K5tQpmL5mmokK64kGdVoSTDjFQDoAm2sGCIGGzQhD3QBJ08sCtiSoNDsSDjhAtgK5mckPcuAkIEhCAIQr8UET/96U+xbNkynpdBImLOnDnor1DrZ43Dz+2f/nCUCy3j8ZDoCIkHQ8tumJq2Qeepbr2RHCbdDuypd6Pa4YMbRtjgRbEpiGHpyUhLSYYm7ObuD0pvqGJRaP0NCAd90Pz4QaSOPAGJQASECAhBEIR+KyKoJoLSGFRY+Y9//APz589Hf4bSGbWOAIsJ9pCwxOchcSjIzdLYvA2mpu3t8zd8XjfKaxtQ2+KDAyZoEcUIgwsFNgNsGXlQqTVQYmE0NDth90ThH3cpfnzmOdBour8mERAiIARBEPotNC+DLK+psJKGbr322mu45JJL0N8hD4kahw+1zgAiUYUjEgmbiqnEoHdXcL2EoWUPu136g2FU11SirtmFUAzwwIRhWg/ytQ7sLq1CeZMfEa0FL69ugk+djCeffBLnn39+t5YhAkIEhCAIQr/vzrj66qvxxhtvcLcDWWAvWLAAAwGnL8xphlpXgFtBSUgYtIkbr80pDsdeGJu3s0lVKBJFWa0dLY1ViEXC8MEIXdSPjEAFvF4vHljuxIaK1ugFTULtjogQASECQhAEYUCYTd1888147rnn+Pqjjz6KX//61xgIKIoCBwsJP+pcra6WJCT02vjGdR8OSmtQ0SVFJuCuw7vLPofNloIMPc3TUCEQU+P+lX5sX7OKhVh+fj5KS0vjTmd05Rya2HcqCIIgCJ2EbK5p4Nbdd9/N1++66y62wCYDqv6OSqXiwVzj8pIxuTCVx2rTZExytqR20ERBxlG+7KloPvYKrIodj0++rcTmDd9hS2kDSr16hNV6WFyl7aKmsrIS//nPf9AbdL+cVBAEQRC6cSJ++OGHkZaWhjvuuIPz+OXl5Xj99de53XMgrD/NokeqWYdmW4gjEg2uIN+X6IhEtTOML2r0+KJGQV6pC+PTNmNsYRq2VjgPelxtbS16A4lACIIgCH3O7bffjrfeegsGgwHvv/8+e0TU19djoKBSqdjMacKwFBxfaOOBWYmOSGRkZLS9Gmq8Giyv1OPpzQYEOwRscnNz0RuIgBAEQRD6BdSJ8dlnn3E0Yt26dTjxxBOxY8cODCRU+4XExPxWIZHI1Mak449HVnY2z8k44BUPeu2CggLMmjULvYEICEEQBKHfMHPmTKxevRojRoxAWVkZpk+fjg8++AADDVWHiMSBQiIYia/GQ6PWcJpn/wv84PWIJ554IiF+EJ1BBIQgCILQrxg9ejSLCBq65Xa7eY7GQw89xF0bg0FIOPxhFhJkmd1V5pw2BwsXLkRWVtZBt1P3RXdbOLuKtHEKgiAI/dYr4pe//CX+/Oc/83WapfHqq68O6M92RVHQ4iNDKj/q3QFE4zSkisai2LRxI/bWNmHa8Eyc9aNTxImyu4iAEARBGFy88soruP766xEKhXDMMcfg7bffxnHHHYeBjLLfR4LGcZOPRJiEhEkPk75rIqAvx3lLCkMQBEHo11xzzTVYtWoVhg0bhl27dnFdxLPPPssn4YGKar+PxLG5rT4SBWkmeEOtkQka4jUQEAEhCIIg9HtINGzatAlnnXUWz9K46aabcOGFF6KlpQUDGZVKxePCx+amYHJRGorSzTz5k6yyvcH+LSREQAiCIAgDAvJBoAFcf/rTn6DT6bB48WJMmjQJK1aswGAgxaTDGIpIFKViRKYVwSgJCT88gUi/jLaIgBAEQRAG1Dd2srv++uuvudWzoqICc+fOxQ033MAdG4OBZKMOo7KTMKUoDaOyrIgoMdQ4/XD5w/1KSIiAEARBEAYcU6dO5ZTGjTfeyNdpmueECRMGTTSCsBq0GJFl5SLJY7KToKiAGmeAx4rH+oGQEAEhCIIgDEisVisP4/r8889RXFzMMzQoGnHVVVf12jyI3sCs16Ik04qpRakYm5sEtQqoc/rZmKovdYQICEEQBGFAQ3MztmzZwoWVlOL4+9//zu2eVCtBXhKDBaNOg8J0C6YUp2LcsBQe1GXQ9d1pXASEIAiCMCiiEWQ4tWbNGpxwwglcD0EmVFRk+emnn/ar2oHuYtBqkJ9q5vbPsXnJSDbp0BeIgBAEQRAGDdOmTWMR8eKLL3LXxvbt23HGGWdg9uzZ+PLLLzGY0GvVyEoyQqfpm1O5CAhBEARhUKFWq3Httddi9+7duO2223hEOBlR0ZTK+fPn49tvv+3rJQ4KREAIgiAIg5LU1FT88Y9/xN69e7FgwQKeFfHJJ59wioPqJshTYiAO6GqD6jv6sutEBIQgCIIwqKFJlS+88AJ27tyJK664goXEF198gXPOOQdjx47Fc889x7MfBgqlpaW4++67UVBQwF0n27Zt65N1iIAQBEEQhgQjR47kDg06Ad955508NIpma5CXRE5ODi677DIuuIxGuz5mu6fx+Xw8rpvqOchA65FHHkF9fT2ys7P5/QwqAfHwww9jxowZMJvNsNlsnXoOVcn+3//9H3Jzc2EymVhZ7dmzp6eWKAiCIAxB6Jv7woULUVlZiSeffBLjxo1DIBDAm2++ySfowsJCFhVLly6F3+/vs3W6XC5eE838oILQiy66qL2jZN68eSwo6D2cffbZfbK+Hhvnff/997NwqKqqwksvvQSHw3HU5zz22GOsqmjee0lJCe677z7u7aUqWqPR2KnXlXHegiAIQleg0+D69ev53PPGG2+gubm5/b62L7Nz5szBiSeeiOOPP56LMnsCr9eL1atXc3qFjnXr1h3kY0HnxUsvvRTXXXcdhg8f3iNr6Mo5tMcERBuLFi1i3/KjCQhaRl5eHm6//XbccccdfBu9AQrP0O+gTesMIiAEQRCEeAmFQvjXv/6Fjz76iA/6Enwger2eRcTkyZMxatQoTovQQSf3znzRpaLNpqYm1NXVYd++fdi6dSvXMNDPHTt2IBI5eALn6NGjOQJxwQUX8OuSUVZP0pVzqBb9BMrh0IaS0muD3gSNcCVFdjgBQWNd6TjwzQuCIAhCPJBAoJHhdDz77LMcBadUBg3vIn+JxsZGrF27lo+OULSCIu90tJ18SRC0HTR6nOoWjlRjQekV8qyg49RTT+VIQ0+LhnjpNwKCxANBEYcDoett9x0KSnk8+OCDPb4+QRAEYWhBJ+6JEyfy0RYppy+79KV2+/btXKNHLaJ0kPMl1UvQ0Zk5HFTTQGJh/PjxBx10W38VDN0SEHfddRfXKRwJCsGMGTMGvcVvfvMbtis9MAJB/wCCIAiCkEjoxE4RgY71B4qicMifUvVtB12nx2u1Wj6odZQiE9TtkZWVBZ2ub+yn+0xAUH3C1VdffcTHxFvYQZtKUHiHujDaoOvkZX44qJilpwpaBEEQBOFoqFSq9tTFUKJLAiIzM5OPnoAKUEhEkKtWm2CgaALlmW644YYeeU1BEARBEPqZD0RFRQU2bdrEP6lghC7T4fF42h9DqY4lS5a0Kzjq1vjd736HDz74gAtXaKY7dWacd955PbVMQRAEQRD6UxElGUJRT20b1H5CrFy5kqtLCXIAO9A+9Fe/+hX3wZJnOeWQZs6ciWXLlnXaA0IQBEEQhN6hx30gehvxgRAEQRCEnj+HyiwMQRAEQRC6jAgIQRAEQRC6jAgIQRAEQRC6jAgIQRAEQRC6jAgIQRAEQRC6jAgIQRAEQRAG7jCtRNHWlSpTOQVBEASha7SdOzvj8DDoBARNRCNkoJYgCIIgxH8uJT+IIWUkFYvFUFNTg6SkpISNRG2b8FlZWSnmVAlC9jTxyJ4mFtnPxCN72v/3kyQBiQcaI6FWq4dWBILecH5+fo/8bvoHkj/6xCJ7mnhkTxOL7GfikT3t3/t5tMhDG1JEKQiCIAhClxEBIQiCIAhClxEB0QkMBgPuv/9+/ikkBtnTxCN7mlhkPxOP7Ong2s9BV0QpCIIgCELPIxEIQRAEQRC6jAgIQRAEQRC6jAgIQRAEQRC6jAgIQRAEQRC6jAiI/TzzzDMoLi6G0WjE9OnTsW7duiM+/t1338WYMWP48RMmTMDSpUt7ba2DcU//+te/YtasWUhNTeVj7ty5R/03GIp09e+0jbfeeoudWc8777weX+Ng3k+Hw4GbbroJubm5XPk+evRo+b/fzT194okncMwxx8BkMrGr4m233YZAINBr6+3PrFq1Cj/5yU/YFZL+/77//vtHfc4XX3yByZMn89/nyJEjsWjRop5bIHVhDHXeeustRa/XKy+//LKybds25ec//7lis9mU+vr6Qz7+q6++UjQajbJw4UJl+/btyr333qvodDply5Ytvb72wbKnl112mfLMM88oGzduVHbs2KFcffXVSkpKilJVVdXrax8se9pGaWmpMmzYMGXWrFnKueee22vrHWz7GQwGlalTpyrz589XvvzyS97XL774Qtm0aVOvr32w7Onrr7+uGAwG/kn7+emnnyq5ubnKbbfd1utr748sXbpUueeee5TFixdTt6SyZMmSIz5+3759itlsVn75y1/yuenpp5/mc9WyZct6ZH0iIBRFmTZtmnLTTTe1X49Go0peXp7yyCOPHPLxF198sXLWWWcddNv06dOVX/ziFz2+1sG6px2JRCJKUlKS8uqrr/bgKgf/ntI+zpgxQ3nxxReVn/3sZyIgurGfzz33nDJ8+HAlFAr14ioH957SY+fMmXPQbXTyO/nkk3t8rQMNdEJA/OpXv1LGjRt30G2XXHKJcvrpp/fImoZ8CiMUCmH9+vUcMj9wngZdX7169SGfQ7cf+Hji9NNPP+zjhxrx7GlHfD4fwuEw0tLSenClg39PH3roIWRlZeHaa6/tpZUO3v384IMPcNJJJ3EKIzs7G+PHj8fvf/97RKPRXlz54NrTGTNm8HPa0hz79u3jlND8+fN7bd2DidW9fG4adMO0uordbucPAPpAOBC6vnPnzkM+p66u7pCPp9uF+Pa0I7/+9a8579fxP8NQJZ49/fLLL/HSSy9h06ZNvbTKwb2fdHL7/PPPcfnll/NJbu/evbjxxhtZ6JIb4FAnnj297LLL+HkzZ87kKZCRSATXX3897r777l5a9eCi7jDnJpra6ff7uc4kkQz5CITQ/3j00Ue56G/JkiVciCV0HRrHe+WVV3JxakZGRl8vZ1AQi8U4mvOXv/wFU6ZMwSWXXIJ77rkHzz//fF8vbcBCBX8UxXn22WexYcMGLF68GB9//DF++9vf9vXShE4w5CMQ9OGq0WhQX19/0O10PScn55DPodu78vihRjx72sbjjz/OAuKzzz7DxIkTe3ilg3dPv//+e5SVlXEF94EnQEKr1WLXrl0YMWIEhirx/I1S54VOp+PntXHsscfytz4K3+v1egxl4tnT++67j4Xuddddx9epo83r9WLBggUszigFInSew52baNR3oqMPxJD/16H/9PRtYsWKFQd90NJ1ynceCrr9wMcT//rXvw77+KFGPHtKLFy4kL95LFu2DFOnTu2l1Q7OPaUW4y1btnD6ou0455xzcNppp/FlapcbysTzN3ryySdz2qJNiBG7d+9mYTHUxUO8e0q1Th1FQptAkzFNXafXz009Upo5AFuPqJVo0aJF3PqyYMECbj2qq6vj+6+88krlrrvuOqiNU6vVKo8//ji3HN5///3SxtnNPX300Ue5/eu9995Tamtr2w+3292H72Jg72lHpAuje/tZUVHBnUE333yzsmvXLuWjjz5SsrKylN/97nd9+C4G9p7SZyft6ZtvvsktiMuXL1dGjBjBnW6Cwp9/1NpOB52u//jHP/Ll8vJyvp/2kva0YxvnnXfeyecmao2XNs5egPplCwsL+SRGrUhr1qxpv+/UU0/lD98Deeedd5TRo0fz46lt5uOPP+6DVQ+ePS0qKuL/IB0P+oAR4v87PRAREN3fz6+//ppbtukkSS2dDz/8MLfKCvHtaTgcVh544AEWDUajUSkoKFBuvPFGpaWlpY9W379YuXLlIT8X2/aQftKednzOpEmTeP/pb/SVV17psfXJOG9BEARBELrMkK+BEARBEASh64iAEARBEAShy4iAEARBEAShy4iAEARBEAShy4iAEARBEAShy4iAEARBEAShy4iAEARBEAShy4iAEARBEAShy4iAEARBEAShy4iAEARBEAShy4iAEARBEAShy4iAEARBEAQBXeX/Ab+w8rAqNbDmAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -549,13 +373,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Iteration 15) \t Best Value: 1.0779572447975334\n", - "Early stopping at epoch 6767 with loss -0.0955379474696385\n" + "Iteration 5) \t Best Value: 1.0157966433570296\n", + "Early stopping at epoch 4125 with loss 1.548313489101463\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -567,13 +391,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Iteration 16) \t Best Value: 1.0779572447975334\n", - "Early stopping at epoch 5970 with loss -0.22222854543641746\n" + "Iteration 6) \t Best Value: 1.0157966433570296\n", + "Early stopping at epoch 10000 with loss 0.8870515445169387\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -585,13 +409,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Iteration 17) \t Best Value: 1.1935042208215094\n", - "Early stopping at epoch 9089 with loss -0.15552467146204463\n" + "Iteration 7) \t Best Value: 1.0157966433570296\n", + "Early stopping at epoch 7657 with loss 0.4598584669936603\n" ] }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhAAAAF2CAYAAAA/RaFTAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAA0FJJREFUeJzsnQV4U9f/xt+4N3UXKMVdh2zM3d39N3ff/nN3d3dhyja2MYNtTBhjuDvUvWnc/897Srq0pG0KLVLOZ09Gc3Nzc3PvzT3v+aoiHA6HIZFIJBKJRNIJlJ1ZWSKRSCQSiYRIASGRSCQSiaTTSAEhkUgkEomk00gBIZFIJBKJpNNIASGRSCQSiaTTSAEhkUgkEomk00gBIZFIJBKJpNNIASGRSCQSiaTTSAEhkUgkEomk00gBIdlm3nrrLSgUCmzYsKF52T777CMeXcVdd90lPkMi2Z7XUmTdmpqa7bJP3f05kp0bhUIhroVdBSkgABx11FEwGo2w2+1trnP66adDq9Witra2+URHP0wmEwYNGoT77rsPLperxXvPOeccmM3muAbhuXPndnr/e/Xq1WJf0tPTsddee+GLL77ArgSPG388v/zyC3YX+F1bX0ttPbqb6M9Sq9VITk7G6NGjcdVVV2HZsmU9+rw+8MADmDp1ao88r7sbixcvxgknnICCggLo9Xrk5OTgwAMPxLPPPrujd63Hod7RO7AzQHHw9ddfiwH3rLPOinkD/PLLL3HIIYcgJSWleTkvysj6DocDs2bNwu23346FCxfik08+2a7fYcSIEbjuuuvE32VlZXj55Zdx3HHH4cUXX8TFF1+M7c0PP/zQ6ffwON99993i79bWi9tuuw0333wzehoDBw7Eu+++22LZLbfcIgTnrbfeut33J3JNs0WOzWYT1/Lbb7+NF154AQ8//DCuvfbaLj2vO4JY1xIFBAedY445pkee192FP//8E/vuuy/y8/NxwQUXIDMzE8XFxZg9ezaefvppXHHFFTt6F3sUUkBstkBYLBZ88MEHMQUExYPT6RRCI5p+/frhjDPOaH7Ogdrn8+Hzzz+Hx+MR6nd7QZUdvS/8HkVFRXjyySfbFBCBQAChUEhYVrqart4mZ8R89DQyMjJanDfy0EMPITU1dYvl24PW13Rkf4488kghUAcMGIDDDjsMuzLb41ra2c7r7sL9998Pq9WKf/75B4mJiS1eq6qq2mH71VORLgwABoNBzNZ//vnnmBcZhQUFBoVGR1DxRkzAOxLuB2dB69evF88Zn8D9euyxx/DUU0+hT58+0Ol0zabpFStWiBkYzdYUPmPGjMFXX321xXaXLl2K/fbbTxyz3Nxc4bKhCGlNrBgIiiqasjlI8TOysrLEcV+7dq3Yv7S0NLEeZ6sR827EH9jabz1kyBAx02gN94Viit8lehm/8+DBg8Xn8uZ+0UUXob6+Pq5jOWPGDOESopuKN6Wjjz4ay5cvb7FOZP/WrFkjXFZcjzeyc889dwuX1tawbt06nHjiieL80N02fvx4fPPNN82v0wLG/aO7oTUlJSVQqVR48MEHt+qzaXX76KOPxDXNG3QEiuU77rhDuDn4Xfn5PE4zZ85sXqej87po0SJxvAoLC8W54XV73nnnNbsK24IWEg7G0RYRnmced37XhoaG5uW0nHDfeYxiXUv8mxMEWloi+8d9iobb647z2pp4PofC/957723+DdOF+X//93/wer0t1uPyI444QrhT+Hvmb3bo0KHNriROdPicx53ncP78+TFdr7z2Dj74YHF+s7Ozcc8994jjHw2vD26D98mEhASxXc74O3MNR7t+Pv74Y3Gt8R7D/dt///3Fb6sjeC/h77y1eCB07Ubz5ptvinsZl/M40gVNi21rtudxjEVpaan4TfC+xf3k93vjjTe2WI8uGr7GY5uUlCT2lWNXt8J23pJw+IcffuCZDD/77LMtltfW1oY1Gk34rLPOarGc655//vnh6upq8diwYUP4/fffD1sslvCZZ57ZYt2zzz47bDKZ2v38N998U2zzn3/+6fS+FxQUhA8//PAWy3w+XzgjIyOcmZkpnq9fv15sf9CgQeHCwsLwQw89FH7yySfDGzduDC9ZsiRstVrFaw8//HD4ueeeC0+ePDmsUCjCn3/+efM2y8vLw2lpaeGkpKTwXXfdFX700UfDffv2DQ8bNkxsm58RYe+99xaPCIFAILz//vuL9U455RTxGQ8++GB4v/32C0+dOjXscDjCL774onj92GOPDb/77rvisXDhQvH+O++8U7wW4Z577gkrlUqxT9H8+uuvYr1PPvmkedn//ve/sFqtDl9wwQXhl156KXzTTTeJ8zF27FhxnNrjxx9/FO/t169f+JFHHgnffffd4dTUVHEMor9vZP9GjhwZPu6448IvvPCC+Fwuu/HGGzt1PgcPHtzi2FVUVIhzyWvr1ltvDT/xxBPh4cOHi+8ffX5OP/10sR6PdTTcb55Lnuv24L5edtllbb7O88fPtNls4jmv+6ysrPC1114rzh0/p3///uL3Mn/+fLFOR+f1scceC++1117ifL7yyivhq666KmwwGMLjxo0Lh0Khdvf3qKOOCo8ePbr5OT+Tn8N9nDZtWvNy/jbGjBnT/Lz1tcT90el0Yj8i+/fnn392+3mNpjOfw/sJl59wwgnh559/Xtyb+PyYY47Z4r7A88FzxN8rf+85OTlhs9kcfu+998L5+fniPsAHf/9FRUXhYDDY4nP0er34jfOext/sEUccIT7r9ttv3+LeyeuD+8PH5ZdfHj7xxBM7fQ3PnDmz+Tjw3HKfue9Go1FcEx1x0EEHic9YvHhxh+vy93/OOeeIz+B9n+/lZ/N77ojjSLiM10L0ccvNzQ3n5eWJ3wh/S7zuuR73IwJ/O5Fr4uWXXw4//fTTYny68sorw92JFBCb4U2XF8iECRNaLOeAwxPz/ffft1jOZbEe/BF7PJ7tLiB48UfEDG/OHKS5vSuuuKKFgEhISAhXVVW1eD9/+EOHDm2x37x5T5w4UVz0Ea6++mqxjb///rt5GbfFH01HAuKNN94Q6/DG0ZrIQMF9b/0Dauumv3LlypiC79JLLxU/bJfLJZ7PmjVLrEdxF8306dNjLm/NiBEjwunp6UJIRuDx5Y0vWlRG9u+8885r8X4OmikpKeFtGWgix53fJYLdbg/37t073KtXr+abFa9Rrvfdd9+12B4FXlsDV2cEBAd3rhMZ/Pmb8Xq9Ldapr68XA0X0cWjvvEbOUzQffvihWP+3335rd38pYFUqVbixsVE8f+aZZ8RvgQMNRSLhsUlMTAxfc801bV5LhL9P/k5b053ndWs+Z8GCBWI9iotorr/+erF8xowZzct4LLgsIoairxGKtGhByUGHyzmAtxYqkXtI5LdKQabVasV5jVwXvK+0Fq7RxHsNRwTEwIEDW1xbHBC5vCNhQDHDa4IP3sspvvidY00UYl17Bx98sJhgRbO9jiNp/TuhCOC4VFNTE46G93fedyPf4eijjxbX1/ZGujA2Q7PnKaecgr/++qtFOiJNQDQd0YTWGpqyf/zxR/FgnASDpKZPn47TTjstLtNUVwct0lTMx/Dhw0UQ55lnninMt9Ecf/zxzSZlUldXJ0z0J510kshCYRoZHzQh09y2evVqYUIj3377rTA7jhs3rvn93Fbr2JBYfPbZZ8LkHCuIaWsi0ekGYeDolClTmpcFg0F8+umnwl9PMyPhcaApmMGBke/GB02NNCtGm9tbU15ejgULFggTJM2uEYYNGya2x+PRmtbxJjTp81g2NjZia+Hn8Jjvueeezcu47xdeeKG4ViNuqAMOOECYRt9///3m9ZYsWSLcBF3hd49kEkWylfibicS60H3Aa4nmdZpO582bF9c2I+cp4uLiueE1RjraBo8tzzkD5wiDmLmMD/4d+f50C3DZttAd53VrPidyzbUOZo0EULd2CdAsP2HChObne+yxh/iXpnsGGrZeTjN7ay6//PIWv1U+p/vqp59+EsvoLqALiPfBbb2GI9B1Ex1HFTl/sfYvGv4ueQ+nu5kBwI888oi4j9Gt2dolG33tMWCY197ee+8tPoPPt/dxbA3HEN43eT/j39H3L34n7mPkN8JzQFclYz+2J1JARBEZCCN+I54Q3ogoLHizbA39c7xp88ELlpHcjAmgT2zatGnbdd954fIHzIuRN1ReZO+8806LHwnp3bt3i+f0K/LiZPZIRIBEHnfeeadYJxIXsnHjRvTt23eLz+7fv39cvkmu15WxISeffDL++OOPZoFDnyT3lcsjUADxh0Y/Z+vvR594e4FV/L5tfT/Gl/AY88YZTfTNhNAXSeKNt2hrP9rah+j9VCqV4hpmOmLEb04xQd8sfc/bSiSGgH7uCIwboKDiZzBWgseVg1jrG3BbUHQwboMindcq3x+5RjvaxqhRo4S/NyIWIgJi8uTJIh2agiTyWvTAtTV0x3ndms/hueZ5ZoB0NIwd4SASuRba2h7FNMnLy4u5vPX34WcxPqW1eCeRidall14qlh166KHinkh/PSdSW3MNx3sc2mPs2LHiHsx158yZIyZ2FL2Mi4oWKrx38N4diW3itcdYkljX3vY4jq2prq4W4veVV17Z4t5FgUUi96+bbrpJCDKKNN6jL7vsMvH9upueF9a+DXBWyijzDz/8UFxI/JeDazwz7AgRS8Vvv/0mlOP2grN7/hg6orWgiARAXn/99ULVxqL1zWpngUKBNwdaGa6++moReMUfMNNto78fxUP0rDyaaGtMVxBLaJLtZZFi9s2jjz4qRMSpp54qxDADwCI3tm2Bs3l+v8gA/9577wnrDFMfb7jhBnGcI8GaFIzxQMsXBS/fT4sSb4I8ZzyHsYJzo9FoNEI487dGIVxRUSEEBMWI3+/H33//LQQEf9Pbep6313mN93Pitdq1tb2u/D4877TUff/99/juu+/EgwGKvBYpMLeGrtg/WjAoJvjgYM1Bl/cKTox4ffJezWvjiSeeEEKA69NSwsy11tfe9jiOrYnsA62HZ599NmJB8R4RYitXrhQTV4o3Wi6Yes0g50gKdXcgBUQrKBY4G6fZlzdfqjlegPFCE270bG1nJ6KKeTPuSICwMAtn9K3hhdsRjBjnDZ03dn5WLDrryuBARsVNNwbNgZx1cDBjpHL059IqM2nSpC3EU0fw+7b1/Zi1QtHG2Ut3w/1oax+i9zOSnTJy5EghmDgb3LRpU5cU0OF2fv31V2HGjVgg6C7i9cPjHn3uIparjs4rZ2nMfOINjje6CLGusbagYKCbjueY54MDAj+P0egUD3xQQHXErlLQieeaAwuPUWT2TiorK8VsNfpa6Ar4WTTHR2bLZNWqVc3ZCRE4+HLCxAffQ6sEa9HwXsoJSGeu4e6AbrWIW5Kw7g+zVujWiLYutOfS3B7HMRqKXv7W6KaLZ3LIexEnVXzQNcIMN2aycJLVXSUFpAujFRFrA29oVNWdsT5ELkzCOIRdAc4emG7JH3vkx9XajBaB+f8syEKzYPTrbc3uW8de0OT/3HPPtanWaY4m0Sl4HcEfC/eJaU3cfrT7IjLD5Q+QaW+xxF57n8U0U86KOYuKXo8zccacbK96CPwcHnP6diPQdULTJm8+9M9Gw9gX7h9TV+lWoGl5W6CbgdYMHsfoIkiR2Vf0bIsiMXo/2zuvsd5PuN+dERAcCPgeuikiQoDLWciJRdXiiX/gzbcz192OInLNtT5GnEWTww8/vMs/M/o3y3PF55wERKytrVNuaa6PzIwjqaWdvYa3FgqAWLP/SOxIxI0S69qj24KWk+7iuQ6OY2u4j7xv0prAe0579+bW54CCjseUn8NJW3chLRAxZrUTJ04UQZGkPQFBBUkzLqHPmQMZBxsqbt7Eo+FJZHxEaxicR7UegQNha/8hoZ842vfclTz//PPi5stcZlZv46ySMxr+2BkHwmAkcuONN4qbMs3L3B/edHkD4OyBFpv2oDmTMRkM/uKNhDd13kA4c+T3Z0AqLQS86GlRoFLnseGMmo+2oECg+4UPrt9aqTMoijUfaFanIDzooIPEj5YzOJozmaseXTOiNXQHcADmzPv888+H2+0WM3q6BLZXzXpWTaQ7jftx5ZVXiu/J64w1Pnhz4Q07Ggbx8lyxsuoll1zSpsWnvWuaNx4G7kWqqtKixkEq2j3EmT2tD8cee6wYuLg/L730kjiH0Ra49s4r4xUY6MbfBwPdKHwitUvigeeFcTWc3TIgLwK3G8npj0dA0H3Ja5HfkYGovA9EAuJ2JjgxoTmbvzsKHl7f/D3xeqD1LVZtlG2BM1fej/iZPB50TzDGhS7eiFvof//7nxCZDCik1YvxDPyNUHxHrCSdvYa3FgZp817Ma5LWKM7E6SLjtUehEokd4H0gYjXh/YHX66uvviomVLEmUtvjOMaCxccoivge3pv5O+KxZvAkr1f+Hfk+jIOhpZUuPNapoUDh77K7xg3Bds/72AVgHjMPTXt5x63TN5k2xHzdCy+8MFxZWdli3UgaT6xHnz59WqRxtvUoLi7uVB2I1kTSOJn6Fou1a9eKtETWjWAeP/Ocmav86aeftlhv0aJFIhWNec1c59577w2//vrrHaZxEqYcMQecqVv8DH4W85b52RGYKsX8b6Y3Rac0xUq9izBp0qSYqW3RME+a22XaFfPEmbbKFK+ysrJwR/z000/iM/hepqsdeeSR4WXLlrVYJ7J/0SlZ0ec1+thsTbofjxGPFVMSeex5bUbXOmjNYYcdtkXqWUdEX29MU+VnMR+faXpLly7dYn2moj3wwAPi+mMdBa7LfeL1zmXRtHVeS0pKRKoiP4tpaawdwHPSVtpnW/n8rdOLuV0uY/58a2JdSytWrBC1T3iO+VokpbO7z2vrfYrnc/x+v6hHEvkd8TvecsstW6SPt3VfiJWuG+v+EEk/57XHNHHWYmCKLvc1us4B7xF8nenOPL+si3DRRRdtUaMlnms4ksYZXcclev94PNqDKcxMhR0wYIBI5+b+sC4DUyhb35e/+uorkeLMfWEqKWvgRNLNo4/39jqOJNZ1z/3m5/A8R+6bTL3nPS06fZTXL1N++VvkuHLDDTc012zpLhSbd1oikfQgOANjU6F4qvdJJLFggCzjXHaVeK6dlXN68HGUMRASSQ+DJliaR1u70SQSiaQrkTEQEkkPgf5k5n6/9tprIu6Bvl2JRCLpLqQFQiLpITDNklYHCgkGqDGoSiKRSLoLGQMhkUgkEomk00gLhEQikUgkkk4jBYREIpFIJJJO0+OCKFkylNXnWDxjVylPK5FIJBLJzgCjGth8jAXVOirw1eMEBMVD6w5pEolEIpFI4qe4uFhUFt2tBESkbCe/fEJCwo7eHYlEIpFIdhlYwp6T8HhKYPc4ARFxW1A8SAEhkUgkEknniScEQAZRSiQSiUQi6TRSQEgkEolEIuk0UkBIJBKJRCLpND0uBkIikUi6imAwCL/fv6N3QyLpUrRabYcpmvEgBYREIpHEyIWvqKhAQ0PDjt4ViaTLoXjo3bu3EBLbghQQEolE0oqIeEhPT4fRaJRF6SQ9rthieXk58vPzt+nalgJCIpFIWrktIuIhJSVlR++ORNLlpKWlCRERCASg0Wi2ejsyiFIikUiiiMQ80PIgkfREtJtdFxTL24IUEBKJRBID6baQ9FQUXXRtSwEhkUgkEomk00gBIZFIJLsZvXr1wlNPPYWewi+//CJm1TJrZvsiBYRkt0vPq3f6sKHGidWVdiwra8SikgYs2NSANVV2lNvcaHD54PEHEQqFd/TuSiSdho0EzzvvPNGOmb7ugoICXHXVVaitrUVPYJ999sHVV1/dYtnEiRNFVoHVat1h+7U7IrMwJLsNjR4/SutdKLN5EAiEoVQqoFQAqs3+wGp7GCGExXOtWgmNUgmNuulvHZ+rlFAqFODqCjS9J8z/wkAwJP5CIBRGIBhCMAQEwyGEQlyHqVN8le8DdGoVtM3bVcGkU8OsU4vnkp4Fg9RmzZolBresrCzstddeUKlU3fZ569atw4QJE9CvXz98+OGHItd/6dKluOGGG/Ddd99h9uzZSE5Oxo44DrQQdEXxolhQKGVmZnbLtiVtI+9Ykh4PrQm0LszfWI9NdS4k6DTITjQgM0GPdIseKWadeGRa9ci2GpBq1gnBwCHf5QuizuFDcZ0ba6ocWFVpx4pyO5ZXNGJ5eSNWVtjFsnXVTqyvcaG0zo2qRp+wctjdQfF+jy8If5DCIgxfICQsHOU2D9ZXu4QF5N8N9ZizoQ5LS23CAuINbFtktGTn4PPPPxeugn333RennXaa+JfPuby7uOyyy8Rg+sMPP2DvvfcWef6HHnoofvrpJ5SWluLWW29tXtdut+PUU0+FyWRCTk4Onn/++RaWurvuuku8X6fTCWvGlVde2fy61+vF9ddfL97H9++xxx7CjRDhrbfeQmJiIr766isMGjRIbOO1116DXq/fws1A68h+++0n/qaVhPvE7TILZujQoUIIRTjnnHPw66+/4umnnxaChI8NGzbEdGF89tlnGDx4sPhsHvfHH3+8xedy2QMPPCCsNWxdze/6yiuvNL/u8/lw+eWXC+HH/aYl58EHH+yCs9RzkAJC0qPhgM2BnoM/Z/vZViP0mvZngCqlAkatGha9BklGrRAXGQl6ZFkN4kHxkb3538gyig8hSBL0SLM0CZJkk1a8P9GohdWgEQ/+zdcoXIRgSTSI9VVQoMLmwaLiBszf1IDKRo90oezCUCSccMIJKCkpabGcgziXd4eIqKurw/fff49LL70UBoOhxWucnZ9++umYMmWKEAfk0UcfxfDhwzF//nzcfPPNYiD/8ccfmwffJ598Ei+//DJWr16NqVOnisE8AgfWv/76Cx999BEWLVqEE088EYcccohYN4LL5cLDDz8shAOtIPx8igpuO9oywX3ia8Tj8WD06NH45ptvsGTJElx44YU488wzMWfOHPE6hQMtLBdccIGw6vCRl5e3xbH4999/cdJJJ+GUU07B4sWLhRi6/fbbhbCJhqJizJgx4hjwuF1yySVYuXKleO2ZZ54RAujjjz8Wy95//30hOiT/IV0Ykh4LB+C11XYxGGcmGIQw2Bnhfpn1avEIbY7RWFjcIIRJQaoRCfqtL/Qi2f5wUORgHBmoo+EyzpTpwz/66KO71J3BwZvbHzhwYMzXuby+vh7V1dXi+aRJk4RwIHR5/PHHH0I0HHjggdi0aZMQHQcccIAoNMTZ+bhx48S6fO3NN98U/9IyQWiNmD59uljOWX2knsYLL7wgREoEDugffPABzj//fPH8559/FlaD448/Xjyn5YHbinDFFVcIUcRBnJ/PGAdaWGidaM9l8cQTT2D//fcXoiHy/ZYtWyZEE60YEQ477DAhHMhNN90kvv/MmTPRv39/8f369u2LPffcU5wzWiAkLZEWCEmPpbjehY21LuGS2FnFQ2sYYyFcKiYdymxu4XYprnPGHIwkOyeMeWhteYiG55KBjlyvO4j3WuFMvvXz5cuXi79pUXC73SgsLBSz/S+++EJULSSc0VMkcVA2m83ND7oW1q5d27w9DvTDhg1r8Rm0NNDdwCqIhLP6ww8/XFgmCLd77733CmsHYzW4XQoIDuadgd+DAikaPqfIii6eFL1/FAkUJVVVVeI5hcaCBQuEmKD7hm4hSUukgJD0SKoaPVhT7YDVoBWui10NBlTSTaJWKrGywoHSBveO3iVJnNCs3pXrxUtRUZEYBCMioDVcnpSUJMoYdwTdAjTb04JAdwhn6ZMnTxZWBYfDISwndBNwgI08uH26GCLwfa0LFo0dOxZ9+vQRrg8KFAqTiPuC0ELAbdAaQEsAt3vwwQeLeITuoHUZZ+4ve0WQUaNGYf369ULQcF/pEqH7SfIf0oUh6XHY3H4R2KhWKEV2Q1sEQ0EsmD8fNTU1SE1NxYiRI6FSqrZ53a4kwdB0g1tZaRfWCcZMSHZuGHTXlevFC/t20P3AQf+aa65pEQfB5mCc7Z911lnNgzozMqLh82j3B99/5JFHigeDMwcMGCCsDyNHjhSzeM7UmVXSWSgYuC+5ubkiK4MWiAh0o9C1c8YZZ4jnHMxXrVolAjGjLRsdlWDm9+C2ouFzWk064zZKSEjAySefLB4UD4zzYKzJjshk2RmRAkLSo2AKJTMuPP6QCHxsixkzZ+Cxxx5DVWVl87L0jAzhf91v3/22et3uEB0UEWE3sLKiUbhi2vtekh0PB1UOjgyYjOVO4ADO17dm8O2I5557TtRE4Kz9vvvua5HGyfiC+++/v8WA+sgjj+CYY44RwZOffPKJCF4kDDbkIM3sCsYbvPfee0JQMA6AQoUigGKEQYgUFIyrYDwDXQLRgiAWfC+DGrkvHJSZJRGBMQeffvop/vzzT2EtYSxDZWVlCwHBQMa///5bZF/QxRFrML/uuuuEtYPWAw7+DPjksaG4ihd+NkUevx+FDo8PXRwRd4ukm10Yv/32m1CvDLThj4aRvB1B/xhNR7yoaJJrHTUrkbRHtcOLGodPxD20BQXBjTfe2EIQEM6ouJyvb826rT+D1/5FF10kUuf4L5+3tX5HMINDpVSKjJIqu2ertiHZPnCGGzHltzbhR56zCmR31IPgADx37lwRu0CTO90FzGRgCikH0ejBloMs1+UASbHBAZPCg3CQfPXVV0XcAEUB00C//vrr5u6kDJakgOA2GCNAEfLPP/+IYMuO4H2dAZHM3oh2X5DbbrtN3P+5HywYxQGb246Gwp3HjqKC7phY8RHcBgMv6SoZMmQI7rjjDtxzzz0tAig7gqmdFFjM0qAYoWD59ttvu62Wxa6IItyN0VksXEKVy7Sc4447Tvi7Wl8M0dDfxJN98cUX43//+59QtIxWpiqOXNgd0djYKCJ1bTabMD9Jdq+UzXmb6uH1h0QKZSyCQT+uPf1gqF3VSNSFkagNIUkXRiAMbLKrsNGhglufhXc/m8a7vRj0W4uHZhQKZKRn4Kuvv2phWYiIDlFhqtX6hDel9iwX7VHr8EKtUmBobqIQFZKuh6mEvBdx9s78/62FqZrMxogOqGRsAcUD74cSyc54jXdmDO1WFwYLmPARLy+99JL4QpGCH/Rj/f777yK1Jl4BIdl9YbqmzeVDpjV2nIDaWQH7729g38QyIIYVMlEXwLBURppvgP/7u+FRJ2CcfhPqMpWo9ypEdcnIhJL/sHCkLlSMslkfYEBRbyhDPoSCPiz94F6cWOiGSgkEQoA/pGj+t86rxJQXHsQ+k8ZBqTV3+jsyQ6OikUWt7BiSY90lA0R3FygS6M/fnpUoJZLdNgaCJjbmHUdD4dC67rlEEqvaJKtMmnQaEWwYjSLggbnsDxhqFqHeVgJPQIEV9SrU+VSwKxNgUyVDr/QjN1SOfKMXWcYQ/I5aqFCLEWlNqWtN1oSw+Le10U695gcEg72h0ulgq6tHnqoWSGpvb4sR/uEupOb3hd+UBU/yQHitvQFlfD/HNLNeiIh11Q70z0gQJbklOycUCzTFSyQ9kZ1KQDBSOCMjo8UyPqdJhWk0raurRUqq8hGB60p2Pypsbtg9fpH6GI3GXgLr+mlQ+l3iebFhAD5KHwxf3wIoDQlQbPZn+gEsC4ewuLEG4dr1mLvKB11jMey1SbAGa5EQskMRahITEfkQCCnggxYLpv4Bn3Iu/Aotwmo9vEhHQKUDVDqoFCFoxCMIrSKAxJANaRq3qNKn9Duha1gjHiG+L6kf3CmDETC1H53PQErGeLC8tlmnQV6ysVuOqUQikewyAmJrYG3yu+++e0fvhmQH4vIFUFzvFhUbo4PWVJ56WNd9BWXAgzok4KWyPvhyowbIBiJG5HDQj6CjDlBpoDYnQ21NB6zpWMIX6ebIP22LzwuH2SErDMVWpnEGXTb826jHpHojxpirMUpXBn3ABUP1IvHwJA+AI3dvhDSmNrchmnBp1Vhb7RDNuNqK+ZBIJJLdQkAw4pYpO9HwOQM5YlkfyC233IJrr722hQUiVm10Sc+lrN4NpyeAnCRjC7dF4tqpCPncmFWlwx0b+8ITUokYhgxPCRZ+8RJ8tZsQdtQj3QRw/A1qLFAm5yOx7yhYew9DwJiGCo8KXqUBSs1/WR0KhbIpCGIzaqUCBq1KNOBSIYjy4o3we1wIBwNCZChUGijUWii0BqgtKVAZrdjgATasCOJ9JEOjTMTheQEcllaDIeoS6OtWQNe4Ho7sPeFOHfZf4EWM9E5mZLDmxfDcRLEPEolEslsKCJZSZZpMNMxPbl1yNRqme0bnEUt2L+i2YJVGNqlqJhRsclu46/HtWjceqxkOD1QwOcuxaepjUDlXYVKiErl9lMhJ0EKr1UChUsNoTsCkPYejsJANcxqxfsNCcf15gwp4oYEvpBSBkOLfsAJj9piAww47UoiLsFKBsEqDkNqMP+eGcOcDz8IZUKBReNcUCIeCCAd8CIeDyO49EPV+JdSpBTAWjQNS8jB1oxZTN2ajl8aAW4qKMdzqgWXTz9DXLkNjr0MR1MfOPacrg509aYkYmJWwy5Tslkgkuz7dKiBY8nTNmjXNz5k2wtKkzEVmvjCtByy28s4774jXmb7JYh9MgWOL1RkzZohc3khxE4mkNeUNHrj9QSSbNovIcBiWkpnQNm7CrLV1eKFmghjIq7+6H5ay2TihrxrDx2SgsG9/5PUqRBgKOD1+aBLSkJubA1U4hFDIDwR9opgN0anC0MH3n99jM4F1f8FU22uLXP9DUoH+V+4p3m+zO1HnUaLWq0BIn4ZDT7sQo/c/HvV2F2bP+gXffzMVf01fBW3RBJgGTsaGhDRcvNyKfXWrcc2ABqSjHEmrPkZ93+MRNDTl4EfDgNF0iw4l9S4k6NXIT2nb7SGRSCS7jIBgkRIWMIkQcTWcffbZokAUU5uii4AwhZNigWVYWYiF1drYClamcErasj6w4RRbZkcwVC+Ec9mP+HHpRnyoPw7VYQsap92Hw02rcNL5EzC0XwEyzUBQZ0VI1ZT/rPS7oYAdAVcVAoY0+M3ZWL6pHl+uYP19ZnUAKkWT14J/KxXhzcs8GGozoaioUFg9FOEQlEEPlAEXCvpZUNCrEJXlpSJgsql7YBYUikpg0YtINGYgZ3QejtzvQdSHzJjxw7f49ssPsNhuQOJep2MG+uPvBQ78T/0Djh6SIkREQ9/jEDC2DDImGpVSxH+sq3E2tSCX8RASiWRXLyS1I5CFpHYfVlXYsb7WgWxrU+zD8rmzUP/5Dahx+jGv36X4N9wfhes/wx1jAxiYlwK9qxRhKBHSmsUgr/I2QhGK3aSnvq4Oy9ZsgCugaH74QyxPDQTDfChENsbee+4pSutG0jxDKq3IvmBWRUipFYGQYbUBIaVGxDJoXZUiuDOagCEF7tSh8CQPQkl5Jd55913MLFdB138vMKfjaNeX2NNcgWGj94B78KlC4LRVB8Nq1GBojhV6jYyH2NGFpCSSnZVdopCURNJdNG62PiQatFi5bDGef+wBJBb/iFFFaWgcdBL+DffDQel23DM+D4aGVVDY1yGgT4HaW49wUIuAIR1+UzbCKi18ljxhjVB76qD21ELlqUXAo4bDvxFqJatVhpGq/y9uUqGg46MptjEX5TDUxJs6rEDAkAqfOQdBfRLCSi1U3gao3bWwFP8Cc+nvsCT1x63XX4mrg2q8+ek0fFdpwRfGY+Fzfo2lb72CwUP/Rs6xd0GT9V9vgAhpFsZDuLG+RtaHkOz8sKx0Q0NDXC0OdhUUCkWHFZd7ElJASHZJKho8KC7eiA+efRjTv/oM2RYFLhxrQOKQffF1eAwm5+lwV8EiGCsWNVkG1AYog154EvshaEgW2Q0UDn5TJlQ+JzTOcgQ8tZtFRB30hjTU/bMcCq8TRjVgVIdFZUmVIgy1QiFcGGqNDoakTATUOoRUDKTUIsx/aYFQqaEMBaHy2qDy2aD0sY6EH2p3tXgIlGoEtFYEjJnCYsHX9bVLoatfBX3WOFx6+nE4ot6Dmz7+F18bjsJhRXr45k/Bgn8Ph37/G3DgyRe1qGrIeIhIfQi6MnKjslIku8+g/Pbbb4v09ptvvrl5OQfpY489NmZzL0nnYTOwqVOnipi+aOiWZxOw3QUpICS7HFUNdjz80P14/+Vn4PW4xbLrj98D/YcOw9SaLKgNibin92KYKhdC6XcIt4LfXCRcF660EXBmTYAiHISufiXMpbOgcVZs+SEKFYaO20tkYYTCTe4Lxj6oGQuxeWJ/4IH7w5vau8399BuscGWMgc+SC58hE8pwk0DQ1y2DrmEt1LQ+CNFSi5Da2ByXwf00l/4BQ+0yaHP3xTNnjMftXy7GNw0H45ghaiQum4KyL+7C+R98gMtvexhjxk9qUR/CyPoQVQ5RJ0LGQ+xg2HZ61iyOLOzfzVadLE/ZrR9Jk/TDDz8sGrjtToNZPPj9fmg0mm4tRbA7IduKSXYp2BFwzIhheOPph4V4GDVuAqZ//g6OPXx/rGoIY3ZoIO7uswKJNQugdtcIt4E3aYCo8lg34HQRa2Dd8B1SF78i3AZCPCiU8Jtz4E4bBnveviJYsWbIeTAf/SisJz2H10p649H5Rjw8z4T7/zXi9eJCJJ34FBIOvxf1/U+GrfBw2PP2gSt9ZJM7ZHMBKFofKBgSNnyP1OVvi9RSmjhtRcehdPLjKJt0P+oGnAavtVDsA60gWnsxtPYSaO2boHZWInHN5yhs+AMPHTsEBWkJmKbaB+ERxyMjLRmjVCtx4cmH48ZLz0NtdVXzMWKTLX8wjDXVDlHiW7KD+Pxz9p4GGEh+2mlN//I5l3cjbAfAgYxWiPZgnyH25mCNHdbOufLKK+F0OsVrzIZjY8MInG3z2mW/oujPYffMtli8eDH2228/sX128WRXUGbmtYaFANlVk/52ZuL5fP/FJbG199ChQ5u3wc+M7CNhkD17JlE0DRgwoEW7bnbP5D5PmTIFe++9t1jnxRdfFNtio8do6HZg900GPJObbroJ/fr1E8HP7Gx6++23C/FBmADAfV64cKHYPh+RrtGtu053dAxoMaK747HHHhO9UrjOZZdd1vxZhN+JXVa5/6zMzBboOwvSAiHZJWD77MsvvxyffPKJeJ6WkYnrbrsPhx55FFKXvYO5Kxvwp78fjk/egFGKtdA4SkSKpie5P1yZY9GYvx9MFf/AVDkXYCVJzkY296HwJPVDWBPb3L/vfgdg8j77YsH8+aipqUFqaipGjBwpum9yaA7G6solClm5oXFVilLaWkeJECoM2jRULRCPoDZBiBpHzmQ09joEhtqlMJb9BUPdcuHiUAQ9YhthtVHsby9PAx488mDc8tUqfFYzGReOBQ7oPR8O37/46OvP8edvM3DDnQ/gqBNOFTcxEQ/RsLlfRqasD7HdoUjgjb61y6C0tGn5p5+y21a3fDTdWg888ABOO+00IQqYzdaatWvX4pBDDhFtvN944w1UV1eL3xcfbNXNAZfv5XIO7r/++qu49n/55RcxyHOAY++iaDdJNBzkmT3HGj5s883fLzssc/uRwZaw4zIHRm6XA/65554rBtH7779fuANOPfVU0b2W7he73S4ak0XcMO+//75o002xw5bk8+fPxwUXXACTySQy/SJwH9mgkevws7iNDz74oEWjR26LAzkFA6GY4H5mZ2cLEcDtchlLDJx88slYsmQJpk+fLtqcEwYdbu0xmDlzphAP/JdlD7j9ESNGiM9kJiPPw7vvvouJEyeirq5O7P/OgszCkOzU8PJkLRD+6DiA8+Z4/DkX49obboHRZIax/G/4Vs/Ep0sbMTM0HC/3m4ds90rRsMKbWARH7mS4U4fAUjxTWASIWJ6zlwhkZPol5s8HamqA1FRg5EhgK0tUt4ci6BOiRl+/SvS+4PMI3sQ+cGWMFfEYLGWdsHE6dPWrofI1CpdGWKkSVhRmX6zPPBRXfbkeOmcZLkuag2FJATw1ZSbemLFabGvi5P1w+0NPIievQLQ3r3Z4RIGpAlkfYvtlYdBtQUtDVBvvFojo21wWxulyd0Z0YCIHrkGDBuH111/fIgaCAxl/Sy+//HILiwSFAwc+FuejcKDFgTNeDr4c2Jhez4H9jz/+ECn6/KzIoBvNq6++KmbxxcXFYkAnLBJ45JFHoqysTMykua+0KHKdyDb4eTfccIO4fzO+YPTo0UJYFBQUbPEZRUVFuPfee4XIiEBBxM9hDRa+j+eQ7dPZVj0Cj8WZZ54pqhzzczlmcH9ohaCoigUtBB999JEY0NuLgVBEBVHGewwonijoIvFMJ510EpRKpfg8toSnqGJLeAqYnS0LQ7owJDstVOy8eZ1yyilCPAweMhTPTfkO1996jxAPCr8Lxoo5mLepHn+EBuF/GWuQ5Vkr6jow7sCZOR4BXSIS10wV4oGzflufo8RDiIeZM4AjjwQuugi49damf/mcy7sYke1hLRTWhuphF8FWeIQQMhxMGA+RtPIjJK3+FEFdIqqGX4H6fifDk9RfxGqo/E7RSVTbuAF9Sj7HgwekoF6TgXcahmCdU4P7Lj8Zj/zfZdDqdMIScdwBE/HFR+9Co1LAqtcKK0SN47+Gc5JuhjPEtsQD4SBeXNy0XjfCOAgGVC5fvnyL12h+5yzYbDY3PzhbDoVCYmDhQDh58mQxuFEkLFu2DJdeeqloXLhixQphkRg7dmxM8UD4mcOHD28eOMmkSZPE9leuXNm8jOtEb4OihyZ+Drp8bf/99xcujBNPPFEMyPX1TSnQFDkcdM8///wW34ECgsujGTNmTIvnhx12mIiD+Oqrr8Tzzz77TAyU0Z2g6fbg/tIVxO3SVRNdsygelsd5DAYPHtwiGJrWCN77yIEHHijEE90oFD20lETcLDsDUkBIdkpoGuSPjwpcrVYLU+XbX/6EooHDmmsc0B1RUmPDYrsJKSoP9ksoE+Z/vzFV9JHwm9KaXBZsuJU+CnWDzhKDNmdhrp9moOGOe1Dp9KPUkoYySypKE9JQ4Qqg/o574fxpBvzB0FZHrYfCYQRDYfHvFig1wn1BIVM76GxhIaHVg+4OxjwkFP8EZ/Z4VI+4HI6cPUWApSLohaFmsYiNGFb7He7eJwmrkY+PqvOxrMKOM8dn4OuvvxQxIW6XE3fecIWIjQh5HQiHFVhT6YDTu7k1uaR7YcBkV663lVAAUBSw4m9rOEgzyJIz6MiDomL16tXo06ePWIdtyCkgaDKnBYKDbERUUEDQWtGdcFBlEDPjFWhJefbZZ9G/f38hcCJxBBQV0d+BroXZs2e32E70AE60Wq2YmNCNQfgvrSu8zxC6Zk4//XQhNKZNmyZcI7feemuL2IyuRNMqqJPijSKD0Oowb948fPjhh0JY8D7I+yJF3c6AjIGQ7FQEAgHceeedIgCMgzfV+XvvvYfsPgOwsNiGlM1ZBWyFra1cgAXFDVgcGobr8lbBal+FkMYMT+owBMxZMFX+K9ZlgKM7fVRz5856hxeG51+Ewe9FqqMeZp8buqAfPpUaTo0ejQYLPM+/CNfY8fBvrv7A/6uiSlY3lY1qcrEIjRAVYtBUsbJpAV8Li/+a3qVSKIUAMmpVooJkUJ8Me8FBIjPEWPkvjNULhEWCwZRcVjvoHPiN6bBu+EHUp9DXLBGNwibjJ1w/YS888ucgpBXbYDU0YmjGYrz5/hS88frreP6x+/H9tC+waP4/ePCZV5HRbzjWVDkwKDtBfK6kG2G2RVeutw089NBDwp/OgTeaUaNGCasC3QBtQYFw9dVXi7gjignCfynu6cK47rrr2nwvAxtp4aClIDKA8z00zUfvC0WL2+1ubpbIwZ8z/khDRA6mnLXzwcGTs3G6CFjVmPEJ69atE4N9Z+F7OLtfunSpaJlAy0UEuj/4ORQNETZu3LiFCAnSVdUO8R6DjqCwoXWED94bExMTxT4f100xNJ1BCgjJTgNNhPRnRnpQMGL5ySefhFanx8KSBjGARwY/Y8U/WFtZjzXeBIzUV2GUZhMUXj98lnx4kgaKwZiwLTbFA60JtU6v6JxZtGk5shf+JgREW6GF3vJV8JWvgHf8RBFL4PUH4Q2GWqxPkaBlB06lAmqlEkpl07KmR9PNjwKDGRGBUAiBYFhYAeqdfjS4ffAHQlAplbDo1TBqLXBQ6KQOQcKmn6FxlMJc8iv0dcthKzgEAWMWklZNEcuZBkqZclyiAuWDxmDKsrFIW/cLTtbXIXnjdzj/kisxbuJk3HzF/1C8cT3OO/FwXHrdrTj0jIth0KjQN8O8Rf8OSRfCVE3GODBgMpYFKhIDwfW6GZr/OVg+88wzLZbTNz9+/HgRW8R4CA5wFBSc8TMokQwbNkykgXKGzpl4REBcf/31zQN7W/AzOdgxmJHxAgzGvOKKK4QZnr7/CJzV0w1BFwFjFvge7hMH2b///lsEWR500EFIT08Xz7kdDsyEmRAMMKS/nrELdK8wRoFujugOzbGgJYXuCe4n4wD22GOP5teY8cB7EWMQ6KZhewWKlmhYfXb95t5ODFKlpaB1U8d4j0F78LhTJHF/eS4YQ0HrRGcESHcipyKSnQLeKDgronigqZQ+SAZ40T9a7fCixuFDcsT64HNAXbkAS8saURZOxbHpFTA0rhfxDu6UgdDZ1jSLB1fGaNjcfhEDkG7RY2R+EorsVTC2Ix6ILhiApbpCFGbKTjSgd5oZAzITREZD5NE3wyKCE1mwKdOqF9vn+txPdgdlOiX/ZUZEltWAvGQjBmQlYFxhMsb0SsawvERkJ+pFM7DSBpfYT58uBfX9TkJjwQEIq3VQu6qQvOojEWBZNepqEUdBl4a+bik0jZtwSdJcTMxS4DPfePy8ugFhW7FoJjZ05Gh8PP03HHnCKeKG89yj9+LRGy7E0o0VonuppBuhP/vpp5v+bi3UIs+feqrb60FEuOeee5pN4hEoDuiGWLVqlUjlpIuCM3zO6v/bVYV4jf/uueeeze/j75NxBa1dA9Hwd/v999+LrAEOwnQZMJ4hIk4icBkHbA6QdCMcddRRYrAl/JzffvtNuBKYUkmRwWyKSPYEhQ/TOJk1QqFEiwln/BQEHcHvxMkKLSCtLRjcB/ZjopCh9Yb3JKZxRnP88ccL0cJAUgab0sWwtcegPWhtoBuXqaAUTgwy5WfRMrszILMwJDsUXn6M7OashiZBRl0z64JBQ8QbCGL+pgZ4/aFmAWEunon1C37BDyVKZOkC+F/yAlFlkvENzGjg7JxZFkzfFINyMCgG/KwEfVN5519+acrJ74iZMznl6u5DAIc3gBq7BxU2L2weP/RqFRKNGqgDLiSs/1a4MzjwOLImwm/KQfq8x0UsBN04tK406rNx0ZIB8DnrcXHyfOzTNxX2XgcIVw757MN38MBt18Pv8yG/dxHuee5NHLn3uObjKemmXhhM5WT0f3RAJU3zFA87gflZsvvikVkYkl0d+j5p3qPap3g466yzRMBWRDyQSpsHDS6fGFAJS0KrKhZgeYUdrrAOB6dUif4WQa0FPjPz3RXwpAwW4oEDMwspUTzkJBr+6w0RMTG3Zcbnct7ot4OJmZh1avRKNWNUQRKG5VqhUytFTwt7SIeGouPgThsuTOHmsj9gqFmAypHXiMJXLFhlqJoHi7cCj/dbDofSis/qCrGotAEJxTOhcZSJ7R9/6ll469PvkJGVg03r1+CSEw/BK+98JIMquxuKhA0bmoQoA/b4L1M3pXiQ9BCkgJDsEJgHTfMoC6Qw2pq52jQ/RoKpCAXAxjoXLDq21G4a7E0Vc7C8tB4VATNGGWvQy7dK9JPggBpW60UapAia9AVFwy36+7Ot+p3axByB8RR0dYzIT0RRulmInwqHD3U5+wqXBqtVso6EpXxWk4gwZQkRYaqcgyzU4vH+K7A0XIAvSxNQXGOHdd3Xwt1D6NL46NtfMHbCniJL45ZLz8Ztd98vYjsk3QivIVqxWKuA/27na0oi6U6kgJBsd5hqxQCuf//9V1SdY+AWC71EB/bRtbGp1imyJhIMGgRDQSya8yvW/zkVKysbwXDG/axlYmbOdtk+U7YYYG29D4MnrEady4c+aSbkJxtjBwxyFshqgDk5LZfTMtGNVQLjgVkaRekWEa/BuAoWg6pLGIT6vieIpmAaZyUSSn9F5cirEDCmI6g2w1gxGwNNdtyVvwS/hIbh2/UBNNrq0fDLc/hh+jf499+5SExOxssfTMWp51wgPuepB+/Cmef9D15v96SnSSSSno3MwpBs92BJph/Rz8ZIYkYVR7ssIjBwsqzBgxSTDjNmzhCV4PYwbMK44f3gTe2PPO9aWGyrELJmImDMAFRaOLInwGvIQE2jG71STOid2kG2AUXC0Udv92ZH8WI1ajBYlwCTToX1NS74NRkI9T8ZSas/g8pTh4SSX1E97FKkz38K8IRhLv8Le2ftiYuci/F27Rho532HwMpfMa8S+GajDukZGSLW5JZ7H0V+7z545K5b8Ml7b6G8ZBOmTf08ZjleiUQiaQtpgZBsN1gVj5HLFA90XzC6OZZ4YNrkxlqXcFv8MetXUX8+bCvHiCwtNKm5UCOIQe75KK2sgc3ugNfaWzSxYjlopmoyE6IwzRxf/4ed3MSsVinRJ82MwdkJCIZCKPcbUdvvJFE/gqWuzWW/i8ZfYa0FYYUa5srZGKVah4n+OfhevTd0BcMxMi2Akal+Ud2Ox5KC7PTzLsZTr70PvcGI33+ZgfETJ6GUaYcSiUQSJ1JASLYLLKvLuu8sFMXS1D/88AOSk5NjrssAwlqHF1aDSlge6KbYN9cHXXZfeKBHumsNcrROBEPAb6vqEFTp0djrYHgCTQWbeqWaRDxBT4FWFKaSDs1NFC26S91a1PY9EX5TBpQBN0xV84WoCLEhWCgE1dqfkbXpOxSFN2GOeR9oM4twSL4PucamoMnHH3tcuIT2PegwvPXZt0hJy8CKZUsxYeIkUYlQIpFI4qHn3GUlOyWMZWA3vEjXPs6AWc+9rfQ4u8ePDbVOJOg1WLxwAaoqK5FnDmJgtgWaxCxo4cOwwFI4/Qq4g0qsqvHiX0caghqLEB25iYbmapU9DaZdDsm1IsWsRZlLibqi44XlhY259LZ1sPU6HI2eAFQhL8Za6tCn9FtoFQFsSt8HusR0nNDHC7M6iMrKCtFdlAwaOgLvffkDcgoKUbxpIybtuaco3SuRSCQdIQWEpNtgauYll1wirA+EbXn5N6vMxSIUCgvXhccXgkWvEQ20WP55f1ofcgYgACWy7MuQpPZCpQhjXrUaxXYVVjoT0OD2w2LQiMJOPbnKIlM+2V0z2axFuTOMuj7HwGsthCIUgMZbg1XKvnAFlEjWhzBIuRHDa39AVdgKZ94kJFiMOL7QC6UivPnYNsHOne9+MR19Bg5BdVWVqDbIAj4SiUTSHlJASLoFv9+PM844Q1ST5ID+yiuviDa97VFp96CswS1iGEhqair6JwbRKzcdOqMZupALQ7EWbj9Q41Gi2qPEtxt1SExJhdsXQO9UEwzanSuGoTswbRYRSUYNKh0BNPQ+Ap6kfqI1eYJRi7lVKjgCCuSaQyhwLsEe7llYoewDZa9xyLcqcHCeTxzbaFLT0vHmx9MwdMwEEaPCJkxsYiSRSCRtIQWEpMthfXuWbWUteXaa478XXNCUOtgWLGq0rtopUhgj8QsjRgzHUYOM0GX3g1oRQoFjMdSKoGhTPbdKjdmVWiit2cgtGoRMqwEZCdtQNXAXtUQwxZUdRW29DhV9NLIyM6HSW7CmQQ27H+ifGEBa9VyMD87DYu1w6PKHY+/eekzI18Ysm/vye59h/L4HiUp1xxxzTHMPBEnPgr0cWHtlW9fZVlj7hdedZNdECghJt4iHr776SsQ5fPnllzjppJPafQ9dF+trnCL+IdHwX2tbU/0KjBo7FomaMBQ+FwaoyhAMA2ttSpS71fitXIPLr7kOeo1apG3GlXXRg6Cbh9kZ/LfK4Yc9/0C4M0ZhwsSJqHQrUOVSw+YDhiW6YS2bjeGKVVhtGYu84RORWDITamfFFts0m4x4/MV3sNdBR4hzyZRbnkvJrkNxcTHOO+880deCXSPZWZJ1Vmprazu1nX/++Uc0tOsqYgkS9r9gPw7JrokUEJIuFw9ff/11s3iINL5pj4rGJtdFmlnfHL/AltXqjb+hyqOAShHCsMBi+IJs3qLAghoV5jiycf+Dj2LYmPHITTKImgm7IxQPAzIt0GmUqHP54cjdBxl7nIj9DjgIFUEznD4lGv3AGGs9UusWoUBZiTmOVJTWOZDISpV+55bbNOlx31OvYJ9DjxauKDYOat2NULJzws6NbHTFbBo2XVqzZo1owMT6KxMmTBCNneKFTaLYEKo7YeVZdtqU7JpIASHpNvHANrwdIVwXNS1dF8RUPhtLN5TDHGxEsl6BkTlG5GalIZQ7DpNOuAzPfPQ9xkzYS5jys5P+K3+9O8KOn/0zLQiFQyILg43E0iecihNPPgN5Yw9Fr15FyCroi1MGa7FHWgAWhQffr3XB0VgH6/pvROxEa5IsRtz+6Is44IjjROotrUifffbZDvl+kvi57LLLhNWBadLsTpmfny9E/E8//STqfNx6663N69rtdtGRkl01c3Jy8Pzzz7drMWhoaBAdMCks2GSJHSLZzTIa/v7ZeZL3AMbZHHvssWI5A3M3btwo+t5wkhCZKES7MGiJ4PIVK1a02OaTTz6JPn3YJO+/Srb8TmazWbTFZnvs6KBgyfZDCgjJNsNZ6oknnthp8RBxXTi9LV0XKncNnOv/Rnl1NfxQYZJhI8JKLTTWbKQNnoy0yedDoVDC4fWLUtVGrSyoypLXbC/u8gfFw5k9Ec6cPZGeWwhj0URYzCaElXqMV69Ef7MH/mAYM1fVI9ywCebS2BkXaVYjbnjwWRx89IlCRHCwYeXQ3TUd2el07pBHvA2TaV1g++hLL720RU8ZkpmZKdpWT5kypXl7jz76KIYPHy7SdplmTTcHy8q3BX/jLEbG4FqWoR81apRoTx2xanzzzTdCMLD9NrdJq8e4cePEa2xJnZubK1qLl5eXi0dr2LKb1hOmeUfD56eddlqziKFwYfvxuXPnYvr06aisrOzQTSrpHuSdV7JNRLpo0k+u0+niFg+kzOZGab0LaZb/XBcsGmXaNBO/rKtGAlzoYwnCqAgA4SBc6SPgyNkTIa0ZDU526NQio3WjrN0Ydhxl2/M11Y6meJCsPQClCuaS3+BOHgBjzVKEFCocbFkHu68Xyj16/LWmBpOV80VPDXYxbU2m1Yir730S4VAQP3z9uYiJoIjgTXx3wuVyiRnvjsDhcAgrQUfQbUFxMHDgwJivc3l9fT2qq6vF80mTJjXXZ+Hg/ccff4jZ/oEHHrjFe3///XfMmTNHCAj+zgmLvE2dOhWffvqpiJW4//77RZG4u+++u/l9FCiERePYNM9isQgx0xYUOc899xzuvffeZqsExcp7770nnvM1iocHHnig+T1vvPEG8vLyxLr8HpLth7RASLYa3qxY54FZFmq1Wswy4hUPbNG9tsoBs04Djeq/y1DXsAob1iyDzlOFgEqPgRrOVELwJfSGN3kg3KnDEAiG4PYHUJBihE7d89M244UijFU4C5KNqHH4EAyF4coYI7qTBg1p8CT1hTLkgxohHJVcjCSlGxttfiwqqYdl088xgyq5zaxEE664+0nsfeCh8Hq9OOqoo/DXX3/tkO8o6Zh4LRaMiWj9fPny5THXpauCQobN7yikIo/169dj7dq1Yp0FCxYIi8S2QAGyYcMGzJ49u9n6QEvHgAEDmvdj5syZLfYh8lpkPyTbD2mBkGz1TYp1HV599VVRGIo/dJou48EbCGJNlUOY0ZNN/7kuWFFRsXYG1pRWwIIQJiVUQqlQii6b7pQhaMxnS2sF6lxepFl0SNtcL0LyH7Q8sA+INxBCRaMbWQkGuNNHibmCpXiGCE7V2dbCqAzhiJQyTK3JxopyG5JMOuSqv0bdgNNEi/Bo2JMkNyUB1z74PHze8/HXbzOFD5o3cs4GdwcYTMgBdEd9djwUFRUJwUcREIk9iIbLk5KSRAxDZ+F3z8rKwi+//LLFa5EYhtZuk62B1glatz744APRsZf/cpISvR9HHnlkc3G6aLh/ku2LFBCSreK+++7D448/Lv6miIjXByniHqqdqHF4kZnQ8oZjrJiDeas3ISNUA6Neh1SVC8qAD86MUXDmTELQkCIabYXCQH6ySTSakmwJg1H7Zpjh9gdRZfeK+hju9BFCfFkoCIJuaO0lSFOFsb+1AjNt6Zi/rhwJejWs66aJtuF0fbQWJrmpibjxsVdx3xVn4d+//xTWJpq9dwezMQfmeNwIOxJaB+h+eOGFF0SwYvSAXlFRIUQ+3Y0Rd2Fklh+Bz9tyf9AKwG3Q0sjgylgMGzZMxD2ce+65MV9ncCddnh1BNwZL3jPmhlkltEpE7weDebkP3BfJjkXegSWd5sUXX8Qdd9wh/qbPlDnn8cKUzU11LtGmO7pug9pVjfqVvyNkK4ZHocVoYyUQDsFvSocnbRicmU3BWOy2mZGg67H9LroKBpYyvZNiot7lE8vcacPRWHAgPClDRMyDIuRHodaGUcYa4e74Z1UxQg3FsJRsOcskdDXlpiXhlqfewpDhI0XkOytWxgqIk+wYGCNANxPPC8uRsyYEAw0pLJhpwTiFCBR/LC/P2AFmYHzyyScikDIWBxxwgHBxsLgYMzzoZmA3XWZ1MJiR3HnnnSJ1lP/S2rF48eIWlgIO+twnZoO0lzXBOBtmiNDysO+++4p6FtFZJgzapLhgnQq6LRg4StESjziRdC1SQEg6BesB8EdMeKO4+uqr436vzeUXrgsObkzbbCYcgm7ddCxdXwoTPBhuboRWGRYzZk/qMDQWHAwo1XD5AtCqlChINkG5mxWN2hoYZNovwyKsNkyXJZ7UoWgsOAiu9JEI6hJFD43hxlr01trg8Qfwz+pN0FUtgL5mccxtMuYkNz0Ztz/zDnr17iMGErozbDbbdv52klj07dtXDOiFhYXCKsj0RwY4ciBm3Ep0B9zrrrtOrEs3FC2KTzzxhBAesaDVgsGzkydPFoM1rU60DDA1k6mUkVRNihAGVI8YMUK4Ihh4GYEZGLxeuE/tuVEYaEk3BeMdaI2IhmKCwodigRawoUOHinsQ3Sht9diRdB+KcLwRN7sIrONvtVrFDY25ypKug5HYnIlwhsPS1JE+F/Hg8QexpNSGBpd/i5LTxop/sHTWVGhqV0CjVmFCYj1UQa/ICqjvfzIcefuImAtmbRSlmVGUQUO8JF421DiwosIhYkYitTb0NUuQsOE7mEv/gNLngD8E/GjLhiukQnpKKkYU5aKeLcPN/83+onF4Alizdi2uO+vI5gZcTO9rq8vqrgTLeDM4sHfv3j3i+2wtjClgNgRrP0h6Fp52rvHOjKFSskniYtmyZWJWEInCp581XvHArAlaHmrsTcGP0ag8dWhYNgO+ug3wK1QYmWCDKuxHwJACV8ZIOHImifVs7Lap1yAnqXsr4/VE8pJNyE82oNrhEa4K4kkdgsbeh8GZPR5htRYaZQh7W0qhRBiNteVYW1YDKytV+uwxt2nWq9G7sBD3vfg+zBaLCK5jQR9pRu4ZKausB8H6CoMHb5naK5FEkAJC0iH0WR5yyCGiiAv9oPRzxhvARMvBhlonSupdSE/Qi4j+qBehWTMdy9ZtgDXswECzGwZVCGGlBp6UQbAVHgkoNU3piJvTNneHbpvdlZlB8VZl9zQvp4WHx9iZNRFQaWBSh7GfeSPc0KKqZA1qa6pgXfcVEPLH3K7VoMGAwcNxz7NvigA51gNg8Jtk14adc+meoGugdaqnRBKNFBCSdmHa1BFHHCGCsZhvzWqTnamPX27zYH2NC8lGXYt6D8RQvRDLli5EdrAEJo0C2cYQlKEAfJZ8NBYcgoCpKS2rzukTQZe7U7fNroYxJ6xUadSpUevwthARDX2PgyNzgkiXTdQCk/Xr0RjWY9PapfDWliBh409C7MUiyaTF8HF74ZaHnxPP6UendUqy60LhwMZbPJcSSXtIASFpE5qjWUKWBWLY8IY+bqaKxQsH/tWVdhg0qi0sBypPA2oWfQ9lwzphNu9vDUAZcCOgT4YrYyyc2U0zn6a0zTDyU4xbCBBJ50jQa9Avw4wgwnBsDqoktPY09D8Zzqw9GLeKDEMIe2jXoyGow9pVi6GqWgJj1b9tbpeWjb0OPgoXXdfUZ+GKK67YbUteSyS7E/KOLGmT66+/vrm/BSOr28r/jkWjx49VFXYEQmFh6m5BKAjVyq+wYcMqJMGOXuYwjPAhpDHAm9gXDX2PFVkXpMbpRaZVL4tGdWHPDAai2tw+Ic4ieFIGon7AGXBmjhUiItcQxFB1MRzeIFatXg5jySxobRva3C7Pz7HnXIYjTzodoVBItGmm8JRIJD0XKSAkMaEZOtKJ75133sEee+wR93uZbrmywi5ERKyB31D6BxYtmoe8YCnMGiCNHhEFhMuioe/xCBib0sLsHj/0GqWwPsQbsCnpmLwko2hCFh1UGRERtYPPgyttFFQqBXob3OilrILHacO6dWtg3fANVJ76mNvk+cm0GnDRzQ9i3KTJwvV1+OGHo6SkZDt+M4lEsj2RAkKyBSw8c+WVV4q/2bSGXfjihematDzQz86YhdYDv6ZxI9bP/QEprrVQK8MoSNSKlM2gPhn2vP1E7wbCgY0CpFeKSZjeJV2HMiqokiIiGm/yANQMu0iUDteo1Sgy2JGCRrjrilFevA6Ja6eKctgxt6tQICfFgusfeRmFffujrKxMFB5iVL9EIul5SAEhacGKFSuE+ZnxDywYE+nWFw/+YAirKx2i2iTLVLfIuOAs1e+Cfd5n8FSthEXhQq5VD13YjaDWAjeD+focI4pHEQoQDnDZidteX18SO6iyKN0i4lPqnU2VKiN4UwagesSVcCcPhE6jQT9dvSjw1Vi6ErbytbCu/1YU/2or46NvbiZuf+ZtJCWniE6K559/ftwNniQSya6DFBCSZtjqlzUeWEhkr732wksvvRS364AWgzVVdpQ2uISfPbpMtSAchmLlN9iwejFyFTVINOqRqA0hrDYgYMpA7aCzENY0ZXe4fUFxZdL6IAMnuw/GpjAzwxcMCbdTaxFRNeoaEZNi1GvRV1MDDfyoW78AgYolMJfOanO7PPfDB/bDzY+9ItJ92a01uv2yRCLpGci7s0RAiwPry69evRr5+fkip5+5/XG9NxQWrbk31rqQat4yXZPoyudixbzf0Ce0AVq1GhmbG2mFNBbU9z0J/oQC8ZwzVXbbzEs0IkUGTnY76RYdeqea0OD2CQtSNN6UgagcewO81kKYDXoUqSqhCnlRuepfaEr+hL52aZvbZaOzA/bbF5f8X5NwuO222zB16tRu/z6SXYe77rpLlLze1dmwYYOYaEWChllUjc9ZN2dr6YptbA+kgJAIbrrpJtGUhjUevvzyS5G22RnxsK7GIWo1sFdCaxj3sPavL5DjXgmtMoTMlESogm5hfWClSZaqjlDv8iPRoBWBk5LuhzcpFujKthpF506mzEbDOhGVY2+GPyEfFoMevVVVUAUdKFv5L8wbpkPjKGtz2xSSZ517Po46rak74xlnnIFFixZ1+3fanTnnnHPEOeWDEwC2+GYPikCgpYVpZxjUmOXF7p09jYkTJ4oGcywHHQ8sA9+6p1Bnt7GjkAJCIrIsIq2533rrrbhnBf+JB6cQDy0aZG1G6bWh/M8PoatZjASFE0mJKdCHvUI8eJL6oW7Q2aKAEfEGgvAFg+iVaoq5LUn3QGtBUboZySaNKDfeGpa9rhj3fwhY82DWa5GvqIbGU4vyVfNgXTMVSl9jm9umoLz5rocwYvxecDqdIqiS3RQl3QerxnLwoTWRDbM403/00Uexs0ArIwWN2WzuVF2ZWPj9sauk7shtabVaZGZmblPmWFdsY3sgBcRuDrvxsVsfuf322+POuKB4WFcdEQ/a2AN+yA/H3I/g3vgPchQ10FtSkKgDwioNgoZUVA+/DCGNqfmmwsErJ9EgzOqS7QsLffVNt0CtUoi+I61hS/XKcf+HcEIejDoNshU1UNuLUbP2XySumQpFsGUgZjRmgw6PPP8msnILRAMfuspkz4zuQ6fTicGnoKBAtMRmAzzWcYnEOZ111llISkoS1kZ2UqXQiMDumux5w9dNJpPohcGiYDTTs6Mn4Wsc2GjtIKz78eCDD4rGTAaDAcOHDxcu0NaWCxaiGz16tNg/NuZr7cLgdmgtyc3NFevwNWaEtXYVTJkyBXvvvbeoT/P+++/HPAZc78UXXxTfj/vE7qTR+9Tetl577TUMHDhQLGP13daVVdlhlB1M9Xo9xowZg/nz53doqWEHUVoaeMx5/Nj1lOeCx/DXX3/F008/3Ww54r5Fb4MxafwOPH6tOyOzc2kky4nVgtmBlZ1J2XX16KOPFtvqTqSA2I2pqanB8ccfLxpk8abBH3S8zbFoeVhb3Y54CIcRXPYNypfNQj9FCaBPRKrVDBrIaX2oHnYRAuamUtWRqpWJJi16p5plq+4dBMtSs9MpAyqZjtsad/pIYYlQWnOh16qRgXooa1fBsW4OEjZMb7PcNclMT8UjL70NnV6PH374QYjVXQkKXB6XHfHY1gwWDj4+X5PA44DFSQMFBdt7c9uHHXZY8+z7sssuE/eD3377DYsXL8bDDz8sLAV5eXn47LPPxDorV64UFg4OeoTigVZMBl0vXboU11xzjXBXcWCMhhldDz30EJYvX45hw4ZtsZ/cHi2hjz32mHB1cZBlUHe0wIls56qrrhLbaav9OOE1xvtbpC04+3vwPe1tiyLijjvuwP333y+WMfiX23n77bdblPYfNGiQyDDiPZOumPZgbMT+++8v3sNjTvHE+y1FNL8z+42wuzGPKR881tGwIyY/84MPPmixnPtKix5FCc8f95+CYtasWUKw8LzRGhU5991BfB2RJD02aHLTpk3o27cv3n33XSiVHetJVi9ktsWmOlebbguiKPkba//+BsNDq+HXWJCZngmFv1FUmKwvOk4MRhGYdcGKlYVpJtksaweTbdXD6QkIy1JmwpbZNO7MMagYdwsy/74furpNSAs2oLZ8AUI6PUyGVDizJ7a57eHDR+CWB5/GXddcJAadsWPH4thjj8WugNsfxKA7vt8hn73snoNh1Hb+Vk1xwBgDxjaxvDgHYgoHDi70sUcGIQ5YDHCl9ZH3Aw66Q4cOFa9z5h6Bs1rC+CjOcgnFBgfZn376qbnxFt/DQfLll18Ws/sItC4ceOCBbe4vhQNjsTjQE4qXmTNnioJ2zz//fPN6jBc47rjjOvz+/D6RVuRsS84Oo88++2wLi0Lrbd15551CxESW0arCTsT8LmeffbYYxGkpef3114UFghYaFkujpactHnnkEWGpiP7c6C6ndFdQBNBq1BYUQOx2S2sD16VV4ptvvhFWCEJLCveL1pOI2+PNN98U54nWjIMOOgjdgbRA7KYwKp4/el6Mn3/+eVzBOpyVrqhoxKY6t0jVbEs8KKuXY80v72NocAn8Kj3SMrOh8TuhUCjhzBwHW5+jW7hCmHXByoiyXPWOhzcfxqBkJuhQ2eiJOft1ZY0XgZWapFxoFEAqGuDeOAfaNd9CV7ey3e0fd8LJOPnci8XfZ5511hYzQsm2M23aNDH75ABHEz7runCmzGPNtNroqrKMQejfv3/zeWABufvuuw+TJk0Sg2lHQa9r1qwRgxqFAT8z8qBFYu3atS3W5SDaFhwQWXiMnxsNn7e+RtrbTjStO4nyeXvbYowO95l1S6K/C49H5LtErCc8thE66lgasUBsC7QSaTSaZlcUrUG0TNA9RWhl4bmgBSKy3xR8Ho9ni/PQlUgLxG4IVStNieSNN97AkCFD4i5PzUElw6IXgXexUNk2YdVPr6Ofez7CCiWS0nKgDfsBRRjexCIR9wDlf8KDBaOYrlmQKstV7yxo1crNroxgUyfUGMLOmTMJlWNuQNrfDwENJUgL16J29R+waAwIDjsfAVPbs6mb7rgPq5Ytxvy//8CRRx+D+f/OFTe+nRkW3KIlYEd9dmdgrAL9/5zZZmdnC9EQL5yx0xTO2S1dTbQUcUZOC0YsaNInXD8nJ6fFa4xjiIYxFV1BV22n9bYi3+XVV1/donS/SqXaJhfStsJzecIJJwgLCC00/JfCMHJuue+ML4kVE5KWlobuQlogdjPov6QpjtBXyYuwIxhUt6TUJsQDK0y2KR5cVVjz48voa58NjSIAc2oejFoVlOEAAsZ0VIy+AWHNfz8mdoSk16RPmjlm+qdkx2HWqUWRqVCrzp3ROPP2Qc2466FMyIZKEUJaqBKOlb/AuuIjKH32NrfNm94TL72F9MxsrF29Cmecfe5OX6mS4pZuhB3x6Kyw5qDI9E3Wc4kWDwwMZPbD33//3byMbbt5T6B/PgJdGhdffLGwTDKLgwMqidSFiQ6A5fsoFOj64GdGP1r78tuDs2mKHbpXouHz6H3rDLNnz97iOY9BW2RkZIh9WLdu3Rbfha4MwvfTKsOZfVuf0xpaLNpLV+VxjSeomG4MBpUyzmTGjBnieYRRo0YJFxXdS633vTtTQaWA2I2gqZEq1m63Y/LkycLH2BFVdg8WlzSg0R1AltWwZYXJzTCVb/2Pr6B33Szo4YMuOR9GsxXKoAchjRkVY25EyNDkQyUsWkRhwiJGyab4ClZJti8sJU5xx54k0Z07o3HkH4CGMVcB5izRlj3NXwL38h+QuOrTdjMzUlLT8PhLb0GlVuOrLz7DQ483NW6TdB+MdWJkPgP2GKNAszeDHWk54PJITABjJpgtM2/ePBGDEBl0mdVBMUMXSXV1tZj10nLEIEJORhhoSHM538dYg0jgYbzccMMN4p5Efz5FDQMcaf5nkOPW8MknnwgL66pVq4Q7htkTl19+ebvvufvuu4XV5ZlnnhHvYyApYwmeeOIJ8fppp50mjgGP4bJly0SGCmM32uOWW27BP//8g0svvVSID7YLoIWIQeyEXY4p6pgxwWWMZYgF79mMk6BwoKCJtpJwWWpqqjiPDKLk+WPsA11S3dnQTgqI3Qj+eJYsWSKUNssL06fWFpwRFtc5heUhEAyLxlite1tE97jYNOM15Fb+CDPcUCXmwpSSC423DmGlFlUjr26uNElYrIhFi3KTDMhL7jpzpKTryU0yIi/JsEXnzmgaCw9H4+grETRlQBkOIcW9Dv6lU5Egema0bVkYPnocrr31HvH3Hf93E6bPaLs8tqRr4GBIUzej+um75++cg2DkXsCZMDMxKBoYwd+vX7/m4D8KDQ6wHNh5D4kMxgxQZKYCB97I++jSiMza44WD3bXXXiusHgzi5GybPn8Kn62B+8r7HC0AjMn48MMPO7Rm0IXDQEQeJ+4Dg0BZGyfyXRhb8PXXXwthMXLkSNx6660dTsR4DOkOomAbN26cOO4s1hexDlGA0UXCfaO7gdacWFC4MPA9klUSDWPZmDlDqxMDQHkeGMtBSwmtO92FIryz2w47CYNxaLKx2WzdeuB2NfiDOO+880SmBYMnIzndsaB1YEONE+trnMKUbWmnG6Yi4EbJzy8hY+OXSIYDIUs2LDkDoG9cLwpEVQ+5EI6ClgFEVY0eWAxqDMtNlAWjdgEYPEsh2eDyCyEZk3AYias/g+7vp6B3VyGkUMKRPAy+8VfCmbNnm9vm7ee6i8/GT99+hfSsHPz+1xz0LcjGjoQ3Xc7gOGhEB8tJdh042DLWi2mOks5d450ZQ6UFYjeAZjOazyKpVO2JB/q7l5U1Ym21A0lGbQfiwYPin15A1sapSIZdBM5ZcgY1iQcoUDvg9C3EQ6PbD5VKIYoWSfGwa8DzxHgInUaJelcbbgkWvel7PLxjLoVDmwpVOARL3SIY/n0J+ppl7d7o7370WeT3KkRVealIVauxx24XLpFIdi6kgOjhMN6B+dBUnIyupj+uLartXhHvUGFryrRob4CneNj00/PI3TQViXAgaM5GQq9R0Dc2pQzV9z0BjX2OavEelqp2+gKibDKLFkl2sc6d6RYRC9G6c2cLETHgFATGXIRGdRLUCMBYNRcJ/zzZbs8MS4IVj7/8NnQ6Pf6eNQO33XP/Fi3GJRLJbiogWASEgSI0lTDwg8EsbUF/U6SkZ+QhzYhbB83DF110kQgGYnnY9957L2axKPq2N9Q4sLi0AV5/CFnWttM0I+Jh4w/Po2DTF0iACwFzDkx9JsJQ35RjbSs8Eg39T9riM2ocPuQlG5Bt3fa0Jsn2JyNBh16pRmGFaN25sxmFErZBp8M76gI0KBKhCQdgKP0dSX8/KvqitEX/QUNxy32PiL9fffJBTPnmJzS0Ze2QSOK490n3RQ8QEIyoZWAMo2AZncs66ZwJV1VVtfke+l0iZT35YH12ydbFPTBwiAE6DCZilG5rnN4AlpbZsKLCAYNGLXL+20sbU3jtWP/NYygs+RwWuOG35MHcZwJM1fPE640FB6Fu4Jkt3sOgyYpGtxAmfdIsslT1rlxkKsWE7ESDyM5p3bmzGaUazmFnwzHsXDQoLFCHfTBu+B6pc5+AIrhls64Ix558Jg49+gSEgkHccdWF+Hv5RthcXdcsSSKR7GICgukvTHk599xzRZQp66UzYpTpNe3dqJiuEnkw4lfSOVgxLTpKunWFNyp01nVYUNyAchsrS+pEwGR7hF11WP/lvRhQOQ1GeOFLKICl1+hm8WDP2w+1g88XpuzWrhGmavbNMIsiRZJdF1qm6MpINGpjdu5sRqmBf/T/UDvgHDSGzVCHvDCu+BQp858DwqE2f/e3P/iEiIeorijFvTddhWVltpjNvSQSyY6nW+/mbOLBhiORcpviA5VK8ZxNRdqC+cXMOWYhEua1snBGW7AWO6NGox+7O263WxSI4r881qwv3zoWYXWlA4tKbAgGw8hKMEDTjsuCBBorUPz5rRjc8IsoEhVI7oeE/GEw1TaVurUVHo6a4ZfwBLd4HytN6jVK9M9I2Kp6/pKdD/Yr6ZfRdufOCGGVDorxF6G46DTYwwaoQx5YFr2JpGVvtfkesyUBj7zwBjRaLf74+Tu8/+bLWF7eKGpRSCSS3UhAsCgG84pbWxD4vKKiIuZ7WJed1gnmydJnz6IabPzSVjEM5h4z5STy6Ez1s54KXUbMU2ZVsugmWbQ60BqwsLgB62ocSDRoRDBjR5Xu3JVrUfX5jRjimiOMC8GMEbBkFcFYR2GnQH2/E1E3qKm1bzR2j19UMuyXaYHV2HY2h2TXI7mDzp0Rwmo9jHtdjpV5J8EZ1kEddCH5n6dgWf1lm+8ZNHREc32IVx67B/Pm/Ssyg3g9SSSSnYedzp7MIhvsV89e8CziwXKqLK7BbmixYFYB81UjD/ZE351hz3u6iQjFQ6TDG2/ytDosLGmAwxMUVSXjSaOsX/UHPF9fj4G+pQgp1QjnTUCiNRFGETCpQN3A09HQr2XAJOHAwoyLvulm0XhL0jM7dzImotbpFS3e2yKkMSF5/2swP+0YuMNaKP1OpP95J4zFLds9R3PauRdh34MOg9/nw8M3XorK2gZhiWirrLZEIulhAoJBewzgq6ysbLGcz9trXRoNK6Sx4hc7jcWCddgZdBn92F1hBbNI+1pWi2MLV1odGPC2YLPVIUGnESWK26oq2Uw4hLI/P4Lhl7vQO7QRfqUeKNwPSWo/dPaNCCs1qBl6YYvOmtHtuRlBX5RmFpUMJT0TWq56p5mEGGVl0fZq0oW0FmQdeiP+tBwKb1gtemVk/3It9JX/trntex57XvTL2LR+Ld5+4m7Uu/wiJkKKCIlkNxAQbBLCsqnRjUTokuDzjlqgRqALhOb4rKysbtzTXR8eJ9a1pxWG5VJZMIoZFpy1LSq2iUGdN3r6rzsi7Hdj4zePIWfx88hS1MCjSYRu0OFI8ZVD46kWM8qKsTfCXvBfbEsEWjrqXD70STejIMUkO2z2cBg7w7oerBNR20HthrA+EblH3YZf9fvBH1ZB4W1A7k+XQluzJOb61qQkPPjMy01VBT96F4t+my5EBK9pXtuSzsP+CDyeDQ0NO3pXJB2wzz77iN4ku7ULg/54dnNjYxVmBlxyySWi7zqzMgjdFdHFjTjwsW44O6Ix7ZODItM4IzNrSWzYnptNVFir/Z1330OF3Y95m+qxqc6FRKMGqeY4rA4MsKwvQ8nHN6B/2WdIUDjhNuTAPORwWBuWQBlwImBIQ+mEe+FJG7HFe1lkiOZsNsjqnWqW6Zq7CSadGkUZZvBsdxSnoDSlIPuoO/GLaiICYSUU7hrk/3gxtHUrYq4/dsJeOP+ya8Xf995yNcL2atQ5fFJExKB1/ZzWj7vuumtH76Kkh9HtAoLZAOxWdscdd4i4BnZXY5OUSGAlze6s9RChvr5epH2yGchhhx0msir+/PPPrW7pujvATm6ss0EefOxJOHWporaDAgrkJBrjbpVdvXwWnJ9djkHO2dAqgvCmDIK1cAwslX9DEfLDm9gHpXs+gEDCloGqLCxU7fAiP9mIPmmmNrt2SnomFKh90k3CvdBeUCXRJWYi6cj7MEsxCsGwAgpnBfJ+oohYFXP9S669GUNGjIbdZsOtV12ENLMGtZtFRJtVMXdDomvnPPXUU1vU02HTJolklwuiZD0CWhGYcsnBLroNKU1qrD4Z4cknn2xel5ka7OrGGAhJ26Wq2WKWLoxDjzoO/fc8QpQBzkwwCLNyPISDPmz88UUkzroThaENCCk1COZNREpS4uZMC8CRMxllE+5BSJcY0/LAOAt212TPhPaqWEp6LhSrFJB0ZbTVuTOCNT0X6oMewN/hwQiGAWVjCfJmXgFd3cqYcVAPP/sajCYz5s35C2889wQyrXrUOLwiO0OKiCaia+cwI611PR1aJyMwvX7MmDGiJg+z3Ng+Oxq2m+7Tp49wQzMzjgHZ0XDbDGxnV09ugxM+puYzVo2md5PJJLbL9t4RaAHhJJLvY7Yc33fSSScJt2v0eEAXLN+fmJgo6tdEFxKMZ7/YTfPYY48V22cnT3b0bA92G+V6rHjMie0JJ5zQ/Bonu3vuuafYl5SUFPF9o7/Thg0bxGd+/PHH2GuvvWAwGDB27FhR/ZctvHmMedwPPfRQ0QI9wjnnnCMqZbJjKJMEKPYuvvhiUfqgLTgmUgSyKyqPD8dRHq8IPE5HHnkkkpKSxOuDBw8WnVa7E3mn38W59LLLhbsnIzsX5998vyjwk56gj9sC4K4txaYpN6Bo3TtIQwM82hToBhyCFDRC66pEWKVFzeDzUD3ickC1Zf8K1pSocXjEwNE/09JhPQlJz4Uuq8I0MzITdKJIWUeNfjPz+8C2zwNYECoC9YaqYR1yfrseurqmkujR5PXqjVvvf0z8/dJTD2Ppgnkipocus+1iieB3Cfh2zKMbGiazDfXjjz+OuXPnirbS7NQbgV0sr7rqKtFWe8mSJaIcPl3OM2fObLENFqijC5pW5QEDBoiJDNelS5rb5fmPFLOLQIHBwZYtsTk4z58/v7nRXyAQEIMqs+/YAJCC5MILL2yOo4p3vzgoU5hwG7Ris/V1XV1dzOPA/WQbcbrOKaK4T5MnT25+ne52uuG5HmP3mBJPccJYvmhoAb7tttuE253Hk8fixhtvxNNPPy1cy/zetMJHw+3RrU8RwIrBzDjkvrcFjyWPCasK87uxxxFbp69evVq8zjbsFBls6824QbYZjxaN3YFs572LQpfB6+98gEvOO1Nc1M+99yX23Guv+DcQDqF03rcwzn8VeaEyKBVh+K2FSMzuC30DM15CCBhSUTXqGniT+sXcRFPAZJPbgtUJpeVBQujGYFM2jz8kXBsdMX/hPAyefR0GKIuhVirhTxuM8on3wZM6uMV6vFXddPn/MP2rz0S1yo+n/wadwYRKu1t8zqAsa1xBwlvV6pgD+azHsUPY6zpA3bnmc7TqMgCvdbAkByt24/3pp5+w//5NnXI5Sz388MNF4Tl+X876OXt95ZVXmt/HAZmDKS3ChIM6B0yKCDJ79mwRGP/66683ixEOdBzgud2IBeK+++4TM2XOogkHbH52aWmpsCpwls99pIhozdbsF1/jIPrdd9+JwbY1HLS5j6wzZLFY4qptRIsBB+ghQ4YICwSvE1o9zj///ObvfeqppwqBsN9++zXHqPGcrFixotkCQRHFsgO0lBCm399www1i7OI9nZYcWmzojqKrv7CwUPybnf1fu3sWCqTF5oEHHsCwYcNw/PHHN7uz20O2895NoWmYs7sf/lmGG66+Qiw799KrOyUe/I46rPv8bmTNfRS9Q8UIK7VQ5IxFalIi9A30Q4fhSh2O0j0fblc80FTdO8UsxYOkBSyJTlcWr6N4ij+NHD4KswffhQ2hTARCIWhrliFz9t3QVzdVOY0gBof7H0dGVg42bViHx+69TVjaMiwGUSBtWXlTtpGkYzjYRIhkuEX6E3FW3Lr0PZ9zeVvbiMS0DR06tMUyDlTR1YHz8/ObxQOh6OBsnrP/5ORkMbCyVxJN8Zy9R8fHbc1+0ZTPQbCt3ksHHnigqHrMwZmt5N9//324XK7m1zm7pxjg69wOm0ISDuSdPRat94F9oSLiIXIsWIU5Vi0jCha6qfv16ycEUeTx66+/NrtUaEmhQOMxoYiglaK7kbWFdxFC7Gbp9KK03o1Kmxt3XX8FHI0NGDh0OC695ub4NhIOoXzJL1DMeRlDguuhUQThM2bBnDsIRmcJFN6AqBxY1+9kNPY+fIueFtEzTA4MDJakyVoGTEpiBlWmmbGiwi7cWh0VLdtr0mR867oFx6y/B9moha56MTLnPITKsTfAnf5fDFRCYiLue/IFXHDK0fj0/bcwef+Dsc+Bh4qYHzZsWwZbl1kiWqDSNFkCdgT87C6GcSURIi6C1mb5rdnGtm6XDQA5ENIywUaMtCb8+OOPGD9+/FbtV2Q/2toHWh3odqDVg9l/dDPQUsL4BcY9UMhQYDCTkDN/boeWh9axCpo4jkVnj280FBasqcTYFf4bTcRNwUxFii9aY/hdWKWZbqorrmiaaHYHctq4KwgHhxeLShpECeo6pw8zP38Xc//4BTqdHg8+/YroG9AR3oZyrP7sbqT8eR/6B9dAxfLWGYORnJkLk309FOGAaI5VOvE+NBYe0aZ4YIEoVphkvAMHCCkeJG3BImLxBlXyBnvQgYfhk4yrUBVOgj8QgK56IdLnPg5DRctiU3tM2htnXdjkW7/zhitQW10lrkOKCFoiGBPR5ZYI/h7oRtgRj+1cS4UBkX/88UeLZXzeFZlwnLmXlZU1P6frg+Z6BkRGYNA84yiYfcfB+oMPPujW/WLMAl0BjzzyiJi10y0xY8YM1NbWCssIRQzdPfx8Zgl2FQsXLmx270SOBcVArHYMPCa0QNCKUVRU1OIRXZSR72UwJl0zjBWh8OlOpAViJxYOLMhEiwOr/FHppZh0KF63Gk8/2JTPfe1t96Cwb/8ONuRH8T/fQLP4AwwPbRBWh4A+FZaMXtAHGqDwuBFWaZracA84PWagZAQKGeqFwdkJIoBNIoknqJLuLrrd2M69vcJirFNyyJGn4MOPbTjD/ipSAnboaxYjfd5TqB55OVxZ/2VvXXnj7fjrtxlYvWIZ7rzxCjz7xkfNIoKWCH7MgMyErrdE7AbQD8/YAg5aHFjpq+eAxLiJbYX+9rPPPluk9tO1QWsDP4uDIH3yjG846qijxGyfgzddCAzU7K79mjZtmghCZ+AksxcYD0JLAQUNnzMmg/tENw/FDyv8dhU+n0/ETVCgULTQ7cBAyUjvomjoumAwKI8FrQo8BszqYJwF3SeMI2HMC7M9uC6FDoNLKXq6EykgdlJXRVm9G9UOnyjOk2LSCjMw+wLcctWF8Ho9mLj3/jjl7Ava3lA4jMaSpSib9RaK7P8iVWFDQKmDKqUPrEYtVL5aMbPxWfJRPfQi+JJjxzoQzh6rHR7RTZOWh3gC4yQSwvbtjIdgQGWNwyfKqLcHr/P9jrsAH3/UgFO8U5Dsc0JXuxRpC59HdSgIV87Epu3qdHjwmVdx2pH74befvsfnH72L4089q1lElDc2zeykiOg8zIRg/AEHeWY9MNCOrgUG9W0rnDEfd9xxIjuCmRFMi2QaJWE8AIMMWXSQs38O2swsYLZFd+0X3RQUIXRbMF6D6ZzMiGCwZiQgkiKHlhCKimeeeaZLjgOhVYOfR/HC7AnGWrRX7IvflTEOtCww6JStIuja4TEktFDweDEglPEaDBplWYTuRGZh7CSwGRFNvWUN7qaZPhSiU2Z0WuRzj96HV555DNbEJHz2459Iz4xd3jtgr8LaWR8jqfgHFCrKRYYFDKmwJqdBHXQL4cD0zIbeR6Kh3wmAsm0dyRoPFA8UDRwI4q0tIZG0buu+uMQmrueEOK4hrr/04ztxTGA6kpQuqAyJ8Cb3R83QC+DM/S/N7u2Xn8Xj990uakR8+sPvyM3v1Sx6KSIyE/SdFhHtRahLth4OjlOnThVpn7s755xzjsiQ4fHYEcgsjB4CB2iKhvnFTTEO9U6/cFWwlkO0eFg8/1+8/nyTmrz9wSdjiwefE8V/T8WGKTdhUPGH6KcoATQGmFILkGI1bhYPSniSB6J00oNoGHBKu+KBpYIj1SWH5FileJBsNSlmnSh3zfiZjipVRtbvfewd+FE5AfUhI4JuG3QNa5C6+FWYN81oro1wxv8uxahxE+ByOnDbNZeIWRihJSJLuDM8WFHRDTEREolECogdBW9oxXUuzNtYLwIknZ6AaHtNE2/rYkwetxu3XnNxU7XJo0/AQUcc0+J1RdCHumUzsXTK7Uhe8AJGhxZCrwpBY81AWkoK9OowoFAhYEhB1YjLUT7hbvgT8tvcNxqlGKzp8AUwINOM/pkJcbX+lkjaIyfREFf77wh5SUaYD3sIf4WHoD5sQNBVD23jBqQsfRPmjT8IEcGI9PueeBEGo0lUqXzvtSZzOJEiQiLpXqQLYzvT6PGjqtGDcpsHTm8QRq1KzOzba3T1yF234L3XX0RaeiY+/+kv0aVQEArCXTwf6/7+Bsn189FXUSrcE1q9GVaTHgqlBmG1VrTebiw4EPX9T0FY3X7wI2/sDNo06dXol24WlhCJpCsLoLH8dLnNLQJx42nwNm9dOTJ+vAxDleuQpPJBaU6Hz5KHuv6nwN77MHHNf/rB27jnpqtERtKUb39FUf//gsc6686QLgxJT8fTRS4MGUS5nQIj610+EYle1eiFJxCEVa9FtlXTIio9GApiwfz5otoZA2RGjByJeX//KcQDueuxZ5vEQziEQNlirPv3e4TKF2GkYi10Cj+UWjOSjCoo1RqENUaElSo400ejbuCZCJg7bodOl0WD2ydu7GzHzYJAEklXQutaPwZVBoIi5TIjDoE6qjALv096BIY/rkIRSpHkrIZGoUTyyo+gDAVg63OkCKCcMX0afp/5I/7v6ovw/pc/Nac3RywRMrBSIula5AjRjUTaWzPGgbENJEGvEf7d1syYOUNEF1dVVjYvS01Ngbtyvfj7hNPPwV777A9ULMb6f39AY+lyDMEaJCnsCKmNSDaooVGrENRZhXDwJPZF7aCz4UvuIM1zs8uCAZxhhNE/w4K8ZKOsLCnpNjh48zpbWNIg6oqwf0tH7DmkCD847oNu4U1AoAqJzlohIpJWfwJQRPQ9Fnc/+iyOO2ACVixZhFeefQyXXfd/ze/fGhHRw4yzEkmXX9vShdENsEpjjd0r3BSNngB0aqVwU7TVaIrigY1XWjfNCTRWI+RuRHp6Or795E1UrZyNitI1GBBciyxFHUIqPVL1IbF9vz5VVKzzmXNR3+8kuLLGx1WApqkktVfcxFkYqqM0O4mkq6AbY2lpIyx6tUgR7gjeqr6ZMQMHrbkfmco6JOqUUBpTEDBloKHwSDT0PQHffT0VN11+vigO9N5XP2HQ0BEtthGPO4OxRuymyN8d6wBIJD0Nm80mCnoxrbZ15U7pwtgBMHag3uUXbgqKBw7MZr1GFM9pz89LtwUtD63FQ8jrgtrXiDG9DDho30FYOOMDFAY3YrKiSgiFZJ0KOpUffmMa/GoD/KYM1Pc9Cc7sPVnBp8P9jQRKBkJhEdjWK9UkAyUl2xUO4i5vEKurHEJcd9TJle6+w/bbD9Nc9Tii7FnAa4NVaYNaoUDiuq+hCAVwyBEn4afvjsaP33yJ2665FB99M1PUjOiMJYKBmawPEOldwPoE7RXAkkh2JVgoi0WoeF1TaG8LUkBsI2wjXOvwidmUze2HAoo23RSxeOONN1q4LYhZFcDoTDsmHjIa6fm90Fdbg/zgPKhVCqRqAYPKIzpl+jUWBEyZaOhzNOx5+wHK+ASAsDo4vEg0aVGYahJWB3mDlGxveM1RuLIl/KY6lygA1VFpdIrxww47Dt99Xo/D696Fwt2IBJULakUNrBu+EyXZb7v3Icyd/QfWrFyGl556BFfedHuLbcQjIiLlgdtqwiSR7Mqw2iUbm23rfV+6MLYCmkHpu62ye0TGgtsXglGjEqbYzsQOCNfFDTc0P88yBrFHrgrDC9OQnJmNXpp65KAGurAbKWo/LHoVgvpEBHVJ8FvyhHBw5O4tajvEu9+0OoTCYeQmGVCQYpLBZJIdDgXt0jKbEOK0SsRzU+N7/pzyGPZ3TUOK0gGzJQlqjRYBfQrs+fvjk40JuPri/4kb5Xtf/oQhI0ZtsY143Rl+f8cdRSWSXQm2To9VMruzY6gUEJ2AWQocgJusDQHRrpjWhnj8t7FcF+z0VlNVgYFJQYzL1aCwVw6SU1KQp65DKhphCdlgDtqgCvmhS8yCOikXPmtv2AqPhCN7UtwWB+LwBGDz+IRlhC6LVLNWWh0kOw2MG2KlSm8gFHepdLvbhyVT7sRE3+9IVrpgtqYKAR/UJ8OeNxmXvPwXvvpyqugXw9ROXYyUzIiIyLDoMTBLZmdIJI1SQHS9gChtcGNNpR1ufxBGjbrT1obWLJwzC2/deynG5huQnJOP9CQLshT1SFQ4kBSshSVogyIcRKMPqA3o0WfySbD1OaaptXGcFodIJgh7a+jVShSkGJGdaBT9CSSSnQ2WcF/SiXLXpNbmRMlnN2JEYBGSVW6Yk7OgRhBBXSJqkkZjn6tewqbyapx7yVW45v/ujrkNigg24GIhNykiJLs7jVJAdL2AWF/twKpKB7ITt6ELZTgMrX0j9NWLsGz2j1heUo1sqxapigaY4EFaoFJYHcLBAJxBFYrtKvxdqUbO0bdg+MFnd0o4RNwVwXBYBHIyNVOWopbs7JTUu0ShqUSDNu6BvKy6Ho4vr0X/0BokqX1ISMmCKuQTImKRIxmH3vIenAEl3p36I4aOHB1zG1JESCRNyF4Y3cTWWvyVfieMFXOQtOQN2Ga/hz9/nwG3owYjEl0oUFSgMLgefXyrYfLVwuH2Y3GtGq8sNeCyWRaUjr4eww85N27xQD3IYM5KuxsJBjWG51kxKCtBigfJLlPumoG9dS6vqFoZD9lpSdAdch82IAf1AS0a6qoRUJuh8towzFyL588ZiQRtCHdcfxl8Xm/MbUS6eDKuaXm5LHstkcSDzMLoLsIhaBs3wlCzGIraNVhbaUNpZRUSAzXIVrhgUPiQHqiAIegQgVr1niDW1IUwdZ0GM2sSUexQIT0jA+edd36n4xyYPjooy4pMa8uGXBLJrpKZ4faHUFrvQlZifOWuC3JzsGbfO1E+81aE/dVAXSWsqdlQe+04YlgqyvZNxKO/rIyZldFaRNASQaQlQiJpHykguhiVpwH62iUw1C2Hs7EeSypssNeWIincgF7wwqj2I1/jgFnlg8+nwMbqMNbUhvHRIi9mbFKgwZAJBYMjFcD1118PVRyBkpwtccbGm13fdItws8gbn2RXhbFFfTPMIr2TFgEO6vFQ1Hcglrlvhvqve0WNiFBdNZJSMqHz2XDKnkXwexbhhXeewgGHHolBw1oWmIolIliZlUJc/pYkkthIAdEFKIJe6OpXw1C3DBp7iahAubC8Bkp7CZIUDqTAD6MayNU6YVJ4RUOroC4ZwcwC/OUK4fpXp6DRC6iTsqFUKJGRnoHrrr8O++27X4epbHUuH7QqhcisyE02yv4Vkh4Bi5r1y7RgUQnTO71x11UZNGwclrouh3rh04DbgXBDPZKSU5GGehw+IgsqRTmevfUiPPPZrOZeGe2JiGWwSREhkbSBHG22xUVh3wR97XLoGtYg6PdhfY0DtZUboffWI1vhQFgJJGqVyNJ6oIcPIa0Ffm0G/KZsUXq3Imk07rh1XyEeDjjiWBx8zMnNTbTaszxwZsbmXEqlAnlJBuQkGmE1yhgHSc+CKdLsmbGktAGNbn/cmRmDxx+MJe56KFe9BTjsgEqPJGsyCgsCmGhrgFK5Hp8+ewdOve6hNrfRWkTQnbE16doSSU9G/iI6icpdA0PtMujrV0Lps8PuCWBNRRU8tcWwhm3IVgQQVqmQplciVeuHRuFHSGOFX2OA35gBG6tG5u4LqNR44pZrUVFWgtz8Xrjv8edgNJo6tDgwQJLuDXbMZDEoBkfKeg6SngqrpBalW0RgI+N54rUEDNn3FCx116Gg+EuEbdUIafRIMWeiqLcDAf8aLFj+Fkrm7YfcUQe1uY2WMRGNUkRIJK2Qv4Z48NqhK5+L3A0LkBJuAPNeK+sdqC3fiJCzRtRuMClU0KqUSDNpYTVqoQoHAJUFAYUCflMWGvocA0fuPs19Kub8+Rs+ee8N8ffdjz3brnigcKDFQaVSiMBIxjgkGaVwkOweUCh7/UGsqXYgXRV/YPCgQy7Gqi/rkVv9K8I1pQiri5Ca3ReZ9bUYqahH8ZRrUFDwBYIp/drchhQREknbyF9CPKz6HobipWh0uFBcV4mG2kqYAnUwKsIszg+DVgdLQiISTDqoAh5Rjz8MreiMaSs6Gg7R4Oq/mZPb7cJdN1wp/j7xjPMwdsJebfbZaHD7oVEpxE2UVodEKRwku2lmhicQEnUi4umZId6nVKLoyJuw4bNGZNrmI1yxDorcQUgrGo3Gxl+Qh3pUf3I9sk56FN522t5HRARTo2kJkSJCImlC/griYJNbh4oVi+FuqIQOXpgVChF/YDRbkZBWAJNWCY27Ckq/A1Co4EvojYbCI+DMngAot/TbPv/o/SjZtAGZ2bm45v/u2uJ1hzcAm9sHvVqF/OQm4SBdFZLdPTOjKD06MyO+nhkqtRoFx9yJ0k9vRKpzFYIlK4HeQ5GYPxiBdQsRLP0X6r+fh2LcRfCkDG57O0oFMixSREgk0chfQBys/OMrWGzF0CkApdoAdWoh0rJ6Qe9vgNaxCapGO8IqHbyJRWjsdSicWXuI57FYNH8u3nv9RfH37Q89CbMlobkAFOMp7F6/8PP2STMjw6oXgWQSiWRzZgaDKgM21Dh8Ij4iHtQ6I7KOuR81n10Dq6cENRuXI61wBALlpSKmqXbRD+hlscDW/yS404a3uR0pIiSSlsirPw7yRx+Eqr/rEM4Yht6ZadA3roW2fglUPhtCGhM8SQNgz98PzqzxIkWzLVgF787rLxf92I84/mTste+BooRuo8cv3BXmzVHn6Ql6mGQ6pkSyBRa9pklElNpEQHG8FVa1JiuSj3oA9i+uhdFfg/L1S5E58iAs/XkKUsONsK/4FYl0e4T8cGWMaXM7UkRIJP8hr/w46D9oBJLDDXCWLkVC6TKovPWizr4nZYjoiknhENKaO9zOq88+hrWrViA5NQ3X3Ha/aB7kC4bETbAwzSq6EHKWJZFI2oY1IfpmWETPDMYHxTuA6xMzETr8Xni+vgm6YCOqyzcgacCeqFjyC5SbNmBwUjISEYYi6Be/6bZq10sRIZE0Ia/6eCj5B4ZNv0DVWIWwOV2YOV0ZY+HI2gMhHectHbNq+RK8/vyT4u9L/+9+BLVmJBvUooZDilkrS05LJJ2ADeKYmbGqyiEGdJ06PuFtTO+D8IG3wf/jXdAGGuHXpsFhzEWprQSmdWvQX6eDde1XwhLhyNlLigiJpB3kFR8PfrcIhrQlD4cydxScWRMQ1CfH/fZAIIDbr7tc/LvnAYfhxBNPEG21k41aEYwpkUg6BwMo81OYmRHExlo3Miw6EWgZD6b8EbBPvg7BXx+GyVeNrL5DMP+3SoRL6pGcWo00FrFa/60QEfa8/aSIkEjaQF7t8TDgcLh8OmzUD0dKRn7cbwttDox8+5VnsXzxAlgSrHj1pRfQPydRZlRIJNsIB/A+aRb4AmGU29wiWymexlvE0ncv2N02hP5+ASn+UvTeY1+s+P17qJeuwwF7pkBnWwtsDEMRCqCx4MA2u+FKESHZnZF283iwZMLZ7xj49JybdEwgGBL1+3lTK9u0Hu89/6hY/sTjj2FAnwIpHiSSLkKrVoqgSsZFVNtjt+puC8vQw6EYfirCUKG3ogIpw/bF4nIv5q/ciLBSA51tPcybfkbChu+AUNvtvSMigjFNjMtgQLREsjsgBUQXwoqRFY0e1Di9MOvVGJZrxYv33wyP2419990X558ff2tuiUQSH0x7pojQa1VCuMeNQgHz2DOAgYcLy8UYaz0UhRMwc+EmlDb4EFaqoWvcAEvxTFjXTwNCgQ5FRK3TKywRUkRIdgekgNhGWL+BhZ9KG1yihkNGgg4j85PE4/svpuCXmTOg1+vxyiuvSMuDRNJNMJOJKdBE9IvpjIiYdDEUhftApQjhwFwfbDkT8MUv8+BSJwpLhLZxE8wlvyFx7ZdAyB+XJUKKCMnugBQQWwnjG3ijKrO54Q+GROGn0fnJGJrTlI5ZXVWJa6+9Vqx7zz33oKioaEfvskTSo2Fhqb6ZFrj9wc4N3ko1TPteA0XuOGgUAZxQFMRK3UD8PG8t/Mb0JhHhKIGp9A8krfkCimDbVg4pIiS7E1JAdJLo+AYGfTNoakyvJJGXzpbaESvDFVdcgYaGBowePRrXXHPNjt5tiWS3INuqR2GqCfUuP3yBUNzvY+VY04H/B2XGYOgUPpw5RIXP1iixvlEFvykTYYUaWmcpjGV/IXHVp1AEPG1uS4oIye6CFBCdwO0LNsc3DM9LxOiCZBSkmLaIuv7yyy/x6aefQqVS4bXXXoNaLaOyJZLt2XirIMWAaodXCP54CWuMMB18B1TJhTApPLhwrAGP/LgRLlOe6KgboiXCWQ5TxRwkrfoYCr+rzW1JESHZHZACIk60GhV6p5kwIq8pvoEpY4wAb43NZsOll14q/r7hhhswYsSIHbC3EsnuSyS9k8WmKu0e4W6Ml5A+CaZD7oTSnAmrwoHTBwNPzqqFz9oLflO2CKxUu6pgrPhHiAilz9GhiGB2iBQRkp6IFBBxkpNowLDcROFnba+V8C233IKysjIR83DHHXds132USCRbpneyeyeDneMlaM6C+bC7EFCZkK60YYJ+Db6uzobfWgCfOQdhlRpqTw1Mlf8gaeVHUHptHbYClyJC0hORAqIL+f333/Hii02dNpl1YTC03VhLIpF0f3pn/0yLcDGye2dnCCYWIuXo++D2hZGrqoVhzZeYo50AX0IB/KZcYYlQeRpgrJqHpJUfi7/bQooISU9FCoguwuPx4IILLhB/s94D6z5IJJIdS4JegwGZFhHw3ODqnIgIpA6GYZ9r4XR5UaQqR/UvL2GheTJ8CfnwmfMRVqpER15j1b/CEqFy18YtIhhPJZHs6kgB0UU88MADWLFiBTIyMvDoo02VJyUSyY6Hbox+mRZ4AyFRs6UzmIYcik1Je8Hl9mKwagM2/PwqlibtD39CHnyWfIQVKqj8zs2WiI9EfEQ8ImJZuU2KCMkujxQQXcCSJUvw0EMPib+fe+45JCUl7ehdkkgkUTDouW+GGXaPX1SM7Qyjzrgb09eE4fF4MTy8Ast/eA0r0g6B35IHX0IvhBVKKIIeGKvmN4kIZ0Wb25IiQtKTkAJiGwmFQsJ14ff7cdRRR+H444/f0bskkUhikJdkRK8Ukyg3zeJv8aJUqbDnVa/h/VkbEPB7MTq4CPO+fQOrMw6F35wLrxARCtG901C9UIgIjb2kze1JESHpKUgBsY0waHL27NmwWCx4/vnnZblqiWQnRalUoDDNhNwko8jMCIbiz8zoXdQPhj0vxcez1iEU8GF84B/88e17WJdzFAKWXPgSCkVZbEU4CGP1QiSu+hjaxg1tbk+KCElPQAqIbaCkpESkbZIHH3wQubm5O3qXJBJJO6hVSuHKyExgjQh3p2pEnHPJNfipLgdf/70OqrAfe/p+x4xv3seG3GPgt+TAa+3TvC5FRNKqT6BtWNvm9qSIkOzqSAGxlTCv/LLLLoPdbseECRNwySWX7OhdkkgkcaBTq0RQZZJR26kW4BqtFrc+/AyemWXDD/+sg04RxGT3DHz/zRSU5B8LvzkbHmsRwlAAChX0NYuRtPpT6OpXtrlNKSIkuzJSQGwln332Gb766itoNBq8+uqrUCrloZRIdhVYG6J/ZoKoFcFy0/EyfNRYHHvG//DwzDrMWVkJoyqIvZ3f46tpX6Cs13EI0BKRWCRiItiEy1CzGImrP4e+dmmb25QiQrKrIke9rYBNstgsi9x0000YPHjwjt4liUSyNS3AMy0MXehUjYgrb7oDltQc3PrlBlS6NDArfdjH/jU+nzYN5b2Ph9+SK0QECakNMNQsgXX1FyLAMl4RIYtNSXYFpIDYCigaKioq0K9fP9x66607enckEslWkmrWCRHRmRoRJrMFt97/GBq9wPkv/glNci8kKD3Yx/Y5Pv3mW1T1Pm6ziOhLXydCGiMMdctgXfsVjJX/digiZAMuya6CFBCdZNasWaJMNaHrQq/X7+hdkkgk27lGxD4HHooDDz8aVY4grvlgGZJzByJR6cLkuk/w8Xffo6rweFGx0pPUT6wf1FqEGyNh3TSYyv4SwiIWsounZFdCCohO4PV6ceGFF4q/Wfth8uTJO3qXJBJJF9WI6J1qQp3LC18gvhoRN9/9MCwJCfhlzmJ8XJqOlJy+SFY4MKn6I3z83U+o7XMc/AkF8CT2hSIcRlCXCEPdciRsmA5z6ay4RMSyMikiJLu5gGB9hF69eonZ+h577IE5c+a0u/4nn3yCAQMGiPWHDh2Kb7/9FjsDTNWMlKt++OGHd/TuSCSSLqwRQQFBIVHt8CAQR6GptIxMXHPrveLv+x59HmWFpyA1uxBpikaMr3gfH02fidrCY+Cz9oYnqa9YL6BPgr5+BSwbf4Cl+Od2RUTEnUER4exkCW6JpEcIiClTpuDaa6/FnXfeiXnz5mH48OE4+OCDUVUVu2b8n3/+iVNPPVU0pJo/fz6OOeYY8WC56B3JsmXLRL8L8uyzz8py1RJJD6wRUZRuES6NCrsnrhoRx51yJkaNmwC3y4n/e+BpBCZchdSsAmQoGzCm9F18/OOvqOtzNHyJRZsDKxUI6FOgb1gN86YZwhqBUGy3iVKhEPtS6/BhWXljp/t4SCTdjSLMggbdCC0OY8eOFT0iIqWf8/LyRBbDzTffvMX6J598MpxOJ6ZNm9a8bPz48RgxYgReeumlDj+vsbERVqsVNpsNCQkJXfIduM90V/zxxx844ogjRPqmrDgpkfRMmEa5tMyGOqdPFJzq6Le+fs0qnHDwnvD7fHj4uddx7MR+UPz5FGoqi7EplIHFvc7FCQfuhaQN30FXvxo62zpWkoHaUwtvQm84syfA1vtwQKmOuX0KmYpGD5JNWgzMSoBZF3s9iaQr6MwY2q0WCJ/Ph3///RcHHHDAfx+oVIrnf/31V8z3cHn0+oQWi7bWZ1wCv3D0o6th0CTFg9lsxgsvvCDFg0TSg2FtCGZmsBV4PIWmWOb6giuuE38/fNfNqFTnAuMvQUp6LvKVlRi04W18/vPvaOh1GDwpA+G1FopW4AF9KnSN62Eu/R2Ja76AIuht0xJBIUNBs6zMJoI9JZKdgW4VEDU1NQgGgyJmIBo+ZxpkLLi8M+szLoFqKfKgdaOroSuF3H///d2yfYlEsnNh0TfViNBqlKiNo9DU+Zdegz79BqCuphpP3H873BljoBr3P6Sk56C3shx9172Dz2f+CVvBwXCnDYXP0gthpRoBQyq09mKYyv9C4qpPoQh42hURDS4/lpY1olGKCMlOwC6fhcFeFDS1RB7FxcVd/hkvv/wyZs6cKUpXSySS3YMkk1aIiDDCsLn9HZa5vuOhp8TfX0x5D3P+/A3OrAlQjz4byanZ6KMoQ681b2PqzD/RmHcAXBmj4LPkI6TUiZgIjbMcpoo5SFo5BUqfo10RQQsEAys72ieJZJcWEKmpqVCpVKisrGyxnM8zMzNjvofLO7O+TqcTfproR3ewzz77iO8ikUh2H9ItevTLTBD1ITrKhBg5djxOOvN88fe9N18Dj8cDR+7e0I4+HclpmeivKEHu6nfw5S9/wp6zN5xZ40TBqZDGgKAuGWp3DYyV/4h24EpvQ8zPoPs0w6KHwxPA8rLGTlXQlEh2KQGh1WoxevRo/Pzzzy0CEvmcDahiweXR65Mff/yxzfUlEomkO8m26lGUbhJug44KTV118x1Iz8jCxvVr8eqzj4sW3/b8A6AfeTKSUzMxQLEJWavexbRf/4Aje084cibBb8pGUGtGUGeF2muDsWoekld8BJW7pk0RkW7RiawMujPqnVJESHqoC4MpnKzY+Pbbb2P58uWiayWzLM4991zx+llnndXcEptcddVVmD59Oh5//HFRc+Guu+7C3Llzcfnll3f3rkokEknMATs/2RRXoSlLghW33PuI+PvNF5/CquVLhYho7HUIDCOOEyJikGIj0la+L0SEM2Mc7Hn7IGDMQECXKISE0u+EoXq+sESoneXtiggPM0bKG+OK05BIdjkBwbTMxx57DHfccYdIxVywYIEQCJFAyU2bNqG8/L8fycSJE/HBBx+IzAfWjPj0008xdepUDBkypLt3VSKRSNosNFWYZkZ+MgtNeeFvp9DU/oceif0OPhyBQAB333SVCCSHQglb7yNgHH4MklPTMUixAanL38c3v/4BV9pINBYciKAxTWRmhDQmKIM+GKsWIGnlx9A0bmxbRCTo4fOHRJ2IzrQml0h2iToQ25vuqAMhkUgkhMKBPSrKGtyiUiQrRsaisrwMx+4/Hg57o7BInHpOUwl8hAIiZdOxeBrqaqqwONQbDQNOxWH77Al9/SpYN3wHpaceGlcVFCE/FOEQ3KmDYCs8Ct7NfTViQQuEQgkMzEwQokIi2eXrQEgkEklPQqNSol+GBRkJelTa3W1Wq8zIysZVN98p/n76oXtQUVbS9IJSjYaiY2AecpiwRAxRrkfiig/x7cxfReOthsIjETSkwG/KQlilFqmehurFQnToaxa1uV8pZh0QVojsjApb7FRQiaSrkQJCIpFIOoFe01RoKtmkQ2WjB20ZcU8841yMGLMHXE4H7r/1+v/WU2pgKzoGlsEHIyU1A4OVG5C48mN8M+MXUWSKAiNoSIbflIOwQilcGvqaJbCunQZjxd9t9s9gpUq6WpaV21Da4O7OQyCRCKSAkEgkkk5i1KoxgNUqDRoRExELVt298+GnodZo8OtP0/HjN182vxZW6dBQdBwsgw5AatpmEbHqU3zz88/wmfNQ3/d4ISJYKwLhEELs5Fm7FJYNP8Jc8mubIiLJqIVWpRIpnsV1zjbFjUTSFUgBIZFIJFtZrZIiQqdRtRnAyOqU5192jfj7wTtuRGPDf/Udwmo9GvqegIQB+yI1LROD6c5Y/Tmm/fgj/MZM1Pc9sUlEJPQCwgFRtdJQtxTmkt+QsOG7NptwWQ0aGLUqrKhwYGOtFBGS7kMKCIlEItlKEo1aDMy0gDXm2qrH8L/LrkWvPn1RW12FJx64o8VrFBH1/U5CwoC9kZaehcHKjUhaOxVfff8dfIY01Pc7GQFjqmi6xaBKxkbo65fDVD4biWunttk/g+LGolNjVaUD66qdCIWkiJB0PVJASCQSyTbAAEZmPwTDoZjlpXV6vXBlkM8/fAdz//o9tojoNxlpGdlCRKRumIavv/0KPm1ik4gwZQgRoQx4RGyErmENDJXzkLj6Uyj8rpj7ZdKphTVidZUda6ocCLSTeiqRbA1SQEgkEsk2wtTJ/ix5HQjG7JY5eo+JIqiSsDaE19MyUyKsNqC+34lI6Lsn0jNzMYgiong6pn3zOfxqsxAYfkuOCLJUBD3wm3NEJ09D1UIkr/wIKk9Dm7EaKSYd1tc6sKrK3m79Comks0gBIZFIJF1AdqIB/TMscPqCosx0a66+5S6kpWeKMtcvP/3oFq+HNUYhIixFE5GRmY/Byk1ILf0J0776CD5o0dD3ePgSCuAT7gyfKIGtdZZDX7MYSSs/hNpZ0WbWSKpJj021bqyssMMbaL8ct0QSL1JASCQSSReRm2RAvwyzsEK4fIEtylz/331NwuGtl57GquVL2hQR5qKJSM/p3SQiKn7Dt1PfgyekQkPRsfAm94PPnM+qVPAb06D21kNfu1RUrdTa1sXcL61aKUpfl9S7sKLc3mFPD4kkHqSAkEgkki7tm2FEnzSz6JTZeqBmmWs+WOb6rhuubCpzHUtE9D0e5t57ICO3CEOUm5BWMxvff/4GXP4QbL0Phzt9OPzmXIQVatFDQxn0Ql+3FIlrPm+z4BSLYLF6ZrnNg6Vltg67i0okHSEFhEQikXSxiGDjLfbOqHVuKSJuuecRWBISsGThPHzw5ssxt9FkiTgBpt5jkFEwoElE1M/DT5++AofHD3ve/nBmjUfAlImQ2oSQ2gAoVNDXLkfC+ukwlf0Rs1YES29nJuhRY/dhcaktZtCnRBIvUkBIJBJJNzXfKtzcwTM67iA9MwvX/N894u9nH7kPpcWxm2WJwMq+J8JQMAoZvQdjsKoY6fbFmPnpC7A5nHBmT4Q9bz8EjakI6JIoXRDSWkTBqaZaEdNF741YIiLLqofDE8CSUhvqZDtwyVYiBYREIpF0AxyoC9NMwqVR42jZBvy4U88SmRketwv33nxNm8WeRLGpouOhzx+FrMLhGKwuRbpzBX7/7DnU1NfDnT5CuDRCovR1pgiuDBjThYgwVs4VPTQUAU/b7cD9QSEiqhpl/wxJ55ECQiKRSLoJtUqJvumWLdqAizLXjzwDrU6HP3+bgWmfT2lzG00i4lho80Ygq2gUBmnKke5ZizlfPIuKqirRpbO+6DgE9UmiDLbS74TPkgt9/UoYapYgadUUKL22NkSEXng6GBPB/hmyaqWkM0gBIZFIJN0tIjIsIkOjyu5pFhG9Cotw8dU3ib8fuesW1NZUt7kN9s6oLzoW6pzhyOk3BgO1Vcj0bcSCr55FcUkx/JY8UXAqqE+BN6EXVD6H6KOhs62DvnYFkttJ82QTLs3m/hkbamTVSkn8SAEhkUgk26kNeE6isYWIOPuiK9B/0BDYGuqFiGgXpQYNfY6GInsEcgeMQ39dHTIDJVj27fNYu2YlAsY01A04ZXPVyl5Q+uzwWfKgcZVDV78KSSuniH9jwYqVZlH6WlatlMSPFBASiUSyHWAtBrYBZ8EpiggO0hqNBnc98qxwaXz35af47efv29+IUg1b4REIZY1C3sBx6GuwIztUjnU/v4rlS+YhpE0Qlgh/Qr5owqUMuuE3ZgiLhL5+Faxrv4Kx4p+YGRosfc0W5etqHFghC05J4kAKCIlEItkBIqJys4gYPHwkzrzgMvH6vbdcC4e9sf2NKJRo7HUI/NnjkD9gHPqYvMgJV6Ls93exaM6vTb01io6DJ2WAiImgWAhqzQgrlNDXrYC5eCYsm36M2c2TVSsZF8GCU8vKGmWtCEm7SAEhkUgk2xGdWrWFiLj0uluQm98LleWlePqhphTPdlEoRAqnJ3cCCgaMQa8EBfIVFaie9wXm/vq1qAnR2OswuDLGNNeKgFKJoC5RtAQ3VjBD4/OYGRqRglOVjR5RK4IFsSSSWEgBIZFIJDtIRGRZm0SERqvHnY80deyc8s5rmDv7j443olDAmbMXnPn7oFe/4chLMqNQUQbb8p8we/p7CIWCcORObqoVYUhGQJ8KJRtxmXKgr18Bfe0yEVyp8tTHTEHNthqaa0XINE9JLKSAkEgkkh0kIgZk/WeJGDV+L1Efgtx945XwuN1xbYdWhsZeByO/aBBy09PQD6Vwb/wHf335MgI+t6gV0VB4lLA++Mw5UPoaRVMunW0ttPWrkbzyA2gaN8ZM88xI0IPxlEvKbCiuc8k0T0kLpICQSCSSncCdwcDKK2++G+kZWaJj54tPPhT3djypQ2ArPBLZvfojJ68A/RSl8FetwOzPnobXUQ9fYh/RpCuoTxbpnSqPTQRZal0V0NavRdLqz2GoWhAzuJJpnnq1CsvLG7FWZmhIopACQiKRSHa0JSIzAblJRriVetx832Ni+dsvP4ulC+fHvR1vYpEoOJWR0xu5vQdggLIMYVsx5nz+NOw1ZSIWoq4/0zwzhQVC6XPAb8wSbg1dwypYNv0kHrGCKy16DRINWqypbsrQkN08JUQKCIlEItkJsjP6bS42NXD8fjjwiGMRCoVw5w2Xw++LP4gxUlAqJbMA+X2HoZ+6CipXJeZ/9SxqNy1DSGdFfb+T4LP2gt+SCyCIkIbNuIww1C2DsfJfJK3+FAq/a4ttG7SbMzTqXCIuotEjG3Ht7kgBIZFIJDtRimd+sgHnXX83rEnJWLV8Kd544alObUcUlOp/MizpBSgcMBJFmjrofbVY8v1rKFv6e3NpbHfacAQM6UI8IByCz5QNfd0y6OpXInnFB1C7KmNnaFgNogHX4hIbqu3eLjwCkl0NKSAkEolkJ6tYOaJfAS68sSmd8+VnHsXqFcs6tR1aGigitKm90XfwaPQ2uJEQbMDK3z/DhtlTxTrMzrDn7YOgPhEBQxpUfju81j6i/DUfrFzJTI22WoL7AyEsKW1AcZ0sf727IgWERCKR7IS9M/53zpnYY5+DEPD7cef1lyMQ6FxRJ9EOvN8JQFp/DBg4HHkWFdLDtVi74Bes+vlNIOiFO32UKI8d0iXAZ8qB2lsPb0JvqN010DWsQ8L672ApnrFFXAQzNFLMOhG/sby8qfx1pDy3ZPdBCgiJRCLZyeAsvyjdgseeegYmSwKWLJyHd197ofMbUmpEdoYvcyQG9h+InBQr8lCN4jWLsWTacwi76uGzForgyqAhRVSupCWC5a9Z8ZL1IgwVc0VcBIMuYwVXJhm1WFvtEJUrXT5ZuXJ3QgoIiUQi2QlRKhWYOLQf7rj3QfH8+Ufvx/q1qzu/IYVSuCucuXuhX2Fv5GTnIB9VqK7YhPlfPoVA7QYEDamoG3AafAn58Juy6QRBSKURQoLBlWzClbzifWjsxTHLX9OlUdHoxqISm4iPkOweKMI9rDJIY2MjrFYrbDYbEhISdvTuSCQSyTbBbIx9DzgIv838GUNGjcW7n0+HSqXaqm3p6lbAuvF7lNfUYcP6NSgNJcFgMGHIPifCUDBGuCosJTNhqF4Epd8JlbceQV0StI3rRcpn0JgGR/YkUbyKlTCj4VBS7fAK6wldMNlWvXB1SHruGCotEBKJRLITw06d7771BkxmM5bM+wevv/LiVm/LmzwA9UXHIyM9A/37D0KeuhF+dyPm/fghbAuniXXs+QfAnr+/iIsQnTw9dfAlFIr4CK1tHcwlv8K67ust+mhQLDDNU61UYmmpDasrZVxET0cKCIlEItnJyc/Px2OPPir+fvWJ+zF/yfKtLivN+g/1/U+FNSULQwcNQZbOD22gEfNm/4zKWW+KGhBM8azvewJCukT4zblQ+WyilwYDM5v7aKx4H2pnxRbbtxqa4iLYFlx29OzZSAEhkUgkuwAXXngh9t13X3g9bjxx+zWosLkR2koREdQnoW7AqdCkFGDU4AHIStDBGm7EkuVLsP77Z6F0VMBvzkHdgNPhN2fDb8qiw1uUuvaZ80XlSsZDJK+aErMENuMiMix6lNvcol5EjUPWi+iJSAEhkUgku4gr4/XXX4fJZMLCubMx/eM3UWHzILiVNRhEmmff4xFMG4yR/QqRl56CFDRibUkZln7zPBQVixHSmkUPDXfaMBELEdBZofY2wGstgsZZCU1jMSybfoZ1/bQtXBpMR2VHT7c/iMUlDdhUK+tF9DSkgJBIJJJdhN69e+PRza6Mlx67D+6aEmGJ2OoGV0o1GnsdAmfuJAwuyES/XnlIU9hRWd+Aud+/g8Dy75rjItjxM6S1wGfKgtpbu9kqoYDethq62uUxXRqMi0g166BXq7GsvBErKhtlH40ehMzCkEgkkl0sK+PAAw/EjBkzMHHSJDz/wVeoaPQh1awVhZ22Fl39aiRsmI5amx0L1mxEo18lyl6PHDwICWNOQkibALWrCtZ106Dy1EPtqWnaH5UBWscm0eWTFTAd2XvClT5qiywNXyCEaodHCIq+6RZYjZptPhaSrkdmYUgkEkkPd2WYzWb8+ccf+PnTt9ErxYgah2+bCjl5k/qivv/JSEpJx6TBRUg1qaAKujFn0RKU/fQCNLYNCBjTRb0Ib1KRKH/NPhoMsGQJbI2zAmp7CczFvyBx7dQtGnKx10eW1YAGlx8LSupR1uDe6kBQyc6BtEBIJBLJLshLL72ESy65BAaDAf/Omw9tco7IfDBq1EgwbP3snvUfaGVQNpZg4fpKbKq1w63QIT/ZhIHjD0UgbyKHDhir/oW59Hcg6IPGVYmgLhEqvwNKnx3ehF4ig8PW+xD4LflbfIbN7YfbH0BBsgm9Uk1CXEh2vTFUCgiJRCLZBeGtm66Mn3/+GePHj8esWbNQYfdhVaUdKoUSySbt1m88qqDU6goblpZUwxtWw6zXYcyIEVANPka0Adc4ymBd/w2U3sb/XBpqIzSOEvhNOQjpLHBmjIEzayKgbOleYSxErdOHdIsORRlmJOilS2NnQLowJBKJpIfDAMU33nhD3ORnz56Nxx9/HLlJRgzJtkKpBKrsnq13EShVTYGTBQegb3YyJg3Ig1GtgMvtwW9z/kXjrJdFGidTPGsHngFfYuFml4ZBVK/0JfSC2l0Njb0UpvI5SFo1BSpPQ8wS2LVOLxYWN4iUzx42n+3xSAuERCKR7MK89dZbOPfcc6HVajF37lwMHToUDS4fVlTYYXP7kGExiPLSW4uwMqybBp/Lhj/XVKLK7kdYocCATCv6jDkInpwJTS6Nyrkwl/2x2aVRIVwayqBXBFx6LQUIa02iJ4cneeAWAZb1Lh+8gaB0aewESBeGFBASiWQ3gbfwo48+Gl9//TVGjhwprBEUE6wAubrSjopGD9LM+m0alNmJ07rhW6gai7FoUz2WVjqhVISQatZj9LBhCA04SqR4qp3lwqWh8tiEBQIICyGhtRcLC0VQZ4UnuT/sefuLDI9YLo00i1Z0ImVFS8n2R7owJBKJZDdyZbzyyitITk7G/Pnzcf/994vlJp0aA7MTkJ9sFE2utiVDQxSUKjoenswxGFGQjMlFKVAoNaixe/HLnH/h+fMVaBvWImDKQt2AM+BN7icyNoIaCzSuKvgseSI4k0JCz5oRy9/borNnxKXBbp50aZQ2uGXhqZ0caYGQSCSSHsDHH3+Mk08+WXTq/OuvvzB27FixnJUqN9Q4sa7GCYNGtc0ze139SiRs/BEOpwuz1tSi2hWCVuHH4Cwr+ozYC868vQGFGvraxbAU/wpF0AONs1wEXYaVmv9v7zzgo67v//+6vbN3ckkgyAaRIMgWsOKoo1q1Yl1/q9JqHdVWW7W22tZW2z6oVmtdVevAhatYBBWUJfoHUUCGhJF1WZd1e35/j/f7SCQUMcld9vv5eNzjcpfv3X3zSXKf173H680OlkFrPhSdCd6sUp7ueWSBJXVpkOCxp5kwLMPK4kLoHSSFIQJCEIQhyA9+8AO89NJLGDVqFLZs2QKz2cz309u8o8XPKY1wVEGm1RDXqG2Nz8mpCpWnHlvKG7G1NgKrmlIlBpw4biQio87iCAQfd+AdaL31/DX5StCET52nmg2oKK0RtmShpfh0REwZHV6DaiJohka61YCSTGt8XSVCpxEBIQJCEIQhSGNjIxdRVldX4/rrr8dDDz3U8fueIPZwcWUI2UnGuIorVZEgbBUf8GTOg04vPjjg46JJqy6KacOzkDLuOzFHSiXCfhHmui1QRQJsOBU2ZfCx5BnB0QitEe78WfBlntChwJKGhVGahM5zWKaFu0ziOWfh2xEBIQJCEIQhyrvvvovTTjut/etTTz21w/fdh4ora1tjttLx2F/TFE6jcwcLCbfXjzVlzaj0qJGicmNUtg1jxk6EZ9hpXGCpbzmApIPvckEmdWmQUAgb0jgaETaksg12MKkQrUWnsm12h3P2h9HiDyEvxcjRCKrvEHoGERAiIARBGML89Kc/xd///nfk5eVh27ZtXGB5ZHpgX72bIwfJJj2scW7IlKLglIbPia3lzVhbq0EaXMi0aHDSyDyoRp6GQNpotrdOKn8Phua9HH3Q+mNDuTSBFqiiIf6aaiNcBfP+p90zFInN0rAadBiRZWUDqnjSMMLREQEhAkIQhCGM1+vF5MmTsXv3blx44YVYunTp/2y21OFQ0eTF3no3NFBxrUE8xFIaqzkiQR0UK/YHEQhFkKHxoLQwFfkjJ7M5laIxwOjcDlvFGqjCPujdVYjqzIjqrDysK2TKhKIzI5AyAq10vC5Wx0HQdtXkDSEYiaIozYzCdLMUWCYYERAiIARBGOKQqdT06dMRDofx3HPP4ZJLLjnqcXWtfuypc8MbCCPLFl9dBEFtmraK9+H3+fDRvhZsbTGjQNWAojQjSo+zI1ByGoLJw9hgiqZ/UoeGxt/IUYiQrYCLLTm9YcpClMynCk9hMfG/nhFSYNkTiIAQASEIgoB7770Xv/71r/m98PPPP0dxcfFRj2v1h7guot4ViL8ugro0/E0xQylvHXY5WvGfCj1s8CBH78f04elIGj4F7oK53NZprvkUVsdGqMJ+6N2VXA+haPQsKqiTgyIWlM5w2ed1MJ9qK7Ak2+7idAsK0szQacTaKF5EQIiAEARB4OjDnDlz2Bdi1qxZWL16NbTao9c7UF3E/noPyhu9sOjjm+jJRCNsbU0W19T9saIsgH0+E4arHBidY8X44XZ4hi1EKKkIWk8NF1hqvQ3QemuhjvgRsuRB43cCGj0XW5KZVWvRdxBMHv4/RaFk2U0mVMMyreJgGSciIERACIIgMPv27cOkSZPgcrk4InHnnXd+47FUF0H1C2X1bjagomiEOs5CRX3rASQdeBfRgBubK1qx3JGMPLUThaYgZpSkw1BYCnfBHCgqNazVG3lMOBVbcjSC6iHUWmgCrVwbAY0O/vSxcBWc3CEaQedKBZZk1z08w4q8lPjmfwxlWkVAiIAQBEFo49///jcuu+wydqlcv349pk2bdszj2S+i1oVmGredZIw7NRDrvlgFQ3MZC5S39qtQF9RjtKYKE/KTMbIwD+6iUxFMLobOXcWCg1IYNMhLpYR56qfW34ioxoAItXzqrGgtXIBgSkmH12n1heAOhpGbbMTwTGvc3SVDkVYRECIgBEEQ2qC3eSqifPHFF1FSUsIzM2w22zEf4wtGOBJR2eRFklEHmzHO1AB7RsTsrQMBP9YdcONdZyZK1A6U2MJcG6HNOx6uArLCpmjEOpjqtvIMDR1FI8zZgEoDddiLkDEdUGvhTxt9qDbC1LHd0xWAxaBhEUGpDbVEIwbeMC1yRaM/WjqJlJQUXHXVVXC73cd8zMknn8ztRodfFi9e3JOnKQiCMKih99FHHnkEhYWFKCsrww033PCtjzHpNRiTm4SxuUkIhqPcrUGFi3GcBPwZE9E45ofQpOTjlOOS8eOSRrSqU7CmNRfLt9WgYucmpH35NKc9aPR308jvc/QhkHIcd2lofPUIG1M5GqEJNMPYuAvpXz7D8zlIoBAULaEUBt3cXtWCLx2tPJlUSDw9GoE4/fTT4XA48M9//hOhUIhn1tOAlxdeeOGYAmLkyJG455572u8jP/fORhMkAiEIgnB01q5dy++x0WiU34cvvvjiTj2OUhp761x8nYguDSqwtNR8AkvNJnj8Qaze78W7zXkYra7A2OQQpg5LgzaLogvzuSOjPRoRdHFtBBtOqbUcnQgfikZQqycdT8WWbZDwodoIip4Mz7Qg2ybRiAGRwti5cyfGjh2LTz/9FFOmTOH7VqxYgTPOOAOVlZXskHY06I+bCn6WLFnSrdcVASEIgvDN3H333fwBjVIYlMqglEZnIO+F/Q1uVDT6eKpnijl+7wXqvkg+sAJqfyN217jwUkUy3FEdTtTuQ2lhMoblpMNdMBv+9AmcxqApoNSZQWPBVdEwgrZCaIIuFhMRQzIUrQGu/Lnwp49rd7GkLa7ZF+LzL0g1oSjdIlbY/T2FQW1DlLZoEw/EKaecArVajU2bNh3zsc8//zwyMjIwfvx4/PKXv2RXNUEQBCF+7rrrLsyePZu7MigCEQwGO/U4cnwclZ2E8fnJgApwtPgQjkTjOpewJQfOMZfAl12K0blJuHlCADOTGrAqNAFv7Qc++rIS2q/eReqelxHVmuEceym8OdPYiCpkzoKh+St+Hu7U8DVAFfQg6eBKpOx9DRp/c3v6JtWsR7rFwC2qWyua+dyp40SIjx6TYTU1NcjKyur4Ylote7LT976JRYsWoaioiCMUX3zxBW677Ta2Y122bNlRjw8EAnw5XD0JgiAIR4feh+lD2vHHH88RYmrrvP/++zv1WAr/U32B1ajFvjo3alr98c/SUOvYVCqQPJy9IM4Z3YpRNQfwYmUaXm3KhcP9FU60+1DiccCbMxXuvBnwp45koRDVWTgaofE3IJhUBE2oFYpKC31rOdJ2PgtP7nR4s0u5KJNaPPOSTRyN+KKyBfkpQQzLkGhEPHQ5AnH77bf/T5HjkZddu3Z1+4SuueYaLFy4kEfSUgHms88+i9dff50Lf47Gfffdx+GWtovdbu/2awuCIAwF6H3yqaee4q8feOABntrZFagrgyIRNHHTHwpzgSV5McRDyGZH45jL4M86nos3b53gw4JkB1aEJuKl/Qas3lkD5cA6pO/8N48Fbxx9CTx5s7iVk0ynjDSgKxxkQaIJNEId8sJatRZpu57nVMnh0YgMiwFVzV58Vt7EbaXxnvtQpcs1EPX19XA6ncc8Zvjw4ey9fsstt6CpqamDK5rRaMQrr7yC733ve516PY/HA6vVyvUTJCw6E4Ggfw6pgRAEQTg21113HXdnULR469atyM3N7fJzUGEltXs63QGkmQ3cvREvOlc5RxjU/lb2o3i+MhUV4VTM0e7EDLsBI7NsCKSPYQMqssAmjwmdq5ILLKnQMphUzP4RtLlFdUkUOoE3azJHJKgos41mbxBe8o1IMaE4w8LCaKjT2p+KKGmgS2lpKd+3cuVKnlN/rCLKIyHTE7JgJR/3iRMnfuvxUkQpCILQOfx+P5tKUbp43rx5WLVqFZtNdRWywS53enGw0QuNSsXDreJ1sKQog7VqHUz1n7Nd9eoDfrzcNAJ5qkbMt1XipGGpSLJZ4c6bBV/6eJic2zniQHM4DC37ETEkcZ2EOuxHVGNk58qIPgmuwvkd7LBjY8IDMOrUGJZu4RSNdgjP1GjtDwKirY2ztrYWjz76aHsbJxVVtrVxVlVVYcGCBZymmDp1Kqcp6HvUqZGens5/1DfffDMKCgrw4Ycfduo1RUAIgiB0Hqoxo/dl8uihAsvDW+i7Am0lDe5YNII+2VPRYiJGbetcFdx9oQ40o6zOjZcqkrA1WIDZ2i9xcl4E4/OSELHmwGVfwDURNFLc0PQVdJ5qaH2x2ggqsoQSiUUjVCoEUo+Dq2Beh5bPmItliCeS0nCu1CE64bO1vwgIMpK6/vrr8fbbb3P3xfnnn48HH3yQUxLEgQMHMGzYMB7wQu2bFRUV+OEPf4jt27dz6oJSEZTqoCIf8YEQBEHoGcihkgrYqUaA0sWnnnpqt5+L2iUPOr2oaPRCq1bxRhxvNALREKzVG2Cu2wJfIIx15V4811ACI0I4zfIVZhbb2HLblzGBIxKUyiAhQdNADS37OG0RstqhigZ5AmhUa+L7OHqROZGLLAmqhWhwB0ABiMI0mvBpit/zYoDRbwREXyACQhAEoeuQ4y+Z/lELPdVD5Ofnd/u5aFshO+l9DZ6ERiO0HgdHIyiyQALltXIj3veNxAnqvTgzqxEn2FOgNVrgzp/F7pUWx8csOrTeukMGVHmc2iAjq6jOzNbYIUsOXIULYlbZhyDnSurWSLPouDYi02pgcTUUaBUBIQJCEAShq/UQ06dPZ/FAPhEffPDBN47+7vRzhmK1EeS/QFGIdGsiohERWGo/ZRfLYDCEzVUePO0oQgNsOMOwHQsK1ZyCYGFgn88PsVW8D31rBVtkqyMBBJKKY0ZTKjX7S9DX3swT4MmjIktD7GUUhQtEKSqRl2pEUdrQaPlsFQEhAkIQBKGr7N27F5MnT2aTqZ///Oed9ofoTG0EuVjShkxtlGZ9/BuxxudEUvl7PL2TiiDfOajCa61jka9qwLmp+zGjyAabSQdf+ji4c2fA2FLGRZbU0mloPYiIIYVFBpQopzUopUFTPmmYVyB1ZLuTJYkgpycAq1GH4nQzD+cazEWWrSIgREAIgiB0h1dffRUXXHABf/3aa6/hvPPOS8jzUqcGpR0oGhGNgmdqaOKdS6EoMDV8wbMylJAfX9a48e/KbGwNF2G6ZjfOz2/iYWBqvZFFRCC5hI81NuyA3l0Brd/JdthUfEnP1RaNoMJLil5EjKmHXkZBqz/M3SDZSYZBXWTZKgJCBIQgCEJ3ufXWW/GXv/yF52WQW+WoUaMS9twUhaBoBNVIJGRMODkiBt2wVq6BsWkPb/Iflgfxb+coBBQdzrXuwKmFKuQmGxE2pcNVcDKLBCqyJMdKKrKkVEbAVsR+EZzW0BgBtQae7BPhyTmRzakIsu52eoJ8mD3VDHuaOSG1Hf0JERAiIARBELoNmf5Ri/1HH33Efj40v6itey4RkPdCdbMPB5we+ENRLlKkMdzxom8ui3VfBFs50vFauQXLfWNQpKrDosz9mG43w6zX8OROd95MGFrKYKn+GDp3BfTuKoRNGQibMmMigkTDoSFdLvu8Dt4RZD7V5A0i2aTj4VzZScb4oyn9BBEQIiAEQRDigmYWUT2Ew+HARRddxK2eie5EaPWHcKDBg5oWP7dLppp1cb+GKhJs774IhcP4rNqLp6sLsCNaiNm63bg434kxORaoNVounPSlj4XVsTGW1mg9wOKD0hoRvQ0qqBClokryjkgp4fqIqCHl6ymf3hB8oTBykmnKpzkhE0r7GhEQIiAEQRDihpyAyaOHIhJ//etf2dgv0dBUzDpXgIVEsy9xRZZabz13X+jc1bzRr6pQ8ELjaASgwzm2XTjHHkBOspHrH2hAV0RnRVLlh9C37IO+ZT+nLQK2QihaEgUq7s4gQyovpzWmtKc1KJpCaRkKoBSkmvmSCDvvvkIEhAgIQRCEhPDQQw/hhhtuYItrGrpFqY2egLodqMiyoilWZJlu0cff7aAoMDq3sSU2WVrvb/BgaUUq3vWPQo6qGZdnlmFOgZrbM8PmTLjyZkPnq4elegNHI/Seak5rBM05nM5gR0uV5phpDRt1a2RYkG0zDMhuDREQIiAEQRASAm0RV1xxBY8cSEtL46JKGpjYU9Cn+YNOD2pbA7DoNVxnEHdaI+zjFk5Tw3YEI1F8Vu3HU9V2bIsWoVR7AP+voAoTs2N1DJSq8GZOhqlxB0y1m2GgtEbIjaC1AGEDdWWooGhjXhE0gtxdcDIixq/TGi2+EDzBCLJsBhSmm1kIDSQTKhEQIiAEQRASajI1Z84cFg8TJkzAhg0bElpUeSTU7VDrCnDEwM2OkAma8umu5rQGpTdoo19VoeJujWZY2RL7EnsjClONXETpzTyeayHIQtvQuAsG10EoKg2CNjv7RUClYv+IWLfGFE5ttE36JPMpmk5Km2teipG7NRLRbdIbiIAQASEIgpBQaPghDd2i4kqaa/TKK6/0+CdrSgtUNvpQ2ZzItEYUpvovYHWshyoc4G6NpRUpeMc7GkYEcUlGGc7K9yLFHDOX8uRM5Y4Ma9V6GJv3Qud1sAlV0JILhaZ8qjWxtIY+Ce6C2QikdDShavTSpE8NClPNPDa8v7d9ioAQASEIgpBwKPJARZU0Xfnee+/lQYe9AaU1yp0e1LT6YdZpeXOPO60R8rKpFKU1wlEFX9T48VRVPjaHh8OuqsfignLMzInAoFXz/AxP1hRoA82wODbC0FwGTciFkDkHIWr71GigqPQxEyqbndMaVFPRhtsfRos/hBSTjtMaWf24PkIEhAgIQRCEHuGJJ57A1Vdf3e5aSdGI3oDSArWtfp6tQd0aySY9rAmYTUFpDWvlaug8tTxEa00V8FTdCFQqmSg1VGKxvQrjM1Q8wyNszoI3YyKMTV/BVLeF0xoU0QhZ8xE2pkGBCqA0hkoFX+bx7H6paI3tszVaqO0zHEGGVc/TPum6v9VHiIAQASEIgtBj3HjjjXjwwQdhMpnYbIpSG70FpQWqmnyobPKyCRUN6Ip75LYShdG5ndMU6rCPhcoblVa82jISXhhxalIFrrTXoDAp9jrBpGIEkopgrtvKj6NujajGhKA1D1FDckxIqLU8NtyTN4PHjB8+Mpxma0QVsDtmQaqpX/lHiIAQASEIgtBjkC/E2Wefjf/+97/Izc3FJ598goKCgl49BzKhomgEmVDRh3gaGR6vG6Qq7IfVsQGm+s+hRBXsdfrwTEU21vhHQIswLs6qwIV59Ug1UTunCv6UUYgYbDDXfAJT425oAk2IGFJj9RFaU6zIkiIXpky47CcjZLO3v1YwTLbYAeg0ZLNtQkGaOSERlXgRASECQhAEocffa2fOnInt27dj0qRJWLt2bY92Zhxr0md5o4evTVoNks26uEeGU5cGzdbQuyrYKGpzTRiPVxVie8SOVJUHi+2VOC2rKVYQqdbAlzaGoxjW6o3Qt+5nz4mQORshSzYXWLaNCPenjoQ7fzZHKdrwBWOFltRlUpBiRn5q3xZaioAQASEIgtDjHDhwANOmTUNdXR1HJJYtW8aGU70NtX2Sm2WsPiKEZKMOVmOcn+YVBYbmvbBWfQRNoIWHdK2u1uLJmhI4kI4iXQtuKK7ESWluaNXkVKmHP3UU1IFmWB2boHNXcn0DF1qasw61feoPuVmWdmj7/LrQMshjwwtTTchONsafmukGIiBEQAiCIPQKGzduxLx58xAIBNixcsmSJX1WGEj1EY5mHyqafNwCmmZOgH9ENAxz3WZYaj7lORv17gBeq0zGq00j4IIJx5sbcUNxFcYlxVIpUZ2ZLbD17kqY6z/naAYJhaAlDxEqtDzU9hnV2+DOmwV/2uj2ts+vx4ZTx4Ye9kMdG4kYNNZZRECIgBAEQeg1Xn75ZR64RTzwwAM8DrwvoWhBZaMXjhYft2iSkNBr49uE1SEPLNXrYXLu4I3+QGMAz1Zm4z3PMAShxfzUBlxbWIVic5CPp2FcIUsOjM7dMDbt5CFdZEAVIiGht3I0goRDyJLL9RFhS277a3HHhi82qItmg5ARFU0s7Y3WTxEQIiAEQRB6FRq2dcstt/DXL7zwAi6++OK+PiU0e6k+wou61gB/yE8zx29EpfXWwlr5EddHUEfF9oYIHqvMx+aAnXov8L2cBlyZX4lMfZiPp7kZZDJlqt8GQ+s+qCKBWKGl9ZARVVt9RNpouPNnIar/et+i56efIRCJIs2ihz3VzK2fPSkkRECIgBAEQehVaCuhaZ1/+9vfoNPpePAWpTb6Gpr26fQEeVBXvSs2NpzaJuPq2KD6iJYyFhKaQDMC4Sg+rtXg0coi7ItmQYcwrixy4sKsKti0bUIiBVGVhtMa1PZJRZfkHRG05gMa3aH6CN2h+ogpHeoj2oVEOIJ0q4EjEhnW+LtOjoYICBEQgiAIvU40GuVUBhlM0fvvunXreHZGf4A24XoqtGz0sLOlRa+Nf1BXNAJTw+ewOjayLTalTlbVWPBEdTEakAyzOoQflzTirLRKmNQRfkjYkMzHmp3bofXVcz0EuVmSSVVUY+SuDkp1uPNnwp82tr0+gh8biXKRaKgtIpEWG9aVyIiECAgREIIgCH02eOs73/kOi4ecnBy+LikpQX+B/BfqXDFHSypYtBm0sBm1cQkJVdgPS80mmOu3sqhwekJ43ZGKF+qHwQMT0vUh3DDCiQVJldCpou01Emq/E6amr7g+gqIPIVMWjw8nD4lYfUQ23PlzEbJ19NhoExJBcrW0GTA2Nzkhw8YIERAiIARBEPqMpqYmzJ07F9u2bcOwYcNYROTl5aE/QR0bNS3kaOnjyEEirLE1/mZYqtfB2LSHb1e1hvF8VTbebi5EEDrYTWHcOLIeM8xV0CAmJCjqoPM4oG89AHXEzzUR1PpJI8KjWjMfE0gZAXf+nPax4Ufae08pTuXURiIQASECQhAEoU9xOByYPXs2ysrKMHbsWLa8Tk9PR3+D2j2rm32oavaxqRN1PZj12vjna1R9xNe0wZY1RfBkZR7WuO2IQo2RSWHcNKIOk43VUClRrqmgUeE6Vzn0HgdUSpjFA3VxUBGmcii14c08gaeDts3XIKjTpLRIBERCEAEhCILQP9i/fz9mzZqF6upqTJ06Fe+99x5sNhv6IxSFqG7ysZjgrgezPj5HSOVQoWXVWmj8Tdyaub1RjUfLC7DZn0PbLyalR3BDSR3GaiqhogkaSgRQItC1HITO76QnQVRnYWvsiD6Fiy15vkbuSfBlTGRRIQIigYiAEARB6D/s2LEDc+bMQWNjI48CX758OczmWGi+P0L+C1XNsRkblCKgiERcjpDRCEzO7TwGXB3yIhxR8GmjAQ+X2/FVMBaROSlbwfXDanCcupKFhyoahirkgcFVDnXIzWKDvCNiEYlULryMGFPZFvsA8lBanCYCIhGIgBAEQehffPrpp1iwYAFcLhdfv/322zzJs79C2yIJCaqPqGn1UyCAhUQ8ZlSqSBDmui0w1/5//ppaP9c6rXjkoB1VkdhsjJPzgcXFDgyLVhx6TICjF3p3FVRRMqhSIWJI4jkbEUMaF1rWa7ORN+UspGV/PagrHkRAiIAQBEHoV6xfvx4LFy6Ex+PhLo0333yzX4sIgrbHJi8JiZgZFUHtk/FYS6tC3ljHRsMXHJ2guouVzjRObTRGLXzMwiIVri50wB4ub3fBJAMrnbeO0xokJKgdlNwrWxQL0mZcilT7mIT8zCIgREAIgiD0O2hi5+mnn84igsTEG2+8AaPx64LA/gqZUTV6g6hq8vHQLvJvSjXHJyR46Fb1RhibdnHawhWMYHldNp6ozIVLMbGr5XeHa3CVvRq5wYP8GBoXToWZ1O0Bdey1W/Q5MC38DdLyhyfkZxUBIQJCEAShX/Lhhx/ijDPOgNfrZTFBEzwHgog43NWSIhL1rgC0ajVSzbq4jJy03jpYqjfA0LKPbzcHgGV12XimMgd+GFisnD1Chyvzq5ET2B97jK8eutaD8DXXwRsC6od/D6UX3paQSagiIERACIIg9FtWr16NM888Ez6fD/Pnz+d0htVqxUCBiiud7gAqmrxwuoMciUgxxSckdK5KWKvXQ+eu4ttOP/BSbT5eqM5GCFq2rf7ecTpcnl8Nz84PsHHDeqSqWpFh0WLx2x6oDElsI37eeefF9bOJgBABIQiC0O8jEd/97nfhdrsxffp0vPPOO0hJ6WiUNBCERAMJiUYSEoH452woChtKWavX8Rhwos6vxvM1+XjVkYkwtFCrFOj2vIcTnP/FWEsrNAYznvm4AXtrXHw82YjHIyJEQIiAEARB6Pds2rSJ0xjkXDlp0iSsXLkSmZmZGGiEI9H2gV2JEhKGpj2wOjZwFwZR7dfh2eo8vFmbyWZUSiQMQ9kHKGn6GCs37ULU18p23AUFBey/0d10hggIERCCIAgDgi+++IK7Murq6jB69GisWrWKN8GBSDgSRYM7yKkNGthloNRGXEIiCqNzByyOTTwvw+GoxgsrN2FL+ukoS58F5ZCQcK58BJ4vVnZIEZHnRk/voT03VFwQBEEQvoWJEyeyzTWJhl27duGkk07iGRoDEa1GjZxkI06wp2BiQTIsRi1qXX6OSlC6o8uo1PBnTIBz3BVw2eeh2ReFLViPuY5ncf6eOzHMuZ46OhGs2fs/NuK9gQgIQRAEoU8ZNWoUD9waM2YMqqqq2P6aPkUPVLQaNXKTTZh0SEiYDRo2pKKoRLeEhFoLX9YJKC++AO9X6uELq5AcrMN8x79w3le/Rb6qocPhubm5ifthjnVavfIqgiAIgnAMioqKWETQAC4Ko5NPxIsvvoiBjO6QkDihMBXH22nktjouITGxdCrKlAI8tM2MNVU6+MMqZKha0PZUVANht9t5DXsDERCCIAhCvyAtLY0LKb///e8jFAph0aJF+MMf/sCOkINFSEwsSIZB1z0hoVFrcOuttyIYVWFdjQF/32bC25U2VLpi4oFYsmRJQvwgOoMICEEQBKHfQKZSL730Em666Sa+fccdd7CQIOOpgY5Oo0ZeiomnZ7YJiVqXD01dEBLz583H/fffj6ysLPgjKnzRFDPhohqSeFs4u4p0YQiCIAj9kkcffRQ//elPEQ6HMXnyZLa+phD9YCEYjqL+kI9Eiy8Ik1aLZLMO6kPRhGMRiUaw9bPPsNfhxNThmThzwRxxoowXERCCIAiDB+rQOP/889HQ0IDs7Gy89tprmDlzJgYTwSOFhE6LZFPnhISjxccRjb4Y5y0pDEEQBKHfMmfOHB4HTu2etbW17G/wl7/8ZcDXRRwOjQnPTzFhcmEqxuUl820SBk3eIKL9+OcUASEIgiD0a4qLi7FhwwZcdNFFnM6gQsJzzjkHjY2NGEzotWoUpJpxQmEKxucnQ6+JCYnmfiokREAIgiAI/R6LxcJtnf/4xz9gMBjw9ttv44QTTsDGjRsx2DBoNTEhUZTCEQlysiQh0eIL9avIiwgIQRAEYUBArYqLFy9m0TBixAiUl5ez58Hdd9+NYDCIwSgk7GlmTC5KxdjcJFBJRHWLv98ICREQgiAIwoCCIg+bN2/GxRdfjEgkgnvuuWdAW2B/G0adBoXpFi6WHJNrY/vq6hYfWllIoM8QASEIgiAMOKhD4IUXXsDSpUvZgOqzzz5DaWkp7rvvPq6TGKxCoijdgilFqRidY4MCBRpNNwd1JQAREIIgCMKAhQord+zYgbPOOovdK3/1q1+xkFi/fj0GK0adBsUZVpQWpbGQsBi0fXIeIiAEQRCEAU1OTg7efPNNPP3000hNTeUR4TSQ68orr0R9fT0GKyZ9rNiSBEVfIAJCEARBGBQFlpdffjn27NmDq666iu8jQTFy5Eg8+OCDCAQCfX2Kgw4REIIgCMKgISMjA0888QT7RkyaNAnNzc248cYbeWT4s88+y0WXQmIQASEIgiAMOqZPn84Olv/85z+Rl5eHgwcPcoTi+OOPx7JlyxCNRvv6FAc8IiAEQRCEQYlWq8U111yDr776Cn/605+4PoIKLmm2xpgxY/DYY4/B5/NhoNLc3Iznnnuuz15fBIQgCIIwqDGbzfjFL36Bffv28XjwlJQUrpW49tprUVRUxD4SlZWVGChs3rwZP/rRj5Cfn49LL72UIy19gQgIQRAEYUhAwuF3v/sdKioqsGTJEhYP1KVBTpaFhYVYuHAh+0r4/X70N5xOJx5//HFMnToVU6ZMwZNPPgmv14tx48bB5XINLgHx+9//HjNmzGDlR7+0zkDWnL/+9a+Rm5sLk8mEU045hUNPgiAIgpAorFYrF1bu3buXzajmzp3L+8/KlSvZ3ZLaQumT/csvv8xjrfuKhoYGFg2nnnoqjzKndAxFG/R6PRYtWoS1a9ey++b8+fP75PxUSg8ZapOiI+FAYSFSSpSr+TYoR0UuYs888wyGDRuGu+66ixfnyy+/hNFoTPgsc0EQBEEgysrKeO+h1k+KUBxeR0ECgz7QUmHmiSeeyB+MewLav0gUrF69mi/krnn4Fk1dJSQcrrjiCmRmZvbYOXR2D+0xAdEG/TJuuummbxUQdBpUKXvLLbfwqFaCfgBSXfQcP/jBDzr1eiIgBEEQhO5CbZ7kYknTPumye/fuDt/XaDTcyVFaWorjjjuu/TJ8+HCOnH8b1P1BkQWHw8E1GfQhmS7bt2/nuowju0No7scFF1zAFxog1tN0ZQ/tG//Lo7B//37U1NSwymuDfohp06bx5LVvEhBkDnK4QQj98IIgCILQHUggzJkzhy8PPPAAp9GXL1/OooL2oqqqKmzZsoUvR0KRcoq804X2L4LmcrRdGhsbUVdXd0wvChIJJ598MubNm8fX9MG6v9JvBASJB4IiDodDt9u+dzQo5fHb3/62x89PEARBGHpQdIGi6HQhKL1BQmL79u0sLtou9OGVii9pvzrWntXmmkkpCLvdjvHjx2PChAl8PXHiRK4BHCh0SUDcfvvtXKdwLHbu3InRo0ejt/jlL3+Jn/3sZ+236ZdIvxRBEARBSDS0v9Dlwgsv7JCCp72nqamJ0/V0oRQACQWqoaALRTYoMkECgcSDTqfDQKdLAoLqE6h441hQHqg7UNUrUVtb20GB0W0qHPkmDAYDXwRBEAShL1CpVJyyaEtbDBW6JCBINfVU5Sd1XZCIeP/999sFAym6TZs24cc//nGPvKYgCIIgCP3MB6K8vBxbt27layoYoa/p4na724+hVMfrr7/eruAox0QmH2+99RZXpV522WVcQHLuuef21GkKgiAIgtCfiijJEIp6ag9vRSGot5UqSwlqjzncpIOsRj0eD5tlUA6J5rmvWLGi0x4QgiAIgiD0Dj3uA9HbiA+EIAiCIPT8HiqzMARBEARB6DIiIARBEARB6DIiIARBEARB6DIiIARBEARB6DIiIARBEARB6DIiIARBEARBGLjDtBJFW1eqTOUUBEEQhK7Rtnd2xuFh0AkIl8vF1zJQSxAEQRC6v5d+22yPQWckFY1GUV1dDZvNxvbYiaBtwieNcRVzqsQga5p4ZE0Ti6xn4pE17f/rSZKAxAONkVCr1UMrAkE/cEFBQY88N/2C5I8+sciaJh5Z08Qi65l4ZE3793p2dqqoFFEKgiAIgtBlREAIgiAIgtBlREB0AoPBgLvvvpuvhcQga5p4ZE0Ti6xn4pE1HVzrOeiKKAVBEARB6HkkAiEIgiAIQpcRASEIgiAIQpcRASEIgiAIQpcRASEIgiAIQpcRAXGIhx9+GMXFxTAajZg2bRo++eSTYx7/yiuvYPTo0Xz8hAkT8M477/TauQ7GNX388ccxe/ZspKam8uWUU0751t/BUKSrf6dtLF26lJ1Zzz333B4/x8G8ns3NzbjuuuuQm5vLle8jR46U//0413TJkiUYNWoUTCYTuyrefPPN8Pv9vXa+/ZmPPvoIZ511FrtC0v/vG2+88a2PWbNmDSZPnsx/nyNGjMDTTz/dcydIXRhDnaVLlyp6vV556qmnlB07dihXX321kpKSotTW1h71+PXr1ysajUa5//77lS+//FK58847FZ1Op2zbtq3Xz32wrOmiRYuUhx9+WPnss8+UnTt3KldccYWSnJysVFZW9vq5D5Y1bWP//v1Kfn6+Mnv2bOWcc87ptfMdbOsZCASUKVOmKGeccYaybt06Xtc1a9YoW7du7fVzHyxr+vzzzysGg4GvaT3fffddJTc3V7n55pt7/dz7I++8845yxx13KMuWLaNuSeX1118/5vH79u1TzGaz8rOf/Yz3poceeoj3qhUrVvTI+YmAUBRl6tSpynXXXdd+OxKJKHl5ecp999131OMvvPBC5cwzz+xw37Rp05Rrr722x891sK7pkYTDYcVmsynPPPNMD57l4F9TWscZM2YoTzzxhHL55ZeLgIhjPf/xj38ow4cPV4LBYC+e5eBeUzp2/vz5He6jzW/mzJk9fq4DDXRCQPziF79Qxo0b1+G+iy66SFm4cGGPnNOQT2EEg0Fs3ryZQ+aHz9Og2xs3bjzqY+j+w48nFi5c+I3HDzW6s6ZH4vV6EQqFkJaW1oNnOvjX9J577kFWVhauuuqqXjrTwbueb731FqZPn84pjOzsbIwfPx5/+MMfEIlEevHMB9eazpgxgx/TlubYt28fp4TOOOOMXjvvwcTGXt6bBt0wra7S0NDAbwD0hnA4dHvXrl1HfUxNTc1Rj6f7he6t6ZHcdtttnPc78p9hqNKdNV23bh2efPJJbN26tZfOcnCvJ21uH3zwAS655BLe5Pbu3Yuf/OQnLHTJDXCo0501XbRoET9u1qxZPAUyHA5j8eLF+NWvftVLZz24qPmGvYmmdvp8Pq4zSSRDPgIh9D/++Mc/ctHf66+/zoVYQtehcbyXXnopF6dmZGT09ekMCqLRKEdzHnvsMZSWluKiiy7CHXfcgUcffbSvT23AQgV/FMV55JFHsGXLFixbtgzLly/Hvffe29enJnSCIR+BoDdXjUaD2traDvfT7ZycnKM+hu7vyvFDje6saRt//vOfWUC89957mDhxYg+f6eBd07KyMhw4cIAruA/fAAmtVovdu3ejpKQEQ5Xu/I1S54VOp+PHtTFmzBj+1Efhe71ej6FMd9b0rrvuYqH7ox/9iG9TR5vH48E111zD4oxSIELn+aa9iUZ9Jzr6QAz53w7909Oniffff7/DGy3dpnzn0aD7Dz+eWLVq1TceP9TozpoS999/P3/yWLFiBaZMmdJLZzs415RajLdt28bpi7bL2WefjXnz5vHX1C43lOnO3+jMmTM5bdEmxIg9e/awsBjq4qG7a0q1TkeKhDaBJmOauk6v7009Upo5AFuPqJXo6aef5taXa665hluPampq+PuXXnqpcvvtt3do49Rqtcqf//xnbjm8++67pY0zzjX94x//yO1fr776quJwONovLperD3+Kgb2mRyJdGPGtZ3l5OXcGXX/99cru3buV//znP0pWVpbyu9/9rg9/ioG9pvTeSWv64osvcgviypUrlZKSEu50ExR+/6PWdrrQdv3Xv/6Vvz548CB/n9aS1vTINs6f//znvDdRa7y0cfYC1C9bWFjImxi1In388cft35s7dy6/+R7Oyy+/rIwcOZKPp7aZ5cuX98FZD541LSoq4n+QIy/0BiN0/+/0cERAxL+eGzZs4JZt2iSppfP3v/89t8oK3VvTUCik/OY3v2HRYDQaFbvdrvzkJz9Rmpqa+ujs+xerV68+6vti2xrSNa3pkY+ZNGkSrz/9jf7rX//qsfOTcd6CIAiCIHSZIV8DIQiCIAhC1xEBIQiCIAhClxEBIQiCIAhClxEBIQiCIAhClxEBIQiCIAhClxEBIQiCIAhClxEBIQiCIAhClxEBIQiCIAhClxEBIQiCIAhClxEBIQiCIAhClxEBIQiCIAhClxEBIQiCIAgCusr/AVaK0v9my4woAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -603,13 +427,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Iteration 18) \t Best Value: 1.1935042208215094\n", - "Early stopping at epoch 6128 with loss -0.11396026729265785\n" + "Iteration 8) \t Best Value: 1.0157966433570296\n", + "Early stopping at epoch 3835 with loss 0.6742690267810687\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -621,13 +445,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Iteration 19) \t Best Value: 1.1935042208215094\n", - "Early stopping at epoch 3919 with loss -0.06498622307422375\n" + "Iteration 9) \t Best Value: 1.0157966433570296\n", + "Early stopping at epoch 7895 with loss 0.40178305739913567\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -645,7 +469,7 @@ "X_bo = torch.rand(2, 1)\n", "Y_bo = objective(X_bo)\n", "\n", - "# lets define the optimizer settings\n", + "# lets define the optimizer settings (the values below are the default values)\n", "optimizer_settings = {\n", " \"num_epochs\": 10_000, # number of epochs\n", " \"freeze_backbone\": False, # whether to freeze the backbone / features during training\n", @@ -657,7 +481,7 @@ " \"clip_val\": 1.0, # gradient clipping value\n", "}\n", "\n", - "for iteration in range(20):\n", + "for iteration in range(10):\n", " print(f\"Iteration {iteration}) \\t Best Value: {Y_bo.max().item()}\")\n", "\n", " # initialize the model\n", @@ -686,6 +510,240 @@ " X_bo = torch.cat([X_bo, X_next])\n", " Y_bo = torch.cat([Y_bo, Y_next])" ] + }, + { + "cell_type": "markdown", + "id": "b802b013", + "metadata": {}, + "source": [ + "Lets plot the performance over the number of iterations." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "f642044d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/b7/4sbb97gd7xdcbjt2mww_cxcr0000gn/T/ipykernel_73018/3219396719.py:8: DeprecationWarning: __array_wrap__ must accept context and return_scalar arguments (positionally) in the future. (Deprecated NumPy 2.0)\n", + " best_value = np.maximum.accumulate(obs)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "\n", + "\n", + "def plot_performance(observations, labels):\n", + " fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(6, 4))\n", + "\n", + " for obs, label in zip(observations, labels):\n", + " best_value = np.maximum.accumulate(obs)\n", + " ax.plot(best_value, marker=\"\", lw=3, label=label)\n", + "\n", + " ax.set_xlabel(\"Iteration\")\n", + " ax.set_ylabel(\"Best value\")\n", + " ax.legend()\n", + " plt.show()\n", + "\n", + "\n", + "plot_performance([Y_bo], labels=[\"VBLL Thompson Sampling\"])" + ] + }, + { + "cell_type": "markdown", + "id": "30c0b3fd", + "metadata": {}, + "source": [ + "# Bayesian optimization on Ackley2D\n", + "\n", + "Lastly, lets also run Thompson sampling with VBLLs on the standard benchmark Ackley. Parts of the code are copied from the TuRBO tutorial." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d381e53c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 0) \t Best Value: -8.450333157127485\n", + "Early stopping at epoch 4679 with loss 5.71127556426972\n", + "Iteration 1) \t Best Value: -8.450333157127485\n", + "Early stopping at epoch 549 with loss 414.52220814723216\n", + "Iteration 2) \t Best Value: -8.450333157127485\n", + "Early stopping at epoch 5071 with loss 3.3508427848898767\n", + "Iteration 3) \t Best Value: -8.450333157127485\n", + "Early stopping at epoch 5381 with loss 3.459799186324661\n", + "Iteration 4) \t Best Value: -3.9786451141759156\n", + "Early stopping at epoch 4833 with loss 2.6036754003988127\n", + "Iteration 5) \t Best Value: -3.9786451141759156\n", + "Early stopping at epoch 7149 with loss 2.3706048504297788\n", + "Iteration 6) \t Best Value: -3.9786451141759156\n", + "Early stopping at epoch 6636 with loss 2.2300785975157407\n", + "Iteration 7) \t Best Value: -3.9786451141759156\n", + "Early stopping at epoch 7487 with loss 2.2630146130558413\n", + "Iteration 8) \t Best Value: -3.0623108858518546\n", + "Early stopping at epoch 5407 with loss 1.1503732474472212\n", + "Iteration 9) \t Best Value: -1.4951551049339042\n", + "Early stopping at epoch 7899 with loss 1.6488724531901233\n", + "Iteration 10) \t Best Value: -1.4951551049339042\n", + "Early stopping at epoch 3443 with loss 581.245456690729\n", + "Iteration 11) \t Best Value: -1.4951551049339042\n", + "Early stopping at epoch 6839 with loss 0.7179800427600189\n", + "Iteration 12) \t Best Value: -1.4951551049339042\n", + "Early stopping at epoch 7264 with loss 1.049935252601062\n", + "Iteration 13) \t Best Value: -1.4951551049339042\n", + "Early stopping at epoch 2818 with loss 341.0419177183832\n", + "Iteration 14) \t Best Value: -1.4951551049339042\n", + "Early stopping at epoch 1717 with loss 819.1292796120731\n", + "Iteration 15) \t Best Value: -1.4951551049339042\n", + "Early stopping at epoch 779 with loss 324.74201771197414\n", + "Iteration 16) \t Best Value: -1.4951551049339042\n", + "Early stopping at epoch 2809 with loss 334168.7470767889\n", + "Iteration 17) \t Best Value: -1.1834588468201734\n", + "Early stopping at epoch 3899 with loss 224.5554078222428\n", + "Iteration 18) \t Best Value: -0.47914417661898456\n", + "Early stopping at epoch 2322 with loss 12248.092699201714\n", + "Iteration 19) \t Best Value: -0.47914417661898456\n", + "Early stopping at epoch 10000 with loss -0.524064767269806\n", + "Iteration 20) \t Best Value: -0.12174630592231539\n", + "Early stopping at epoch 8108 with loss 0.07264085324399827\n", + "Iteration 21) \t Best Value: -0.12174630592231539\n", + "Early stopping at epoch 5289 with loss 0.7513088722962957\n", + "Iteration 22) \t Best Value: -0.009137546227745208\n", + "Early stopping at epoch 4626 with loss 32.181458277124555\n", + "Iteration 23) \t Best Value: -0.009137546227745208\n", + "Early stopping at epoch 4817 with loss 0.046897905443062715\n", + "Iteration 24) \t Best Value: -0.009137546227745208\n", + "Early stopping at epoch 2283 with loss 8438.196788256188\n", + "Iteration 25) \t Best Value: -0.009137546227745208\n", + "Early stopping at epoch 9827 with loss -0.9441056886352378\n", + "Iteration 26) \t Best Value: -0.008587574179629076\n", + "Early stopping at epoch 7083 with loss -0.12972537421971375\n", + "Iteration 27) \t Best Value: -0.008587574179629076\n", + "Early stopping at epoch 1903 with loss 378.6610015741472\n", + "Iteration 28) \t Best Value: -0.008587574179629076\n", + "Early stopping at epoch 5740 with loss -0.05027197016574714\n", + "Iteration 29) \t Best Value: -0.008587574179629076\n", + "Early stopping at epoch 3322 with loss 750.8233365118181\n" + ] + } + ], + "source": [ + "from botorch.test_functions import Ackley\n", + "from botorch.utils.transforms import unnormalize\n", + "from torch.quasirandom import SobolEngine\n", + "\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "\n", + "\n", + "def get_initial_points(dim, n_pts, seed=0):\n", + " sobol = SobolEngine(dimension=dim, scramble=True, seed=seed)\n", + " X_init = sobol.draw(n=n_pts).to(device=device)\n", + " return X_init\n", + "\n", + "\n", + "fun = Ackley(dim=2, negate=True)\n", + "fun.bounds[0, :].fill_(-5)\n", + "fun.bounds[1, :].fill_(10)\n", + "dim = fun.dim\n", + "lb, ub = fun.bounds\n", + "\n", + "\n", + "def eval_objective(x):\n", + " \"\"\"This is a helper function we use to unnormalize and evalaute a point\"\"\"\n", + " return fun(unnormalize(x, fun.bounds))\n", + "\n", + "\n", + "batch_size = 1\n", + "n_init = dim * 2\n", + "max_cholesky_size = float(\"inf\") # Always use Cholesky\n", + "\n", + "X_bo = get_initial_points(dim, n_init)\n", + "Y_bo = torch.tensor([eval_objective(x) for x in X_bo], device=device).unsqueeze(-1)\n", + "\n", + "for iteration in range(30):\n", + " print(f\"Iteration {iteration}) \\t Best Value: {Y_bo.max().item()}\")\n", + "\n", + " # initialize the model\n", + " model = VBLLModel(\n", + " in_features=dim,\n", + " hidden_features=50,\n", + " num_layers=3,\n", + " out_features=1,\n", + " device=device,\n", + " )\n", + "\n", + " # we can also only change part of the optimizer settings, the rest will be the default values\n", + " optimizer_settings = {\n", + " \"lr\": 1.001e-3, # value only changed for demonstration, default is 1e-3\n", + " }\n", + "\n", + " model.fit(X_bo, Y_bo, optimization_settings=optimizer_settings)\n", + "\n", + " # Thompson sampling as acquisition function\n", + " thompson_sampling = BLLMaxPosteriorSampling(\n", + " model=model,\n", + " num_restarts=10, # define the number of restarts for the optimization\n", + " )\n", + " X_next = thompson_sampling(num_samples=batch_size)\n", + "\n", + " # evaluate the objective\n", + " Y_next = torch.tensor([eval_objective(x) for x in X_next], device=device).unsqueeze(\n", + " -1\n", + " )\n", + "\n", + " # update the data\n", + " X_bo = torch.cat([X_bo, X_next])\n", + " Y_bo = torch.cat([Y_bo, Y_next])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "21a4cce2", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/b7/4sbb97gd7xdcbjt2mww_cxcr0000gn/T/ipykernel_73018/3219396719.py:8: DeprecationWarning: __array_wrap__ must accept context and return_scalar arguments (positionally) in the future. (Deprecated NumPy 2.0)\n", + " best_value = np.maximum.accumulate(obs)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_performance([Y_bo], labels=[\"VBLL Thompson Sampling\"])" + ] } ], "metadata": { From 1b0f8996cb2214e15ccf19ce9d2977fcf64fb5e5 Mon Sep 17 00:00:00 2001 From: pbrunzema Date: Thu, 20 Feb 2025 17:10:42 +0100 Subject: [PATCH 3/6] update optim config --- botorch_community/models/vblls.py | 60 ++++++++++++++++++++++--------- 1 file changed, 43 insertions(+), 17 deletions(-) diff --git a/botorch_community/models/vblls.py b/botorch_community/models/vblls.py index c5a8900f36..10c14d3393 100644 --- a/botorch_community/models/vblls.py +++ b/botorch_community/models/vblls.py @@ -16,12 +16,13 @@ Contributor: brunzema """ -from typing import Optional, Dict +from typing import Dict, Optional, Type from abc import ABC, abstractmethod import torch import torch.nn as nn from torch import Tensor +from torch.optim import Optimizer from torch.utils.data import DataLoader from gpytorch.distributions import MultivariateNormal @@ -166,6 +167,27 @@ def sample_posterior_function( return SampleModel(self.backbone, sampled_params) +def _get_optimizer( + optimizer_class: Type[Optimizer], + model_parameters, + lr: float = 1e-3, + **kwargs, +) -> Optimizer: + """ + Creates and returns an optimizer. + + Args: + optimizer_class (Type[Optimizer]): The optimizer class (e.g., torch.optim.AdamW). + model_parameters: Parameters to be optimized. + lr (float): Learning rate. + **kwargs: Additional arguments to be passed to the optimizer. + + Returns: + Optimizer: The initialized optimizer. + """ + return optimizer_class(model_parameters, lr=lr, **kwargs) + + class AbstractBLLModel(Model, ABC): def __init__(self): super().__init__() @@ -188,8 +210,8 @@ def fit( self, train_X: Tensor, train_y: Tensor, - optimization_settings: Dict = None, - initialization_params: Dict = None, + optimization_settings: Optional[Dict] = None, + initialization_params: Optional[Dict] = None, ): """ Fits the model to the given training data. Note that for continual learning, we assume that the last point in the training data is the new point. @@ -226,17 +248,19 @@ def fit( "freeze_backbone": False, "patience": 100, "batch_size": 32, - "optimizer": torch.optim.AdamW, + "optimizer": torch.optim.AdamW, # Now uses a class, not an instance "lr": 1e-3, "wd": 1e-4, "clip_val": 1.0, + "optimizer_kwargs": {}, # Extra optimizer-specific args (e.g., betas for Adam) } # Merge defaults with provided settings - if optimization_settings is None: - optimization_settings = default_opt_settings - else: - optimization_settings = {**default_opt_settings, **optimization_settings} + optimization_settings = ( + default_opt_settings + if optimization_settings is None + else {**default_opt_settings, **optimization_settings} + ) # Make dataloader based on train_X, train_y device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") @@ -267,8 +291,16 @@ def fit( } ) - optimizer = optimization_settings["optimizer"]( - lr=optimization_settings["lr"], params=param_list + # Extract settings + optimizer_class = optimization_settings["optimizer"] + optimizer_kwargs = optimization_settings.get("optimizer_kwargs", {}) + + # Initialize optimizer using helper function + optimizer = _get_optimizer( + optimizer_class, + model_parameters=param_list, + lr=optimization_settings["lr"], + **optimizer_kwargs, ) best_loss = float("inf") @@ -329,11 +361,9 @@ def posterior( if len(X.shape) < 3: B, D = X.shape Q = 1 - batched = False else: B, Q, D = X.shape X = X.reshape(B * Q, D) - batched = True posterior = self.model(X).predictive @@ -345,11 +375,7 @@ def posterior( # pass as MultivariateNormal to GPyTorchPosterior dist = MultivariateNormal(mean, cov) post_pred = GPyTorchPosterior(dist) - - if batched: - return BLLPosterior(post_pred, self, X, self.num_outputs) - else: - return post_pred + return BLLPosterior(post_pred, self, X, self.num_outputs) @abstractmethod def sample(self, sample_shape: Optional[torch.Size] = None): From 2606ac382334885a990289d395ce840301bda402 Mon Sep 17 00:00:00 2001 From: pbrunzema Date: Fri, 21 Feb 2025 15:11:06 +0100 Subject: [PATCH 4/6] add tests for vbll model --- botorch_community/models/vblls.py | 54 +++++--- test_community/models/test_vblls.py | 186 ++++++++++++++++++++++++++++ 2 files changed, 225 insertions(+), 15 deletions(-) create mode 100644 test_community/models/test_vblls.py diff --git a/botorch_community/models/vblls.py b/botorch_community/models/vblls.py index 10c14d3393..707ddf4077 100644 --- a/botorch_community/models/vblls.py +++ b/botorch_community/models/vblls.py @@ -87,7 +87,7 @@ class VBLLNetwork(nn.Module): def __init__( self, in_features: int = 2, - hidden_features: int = 50, + hidden_features: int = 64, out_features: int = 1, num_layers: int = 3, prior_scale: float = 1.0, @@ -206,6 +206,10 @@ def num_inputs(self): def device(self): return self.model.device + @property + def backbone(self): + return self.model.backbone + def fit( self, train_X: Tensor, @@ -308,12 +312,13 @@ def fit( early_stop = False best_model_state = None # To store the best model parameters + self.model.train() + for epoch in range(1, optimization_settings["num_epochs"] + 1): # early stopping if early_stop: break - self.model.train() running_loss = [] for train_step, (x, y) in enumerate(dataloader): @@ -323,9 +328,12 @@ def fit( loss = out.train_loss_fn(y) # vbll layer will calculate the loss loss.backward() - torch.nn.utils.clip_grad_norm_( - self.model.parameters(), optimization_settings["clip_val"] - ) + + if optimization_settings["clip_val"] is not None: + torch.nn.utils.clip_grad_norm_( + self.model.parameters(), optimization_settings["clip_val"] + ) + optimizer.step() running_loss.append(loss.item()) @@ -355,26 +363,42 @@ def posterior( self, X: Tensor, output_indices=None, - observation_noise=False, + observation_noise=None, posterior_transform=None, ) -> Posterior: - if len(X.shape) < 3: - B, D = X.shape - Q = 1 + # Determine if the input is batched + batched = X.dim() == 3 + + if not batched: + N, D = X.shape + B = 1 else: - B, Q, D = X.shape - X = X.reshape(B * Q, D) + B, N, D = X.shape + X = X.reshape(B * N, D) posterior = self.model(X).predictive # Extract mean and variance - mean = posterior.mean.squeeze(-1) - variance = posterior.variance.squeeze(-1) + mean = posterior.mean.squeeze() + variance = posterior.variance.squeeze() cov = torch.diag_embed(variance) + K = self.num_outputs + mean = mean.reshape(B, N * K) + + # Cov must be `(B, Q*K, Q*K)` + cov = cov.reshape(B, N, K, B, N, K) + cov = torch.einsum("bqkbrl->bqkrl", cov) # (B, Q, K, Q, K) + cov = cov.reshape(B, N * K, N * K) + + # Remove fake batch dimension if not batched + if not batched: + mean = mean.squeeze(0) + cov = cov.squeeze(0) + # pass as MultivariateNormal to GPyTorchPosterior - dist = MultivariateNormal(mean, cov) - post_pred = GPyTorchPosterior(dist) + mvn_dist = MultivariateNormal(mean, cov) + post_pred = GPyTorchPosterior(mvn_dist) return BLLPosterior(post_pred, self, X, self.num_outputs) @abstractmethod diff --git a/test_community/models/test_vblls.py b/test_community/models/test_vblls.py new file mode 100644 index 0000000000..97110e43d9 --- /dev/null +++ b/test_community/models/test_vblls.py @@ -0,0 +1,186 @@ +#!/usr/bin/env python3 +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import copy + +import torch +from botorch.utils.testing import BotorchTestCase +from botorch_community.models.vblls import VBLLModel +from botorch_community.posteriors.bll_posterior import BLLPosterior + + +def _reg_data_singletask(d, n=10): + X = torch.randn(10, d) + y = torch.randn(10, 1) + return X, y + + +def _get_fast_training_settings(): + return { + "num_epochs": 3, + "lr": 0.01, + } + + +class TestVBLLModel(BotorchTestCase): + def test_initialization(self) -> None: + d, num_hidden, num_outputs, num_layers = 2, 3, 1, 4 + model = VBLLModel( + in_features=d, + hidden_features=num_hidden, + num_layers=num_layers, + out_features=num_outputs, + ) + self.assertEqual(model.num_inputs, d) + self.assertEqual(model.num_outputs, num_outputs) + + hidden_layer_count = sum( + isinstance(layer, torch.nn.Linear) + for submodule in model.backbone[1:] # note that the first layer is excluded + for layer in ( + submodule if isinstance(submodule, torch.nn.Sequential) else [submodule] + ) + ) + self.assertEqual( + hidden_layer_count, + num_layers, + f"Expected {num_layers} hidden layers, but got {hidden_layer_count}.", + ) + + def test_backbone_initialization(self) -> None: + d, num_hidden = 4, 3 + test_backbone = torch.nn.Sequential( + torch.nn.Linear(d, num_hidden), + torch.nn.ReLU(), + torch.nn.Linear(num_hidden, num_hidden), + ) + model = VBLLModel(backbone=test_backbone, hidden_features=num_hidden) + + for key in test_backbone.state_dict(): + self.assertTrue( + torch.allclose( + test_backbone.state_dict()[key], + model.backbone.state_dict()[key], + atol=1e-6, + ), + f"Mismatch of backbone state_dict for key: {key}", + ) + + def test_freezing_backbone(self) -> None: + d, num_hidden = 4, 3 + for freeze_backbone in (True, False): + test_backbone = torch.nn.Sequential( + torch.nn.Linear(d, num_hidden), + torch.nn.ReLU(), + torch.nn.Linear(num_hidden, num_hidden), + torch.nn.ELU(), + ) + + model = VBLLModel( + backbone=copy.deepcopy(test_backbone), # copy.deepcopy(test_backbone) + hidden_features=num_hidden, # match the output of the backbone + ) + + X, y = _reg_data_singletask(d) + optim_settings = { + "num_epochs": 10, + "lr": 5.0, # large lr to make sure that the weights change + "freeze_backbone": freeze_backbone, + } + model.fit(X, y, optimization_settings=optim_settings) + + if freeze_backbone: + # Ensure all parameters remain unchanged + all_params_unchanged = all( + torch.allclose( + test_backbone.state_dict()[key], + model.backbone.state_dict()[key], + atol=1e-6, + ) + for key in test_backbone.state_dict() + ) + self.assertTrue( + all_params_unchanged, + f"Expected all parameters to remain unchanged, but some changed with freeze_backbone={freeze_backbone}", + ) + else: + # Ensure at least one parameter has changed + any_param_changed = any( + not torch.allclose( + test_backbone.state_dict()[key], + model.backbone.state_dict()[key], + atol=1e-6, + ) + for key in test_backbone.state_dict() + ) + self.assertTrue( + any_param_changed, + f"Expected at least one parameter to change, but all remained the same with freeze_backbone={freeze_backbone}", + ) + + def test_update_of_reg_weight(self) -> None: + kl_scale = 2.0 + d = 2 + model = VBLLModel( + in_features=d, + hidden_features=3, + out_features=1, + num_layers=1, + kl_scale=kl_scale, + ) + self.assertEqual( + model.model.head.regularization_weight, + 1.0, + "Regularization weight should be 1.0 after init.", + ) + + X, y = _reg_data_singletask(d) + + optim_settings = _get_fast_training_settings() + model.fit(X, y, optimization_settings=optim_settings) + + self.assertEqual( + model.model.head.regularization_weight, + kl_scale / len(y), + f"Regularization weight should be {kl_scale}/{len(y)}, but got {model.model.head.regularization_weight}.", + ) + + def test_shape_of_predictions(self) -> None: + d = 4 + model = VBLLModel( + in_features=d, hidden_features=4, out_features=1, num_layers=1 + ) + X, y = _reg_data_singletask(d) + optim_settings = _get_fast_training_settings() + + model.fit(X, y, optimization_settings=optim_settings) + + for batch_shape in (torch.Size([2]), torch.Size()): + X = torch.rand(batch_shape + torch.Size([3, d])) + expected_shape = batch_shape + torch.Size([3, 1]) + + post = model.posterior(X) + + # check that the posterior is an instance of BLLPosterior + self.assertIsInstance( + post, + BLLPosterior, + "Expected posterior to be an instance of BLLPosterior.", + ) + + # mean prediction + self.assertEqual( + post.mean.shape, + expected_shape, + f"Expected mean predictions to have shape {expected_shape}, but got {post.mean.shape}.", + ) + + # variance prediction + self.assertEqual( + post.variance.shape, + expected_shape, + f"Expected variance predictions to have shape {expected_shape}, but got {post.mean.shape}.", + ) From 873163f16f54ef745d533010ce4fbbb59f63ba3a Mon Sep 17 00:00:00 2001 From: pbrunzema Date: Fri, 21 Feb 2025 15:52:46 +0100 Subject: [PATCH 5/6] update tutorial for vblls --- .../vbll_thompson_sampling.ipynb | 267 ++++++++++-------- 1 file changed, 150 insertions(+), 117 deletions(-) diff --git a/notebooks_community/vbll_thompson_sampling.ipynb b/notebooks_community/vbll_thompson_sampling.ipynb index ca0d7bca9e..687dd03645 100644 --- a/notebooks_community/vbll_thompson_sampling.ipynb +++ b/notebooks_community/vbll_thompson_sampling.ipynb @@ -13,9 +13,9 @@ "\n", "In this notebook, we will demonstrate how to use variational Bayesian last layers (VBLLs) for Bayesian optimization [1, 2].\n", "\n", - "[1] P. Brunzema, M. Jordahn, J. Willes, S. Trimpe, J. Snoek, J. Harrison. Bayesian Optimization via Continual Variational Last Layer Training. International Conference on Learning Representations (ICLR), 2025.\n", + "[1] P. Brunzema, M. Jordahn, J. Willes, S. Trimpe, J. Snoek, J. Harrison. [Bayesian Optimization via Continual Variational Last Layer Training](https://arxiv.org/abs/2412.09477). International Conference on Learning Representations (ICLR), 2025.\n", "\n", - "[2] J. Harrison, J. Willes, J. Snoek. Variational Bayesian Last Layers. International Conference on Learning Representations (ICLR), 2024.\n" + "[2] J. Harrison, J. Willes, J. Snoek. [Variational Bayesian Last Layers](https://arxiv.org/abs/2404.11599). International Conference on Learning Representations (ICLR), 2024.\n" ] }, { @@ -33,8 +33,8 @@ "$$\n", " y = \\mathbf{w}^\\top \\phi_{\\theta} (\\mathbf{x}) + \\varepsilon\n", "$$\n", - "where $\\varepsilon \\sim \\mathcal{N}(0, \\sigma^2)$\n", - "VBLL models use a variational posterior distribution on the weights as $\\mathbf{w} \\sim q(\\mathbf{w})$ with $q(\\mathbf{w}) = \\mathcal{N}(\\bar{\\mathbf{w}}, S)$ where $\\bar{\\mathbf{w}}$ is the mean and $S$ the full covariance of a multivariate normal distribution.\n", + "where $\\varepsilon \\sim \\mathcal{N}(0, \\sigma^2)$.\n", + "VBLL models use a variational posterior distribution on the weights as $\\mathbf{w} \\sim q(\\mathbf{w})$ with $q(\\mathbf{w}) = \\mathcal{N}(\\bar{\\mathbf{w}}, S)$ where $\\bar{\\mathbf{w}}$ is the mean and $S$ the full covariance of a multivariate normal distribution (for more information, see [1,2]).\n", "Through conjugany, we yield the posterior predictive\n", "$$\n", " p(y \\mid \\mathbf{x}, \\mathcal{D}_T, \\theta) = \\mathcal{N} \\big( \\bar{\\mathbf{w}}_T^\\top \\phi_{\\theta}(\\mathbf{x}), \\, \\phi_{\\theta}(\\mathbf{x})^\\top S_T \\phi_{\\theta}(\\mathbf{x}) + \\sigma^{2} \\big).\n", @@ -43,7 +43,7 @@ "\n", "## The VBLLs on Toy Data\n", "\n", - "Before using the VBLL model in the context of Bayesian Optimization, let's see how the interface of the model looks. The current implementation allows for passing a full backbone to the model (which could be anything). If no backbone is provided, a standard MLP is created. For training, [1] discusses continual learning approaches which will be added to the implementation but in the following, we will not go into detail. See the docstring of `model.fit` for the different options for configuring the optimization and the training.\n", + "Before using the VBLL model in the context of Bayesian Optimization, let's see how the interface of the model looks. The current implementation allows for passing a full backbone to the model (which could be anything). If no backbone is provided, a standard MLP is created. For training, [1] discusses continual learning approaches which will be added to the implementation, but in the following, we will not go into detail. See the docstring of `model.fit` for the different options for configuring the optimization and the training.\n", "\n", "Below, we use the model in a 1D regression example.\n" ] @@ -104,31 +104,31 @@ "VBLLNetwork(\n", " (activation): ELU(alpha=1.0)\n", " (backbone): Sequential(\n", - " (0): Linear(in_features=1, out_features=50, bias=True)\n", + " (0): Linear(in_features=1, out_features=64, bias=True)\n", " (1): ELU(alpha=1.0)\n", " (2): Sequential(\n", - " (0): Linear(in_features=50, out_features=50, bias=True)\n", + " (0): Linear(in_features=64, out_features=64, bias=True)\n", " (1): ELU(alpha=1.0)\n", " )\n", " (3): Sequential(\n", - " (0): Linear(in_features=50, out_features=50, bias=True)\n", + " (0): Linear(in_features=64, out_features=64, bias=True)\n", " (1): ELU(alpha=1.0)\n", " )\n", " (4): Sequential(\n", - " (0): Linear(in_features=50, out_features=50, bias=True)\n", + " (0): Linear(in_features=64, out_features=64, bias=True)\n", " (1): ELU(alpha=1.0)\n", " )\n", " )\n", " (head): Regression()\n", ")\n", - "Early stopping at epoch 6195 with loss 1.0684124442429037\n" + "Early stopping at epoch 7429 with loss 2.049139128994765\n" ] } ], "source": [ "model = VBLLModel(\n", " in_features=1,\n", - " hidden_features=50,\n", + " hidden_features=64,\n", " num_layers=3,\n", " out_features=1,\n", ")\n", @@ -156,7 +156,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -207,7 +207,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -217,14 +217,21 @@ } ], "source": [ - "def plot_model(model, x, y, new_data=None, show_opjective=False):\n", + "def plot_model(\n", + " model,\n", + " x,\n", + " y,\n", + " new_data=None,\n", + " show_opjective=False,\n", + " title=\"VBLL Predictive on Toy Data with Thompson Samples\",\n", + "):\n", " x_test = torch.linspace(0, 1, 100)\n", " with torch.no_grad():\n", " posterior = model.posterior(x_test.view(-1, 1))\n", " mean, std = posterior.mean.squeeze(), posterior.variance.sqrt().squeeze()\n", "\n", " fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(6, 4))\n", - " ax.set_title(\"VBLL Predictive on Toy Data with Thompson Samples\")\n", + " ax.set_title(title)\n", " ax.scatter(x, y, c=\"k\", label=\"Observations\")\n", "\n", " if new_data is not None:\n", @@ -239,7 +246,9 @@ " # Posterior samples\n", " with torch.no_grad():\n", " for i in range(5):\n", - " ts_sample = model.sample() # a sample is essentially a standard MLP (one can also generate multiple samples, see function)\n", + " ts_sample = (\n", + " model.sample()\n", + " ) # a sample is essentially a standard MLP (nn.Module)\n", " ts_mean = ts_sample(x_test.view(-1, 1)).squeeze()\n", " ax.plot(\n", " x_test,\n", @@ -270,7 +279,7 @@ "id": "4e99876e", "metadata": {}, "source": [ - "Next, lets us the VBLLs for Bayesian optimization to optimize the toy function above using Thompson sampling. Note that setting up the Thompson sampling is similar to the standard `MaxPosteriorSampling` in BoTorch." + "Next, lets us the VBLLs for Bayesian optimization to optimize the toy function above using Thompson sampling. Note that setting up the Thompson sampling is similar to the standard `MaxPosteriorSampling` in BoTorch. Below, we also included logEI as an acquisition function to demonstrate the staight-forward use of the model also for other acquisition functions." ] }, { @@ -284,12 +293,12 @@ "output_type": "stream", "text": [ "Iteration 0) \t Best Value: 0.3324226803440067\n", - "Early stopping at epoch 3537 with loss 8.284433330961363\n" + "Early stopping at epoch 5831 with loss 11.785646554827284\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -302,12 +311,12 @@ "output_type": "stream", "text": [ "Iteration 1) \t Best Value: 0.3324226803440067\n", - "Early stopping at epoch 2946 with loss 5.458685157415583\n" + "Early stopping at epoch 6783 with loss 7.619170919493615\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -319,13 +328,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Iteration 2) \t Best Value: 1.0040176868451611\n", - "Early stopping at epoch 5318 with loss 3.4427417449798003\n" + "Iteration 2) \t Best Value: 0.9259503761120249\n", + "Early stopping at epoch 6535 with loss 5.244918662626183\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -337,13 +346,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Iteration 3) \t Best Value: 1.0040176868451611\n", - "Early stopping at epoch 3298 with loss 2.7493056257019517\n" + "Iteration 3) \t Best Value: 1.0655169256110333\n", + "Early stopping at epoch 4470 with loss 4.343606428142312\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -355,13 +364,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Iteration 4) \t Best Value: 1.0157966433570296\n", - "Early stopping at epoch 4937 with loss 1.7227881954940887\n" + "Iteration 4) \t Best Value: 1.0655169256110333\n", + "Early stopping at epoch 8523 with loss 2.8553055975418022\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -373,13 +382,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Iteration 5) \t Best Value: 1.0157966433570296\n", - "Early stopping at epoch 4125 with loss 1.548313489101463\n" + "Iteration 5) \t Best Value: 1.0655169256110333\n", + "Early stopping at epoch 6311 with loss 2.244350903200155\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -391,13 +400,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Iteration 6) \t Best Value: 1.0157966433570296\n", - "Early stopping at epoch 10000 with loss 0.8870515445169387\n" + "Iteration 6) \t Best Value: 1.0843359735924152\n", + "Early stopping at epoch 7897 with loss 1.730155204339289\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -409,13 +418,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Iteration 7) \t Best Value: 1.0157966433570296\n", - "Early stopping at epoch 7657 with loss 0.4598584669936603\n" + "Iteration 7) \t Best Value: 1.0843359735924152\n", + "Early stopping at epoch 4368 with loss 1.932662771482418\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -427,13 +436,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Iteration 8) \t Best Value: 1.0157966433570296\n", - "Early stopping at epoch 3835 with loss 0.6742690267810687\n" + "Iteration 8) \t Best Value: 1.0843359735924152\n", + "Early stopping at epoch 6996 with loss 1.351011901420722\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -445,13 +454,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Iteration 9) \t Best Value: 1.0157966433570296\n", - "Early stopping at epoch 7895 with loss 0.40178305739913567\n" + "Iteration 9) \t Best Value: 1.0843359735924152\n", + "Early stopping at epoch 4938 with loss 1.1992996568832108\n" ] }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhAAAAF2CAYAAAA/RaFTAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAA0YpJREFUeJzsnQd4VGX2xt/pfSaT3nvovYqgiKLYC3Zdu7u6unZXV13Xvta17Nr1r+7aOyIIiqCIiiK9l5De22R6n/k/5wyJgSQwEwgk4fs9z5Apd+7cDJm573fKeyThcDgMgUAgEAgEghiQxrKxQCAQCAQCASEEhEAgEAgEgpgRAkIgEAgEAkHMCAEhEAgEAoEgZoSAEAgEAoFAEDNCQAgEAoFAIIgZISAEAoFAIBDEjBAQAoFAIBAIYkYICIFAIBAIBDEjBIRAIDikfP/995BIJPxTIBD0H4SAEAgGEG+99RafjFeuXNl+31dffYX7778fh5oXX3yRj6+v8fzzz2Po0KFQqVTIyMjArbfeCqfTeagPSyDo8wgBIRAMcEhAPPDAA31WQBx99NFwu93882Bz55134oYbbsCIESPw3HPP4eyzz8Z//vMfzJ49+6Afi0DQ35Af6gMQCAT9D5rB5/F4oNFo9ntfUqkUarUaB5va2lo8/fTTuOSSS/C///2v/f5BgwaxqPjyyy9x2mmnHfTjEgj6CyICIRAMYC6//HK88MILfJ1SG22XNkKhEJ599lkMHz6cT+IpKSm45pprYLFYdttPbm4uTj31VHz99deYMGECC4dXXnmFH3vzzTdx7LHHIjk5mdMAw4YNw0svvdTp+Zs2bcLSpUvbj+GYY47Zaw3Exx9/jPHjx/NrJSYm4g9/+AOqq6s7/X56vZ7vP/PMM/l6UlISbr/9dgSDwb2+N8uXL0cgEMAFF1yw2/1ttz/44IOo32eB4HBERCAEggEMiYGamhosWrQIb7/9dpePU1rhiiuuwI033ojS0lKuCVizZg1++uknKBSK9m23bduGCy+8kJ/zxz/+EYMHD+b7SSyQADn99NMhl8t55X7dddexOLn++ut5GxIptKqnE/w999zD95FY6Y62Y5o4cSIeffRR1NfXc4qBjomOLS4urn1bEgqzZs3C5MmT8dRTT+Hbb7/Fv/71LxQUFODPf/5zt6/h9Xr5555RFK1Wyz9XrVoV9fssEByWhAUCwYDhzTffDNPH+rfffmu/7/rrr+f79mTZsmV8/7vvvrvb/QsXLux0f05ODt9Hj+2Jy+XqdN+sWbPC+fn5u903fPjw8PTp0ztt+9133/G+6Sfh8/nCycnJ4REjRoTdbnf7dvPmzePt/vGPf7Tfd9lll/F9Dz744G77HDt2bHj8+PHhvbFq1Sp+7kMPPdTl76/X6/f6fIHgcEekMASCwxRKEZhMJhx//PFoampqv1DagCIF33333W7b5+Xl8Up/Tzqu4K1WK+9j+vTpKCkp4duxQh0kDQ0NHMXoWBtxyimnYMiQIZg/f36n51x77bW73T7qqKP49ffGuHHjOGrx+OOPcxqmrKwMCxYs4AgLRV6osFMgEHSPSGEIBIcpO3bs4BM81S50BZ3E9xQQXUFphfvuu49rClwu126P0f5JpMRCeXk5/2xLkXSEBMSPP/64230kMqjuoSNms7lTHUdXfPrppzj//PNx5ZVX8m2ZTMZtnFSrQSkbgUDQPUJACASHKVSjQOLh3Xff7fLxPU/KXXVc7Ny5E8cddxyf2KmjISsrC0qlkltHn3nmGX6N3oZO+j2FfB9IkJCYqqurQ1FREVJTU5Gens7dGAKBoHuEgBAIBjgduy46QkWGVHA4derUHrdjUsEkFSPOnTsX2dnZ7ffvmf7Y23HsSU5ODv+kCAB1d3SE7mt7/EBCwoEuxObNm7nFkzo8BAJB94gaCIFggKPT6fhna2vrbvefd9553MHw0EMPdXoOtTfuuf3eVv/kC9ExbUE1BV0dRzT7pDZRioy8/PLL7Z0SBNUnbNmyhWsheguKmNxxxx3cibFnXYVAINgdEYEQCAY4VBRJUJsmFUHSSZ+8DqjQkQoGqU1y7dq1OOGEE7h4kML5VGBJbZPnnHPOXvdNz6GUBRku0b4cDgdee+01FgC0it/zOKjl8+GHH0ZhYSFvs2eEgaBjoMJGauOkY6TW0bY2TvKTuOWWWw7Ye3PTTTexIdaYMWPg9/vx3nvvYcWKFfjvf/+7W0RFIBB0waFuAxEIBL3bxhkIBMI33HBDOCkpKSyRSDq1dL766qvc8qjRaMIGgyE8cuTI8B133BGuqanZrY3zlFNO6fI1586dGx41alRYrVaHc3Nzw48//nj4jTfe4NcpLS1t366uro73Qa9Bj7W1dO7ZxtnGhx9+yO2YKpUqHB8fH7744ovDVVVVu21DbZw6na7TMd13331dtq529X6NHj2a90HHddxxx4WXLFmyz+cJBIJwWEL/dCUsBAKBQCAQCLpD1EAIBAKBQCCIGSEgBAKBQCAQxIwQEAKBQCAQCGJGCAiBQCAQCAQxIwSEQCAQCASCmBECQiAQCAQCQcwMOCMpcpKrqamBwWCI2jpXIBAIBAIB2FXWbrfzPBipVHp4CQgSDzTQRyAQCAQCQc+orKxEZmbm4SUgKPLQ9ssbjcZDfTgCgUAgEPQbbDYbL8LbzqWHlYBoS1uQeBACQiAQCASC2ImmBEAUUQoEAoFAIIgZISAEAoFAIBDEjBAQAoFAIBAIYkYICIFAIBAIBDEjBIRAIBAIBIKYEQJCIBAIBAJBzAy4Nk6BIGaCQWDZMqC2FkhLA446CpDJDvVRCQQCQZ9GCAjB4c1nnwE33QRUVf1+H7mvPfccMHv2oTwygUAg6NOIFIbg8BYP55yzu3ggqqsj99PjAoFAIOgSISAEh2/agiIP4XDnx9ruu/nmyHYCgUAg6IQQEILDE6p52DPysKeIqKyMbCcQCASCTggBITg8oYLJA7mdQCAQHGYIASE4PKFuiwO5nUAgEBxmCAEhODyhVk3qtuhu4hzdn5UV2U4gEAgEnRACQnB4Qj4P1KpJ7Cki2m4/+6zwgxAIBIJuEAJCcPhCPg+ffAJkZOx+P0Um6H7hAyEQCATdIoykBIc3s2fDeeIpsC79CYrGBqjTU6A+ehoUSsWhPjKBQCDo0wgBITgsCYXCsLh8qLd70GjzwpM9DMgaCoVcCmWFFTqlDEkGFRL1KqgVIo0hEAgEeyIEhOCwIhwOo9HhRWWLCxanH2GEYVQrEK9T8eP+YAjeQAhWlx/1Ng/0agUyTGokGdXQq8THRSAQCNoQ34iCwwa3L4jyZieqLG5IJRLE65RQyHYvA6LbdCGxQGLD7glgW70dFS0upBjVSDdrWHAIBALB4Y4QEILDIl3RYPeitMnBkYWEDmmJYCiItWvWoKmpCYmJiRgzdixk0shjEokERo2CLy5fAOUtTtRZPUg1CSEhEAgEQkAIBjQefxAlTQ5UW9xQymRIj9OwMCCWfLcETz31FBrq69u3T05Jwe23345jZxy72360SjlfhJAQCASCCKKNUzBgaXX5sKHaiopmF8xaJacsOoqHO+64YzfxQNDtO/76Vyxe/G2X+yQRkW7SQqOUsZBYU27Bjno7nN7AQfmdBAKBoK8gBIRgQKYsqlvdWFfZyimLNJMGKvnvnRSUtqDIQ5eTOHdx191349tvF3X7eJuQoP3ubHRiVbkFJY0OrrMQCASCwwEhIAQDCl8ghO31dmyqtkImlXLhIxVMdoRqHjpGHjTyMBLVIahkvwuKUDCIv/3tbxyp2Bs6lRwZcRoopFJsb7BjVYUFFc1OeANCSAgEgoGNqIEQDBgojUDphDqbFwk6Zbf+DVQwScSrQpiS6seohADamjG8QQnsPglavBJsbJbj2X89henTp7cXVnaHXi2HTiWDzRPA5lobaqweZMdrkWxQQb5Hp4dAIBAMBISAEAwIWpw+jjxY3T6kGjWQSbsZkgUgyyTF2QUeDIkLto+9IOFAEQi+aMJI1ACD4oJwB0rRsPRNZE45G0G1ea/HQPUVJo0CBrWcUyfrq6xI1CtZSJAhlXQvxyQQCAT9DSEgBP0a8mqos3lYPAQCYaQZf++y2BNJ0At99Y+YLt+A6kw1nE4ndrTK8HOdApUOGRTSMAyKMEzKMLINQYxJDMCgDEPfuBoJm2zwmfLgTJkIvz6j+ymelBeUSGDWKWHc5Xa5trKVUymZZs1uhZwCgUDQnxECQtCviyXJGIqKGFVyKZKNETfJrlDYymGsWASZ18Yn/8HHnIdrHv8AjZ7f0wv+UCR10eIFSu0y/FCjQJEpiKPPLuTnKK2lfPHr0uBKnQivqWCvQoKiIBR5IHfLJocXjXYvt35mmbUwaUXrp0Ag6N8IASHol9BJeWeDA+UtLsRpFNwV0X3UYRk0jev5dlBlhC3nBGSPz8bt2vHcbUEFk10RhgSt6gyYjrsJzT47tA0roW7eDIWzFqadcxHQJMCZOhle8yBA0n2dAzlbJhvUXFhZ0+pGo93DnSEZZg0MwkNCIBD0U3q1uuuHH37AaaedhvT0dA7bzpkzZ5/P+f777zFu3DioVCoUFhbirbfe6s1DFPRTc6gttTaUNbu4WLI78SB31SN+63vt4sGdPAYtQy+F35DNt2dOn4q37r0MD0924PUZNrw03Yb/HGXHv6ba8cBEB07K9iJB6sDS779HUB0He/ZMNI+4Cs7USQjLVZC7m2Eq/QoJm/8HdfMWIBza63FTyycJB51SgbJmJ1ZXWFDcYGdzKoFAIOhv9GoEgnLMo0ePxpVXXonZs2fvc/vS0lKccsopuPbaa/Huu+9i8eLFuPrqq5GWloZZs2b15qEK+gl2jx/b6uxocviQ0l2HQzgMTeNaGKp/oH5MBJVG2HJnwW/I4scU9gpo61dxPUQuKuCZFI/mpgYeouUPUXQjks6YkBxAnbsW297/C4rdf8bg4y5lIeHMmAZXygRoGtdB27AKMk8LjGULoKv7BY60KfCaB+81tUEmVBlKLRzeAIobHOxqSfURqSaNmPwpEAj6DZIwVaEdjBeSSPD555/jzDPP7HabO++8E/Pnz8fGjRvb77vgggvQ2tqKhQsXRvU6NpsNJpMJVqsVRqPxgBy7oG9gcfpYPNg8/i79HQhJwANj+TdQtRbzbW9cAWw5sxCWqaC0l0NfuZRP+gpHNeReKxDyI6AyY8maHfB5vVBIwtzSGacMswagD0cwLIEzrMGEE86FO3UCXCmTENAmRV4v6GWxoq1fDWnAzfcFNElwpB8Jnyl/r0KCaBvYZfcGuHuDWz+Nqt2MrwQCgeBgEcs5tE/VQCxfvhwzZ87c7T6KPNx8883dPsfr9fKl4y8vGHg02DzYWmeHPxBCqlHdZSeD3NUAU8mXkJEwkMpgzzga7qQxUDgqoa/+CdqG1VDaKiDztrAy8KgTsTOUhnkNyVhpOBYGWTVM7mqYvY3Q2RsRH7YiXReETh6GLGRDw2+fwy1dhFqPGjscWmx2JcAmNUGpVEKjlGO40YkRJgeMWhV0ZRsgT8wHhpyMgDGSMumKtoFdJB7IQ2JTjRXVFiUy4zVcN6GUCw8JgUDQN+lTAqKurg4pKSm73Ue3SRS43W5oNJpOz3n00UfxwAMPHMSjFBxMaIVOttTUpimTUKeFusvtVC3bOPIgCfkRVJlgzTsFIbkapp1zWDiobOWQeVuBoB82eRI2eZOwsCYdy3xDUIsEgBo4VOOAXVYPSbBgdOv3aGpaBpW1AllGCRCsRzBcD4McyHACvtYQNjWE8H1ZANX2SCBPLQemZskwOZPaQiVQKh+BTZWGWv1IJBSMxojRYzFizHhoNNruPSTcfhYSVRo3RySSDKpOY8cFAoHgUNOnBERPuOuuu3Drrbe23yaxkZWVdUiPSXBg2zSLG53QKmS8Uu9EOMS1DNr6lXzTZ8yBNecEaJs2QlfzI9StxVyjQNv5JCqs92XgW0siFgUnsHAItdaideWr8NXtgCIxB4qkXCiTctCQPgTfxp0FY9wJGOVZDW/zEhToPCiKC0MjCyFJqsAwnwMT3HKcGtTBIk/Baose22ttqK2vx3ul9Ripa8aYFC/UvnLk2suwbs0X+L+nAnAF5RgyfBTGTjwCE488CpOnTW8XFOwhoSUPCQULCTKjitcpkLXLjEoICYFA0FfoUwIiNTUV9XtMR6TblIfpKvpAULcGXQQDi0AwhJJGJ4/iphNqV50WVO9gKp3HaQnCmRoxeYrf9hHUrduhtJUjLJUhHJZim12JX1rj8AtGYHloGOxbf4Z5+1wUBnZgeIoCyiIZyu3VKK/8FeVbVWiQJEAzZDqCQ6fhR81RWJUxEUcqimFOrUe8pxKWbcsR9nsQCAEJ8iYEAs24atxRSB97Mdc/BDWJ8Pt8qN2+BqGtCyBt2IDCpkYckV+Nb7e24seNq7Fx3Wq8/fqLUKnUmDT1aEyfeSKOnjkLqWkZ7CFBplPBUJinipKQMGsjQiJJL+yxBQLBoafPFVF+9dVX2LBhQ/t9F110EVpaWkQR5WEE+SXsqHeg2uJCvE7VZWeCzGNB3M45/DMsU8KeOZ39GXR1K6Gy7mRxYXP7UVNbjZWedNTrBuPr4EQ0NLdg5OYXMCNbhoLcDKRnZCElLR2VVVVYtOj36ZuegAS/1Mvxa5MG8uzxKJx5IZq8UujgxvjwJgy1/IA42w7kaV3wBiOeEUopkDZyOtILR8ATP5Q7MkIqE+9P7qxjPwqlvRJ2mxWVtQ1YtN2Ft79ZharKqt1+t4lTpuHU2efj+FPOgN4Q+RtuExKeQBAJehWbUZFNthASAoHgQBLLObRXBYTD4UBxcaQafuzYsXj66acxY8YMxMfHIzs7m9MP1dXV+N///tfexjlixAhcf/313Pq5ZMkS3HjjjdyZEW0bpxAQ/Rsah72tzsb21FRE2FXIXmGv5GJJacDDLZqOhJGwrp0HVetOxIdb0OwOo66qDDVeNVozpmKLtAhLfMMwwf4DrilsRWFuJpRKFXs5eOKK4I0rQkihxboln+G7z95EotQOtTzysZCojCg48RoMP+Ey/FJuwSPvLYEkLgMGuHAENqDI8iOSHNuRpfbA5pdAq1bhiClT4TfmIqTUwZU4is2mwgott5AqrSUwVC+LpFUo0qKKwxZ/Bub9vAlLv/0a61at4LoPgiITM2adgvP+cAXGHzGVRXibkCCRFS+EhEAgGKgCgkyhSDDsyWWXXcYGUZdffjnKysp4u47PueWWW7B582ZkZmbi3nvv5e2iRQiI/u3xQJ0WzQ5vtwOx1E0bYaxczP4Ofk0CNhRXYeeyT5Ehb4VaEkCVxcdTMRvMoxBIHobvQmPhU5nxxLhWpIcj6bGAJhGOjGlw6zKxdt16ns5ZUVnJETIa8y1BGMPigzi5UI5Tj52CvLx8HqT1S2s8LrzpASjTBkM/6gSo0oqQCCumYi1yLL8izbUDSUof8kdOQoJJj5BcyykVEieu5PFwpYzjdlKqx9A0bYCudjmkfhcfE21HUZTKVj/mf/4xvvz0A5QWb2//vQcPG4GLrrgGJ51xDtQajRASAoFgYAuIQ4EQEAPU4yEchq7mJ+jqVvBNvyYRpVvXY8P3n6HI4EOdLQC7Lwyl1gBr1jTYNFmYH5yMi4ZrcIFpM2RhP7d2OlKPYBOoJUuX4qmnnmLB0B1SKTA+KYDHrjoeRTnp2LmzGK9+vhTfVCrR7JFCmVoIw9iToUwpQJakHkeF1yDNshrH58qRkWhEQBUPSdCDkCoOfm0KRyQoGuFOHMXHQh4SVPxJHhLUPUJ44gfDkT4VQaUJm9evxafv/xfzPv0QHk/EYyLOHI/zL7saf7jyzzCZzZ1SG2RIJYotBQJBTxECQgiIfufxsK3eDp8/xC2LnTweQgFu0VS3bOXVe0ihR33ZVmz54TPEyQPY2hQZyx02ZwG5R6BEko0FjkJMrvoA/7p0Mu/Pb8iELXsmgup4LPluCe644w4WJftEIkFWahIWvvg32NbPx/wv5yIUBlbUK3jYli8k4YiEYdzJUCVlY6ikAkfLN2F6sgdDVE2QSeXcVioNeuDXJiGoMvNtEgltjpVSnx36mp+hbtkcOSapDK6ksbsss9WwWiz4/MN38MF/X0VNVSUflk5v4IjEJX+8jkVFe0QiGOJiy0yzaP8UCASxIwSEEBD9AvrTq7F6sL3OBqlEyl0HXXZalHzJxYd0vaGxEWt//REmbxUcNDWzNQSJXAVZ1kgoU4uwIjQEP1UBMypfR4HOgdNOPRXGcWfBmXYkn6yDoSDPZ9lb5KErXnnlFYwfmotXbzkdyZJI/YLLL8HSGgXWNMkRCkugyhoO88QzoDQmYJxkB6aqtmNqghuFyhZAGUlpSEI++HWpLIIC2mROpfgMOXxsZISlr/6hvauEfCxcqZPhShoNkBAJBrF4wZd45bknsGPrZt5Gq9OzkLjyupu44PL3iEQIcR26NoQhlUAgiAYhIISA6BceDxUtThQ3OLnLgkyU9kTqtXKnhdzVBHdTBVat/A11lSXIj5NgZ2sYDR4l5BodtHnjAGMqvg2Nx47Nm3Cqcw4S1UFuscw77XaMP+3q9n2uWrUS11xzTczH+8gjj2DWrBM5evHqw7fihCwf4tWR4VktHimWVCuxtVWGxx9/EorMkXjn13LYrBYcId2MI1RlODLBhWyFFUFNAsISakkN8VjwsEwNnzEbjvRpCOhSI4WWtnIWEnJ3E+8/ErGYtmvqpwShUAjffT2fhcTWTZGOJXNCIq679S6cfdFlkMvlLCSoC8UdCMCkUXJqgyISwiJbIBDsDSEghIDo8x4PpU1OlDQ6+OSmU3X2eKDVeFzxHATtDahYswS/rtuKJE0YWoUEocTBiMsfg6U//ABz0Ti4VQmY65sAy4q5OFv9G7SKMBw+CT7aqcJ9T7+O8eMntO/3668X4p577on5mDkCsWs/JCKefupJZISqMT3dz6+n1+kx8uhTkHnsVTztk37HxVsb8MFvFQg7GjFNugHj1bWYEu9AqsLJ8zJAmRqJLCIkpAp4zIPgpPoHtZlTNermTdDXUKGlg1+XIheOjKMiQ8F2RXBISDz72AMo27mD78srHIRb73kQRx83i1M3oXCYDancPpq1QakNDbt5iqFdAoGgK4SAEAKiz+ILhHiEdUULjeLu2uOBpmWads5F5YafUL95ObbVu5FvlkJmSEbR5BOhL5qCpqpiLN1UilZpPD62DQd+eQuzE8uhkoVR75Lig2I1tOY0zP1yLmRSWc8jEBIJUpJTOu2HUiFr16yBpbEWQ9VNGG20QRoORn5HjihMRUCXxr/vVxtr8fHKShi9NZgm3YixmgZMNtuRIPdFhnKFQwjLFAhoKSKhhDtxJJxpRyCk0EES9EHTsAa6+t/4OuE15XPqg8yqCL/fj0/f+y9eevpRWFqa+T4ypbrroSeQnhmZwxHaNbSLJoDq1XJkxqmRYtTwZFCBQCBoQwgIISD6rMcDzbSotbq79XigmRZY8x62/fQFAtZ6VNpCGJSqR/Lwo5E2ZDw88cNRs/UXrCptQHUoHp/UZ8Cw8nWcmd7CUzTL7TJ8tFMNb1CCJ554AsfOOHa3/bfXQDQ07LuIclcxZ1f72ROpzwFd/Qpuz6QW07YTPQkBSk24fAF8sbYGc9ZWIc1fiakkJHTNmGC0IU4ZQkCdCIT9CMt1HGmgdk9q+6SOEbou8bugr/sFmsb1LDjo2Dzxw+BIn4KQMvJ3TgZVrz//NLtbBvx+qDVaXHvLnbjk6uugUERSRPRxp6FdDq+fIz/pJhojru4yCiQQCA4/bEJACAHR16CV79ZaG5ocPqQYurZiVtSsQOXcx+Hc+St8gSAcfilGjxiKtDEzETamwRVXhNKV32BzTStKQ6mw5J2C48O/oWHxi3A5HdhmkeGzEhUSk9Nw2+23dXvSb+/CIPby55+SkrrX/XQF1W3o6n6Fppk6KiI1Ej5THrdv+vXp7HXx+ZpqfLmuCgXBMkyWbsYYXQvGG20wKiUIquO46ySkNMGvTeYohDOtrfVTzs6b+pofobJEUhZhqZwnjrZ1bBAlO7bhobtuwapff+bbhYOH4f4n/41RY39P5dDHnv5PqE5Co5KxkEgxqWFUdzFvRCAQHDbYhIAQAqIvQV0BZBBFufjUbjwerL+8i51zHkWqxIImdxjxiUkYNn4a1MkF7I3gVidiy49forzFic2hHJjHnoGr85phrF7GJ8NNNg3W+HKRmJSMMWPH7pZu6E5E7OkDkZySgrPOOgvZWVlITEyMaj/dQSd6EhJtradtqY2IkMiExe3HJ6uq8M3GGhSFSjBJuhnjdS0YY7DBoJIhqNBDgiCC6gT4NckIqk3cSeKJHwJIpJA7a3mIGHWn8FsoV8GZMhGu5LGAVMHvydyP38O/Hr4XrZYWSKVSXHndLbj25jug3GN2jNMbQKvbB7VchhSTCmkmDRe1djUyXSAQDGxsQkAIAdFXaLR72Zra4w8huQuPh6DfhzVv3AZs+BS5JqDeI8fwkaOROmQSQko9HGlT4fb6sf7HuWhweLEuXIRRR8/GGeYS6Gp/5X1QmJ+KC9tSDtHSVsdATpT7Kxi6Q+ZphZZSGx0iElQ06UqdCK+pAM1OHz5ZXYVFG6sxNFyCidItGK9rxiiDHQalDCGFBpJwiKMRAU0y10xw66cxj/eltJWxkJC7G/k2tYc60o/gVA/5SVBNxBP334X5n3/Ejw8aOhyPPPsyBg8b2elYKc3S6vZDLpMgxaBGmknNg8ykXTiCCgSCgYkQEEJAHHLoz6qWPR7sfJtcEvekpnwnfvrXHzBSVoZErQQ+bSpGTTgC0vg8hBUaWHNPgquhFGt+/podKldLRuD4E2djmnQdtA1reB+OjKnsldDX4dRG/W9QN2+GJBTg+wKaBBY/HvMQNLkC+HhVFRZvqsbgcCkmSbdggq5xl5CQcnFlm/ggIUHGWCQkyAKbOzZatkJX+zNkXhtvR50cNBXUGxdp/Vz01Rd4+K5bWVDIFQpu+bzizzdBJussmDz+IEeLCLLHTo/T8P9fV9biAoFgYCEEhBAQh9zjodLi4oma3Xk8LPnyI9R8cDumZ/p5VHdc/mhkFY3kYsKgJh6teafCWvwL1q34nm2a1ygn4OzTzsBo58/c3kjYs46FO3nMASnudPoCfIJUyaVQyqS9NlNC6ndC07Aa2sZ17V0VFDVwJY+GO3E0Gj0SfLqqCos216AwVMY+EhO0DSwkjMowQB4SEikLCL8mCV5zEac2uJsjFICmaT1HZqSBiPU1m1WlU8QiB83NTXjobzdjydfz+bHJ06bj0edeRWJySpfH6g+GYHH5EAiF2eSLWkCpc0aYUgkEAxchIISAOGSQgVFpowMlTU72HdDvUd3v9XjwwsN3Iq/8fUzNkkNnMCBj5FFQJ2QhpDTwiY4iD41r5mPT2uXwB8PYZJiKP5x+EvKblkSKByVS2HJOgCdh2H4dJ0U1KGxPIodC9b5giFff3kCIH5dJJCx+esMzgVw16WSvbVjb7vPALZwJw7kosiGgxaerq/DNplrkhCpZSEzW1LCQiFMEOBVEBZTkOUFdG56E4e3jw3nGRsManrPRJlJ8hiz2mPDp0vDFR+/in/feAY/bxbUmjzzzMqYec1y3x0qeFhSRYHdLjQLpcWokGdSiBVQgGIAIASEExKHzeGi0o7LFBbNG1ekEU166E/+86Q+4JK0UQ5OkSErPRvLwaQiRqZJMwQWA5J9Q+dOH2LFlNYIhCUqTZuAPp8xEetUCzvdTXt+aezKvvHsCCYMWJ62qQzBqFJznp/A8CR36KERERERI1Ns8PBnUFwjz4+Sf0KkAdH8JBaG2bIO2flV7HQOlHLzGPH4/GqSpmLOuBl9trEFaoIZTG1PVZSwkEhR+SBHiokmvMZe7PGjqJ3dkKLSQBNw8fExD0Y5daRNvXAFHLLZXt+Cv113Rbol95XU34y9//Tu7WHZ7qNQC6vbD6QtCr5JxsWWyUcVCUSAQDAyEgBAC4qBDJ1waiFXb6uly9gLNcHjt/uvw9yP8yDIrkVM4DJrccdxlQKLAnjUDrvih2L74f6gq2YhAWIam7JNw/swjkVQ+Dwp7Fbs1WgtOg8+Y26NjpBZKijqQYMiJ13JYfm+pCvpo2L0BNNq8qLV54PCQ66SchccBrwcgC2t7OUcOlNbS9rtp9Lg7aTQaNIX4YlMT5q2rgdHXwEJiumoHxhjtSFZ4IQt5EZKpuGWUojhOnjoaGR8u9dmgq/0FGkr90MedPCTMg9FsHovHn3gKH739f/xak6YejSdffBPm+IR9HOquFlAPRW+kLCJo/DpFJ0TBpUDQvxECQgiIgwqdTKjTgk60NIq740mZ5ja89MxjWPnhU7j/GBVSE0zIGTwKSBnGBkg0MMqadwq8mhSsXfA6LDXF8Ifl8A2djdOmjkFC8Wdsa01tiq0FZ0aKBnsQGWlyeDkikpOg5ZVzrHl8EkjUMUHRFWpLpZkSlN7ojWmXMk8LtI1rIwWXu1IQ9Pu7E0aiyTgcX+5wsSmV1N2M8dJtmKncjPEGK1KVLiiCboRovoYpD564Ijgyj2Zny4iHRAt0NPXTsj3yQhIp3Ikj8OXaRtz519vhdjmRlpGJZ157B8NGjom6fsTq8UECSXvBpVmnFFNABYJ+ihAQQkAcNKwuP7bU2fgniYeOK3OH3Ya7bvwTtGWLcMsUJTIz0pFWMBI+cxHCcg2Cqji0Fp4FV1iJVfNehru5Er6wAroJF+KY0UWII/HgbkZIrkFr0WwEtF0X++0NOtm7/EFkxGlYPOxvuJ0KCykFUmVx8U8pJL12wuQ6ieZN0DSuhcxr3XWnhB0uW82jML9SiU/X1MDpsGKMdCdmyddgkqEZmUonVEFnREgYc+FKGgFH1sxdHhI09bOex4e3RTqolmKnNx5X3fU0thWXQKVS497HnsHp51wYk0gjLwmqlzBplfx+J+o7p7EEAkHfRggIISAOCrSqJ4Mojy/YyeOhrKQYN111IY41lOKS0Wrk5hfAlDUUXlMuIFVyF0Fr/mmwu334be5LCNnr4JeokHrU5Rifn4a44k+4JZEKKy1FZyOojo/p2OhERr4RWqUMBUn6iIHVAQyvt9VSVFtcaHSQkEDvrbzDIa7/4PSGrfz3Y1DHw5YwCt80J+GjtQ2os9gxRFLOQmK6oRY5CivUIQfCUhV8xiw2sbLlnsQpDhISlBbS1/wEhaOa9+f2h/DM+9/i5S9+gS8IXPqnv+CWux/ostVz38WpQehUMn7fybbcqJELYyqBoB8gBIQQEL1OndXDaYtQmLwCdvd4WLn8R/z1motx7Qg3ThqiReGgIVAmF8FnyOZ6B+oYsGXPRKPFgjVfvgSZpxlBmRb5M6/CkBQjRx6o3ZEiFCQeqLMgFtqcFSlVkZek61V7ZmpZpdRGTaubTbOI+F4M4XeZ3pAp4YofhmXuHLy73s7zRrIl9ZgpXY1T9MUoUFmgCTm5BdRHdtpZM2AtOKPD+PAytseWuxq5vuHn5b/gqfeW4LeaIKYddxIe+89r0Or0MR0n7cfpDcLm9fF7Qe2faXFqxGv3XnciEAgOLUJACAHRa9CfC9UBbG9wQCWTIk4bMThq48tPP8BT99yAf0yTYmphHAoHDUUooQABXTqvetn4KWUSKmprsWnBK1D6rQgrDRhx0rXIMkgQt/NzSAJe9jVoLZzNsyBiOTaKCgQRRn6CDlnx2oN2siIh0eKiiIQbDXZv70Yk6IMb9LKIIDFBttlteI05WBsqwH+3SrGq0gYzbDhGug7n6NZjqKoBOpA/hITfX2vOibAMvgAhmr8RDkPVup1TG7S/4m1b8MWX87F4p4eHdj375odITYu9/qStfoS6N4LhMBegUnojQa9k/w+BQNC3EAJCCIhegcLTZU1O7Gx0wKBScFtjG/Rn9OLTj+LL15/EQ8eqML4wCXkFg+E3F7KZEeXZbbmz4DUPxqbiUpQt+T8Or8u0Zow99c9IkrlgKvkSkpCfCyVbC85oHw4V7bFR26VBLUdRigFJhs7OlweDtohEJLXh5bZP8pjotaLCXd0b1Kqpspa0DwcLqkwoVgzCf0uM+K7EDkXYhymSTbhIuwLjVZXQSyLREntIhc3KUSjPPhcjJx7J3hdk1EVmVE3lW7Bg7qeobnZhvd2MPz/1AYaNGtvjQ21Lb1DhpVopZbvsZKNadG8IBH0IISCEgDjgUPHgzgYHyppdMGsVu60e/T4f7vvrX1D+4ye45yglxgzORnp2ATxxBQip47kIkkLm5FOwfN1mNC9/Gxq4oTElY9ypf4bJXw9T2ULO9VPRnzX/1Hbr5lg6JFKNKhSmGDqZVx0qIdHk9HJEglIbcqmU37fejIhIva3QNq6HunkjpAEP30etr7XqAnxYk4TPdvjhDwQwQlKKSxTfYYx3JZQBMrEKw+aV4tsGM9QnP4ijZp66y9VyAwJbF+KbT99BS3MTLH4Fjvzjkxh23AUxzx3pKs1EYoIEVpxWgbQ4Dac3RNGlQHBoEQJCCIgDijcQZFtq6jygegdqYWyDxmjfes2lUFcsxY2TVRg9tBAJaTnwGPM4NE6FftR+GVCZsPCXNQit/QBqiQ/mpEyMPuVa6G07YKj8jvdFXQK2nFlcJxEtEWOjAHITdMhN1PU5m2VadZMZFVl7Nzsi9QC04u7V1ErIz7MxyOWy3ZyKOmZUaZjfnIZXN0vgDsqQjkZchi8xPbQCmqATYYTg9EvhypsF3ckPIKhLidRZlC3D0lfvRmN1GaQyKSaceDHyT72ZC2EPhDCl/0OyK9ep5ByVSDSouEVWzN4QCA4+QkAIAXHAIKtnGohVZ/NwNX3HUDwNZrrx8nMxxLcel4xRY8yIIdAnZcNvyOIQOtknW/NPQ0CqwseLf4Kp+AsoJX6kZxVgyPFXQd+0lg2OCJppYc+cEdPKlk7MYYQ5ZUF59b5c5U9CgrpWqH6E6jQOipAIh7nDQtu4BqrWnRzhoY/7q+98gl/8BdieeToChnQYYcNVkvk4IfQjtEE76LydmJ7L9SqWIRdx2snvsuOTBy+FtHI55FIJjpw+A0OPOY8HelGKav8PNcwOlxSVYAtxikrsmgZKwkIgEBwchIAQAuKAQF/m2+rsfKImp8GOK8KaqgrcdNlszDCU46wRGowaMZznWfj1mTyGOxJNOAGeoAT/m/8dsmsXQiEJoKBoGPKmX8IjqClETjjTj+QWw2jFA1kqN9g9nEYZdAjrHfqNkKD0hs8GTeN6tKxbwHUNRCAkwXZ5EbamngJL/HCo4caVkgU4KbQUWfowtGoVgkodXElj2QHUmTgOzz12H+qW/hfj0qQYN3Eyphw1g/+vyR47SMWYBwCKStg9Abj9QWgUUv7/pahEr9aSCAQCRggIISD2G4vTx+KBRAQZRHWcAVFavB1/vfwMnJXZjFmDdRg+YgSUcekccaAZDDSLgQY3tbr9eGvu1xhm+Q5KaRjDR4xF0uRzYCr/FqrWYhYMPFEzaXRMJ5cGm4dPKINSDb3aonkwhcTBqJEgvlk4Hx88czcmJvuRpgu1318rTcOmxJmoSD4KWnhwiWwRzlKvRrrCBaVcgqDSAK95CGxZM/Dmoo3499NPYUaeHOfPHIejj50FiVTGrpZkoU0C8kBGwMgym76mqLaF/hapg4P+30XhpUBw4BECQgiI/YJW9yQefP4Qr/46pga2bd6AB/50Js7Lc2DGIAOGjhgFmSGZPR5IPNiyj4UncRT7IrzzxTyMc/0MlVyCMeOnwDjiFMSVReZaRIZinQSveVCMxZJetkumyENvTMk81DUSFOXpzZX2qlUrcc0113DhZKYuhAnJAQyLD3DagnDK4rApbip2pp8MbdiF82Tf40TlRmSpnNDKw+zNQU6Yv1T5cc/zn6DeHsQt507FxacdA6lUykWbNIODhnrF0kUTzftElulOnx8yaSRqQ2KCWmV1SlmfTl8JBP0JISCEgOgxdOKnmgeChk51ZOPa1XjmxrNwboEHUwuNGDxyPKTaOPiMeQgrdTzTgmYwbK2z4fN5czEpsBI6pRzjJk+HuvBoxO38AnJ3E3dYUJsm1UrEag6Vl6hHfpJuwIWyWUjs6tpoctBsCbCQONBFocFQEKeddhoaGhraWz71ihDGJwX4olWEodfpcdo5F+K71mT8tyIRsoADs6U/4ghFMfLUDhgUYYTUZpTbJPjw61/wU4UfuaOn4e/XnAONN1K0SZ03rtRJcFF0SXpgaxh+T3EEoJbLWETQQK84jejiEAj2FyEghICIGfozqGhxcbcFreypCr4jq1csx1t/Ow9nFvhwREEcCkdMgFRj4rZLcops3eVs+MvOJny36AtMwgY+AY6bcjxkGWNg3jkHUp8dIYUerYVnxlR4Z6UqfX8QBUk65CToBnTous2QioQcGVLR/wudGA9ktGXJd0twxx13RG50+PiTJhtmDuDx687AiMxIPQONN/+t1YB3KxIQ9Npwouw3DJHVoEhth0ktg9UdwLK121Ha4ofHPAQX/uXvMHqq282tgiojHOnTuBBzf1s/uzWp8vh5PLtGIUeCTslRMyrC7NgtJBAIokMICCEgYl79ljY5UNLo5GFTe/oorPjpe3zx4MU4MTeISQVm5I+YBKlKB68pD0FNIiyFZyGkisP8ddXY/NNcjJNuQ7pJg5FTT4EkLhtxpV+yuyS1dEa2jd6amsL7BNU7UFX+4RKqpo9lq8uPWqubDbJ8gTCLugPVkUAi4qmnnkJDfX37fSkpqbjt9ttw7DEzoHDWQtOwGmqqVQmHuHB1S6sMn1ab4XVacIR0C3KkDShQO6FAEKXF21BtDcJvzMDRs/8ImS4Rcnd9ux8FCUZ7xlHw0xyOXnq/qOiSIhMkJuhvmFqO4/VKft+EmBAIokMICCEgDohBFLHy5++x+NGLcHRmCBPy45E7cgokisi4aB6IVXAGgjI13v65FJZ1X2KktBQFiXoMnnYmoDTAVL4QCAVjdpekP0tagasVUgxONfarTosDCb0PVERYb/WwmCAXRxJ55Li5v2KK0hlr16xBU1MTEhMTMWbsWMj28OCIdG+s444ZEgP0ZVFhDWBRnQau1ibkS2uRKWlEqtyFusoyyHw2hLRJGHHs2ZCq43hcu8xn59HhBEWs7JlHs/DsLUjsuLxB9geh61qVHEl6JeJ1Kh7qJcSEQNA9QkAIAbHfBlHEmp+W4Md/XYIj0oIYnZeAvBFTIFFp4DPkwmsugjXvJPjDMjy3aAu0JQsxWFqJkRlxyJ58FqRhP/RVP0ReJ66Qt4VUEZMtNYWhh6Ya+acAXERIHSiU3nB4gzxplLoRDorhEptTbeGJoDRinSCHzVV1AbS2NvGMjUxJE6RuC5ob6pBtlGLI+KMQNGazjbkkFGCbcpquSqkMd8Jwbv08kB0bXR42D/Wi4kvq5ACLiUSdUkQmBIJuEAJCCIh9QitZmqbZlUEUse6nRfjtucsxPiWIYdkJyB85GVCb2OfBnTya2y8d3hAem78OefWLkCerx8S8RCROmA2lo4ZXrYQreSwcmdPbV6DRjOEm8ZBkVHHkoS/YUvc1KO9PJ+/qVjfXhyhlUj4ZHpTC0l2zN3i0uLWU77K6vCipbUSDxQZ/WIp0NMPl8cDvduH4cQWQKtQcgaLnyr0WhCUyBDSJCMtUcKVMgCtlfEzW5QcsMqGUsZCgSaH0/g2Erh6BYH8RAkIIiL1i32UQ1dSFQRSx6eevseb5qzA6KYjC9HgUjZ6EsDYBfl16u+lTvd2LR+euxnj7YuTILZhalArN6LOgad4UGerEkzePhit5XNTFc75AiAdQpcepB0ybZm9C6Sdq/axuJS8JP3duHMwToczdzC6X6uYtHF1wu11oqC5FZasX9rAaCbDBFpCjIDsLRQYPe0UENMk8SVThrEFYroVfm4KgJgGO9KnwxA/tlULLbsWEL8hRHbquUVA3h4IjcRTVIXFxuNTbCAQdEQJCCIhuaXX5sJUMotydDaKInSu+weoXrsKI+ACyUuIxZPQEhPRpCOhSYMueCU/iSBQ3OPDUlysxw/cdspQOHDU0C/Khp0BX9yvkroZdkzfJ46EopogIdR/kJGhQmGwYcG2avQmlfCy7OjdIFPoPcMHlvpAE3NA0rYe2YR2kfgeCzhY0lG5EmUMGp8wAOYJwy03ITzFjsNEHmVyGoMLE9RIqRyWbVPl1aVyU68iYfkBmbMRCeJeYoFQHFWCqFDLufEk0KHn8uF4pH9CdPwJBR4SAEAKiS+jkQuLB6w8iSb+7QRRRvXoRVj1/FYaa/UhONGP46AkIGrNYPLDHQ1wBfitrwcsLV+KU8FLkaH2YNjwPwfzjYKheFimgk2sibZq6tKiPy+EJwO71s78D+TyIIUr7UXDpDnAKiFJT5OKoV0UKLvcUir1CKAi1ZRu0Dasgd9ajpWQNCwmHPgsOmRk2aBGUaVCUYsTQeAnkSjXCkELhbuCZHVQfwVGu1IlwZBwVU7fOgYTELKU5qEaIfDioaJWKME0aJb+Xve0WKhAcSoSAEAKiE3VWcpe0cSHZngZRRPP6RfjthT9hkMGDuDgTRo6dgJA5n8VDaz6ZPmViwcZafLJ0Fc6Q/ogCE3DE8AL40yfDUP0DT20Mqs1oLTgrppkIFBHxBkMYlKxHVrxWhI0PECQeuE7C4uYuDrVcyqvpg1UnoXBUQduwGk2rv0Lpr/ORnGCCPy4HDZJE1IbNUMhkKErWY2iyBkqtHhKfE0pHFRSuBoQUWnY2pVkqZEZ1MOoj9pZWo8iEyx9gu3GdUs6RiThtREyINJtgoCEEhBAQ7dB/LxXbbau3Q8HzFjp/GTs3LsQvL/0FBTonNDoDxo2biGBiEQK6dLQWngWfJhFvLy/H8tVrcLpsOYYmKTBm6GD44wdBX7ucTxhtkzdjsS+miAgFG6hYMtV04GyPBbufANscLi2uQ1An4WnBjq9eRtlX/8bgRCnSsnLg1SRiszcZDTBDIyWDMD0GZyZCpY+H0l4FlbWYo1lhmRreuAK0DDoH3vjhB60+Ym8FvjQxlBww6VuTXC/p80SzOShKISy1BQMBISCEgGh3NSxvdqK40clfbvQltxvhMAJbv8byl29ErtoOqUqPiRPGI5Q8nCMOlsLZ8MoNePbbHagqXoeTpb9ibKYeg4qGIKhOgKZ5I+/GkzCc6yNovkVUxxUO8+qYvoAHpxq4cE1wcOokKBLVaPeww6RRRaOyD85J7+vP3sWCZ2/C+cPlOHpUDkxJ6aixB7DKkwEbNFBKgfxEHQpzsqGNS2bfCUqHUMElzddwJ45C89A/IHCQ6yP29jfs7lg3IZfBoJFzRxNFJuizJlJxgv6IEBBCQPAJo6SR3CUdHG7d0yCKxIN0x0Isf+12ZMosbAY1aeIEhNNGw2fK5VSELajAI19tQbh2PY6XrcaUPDPS84fSnw1UtnLejSNjKlwpk6JeHdJx1dnciNcpOfKwp2W24OAYUzXsqpNwHkQ/iQ//93947O+3YUaeDE9cMhFFqQY+AZfaZVjtJmtzCfxSJfISdMgvGg6dORmGqqVQW7YD4SAX55J3RMvQi9nVtK+11tLv4gmEIJdKoFeTE2akbkKYVwn6E0JAHOYCgtr7djTYeVR0vFbVOVwdDkFdvAC//vdeJAfr4AkrMHnyZEgyxkZMnwpOR60jjPvnbkSabS1mKDfjqMJExGUOhcxvYyOhSKfFrMiMgxiOiyZ9UvcHtWkerC4BQdfQCprSSAfTT+LV557E8089wqmUT568HscmNkPuaYbTF8Zmhw4lLhWkJHIkWuQmGpA1dDLijCa2Q1fayngfIZkK9uzjuVj3UBVa7uvvnLo6qA6Fvlx17akOFUcnRIuooC8jBMRhLCBoJbS93o6aVg93WnSa5hgKQl8yH6vf/yeMrnI4g3JMnDQJ8uxJ8CYO4xHb2xvdeOjLTRjtW4WpqlJMH5QETeogKFx1kAbcCCl07cOzDudR3APRT8Li9PN9vVUnQV83TzxwF979v5chl8vx4iuv4eQMK3R1K3hSqy2oxFq7AQ6HAwFI0QQTMhLjkT16BhLUYZh3fMp/hwSNFrfmzoIja2ZMhbsHkza/CRelOsKRVAe9t+w3oVHAoBItooK+hRAQh6mAoBUPGUTVd+MuSXbEpp1fYuMX/4ayZRvsfinGjZ8IdcGRcCePhT37OCwvteDpb7bgmNAKTNHVsXiQJRZwVT3ZEQe0SSweQkpjTMdF+ffcBB0KkvXC46EP18zQ/1NtxzoJtfKAFweGQiH8/ZZrMe+zj6BWa/DaB19gcq4exvKvobSVs5dIsyQBG5oBqbMWrrAa9TAjOTkNWeNOQHqwFqbSeZB7WiJpD30G1+CQyRl1AvVl2lMdwSB/DkhAJNP0UNEiKugjCAFxGAoIcpckj4cWpxcphs7uktRmadr5BXZ++wYCVWvh8AEjxkyAYcjRcKYdAWf6NMxdX4P/LduOk6W/4Ig4G6YWJgKGtPYVH6U3bLknxtRWR6FxmpJYeBiM4h5I0P8b1UmQmOgNPwm/34+br74Yy5Z8gzhzPP435xvkZaXDWLkY6patLCJo/Du1fZbUNUPlqIIVOtQiAfqUIhRNOA5Z1lXQ1/wEmbeVbbG9pnw406bAmTa5z9VIdBf5ISdM6uqQSaTtdROU7jhoLbcCwR4IAXGYCQh2l6y1w+bp2l1SEvAgbucc1C3/CNbty2H3AYXDRiNp1EyeU2FPnoA3firFt+tKcKbsJ0xJ9mN8bgKgNELms/I+nKmT4EyfGlMrHY3iDiOMQalGpB9Go7gHrp+EHxqFnEPwB6Lg0uVy4urzTsPGdauRkZ2Dd+YsQkJSMlSWbTBUfgep3wmZx8JdGI0eKWqrSqFy1aIVetQiEZLMiRg3ajQyGpay6JB5LQioE7kImLo2SBj39YjEni2iZGBFb61OKUeyUcUF0AdtzolAACEgDisBwe6StTZ4/CEOhe55kiabYcobW9d9hdoN38PlCyM1bwiyJ58GW87xaDUNw9OLtmNLSRnOkv2Io7MUGJpmQlimgDTo42JJKljzJFD3RXTQnxTNtKD6C2rTpHSKoH9DroxNVCdhoToJHxtBxWn3/8TW3NSIS888AZXlpRg2cgze+HgetDo9JH4XDFXfQd2yjbcLS2UIKo2wNlSiqXIbFO4mFhJVSEEgbwaOzjchuelXNqOSem3wGbMR0KbCnTicxW9I1TdrJLrrVKLIxJ5igsaRHyjxJhB0hxAQh4mA2Je7JH0Jm3d8At+2xShZtZir7nVJORh67Pmw5Z+COlUuHp6/Gbb6cpwl/xkz8g3ISdC2Pz9SLHl6TLbUHUdxD0k18ApKMHCglXKzk4SEm3/SqYxC7p2KdWOgorQEl5x1AizNTThy+nH4z5sfQKGItPdyNKJiCRfvks+IO34oR9ScJSvQWr0VUp8NtrAWJZJsyAqPxcwkO/TOUjakom4jSmuEFdpd48OPiIwT70e0iwlvgIUDpTlSjSqYtVSEKRdRPcEhPYcelLjYCy+8gNzcXKjVam4XXLFiRbfbvvXWW/yh6Hih5wl+hzRflcWFTbVWfn+6Eg9SnwPm7R8BJd+jfO33PP8C+lQMnnE+rIVnoRiZ+Osn6xBo2I6LVD/hlCFxyDEruN+eCGiT0TLkopjEA+V0yeMhyaDCyAyTEA8DECryozTZmKw4vtD/NRVekmikKEVPyM7Lx/Nvfgi1Roufly7GI/fcxn/jBLUJtwy7lIUAdRBpmjZCFnBDOvmPSDvmTzBmj4ZZEcIYbEX+jjcw99eNWOwZAmfCCI5CqOwVUNiroGlcj4RNb0Jf+T0L6/4CiQaKOlD3UoJOCX8ghG11DqysaMGaSgu34FKaSSA4FPR6BOLDDz/EpZdeipdffpnFw7PPPouPP/4Y27ZtQ3Iymcd0FhA33XQTP95+kBIJUlJSonq9gR6BoEr5ihYndjQ4oVXIuNhqT6j4zLz9YyiqlmPbb0vgcLpgk8Zh8hlXwz38Aqy26vHIV5uR79uB07UbMKMoASa5n22owxIZPPGDeQ4BpIqY2zQzzVoUJutFm+ZhAn19tDh9qLG60WD38t8nTbLsyf//0m8X4qarLuIujZvvuh9XXndzxxeCunkTDFXfc0EwFfLas45jC3VN7S/wrJ8DV0MJAsEAnGE11stHYWRBNkYYHJD77FzL41fFczSCnutKHgtX8viYrNf7mkU5FU57AkF2dCUhl2JQs2gXKQ7BgElhkGiYOHEinn/+eb5NXw5ZWVm44YYb8Le//a1LAXHzzTejtbW1R683kAUEhTNLyV2yycnOgV0ZMUm9Vo48aGpXYMean2CxWFDr02Dq2dciMPYyfFspwXOLt2MSNuJkQymmF8ZBE3YjqDQBUikc6eQsOTGmYkkKsdrcPp6kSRM1RSva4Qd9jbS6/Lwirrd7EAyGObURq5B4781X8Ng/7uTrT774JmaddtZuj0u9rTCVLYTCUcO3PfFDYM86lo4Amsof4Fv7EZzN1WwvbQ3rUKoejonZRmQaZJD5HQhJ5Txjg/6+aXIsDetyJY0GpPJ++75TlxMVuFJLq0kj3xWtULGwEAj6bQrD5/Nh1apVmDlz5u8vKJXy7eXLl3f7PDKRycnJYaFxxhlnYNOmTTjcofTA9nobihsd/MXcnXiI3/YBdLW/omLLKhYPJTY5xp58OXzjrsK7m7x4ZtFWHIffcHZCBWYWaKENOdmQJyxXsb8DfaHGIh6oA4Tys0PSjBx5EOLh8ISihGadEsPTjRifbUZGnAY2r59TWrGkNi664hpcfNW1fP2eW67FulW7pzupGNIy6Dz2fIBEyt0X8VveYU8IV94sBE9/EXFHXQNTXCLMUhfGeFegbvsKLN1ag0afAmG5hmspqO2T6ir0VUuRsOktjm5QzUR/fN/Jpj7VqEGiTgm3L4SN1Tb8VtaCHfV2WF3+9nSQQHCg6dUIRE1NDTIyMvDzzz9jypQp7fffcccdWLp0KX799ddOzyFhsWPHDowaNYoV0FNPPYUffviBRURmZudBOl6vly8d1RMJj4EUgaD0wI56B6/uunSX3LUyi9/6PnR1v6G2bBvKSkuwtTmM8SdfCuOsu/Dv5Y1YtqUKp0p/wQnpHoxPDNKChYdi8Rju/NMR1CREfUz0Z0NV+aQXBqUakGbSHODfWtCfob8P8pKosrh55gZ5OkdbbBkMBnHLH/+A7xctgDk+Ae988S2ycvM6bSd3kqHUAvaBINHrSDsSrlSKnkm5zkGz+UP4Ns2HzWFHKAw0wwi1KRn52VnQqjXw69Mg97RC6nfw/gKaJDgyjuI20P7+3lNLqM1D3TJSdr2kzyfVUAgfFkG/SWH0REB0ZTgzdOhQXHjhhXjooYc6PX7//ffjgQce6HT/QBEQ1DlBnRZ13blL7hIPCVvehbZuBSz1VdiyZTM2NYRQNO0MpJ73BP65uAo7K2twluwnnJAjxTCdjTssKPLgM+WxfXUsuWBKpdBMCzIWIlvqroo4BQKCvl5ojDgV/TbYvNy1QYPU9hWpIo+IK845GVs2rEN+0WC8PecbGIyd517QtE7q0lC3bOHbVBNBZmdt3RZSdxPUa9+Cq/hHON0uBMJSeKCGNiED2Vm5CMdlIqBNg6ZlEySByELEZ8xhIUGFxANh8UFCjr7kyaSKIkP0eRV1EoI+LyAohaHVavHJJ5/gzDPPbL//sssu4xqHL774Iqr9nHvuueyb//777x9WEQgqkiJravJ6oBBlVx96Fg+b3+ZZAi5rM9atW4d1dQHED52G/D++jvsWlMLdUoNzlD9jVp4SudJG+HWpLCAi5lCRUHBMA7FsHiQaVOzx0GlEuEDQBVRc2eLy8YA3MqaiwV37KvhrqKvFRacdh4a6Gm7vfP6tD/l7oCvUzZthqFzCBZZU20AigsRxG0rLdkhXvwlH5SZ4fR4Ew1L2OtElFyAlswCujCMh89mhbVrH3R4U0fDED+OaoJBSj/4OfW6pW4bEf4JeycXOFJkQQkLQZ2sglEolxo8fj8WLF7ffR0WUdLtjRGJf4cwNGzYgLa3rdkKVSsW/ZMfLQIByl5tqbFzhTuHHbsXDpv9CV/sL/G47NmzahNW1AYSShiL+4pdw6+fbIbGU4DLNMswulCFXUgefIZNTFtb8U+DMmBaTeKDVDEUe0s0ajMgwCfEgiBoKndMJa1RmHEZnxUGrkqHe7uYamu7WMMmpafj3G+/xvAxq73zqoXu63b8nYRhahlzMUQOqbYgr/hy66mXtdQ0+8yB4ZjwI03G3IC5zCBRyORRBD/y1m1C+djH8az6AzGdD86DzuQupresjYfNb/PmiOTL9GYpcUgSTUqA2dwDrKlv5QmKOxJ1A0GfbOCni8Morr2DSpEncxvnRRx9h69at3JpJLZ6U5nj00Ud5+wcffBBHHHEECgsLOUrx5JNPYs6cOVyMOWzYsMOiC4MsoLfU2eHxBbt0l2wrmEzc+H/Q1q9E2O/F2vUb8GOxFRZFCvJv/gLP/VSLwkAxZus34YRswBCw8CyLgCaRzaGCmsSYjqljp0Vekk5Y6wr2e0VM3hHlzS6OtFHrZ3fj3b9dMBe3/ulSvv73fz6N8y65svsdhwIwVP8ATcPayOsYMmHNPXm3KILM3QxdyQK0bv8RrqYKKMJertGAJh7m/LHwj/4D22cbqpa2d3tQSsSecVRkfP0AMG8iQzCKCJF2SDGqkGXWsrOoMKYS2PpKCqMNauEkIVBXV4cxY8bg3//+N7d3EscccwybTFH7JnHLLbfgs88+423NZjNHMB5++GGMHTs2qtfq7wKCvlS31tkQClHOsuvaAnLfS1z/KnT1K/kLc+PWYizeUItytwaJ18/BB5vsmCLZiNNNpTg21QUFyJGvAL64/JjrHQiyLvaFQihK1vMXjSjEEhwoKKpF9RFUbOkNhJCo67pI+LX//Av/eeIhyGQyvPTOZzhi2vS97pccLI3liyIpDYWW/+79xpzfN+AIwwaoSr5FXdlmSCxlUEgC8EEJjSkJ6jFnw1N4OlTWndDXLIPMa+On0eRPe9YxCGij86XpD34SlNqQSoHMOC2y4rWi/fMwx9bXBMTBpL8KCPpvoC6L7fV2yCVSbonrCjKJSlz/EnT1q3i8dnFVA+b+vB1bWiSQXPYhfmkAZkl/wylJjZhqbERYHQefPpMnFNKkwlhSFjzTwu6FYtdMC3IgFAh6Ayr0o/oIsmenYXBUaNkxbUd/i3ffdA3mf/4RjKY4vPflEnaw3Bs0iIvHfrsaI10aXXic0MAufeV38Fet4e4lk7sSQYkUQakKqtRBkB91KwKGDGjrV3OdkYRSGRIJW2M70qexMdVAgIq1aZKvQaNAXqKOP+uiPuLwxCYERP8SEG3uksUNTmi6cZdss6dOWvs8tA2rWTzUWr1475uV2NAkQfNZb6DWp8Spsl9wZpoFI1X18BuyeMVEBWWUvoiFjjMtBqcYuhU0AsGBom0IG6U1KI1HZmkd62y8Hg+uPO9UbFizEgWDhnBnht6wj894yM+TPckCu30kfc4JnaJwytadMFQsRmNdFRyV6xAXaIZDooFCqYZ02OmQj70YknAQ+upl7D3BxytXwZE2Fe6kUTEJ8z5tBub2szU21V3lJuj48y84vLAJAdF/BEQ07pIE9bUnr3kG2oZ1vAqy+FX437wfsapBih0z/wOZQoHZ8p9wVoYdOfImeOOKeH6ANf80BNXxMYc1Gx0eXoVQm2Z3xyQQ9Ab091drdbOQoJUxpfLa0hrUmXHhKTPQ2FCHY44/Cc++/i6b0+2VXekKY+V33GER8T05rVMdEA3p0tf8CFXDOpRVVUHTsI4UCDxQAqZMGCZdilDOVChcDSxK5K4Gfh4VbpIbpl+fjoFSn0K29NQpQ9GIDLNWRCMOI2xCQPQPAUEf1OIGO39Rxmu7t56lkdwpq/4FTeM6SIJ+uBTxeHv+MiyrkmD9tKeQpg3iHOVynJXWiniZm+19aVXEKy1ZbB4NtPqgvv3seA0KkvVQyUU+VHBooOJK+myQmFBIpZzWoCK/DWtW4YpzT4bP68Wfbrwdf/nr36Pan9xZB1PJPO62oHkYtpxZ8JqLOm1Hw7eM5d/Aa2tCY8kaqJw18EiU8Eq1kGVNQtL4M+CNHwpN80YWHG3+Ee7EEewfwW6XA+T9t3kCSI9TIz9JD71YSBwW2ISA6PsCgorHqN6BxiLTIJzuTtQSP4mHJ6Fp2gBp0AuPNh2ffrcS83cEsOaIRzFM3YJz1b/hlORmaFQKuM1D4MiaAVfKhJirxSkPTb76+Yk65CbqxKpD0CfSe5TWKG1ycstnm9D+8tMPcM/NEcvrp156Cyec+rvPzN6gSJ6pdD6U9kq+TSO+I7VBe/yth/zQ1/zM6UJLYx3cVevhDwTghwwWTS6yh06EcsjxCKgTWUS0pUjIg4JEhCdh+IDo1qBFDtVB6VQyXlCkGtWiU2OAYxMCom8LCFrlk0FU/V7cJdtCqim/PQpN82ZIAx54DTn4bl0J/rfagTUT/oEjlTtxnm4tjom3QKI18wqIUhZ+Q3ZMx9PRlroohWypxZeEoO8J7opmFypbXdxyScOinnnkXvzv1efZJ+LtL77B4GEjo9tZOAR91Q8sDtrrInJndRmtozZOY/nXkDrq0Fq2AS1WC6dEGhEHdXIhCodPgDf7GEgDLq6hkLsb29tHbVnHxWQP35ehTg3qkslL0CInUbRxD2RsQkD0XQFBU/NIPFDFc4qha4MoJuhF2q+PsEUviQePMRcbqhx45sdmbBx1C46XrsJ5ps0Yb7QjaMiAM2USrAWnIqQ0xl4saffApFagKEUvbKkFfZrmXdEIErxGlRR/vfpC/PzDEmRk5+D9ed8hzhx9vQ8ZRRkrvuW6iIAmgYfJ0bCuTrRFI+pXIdhSiqaaCtR5JGzLXS3Pxqi8dJgHHQlnygRoWjZDV7M80q0hlcGZMpEdX/vrtM9OnRouL0/7pMF5NMRLMPAQAqKPCgjyUyCPBzJlosgDtat1ScCHtBUPcbU31T+Qh0O1S4kHljRhc95FOEv2I86NK0aBwQ9fXAHs2cfBnnlMzF9SbEtt93AKZXCqUeQ4Bf2myJK6lipaXLBaLLjxgpNQVVGGKUfNwItvf8JeEdFCA7nidn7JA7Uo/RCJ4HUe2vd7bcTXUFrL4K3biq0WwBUAGmGGyZyIMQUZCOVO57ZpQ/VSqFp38vOoiNmWczx3RA0EAypacJANuejOGpgIAdEHBQTNj9haZ4c/EOITdrcpAoo8/PIw1JatbMnriSuERZqAe5bYsCNxOi6WfovTE6qRopezfW9r0exIvjVGIsWSPmTHa0WxpKDfRiOoe2nlqrW49ZLT4HG7cOV1N+Pmu+6PaT/UHm0q+QIKZz1HDWzZM7v9TJExFbVyamt/haJlG2otTqy3aWEPa+CTazEm04zs3EKuQ5L57dytQV4TBBU2s3dEjEZufY02fxi5XIIhqUbhDzPAEAKiDwkIentrrB5sr7NBKolUkndHyOeE4qtbYbAVQyMLQZI+CjZ1Bu790Y9K7SBcIf0Kx8a3wGw0sjGUZdB5PZoYKIolBQMFbyCIymYX3nrnPTxye6So8skX38Ss086KbUchP0xlC6Gy7OCbVITs2MusGIpCGEsXQNO8AX5bPVa36rHBE2kLTTfIMSkvAfLMMXAmT4CuYRUXQfPLKA0sUDoO+uqv0AIkEApx9DJd1E0NGISA6CMCoqNBlFohg6kbgyjih2+/gmbx3SjQ2KCVAVtapWiSpWJ16llwKky4DAsw3uyGKTEN1txZsOafHvNKps2oRy6ViGJJwYCh7e/61tv+indfex5qjRbvfLEIg4bGGJkLh6Gr/Rm62l/biyuteScB0q4/t5ReJLtsXfWPUNrKUOuWY25LBiqDiSiU1fHAucEZSTzpM6COh7FiMWTeVn4uRQ8p7djfoxG0GKECV6qfomim+D7p/wgB0QcEBOUKSxqdKG1ywLSXQUHED4u+RPDL2zA6MQCtLIytrXJUBhOwIetcmFUhnBlajCK9D+bsoWgecjFcXbWdRessqVFgUKphr5EQgaA/4nD7MOvEE/HzD98hMycPH8z/jm2vY0XdvAXGim+4uNKvS+Piym4tq8mkqmULTMWfQ9O8Cb5AAD/aU/GmZSyGySowROfEEfkJ0CWkw55xNFS2cmgbVvHzQgod1y/F6hLb16CaLvKMKEjSs/GUmJXTvxEC4hALCAqr7qh38JAgajej6EN3LPv6C/jn34kxiT6oZWEUW+WokKRja+aZKJTVY3pgOSTWagw95lw0j7oGPlNuzMfT0VmSIg+iWFIwUGloaMS48eNRXVWJI445AS+8+T4UPajvoYJJU8lc7oAKqkxoLTxrr46uNB2XRogbqr7nmoeqgBEPNE6DwyfDUbJNmJChxtA0I3yJw+E2D4Kx6gfIPC0DJhpBNVVkg12QpEN+ol6IiMPkHCqaeXvhg7SlxsaDgajTYm/i4edv58Lz5V9ZPCilYZTYZKhU5qMs+zQcrdiMY31LEWgsxZJKGb5Wndgj8UDHQ+Hd7AQthqWLTgvBwCY5OQlzPv8MKpUKv3z/DZ57+gkOsccKdWJYBl/A4kHmtcK87QMWFd0RUpnQMuxSNI24GgFNIjLlNryQ9i1OSLbizcBMvFcZj28218NDczbKFsCVOBLOlPEcSVQ3b0bClre5rqK/Qi2dZo2So67lzU5OKwkGPkJAHOB84MZqK+psHh5GszezFYmzDsGv78e4pCDkEqDSIUOlbhha0qfiFNkKDHaugaO+Am/v0OHxNTrUWtw9KnKyewIYnKLH4BSj6LQQHBZMmDABL7zwAl9/+/kn8O23i7iFOlYo4tAy+EJOY1AkIq74M6gs27t/gkQKZ8Y01E36Ozzxg6GED1doluHNQb9gtWIsXrJNxdubPNhc0Qh95VIoHVWwZR3Lszloyi7t37BrBHl/hBxCaZ5PcaODF1CCgY8QEAeIJoeXxQOJCBIPe+tsIE/+0OJ/YqjeCpkkjFqXDOWmcQgnDcJJshUw27aiqbYaD6/W471iLYJhCRITdx/8szdI/VO9A0GFXKLTQnC4cdVVV+Hqq6/mz8KTd16HejJ/srm5FigWqPbBMugcrlOgCbhkg00zafaG35DBIsKWfTxHGEb41uOr/M8xKjse7wZm4LmKXHy1pQXu5ioYK5fAp8+AO2EEP5e6NeK3vMMOmP0RqvXSKxXYXu9ATWvsix5B/0LUQOwn9PbVUptmvZ3qopCwa+BPd1AYNH7rO3BvXYLSkmK0+hUojpuAZL0ShahGsKUSxTUW3L9Ch7pQpAAsJSUVc7+cC5lUFqWzpJsLN4XRi+BwxuPx4KijjsLKlSsxZtw4vPDel7D5JfusS+qScAiGyiXQNK7nm9RG7Uw7cu/FzOEw9JVLkLDpTZ5jE1To8ZX5D3horRbwOXGsYiPOy7LyxNuwQgePeRBUlmL2j6D9OlMn84W8KfobtJDyB4MYnm5CsvCJ6FeIGoiD2KZJ+b7NNTbIpVIeO7w38UA5TvPW96Fp3ACFQgF7UImqhMkYqXehCJUINJVh6dZmXP+tArVBU/vzbrv9tqjEAxVvUvok1ajBqEyTEA+Cwxq1Wo1PPvkE8fHxWLt6Nd781wPITdBxas/m9se2M4kU9qzj4Ew/km9Sq6ehYhELi+6fI4Ej+zjUTnkQAU0SZH4HTmt8DR8dWY1BmSmY55+Au0tHYu4OL7xOG7QNaxBS6uEzZO1qKf0F5u0fQuaxoL9B3V7ke7Ot3s5iQjAwERGIHkI20KVRtmkSqtZirtJWN66HBGE4/GEsrJBguKIewVAQnoYKvPVbK97eJIU8PgMSiRRSmQyP/vOfOO64mVG1UtncPuQk6Hj0rlIutKFAQCxcuBAnn3wyRwvfeuu/OO70c1Dc4OBoXdI+RH9XqJs2RGZohMO7vCJO3qeNPNU4pKz6F8/fACRwpE/FO7LT8eryWgQDfkxT7cR1efXINas44uDTpUHuaoA06ENYqoA96xh4KM3Rz3wWKJUap1VwKjXmqI/gkCDaOHtZQLSN4qYcXzThUFXLVphK5kHTvJFXLNQzvboRyAtVwRaUobW2Cg9/24Ll1YAiPhMSecS45rHHHsPMmcfv83ioQMwXCqEoWY8ss1a0UAkEe3DffffhwQcfhEajwa+//oqM/MH8GaYR4RSxi7VGiBYExtKvuC6CIgbWgtO7nOa5G8EAEja/wYZS9D3gMRdhfe7V+OePNi48NMKB6zN24pQMNxdghxRahCVSyHyO36eG5hyPsFyD/kKIUrytbmTGa7mNVdRi9X2EgOhFAUHTNLfX2XkaYLJBtc+xtrxaKf+GzWmAEKw2B0qbXUiTNMOjiIPN6cOFL61ClQ2Qm1IhVeu45oHSFsfOOHafH07ypFcppJxHFZ70AkHXBINBjkJ88803KCoq4roImUrLkQiqYaLapVhXyAp7BeJ2zuWuCb8ulb0i9nlyD4dhLFuA+K3vQxL0IKBNQd2wK/FmaTw+Xl3Fn+kp+gb8rbAKqZpI+2lIpoI0SAWJUrbCJidavyEb/YXI0D4vd4PlJekP9eEI9oEQEL0kIKjTgkZxk7fCXqdp7kLTsAaGiiVQWYt5pdLS3ASr1QK9xA2fKgHSlOGYevv7aLE6cPLs8zHj5LO422LM2LH7rHlom4pHjpLUomnSdm+TLRAIgKamJowbNw6VlZU4++yz8fHHH8MfDPN4cKplMqgU0Ktj80mhjipKTdLgOx4JXjibT/L7QlO/GokbXoPc04SgKg6WwrOwQjkZT31bwidbtcSHe4bUY2ZcHaQIc8RCEg4gLFEAUimPCHeyI23/SFXSdya1lI/MNImFTh9HCIheEBA09pqKJaPptCC0dSugZ4/8ckiCXrTUVyDobOYvg4A2FfIRZ+Kk21/Djm1bMOGIqXj1/S8gl8ujTqE0O308y4IiD9R/LRAI9g2lL6gzw+/347nnnsONN97IxdDkGruj0QH5PgbedYXM3Qxz8Wdc50DGU5aic9hYal8oraVIXP8yVNZShBR6Ht5VnXMm/vNzI37Y0cjbTE/x4u6CMsSFrZCEg5AEPAhL5Zwu8evTYc09KarX6gtQqlUqk2BMVpwwtOvDiC6MXsDpCcDrD+2z04Krp2t+YvGgcNYiHAzAUr0DCmcdZAghYMqBbPrtuPW/v7F4SExOwRMvvBG1eKBiyRanlz3nyVlSiAeBIHomT56Mp556iq/ffvvtLCioZig7QYeR6SZa3HPhH6USoiWoSUDLoPN+d63c/nFUnRM0kbNh3M1wJY3hdIa+6ntkbX8Ldx+hwi0zB0GjkGFpvQrnrRqCFRiOsEzJ8zPI1ErmaYbCXo2Ere+0TxDt61BXGH2PljRGClgF/R8hIGJgnwXQ1Pdd/QO3eNGqJOR3w1G5DmpvIwKQwZs0CuFZj+G9n8ox95P3IZVK8cTz/8ciIloF7/IHMCTNyAWT+6q/EAgEnbnhhhtwzjnncBTivPPOQ3NzM99PfgWjMuJg1MhRa43NdIqiABYSEep4yHw2mLd/BJm7aZ/PC+jS0DTqGjjTKR0hg65hNeK3votT48rw3PmjUZish9Ubxg3LdXjGMg1uTRoLFRISCmcNpB4rTCVfQl/5HQ//6uskGVRcfE7vr6D/I85AB4pwGIbKxdDWr4LUZ0PY3Qpv2Qqo/a3wQglX1gyET3wSm2rd+Off/8pPuf72ezBhyrQodh3mFAqlO0ekm7hVU3RaCAQ9gyKIr7/+OgoLC1FRUYFLL70UoVDEz8G0q+WQ3GTJuZIG0UUL1T5QJII8H2igFkUi5K76qCIYzcMugz3jKK6HoKmexrKvMaRlMZ48czDOHJPB232w2Y2r1g1CiWkKQgoD/Lp0yCkS4ayFtn41e0bQUK++DC169CoFz8yggnRB/0YIiANBOARj+dfsUseV1dZaBMuXQxV0winRwjbkAoSPfxDWgBy3XXMZvF4Pph4zE1ddf8s+d02roFqbm30mRmaIAiSB4EBAOV4ymSKzqa+++gpPPPHEboOhqOUwO16LJqcHbl8wRuvrc+HXpXBhZdyOT6MSESGlEZYhF8KRPoXbQmlEuKZ+FZKLP8KfJsThvlOHwaiWY2ezG1cuBr5UngSfMRt+fQZCcjVUrTvYqI5SGsrWnejrJlNUx0U+OlQMLui/CAGxv4SC3A9OE/WonSvYuAPSql+gDLthlRphHXc9JNNu4VasB++8GeWlO5GSloF/PvcKpzD2Bq1+SDy0OUvGaYWzpEBwoBg9ejSef/55vn7PPffghx9+aH+MjNgGpxpRkKhHq9vHtUfRQmO5WwvP5iJHqlcw7/iEuzX2/TwNWovOgTtlPLzmwVBbS6Bq3Yn4be/hSLMV/75gLEakG+H2B/HId3V4pGoMWjJmcCuoz5gDla0UClsF4ornQF/1w95dMg8xZOBFaYxqMS+jXyMExP7Aw3XmQW3ZztXRgdr1kNWsgjLkQ5MkEY6p90A27lJ2lvvo7Tew8MvPuFjyyRffgDk+Iaox3LkJEQMWWhUJBIIDy5VXXtmewrjwwgvR0NDQ/hiZHhUk6zE41QCnL8CmU7GJiLNYREgCXpiLP41ORMhU3NLpThwJd/wwrnOQO2oRt3MOshxr8fAZI3D+hCxQAnPh5npc9z2wKf0c+OIK4DEP4aiH2rIVupqfOfoh8ffNqZhymZQnd5Y1OYXVdT9GCIieEvKziQytEKReG3zVayFv2ABF2I86WTq8xz4E6dBTufJyy8Z1eOKBu/hpN/3tPoyZMHmvu6YPlM0TwKAUPQalGIUttUDQi/UQL774IoYOHYqamhpccskl7fUQbY9TzdHwdCOC4TCaHd6o901iICIiMiIigiMRtft+olSB1oIz4EkcDo95KBdlylxN0Ff/hPjy+bhkYhruP304pwLIw+Ivn5dinuQYOLKOYbfKgDaZ6yhoamjC1neje81DgEGtgDcQQkWzi1tpBf0PcWbqAZSqoDAh9XFTAZOreiOUzVsgDwdRq8wGTngYyD+Gt3XYbbj92svh9/kwfeaJuPRPf9mnWVUgFOIWTWrVFNavAkHvotPp2FSKbK7JqfLRRx/ttA0VVdJkSZlMggabhwubYxIRhkz+3jDviC4SQVFLa94pLCJ8xlxIEITc08Itm+ZtH2JCigTPnT+GhQ2lNB77ejv+s8OMxkEXwhM/FJ74IVDZK6BuXMeul+qmyBTRvgaNAqBiVfreE/Q/hICIEUpVxBV/BiXlJ63FaK0thbp1G5nMok6VD/nxDyKQNYW3pS+ZB+64CZXlpUjLyMTDT7/UrYcE9Z1T/zlFG6gKPCNOE/OQH4FA0DOGDx/OkQjiH//4B5YuXdplCyJ1QWlVMnaBjdYrgvwbWgvO/F1EFEdXWEltV7acE+BOHIGAJhkhmZLNquTuRhYFqeF6PHLmSMweG+nSmLO2BncurMWOjNlwZBwFV+IoSEN+aBrX8oLHQDM4+lirJ33f0STjsmZnTB0vgr6BEBAxIA1GxIOqZRs0zZvR0FAHjTVi4tKkLYBy5t3wZvyenqC6h6/nfc51D0+8+CZMZnP3nRZWN7eQkdUrmVUJBIKDy+WXX47LLrusvR6ivr6+SzOk4RkmTh/UWT1Re0VERMQZ7emMSHfG7/UWex0jnn083Emj2a2SB3aFAlzrYN7xGfRNa3HFkbm4+6Qh0Cpl2Fxrw80fb8ByyWhYBp8HV/J4biullIahbCGnUfpaXYRZq0SL0ye8IfohQkBEicTvRnrpZ9A0rOUipdomC9T2coQggV1fCNXUG+EmM5hdUN3Dkw/ezddvvut+jB43scv9kuqmEB6FSGl1Q4VFAoHg0PDCCy9g2LBhqK2t7VQP0QZ9RimdkWhQ8mc3ehFB6Ywz4delcXcGiYhozKaojsqedSxcyeNYiJCoCNHQrnAIhsrvYKhYhCl5cXjmvDFcdN3q9uPvczbg0xIZmoZeAkfmdHjiBkFlr4S+cgnit/w3OvFykKA0Lc0hqWhxxdTtIjj0CAERDV4H9JvfRXzjr9xrXdlkh3TXB9Bnyodi8pVw5BzXblVJdQ9//fMV8Hm9XPdwyR+v73K31F9OfebUb06dFsKWWiA49PUQH330EddDLFq0CI899ljX26nkGJYW8WWpi8G1sr0mQpe6K4rwCWSeln0/USJhIeBKmcACgp5LQoTu1zRt5NqKDF0YT54zGscMSgIdzmvLSvGv7ypQn3UyWovOhitpNGR+FwzVPyFh4+t9yi/CqFHA6Q2gssUZdX2J4NAjBEQ0rH0X2oqlULgbUd7sgNfthAxBSMy5kI85F7bck9rFA/3xP/i3W1BRVrLXugeHJ8D95QVJ1CYmOi0Egr5UD0GRCOLee+/FsmXLutyOBD8J/7S4iGslja2OvsVzNndLSP0uPvlLva3RiQiqbSARQa6OzlqOLITlKigc1Yjf+h70/hbcevwg/PGoPFD99ffbG3HnZxtQqh6C5hFXstslGU9pG9YiccMrbFbFEwL7SEFldauH0xmC/oE4a0WDRIaQ14FyixfNXkAn9UCTkAXZkJNgLZwNSH/3aPj0/f9h4dxPI3UPL7zRZd0D9ZM7/QHuLycBITotBIK+Vw/RlsKgeggaBd4VaoUMQ9IMSI/TcGFlLCLCUnQ2jwCnwkiKRNDPaEUEjfPm17dsY78IssCOzOD4EGrrTpw+OoM9I6hWo6TJiVs/Wos1LSq0DL8Mrfmns3ihKaCJG1+HofybPmE6Re8lTS6vsrhFW2c/QQiIKLCqUrCqSYYqvw6JUgfi4tMgyZ0Gy5CLIkVNu9i+ZSMe/8edfP2GO/+B0eMjH/KOULsS9ZNT+xX1l4tOC4Gg7/pDDBkyBNXV1bvNy9gTlVyGIalGZJm1aLB7YxARGnas5JO/1xYREX5nNAcHZ/pUONMiBdvahjUsIsjamro8TDvnQlv3K1vfU10EDeSyewK4d+4mfLWlBbb809A0/AqeBip3N3PkIn7Lu5AED30rJY1Sb7R70RKDaZfg0CEERBQ8t6wOVV41MmWtSElIhCR9NFqGX8ET8dpwOR24/c9X8JyLaTOOx2V7+D2Ed7VpKna1aVLRpEAg6Lvo9Xquh6B5GQsWLGgfA94VEetrA7LjNTz4LloREVLqYRl0DoJKI48Aj9vxGbeKRyUi0o5sFxH62p/hNeTCnTwmcrv6J57Pk6ST4bHZI3F0URLXabz4/U689EMJ7Ilj0TDmRu7ukAa9MJbOR+K6l6ITML1I24ThahGF6BcIAREFl5wwBblqJ9LNekgTC9A06k8IqndPTTzy99tRtnMHklPS8MizL+8254L6xetsHujVcoyk6m3RpikQ9AtGjhyJf//73+3zMpYvX77Xk19RCokIikR4ovY1oEFaNAODFiTk8RBX/DlHEqIWEbvSGYbqHxBQxcOeTQXdUp7PQ/UV6rAXt58wCJdOyWEL7K821OK+uZvQokhBw9ibYMs6lrfX1/yM5JVPQua24FBHISiS0yxqIfo8QkBEQV7lZxiXJEVYl4TGkdcgQNXPHfji4/fw5ScfsGh47PnXd5tz0ebxQB8KSluQ14NAIOg/XH311bjgggsQCAT4p8ViiUpENDqiFxFBdRzXRFCBIxVHmkrmst9D1OmM1EibuKFyCf+kdtH24spt7/HY73PHZ+HvpwyFRiHD+mor/vrJelS5ZGgecRUsRedyOpb8IlJXPAi5vQqHCnoP6cRUbREW130dISCiIe9oBIyZqCi6HD5z4W4PlRZvxyP33M7Xr7vtbkw4Ymr7YxTGpOrsVKOa+8bJ+10gEPS/eohXXnkFBQUFqKio4AFce2s1pBPgIBIRCREREW06I6hJ5O4M8npQ2ipgKv0quuJGFhHT2rszyHFS6rOhZfCF7fUV8ds+gNJWhkl5CXj87FEcBaVJmLd/sg6b6hywFp6JxtF/5iiI0l6F9F8ehLJlKw4VZNjV6PCJKEQfRwiIaMg/BpYpd8GaOHa3uz1uN27/8+XwuF2YPG06rrr+lvbH6EuDwnBUnT1EeDwIBP0ao9GIDz/8EAqFAnPmzGlv89zbtMlByW3pjOgLKwO6VLQWnI6wVA5VazGM5Yuia7Pco8XTWLEYCmcdWoZc2G6hTXbWNGCLZuw8fe5oFO0qrvz7nI34bnsjnOlHom7S3QhoEiHzWpC24lGo61fjUCCiEP0DISCiJKhL7XTfkw/egx1bNyM+MQmPPvcqZLKISPAGgmi0k0GUhvvEuT1JIBD0a8aPH99eSHnbbbdh9erV+xQRlM7INGtiEhF+QzZseSfvqmPYBH3V0phEBBdShsNcREmRDEvhbHgShkWcKysWQ1/1A8xaOf551kgcWZCAQCiMpxdtx4crK+GJK0LNlAfg12dCGnAhddW/oKv6EYcuCuFFk/PQd4cIukYIiB7yzbw5+PidNzi8SeIhMTmF7/f4g9yqSS2aFMZsqyoWCAT9nxtuuAFnnHEGfD4fzj//fNjte/duaEtnRERE9OkMGstNg7QIbcNqaOtWRHeAZHudOQPuxJEsIkxlC9jvwZYzC470SHpVW78SppJ5UMtCuPPEITh7XGQY1zu/lOOlpTvhUyeh5sgH+RgkIR+S1z0PQ+kCHJIohESCGtGR0WcRZ7ceUFVehvvvuJGvX3X9rZhy9Ay+7vIF0Oz0sjkUrTxoBSIQCAYOtGB44403kJWVheLiYlx77bX7tF6mFk8SEZTOJBERiFJEUNTAnhX5btHX/MTphygPEvbsme1RB1PZV1z/4EqbDGveye3pEfP2jyEPuHD5kXm45uh87tBYsLEOjy3cArdUi9oj7oc7cRQQDiJx05uI2/4xDjZxGiWaHD6e7yHoe4gzXIz4fT7ccf2VPO9i7MQjcN1td7WLB6vbj6Jk4S4pEAxk4uPj8cEHH3DK8r333sObb765z+e0+USQ/wv5wUQ7O8OdPBbOtCPaOyxU0RY2SiQcwfDED+YR3qaSL6GwV8IbP4TnYtAwLqqRMG/7gGdxnDoqnaMRCpkEv5S0cF2E1S/lmghH+pHkZAPz9o9g3vIeDib0voUR5nkjgsNUQFDBUW5uLhuyTJ48GStW7D0c9/HHH7MDHG1PfdhfffUV+grPPfYANq5bDaMpDo/95zW2rKYhMCQeBqXokZ+kg1SIB4FgQHPkkUfioYce4ut/+ctfsHnz5n0+hxwrSUSkmtSojWGKpzNtSntdg6lsIZTW0ugOUiKFLedEeOMKIAkFELfzC8idtTxS3DL4gl0dGlbEb3ufxcXUwkQ8dMYI6FQybK2z467PN6DZFUDjmF1eERQR2Pk54je/fVDnZ9D0U6ohsXtEFOKwExBUuXzrrbfivvvu46Kj0aNHY9asWWho6Hqc7M8//8ze81dddRXWrFmDM888ky8bN27EoebXpd/if69Fqq8fevpFpGVk8fhZuzciHoQ1tUBw+HDnnXfi+OOPh9vt5noI+rkvqKCahuclG1Tc4k0mc9HWNXjih0RSEiXzoHDURHeQUhmseae021yTSZXc1chGeC2DL+CJnpKAF+biz6Bq2cbt5o/PHsW+NTRe+87P1qPO7kPzqGthyz6ed0keFQmb3zpoIkKrlMPjD6HBJoop+xqScC/PTqWIw8SJE/H888/zbfKTp/whFSP97W9/67Q9fRCdTifmzZvXft8RRxyBMWPG4OWXX97n69lsNphMJlitVm69OlD8vG4bTjpmCmytFlx05TX42wOP80RNhy/A4oHatYR4EAgOL+rr63lRRD//9Kc/sV9ENFDKc1ONjSdPphnV0X13hIKIK5nLEQgyibIUnYeANimq14uIh89YeJDXg2XQeRE33ZCfoxoqyw7eLjIyfDw75/7ji42otXoQr1XiwTOGIydei4RNb8JYFimotOXOQvPwq9onEfcmFH0gsTUhN150tfUysZxDezUCQZXKq1atwsyZM39/QamUb3dnCUv3d9yeoIjF3ixkextyoLvlz1exeBg6cjRuvftBFg9OXwCDhXgQCA5bUlJS8M477/Dn/9VXX+WIa7SramrxpmmZFJ6Pah0nlaE1/1T49ekcNaBoQlRjwKmCQaZEa8GZLDho3kUcjRD32QCpgiMUruSIxw21jNIl1aDCY7NHITdBy4Ot/vbZBmyrd6B5+BW8PSCBsewbxG85OOkMvUrO0V7qcBP0HXpVQNAI3GAwyB+yjtDturq6Lp9D98eyvdfrZcXU8XKgoVzniuU/QavT48kX3oQvLIuIh1Q9soR4EAgOa2jBc/fdd/P1P/7xjygpKYn6pEgiQquUsd9BVEgVESGgSYTU74B5x2dRD8DiEeI0/VMdz6O/eeZGwM21Eo7MY+DIPJq309av4uFa8Rope0UMTjHwyfveLzZiS50dLcMugzX/lF3pjHmI2/5Rr4sI+o7VKuQ86jvaVlhB79PvuzAeffRRDre0XSg9cqBRqVQcObnxvicQn57dnrbINAvxIBAIgPvvvx9Tp05lXwhKw1L0NRooAkEigroNmqMUESQEyPI6qDJC5m3l1ERUEzzpuQotLEWzEVIaeJR3++AuiYRdLKnNkyIdast2fsyoCHFh5agME9z+IA/h2lRrQ8vQS2HnwsowzMWfR2Z39DJGjQJWl4/TPoLDQEAkJiZyqxPlBztCt1NTOzs7EnR/LNvfddddnKtpu1RWVuJAQ6uLb35aiSOPPwOOXQWTIvIgEAjaoG4sauk0m81YuXIlfy/F4rg4JNVIWQFYXL6ox4C3Fu6a4Olq5NoIqmeI7rlGdqeMDO6q4xbPtsFd1OZpKTgzMo/DXsleEVqJF/eeOgxjsuLaRcSGaiuaRv4RjvRp7BNBszYMZQvRm1BrvEImQ22rMJbqK/SqgFAqlWz/unjx4vb7qIiSbk+ZMqXL59D9HbcnFi1a1O32FB2gQo+Ol94gv6AIKsWuITlCPAgEgj3Izs7GW2+9xdeffvppzJ8/P+rnJhlULCL8oRBsUZom0QTP1sKz+GSvsFdFP3yLB3cltD9XaSuHkU7+u57rN+bAwuPFtZC7GlgcaEN2nuQ5NisO3kAI98/bjHU1djSOuQ6ulIksQBI2/w+6qmXoTeK0CjaWorZ5wWGQwqAWztdeew3//e9/sWXLFvz5z3/mLosrrriCH7/00kt3U+s33XQTFi5ciH/961/YunUrhwZJ0VOv9aFEo5RjSKoQDwKBoHtOP/103HhjxKX2sssuQ1VV9GOxyR+C6g1c/iB7y0RDQJuM1oIzdrlL7ox++BYP7kqDNf/U9pSFoer79ufSUC/LoPPb0yTx2z6CzteCv58yDONzzDym/MF5m7Gx1oWGsTeydbYk5EfixtehbtrYq/bW1I1BZlyCw0BAUD6QBtD84x//4FbMtWvXskBoK5Sk8bi1tbW7GbRQKJAqmqk96pNPPuHpdyNGjMChhD7c2cLnQSAQ7IMnnngC48aNQ3NzMy666CLu4oqWjDgNipJ1sLp9PFcnGvyGrF3DtySR4VvV0UcBfMZcWHNO5OuahrXQ1v/W/hi1eVoGXdBesBm342NovQ245+ShmNBBRGxt8qNh7C3wGnN5AFfymn9DYatAb0F1I/V2T9QiS9CPfSAONr3lAyEQCATRQnMySERQUeW9996LBx98MOrnUn5/Z6MDJU0OJOrUXGAZDbTyN5Z/w9d5tHfqxKhfkzoveOon+zucGJmjsQsq0KSCSoWzdlc76BlwajLwwLxNWF9lZefKf545EoO0TqT98gDk7kZ2u6ydfC+nSnqDaqsLQ1ONbN4nGKA+EAKBQHA4UlhY2G4q9fDDD2PJkiVRP5es8PMSdVyoTe2dUQ/fShzR3opJUYhYUglkHkVdGASJEBq+tVvXR9HZ8Bmy2t0s9c5y/P3kYRiaaoDTG+QWzxKvAfXjbuEOD4WjGsmrn4m6xTRWdAo5als9HAURHDqEgBAIBIJegCz5r776ajaJuvjiizt1l+0NmuRbmEQTPNUxDd8iEdAuBCoW8dTNaKGoRUe7bLnr9+PlyEPhWbvN1YhzFuO+04ajMEkPmyeAe+dsRIU0Cw2jrkVIpobasg2J619t7/A4kBjUClg9ftHSeYgRAkIgEAh6ieeeew7Dhw9nIzwqGKcutGhpGwOeZFSxiIg220xCwJ04ggsijaVfcYdG9BM8Z3WYmzEn4lbZhlQOa96pkQmfJDJKv0K8sxgPnB6xuSbHyvvmbkSdaSxahlyIsEQOXd0vHLHolZZOqRS1VtHSeSgRAkIgEAh6Ca1Wi48++ggajQbffPMNHn/88ZieT3MfqL3TpI1YXkcFDd/KntkhWjCH2zGjHr6VfxoCml2W18Vzdjepkspgyz2pXaCYyhYg2RURETQgrMbqwYPzNqEx43g4smbwNhSt0NTtfQJzT1s6m0VL5yFFCAiBQCDoRYYNG9Y+TJAKKn/66aeYnq8jy+tUI9RKWfSzICRSdpX0GzLb6xZknmjnZqjQWngGQgo95O6mXUZTHTpCJFLYs4/n1k2OcpQvRIY3IiIMKjm21zvw+Nfb0TDkEnjih0IS9CJp4//xyPADiWjpPPQIASEQCAS9DPneUB0EzQa64IILuMUzFigCQT400hjcKnluRv7pvw/QKv406qJGcqtsLfzdkZLqKXbzl9gV5XAnjd4lIr5BYbAE/zh1GKdeVpZb8PyyKtSPvh5+bQpknhYkrX0BUp8dBxLR0nloEQJCIBAIehnyj3nppZdQVFTE5lKXX3551DUNbSTqVRi8y62SpgHHNjfDBJnXGtPcDDKpopoHijiomzdDV/vLnr8Uz8NwJ49pFxFjlJW4Y9ZgFjqLttTj3U0eNI6+FiG5FirrTiRs/L/doxn7CU01JXttMaXz0CAEhEAgEBwEDAYD10OQ/f68efPw7LPP9sjQrihJD7vXD7cvuhMxzctoLTx7j7kZ0QkQnykXtmwamgXoapdD3byls4jInNE+DpxExNGmJvx5eiHffm9FBRZbUmEZfAEXVeprf4GBohkHEL1SIVo6DxFCQAgEAsFBgtx4aU4Gceedd2LFitiLC8kfIj9Jx10P0Z40I3MzzuzR3AxP4qgOraHfdO7qkEh4HLg7aVR7YeUZGXacOSadH37m2+1YrZ0KZ9oUHrxl3v4RFNbffSb2F4Najla3aOk8FAgBIRAIBAcRmgd0zjnnwO/3s9V/a2t0xY0d0yF5iXrkJGhiMpoKaFM6zM0ohqHi26jnZlBrqNdcxOkHKqrsVJDJ6YzjIg6W1OJZ9hX+NBwYlx2xvH5kwVYU513ERZ0ynx1JG16BxO/CgUAqkUAll6K61SVaOg8yQkAIBALBQYQEwOuvv468vDyUlZXhyiuvjLkegnwQCnpgNNVxboamaSN0NT9Ge9Cw5p4Ivy4V0oAbcTs/71xLwT4SJ8BjHsRCI75sHu49UotMs4YnaD70bTVqhlwZqYdo3Yn4re9HLWCiKaa0OP3RF5gKDghCQAgEAsFBhmYNUD2EQqHA559/3t7mGQu7GU3Zozea8sYVwpY9k6/r6n6Dtn5ldC8oVcBacAaCSiNkHkvn9k5CImWfiDYPirSq+Xjo2ERu79xWb8dT65VozTuFxYah6jto9yzM3I+WzjBES+fBRggIgUAgOARMmDCBJxUTt912G1aujPJEvofRFHVm0Aq8MVqjKa5rGAlHxjS+rq/6gbssoi/I/L2901C5uHMUgcyo8k5pn50xpHEh/jEznTszvtvWiI+9k+FOGMH+EAlb3o7e5GofGNURsy27RxhLHSyEgBAIBIJDxA033ICzzjqL6yHOO++8mOshCL1Kzh4RSoU0pkJCV8rE3Qdote6M6nlBTSILhLY0iLZhdeeNyPaaHC13eVBMdX6Lqycl80Mv/ViF31IuQFCdwJM747e8E3VB575aOj2+IJpiEFKC/UMICIFAIDiE9RBvvPEGcnNzUVpa2j58K1bitEoMTjEgFA7BFq21M3VP0ACthOG7ZlvMj3puhs+UB3vmdL6ur/4BSmtJ1x4UBWchqDJC5m3FpfoVmJanRyAUxv0/tKI6dza3dlIKRVcTmztnd+jVCrbT9gYOnNeEoHuEgBAIBIJDSFxcHD788EOuh/j00097VA9BJBvVKEoxwOUPwuWL0pmRCx+P79HcDHfS2HY7a2oLlbmbOm0TUuojHhRyDRSuBtyXvwNpBiWnGh7YkgpX0ihIQn7Eb/sIMnds7pzdtXQ6vH6ekSHofYSAEAgEgkPMpEmT8OSTT7bXQ/z222892k9GnAb5iTr2RYh6Fd7TuRm7nCjbah1IfHTVmhlUm3kUeFiqgNFViafHNUIhA34tt+HtwEx+XO6q29WVEdr/lk6ZDNWt7qjbWwU9RwgIgUAg6APceOONmD17NtdDnHvuubBYLD1KieQm6pAdH2mdjPok2tXcDJ8j6umdQVUcZF4b4krndWlVHdClwpZ3EouOfN823Dc20i3x4hovNsafgLBExqO/tbX7P7WT0jkWp08YSx0EhIAQCASCPlQPkZ+fj/Ly8h7Ny2jziChM3uURYfdG7RHx+9yMuF1zM7rweujueWRQtcvl0lC5pEt/B2ofdaRHOj9mKjbgvDwf6NDu2JAOR1xkamf89g+5RXR/oN+fLjWtbmEs1csIASEQCAR9yB/i448/hlKpxNy5c9ttr3vii0AeEYl6qjeI3iOC2jQtRbMjczPcjZyWQGjfRZlBTUKHzowN0DSt73I76vpwJ46ABGH8JWUjBus9qLaH8B/bUSxcFI5qmIrn7LfBlFmr5AiMMJbqXYSAEAgEgj7EuHHj2gdt0byMn3/+uUf7iXhEGNgfgSyvoyWkorkZsxGWq6Bw1CCupOu0RFedGW0RBkPld1DYKzpvtMvymuotVJIAHi3aCg28eG+nEqvUR0YMpqqXsdX2/kACiqi1Ri+eBLEjBIRAIBD0Ma699lpccMEFCAaD7A/R2NjYo/0Y1AoMSjVALpPEtBqnWghqwaTCR6W1FMbyr6OKClCEwRM/NNIWWjIfUm8XxZhSGVp31U1kqH34R8FOSBDCXVtzYVNnQOq388CtaCIfe4PMtSj6YnNH2ZEiiBkhIAQCgaAP1kO8+uqrGDx4MKqrq3HxxRezmOgJ8TryiDDCFwzB4Yn+ZOrXp3OBJHVpqFu2svX0PkUEt4XOhF+XEpmZwXbXnYVAWK7hfZNAOSbJjrPNpaj3KvBS8ziEZCp2xtTX9Czy0jEC4w+EUWdz79d+BN0jBIRAIBD0QQwGA/tCaLVaLFq0CA899FCP95VqUqMoWQ+71w+PP3oh4jPlwpob6Z7QNKyFrvbn6GZm5J+OkEILuasRxvJFXQoPinLYs2dy6+U1uXUYLK/Dew1Z2BTKhSTkg6lkbtcRjBiI0ypQZ/XA4RVRiN5ACAiBQCDoowwfPhwvv/wyX3/wwQfx9ddf93hfWWYt8hJ1aHZ64Y/BI8EbP5j9Hghd7a/Q1q/a53NCSgOseae2Ry80jWu63M6TMBSu5LFcp3FXbjH0cOPhqlFwyQxQ2qtgLF2A/bW3dvuCaBBDtnoFISAEAoGgD3PJJZfgmmuu4WJASmVUVlb2aD9SqYQFRKZZy7UB0bZ3Eu6k0XBkTOXr+qqlUDdt3OdzqFDSnnk0XzdU/QCFvevjdmQcDb8+A0OSlPiTeQ22+5Mw11rEUQtD1dIubbJjwahRcEsnCQnBgUUICIFAIOjjUFcGdWc0NzezyZTP17P2RLlMiqIUPVKMah59HUuHgitl0u/DtyoWQWXZHpXddXtRZel8SH32zhvtmt4ZVuhwQq4Ux8rX45WmkagMxkPuaYZp59youkD2NmyMUhj1ohbigCMEhEAgEPRx1Go1PvnkE56b8euvv+LWW2/t8b5Uchl7RJi0kfHXUbNr+Bb5OPD8i7IFUNrKoiqqjDhcumDiospglzMzrHknwahR4oIMC0wSB15uGAp/WA5t4zr2ltifglSDSoGqVk9M9R+CfSMEhEAgEPQD8vLy8Pbbb/P1F154Ae+++26P96XbNQJcFeMIcPZxyJ4Jr7mIhYBp55ds/rRvm+zTIr4Szjroq5d1uZnfkA1nygQMSTPgPMNG/OzNxypHHKR+B0yl89ipcr+GbHkoCiFqIQ4kQkAIBAJBP+HUU0/F3//+d77+xz/+ERs29Hxl3jYCPBgOwe6JwXOBhm/lngyfkbol/Gx5LXfV79OcyppzIl/XNqzuNv3hTDsSQX0qjsrV4xjZerxlGQGLTw6VZQe0dT0bMMaHLJFwKqPK4hZRiAOIEBACgUDQj7j//vtxwgknwO124+yzz4bVau3xvngEeLKeawRiKjIkM6iC036f4LnjM8g8LXt9ii+u4PcaivJvup74KZXBlnsyzEY9ZqZ5EQrLsNRiBvwuNrPqsoYiSoxqOeyegOjIOIAIASEQCAT9CJlMxumL7Oxs7NixA1dcccV+2TVTV0Z+kg4Wd2ztnW0TPNtMo8w7Pt2nb4MjfSp3XJDoMJVSPURnfwYa723PPAYjMkyYrtmJZZ4CVDrlUFnLoKv+EfsThdApZRyFiHrUuWCvCAEhEAgE/YzExEQuqqShW59//jkef/zxHu+LR4An9Ky9s22CZ0CTwNEBFhF7ixJwx8XJCMk1bDJFMzO6wpMwHIGEwZiQHYc0qQVLWxPg97pgqF4KuasB+9PSafP40WDreT2F4Hck4QE2acRms/FEOwrrGY3GbrcjW1i/f/+81gWCvgadUKRSsS44XHjttdfwpz/9if/PFyxYwKmNnkKr8s01Nj65ppnULCyiRepz8PwKmbcVQXU8Wgadh7BC2+321L1BtRPUzUEtnGRWtSc0Sjx+81tYtqkcGy0KnKgvxqhECVoLz0DroPN6/HvSTBClTIqxOXHckSLo2Tn0sBQQ9OvW1dWhtXX/LFIFgr4InUioWp+EhODwgIopX3/9dZjNZqxatYr//3uK0xvAhmornJ4A10fEgtRrhXn7x5D5bNy2aSk6lyMU3aGr+YmdLcMyJZqH/oELLfeEiielmz/HVxtqIQ97cUZSHTTJBWgY8xf4jTk9+h1D4TBqrW4MTzchK757kXO4YhMCovtfvra2lsVDcnIye8zHorIFgr5MKBRCTU0NFAoF58fF3/bhgdfrxdFHH40VK1Zg9OjRPP6bvtt6SqvLh/VVViAMmHWxCVGZx8KRCKnfCb8uFa1FZyMsU3W9cTjEgoPaQP26NFgoqiDtHBEwlszD9g2/YVtNCwoUTTgyDXDknYiWoZdyW2lPsLr9/NTxOWYeuiX4HSEguvnlKW2xfft2Fg8JCQmH7BgFgt6C/u5JRBQWFrKQEBwekL31+PHjeew32V2TX8T+CEjyS9hYY4VWLodeLY/puTJ3U0REBDzcpdFacCZHGbqLWiRsfQeSgBfO1IlwZhzVeRu/E8YNb2HhmhKo/C2YYrIgIb0ATaP+BK+5c+ojGui0V211Y2iqAbmJ+h7tY6ASi4A4rJKlbTUP+6POBYK+TFvqoqejnwX9k6ysLHz00UftHRrPPffcfu2PrK6LkmKf3kkENYlcWMnGUfYqmHZ+0eVIbyKkMsGWHanb0NX91qWzZUihgyfnWIzLiedT1labCuHWKugrl/bY4prElZHcKS1uuHxiUmdPOawERBsitCsYqIi/7cOXY445Bk899RRfv/3227F48eL92h91ZVB3RkuM0zuJgC4VFhIRMiWU9krE7ey6ZZMgV0t30ii+biz7GhK/q9M2nvghSModBpUxiWsYKls9ULdsgaZ530O99upO6Q2gtlX4QvSUw1JACAQCwUDkpptu4umdFIE677zzUFpa2uN90fRO8ofI6EF7JxHQpUXSF1IFRxZomFZ3EQN75nQENImcrjCVf83dGV1ZaI/NS4VdokejG3A3V7AtNnlK9FRsmzRKVLW6WEgIYkcIiAFGbm4uT+4bKHz//ff8QRddMwLBvqHPyiuvvIIJEyagpaUFZ555JpxOZ4/3R9M7C5P1SDKoUG+PbXonEamBOB1hqRyq1p0wlX3FxZOdkCrYH4K2U1pLoWlc12mTkNIASdFxSErJBCRAjcUNhaWYrbF7Ctlbu30h1LaKSZ09QQiIflYodeWVVyI9PZ1z3Tk5ObzioBG/AyUEe/PNN+9235FHHsmdM1TUIxAI9o1Go2FzqZSUFKxfv36/nSqpS4Gnd6oVaHTEbsBE7ZbW/NO5w4LaMo1lC7oUEVQ7QdM+CX31D1yMuSeehBEoHDwCLbJkTqu01pVBV7u8y7RHtJi1ClS3utlgShAbQkD0EAoR0ur4/fff55+9XbRWUlLCqwqyrqXXLC4uxssvv8x5zilTpvBq41BAvze1D/YWJJRSU1NFbl8giIHMzEx8+umn3Inz8ccf45///Od+7c+gVmBQqgFymYTbPGPFZ8pFa96pLCLULdu41qErEeFOGgOfKQ+SUACm0gWd6yYkEnjyT0B2TgHcUKLF7kSoqQT6ul96/LtplXJ4/SFUtbj2S2gdjggB0QM+++wzThXMmDEDF110Ef+k23R/b3H99dfzyfSbb77B9OnTuc//pJNOwrfffovq6mrcc8897dva7XZceOGF0Ol0yMjI4NG/bdAHhIbx0PNVKhVHM2688cbdesqpAIueR8+fPHkyC6Q23nrrLcTFxWHu3LkYNmwY74NMbNRqdac0A0VHjj32WL5OURI6JtovdcGMHDmShVAbl19+OZYuXcrV4yQW6FJWVtZlCoO+GIcPH86vTe/7v/71r91el+6jL0yK1hgMBv5dX3311fbHfT4f/vKXvyAtLY2PmyI5jz766AH4XxII+g5Tp07F888/z9dpgucXX3yxX/uL1yk5EuENhNhwKlZomBa5TtI0TyqANJYv6rLWwZZzAkIKLeTuRui7mH1BhlOJo2fBqc2EJBxEa91OaOtXsgfF/vxuNVZPbKPNBUJAxAqJhHPOOQdVVVW73U8ncbq/N0QERRe+/vprXHfddRye7Aitzqnv+8MPP2xXz08++SQbyqxZswZ/+9vf+ES+aNGi9pPvM888w3lSimbMmTOHT+Zt0Il1+fLl+OCDDzj8ee655+LEE0/kbdtwuVzsvU/CYdOmTfz6JCpo3x0jE3RM9Bjh8Xi4T33+/PnYuHEj2+9SsReZ3xAkHCiSQq56lLKgC7Wm7Qk57VFx2AUXXMCjjEkM3XvvvSxsOkKigiI29B7Q+/bnP/8Z27Zt48f+/e9/swCitje6j9reSHQIBAMN+pzRZ5qgzyJ9pveHNJMGhck6WN2+Ho3F9sYVcq0Di4jmTTBUdBYR1LZJIoKg+galtXNrpydpDLKGTkYrjPB5nHDU7oS+pueDtthMKgxUtrhiLhY9nBECIgbopEgn467CXG33UQ7/QKcz6ORN+x86dGiXj9P9FouFTWTaVh4kHAYNGoQbbriBhQ2JBqKiooJFx8yZM3llPmnSJD5ptz325ptvcsjzqKOOQkFBAUcjpk2bxvd39NN48cUXuT5h8ODBHKmgE/p7773Xvg2lVihqQOOGCYo80L7GjBmD/Px8Pi4SJnQSJ6jGgSIsFJ2g46ML9bTvydNPP43jjjuORQP9fhS5oC9IEk0dOfnkk1k4kKHSnXfeycOHvvvuu/bfs6ioiH8vij7QT4qOCAQDEfrs0+ediilPP/10NDT0fBgVkR2vY/OlZqcXgRjbOwmveRCsuSdxtEHTtBGGysWdRITPlA938hi+TmO8JYE9ihwlEqhGnA5pQj78kMHbsB3Kxg2QO2t7/Hsl6JRosHvRaBeDtqJFCIgYWLZsWafIQ0foJE+FjrRdbxBtfo5W8nve3rJlC1+niILb7eaTOAkHKrYKBCLhSFrRk/ihE7Ner2+/UGph586d7fujE/2oUZG+7TZodUPpBnJBJGhVf8opp3BkgqD9PvTQQxztiI+P5/1SVIVO5rFAvwcJpI7QbRJZHYVbx+OjFAgJkrYvThIda9euZfFD6RtKCwkEAxW5XM5CnURzeXk5i3pKVe5ve2d6nAb1di/7MsQKDc9qFxGN62Go+q6TiLBnHBWZ8klOlF2kO2jsd/Lk82GXxgEBH5rLN8NQ9UPntEgMHSc0ZKus2QlfoPfqugYSvSogKPROJxayw6QTyVVXXQWHw7HPSvy2HHjb5dprr0VfgMLqB3K7aKFVNL0PbSJgT+h+GqSTlJS0z31RWoDC9hRBoHQIrdLJR5+iCvR/Q6t+ShPQCbbtQvvv6GxHz9uzqHHixIkcsaDUBwkUEiZt6QuCIgS0D4oGUCSA9jtr1iyuR+gN9rRxpuNtK/YcN24c98eToKFjpZQIRWkEgoEKfT9Q2o4ifT/++COn9PanYFAhk3I9RKJeybbXPdmXN35IJFVBIqJhLfRVS3c/+UsVsOWeGOneaC3mlMeehDMnQZ47FQ6JGsrWnQjUb4XK+vtiJ1Zo9gcVidZZRVvnIRcQdAKhHDnl3+fNm4cffviBc3L7omMenC5PPPEE+gJUdHcgt4sWmttx/PHH80mfTngdocmitNo///zz20/qv/yye0Uy3e6Y/iABcNppp3EtAEUNqOaBog9jx47lVTyt1Em0dLzQCj6a/286li+//JKnQlIEoo2ffvoJZ5xxBv7whz9wfQZFQGguSUcosrGv9A/9HrSvjtBtipp0lfLoDhK19J7ROGSq1aD6jUPVySIQHAyGDBnCkQj6bFJKcs+0X0/qBganGtjRscnRs4WAJ2E4bNkz2+sdyBiqo4gIaFPgSItEVA1V30Pm2cMPRiJB/LSr4FGlwA8p7KUrI4WXXXlNRIFUIoFepUBFi0tYXB9KAUGr1oULF3KhHVXyU575P//5D69Q28Lc3dExD06XfQ30OFhQXQC1R3XXUkj30wqftjvQUDU1hR1p1U5CjFIl9P6SsKD6gkceeWS3EyqJLjpBUwcG1TRQ7QZBxYb/93//x4WM1Br6zjvvsKCgWgA6CZMIuPTSS7kYlFbpVORIHQpU/Lgv6LmrV6/mY6EVPXVJtEHhUxKSNCmQ/jauueYa1NfX7/Z8KmT89ddfufuiqampy/bQ2267jesrKHpAv99///tffm+oviJaqI6COkC2bt3K+6D3h/7O2tItAsFA5YQTTuCFA0HRwP0t+ub2zhQDZNLIFM+e4EkcCXv2cXyduil0tT/v9rgrZQIbUpHjpLF8YSdxEFLHQTnxEtihhcFbi9bKTdA0bejx72Qki2tPAFUtIgpxyAQErWrpC5kq4dugQh5Sv3SS2Bu0iqWitxEjRuCuu+7iqv/uoJMqTQ/reOktaIXbFsrfU0S03SYXyFhWwtFCJ+CVK1fyyp1C7pQuoGgOtZDSe011BR1PsrQtRRQefvhhPmGS8CDo/4RW3VQ3QHUC1AZKEYO26aS0MiEBQfugGgFysvvtt9+44HJfUKSCijKp0rtj+qKtjYxSB3QclKaiEzbtuyMkAui9o/ZQSsd0VR9B+6BVFAlR+vv4xz/+gQcffJDrGqKFWjtJYNHfJqVeSLB89dVX/LcpEAx0qCWcipgJigjS53t/SNCr2COip+2dhDtpNOxZkZZvXe2v0NZ2OEdIpLDmzOK5GgpHDXR1kc6tjmiHnghfwlDYoYGk6jeoK5d1LryMEvoup1QGWVxbRFvnoRnnTX34tDpsa51rg0ZpP/DAA5yD6wrq16fVMPkT0ImIVDKdlLpTytTGR/vbk65GkVIrIa2q8/LyuP+/p9Cx0Iq+Y0ElRR5IPMyePbvH+xUI9pcD9TcuGNhQ4TSlFEk4k5inRV00i4TuoNNIebMTW+vsSNCpIm2RPYAiEHoqhATYldKVOrH9MXXzloiLpUQKy6Dz4Nen7/bcYFMJPHP+gpRQI2xxw2A64hKen9FTqLaDajxGZsZBJj18jOxsvTnOm9oD9yxy3PNCoeGeQqtqWqVStT6tYv/3v/9xQV7HLoCOUISCftG2C4X2exsSCbRqpWJAal2kn/SlLcSDQCDoL50ZFMWj71mqozr11FP3K3pL3/vc3pmg63F7Z1u6wpEe6bKieghNw5rdJnLShVIYxrKvIAnsPkVTlpiPYMEJsEAPXetWBEuWQe7aPU0aa1sndZnU2cS0zu6QI0YotL2vcDGF2Tu2zXVUvVSoFk1BXhtUP0GQdTOF7feE8uwdc+0HCwq1UyheIBAI+iOUyqPidvqOpSJqqluiWqc9O5hiae8sSNbDFwyhptWDNJOaixJjxZU2GZJwgFMZhsrvOOJAKQ6eyJl1LBTOWsi8VvaPsOWSKdXvr2E64jLYqlZC7y6Gp2QF4pKLYB168W7bxNLWqVHIUNbkRLxWCY3ywKem+zsxRyAoN03VvHu7UDU9eQ+QkRC1BLaxZMkSLoxrEwXRQO1+vdHZIBAIBIc7lLagGigqXKciZ4oAH+r2TsKZdiRHIwhDxWKodxVFhuXq350sW7Z1au0Ma8zQTboILYiDLtAM29bv2Ta7p8RpFLB7/Kiy9HxY10Cm16rGqN2OnAapJZMq+akzgBwDybGQ6hva7J9JcLTZGVOagqrrSXRQioD6lqmgj3wK9jQuEggEAsH+Q8XEbe2d1KVFRcmHur2TIgZcA5E8jm8aK76FumkjXw/o0uBIP5KvU4RC5tm9/VpWcCyQNgYeKIHmHVBs+bxTuiP6w5DArFWi0iIKKruiV8vOqZuCBAJZD5O1MLVydhxqROZFVGTZ1mVBkQvqCqBWI3oepUvINY0UskAgEAh6B/Jseemll9oL0zta1/e0vXNwqhHUkNbT9k4WEZnTI5bW4TCMFYugbt7MD7lSJsJnyIIk5IepdP5uUzspSpEw6Vw0KnKgDntg3fkrdGRStR/TOqmjnIpEe1rbMVDptS6MvlhBKirUBQMd8Tcu2B/uvvtu9n2hIkuqj2hr/+4ptVY3NtXYoFPKoVfFXHIXIRyGoXIJNI3rdk3rPBGehKGQ+hyI3/I2pAF3pA10l5cEEwpC9utLsG+YCwNcUKQMQuC4fyKgj77+riMkHKigcni6EVnxWgxkbL3ZhSEQCASCgQmZwFH3GxW8U/S3Lb28P9M7i5L1XEfQk+mdzK7iSXfiyEgkonwh1z6ElPqI1TW56zaug6qlg2WAVAb5kOPhTRpFq2TYGyuh2/BfFhY9gQoqSQCVNjn5dxFEEAJCIBAIBO05/zfeeIMdbml6J6U29vTyiZUss5bbO1ucXvh7mgIgEZE983cRUfY1iwafKQ/O1Em8CaU4ZB5L+1O8cYOQM2QcKhR5UIfcsO34CfrqnqcyTBoF3L4gyptdCImR34wQEAKBQCBoh2rRaDYMFVeSpTylMfY1fiCa6Z0ZZi0a7B4Ee3ry3SUiXMlj27szNA2r4Uw/MlIPEfTBVDIPCO2KEEgkcGdNR3bBcLSGdfB6HAivfAsyd3OPf5ckgwo1rW7U24U3BP/f9vidFAi6gXxC9rSpHggrszlz5hzqwxAIDppHBLlUto0Ap446asvvKZQCKEzWI9mg3q/2zkhh5TFw7nKoNFR+D239b7DlnoSQQgu5uzHiHbELvz4D2uzR8CWPgRxBNDfXQ7/6pR6P/KY2VbVchpJGpxi2JQRE/zop00nsscce2+1+Oql1N9xLEDtUgT5mzJhO99NU2JNOOumQHJNAcCggz59vvvmGPXjIaIrcKvc2lyja9k6TVoFGh7fnByaRwJk+Dc5dUzr11T9B07gG1pwTI6PBmza2d2sQ1A5alJOJakU+FEEv7Dt/gb6DyIiVOC15QwS4K2OA9SDEjBAQPYXGTn//PfD++5Gf+xhDfSCgqvrHH38cFsvveT7B7y3BvQm5px4Kx1OB4FBCE3Jp6i8N4SMvn7POOosHGPYUnUqOIakGqORSNO+3iJjC4oD3W/cb1K3b4Uyd3J7ekLsa+XpIaYAnfTIKCgfDAgMcHi/w2+uQuZt6+NIStrmusnjQYN+P32EAIARET6DBXrm5wIwZwEUXRX7S7f0cjbsvaJopnciozWpv/PjjjzxSnMZ005CvG2+8kQuiCBp9TVMs94xgvPzyy7u9Dk3P7A5ajRx77LG8f5riSe51Doej03Y05IxWMdQKdO2118Ln+70f/JNPPmEf/rZ90Gu2HSNBY+DJjIxEE3mCvPjii+2PkckYHfOHH36I6dOn8zbUw077WrBgwW7HQHNUKBzbtnKi4Ww0tpyc98hy/d57720XH2SiQ8e8bt269rkudF9XKYx9vQdtaZynnnqKV3C0DU1B7Ch06HeiEDEdf0pKClsJCwR9DTLxo3SGTqfjiMRFF13EXRo9JU6r5OmdYYRhc++f8KdhW7ac49sjD3J3M3yG7Ig/RMmX7QZSZEhlMCcDqSMRCkvQ1NIM44qnwQYPPYymKGVSlDQ6DutUhhAQsUIigb7oO0ziZKqrI/f3ooig+Rs05fQ///nPbpNAO0JunpSvpBYsmmZKJ1kSFOQCStAJd/PmzWhsjKjzpUuX8uj07ymKsmslT+PBu5vzQSd5Kqoym808Bvjjjz9m86+2/bexePFibNmyhff7/vvv8wTTtqmplA648MILceWVV7ZvQ4PI2sKBZEBGY7qppYwep9+ZTvQ03XXPwW40FZW2OffccznESsPNOkL7ohM5CQaCxASJAnoPaDQ7jTZ/5pln+LHzzz+fzcuGDx/Ox0gXuq+n7wENWaP/D/pJx06v2yZIaNw6CTty/aMqd1rlkeOqQNAXodEEJKCpwJI+y1dffTWPJegpVAsxKNUIlz+43ydgT+JIWPNO4dZNVesOFg9BhRYybyuM5d9E6h2kctizjsGQjATUqfP52C2la2Ha8WmPX9esVaDV7edZGYdtV0Z4gGG1Wul/kn/uidvtDm/evJl/9ohAIBzOzKQ/x64vEkk4nJUV2e4Ac9lll4XPOOMMvn7EEUeEr7zySr7++eef8+/bxlVXXRX+05/+tNtzly1bFpZKpfx7h0KhcEJCQvjjjz/mx8aMGRN+9NFHw6mpqXz7xx9/DCsUirDT6ezyOF599dWw2WwOOxyO9vvmz5/P+6+rq2s/1vj4+N328dJLL4X1en04GAyGV61axcdcVlbW5WsUFBSE33vvvd3ue+ihh8JTpkzh66Wlpfz8Z599drdt6L2g12h7XfobUKvV4QULFnT7vj755JPh8ePHt9++7777wqNHj+60Hb0e7T+W9yAnJycc6PC3cO6554bPP/98vv7pp5+GjUZj2GazhQ8k+/03LhDshTlz5oRlMhl/Hv7yl7/w90lPoeeWNNjDCzbUhFeUNIfXV7bu12XLpnXh2i8fDtfN+Ue4Zt5j4bo5f+frxb8timxTYQlXfPdmeMcHd4c//Pvp4eX3TgrvfPLY8Nb1v/X4NVeWtoS/3lgbrra4wofDOXRPRAQiFpYt6xx56AidZ2icOG3Xi1AdBK1oaeW9JxR+p1WuXq9vv9BqmRQ3ORRSKJ5WurTqp6pqWolfd911nNekMewUkZg4cWL7in1P6DVHjx7N4cw2pk6dyvvv2C9O23TcB61gKMRP49bpMbI3pxQGRQ4oCtBW10Gre1q1X3XVVbv9Dg8//HCnke7UZtYRskunSYI0Q4WgVjRKn1B6pA2KyNDxUiqI9kupmoqKipje/2jfA4pkUNSoDUpltE2opT77nJwcTqNccsklHCnZnwI1geBgcMYZZ7RH0Sgdevvtt/e4kJC+i3ISdMhL1PMI8B57ROzCb8yBpegchORqSAMuSIJ+bu3U1/wIhb0i0gaaeQwMWhUys/LRGDKh0eaE9pengR7OylDKIxM7KZVxOBpMCQERC7W1B3a7HkICgETBXXfd9f/tnQd0VNXaht9JZpJJb5BAIHQIBJAqIE0BEUXFdtF7VcSOYrvqVfFHxYqI4LWBIip2sQFXAQURFAERhNBrgFDTe08mc/71bjxxEtOmpE2+Z61Zk2ln9uzMnP3ur/7tMS7SU6ZMUV1M9QtFxeHDh8vaodM9QQHx66+/ol+/fmqR1UUFBQTdHHUJF1V2/mO8QkxMjHLJREdHK4GjxxFQVNh+hj179mDz5s3ljmO7gBOaVxlHoLsxeE0XBMvyErpmWGWPQoNlemNjYzF9+vRysRmupGJbZJ4wdbMvXSnbt29X7h0KC7psKEqcSZUThPrgxhtvLOtp9MorryhXoqMiQq8R0dbZGhF/YvFrhYxu18Jq8ofm6Q1jYRoMJQUIOrYSHsXZKDWHIC/iXHSOCERRcGcUaCaknIlH8M6/ejQ5EtORV1SqqlQ6O/6mhggIe6htS/F6aD3OdE42GeOiaEv//v2VVaFLly5/u3CBtY2DoO9ej3XgNf34jLSuKv6BMLCRgsQ24JGvYSc/igAdPqegoKDsNhd/7vgZ1Kkvpty1My6CCznHxoBHBhOyW+vRo0f/Nn72d6gJCgTGE+zdu1e1j+dtnU2bNqldP0UDrRd6jrstHEdpDRk1tZ2DmqCwoXVk9uzZKl6FwaEcsyA0dthlWQ9s5veXljzNidoKrBEREWhGUk4BrE6mRpb6tEB69LUo9Q5CiW8EvHOOwzM/9c8iUxZVuZJCYlDHFjjgGY0iixX5+3+E36kNThaYKmx2bb9FQNjDiBFA27bKFFYpvJ8LJJ9Xx9D8z8Xx9ddfL3c/swy4UDKgjzt3Wh7+97//lQvwY1Q1AwC5Q7cVEAySoiuDC3tV8D2ZNTB58mRlFWCA4H333afM8Fz8dbirpxuCQoUR3DNmzFBj4CL7+++/q8BIBhLSfcCgLAZ1cmEmFBXMNOFnO3TokMp4YHdA7nZqgpYUuic4TgqOwYPPpnURCga+3+LFi5U7hMenaKmYtkZLCOeOVfgqS1mr7RxUBy0gfH++D0XMRx99pKwT9ggQQWhI7r777rLzD3/PrKHibI0Its5OySlyur6C1TsYGd2ug8U3HEWBHVSKp3dGnGrKBYMnsttdqFJJh3YKxT5re2TkF8Fzy3wY8xIcFkFBZhOOpeQhvRm1/RYBYQ/0Z7/22tm/K4oI/farr559Xj3ACP6KkdAUB3RDcOFlKiddFDSPc1f/11AN6jFes8W6/jq6Mrgzr+gasIVxDatWrUJ6erqKlaDLgPEM9Ifawvu4YHNBpxthwoQJZScYvs/69euVK4Epldy9zJ07t6xQEyO8mcZJ0UChRIsJ/a61sUDwMzHDgxYCW+sD4RgefPBBJWRYLIpCi9kdtjB7hVkso0aNUimodDE4OgfVwbx6CiemglI4MY2W78W4CUFoKlA468Ke5yP+nhxd/H29jKoFuK+Xp3OFpv6EzbbozigO7KAu5oz98GPRqdRdKAmIQkGLXogI8kFoZGckaSFISktDwG8vw2Bx7L39zUaUahriknMcbxzWxJB23o7AVM0HHigfUEnLA8XD1Vc7MXpBcA5p5y00BNwAMKCSPPLIIyrQ29EKudzB7zmdBWhAiN9Zt6szGEqLEHTkW/gl/A6v3JMoDO2O1N5TYDGHImzfB0BxHj466IEhuWsQbLIirP/lyOhzd9WW5mqwahoSMgvQLswX3VsFqhiPpoa0865rKBLi45noz0i9s9fHjol4EAShWcL6Kbo74+WXX1b1WRzdm4b6ealqlaWa1elCU4TBlJldrkJum+GweIfAnLYfYXveU/UimJXhYTBgYmcrVnsMR36JFXl7f4Df6fUOvZeHwYCWAWacTM/H6cy/YsDcFREQjkI3BeMH/vWvs9f15LYQBEForO6MBQsWKMsDM6tYfdbRYlPhgWcLTRWUlCKvyAWVHj2MyOp0ObI7jofV6AOf1N1osXM+ioI6qZbgfiYDxvcIwxZrNDLyCuGxZQGMOdWk7NeQ2unvbVKpnRluHg8hAkIQBEFwCSzpztglBksz1fOmm25yuE9NZJAZXcL9kF1YgoJiF8QUeHgqEZHR9WpoHkb4Jf2BljvnI7vtaGhGb3TxyYW54zAkWMOQnJaGwM0vw1DiWFZFoI8JFquGuJRct46HEAEhCIIguAxmJ33yySeq3oteSt6RImm0ZLQL9VN1ItLzi1FkccFCbDAgu9MEFVwJGOB/ZiNCDn+BnDaj1MMTWp7B+uArkGf1QsrJQwiJfRPQHLOitPD3RlpuMQ4n5cLiZJGsxooICEEQBMGlMBOK6eNsNsc07osuusihImkMQmSlyg5hvkjNdb5apcJgQFaXK5HZ9WzMWuDxH+GbtFW5Mzyg4e7ofHzjeTHySjRkHVyPoMPlU71rPXaDAeEB3jidmY94N239LQJCEARBcDmXXnqpqjirtwJnOjYb1NmLp4dBFZpqF3q2WqWrdvMZ0f9UMRG0RATFfw/PwnRVBjvImolrzu2ENdpAZBcUo2T7p/BJ2uZwfYgQXy/Ep+YjMduxctmNGREQgiAIQp3AonSsS8Pibqy2OnTo0Ep7+NSEUVWrDEDrIB8kZTtf8lonrcdNyGnL0v0aAk+uhaGkUFWrjCk9gJYDrsI+awekZOfCa/Nr8HSwyJSvl1EVraIrIzPfvYIqRUAIgiAIdQaL1NECwXL0LNdOEcG+O45kN7BaZUSQGYnZBa4RER6eSOt1G/JaDVHCwTdtF4wFqYClGFeaY7G7wy1IsQYjKTkJQb/NVn01HO2XUVJqxaGkHKfblzcmREAIgiAIdQq7zrJvD7vyMhaCMREMtHSk5DULNLH3hCv6ZhDNaEZqr1uQHzFQde80FqbDnBUHY34y7uucgiWBN54NqjxxAKF/vAJYSx0OqszIL8ahxBzXBIQ2AkRAuBns5fAqK2I6+RxnYelp+j4FQRBIixYt8NNPP6nS70ztZO+Y5557zu7gQh8vT/RoHYgwP28VV+AKEaF6Z3S/Hvkt+8CjlLEKBvik70NA2k5MHRaJzzwnqKDKjEObELzvI4eDKiMCfJCQVeg2mRkiIJoQJ0+exK233qr6WrBrJDtLsuJbWlqaXcfZunWrytd2FZUJEva/YD8OQRAEHWZlfPHFF6rcNWGfnuuvv97uNE/GFXRvHYgQX5OKiXBFhkOJf6TKzigI66XKX2seJpjT9qJDwve4fOyF+FYbgexCCwp3LkVA/CqH3oMBoew6yq6dbP9tbeLtv0VANBHY3pqNrthdk02X4uLiVAMmKnqaBdnYqbawSRQbQtX1iSI8PLxO30MQhKYHi0yxBTjPX2xpz+64bO7HDZI9+HsblSWCRZuSclwjIopCopHTbjQKwnpCM3iqlE+ftD0YlPI1Ol5wMzZZeyItrxDYshDmlF0OZ2bQekIBcbKJt/8WAdFEuOeee5TVYfXq1Sodql27dqp75Zo1a3D69GlMnz697Lk5OTkqD5tdNdu0aYN58+ZVazGgT5IdMCks2DyFHSLZzdKW7777TnWeZIMmmiKvuuqqsjbgbEfNLpcs/KI30LF1YdASwfsPHDhQ7pj//e9/0blz57LbbI3Nz+Tv76/aYtPEyZbagiC4H1OmTFHnL55Ptm/frs4vDLa0hwCzCTGRgeraVSIiP+JcFEQMUE23Sk0BMFgt8EvcignFy5HRdyoOWdsiMTMH5k2zYcp2rNw1Yzk4ZroymnLPjGYvIPiFy8vLa5BLbb/stC6wffTUqVPVzt4WpkexbTXNgvrx2MymT58+iI2NxbRp05Sbg/nYVTFx4kQkJyfj+++/x7Zt29C/f3/Vnlq3aqxYsUIJBrbf5jFp9Rg0aJB6jC2p27Ztq1r5Mse7sjxvtuym9YRV6WzhbZovdRFD4cL243/88Qd++OEHJCUl4dprWTFOEAR3hJshulSZqcHf+6hRo9SGxx4hEOhqEWEwICdqFIpCuimLRIlPGAzWYgSeWIO7AjdhU7upSNGCkJCcgqCNz8CjMMOht6EFhULiQGI2ErKapogwoplD3xt3vA1Bbm6ushLUBN0W/FH06NGj0sd5f0ZGBlJSUspyrykc9MWbqp67/bFjx/7ttRs2bMCWLVuUgPD29lb3zZkzB8uWLcPXX3+tYiVeeOEF/POf/8QzzzxT9joKFBIaGqpK1gYEBCgxUxUUOW+++aYKmtKtEhQreiQ2H6N4mDlzZtlr3n//fURFRann8nMIguB+0CK6adMm3Hzzzeqcc++996rzEntp8Lxij4jYdyZbiYiIALPD7cQVBg9kdbwEIZY/F3arFabCdATHr8C0jkY8mXM7bsqcD8/TJxG54RmknT8Tmsl+t3CQjwmZ+RoOJuScDbIMNKMp0ewtEE2J2iprxkRUvF1V8Ra6KihkwsLClJDSL8eOHcORI0fUc3bs2KEsEs5AAcIc8M2bN5dZH2jp6N69e9k41q1bV24M+mP6OARBcE+4kfryyy8xd+7csrgIWi13797dcJYIDxMyO18Bi28LFIXFwGIOVrUiwuJX4KmYZHzscwNySo1IPH4QYZtnAqUlDteIoHg4kJCtKm02JZq9BYLBhFxAG+q9awMLsFBNUwTosQe28P6QkBAVw2Av/OytW7eutLCLHsNQ0W3iCLRO0EXx2WefYciQIer67rvvLjeOyy+/HC+99NLfXsvxCYLg3vAc99BDD6nzg57FNXjwYLz22msqRqs2FgVbS0RCdiFaBZrV4uxMjYjMLlch9OAXKArtAe/UvfC05CMiYS0e7zUCr26/ApMsS5Aatx1h5teQNvAhZb2wlxA/L6TlFuHAn5YI1oxoCjR7CwS/lFS/DXGprYmN1gG6H+bPn4+CgvK+ssTERLWb5w9OP56+y9fh7arcH7QC8BhU/RQqthcGNxH6Jxn3UBUM7iwtrbkwih6rwYIyzCqhVcJ2HHv37lXmzIrjqI2bRxAE94CVKhlrNW7cOHW+oxuVGyfdRVsbEdGrTRBC/byQmOV8nQirVyAyul6DUpM/ikO6qX4ZbPPdOnMb7u1twf8MFyCn2IrM/esQuvsdh7t3hvl7q+qae89kIbmJ9M1o9gKiqcAYgaKiIvWjWr9+vUp5YqAhhQUzLRinoMOYB6ZJUcEzIOmrr75SgZSVceGFFyoXB1vuMsODbgb6I5nVwWBGMmPGDJU6ymtaO2hWtLUUcNHnmJgNUl3WxNVXX60yRGh5YLAU61nYZpkwaJPZIwyqotuCgaO33HJLrcSJIAjuAzcv7OLJ85jJZFKdPXv37q0CvWsboBjDYlP+Xi4pe11qDlXdO0u9A1Ec2B6a0QceRZloU3QM/+puws/WvsgssCB31wqE7v3QqWqV0AxnLShNILBSBEQToWvXrmpBZ0lYZiYw/ZHKnAsxd/QMZtR5+OGH1XMZlPj888/jlVdeUcKjMmi14A915MiRarFmsCItA0zNZCqlnqpJEfLtt9+ib9++yhXBwEsdZmBQeHBM1blRGBBFNwXjHWiNsIVigsKHYoFlbnmy+Pe//63cKMwbFwShecHfPQtO8VwTExOjsjSYCcZstOzs7Bpf70cRERmoFmVXiAiLbwQyO18Ji09LWMyhsBp9YCxIQTvPDIzpGoRtpd2QlleMvF3LEHLwM4dFBC0nLDi1LyFbFZxqzG3ADVpjHp0D8IsVFBSErKwsVdPAlsLCQhUc2LFjR1XPoLnCmAJmQ9CvKLgX8h0X3BG6Mh5//HEVD0GYOs5CVGwZXuNri0txMDFblb1mdgY7ezqDV9YxBB/5H7wzD5eJhBL/NjicacXBYycR7XESLYP8YO53LTK7TlQNuxwhu6AEBSWl6Brhj6gQX3h4OJFV4qI1tCKytWtmKausB0El37Nnz4YejiAIQq1gIDeL37HwFK2wp06dwmWXXabqyNQUG8HeGSx7HRnso7Iz2BXTGYqDOqoUz6KgzjBopapipWdhJrqEeqFLVGskaGFIycpF0c4lCI77BrA6lp3BCpu0ohxMzEFccq7T464LREA0I5hXTfcEXQMVUz0FQRAaO0wnZwzWf/7zH+XiYGwW073feuutamOl9C6e7UJ9Vaqks90wWWAqq+N4FIZ0g2dJruqdwU6e0a0C0aJ1B2RpAUjOyEKRcmd8CYPFsaBIxnKE+HrhaGou9idko7CkccWDiQtDENwI+Y4LzQXGedENq5fdZ7bY66+/rqpbVgU7YHI3H5+Wh1Bfb2WdcAZz2l4EHf0OPim7YfEJQ3FgR2iwYt/xJCB5P8yGYrRoEQ6/7mOQ2fUfsHo5VrSQ407KKVJBod0iAlQBqrpCXBiCIAiCW8NCUxQRb7zxhqqDs2vXLhXwzSDzqorPMf6ha0QAurT0R2ZBMXKLLE6NoTCsJ7I6Xqr6Zpjyk+GVfQylpkD06NgWhhbdYIEnUlOTkHNgHUIOLlauDkfguFsHmZGZX4zdpzJVempj2PuLgBAEQRCaJKxfw9LXTFlnejjdGswYo1vjrrvuUrESFWGGQ6eW/ugW4Y+8IguyChyLUdApbNEbWZ0n/CkikuCbuktlakR3i4YWxhL8BmSkJiDz8CaEHPwcxry/9wuqDSww1SrQh1W1sft0lrKkFFsaNi5CBIQgCILQ5OtGsNAeu3pefPHFsFgsWLBggSpEx+qWDBy3hRkN7cP80CMyECWlpUjPK3bq/Qta9lHFpgpDzooI/zMbUeLXGp1jBqA0LBrMn8hOOYm0I9tVTIR3xkGH34tVK4PMJhxJycOe01lOCyBnEAEhCIIguAVs8sdiUyxsN2LECFV8j40E27dvr+rmHDx4sFwNnDbBPugZGcQGnCq40hm3QGGL3siIvlYFVtKdERT/gxIR7fuMgjWsq3qPnJTjSDi6B0FHV8A38Xc2OHLovRi7wTLdaXlFyhqRU9gwIkIEhCAIguBWUDz88ssvqlov+2lQSCxcuFCV9GfVXT6mi4XwQLMqfe3nZVS1IpwpfV0Y1hPpPW5EUXAnGAuSERL3jape2frcq2EIZU8joDDtOI4fOQD/0xsRcOJH1aDLEeiKoUsjr9DSYK4MERCCIAiC20ELAyvwslLvr7/+igkTJijRwLLYDLZknMTLL7+s3Bus/tizTaC6TsgqVFkPjlIU2h1pPW9BUXBnGAtSVSMuwIrQEXfAq+VZEWHNiMeRw/tgTtmDkENfwaM4x6H3OnU8Hks/XgArAyMaABEQgst5+umnVcnrpg7Lc/MkxHbmhB1LeTsz07FIalcdQxCE2sPf2/Dhw5VwYC8fujLYoI+Bl48++qiqaslmXSuWfYP2gWezHZgy6UytiKKQaKT2nnK2TkRRBkIPfq5iI/xGPQzfiGjGVcIj6wT2HzoAz9wzCD3wKUw5fw/4rIy0lGR8tmgBbrxiLMYP74sFs5/G1t/LN1Bs8gKCzZ3YVY0tq/W20DVBdfjUU0+pUsusPMZGT4cPH66rITYpbr75ZvVD4IXdLxkcxB4UDBZyFlcvaizyUl33zqYKv88JCQkqR7o2cJfDol3OHEMQBNdBqwODK/kbpEuD7g2eQ5ctW6Ya+UVFtsL0qZMQ+9NSHD5+CvnFFqcqVqb2uQeFoT3gWZyr0jhZN8I0Zjr82/RU51xzTjxi9x9CaWEuQg5/DZ/k2L/FRXBdPHLoAD5c8AZu/+cEjBnYHbOeegy7tm9VWSf9hoysdWdnV2OsqwMXFxdj4sSJquLhe++9V6vXsPMaC4F8+OGHqhDOk08+qUxQ+/btk6I4gIouXrRokfLnsQEWO1iyUx1rxDcG+EVnNTh/f391cYaSkhL12VyBq45F4daqVasGP4YgCM7Bxn4sQsULK1t+9tln+Oabb9SGdcXy5epCOnSJxoDzRmDk+aNwzoBBCGtRdbPAyijxj0RK3/vQYtdb8Endg9BDX8KzOAdZY55CwPqXkHs8FiH5x/DbPk8MjO6IgJPrYMw5hT2lnbBj507s3LYFG39eg4TT5a0TvfoOwPgr/4Fxl10FizkIA9qHoEHQ6phFixZpQUFBNT7ParVqrVq10l5++eWy+zIzMzVvb2/t888/r/X7ZWVlUb6p64oUFBRo+/btU9dNjcmTJ2tXXHFFufvGjh2rDRkyRP2dnp6uTZo0SQsODtZ8fHy0iy++WDt06FDZc+Pj47XLLrtMPe7r66vFxMRoK1as0I4dO6bmy/bC9yKlpaXazJkztQ4dOmhms1k755xztK+++qrsmOvWrVPPX7lypda/f3/NZDKp+2bMmKH16dOn7Hk8zjPPPKO1adNG8/LyUo99//33ZY/rY1i8eLE2cuRI9T/n96Yy+Lz58+erz8cxdezYsdyYqjvWwoULte7du6v7oqOjtXnz5pU79u+//6717dtXPT5gwABtyZIl6lixsbHlPm9GRkbZazZs2KCdf/75as45txdddJH6X3AOK84rx2Z7DH5H+Rk4f7bwff39/bW8vDx1+8SJE9rEiRPV7ygkJESbMGGCOlZlNOXvuCA0JFyDdu3apc5f/fr10wwGw99+w+ERrbWRY8Zpd97/H232vPe1T75do63ddlDbeSJD23Uys8rLnrh4LWnJNC3n7XFa9tuXaKeXz9J2HT6uxS6cqm15apD225ODtIWP/0N7+7Z+2sxxgdr9g720yIC/3t/L21sbOnK09siMmdry9dvLHXvVngQtNafQZfNQ3RpakTqzQNgLy+8mJiYqt4UOzbw0MTEIhj0cKoO7cV50atPm1RauSex41hD4mDydMj3RzZOWllbm4qB6Zsttlh997LHHVOtbWm+4+6a1glYhpjfR/8f7aSWIiopSyvuaa65RKU58LY9LXnzxRXzyySeq6x3bifO1N954o2rZbVsudtq0aZgzZ45qcsOKcHSJ2MIOenPnzlWmQ7YYf//991VA0969e9VxbY/D5/E51VmcaJmaNWuWOu7HH3+svhvcRTDCuqpjffrpp8o99uabb6r7YmNjcccdd6i5mDx5MnJzc1VznrFjx6rPzO/jAw88UO38MzaCtflvvfVWNRYWtVm3bp2ywvA2fay9evVSribCeWNchQ7nmu/J3c8ll1xSdj/Hykhxuv9oPaEVjpY8BoLxPdiindYoVt6jRUMQBOfhubh3797qwjgunlt5Llu56kesXbsOx48eRnJSgrqs/2lVudd6e5sR3qo1AgKD4BcQAH//APj6nbXC8nxgtZbCaC3CJcHx6B+YhtKtv+HX+Gcwc30B7h0eggmD26GX6QRiW3RGVkI6Wvqn4onLopAa0h+h516DgUNHwNfXD42NRiMgKB5IREREuft5W3+sMrjIPfPMMw6/L8VDzFPlvwz1xb5nx8HXy/5/AUUPYwxWrVqF++67r0w4bNy4UfnY9UWI4oC+PbqSTpw4oUQCfxyEi71OaGioug4PDy+LV6Eomzlzpup+pzfe4ms2bNighICtgOACyYW3KiguKGh0EfjSSy+phZbd9ebNm1f2PMYLXH311TV+fn4evRU525KzwyjL2bKQTFXHmjFjhhIU+n10kVFE8bNQQHARZyQz3W0UHOxWyip2rG5XncuN5XRt39e2yykXd4qA6lwWN9xwAyZNmqQ6pfK5FMArVqzA0qVL1eNffPGFGte7775bJjbpxuL/iSe3iy66qMb5EgTBfsLCwtQ5kxeWvN55NAGb/9iOpKMHELd/D+KPHsGZUyeQnHgGRUWFOHn8WI3HXGUAbulnwsQYE4a2NWDWhWa8e8QfISc8MapjKfp5nYCp72BEdOmPQaH56jXFgfnINrLDRuPDrtWLuzqe/KuDUa4MVKkv6P9npTEdnoC5cLojy5cvV1YD7kq5qLCVLZUyxQR3prTW2H75o6Oj1f+D3H///WoxXL16tbLy8EfB5jNVERcXpxa1isKAVgzu4G3hIloV/H+cOXMGw4YNK3c/b+tNcGpzHFsqdhLlbT1TorJj5eXlqdr4t912m7I66DB4Sg9m5DxxPmwtHzV1LOV7Usw4A61EtBBRAFJg0RpEy4RuieMc8X9Bn23FpllV1fsXBMG1sCvmwK6RCA0OxPG0QbjKx0vdR0qKi5GUcEZZJvJyc5Cbk1N2Tc3vaTTC09MTHh6e8A8IQEhIGPw8DiE6fS0GeGi40b8VkvreD1PqXuRv+RC98uMRd6QEXxeOwlWRGfDKjkfo/o+QEzUGRaHRaLIC4uGHH1am8uqw3dnag75LY04uszB0eLu6lEBvb291ccaNQEtAQ8D3todRo0aptrXc2UZGRirRUFu4Y6cpnLtbighabrgjpwWjMmjSJ3x+mzZtyj1Wcb7pBnAFrjpOxWPpn0WPuraFP2xH0V09zsD/5T/+8Q9lAaGA4PV1111X9r/l2AcMGKAsShWhS0QQhPrB2+iJ6IhAZTWOSznbh4J1I0xeXmjbvoO61J4xyEwciJa7F8CYn4TWW2ciNeZW+A2/F6Yt76JL5mmcOr0K8/Mvxi0xGvyLUxF0bAUKs+KUkNCM5qYnIHjCqquTFk3KFBHcTeuCgbvX33//vVozsrPQLOyIG6Eh4KLI9M2K0PfP3TTnSndh0H/HmIaYmJiy59EywwYzvNBywwWVAkL3o9NXp8PXUSjQ9VFde9ya4G6aYofuFdvj8PagQYMcOubmzZtx0003lbtd0SpS0Q3GMRw9elS5DCqDc8h4Cu7sdSsEj1sdtFjw+1qVC43zajunVcEx0dLDmJC1a9eqGAed/v37KzcG3Us1tdYVBKFu0XtocPN3KDkXidkFaOlvVlUh7aWg1blI8A1HROxrMOWcRMvdbyGr0wRYh9+P8K3vwiP5NIyZK/Dm1gtwzZBz0LVwD8zpB+GVcwo5UaNQFNyVCxgakjqrA8GFhyZeXvMkyr950XeDhK4O3dfLhZx+a548ac5lUBwXCZ74GVAmVA0DEa+44gplnmeMAs3eDHak5YD3E84tYyYYHMiGM4xB0IMOWSee808XSUpKivof0WTOeg4PPvigSquluZyvY6wBb9vDI488olxfXAgpaugK43ehpiDFqmC3PQZiMkiRsQ1btmxRHfmqg4s8rS5ME+br+P1iLMErr7yiHqc7iHPAOWRsBNNkGbtRHRRhW7duxdSpU1VA44EDB5SFKDU1VT3eoUMHJeoYOMn7qqoWN3LkSCWeKSQopG2tJLyPjYL4f2QQJf9/jH2gS6qyToOCINQ9LH99TtsgZYGgiHC06FRJYHucGfI08lv2g8FaiuC4pQg4tR7awDvQql00ojwzMbrkJ3y3fgtWGkag1BwKj5I8BB1djqCj3zlcwbLRCwhGvHNXyBM8FyT+zQv7t+twMcnKyiq7zapg3BGzUti5556rXsda5lIDoma4GNLUzah++u4ZaMlFUK9/QBHHTAyKBkbwd+vWrSz4j0KDCywXdu7W9cWYAYrMeODCq7+OLg0ucvbAxY5xKnSBMYiT/1OKRNsMDHvgWBcvXqwsAB999BE+//zzcpaWqlw4DETkPHEMtIZ88MEHZZ+FsSXfffedEhb8nk6fPr3GeB/OId1BFGy0pnDeWe1Odz9QgNFFwrHRckcxXRkULixiw+NUtJAwsJLZL+3atVMBoPw/MJaDlhKxSAhCwxFoNqkeGu3DfJGWW4TcQseKTlm9A5F07qPI6ngpYPCAb/I2hB76DNboS9G62wC0NxfiAsMfOL35a7yZ0ANZEYPU87wz4xC270MEpu92uCmXsxiYywk3gm4PBsZRmFQ8wfKkyx0cFw0RJU0TLra0WolVqnLkOy4I9YvVquFURj6OpORC0wxo4e/lWHq+psHvzCa02PMuPEpyYTWakR11IUy5Z5B5bBtOZFmwx9oRe0PGYPLovuiY/itMeQkqQ6RFv8sQ1LX6oG9XrKEVkV4YgiAIguBEXES7MD/0bhsMX29PnMkqQIkjzbgMBuS1GYbTw55DcWAHeFgKERy/Eh5aKYI7D0LXiEAMMB5B/8zvseh/K7HSOPpsLIQ5DJbws+n59U3TiB4UBEEQhEZMC39v+Hp5Ii45FwlZBQj28XIoQN/i3xZnznsWYXvfRcDpDfBJ3QmLOQyGVt3QxTcBvqdPwlhUin2r0/FLy/PQ3isSQ37fikvHjHQqq8wRREAITQo387gJguBG+HoZEdM6UNWIOJqah4LiUhVoaa9LQzP5ILXPvSgMjUHY/k9gLEyDZ3EWSnwj0L5zDxjjdsOr2ILjqTlYmt4Jc1+YgXDPfFUBtzbF+FyFuDAEQRAEwUUYPT3QqaW/ytLwMnool4bFQZdGbrsxOD30WRQFd4HBaoFX7mnkntyNP/YcRmTaVnSxxuOG0P2Iad8Cp0+fVjVllixZgvpCBIQgCIIguJjwADP6RAWjdbAPknMLkVfkWJaGJSAKCUNmILvDxbB6mJB44gh6hlqQk5ODwKRtiMzYhjOH9pRZZ5myX5v6M65ABIQgCIIg1AF+3kb0bB2IbuEByCuxIDW3yCE3LCtPpvW8FRt9xyE+w4piqwHtAzUEGYtQlJWKTmdbGKljnzx5UtWMqQ9EQAiCIAhCHbo0OtKl0SZYVbB0Jktjb1EEHv3NH+tPeyG9yAN+RiAm6K9u1DoJCQmoD0RACIIgCEId0zLAG+dEBaFtiC9ScouQU1hi9zFYlTa5wAOzYn2xcK8PDmV5Iq/UA+YK6RC2/aTqEsnCEARBEIR6ytLo0ToQgeazWRpJ2YVKWHjUMkujb79+CI+IQHJyMr6N98bBTE8MaW/GhlNnW38z26Nt27YYMWIE6gOxQLgJ7I/AL09mZmZDD0WogQsuuEAFOgmC0Pzw/LPwVJ+2wQjyNamaEYUltQt69PTwVCXyFQYDDmYa8cnRYFi1s+KBvPrqq/VWD0IERBOAX4zqLk8//XRDD1EQBEGwgxA/L/RuE4QOYX7ILChGRn5xrV43etRozJ49W3XotYWWh6+//rpe60CIC6MJYBsQw46WbFTGRmQ6bARl26RMEARBaPyYTZ6IbhWgLBFHknNVgGW4v7cKvKxJRLAh4I7YWMQlpGFQp5YNUolSLBBNALZ61i9sckKrg+19FBA627Ztw8CBA1UXx6FDh5YTGoTtpjt37gwvLy9ER0fj448/Lvc4j71gwQLV1ZPHYPfH3377DXFxccr07ufnp47L9t46tID07dtXvS4qKkq97tprry3XaZUuFnas5OuDg4MxbNgwHD9+3K5xsZvmVVddpY7PTp7s6Fkd7DbK57GpFLuMssiKDjuCDh8+XI0lLCxMfV7bz8QW3HzPL7/8UvkTfXx8VIdYtgJnC2/OMef9kksuUS3QdW6++WbV6IsdQ9mBk81o7rrrLhQXV727KCoqUmZJdkXl/LCdN+dLh/N0+eWXIyQkRD3es2dP1WlVEISmj8FgQOsgH1UzolWgGUk5tasZQXfGgAEDMXLESAwbOrTexQMRAcGcXEtxw1zqoCwz21DPnTtXWSTYVvrWW28te4xdLB944AHVVnvPnj2YMmUKbrnlFqxbt67cMdjG+6abbsKOHTvQvXt3XH/99eq5jz/+uDouc431lt86FBhcbNkSm4tzbGwspk6dqh6zWCxqUaVi3rVrlxIkbNmu++xqOy4uyhQmPMb48eNV6+v09PRK54HjZBvxZ599VokojmnkyJFlj+fl5akW43zeTz/9BA8PDyVOrNby6VVsR//EE09g+/btaj45F2w7z5KxzLXm56ZFyBYeb//+/UoEsNU4K8Nx7FXBueScsEU5P9vEiRNV6/TDhw+rx9mGnSKDbb3Zbpxtxm1FoyAITZ8Aswk9IwPRLSIA+SUWpOQ4VjOiPpF23lzIf53bMIMd8TBg9LLrJR988IEKwKsYLMnFatSoUVizZg3GjBmj7uMu9dJLL0VBQYH6vNz1c/f6zjvvlL2OCzIX0xUrVqjbXNS5YFJEkM2bN+O8887De++9VyZGuNBxgedxdQvE888/r3bK3EUTLth8b5ZXpVWBu3yOkSKiIo6Mi49xEf3+++/VYlsRLtoc46lTpxAQEFDjvKampiqLARfoXr16KQsEvye0etx2221ln/tf//qXEgijR49W982aNUv9Tw4cOFBmgaCIYjEXWkrI22+/jUceeUR9JylUaMmhxYbBTidOnECnTp3UdWRkZNl4LrzwQmWxmTlzJs455xxcc801SszUhLTzFoSmT2pukWrKlZlfgpb+3qokdlUwCHNA+xCE+Xu75L2lnXczhotNxVxgpvwQ7oq5WNvC27y/qmPQ9E969+5d7j4uVPyi6bRr165MPBCKDu7mufsPDQ1VC+u4ceOUKZ67d9u4DkfGRVM+v9z6Z6vI2LFj0b59e7U4T5o0CZ9++iny88+mOhHu7ikG+DiP06FDB3U/F3J756LiGPr06VMmHvS5yM3NVaKiIhQsLDvbrVs3JYj0yy+//FLmUqElhQKNc0IRQSuFIAju3dmzT9tgtAv1QWpuIbIK7K8ZUR9IEKWn6awloKHe28WYTH8dU3cRVDTLO3IMZ4+7aNEitRDSMsFAUFoTfvzxRwwZMsShcenjqGoMtDrQ7UCrx+rVq5WbgZYSxi8w7oFChgJj4cKFaufP49DyUDFWoTZzYe/82kJhQd8lY1cq+jB1N8Xtt9+uxBetMfwsL774onJT3XfffQ6/ryAIjRsfL090bxWIQB8TjqTkqpoRFBZMA20siAWCiwLdCA1xsbPFq7MwIHLjxo3l7uPtmJgYp4/NnfuZM2fKbtP1QXM9AyJ1+vXrp+IoNm3apBbrzz77rE7HxZgFugKY8sRdO90Sa9euRVpamrKMUMTQ3cP3z8jIgKvYuXNnmXtHnwuKAQaYVoRzQgsErRhdunQpd2GArA5fy2BMumYYK0LhIwiCe+PhYVCVK/u2DUGInwmJ2bWvGVEfiAWiGUE/PGMLuGhxYaWvngsS4yachf72yZMnY86cOcq1QWsD34uLIH3yjG+YMGGC2u1z8aYLgYGadTWu5cuX4+jRoypwktkLjAehpYCChrcZk8Ex0c1D8TNt2jS4CloxGDdBgULRQrcDAyUpqCpC1wWDQTkXtCpwDpjVwTgLuk8YR8KYF2Z78LkUOgwupegRBKF5EORrQq82QTiemo/j6fnwLilFiK998XN1gQiIZgQzIRh/wEWeWQ8MtKNrgUF9zsIdMwuYMDuCmRFMi2QaJWE8AIMMP/zwQ7X756LNzAJmW9TVuOimoAih24LxGkznZEYEgzX1gEiKHFpCKCpef/11l8wDoVWD70fxwuwJxlpUV+yLn5UxDrQsMOiU9e7p2uEcElooOF8MCGW8BoNG//vf/7pkrIIgNA28jZ7oGuGvXBpxyTkqeJItwxsSycIQnIaL47Jly1TaZ3OHwaLMkOF8NATyHRcE9yensEQVnkrMLoQBBgzs0DBZGGKBEARBEISmVjOiTRD8zUYkZReVBXjXNyIgBEEQBKGJYfL0QOeW/mjpb1ZCoiEQF4YguBHyHRcEwRmkkJQgCIIgCHWKCAhBEARBEOymWQoIZyoHCkJjxs08koIgNGKaVRAlmzqxmA8rJrJxEm83VPSqINSFeGARKn6nK5b9FgRBcDXNSkBQPDC4jI2cbMsuC4K7QPHQtm3bv/XVEARBcDXNSkAQWh3YOdJisagKf4LgTtDyIOJBEIT6oNkJCKKbeMXMKwiCIAiO0SyDKAVBEARBcA4REIIgCIIg2I0ICEEQBEEQ7MbornnwLMcpCIIgCELt0dfO2tSUcTsBkZOTo66joqIaeiiCIAiC0GTXUvbEaFbNtFhlkjUeAgICXFYkioqMguTkyZM1NhcRaofMqeuROXUtMp+uR+a08c8nJQHFQ2RkpKqd1KwsEPzALKRTF/AfJF961yJz6npkTl2LzKfrkTlt3PNZk+VBR4IoBUEQBEGwGxEQgiAIgiDYjQiIWuDt7Y0ZM2aoa8E1yJy6HplT1yLz6XpkTt1rPt0uiFIQBEEQhLpHLBCCIAiCINiNCAhBEARBEOxGBIQgCIIgCHYjAkIQBEEQBLsRAfEn8+bNQ4cOHWA2mzF48GBs2bKl2ud/9dVX6N69u3p+7969sXLlynobqzvO6cKFCzFixAiEhISoy4UXXljj/6A5Yu/3VGfx4sWqMuuVV15Z52N05/nMzMzEPffcg9atW6vI927duslv38k5ffXVVxEdHQ0fHx9VVfHBBx9EYWFhvY23MbN+/Xpcfvnlqiokf7/Lli2r8TU///wz+vfvr76fXbp0wQcffFB3A2QWRnNn8eLFmpeXl/b+++9re/fu1e644w4tODhYS0pKqvT5Gzdu1Dw9PbXZs2dr+/bt05544gnNZDJpu3fvrvexu8ucXn/99dq8efO02NhYbf/+/drNN9+sBQUFaadOnar3sbvLnOocO3ZMa9OmjTZixAjtiiuuqLfxutt8FhUVaQMHDtTGjx+vbdiwQc3rzz//rO3YsaPex+4uc/rpp59q3t7e6przuWrVKq1169bagw8+WO9jb4ysXLlSmz59urZkyRJmS2pLly6t9vlHjx7VfH19tYceekitTW+88YZaq3744Yc6GZ8ICE3TBg0apN1zzz1lt0tLS7XIyEjtxRdfrPT51157rXbppZeWu2/w4MHalClT6nys7jqnFbFYLFpAQID24Ycf1uEo3X9OOY9Dhw7V3n33XW3y5MkiIJyYz7feekvr1KmTVlxcXI+jdO855XNHjx5d7j4ufsOGDavzsTY1UAsB8eijj2o9e/Ysd991112njRs3rk7G1OxdGMXFxdi2bZsymdv20+Dt3377rdLX8H7b55Nx48ZV+fzmhiNzWpH8/HyUlJQgNDS0Dkfq/nP67LPPIjw8HLfddls9jdR95/Pbb7/Feeedp1wYERER6NWrF2bOnInS0tJ6HLl7zenQoUPVa3Q3x9GjR5VLaPz48fU2bnfit3pem9yumZa9pKamqhMATwi28PaBAwcqfU1iYmKlz+f9gmNzWpHHHntM+f0q/hiaK47M6YYNG/Dee+9hx44d9TRK955PLm5r167FDTfcoBa5uLg4TJ06VQldVgNs7jgyp9dff7163fDhw1UXSIvFgrvuugv/93//V0+jdi8Sq1ib2LWzoKBAxZm4kmZvgRAaH7NmzVJBf0uXLlWBWIL9sB3vpEmTVHBqixYtGno4boHValXWnHfeeQcDBgzAddddh+nTp+Ptt99u6KE1WRjwRyvO/PnzsX37dixZsgQrVqzAc88919BDE2pBs7dA8OTq6emJpKSkcvfzdqtWrSp9De+35/nNDUfmVGfOnDlKQKxZswbnnHNOHY/Ufef0yJEjiI+PVxHctgsgMRqNOHjwIDp37ozmiiPfUWZemEwm9TqdHj16qF0fzfdeXl5ozjgyp08++aQSurfffru6zYy2vLw83HnnnUqc0QUi1J6q1ia2+na19YE0+/8Of/TcTfz000/lTrS8TX9nZfB+2+eTH3/8scrnNzccmVMye/ZstfP44YcfMHDgwHoarXvOKVOMd+/erdwX+mXChAkYNWqU+pvpcs0ZR76jw4YNU24LXYiRQ4cOKWHR3MWDo3PKWKeKIkEXaNKmyX7qfW2qk9DMJph6xFSiDz74QKW+3HnnnSr1KDExUT0+adIkbdq0aeXSOI1GozZnzhyVcjhjxgxJ43RyTmfNmqXSv77++mstISGh7JKTk9OAn6Jpz2lFJAvDufk8ceKEygy69957tYMHD2rLly/XwsPDteeff74BP0XTnlOeOzmnn3/+uUpBXL16tda5c2eV6SZo6vzH1HZeuFy/8sor6u/jx4+rxzmXnNOKaZyPPPKIWpuYGi9pnPUA82XbtWunFjGmIm3evLnssfPPP1+dfG358ssvtW7duqnnM21mxYoVDTBq95nT9u3bqx9IxQtPMILj31NbREA4P5+bNm1SKdtcJJnS+cILL6hUWcGxOS0pKdGefvppJRrMZrMWFRWlTZ06VcvIyGig0Tcu1q1bV+l5UZ9DXnNOK76mb9++av75HV20aFGdjU/aeQuCIAiCYDfNPgZCEARBEAT7EQEhCIIgCILdiIAQBEEQBMFuREAIgiAIgmA3IiAEQRAEQbAbERCCIAiCINiNCAhBEARBEOxGBIQgCIIgCHYjAkIQBEEQBLsRASEIgiAIgt2IgBAEQRAEwW5EQAiCIAiCAHv5f5RTvSb5zsHcAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -462,9 +471,13 @@ ], "source": [ "from botorch_community.acquisition.bll_thompson_sampling import BLLMaxPosteriorSampling\n", + "from botorch.acquisition.analytic import LogExpectedImprovement\n", + "from botorch.optim import optimize_acqf\n", "\n", "batch_size = 1\n", "\n", + "acq_function = \"ts\" # \"ei\" or \"ts\"\n", + "\n", "torch.manual_seed(42)\n", "X_bo = torch.rand(2, 1)\n", "Y_bo = objective(X_bo)\n", @@ -487,24 +500,44 @@ " # initialize the model\n", " model = VBLLModel(\n", " in_features=1,\n", - " hidden_features=50,\n", + " hidden_features=64,\n", " num_layers=3,\n", " out_features=1,\n", " )\n", " model.fit(X_bo, Y_bo, optimization_settings=optimizer_settings)\n", "\n", - " # Thompson sampling as acquisition function\n", - " thompson_sampling = BLLMaxPosteriorSampling(\n", - " model=model,\n", - " num_restarts=10,\n", - " )\n", - " X_next = thompson_sampling(num_samples=batch_size)\n", + " if acq_function == \"ts\":\n", + " # Thompson sampling as acquisition function\n", + " thompson_sampling = BLLMaxPosteriorSampling(\n", + " model=model,\n", + " num_restarts=5,\n", + " )\n", + " X_next = thompson_sampling(num_samples=batch_size)\n", + "\n", + " elif acq_function == \"ei\":\n", + " bounds = torch.tensor([[0.0] * 1, [1.0] * 1])\n", + " # (log) Expected Improvement as acquisition function\n", + " acq_func = LogExpectedImprovement(model, best_f=Y_bo.max())\n", + " X_next, _ = optimize_acqf(\n", + " acq_function=acq_func,\n", + " bounds=bounds,\n", + " q=1,\n", + " num_restarts=5,\n", + " raw_samples=20,\n", + " )\n", "\n", " # evaluate the objective\n", " Y_next = objective(X_next)\n", "\n", " # plot the model, the thompson samples and the objective\n", - " plot_model(model, X_bo, Y_bo, new_data=(X_next, Y_next), show_opjective=True)\n", + " plot_model(\n", + " model,\n", + " X_bo,\n", + " Y_bo,\n", + " new_data=(X_next, Y_next),\n", + " show_opjective=True,\n", + " title=f\"Iteration {iteration}\",\n", + " )\n", "\n", " # update the data\n", " X_bo = torch.cat([X_bo, X_next])\n", @@ -529,13 +562,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/b7/4sbb97gd7xdcbjt2mww_cxcr0000gn/T/ipykernel_73018/3219396719.py:8: DeprecationWarning: __array_wrap__ must accept context and return_scalar arguments (positionally) in the future. (Deprecated NumPy 2.0)\n", + "/var/folders/b7/4sbb97gd7xdcbjt2mww_cxcr0000gn/T/ipykernel_75108/3219396719.py:8: DeprecationWarning: __array_wrap__ must accept context and return_scalar arguments (positionally) in the future. (Deprecated NumPy 2.0)\n", " best_value = np.maximum.accumulate(obs)\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhgAAAFzCAYAAAB8X3AUAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAN/ZJREFUeJzt3Ql4VNXdx/F/9kA2kEDCKoJo2AQEoahVRBYVUdDXFWVxr9Qi1LoUgboiWhRFFLF1a1Hh7VsQNywiggqKoCD7LkEgQFiykoVk3ud/7ITcSSAJmeTeO/P9PM88ydxkZk4mydzfnPM/54R4PB6PAAAA+FGoP+8MAABAETAAAIDfETAAAIDfETAAAIDfETAAAIDfETAAAIDfETAAAIDfETAAAIDfhUuQKS4ulj179khcXJyEhITY3RwAAFxD1+bMysqSJk2aSGjoyfsogi5gaLho3ry53c0AAMC1du3aJc2aNTvp9wRdwNCeC++TEx8fb3dzAABwjczMTPMm3XsuPZmgCxjeYRENFwQMAACqrjIlBhR5AgAAvyNgAAAAvyNgAAAAvwu6GozKTsM5duyYFBUV2d0UIOiFhYVJeHg408oBlyFg+CgoKJC9e/dKbm6u3U0B8F9169aVxo0bS2RkpN1NAVBJBAyfRbh27Nhh3jHpIiL6Ysa7JsDe3kQN/QcOHDD/m23atKlwcR8AzkDAKEVfyDRk6BxffccEwH516tSRiIgI2blzp/kfjY6OtrtJACqBtwLl4B0S4Cz8TwJVV3CsWOzEfy0AAAEmO/+Y9Hl+sTy/YLPkFdozYYGAAQBAgHlhwWZJPZQrLy3cIv2nLJHFmw/UehsIGLDdl19+aYppjxw5YndTUAk///yz+X2tWrXKXOf3BzjLuj0Z8uY3O0qu7zyYK3/7arspmq5NBIwAMHDgQLnsssvK/dpXX31lXvx/+umnkhOD96KzZM4880x58sknLX94f/nLX6Rz584nfLxevXrJ/fffX6m2lX688i76WChLZ0zcfPPNZjaTFjXqroVXX321bNy4UZzm/PPPN1O7ExIS7G4KEPSKiz0yds5aKS6VJSLDQ+WJqzvU+qxIW2eRLFmyRJ577jlZuXKleYGaM2eODBo06ITf/+9//1teffVV884pPz9f2rdvb05Q/fv3r7Ff1OHcArFT/bqREhp68j+K22+/Xa699lr55Zdfymyf++abb0q3bt3knHPOMQFDff755+a50+fw66+/ljvuuMOsMaD342/6e/WaNWuWjB8/XjZt2lRyLDY2VlasWOH3x3WzwsJC6du3r5x99tnmb15/N/q7/fTTTx3ZS6BBNTk52e5mABCR975PlVW7rK8TI3udKS0TY2q9Lbb2YOTk5EinTp1k2rRplQ4k+sL7ySefmFByySWXmHfvP/74Y420T8NF1yc/t/VSmYBz5ZVXSsOGDeWtt96yHM/Ozpb//d//LRMcGjRoYE4Ip59+ugwZMkQuuOAC+eGHH6Qm6ON4L/oOVxN06WMaMLz0d6phSKcI67vi0kFEabhs3bq1OaHpyfcf//iH5et636+99pp5PvQ+2rZtK8uWLZOtW7eaXpeYmBhzv9u2bSvTW6O3805Pvv766yUjI6Pke3QIoHv37ub29erVM8+XTpmsSrv+9re/yeDBg83961oO8+bNO+Fztm7dOtPGV155RX7zm9+Y35M+pvY06XWvhx56SM466yxzn61atZJx48aZcOL7s73xxhvSokUL81zfe++9ZoXaZ5991jz/jRo1kqeeeqpMe/Vnuvzyy80UUb3vf/3rXydsr+8Qif4d6vP02Wefmd+BPq72sJUOm7pS7h/+8Afzffr3qD/LsGHDTvoGA8DJpWfny6RPrb2crRJj5J5ercQOtgYMfQHTF0194a2MKVOmyIMPPijnnXeeeZF++umnzccPP/xQgpkuozx06FDzwl56qEPDhZ5MbrrpphPeVnsP9MTeo0cPsdvYsWNl8uTJpk36M912220lX9PerVGjRskf//hHWbt2rdx9990yYsQIWbRokeU+nnjiCfNcaC9XSkqKGWbQ733kkUfM/erz8/vf/95yGw0gs2fPNn9H8+fPN4FVT8TeE6Ge9C6++GIzzKSB5a677irpaqxsux577DETXPQ+rrjiChPsDh06VO7zoGFRp2XqSf1ky9XHxcWZ3/n69evlxRdflNdff11eeOEFy/doUNGeD/253nvvPfn73/8uAwYMMD0iixcvlkmTJsmjjz4q3333neV2Gla0V2z16tWmrTfeeKNs2LBBKktXwv3rX/9qwpa+MUhNTZUHHnig5Ov6uDNnzjQ9bN98841kZmbK3LlzK33/AMp6+uMNkpl3zHLsiUEdJCo8TOzg6hoMXRQrKytLTjvttBN+jw4D6ItX6Usg0pOxnkz0pOGlL956kvAdG9d38fquUt9xa1jTE5+elO2m76T1RN6uXTt5+OGHZenSpZKXl2e+pier4cOHmxO/vmsfM2aMXHPNNeZ4aXpy159Hv0ffFeuwkJ4gdRhN301rGNB33KXpY7zzzjvm3f5FF10kU6dOlffff1/S0tLM34v2ZmiviPZS6H3oO23tEahKu/R7NOhpzYsGY+1dWr58ebnPQ9OmTeWll14yw0n169eX3r17m+C0fft2y/dpMNDfZcuWLU1Pnp7ANSj5/o9oD4Y+p/o92uunPUMa1rW3RZ8v/egbiK677jozdKY/kz629izp81JZ2pMyffp0c7tzzz3XhLqFCxeWfF3vS0OfvrnQIPjyyy+b3gwAp2bptnT594+7Lceu7txELjgzUezi6oChL+L6Qq0nlBOZOHGiOcF6L9oNHoj0RVpPNnoy8b4r1wLP8uoqtBZC3+Hru1M9IX3wwQfmhG43rRPx0roDtX//fvNR3z3rMEFpet33XXXp+0hKSjIfO3bsaDmmgaJ00NSwoCd1r549e5oTs56INbxqONCAoido7Sko3dV/Ku3SoZb4+PiSn608I0eONAFH3+Vre7Q3SutmFixYYPk96mN5h5o0cGhPQWkaPrSno/TPr2Gj9MJVesy3LfqYvter0oOhwzYayEr/Pr2PoYFt3759ZtjJS5fn79q1a6XvH8Bx+ceK5NG5a0sdEYmLDpexA9qKnVy7VPi7775rup315KjjyCei75L0XaWXnlgqGzK0wHLlo33ETtqGytIwcd9995maFu290Bd47RHwpT+/vpNW+o5cez60S1zH7O1chlmXg/byDkHoib6691Hd+9XnUusFdJhBT+p6ItcTfel6iKq0y9uOitqgwUBDjV50KFFDjn7UOiQdqtGeGf0f0OManrXXRYeYKnrcU2lLVZX3GLU9RQ4IFq8v2S7bD+RYjj3Y/2xpFGfvsvqu7MHQF1LtvtV33336nDwAREVFmXeLpS+VpbM3GsRG2XqpaAZJadqTo+9MNXxpl78Om1RmWpK+e9RaA93nwak0COlYfWl6Xd+NV5e+69+zZ0/J9W+//dY8jzp04NWlSxcTVnXYpkOHDuY5rul2laa/R+2l0sJope3Q4k+tW9FhCK1FKl14Wl36HPhe15/VHzQMaa/J999/X3JMa01qqtAYCGSpB3Nl6hdbLcc6NUuQm3ucLnZzXQ+GFqrpiVNDhhar4TjtJr/hhhvMiVB7arRrvzwHDx403e8aKtasWWO6/XVsvnT4Onr0aMlCSqXfUXu7vXV3S9+vaze4d1jC3/70pz+ZAKUneg2VWpCpUzh1ym11aa+N1lXokJs+b9pboY+lQw+6HsWMGTPkqquuMmtS6LDJli1bSmpWaqJd+rxOmDBBbr31VhNUtFZGa2t0+EvrSpQGCg1G+n+gdTQff/yxKTj1Fx2S0eBy4YUXmmEarRfRAlF/0Z42Hb7UnjQNTlqTcfjwYXYvBqpAewXHfbBW8kvtOaLvSZ8a3FHCqvDmNCADhtZPaK2Al76Y64urjnvruLieKHfv3m3ejSt916gnAj0h6qwHPUkqnUrHIj/Hh0n0RKAzFfSEWB5vr4/2XGgo0O/1naq4efNmc9Is7dJLLy05cervwvsu3kuLAXX4oCboTA79vWsI0ELNM844wwxd6PTT6tKTnBZm6vOgMzu0oFOniHprCXRxq7ffftsEM32+tD5CZ4vUVLt0LROtndDhD+/iaN7ro0ePNt+jgUc/1+JJLWTWsO0d5vIHfSwNL1q8qj+zBnt/9spoUNL/Xw1q+neoM3N0qEc/B1A5n65NK7ME+NCeLaVDU2ecD0M8Ng6MajW/vnP2pSFCp9/pO3B9gfVW/euLdulZEr7fXxn6DlXDiBaa+Q6XaPGfhhw9SbAldHDQE7JOj/TtjQlmGmgqWvTO37QGRIdgtDdIg6ov/jcBq6y8QrOZ2b7M/JJjjeKiZOEfL5a4aGsNlD+d7BzqqB4MDQwnyze+ocF3eiEAd9J6kf/85z+mCFl7YHSaqnd5dAAVe2HBFku4UBMGtq/RcBEURZ4A3E2LaPUNhNaP6FRbrQXS4Td/FZICgWzt7gx5a+nxzczURWc1lCs6OmvJfluHSOzAEAngPvxvAr8qKvbINa8uldWl9hvRzcwWjL5ITm9Q8/uNVGWIhB4MAABc4r3lqZZwoX5/yZm1Ei6qioBRjiDr1AEcj/9JQORAVr5Mml92M7O7L7ZnM7OKEDDKWX1QN2oC4Bze/0nfFUKBYPL0Jxsky2czsydt3Mws4Bbaqkk6B183XPLumaBrILDwD2Bvz4WGC/2f1P9N1slAsFq6NV3m+GxmNqhzEznfxs3MKkLA8KGrN6qTbUQFoHZpuPD+bwLBJv+Em5n5d0sCfyNg+NAeC125UDdQ0y2nAdhLh0XouUAwm7F4u2xPt25m9tBlKdIwLkqcjIBxAvqCxosaAMBOP6fnyNRFPpuZNa8nN3dvIU5HkScAAA6tQRo/b50U+G5mNqhDlXbatgsBAwAAB/pkTZos8dnMbPj5ZzhmM7OKEDAAAHDgZmaPfbjOciwpPkrG9DtL3IKAAQCAw0z+z2bZn1V2M7PYKPeUThIwAABw2GZm7yz72XLs4rMayuUd3DVVm4ABAICDNjMbO2eNFJdaHT8qPFQev7q96xZ+JGAAAOAQ7+pmZr9kWI7d19uZm5lVhIABAIAD7M/Kk2d9NzNrGCN3XuTMzcwqQsAAAMABnvrYXZuZVYSAAQCAzb7Zmi4frNpjOXZNl6ZyfmvnbmZWEQIGAAA2yissu5lZfHS4/HlAW3EzAgYAADZ6bfF22eG7mdnlKZIY6+zNzCpCwAAAwMbNzKZ9ad3MrHPzenLTec7fzKwiBAwAAGzazGzcB2vLbmY22B2bmVWEgAEAgA0++mmvfLUl3XJsxAVnSPsm7tjMrCIEDAAAallmXqE88dF6y7Hk+GgZ3dc9m5lVhIABAEAte77czczauWozs4oQMAAAqEVrfim7mdklZzeUy1y2mVlFCBgAANTmZmZzy25m9thVHVy3mVlFCBgAANSSmd/tlJ98NjP7w6VtpEWDuhJoCBgAANTSZmbPzd9kOXZmo1i587fu3MysIgQMAABqwZMfbZCsfOtmZk9c3UEiwwPzVByYPxUAAA7y1ZYDMm+1z2Zm5zaVnq0bSKAiYAAAUMObmY3/YJ3lWEKdCPnzFe7ezKwiBAwAAGrQ9MXbym5mdpn7NzOrCAEDAIAasiM9R15ZtM1yrEuLenLjec0l0BEwAACooc3MxutmZkXHNzMLCw2RpwZ1DIjNzCpCwAAAoAZ8WN5mZue3lHZN4iUYEDAAAKiFzcwaJ0TL/QG0mVlFCBgAAPjZ5M82yYEA38ysIgQMAAD86Kdfjsg73+60HOud0kj6tw+szcwqQsAAAMCfm5nNWSueUpuZRUfoZmbtA24zs4oQMAAA8JN/frtT1uy2bmZ2X+820vy0wNvMrCIEDAAA/GB/Zp789bPg2cysIgQMAAD84ImPy25m9uSgwN3MrCLB+VMDAOBHSzYfkA99NjO79txm8ptWgbuZWUUIGAAAVHszs7XlbGaWIsGMgAEAQDW8+uU2+flgruXYw5enSIMA38ysIgQMAABO0fYD2SZglHZui3pyQ7fA38ysIsGzpBiAKissKpaD2QVmRcL9WXnmo7lk//ejOZ4vh3MKpLj0xH8gSBQWecpuZjY4ODYzqwgBAwjCHR4zjx6TA9l5sj/TGha84cF7/FBOgd3NBVzltgtaStvGwbGZWUUIGEAAFZqlazgoHRZK9Tbo8fT/Hiv9jguAf5jNzPoEz2Zmjg4YS5Yskeeee05Wrlwpe/fulTlz5sigQYNOepsvv/xSxowZI+vWrZPmzZvLo48+KsOHD6+1NiOwHS0okpU7D0t2fqE4UU5+kc/wxPFhi8w86/x7ALUnJjJMXryxi8QE0WZmFbH1mcjJyZFOnTrJbbfdJtdcc02F379jxw4ZMGCA3HPPPTJz5kxZuHCh3HHHHdK4cWPp379/rbQZgR0uBk37Rjbty7K7KY4THhoiibFR0jAuShrF/fqx5BIbJYlxUeZ7gGAUGhIiZyXFSZ3IMLub4ii2BozLL7/cXCpr+vTpcsYZZ8jkyZPN9bZt28rXX38tL7zwAgED1faf9WlBFy50rr43JJQbHsyxaKlXJ4KiNQBV4qq+nGXLlkmfPn0sxzRY3H///Se8TX5+vrl4ZWZm1mgb4V4//WLdoMitIsNCywkJx3sbvMe0RyI6gndcAGqGqwJGWlqaJCUlWY7pdQ0NR48elTp16pS5zcSJE+Wxxx6rxVbCrTbstYbPBjGR5h2+k+ieBr5BwRIiYqMlvk540G0LDcB5XBUwTsUjjzxiikK9NIxocSjgO3VzvU/A0Lnsl3VItq1NAOBmrgoYycnJsm/fPssxvR4fH19u74WKiooyF+Bk0jLz5EiudeZI+ybMZQeAoFgqvGfPnmbmSGkLFiwwx4HqWL/H2nsRFxUuzeqXH1oBAA4PGNnZ2bJq1Spz8U5D1c9TU1NLhjeGDh1a8v06PXX79u3y4IMPysaNG+WVV16R2bNny+jRo237GRCY9Re6Eh91DADg0oCxYsUK6dKli7korZXQz8ePH2+u6+Jb3rChdIrqxx9/bHotdP0Mna76t7/9jSmqqDbf+ou2jeNsawsABAJbazB69epliutO5K233ir3Nj/++GMNtwzBZsNe6/oX7ai/AIDgqcEAakJO/jH5+WCO5RibFQFA9RAwEPQ2pmVJ6Y403W5Zl/0FAJw6AgaCnm/9RavEGFa4BIBqImAg6PnOIKH+AgCqj4CBoOe7Bgb1FwBQfQQMBLWiYo9sSvOZQULAAIBqI2AgqOnskaOFRZZj9GAAQPURMBDUfOsvvDuTAgCqh4CBoEb9BQDUDAIGglqZGSQEDADwCwIGghp7kABAzSBgIGgdzM6XfZn5lmPtWQMDAPyCgIGg5bvBWVR4qLRsEGNbewAgkBAwELR86y9SkuMkPIx/CQDwB15NEbTK1l8wPAIA/kLAQNBiDxIAqDkEDASl/GNFsnV/tuUYPRgA4D8EDASlLfuy5Vixp0wNBgDAPwgYCEq+9RenN6grcdERtrUHAAINAQNBybf+om0ywyMA4E8EDAQl3z1IKPAEAP8iYCDoeDwepqgCQA0jYCDo7D5yVLLyjlmO0YMBAP5FwIAE+/BIfHS4NEmItq09ABCICBiQYN+DRHsvQkJCbGsPAAQiAgaCzvq9GZbr1F8AgP8RMBB0yvRgEDAAwO8IGAgqWXmFknoo13KMHgwA8D8CBoLKxjRr70V4aIi0SYq1rT0AEKgIGAjqGSRnNoqVqPAw29oDAIGKgIHg3qKd4REAcE7AOHbsmHz++efy2muvSVbWr13Oe/bskexs6/bXgNOwgicA1I7wqt5g586dctlll0lqaqrk5+dL3759JS4uTiZNmmSuT58+vWZaClTTsaJi2eRTg8EKngDgkB6MUaNGSbdu3eTw4cNSp06dkuODBw+WhQsX+rt9gN/sSM+R/GPFlmP0YACAQ3owvvrqK1m6dKlERkZajrds2VJ2797tz7YBNTo8khwfLafFWP+OAQA29WAUFxdLUVFRmeO//PKLGSoB3FN/wd8rADgmYPTr10+mTJlScl33cNDizgkTJsgVV1zh7/YBNboHCQDAIUMkkydPlv79+0u7du0kLy9Pbr75ZtmyZYskJibKe++9VzOtBGpgDQzqLwDAQQGjWbNmsnr1ann//fflp59+Mr0Xt99+uwwZMsRS9Ak4yf6sPEnPzrccYw0MAHBQwDA3Cg+XW265xf+tAWppeKRORJic3iDGtvYAQKCrcsB45513Tvr1oUOHVqc9QK2s4JnSOE7CQkNsaw8ABLrwU1kHo7TCwkLJzc0101br1q1LwIAjUX8BAA6fRaILbJW+aA3Gpk2b5MILL6TIE47FHiQA4MLNztq0aSPPPPNMmd4NwAnyCotk2wHrPjn0YACAS3ZT1cJP3fAMcJrN+7Kk2HP8ekiISEoyi2wBgKNqMObNm2e57vF4ZO/evfLyyy/LBRdc4M+2ATVSf9GyQYzERJ3SBCoAQCVV+VV20KBBluu6kmfDhg2ld+/eZhEuwGmovwAAFwQM3YsEcBP2IAEAF9dgAE5UXOxhDxIAcGoPxpgxYyp9h88//3x12gP41S+Hj0p2/jHLMWaQAIBDAsaPP/5YqTvTeoyqmjZtmjz33HOSlpYmnTp1kqlTp0r37t1P+P26k+urr74qqampZoO1//mf/5GJEydKdHR0lR8bwTc8Ur9uhCTH87cCAI4IGIsWLaqRB581a5bpHZk+fbr06NHDhAfdqVUX7mrUqFGZ73/33Xfl4YcfljfeeEPOP/982bx5swwfPtwEG3pOULn6i/hTCsIAABfVYGgouPPOO2XEiBFm+3cNGrrcuAaI8ixdutRMhdUt4lu2bCn9+vWTm266SZYvX17rbYc7MIMEAOxxSosBrFixQmbPnm2GKQoKCixf+/e//12p+9DbrVy5Uh555JGSY6GhodKnTx9ZtmxZubfRXot//vOfJlDoMMr27dvlk08+kVtvvfVUfgwEAfYgAQCX9GC8//775kS/YcMGmTNnjtnsbN26dfLFF19IQkJCpe8nPT1dioqKJCkpyXJcr2s9Rnm05+Lxxx83+55ERERI69atpVevXvLnP//5hI+Tn58vmZmZlguCQ8bRQtl95KjlGDNIAMChAePpp5+WF154QT788EOzg+qLL74oGzdulOuvv15atGghNenLL780j//KK6/IDz/8YHpLPv74Y3niiSdOeBstANXg4700b968RtsI5w6PRISFSOuGsba1BwCCSZUDxrZt22TAgAHmcw0YOTk5pmhu9OjRMmPGjErfj84ACQsLk3379lmO6/Xk5ORybzNu3DgzHHLHHXdIx44dZfDgwSZwaIg40QJgOgSTkZFRctm1a1eVfl4ETsBo0yhOIsNZ+gUAakOVX23r168vWVm/LlzUtGlTWbt2rfn8yJEjkpubW+n70XDStWtXWbhwYckxDQl6vWfPnuXeRu9f6zRK05Di3ROlPFFRURIfH2+5IDhQfwEALiryvOiii2TBggWmB+G6664zW7Rr/YUeu/TSS6t0XzpFddiwYdKtWzdTtKnTVLVHRGeVqKFDh5oQoz0UauDAgWbmSZcuXcy01q1bt5peDT3uDRqA14Y0nxkk1F8AgHMDhu6ampeXZz4fO3asKbbU6aPXXnutPProo1W6rxtuuEEOHDgg48ePN4WdnTt3lvnz55cUfuosldI9Fnr/OhyjH3fv3m02WdNw8dRTT1X1x0CAKywqls1p2ZZj7EECALUnxHOisYUApbNItNhT6zEYLglcm9KypP+UJZZjq8b3lXp1I21rEwAE0zm0yjUYuk7FW2+9xXRPONr6vRmW603r1SFcAEAtqnLAaN++vZmZoTM9tAbjgw8+MGthAE7iu4MqwyMA4PCAoeteaP3D3LlzJSYmxhRias3EXXfdJYsXL66ZVgLVnEHCEuEAULtOaVEALbzUfUB0qETXrXjttdfM8t29e/f2fwuBKtKyIt81MJiiCgAu2IvES2d+6NLhuj/ITz/9dNJt1oHasj8rXw7mWPfIYYoqADi8B0OLO998803p27evWXb71Vdflauuukq2bNki3377bc20EqjGFu0xkWHSvH5d29oDAMGoyj0YWm+hq3nqGha6AJYukgU4fQXP0NAQ29oDAMGoygFj3rx5ZsVO3yW7Aaeg/gIAXBgwdGgEcNMQCfUXAFD76IZAQMktOCY70nMsx+jBAIDaR8BAwC0RXnrxey29ODuJRbYAoLYRMBDQK3iekRgjdSLZaRcAHB8w3nnnHcnPzy9zvKCgwHwNcNIeJO2aJNjWFgAIZlUOGCNGjDC7qPnKysoyXwPsxB4kAODSgKHLMIeElF1T4JdffjFbuAJ2KS4uu0Q4e5AAgMOnqXbp0sUEC73oOhjh4cdvWlRUJDt27JDLLrusptoJVCj1UK7kFhRZjhEwAMDhAWPQoEHm46pVq6R///4SGxtb8rXIyEhp2bKlXHvttTXTSuAU1r9IjI2UhnFRtrUHAIJZpQPGhAkTzEcNEjfeeKNERfHCDeev4FnecB4AwIE1GLol+4EDB0qu6zbt999/v8yYMcPfbQOqtQcJwyMA4KKAcfPNN8uiRYtKtmvv06ePCRljx46Vxx9/vCbaCFQKe5AAgIsDxtq1a6V79+7m89mzZ0vHjh1l6dKlMnPmTHnrrbdqoo1AhY7kFsiejDzLMfYgAQAXBYzCwsKS+ovPP/9crrrqKvN5SkqK7N271/8tBE6hwDMyPFRaJcbY1h4ACHZVDhjt27eX6dOny1dffSULFiwomZq6Z88eadCgQU20Eahy/YXuPxIexkr4AGCXKr8CT5o0SV577TXp1auX3HTTTdKpUydzfN68eSVDJ0BtYwVPAHDpNFUvDRbp6emSmZkp9evXLzl+1113Sd26df3dPuCUhkiYQQIA9jqlPmRdLnzlypWmJ0P3IPEutkXAgB0KjhXL1v2+PRgEDABwVQ/Gzp07Td1Famqq2VW1b9++EhcXZ4ZO9LrWZwC1aev+bCks8liOtWUGCQC4qwdj1KhR0q1bNzl8+LDUqVOn5PjgwYNl4cKF/m4fUOX1L5rVryPx0RG2tQcAcAo9GDp7RNe90CGR0nQJ8d27d/uzbUClUH8BAAHQg1FcXGx2Ty1vu3YdKgFqGyt4AkAABIx+/frJlClTSq7rZlLZ2dlmM7QrrrjC3+0DKiw4LtODQf0FALhviGTy5Mlmu/Z27dpJXl6e2Ztky5YtkpiYKO+9917NtBI4gbTMPDmSW2g5xhAJALgwYDRr1kxWr14ts2bNMh+19+L222+XIUOGWIo+ATtW8IyLCjdFngAAlwUMc6PwcBMo9AI4rf5Ch+0AAC4LGAcPHizZc2TXrl3y+uuvy9GjR2XgwIFy0UUX1UQbgROi/gIAXF7kuWbNGjMVtVGjRmbn1FWrVsl5550nL7zwgsyYMUN69+4tc+fOrdnWAj7YgwQAXB4wHnzwQenYsaMsWbLE7Edy5ZVXyoABAyQjI8MsunX33XfLM888U7OtBUrJyT8mPx/MsRxr1zjBtvYAAE5hiOT777+XL774Qs455xyzg6r2Wtx7770SGvprRrnvvvvkN7/5TWXvDqi2jWlZ4im1QnhYaIi0SYq1s0kAgKr2YBw6dEiSk5PN57GxsRITE2PZTVU/9258BthRf9G6YYxER4TZ1h4AwCkutOVbnU+1Ppw0RZUVPAHApbNIhg8fLlFRUeZzXWTrnnvuMT0ZSndSBeycosoCWwDgwoAxbNgwy/VbbrmlzPcMHTrUP60CKlBU7JGNafRgAIDrA8abb75Zsy0BqkBnj+QVFluOETAAwMWbnQFOrL9oGBdlLgAAZyBgwJWovwAAZyNgwJVYIhwAnI2AgYDZ5AwA4BwEDLjOwex82ZdpnRbNEAkAOAsBA67f4Cw6IlTOSPx1PRYAgDMQMOA66/dmWK6fnRxv9iEBADgHAQOu78FoxxbtAOA4tgeMadOmScuWLSU6Olp69Oghy5cvP+n3HzlyREaOHCmNGzc2y5afddZZ8sknn9Rae+G8NTCovwAAl+9F4m+zZs2SMWPGyPTp0024mDJlivTv3182bdokjRo1KvP9BQUF0rdvX/O1f/3rX9K0aVPZuXOn1KtXz5b2o/blFRbJtgPZlmPMIAEA57E1YDz//PNy5513yogRI8x1DRoff/yxvPHGG/Lwww+X+X49rtvGL126VCIiIswx7f1A8Ni6P1uOFXssx1IIGADgOLYNkWhvxMqVK6VPnz7HGxMaaq4vW7as3NvMmzdPevbsaYZIkpKSpEOHDvL0009LUVHRCR9Hd3nNzMy0XBA4C2yd3qCuxEbZmpMBAE4KGOnp6SYYaFAoTa+npaWVe5vt27eboRG9ndZdjBs3TiZPnixPPvnkCR9n4sSJkpCQUHJp3ry5338W1B7qLwDAHWwv8qyK4uJiU38xY8YM6dq1q9xwww0yduxYM7RyIo888ohkZGSUXHbt2lWrbYZ/sYInALiDbX3LiYmJEhYWJvv27bMc1+vJycnl3kZnjmjthd7Oq23btqbHQ4dcIiMjy9xGZ5roBe7n8XjK7kFCwAAAR7KtB0PDgPZCLFy40NJDode1zqI8F1xwgWzdutV8n9fmzZtN8CgvXCCw7D5yVLLyjlmOtWWTMwBwJFuHSHSK6uuvvy5vv/22bNiwQX73u99JTk5OyaySoUOHmiEOL/26ziIZNWqUCRY640SLPLXoE8FXf5FQJ0KaJETb1h4AwInZWn6vNRQHDhyQ8ePHm2GOzp07y/z580sKP1NTU83MEi8t0Pzss89k9OjRcs4555h1MDRsPPTQQzb+FLBrBc+2jeMkJIQlwgHAiUI8OrAdRHSaqs4m0YLP+Hi6193k7n+skM/WHa/Zue2CM2T8wHa2tgkAgklmFc6hrppFguBWXg8GAMCZCBhwhay8Qkk9lGs51o4CTwBwLAIGXGFjmrX3Ijw0RM5sFGtbewAAJ0fAgCtnkGi4iAo/vh4KAMBZCBhw5QqeLLAFAM5GwIArlFnBk/oLAHA0AgYc71hRsWzyqcFgDxIAcDYCBhxvR3qO5B87vjy8ImAAgLMRMOC64ZHk+Gg5LYa9ZwDAyQgYcDzqLwDAfQgYcDxW8AQA9yFgwHVrYLRrnGBbWwAAlUPAgKPtz8qT9Ox8yzF6MADA+QgYcNXwSN3IMDm9QYxt7QEAVA4BA65awfPs5DgJCw2xrT0AgMohYMBl9RfMIAEANyBgwFU9GCywBQDuQMCAY+UVFsm2A9mWY6yBAQDuQMCAY23elyXFnuPXQ0JEUpKZQQIAbkDAgGvqL85oECN1I8Ntaw8AoPIIGHAs6i8AwL0IGHAs9iABAPciYMCRios97EECAC5GwIAj/XL4qGTnH7McYw8SAHAPAgZcMTxSv26EJMVH2dYeAEDVEDDgmvqLEJ2nCgBwBQIG3DGDJJkCTwBwEwIG3LEHCTNIAMBVCBhwnIyjhbL7yFHLMQIGALgLAQOOHx6JDAuV1g1jbWsPAKDqCBhwfMBokxQrEWH8qQKAm/CqDcfXX7BEOAC4DwEDjrMhzafAk4ABAK5DwICjFBYVy+a0bMsxejAAwH0IGHCU7QdypKCo2HKMHgwAcB8CBhxl/d4My/Wm9epIQt0I29oDADg1BAw4StkdVOm9AAA3ImDA2St4skU7ALgSAQOO4fF4yqyBwQqeAOBOBAw4xv6sfDmYU2A5xhAJALgTAQOO3aI9Nipcmteva1t7AACnjoABx9ZfpCTHSWhoiG3tAQCcOgIGHIP6CwAIHAQMOHaIhPoLAHAvAgYcIbfgmOxIz7EcYwVPAHAvAgYcYVNalng8x69r6cXZyayBAQBuRcCAI1fwbNUwVqIjwmxrDwCgeggYcOQeJNRfAIC7ETDgyB4M6i8AwN0IGLBdcXHZJcLbsgcJALgaAQO2Sz2UK7kFRZZjrIEBAO7miIAxbdo0admypURHR0uPHj1k+fLllbrd+++/LyEhITJo0KAabyNqb/2LxNhIaRQXbVt7AAABEDBmzZolY8aMkQkTJsgPP/wgnTp1kv79+8v+/ftPeruff/5ZHnjgAfntb39ba21FzSg7PELvBQC4ne0B4/nnn5c777xTRowYIe3atZPp06dL3bp15Y033jjhbYqKimTIkCHy2GOPSatWrWq1vaj5PUgo8AQA97M1YBQUFMjKlSulT58+xxsUGmquL1u27IS3e/zxx6VRo0Zy++23V/gY+fn5kpmZabnA2UMk1F8AgPvZGjDS09NNb0RSUpLluF5PS0sr9zZff/21/P3vf5fXX3+9Uo8xceJESUhIKLk0b97cL22HfxzOKZC9GXmWYwyRAID72T5EUhVZWVly6623mnCRmJhYqds88sgjkpGRUXLZtWtXjbcTp15/ERkeKq0SY2xrDwDAP8LFRhoSwsLCZN++fZbjej05ObnM92/bts0Udw4cOLDkWHFxsfkYHh4umzZtktatW1tuExUVZS5wx/DI2UlxEh7mqtwLACiHra/kkZGR0rVrV1m4cKElMOj1nj17lvn+lJQUWbNmjaxatarkctVVV8kll1xiPmf4IwDqLxgeAYCAYGsPhtIpqsOGDZNu3bpJ9+7dZcqUKZKTk2NmlaihQ4dK06ZNTS2FrpPRoUMHy+3r1atnPvoehzuXCGcFTwAIDLYHjBtuuEEOHDgg48ePN4WdnTt3lvnz55cUfqamppqZJQg8BceKZet+nz1ImiTY1h4AgP+EeDwejwQRnaaqs0m04DM+nu54u9e/uOKlryzHfvpLP4mPjrCtTQAA/5xD6RqAY+ovmp9Wh3ABAAGCgAHnLBGeTI8SAAQKAgacs0Q4K3gCQMAgYMAWWvqzIY1NzgAgUBEwYAtdHvxIbqHlGGtgAEDgIGDAEfUXcdHh0qx+HdvaAwDwLwIGHFF/ocMjISEhtrUHAOBfBAzYwrf+guERAAgsBAw4YwYJAQMAAgoBA7UuO/+Y7DyUaznGFFUACCwEDNS6TWmZUnqB+rDQEDmzUaydTQIABNpmZ6g5RwuKZNuBbDlaWCROsnDDfsv1MxvGSnREmG3tAQD4HwEjABQXe+SXw0dN4eTGvVmyad+vH3cczLH0FDgVW7QDQOAhYLhMxtFC2ZSWJRvTMmXD3l8/bk7LkpwCZ/VSVAX1FwAQeAgYDlVYVCw70nNko4aJvZklH/dk5EmgOb91ot1NAAD4GQHDAXtyHMjO/3VoIy2rZJhj6/5sKSgqrvb969pVsVHh4sQlrOKiI2Roz9OlQ9MEu5sCAPAzAkYtyisski37ssvUShzMKfDL/devGyEpyfGS0jjObH2uH9s0ipM6kRRQAgBqFwGjhnoltOjSMryRlmmGPIr9UHQZERYirRvGmuW1U5LjJKVxvLRNjpOGcVEstw0AcAQCRjVl5nmLLo+HCb2ui0n5Q+OEaBMizk6ON7MttIeiVcMYiQhjCRMAgHMRMKrZU9HruS/lkB+GOOpEhMnZyXEmRJyd9GuvhAaLenUj/dJWAABqEwGjGnQ44qykWPl2+6Eq3Ebk9NPqltRKmCGO5HhpcVpdCQ1leAMAEBgIGNWk4eBEASOhjhZdaq/Er70R2kNxVlKcxETxtAMAAhtnumrSIY3w0F+LLn/tkTg+iyMpnqJLAEBwImBU09Wdm8rgLs0kMpyiSwAAvAgY1cQmXQAAlMXbbgAA4HcEDAAA4HcEDAAA4HcEDAAA4HcEDAAA4HcEDAAA4HcEDAAA4HcEDAAA4HcEDAAA4HfhwbjFusrMzLS7KQAAuIr33Ok9l55M0AWMrKws87F58+Z2NwUAANeeSxMSEk76PSGeysSQAFJcXCx79uyRuLg4v+10qolOA8uuXbskPj7eL/cZ6HjOqo7nrOp4zqqO56zqguk583g8Jlw0adJEQkNPXmURdD0Y+oQ0a9asRu5b/7AC/Y/L33jOqo7nrOp4zqqO56zqguU5S6ig58KLIk8AAOB3BAwAAOB3BAw/iIqKkgkTJpiPqByes6rjOas6nrOq4zmrOp6z8gVdkScAAKh59GAAAAC/I2AAAAC/I2AAAAC/I2AAAAC/I2D4wbRp06Rly5YSHR0tPXr0kOXLl9vdJMeaOHGinHfeeWYl1UaNGsmgQYNk06ZNdjfLNZ555hmzAu39999vd1Mcb/fu3XLLLbdIgwYNpE6dOtKxY0dZsWKF3c1ypKKiIhk3bpycccYZ5rlq3bq1PPHEE5XabyJYLFmyRAYOHGhWsNT/wblz51q+rs/V+PHjpXHjxuY57NOnj2zZskWCGQGjmmbNmiVjxowxU5R++OEH6dSpk/Tv31/2799vd9McafHixTJy5Ej59ttvZcGCBVJYWCj9+vWTnJwcu5vmeN9//7289tprcs4559jdFMc7fPiwXHDBBRIRESGffvqprF+/XiZPniz169e3u2mONGnSJHn11Vfl5Zdflg0bNpjrzz77rEydOtXupjmGvkbp67u+oSyPPl8vvfSSTJ8+Xb777juJiYkx54K8vDwJWjpNFaeue/funpEjR5ZcLyoq8jRp0sQzceJEW9vlFvv379e3SJ7Fixfb3RRHy8rK8rRp08azYMECz8UXX+wZNWqU3U1ytIceeshz4YUX2t0M1xgwYIDntttusxy75pprPEOGDLGtTU6mr1lz5swpuV5cXOxJTk72PPfccyXHjhw54omKivK89957nmBFD0Y1FBQUyMqVK01XWOm9TvT6smXLbG2bW2RkZJiPp512mt1NcTTt9RkwYIDlbw0nNm/ePOnWrZtcd911ZiiuS5cu8vrrr9vdLMc6//zzZeHChbJ582ZzffXq1fL111/L5ZdfbnfTXGHHjh2SlpZm+f9MSEgwQ+bBfC4Ius3O/Ck9Pd2MXSYlJVmO6/WNGzfa1i437WyrtQTald2hQwe7m+NY77//vhl+0yESVM727dtNl78OX/75z382z90f/vAHiYyMlGHDhtndPMd5+OGHzY6gKSkpEhYWZl7XnnrqKRkyZIjdTXMFDReqvHNB2n+/FowIGLD1XfnatWvNOyWUT7d/HjVqlKlX0SJiVD68ag/G008/ba5rD4b+ren4OAGjrNmzZ8vMmTPl3Xfflfbt28uqVatM+NeCRp4vnCqGSKohMTHRpP19+/ZZjuv15ORk29rlBr///e/lo48+kkWLFkmzZs3sbo5j6RCcFgyfe+65Eh4ebi5aKKvFZPq5vtNEWVrJ365dO8uxtm3bSmpqqm1tcrI//elPphfjxhtvNLNtbr31Vhk9erSZ9YWKeV/vORdYETCqQbtbu3btasYuS79z0us9e/a0tW1OpfVRGi7mzJkjX3zxhZkWhxO79NJLZc2aNeYdpfei78y161o/14CLsnTYzXf6s9YXnH766ba1yclyc3NN/Vhp+relr2eomL6OaZAofS7IzMw0s0mC+VzAEEk16RivdiHqi3737t1lypQpZjrTiBEj7G6aY4dFtBv2gw8+MGtheMcntSBK547DSp8j3/oUnf6maztQt3Ji+u5bCxd1iOT66683a9PMmDHDXFCWru+gNRctWrQwQyQ//vijPP/883LbbbfZ3TTHyM7Olq1bt1oKOzXka4G6Pm86pPTkk09KmzZtTOAYN26cGWLStX6Clt3TWALB1KlTPS1atPBERkaaaavffvut3U1yLP2TK+/y5ptv2t0012CaauV8+OGHng4dOpipgikpKZ4ZM2bY3STHyszMNH9T+joWHR3tadWqlWfs2LGe/Px8u5vmGIsWLSr3tWvYsGElU1XHjRvnSUpKMn9zl156qWfTpk2eYMZ27QAAwO+owQAAAH5HwAAAAH5HwAAAAH5HwAAAAH5HwAAAAH5HwAAAAH5HwAAAAH5HwADgSi1btjQr5wJwJgIGgAoNHz68ZMnjXr16mWWRa8tbb70l9erVK3Nct2C/6667aq0dAKqGvUgA2KKgoMBsGHiqGjZs6Nf2APAvejAAVKknQ7eLf/HFFyUkJMRcfv75Z/O1tWvXyuWXXy6xsbGSlJRktvxOT08vua32fOhOutr7kZiYKP379zfHdVMt3SJcN3Fr3ry53HvvvWZjKfXll1+ajQMzMjJKHu8vf/lLuUMkuhX71VdfbR4/Pj7ebHJWevtsvV3nzp3lH//4h7mtbrCn25NnZWXV2vMHBBMCBoBK02Ch20/feeedsnfvXnPRUHDkyBHp3bu3dOnSRVasWCHz5883J3c9yZf29ttvm16Lb775RqZPn26O6TbhL730kqxbt858/YsvvpAHH3zQfE13RNUQoYHB+3gPPPBAmXbptuIaLg4dOmQC0IIFC2T79u1yww03WL5v27ZtMnfuXPnoo4/MRb/3mWeeqdHnDAhWDJEAqDR9168BoW7dupKcnFxy/OWXXzbhQrdH93rjjTdM+Ni8ebOcddZZ5phuZf3ss89a7rN0PYf2LOiW1/fcc4+88sor5rH0MbXnovTj+Vq4cKGsWbPGbKGtj6neeecds/W41mqcd955JUFEazri4uLMde1l0dvqVuUA/IseDADVtnr1alm0aJEZnvBeUlJSSnoNvLp27Vrmtp9//rlceuml0rRpU3Pi15P+wYMHJTc3t9KPv2HDBhMsvOFCtWvXzhSH6tdKBxhvuFCNGzeW/fv3n9LPDODk6MEAUG1aMzFw4ECZNGlSma/pSdxL6yxK0/qNK6+8Un73u9+ZXoTTTjtNvv76a7n99ttNEaj2lPhTRESE5br2jGivBgD/I2AAqBIdtigqKrIcO/fcc+X//u//TA9BeHjlX1ZWrlxpTvCTJ082tRhq9uzZFT6er7Zt28quXbvMxduLsX79elMboj0ZAGofQyQAqkRDxHfffWd6H3SWiAaEkSNHmgLLm266ydQ86LDIZ599ZmaAnCwcnHnmmVJYWChTp041RZk6w8Nb/Fn68bSHRGsl9PHKGzrp06ePmYkyZMgQ+eGHH2T58uUydOhQufjii6Vbt2418jwAODkCBoAq0VkcYWFhpmdA16LQ6aFNmjQxM0M0TPTr18+c7LV4U2sgvD0T5enUqZOZpqpDKx06dJCZM2fKxIkTLd+jM0m06FNnhOjj+RaJeoc6PvjgA6lfv75cdNFFJnC0atVKZs2aVSPPAYCKhXg8Hk8lvg8AAKDS6MEAAAB+R8AAAAB+R8AAAAB+R8AAAAB+R8AAAAB+R8AAAAB+R8AAAAB+R8AAAAB+R8AAAAB+R8AAAAB+R8AAAAB+R8AAAADib/8PCURHkDMqPjYAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -571,12 +604,12 @@ "source": [ "# Bayesian optimization on Ackley2D\n", "\n", - "Lastly, lets also run Thompson sampling with VBLLs on the standard benchmark Ackley. Parts of the code are copied from the TuRBO tutorial." + "Lastly, lets also run Thompson sampling with VBLLs on the standard benchmark Ackley. Parts of the code are copied from the [TuRBO tutorial](https://botorch.org/docs/tutorials/turbo_1/)." ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "d381e53c", "metadata": {}, "outputs": [ @@ -585,65 +618,65 @@ "output_type": "stream", "text": [ "Iteration 0) \t Best Value: -8.450333157127485\n", - "Early stopping at epoch 4679 with loss 5.71127556426972\n", + "Early stopping at epoch 5045 with loss 7.074760507691988\n", "Iteration 1) \t Best Value: -8.450333157127485\n", - "Early stopping at epoch 549 with loss 414.52220814723216\n", + "Early stopping at epoch 9201 with loss 5.572309673488878\n", "Iteration 2) \t Best Value: -8.450333157127485\n", - "Early stopping at epoch 5071 with loss 3.3508427848898767\n", + "Early stopping at epoch 10000 with loss 6.516906743457357\n", "Iteration 3) \t Best Value: -8.450333157127485\n", - "Early stopping at epoch 5381 with loss 3.459799186324661\n", - "Iteration 4) \t Best Value: -3.9786451141759156\n", - "Early stopping at epoch 4833 with loss 2.6036754003988127\n", - "Iteration 5) \t Best Value: -3.9786451141759156\n", - "Early stopping at epoch 7149 with loss 2.3706048504297788\n", - "Iteration 6) \t Best Value: -3.9786451141759156\n", - "Early stopping at epoch 6636 with loss 2.2300785975157407\n", - "Iteration 7) \t Best Value: -3.9786451141759156\n", - "Early stopping at epoch 7487 with loss 2.2630146130558413\n", - "Iteration 8) \t Best Value: -3.0623108858518546\n", - "Early stopping at epoch 5407 with loss 1.1503732474472212\n", - "Iteration 9) \t Best Value: -1.4951551049339042\n", - "Early stopping at epoch 7899 with loss 1.6488724531901233\n", - "Iteration 10) \t Best Value: -1.4951551049339042\n", - "Early stopping at epoch 3443 with loss 581.245456690729\n", - "Iteration 11) \t Best Value: -1.4951551049339042\n", - "Early stopping at epoch 6839 with loss 0.7179800427600189\n", - "Iteration 12) \t Best Value: -1.4951551049339042\n", - "Early stopping at epoch 7264 with loss 1.049935252601062\n", - "Iteration 13) \t Best Value: -1.4951551049339042\n", - "Early stopping at epoch 2818 with loss 341.0419177183832\n", - "Iteration 14) \t Best Value: -1.4951551049339042\n", - "Early stopping at epoch 1717 with loss 819.1292796120731\n", - "Iteration 15) \t Best Value: -1.4951551049339042\n", - "Early stopping at epoch 779 with loss 324.74201771197414\n", - "Iteration 16) \t Best Value: -1.4951551049339042\n", - "Early stopping at epoch 2809 with loss 334168.7470767889\n", - "Iteration 17) \t Best Value: -1.1834588468201734\n", - "Early stopping at epoch 3899 with loss 224.5554078222428\n", - "Iteration 18) \t Best Value: -0.47914417661898456\n", - "Early stopping at epoch 2322 with loss 12248.092699201714\n", - "Iteration 19) \t Best Value: -0.47914417661898456\n", - "Early stopping at epoch 10000 with loss -0.524064767269806\n", - "Iteration 20) \t Best Value: -0.12174630592231539\n", - "Early stopping at epoch 8108 with loss 0.07264085324399827\n", - "Iteration 21) \t Best Value: -0.12174630592231539\n", - "Early stopping at epoch 5289 with loss 0.7513088722962957\n", - "Iteration 22) \t Best Value: -0.009137546227745208\n", - "Early stopping at epoch 4626 with loss 32.181458277124555\n", - "Iteration 23) \t Best Value: -0.009137546227745208\n", - "Early stopping at epoch 4817 with loss 0.046897905443062715\n", - "Iteration 24) \t Best Value: -0.009137546227745208\n", - "Early stopping at epoch 2283 with loss 8438.196788256188\n", - "Iteration 25) \t Best Value: -0.009137546227745208\n", - "Early stopping at epoch 9827 with loss -0.9441056886352378\n", - "Iteration 26) \t Best Value: -0.008587574179629076\n", - "Early stopping at epoch 7083 with loss -0.12972537421971375\n", - "Iteration 27) \t Best Value: -0.008587574179629076\n", - "Early stopping at epoch 1903 with loss 378.6610015741472\n", - "Iteration 28) \t Best Value: -0.008587574179629076\n", - "Early stopping at epoch 5740 with loss -0.05027197016574714\n", - "Iteration 29) \t Best Value: -0.008587574179629076\n", - "Early stopping at epoch 3322 with loss 750.8233365118181\n" + "Early stopping at epoch 10000 with loss 5.331449014981651\n", + "Iteration 4) \t Best Value: -5.353867137671827\n", + "Early stopping at epoch 5840 with loss 3.415486893935089\n", + "Iteration 5) \t Best Value: -3.5552737959845726\n", + "Early stopping at epoch 546 with loss 1063.4396296217765\n", + "Iteration 6) \t Best Value: -3.5552737959845726\n", + "Early stopping at epoch 10000 with loss 2.5875380664860703\n", + "Iteration 7) \t Best Value: -2.9879735890732815\n", + "Early stopping at epoch 461 with loss 295243.30102552986\n", + "Iteration 8) \t Best Value: -2.9879735890732815\n", + "Early stopping at epoch 8553 with loss 2.4755643348361596\n", + "Iteration 9) \t Best Value: -1.520860338908133\n", + "Early stopping at epoch 7032 with loss 2.5783828400381505\n", + "Iteration 10) \t Best Value: -0.3298738543459483\n", + "Early stopping at epoch 303 with loss 150373.37746060124\n", + "Iteration 11) \t Best Value: -0.3298738543459483\n", + "Early stopping at epoch 7865 with loss 1.6680521188965902\n", + "Iteration 12) \t Best Value: -0.3298738543459483\n", + "Early stopping at epoch 6839 with loss 1.0198157805031434\n", + "Iteration 13) \t Best Value: -0.2791789195249419\n", + "Early stopping at epoch 4322 with loss 1.5767890044923951\n", + "Iteration 14) \t Best Value: -0.2791789195249419\n", + "Early stopping at epoch 5870 with loss 1.1585237972247597\n", + "Iteration 15) \t Best Value: -0.2791789195249419\n", + "Early stopping at epoch 10000 with loss 1.1302222447283858\n", + "Iteration 16) \t Best Value: -0.19361660487044263\n", + "Early stopping at epoch 5342 with loss 0.9036699674848698\n", + "Iteration 17) \t Best Value: -0.03870638136386306\n", + "Early stopping at epoch 5518 with loss 1.121651528877368\n", + "Iteration 18) \t Best Value: -0.03870638136386306\n", + "Early stopping at epoch 7063 with loss 0.41840731263941877\n", + "Iteration 19) \t Best Value: -0.023038777638398233\n", + "Early stopping at epoch 9377 with loss 0.05129676120105198\n", + "Iteration 20) \t Best Value: -0.023038777638398233\n", + "Early stopping at epoch 9720 with loss -0.11266335588458953\n", + "Iteration 21) \t Best Value: -0.023038777638398233\n", + "Early stopping at epoch 3280 with loss 1.4169721240479478\n", + "Iteration 22) \t Best Value: -0.023038777638398233\n", + "Early stopping at epoch 7150 with loss -0.01764592691036948\n", + "Iteration 23) \t Best Value: -0.016626422276008856\n", + "Early stopping at epoch 6065 with loss 0.11492519560720416\n", + "Iteration 24) \t Best Value: -0.008605201155643005\n", + "Early stopping at epoch 10000 with loss 0.554496002568626\n", + "Iteration 25) \t Best Value: -0.008605201155643005\n", + "Early stopping at epoch 9961 with loss 0.03742027572397766\n", + "Iteration 26) \t Best Value: -0.002378257967070585\n", + "Early stopping at epoch 1198 with loss 164575.57768542215\n", + "Iteration 27) \t Best Value: -0.002378257967070585\n", + "Early stopping at epoch 6625 with loss -0.043809670219545405\n", + "Iteration 28) \t Best Value: -0.002378257967070585\n", + "Early stopping at epoch 7564 with loss 1.110163407929918\n", + "Iteration 29) \t Best Value: -0.002378257967070585\n", + "Early stopping at epoch 7247 with loss 1.0858421034577659\n" ] } ], @@ -686,7 +719,7 @@ " # initialize the model\n", " model = VBLLModel(\n", " in_features=dim,\n", - " hidden_features=50,\n", + " hidden_features=64,\n", " num_layers=3,\n", " out_features=1,\n", " device=device,\n", @@ -718,7 +751,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "21a4cce2", "metadata": {}, "outputs": [ @@ -726,13 +759,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/b7/4sbb97gd7xdcbjt2mww_cxcr0000gn/T/ipykernel_73018/3219396719.py:8: DeprecationWarning: __array_wrap__ must accept context and return_scalar arguments (positionally) in the future. (Deprecated NumPy 2.0)\n", + "/var/folders/b7/4sbb97gd7xdcbjt2mww_cxcr0000gn/T/ipykernel_75108/3219396719.py:8: DeprecationWarning: __array_wrap__ must accept context and return_scalar arguments (positionally) in the future. (Deprecated NumPy 2.0)\n", " best_value = np.maximum.accumulate(obs)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] From f4563cace07f920189df6c8f0ceb6edd02066903 Mon Sep 17 00:00:00 2001 From: pbrunzema Date: Tue, 25 Feb 2025 09:37:39 +0100 Subject: [PATCH 6/6] update docsting vbll --- botorch_community/models/vblls.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/botorch_community/models/vblls.py b/botorch_community/models/vblls.py index 707ddf4077..0751a0a13e 100644 --- a/botorch_community/models/vblls.py +++ b/botorch_community/models/vblls.py @@ -81,7 +81,7 @@ class VBLLNetwork(nn.Module): Activation function applied between hidden layers. Defaults to `nn.ELU()`. Notes: - - If a `backbone` module is provided, it is applied before the fully connected layers. If not, we use a default MLP structure. + - If a `backbone` module is provided, it is applied before the variational last layer. If not, we use a default MLP structure. """ def __init__(