From 59501d4ad4734a30b844af742c5a3d515dd81a87 Mon Sep 17 00:00:00 2001 From: Michael Diskin Date: Fri, 10 Apr 2020 23:05:30 +0300 Subject: [PATCH 1/2] remove theano from week5 --- week05_explore/bayes.py | 364 +++++++----- week05_explore/week5.ipynb | 1071 ++++++++++++++++++++++++++---------- 2 files changed, 1016 insertions(+), 419 deletions(-) diff --git a/week05_explore/bayes.py b/week05_explore/bayes.py index ffb9b9adc..93d93b51c 100644 --- a/week05_explore/bayes.py +++ b/week05_explore/bayes.py @@ -1,153 +1,261 @@ -""" -A single-file module that makes your lasagne network into a bayesian neural net. -Originally created by github.com/ferrine , rewritten by github.com/justheuristic for simplicity - -See example in the notebook -""" - +import torch import numpy as np +import torch.nn as nn +import torch.nn.functional as F -from theano import tensor as T -from theano.sandbox.rng_mrg import MRG_RandomStreams as RandomStreams -import lasagne -from lasagne import init -from lasagne.random import get_rng +class BayesianModule(nn.Module): + """ + creates base class for BNN, in order to enable specific behavior + """ + def init(self): + super().__init__() -from functools import wraps -__all__ = ['NormalApproximation', 'get_var_cost', 'bbpwrap'] +class GaussianVariational(nn.Module): + #Samples weights for variational inference as in Weights Uncertainity on Neural Networks (Bayes by backprop paper) + #Calculates the variational posterior part of the complexity part of the loss + def __init__(self, mu, rho): + super().__init__() + self.mu = nn.Parameter(mu) + self.rho = nn.Parameter(rho) + self.w = None + self.sigma = None + self.pi = np.pi + self.normal = torch.distributions.Normal(0, 1) -class NormalApproximation(object): - def __init__(self, mu=0, std=np.exp(-3), seed=None): + def sample(self): """ - Approximation that samples network weights from factorized normal distribution. - - :param mu: prior mean for gaussian weights - :param std: prior std for gaussian weights - :param seed: random seed + Samples weights by sampling form a Normal distribution, multiplying by a sigma, which is + a function from a trainable parameter, and adding a mean + sets those weights as the current ones + returns: + torch.tensor with same shape as self.mu and self.rho """ - self.prior_mu = mu - self.prior_std = std - self.srng = RandomStreams(seed or get_rng().randint(1, 2147462579)) + device = self.mu.device + epsilon = self.normal.sample(self.mu.size()).to(device) + self.sigma = torch.log(1 + torch.exp(self.rho)).to(device) + self.w = self.mu + self.sigma * epsilon + return self.w - def log_normal(self, x, mean, std, eps=0.0): - """computes log-proba of normal distribution""" - std += eps - return - 0.5 * np.log(2 * np.pi) - T.log(T.abs_(std)) - \ - (x - mean) ** 2 / (2 * std ** 2) + def log_posterior(self): - def log_prior(self, weights): """ - Logarithm of prior probabilities for weights: - log P(weights) aka log P(theta) + Calculates the log_likelihood for each of the weights sampled as a part of the complexity cost + returns: + torch.tensor with shape [] """ - return self.log_normal(weights, self.prior_mu, self.prior_std) - def log_posterior_approx(self, weights, mean, rho): + assert (self.w is not None), "You can only have a log posterior for W if you've already sampled it" + + log_sqrt2pi = np.log(np.sqrt(2*self.pi)) + log_posteriors = -log_sqrt2pi - self.sigma - (((self.w - self.mu) ** 2)/(2 * self.sigma ** 2)) + return log_posteriors.mean() + + +class ScaleMixturePrior(nn.Module): + #Calculates a Scale Mixture Prior distribution for the prior part of the complexity cost on Bayes by Backprop paper + def __init__(self, pi, sigma1, sigma2): + super().__init__() + + self.pi = pi + self.sigma1 = sigma1 + self.sigma2 = sigma2 + self.normal1 = torch.distributions.Normal(0, sigma1) + self.normal2 = torch.distributions.Normal(0, sigma2) + + def log_prior(self, w): """ - Logarithm of ELBO on posterior probabilities: - log q(weights|learned mu and rho) aka log q(theta|x) + Calculates the log_likelihood for each of the weights sampled relative to a prior distribution as a part of the complexity cost + returns: + torch.tensor with shape [] """ - std = T.log1p(T.exp(rho)) # rho to std - return self.log_normal(weights, mean, std) - - def __call__(self, layer, spec, shape, name=None, **tags): - # case when user uses default init specs - assert tags.get( - 'variational', False), "Please declare param as variational to avoid confusion" - - if not isinstance(spec, dict): - initial_rho = np.log(np.expm1(self.prior_std)) # std to rho - assert np.isfinite(initial_rho), "too small std to initialize correctly. Please pass explicit"\ - " initializer (dict with {'mu':mu_init, 'rho':rho_init})." - spec = {'mu': spec, 'rho': init.Constant(initial_rho)} - - mu_spec, rho_spec = spec['mu'], spec['rho'] - - rho = layer.add_param( - rho_spec, shape, name=( - name or 'unk') + '.rho', **tags) - mean = layer.add_param( - mu_spec, shape, name=( - name or 'unk') + '.mu', **tags) - - # Reparameterization trick - e = self.srng.normal(shape, std=1) - W = mean + T.log1p(T.exp(rho)) * e - - # KL divergence KL(q,p) = E_(w~q(w|x)) [log q(w|x) - log P(w)] aka - # variational cost - q_p = T.sum( - self.log_posterior_approx(W, mean, rho) - - self.log_prior(W) - ) - - # accumulate variational cost - layer._bbwrap_var_cost += q_p - return W - - -def get_var_cost(layer_or_layers, treat_as_input=None): - """ - Returns total variational cost aka KL(q(theta|x)||p(theta)) for all layers in the network + prob_n1 = torch.exp(self.normal1.log_prob(w)) + prob_n2 = torch.exp(self.normal2.log_prob(w)) + prior_pdf = (self.pi * prob_n1 + (1 - self.pi) * prob_n2) + + return (torch.log(prior_pdf)).mean() - :param layer_or_layers: top layer(s) of your network, just like with lasagne.layers.get_output - :param treat_as_input: don't accumulate over layers below these layers. See same param for lasagne.layers.get_all_layers - Alternatively, one can manually get weights for one layer via layer.get_var_cost() +class BayesianLinear(BayesianModule): """ - cost = 0 - for layer in lasagne.layers.get_all_layers( - layer_or_layers, treat_as_input): - if hasattr(layer, 'get_var_cost'): - # if layer is bayesian or pretends so - cost += layer.get_var_cost() - return cost + Bayesian Linear layer, implements the linear layer proposed on Weight Uncertainity on Neural Networks + (Bayes by Backprop paper). + Its objective is be interactable with torch nn.Module API, being able even to be chained in nn.Sequential models with other non-this-lib layers + + parameters: + in_fetaures: int -> incoming features for the layer + out_features: int -> output features for the layer + bias: bool -> whether the bias will exist (True) or set to zero (False) + prior_sigma_1: float -> prior sigma on the mixture prior distribution 1 + prior_sigma_2: float -> prior sigma on the mixture prior distribution 2 + prior_pi: float -> pi on the scaled mixture prior + freeze: bool -> wheter the model will start with frozen(deterministic) weights, or not + + """ + def __init__(self, + in_features, + out_features, + bias=True, + prior_sigma_1 = 1, + prior_sigma_2 = 0.002, + prior_pi = 0.5, + freeze = False): + super().__init__() + + #our main parameters + self.in_features = in_features + self.out_features = out_features + self.bias = bias + self.freeze = freeze + + #parameters for the scale mixture prior + self.prior_sigma_1 = prior_sigma_1 + self.prior_sigma_2 = prior_sigma_2 + self.prior_pi = prior_pi + + # Variational weight parameters and sample + self.weight_mu = nn.Parameter(torch.Tensor(out_features, in_features).uniform_(-0.2, 0.2)) + self.weight_rho = nn.Parameter(torch.Tensor(out_features, in_features).uniform_(-5, -4)) + self.weight_sampler = GaussianVariational(self.weight_mu, self.weight_rho) + + # Variational bias parameters and sample + self.bias_mu = nn.Parameter(torch.Tensor(out_features).uniform_(-0.2, 0.2)) + self.bias_rho = nn.Parameter(torch.Tensor(out_features).uniform_(-5, -4)) + self.bias_sampler = GaussianVariational(self.bias_mu, self.bias_rho) + + # Priors (as BBP paper) + self.weight_prior_dist = ScaleMixturePrior(self.prior_pi, self.prior_sigma_1, self.prior_sigma_2) + self.bias_prior_dist = ScaleMixturePrior(self.prior_pi, self.prior_sigma_1, self.prior_sigma_2) + self.log_prior = 0 + self.log_variational_posterior = 0 + + def forward(self, x): + # Sample the weights and forward it + + #if the model is frozen, return frozen + if self.freeze: + return self.forward_frozen(x) + + w = self.weight_sampler.sample() + + if self.bias: + b = self.bias_sampler.sample() + b_log_posterior = self.bias_sampler.log_posterior() + b_log_prior = self.bias_prior_dist.log_prior(b) + + else: + b = torch.zeros((self.out_features)) + b_log_posterior = 0 + b_log_prior = 0 + + # Get the complexity cost + self.log_variational_posterior = self.weight_sampler.log_posterior() + b_log_posterior + self.log_prior = self.weight_prior_dist.log_prior(w) + b_log_prior + return F.linear(x, w, b) -def bbpwrap(approximation=NormalApproximation()): + def forward_frozen(self, x): + """ + Computes the feedforward operation with the expected value for weight and biases + """ + if self.bias: + return F.linear(x, self.weight_mu, self.bias_mu) + else: + return F.linear(x, self.weight_mu, torch.zeros(self.out_features)) + + +def kl_divergence_from_nn(model): + + """ + Gathers the KL Divergence from a nn.Module object + Works by gathering each Bayesian layer kl divergence and summing it, doing nothing with the non Bayesian ones """ - A decorator that makes arbitrary lasagne layer into a bayesian network layer: - BayesDenseLayer = bbwrap()(DenseLayer) - or more verbosely, - @bbpwrap(NormalApproximation(pstd=0.01)) - BayesDenseLayer(DenseLayer): - pass + kl_divergence = 0 + for module in model.modules(): + if isinstance(module, (BayesianModule)): + kl_divergence += module.log_variational_posterior - module.log_prior + return kl_divergence + + +def variational_estimator(nn_class): + """ + This decorator adds some util methods to a nn.Module, in order to facilitate the handling of Bayesian Deep Learning features + Parameters: + nn_class: torch.nn.Module -> Torch neural network module + Returns a nn.Module with methods for: + (1) Gathering the KL Divergence along its BayesianModules; + (2) Sample the Elbo Loss along its variational inferences (helps training) + (3) Freeze the model, in order to predict using only their weight distribution means """ - def decorator(cls): - def add_param_wrap(add_param): - @wraps(add_param) - def wrapped(self, spec, shape, name=None, **tags): - # we should take care about some user specification - # to avoid bbp hook just set tags['variational'] = True - if not tags.get('trainable', True) or \ - tags.get('variational', False): - return add_param(self, spec, shape, name, **tags) - else: - # we declare that params we add next - # are the ones we need to fit the distribution - # they don't need to be regularized, strictly - tags['variational'] = True - tags['regularizable'] = False - param = self.approximation(self, spec, shape, name, **tags) - return param - return wrapped - - def get_var_cost(self): - """ - Returns total variational cost aka KL(q(theta|x)||p(theta)) for this layer. - Alternatively, use function get_var_cost(layer) to get total cost for all layers below this one. - """ - return self._bbwrap_var_cost - - cls.approximation = approximation - cls._bbwrap_var_cost = 0 - cls.add_param = add_param_wrap(cls.add_param) - cls.get_var_cost = get_var_cost - return cls - - return decorator + def nn_kl_divergence(self): + """Returns the sum of the KL divergence of each of the BayesianModules of the model, which are from + their posterior current distribution of weights relative to a scale-mixtured prior (and simpler) distribution of weights + Parameters: + N/a + Returns torch.tensor with 0 dim. + + """ + return kl_divergence_from_nn(self) + + setattr(nn_class, "nn_kl_divergence", nn_kl_divergence) + + def sample_elbo(self, + inputs, + labels, + criterion, + sample_nbr, + complexity_cost_weight=1): + + """ Samples the ELBO Loss for a batch of data, consisting of inputs and corresponding-by-index labels + The ELBO Loss consists of the sum of the KL Divergence of the model + (explained above, interpreted as a "complexity part" of the loss) + with the actual criterion - (loss function) of optimization of our model + (the performance part of the loss). + As we are using variational inference, it takes several (quantified by the parameter sample_nbr) Monte-Carlo + samples of the weights in order to gather a better approximation for the loss. + Parameters: + inputs: torch.tensor -> the input data to the model + labels: torch.tensor -> label data for the performance-part of the loss calculation + The shape of the labels must match the label-parameter shape of the criterion (one hot encoded or as index, if needed) + criterion: torch.nn.Module, custom criterion (loss) function, torch.nn.functional function -> criterion to gather + the performance cost for the model + sample_nbr: int -> The number of times of the weight-sampling and predictions done in our Monte-Carlo approach to + gather the loss to be .backwarded in the optimization of the model. + + """ + + loss = 0 + for _ in range(sample_nbr): + outputs = self(inputs) + loss = criterion(outputs, labels) + loss += self.nn_kl_divergence() * complexity_cost_weight + return loss / sample_nbr + + setattr(nn_class, "sample_elbo", sample_elbo) + + + def freeze_model(self): + """ + Freezes the model by making it predict using only the expected value to their BayesianModules' weights distributions + """ + for module in self.modules(): + if isinstance(module, (BayesianModule)): + module.freeze = True + + setattr(nn_class, "freeze", freeze_model) + + def unfreeze_model(self): + """ + Unfreezes the model by letting it draw its weights with uncertanity from their correspondent distributions + """ + + for module in self.modules(): + if isinstance(module, (BayesianModule)): + module.freeze = False + + setattr(nn_class, "unfreeze", unfreeze_model) + return nn_class diff --git a/week05_explore/week5.ipynb b/week05_explore/week5.ipynb index 355a7cecf..de0055ef9 100644 --- a/week05_explore/week5.ipynb +++ b/week05_explore/week5.ipynb @@ -2,39 +2,143 @@ "cells": [ { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 9, + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-03T22:51:31.696358Z", + "start_time": "2019-04-03T22:51:31.694140Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--2020-04-08 21:10:21-- https://raw.githubusercontent.com/yandexdataschool/Practical_RL/master/week05_explore/action_rewards.npy\n", + "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 151.101.84.133\n", + "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|151.101.84.133|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 72008 (70K) [application/octet-stream]\n", + "Saving to: ‘action_rewards.npy’\n", + "\n", + "action_rewards.npy 100%[===================>] 70.32K --.-KB/s in 0.05s \n", + "\n", + "2020-04-08 21:10:22 (1.28 MB/s) - ‘action_rewards.npy’ saved [72008/72008]\n", + "\n", + "--2020-04-08 21:10:22-- https://raw.githubusercontent.com/yandexdataschool/Practical_RL/master/week05_explore/all_states.npy\n", + "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 151.101.84.133\n", + "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|151.101.84.133|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 431408 (421K) [application/octet-stream]\n", + "Saving to: ‘all_states.npy’\n", + "\n", + "all_states.npy 100%[===================>] 421.30K --.-KB/s in 0.1s \n", + "\n", + "2020-04-08 21:10:23 (3.23 MB/s) - ‘all_states.npy’ saved [431408/431408]\n", + "\n" + ] + } + ], "source": [ - "import sys\n", - "if 'google.colab' in sys.modules:\n", - " !pip install --upgrade https://github.com/Theano/Theano/archive/master.zip\n", - " !pip install --upgrade https://github.com/Lasagne/Lasagne/archive/master.zip\n", - "\n", - " !wget -q https://github.com/yandexdataschool/Practical_RL/blob/spring20/week05_explore/bayes.py?raw=true -O bayes.py\n", - " !wget -q https://github.com/yandexdataschool/Practical_RL/blob/spring20/week05_explore/action_rewards.npy?raw=true -O action_rewards.npy \n", - " !wget -q https://github.com/yandexdataschool/Practical_RL/blob/spring20/week05_explore/all_states.npy?raw=true -O all_states.npy" + "# Run this if in COLAB\n", + "# !pip install --upgrade git+https://github.com/Theano/Theano.git\n", + "# !pip install --upgrade git+https://github.com/Lasagne/Lasagne.git\n", + " \n", + "# !wget -q https://raw.githubusercontent.com/yandexdataschool/Practical_RL/master/week5_explore/bayes.py\n", + "!wget https://raw.githubusercontent.com/yandexdataschool/Practical_RL/master/week05_explore/action_rewards.npy\n", + "!wget https://raw.githubusercontent.com/yandexdataschool/Practical_RL/master/week05_explore/all_states.npy" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-03T22:51:32.147539Z", + "start_time": "2019-04-03T22:51:31.701723Z" + }, + "nbdime-conflicts": { + "local_diff": [ + { + "key": "ExecuteTime", + "op": "add", + "value": { + "end_time": "2019-03-22T17:28:37.673293Z", + "start_time": "2019-03-22T17:28:36.802492Z" + } + } + ], + "remote_diff": [ + { + "key": "ExecuteTime", + "op": "add", + "value": { + "end_time": "2019-04-02T18:26:40.998588Z", + "start_time": "2019-04-02T18:26:40.616120Z" + } + } + ] + } + }, "outputs": [], "source": [ "from abc import ABCMeta, abstractmethod, abstractproperty\n", "import enum\n", "\n", "import numpy as np\n", - "np.set_printoptions(precision=3)\n", - "np.set_printoptions(suppress=True)\n", + "np.set_printoptions(\n", + " precision=3,\n", + " suppress=True,\n", + ")\n", "\n", - "import pandas\n", + "import pandas as pd\n", + "from tqdm import tqdm_notebook, tnrange\n", "\n", - "from matplotlib import pyplot as plt\n", + "import matplotlib.pyplot as plt\n", "%matplotlib inline" ] }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-03T22:51:32.160485Z", + "start_time": "2019-04-03T22:51:32.151084Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'divide': 'warn', 'over': 'warn', 'under': 'ignore', 'invalid': 'warn'}" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.random.seed(1)\n", + "np.seterr(all='raise')" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-03T22:51:32.172125Z", + "start_time": "2019-04-03T22:51:32.164269Z" + } + }, + "outputs": [], + "source": [ + "def moving_average(x, **kwargs):\n", + " return pd.Series(np.asarray(x)).ewm(**kwargs).mean().values" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -75,8 +179,13 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 5, + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-03T22:51:32.187664Z", + "start_time": "2019-04-03T22:51:32.176471Z" + } + }, "outputs": [], "source": [ "class BernoulliBandit:\n", @@ -88,9 +197,9 @@ " return len(self._probs)\n", "\n", " def pull(self, action):\n", - " if np.any(np.random.random() > self._probs[action]):\n", - " return 0.0\n", - " return 1.0\n", + " if np.random.random() < self._probs[action]:\n", + " return 1.0\n", + " return 0.0\n", "\n", " def optimal_reward(self):\n", " \"\"\" Used for regret calculation\n", @@ -109,8 +218,13 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 6, + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-03T22:51:32.206933Z", + "start_time": "2019-04-03T22:51:32.191578Z" + } + }, "outputs": [], "source": [ "class AbstractAgent(metaclass=ABCMeta):\n", @@ -149,6 +263,22 @@ " return np.random.randint(0, len(self._successes))" ] }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-03T22:51:32.217096Z", + "start_time": "2019-04-03T22:51:32.210310Z" + } + }, + "outputs": [], + "source": [ + "def random_true(bool_arr):\n", + " assert len(bool_arr.shape) == 1\n", + " return np.random.choice(np.arange(len(bool_arr))[bool_arr])" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -176,8 +306,13 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 8, + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-03T22:51:32.228768Z", + "start_time": "2019-04-03T22:51:32.218598Z" + } + }, "outputs": [], "source": [ "class EpsilonGreedyAgent(AbstractAgent):\n", @@ -185,7 +320,44 @@ " self._epsilon = epsilon\n", "\n", " def get_action(self):\n", - " # YOUR CODE HERE\n", + " if np.random.random() < self._epsilon:\n", + " return np.random.randint(0, len(self._successes))\n", + " else:\n", + " denom = self._successes + self._failures\n", + " if np.any(denom == 0):\n", + " return random_true(denom == 0)\n", + " else:\n", + " theta = self._successes / denom\n", + " return random_true(theta == theta.max())\n", + "\n", + " @property\n", + " def name(self):\n", + " return self.__class__.__name__ + \"(epsilon={})\".format(self._epsilon)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-03T22:51:32.237971Z", + "start_time": "2019-04-03T22:51:32.230941Z" + } + }, + "outputs": [], + "source": [ + "class EpsilonGreedyAgent2(AbstractAgent):\n", + " def __init__(self, epsilon=0.01):\n", + " self._epsilon = epsilon\n", + "\n", + " def get_action(self):\n", + " if np.random.random() < self._epsilon:\n", + " return np.random.randint(0, len(self._successes))\n", + " else:\n", + " denom = self._successes + self._failures\n", + " theta = np.full_like(self._successes, 0.5)\n", + " theta[denom != 0] = self._successes[denom != 0] / denom[denom != 0]\n", + " return random_true(theta == theta.max())\n", "\n", " @property\n", " def name(self):\n", @@ -199,11 +371,9 @@ "### UCB Agent\n", "Epsilon-greedy strategy heve no preference for actions. It would be better to select among actions that are uncertain or have potential to be optimal. One can come up with idea of index for each action that represents otimality and uncertainty at the same time. One efficient way to do it is to use UCB1 algorithm:\n", "\n", - "**for** $t = 1,2,...$ **do**\n", - "\n", "   **for** $k = 1,...,K$ **do**\n", "\n", - "       $w_k \\leftarrow \\alpha_k / (\\alpha_k + \\beta_k) + \\sqrt{2log\\ t \\ / \\ (\\alpha_k + \\beta_k)}$\n", + "       $w_k \\leftarrow \\alpha_k / (\\alpha_k + \\beta_k) + \\sqrt{\\frac {2 \\log t} {\\alpha_k + \\beta_k}}$\n", "\n", "   **end for** \n", "\n", @@ -216,20 +386,55 @@ "\n", "**end for**\n", "\n", - "__Note:__ in practice, one can multiply $\\sqrt{2log\\ t \\ / \\ (\\alpha_k + \\beta_k)}$ by some tunable parameter to regulate agent's optimism and wilingness to abandon non-promising actions.\n", - "\n", "More versions and optimality analysis - https://homes.di.unimi.it/~cesabian/Pubblicazioni/ml-02.pdf" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 10, + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-03T22:51:32.248360Z", + "start_time": "2019-04-03T22:51:32.243272Z" + } + }, "outputs": [], "source": [ "class UCBAgent(AbstractAgent):\n", + " def __init__(self):\n", + " super().__init__()\n", + " \n", + " def get_action(self):\n", + " denom = self._successes + self._failures\n", + " if np.any(denom == 0):\n", + " return random_true(denom == 0)\n", + " else:\n", + " w = self._successes / denom + np.sqrt(2 * np.log(self._total_pulls) / denom)\n", + " return random_true(w == w.max())" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-03T22:51:32.259175Z", + "start_time": "2019-04-03T22:51:32.249939Z" + } + }, + "outputs": [], + "source": [ + "class UCBAgent2(AbstractAgent):\n", + " def __init__(self):\n", + " super().__init__()\n", + " \n", " def get_action(self):\n", - " # YOUR CODE HERE" + " denom = self._successes + self._failures\n", + " w = np.full_like(self._successes, 1)\n", + " w[denom != 0] = \\\n", + " self._successes[denom != 0] / denom[denom != 0] + \\\n", + " np.sqrt(2 * np.log(max(1, self._total_pulls)) / denom[denom != 0])\n", + " return random_true(w == w.max())" ] }, { @@ -263,29 +468,40 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 12, + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-03T22:51:32.267647Z", + "start_time": "2019-04-03T22:51:32.261060Z" + } + }, "outputs": [], "source": [ "class ThompsonSamplingAgent(AbstractAgent):\n", " def get_action(self):\n", - " # YOUR CODE HERE\n" + " # Wrong prior, but at least not an improper one\n", + " theta = np.random.beta(self._successes + 1, self._failures + 1)\n", + " return random_true(theta == theta.max())" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 13, + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-03T22:51:32.278448Z", + "start_time": "2019-04-03T22:51:32.269305Z" + } + }, "outputs": [], "source": [ - "from collections import OrderedDict\n", - "\n", - "def get_regret(env, agents, n_steps=5000, n_trials=50):\n", - " scores = OrderedDict({\n", - " agent.name: [0.0 for step in range(n_steps)] for agent in agents\n", - " })\n", + "def plot_regret(env, agents, n_steps=5000, n_trials=50):\n", + " scores = {\n", + " agent.name: np.zeros(n_steps)\n", + " for agent in agents\n", + " }\n", "\n", - " for trial in range(n_trials):\n", + " for trial in tnrange(n_trials):\n", " env.reset()\n", "\n", " for a in agents:\n", @@ -302,14 +518,9 @@ "\n", " env.step() # change bandit's state if it is unstationary\n", "\n", + " plt.figure(figsize=(17, 8))\n", " for agent in agents:\n", - " scores[agent.name] = np.cumsum(scores[agent.name]) / n_trials\n", - "\n", - " return scores\n", - "\n", - "def plot_regret(agents, scores):\n", - " for agent in agents:\n", - " plt.plot(scores[agent.name])\n", + " plt.plot(np.cumsum(scores[agent.name]) / n_trials)\n", "\n", " plt.legend([agent.name for agent in agents])\n", "\n", @@ -321,14 +532,40 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 14, + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-03T22:51:51.386184Z", + "start_time": "2019-04-03T22:51:32.280069Z" + } + }, "outputs": [ { "data": { - "image/png": "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\n", + "application/vnd.jupyter.widget-view+json": { + "model_id": "b18531f2978448e3ae2b1259534abd6b", + "version_major": 2, + "version_minor": 0 + }, "text/plain": [ - "" + "HBox(children=(IntProgress(value=0, max=10), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" ] }, "metadata": {}, @@ -336,15 +573,68 @@ } ], "source": [ - "# Uncomment agents\n", "agents = [\n", - " # EpsilonGreedyAgent(),\n", - " # UCBAgent(),\n", - " # ThompsonSamplingAgent()\n", + " EpsilonGreedyAgent(),\n", + " EpsilonGreedyAgent2(),\n", + " UCBAgent(),\n", + " UCBAgent2(),\n", + " ThompsonSamplingAgent(),\n", "]\n", "\n", - "regret = get_regret(BernoulliBandit(), agents, n_steps=10000, n_trials=10)\n", - "plot_regret(agents, regret)" + "plot_regret(BernoulliBandit(), agents, n_steps=10000, n_trials=10)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-03T22:54:26.224093Z", + "start_time": "2019-04-03T22:51:51.387905Z" + } + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3ebe9250e85d4394a96715aef9512c1d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(IntProgress(value=0, max=10), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_regret(BernoulliBandit(), agents, n_steps=100000, n_trials=10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "> UCB is extremely unstable and only wins against `EpsilonGreedy` with a large number of steps (I have conducted a lot of experiments). Thompson sampling is a lot more reliable." ] }, { @@ -370,8 +660,13 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 16, + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-03T22:54:26.233969Z", + "start_time": "2019-04-03T22:54:26.225822Z" + } + }, "outputs": [], "source": [ "class DriftingBandit(BernoulliBandit):\n", @@ -419,14 +714,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 17, + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-03T22:54:27.708307Z", + "start_time": "2019-04-03T22:54:26.236736Z" + }, + "scrolled": false + }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, "metadata": {}, @@ -442,7 +743,7 @@ " drifting_probs.append(drifting_env._probs)\n", "\n", "plt.figure(figsize=(17, 8))\n", - "plt.plot(pandas.DataFrame(drifting_probs).rolling(window=20).mean())\n", + "plt.plot(pd.DataFrame(drifting_probs).rolling(window=20).mean())\n", "\n", "plt.xlabel(\"steps\")\n", "plt.ylabel(\"Success probability\")\n", @@ -460,23 +761,77 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 18, + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-03T22:54:27.724663Z", + "start_time": "2019-04-03T22:54:27.709971Z" + } + }, "outputs": [], "source": [ - "# YOUR AGENT HERE SECTION" + "class DriftingAgent(AbstractAgent):\n", + " def __init__(self, lr=0.01, scale=10):\n", + " super().__init__()\n", + " self._lr = lr\n", + " self._scale = scale\n", + " \n", + " def init_actions(self, n_actions):\n", + " super().init_actions(n_actions)\n", + " self._probs = np.full(n_actions, 0.5)\n", + "\n", + " def get_action(self):\n", + " if self._total_pulls == 0:\n", + " return 0\n", + " theta = np.random.beta(self._probs * self._scale + 1, (1 - self._probs) * self._scale + 1)\n", + " return random_true(theta == theta.max())\n", + " \n", + " def update(self, action, reward):\n", + " super().update(action, reward)\n", + " self._probs[action] = (1 - self._lr) * self._probs[action] + self._lr * reward\n", + "\n", + " @property\n", + " def name(self):\n", + " return self.__class__.__name__ + \"(lr={})\".format(self._lr)" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 19, + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-03T22:55:32.717499Z", + "start_time": "2019-04-03T22:54:27.729989Z" + }, + "scrolled": false + }, "outputs": [ { "data": { - "image/png": "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\n", + "application/vnd.jupyter.widget-view+json": { + "model_id": "91a59d1bd57441909b1b2b59ec481efe", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(IntProgress(value=0, max=10), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, "metadata": {}, @@ -488,12 +843,23 @@ " ThompsonSamplingAgent(),\n", " EpsilonGreedyAgent(),\n", " UCBAgent(),\n", - " YourAgent()\n", + " DriftingAgent(lr=0.1),\n", + " DriftingAgent(lr=0.2),\n", + " DriftingAgent(lr=0.3),\n", + " DriftingAgent(lr=0.4),\n", + " DriftingAgent(lr=0.5),\n", "]\n", "\n", "plot_regret(DriftingBandit(), drifting_agents, n_steps=20000, n_trials=10)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "> My implementation is basically Thompson sampling with two hacks that ensure it updates with the data. `probs` minimizes cross-entropy with the current distribution in the bandit using gradient descent. `scale` is a parameter that controls variance of the beta distribution (essentialy `scale=10` is equivalent to Thompson sampling with 20 samples). The plot illustrates that in the particular problem, the optimal learning rate is approximately 0.2. I zabeel to tune scale." + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -506,15 +872,15 @@ "\n", "> Contextual advertising. We have a lot of banners and a lot of different users. Users can have different features: age, gender, search requests. We want to show banner with highest click probability.\n", "\n", - "If we want use strategies from above, we need some how store reward distributions conditioned both on actions and bandit's state. \n", - "One way to do this - use bayesian neural networks. Instead of giving pointwise estimates of target, they maintain probability distributions\n", + "If we want to use strategies from above, we need to store somehow reward distributions conditioned both on actions and bandit's state. \n", + "One way to do this is using bayesian neural networks. Instead of giving pointwise estimates of target, they maintain probability distributions\n", "\n", "\n", "Picture from https://arxiv.org/pdf/1505.05424.pdf\n", "\n", "\n", "More material:\n", - " * A post on the matter - [url](http://twiecki.github.io/blog/2016/07/05/bayesian-deep-learning/)\n", + " * A post on the subject - [url](http://twiecki.github.io/blog/2016/07/05/bayesian-deep-learning/)\n", " * Theano+PyMC3 for more serious stuff - [url](http://pymc-devs.github.io/pymc3/notebooks/bayesian_neural_network_advi.html)\n", " * Same stuff in tensorflow - [url](http://edwardlib.org/tutorials/bayesian-neural-network)\n", " \n", @@ -523,8 +889,13 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 27, + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-03T22:55:32.725132Z", + "start_time": "2019-04-03T22:55:32.719599Z" + } + }, "outputs": [ { "name": "stdout", @@ -544,23 +915,6 @@ "print(\"State size: %i, actions: %i\" % (state_size, n_actions))" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import theano\n", - "import theano.tensor as T\n", - "import lasagne\n", - "from lasagne import init\n", - "from lasagne.layers import *\n", - "import bayes\n", - "\n", - "as_bayesian = bayes.bbpwrap(bayes.NormalApproximation(std=0.1))\n", - "BayesDenseLayer = as_bayesian(DenseLayer)" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -572,59 +926,55 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 28, + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-03T22:55:33.607149Z", + "start_time": "2019-04-03T22:55:33.593883Z" + } + }, "outputs": [], "source": [ - "class BNNAgent:\n", - " \"\"\"a bandit with bayesian neural net\"\"\"\n", - "\n", - " def __init__(self, state_size, n_actions):\n", - " input_states = T.matrix(\"states\")\n", - " target_actions = T.ivector(\"actions taken\")\n", - " target_rewards = T.vector(\"rewards\")\n", - "\n", - " self.total_samples_seen = theano.shared(\n", - " np.int32(0), \"number of training samples seen so far\")\n", - " batch_size = target_actions.shape[0] # por que?\n", - "\n", - " # Network\n", - " inp = InputLayer((None, state_size), name='input')\n", - " # YOUR NETWORK HERE\n", - " out = \n", - "\n", - " # Prediction\n", - " prediction_all_actions = get_output(out, inputs=input_states)\n", - " self.predict_sample_rewards = theano.function(\n", - " [input_states], prediction_all_actions)\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "import torch.optim as optim\n", + "import numpy as np\n", "\n", - " # Training\n", + "from bayes import BayesianLinear, variational_estimator, kl_divergence_from_nn\n", "\n", - " # select prediction for target action\n", - " prediction_target_actions = prediction_all_actions[T.arange(\n", - " batch_size), target_actions]\n", "\n", - " # loss = negative log-likelihood (mse) + KL\n", - " negative_llh = T.sum((prediction_target_actions - target_rewards)**2)\n", "\n", - " kl = bayes.get_var_cost(out) / (self.total_samples_seen+batch_size)\n", + "@variational_estimator\n", + "class BayesianRegressor(nn.Module):\n", + " def __init__(self, input_dim, output_dim):\n", + " super().__init__()\n", + " #self.linear = nn.Linear(input_dim, output_dim)\n", + " self.blinear1 = BayesianLinear(input_dim, 256)\n", + " self.blinear2 = BayesianLinear(256, 128)\n", "\n", - " loss = (negative_llh + kl)/batch_size\n", + " self.blinear3 = BayesianLinear(128, output_dim)\n", + " \n", + " def forward(self, x):\n", + " x = self.blinear1(x)\n", + " x = F.relu(x)\n", + " x = self.blinear2(x)\n", + " x = F.relu(x)\n", + " x = self.blinear3(x)\n", + " x = torch.sigmoid(x)\n", "\n", - " self.weights = get_all_params(out, trainable=True)\n", - " self.out = out\n", + " return x\n", "\n", - " # gradient descent\n", - " updates = lasagne.updates.adam(loss, self.weights)\n", - " # update counts\n", - " updates[self.total_samples_seen] = self.total_samples_seen + \\\n", - " batch_size.astype('int32')\n", "\n", - " self.train_step = theano.function([input_states, target_actions, target_rewards],\n", - " [negative_llh, kl],\n", - " updates=updates,\n", - " allow_input_downcast=True)\n", + "class BNNAgent:\n", + " \"\"\"a bandit with bayesian neural net\"\"\"\n", "\n", + " def __init__(self, state_size, n_actions):\n", + " self.n_actions = n_actions\n", + " self.model = BayesianRegressor(state_size, n_actions)\n", + " self.optimizer = optim.Adam(self.model.parameters(), lr=0.001)\n", + " def predict_sample_rewards(self, states):\n", + " return self.model(torch.Tensor(states))\n", " def sample_prediction(self, states, n_samples=1):\n", " \"\"\"Samples n_samples predictions for rewards,\n", "\n", @@ -632,11 +982,11 @@ " \"\"\"\n", " assert states.ndim == 2, \"states must be 2-dimensional\"\n", "\n", - " return np.stack([self.predict_sample_rewards(states) for _ in range(n_samples)])\n", + " return np.stack([self.predict_sample_rewards(states).detach().cpu() for _ in range(n_samples)])\n", "\n", " epsilon = 0.25\n", - "\n", " def get_action(self, states):\n", + "\n", " \"\"\"\n", " Picks action by \n", " - with p=1-epsilon, taking argmax of average rewards\n", @@ -651,7 +1001,11 @@ " # ^-- we take mean over samples to compute expectation, then pick best action with argmax\n", "\n", " # YOUR CODE HERE\n", - " chosen_actions = <-- implement epsilon-greedy strategy - ->\n", + " chosen_actions = np.where(\n", + " np.random.random() > self.epsilon,\n", + " best_actions,\n", + " np.random.randint(0, self.n_actions, best_actions.shape)\n", + " )\n", "\n", " return chosen_actions\n", "\n", @@ -661,8 +1015,15 @@ " \"\"\"\n", " loss_sum = kl_sum = 0\n", " for _ in range(n_iters):\n", - " loss, kl = self.train_step(states, actions, rewards)\n", - " loss_sum += loss\n", + " self.optimizer.zero_grad()\n", + " cur_actions = self.predict_sample_rewards(states)\n", + " pred_rewards = cur_actions.gather(1, torch.tensor(actions, dtype=torch.long).unsqueeze(1)).squeeze()\n", + " mse = torch.sum((pred_rewards-torch.tensor(rewards))**2)\n", + " kl = kl_divergence_from_nn(self.model)\n", + " ((mse+kl)/states.shape[0]).backward()\n", + " self.optimizer.step()\n", + "\n", + " loss_sum += mse\n", " kl_sum += kl\n", "\n", " return loss_sum / n_iters, kl_sum / n_iters\n", @@ -681,8 +1042,13 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 29, + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-03T22:55:33.622446Z", + "start_time": "2019-04-03T22:55:33.609114Z" + } + }, "outputs": [], "source": [ "N_ITERS = 100" @@ -690,8 +1056,13 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 30, + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-03T22:55:33.631730Z", + "start_time": "2019-04-03T22:55:33.624908Z" + } + }, "outputs": [], "source": [ "def get_new_samples(states, action_rewards, batch_size=10):\n", @@ -702,16 +1073,17 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 31, + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-03T22:55:33.645631Z", + "start_time": "2019-04-03T22:55:33.633443Z" + } + }, "outputs": [], "source": [ "from IPython.display import clear_output\n", "\n", - "from pandas import DataFrame\n", - "moving_average = lambda x, **kw: DataFrame(\n", - " {'x': np.asarray(x)}).x.ewm(**kw).mean().values\n", - "\n", "def train_contextual_agent(agent, batch_size=10, n_iters=100):\n", " rewards_history = []\n", "\n", @@ -719,9 +1091,7 @@ " b_states, b_action_rewards = get_new_samples(\n", " all_states, action_rewards, batch_size)\n", " b_actions = agent.get_action(b_states)\n", - " b_rewards = b_action_rewards[\n", - " np.arange(batch_size), b_actions\n", - " ]\n", + " b_rewards = b_action_rewards[np.arange(batch_size), b_actions]\n", "\n", " mse, kl = agent.train(b_states, b_actions, b_rewards, n_iters=100)\n", "\n", @@ -733,7 +1103,7 @@ " (i, np.mean(rewards_history[-10:]), mse, kl))\n", " plt.plot(rewards_history)\n", " plt.plot(moving_average(np.array(rewards_history), alpha=0.1))\n", - " plt.title(\"Reward per epesode\")\n", + " plt.title(\"Reward per episode\")\n", " plt.xlabel(\"Episode\")\n", " plt.ylabel(\"Reward\")\n", " plt.show()\n", @@ -754,50 +1124,52 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 32, + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-03T23:00:36.944085Z", + "start_time": "2019-04-03T22:55:33.650484Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "iteration #90\tmean reward=0.560\tmse=0.457\tkl=0.044\n" + "iteration #90\tmean reward=0.450\tmse=0.278\tkl=-28.015\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ - "Q(s,a) std: 0.178;0.011;0.000;0.000;0.195;0.000;0.000;0.124;0.023;0.000\n", - "correct 4\n" + "Q(s,a) std: 0.000;0.000;0.000;0.027;0.013;0.000;0.000;0.000;0.000;0.002\n", + "correct 0\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.5/dist-packages/ipykernel_launcher.py:37: FutureWarning: pd.ewm_mean is deprecated for ndarrays and will be removed in a future version\n" - ] } ], "source": [ @@ -817,8 +1189,13 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 33, + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-03T23:00:36.949294Z", + "start_time": "2019-04-03T23:00:36.945467Z" + } + }, "outputs": [], "source": [ "class ThompsonBNNAgent(BNNAgent):\n", @@ -828,55 +1205,59 @@ " This is exactly thompson sampling.\n", " \"\"\"\n", "\n", - " # YOUR CODE HERE" + " reward_samples = self.sample_prediction(states, n_samples=1)\n", + " best_actions = reward_samples.squeeze(axis=0).argmax(axis=-1)\n", + " return best_actions" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 34, + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-03T23:04:11.672929Z", + "start_time": "2019-04-03T23:00:36.951886Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "iteration #90\tmean reward=0.360\tmse=0.590\tkl=0.038\n" + "iteration #90\tmean reward=0.740\tmse=0.090\tkl=-27.795\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD8CAYAAACMwORRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvAOZPmwAAIABJREFUeJzsnXmYHFW5/z+n956Z7pnJnpkkJGAwLApiWNwAFRBFQcUFFBUVUa9cF7wqXhV3/d2rcvUqLsj1uiKbC1FRUC4qyiKRTcIaQkgykz2z91pV5/dH9amuqq7q7pnpWT2f5+Eh011ddbqr6q33fM+7CCklGo1Go5lfRGZ6ABqNRqNpPdq4azQazTxEG3eNRqOZh2jjrtFoNPMQbdw1Go1mHqKNu0aj0cxDtHHXaDSaeYg27hqNRjMP0cZdo9Fo5iGxmTrwokWL5OrVq2fq8BqNRjMn+fvf/75PSrm40XYzZtxXr17Nxo0bZ+rwGo1GMycRQjzVzHZaltFoNJp5iDbuGo1GMw/Rxl2j0WjmIdq4azQazTxEG3eNRqOZhzRl3IUQpwshHhVCbBZCXBLw/n8JIe6r/PeYEGKw9UPVaDQaTbM0DIUUQkSBy4FTgR3A3UKIDVLKh9Q2UsoPuLb/V+BZUzBWjUaj0TRJM577ccBmKeUWKWUJuBo4q8725wI/bcXgNOPjwFiJ3zywc6aHodFoZgHNGPdeYLvr7x2V12oQQhwErAH+L+T9C4UQG4UQG/fu3TvesWoacMN9fbznqnsYypVneigajWaGafWC6jnA9VJKM+hNKeUVUsr1Usr1ixc3zJ7VjJOiYQEwVjJmeCQajWamaca49wErXX+vqLwWxDloSWbGMEzbuOfLgc9WjUbzT0Qzxv1uYK0QYo0QIoFtwDf4NxJCrAO6gTtaO0RNsxiWBCBf0sZdo/lnp6Fxl1IawEXATcDDwLVSyk1CiM8IIc50bXoOcLWUUk7NUDWNMCvGvaA9d43mn56mqkJKKW8EbvS9dqnv70+1bliaiVA2beOe0567RvNPj85QnUeYltbcNRqNjTbu8wjluWtZRqPRaOM+jzD1gqpGo6mgjfs8womW0Z67RvNPjzbu8wgV564XVDUajTbu8wgdCqnRaBTauM8jdBKTRqNRaOM+jzB0KKRGo6mgjfs8wjD1gqpGo7HRxn0eoWUZjUaj0MZ9HqFDITUajUIb93mEU35Ae+4azT892rjPI3T5AY1Go9DGfR6h4tx1EpNGo9HGfR6hOzFpNBqFNu7zCENnqGo0mgrauM8jdFVIjUaj0MZ9HlF2yTK626FG88+NNu7zCOW5WxKKhjXDo9FoNDNJU8ZdCHG6EOJRIcRmIcQlIdu8TgjxkBBikxDiqtYOU9MMSnMHrbtrNP/sNGyQLYSIApcDpwI7gLuFEBuklA+5tlkLfBR4npRyQAixZKoGrAlH1ZYBW5rpmsGxaDSamaUZz/04YLOUcouUsgRcDZzl2+YdwOVSygEAKeWe1g5T0wyGJWlPRAG9qKrRtALTkjy1f2ymhzEhmjHuvcB21987Kq+5ORQ4VAjxVyHEnUKI04N2JIS4UAixUQixce/evRMbsSYUw7LIpOKAjnXXaFrB7x7cxYu/8if2jxZneijjplULqjFgLXAycC7wXSFEjSogpbxCSrleSrl+8eLFLTq0RmGakkzKVtq0567RTJ7+wTyGJRnIlWd6KOOmGePeB6x0/b2i8pqbHcAGKWVZSvkk8Bi2sddMI4blMu7ac9doJs1IwTbqc9FZasa43w2sFUKsEUIkgHOADb5tfonttSOEWIQt02xp4Tg1TWBYFh1KlpmDF6NGM9sYLhjA3HSWGhp3KaUBXATcBDwMXCul3CSE+IwQ4szKZjcB+4UQDwG3Ah+SUu6fqkFrgjEsSSapPXeNplUMK899Dt5PDUMhAaSUNwI3+l671PVvCVxc+U8zA1iWREocWUbHuWs0k2dEee5zcCasM1TnCeVKow5l3HXZX41m8gznbc99LjpL2rjPE1TpgY6kDoXUaFqF8tznorOkjfs8QXVhak/aSUyFOXgxajSzjZHi3NXctXGfJyjPPR6NkI5H5+TFqNHMNobztueuZRnNjGFUNPdYVNCWiM7JaaRGM5uQUjJa1AuqmhlGFQ2LRQQp7blrNJMmVzKrDXDm4P2kjfs8QV2E0UiEdCI6J6eRGs1sQsW4g15Q1cwgqgtTPCpszX0OXowazWxCRcqA1tw1M0jVcxekE1qW0Wgmy4jLc5+LzpI27vME1YUpFtGeu0bTClSkjBBac9fMINUFVR0KqdG0AqW5L+pIzsn7SRv3eYIKhYxGtSyj0bQCpbkvySTn5ExYG/d5gpPEFInYoZAla4ZHpNHMbZTnvjSbmpPOkjbu8wRVfiAasZOY5uLqvkYzmxgpGMSjgq50XHvumplDee6xSihkrmRgV2LWaDQTYaRQJpOKz9m8EW3c5wmq5G+sEgppSSiZWprRaCbKcN4gm4pVnCVt3DUzhOmKlknFVWVIbdw1momiPPe2SoDCXJsJa+M+TzAsr+YOczM2V6OZLYwUDDKpGKnK/VQ05pazpI37PEGFQqryA6CNu0YzGYYLZbKpePV+mmPSTFPGXQhxuhDiUSHEZiHEJQHvny+E2CuEuK/y3wWtH6qmHu7yA0qWyZWMeh/RaDR1UJ77XHWWGjbIFkJEgcuBU4EdwN1CiA1Syod8m14jpbxoCsaoaQKVoRqP2lUhYW4WO9JoZgu2cY8799NcW1RtaNyB44DNUsotAEKIq4GzAL9x18wgToaqW3PXC6qaKcSypBOlBfZifjQiWrZ/w7QwXYuYyVi0ZftuhGnZjTqy6arnPtecpWaMey+w3fX3DuD4gO3OFkKcCDwGfEBKuT1gG80U4S8cBpOfRg7lypz+tT/zrfOezdEruyY9Rs3MMTBW4vSv/Zn/ecuxHNnb2ZJ9nvc/d3H7E/udv1cuSPPnD70QISZv4PsH87z4K3/yXMMXPH8NH3/54XU/9+WbHmXr/jG+8YZj6m537cbt/PjOp9hw0fMD3x+tlB5we+5zTZZp1YLqr4DVUspnAr8HfhC0kRDiQiHERiHExr1797bo0BpwFQ6LRlqmue8czrNzqMBju0YmPT7NzNI3mGf3cJHHdrfuXD6+Z5SjVnbxoZc8nRetW8L2A3nGWiRdPLU/R75scu5xq/jQS57OwYvb+fu2gYafe7B/iPu2Dzberm+IB3YMOX0Q/KjSAx7NfY7JMs0Y9z5gpevvFZXXHKSU+6WUxcqfVwLPDtqRlPIKKeV6KeX6xYsXT2S8mhAMXz13mPw0slQJ/ZprHoumFpXQ1spzWTIsnrWyi/e88GmcdvhSAIbz5Qafag5lXN94/Cre88Knsf6gbvoG8g0/ly+ZTY1BbeNuyOFGvZ5NxR1naa7dB80Y97uBtUKINUKIBHAOsMG9gRBiuevPM4GHWzdETTOYrgzVthZ5GkVt3OcNxXLlXLbQ+ywaJsmYbUIyqTgQbizHi9u4AvR0pdkzUqRo1B9/oWwyWmxcekPt392Qw416uGRTMdca1ty6DxoadymlAVwE3IRttK+VUm4SQnxGCHFmZbP3CiE2CSHuB94LnD9VA9YEUzZdtWUcjXByC6rKIMy1KAFNLcootspASSkpGpZj3LNpe/kuzFiOF7Uftd/erjQAu4YKdT+XK5lYkobyUNW41/fc57Lm3syCKlLKG4Ebfa9d6vr3R4GPtnZomvHgFA6LRFABC5O9GEum/fm5FiWgqaXVEpthSaSEhM9zH26RcVddkDqSFePebRv3voE8By1sD/2c+n7D+bLz2cD9V8YZJuG4Hy5zVXNvyrhrZj+GaSEETiia3WpvclPkqZjKa2aGVktsan8qPDGTUp57q2SZMm2JKLGo/fBQnvuOwfq6u3JEGo1DvT8csp0y+pk5rLlr4z5PMCxJzBVj3IpuTFpznz+oc9mqWVixsp9kvCLLOJ576zR3tU+AZZ0phLBDJOuhHJFG8pDy3MO2q8oyMWIRQUTMvRmsNu7zBNOSngSSdAu6MelomflDqzV3FX2TiCpZxjYlrYyWUfsEe4awuCNZN2JGSlmVZeoYd6uSoGRvF6K5Fw3S8Sjxyvebi2V/deGweULZlMQj1dPZigYDrTYImplDPahbZaCUZKc891Q8SiIaaWm0jNu4g62799Xx3IuGRWXpqe44RksG0tkuJFom7324zMW+xNq4zxNMyyIa9XnurZJltHGf80y15g724mMro2Wy6bjntd6udF1Zxu3M1JOH3Ia/XrSM27in4lEKc+w+0MZ9nlCjuVda7U0GrbnPH5Sn3SrdWM0ElCwD9uJjqzT34UrRLje2cS9gWcEx7O7rtJ485H4vbLth38OlTXvumpnCMCUxnywz6Tj3Fi/CaWYOFdbaOs/du6AKtu7eSs89SJYpmRb7xoqBn3HPMOvJMs147v6Hi9bcNTOGEbCgOtlppKO5a+M+52l1QloxwHPPpuIt09yHfdEyUA2HDFtUdV+n9R4y6r1ELMJIMTzO3S/LzLX7QBv3eYJhWcSjrQ2FbPUinGbmcGZhrYqWUZp7vKq5Z1KxlkTLFMomJcOq8dx7lHEP0d3dnns9eUhF0vR2pZ1kKT/+UMxWBChMN9q4zxP8nnsrPI1WGwTNzNHqsFZHlon5ZZnJe+7VujK1sgyEx7o377nb++/pStWNlnEf3w4tnlv3gTbu8wTTp7m3JSZ/MToZqnPMY9HU0mqJzZFlYn5ZZvKeezX13yvLZFNxMslYuCxTud470/XlIce4d6YDtysZFkXfzEGHQmpmDMOyiAWEQjaqjlcPlahiWDK07rVmblBdHLdCo00msj+v5x5nrGRiTPJaGXZlh/qpF+uujO/SbLJhtEwyFmFhR5LhQrnmHhkpVEsPKLTnrpkxgsoPmJZ0qkVOhKLLU9G6+9xGyTIAhQZlc5shKM5dGWOV/TlRgoyrorcrTd9gcGVIZXyXZlN1PXcVCZNJxSib0vku7vehWpESWpM3Mt1o4z5PMC3pFFkCWlLsyH3Rz7XFJI0X97lshQeqHvweWSbdmpru/lrubnq60vQN5AI/p671xZlkw2iZbDrmjNdfqsB5uCS9C6qTnQlPN9q4zxPKplUTCgmTu5FLLTYImpnD3eSiFR6okuz8C6oAQ5OMmKlWZAyWZYYLRqDxrsoyqbrykPLcs049HO/DaCRAFkonokhJjZc/m9HGfZ5g+mSZthY0GGi1QdDMHKUWz8Kc2jIBxr1Vnnugce9SETO10oyK6lrUkQTC5aGRgh0Jk3W6R3kfFOrh4l7QVc7SXJrBauM+TyibIbLMJDzuomE5Dwxt3Oc27nPZivWTomGRiEYQoupQhBnL8TJSKBMR0J6oNe7VWPdaaSZfNknHo45HXq9uTLaiuQdtF+i5O03n5859oI37PMHvubeiNVjJsOhqs29YLcvMbYotPpclV4s9Ratqug8XDDqSMSKu61mxojs8SzVXMkknoo7HHSYPqYqPYd2jhoOiZeZgqz1t3OcJQeUHYHLTyKJh0ZnWxn0+UHKfy1bIMobpqSsDbllmkpp7oRwYKQOwuCNJPCoCI2aU595IHlIVH6t9X73bDRcMhIBMstZzn0v3QVPGXQhxuhDiUSHEZiHEJXW2O1sIIYUQ61s3RE0zGKa3/IDS3CczjSwaJl1tCWBueSyaWtznsiWae0WWcdNKzd2fwKSIRATLO4Nj3QvliudeRx4qmxb5slmRZYK3GymU6Uh4Zw7Kc59XmrsQIgpcDrwUOBw4VwhxeMB2GeB9wF2tHqSmMXYnptaGQrba29PMHMVy9Vy2QjcuGZanrgxALBqhLRGddH0Zf6MMP2F13fMlr+ceJA+59fT2RJSICI6W8R9/vmruxwGbpZRbpJQl4GrgrIDtPgv8BxCcYaCZUsqWRTzI05jkgmpXxSDMJY9FU0vRrJ7LlskysVrz0Yr6MvaCZ7hxt2PdA4y7s6Aa7rm7E6SEEGQCSiYENQqZi02ym+mh2gtsd/29AzjevYEQ4hhgpZTyN0KID7VwfJomMc1gzX0yDTvsRbhEZT+tv6jv3TbAdX/fwedfeaQn6qIRn/v1Q5z09MW8YO3iuttdfutmbt60y/l7aTbF5W88xumLGcSuoQLvu/re6sNMCN514sG89BnLmx7fdLJ7uMBnfv0QX3rNM2kLiC4Bu7doyXUu/brxQ/3DXHrDg6ElJp6/dhEfesk6z2tFw/IkMCmyqXhoGd0gPrVhE6cevpTnPW2R89pIsUwmlQn9TG93mt0jBUq+MeRLtvTUUUcechKkKsY76GE0nA/w3BvIMkO5Mh/9xQN87pXPYEF7wvPexq0H+PyND3vKPrzrpEOm/Jqa9IKqECICXAZ8sIltLxRCbBRCbNy7d+9kD61xYVjSU1tGae6FCSZdGKaFaUln0WkqFpL+75E9XHXXNkbGka5eNEyu/MuT3OQy2mFsuK+f/qEC3e0JDEty80O72X4gOLtRcdeT+7nryQOk4lG62xM8tmukqWPNFHdvPcBvHtjJ47tHQ7dRiTedIbOw25/Yx8anBsim43S3Jzz/7Rkp8st7+2v2GRQtA6rsb3PnM1cy+P7tW/n1A979D+fre+6LOxJICYP5kud15bnHoxHS8WB5yJ8gZXeP8m63d7TIwvak5zUnbyTkPniwf4gb/7GLe7cN1Lz3p8f2ct/2Qc/vmvJJWlNBM557H7DS9feKymuKDHAk8MeK97UM2CCEOFNKudG9IynlFcAVAOvXr587ebxzALu2TPVmUzfeRD1ulYGYikdJxSNTIssoj8lfO7seOytREs1M/XNlg+c/bRH/9fqjuXPLfs654k76BvMcvLgj9DNqoe575x9LezLGy752W8saUEwF6vzWO8/qXLYno8QiomZb9f2+/9bjPLM/gE/88sEa4wv2AyMdYKAyqTiDuVLN60Eo3XyHS2KRUjJarG2x58Zd5mCJy8HPVxZU7W2C5SF/UbJsKubR5qWU9A3kOelQ76ww3UCWUb9p2Gwhk4zx/bceF/qdpoJmPPe7gbVCiDVCiARwDrBBvSmlHJJSLpJSrpZSrgbuBGoMu2ZqMXzlB4QQdjemCRpldwbiVBVNUh7TeELnlEFoxuDmS5Zzs1czG8MbLKv3u9ritFfC4MKMxGxBnd9659k5l/Fo4LkcqcSV+w07hPcOLRpmsCzToNyuGxXO6I58yZVMTEvWXVB1Fkx9nnm+ZDkecSZEHnLKCafi1e1c4x3IlcmXTed6UaQaLKiq3yjoWvb3Y50uGhp3KaUBXATcBDwMXCul3CSE+IwQ4sypHqCmOfxJTFApdjRJzz0Ri9CWiE2J5q6m781O4wF2VAxBMxEZhco0HWBZZ4qICG/RpugbyHtu7KBp+2xCnd96D1+nsUY0EthRaDigX6kiFY8GlgmuK8s0+Xupc9E/mHcKcqnP1jOG1RBG73WTLxmOfBImDzkVHyv7yPq6R6mHv2oMokjGIggR/hBVgQtBETq2hj/9xr0ZWQYp5Y3Ajb7XLg3Z9uTJD0szXsq+qpAwuTKlVc/dlmWmwnMfmYDnrgxCI+9QSulosADxaISl2ZTzcAjd/2Cegxa2O3+3qrvQVKHOS72HeLUlXiTwgR/UjFqhZj5FozoLUn+HG/dmPXd7/aNQtjgwVmJhR7JuXRlFNsC4+893NkQeUteaWnS1ZxrV609JRH7PXQhBW52a7uo8BD3Y6v2+U4nOUJ0ntNpzd7dRSycm32w7CLfm3ixVWab+A6FUWRB2G6Sw+GiF0lvdN3Z2tnvuFaOSq+u515fY6q15hEVdFcvh0TIlw2pKDnQX/+rzndd6nm41jr16XkqmhSWrD6Owh7JfgsqkYowWDWdmosbhN+5QvxtTI8292TWlVqKN+zxASlmp5+4z7pPx3F1t1KZacx+P8VQ3XyPvsFCyx+9e9KvXxQfs6fNYyXTql4A9bXff/LMN9fCu9/B1n8tUPFojsdWTZcJqqpRMy9OoQ9GoaJebvoG8c9x+R24L7p/qJqjMgTrfbs096LryJ0hlUjEsCWOVh1f/YJ62RNSpw8MTt8I3joX7ryYVC5/BOp57UIROoVz3+0wV2rjPA4yK4anx3CfRGszt7bWi2XYQE/HclXEeLRqYdQyuGq/bc+/pSrNzsBD6uR0VmaDHp7lLCaOTyBeYSprR3B1ZJhYNXGQfKYRrwmE1iorlsCSm5itD9g3mOXb1AqAqhwQV7fLTnogREd7rxjnf8Wq0TFiGqtu4+yWevoE8PV1pO+9CSvjDJ2H/ZvjFO/la+dO0j20LHFOhXN9z17KMZkIoY+UuPwCQmkRT36osE21Js20/UkrHADTruVuWZOdgwTEq9dq5+W92sKfahiXZO1IM/ExfgN4aVlxqtuBo7s0sqMYigdEvdi2XEM/dKZjlzZcITWJq8vcyTItdwwUOW56hPRF1yTKNPfdIRNCR9C6EKtlILaiGyUMjxbJHIvEvzvYNumS5zbfAzvvh5V+FM77CYdZjfGLb2+Gxm2vGlHdkGe+1rK7zWRkto5n9qMzCeI0sM/H49NIUyzJjJRPlQDcbLbNvtEjJtHj6skzlc+EPBXWzpXzGHYJrgUNwpIRTFnaS9VKmikITC6pqcTwRi9gPfNe2UsqKVBHiuQfIMqYlMSwZKMuEldH1s3ukiGlJerva6HGthTQTLaOOE+S5V2WZkIqPvuxTv37fP5ivztxu+zJkV8BR58KxF3Dx4u+yN7IEbvm07dW7qC6oeo+nrnPtuWsmRNVz9xr3yYQwehbhpsBzd3s4zUbLqEiXdRXjXs87zJft9zwLqqoWeEiD5b7BPMlYhIWu9PFWVTqcKtT5rRstY3plGfe2hbKFUSeuPBWwoOqOvvHT7O/lzJK60561kJGCQTwqAiUfN9l03GNICz4ZLqz88IivnHA1IapMvmSyf6xkr7ls/StsuwOe9z6IVappppfys/TZsPtBePJPnv2Gee7NLBBPFdq4zwPKZrDmPhmtXBn3VHxqNHf3zd+s4ex3jHu28rl6nrs9/jaf5g7hse5qSj4V3YWmivHIMkGzMH9Sj5+2gJoqzv4CavQ0+3v1u6JSel2FwJTxbVRryB9Pn/ctoAeFS6q/3RKU+2HkiZT585egfQkc8yZn23Q8yk2RF0D7Yrjjcs9+8yGae71m31ONNu7zAOW5B8W5TzSE0ZFlosGLcJNFyRwR0bzmrgzAuuUVWaau516ruXckY3Sm46GyTN9goSZ5JSjsbjbRVBJT2TcLc21bXcBsoLm7PtOM595IalOGtKcrRU9XmoFcmVzJaFhXRpH1hTr6NfcgeUhKWdMIxJ3tqsa01ngMttwKz3kPxKvXQzoeZagcheMuhMdvhr2POu+p85ArmZ4CbPWafU812rjPAwzLvpj8skw6MfHkI2cRLm4vwpVNGVo1cCKoG3NZNjWOdHU7dK6nM13ZRx3P3afBKuxY9xBZZiDv7FsRlg05W2im/EBVlolUHtTVjFN/xqYfR3N3LagWXdE3ftoTMYRo7LnvGMizoD1BWyLmhJ72D+ZrZJMwsr5Svc1o7kXDomxWJKiHNsBP30DXUzcTxWS4YNA/MMapkY0ceudHINUFx7695rcolE1Y/zaIpTzeu/s+Gw2YlWrjrpkQRkWW8S+otiViGJZ0PK3x4Pb2pqKWtfKoervTTUse/RXZpBldN1+q1dzV8YJkmULZZN9oMdRzn63G3UlianJB1Slda3hlhLBomSDN3S3z+IlEBJlk4yxVe+EyBVTlsh0D+abDBjO+sgF+zd2tpSvUNddj7oRfvAsev4nE9W/iz8kPsP6xyzjt1jP5buIyYkYOzrockt6yw856RfsiOOocuP9qGNsHhSFeOXIVv078O0eJzZ5rpWaB2DTsz41OfVVcbdznAUZYKOQkjLK7tkwrGn/4UTd/b1e66WiZHQN5VnSnm4pgUdNkf+XC3i578U76oh12DhWc992k4lESscisjZZpZkHVHdbq7wXaaMEvKM7dvdgeRDP1eNwhh9WiboVKwk8Tnns6zmjRcM6j+j5thT2w4+9kkvbY3NfWcN4gjsFJ/7gEonH413vg9T9mR2Q5x+/8CTmSXBq/GPHe++Cwl9f+FhVJS0oJJ7wHzCJc+2b46jM4v/Bj1ohdXJG4jNz+avsLpwplQsAD18E3j4dfvBPuv6rhd5ws0z9X0LQcs04SE9g3Zuc442wdb69SGxta67kro9LTlSZftnXKek00wDYIx61ZUMm0jNStA58v1y6ogm1IRosGwwXD85u4ozf8+MvCziaakmUMCyHsmZ3/XCrjF+YtJ2IRYhHhOfeNjXv9ejyqzMOJlWYrS7MpohFB32CuOc+9nGeF1VfJLDXpSMbIly3SFOi89lVw4AkynSv5SOxokvtfD3INCMFIoczFsevoHnwQXvcj6D4Iug/ikvYM65dFeWo0CgiIhs9iLGl//9TiQ+HQl8Jjv4V1L+dNm08kHk/y9dyHabv5QlhzE8RTjORLnBa5m0U/+hTsewyWHAGv/zE8/Yz637EFaOM+D1BaeG1tGfvmm0gYY9EwiUUEMZdxb2VlyJGCQSIaYVGH3RRhtGDQ7etg42a4UGakYDheXlB7NDfKGPkNkBMOOZD3GvfKImtQTRG/vjtbKJuWEylVP1rGbmYthCDli35pFC0DSo5wae4umScIfzEuP4OVsrpKlolGBMuyKfocWSZkLFLCQ7+Emy/ldUPbuTXyPobzL7KNe8ngw7FriBx4Al74McT2v/GOod8Qu/9XsG0NrDuDDmMx74z+mr2Hnsviw6sFbTOpGHvLCfoGRzluzYLQcbsjh1LxKLz6O5DbDwsO5r5P3sRhi7NcPPRuvrPvq/Cbi+G4Cznj3g/wL4l7kBwKr/0+HHYWRKZHMNGyzDygGi0T7LlPSJZxZSCG1ReZDKrGh9IiG03j/QlG2QYdf1S5X39InRMO6asx0zdYICLs0sB+xlPpcDpxe+t1NXdXBcc2X8bpSMEgGhE1Mxw3dqazK87dDF9QhcbnRv327ho+vd1pth3IMVoMyZbdvQm+fwZcdz6kOhnqOpyvxi+n/NRdACzZfxdvjd0Ex78bTvownHf92fufAAAgAElEQVQ9Zyb/l2uX/xssfBr87QrW3v1JtsjlDJ74Gd944wzkyuwaLjgPnCBq7qdUJyw42HltaTbFTdZxbFr7brjvJ3DFSSwa28IXxTsQ774DjnjVtBl20J77vKAaLeMLhaz01JyIx+02CI6802LPPZOKjTvppcfludd7IORKRs1iKoQ37egbyLM0mwqUhhrNEmYKZWQyyVhDzz1ZOYfqN1ELpMOFMh3JWN24cn/iUzFkVqSwG2WMhO6vWla3zXltRVea3z+02/m8h7F98P2XgxB2KYBj3szDDz5Oz/WvoOe3b4Mlv+DlWz7HVnpY/eJqJXIrvYDfp1/K6877BBSGue3mn3HJ7YLrM96F0kwqxv3bB52M2dDfIaTVXsmwE8GWZOxZ6F2r3sERCyMQS/CZXS/irp0mHw2ReqYS7bnPA5xomTqa+3ixu9t7DUKrNfdsOu7IAc167isc415f182XgtvALepIkIhFAjz3nKdgmJvZ2o1JGZnu9gQlwwotiFY0TCfhyL/IXq+ujMJfj6aR5u6PQffjjnFX9HSlnTWUGs39pn+H4gic/xtY/1aIREl1LeX88kfAMuG7LyJb3ssXEu+FRNU4e+S0VJaHu06kj8U1D49MKuYcO2jNRREWoKD+VsZ9pGjB6V+AUz7FnnJqRurKgDbu84Kw8gP+yIjx4JFlpiQU0uu5N4qY2TGY92j0dvp5+AOh4Oqn6UYI4cmIVPQPFgL1doBMMj4ro2XU+VhQWasIe4jbnrtvFubS3DPJ+sbHzlCuau6lOnHuUK374o9IUvQP5knFI864wWtUPfr/5j/AA9fA8z8ASw6rbpOO86Rczp3H/TdE4vxuwXlsSR3uG0esJlomIqDdd124j9fbjCzju5/Ub5lJxWlLRD3X5XCToZ1TgTbu84ByWIaqWlCdkOfukmUSU7GgahuVZtPV+wbyLO9KEak8wBp5h+6uPH5UOKTCsiQ7h/KhXtts7cakjIyqhRN2nu2WePZv0eabhfkLaQXhz3Qu1slQBfv3Mi0Zer2ohihuKcjbIKUyntIY/PoDsHAtvOCDNccA2NpxNHx4C9dl3lRzvm2P3FvDKKi0gduTD5u9Qe1vp3DCbhORyrXiO2aDh+dUoY37PMC0gqNlUpPw3Ot5e61AyQHNlojtH6ztbVrvgZArGaHGvacr5THue0aKlE1ZR5aJO+GaswllZFSUUdh5LgYsjivD20zz5nQiSq4ckMQUErpaTSAKPqd97sqLFfw19AG49QswuA3O/G+Iez3qrDvXIdEW+DD3V44MC7NUr3W3xWlLhD/owu4nd6mLoGM2kr2mCm3c5wFKcw+qCgmTiJaJ+qJlWpnEVCkz25FsrnZL36C//V2MQtkKzb7Nly0n7M9Pb1cbe0eKjpHq8+n5fmZrlmrBJ8uEnWd3Yw2/gWomrty/oFqvtgw0rsfTP5j3RMpAQA39nQ/And+EZ78VDnpuzT6SsQiJaMQ5J0HnW62VuJtvB4V8qodRPb0dwtee1IMyFY9WciJcskydcspTTVPGXQhxuhDiUSHEZiHEJQHvv0sI8Q8hxH1CiL8IIQ4P2o9malAZqv5Ij8lo5e4F1VSstZq7aUnGSiaZVIxY1K5dU89wlgyLPSPFwDrrYd57oWQ6YX9+1H52VmrM9A2GJzA1c6yZQhmV7rb6nrvdEi94FtZMRqhdU6W2tozHc9/zCNz0Mbj1Cxz25A85O/JnxkaGavalyur61zfSiagjL2WSMfjdJZDuhlM+FTgmIYRHAgk635lU3CMPhenf6rWwNRdnjCEzWPV3WyLm8dzd1/lM0PCoQogocDlwKrADuFsIsUFK+ZBrs6uklN+ubH8mcBlw+hSMVxOAEbKgqm7oicoy7e325RGJ2PW1W2XcVWElZVQaJQntGiogpX/qXvWmF1YWWd3kQxZUoRql0TeYZ/Wi9powSz/j6Qs6nTSruRfLFgvb7WshHhVEKxmnliXtuPJmPHdfyd9oJcENAMuCG/4F+u8FKTkEyVcSsOX+JDzNG1NejZSp/a17utLsHyuRffJGeOqvcMZlkO4KHZc7/yBXrg19dV8j7cmYJwkuaLt6ejtUNXf/WoK71EUmFWPbATshzn+dTzfNPFKOAzZLKbcACCGuBs4CHOMupRx2bd8OzM5uwnOI3zywk2f0drJqYXjcrcIIyVCNRASpJrox3bRpF4csbudpS6rxv25ZBmjYau8ndz3Fk3vHAt9rS0R598lPc24+f5lZf1SDH9XbdEVXbURFmMHNqyzCAFZUYpmvvG0Ltz6yhzuf3E9nuioRORSGYMN7OSy2EsHxnogZKSU/vvMpzjy6t6a0w1C+zIb7+jjvhIMa1iWfDDWyTKjmXp2FCSFoqzTJHisZSNm4kUQ6Ea1p1uEJg9z0c+j7O5z1TTjqXLb07WLXFWdz9ObrwPqUJ3HHXcfdT29Xmm17DhC75VI7Tf+Yt9QdlzsTNl+yas63uka+fPOjdKXj7BjIcdjyTO1+Kts18twbhUKmExE7iivvbR85az13oBfY7vp7B3C8fyMhxHuAi4EE8KKgHQkhLgQuBFi1atV4x/pPg5SS9119L2993mo+dkZjhcsIyVAF25uoF+UipeQD19zHWUf38MVXP9N53Z34ovYTZjzGigYf+8WDJKKRmsqUlrQv/mes6OLUw5cCtU2Q/VENfoI860a6br4UHi2zvCvFumUZ/vbkAf725AEAXnzYUu9Go3vhx6+GXf9gJZJvxu9kdPRIYBEAj+0e5RM3bEIIwXknHOT56K/u7+cTN2ziuDULnZaAU0HNgmpYtIzpNcapSulap6hVA+OTcpUJjkSEJ5KKcgH+8GlY9gy7HV0kQnvnAq4yX8xz81+HJ/8Ih1TNwb5Ru3/tkmxtyOHJT1/MSwd/Avu3wZs3hNZ4UbijmAoBC6rrlmVY1JHgt//YCdgPtmNWddfs56CFbaxbluGEgxfWPV4yFiEaEeSKwcY9VfHc1ZiaafY9lbTskSKlvBy4XAjxBuDjQM1jV0p5BXAFwPr167V3H0KuZGJYsulqidXCYbVLKG2J+tmLg7kyuZJZcyx/d/t6zbaVN/al1z6Ts47u9by3d6TIsZ//gycj1F9mNpuOc2CsFDpGVX99uSsGuZ4OLqWsyDLBS0rxaITfvf/E0OMx8BT86FUw3A9vvJ6BbQ/ykj9/isFb3wgHXw+xFAe2PcbhYit9B1bXfFxJD32DuSk17lXN3f4tQj33sreZtXpQN9sCThnNomGRTkS9+7vrWzC0Dc7a4HjoqXiUm631FOKdpO75oce45x192vfglZJznmbC76+GdS+Hg09q+P0zyTh7hked8+3f59qlGTZ+/NTG+0nF618PFfw6v8Ity2RTcUqm3Zi7mWbfU0kzR+0DVrr+XlF5LYyrgW9NZlD/7KgnfrPdfxxZJsBzT8Xra+XKEPmPVTJrDUKYvLMjoFaIIigjVE1bs47nHmfrvmBJxx5jjiWZpCdpRj0Ygmq+lE2Jacm6YW2h7HscfnAmlMfgzTfAquMRvSfyjluG+fboN+EyO5HmOcCNSXj0wWPgxGugY0l1vJWZRlg7v1aRL5skYhFHTgrV3H0yitLQG9VyV7jju9OJaGUmELXLAtx2GRx6uscYp+NRSsR5ZMnLOPrh62FsP7TbXrGncXl+AH7+Tth5n12AyzIgmoDTPtvU91fRMOp8h62xtJKgOkN514Jq1jWjdK7zGcpQbebqvxtYK4RYg23UzwHe4N5ACLFWSvl45c8zgMfRTBh10zW7gGeElPyFSqRDHVlG1fnwX7DFcq1BqJeUAsELUkEZof7uNI2ShPoGaxOM6tV0D+vC1JADW+AHrwCzDOffCMuOBOz2fLdYz+bqZ36PN3U+AKlONjxe4L5HnuAjuWvgOyfaFf9WnQDAroEROsg5D72polCyvVWn3n69JCbXb2HPwqxxe+7qd7U1/Aj88Yt2otGpXmOsygTfu+gVHN33U3jgartlHa6669Yo/ORVdkGwZ77O7lfathAOeo5TjKsRKtfB88CYYjLJ2sV/dfxkLOLp3DWTXZigCeMupTSEEBcBNwFR4HtSyk1CiM8AG6WUG4CLhBCnAGVggABJRtM86uJpNvQuLM4dGmvuSi7xH6voymoE+yExGlI/vW8wTywiWJIJTt32Z4T6y8xmXenqQQuQ/YMFDu/Jel5T3mrQQyGsUUddBrfZHrtRgLf82jHsgBOuuTW6Ck5+GQC/f/JefmUeymPpo/lx7Bt2xcLVz4fBbVx1YCsk4ebNbwLzsoba8URRiTvVbkm151lK6aktA3ZlyHylXyk0obk7eQ729sWyxUqxB/7+fXj2W2DxoTWfScejbI+thBXHwj0/hBP+BYQdpdMVyRO/6jWw68FKbfOJBdZlUjHGSqazXjOu8z1Bsulaz90uARyxu1C5InSafXhOFU3FuUspb5RSHiqlPERK+fnKa5dWDDtSyvdJKY+QUh4tpXyhlHLTVA56vqNuumbLzIbFuYNdGbIpWcaluUspA2WZME23f9AuDRD0cIFa466+V4fLcy+ZlhM/7cayJH2D+ZoEo2ilnVugcXdFLzREStj7mG3YC8Pwpl96DLsim/LWl+kbsCN4/jq2nPIFt8KRr4HcfqxlR/Ft40x+Y53Ay/b/AP73dHtGMAXky3ZxtHhlITvoPBuWxJLeIl+qo1DDWu5Swq1fZP09H0FgOWWCS6bFG4rXgojAiR8K/KizRnPMm2HvI7DjbiiOsmjgHv43/p+2FPO6H0zYsLvHvXekWPleU5+TmUnV1hnKuRbvnRLW+XLTC9ZThS75OwsZHqfnboY0yAZIxyPsGa5j3AdqPfegqn9Oc+CQffgbS7vp6Uqzd6ToNDkYKZQdowR4dEr/1HrfWJGSYQVKPhlfNqCi6rkHXN6lMdixEbbfZf+//x4Y2wuJDLz5l9BzdOB38EtHfZVCZiXTYlcxycpXf8d+/UCOL99zK4lohLsSJ/CFff8D334BvPYHsPaU0N9oIuRLhvN7pUIevkHZpOpB3dD4/PVr8Kf/Rw/w5mg3+fLzAOjM93Fy4RY47u2Q7Qn8qLNGc8Sr4XcfhZ+8BoojvE1alEUMXvM9WDe5bkRq3HuUcQ863y0mSEJ0lz7we+7u63y60eUHZiHVUKrmPHfVjSdQc4+HR7kA9A/Zxr1oWE46fqBxr7OfIE3cjXpvV6VPqb/eRr1aJCpSJjj5JDj5qeq5ux4U2/8GV7wQvrgSfnhmpW7JU7D2NDjjK/Duv8CK9aHfwR2uqTJmj1rZCVTXLaA6EzpqZSc/za2n9I6/QPdqu2/m2L7Q/U8Ed6JW2IJ3UDapCm0cLpRJRCPBWvV9P4U/fBKOPJuhFS/kI7GrkZUZyFkjV2ERgedfHDq2NhUbn+yAF30cVj0HTvwwV6z4Amenr4TDz5rMVweqcseeYfsamY4F1aCEO/d5cEdxNdvse6rQnvssRHmjJcOqtvSqg2lJohERqFenGyQf9Q3kiQg7Hn2kYJDsiLq8PdciXIh2XzYtdg8XQuuyQNUwq4zQ4YK33ka17G+toa7b2zSkzroyco4Ge+BJuOr1kGiH57/fNjQrjq2b/Vh7rDj7R+1wTZUxe+zqBdy9dcAT5qnGq97bxSJWnX2lvej66/fbvTtblNiUL5m0V9YebGMaZNwri33unIVEhFzJCC9q9fgfYMNFsOZEeOW32P3kVpb9+GTW3vERWH0FLyrewh+zZ/Hi7PLQsXnKBJ/wbvs/YOP2jZSSuYl+ZQ9q7FXPfTqMu137XcX8g72wrYy7J1qmiaJsU4n23Gch/qpyjTAqxj2IsOk6VOt8HLy4w3MsxyD4MlSDPMNdQwUsWT912zHujgTk9WgydbJNVW9Tz/7vvwa2/iW0G1POvaBaGIafngPSskMbX3wprD11XIZdjVF5bCpj9tjVCypjrPXc1Xs7BnN2HfIXfgwe/hX84/pxHbce+bLllWUCzk8pYBamch8C+5Xu3gTXvhkWHwav/wnEksS7V/BZ4zwW7NsIP3wlBjH+b/Eb647NXya4OubGzkqzKM19t/LcpyNaJhVHShhzZey6ZZn2RAwhqtEyM+m5a+M+C/HXg26EYVo1XZgU/i46bpQks66SaKOOFVSvOx2PUjZlTdnbRkW3wO5LKoQ7pt7wLOLVKyXQP1ggk4xVU/zvuwp+cSF8/ww+uPfjLMzVLlY6skxMws/eDvs3w+t+CAsPCR1jI9xaq5KK1ixqZ3Em6Qnz7B/MsziTZM2ids+2PPdfYcVxcOMHYXjnhMfhxp2VGbYm4sgysVpZZqjSx9YhdwCufoMtpbzxWkjZEUrpeJTrzJPoX/Q8GNrGDdHTKCSXUI90yHUXlEk6UdTYdw+rBdXpiXMH77WaK1UfWJGIoKOy0D9cr9n3NKCN+yzE0z1mkp57Oh7FsGqNMlQ96cOWZz3HDfL2wmKp69UKUSRiEZZkko5xH/EZlXqlBHYMuPT8nQ/YzRtWvwBO+TQH5x/ke/n3w28/Ykd2VFAe49K/fREevxle9qWmMh7rka3MEqSUzu+2rDNFT1faeUhCtVa5arTtGP5IFF71bTBKtuRhTb42vLtmfVg0U7Fc2zVJfWbvSLH6kDUNuP5tMNRnhye6Fkrtcy/402GfhOPfxXc4O7Tcr/sYQcY9Vwov6DZe1NgdWWY6NPeAhu4FX3asiqwayZdnLDsVtHGflYzbc7esmi5MirBiR1D1pMM8d7+3F7SfRhUVFb1daedB4Hg0A0/BXd8hU6k7F/Rd+1Vjh/wAXHMepBfAa/4Xnv9+vvusn3ON+UK469twZzUpOl82OS1yN5l7vg3HXgDr31Z3bM2QScUom5KiYTneeSoeZYUvQatvwA7bTMWjtlc/6NKXFx5iZ19u/gPc/t+THlPeZSgbau6exXH733uGC9WH7C2fhi232ovLK4/z7EM9DPaLBfDS/2CP2R7aP9X5TMhaT71qneNFhdLumVZZptZz9zcKUVms2nPX1DBSMFjUkXD+3QjTkoGRMlC/0Ub/oL2YunaJMu4qSUUZhOoF2xayn77BPIs6Eg111N7utqrnXijTnTRtCeC3H6bjm0fzqdgPEIPbaj7XN5hnRWcSfn6hXevldT+EjsUAxDOL+Pfy2zAPfRn8/lLY8XcAokPb+FL8O1jLnwUv+ULdcTWLe6HM3Tikt9uO4ZdS2l69K3LIfqAVvDs69gI4/JVwy2fgqTsmNaZC2XLObyokWqYU8KBWZRn2j5VsY7XpF/bD5tgL7KQkH+4ywWqfiUbGPcRzL9Qp6DZe4tEI6XiU/ZW6RNOluYPXEcn7ZiMqomakoD13jY/hQtkxHs00ZjbMOsa9Tqu9voE8y7Iputq9U82SGRwKCQGeu69DUhg9XSl2DhYolE2KhsVp/d+B3Q/Cy76MOOJVvDH2B952z9m2d/7ErSAlo/kCJxdv5f2Pv8WWV07/Iqw81tmnHS0hOHDKf0FmOVx3Pozu5ZRNH0EgbQ8/VlvrfSJUk1MMz3fu6UxRNCz2jZbYP1aiaFj0VCQZf/IWYEfKnPnf0LXKlkEmGB5pmBYl0/LKMnU0d38ROMUqsRc2vNeOHnrJFwOPJYSoyD5WJePVm70cRF3PvYVG2B3t02g20ZLjBTR09y8SZ9Mx9o0WKRqWjpbReBkpGI7M0XS0TEDRMAhv6gt2wa/e7jQdlRX+YcdzD5Bl6njujdqTgV2LvWRabNk7xkmR+zm67yo47p1w3Dvgld/ktclv86eFr4Otf4UfvRK+sZ7Et47ja4lvEotF7aSXYy/w7FN5UUO0w2v/F0b64ZsnsGz0IT5uvYvIwjUNx9UsGb/nrrzzbrs2fP9g3hW22Vb5v23cLctXADXVaWdn5vbbM5Kyz7tvgkLFaLsXVIONe+0sTH0mhsHZWz9lv3j2lRBLhB5PReMEPfjrbS+l97u3UnOH6jWQjked0MSpJNRz98gycXZWcjp0tIzGw0jBYGk2RUQ0q7lL4gHlfqG+5q6aTkcigo5ErDZaJsAguPcjpbQ18bDs1Pyg3XrtP9bw0n+8n1dEbmfblof5cvzbDGXWwqnVLj2F9DKuyl4AFz8Mr7oC2peQSyziHaWLefzVN8GRZ9fEh1cNrmEnIJ3yacjt485FZ/OXxPPq/mbjRd3UW/eN2RmzFe/c3dVJrSmo13o6U5QMy5ENPCw/yp6JPHELfPlQuOE9sOVPYDXX7Uo1z0i5kpgCF1SdJCZhz4iG+pxz+b7Yz1k+8g94xVftRKs6qFDYoMX2IKot6aoLx5Zle/2tLPClroHpWEx1H085QmXTwrCkZ0E1k4o56x86iUnjYFZan6nOQM1Ey5iWVTdaBmo9btOS7BoqODMEu4NMJVrGDFqEq93PgbEShbJV67mbZbuo1K1fsBdCD30JnX338fXErfCHb1Akzr3P/S9OcHW0z6YrMevxFBz1ejjq9fzqzqf4/S8f5LPd7YHfrSaE8jnvgZXH87PbI6RHa/t3TgZ1rEd2jQBV71x1deobyDvPHvWa2qavsgBbw7FvtxdZ778aNv0S7v2xXR1x3cvgsFfA6hNDvelCpc5LRhThgetojx1O0bCchDaFMu7Z/tvghnMBOHrxMVwS6+XC6K95cuWrWXPk2Q2/v12AzgiUeYLwlwkGKBghtdwnQdbluU8HqXiURCziSJhBFUiDwnxnAm3cZxmq72ImFQtN0vFTNmVotEzYguru4QKGJR3D7G5CECTLBMk7fUFhkNvvhl+9D/ZsskMWX/IFWP5MCrkCb/rc17mg+z5+MXAwb1l2hGc82VSMPt/iY/9gnnhUsCTIMOLWPyu/kRCw8lhyxj2kGoTqjRflgT28047s6XUeijE6kjH6Bm3j3pGMOTqwO3nr6JUhSVMHn2z/d8Zl8Njv4OEN8MB19sMxmbXfW3sqPO0UT3iiOg/HPPyfsPU6XrLs5VzGuRTK1axVqBr3zgd/AG2L4IR3E33gl7wr9iuesJbz5PpP0Ix4pcoEB83qggia6U2oWmcD1Hlp9fmuR9bdAUp9J5/nXv23Nu6aCsqYZ9PxSo/ISUbLhMgy/vh0d5JO4CJcgOfuCYMsDNsRIHdfaRuh1//Y7qhTcWczbSkeSjyTj5aexV6ryEW+6aqdATriea1vIM/yznSolhqW2drKcLvqsezxOp575XcTQtDTlbKNO7Yko8pAqG36/YuqQSTa4MhX2/+V87Dlj/DIb+ywyYc32Nu8+JPwArueS75s8rzIP1i19TpYcgRP3/VrPhCLky+f6jHuJcOih30kttwMz3s/nPhv7Dr83Zz35esYJc23OrIBg6klHY9QKJmB0TdBBK3ROMllLTXu9jUwocYskzimuuZyAQ+soNIaM4E27rMMx7inYpXG0c147nVkmZAFVb/XnU3F2VWJFw6qLROUxKT2sXrob3D1e2FkJxz/TrtQVLK2vVxPV9oxjv4ogmzAd7UTgoJrxNv7UDHHtc0T2lpcIbA9ESMi7MQft3cOOM1IhPDOYtxe/biIp+HpL7X/k9IuCfDn/7Rj0dsWwLPPpzA2xP+LXUk+u4b0O25hyw//hfdt/zkH7nkenPgOZ1dFw+Tc2P/Z+1n/VsA2RH3Y4aTNygZtiRh7R4qBcfNBVDX3Ws891UpZpnIepkuWAe+1GtQ2MKgo3kygjfsso9q9JU42FauNkw7AtGRNY2pF0E0G1UqGblnm8T3e2jKJ4iD84LWQ7ia79GhOjUgiI10gDwIh2HVgiE8lf0LHtb+BRYfC62+BFc8OHeeK7qpx93s0mVSc0aK3YUf/YJ7nHrIodH/peJRoRNRIV/my2fKbSqWVDxcMervSniJtvd1p7t0+iACetaoqv6guVDsm025PCLu+/Nn/A6WcnaHbtpDee26iV+zjiRO/xdp4moef/Sm2b93Mibd+BJatgkNfAkC5WOQN0Vvtv7vspvTpEH24Ho7mrjJeG8ggytjlAjz3tlaGQlbG38oHRiPcdYaCNHftuWsCqTbVjZNNxXm0ONLgEw3KDwTcZGB7xd1tcWc6675gi4aFEBB/6Dq73vnidcS3/JHvJky4/TK4pwuWHsnb+rfTI56yQxRP/awtLdShKmVAR8Jv3GNYEsZKJh3JmFNtsl6YZbVhsU+WKZkszbYmvt07xjjDBaNmNtHTlWYwV3b+7X0vNX7PPYho3A6f/OFZcP3bWGGW+b55Gs9babf2SyVT/Ev5fdy99Ku0XfMmeMM1cMgLWb33/1gshjxhpClXU4tmjY+qR6NCIRPR+sY0KEorH6BPTxYnWmYaNfdMKuYUKysEyjL2mIKu8+lEh0LOMtR0L+PIMk3EuZsWsbBQyFjwgqqT1l9BtQ+TUto9N2MRxP1Xw7JnwnvuQnx0B+cYn+am1f8GR7wKzCJlS/Jfiz9np6w3MOxQNXwdyViNju7uYAPVapO9dWQZaNw8oZWoMfofOG4pxp/Q1dudbk5zb4ZEO7zhWlhwCGNtK/iS8XpPEtMYaR560fdh0Vr46bnw5G0ctetnbJdL4JAXV3cTjTjOQLPGPZ2wG60367kHRVdNuLdtHbIzoLlnXYEOQb0D1JiCrvPpRBv3WUa172LMI1XUw7QksRBZJhIRpOKRGlmmb8CbWZpJxTEtad/AhsVh0T67FdpRdvgciTYeSRzO7d2vsuOiL/gDr5RfYV/PyU1/N2UUg6QAf82O6ppA/YeGv/0dTM2CqnuM/jGtcBn7FTWGv42hfDm0/+y4aVsA7/wTv3ruteRIVUv+Vr7vSDRrlzbuPgh+8lpWj97LzyOngevhrzJO2xLR0CgrPyqOvmnNPWCNpqbOfguoRstMpywTq7ugqqK4ZjIMEpo07kKI04UQjwohNgshLgl4/2IhxENCiAeEELcIIQ5q/VD/OfBo7ukYpiXrNriGSihkHQ/Bn5quaqD0eIx71bgWDZNXRm4DEYVnvCZwP7mSwUCu3LBgmJseV9WDk00AACAASURBVGSOH3/mXzUSZ/yeu12/pPWenLppg2SZoH+7t+2bjO7uJ5ZkxLJlJ3cnJqjIBO2L4M0boHMFZZHgt/Ha9n6peHRcerDqxRtUVC5w+4Cm3erfrYxzz0xznLs6Zq5kYphWoOeuxjSTejs0YdyFEFHgcuClwOHAuUKIw32b3Qusl1I+E7ge+M9WD/SfBbuPaIRELOJcJI1i3e1QyPBTmfZ1URrKl8mVTI+XqbyM4XyZUrnMS63b7NjqjiWe/ajuOkpq8Huq9VjRFe65uwtzufff6OHhzwWQUpIrm1PSLFmN2/+dl2RSxCKCWESwJOM1/GrblkkzFVSzamXUahYwM0vhgj/wHwd9l0K8NsY+nYiMy7NUxxmqzJKaqS0DPs09qP3hJHGiZaahObb/mCMFI3A2korbDctn2nNv5tFyHLBZSrkFQAhxNXAW8JDaQEp5q2v7O4HzWjnI6WTXUIFoRARmFG7eM8KK7raaKaCUkk39wxzZ2znp47u747i96eV1dm1YVnBtGSlBiGon+gpOpExX2s4mvfXzHGwdBCxhuGBw0PA9LGE/HHWOZ3fpRJRtB3LctGkXj+z0xns3w6KOJIlopK7nfvvm/ZRNycanBljUkWw43c6mvLkAZVNiWnJKPLkwWSYaESyveOj+hW217Y4mjPvWfWM8ujt4AT0eFTz3kEWehcpErKqdB+YzpLvYHl1BMlbb1q4tHqM92fxvpBYs1cLxpEIhpyDOfbo9d7Dvy6BFYnuhPz7jnnszR+8Ftrv+3gEcX2f7twO/DXpDCHEhcCHAqlWrmhzi9PL+a+6lIxnjyrcc63k9XzI547//wsWnHso7TzrE897GpwZ47bfv4Gfvfi7PPqh7UscfKRg1ml2j+jJGUBLT6F67b+dhL6c9doan5ZnjFWdjdmXChzdwBPCu6DmM5NezfugmRkU7HU9/qWeXSzJJbn10L+/8UaW0bkSwelFwaYAgIhHBuuUZVi6o1dEXZ5LEo4Ir//IkV/7lSQBOOHhBw312puMM5kpOCOVULNopVi5oY2F7IvDBf9iyLEErI+p7NSPLXPijjTy2ezT0/c+edQRves5qoLajUSpA44bw8rw9XSm62sILhflRxkt57o1kGadMcGlqNfcFbQkyyVhTxetahbuInHO9+WYyqxa0BV7n00lLHy1CiPOA9UBg2xsp5RXAFQDr16+vv0o4Q+weLrKHYs3rfYN5ioZd1dDPE3vsG3LL3tFJG3d38+hq4+j6i3F2yV/fzXbn5XaVxL9dwceSm/hWurpU0jeYJ47Butv+FTb/Fk79LCNbN3LJ41fz5F2wfOw2/pw8mdPi3hvm6284hqf2V79/V1uCRR3jCzm86h0nBMbkd6bj/PnDL+SAq8jWqiZujp6uFGMlk+GCXY+nMAVTf8X5z13Na9evDAw7/do5z0IGmPdoRLCsM9VQlrEsydb9OV7z7BW89Xmra95/zbfuYOv+qgfur0QYVkOoWIl88nP5G48hMo5G3SlHlrHPTyPP3SkTXPZq7tGICM3JmAjpRJS/fORFTuOO6SDrkkvzJZNkLFITFfOTC44PDXKYLpr5RfqAla6/V1Re8yCEOAX4GHCSlLLWOs4R7CL73mQaqEZvBMUs13tvvAy7PPfxae6uCyl3AP72XbuS4opjOeF3l5DZewkMXgOlUZJb7+Q7iR+S3HwPvPQ/4fh3kjsyx9VfKvOOJ68G4Lb2UzjNd5yOZIwjeiYnPXUkwy+55Z1plodVmAyhx1W/pTMdd4xbKxftFLFohM50/Ro+QQTWdfexb6xIybB4Rm9n4G/c05XyeP85X2u3eNTWeXPlWuMeVHdlvKGDavuqLNP490351nryZZO2eNRzX7WCzrbp1bbdcmnedx4U7XWu8+mimRHcDawVQqzBNurnAG9wbyCEeBbwHeB0KeWelo9yGhkuGE6ZVrdX2t+EcW/FotlIoewswrkXbupRo7n/7QoojcILPghLj+C794xw/p7/gK8eCdgnz4oIeNmX7XrqQCad4PPGeRx22JGUt21ka/oZk/4u04FTnGswz+E92cDQtJmmpyvNHU/sr7tNn3sdJAB3JyuwPXS/9JQKKPtbMqyWdANSv6cy7s1436pMsKJQNqc1k3SqyPo099l0rblpeNallIYQ4iLgJiAKfE9KuUkI8Rlgo5RyA/AloAO4rvJU3ialPHMKxz0luOtV9w3kPcZd3XyqpZrHqx9ooeeer9XcG3nudj33yngKw3Y/0aefAUvtyosPLjiVi4a7+M6JJcgs46N/2Mdo+yq+ftzLnH2k41FiEcHtC8/mj/tOpGcKQgmngl5fNMpUau4TZUVXmt3DBcqmRTwkrlyVmQjTjnu70mzqq5YxLgTE8qcDWu0VDbMpL7sRKhplMF+2E9ya8L79NeZnsyEcD8rpGs7bmvtsfWA1dQdLKW8EbvS9dqnr37WBtHMQt4fcN5jnKFeZVmW4S5WWau5FNUeWaUEs84hLc0/G7Kl2Q8/dlESV5r7xf6AwCCd+0Hk/HY9yh3kwPNc+Tb+/4fecsmqpZx/uVH7bIMyN/LaF7QmSsYhzDqZi0W6y9HansaQdiRW2yKYaaYeFfvZ2pdg/VnL6dQZl4QZ1YyoaVsNs0mZwNPdcqelrwx+lNVWZw9ONkhZnu+c+N+7gacIdleKXWNxeufvfqukFQP9Qobal2jgoGnaSSNapTSGcZrv1MCzLniaXcnD7N+xU895qAS/3TV8om+wbLQUaEVVfJmwRbjaiinOpB2tVc589M48el3QURt9AnkwyRmdIwTPl0at9BMkyQd2YSoZFosks1Ho4mnu+TKLJmUA6HvGMp9Ut9maKWDRCWyLKSCVaZirWd1rB3LiDpwl31yN/Jb++gTzrltllbN2Gf8+I3fRi3bKM7dWPTXwt2Z2dqmimvozTfefB6yG3D078N8/77pveX8fdjaovU2qRtzdd9HannTjynBMtM3vG727aEUbfYP0iaSpe3i0/+Y3KVHru7ozTZh/8/mgZf/jmXEbVl/E3x55NzJ47YBbg9pDdXpZhWuwaLnDcGjvu2n2Tqn8HvTf+41e7MCkyDTx3KWW1/MCOjZDuhlXP8WyTjkcxLEnZtKo1WwIMSSZZ9dxb4e1NFz2d1eJchSlIlJksTXnuvnIQtfuo9mqFYP06yHMvllukubuO1ezDoq1SskAxVTV/ZgIlYWpZZo6gjGtvV9rnnRcxLcm6ZVkyvuYL6t/HrraNezP118OPrxp1uHowpmtrp7hRKlAsGoHdD8LSI2saSbtTwet57h7NfZZesEH0dqfZO1KkUDanpNvPZEnFoyzqSNSNpuobyNXN9l2WTRGNVJOhggyl31MGKJnBSUzjxV0muNkHvz96ZzYbwvGSScUYLpQDF7ZnC9q4u1DVBdctywQa8J6uFD2+mGW/cVcLYxM7foDnnqzfR7Vcqa8dExbsfsg27j6UF1somfQN5IkIWNZZW5DLbpJddkr+zhWUx7tzqDAl9UtaQb1Y95FC2W4CUkeWiUUjLMumPLJMTSikT5YxLXtW14pzmYhGUAFZzT7404lITfmB2TSjmgyqBWZuFj+w5s4dPA0oD3nd8gyDuTJjlTKtylta0Z2mtztdI8t0t8VZ1pmyvfpJyTKq3K9Xc6/nuZsV131BsQ+MvN21x4e7uXXfYIGl2VRgSF4mFeNAroQlm/fOZgPuXqVO/ZIWSBGtxH/duHHCIBvU6entstcWTMuuue/X3Nt8nnKpyWbWzSCEcBZVx6O51yQxzbKH7kRRfVRns9Q0d+7gaWCkUCYiYO0S78Jp1XNP13hg/YN5x+Pq7U7TNylZptKFydeDsZ5xNyrGfXHucfuFAM/dvRjWN5gL1XYzqTiFJpsxzCZU0lffQL7i0damg880PZ1pJ0fCT6MwSGcflSzVMOnJv6DabDPrZlFed9PGvaK5q+88mw3heFH9jWfzIvHcuYOngeGCQUcy5hiLHS7jrlrS9XSlPc0X+gbz9FRS5v2SzfiPH+y5jxYNx0P3Y1RkmcWjj9v11xevq9km5fHc86EeojuTsRXe3nSxNJtCCPt8zVZdt7c7TbGS+exHOQSNyif3dqfZNVxwZpT+5Bn/gmqzjTWaRUUgjcdzt8dhYVmSQtmaP7JMKs5gvkzZnJoKpK1AG3cXqmhXb7c3dK1vwOudg+2xSym973VNrqWaCsV0119Rhn40xHt3ZJmxx+z2avFaLV1dfGNFg11D4SF37oXcVnl700EiFmFpxtajZ2uijFs68tM3kCceFSxuUIStt6sN05Js3WcXb/N/z1Q86hhSwGms0TLj7njuzce5A5UOTt7683OdTCrm3HuzdTYyd+7gaWCkYJBNx53mC+pG7Hd5u+6Y5eG8wVjJrL7XnZ5US7WRQplMMuapOuhvYuFHyTLdI48FSjJQ1dy3HchRNmUdWcbtuc+tS0Np2rM1HbynTqx732Ce5Z3phlKSCofcvNeuQhoky0C1BEOzXZOaRR2v2f05zdnLJrmSfU/MF83dPcudrbORuXUHTzHD+TKZVMwp06o0UncMsjLkOwbz7Khopeq1ejdwc8c3agr8N6oMaZiSLKO053cGLqZC9abcXClNvCJMlnFlR84lWQaqkli+NDsX7VZ0h8e699eRyoL2oc5jzYJqjXFXskxrfg9lrJsuP+AqQzwbQ1Qng/temY3XG2jj7sHdKEOltA/m7JZ06uZbUmm+0D+Yr1by6/Ya/olKM+66Mopsqn5lSMOyOExUeqksDa7kmPIZ9zBZxv1gmUuyDNi//c6hPGNFY1YakM50nPZENLiqqEvaq4dyHtR5DKoKCdUSDI4s06LF8fQ4F1RVdE2hbDohkbNxVjUR3PfKbLzeQBt3DyPFsqM793bb+rmT0Vm5sSLKqx/I1/T5dHv1Ezp+IdxzDzfuknWRbfYflSqQfpTHpZqK1IuWUcxFWaZsSrYfyM3KabIQwp5d+GZ1JcNi90ihqUbjbYkY3W1x5zwGJTFBtXiaEwrZorBWdbymZRlX6z9/z9e5jvtema0PrLl1B08xblmkt8uOTNh2oCK9uDwrFQ7ZN5gnFY+wsN1uV7ZkHC3VAo9fKFene2P7oZTzlBcNwjAlh4mnKCW6IbMscBt1Q/UPFehMx0MbZmTnsuZe0aP7hwqz1oDYobLea2P3cAEpw6WyoH30VwrVBZUfgFrNvVWee2q8C6qJ6oLqvJNlXMZ9tn6n2VM6b4aRUjJarDan7u2yy7Te89SA87eit6uN25/Yx7KsnbGqaltHIoLlnROPmBkpGDxtScw27F9/FpQL9Kw4gQujPcT3RsDqAV87PdOSHBbZxkjXOhaG1Nh2X3z1tN3MHI2WAW/T6tmqgfZ2pbl/+6DntR0+aa+ZfTzYNwyEa+4qcahYbq3m3jZBzT1XMrHk7I4sGS/uGfZsvd60ca+QK5mYlnQ8ZXWz3b31AKl4hAXt1WbCvV0pdg8X2Lp/rMZY9nSlJhzrbmvuMfjLZVAcgfVvI7b1L/x7/E9w50/hvk67KNjqF8Cxb4d4mrJR4nCxnT3dJ7MwZL+RiCAZi1A0rLrT/0Qs4mw39xZUqyGgs9WA9HSlGciVyZUMR4/u80l7zexDEVR+AKqee8mc4WgZj0wkPa/NdbTmPofwJxCpm+jB/mGPdw7V5guP7BqpMe69XW0TkmWklAwXDHpEpf/pUefCGV9BvOcuTja/yQ1rLoXDz4L9T8DNH4OfXQCWSXxwKylRprCgNnnJjTJ4jRJllCw0lzJUwT5vSlaajZo7eDNpFWqWtzyg1k8Q7ustVHN3PPepinMf34Jq3l3QbZY+eMdLeyLm1NqZrdfb3LqDpxB/uV11E5mWDDTgoe91p9k9UnAKejVLvmzPHE7a9X2QFpx8ifNeLrWUOzpOhTO/Dv+60W5q/civ4aaPkdz/kP35BYfX3b+6MRuF3KnvP5dqyyh6u+3zMls9KXe/V0XfQJ7FmWTTBsL9cE75jGyY5t6y8gPOgmqzSUyuUMh5tqAaiQhn7Wq2PrC0LFPBX7QrFY+ysD3B/rFSoPRS/XcaLAu23QHxNGvaYkgp67ZUCz6+wUFiF4ftugGOvQC6Vjnv1RQPO/6dMLAV7vwmKzJrKMso5QVPq7t/dVM1mv47Lf7mmOcOtlz28M7hWWtAguq6N6rjHraPRDRil3l2kfZp7qVWx7mP03NXZYLz5fmnuYN9rwwXZmfoLTRp3IUQpwNfw26QfaWU8v/53j8R+CrwTOAcKeX1rR7oVKPK7bojRnq70yHGPe3Zht9/Au74BgCvAk5Jpon+cCUsXAnZ5ZDpgY4l9n/tS6B9EbQthFSXs0A6nC/zgdj1WJEEkRd80HO8bDqg7O9pn4PBbbQ98mseliuJBpQdcKNuqkYLd+r7zzXNHaqe8Ww1IEuz/7+9cw+Oq77u+OfsS9rVwyvJD7BsWbZlm1daMMK8HwWT8DRJ6xSHMkBDQmhJizMlFNKZlCST0kyaEGZCUh4OJaEDSShp3MQD4WE6aeI4NiEBjCEYYxtLNpath/VYab3aX/+49652pZV2JaTdu3fPZ8bjvff+dnX2t7/73bPn9/udk7nzGaywzInH1+b9GhO9R+fc4OjVMtPkuacmVPP84nfSBMfiI8nD3CqEU6E2HKStO+ba95RT3EXEDzwAXArsB7aJyEZjzBtpzfYBNwF3jH2F0iBb0q7GaJhX9/eMEUSr+EIFh/uGWN72E0vYT78JWi7lSNvbbHxpCx+uTBCJdVoFNPoO4UwoZSA+S+DDUeb7aljqe5X3VnyGRTWZxatrKoP0jF4K6fPDnz/MkQ1r+UXbXC72TXzD5RuWqU0rzl1qOJ+TW8Xdn7ZHAkjtfl590rwczxyhvipEZdCXVVDSwyAwA2EZZ0I1z5CdiKQKiBisUpBBv7uydX4QaioDVATcl4HUIR/PfRWwyxizG0BEngSuAVLibozZY1+bXKB5hukbSnAskd2kqopAxqBPpdtN89wdDz3bz+bGaCUtA7+nbvO/wtKL4YpvgD9AVcswX3p+OR3NS/n0+UusxskEMnAYX38HMtCBL9aJxI4gsU4k1oVvqIf+zg5+kzyVhlNvZdGov1VTGWDfkX667IyCwYDPiveFImw7fwP3Pf47PpzjpgmH/IQCI2vyx6OUY+7O5+RWTwosG/d2DtDVH6dzIG6tYMpzMhVGNkNlyRxM0O8j4BM6B+J09cc5GrNSWAemSXxSYZlJ9O9I2l/r+TLOct1SpLYy4FpHAvIT90bgvbTj/cCZM2PO9PHy3i7W/vuvs94EAItnV7H5jotSx47nnp4zYlGDFTNvcmLnsW442gbHYlxe8SrrQt9C6pph7aPgH1mpMa+2gu+89A7feemdcaybZf9bMubKC3Vzxpyrj4TYc2SA077yHAA+gaf/9lxOXRhNJQ7LdQPXVgZpqo/k9DLqq0JUhfyu9UYmYlF9FZC5wcRtNNVHeOrl/anPEpjU3AzAovoInVlSB4P15fzor/bw6K/2WMcVgWkTVOfeGG8TXDbCIR+DcVvcXSyEU6G+KuTqsVbQCVURuQW4BaCpqSlH6w/GjvYejIE7L1tBZJSn8ZvdnTyz42BGLpfewQRBv2SEI9aevoBFDVWWR9j5Ljx4IQz1AHArkKiIwnU/hHA04/W/fd1KdrT1TNrmuqoQS2ZXjTn/NxctpWVuNcYY+uPDfP3Zt9jR3mOJ+7Al7v4cYvyPl52QV7bKm89bzMUnzJ207W7glMZaHrmhlQtXjP2CdAu3X7KMDzXOGolBh/ycv2xy9v7z1SczmBjOeu2B61byx/d7U8ctduGZ6WBVcz0P39DKyqZo7sY2TjWmpHFv3vOpsn71co70Zf+SdQP5iHsbsDDteIF9btIYYx4CHgJobW0dx6eeHtq6Y4T8Pm69YOkYL7ShuoJndhykvXuQFcc54m4JfbqXEwkFuHD5HDAGfrbeWqL4FxugohZCEQKzV0D12BvzjOb6VE3V6WB+NMyN5zQD1vLL+577Y2pSzvHcs5XNS6epIT/vsKG6goYcecXdiohMKn5dDBbWR1Kf5VRpzuIAOJzTMptzWmZ/oNcfD59PuHSS/Zsec/eauM+Phie10qnQ5CPu24BlIrIYS9TXAdfNqFXTQFtXjPnRyqzhhVQxju4BVhxneTZHY4mMeHsGf3gCdr8EV34DPrR2pkzOi9GTck4lplyeu6IUA6f0n8G9Cba8Ss5ZM2NMAvgs8CywE/iRMWaHiHxZRNYAiMgZIrIf+DjwoIjsmEmj82Gi9cPpBTccsqXbBaCvA579Aiw8C07/5IzYOlnSy/nlG3NXlGIQDvqtlL/x4VRlJqUw5BVzN8ZsAjaNOvfFtMfbsMI1rqG9O8YF48Qy51RXEPL7MlLzZku3C8Azd0G8H66+f0zSrmKxIBpm67udwEiZvdEbWhTFDYRDfmJd1oTqnJrSDPeVKp5UhHgiyaHeoXE37Ph8wvHRStrtwsRgp9t1PPdkEvZugY1/B68/BeffAXMnzt1SSJxCyYnhZCrNgYZlFDdSaU+oDsTdu5PTq3gy/cCBnhjGTLzVfv6sMG1dA6njlOf+hydh81ehex8EwnDa9XDe+kKYnTfzo2GGk4aDRwdTnruXNoco3sEJy4B7E2x5FU+KuxOPnqgAQmNdmF++3ZE67h1MMCcwAP+zHmYvg4/9E5xwJVRM31Ky6WKknN9gKuaunrviRiJpE6pO8Q6lMHhT3PMogNAYDXOod4h4IonfJ/QNJTi3eyMkYvCxB2HexFkWi0n6ah9nnXvAJfMBipKOsxQyaUwqBbBSGDypCG3dMUTguAm2dTfWWVu4D/YM0jeYIEiCUw/82Eol4GJhByukBNaX2HAyiYh67oo7qQz5MQYGjyU1LFNgvCnuXTHmVFeMn9kwOUxTxEo3sL97gKODx7jKt4WqeAecfVsBLZ0a4ZCVjrite5BjSaPLIBXXkj6JqhOqhcWT4t7eExs/JDPUC4+tYdVPzuVc32u0dw9yNBbnU4FN9Na2wNJLCmvsFHHWug8njXrtimvJFHdPyo1r8WRvt3XFsqe2jXXB9z8K+7Yg1fP4XvDrVL79c2Tv/3Gyby/vn/hJKJGsdY1RqxB3YtgQ1Hi74lLSk4V5LXGY2/GcKiSThvbuwbHi3tcB/3E1HHwVrv0Bcstm3vQt5Yo376L513dz2NQyeGJxUwtMhsa6MG1dMRLJJH5dBqm4lAzPXSdUC4rnxP1w/xDx4WRmWCY+AN9fA0d2wSeesJY4huv4l4Z7ea1iJZG+fTw+vJqamuriGT5J5kfDxI4N09E7pCtlFNeS4blrzL2geE4VUssg0z335++BQ2/AtY9Dy+rU6dn1ddwRuIv/PeVevptYkz23jEtx3t++zgGdUFVci06oFg/vibu9gSm1O/WdF+G3D8KZt8Ky1RltG6Nh9vYk+H30UoYIZc8t41IW2L9M9h0Z0AlVxbVkxtw9JzeuxnO97eQ5b6wLWxOo/30bzF4Oq+8Z07YxGiaeSLLnSD/hoD9nTnQ34Xx59Q4lNPWA4loyPffScZ68QOmoWZ60dcWoqQxYScA2fR76D1k7ToPZ6qBa53YeOFpSXjtAXSSYunHUc1fciq6WKR7eE/duexnkrhfgtR/DBXdC48qsbR3v952OvpITdxFJTRrrhKriVjTmXjw8pwptzjLIrQ9C9Tw473PjtnXE8diwySiMXSo4X04BDcsoLqVSxb1oeE/cuwY4OdINb/8CVt4AgdC4bWeFg9TYldxLaaWMgxNW0tUyilupCPhwhmelTqgWFE/1du/gMY4OJrio7+fWTtPTb8r5HMf7LbWwDIysmNEqTIpbERHCQT9+nxDScVpQPNXb7d2DhDjGyQd/Cssvh1m5K/85oZnaEvTc50etrJc6oaq4mXDITzjoR0oktYdXyEvcReQyEXlLRHaJyF1ZrleIyA/t61tFpHm6Dc2Htu4BLvP9lop4J5xxc17PcUIbtSXouTdGI4CGZRR3Uxn0a7rfIpBT3EXEDzwAXA6cBHxCREYnPL8Z6DLGtAD3AV+bbkPzoa0rxvWB50nMaoYlf5bXc0o5LON47hqWUdxMOOjXDUxFIJ8eXwXsMsbsNsbEgSeBa0a1uQZ4zH78FHCJFOE3WLz9dVb53sK36mbIc3lgKixTgqtljqutxO8T9dwVVxMJ+YnoBqaCk0+PNwLvpR3vB84cr40xJiEiPUADcHg6jExn29P3M+f1h7NeW5PsZYggFaddn/frNZaw5x7w+1ICryhuRUMyxaGgiiYitwC3ADQ1NU3pNQLVDXRGFme91gkkmy+iNVKf9+v9yYJZfObCJVy4fO6U7Ck2n//IChqqx1/uqSjF5tPnLyGRTBbbjLJDjDETNxA5G7jHGPMR+/huAGPMvWltnrXbbBGRAHAQmGMmePHW1lazffv2aXgLiqIo5YOIvGyMac3VLp/A9DZgmYgsFpEQsA7YOKrNRuBG+/Fa4MWJhF1RFEWZWXKGZewY+meBZwE/8D1jzA4R+TKw3RizEdgA/EBEdmFFR9bNpNGKoijKxOQVczfGbAI2jTr3xbTHg8DHp9c0RVEUZaro4lNFURQPouKuKIriQVTcFUVRPIiKu6IoigdRcVcURfEgOTcxzdgfFukA9k7x6bOZgdQGJYz2RybaHyNoX2Tihf5YZIyZk6tR0cT9gyAi2/PZoVUuaH9kov0xgvZFJuXUHxqWURRF8SAq7oqiKB6kVMX9oWIb4DK0PzLR/hhB+yKTsumPkoy5K4qiKBNTqp67oiiKMgElJ+65inV7GRFZKCKbReQNEdkhIrfb5+tF5DkRedv+v67YthYSEfGLyCsi8jP7eLFdqH2XXbi9bKqZiEhURJ4SkTdFZKeInF2u40NEPmffJ6+LyBMiUllOY6OkxD3PYt1eJgH8gzHmJOAs4Db7/d8FvGCMWQa8YB+XE7cDO9OOvwbc9LZEagAAAmRJREFUZxds78Iq4F4u3A88Y4w5AfhTrH4pu/EhIo3A3wOtxphTsNKVr6OMxkZJiTv5Fev2LMaYA8aY39mPe7Fu3EYyC5Q/Bny0OBYWHhFZAFwJPGIfC3AxVqF2KKP+EJFZwAVY9RUwxsSNMd2U7/gIAGG7OlwEOEAZjY1SE/dsxbobi2RLURGRZuA0YCswzxhzwL50EJhXJLOKwbeAOwGnSGcD0G2MSdjH5TRGFgMdwKN2mOoREamiDMeHMaYN+DdgH5ao9wAvU0Zjo9TEXQFEpBr4L2C9MeZo+jW7vGFZLIESkauAQ8aYl4tti0sIACuB7xpjTgP6GRWCKZfxYc8rXIP1hTcfqAIuK6pRBabUxL0NWJh2vMA+VzaISBBL2P/TGPO0ffp9ETnevn48cKhY9hWYc4E1IrIHK0R3MVbMOWr/FIfyGiP7gf3GmK328VNYYl+O42M18K4xpsMYcwx4Gmu8lM3YKDVxz6dYt2ex48kbgJ3GmG+mXUovUH4j8NNC21YMjDF3G2MWGGOascbCi8aYvwI2YxVqh/Lqj4PAeyKywj51CfAG5Tk+9gFniUjEvm+cviibsVFym5hE5AqsOKtTrPurRTapYIjIecAvgdcYiTF/ASvu/iOgCSvT5l8aYzqLYmSREJGLgDuMMVeJyBIsT74eeAW43hgzVEz7CoWInIo1uRwCdgN/jeXEld34EJEvAddirTJ7BfgUVoy9LMZGyYm7oiiKkptSC8soiqIoeaDiriiK4kFU3BVFUTyIiruiKIoHUXFXFEXxICruiqIoHkTFXVEUxYOouCuKoniQ/wf+r4TJmweh4AAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ - "Q(s,a) std: 0.000;0.028;0.277;0.000;0.044;0.059;0.063;0.093;0.000;0.018\n", - "correct 2\n" + "Q(s,a) std: 0.000;0.002;0.001;0.000;0.000;0.000;0.006;0.001;0.003;0.000\n", + "correct 1\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.5/dist-packages/ipykernel_launcher.py:32: FutureWarning: pd.ewm_mean is deprecated for ndarrays and will be removed in a future version\n" - ] } ], "source": [ @@ -886,8 +1267,13 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 35, + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-03T23:04:11.677959Z", + "start_time": "2019-04-03T23:04:11.674863Z" + } + }, "outputs": [], "source": [ "class BayesUCBBNNAgent(BNNAgent):\n", @@ -901,55 +1287,60 @@ " This implements bayesian UCB strategy\n", " \"\"\"\n", "\n", - " # YOUR CODE HERE" + " reward_samples = self.sample_prediction(states, n_samples=100)\n", + " best_actions = np.percentile(reward_samples, self.q, axis=0).argmax(axis=-1)\n", + "\n", + " return best_actions" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 36, + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-03T23:09:17.506026Z", + "start_time": "2019-04-03T23:04:11.679581Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "iteration #90\tmean reward=0.630\tmse=0.354\tkl=0.047\n" + "iteration #90\tmean reward=0.710\tmse=0.009\tkl=-26.576\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ - "Q(s,a) std: 0.067;0.027;0.093;0.069;0.014;0.148;0.173;0.026;0.043;0.101\n", - "correct 5\n" + "Q(s,a) std: 0.000;0.015;0.000;0.008;0.000;0.002;0.002;0.002;0.015;0.019\n", + "correct 8\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.5/dist-packages/ipykernel_launcher.py:32: FutureWarning: pd.ewm_mean is deprecated for ndarrays and will be removed in a future version\n" - ] } ], "source": [ @@ -959,17 +1350,24 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 37, + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-03T23:09:17.964523Z", + "start_time": "2019-04-03T23:09:17.509546Z" + } + }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -989,6 +1387,13 @@ "plt.show()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "> UCB and Thompson sampling work better than Greedy, but the two of them show similar performance." + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -1016,8 +1421,13 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 32, + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-03T23:09:17.977179Z", + "start_time": "2019-04-03T23:09:17.966324Z" + } + }, "outputs": [], "source": [ "class RiverSwimEnv:\n", @@ -1101,8 +1511,13 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 33, + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-03T23:09:17.988800Z", + "start_time": "2019-04-03T23:09:17.979066Z" + } + }, "outputs": [], "source": [ "class QLearningAgent:\n", @@ -1130,14 +1545,24 @@ " pass\n", "\n", " def update(self, state, action, reward, next_state):\n", - " # YOUR CODE HERE\n", - " # Finish implementation of q-learnig agent" + " next_value = \\\n", + " (1 - self._epsilon) * self._q_matrix[next_state, :].max() + \\\n", + " self._epsilon * self._q_matrix[next_state, :].mean()\n", + " \n", + " self._q_matrix[state, action] = \\\n", + " (1 - self._lr) * self._q_matrix[state, action] + \\\n", + " self._lr * (reward + self._gamma * next_value)" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 34, + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-03T23:09:18.001578Z", + "start_time": "2019-04-03T23:09:17.991247Z" + } + }, "outputs": [], "source": [ "def train_mdp_agent(agent, env, n_episodes):\n", @@ -1161,22 +1586,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.5/dist-packages/ipykernel_launcher.py:6: FutureWarning: pd.ewm_mean is deprecated for ndarrays and will be removed in a future version\n", - " \n" - ] + "execution_count": 35, + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-03T23:09:19.218252Z", + "start_time": "2019-04-03T23:09:18.003126Z" }, + "scrolled": false + }, + "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, "metadata": {}, @@ -1204,8 +1627,13 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 36, + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-03T23:09:19.224687Z", + "start_time": "2019-04-03T23:09:19.220203Z" + } + }, "outputs": [], "source": [ "def plot_policy(agent):\n", @@ -1221,14 +1649,19 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, + "execution_count": 37, + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-03T23:09:19.555096Z", + "start_time": "2019-04-03T23:09:19.227460Z" + } + }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, "metadata": {}, @@ -1246,6 +1679,13 @@ "As your see, agent uses suboptimal policy of going left and does not explore the right state." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "> Life is hard and sad." + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -1287,7 +1727,12 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-02T20:29:57.407894Z", + "start_time": "2019-04-02T20:29:48.154Z" + } + }, "outputs": [], "source": [ "def sample_normal_gamma(mu, lmbd, alpha, beta):\n", @@ -1352,32 +1797,15 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.5/dist-packages/ipykernel_launcher.py:7: FutureWarning: pd.ewm_mean is deprecated for ndarrays and will be removed in a future version\n", - " import sys\n" - ] + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-02T20:29:57.409097Z", + "start_time": "2019-04-02T20:29:48.158Z" }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "scrolled": false + }, + "outputs": [], "source": [ - "from pandas import DataFrame\n", - "moving_average = lambda x, **kw: DataFrame(\n", - " {'x': np.asarray(x)}).x.ewm(**kw).mean().values\n", - "\n", "horizon = 20\n", "env = RiverSwimEnv(max_steps=horizon)\n", "agent = PsrlAgent(env.n_states, env.n_actions, horizon=horizon)\n", @@ -1394,19 +1822,13 @@ { "cell_type": "code", "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "ExecuteTime": { + "end_time": "2019-04-02T20:29:57.410286Z", + "start_time": "2019-04-02T20:29:48.160Z" } - ], + }, + "outputs": [], "source": [ "plot_policy(agent)" ] @@ -1423,9 +1845,76 @@ } ], "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", "name": "python", - "pygments_lexer": "ipython3" + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.7" + }, + "nbdime-conflicts": { + "local_diff": [ + { + "diff": [ + { + "diff": [ + { + "key": 0, + "op": "addrange", + "valuelist": [ + "2.7.15" + ] + }, + { + "key": 0, + "length": 1, + "op": "removerange" + } + ], + "key": "version", + "op": "patch" + } + ], + "key": "language_info", + "op": "patch" + } + ], + "remote_diff": [ + { + "diff": [ + { + "diff": [ + { + "key": 0, + "op": "addrange", + "valuelist": [ + "3.7.2" + ] + }, + { + "key": 0, + "length": 1, + "op": "removerange" + } + ], + "key": "version", + "op": "patch" + } + ], + "key": "language_info", + "op": "patch" + } + ] } }, "nbformat": 4, From b4f7b6255b5c2c4c18986b86cdaf005740612faf Mon Sep 17 00:00:00 2001 From: Michael Diskin Date: Sat, 11 Apr 2020 21:07:29 +0300 Subject: [PATCH 2/2] Prefinal version --- week05_explore/bayes.py | 286 ++-------- week05_explore/week5.ipynb | 1050 +++++++++--------------------------- 2 files changed, 311 insertions(+), 1025 deletions(-) diff --git a/week05_explore/bayes.py b/week05_explore/bayes.py index 93d93b51c..ea464301f 100644 --- a/week05_explore/bayes.py +++ b/week05_explore/bayes.py @@ -2,260 +2,80 @@ import numpy as np import torch.nn as nn import torch.nn.functional as F +from torch.nn import Parameter +import math -class BayesianModule(nn.Module): - """ - creates base class for BNN, in order to enable specific behavior - """ - def init(self): - super().__init__() +def calculate_kl(log_alpha): + return 0.5 * torch.sum(torch.log1p(torch.exp(-log_alpha))) -class GaussianVariational(nn.Module): - #Samples weights for variational inference as in Weights Uncertainity on Neural Networks (Bayes by backprop paper) - #Calculates the variational posterior part of the complexity part of the loss - def __init__(self, mu, rho): - super().__init__() +class ModuleWrapper(nn.Module): + """Wrapper for nn.Module with support for arbitrary flags and a universal forward pass""" - self.mu = nn.Parameter(mu) - self.rho = nn.Parameter(rho) - self.w = None - self.sigma = None - self.pi = np.pi - self.normal = torch.distributions.Normal(0, 1) + def __init__(self): + super(ModuleWrapper, self).__init__() - def sample(self): - """ - Samples weights by sampling form a Normal distribution, multiplying by a sigma, which is - a function from a trainable parameter, and adding a mean - sets those weights as the current ones - returns: - torch.tensor with same shape as self.mu and self.rho - """ - device = self.mu.device - epsilon = self.normal.sample(self.mu.size()).to(device) - self.sigma = torch.log(1 + torch.exp(self.rho)).to(device) - self.w = self.mu + self.sigma * epsilon - return self.w + def set_flag(self, flag_name, value): + setattr(self, flag_name, value) + for m in self.children(): + if hasattr(m, 'set_flag'): + m.set_flag(flag_name, value) - def log_posterior(self): - - """ - Calculates the log_likelihood for each of the weights sampled as a part of the complexity cost - returns: - torch.tensor with shape [] - """ - - assert (self.w is not None), "You can only have a log posterior for W if you've already sampled it" - - log_sqrt2pi = np.log(np.sqrt(2*self.pi)) - log_posteriors = -log_sqrt2pi - self.sigma - (((self.w - self.mu) ** 2)/(2 * self.sigma ** 2)) - return log_posteriors.mean() - - -class ScaleMixturePrior(nn.Module): - #Calculates a Scale Mixture Prior distribution for the prior part of the complexity cost on Bayes by Backprop paper - def __init__(self, pi, sigma1, sigma2): - super().__init__() + def forward(self, x): + for module in self.children(): + x = module(x) - self.pi = pi - self.sigma1 = sigma1 - self.sigma2 = sigma2 - self.normal1 = torch.distributions.Normal(0, sigma1) - self.normal2 = torch.distributions.Normal(0, sigma2) + kl = 0.0 + for module in self.modules(): + if hasattr(module, 'kl_loss'): + kl = kl + module.kl_loss() - def log_prior(self, w): - """ - Calculates the log_likelihood for each of the weights sampled relative to a prior distribution as a part of the complexity cost - returns: - torch.tensor with shape [] - """ - prob_n1 = torch.exp(self.normal1.log_prob(w)) - prob_n2 = torch.exp(self.normal2.log_prob(w)) - prior_pdf = (self.pi * prob_n1 + (1 - self.pi) * prob_n2) + return x, kl - return (torch.log(prior_pdf)).mean() -class BayesianLinear(BayesianModule): - """ - Bayesian Linear layer, implements the linear layer proposed on Weight Uncertainity on Neural Networks - (Bayes by Backprop paper). - Its objective is be interactable with torch nn.Module API, being able even to be chained in nn.Sequential models with other non-this-lib layers +class BBBLinear(ModuleWrapper): - parameters: - in_fetaures: int -> incoming features for the layer - out_features: int -> output features for the layer - bias: bool -> whether the bias will exist (True) or set to zero (False) - prior_sigma_1: float -> prior sigma on the mixture prior distribution 1 - prior_sigma_2: float -> prior sigma on the mixture prior distribution 2 - prior_pi: float -> pi on the scaled mixture prior - freeze: bool -> wheter the model will start with frozen(deterministic) weights, or not - - """ - def __init__(self, - in_features, - out_features, - bias=True, - prior_sigma_1 = 1, - prior_sigma_2 = 0.002, - prior_pi = 0.5, - freeze = False): - super().__init__() - - #our main parameters + def __init__(self, in_features, out_features, alpha_shape=(1, 1), bias=True, name='BBBLinear'): + super(BBBLinear, self).__init__() self.in_features = in_features self.out_features = out_features - self.bias = bias - self.freeze = freeze - - #parameters for the scale mixture prior - self.prior_sigma_1 = prior_sigma_1 - self.prior_sigma_2 = prior_sigma_2 - self.prior_pi = prior_pi - - # Variational weight parameters and sample - self.weight_mu = nn.Parameter(torch.Tensor(out_features, in_features).uniform_(-0.2, 0.2)) - self.weight_rho = nn.Parameter(torch.Tensor(out_features, in_features).uniform_(-5, -4)) - self.weight_sampler = GaussianVariational(self.weight_mu, self.weight_rho) - - # Variational bias parameters and sample - self.bias_mu = nn.Parameter(torch.Tensor(out_features).uniform_(-0.2, 0.2)) - self.bias_rho = nn.Parameter(torch.Tensor(out_features).uniform_(-5, -4)) - self.bias_sampler = GaussianVariational(self.bias_mu, self.bias_rho) - - # Priors (as BBP paper) - self.weight_prior_dist = ScaleMixturePrior(self.prior_pi, self.prior_sigma_1, self.prior_sigma_2) - self.bias_prior_dist = ScaleMixturePrior(self.prior_pi, self.prior_sigma_1, self.prior_sigma_2) - self.log_prior = 0 - self.log_variational_posterior = 0 + self.alpha_shape = alpha_shape + self.W = Parameter(torch.Tensor(out_features, in_features)) + self.log_alpha = Parameter(torch.Tensor(*alpha_shape)) + if bias: + self.bias = Parameter(torch.Tensor(1, out_features)) + else: + self.register_parameter('bias', None) + self.reset_parameters() + self.kl_value = calculate_kl + self.name = name + def reset_parameters(self): + stdv = 1. / math.sqrt(self.W.size(1)) + self.W.data.uniform_(-stdv, stdv) + self.log_alpha.data.fill_(-5.0) + if self.bias is not None: + self.bias.data.zero_() def forward(self, x): - # Sample the weights and forward it - - #if the model is frozen, return frozen - if self.freeze: - return self.forward_frozen(x) - w = self.weight_sampler.sample() + mean = F.linear(x, self.W) + if self.bias is not None: + mean = mean + self.bias - if self.bias: - b = self.bias_sampler.sample() - b_log_posterior = self.bias_sampler.log_posterior() - b_log_prior = self.bias_prior_dist.log_prior(b) + sigma = torch.exp(self.log_alpha) * self.W * self.W + std = torch.sqrt(1e-16 + F.linear(x * x, sigma)) + if self.training: + epsilon = std.data.new(std.size()).normal_() else: - b = torch.zeros((self.out_features)) - b_log_posterior = 0 - b_log_prior = 0 - - # Get the complexity cost - self.log_variational_posterior = self.weight_sampler.log_posterior() + b_log_posterior - self.log_prior = self.weight_prior_dist.log_prior(w) + b_log_prior + epsilon = 0.0 + # Local reparameterization trick + out = mean + std * epsilon - return F.linear(x, w, b) - - def forward_frozen(self, x): - """ - Computes the feedforward operation with the expected value for weight and biases - """ - if self.bias: - return F.linear(x, self.weight_mu, self.bias_mu) - else: - return F.linear(x, self.weight_mu, torch.zeros(self.out_features)) - -def kl_divergence_from_nn(model): - - """ - Gathers the KL Divergence from a nn.Module object - Works by gathering each Bayesian layer kl divergence and summing it, doing nothing with the non Bayesian ones - """ - kl_divergence = 0 - for module in model.modules(): - if isinstance(module, (BayesianModule)): - kl_divergence += module.log_variational_posterior - module.log_prior - return kl_divergence - - - -def variational_estimator(nn_class): - """ - This decorator adds some util methods to a nn.Module, in order to facilitate the handling of Bayesian Deep Learning features - Parameters: - nn_class: torch.nn.Module -> Torch neural network module - Returns a nn.Module with methods for: - (1) Gathering the KL Divergence along its BayesianModules; - (2) Sample the Elbo Loss along its variational inferences (helps training) - (3) Freeze the model, in order to predict using only their weight distribution means - """ - - def nn_kl_divergence(self): - """Returns the sum of the KL divergence of each of the BayesianModules of the model, which are from - their posterior current distribution of weights relative to a scale-mixtured prior (and simpler) distribution of weights - Parameters: - N/a - Returns torch.tensor with 0 dim. - - """ - return kl_divergence_from_nn(self) - - setattr(nn_class, "nn_kl_divergence", nn_kl_divergence) - - def sample_elbo(self, - inputs, - labels, - criterion, - sample_nbr, - complexity_cost_weight=1): - - """ Samples the ELBO Loss for a batch of data, consisting of inputs and corresponding-by-index labels - The ELBO Loss consists of the sum of the KL Divergence of the model - (explained above, interpreted as a "complexity part" of the loss) - with the actual criterion - (loss function) of optimization of our model - (the performance part of the loss). - As we are using variational inference, it takes several (quantified by the parameter sample_nbr) Monte-Carlo - samples of the weights in order to gather a better approximation for the loss. - Parameters: - inputs: torch.tensor -> the input data to the model - labels: torch.tensor -> label data for the performance-part of the loss calculation - The shape of the labels must match the label-parameter shape of the criterion (one hot encoded or as index, if needed) - criterion: torch.nn.Module, custom criterion (loss) function, torch.nn.functional function -> criterion to gather - the performance cost for the model - sample_nbr: int -> The number of times of the weight-sampling and predictions done in our Monte-Carlo approach to - gather the loss to be .backwarded in the optimization of the model. - - """ - - loss = 0 - for _ in range(sample_nbr): - outputs = self(inputs) - loss = criterion(outputs, labels) - loss += self.nn_kl_divergence() * complexity_cost_weight - return loss / sample_nbr - - setattr(nn_class, "sample_elbo", sample_elbo) - - - def freeze_model(self): - """ - Freezes the model by making it predict using only the expected value to their BayesianModules' weights distributions - """ - for module in self.modules(): - if isinstance(module, (BayesianModule)): - module.freeze = True - - setattr(nn_class, "freeze", freeze_model) - - def unfreeze_model(self): - """ - Unfreezes the model by letting it draw its weights with uncertanity from their correspondent distributions - """ - - for module in self.modules(): - if isinstance(module, (BayesianModule)): - module.freeze = False + return out - setattr(nn_class, "unfreeze", unfreeze_model) - return nn_class + def kl_loss(self): + return self.W.nelement() * self.kl_value(self.log_alpha) / self.log_alpha.nelement() \ No newline at end of file diff --git a/week05_explore/week5.ipynb b/week05_explore/week5.ipynb index de0055ef9..e645a74d1 100644 --- a/week05_explore/week5.ipynb +++ b/week05_explore/week5.ipynb @@ -2,143 +2,39 @@ "cells": [ { "cell_type": "code", - "execution_count": 9, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-03T22:51:31.696358Z", - "start_time": "2019-04-03T22:51:31.694140Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--2020-04-08 21:10:21-- https://raw.githubusercontent.com/yandexdataschool/Practical_RL/master/week05_explore/action_rewards.npy\n", - "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 151.101.84.133\n", - "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|151.101.84.133|:443... connected.\n", - "HTTP request sent, awaiting response... 200 OK\n", - "Length: 72008 (70K) [application/octet-stream]\n", - "Saving to: ‘action_rewards.npy’\n", - "\n", - "action_rewards.npy 100%[===================>] 70.32K --.-KB/s in 0.05s \n", - "\n", - "2020-04-08 21:10:22 (1.28 MB/s) - ‘action_rewards.npy’ saved [72008/72008]\n", - "\n", - "--2020-04-08 21:10:22-- https://raw.githubusercontent.com/yandexdataschool/Practical_RL/master/week05_explore/all_states.npy\n", - "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 151.101.84.133\n", - "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|151.101.84.133|:443... connected.\n", - "HTTP request sent, awaiting response... 200 OK\n", - "Length: 431408 (421K) [application/octet-stream]\n", - "Saving to: ‘all_states.npy’\n", - "\n", - "all_states.npy 100%[===================>] 421.30K --.-KB/s in 0.1s \n", - "\n", - "2020-04-08 21:10:23 (3.23 MB/s) - ‘all_states.npy’ saved [431408/431408]\n", - "\n" - ] - } - ], + "execution_count": 1, + "metadata": {}, + "outputs": [], "source": [ - "# Run this if in COLAB\n", - "# !pip install --upgrade git+https://github.com/Theano/Theano.git\n", - "# !pip install --upgrade git+https://github.com/Lasagne/Lasagne.git\n", - " \n", - "# !wget -q https://raw.githubusercontent.com/yandexdataschool/Practical_RL/master/week5_explore/bayes.py\n", - "!wget https://raw.githubusercontent.com/yandexdataschool/Practical_RL/master/week05_explore/action_rewards.npy\n", - "!wget https://raw.githubusercontent.com/yandexdataschool/Practical_RL/master/week05_explore/all_states.npy" + "import sys\n", + "if 'google.colab' in sys.modules:\n", + " !pip install --upgrade https://github.com/Theano/Theano/archive/master.zip\n", + " !pip install --upgrade https://github.com/Lasagne/Lasagne/archive/master.zip\n", + "\n", + " !wget -q https://github.com/yandexdataschool/Practical_RL/blob/spring20/week05_explore/bayes.py?raw=true -O bayes.py\n", + " !wget -q https://github.com/yandexdataschool/Practical_RL/blob/spring20/week05_explore/action_rewards.npy?raw=true -O action_rewards.npy \n", + " !wget -q https://github.com/yandexdataschool/Practical_RL/blob/spring20/week05_explore/all_states.npy?raw=true -O all_states.npy" ] }, { "cell_type": "code", - "execution_count": 1, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-03T22:51:32.147539Z", - "start_time": "2019-04-03T22:51:31.701723Z" - }, - "nbdime-conflicts": { - "local_diff": [ - { - "key": "ExecuteTime", - "op": "add", - "value": { - "end_time": "2019-03-22T17:28:37.673293Z", - "start_time": "2019-03-22T17:28:36.802492Z" - } - } - ], - "remote_diff": [ - { - "key": "ExecuteTime", - "op": "add", - "value": { - "end_time": "2019-04-02T18:26:40.998588Z", - "start_time": "2019-04-02T18:26:40.616120Z" - } - } - ] - } - }, + "execution_count": 2, + "metadata": {}, "outputs": [], "source": [ "from abc import ABCMeta, abstractmethod, abstractproperty\n", "import enum\n", "\n", "import numpy as np\n", - "np.set_printoptions(\n", - " precision=3,\n", - " suppress=True,\n", - ")\n", + "np.set_printoptions(precision=3)\n", + "np.set_printoptions(suppress=True)\n", "\n", - "import pandas as pd\n", - "from tqdm import tqdm_notebook, tnrange\n", + "import pandas\n", "\n", - "import matplotlib.pyplot as plt\n", + "from matplotlib import pyplot as plt\n", "%matplotlib inline" ] }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-03T22:51:32.160485Z", - "start_time": "2019-04-03T22:51:32.151084Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "{'divide': 'warn', 'over': 'warn', 'under': 'ignore', 'invalid': 'warn'}" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.random.seed(1)\n", - "np.seterr(all='raise')" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-03T22:51:32.172125Z", - "start_time": "2019-04-03T22:51:32.164269Z" - } - }, - "outputs": [], - "source": [ - "def moving_average(x, **kwargs):\n", - " return pd.Series(np.asarray(x)).ewm(**kwargs).mean().values" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -179,13 +75,8 @@ }, { "cell_type": "code", - "execution_count": 5, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-03T22:51:32.187664Z", - "start_time": "2019-04-03T22:51:32.176471Z" - } - }, + "execution_count": 3, + "metadata": {}, "outputs": [], "source": [ "class BernoulliBandit:\n", @@ -197,9 +88,9 @@ " return len(self._probs)\n", "\n", " def pull(self, action):\n", - " if np.random.random() < self._probs[action]:\n", - " return 1.0\n", - " return 0.0\n", + " if np.any(np.random.random() > self._probs[action]):\n", + " return 0.0\n", + " return 1.0\n", "\n", " def optimal_reward(self):\n", " \"\"\" Used for regret calculation\n", @@ -218,13 +109,8 @@ }, { "cell_type": "code", - "execution_count": 6, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-03T22:51:32.206933Z", - "start_time": "2019-04-03T22:51:32.191578Z" - } - }, + "execution_count": 4, + "metadata": {}, "outputs": [], "source": [ "class AbstractAgent(metaclass=ABCMeta):\n", @@ -263,22 +149,6 @@ " return np.random.randint(0, len(self._successes))" ] }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-03T22:51:32.217096Z", - "start_time": "2019-04-03T22:51:32.210310Z" - } - }, - "outputs": [], - "source": [ - "def random_true(bool_arr):\n", - " assert len(bool_arr.shape) == 1\n", - " return np.random.choice(np.arange(len(bool_arr))[bool_arr])" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -306,13 +176,8 @@ }, { "cell_type": "code", - "execution_count": 8, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-03T22:51:32.228768Z", - "start_time": "2019-04-03T22:51:32.218598Z" - } - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ "class EpsilonGreedyAgent(AbstractAgent):\n", @@ -320,44 +185,7 @@ " self._epsilon = epsilon\n", "\n", " def get_action(self):\n", - " if np.random.random() < self._epsilon:\n", - " return np.random.randint(0, len(self._successes))\n", - " else:\n", - " denom = self._successes + self._failures\n", - " if np.any(denom == 0):\n", - " return random_true(denom == 0)\n", - " else:\n", - " theta = self._successes / denom\n", - " return random_true(theta == theta.max())\n", - "\n", - " @property\n", - " def name(self):\n", - " return self.__class__.__name__ + \"(epsilon={})\".format(self._epsilon)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-03T22:51:32.237971Z", - "start_time": "2019-04-03T22:51:32.230941Z" - } - }, - "outputs": [], - "source": [ - "class EpsilonGreedyAgent2(AbstractAgent):\n", - " def __init__(self, epsilon=0.01):\n", - " self._epsilon = epsilon\n", - "\n", - " def get_action(self):\n", - " if np.random.random() < self._epsilon:\n", - " return np.random.randint(0, len(self._successes))\n", - " else:\n", - " denom = self._successes + self._failures\n", - " theta = np.full_like(self._successes, 0.5)\n", - " theta[denom != 0] = self._successes[denom != 0] / denom[denom != 0]\n", - " return random_true(theta == theta.max())\n", + " # YOUR CODE HERE\n", "\n", " @property\n", " def name(self):\n", @@ -371,9 +199,11 @@ "### UCB Agent\n", "Epsilon-greedy strategy heve no preference for actions. It would be better to select among actions that are uncertain or have potential to be optimal. One can come up with idea of index for each action that represents otimality and uncertainty at the same time. One efficient way to do it is to use UCB1 algorithm:\n", "\n", + "**for** $t = 1,2,...$ **do**\n", + "\n", "   **for** $k = 1,...,K$ **do**\n", "\n", - "       $w_k \\leftarrow \\alpha_k / (\\alpha_k + \\beta_k) + \\sqrt{\\frac {2 \\log t} {\\alpha_k + \\beta_k}}$\n", + "       $w_k \\leftarrow \\alpha_k / (\\alpha_k + \\beta_k) + \\sqrt{2log\\ t \\ / \\ (\\alpha_k + \\beta_k)}$\n", "\n", "   **end for** \n", "\n", @@ -386,55 +216,20 @@ "\n", "**end for**\n", "\n", + "__Note:__ in practice, one can multiply $\\sqrt{2log\\ t \\ / \\ (\\alpha_k + \\beta_k)}$ by some tunable parameter to regulate agent's optimism and wilingness to abandon non-promising actions.\n", + "\n", "More versions and optimality analysis - https://homes.di.unimi.it/~cesabian/Pubblicazioni/ml-02.pdf" ] }, { "cell_type": "code", - "execution_count": 10, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-03T22:51:32.248360Z", - "start_time": "2019-04-03T22:51:32.243272Z" - } - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ "class UCBAgent(AbstractAgent):\n", - " def __init__(self):\n", - " super().__init__()\n", - " \n", " def get_action(self):\n", - " denom = self._successes + self._failures\n", - " if np.any(denom == 0):\n", - " return random_true(denom == 0)\n", - " else:\n", - " w = self._successes / denom + np.sqrt(2 * np.log(self._total_pulls) / denom)\n", - " return random_true(w == w.max())" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-03T22:51:32.259175Z", - "start_time": "2019-04-03T22:51:32.249939Z" - } - }, - "outputs": [], - "source": [ - "class UCBAgent2(AbstractAgent):\n", - " def __init__(self):\n", - " super().__init__()\n", - " \n", - " def get_action(self):\n", - " denom = self._successes + self._failures\n", - " w = np.full_like(self._successes, 1)\n", - " w[denom != 0] = \\\n", - " self._successes[denom != 0] / denom[denom != 0] + \\\n", - " np.sqrt(2 * np.log(max(1, self._total_pulls)) / denom[denom != 0])\n", - " return random_true(w == w.max())" + " # YOUR CODE HERE" ] }, { @@ -468,40 +263,29 @@ }, { "cell_type": "code", - "execution_count": 12, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-03T22:51:32.267647Z", - "start_time": "2019-04-03T22:51:32.261060Z" - } - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ "class ThompsonSamplingAgent(AbstractAgent):\n", " def get_action(self):\n", - " # Wrong prior, but at least not an improper one\n", - " theta = np.random.beta(self._successes + 1, self._failures + 1)\n", - " return random_true(theta == theta.max())" + " # YOUR CODE HERE\n" ] }, { "cell_type": "code", - "execution_count": 13, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-03T22:51:32.278448Z", - "start_time": "2019-04-03T22:51:32.269305Z" - } - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ - "def plot_regret(env, agents, n_steps=5000, n_trials=50):\n", - " scores = {\n", - " agent.name: np.zeros(n_steps)\n", - " for agent in agents\n", - " }\n", + "from collections import OrderedDict\n", "\n", - " for trial in tnrange(n_trials):\n", + "def get_regret(env, agents, n_steps=5000, n_trials=50):\n", + " scores = OrderedDict({\n", + " agent.name: [0.0 for step in range(n_steps)] for agent in agents\n", + " })\n", + "\n", + " for trial in range(n_trials):\n", " env.reset()\n", "\n", " for a in agents:\n", @@ -518,9 +302,14 @@ "\n", " env.step() # change bandit's state if it is unstationary\n", "\n", - " plt.figure(figsize=(17, 8))\n", " for agent in agents:\n", - " plt.plot(np.cumsum(scores[agent.name]) / n_trials)\n", + " scores[agent.name] = np.cumsum(scores[agent.name]) / n_trials\n", + "\n", + " return scores\n", + "\n", + "def plot_regret(agents, scores):\n", + " for agent in agents:\n", + " plt.plot(scores[agent.name])\n", "\n", " plt.legend([agent.name for agent in agents])\n", "\n", @@ -532,40 +321,14 @@ }, { "cell_type": "code", - "execution_count": 14, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-03T22:51:51.386184Z", - "start_time": "2019-04-03T22:51:32.280069Z" - } - }, + "execution_count": null, + "metadata": {}, "outputs": [ { "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "b18531f2978448e3ae2b1259534abd6b", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(IntProgress(value=0, max=10), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "" ] }, "metadata": {}, @@ -573,68 +336,15 @@ } ], "source": [ + "# Uncomment agents\n", "agents = [\n", - " EpsilonGreedyAgent(),\n", - " EpsilonGreedyAgent2(),\n", - " UCBAgent(),\n", - " UCBAgent2(),\n", - " ThompsonSamplingAgent(),\n", + " # EpsilonGreedyAgent(),\n", + " # UCBAgent(),\n", + " # ThompsonSamplingAgent()\n", "]\n", "\n", - "plot_regret(BernoulliBandit(), agents, n_steps=10000, n_trials=10)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-03T22:54:26.224093Z", - "start_time": "2019-04-03T22:51:51.387905Z" - } - }, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "3ebe9250e85d4394a96715aef9512c1d", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(IntProgress(value=0, max=10), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_regret(BernoulliBandit(), agents, n_steps=100000, n_trials=10)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "> UCB is extremely unstable and only wins against `EpsilonGreedy` with a large number of steps (I have conducted a lot of experiments). Thompson sampling is a lot more reliable." + "regret = get_regret(BernoulliBandit(), agents, n_steps=10000, n_trials=10)\n", + "plot_regret(agents, regret)" ] }, { @@ -660,13 +370,8 @@ }, { "cell_type": "code", - "execution_count": 16, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-03T22:54:26.233969Z", - "start_time": "2019-04-03T22:54:26.225822Z" - } - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ "class DriftingBandit(BernoulliBandit):\n", @@ -714,20 +419,14 @@ }, { "cell_type": "code", - "execution_count": 17, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-03T22:54:27.708307Z", - "start_time": "2019-04-03T22:54:26.236736Z" - }, - "scrolled": false - }, + "execution_count": null, + "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "" ] }, "metadata": {}, @@ -743,7 +442,7 @@ " drifting_probs.append(drifting_env._probs)\n", "\n", "plt.figure(figsize=(17, 8))\n", - "plt.plot(pd.DataFrame(drifting_probs).rolling(window=20).mean())\n", + "plt.plot(pandas.DataFrame(drifting_probs).rolling(window=20).mean())\n", "\n", "plt.xlabel(\"steps\")\n", "plt.ylabel(\"Success probability\")\n", @@ -761,77 +460,23 @@ }, { "cell_type": "code", - "execution_count": 18, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-03T22:54:27.724663Z", - "start_time": "2019-04-03T22:54:27.709971Z" - } - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ - "class DriftingAgent(AbstractAgent):\n", - " def __init__(self, lr=0.01, scale=10):\n", - " super().__init__()\n", - " self._lr = lr\n", - " self._scale = scale\n", - " \n", - " def init_actions(self, n_actions):\n", - " super().init_actions(n_actions)\n", - " self._probs = np.full(n_actions, 0.5)\n", - "\n", - " def get_action(self):\n", - " if self._total_pulls == 0:\n", - " return 0\n", - " theta = np.random.beta(self._probs * self._scale + 1, (1 - self._probs) * self._scale + 1)\n", - " return random_true(theta == theta.max())\n", - " \n", - " def update(self, action, reward):\n", - " super().update(action, reward)\n", - " self._probs[action] = (1 - self._lr) * self._probs[action] + self._lr * reward\n", - "\n", - " @property\n", - " def name(self):\n", - " return self.__class__.__name__ + \"(lr={})\".format(self._lr)" + "# YOUR AGENT HERE SECTION" ] }, { "cell_type": "code", - "execution_count": 19, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-03T22:55:32.717499Z", - "start_time": "2019-04-03T22:54:27.729989Z" - }, - "scrolled": false - }, + "execution_count": null, + "metadata": {}, "outputs": [ { "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "91a59d1bd57441909b1b2b59ec481efe", - "version_major": 2, - "version_minor": 0 - }, + "image/png": "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\n", "text/plain": [ - "HBox(children=(IntProgress(value=0, max=10), HTML(value='')))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABX0AAAKqCAYAAABmc/3ZAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzs3Xt8j/X/x/HHx86b7cOGbQ6Zww6Oc2aUQ8aInAqRwwpLyiFElJwPkRA5lGVIrSRKJMTIz2mJctbBsTY6zBg72a7fH/vuk48Zw/hIz/vtdt3a9b7e1/t6Xdfn0263Xr32ukyGYRiIiIiIiIiIiIiIyAOhgK0DEBEREREREREREZH8o6SviIiIiIiIiIiIyANESV8RERERERERERGRB4iSviIiIiIiIiIiIiIPECV9RURERERERERERB4gSvqKiIiIiIiIiIiIPECU9BURERERERERERF5gCjpKyIiIiIiIiIiIvIAUdJXRERERERERERE5AGipK+IiIiIiIiIiIjIA0RJXxEREREREREREZEHiL2tA/i3yMzM5Pfff8fd3R2TyWTrcEREREREREREROQBZxgGFy9epHjx4hQocAv1u8Z9YtKkSQZgDBw40DKWmZlpjB492vD19TWcnZ2NRo0aGQcOHLA6LyUlxXjxxRcNLy8vw9XV1Xj88ceN06dPW835+++/jW7duhkeHh6Gh4eH0a1bNyMhIeGW4jt9+rQBaNOmTZs2bdq0adOmTZs2bdq0adOmTds93a7Nd97MfVHpGxsby7vvvkvVqlWtxqdOncpbb71FVFQUAQEBTJgwgWbNmnH06FHc3d0BGDRoEKtXryY6OhovLy+GDBlC69at2bNnD3Z2dgB07dqVM2fOsG7dOgAiIiLo3r07q1evznOM2dc7ffo0Hh4e+XHbIiIiIiIiIiIiIrm6cOECpUqVsuQm88pkGIZxl2LKk6SkJGrUqMHcuXOZMGEC1apVY+bMmRiGQfHixRk0aBDDhw8HIDU1FW9vb9544w2ee+45EhMTKVq0KEuXLqVz584A/P7775QqVYq1a9cSFhbG4cOHqVixIjt37qRu3boA7Ny5k5CQEI4cOUJgYOB140pNTSU1NdWyn/2AExMTlfQVERERERERERGRu+7ChQuYzeZbzkna/EVuL7zwAq1atSI0NNRq/Pjx48THx9O8eXPLmJOTE40aNWL79u0A7Nmzh/T0dKs5xYsXp3LlypY5O3bswGw2WxK+APXq1cNsNlvmXM/kyZMxm82WrVSpUvlyvyIiIiIiIiIiIiJ3k02TvtHR0Xz//fdMnjw5x7H4+HgAvL29rca9vb0tx+Lj43F0dKRw4cI3nFOsWLEc6xcrVswy53pGjBhBYmKiZTt9+vSt3ZyIiIiIiIiIiIiIDdisp+/p06cZOHAg69evx9nZOdd5JpPJat8wjBxj17p2zvXm32wdJycnnJycbngdERERERERERERkfuNzZK+e/bs4dy5c9SsWdMylpGRwdatW5kzZw5Hjx4Fsip1fX19LXPOnTtnqf718fEhLS2NhIQEq2rfc+fOUb9+fcucs2fP5rj+H3/8kaOK+E4ZhsGVK1fIyMjI13VFRG6Vg4OD5WWWIiIiIiIiIvLfYrOkb9OmTdm/f7/V2DPPPENQUBDDhw+nbNmy+Pj4sGHDBqpXrw5AWloaW7Zs4Y033gCgZs2aODg4sGHDBjp16gRAXFwcBw4cYOrUqQCEhISQmJjI7t27qVOnDgC7du0iMTHRkhjOD2lpacTFxXH58uV8W1NE5HaZTCZKlixJwYIFbR2KiIiIiIiIiNxjNkv6uru7U7lyZasxNzc3vLy8LOODBg1i0qRJ+Pv74+/vz6RJk3B1daVr164AmM1mevXqxZAhQ/Dy8sLT05OhQ4dSpUoVy4vhKlSoQIsWLejTpw8LFiwAICIigtatWxMYGJgv95KZmcnx48exs7OjePHiODo63rQFhYjI3WIYBn/88QdnzpzB399fFb8iIiIiIiIi/zE2S/rmxbBhw0hOTqZfv34kJCRQt25d1q9fj7u7u2XOjBkzsLe3p1OnTiQnJ9O0aVOioqKskhzLli1jwIABNG/eHIA2bdowZ86cfIszLS2NzMxMSpUqhaura76tKyJyu4oWLcqJEydIT09X0ldERERERETkP8ZkGIZh6yD+DS5cuIDZbCYxMREPDw+rYykpKRw/fpwyZcrc8KV0IiL3in4viYiIiIiIiPz73SgneSMF7mJMIiIiIiIiIiIiInKPKekrIiIiIiIiIiIi8gBR0ldydeLECUwmE/v27bN1KHIdUVFRFCpUyLI/ZswYqlWrZsOIRERERERERETkfqCk73+UyWS64RYeHm7rEO8LmzdvpkmTJnh6euLq6oq/vz89e/bkypUrtg4th6FDh/LNN9/ctfUnTZqEnZ0dU6ZMuWvXuJlrE90iIiIiIiIiIpKTkr7/UXFxcZZt5syZeHh4WI3NmjXL1iHa3MGDB2nZsiW1a9dm69at7N+/n9mzZ+Pg4EBmZqatw8uhYMGCeHl53bX1Fy1axLBhw3j//ffv2jVEREREREREROTOKel7FxiGweW0KzbZDMPIU4w+Pj6WzWw2YzKZcoxl+/XXX2nSpAmurq4EBwezY8cOq7VWrFhBpUqVcHJyws/Pj+nTp1sd9/PzY8KECfTo0YOCBQtSunRpPv/8c/744w/atm1LwYIFqVKlCt99953lnOyKzlWrVhEQEICzszPNmjXj9OnTljk//PADTZo0wd3dHQ8PD2rWrGm1Rl7imjRpEs8++yzu7u489NBDvPvuu5bjGzZswNfXl6lTp1K5cmXKlStHixYtWLhwIY6OjgD89ddfdOnShZIlS+Lq6kqVKlX46KOPrK7TuHFj+vfvz6BBgyhcuDDe3t68++67XLp0iWeeeQZ3d3fKlSvHV199ZTknJiYGk8nEmjVrCA4OxtnZmbp167J///5cP9Nr2zuEh4fTrl073nzzTXx9ffHy8uKFF14gPT3dMicuLo5WrVrh4uJCmTJl+PDDD/Hz82PmzJlWa2/ZsoXk5GTGjRvHpUuX2Lp1a47rT5gwgWLFiuHu7k7v3r155ZVXcrSbWLRoERUqVMDZ2ZmgoCDmzp1rOZbdTuSzzz677vctJiaGZ555hsTEREtF+pgxY3J9HiIiIiIiIiIi/1X2tg7gQZScnkHF17+2ybUPjQvD1TF/P9ZXX32VN998E39/f1599VW6dOnCzz//jL29PXv27KFTp06MGTOGzp07s337dvr164eXl5dVi4gZM2YwadIkRo0axYwZM+jevTsNGjTg2WefZdq0aQwfPpwePXpw8OBBTCYTAJcvX2bixIksXrwYR0dH+vXrx1NPPcX//d//AfD0009TvXp15s2bh52dHfv27cPBwQEgz3FNnz6d8ePHM3LkSD799FOef/55GjZsSFBQED4+PsTFxbF161YaNmx43WeTkpJCzZo1GT58OB4eHqxZs4bu3btTtmxZ6tata5m3ePFihg0bxu7du/n44495/vnnWbVqFe3bt2fkyJGWZ3Lq1ClcXV0t57388svMmjULHx8fRo4cSZs2bTh27JjlPm9m8+bN+Pr6snnzZn7++Wc6d+5MtWrV6NOnDwA9evTgzz//JCYmBgcHBwYPHsy5c+dyrBMZGUmXLl1wcHCgS5cuREZGWj2TZcuWMXHiRObOnUuDBg2Ijo5m+vTplClTxjLnvffeY/To0cyZM4fq1auzd+9e+vTpg5ubGz179rTMy+37Vr9+fWbOnMnrr7/O0aNHgazqZhERERERERERsaZKX7mpoUOH0qpVKwICAhg7diwnT57k559/BuCtt96iadOmjBo1ioCAAMLDw3nxxReZNm2a1RqPPfYYzz33HP7+/rz++utcvHiR2rVr07FjRwICAhg+fDiHDx/m7NmzlnPS09OZM2cOISEh1KxZk8WLF7N9+3Z2794NwKlTpwgNDSUoKAh/f386duxIcHDwLcfVr18/ypcvz/DhwylSpAgxMTEAdOzYkS5dutCoUSN8fX1p3749c+bM4cKFC5bzS5QowdChQ6lWrRply5alf//+hIWFsXz5cqvrBAcH89prr+Hv78+IESNwcXGhSJEi9OnTx/JM/vrrL3788Uer80aPHk2zZs2oUqUKixcv5uzZs6xcuTLPn13hwoWZM2cOQUFBtG7dmlatWln6/h45coSNGzfy3nvvUbduXWrUqMHChQtJTk62WuPChQusWLGCbt26AdCtWzc+/fRTq+cwe/ZsevXqxTPPPENAQACvv/46VapUsVpn/PjxTJ8+nQ4dOlCmTBk6dOjASy+9xIIFC6zm5fZ9c3R0zFGVrqSviIiIiIiIiEhOqvS9C1wc7Dg0Lsxm185vVatWtfzs6+sLwLlz5wgKCuLw4cO0bdvWan6DBg2YOXMmGRkZ2NnZ5VjD29sbwCopmD127tw5fHx8ALC3t6dWrVqWOUFBQRQqVIjDhw9Tp04dBg8eTO/evVm6dCmhoaF07NiRcuXKAdxWXNnJxOxKVzs7OxYtWsSECRPYtGkTO3fuZOLEibzxxhvs3r0bX19fMjIymDJlCh9//DG//fYbqamppKam4ubmlusztLOzw8vLK9f7v1pISIjlZ09PTwIDAzl8+DB5ValSJcu9Qtbnl90i4ujRo9jb21OjRg3L8fLly1O4cGGrNT788EPKli1rSahnJ7ijo6OJiIiwrNWvXz+r8+rUqcOmTZsA+OOPPzh9+jS9evWyVBkDXLlyxaqVCNz4+yYiIiIiIiIiIjenSt+7wGQy4epob5MtuzVCfrq6lUD2+tkvMjMMI8c1r9dX+Hpr3Gjda8evNzZmzBgOHjxIq1at2LRpExUrVrRUwd5OXNlrXxtDiRIl6N69O++88w6HDh0iJSWF+fPnA1ntIWbMmMGwYcPYtGkT+/btIywsjLS0tJteJy/3fz238hnf6P5y6/987fj777/PwYMHsbe3t2wHDx4kMjLyhnFdvU72Nd977z327dtn2Q4cOMDOnTtzjflWnouIiIiIiIiIiGRR0lfuSMWKFdm2bZvV2Pbt2wkICLCqML0dV65csXox29GjRzl//rxVxWdAQAAvvfQS69evp0OHDixatOiuxlW4cGF8fX25dOkSAN9++y1t27alW7duBAcHU7ZsWX766afbXv9aVydEExISOHbsWL5VvAYFBXHlyhX27t1rGfv55585f/68ZX///v189913xMTEWCVrt27dSmxsLAcOHAAgMDDQ0nYj29Wfnbe3NyVKlODXX3+lfPnyVtvVfX9vxtHRkYyMjNu9ZRERERERERGR/wS1d5A7MmTIEGrXrs348ePp3LkzO3bsYM6cOcydO/eO13ZwcKB///68/fbbODg48OKLL1KvXj3q1KlDcnIyL7/8Mk8++SRlypThzJkzxMbG8sQTT+RbXAsWLGDfvn20b9+ecuXKkZKSwpIlSzh48CCzZ88GstohrFixgu3bt1O4cGHeeust4uPjqVChwh3fP8C4cePw8vLC29ubV199lSJFitCuXbt8WTsoKIjQ0FAiIiKYN28eDg4ODBkyBBcXF0uFbWRkJHXq1Lnui+xCQkKIjIxkxowZ9O/fnz59+lCrVi3q16/Pxx9/zI8//kjZsmUt88eMGcOAAQPw8PCgZcuWpKam8t1335GQkMDgwYPzFLOfnx9JSUl88803BAcH4+rqavXiOxERERERERERUaWv3KEaNWrwySefEB0dTeXKlXn99dcZN24c4eHhd7y2q6srw4cPp2vXroSEhODi4kJ0dDSQ1Rf3r7/+okePHgQEBNCpUydatmzJ2LFj8y2uOnXqkJSURN++falUqRKNGjVi586drFq1ikaNGgEwatQoatSoQVhYGI0bN8bHxyffkrIAU6ZMYeDAgdSsWZO4uDi++OILHB0d8239JUuW4O3tTcOGDWnfvj19+vTB3d0dZ2dn0tLS+OCDDyyJ9Gs98cQTfPDBB6SlpfH0008zYsQIhg4dSo0aNTh+/Djh4eE4Oztb5vfu3ZuFCxcSFRVFlSpVaNSoEVFRUbdU6Vu/fn369u1L586dKVq0KFOnTr3jZyAiIiIiIiIi8qAxGbk19hQrFy5cwGw2k5iYiIeHh9WxlJQUjh8/TpkyZaySXHL7oqKiGDRokFWrgf+SmJgYmjRpQkJCAoUKFbpn1z1z5gylSpVi48aNNG3a9I7WatasGT4+PixdujSfopNbod9LIiIiIiIiIv9+N8pJ3ojaO4j8h23atImkpCSqVKlCXFwcw4YNw8/P77rtHG7k8uXLzJ8/n7CwMOzs7Pjoo4/YuHEjGzZsuEuRi4iIiIiIiIhIbtTeQeQ/LD09nZEjR1KpUiXat29P0aJFiYmJwcHB4ZbWMZlMrF27lkceeYSaNWuyevVqVqxYQWho6F2KXERERERERET+k5LPw7dvQdolW0dyX1N7hzxSewcR+TfR7yURERERERF5oFz4HfZEwc55kHoBwiZDSD9bR3XXqb2DiIiIiIiIiIiIPDgyM+HXTbBnMRxdC5lXssaLVQTPvL8Y/r9ISV8RERERERERERG5f6Rdgv2fwva34a+f/xn3DYb6A6BSByigrrU3oqSviIiIiIiIiIiI2N4fR2HHO1kJ3/T/9ex1MkPVTlCjB/hUAZPJtjH+SyjpKyIiIiIiIiIiIrbzawxsngynd/4zVrgM1O4NNXuCk7vNQvu3UtJXRERERERERERE7r3fvodvxmYlfQFMBSDwMajXD0rXV1XvHVDSV0RERERERERERO6dv4/D5kmw/5Os/QIOUOtZeGQwuPvYNrYHhDoey11lMplYtWoVACdOnMBkMrFv3z4bR3VvjBkzhmrVqtk6jLti1KhRRERE3LPrxcTEYDKZOH/+PABRUVEUKlTonl3/fjNnzhzatGlj6zBEREREREREbs2VtKw2DnPr/ZPwrfoU9N8Dj01VwjcfKen7HxceHo7JZMqxtWjRIl/Wj4uLo2XLlvmy1o3s3buXzp074+vri5OTE6VLl6Z169asXr0awzDu+vXzW2BgII6Ojvz22282i6Fx48YMGjQox/jZs2eZNWsWI0eOvGex1K9fn7i4OMxm8z27Zl5s2bKFmjVr4uzsTNmyZZk/f/5Nzzl16hSPP/44bm5uFClShAEDBpCWlmY5npKSQnh4OFWqVMHe3p527drlWKNPnz7Exsaybdu2fL0fERERERERkbvCMOD4t/Deo7BlClxJgTINoc9m6LAACpe2dYQPHCV9hRYtWhAXF2e1ffTRR/myto+PD05OTvmyVm4+//xz6tWrR1JSEosXL+bQoUMsX76cdu3a8dprr5GYmHjd8wzD4MqVK3c1ttuxbds2UlJS6NixI1FRUbYOJ4fIyEhCQkLw8/O7Z9d0dHTEx8cH033Uy+f48eM89thjPPLII+zdu5eRI0cyYMAAVqxYkes5GRkZtGrVikuXLrFt2zaio6NZsWIFQ4YMsZrj4uLCgAEDCA0Nve46Tk5OdO3aldmzZ+f7fYmIiIiIiIjkq9/2wOLHYXFrOLsfXDzhyfehxxdQooato3tgKel7NxgGpF2yzXYbVa1OTk74+PhYbYULFway2jPMmzePli1b4uLiQpkyZVi+fLnl3LS0NF588UV8fX1xdnbGz8+PyZMnW45f3d7herZs2UKdOnVwcnLC19eXV155xSoR27hxYwYMGMCwYcPw9PTEx8eHMWPGWI5funSJXr160apVK9asWUPz5s0pV64cderUoXfv3vzwww+W6tDsFgFff/01tWrVwsnJiW+//RaA1atXW1Vsjh071iqOxMREIiIiKFasGB4eHjz66KP88MMPVvcyZcoUvL29cXd3p1evXqSkpFiObd26FQcHB+Lj463OGTJkCA0bNrQai4yMpGvXrnTv3p33338/R6VyXFwcrVq1snweH374IX5+fsycOTPP8Wa3nli6dCl+fn6YzWaeeuopLl68CGRVgG/ZsoVZs2ZZqr9PnDgBQHR0dI7WAoZhMHXqVMqWLYuLiwvBwcF8+umnluPZz37NmjUEBwfj7OxM3bp12b9/v2XOyZMnefzxxylcuDBubm5UqlSJtWvXWp2f3d7heubNm0e5cuVwdHQkMDCQpUuXWh03mUwsXLiQ9u3b4+rqir+/P1988UWu693M/Pnzeeihh5g5cyYVKlSgd+/ePPvss7z55pu5nrN+/XoOHTrEBx98QPXq1QkNDWX69Om89957XLhwAQA3NzfmzZtHnz598PHJ/c9a2rRpw6pVq0hOTr7texARERERERG5KzIz4aeNEP10VnXviW/BzhFq94YXdkHlJ/SStrtML3K7G9Ivw6Titrn2yN/B0S1flxw1ahRTpkxh1qxZLF26lC5dulC5cmUqVKjA22+/zRdffMEnn3zCQw89xOnTpzl9+nSe1v3tt9947LHHCA8PZ8mSJRw5coQ+ffrg7OxsldhdvHgxgwcPZteuXezYsYPw8HAaNGhAs2bNWL9+PX/99RfDhg3L9TrXVocOGzaMN998k7Jly1KoUCG+/vprunXrxttvv80jjzzCL7/8YulXO3r0aAzDoFWrVnh6erJ27VrMZjMLFiygadOmHDt2DE9PTz755BNGjx7NO++8wyOPPMLSpUt5++23KVu2LAANGzakbNmyLF26lJdffhmAK1eu8MEHHzBlyhRLbBcvXmT58uXs2rWLoKAgLl26RExMDE2aNLHM6dGjB3/++ScxMTE4ODgwePBgzp07Zzmel3gBfvnlF1atWsWXX35JQkICnTp1YsqUKUycOJFZs2Zx7NgxKleuzLhx4wAoWrQoCQkJHDhwgFq1alk909dee43PPvuMefPm4e/vz9atW+nWrRtFixalUaNGlnkvv/wys2bNwsfHh5EjR9KmTRuOHTuGg4MDL7zwAmlpaWzduhU3NzcOHTpEwYIFb/5FAlauXMnAgQOZOXMmoaGhfPnllzzzzDOULFnS6tmNHTuWqVOnMm3aNGbPns3TTz/NyZMnLc/kZtd75JFH+OqrrwDYsWMHzZs3tzoeFhZGZGQk6enpODg45Dh/x44dVK5cmeLFi1udk5qayp49e6xivZlatWqRnp7O7t27rZ6xiIiIiIiIiM0knoHvl8C+DyExOz9kguCnoMmrUKiUTcP7L1HSV/jyyy9zJLuGDx/OqFGjAOjYsSO9e/cGYPz48WzYsIHZs2czd+5cTp06hb+/Pw8//DAmk4nSpfPeg2Xu3LmUKlWKOXPmYDKZCAoK4vfff2f48OG8/vrrFCiQVYhetWpVRo8eDYC/vz9z5szhm2++oVmzZhw7dgzI6oGbLTY21ip5Fh0dTevWrS3748aNo1mzZpb9iRMn8sorr9CzZ08AypYty/jx4xk2bBijR49m8+bN7N+/n3PnzllaVbz55pusWrWKTz/9lIiICGbOnMmzzz5reU4TJkxg48aNVtW+vXr1YtGiRZak75o1a7h8+TKdOnWyitXf359KlSoB8NRTTxEZGWm5nyNHjrBx40ZiY2MtideFCxfi7+9vWSMv8QJkZmYSFRWFu7s7AN27d+ebb75h4sSJmM1mHB0dcXV1tao2PXnyJIZhWCUtL126xFtvvcWmTZsICQmxPMNt27axYMECq4Tk6NGjLc9+8eLFlCxZkpUrV9KpUydOnTrFE088QZUqVSxr5NWbb75JeHg4/fr1A2Dw4MHs3LmTN9980+q7EB4eTpcuXQCYNGkSs2fPZvfu3ZYe1jd7yaCLi4vl5/j4eLy9va2Oe3t7c+XKFf788098fX1znH+9cwoXLoyjo2OOKvCbcXNzo1ChQpw4cUJJXxEREREREbGt+P2wdRoc+gL4318sO5uhSieo3QuKVbBpeP9FSvreDQ6uWRW3trr2LWrSpAnz5s2zGsuufAQsibyr97OTY+Hh4TRr1ozAwEBatGhB69atc1Q/5ubw4cOEhIRYVeI2aNCApKQkzpw5w0MPPQRkJX2v5uvra1XZeq2qVata4vP398/Rt/faKtU9e/YQGxvLxIkTLWMZGRmkpKRw+fJl9uzZQ1JSEl5eXlbnJScn88svv1jupW/fvlbHQ0JC2Lx5s2U/PDyc1157jZ07d1KvXj3ef/99OnXqhJvbP5XZkZGRdOvWzbLfrVs3GjZsyPnz5ylUqBBHjx7F3t6eGjX+6XlTvnx5SzuO7Pu5WbwAfn5+loQv3Py5Zq8B4OzsbBk7dOgQKSkpVol0yGr9Ub169RzPJJunpyeBgYEcPnwYgAEDBvD888+zfv16QkNDeeKJJ3J89rk5fPiwJZmdrUGDBsyaNctq7Or13NzccHd3t7rn8uXL5+l62a6tIs9uxXGj3sPXO2YYxm31K3ZxceHy5cu3fJ6IiIiIiIjIHctIhwMrYE8UnNrxz3jJ2lC7D1RsAw4uuZ4ud5eSvneDyZTvLRbuJjc3t9tOdtWoUYPjx4/z1VdfsXHjRjp16kRoaKhVP9fcXC/Rdb2k2bV/Jm8ymcjMzASwVLgePXqUevXqAVk9im90P1cnWSGr4nXs2LF06NAhx1xnZ2cyMzPx9fUlJiYmx/FChQrlep1rFStWjMcff5xFixZRtmxZ1q5da7XmoUOH2LVrF7GxsQwfPtwynpGRwUcffcTzzz+fo79vtqvH8xrvjZ5rbooUKQJAQkICRYsWtVwPsiqXS5QoYTU/Ly/xy/6se/fuTVhYGGvWrGH9+vVMnjyZ6dOn079//5uucfU62a73/brZPd9KewcfH58c1bnnzp3D3t4+R8I9m4+PD7t27bIaS0hIID09PUcFcF78/fffls9BRERERERE5J5IuwS734Pd78KF3/43aIJK7aHhUPCuZNPwJIuSvnJTO3fupEePHlb7V1dwenh40LlzZzp37syTTz5JixYt+Pvvv62qha+nYsWKrFixwio5t337dtzd3XMkD3PTvHlzPD09eeONN1i5cuVt3F1W4vro0aO5Jopr1KhBfHw89vb2+Pn5XXdOhQoVrvucrtW7d2+eeuopSpYsSbly5WjQoIHlWGRkJA0bNuSdd96xOmfp0qVERkby/PPPExQUxJUrV9hd7N7hAAAgAElEQVS7dy81a9YE4Oeff7Z6wVle4s0LR0dHMjIyrMbKlSuHh4cHhw4dIiAgAMj6HJ2cnDh16tRN2wzs3LnTUsGdkJDAsWPHCAoKshwvVaoUffv2pW/fvowYMYL33nsvT0nfChUqsG3bNqvnv337dipUuLU/H7mV9g4hISGsXr3a6vj69eupVavWdfv5Zp8zceJE4uLiLO0f1q9fj5OTk+XzzKtffvmFlJSUHNXUIiIiIiIiIvnOMOBMLOxbBgdXQcr/8hBuRaFOBFR7Gsx5y+XIvaGkr5CampqjYtHe3t5S1bl8+XJq1arFww8/zLJly9i9ezeRkZEAzJgxA19fX6pVq0aBAgVYvnw5Pj4+eaqA7devHzNnzqR///68+OKLHD16lNGjRzN48GBLP9+bKViwIAsXLqRz5860atWKAQMG4O/vT1JSEuvWrQPAzs7uhmu8/vrrtG7dmlKlStGxY0cKFCjAjz/+yP79+5kwYQKhoaGEhITQrl073njjDQIDA/n9999Zu3Yt7dq1o1atWgwcOJCePXtaPaeDBw/m6EsbFhaG2WxmwoQJlhekAaSnp7N06VLGjRtH5cqVrc7p3bs3U6dO5YcffiA4OJjQ0FAiIiKYN28eDg4ODBkyBBcXF0viPC/x5oWfnx+7du3ixIkTFCxYEE9PTwoUKEBoaCjbtm2jXbt2ALi7uzN06FBeeuklMjMzefjhh7lw4QLbt2+nYMGCll7JkNVP2cvLC29vb1599VWKFCliWWfQoEG0bNmSgIAAEhIS2LRpU56Tti+//DKdOnWiRo0aNG3alNWrV/PZZ5+xcePGPJ2f7VYq3vv27cucOXMYPHgwffr0YceOHURGRvLRRx9Z5qxcuZIRI0Zw5MgRIOt/UlSsWJHu3bszbdo0/v77b4YOHUqfPn3w8PCwnHfo0CHS0tL4+++/uXjxoiUZXa1aNcucb7/9lrJly1KuXLlbukcRERERERGRPEs4CT9vgN0L4Y/D/4wX9oOGw6DKk2B/87/yFRswJE8SExMNwEhMTMxxLDk52Th06JCRnJxsg8juTM+ePQ2yOmxbbYGBgYZhGAZgvPPOO0azZs0MJycno3Tp0sZHH31kOf/dd981qlWrZri5uRkeHh5G06ZNje+//95yHDBWrlxpGIZhHD9+3ACMvXv3Wo7HxMQYtWvXNhwdHQ0fHx9j+PDhRnp6uuV4o0aNjIEDB1rF3LZtW6Nnz55WY7GxscaTTz5pFCtWzLC3tze8vLyMsLAwIzo62sjMzDQMwzA2b95sAEZCQkKO57Bu3Tqjfv36houLi+Hh4WHUqVPHePfddy3HL1y4YPTv398oXry44eDgYJQqVcp4+umnjVOnTlnmTJw40ShSpIhRsGBBo2fPnsawYcOM4ODgHNcaNWqUYWdnZ/z++++WsU8//dQoUKCAER8ff51PyTCqVKli9O/f3zAMw/j999+Nli1bWj6PDz/80ChWrJgxf/78PMc7evToHLHNmDHDKF26tGX/6NGjRr169QwXFxcDMI4fP255ViVKlDAyMjIsczMzM41Zs2YZgYGBhoODg1G0aFEjLCzM2LJli9WzX716tVGpUiXD0dHRqF27trFv3z7LGi+++KJRrlw5w8nJyShatKjRvXt3488//7zuZ7do0SLDbDZbxT937lyjbNmyhoODgxEQEGAsWbLE6vjV38VsZrPZWLRo0XWfeV7ExMQY1atXNxwdHQ0/Pz9j3rx5VscXLVpkXPtr9uTJk0arVq0MFxcXw9PT03jxxReNlJQUqzmlS5e+7r+XV2vevLkxefLkXGP7N/9eEhERERERERs6f8Ywdsw1jLkNDGO0xz/beG/DWBFhGD9vMoyMK7aO8j/jRjnJGzEZRi5NQsXKhQsXMJvNJCYmWlXkAaSkpHD8+HHKlClj9YKrB4HJZGLlypWWaky5c3369OHs2bN88cUX+bLemTNnKFWqFBs3bqRp06b5suaNGIZBvXr1GDRoEF26dMnTOTExMTRp0oSEhIRb6oMs13fgwAGaNm3KsWPHMJvN153zIP9eEhERERERkXx2JRUOroS9H8CJb/8ZL2AP3pUhuAsEPwUu+m/6e+1GOckbUXsHkXskMTGR2NhYli1bxueff37b62zatImkpCSqVKlCXFwcw4YNw8/Pj4YNG+ZjtLkzmUy8++67/Pjjj/fkepLT77//zpIlS3JN+IqIiIiIiIjcVGYGnN4F3y3KSvhmpv9zrERNqNoZKnWAgnqB+L+Rkr4i90jbtm3ZvXs3zz33HM2aNbvtddLT0xk5ciS//vor7u7u1K9fn2XLluX68rC7ITg4mODg4Ht2PbHWvHlzW4cgIiIiIiIi/1apF+G797P69Cae+mfc1QtqPgM1e0Khh2wXn+QLJX3lhtT9I//ExMTkyzphYWGEhYXly1r3SuPGjfVdEhEREREREbGl+P2wfQ4c+hyuJGeN2btAxTZQu3dWdW8BO9vGKPlGSV8REREREREREZEHUUoi/LIZ9i+HI1/+M+5ZDh5+Cao8CQ4utotP7holfUVERERERERERB4Uv++FfR/BT19Dwkngqr+8rdQe6r3wv6reAjYLUe4+JX1FRERERERERET+zS79Cd8vyarm/W2P9TEvf/BvDtWfBu9KtolP7jklfUVERERERERERP6NznwHsQvhwArISMsas3OEwMegSkcoVRcKFrVtjGITSvqKiIiIiIiIiIj8W2RmwqGVWZW9v8b8M168BlTvBoEtwaO4zcKT+4OSviIiIiIiIiIiIve7zEw4/DnEvAF/HP5nvEpHqPs8lKxpu9jkvqOkr4iIiIiIiIiIyP3KMODQKoiZAn8cyRpzMkO9vlC1M3iVs218cl/Sa/r+wxo3bsygQYNyjK9atQqTyWTZT0tLY+rUqQQHB+Pq6kqRIkVo0KABixYtIj09HYDw8HBMJpNl8/LyokWLFvz444/XvXZERAR2dnZER0ffnZvLgzFjxlCtWjWbXV9EREREREREJFepSbB9NixoCMvDsxK+Th7Q6BUY9CM0GamEr+RKSV+5obS0NMLCwpgyZQoRERFs376d3bt388ILLzB79mwOHjxomduiRQvi4uKIi4vjm2++wd7entatW+dY8/Lly3z88ce8/PLLREZG3svbERERERERERG5vxkGHF4N7z0K61+D+B/B3hkaDYeXDkCTEeBSyNZRyn1O7R3uAsMwSL6SbJNru9i7WFXp3qmZM2eydetWvvvuO6pXr24ZL1u2LB07diQtLc0y5uTkhI+PDwA+Pj4MHz6chg0b8scff1C06D9vily+fDkVK1ZkxIgR+Pr6cuLECfz8/CzHr1y5wuDBg1myZAl2dnb07t2b+Ph4EhMTWbVqFZD1jKdNm8b8+fOJi4sjICCAUaNG8eSTTwIQExNDkyZN2LhxI8OHD+fQoUNUq1aNRYsWERgYSFRUFGPHjgWwPK9FixYRHh6eb89ORERERERERCTPDAOOrIEtUyB+f9aYqxc0HgEV20HBojc+X+QqSvreBclXkqn7YV2bXHtX1124Orjm23rLli0jNDTUKuGbzcHBAQcHh+uel5SUxLJlyyhfvjxeXl5WxyIjI+nWrRtms5nHHnuMRYsWWRKwAG+88QbLli1j0aJFVKhQgVmzZrFq1SqaNGlimfPaa6/x2WefMW/ePPz9/dm6dSvdunWjaNGiNGrUyDLv1VdfZfr06RQtWpS+ffvy7LPP8n//93907tyZAwcOsG7dOjZu3AiA2Wy+o2clIiIiIiIiInLL0pPhx08gdmFWVS+AY0Go2xdCXgBXT9vGJ/9KSvrKDf300080btw4T3O//PJLChYsCMClS5fw9fXlyy+/pECBf7qI/PTTT+zcuZPPPvsMgG7dujFgwABGjx5tmTd79mxGjBhB+/btAZgzZw5r1661rHHp0iXeeustNm3aREhICJBVebxt2zYWLFhglfSdOHGiZf+VV16hVatWpKSk4OLiQsGCBbG3t7dUJ4uIiIiIiIiI3DPJ52H72xAbCSnns8YcC0KdCKjfX8leuSNK+t4FLvYu7Oq6y2bXzk+GYeS5XUSTJk2YN28eAH///Tdz586lZcuW7N69m9KlSwNZVb5hYWEUKVIEgMcee4xevXqxceNGmjdvTmJiImfPnqVOnTqWde3s7KhZsyaZmZkAHDp0iJSUFJo1a2Z1/bS0tBwVyVWrVrX87OvrC8C5c+d46KGHbuUxiIiIiIiIiIjkn19jYOXzcPH3rP1CD0HNZ6BGT3DzuuGpInmhpO9dYDKZ8rXFwt3i4eFBYmJijvHz58/j4eEBQEBAAIcPH87Tem5ubpQvX96yX7NmTcxmM++99x4TJkwgIyODJUuWEB8fj739P1+9jIwMIiMjad68uWXs2kSzYRiWn7OTv2vWrKFEiRJW85ycnKz2r24/kb1m9vkiIiIiIiIiIvfU5b9h4xj4fnHWvmdZaPo6VGgDBexsGpo8WJT0/Q8LCgriq6++yjEeGxtLYGAgAF27dmXkyJHs3bs3RxXtlStXSE1Nxc3N7brrm0wmChQoQHJy1kvt1q5dy8WLF9m7dy92dv/8Ijty5AhPP/00f/31F15eXnh7e7N7924eeeQRICspvHfvXqpVqwZAxYoVcXJy4tSpU1atHG6Vo6MjGRkZt32+iIiIiIiIiEieJP4GO+fCnihIS8oaq/kMhE0Ex+vnVUTuhJK+/2H9+vVjzpw5vPDCC0RERODi4sKGDRuIjIxk6dKlAAwaNIg1a9bQtGlTxo8fz8MPP4y7uzvfffcdb7zxBpGRkZZkbGpqKvHx8QAkJCQwZ84ckpKSePzxx4Gs1g6tWrUiODjYKo5KlSoxaNAgPvjgAwYOHEj//v2ZPHky5cuXJygoiNmzZ5OQkGCp1HV3d2fo0KG89NJLZGZm8vDDD3PhwgW2b99OwYIF6dmzZ57u38/Pj+PHj7Nv3z5KliyJu7t7jkphEREREREREZHb9sfRrGTvvg8hIy1rzLsytJwKfg1sG5s80JT0/Q/z8/Pj22+/5dVXX6V58+akpKQQEBBAVFQUHTt2BLLaJWzYsIEZM2awYMEChg4diqurKxUqVGDAgAFUrlzZst66dessfXPd3d0JCgpi+fLlNG7cmLNnz7JmzRo+/PDDHHGYTCY6dOhAZGQkAwcOZPjw4cTHx9OjRw/s7OyIiIggLCzMqjp4/PjxFCtWjMmTJ/Prr79SqFAhatSowciRI/N8/0888QSfffYZTZo04fz58yxatIjw8PDbfJoiIiIiIiIiIv/z1y+w4x347n3gfy0rHwqBR4ZA+VDI4/uTRG6Xybi6Wark6sKFC5jNZhITEy39brOlpKRw/PhxypQpg7Ozs40ifHBlZmZSoUIFOnXqxPjx420djsi/gn4viYiIiIiI2EDSH7DlDdizCDKvZI2VexQavpyV9FWyV27RjXKSN6JKX7nvnDx5kvXr19OoUSNSU1OZM2cOx48fp2vXrrYOTURERERERETEWtol+Gk9/LoFfoiGK1nvNqLco1C/f9Y/Re4xJX3lvlOgQAGioqIYOnQohmFQuXJlNm7cSIUKFWwdmoiIiIiIiIhIlrTLcOBT+HY6JJz4Z7x4DWg2Fso0tFloIkr6yn2nVKlS/N///Z+twxARERERERERyeliPOyaD7HvQ2pi1lhBb6jweNZWppHaOIjNKekrIiIiIiIiIiJyM/H7YftsOPAZZKZnjRX2gxo9oHZvcDbbNDyRqynpKyIiIiIiIiIikpu/foGNo+Hw6n/GStWDBgMgoCUUKGC72ERyoaSviIiIiIiIiIjItdKTYes0+L+3/1fZa4KKbaHBQChRw9bRidyQTf9XxLx586hatSoeHh54eHgQEhLCV199ZTkeHh6OyWSy2urVq2e1RmpqKv3796dIkSK4ubnRpk0bzpw5YzUnISGB7t27YzabMZvNdO/enfPnz9+TexQRERERERERkX+Rv3+Fr1+F6UFZL2nLTIfyodBvB3RarISv/CvYtNK3ZMmSTJkyhfLlywOwePFi2rZty969e6lUqRIALVq0YNGiRZZzHB0drdYYNGgQq1evJjo6Gi8vL4YMGULr1q3Zs2cPdnZ2AHTt2pUzZ86wbt06ACIiIujevTurV69GRERERERERESEU7uyKnt/3ggYWWOFHoLmE6FiG5uGJnKrbJr0ffzxx632J06cyLx589i5c6cl6evk5ISPj891z09MTCQyMpKlS5cSGhoKwAcffECpUqXYuHEjYWFhHD58mHXr1rFz507q1q0LwHvvvUdISAhHjx4lMDDwumunpqaSmppq2b9w4cId36+IiIiIiIiIiNxnEk7C1qmwdxmWZG/5UKjdB/ybQQE7m4Yncjvum07TGRkZREdHc+nSJUJCQizjMTExFCtWjICAAPr06cO5c+csx/bs2UN6ejrNmze3jBUvXpzKlSuzfft2AHbs2IHZbLYkfAHq1auH2Wy2zLmeyZMnW9pBmM1mSpUqlZ+3+0CIiYnBZDJZtcpYtWoV5cuXx87OjkGDBuV6rp+fHzNnzrwXYd6XRo0aRUREhGW/cePGN3xe95P9+/dTsmRJLl26ZOtQRERERERERG5P2iU4th4+fApm14S9HwAGVHsa+n8P3VZAYAslfOVfy+ZJ3/3791OwYEGcnJzo27cvK1eupGLFigC0bNmSZcuWsWnTJqZPn05sbCyPPvqopQI3Pj4eR0dHChcubLWmt7c38fHxljnFihXLcd1ixYpZ5lzPiBEjSExMtGynT5/Or1u+r1zdN9nBwQFvb2+aNWvG+++/T2Zm5g3PrV+/PnFxcZjNZsvYc889x5NPPsnp06cZP348UVFRFCpUKMe5sbGxVknP/BYYGIijoyO//fbbXbvGzeSWyD179iyzZs1i5MiRdz2G/fv306hRI1xcXChRogTjxo3DMIwbnjNx4kTq16+Pq6vrdT+7KlWqUKdOHWbMmHG3whYRERERERHJf6lJWYne1YNgegX4sCMc+yqrZ2/ph6HXBmg3F7zK2TpSkTtm0/YOkJWc27dvH+fPn2fFihX07NmTLVu2ULFiRTp37myZV7lyZWrVqkXp0qVZs2YNHTp0yHVNwzAwmUyW/at/zm3OtZycnHBycrrNu/p3ye6bnJGRwdmzZ1m3bh0DBw7k008/5YsvvsDePufXJD09HUdHR6vWG0lJSZw7d46wsDCKFy9+w2sWLVo03+8j27Zt20hJSaFjx45ERUXx6quv3rVr3Y7IyEhCQkLw8/PL8zlpaWk5+lnfzIULF2jWrBlNmjQhNjaWY8eOER4ejpubG0OGDLnhtTp27EhISAiRkZHXnfPMM8/Qt29fRowYYemdLSIiIiIiInJfOncYYhfCD9GQlvTPuEcJCGoF1buDTxW4QZ5I5N/G5pW+jo6OlC9fnlq1ajF58mSCg4OZNWvWdef6+vpSunRpfvrpJwB8fHxIS0sjISHBat65c+fw9va2zDl79myOtf744w/LnPxmGAaZly/bZLtZFef1ZPdNLlGiBDVq1GDkyJF8/vnnfPXVV0RFRQFZifP58+fTtm1b3NzcmDBhglV7h5iYGNzd3QF49NFHMZlMxMTE8Mwzz5CYmGipJh4zZgyQs72DyWRi4cKFtG/fHldXV/z9/fniiy+s4vziiy/w9/fHxcWFJk2asHjx4hztJSArqdq1a1e6d+/O+++/n+OZxMXF0apVK1xcXChTpgwffvhhjngSExOJiIigWLFieHh48Oijj/LDDz9Yjo8ZM4Zq1aqxdOlS/Pz8MJvNPPXUU1y8eBHIqqDesmULs2bNstz7iRMnAIiOjqZNmxs3gPfz82PChAmEh4djNpvp06fPTT7FnJYtW0ZKSgpRUVFUrlyZDh06MHLkSN56660bfk/Gjh3LSy+9RJUqVXKdExYWxl9//cWWLVtuOS4RERERERGRuy4lEX74GJa0hbn1spK+aUlZL2ar1g16fA6DDsBj08C3qhK+8sCxeaXvtQzDsHqB2tX++usvTp8+ja+vLwA1a9bEwcGBDRs20KlTJyAroXfgwAGmTp0KQEhICImJiezevZs6deoAsGvXLhITE6lfv/7duYfkZI7WqHlX1r6ZwO/3YHJ1veN1Hn30UYKDg/nss8/o3bs3AKNHj2by5MnMmDEDOzs7jh8/bplfv359y4vxVqxYQf369fH09GTmzJm8/vrrHD16FICCBQvmes2xY8cydepUpk2bxuzZs3n66ac5efIknp6enDhxgieffJKBAwfSu3dv9u7dy9ChQ3OscfHiRZYvX86uXbsICgri0qVLxMTE0KRJE8ucHj168OeffxITE4ODgwODBw+26hVtGAatWrXC09OTtWvXYjabWbBgAU2bNuXYsWN4enoC8Msvv7Bq1Sq+/PJLEhIS6NSpE1OmTGHixInMmjWLY8eOUblyZcaNGwdkVTcnJCRw4MABatWqddPPYNq0aYwaNYrXXnvNMlapUiVOnjyZ6zmlS5fm4MGDQFY/60aNGllVrIeFhTFixAhOnDhBmTJlbhpDbhwdHQkODubbb7/l0Ucfve11RERERERERPJFZgb89Qsc3wK/bIafN0JGdn7JBBVaZ72YrUxDJXjlP8GmSd+RI0fSsmVLSpUqxcWLF4mOjiYmJoZ169aRlJTEmDFjeOKJJ/D19eXEiROMHDmSIkWK0L59ewDMZjO9evViyJAheHl54enpydChQ6lSpQqhoaEAVKhQgRYtWtCnTx8WLFgAQEREBK1btyYwMNBm9/5vEBQUxI8//mjZ79q1K88++6xl/+qkr6Ojo6V3sqenp6Xtg9lsxmQyWbWByE14eDhdunQBYNKkScyePZvdu3fTokUL5s+fT2BgINOmTQOy2oIcOHCAiRMnWq0RHR2Nv78/lSpVAuCpp54iMjLSkvQ9cuQIGzduJDY21pJ4XbhwIf7+/pY1Nm/ezP79+zl37pwlYfrmm2+yatUqPv30U0sv4szMTKKioiwVzt27d+ebb75h4sSJmM1mHB0dcXV1tbr3kydPYhjGTdtfQFbi/drE9tq1a0lPT8/1HAcHB8vP8fHxOVpIZFe3x8fH31HSF6BEiRKW6mURERERERGRey4zAw6uzNp+2QTpl62PFwmASh2gWhco7GeTEEVsxaZJ37Nnz9K9e3fLy8CqVq3KunXraNasGcnJyezfv58lS5Zw/vx5fH19adKkCR9//LElyQYwY8YM7O3t6dSpE8nJyTRt2pSoqCirPqPLli1jwIABNG/eHIA2bdowZ86cu3ZfJhcXAr/fc9fWv9m188u1fY/zUp16J6pWrWr52c3NDXd3d0sF7tGjR6ldu7bV/OzK7atFRkbSrVs3y363bt1o2LAh58+fp1ChQhw9ehR7e3tq1KhhmVO+fHmrlwHu2bOHpKQkvLy8rNZOTk7ml19+sez7+flZfRd9fX2tKoavJzk5GQBnZ+cbzoPrP+/SpUvf9LyrXdu3Orutw436WeeVi4sLly9fvvlEERERERERkfyUmQEHVkDMZPj713/G7V2geHUo3xT8m4GP2jbIf5dNk765vSQKshJKX3/99U3XcHZ2Zvbs2cyePTvXOZ6ennzwwQe3FePtMJlM+dJiwdYOHz5sVQ3q5uZ2V693dZUqZD3HzMxM4Pov3ru2L+2hQ4fYtWsXsbGxDB8+3DKekZHBRx99xPPPP59rL9urxzMzM/H19SUmJibHvEKFCuUp3twUKVIEgISEhJu+zO56z/tW2jv4+PgQHx9vdTw7KZ0f/az//vtvypXTG01FRERERETkHsmu7P1mHJz/338bOxeC2r0h8DEoXg0K6GXjInAf9vSV+8OmTZvYv38/L7300h2t4+joSEZGxh3HExQUxNq1a63GvvvuO6v9yMhIGjZsyDvvvGM1vnTpUiIjI3n++ecJCgriypUr7N27l5o1s/ou//zzz1Yvg6tRowbx8fHY29vnaI9wK6537+XKlcPDw4NDhw4REBBwy2veSnuHkJAQRo4cSVpaGo6OjgCsX7+e4sWL39F9ZTtw4ABPPvnkHa8jIiIiIiIickN//gzfL4YfP4Gk/xU3OZuh/gCo2xeccn9/kMh/VQFbByC2l5qaSnx8PL/99hvff/89kyZNom3btrRu3ZoePXrc0dp+fn4kJSXxzTff8Oeff952O4DnnnuOI0eOMHz4cI4dO8Ynn3xCVFQUkFVhm56eztKlS+nSpQuVK1e22nr37s2ePXv44YcfCAoKIjQ0lIiICHbv3s3evXuJiIjAxcXFUkkcGhpKSEgI7dq14+uvv+bEiRNs376d1157LUei+Wb3vmvXLk6cOMH/s3fvcVFW+QPHPyMwCAijKHLzMqRcUpFSNKEWBVHY1fXSYimpixdQ235p6OqKaWaiJa6KVmorRpnJlpmyLZpX3CwVMi+QiWUOKoKkIorKRWZ+f8z6rBM3UXE0v+/Xa14vznnOOc/3eSBeu1+O33P+/Hn0ej2NGjUiNDSUPXv23NF7aNu2Le3bt6/xc2v5h8jISKytrYmKiiI7O5vPP/+cefPmERsbqzxrRkYGPj4+5OXlKfNOnTrFoUOHOHXqFJWVlRw6dIhDhw5RUlKijNHpdOTl5Sm1s4UQQgghhBBCiHuqsgKy1kNyf3i7K3yz1JjwtXGEoL/Cy4cgaIokfIWogSR9BVu2bMHV1RWtVkt4eDi7du1i6dKlbNq0yaQ28p0IDAxk/PjxPP/88zg5ObFgwYI7WsfDw4P169ezYcMGOnfuzPLly5kxYwYA1tbWpKamcuHCBeWQv1t5enri6+urlBP58MMPcXZ2JigoiMGDBxMdHY29vb1SZ1elUpGWlkZQUBCjR4/Gy8uLoUOHotPp6lUWYcqUKVhYWNChQwecnJw4deoUYDxIMCUlpc5SEHdLo9Gwbds2zpw5g7+/Py+++PddKV8AACAASURBVCKxsbHExsYqY65du0ZOTo7J7uFZs2bx5JNP8tprr1FSUsKTTz7Jk08+aZLwXrduHX379q13jWEhhBBCCCGEEKJWVwog/S1IfAI+GwO6rwAVePaF5z+Cyccg5FWwdTR3pEI80FSGmoqcChOXL19Go9FQXFyMg4ODybXS0lJOnjyJh4fHbR3QJe6N+Ph4VqxYwenTp+9qnTNnztC6dWu2b99O796971F0NTMYDPTo0YNJkyYxbNiwBr/fvVZWVoanpyfr1q3j6aefNnc4ogbye0kIIYQQQgjx0Ki8ASfT4dA6+CEVKsuN/bbNjfV6nxwBTVubNUQhzKW2nGRtpKaveGi8++67dOvWjebNm/P111+TkJDASy+9VO91du7cSUlJCb6+vuTn5zN16lS0Wi1BQUENEHVVKpWK9957jyNHjtyX+91rubm5zJgxQxK+QgghhBBCCCHunF4Phd/DwY8gewNcLfzftdZPQbdoePyPYCWbWIS4E5L0FQ+NH3/8kblz53Lx4kXatGnD5MmTmT59er3XqaioIC4ujp9//hl7e3sCAwNZu3atySFoDc3Pzw8/P7/7dr97ycvL644OoRNCCCGEEEIIIZRD2Q6vg6u//K/ftjl0fBaefAHcnjRffEL8Rkh5h9sk5R2EEA8T+b0khBBCCCGEeGCUlcBP2yHjH5B7y8HmljbQvjd0GQntQsDi/m3GEuJhIeUdhBBCCCGEEEIIIcSD4+xB2LcCsj8D/X8PEFc1gvZ9oOufjYezSaJXiAYhSV8hhBBCCCGEEEIIce/kfQdf/R2OffG/PodW0HmIsVavxt18sQnxiJCkrxBCCCGEEEIIIYS4exdOwLZZtyR7VeA7BJ4aD626mjU0IR41kvQVQgghhBBCCCGEEHfu+iX4TwLsX2ks46CygE5/gt/FQsvHzR2dEI8kSfoKIYQQQgghhBBCiPorvQxH/gnp8+HaBWNf+1DoGw8tfcwbmxCPOEn6CiGEEEIIIYQQQojbd/UCHFoLexbD9YvGvhbeEBYPnn3MG5sQAoBG5g5APLzS09NRqVRcunRJ6du4cSPt27fHwsKCSZMm1ThXq9WyZMmS+xHmA2nmzJnExMQo7V69etX6vh4kWVlZtGrViqtXr5o7FCGEEEIIIYQQ91NZCex9F97uCttmGhO+jo/B7xfAhK8l4SvEA0SSvo+4qKgoVCoVKpUKKysrnJ2d6dOnD6tXr0av19c6NzAwkPz8fDQajdI3btw4IiIiOH36NG+88QbJyck0bdq0ytzMzEyTpOe95u3tjVqtJi8vr8HuUZeaErnnzp0jMTGRuLi4Bo8hKyuLnj17YmNjg7u7O3PmzMFgMNQ4XqfTMWbMGDw8PLCxsaFdu3a89tprlJeXK2N8fX3p3r07ixcvbvD4hRBCCCGEEEI8ILLWQ2Jn+HI6XC8Cp8eh/2L4SyY8NQ4srMwdoRDiFpL0FYSHh5Ofn49Op2Pz5s0EBwczceJE+vfvz40bN6qdU1FRgVqtxsXFBZVKBUBJSQmFhYWEhYXh5uaGvb19jfd0cnLC1ta2QZ5nz549lJaWMmTIEJKTkxvkHncjKSmJgIAAtFrtbc+5Nel6uy5fvkyfPn1wc3MjMzOTZcuWsXDhQhYtWlTjnGPHjqHX61m5ciXff/89ixcvZsWKFVUS1KNGjWL58uVUVlbWOy4hhBBCCCGEEA+R05nwwR/hszHGur3NtMZk7/g94D8aLKRyqBAPIkn6NgCDwUBFWaVZPrXt4qyJtbU1Li4uuLu706VLF+Li4ti0aRObN29WkqYqlYoVK1YwcOBA7OzsmDt3rkl5h/T0dCXJGxISgkqlIj09nVGjRlFcXKzsJp49ezZQtbyDSqVi1apVDB48GFtbWzw9PUlNTTWJMzU1FU9PT2xsbAgODuaDDz6oUl4CjEnVyMhIRowYwerVq6u8k/z8fPr164eNjQ0eHh58/PHHVeIpLi4mJiaGli1b4uDgQEhICIcPH1auz549myeeeII1a9ag1WrRaDQMHTqUK1euAMYd1Lt37yYxMVF5dp1OB0BKSgoDBgyo9Xui1WqZO3cuUVFRaDQaoqOj6/guVrV27VpKS0tJTk6mU6dOPPvss8TFxbFo0aIaf07Cw8N5//336du3L4899hgDBgxgypQpbNiwwWRcWFgYFy5cYPfu3fWOSwghhBBCCCHEA85ggNxv4KM/QVIonPwPWKjhd1PgLxmS7BXiISD/hTaAG+V63ptonmRYTGJPrKwt7nqdkJAQ/Pz82LBhA2PHjgXgtddeY/78+SxevBgLCwtOnjypjA8MDCQnJwdvb28+++wzAgMDcXR0ZMmSJcyaNYucnBwAmjRpUuM9X3/9dRYsWEBCQgLLli3jhRdeIDc3F0dHR3Q6HREREUycOJGxY8dy8OBBpkyZUmWNK1eu8Omnn7J//358fHy4evUq6enpBAcHK2NGjhzJ+fPnSU9Px8rKitjYWAoLC5XrBoOBfv364ejoSFpaGhqNhpUrV9K7d2+OHz+Oo6MjACdOnGDjxo188cUXFBUV8dxzz/Hmm28SHx9PYmIix48fp1OnTsyZMwcw7m4uKioiOzsbf3//Or8HCQkJzJw5k1dffVXp69ixI7m5uTXOadu2Ld9//z0Ae/fupWfPnlhbWyvXw8LCmD59OjqdDg8PjzpjAGMC/OYz36RWq/Hz8+Orr74iJCTkttYRQgghhBBCCPGA01dC9gZInw8XTxj7VBbwxDAImgrN2po3PiHEbZOkr6iRj48PR44cUdqRkZGMHj1aad+a9FWr1bRs2RIAR0dHXFxcANBoNKhUKqVdm6ioKIYNGwbAvHnzWLZsGRkZGYSHh7NixQq8vb1JSEgAjDV7s7OziY+PN1kjJSUFT09POnbsCMDQoUNJSkpSkr7Hjh1j+/btZGZmKonXVatW4enpqayxa9cusrKyKCwsVBKmCxcuZOPGjaxfv16pRazX60lOTlZ2OI8YMYIdO3YQHx+PRqNBrVZja2tr8uy5ubkYDAbc3NzqfB8hISFVEttpaWlUVFTUOMfK6n81lAoKCqqUkHB2dlau3U7S98SJEyxbtoy///3vVa65u7sru5eFEEIIIYQQQjzEDAb4aTtsnQm//GDss7AGv+fhmVeMh7UJIR4qkvRtAJbqRsQk9jTbve8Vg8Gg1OsFbmt36t3o3Lmz8rWdnR329vbKDtycnBy6detmMr579+5V1khKSmL48OFKe/jw4QQFBXHp0iWaNm1KTk4OlpaWdOnSRRnTvn17mjVrprQPHDhASUkJzZs3N1n7+vXrnDhxQmlrtVqTusWurq4mO4arc/36dQAaN25c6zio/n23bVu/v6re+v0DlLIOv+6vztmzZwkPD2fIkCHKbu9b2djYcO3atXrFI4QQQgghhBDiAVLyCxz8EI58+r9kr00z6PEidI82fi2EeChJ0rcBqFSqe1Jiwdx++OEHk92gdnZ2DXq/W3epgvE96vV6oGoC+mbfrY4ePcr+/fvJzMxk2rRpSn9lZSXr1q1jwoQJNdayvbVfr9fj6upKenp6lXFNmza9rXhr0qJFCwCKiopwcnKqdWx177s+5R1cXFwoKCgwuX4zKX1zx29Nzp49S3BwMAEBAbz33nvVjrl48SLt2rWrdR0hhBBCCCGEEA8gvR4Ofwxb4qCs2NinbgJdo+B3k8HWsdbpQogHnyR9RbV27txJVlYWr7zyyl2to1arqaysvOt4fHx8SEtLM+n79ttvTdpJSUkEBQXxzjvvmPSvWbOGpKQkJkyYgI+PDzdu3ODgwYN07doVgJ9++snkMLguXbpQUFCApaVllfII9VHds7dr1w4HBweOHj2Kl5dXvdesT3mHgIAA4uLiKC8vR61WA7B161bc3Nxqfa68vDyCg4Pp2rUr77//Po0aVb97PDs7m4iIiHo/gxBCCCGEEEIIM8rdC5unQsF/yzm6dIYuI8F3CNg0rX2uEOKhce9qAYiHVllZGQUFBeTl5fHdd98xb948Bg4cSP/+/Rk5cuRdra3VaikpKWHHjh2cP3/+jssBjBs3jmPHjjFt2jSOHz/OJ598QnJyMmDcYVtRUcGaNWsYNmwYnTp1MvmMHTuWAwcOcPjwYXx8fAgNDSUmJoaMjAwOHjxITEwMNjY2yk7i0NBQAgICGDRoEF9++SU6nY5vvvmGV199tUqiua5n379/PzqdjvPnz6PX62nUqBGhoaHs2bPnjt5D27Ztad++fY2fW8s/REZGYm1tTVRUFNnZ2Xz++efMmzeP2NhY5VkzMjLw8fEhLy8PMO7w7dWrF61bt2bhwoX88ssvFBQUVNkxrNPpyMvLIzQ09I6eQwghhBBCCCHEfXbtIvxrErwfbkz4WjtA6OsQveu/pRwk4SvEb4kkfQVbtmzB1dUVrVZLeHg4u3btYunSpWzatAkLi7srUxEYGMj48eN5/vnncXJyYsGCBXe0joeHB+vXr2fDhg107tyZ5cuXM2PGDACsra1JTU3lwoULDB48uMpcT09PfH19SUpKAuDDDz/E2dmZoKAgBg8eTHR0NPb29kqdXZVKRVpaGkFBQYwePRovLy+GDh2KTqersyzCraZMmYKFhQUdOnTAycmJU6dOARATE0NKSkqdpSDulkajYdu2bZw5cwZ/f39efPFFYmNjiY2NVcZcu3aNnJwcZffw1q1b+emnn9i5cyetWrXC1dVV+dxq3bp19O3bt941hoUQQgghhBBCmMGxf8M7T8GB943tJ0fAy4fgmUlgIf8IXIjfIpWhpiKnwsTly5fRaDQUFxfj4OBgcq20tJSTJ0/i4eFxWwd0iXsjPj6eFStWcPr06bta58yZM7Ru3Zrt27fTu3fvexRdzQwGAz169GDSpEkMGzaswe93r5WVleHp6cm6det4+umnzR2OqIH8XhJCCCGEEEJw9byxlEP2Z8Z2C2/o93fw+J154xJC3LbacpK1kT/niIfGu+++S7du3WjevDlff/01CQkJvPTSS/VeZ+fOnZSUlODr60t+fj5Tp05Fq9USFBTUAFFXpVKpeO+99zhy5Mh9ud+9lpuby4wZMyThK4QQQgghhBAPKoMBvv8c0v4K186DqhEEvgy9poOVbAoR4lEgSV/x0Pjxxx+ZO3cuFy9epE2bNkyePJnp06fXe52Kigri4uL4+eefsbe3JzAwkLVr15ocgtbQ/Pz88PPzu2/3u5e8vLzu6BA6IYQQQgghhBD3QflV+CIWjqQY2y07wMB3wL2LeeMSQtxXUt7hNkl5ByHEw0R+LwkhhBBCCPGIuXYR9q+EjJVwvQhUFhA0BX43BSzV5o5OCHGHpLyDEEIIIYQQQgghxKOmrAR2vwmZq6HiqrGvaVsY9C5onzFvbEIIs5GkrxBCCCGEEEIIIcTDprICDqfA7reg+L8HnLfsaNzd22EgNLIwb3xCCLOSpK8QQgghhBBCCCHEw6QgCza+CAX/PSBc0wZ+/xZ4hUOjRuaNTQjxQJCkrxBCCCGEEEIIIcTDQK+H/Stgx+twoxQaa+CZWOgeDWo7c0cnhHiASNJXCCGEEEIIIYQQ4kF38j+wYw6cyTS2PcNg4NvQpKV54xJCPJAk6SuEEEIIIYQQQgjxoDp7EHbGw0/bjG0rOwibC11HgUpl3tiEEA8sKfQi7lh6ejoqlYpLly4pfRs3bqR9+/ZYWFgwadKkGudqtVqWLFlyP8J8IM2cOZOYmBil3atXr1rf14MkKyuLVq1acfXqVXOHIoQQQgghhBC/Xb8ch9SX4R+9jQnfRpbQLRr+71vwHy0JXyFErSTp+4iLiopCpVKhUqmwsrLC2dmZPn36sHr1avR6fa1zAwMDyc/PR6PRKH3jxo0jIiKC06dP88Ybb5CcnEzTpk2rzM3MzDRJet5r3t7eqNVq8vLyGuwedakpkXvu3DkSExOJi4tr8BiysrLo2bMnNjY2uLu7M2fOHAwGQ61zBgwYQJs2bWjcuDGurq6MGDGCs2fPKtd9fX3p3r07ixcvbujwhRBCCCGEEOLRU1kBmatgxTPw3QdgqISOg+EvGdBvITi4mTtCIcRDQJK+gvDwcPLz89HpdGzevJng4GAmTpxI//79uXHjRrVzKioqUKvVuLi4oPrvXxdLSkooLCwkLCwMNzc37O3ta7ynk5MTtra2DfI8e/bsobS0lCFDhpCcnNwg97gbSUlJBAQEoNVqb3tOeXl5ve9z+fJl+vTpg5ubG5mZmSxbtoyFCxeyaNGiWucFBwfzySefkJOTw2effcaJEyeIiIgwGTNq1CiWL19OZWVlveMSQgghhBBCCFGD/MPwtj/8ezJUlsFjwRD1bxiSDM3bmTs6IcRDRJK+DcBgMFBRWmqWT127OKtjbW2Ni4sL7u7udOnShbi4ODZt2sTmzZuVpKlKpWLFihUMHDgQOzs75s6da1LeIT09XUnyhoSEoFKpSE9PZ9SoURQXFyu7iWfPng1ULe+gUqlYtWoVgwcPxtbWFk9PT1JTU03iTE1NxdPTExsbG4KDg/nggw+qlJcAY1I1MjKSESNGsHr16irvJD8/n379+mFjY4OHhwcff/xxlXiKi4uJiYmhZcuWODg4EBISwuHDh5Xrs2fP5oknnmDNmjVotVo0Gg1Dhw7lypUrgHEH9e7du0lMTFSeXafTAZCSksKAAQNq/Z5otVrmzp1LVFQUGo2G6OjoOr6LVa1du5bS0lKSk5Pp1KkTzz77LHFxcSxatKjWn5NXXnmFHj160LZtWwIDA/nb3/7Gvn37qKioUMaEhYVx4cIFdu/eXe+4hBBCCCGEEEJU48in8P4foEgHdi0hbD4M3wDaZ8wdmRDiISQHuTWAG2VlLP1zRN0DG8DLH6zHqnHju14nJCQEPz8/NmzYwNixYwF47bXXmD9/PosXL8bCwoKTJ08q4wMDA8nJycHb25vPPvuMwMBAHB0dWbJkCbNmzSInJweAJk2a1HjP119/nQULFpCQkMCyZct44YUXyM3NxdHREZ1OR0REBBMnTmTs2LEcPHiQKVOmVFnjypUrfPrpp+zfvx8fHx+uXr1Keno6wcHBypiRI0dy/vx50tPTsbKyIjY2lsLCQuW6wWCgX79+ODo6kpaWhkajYeXKlfTu3Zvjx4/j6OgIwIkTJ9i4cSNffPEFRUVFPPfcc7z55pvEx8eTmJjI8ePH6dSpE3PmzAGMu5uLiorIzs7G39+/zu9BQkICM2fO5NVXX1X6OnbsSG5ubo1z2rZty/fffw/A3r176dmzJ9bW1sr1sLAwpk+fjk6nw8PDo84YLl68yNq1awkMDMTKykrpV6vV+Pn58dVXXxESElLnOkIIIYQQQgghanClADa+CCd2GNseQfD8R9BYU/s8IYSohSR9RY18fHw4cuSI0o6MjGT06NFK+9akr1qtpmXLlgA4Ojri4uICgEajQaVSKe3aREVFMWzYMADmzZvHsmXLyMjIIDw8nBUrVuDt7U1CQgJgrNmbnZ1NfHy8yRopKSl4enrSsWNHAIYOHUpSUpKS9D127Bjbt28nMzNTSbyuWrUKT09PZY1du3aRlZVFYWGhkjBduHAhGzduZP369UotYr1eT3JysrLDecSIEezYsYP4+Hg0Gg1qtRpbW1uTZ8/NzcVgMODmVncNppCQkCqJ7bS0NJMdt792a2K2oKCgSgkJZ2dn5VptSd9p06bx9ttvc+3aNXr06MEXX3xRZYy7u7uye1kIIYQQQgghxB04lgb/ehmu/gKNrODpl6FXHFhIukYIcXfkt0gDsLS25uUP1pvt3veKwWBQ6vUCt7U79W507txZ+drOzg57e3tlB25OTg7dunUzGd+9e/cqayQlJTF8+HClPXz4cIKCgrh06RJNmzYlJycHS0tLunTpooxp3749zZo1U9oHDhygpKSE5s2bm6x9/fp1Tpw4obS1Wq1J3WJXV1eTHcPVuX79OgCNb2M3dnXvu23btnXOu5XqV6e53izr8Ov+X/vrX//KmDFjyM3N5fXXX2fkyJF88cUXJvNsbGy4du1aveIRQgghhBBCCAFU3oCdc+DrRGPbuRNEvA9OXuaNSwjxmyFJ3wagUqnuSYkFc/vhhx9MdoPa2dk16P1u3aUKxveo1+uBqgnom323Onr0KPv37yczM5Np06Yp/ZWVlaxbt44JEybUWMv21n69Xo+rqyvp6elVxjVt2vS24q1JixYtACgqKsLJyanWsdW97/qUd3BxcaGgoMDk+s2k9M0dv7XF2aJFC7y8vHj88cdp3bo1+/btIyAgQBlz8eJF2rWTgwSEEEIIIYQQol5KCmFDNPycbmz3+Av0nglWNmYNSwjx2yJJX1GtnTt3kpWVxSuvvHJX66jVaiorK+86Hh8fH9LS0kz6vv32W5N2UlISQUFBvPPOOyb9a9asISkpiQkTJuDj48ONGzc4ePAgXbt2BeCnn34yOQyuS5cuFBQUYGlpWaU8Qn1U9+zt2rXDwcGBo0eP4uVV/7/g1qe8Q0BAAHFxcZSXl6NWqwHYunUrbm5u9XqumwnxsrIyk/7s7GwiIsxTu1oIIYQQQgghHjrl1+A/CZC5Csoug5UtDHwbOv3J3JEJIX6DGpk7AGF+ZWVlFBQUkJeXx3fffce8efMYOHAg/fv3Z+TIkXe1tlarpaSkhB07dnD+/Pk7Lgcwbtw4jh07xrRp0zh+/DiffPIJycnJgHGHbUVFBWvWrGHYsGF06tTJ5DN27FgOHDjA4cOH8fHxITQ0lJiYGDIyMjh48CAxMTHY2NgoO4lDQ0MJCAhg0KBBfPnll+h0Or755hteffXVKonmup59//796HQ6zp8/j16vp1GjRoSGhrJnz547eg9t27alffv2NX5uLf8QGRmJtbU1UVFRZGdn8/nnnzNv3jxiY2OVZ83IyMDHx4e8vDyl/fbbb3Po0CFyc3PZtWsXkZGRtGvXzmSXr06nIy8vj9DQ0Dt6DiGEEEIIIYR4pBRkwz+CYc8iY8LX1Q/GbpeErxCiwUjSV7BlyxZcXV3RarWEh4eza9culi5dyqZNm7CwsLirtQMDAxk/fjzPP/88Tk5OLFiw4I7W8fDwYP369WzYsIHOnTuzfPlyZsyYAYC1tTWpqalcuHCBwYMHV5nr6emJr68vSUlJAHz44Yc4OzsTFBTE4MGDiY6Oxt7eXqmzq1KpSEtLIygoiNGjR+Pl5cXQoUPR6XR1lkW41ZQpU7CwsKBDhw44OTlx6tQpAGJiYkhJSamzFMTd0mg0bNu2jTNnzuDv78+LL75IbGwssbGxyphr166Rk5Oj7B62sbFhw4YN9O7dG29vb0aPHk2nTp3YvXu3cqgdwLp16+jbt2+9awwLIYQQQgghxCNFr4f970FSH/jlGDRxhuc/guh0cO5o7uiEEL9hKkNNRU6FicuXL6PRaCguLsbBwcHkWmlpKSdPnsTDw+O2DugS90Z8fDwrVqzg9OnTd7XOmTNnaN26Ndu3b6d37973KLqaGQwGevTowaRJkxg2bFiD3+9eKysrw9PTk3Xr1vH000+bOxxRA/m9JIQQQgghhJkV58HG8XDyP8Z2uxB49h9g18K8cQkhHiq15SRrIzV9xUPj3XffpVu3bjRv3pyvv/6ahIQEXnrppXqvs3PnTkpKSvD19SU/P5+pU6ei1WoJCgpqgKirUqlUvPfeexw5cuS+3O9ey83NZcaMGZLwFUIIIYQQQoiaHPkEUl+GG9eNtXv7zAH/MdBI/sG1EOL+kKSveGj8+OOPzJ07l4sXL9KmTRsmT57M9OnT671ORUUFcXFx/Pzzz9jb2xMYGMjatWtNDkFraH5+fvj5+d23+91LXl5ed3QInRBCCCGEEEL85lVch22zIOM9Y9u9Kwx+D1q0N29cQohHjpR3uE1S3kEI8TCR30tCCCGEEELcZ3kHYOOLxtq9AM/EQshM2d0rhLgrUt5BCCGEEEIIIYQQwhwO/xNSX4LKcrBzgkHLwbOPuaMSQjzCJOkrhBBCCCGEEEIIcSf0lbBzLuxZZGx794OBb4Oto3njEkI88iTpK4QQQgghhBBCCFFf14tg/Wg4sdPYfuYVCJkl5RyEEA8ESfoKIYQQQgghhBBC1MfJr+Dz8XD5DFjZwh+XQuch5o5KCCEUkvQVQgghhBBCCCGEuB2VFbDzDfh6KWAAx8fgT6vAvau5IxNCCBOS9BVCCCGEEEIIIYSoy5UC+DQKTu01trtGQd94sG5izqiEEKJaUmhG3LH09HRUKhWXLl1S+jZu3Ej79u2xsLBg0qRJNc7VarUsWbLkfoT5QJo5cyYxMTFKu1evXrW+rwdJVlYWrVq14urVq+YORQghhBBCCCHuj9y9sDLImPC1doDnP4I/JkrCVwjxwJKk7yMuKioKlUqFSqXCysoKZ2dn+vTpw+rVq9Hr9bXODQwMJD8/H41Go/SNGzeOiIgITp8+zRtvvEFycjJNmzatMjczM9Mk6XmveXt7o1arycvLa7B71KWmRO65c+dITEwkLi6uwWPIysqiZ8+e2NjY4O7uzpw5czAYDLc1t6ysjCeeeAKVSsWhQ4eUfl9fX7p3787ixYsbKmwhhBBCCCGEeDAYDLBvOXzQH0rOgdPjEL0LHv+juSMTQohaSdJXEB4eTn5+Pjqdjs2bNxMcHMzEiRPp378/N27cqHZORUUFarUaFxcXVCoVACUlJRQWFhIWFoabmxv29vY13tPJyQlbW9sGeZ49e/ZQWlrKkCFDSE5ObpB73I2kpCQCAgLQarW3Pae8vLze97l8+TJ9+vTBzc2NzMxMli1bxsKFC1m0aNFtzZ86dSpubm7VXhs1ahTLly+nsrKy3nEJIYQQQgghxEOhsgI2/QW2/A30N6BTBETvgBbtzR2ZEELUSZK+DcBgMKAvrzTL53Z3cd7K2toaFxcX3N3d6dKlC3FxcWzatInNmzcrSVOVSsWKFSsYOHAgdnZ2OIOpOgAAIABJREFUzJ0716S8Q3p6upLkDQkJQaVSkZ6ezqhRoyguLlZ2E8+ePRuoWt5BpVKxatUqBg8ejK2tLZ6enqSmpprEmZqaiqenJzY2NgQHB/PBBx9UKS8BxqRqZGQkI0aMYPXq1VXeSX5+Pv369cPGxgYPDw8+/vjjKvEUFxcTExNDy5YtcXBwICQkhMOHDyvXZ8+ezRNPPMGaNWvQarVoNBqGDh3KlStXAOMO6t27d5OYmKg8u06nAyAlJYUBAwbU+j3RarXMnTuXqKgoNBoN0dHRdXwXq1q7di2lpaUkJyfTqVMnnn32WeLi4li0aFGdPyebN29m69atLFy4sNrrYWFhXLhwgd27d9c7LiGEEEIIIYR44F09Dx/9CQ6tBVUjCJtvPLBNbWfuyIQQ4rbIQW4NwFCh5+ysb8xyb7c5gajUFne9TkhICH5+fmzYsIGxY8cC8NprrzF//nwWL16MhYUFJ0+eVMYHBgaSk5ODt7c3n332GYGBgTg6OrJkyRJmzZpFTk4OAE2a1Fzv6PXXX2fBggUkJCSwbNkyXnjhBXJzc3F0dESn0xEREcHEiRMZO3YsBw8eZMqUKVXWuHLlCp9++in79+/Hx8eHq1evkp6eTnBwsDJm5MiRnD9/nvT0dKysrIiNjaWwsFC5bjAY6NevH46OjqSlpaHRaFi5ciW9e/fm+PHjODo6AnDixAk2btzIF198QVFREc899xxvvvkm8fHxJCYmcvz4cTp16sScOXMA4+7moqIisrOz8ff3r/N7kJCQwMyZM3n11VeVvo4dO5Kbm1vjnLZt2/L9998DsHfvXnr27Im1tbVyPSwsjOnTp6PT6fDw8Kh2jXPnzhEdHc3GjRtr3I2tVqvx8/Pjq6++IiQkpM5nEUIIIYQQQoiHRt538MlIKD4NVnYw5H3wCjN3VEIIUS+S9BU18vHx4ciRI0o7MjKS0aNHK+1bk75qtZqWLVsC4OjoiIuLCwAajQaVSqW0axMVFcWwYcMAmDdvHsuWLSMjI4Pw8HBWrFiBt7c3CQkJgLFmb3Z2NvHx8SZrpKSk4OnpSceOHQEYOnQoSUlJStL32LFjbN++nczMTCXxumrVKjw9PZU1du3aRVZWFoWFhUrCdOHChWzcuJH169crtYj1ej3JycnKDucRI0awY8cO4uPj0Wg0qNVqbG1tTZ49NzcXg8FQY9mEW4WEhFRJbKelpVFRUVHjHCsrK+XrgoKCKiUknJ2dlWvVJX0NBgNRUVGMHz8ef39/ZXdyddzd3Wu9LoQQQgghhBAPFb0eDrwPW6ZDZRk4toOha6Hl4+aOTAgh6k2Svg1AZdUItzmBZrv3vWIwGJR6vcBt7U69G507d1a+trOzw97eXtmBm5OTQ7du3UzGd+/evcoaSUlJDB8+XGkPHz6coKAgLl26RNOmTcnJycHS0pIuXbooY9q3b0+zZs2U9oEDBygpKaF58+Yma1+/fp0TJ04oba1Wa1K32NXV1WTHcHWuX78OQOPGjWsdB9W/77Zt29Y571a3fv8ApazDr/tvWrZsGZcvX2b69Ol1rm1jY8O1a9fqFY8QQgghhBBCPJCunIPPx8HPu4xt7z/A4BXQWFP7PCGEeECZtabv8uXL6dy5Mw4ODjg4OBAQEMDmzZuV6waDgdmzZ+Pm5oaNjQ29evVS/un6TWVlZfzf//0fLVq0wM7OjgEDBnDmzBmTMUVFRYwYMQKNRoNGo2HEiBFV6sDeSyqVikZqC7N8akrm3YkffvjBZDeonV3D1i66dZcqGN+jXq8Hqiagb/bd6ujRo+zfv5+pU6diaWmJpaUlPXr04Pr166xbt67aOdWtpdfrcXV15dChQyafnJwc/vrXv95WvDVp0aIFYPyZrEt177tjx440adKkxs/NHc4ALi4uFBQUmMy/mZS+ueP313bu3Mm+ffuwtrbG0tKS9u2NBxT4+/vz5z//2WTsxYsXcXJyqvM5hBBCCCGEEOKB9uM2WB5oTPha2kDYPHh+rSR8hXhAFRSXsnL3Cc5dLjV3KA80s+70bdWqFW+++aaSWPrggw8YOHAgBw8epGPHjixYsIBFixaRnJyMl5cXc+fOpU+fPuTk5Cg7LCdNmsS//vUvUlJSaN68OZMnT6Z///4cOHAACwtjbdvIyEjOnDnDli1bAIiJiWHEiBH861//Ms+DPwR27txJVlYWr7zyyl2to1arqaysvOt4fHx8SEtLM+n79ttvTdpJSUkEBQXxzjvvmPSvWbOGpKQkJkyYgI+PDzdu3ODgwYN07doVgJ9++snkjwBdunShoKAAS0vLKuUR6qO6Z2/Xrh0ODg4cPXoULy+veq9Zn/IOAQEBxMXFUV5ejlqtBmDr1q24ubnV+FxLly5l7ty5Svvs2bOEhYXxz3/+k6eeespkbHZ2NhEREfV+BiGEEEIIIYR4INwogx1zYO/bxrZzJ4hYDU7e5o1LCFGt8ht6kvacZOmOH7leUYnashGjnq7+vCJh5qTvH//4R5N2fHw8y5cvZ9++fXTo0IElS5YwY8YMnn32WcCYFHZ2dubjjz9m3LhxFBcXk5SUxJo1awgNDQXgo48+onXr1mzfvp2wsDB++OEHtmzZwr59+5Sk1T/+8Q8CAgKUg8eqU1ZWRllZmdK+fPlyQ7yCB0JZWRkFBQVUVlZy7tw5tmzZwvz58+nfvz8jR468q7W1Wi0lJSXs2LEDPz8/bG1tazwcrDbjxo1j0aJFTJs2jTFjxnDo0CGSk5MB4w7biooK1qxZw5w5c+jUqZPJ3LFjx7JgwQIOHz6Mn58foaGhxMTEsHz5cqysrJg8eTI2NjbKTuLQ0FACAgIYNGgQb731Ft7e3pw9e5a0tDQGDRp022UutFot+/fvR6fT0aRJExwdHWnUqBGhoaHs2bOHQYMG1fs91Ke8Q2RkJK+//jpRUVHExcXx448/Mm/ePGbNmqU8a0ZGBiNHjmTHjh24u7vTpk0bkzVuHrzXrl07WrVqpfTrdDry8vKU/+6EEEIIIYQQ4qFy7ihsHA/5h43t7uOgzxywqrsUnxDi/rpcWsGavbmkZJ7i9EVj2cwnWjelVbP655ceJWYt73CryspKUlJSuHr1KgEBAZw8eZKCggL69u2rjLG2tqZnz5588803gLH2akVFhckYNzc3OnXqpIzZu3cvGo3GZJdijx490Gg0ypjqzJ8/XykHodFoaN269b1+5AfGli1bcHV1RavVEh4ezq5du1i6dCmbNm1SdkvfqcDAQMaPH8/zzz+Pk5MTCxYsuKN1PDw8WL9+PRs2bKBz584sX76cGTNmAMafi9TUVC5cuMDgwYOrzPX09MTX15ekpCQAPvzwQ5ydnQkKCmLw4MFER0djb2+v1NlVqVSkpaURFBTE6NGj8fLyYujQoeh0uhrLIlRnypQpWFhY0KFDB5ycnDh16hRg3GmekpJSZymIu6XRaNi2bRtnzpzB39+fF198kdjYWGJjY5Ux165dIycnp9bdw9VZt24dffv2rXeNYSGEEEIIIYQwK70eMv4B7/U0JnxtHGFYCvxhgSR8hXjAnL54jZkbs+m5YBcJX+Zw+uJ1mtup+fsQPz5/MZA+HW4/R/MoUhlqKnJ6n2RlZREQEEBpaSlNmjTh448/5g9/+APffPMNTz/9NHl5ebi5uSnjY2JiyM3N5csvv+Tjjz9m1KhRJjtyAfr27YuHhwcrV65k3rx5JCcnc/z4cZMxXl5ejBo1qsYDq6rb6du6dWuKi4txcHAwGVtaWsrJkyfx8PC4rQO6xL0RHx/PihUrOH369F2tc+bMGWV3eO/eve9RdDUzGAz06NGDSZMmMWzYsAa/371WVlaGp6cn69at4+mnnzZ3OKIG8ntJCCGEEEKIX7l0GjZOAN1Xxnb7UBiwDBzcap8nhLivjpy5xPL0E+z4oZDySuOGuXZOdozv2Y4/+LpiZ23WwgX33eXLl9FoNNXmJGtj9rfk7e3NoUOHuHTpEp999hl//vOf2b17t3K9usO76jqs7Ndjqhtf1zrW1tZYW1vf7mOI++Ddd9+lW7duNG/enK+//pqEhAReeumleq+zc+dOSkpK8PX1JT8/n6lTp6LVagkKCmqAqKtSqVS89957HDly5L7c717Lzc1lxowZkvAVQgghhBBCPByuF8GeJbB/BdwoBSs76D0LukdDo7v7161CiHvnW91FEnf8yFc/nlf6nmnfgjHPePA7zxZYWjwwBQseCmZP+qrVauUgN39/fzIzM0lMTGTatGkAFBQU4OrqqowvLCxU/om9i4sL5eXlFBUV0axZM5MxgYGByphz585Vue8vv/xSr3+qL8zvxx9/ZO7cuVy8eJE2bdowefLkGndq16aiooK4uDh+/vln7O3tCQwMZO3atSaHoDU0Pz8//Pz87tv97iUvL687OoROCCGEEEIIIe6rG+XwdSJ8swzKio19bZ+BPyZCi/bmjU0IARg3Ze79+QLv7jrBnp+MyV6VCgY94U707x6jg9vt72wVpsye9P01g8FAWVkZHh4euLi4sG3bNp588kkAysvL2b17N2+99RYAXbt2xcrKim3btvHcc88BkJ+fT3Z2tlI7NiAggOLiYjIyMujevTsA+/fvp7i4WEkMi4fD4sWLWbx48V2vExYWRlhY2D2ISAghhBBCCCHEA6nwGGyIhoL//gvLlh2h90zwCjdmlIQQZnWjUs/eny/wzq6f2PfzRQAsG6kY4t+aCT3b0aa5HNJ2t8ya9I2Li+P3v/89rVu35sqVK6SkpJCens6WLVtQqVRMmjSJefPm4enpiaenJ/PmzcPW1pbIyEjAeFDVmDFjmDx5Ms2bN8fR0ZEpU6bg6+tLaGgoAI8//jjh4eFER0ezcuVKwFgXuH///nh7e5vt2YUQQgghhBBCCHGP6fXGMg7bZ0NlGdg0g/C3wDdCSjkIYWbXym+wO+cXth09x66cQoquGQ+VV1s0Yoh/K8b3bEdrR0n23itmTfqeO3eOESNGkJ+fj0ajoXPnzmzZsoU+ffoAMHXqVK5fv86LL75IUVERTz31FFu3bsXe3l5ZY/HixVhaWvLcc89x/fp1evfuTXJyMhYW//tlvnbtWl5++WX69u0LwIABA3j77bfv78MKIYQQQgghhBCi4fy0HXbMgfzDxnb7PjDwbbB3MW9cQjzirpRW8M/M06zY/TPnS8qU/qa2Vgzwc2Ncz3a4N7UxY4S/TSqDwWAwdxAPg9pOyistLeXkyZN4eHjQuHFjM0UohBD/I7+XhBBCCCHEI6OiFHa+AXv/u7nLyhb6zgX/0VLKQQgzMRgMHD5TzEf7cvn3kXyuV1QC4OLQmD/4utK3ozP+bZvJ4Wy3obacZG0euJq+QgghhBBCCCGEEHXS6+G7D+A/CXA5z9jXbSz0nAZNWpo3NiEeUVfLbrDhYB4pGaf4/uxlpb99yyaMecaDP3VphdpSEr33gyR9hRBCCCGEEEII8XAp+QVS/w+Obza2m7jAH5eA9+/NG5cQjyCDwcCB3CI++fY0XxzJ51q5cVev2rIR/X1diXyqDV3bNkMlO+/vK0n6CiGEEEIIIYQQ4uFQWgzfrYFvlkLJObCwhtDXwH8MWElZMyHup8LLpXz2XR6ffnuan89fVfofa2HHCz3a8uyT7jSzU5sxwkeb7KcWdyw9PR2VSsWlS5eUvo0bN9K+fXssLCyYNGlSjXO1Wi1Lliy5H2E+kGbOnElMTIzS7tWrV63v60GSlZVFq1atuHr1at2DhRBCCCGEEOJeOfZveDcQts4wJnydfGDMlxDwF0n4CnGflN/QsyW7gDHJmQS8uZO3thzj5/NXsVVb8Jx/K9aPD2DH5J6MecZDEr5mJknfR1xUVBQqlQqVSoWVlRXOzs706dOH1atXo9fra50bGBhIfn4+Go1G6Rs3bhwRERGcPn2aN954g+TkZJo2bVplbmZmpknS817z9vZGrVaTl5fXYPeoS02J3HPnzpGYmEhcXFyDx5CVlUXPnj2xsbHB3d2dOXPmUNfZjVqtVvmZuPn529/+plz39fWle/fuLF68uKHDF0IIIYQQQgi4eBLWPAspkXD5DGjaQP/FEL0L3J40d3RCPBJ+KizhjS+OEjB/B+M/OsCOY4VU6g100zZjQURnMmeEsiDCD3+to5RxeEBIeQdBeHg477//PpWVlZw7d44tW7YwceJE1q9fT2pqKpaWVX9MKioqUKvVuLi4KH0lJSUUFhYSFhaGm5tbrfd0cnK6589x0549eygtLWXIkCEkJyczY8aMBrvXnUhKSiIgIACtVnvbc8rLy1Gr6/cXssuXL9OnTx+Cg4PJzMzk+PHjREVFYWdnx+TJk2udO2fOHKKjo5V2kyZNTK6PGjWK8ePHM336dCwsLOoVlxBCCCGEEELclisFsGcJZLwHhkpoZAWB/wdBfwW1rbmjE+KRkHHyIu/95wTbfyhU+lraW/Onrq0Y0rUVjzk1qWW2MCfZ6dsADAYD5eXlZvnUtYuzOtbW1ri4uODu7k6XLl2Ii4tj06ZNbN68meTkZABUKhUrVqxg4MCB2NnZMXfuXJPyDunp6djb2wMQEhKCSqUiPT2dUaNGUVxcrOwYnT17NlC1vINKpWLVqlUMHjwYW1tbPD09SU1NNYkzNTUVT09PbGxsCA4O5oMPPqhSXgKMSdXIyEhGjBjB6tWrq7yT/Px8+vXrh42NDR4eHnz88cdV4ikuLiYmJoaWLVvi4OBASEgIhw8fVq7Pnj2bJ554gjVr1qDVatFoNAwdOpQrV64Axh3Uu3fvJjExUXl2nU4HQEpKCgMGDKj1e6LVapk7dy5RUVFoNBqTBOztWrt2LaWlpSQnJ9OpUyeeffZZ4uLiWLRoUZ0/J/b29ri4uCifXyd9w8LCuHDhArt37653XEIIIYQQQghRq4pS2PoqLPGF/cuNCd/HguEv+431eyXhK0SDKSm7wd4TF5iX9gMD3t7Dcyv3sv2HQlQqCH3cmdVR/nzztxCmhftIwvcBJzt9G0BFRQXz5s0zy73j4uLqvSO0OiEhIfj5+bFhwwbGjh0LwGuvvcb8+fNZvHgxFhYWnDx5UhkfGBhITk4O3t7efPbZZwQGBuLo6MiSJUuYNWsWOTk5QNUdo7d6/fXXWbBgAQkJCSxbtowXXniB3NxcHB0d0el0REREMHHiRMaOHcvBgweZMmVKlTWuXLnCp59+yv79+/Hx8eHq1aukp6cTHBysjBk5ciTnz58nPT0dKysrYmNjKSz831+sDAYD/fr1w9HRkbS0NDQaDStXrqR3794cP34cR0dHAE6cOMHGjRv54osvKCoq4rnnnuPNN98kPj6exMREjh8/TqdOnZgzZw5g3N1cVFREdnY2/v7+dX4PEhISmDlzJq+++qrS17FjR3Jzc2uc07ZtW77//nsA9u7dS8+ePbG2tlauh4WFMX36dHQ6HR4eHjWu89Zbb/HGG2/QunVrhgwZwl//+leTnyu1Wo2fnx9fffUVISEhdT6LEEIIIYQQQtRJr4ecf8PWmVD03/+/2fop6DkV2oeaNzYhfsNKym7wxeGzpGSe5siZS+hv2SdmZaEiomtrxv7Og3aS5H2oSNJX1MjHx4cjR44o7cjISEaPHq20b036qtVqWrZsCYCjo6NS9kGj0aBSqUzKQNQkKiqKYcOGATBv3jyWLVtGRkYG4eHhrFixAm9vbxISEgBjzd7s7Gzi4+NN1khJScHT05OOHTsCMHToUJKSkpSk77Fjx9i+fTuZmZlK4nXVqlV4enoqa+zatYusrCwKCwuVhOnChQvZuHEj69evV2oR6/V6kpOTlR3OI0aMYMeOHcTHx6PRaFCr1dja2po8e25uLgaDoc7yF2BMvP86sZ2WlkZFRUWNc6ysrJSvCwoKqpSQcHZ2Vq7VlPSdOHEiXbp0oVmzZmRkZDB9+nROnjzJqlWrTMa5u7sru5eFEEIIIYQQ4o4ZDPDjNtj+GhQeNfbZuxrr9nr/3ryxCfEbda38Bv85/gu7j58n9VAeV8srlWst7a0JaNecHo81J8jLCfemNmaMVNwpSfo2ACsrq/tySFdN975XDAaDSfHt29mdejc6d+6sfG1nZ4e9vb2yAzcnJ4du3bqZjO/evXuVNZKSkhg+fLjSHj58OEFBQVy6dImmTZuSk5ODpaUlXbp0Uca0b9+eZs2aKe0DBw5QUlJC8+bNTda+fv06J06cUNparVZJ+AK4urqa7BiuzvXr1wFo3Ljuk2Wre99t27atc96tfl08/WZZh9qKqr/yyivK1507d6ZZs2ZERETw1ltvmbwTGxsbrl27Vq94hBBCCCGEEEKhr4QTO+E/CXB6v7HP2gG6R8PTk6Cxg3njE+I35kalnm9OXGDjoTy2HT3HldIbyrXHWtjxXLfWhHV0QdvcVg5j+w2QpG8DUKlU96TEgrn98MMPJrtB7ezsGvR+v05Yq1Qq9Ho9UDUBfbPvVkePHmX//v1kZmYybdo0pb+yspJ169YxYcKEGmvZ3tqv1+txdXUlPT29yrimTZveVrw1adGiBQBFRUV1HmZX3fuuT3kHFxcXCgoKTK7fTErf3PF7O3r06AHATz/9ZJL0vXjxIu3atbvtdYQQQgghhBBCcWKXsYzDuSxj27KxMdn7u8lg06z2uUKIeimtqGTDd3m8958T6C78b/OWq6Yxvbyd6OfrxtPtm0ui9zdGkr6iWjt37iQrK8tk1+edUKvVVFZW1j2wDj4+PqSlpZn0ffvttybtpKQkgoKCeOedd0z616xZQ1JSEhMmTMDHx4cbN25w8OBBunbtChiTmbceBtelSxcKCgqwtLSsUh6hPqp79nbt2uHg4MDRo0fx8vKq95r1Ke8QEBBAXFwc5eXlyh8htm7dipubW72e6+DBg4BxJ/OtsrOziYiIqEf0QgghhBBCiEeavhKOb4F9y0H3lbHPWgNPDINnXgH7ussCCiFuj15vYN/JC2w6eJa0rHyulBl39TazteIPvq707+zGUx6ONGokid7fKkn6CsrKyigoKKCyspJz586xZcsW5s+fT//+/Rk5cuRdra3VaikpKWHHjh34+flha2uLrW39T1odN24cixYtYtq0aYwZM4ZDhw6RnJwMGHfYVlRUsGbNGubMmUOnTp1M5o4dO5YFCxZw+PBh/Pz8CA0NJSYmhuXLl2NlZcXkyZOxsbFR/qIVGhpKQEAAgwYN4q233sLb25uzZ8+SlpbGoEGDbrvMhVarZf/+/eh0Opo0aYKjoyONGjUiNDSUPXv2MGjQoHq/h/qUd4iMjOT1118nKiqKuLg4fvzxR+bNm8esWbOUZ83IyGDkyJHs2LEDd3d39u7dy759+wgODkaj0ZCZmckrr7zCgAEDaNOmjbK2TqcjLy+P0FA5TEEIIYQQQghRh8JjcHANHE2F4lPGvkaW0C3aeEibraN54xPiN+T0xWv8M/M06w+coeByqdLv4tCYsb/zYFj3NthZSzrwUdDI3AEI89uyZQuurq5otVrCw8PZtWsXS5cuZdOmTVhYWNzV2oGBgYwfP57nn38eJycnFixYcEfreHh4sH79ejZs2EDnzp1Zvnw5M2bMAMDa2prU1FQuXLjA4MGDq8z19PTE19eXpKQkAD788EOcnZ0JCgpi8ODBREdHY29vr9TZValUpKWlERQUxOjRo/Hy8mLo0KHodLp6lUWYMmUKFhYWdOjQAScnJ06dMv6Pm5iYGFJSUuosBXG3NBoN27Zt48yZM/j7+/Piiy8SGxtLbGysMubatWvk5OQou4etra355z//Sa9evejQoQOzZs0iOjqadevWmay9bt06+vbtW+8aw0IIIYQQQohHRPlVOLgWkvrCu0/B3reNCV+bZsZdvS8fgt+/KQlfIe6B8ht6/v3/7N13eJX1/cbx98nJJCQnBLIJIUCI7L33kKGIe6EoVau2iqWIWrVat1W7bK2jzmpVtNYBCggyghBm2CtAdsgghORkkHGS8/z+eH6Gpi6ICU/G/bour/p8z5OT+/Qiwdz5ns93Ty5zX9/CuGfX8sLao+SVVBLo68m1w6N5/+cjSfzNZG4Z102FbxtiM75vyKnUU1JSgsPhwOl0EhhYf5h8ZWUlaWlpxMbGntEBXdI4nnzySV5++WWysrJ+0vNkZ2cTHR3NV199xZQpUxop3fczDIORI0eyYMECrr322ib/fI2tqqqKuLg43n//fcaMGWN1HPke+r4kIiIiIudcUTocXgmZiXB0NVSVmOs2O8TPhH5XQtw08D77d3+KyLeVVrpYvjePP65KJr+kqm59XFwnrh3ehSm9QvHx/Gmb+cR6P9RJ/hDV+9JivPjiiwwbNoyOHTuyceNGnnvuOe68886zfp41a9ZQVlZGv379yM3N5d5776Vr166MHz++CVJ/m81m4x//+Ad79uw5J5+vsWVkZPDggw+q8BUREREREagogh3vwM5/wYnk+o916AqDb4CB12ler0gjKql08caGNF7fkEZppTmrNyTAh6uHRnP1sGiig/WLFVHpKy3IkSNHeOKJJzh58iRdunTh7rvv5v777z/r53G5XDzwwAOkpqYSEBDA6NGjeffdd+sdgtbUBgwYwIABA87Z52tMPXv2bNAhdCIiIiIi0opUFMH6P8D2N8FVbq7Z7BAzGmInmP/bZRR4aKqkSGMprXTx1sZ0Xv06lZL/L3tjO/lz+eAobhobSztv1XxymsY7nCGNdxCRlkTfl0RERESkSdS6YNvrkPB7s/gFCOsLw38OvS8BvyBr84m0QgWlVXy26xh/X3uUolPmmTxxoe351dQ4LugbgYeHzeKE0pQ03kFEREREREREmkatC3a9Z+7udZqHVBPaG85/DHpMBZtKJ5HGZBgG6w4X8NrXqWw8Wli33i3EnwVTe3JhvwjsKnvlB6j0bURut9vqCCIigPkfCCIiIiIijSI1AZbdc3pmb7uOMPkhGDQX7KoVRBpTdY36tkCMAAAgAElEQVSblQfyeO3rNHZlFdet94oI5IZRMVw5pDOedo1NkR+n786NwNvbGw8PD3JycggJCcHb2xubfsspIhYxDIOCggJsNts5nVUtIiIiIq2MMxu+fBAOfGpet+sEY38NQ28Cbx0UJdKYXLVuPtuVw9/WHCGj8BQAvl4eXDu8CzeNidXhbHLWVPo2Ag8PD2JjY8nNzSUnJ8fqOCIi2Gw2OnfujN1utzqKiIiIiLQ0rgrY/gasfgxqKgEbDLkRpvwO2gVbnU6kVal01fLpzmO8uC6FzJNm2dupvQ9XD+vMjaO7EhqgM1qkYVT6NhJvb2+6dOlCTU0NtbW1VscRkTbOy8tLha+IiIiInJ3qcvOQtsS/QnmBuRYzBmb8HiL6W5tNpJU5UVbF25syeG9LBifKqgHo1N6bm8d2Y+6oGNr7qLKTn0Z/ghrRN2+l1tupRUREREREpMU4dRJ2vG2Wvaf+/8AoRzSMXQBDbgIPzQ8VaSyVrlpeSUjlpYSjVLrMs6EiHL78bExXrh8ZQztvVXXSOPQnSURERERERKStcbshLQF2vgMHP4faKnO9QyyMXwT9rwa7NjSJNJaT5dW8uzmDtzdnUFBqfr317+zg5+O6MaNvOF46nE0amUpfERERERERkbaipgq2vgpbX4HizNPrYf1g5C/+v+xVVSDSWI6XVvLq+lT+tTmTCpc5DjTC4cu9M+K5ZGAUNpvN4oTSWuk7uYiIiIiIiEhrV5oHBz6D7W9CwUFzzccB/a6AwXMhYiCofBJpNK5aNx9uz+KJzw/Wlb19IgO5eWwss/pH4u2pnb3StFT6ioiIiIiIiLRGbjekrzd39iYvA8OcH0q7jjDlYXNXr5eftRlFWhm32+CLvbn8cWUy6YWnABgQHcSCKXFMjA/Rzl45Z1T6ioiIiIiIiLQWhgEFyXB4BWx/vf4Ih87D4bwLYMAcCAizLqNIK1RT62ZjSiHPLD/EgdwSADr6e/OLid352ZhY7B4qe+XcUukrIiIiIiIi0pI5syEjEVLWQuo6KM05/ZhPIPS9HEbcBqG9LIso0loVn6rm053HeG1DGtlFFQAE+Hhyy7hu3DwulvY+qt7EGvqTJyIiIiIiItLSHD8E+z6Cw19C3p76j9l9oMsI6HsF9LsSvNtZk1GklTIMg23pRbyzOYMv9+VRXWuOTnH4eXHJwEjumhJHx/Y+FqeUtk6lr4iIiIiIiEhLUJoH+z6G3e/XL3ptdgjrDd0mQfdJ0GWUZvWKNIGT5dW8viGVT3fmcKy4om69d0Qg1wyP5soh0fh52y1MKHKaSl8RERERERGR5ixvLyQ8C4c+P30Ym80D4qabM3p7zoT2IdZmFGnFSipdvLY+ldc3pFFeXQuAv7edWf0jmTsqhr5RDosTinybSl8RERERERGR5qa6HI6shO1vQlrC6fXIQTBoLpw3S4exiTQxwzBYsS+PR5buJ7+kCoA+kYHcPqE75/cOw9dLu3ql+VLpKyIiIiIiItJc1LrMonftE1DpNNdsduhzCYxbZI5xEJEml1JQxqNLD7D+cAEAsZ38uW/GeUzvE4bNZrM4nciPU+krIiIiIiIiYjV3LexeDAnPQHGGuRYYBf2vgiE/gw4x1uYTaSOS80r56+ojLN+Xi9sAb7sHt0/oxi8n9dDOXmlRVPqKiIiIiIiIWClnJ3x2J+TvM6/bdYKJv4GhN4GHSiaRc2FvtpNXv07li7251LoNAKb2CuXBC3sT28nf4nQiZ0+lr4iIiIiIiIgVaqpg3e9h4/Ng1IKXP0y8D4bdAt4qmUTOhcKyKh7//ACf7sqpW5t8XigLz++pA9qkRVPpKyIiIiIiInKuZW+Hpb86vbu3z2Uw42kICLc2l0gbUes2WLwtk2dXJOOscOFhg9kDIrlpbCz9OwdZHU/kJ1PpKyIiIiIiInKuVJXC6sdh6z8AA/yC4aLnofdsq5OJtAmGYbDxaCFPLjvIwdwSAHpFBPL7y/oxIFplr7QeKn1FREREREREmpphmAe1rXkCSrLNtQHXwrQnwL+TtdlE2ogdmUU8s/wQW9JOAhDo68mCqT25YVQMnnYPi9OJNC6VviIiIiIiIiJNqTQflsyHI1+a10ExcNFfoPtka3OJtAGGYbA728krCSks35cHgLenB3OGd+GuKXEE+3tbnFCkaaj0FREREREREWkKZQXmGIdNL4DrFNh9zIPaRtyug9pEzoHEoyf465ojbE41d/babHDF4M78+vyeRAb5WZxOpGmp9BURERERERFpTJmbzaI3eTm4a8y1qKEw+68Q1sfabCJtQEV1LQ9/to9/J5mjVLztHswaEMFt47sTHx5gcTqRc0Olr4iIiIiIiEhjyN0D634PyV+cXoscBGN/Db1mm9sMRaTJlFfVsGxvLn9dc4SskxV42OC6ETHcPrE7UdrZK22MSl8RERERERGRn+LEEdjwZ9j1HmCAzQMGXW+OcdDOXpEmV+mq5a3EdF5OSKH4lAuAsEAf/nL1IEZ172hxOhFrqPQVERERERERaYjCFNjwJ7PsNdzmWu+LYfy9EN7X2mwibcSGIyd4+LN9pJ4oByAqyI/rRnZh3uiutPNW7SVtl/70i4iIiIiIiJyNwhTY+DzsfOd02Rt/gTnGIXq4tdlE2ojD+aU8u+IQXx08DkBIgA/3To/n0kFReNo9LE4nYj2VviIiIiIiIiJnojDl9BgHo9Zci5sO4xZCl5HWZhNpI5ynXLyUkMIbG9OornFjs8H1I2K4Z0Y8gb5eVscTaTZU+oqIiIiIiIj8kJOpsO4Z2PMBYJhrPabCuLshZrSl0UTaiqqaWt7YkM6L645SWlkDwISeIfzuot50C2lvcTqR5kelr4iIiIiIiMh3qSqFhGdh84vgNksmekyFCfdpjIPIObTmUD6PLT1AeuEpAOLDArh3RjyTzwvFZrNZnE6keVLpKyIiIiIiIvLf3G7Ysxi+ehTK8sy1HlNh8m8hcpC12UTakJSCMp784iBrDp2e2/ubGedx6aAoPDxU9or8EJW+IiIiIiIiIgCGAYdXwPo/wLHt5lpQDFzwHPScbm02kTbEecrF39cd5fUNadS6DbzsNm4aE8v8KXG091GVJXIm9JUiIiIiIiIiUlEES38FBz4zr738YcK9MPIX4OljbTaRNqLSVcu/NmfwtzVHcVa4AJgUH8JvZ/Wmu+b2ipwVlb4iIiIiIiLSth1eCV8sBGcWeHjCsJ/D6PngiLI6mUibUF3j5tNdx/jr6iNkF1UA0DOsPffNOI8pvcIsTifSMqn0FRERERERkbbJVQlf3g/b3zCvO8TCFa9D1BBrc4m0IVvTTnL/x3tIKSgHIMLhy6+mxHHl0Gjsmtsr0mAqfUVERERERKTtyd8P/7kFjh8AbDDidpj0APgGWp1MpE3ILjrF08sP8cWeXAA6tffm5rHduHF0DO28VVeJ/FT6KhIREREREZG2w+2GLS/BV49AbTX4h8DFL0LPaVYnE2kTDuSU8MG2TN7flkV1jRsPG1wzvAv3To8nqJ231fFEWg2VviIiIiIiItI2lOTAF4sg+QvzuucMmP0CtA+xNpdIK1fpquWjpGw+2JbF3mPOuvVR3Try4IW96BvlsDCdSOuk0ldERERERERaN8OApLdg5UNQXQp2H5jxNAy9CWyaGSrSVPJLKlm6O4dXv04lv6QKAC+7jfN7hzFneAxjenTEpq9BkSah0ldERERERERar6J0WDIf0tab11FD4II/QNRgS2OJtFbFp6r5KCmbJbtz2JN9eldvVJAfPxvTlUsHRdGxvY+FCUXaBpW+IiIiIiIi0vq4ayHpTVj5MLjKwdMPpjxkHtjmYbc6nUirk1JQxjubMvgoKZuyqpq69f6dHVw9LJorhnTGx1NfeyLnioeVn/zpp59m2LBhBAQEEBoayiWXXEJycnK9e+bNm4fNZqv3z8iRI+vdU1VVxfz58+nUqRP+/v7Mnj2b7OzsevcUFRUxd+5cHA4HDoeDuXPnUlxc3OSvUURERERERM6xgmR4eSx8cbdZ+MaMhV9shFF3qPAVaUQ1tW5W7Mvj+te2MOWPCbyVmE5ZVQ3nhQfw+CV92fbgVJbcOZbrRsSo8BU5xyzd6ZuQkMAdd9zBsGHDqKmp4cEHH2TatGkcOHAAf3//uvtmzJjBm2++WXft7V3/NMcFCxawdOlSFi9eTMeOHbn77ruZNWsWSUlJ2O3mN5U5c+aQnZ3NihUrALj11luZO3cuS5cuPQevVERERERERJqcuxZ2vgMrHjDLXp9AmHAfjPwleFi650mkVSkoreKDbZm8tyWTHGclYI7HnnJeKNePjGF8XAgeHprVK2Ilm2EYhtUhvlFQUEBoaCgJCQmMHz8eMHf6FhcX8+mnn37nxzidTkJCQnjnnXe4+uqrAcjJySE6Opply5Yxffp0Dh48SO/evdm8eTMjRowAYPPmzYwaNYpDhw4RHx//reetqqqiqqqq7rqkpITo6GicTieBgYGN/dJFRERERETkp8jcAssWQd4e87rrOLjiDWgfam0ukVbC7TbYcPQEH2zPYuX+PFy1Zp0U7O/N1cOimTO8C9HB7SxOKdL6lJSU4HA4zrqTbFYzfZ1Oc8B3cHBwvfV169YRGhpKUFAQEyZM4MknnyQ01PyLOykpCZfLxbRp0+ruj4yMpG/fviQmJjJ9+nQ2bdqEw+GoK3wBRo4cicPhIDEx8TtL36effppHH320KV6miIiIiIiINJbqclj1O9j2qnnt64Dx98LIX2iUg0gjqKqp5fPdubyyPoXD+WV16wOjg7hhVAwX9IvA10tfayLNTbMpfQ3DYOHChYwdO5a+ffvWrc+cOZMrr7ySmJgY0tLSeOihh5g8eTJJSUn4+PiQl5eHt7c3HTp0qPd8YWFh5OXlAZCXl1dXEv+30NDQunv+1/3338/ChQvrrr/Z6SsiIiIiIiLNRMYm+PQXUJRmXg+8DqY+ot29Io2g+FQ1byWm86/NmZwoM98J3d7Hk8sHR3Hl0Gj6RjksTigiP6TZlL533nkne/bsYcOGDfXWvxnZANC3b1+GDh1KTEwMX3zxBZdddtn3Pp9hGNhsp+fH/Pe/f989/83HxwcfH5+zfRkiIiIiIiLS1CpLIOEZ2PR3wIDAKJj9N+gxxepkIi1efkklr32dyntbMimvrgUgPNCXuaNiuH5kDA4/L4sTisiZaBal7/z581myZAnr16+nc+fOP3hvREQEMTExHDlyBIDw8HCqq6spKiqqt9v3+PHjjB49uu6e/Pz8bz1XQUEBYWFhjfhKREREREREpMlUFMNXj8COt8EwyygGXg/TnwS/IEujibR0J8uref6rwyzelkVVjRuAHqHtuWtKHDP7huNl12GIIi2JpaWvYRjMnz+fTz75hHXr1hEbG/ujH1NYWEhWVhYREREADBkyBC8vL1atWsVVV10FQG5uLvv27ePZZ58FYNSoUTidTrZu3crw4cMB2LJlC06ns64YFhERERERkWbKMODIKvj811CSba516gnnPw7xM6zNJtLCFZRW8fe1R/lgWxYVLvOXKUNiOvDLid2ZfF7o975DWkSaN5thGIZVn/yXv/wl7733Hp999lm9w9QcDgd+fn6UlZXxyCOPcPnllxMREUF6ejoPPPAAmZmZHDx4kICAAAB+8Ytf8Pnnn/PWW28RHBzMokWLKCwsJCkpCbvdHCY+c+ZMcnJyeOWVVwC49dZbiYmJYenSpWeUtaEn5YmIiIiIiMhPkL8fVvwG0tab1x1i4eIXoOtYa3OJtHB7s508v/owqw8d55tmqHdEIPfOiGdCzxCVvSLNREM7SUtL3+/7BvLmm28yb948KioquOSSS9i5cyfFxcVEREQwadIkHn/88XqHqlVWVnLPPffw3nvvUVFRwZQpU3jxxRfr3XPy5EnuuusulixZAsDs2bN54YUXCAo6s7cAqfQVERERERE5h8pPwNonIektMNxg94Zht8CkB8GnvdXpRFokt9vgPzuy+eemdPYdK6lbHxgdxF1TejApXjt7RZqbFln6tiQqfUVERERERM4Btxu2vQZrnoAqp7nW+2I4/zHo0NXSaCItVaWrls/35PLGhjQO5Jplr7fdg5n9wpk/uQc9QgMsTigi36ehnWSzOMhNREREREREhBNH4bM7IGuzeR3eD2b8XqMcRBqoqLyaf23O4J+b0jlRVg1AgI8nv5jUnWuGdSHY39vagCLSZFT6ioiIiIiIiLVqa2DTC7D2KaitAu/2MPURGHoTeNitTifSohiGwYHcEhZvzeLfSVlUutwARDh8uW5EF+aMiFHZK9IGqPQVERERERER6+TvN3f35uw0r7tPgYv+AkFdrM0l0sLU1Lr5eOcxXv86jeT80rr1vlGB/HxcNy7oF4GX3cPChCJyLqn0FRERERERkXOvpho2/AnW/wHcLvB1wPSnYeAc0EFSImessKyKxduy+NfmDHKdlQB4e3owtVcoc4bHMKZHRx3OJtIGqfQVERERERGRcys1AZbfCwWHzOv4C2HWnyAg3NpcIi1I+olyXtuQyofbsqmuNUc4BLXz4tbx3bhuRAwOPy+LE4qIlVT6ioiIiIiIyLmRsQkS/wrJy8zrdh1h5rPQ93Lt7hU5Q5WuWl5al8KL647iqjUA6N/ZwY2junJh/wh8vTQHW0RU+oqIiIiIiEhTqyqFLxbBnsXmtc0Dht4Mkx6AdsHWZhNpIdxugyW7c3juy2SOFVcAMLp7R+6c1IPRPTpZnE5EmhuVviIiIiIiItJ0UtbC5wugKB1sdhh0PYy6A0LirU4m0mLsyirmqS8OsjX9JACRDl/um3keswdEal6viHwnlb4iIiIiIiLS+HJ2wZon4Ogq89oRDZf9A2JGW5tLpAUpqXTxxy+T+eemDAD8vOzcObkHPxvTlXbeqnRE5PvpO4SIiIiIiIg0npOp8PlCSF1rXnt4wZB5MOVh8A20NJpIS1Fd4+Zva47wz8R0SiprAJg9IJJ7pscTHdzO4nQi0hKo9BUREREREZHGse8/sOQuqC4DD0/oOQOmPgqdelidTKRFqK5x8/meHP66+gjphacA6BHangcv7MWk+FCL04lIS6LSV0RERERERH6asgL45DZIWW1ex4yBi1+A4G7W5hJpIYpPVfPulkz+mZjO8dIqADq08+KR2X2Y1T8Su4fm9orI2VHpKyIiIiIiIg2XuRk+uglKjpkHtY2eD5MfArt+3BT5MUXl1Ty/+ggfbMuiwlULQGiADzeO7srcUTEE+npZnFBEWir9LSwiIiIiIiJnz+2GxOdh9eNg1ELHOLjmXQiJtzqZSLNXVlXDJzuP8edVhzlZXg1Ar4hAbhkby0UDIvH29LA4oYi0dCp9RURERERE5OyUn4BPboejq8zrflfCrD+DT4C1uUSauVq3wZsb03j+qyOUVpkHtMWHBfDQrN6M6dERm01jHESkcaj0FRERERERkTOXkQgf3QylOeDpCzOfhcE3gMoqke9lGAabUgv5w5fJ7MgsBqBbJ3+uHd6FG0d31c5eEWl0Kn1FRERERETkx7ndsPHPsObJ0+McrnwLwvtanUyk2TIMg+X78nhlfSq7s8yy19/bzoMX9uaaYdF46IA2EWkiKn1FRERERETkh504CssWQepa87r/1XDhn8CnvbW5RJqx/JJKFv17N18fOQGAt92Da4ZHc/uE7kQG+VmcTkRaO5W+IiIiIiIi8t3cbtjyEqx8yNzd6+kHFzwHg67XOAeR71HrNnhvSwbPfplMaWUNPp4e3Da+G9ePiiE0wNfqeCLSRqj0FRERERERkW/LSISvHoWszeZ1j/NhxtPQKc7aXCLN2P4cJw98sq9ulMOAzg7+eNUAeoTqkEMRObdU+oqIiIiIiMhpFcWw8rew8x3z2ssfpv4Oht+q3b0i36OgtIq/rz3K25vScRvQ3seTe6bHc/3IGOya2ysiFlDpKyIiIiIiIqbkFfD5AijNNa8HXg8T74OgLtbmEmmmqmpqeSUhlZfWpVDhqgXgwv4RPDyrN2GBGuUgItZR6SsiIiIiItLWnToJy++DvR+a18Hd4OK/Q8xoa3OJNGP7jjm5+8PdJOeXAuYoh3tnnMeYHp0sTiYiotJXRERERESk7XK7Yd9H8OUDUF4ANg8YdSdMegC8/KxOJ9IslVfV8OrXqbyw5ig1boOO/t48fFFvZg+IxKYRKCLSTKj0FRERERERaYuytsKyeyB3l3kd0svc3dt5iLW5RJqp4lPVvJWYzluJ6RSfcgEws284T1zSl47tfSxOJyJSn0pfERERERGRtqSiCNb9Hrb+Aww3eLeHsQtg9F3gqeJK5H+dKKvilYQU3tuSSXm1Obc3tpM/v5oSx8UDtbtXRJonlb4iIiIiIiJtQa0Lkt6CtU9BxUlzbcC1cP7j0D7E0mgizVGes5I3E9P416aMurK3V0Qgd0zqzsy+Edg9VPaKSPOl0ldERERERKS1S1tvzu3N22teh/SCGU9B98nW5hJpZtxug6+PnuC9LRmsTS6gusYNQL8oBwvP78nE+BDt7BWRFkGlr4iIiIiISGtVnAlfPggHl5jXvkEw+bcw5Gdg14+DIt84kl/Kf3YcY8muY+Q4K+vWh3cN5pZxsZzfO0xlr4i0KPpbXkREREREpLWpKoMtL8P6P0BNBdjsMPRnMOE+aB9qdTqRZqGk0sXyvbn8e3s22zOK6tbb+3hy5dDOXD64M30iA1X2ikiLpNJXRERERESktXBVQOILsOkFqCw212LGwgXPQlgfa7OJNAMnyqr4eEc2qw8eJymjiBq3AYDdw8ak+FAuHxzFpPNC8fWyW5xUROSnUekrIiIiIiLSkhkGFKbAvv/AjrehJNtc7xALE++H/leBdipKG1XpqmX94QJWHchnT7aTw8dLMYzTj3cP8eeKIdFcNjiKsEBf64KKiDQylb4iIiIiIiItSdlx80C2Yzsge5v5T8XJ048HRMD5j0Pfy8BDuxWl7TmSX8qm1EK2pJ5kw9ETOCtc9R4fEB3EZYOimBgfQkxHf4tSiog0LZW+IiIiIiIizVn1KSjNhbQE2PU+ZG/99j12H+gyAgbMgT6Xgpd2LErb4XYb7D3mZEtaIcv35bEzs7je4+GBvlzQL4JhXTswpGsHQgP09SEirZ9KXxERERERkebEMCBnB+z7GA6vMEc3YNS/p0NXiBoCnYdD52EQ3hc8faxIK2KZkkoXn+/O5fUNqaQUlNete9hgTI9ODInpwLi4EAZGB2H30IgTEWlbVPqKiIiIiIhYzTDgZCokL4ed70DBofqP270hrC/0uggGzoGAcGtyiljMMAy2pRexeGsmX+zNparGDYC/t53hscGM6dGJKb3CiO2ksQ0i0rap9BUREREREbGC2w3HkmDvh3D0K7P0/YanH8TPNEc1dBkJ7UOtyynSDKQWlPHJzmMs3Z1DeuGpuvW40PZcObQz1w7vQoCvl4UJRUSaF5W+IiIiIiIi54phmIew7XgbDnwK5QWnH/PwgugR0OcS6HMZ+He0LqdIM5BSUMaX+/NYdSC/3pzedt52LuofyTXDoxkYHYTNptENIiL/S6WviIiIiIhIUyo7bs7mzdoC6RugKP30Y17t4LxZ0Hs2dJsIPgEWhRRpHgzDYFNqIW8nZrBif17dut3Dxvi4TlwyKIrJ54VqV6+IyI9Q6SsiIiIiItKYygpg778hbb25q7cku/7jnr4QNw0GXQ/dJ4Nd5ZWIYRh8sTeXP608TOoJ81A2DxtM6BnCuLgQZg2IIDTA1+KUIiIth0pfERERERGRn8pVAcnLYPcHkLIa3DX/9aANQntDz2nm+IauY7WjV+S/bE07yVPLDrIryxzh0M7bzqWDorhuRAy9IwMtTici0jKp9BUREREREWkIwzBHNuz5EPZ9BJXO049FDjYPYYsaAmG9wa+DdTlFmqGc4go+2XmMFfvy2HvM/Npp523ntvHduXlcLO19VFeIiPwU+i4qIiIiIiJypmprzKL36CrY+xE4s04/5uhizuYdfAOExFuXUaQZKyit4tWvU3krMZ3qGjcAXnYbVwyJ5tdT4wgN1AgHEZHGoNJXRERERETkx1SVQtJbsPklKDl2et27vXkQW/+roNsk8PCwLKJIc7Y328nLCSms2J9HrdsAYFjXDszqH8ms/hF0bO9jcUIRkdZFpa+IiIiIiMj3KS+ELS/D1n9ApTlvFL8OEDsB+l4GPc4H73bWZhRppgzDYF1yAS8npLAl7WTd+oDoIBZMiWNifAg2m83ChCIirZdKXxERERERkf/lzIbEF2DHP8F1ylwL7g5jF0C/q8BLb0EX+T57s52sOpDHiv15HM4vA8DTw8ZFAyL5+bhu9IoIUNkrItLEVPqKiIiIiIh8o+AwbHwe9nwAbpe5FjEAxi6EXheBh93afCLNVFVNLcv25vLPxAx2ZRXXrft52bl+ZBd+NiaWyCA/CxOKiLQtKn1FRERERKRtMwzI3ASbX4SDnwPmvFG6joOxv4buk0G7EkW+U35JJe9uzuC9rVmcKKsCwNvuwcT4EKb3CWdifIjm9YqIWEClr4iIiIiItF1ZW+HLByB72+m1+AvMnb3Rw6zLJdKMGYbBptRC3t+axfK9udT8/8FsYYE+XD8ihmtHdKGTil4REUup9BURERERkbbHeQy+vB8OfGZe232g35Uw+k4I7WVtNpFm6nhJJe9tzeSLPbkcOV5Wtz6sawduHN2V6X3C8bJ7WJhQRES+odJXRERERETajupy2PY6JDwD1WVgs5tl79RHIDDC6nQizY5hGOzKKua9LZl8svNY3a5eH08PLhscxZzhMfTr7LA4pYiI/C+VviIiIiIi0vq53bDzHVj7JJTlm2tRQ2HWnyGiv7XZRJoh5ykXn+46xhsb08goPFW3PiSmA9eN6MLk80IJaudtYUIREfkhKn1FRERERKR1O5kKS2xJGJcAACAASURBVO6C9K/N66AYmHAvDLgWPOzWZhNpRmrdBl8fKeCjpGxWHsinusYNmLt6Z/YN54bRXRncpYPFKUVE5Eyo9BURERERkdaptga2vgKrH4eaCvD0g8m/heG3gqd2KIp8I7+kknc3Z/DB9izyS6rq1s8LD2DOiC5cNrgz7X1UH4iItCT6ri0iIiIiIq2LYUDycnOUQ/4+cy12PMz+G3Toamk0kebCecrF2uTjfHUwv96u3g7tvLh4YBRXDOlMn8hAbDabxUlFRKQhVPqKiIiIiEjrUX4CvrgbDnxqXvs64PzHYPCNoPJKhKPHy3h7Uzofbs+i0uWuWx/Q2cEt47oxvU843p4e1gUUEZFGodJXRERERERavloXbHkFNj4P5cfBZofR82H0XeDf0ep0IpaqdRskHD7Oh9uyWXkgD7dhrseFtmd8zxAuGRhFv84Oa0OKiEijUukrIiIiIiItW3EmfHQzZG81rzv2gMtehajB1uYSsVhReTVf7M3ljQ1ppJ4or1uffF4oN42JZUyPjhrfICLSSqn0FRERERGRlskwYOe/4MsHocoJPg44/1EYcA14+VmdTsQymYWneGNjGou3ZdaNcAj09eTigVHMHRVDz7AAixOKiEhTU+krIiIiIiItT0kOLJkPR78yr6OGwhWv66A2abNOlFWxfF8eK/blsvFoYd16XGh7rh4WzTXDu9DeRxWAiEhb0aDv+I899hiLFi2iXbt29dYrKip47rnnePjhhxslnIiIiIiISD2GAbsXw7J7oLoU7D4w6QEYdSfYVWhJ21LpqiXhcAH/Scpm1cF8DOP0Y+PiOnH7hO6M7q4RDiIibZHNMP77r4UzY7fbyc3NJTQ0tN56YWEhoaGh1NbWNlrA5qKkpASHw4HT6SQwMNDqOCIiIiIibY/zGHxxNxxebl5HDoZLX4aQeGtziZxDbrdBYkohH27PYvXBfMqrT//83b+zg1n9I5jWO5yunfwtTCkiIo2loZ2kR0M+mWEY3/mbwt27dxMcHHzGz/P0008zbNgwAgICCA0N5ZJLLiE5Oflbn+uRRx4hMjISPz8/Jk6cyP79++vdU1VVxfz58+nUqRP+/v7Mnj2b7OzsevcUFRUxd+5cHA4HDoeDuXPnUlxcfBavWkRERERELGEYsONteHGkWfh6eMHkh+DmVSp8pc0oqXTxwpojjPr9aq5/fQtLdudQXl1LpMOXm8fGsvLX41ly51huHd9dha+IiJzdeIcOHTpgs9mw2Wz07NmzXvFbW1tLWVkZt99++xk/X0JCAnfccQfDhg2jpqaGBx98kGnTpnHgwAH8/c2/pJ599ln+9Kc/8dZbb9GzZ0+eeOIJzj//fJKTkwkIMIfPL1iwgKVLl7J48WI6duzI3XffzaxZs0hKSsJutwMwZ84csrOzWbFiBQC33norc+fOZenSpWfzf4GIiIiIiJxLJbmwbBEc+ty8jhoKF78Aob2szSVyjqQWlPHO5gw+25XDyfJqANr7eHLJoEguHdSZQdFBeHhofIOIiNR3VuMd/vnPf2IYBjfddBN/+ctfcDgcdY95e3vTtWtXRo0a1eAwBQUFhIaGkpCQwPjx4zEMg8jISBYsWMB9990HmLt6w8LCeOaZZ7jttttwOp2EhITwzjvvcPXVVwOQk5NDdHQ0y5YtY/r06Rw8eJDevXuzefNmRowYAcDmzZsZNWoUhw4dIj7+x3cHaLyDiIiIiMg5VFsD216DNU+Ys3s9PGHKw+bsXg+71elEmtzurGJeTkhhxf68ulm93Tr5c9eUOGb0DcfXS18HIiJtQUM7ybPa6XvjjTcCEBsby5gxY/D0bNyDEpxOJ0DdiIi0tDTy8vKYNm1a3T0+Pj5MmDCBxMREbrvtNpKSknC5XPXuiYyMpG/fviQmJjJ9+nQ2bdqEw+GoK3wBRo4cicPhIDEx8TtL36qqKqqqququS0pKGvW1ioiIiIjI98hOgs8XQN4e8zpqKMz6E0QMsDaXyDmwLf0kjy09wN5jzrq1qb1CuXZ4F8b3DMHL3qApjSIi0sY0qLWdMGECKSkpvPnmm6SkpPD8888TGhrKihUriI6Opk+fPmf9nIZhsHDhQsaOHUvfvn0ByMvLAyAsLKzevWFhYWRkZNTd4+3tTYcOHb51zzcfn5eX961D5wBCQ0Pr7vlfTz/9NI8++uhZvw4REREREWmg8kJY8zgkvQUY4OuAqY/A4HngoaJLWjdnhYtX16fy4rqjuA3wstu4qH8kt0/sTs+wAKvjiYhIC9Og0jchIYGZM2cyZswY1q9fz5NPPkloaCh79uzhtdde46OPPjrr57zzzjvZs2cPGzZs+NZj/3to3PcdJPdD93zX/T/0PPfffz8LFy6suy4pKSE6OvoHP6eIiIiIiDRASS5sfB52vgPVZebagGvh/MehfYi12USaWEmli39uTOeV9amUVdUAcOmgKB6a1Ztgf2+L04mISEvVoNL3N7/5DU888QQLFy6sO0wNYNKkSTz//PNn/Xzz589nyZIlrF+/ns6dO9eth4eHA+ZO3YiIiLr148eP1+3+DQ8Pp7q6mqKionq7fY8fP87o0aPr7snPz//W5y0oKPjWLuJv+Pj44OPjc9avRUREREREzpCrAhJfgA1/Ble5uRbWD2Y+A13HWJtNpIlVVNfyxsY0Xl6XQun/l73xYQEsmBrHzH4RP/LRIiIiP6xB75Hau3cvl1566bfWQ0JCKCwsPOPnMQyDO++8k48//pg1a9YQGxtb7/HY2FjCw8NZtWpV3Vp1dTUJCQl1he6QIUPw8vKqd09ubi779u2ru2fUqFE4nU62bt1ad8+WLVtwOp1194iIiIiIyDniqoBtr8PzA2HtE2bhGzUE5nwIt61X4SutmvOUi9e+TmXCc2t57stkSqtq6BHanr9cPZDlvxqnwldERBpFg3b6BgUFkZub+62SdufOnURFRZ3x89xxxx289957fPbZZwQEBNTN13U4HPj5+WGz2ViwYAFPPfUUcXFxxMXF8dRTT9GuXTvmzJlTd+/NN9/M3XffTceOHQkODmbRokX069ePqVOnAtCrVy9mzJjBz3/+c1555RUAbr31VmbNmvWdh7iJiIiIiEgTMAxIXgZfPgBF6eaaI9qc29vnMs3tlVatusbNq1+n8ve1RzlVXQtAVJAf986I56L+kXh4/PAIQxERkbPRoNJ3zpw53Hffffz73//GZrPhdrvZuHEjixYt4oYbbjjj53nppZcAmDhxYr31N998k3nz5gFw7733UlFRwS9/+UuKiooYMWIEK1eurDdW4s9//jOenp5cddVVVFRUMGXKFN566y3sdnvdPe+++y533XUX06ZNA2D27Nm88MILDXn5IiIiIiJyNtxuOLrKHOOQuclcC4iEMXfB0JvAU2PVpHXbnFrII0v2cyivFIDzwgO4YVRXrhjSGW9P/bJDREQan80wDONsP8jlcjFv3jwWL16MYRh4enpSW1vLnDlzvlW2thYlJSU4HA6cTieBgYFWxxERERERaf5OpsKu92Dvv0/v7LV7w6g7YNzd4BPwgx8u0tIdzC3h2RWHWJtcAECwvzcPzerFJQOjfvRwchEREWh4J9mg0vcbqamp7NixA7fbzaBBg4iLi2voUzV7Kn1FRERERM5Q+QlIeBa2vw5u84AqfBww5AYYeQcEamaptF6GYbBkdw6Lt2axKdU888bTw8a1w7vwq6lxdGqvne0iInLmGtpJnvV4B5fLRXx8PJ9//jm9e/emW7duZ/sUIiIiIiLSGuXshA1/gcMroKbSXOs2CQZcA70uAm9/a/OJNLFDeSX84cvDfHUwHwCbDS7oF8E90+Lp2kl//kVE5Nw569LXy8uLqqoqvRVFRERERESgpgqSl8PmlyBr8+n1iIFw/qPQbaJVyUTOiUpXLcv35fL2pgx2ZhYD4GW3cev4bswZEUNUkJ/FCUVEpC1q0EFu8+fP55lnnuG1117D07NBTyEiIiIiIi2ZYUDqOvhioTm7FwAb9LsSRt8J4f3NbY4irVClq5avDuazfG8eqw/lU+lyA2D3sDG9TxjzJ8fRK0JjAUVExDoNamy3bNnC6tWrWblyJf369cPfv/7bVD7++ONGCSciIiIiIs1MdTns/BfseBvy95lr7cPMEQ4jbofASGvziTSh/TlOPtiWxac7j1FSWVO3Hhrgw9yRMVwxtDMRDu3sFRER6zWo9A0KCuLyyy9v7CwiIiIiItJcGQYc/QqW3QNFaeaaVzsYeB1MegDaBVubT6QJlFXVkJRRxObUQr7cn0dqQXndY1FBfswaEMGsfpH0jQrUCEQRkXOouLIYH08f/Dz1i7bv06DS980332zsHCIiIiIi0lwd2wFf/Q7S1pvX7cNh7K/NUQ7+Ha3NJtIEUgvK+HB7Nu9vzcRZ4apb97LbmNY7nGuGRzOmeyc8PFT0ioicC27Dzf4T+1mTtYYNxzZw6OQh/jjhj0zrOs3qaM2WBvKKiIiIiMh3y90D656G5GXmtd0bht8K4+8BvyBrs4k0MmeFiy/25PL+1kz2HnPWrUc4fBncpQPT+oQxpkcnOrX3sTCliEjbYRgGh4sO88nRT1iVvorjFcfrPZ5SnGJRspahQaXvoEGDvvOtKzabDV9fX3r06MG8efOYNGnSTw4oIiIiIiLn0KmTsOdDOLISUlabazYPc1fvpAehQ4y1+UQamfOUi8XbMnk5IYWiU+auXg8bTIwP5fLBnZnRNxy7dvSKiJwzqc5UtudtZ3HyYo4UHalb9/fyZ1zUOCZET2BkxEg6+XWyMGXz16DSd8aMGbz00kv069eP4cOHYxgG27dvZ8+ePcybN48DBw4wdepUPv74Yy6++OLGziwiIiIiIo2ppsrczbvrfbPodZ8+oIo+l5kzezvFWZdPpAmcLK/m72uP8v7WTE5V1wLQrZM/1wyP5vLBnemoHb0iIueMs8rJmsw1fHzkY3YV7Kpb97H7MCZyDJf3vJyRESPxtntbmLJlaVDpe+LECe6++24eeuiheutPPPEEGRkZrFy5kt/97nc8/vjjKn1FRERERJojw4Dc3bDrXdj7b6goOv1YeD/oewXEz4SQeOsyijSyWrfB7uxi3t+SyfJ9eZRVmb/giA8L4OZxsVw2KApPu4fFKUVEWj+X28XW3K18lfkVh4sOc7DwIC63+W4LT5sn/UP6MyZqDFfHX43Dx2Fx2pbJZhiGcbYf5HA4SEpKokePHvXWjx49ypAhQ3A6nRw6dIhhw4ZRWlraaGGtVFJSgsPhwOl0EhgYaHUcEREREZGGqa2BtHWw7veQve30ekAkDLwW+l+toldanUpXLcv25vL86iNkFJ6qW48PC+D+C85jQs+Q7xxhKCIijevQyUN8fORjVqStoKiqqN5j3RzduLDbhVza41JC2oVYlLD5aWgn2aCdvr6+viQmJn6r9E1MTMTX1xcAt9uNj4/eDiMiIiIi0iy4a2H7G/D1H6E011yz+8B5F8Kg66DbJPCwW5tRpBHV1LrZmVXMin15fLbrGCfKqgHw97YzuVcYc0fGMDSmAx6a1ysi0mRq3DUcLDxIYk4iy9OWk+I8ffhasG8w58ecT/+Q/vQO7k33oO76BVwjalDpO3/+fG6//XaSkpIYNmwYNpuNrVu38tprr/HAAw8A8OWXXzJo0KBGDSsiIiIiImepuhy2vwk734GCQ+aabxAMuAbGLoSAMGvziTSiSlctG4+eYOX+fJbvy6Wk8vR86rBAH64fEcMNo7vi8POyMKWISOuW5kwjISuBbfnbSMpPotxVXveYp4cnk6IncVncZYyMGImnR4OqSTkDDRrvAPDuu+/ywgsvkJycDEB8fDzz589nzpw5AFRUVGCz2ep2/rZ0Gu8gIiIiIi1KdTns+QASnoPSHHPNOwCmPAxDbgRPvStPWgdXrZs1h47z7+1ZrDl0HPd//YQb1M6L8XEhXDwwkvE9Q/DSvF4RkUZnGAYZJRlsyd3CZymfsffE3nqPB3gHMDRsKJOiJzEpehJBvkEWJW2ZGtpJNrj0bWtU+oqIiIhIi+CuhW2vmTN7K06aa0FdYOyvoc9l4KcftKRlq6l1szXtJPtzSvh8by4Hc0uornHXPR4S4MP0PmFc2C+SYV076GA2EZEmsvP4Tlamr2RZ2jJOVp6sW7dhY1TkKEZHjmZY+DDiO8Rj1wipBjunM30BiouL+eijj0hNTWXRokUEBwezY8cOwsLCiIqKaujTioiIiIhIQ6VvhFUPw7Ht5nWHWBh8A4z8BXj5WZtNpIGqa9zsyS5mZ2Yxm1ML2ZJ2krKqmnr3BPp6ctXQaK4Y2pmeoQGa0ysi0kSKKotIyE7gkyOfsOP4jrp1Tw9PBoUOYkzkGC7ucTGd/DpZmFKggaXvnj17mDp1Kg6Hg/T0dG655RaCg4P55JNPyMjI4O23327snCIiIiIi8n0KU2Dtk7DvP+a1d3uY/FsY9nOwa1aetCyGYbAjs5hPdx4jMeUEGYWnqHHXf4NqUDsvBnfpwKhuHZnSK5To4HYa3SAi0kROVp5kZfpKVmasJCk/CbdhvrvC0+bJzNiZTIyeyPjO4/H1bB0jXluLBv0X4MKFC5k3bx7PPvssAQEBdeszZ86sm+krIiIiIiJNrOw4rP8DbH8D3C5zbdBcs/ANCLc2m8gZqqiuZV+Ok91ZxezMKiYpvYi8ksp69wT6ejI8tiPDYzswunsnekUEYtduXhGRJlNcWUyKM4W1mWv5IPkDKmtPf1+O7xDPlC5TuDTuUsL99d8bzVWDSt9t27bxyiuvfGs9KiqKvLy8nxxKRERERER+QPkJ2PoqJP4NvjkRu8dUmPoIhPezMpnIDyqrqiHr5Cn255SwJbWQpMwiMgpPUfs/O3nbeduZ0SecC/pF0CcqkPBAX2w2lbwiIk3FVeti5/GdbMzZyIZjGzhcdLje472Ce3FB7AVMjZlK54DOFqWUs9Gg0tfX15eSkpJvrScnJxMSEvKTQ4mIiIiIyHcoPwFrnoBd70FtlbkWORim/g66TbQymQhgHrKWXljOobxScooryCmuJKe4gmPFFRwvraKovPpboxoAQgN8GBgdxIDoIAZGBzEkpgO+Xjr0R0SkKZ2oOMHX2V+zOnM1W/O2UlFTUe/xsHZh9OzQk2vPu5axUWP1y7cWpkGl78UXX8xjjz3Ghx9+CIDNZiMzM5Pf/OY3XH755Y0aUERERESkzasqhU0vmjt7q0vNtchBMPou6HMp6IcwsUhJpYuk9CJ2ZxeTlFHEjowiyqtrf/BjOrTzIraTPyO6dWR412B6RQQS7tAcSBGRppZVmkVSfhLb8raRWpzK/sL9GJz+RVywbzCjI0czNmosoyNH08G3g4Vp5aeyGYbx7V+z/oiSkhIuvPBC9u3bR2lpKZGRkeTl5TFq1CiWLVuGv79/U2S1VElJCQ6HA6fTSWBgoNVxRERERKQtqKmGxL/C138E1ylzLWIATH8Kuo61Npu0KYZhkFJQTubJco4VVZB58hQ7M4vZkVnE/27c9fOy0yO0PbGd/IkM8iMqyJfIID9CA3zp2N6byCA/a16EiEgbYxgGuwt28+nRT9l1fBcpzpRv3dMruBdTukxhfOfxxAfH42HToZjNTUM7ybPe6etyubj44ot59dVXycnJYceOHbjdbgYPHszUqVPP9ulEREREROR/1VTDvv9Awu+hKN1c6xgHk+6H3peCh34gk6bldhukF5azK6uYVQfyScoo4nhp1Xfe27VjO/p3DmJY1w4M7RpMz7AAHbImImKhA4UH+D/27ju68cM68P0XHSBRSIAkSLCAnZymqdIU9eKRZEu2Y63lF5c41fbmJE42TnaTnGQ3Pi/tJRvHm3idl42bHDuWfV4cW26yJGvUps9oZjicYa8AQRQCJHrH7/1BaUYUObIKhyA593OOjoTf70K8IHFI4OL+7n3e8zxPjD2BN+G9clytUrOjZgc3199Mj72HXbW7ZBHbJvaWi746nY7+/n40Gg333HMP99xzz/XISwghhBBCiBtPLgnnvgEvfR7ivsVjlXVw+P+Gmz4kYxzEdTcciPOvx6d44oKPaDq/5JxOo6Kj1kxTdQUt9graayu5p7dOOneFEGKdOO0/zT9d+CdO+09fOWbUGDnceph7W+5lV90u7EZ7GTMUa+ltzfT9pV/6Jb785S/z13/916udjxBCCCGEEDeeV2f2nv4SJIOLxypq4NBvwS2fAP3mG58m1o9CscQzA0EeOzbJ8fHwleNGnZquOgu3dtawv83O/nY7Ffq39RZSCCHEdZLIJTjmO8Y3B77Jy8GXAdCqtRxyHeL+1vu5r+U+KnQVZc5ydSmKQiKRQKfTYTTKTPhreVt/sXO5HF/60pd4+umn2bdv37IZvp/73OdWJTkhhBBCCCE2NUWBwR/CT/4bxGYWj9la4NZPw55fAq2hvPmJTStbKHJqIsKzg0GeuhRgZmFxY7taBYe31vPRA24OtNvRamSUiBBCrCeKojARm+Bs4Cwvel/k6MxRcqUcADq1jg90fYBf3/Hrm2psQ6FQwOv1Mjk5ydjYGH6//8r42d27d5c7vXXrbRV9+/v72bNnDwDDw8NLzqnkkjMhhBBCCCF+vsgEPPmHMPzk4u3qVrjrj2H7B0CjK2tqYvMKxDJ85aUJ/u3UNPFM4crx6god/9ctLXz0gJtGGdcghBDrRqFUYGh+iHOBc7wcfJlzwXPMpeeWxLitbu5pvoePbPkIzkpnmTJdPalUiqmpKSKRCLFYjEuXLpFIJJbEqFQqUqlUmTLcGN5W0ffIkSOrnYcQQgghhBA3hmIejv0DvPg5yCVArYPbfhdu/wzopNgmVl+hWOKpywG+enSCs1PzlJTF47UWA3f31HJ3Tx1399Zh1GnKm6gQQggAQqkQ3x/7PidnT3IhdIF0Ib3kvE6tY3fdbnbW7uRw62F6qns2dBNmOp1menqasbExxsbGCIfDy2IqKipoa2ujra2N1tZWqqqq0Gpl5NAbke+OEEIIIYQQa6FUhP7vwnN/BZGxxWMth+Dhz0NtT3lzE5tSPJPnO2e8fPXoBN75qwWDW1rtfPLOdu7uqUOt3rhFAiGE2ExmE7Mc9R3lqcmnOB04TaF09WoMi87Crrpd7HHuYXfdbrbXbMeg2bgjoAqFAtPT00xOTjI+Ps7MzAyKoiyJsdvtOJ1OLBYLbrebnp4eKfK+RfLdEkIIIYQQ4nob/BE881mYG1q8XVEDh/8cbnoU1NJdKVbXzEKarx2d4PFTHuLZxaKBvVLPRw+4eXRfE03Vm2uhjxBCbESpfIqh+SGOeI5wee4ypwOnKSmlK+d31e7iPe3vYY9zD51VnahVG3fGeqlUYnh4mOHhYYLBID6fj1KptCTG4XDQ2NjIli1baGlpWbY/TLx1UvQVQgghhBDieon74ck/gkvfXbxttMGhT8P+T4HBXN7cxKaSyhX42UCQpy4H+PHFWYqvzHBor63k129r5wN7GmV8gxBClFm+mOds8CzfHf4uT009RVEpLjm/s3YnB10HeXfbu2mztZUpy3cmk8kQDodJJBJMTU3h8/nw+XzkcrklcRUVFXR2duJ2u+no6KCqqqpMGW9eUvQVQgghhBDieph8Cf79NyDuA5UaDv4W3PEHYLSWOzOxSfijGb53foZTExFOTURIZK9eCnyow8Gv397GXd0ywkEIIcqhUCrQP9fPyMIIk9FJJmOTnPafXjKft9pQzYGGA+yr38f+hv24re4yZvz2lEol/H4/Fy9eZHBwkIWFhWWjGgBMJhM7d+7E5XLR2NhIdXU1avXG7V7eCKToK4QQQgghxGoqFeHIX8KL/3Pxdk0PPPIlaLipvHmJTaFYUjgxHubfTk7z00t+CqWrb6zdjgru7qnjg/ua2OaylTFLIYS4cSiKgjfh5XzwPCMLI4RSIRayC1ycu0g0G10Wbzfaubv5bh7teZStjq1lyPjtK5VKRCIRAoEAU1NTjI6OMj8/v6zIW1lZiclkoqGhgba2NhobG6mpqUGjkStO1pIUfYUQQgghhFgtkQn43n+G6eOLt3d/DO7/i8WxDkK8TfliiWNjYX7cN8uzQ0FC8eyVc7e02jm8zcnNrXZ2NNqkq1cIIa6jaDbKpblLzCRn8MQ8TMQmGIwM4k/6V4yvMlSxzbGNNlsbbbY2eu29bK/ZviHm85ZKJQKBAPPz88TjcQKBAJcvXyaTySyL1el0NDc3s3v3btxuN1arXNW0HkjRVwghhBBCiNVw+fvw/d+CbAx0lfDw/4KbPljurMQGFU3l+UGfjxdHQpyaiDCfyl85ZzVqeWini4/sb5GOXiGEuA6S+SSDkUGG54fxJXxMxaYYiAxcs7irVWnZVrONrY6t1FfWY9VbabW2sqtuF1r1xim9KYrCzMwMFy9eZHh4mPn5+WUxWq0Wp9NJfX09XV1duFwuzGazjGpYhzbOM08IIYQQQoj1KBWBZ/4MXn5s8XbzAfjA/4HqjTeXT5TXeCjBd854OTo6x+XZ2JVlbAA2k477tjh53y4X+9vtGLRyiawQQrxT+WIeT9zDRHSCWC7G2cBZzgXPMR2fvuZ9msxNtNnaaLG20Gxppru6m22ObVToKtYw89VTLBbxeDxcuHCBycnJJYVenU6H0+nEYrFQVVVFV1cXbrdbxjRsEFL0FUIIIYQQ4u3IROH4/4YT/7TY3Qtw6NNw7/8AjbzMFm9OMlvgh30+/vXEFP0zsSXneustPLzTxS1ti6MbjDp5ky2EEG+XP+nnmO8Yc+k55jPzDM8Pczl8mUQ+sWK8s8JJr72XFmsL9RX1bHVspdfei1lvXuPMV1exWGR2dpZgMMjs7Cz9/f2k01eXy2m1Wnp7e+nt7aWrqwuDwVDGbMU7Ia9GhRBCCCGEeKsmX4L/+BREPYu367bCg/8PtN1R3rzEhnHZF+Nrxyb43jkfuWIJAJUK7uqu4fJQygAAIABJREFU5f27G9nTUk2zfWN2jQkhxHoQSAY44jnCM1PPcHHuIqlCasU4k9ZEu60dm8FGR1UHt7pupcfeQ42pZo0zXn2FQoFAIIDH42FmZoZQKEQoFKJYLC6JM5lMdHd3s2XLFtra2qTQu0lI0VcIIYQQQog3KxGCp/87XPi3xdvVrXDfZ2HLe0Fm2YmfI5kt8NRlP187OskF79WN7m01lXzo5mY+uLcJh1neaAshxFs1n5lnIDLAYGSQwcggfaE+ZhIzS2JUqNhZu5OOqg4qdZV0VnXSa++lx96zIRarvRnJZJKRkRFmZmbweDwEg0FKpdKyOJPJRENDAzU1NbS3t9Pd3b1hZvIqikIxmiV50o/ljibUJiltXot8Z4QQQgghhPh5igU4/SU48peQjQIq2PtxOPznYLCUOzuxzg0H4nzh2VGe7Pdf6erVaVS8a6uTX7utjT0t1ahUqjJnKYQQG0c0G+UF7wucmD3BxbmLTEQnlsWoULG9Zjv3t97Pra5bcZldG3bu7utls1lisRjRaBS/38/U1BShUIiFhYVlsSaTCZfLhdvtxm6343K5qKqq2lhF3kiGnDdObjpO6kKIUmJxuanaqMVyZ1OZM1y/pOgrhBBCCCHEtSgKjD0LT/0JBC8vHmvYCe/+O2i+uby5iXVNURTOTs3zlaMT/Pji1W3vLfYK3r+7kY8dcFNrka5eIYR4swLJAM97n+fHEz/mfPA8RWXpiAK31U2vvZdeey9b7FvYWbtzw8/fBSiVSvh8PrxeL7Ozs0xNTa1Y3H1VXV0dnZ2duFwumpubsVqtG+6DRUVRKARSpM4FSV2coxjJLIvRt1nRuSrLkN3GIUVfIYQQQgghVhIPLI5y6Ht88bapenFJ255fArUs1BIr65+J8pP+WX56KcBo8OpyoHfvqOc37+pkm2vjvfkWQoi1VlJKhNNhzgbPMhge5JjvGAORgSUxnVWdHHIdYn/DfrY6tm6KGbwA+Xwer9fL5OQkk5OTBAIBMpnlRU+DwYDVaqW6upq2tjbq6+upr6/HZDKVIeu3L+9PUohkyAdSKJkCxXiO7OgCxVjuapBGha6hEn2jGUNnNcauKtRGKWn+PPIdEkIIIYQQ4rWycTj+v+HoP0A+Cahg/yfhzv8GFfZyZyfWoXgmz08u+vnGySn6XjOr16BV875dLn7ttnZ66mUMiBBCvJGFzAJHPEd4euppTsyeIF/KL4vZ6tjKu9vezb0t99Jk2fiX9ReLRYLBIF6vl1AoRDgcZnJyctmiNYPBgNvtpqGhgaamJpqamjZccRde08F7cY7cdIz8bPLKqIbXU+nUGDqrqNhdh7HHjtogH7i/VVL0FUIIIYQQAiCfgbNfhRf+FlLhxWONe+HwX4D7YHlzE+tOMJ7hheE5nh0M8MxAkFxhcVavVr04q/eB7fXc1VOHzaQrc6ZCCLE+FEoF5tJzRLNRYrkYU7EpPHEPnrgHb9zL8PzwkpENKlS029rpdfRyyHWIQ65DG7qbt1QqEQqF8Hq9zMzMEAwG8fv9FAqFZbFms5nW1lZaW1tpamqipqYGrXbjlfCUkkIhnCYzPE9+NkluMkZhLr00SL3YxautMaGx6FHp1RjabBhabah0G2Pu8Hq18Z4xQgghhBBCrKZcEvq+DS/9PSxMLx6zd8A9fwLbfgHkUnzxilJJ4emBAI8dm+T4eBhFuXquo7aSR/Y28aF9zTjMMqtXCHFjURSFXGnxcvxgKsjZwFn65/qJ5WIMRYaYTc6SL+UplJYXOF+ru7qb+9z38a6Wd+G2udGpN94HZ8VikYWFBSKRCOFwmHA4TCQSwev1ks1ml8UbDAbq6+uvLFhra2ujtrZ2w40CUkoKhVCKQii9OK7BlyA9OI+Sed3PXKvC2FWNsdeOzlmBtrYCTeXG+zlvBFL0FUIIIYQQN6Z8Bk5/CV78O0hHFo9ZGhbHOOz+GGjkpbJYpCgKT1zw8YVnRxl5zZzebS4rd3TX8p4dDTKrVwixqSmKQigdYjo2jTfhZSGzQLKQxBv3Mh2bZiI6QTwf/7n/H61ai1Vvxaq34jK7cFvdNFuaabY002Zrw211r8GjWT3FYpFwOMzs7Cz9/f2EQiFisRilUmnFeJ1Oh9PppLW1FafTSUNDAw6HY0P9/SjliuRnEuT9STJD8xSTeZR0gVIqTym1QlFfo8LQZkPfYkFXX4mxpxq1QV5jrQX5LgshhBBCiBuLosDF/w9+9lmIehaPVbfCLZ+EvR8HvWyCFosUReG8Z4HPPzPC88MhACwGLR876OYXb2mh2V5R5gyFEGL1FEtFRhdGORc8RzAVZCG7gD/p53L4Msl8kkxx+TKxlWjVWnqre9lWs42Gyga6qrtosbSg1+ipr6xHrdp4l+yn02kSiQSZTIZMJsPk5CRjY2OEQqFl83cBtFotdrsdh8OB3W6nqqoKl8uF0+nckGMaSpkCOW+C1Lkg6b4QSn7lojZaFbqaCrR1JrS1FegbKjH22lFpN97PfDPYeM80IYQQQggh3q5UBH74X+Dy9xZvWxvhrj+EnR+Wzl6xxPPDIf78h5evdPbqtWp+++5OPn5rK1ajXIYqhNjYErkEF0IXGIwMMhWbYmR+hNGF0Tcs7KpValyVLpotzThMDkxaEy6zixZLC26rG5fZBUCFtgKNeuMt3SqVSkSjUSKRCNPT0wQCARYWFpifn19xLMOrtFrtle7dtrY2ampqsFqtqNUbp9Cp5IsU43mK8RzFSIbsVIxSIkcxkSfvT6Jklha21WYdOpcZg9uKrqESlVaNulKHzlkhBd51RF7ZCiGEEEKIzU9R4MK34On/AckgqLWLxd6DvwW6jbf9WlwfiqLw8vQCn3t6iKOji8v8jDo179paz+/c20lnnaXMGQohxFs3m5jlxOwJwpkwM4kZ+kJ9jC+MU1CWX4pv0prYXbebFksLdqOdamM1nVWdOCuc1FfWo9Nsjg+9FEUhkUjg8XgYGhoiEokQDAbfsLhrMBgwmUwYDAYcDge9vb00Nzdjs9k2VIG3mMiRvhAifTlMMZajGM8tK+quRF2pxbjFQeU+J3r32o40UhQFJZullE6T6e8nOzZG6tRpan/n0xh7etYsj41Gir5CCCGEEGLzKpUWu3pf+J8QvLR4rKYb3vdFaL65vLmJdaNQLPEf52b48ksTDPoXZ1LqNCo+st/N7x3uls5eIcS6VVJKzKXn8CV8zCZnmYhOEEwFiWQihDNh/Ek/wVRwxfs2mZvYXrOddls77VXt9FT30Gxp3pBduj9POBzG6/UyOzvLzMwMoVCITGZ5V7NGo6G6upra2lpaW1uprq6mqqqKqqoq9Hp9GTJ/+xRFoRjLkR2PkvfEyfkSKJkC+WAKVprOoFWhMevR2Azom8xoHSbUFVq0zkq0diNqw9o9L0rpNOkLfWQGB0geP07m/AWK0eiyOGNvrxR934AUfYUQQgghxOY0+rPFzt7AxcXbugq4/TNw6LdBayhvbmJdmE/m+N75Gb704gQzC2lgsbP3PTtc/O59XTKzVwhRdoVSgUAqwEx8hlQhRTwXxxP3MBGdYDw6zmR0klwp94b/DxUqdtbuxG11Yzfa2Vm3ky32LTRUNmyoBWJvVi6XIxQKMTg4iMfjIRwOE4+vvGSutraWjo4OXC4XtbW1OJ3ODdW1+1pKSSE/myR5apacJ04hkrlmB6+uyUzFTbXoGs1oLHo0Fj0qo2bNnw+KopAdGqIYiVAIh8n7ZkmdPk3q7FmUdHrl3FtaMHR0YNy6Fet73r2m+W40UvQVQgghhBCbSyIIT/0J9H178bbeAvs/CYd+C0zV5c1NrAujwQRffG6UH1+cJfPKMhpHpZ5fv72dX7ylmaqKjdXNJYTYPDKFDCdnT3I2eJaB8ACX5i4Rz69csHyVWqWmvqKeBnMDjeZGmi3N2I12qgxV1FfW02Rpwm60r9EjWDuKopDJZAiHw4RCIebm5vB4PExPTy+LVavVNDY20tDQQGNjI06nE4fDgU63Ma/kUAol8oEUhXCavC9JbjpGPpSiFM8vDVSBrtGMvsmCvtmyOHe3vgJtlXHNcy7GYqQvXiTT10fO4yU3NUVuYoJiJLJivLa2FuP27VTs20vFvn3o29tBpUZjloW7b5YUfYUQQgghxOaw4IGT/y+cfQxycUAF+z8Fd/5XqNh8b3bFm6coCrPRDC+NzPHj/lmeHw6hKIvntjZY+eC+Jn7xlhaMus13SbMQYv0plAqMLowyFZvCn/TjiXuYz8xf6dx9/axdvVpPg7kBs86MUWukxdJyZSRDm7WNenM9OvXGLF6+FalUiomJCSYnJ5mcnGRhYYF8Pr9irE6no6Ojg66uLurq6qipqcFk2rgz/BVFoRBIkR4Ik74QIh9IgbI8TqVXY+ispmJ3Hbo6E1q7EdUa/21TFIXc6Cipl89RCPjJDA2THRwkPzOz8h1UKnRNTejq69E6nRi3baPy0CEMXZ2oNmjX9XohRV8hhBBCCLGxJYKLM3tPfwmUVy5jdO2Gd/8dNO0tb26irOaTOZ667OfLL00wHEgsOfeurU4+dWcHe1qqNuXlzUKI9SNbzBLLxnh66mme8zzH+dB50oWVL10HqK+s57bG2+ip7mFn7U66qrvQqm+s8k0+n2d6epqhoSGmpqbIZDJEV5jpCmA2m6mtraWmpoba2lq6uro23HK1lSiKQt6bIHnaT3ogvKyLV2XUoqs1oauvROeqROesQN9sRaVb+8ddmJ8n8dzzpC+cJ/nSUfJe74pxupYWTNu3oe/oQN/iRt/qxtDTg3qDzUveKG6s3xpCCCGEEGLzGH8eznwFBn8EpVfeCLUcglt/B7oOwwZ/syfeumyhyJnJeV4YCXHZF+PEeJh8cbEVSqWCLfVW7t9Wz8M7G2ivNZc5WyHEZhXNRjnlP8XRmaOcDZxlMja5LMasM9NZ1UldRR0t1hbsRjvNlmZ67b04K5w35IdRpVKJmZkZTpw4wdDQEIVCYVmMw+Ggo6ODxsZGmpqaMJvNGAybZ06/ki+Rm02QHZ4nfTlM3pe8elKrwthZjXGLHVOvHbVVX7bniZLLkTx5isSRZ0keP0FuYmLJeZVOh2nfXvRNTRi6ujH09mDs6UFjs61aDvHwHIaKCvQmmb9/LVL0FUIIIYQQG0epBAPfh5e/DmPPXj3edDPc9YfQeV/5chNlkS+W+Napab53boY+b5RCaen1rlsbrLznpgY+ut+NrWLzX/4shCiPXDHHEc8Rfjj+Q170vkhRWb5Aa6tjKw+2PshtjbfRXtWOWiUfTr7a0dvX18fw8DDp1yzvMpvNdHV10dXVhdVqxWazYbFYypjt6lIUhcJcmrw3QSGaJTM0T246BsXX/B3TqqjYXkPFHif6Vitq/dqPIcoHAiSPHiPdd4FCaI789BS5qWmU3NIFglqnE+sDD2DcsQPzXXeiMa/eh6vFQoF4eI7Q9AS+oQHGzp5i3ufl3Z/+A7bceueqfZ3NRoq+QgghhBBi/Yv5YPhJOPNV8PctHlNpYO/HYd+vQv2O8uYn1pSiKPTPxPj3l7389JKf2Wjmyrkas547u+vY665mV3MVW13WMmYqhNjMiqUipwOn+eHYD/nZ9M9I5K+OkWm1tnJr460caDjANsc2bAYbeo1cwp7JZPD7/czOzjI9Pc34+DjZbPbKeb1eT1dXF4cOHcLlcm2qjudSKk/WEyfvTZCbjpHzxCmllnczqyu06FttGDurMO2sRVO5dh9YKopCwe8nMzBI6uQJEi+8uKyL91Wamhos995L5cGDVB46iMa6On9vFUUhFgowM3iZwPgooelJfMMDFF83v1mlVhMLBlbla25WUvQVQgghhBDrU3QG+h6HgR+A7zxXNpYYrHDzr8Puj4Kjo6wpirWVzBb47steHj/t4ZIvduV4jVnPf76rk8NbnTRVmzZVkUAIsb5Mx6Z5aeYljvuOcz50noXswpVzdRV1PNT+EA+3P0xndWcZs1w/0uk0w8PD+P1+JicnmZ2dXRZTWVlJT08PO3fupKmpCY1mYy/VVBSFUjxHIZyhEMmQn02SnYqR98aXL1/TqhcXrjlM6N1WTFvsaOzGNfs7pigK2YEB4s88Q/LoMbLj45Ti8aVBKhXGbduo2LcPfasbbU0Nht5edC7XO160loouMNV/gXnfDJEZD9Ggn2gwQDoeWxar1mioaW6ltrUN9/adtO25GWOljGp6I1L0FUIIIYQQ64eigP8iHP8C9H2HJe+OGnbC1vfDnl+CypqypSjWTipX4PhYmJMTEfpnopyZmidXKAGg16q5f1s9793p4vauGoxrvJ1cCLG5pfIp4rk4Y9ExxhbGuDh3kXPBc/iT/iVxVr2V+1vv5z3t72FX7S40avldlE6nGRwc5NKlS4yPj1MqlZact1qtNDQ04HK56OzspKGhYUMvXVPyJbLTMQpzaQrhDOn+OYqRzIqxGocRQ7MFXbMFQ4sVXUMlKu3aPfZSOk1uYoLU2ZeJ//SnZEdHKS4sLA3SajG0t2PcsR3z7XesahdvqVRk+uIFZoYGmBnoxztwCUUpLYtTazTUtXXg6urF0dxCY882quob0GiljPlWyHdLCCGEEEKUX9QLfd+G89+C8MjV4+5b4aZHF2f12prKl59YM/FMnif7/TxxwcexsTDF183oba+p5CMH3HxgdyPVlXKptBBidUSzUZ73Ps+luUucC55jIDKwYpxWrWVv3V5uabiFPXV72Fm7E53mxp4XHo/HGR0dvTK2wePxoChXf3fX1tbS1tZGU1MTbW1tG34ubyldIDsdI+9LkvfGyQzPo+RfV7hUgabaiLbKgNZZgd5lxtBdjda2dkvnirEY2ZERkkePkXjpJQrBIIVgcHE/wmtptZjvvBPLPXdj3L4dQ1sbKv3q/X1Nx2NM9p1j7MxJpvsvkI5Fl5yva+3A2d6Bra4ee1Mz5mo7tS1taFcxhxuVFH2FEEIIIUR5FHIw8ASc+QpMH4dXOz3UOtjyEBz6NDTuKW+OYk0oisLR0TD//MIYJ8cj5IpX35A2Vpm4o7uGnU1V7HFX01VnlvENQoh3RFEUQukQfaE+jniOML4wzuD8IIXS0vmqKlS4rW5aba1sc2xjm2Mbe5x7qNRVlinz9SEWizE+Po7X68Xj8RAMBpcUeQFqamrYsWMHW7dupba2tkyZvnOKoiyOZ5iIkp9NkvPEKQRTy8Y0qC069I0WNNUG9E0WTNtrUBvWruu7GI+T7usjdfIU6XPnyE1OUgiFVozV2Gxo62qxfeARKm6+GUNnB2qjcVXzSS7M03/kaS49/wzzs74l54wWK+279lLf2U3b7pupctav6tcWV5W16PvCCy/wt3/7t5w9e5bZ2Vn+4z/+g/e///1Xzv/yL/8yjz322JL77N+/nxMnTly5nc1m+f3f/32+9a1vkU6nuffee/niF79IU9PVTpD5+Xk+/elP88QTTwDw3ve+l3/8x3+kqqrqOj9CIYQQQgixTNQLZx+Ds1+DZPDqcddu2P2xxc5ew8buAhJvTjyT5+joHJ9/ZoRB/9UZgh21lbxnRwP3b69nm8tWxgyFEJtBNBtlKDLEYGSQM4Ez9IX6CGfCy+LabG0cch1iZ+1O9jr3UmOqQa3auGMHVkOpVCIQCDA9Pc3IyAjBYJBYbPm8VZfLRUtLC/X19TQ3N+NwOMqQ7eoo5YpkRxZIXw6TGZ6nFM8ti9HWmNA1mdE5KzB2VaNrXNsPJPOzs6ROnSI7Nk7ipRfJDgwujsh6fZ51dRhv2kHl/gOYdt6ErqEB7SoW4dOJOHPTkwQnxslnM6TjMfxjI/iGLi+Jq2l207prLx17bqG+qwet7sbujl8rZS36JpNJdu7cya/8yq/wyCOPrBjzwAMP8NWvfvXKbf3r2rt/93d/lx/84Ac8/vjjOBwOPvOZz/DQQw9x9uzZK8O/P/zhD+P1ennyyScB+MQnPsHHPvYxfvCDH1ynRyaEEEIIIZYolWD8WTjzVRj6CSjFxeMVNXDLJ2DXL0JVS3lzFNddrlBiyB/nmYEAT10OMOSP8er0hkq9hkf2NvHh/S30OC3SzSuEeFvShTThdJjh+WFO+0/znOc5vAnvsjiNSkOzpZlbG29lr3MvnVWdtFpbb+jfPYqi4PV66e/vZ2FhgWg0yvz8PNlsdlnsq0Xe5uZmmpubsa7SzNe1phRLlNIFctNxsuNRsqPz5OfSUHhNAVWjWizsuirRu8zo3VY0lrUdPZAdnyDx3HMkTxwnOzRMIRBYFqNrasLQ04Pl3nsxdLSjb29Hs4qjNIqFPBPnzjI7OsTs8CCh6Ukyifg14+taO9j1wHvo3HcAk2VjPj82urIWfR988EEefPDBN4wxGAzU16/c6h2NRvnyl7/Mv/7rv3LfffcB8I1vfIPm5maeeeYZ7r//fgYGBnjyySc5ceIE+/fvB+Bf/uVfOHjwIENDQ/T09KzugxJCCCGEEFdFvYsL2V7+OsxPXD3uvg32fhy2/QLc4LMQN7tiSaHPu8Czg0H+7eQ04eTSjqlmu4l372jgk3d0YJcZvUKItyhfzHPKf4pjvmMc8x1jdGF0xbhGcyM91T3sqN3BXudetti3YNSu7iXtG0mpVCKXyxGPx+nr62NycpJAIEAut7yrVa/X09zcTEtLC263G6fTiclkKkPW75xSVMhNx0hfnCMzMk8hlF4xTlNlwLTNgXGLA32LBbX++o9qUHI5CqEQhbk5MoND5KamyI6MkB0ZoeBfukAQtRrjju0Yu3sw7d5N5a23onPWrWo+yYV5wl4P+WwG/9gwF3/2U5IL88vizI4anG0dVFhtaA0GqpwuOm8+gLVm44712CzW/Uzf5557jrq6Oqqqqrjzzjv5i7/4C+rqFp/IZ8+eJZ/Pc/jw4SvxLpeL7du3c+zYMe6//36OHz+OzWa7UvAFOHDgADabjWPHjl2z6JvNZpd8mrXS5QtCCCGEEGIFpSKMPAXnvrG0q9dgW+zo3ferUCsfvG9m0XSe854Fnuyf5Yd9s8QzV+dkWgxa9riree9OF7d31VBnvXGLLkKIt8+X8PHE2BN8b/R7zCRmlpxTq9Q0mhs50HCA/Q37Oeg6iFV/Y3calkolxsfHGRoaIhwO4/F4yOfzy+J0Oh2tra10dHRgt9upqqrC4XBcuZJ6I1IUhbwvSfK0n/TFOUrJ5Y9bYzNg6KrC2FWFvsmCxm687l3fpVyO9JkzJE+cJHP5MqkzZ1AymZWDNRoq9++n8o7bMd20E0N3FxqzeVXzUUol4uE5xs+dYeTkUTyXLqIoS5e+VVZV07Z7H7UtrTT2bqPa1YjeuDE/ALgRrOui74MPPsgHP/hB3G43ExMT/Omf/in33HMPZ8+exWAw4Pf70ev1VFdXL7mf0+nE/8qnIH6//0qR+LXq6uquxKzkr/7qr/jsZz+7ug9ICCGEEGIzy6Vg8Efw0ucg+JpZbo17Ye8vw/ZHQH9jL7/Z7C54FvjHZ0d4djB4ZWwDgNWo5UC7g/fc1MCD2xvQa2/sGZlCiLdHURTOBs7yzYFv8qznWUqvFKTsRjt3Nd/FQddBbnbejN1ov6HHNLwqlUoxOjrK5OQko6OjKzazabVaWlpa2LJlC42NjdTU1Cwbq7kRKfkS2YkomcEI6cEIxcjVYqq6QouhuxrTthoMrVbUJi2q6/B3SSmVKAQC5KY95D3T5KamyXk85KenKSWT5Hw+eH3hXadDW1WFobsbfXs7+rZWjF1d6Ds70b6u9vV2FAsFpvrOMf7yaeLhEBqtjuTCPIn5MIlIhFJx6TLDKmcDhspKLI5aOvbewpbb70KjlSu0Nop1XfT90Ic+dOW/t2/fzr59+3C73fzoRz/iAx/4wDXvpyjKkl/wK/2yf33M6/3RH/0Rv/d7v3fldiwWo7m5+a0+BCGEEEKIzS+fhuf/Bk5/CbKvvKE02l5ZyvYhaLipvPmJ66pYUniy38+XXhrn3PTCleMum5G7eut46KYG9rc50KilACOEeOt8CR9HfUc5PXuaM4EzhNKhK+f21+/ncOthHu54GJNWug0VRcHv9zM0NMTw8DA+n2/Jeb1eT29vL263G5fLRU1NDRqNBrV6Y38Qp+RL5Lxxcp44xWiWnC9B3ptAyb+mS1WjwrTNQeVeJ4bOKlSa1XvMpWyW3OQU2eFhMv0XSR47TiEcphSPo6zQTf1aGocD8x13YNyyBeP27Zh27US1yj+PVHSBwMQY4y+fZvDYC2Ti176SXaVWU9/ZTcfe/fQcvJ0q58rjVsshmy4QmUkQ8iQIe+PMeRPc8nA77u0bd2ng9baui76v19DQgNvtZmRkBID6+npyuRzz8/NLun2DwSCHDh26EhNYYcB1KBTC6XRe82sZDAYMBsMqPwIhhBBCiE0kNgtnv7q4nC0ZXDxma4HdH4H9nwTTO+9IEevXaDDB98/P8L3zM3giizMRdRoVD9/k4jfv7qCzbvWWxwghbhzZYpbhyDBHPEd4aeYlBiODKFy9dMCoMfJQx0N8pPcjdFZ3ljHT8lMUhXQ6zcTEBKOjo4yOjhKPL12s5XA46Onpwe1209bWtmG7eJV8kZwvSSmRp7iQoRDOUAinKcxnKYTTUFSW3Udt1WPqtWPssWPorEJteOcjKpR8ntTL54j/9ElyMzPkJibJe72LC2tXotWia3Shb3Gjb25G19KMvqUFtdmMztWIrtG16l3phVyO2dEhZgYv47l8EU9/35IxDRW2Krr230ptSyulUpHKqmrM1XbM1Q4qq6vXRSdvqaQQmo7jG1lg6uIc8/4UqdjyedOh6ZgUfd/Ahir6vjp3pqGhAYC9e/ei0+l4+umnefTRRwGYnZ2lv7+fv/mbvwHg4MGDRKNRTp06xS233ALAyZMniUajVwrDQgghhBDiTcqnYfincOHxxbm9r87rtbjggb+ELe+DDd4xJK4tkS3wk4uzfOPkNBc8V7t6bSYdHz9GjqBUAAAgAElEQVTo5qMH3dRZZEavEOLNUxSFqdgUp/ynODpzlJP+kyTzySUxu+t2c6DhADfX38w2xzYqdBVlyrZ8FEUhEAjg8/nw+XzMzMwQiUSW7CKCxXENnZ2ddHd309nZidW6cWcZFyIZ0pfDZMcWyI5HUbLFa8aqTFqMnVVoqgzo6irQN1vQOivecUE1HwySOn6c1NmXyY6Okrl0CeV133MAtcWCoaMD49atmHbvRt/WhqaqCl29E5X2+pbeCrkcM0OXme6/wOzwIL6RQYqv6zC21NTS1LuNLbfdhfum3ajX0YzmTCJPZDaBfzxG2Jcg4ksyP5uiWFheSK+w6qlzW3A0malpsuBs27jP77VQ1qJvIpFgdPTqZs2JiQnOnz+P3W7HbrfzZ3/2ZzzyyCM0NDQwOTnJH//xH1NTU8Mv/MIvAGCz2fi1X/s1PvOZz+BwOLDb7fz+7/8+O3bs4L777gNgy5YtPPDAA/zGb/wG//zP/wzAJz7xCR566KFrLnETQgghhBCvkQjC2BEYfRqGnoTca7qIWg7BLb8BWx4GTfk7Q8T1kc4V+dzTQzx2fIrcK2/CNGoVd3bX8r5dLt611UmFfkP1kwghyihfzPOTyZ/wkvclzgbOEkwHl5yvNlSzo3YH73K/i0OuQ9RVLN/TcyNIpVIEAgE8Hg99fX3Mzc2tGOdwOOjs7KSrq4uWlpYN2c2rKArFcIbM6AKZkXmyY1GUzNL5smqzDk21EY1Vj7bGhLbaiNZhRGs3vuPFa0qhQG7aQ3ZkhNzUFLmpSdLnzpMbH18Wq66sxPLgAxh7t2Do6sLQ0Y7G4VizOdL5XJapC+cYf/kUc95pQhPjFPJLu2Arq+009mylsXcbrTv3YHc1rklub0Y8kmF2bAH/eIzQVIzARAxleaM2hgotzjYbLVvt1LVasTdUYKiQ15pvRVlfmZ05c4a77777yu1XZ+h+/OMf55/+6Z+4ePEiX//611lYWKChoYG7776bb3/721gsVy8V+/u//3u0Wi2PPvoo6XSae++9l6997WtLNkt+85vf5NOf/jSHDx8G4L3vfS9f+MIX1uhRCiGEEEJsIIoCgf7Fbt6Zl2H2AsS8S2NsLbD9A7Drw1ArH6JvZoqi8OOLfv7yxwPMLCyOcHA7Knh0XzMfurmZGrOMQxNCvHnzmXl+OP5DHrv0GIHU1TGMerWe7TXbOeA6wK2uW9lesx216sa7aiQajTI2NsbMzAyzs7PMzs6ivKYaptVqaWpqoqGhAafTSX19PXa7fWMWeUsKhXCavDdBdipGZihCcf51HbRq0LttmHqrMbRXoWs0o1qF+fBKsUhufJzsyAjxZ54hdf48hWAICoXlwSoVxi1bqDx0EH1b+2IXr7sF1Rp1ysbmgngv9zPv9xGfmyM4MUrIM8Xrq6Tmajst23fi6tlC87abqG5oLPsyw0wiT2g6TjZdIBpKMTM0T3gmueKYBovDSE2TGburktoWCzVNZiwOE2rZB/COqBRlpXq6eL1YLIbNZiMajW7oyyOEEEIIIZYplcB7Cvq/CwM/gLhveUz9Duh8F3Q/AE03ywiHTS5XKPHCcIj/8+I4pyYiwOJitj95aCsPbq8v+xtJIcTGEUwFeXb6WX42/TNOzp68Mp+31lTL+zrfx/6G/eyq3YVRe2OOhimVSly6dImjR4/i9/uXnbdarTQ2NtLa2spNN92EybTxFtYVY1mykzFy03HyswmK8RzFhRxK7nXjGjQq9C0WjJ3VGLqq0Dkr3/Ec3lIqRW5qiszAINmhQTKDQ2QGBijFli8zU5lMGDo70be1om9qxrhtKxX79qGx2d5RDm9FPpfFe+kiUxfP4RsZYnZ4cMU4s91B9/5bqe/sxtneRXXD6s8GfisyiTwTfSEWAimioQwLwRTz/iSlwvKSo0qtwu6qpKm7mtoWM/UdNmy1N97Ilrfi7dYk5RosIYQQQogbVXoBLnwLzj4GoYGrxzUG6LgHWm8D126o3w7GtXvDI8qnWFL47ste/tfPRvDOL3b2GrRqPnVnB5+6swOTfv3MABRCrG8vel/kK/1f4UzgzJLjHbYOPrr1o7y3473oNRuvQ/WdymazhMNhotEos7OzDAwMEAqFAFCpVDQ2NtLc3ExTUxMul2vJ0vr1TikpFIIpstMxitEcSqZAbjpOzhuHldoNtWr0rkp0LjPG7moMHe982VoxFiNzeYB0Xx+JI0dI9/VBcfksYHVFBfrOTkw7dmA5fBh9SzNapxPVGn+onU7EmRm8zNzUBDPDA3gvXVwyqkGlUlPf2UWtuw2LoxZbnZPmbTdRWVVdliJvLlMgGkwT9iUITcWJzaUJ+5LEw5kV4221JkwWPRa7AburkoaOKmpaLBhMUo5cC/JdFkIIIYS40STn4MQX4dS/QPaVThe9GXrfA9s+AO13gm7jdRKJt69UUvhBn4/PPzPCxNziAiV7pZ7372rkV29rpalaOnCEED9foVTgRe+LPD70OMd8x64c31m7kzua7uD+1vtxW91lzHBtFYtFfD4fExMT+Hw+AoEA8/Pzy+IMBgMHDhzglltuobKysgyZvnWlVJ6cN0HOs1jULcZzFAIplPzy5VsAukYz+iYz+iYLmmoDGqsBrcOESvPWC5dKPk8hGCQfCFBcWCBzeYDsyAjZ4WFyExPL4jU2G4aeHgy9PRh7el/5d891X7AGoJRKRENBsskE2VSSRCSMf2yEBb+P2FyIyIwXRVn6PbM4amnbtZe6tnbadu/DWlO+mdbJhSyzY1FmxxaYvhRhIZC6ZqyjsRJXVzW2WhO2WhNVzgpsdSa5OqiMpOgrhBBCCHGjmJ+EY1+A89+E/Csv2mu3wJ6Pwa6PgKmqrOmJtZctFPmPl2f48ksTjAQTAFRV6PjUnR18/GCrdPYKId4Uf9LPD8Z+wHeGv4M/uTiiQK1S8+HeD/PxbR+nvrK+zBmunWKxyMTEBP39/YyOjpJIJJbFmEwmzGbzlW7eHTt2YDSuz/EWpUyBYjyHkimS9ycXxzRMRilco7NTpVOjb7EsFnT1GnQNlRg6bGir3v7jy8/MkDx1msylS2QGB8hc6EPJ568Zr2tsxLClF/Ott1J5+x3om67/ErN8NkNiPkIiPEfY68E7eIm56UmioQCFbPYN72tvbKbW3UZ9eyetO/fgaHaXpVCqKAoRX5LpyxE8AxGCkzGyqeVzjo1mHdX1FdS1WLHUGHE0mqlpMmOslCVr640UfYUQQgghNrvQMLz0Oej7DiivXOLYsAvu/K/Q/aDM570BlUoKT1zw8Vc/GSAQW3wzajVq+eSdHfzyoVYqDfI2QQjxxhRF4VzwHP82+G/8dPKnV47bDDYebn+Yj2z5CE2WpjJmuHYSiQSTk5NMTk4yODi4pNBrMplwu9243W6cTidOp3PddfMqRYXCfAYlXUDJFymEM+R8CXJTMfK+5DXvp3UY0TVZ0Ddb0Fj16JwVaGsq3lb37muVcjnSZ86QPHmK+DPPkBsbWx6k06GtrUFdUYFp2zYM3d0YursxbtmCtqbmHX391yvkckxdPE8quoBao0H7yuK8ed8MU/3nmffNkFxY3sH9Ko1Oh8lqQ2cwUmG14WzrwN7YjNnuwNneibnavqr5vlnJaBbfyAKzIwvMzSRYCKRIx5cW01UqsDeaqW+30dxbjau7CpP5xhvLslHJqzkhhBBCiM0q5oOj/wCn/hlevXSw41449NvQftfiK3lxQ0nlCnz9+BTfPDmFJ7I4s7fBZuTXbmvj0ZubsRqlS0cI8cbmM/O8OPMi3xr4Fv3h/ivHd9Xu4j91/yceaHsAg8ZQxgyvn1KpRD6fJ5VK4ff7GR8fZ2xsjEgksiTOZDKxdetWenp6aG9vR7sGYwTejEI0S34mQTGaXfwnliPniS927ZZWGrq7SGXQoDJo0FYZMLTb0LfaMLRYUFe8878ZiqKQm5gg8dzzJE+eIDs0TOH1C+3Uakw33YRxxw5M27dh3LYNfXv7dZu/qygK/rFhvJf78Q0PMtn38s/t1oXF+buV1dXY6upp2b6Thq4ebHVOqpwNqDXlvXJGURQis0n8Y9HFfyZiK45q0OrVuLqqaN5ip7G7GludCb1xfTx/xVsnPzkhhBBCiM1mfhKe/xvo+zaUXrksr+fdcMcfQOOesqYmymNiLsnjp6b5zhkP86nFLh6LUcsnbm/nE3e2Y9DKGAchxLWl8imOeI7w7yP/ztnAWUqvfJBo0Bg47D7Mh7d8mO0128uc5epQFIVwOMzY2BjhcJh4PE4ymSSXyxEOh8lfY6xAfX09breb9vZ2Ojo6yl7oVUoKeX+SvC9BZmiezFAEJbfyvF1YHMugMmhQ6TVoa0zo6irQNZoxdlWhWcXOTqVQIDs2Rqb/EplLl0ieOkludHknr9pmw3zbbZjvvIPK229Hex0X2uXSKTyX+xk/e4qpi+dIRaPks0vHV5gdNdS52yiVShRzOUqlItaaOpztXTT2bMFW34CxonLNF8FdSyFXZPpyhOBUjIgvyZwnQTzyupEcKqhpMuPqqsLeUIndZaauxYJGtz4eg3jnpOgrhBBCCLFZxP2Lxd6XH7ta7HXfCrf9F+h6V3lzE2tOURTOeRb44pExnhkIXDneYq/gt+/p5N07GmSMgxDiDQVTQb4x8A2+M/Qdkvmrl/l3V3dzn/s+PtTzIezG8lya/k4Vi0USiQQ+n4/Z2dkrxV2/308sFnvD+2o0GhwOB83NzXR1deF2uzGZyrcAVSkpZCei5H0JCpEMxUiG3GySUiy3NFANurpKNHYj2ioD6kodukYzuvoKNFYDKvXqXQGkKAqlZIq8Z5rcxATJ4yfIeT1kLvRRSi3tMFXpdJj27sVyz90YensxdnejtlqvSwG1VCziGxlk4IUjhKYmyKSSLPh9KKWlBXGNTkfL9p009mzFfdNunO2d63ohWWwujWcgQjKaY342yVR/mHy2uCRGq1Njd1VS326jqbeahs4qmcO7ycmrPCGEEEKIjW5uFI79A1x4HIqvXH7Yfjfc9YfQcqC8uYmyeHEkxF/8aIBBfxxYnORxe1ctH93fwj29dWg10sUjhFhZLBfj6cmneXLySU77T1N8ZRa8s8LJI92P8HD7wxtuVm82m8Xr9TI1NcX09DQLCwvE43GKxeKK8RqNhubmZlwuF1arFYvFglqtpqamBovFglarLWsnr6IoFObS5LyLc3czQxGK88vHD6gMGvSNZnRNFip21KCrr0ClW90rO5RikczlAdIXLpAdGSE7Okre46EQiUBh+RIwAHVlJcatWzFuWxzVYL79NjRVq79M9tUC7+zwIHPTkwSnJojMeCkVl+dlc9bj3r6Ljpv3Y3XUYqurR7dOl+u9unAt4ksSmIoxMzTPnGf5wkCz3UDLVgeOxkrsDZXUtVplVMMNRn7aQgghhBAblfcsHP17GPgh8Mosvub9cO9/h9bbypqaWHvFksLTl/08ftrDc0MhAAxaNQ/d5OI37+6go9Zc5gyFEOtNSSnRP9dPX6iP0/7TTMWmmIxNXin0Auyp28OvbP8V7mi6A7Vq/X9glE6nmZiYIBwOEwqFmJycJB6Poygrz6ytq6ujsbGRqqoqzGYz1dXVNDU1odeXf1mVUiiRD6UpzKXIXAqTn0ujZIqUsgVKr1+4ZdBg7K5G6zAudvJWG9G7raj1qz++Jzc9TerUKVLnzxP/6VOU4vFrxqptNvStbozd3Ri378C0axeGzg5UqzjjVlEUCvkcqYUF0vEY3oF+AuOjTPadIxNf3rWtN1XQvudmuvYfwlhpprqhEYtjdZe/rbZsuoB3MMLM8AJTF+eIzS0f1dDYVUWVs4LKKgPNW+04W63rujtZXH9S9BVCCCGE2EhKJRh4Ao5+Hnznrh7vfhBu/Z3Fzl55gX9DKRRLPHU5wOefGWY4sNjpo1Wr+NhBN79zbxdVFeUvXAgh1pep2BQ/Hv8xP5r4EVOxqWXnO6s6eaj9Ie5puYc2W1sZMnxzEokEwWAQv99PJBIhGAzi8XhWLPDabDaam5tpb2/H4XBgtVqxWq1oyr1gq6RQXMhSXMiSD6UoBFMU5tIUE3nys8lrL1jTqtA3WtA3W9C7LRi77agNq/9YSqkU2dFRSskkyeMniH7/+xQCgSUxqooKKm7eh7GnF0NXJ/rWVrQ1NWisVlQVFateeMznssz7ZoiGAviGBhg6/iLxudCKsUazhaYt26lrbcfR3IKzrRNrTe26mb17LaWSgm9kgcmLc/iGFwh7E5Re81zQ6tTUNFuwN1bS1F39/7N358Fx3ved59993/cJNIDGDQK8D1ESdVrWYStxnDieSWJncmxmsplNYs9UZWo3Ndk/ZjNbmZ2ZbM2mypVJYsdxOXHixHFmbMVHbMs6SVGUeAMg7qNP9H1fT3c/+0dTJEEQ1EWwQen3UrEoPf17Gr+HAgH0p7/P90vvuB2T7YM5QFF470ToKwiCIAiCcC+o5uD8X8GZL0JmuXNMqYED/xxOfA68e7q7P+Gum4kW+N7lGH9/NkIkVwXAZtDwc/f18/P39TMsKnsFQbhBvVXnr2b/iueWn2Mhu3DtuEFt4Lj/OIe8hxh3jDNiHyFgDnRxp9uTJIliscjKygpvvPEGsVjsluucTid9fX04HA76+/vx+XxYLJa7vNut3mrLUF/J01grIkWKSIkKbD9fDYVejdqlR9tnRjdkQ2nRotSqUHuNdzzklWUZKRKhevYslbNnqZ47T315GW4eXqdWYzh0EN3oKNZnn8V45AiKHWx3Icsy8cV5ls+dYWN5kdD0JZqNre0sVBoNWoMR//AovRNTeIeG6d97AI323ghDZVkmG6+wfC7B9CtRSpnN12j3Genf4yAw4WBgrwvNDoT8wgeLCH0FQRAEQRB2s1wIXv8TeOPL0Ljar01ng/v/V7jv18Di7+7+hLtKlmXOrGb5f38wx2vLmWvHHUYNv/hAkH/58DA2oxjKIgjCdc12k++ufJcvnP8CkVIEAJVCxQO9D/ATQz/BEwNPYNKYurzLzVqtFoVCgXq9TjweJ5vNsrKyQjgcpn3TwC2n04nH48Hn82G32wkGg7hcri7tfDNZlqEN9dU81Usp6gtZmuna1oVKBSq7Do3HgNpjRO0xoDJr0fSYUDl0O3aLvizLNBYXKb34IpXz56leuEArmdqyTuVyoTSZ0I2NYX3maSwf/ShK085+zsjtNuEr0yycPsnK+TfIxTcH/HqzBZvXhyvQz/DR+wnuP4TOZLqn2hnIskw+UaVSqLN2Oc3i2SSFZPXa4zqTmsF9boL7XfiHbVicu7PHsLB7idBXEARBEARhN5FqsPxjWHsVFn4Iydnrj3kmO2HvgX8O2t31Al3YWe22zJnVDP/thwucWk4DoFTA8SEnP3/fAB/b50d/h4fzCIJwb0tX03xz4Zt8fe7rbFQ6t+O7DW5+89Bv8lTwKWw6W5d3CM1mk2q1SqPRoNFoEAqFmJ+fZ319nUajcctzNBoNDoeDQ4cOcfDgQUw7HD6+G+1aEylRoXYlQ20+ixQpXWu5f41KgXbAim7QirbPjCZgRmXRoVDdvbCyeuEC+W99m9ILLyBFIpsf1GjQT01iPHwEw+HDGPbtRd3bu+NhaimbITo/S3jmMqnQGsnVZWrl68PJ1DodQ4eO0js+SWDPFP6R8Xsq4H1LOVdnY6VAYr3A8vkU2Vh50+MqtZLeMRsTD/QwcsSDWnxvF94HEfoKgiAIgiB0W2oR5r8HKy91wt7GTROYgw/DA78BE8+CUvzw/2FSqjf5xhshvvTqCqFMp/pHq1Lys0cD/PYTY/TaDV3eoSAIu8lCdoEXQi/wQvgFLiUvIV9NHB06B/9i6l/w2cnPYtQY7+qems0mS0tLbGxsEAqFqFQq1Ot1KpUKlUrltucqlUr6+/txuVz4/X5GRkZwOp1dDftkWaaVrlGdTdNYLdCIlWnl6iDLWwPeqxR6NYZ9LgyTLnSjNpS6uxfFyK0W1QsXKL34EtU336S+skIrnb6+N50O4/HjmE6cwLB/H/p9+1Dqd66itFGrsrG0wMbyIqVshnxig43lRYrprT15NXoDY/c9wNCR+xg+ch9a/b3zPS+XqBC+kqWQqlJM1zq/Z2pUbxrAp1QrMFq0+IdtDB/2ENznQqsXUZ1wZ4jPJEEQBEEQhG6Qqp2Q98yXYOGf2PRK0RqA0Y/C4KOd343Orm1T6I71dIUvn1zh794IU6o3ATDr1PzkgR5++6NjBETYKwgCILUlLqcu84O1H/DmxpvMpGc2Pb7PtY/PTH6GpwefRqe6O31NG40GyWSSmZkZlpaWSCaTtFqt256jVqvRaDTY7XYmJiaYmJjA5/OhUCi6H/BmajRCReoreaRYGSlRRa41tz1HaVSjG7Khn3ShG7SiMKhRGtQolDt/HY1QiPrSEo3FReoLC9QXFqkvLyPXNreUUGg0WJ/9OOYnPor50UdQGnbue0q71SK5tsLimVNsLC+yevEccntrE2OFQokz0Ef/3gO4+wfwBIfxDY+i2sFewXdCMVMjHS6RChcpZutkY2WKmdqWfrxvUSjA2WvCG7TiG7IyetSLTrRlEnbI7v7bIwiCIAiC8EHRqED4dVh9BVZfhcgb0Lrh1tXBR2DsaRh6FPwHYJdPlRZ2xsVwji/8eJEfzGxcG9g+7DHxqycG+fTRfgxaUektCB92xUaR59ef53ur3+N07DRS+3rloFqp5kTvCR7re4zH+h7DZ/Lt2D4ajQaFQoFEIkE8HicSiZBMJikUClvWms1mhoeH8Xq9uFwu9Ho9BoMBs9mMTqdDo9k9oVe73qQ2m6F6JUN9KU+7eIs2E0oFuiEr+nEHap8Jjd+IQqlEoVPd8eFqm/dWp7G6RmNpkWYqRatUopXL0UpnqLz+Os3k1mpZAKXFgumhhzA//BC6yUl0g4M71pNXqtWILlwhubZCePYyoelLNKqbK7otLg++4RFsvh4sThee4DD+kVG0hrtbhf5uyLJMJlpmfTpDdqNMLl4hEy9TL2//BkDvmB13nxmLS4/VbcDs0GH3GUUlr3DXiM80QRAEQRCEndCsQ+g0LL8A4TOw/trmkBfA0gN7PwVHfwU8493YpbBL5CsS/9+PFviLkyvXwt5Hxz382sNDPDrmvif7FgqCcOdUpArPLT/HS+GXOBk9uSnotWqtPNL3CCd6T3Ci9wRug/vOfuxKhXA4TDgcJpFIUCgUKBQKlEqlbc8xGAwMDAywd+9e/H4/LpcLlWp3vWklN9s0MzUakRLNjTLtapNGpIQUK0PrhrtvlAq0ATOaPjPaPguaXjMajwGFeufenJVlGbnRoLG6RuX0aerLS1TPnac+P99pI7EdpRLdyAi6sTF042PoRkfRjY2h6etDsUN//u1Wi/jSAtG5GRbfOE1s4Qrtmyq7dUYTgcm9DB44TN/kPjzBoR3Zy50iyzKVfINCukZyvUg6XCR0JUvxVkP4FODwm/AGLRjMGjxBC1aXAavbgNGqvfubF4QbiNBXEARBEAThTinGYeZbMP0PEHkTWjfd2mcNwODDnV/Bh8A53LnPT/jQiuSqfPmVFf7mTOhaG4dPHOzlc0+MMuazdHl3giB024XkBb4681V+vP5jGu3rbxwO24b52NDHeCb4DEO2oTv+xlCpVOLKlSvMzMywsrKCvE3QqFar8Xg8eL1e+vr68Pl8uFyuXTVcDa62acjWqS/lqM1naYSKnT6821C7DRj2utAO2dCP2nc04AVolUrU5+YovfIKldfPUJue3tKS4S1KiwXd8DDq3h6UBiNqlwul2dwZvnb0KErjzlXLtpoS8aVFwjOXyERC5BIbJFaXaNY3/1ma7A78o+P0jO0huO8g3uERlLtwJoEsyxTTNUKzGWKLeeIreZChUmwg1ba2JFGplfRNOvD0W3D2mLB5Ddi8RnQGEa0Ju5P4zBQEQRAEQXg/2u1OJe+Fv4bzX9sc9Jq8MPIRGHigM4zNPSZCXgGAC6EcXzm5yrcuRGleLe3d47fwu89O8ti4p8u7EwShm5rtJi+EXuBv5/6WU7FT144PWAY6Qe/gM4zZx+5I0Ntut8nlcoRCIdLpNJIkEYvFWFtb2xT0Op1O+vv76enpwWazYbPZsNvtGAyGXXknwrVevOEitYUc9eU8rczWEFWhUXYqd3tMKA1qND4j2gErKodux66rXalQX1qiXSxSX12l/OpJyi+/jNzY2kZCaTKh37sXw8GDaIeGMN53rFO1u8N/5lK9RjGdopLPkQ6HyMajJFeXiC7MbQl4AbQGI/1799M/dYDBg4dxBvp31eeFLMtUCg0y0TKZaJl0pEQuUSG3UdkyWO1GOpMaX9CKu99Cz6iN3jG7aM0g3FPEZ6sgCIIgCMK79VZ/3iv/CLPfhmLs+mOBYzD5kzD5U6KSV9hiJlrgv/1wnn+a2bh27MSIi19/dJjHxj276kWyIAh3V0Wq8M2Fb/KVma8QL8cBUCqUfGL4E3xm8jPsce5BqXh/FaeSJDE7O8vS0hKhUIhsNrttFW9PTw9TU1NMTU3hcrne18fdaXJbphEqUpvLIMUrSJEirfxNIaoStP1WdCM2dCN2ND4jSoMGherOf91tZjLUpqdpJpLUl5eQ1teREgna+QKNUAhuMdhO7fOhn5rC8uSTGA4eQO31ojSbUexQj/9WU6KYTpNaX6VaLCC32+QScZbOvEY2Hr3lsDUAg9VGz+g4vRNTWD1evMEhnL19O7bPd6tWksjESqQjnYA3EyuTjpa27b2rVCrwDloITDjoHbWj1qnQGdTY/UZUqt1xTYLwXonQVxAEQRAE4Z3IR2DtJJz9SqdX7439ebUWmPgYHPnlTusGEdwJN3ltOc2XXlnhB1fDXqUCPnkowK+cGORgv73LuxMEoRtkWSZcCvP8+vO8Hn+dNzfepCyVAbBoLfz8xM/zydFPErQG39fHyOVyLC8vs7i4yPLyMvWbKjWVSm3Hq68AACAASURBVCV+vx+fz4der8dutzM+Po7D4Xhf17dT2vUmUqRMM1tDipSQkhUa4RJy9aZQT6VA4zWiG7GjG+4EvTs5ZK2xvk7+29+mcvp1KmfPQnP7AV8qtxuV3YamtxfDwYNYnnwK3fidqd6+WbvVIrm+SiGVIBeLsj59kY2lBarFrQP3bqTR6dEZjXgGh7H7enAPDOINDuEb2Zl9vhtSvUVsKUcqXKJalChnaxTSNfKJKrXyrSt3FQqweY04e0w4e03YvQYcV/9drdl9rScE4U4Qoa8gCIIgCMJ2qjl488tw7i8hvbj5MaMLxj8OUz8Fw4+DWteNHQq73GKiyH/9/jzfm+5U7SkU8JMHevn8R0cZ9YqevYLwYdNoNbiUusQ/rf4TP1z7IYlqYtPj/ZZ+Pjv5WX5m9Gcwat57b9Z4PM7Zs2eZnp6mXC5vesxqtXLgwAECgQC9vb1YLBaUu6RK82ayLNNK12imq7TKEpU3N6ivFjYPWrtKoVehH3egC1pR2XToxuwodXcu8mjX69TnF5BC6zTW1pA2NmisrdHKZGlubNDK5Tat1w4Nofb70I2Moh0cROP3obRY0fb3oentvWP7eku9UiYXj5GJhkmsLpNcWyETDVPJ52hJtw5ClSo1dn8PNq8PhVKJVm9gYN9BBg8dwexwdSXclWWZalEiEyuTi5cp5xvkk1XKV3swS/UWqXAJub39QDuLU48zYMLVa8LZa8bZY8LhN6LWinBX+HARoa8gCIIgCMKN2m1YexWmvwkX/xYaV6eTK5TgP9AZwLb/Z6HnMOzSF8lC9y0lS/zRjxb49oUobbkT9n76SB//8pFhJvwi7BWED5NWu8UrkVf4xsI3eD32OpVm5dpjKoWKo76jnOg9wXH/cfa6977rFg7NZpNwOMzCwgKhUIhcLkehcL2KU6lU4vP5CAaD7N27l0AgsHtD3mab2mIOKVxESlSoL+dpl7YGliqbFqVZiy5oReM3oek1oekxobgDt+O3y2WkaJRGKEx9cZHG6iq16WnqS0u3rd5FocB04gSWp57CePw+dMPD73svtyLLMqVMmtjCFQrJBJlYhPVL58knNrY9R2c0YXa6cAb68I+ME9x/CIvbg8Fs6UpbBlmWqZUl0uES+WSVSqFBKVcnG+u0Y9iuFcONzE4dvkEbZocOo02L1WXoDFbzGETfXUG4SvxNEARBEARBAEgtwMWvd37l1q8f907Bg78Fe54Fw+681VXYPWL5Kn/8whJ/dXqd1tUqpKenfPzOMxOM+0TYKwgfNicjJ/n9136fcCl87ZhRbeSjAx/lqeBTPND7AAa14V09Z6vVIhKJsLq6ysrKCqFQiOZNYaRSqWRiYoKjR48SDAbRaDR35HruBFmWkeIV6ks55HoLZJlWsUEr36C+WkCu3RT4KRWo7DqUBjX6PU4Me12dgPd9VKG2q1WaqRS16Wmq587TCIeRYlGakSitfH7b81R2O9rhYTSBANr+PtReL5pAALXHg7a/H6XJ9J73tGl/V1syxBfnySc3qBbypEJrFNMpqoU87Vv0BAYw2uw4enpxDwzhHRzCFRjAZHdg9XpRKu9ulWu9IlHONcjEykj1FvWKRGwpT2KtQClbh+0LdUEBVrcBp9+IyaHH6tJjceqRkVFrVLj7zFhc+q63mRCE3U6EvoIgCIIgfLgl5+H534fZb10/prXA3k/Cvp+F4Y+IHr3CbcmyzJnVLF85ucr3puPXwt4nJ738myfH2RewdXmHgiDcbWWpzH8581/4+4W/B8Cms/HTIz/Nx4Y+xqRzEtU7COBkWSYWizEzM0Mul6NUKlEsFikUCkg33a5vMpkYHh5mZGQEl8uF2+3GYHh3YfJOaDeuhrqFBrUrWeoreaRIiVa+vu05SqsW/Ygdjd+Ips+CbsCC4j30XJVbLaRIhMbKCvXllc7vS0udlgyp1G3PVVqtaHp70Q0Pox0aQj+5B/3evaj9/jsaNMqyTCG5QTocolosUMpmiMxeJjI3S6Na2fY8hUKJZ3AIR08Aq8dL79ge+qb2oTeZ79je3k67LdOst9DoVRTTNRJrRdKREplomfhKnsrNg/RuwezQ4egxYXHoMNp02H1G0YpBEO4gEfoKgiAIgvDhVIjBj/8jnP8ayG1AAaNPwsGfh4lnQfveeykKHw7ttsw3z0X44svLXIkXrx0/PuTkc0+M8fCYu4u7EwShW26u7v25iZ/j80c+j0W7fbW/LMvXAt3l5WXC4TDxeHxTm4YbGQwGBgcHGRoaYnBwEI/Hs2uqHlulBuXXYlQuJmkmqrdepFSgH3egsmhBAUqjGpVDj9qhRzdie8dtGmRZpplIUD1/ASkcoplMUbtyhWYqibS2jrxNL1sAhUaDdmQE45Ej6MZGUfv9aHoDaAK9qMw7E542qhVWzr/J+qULLL15mmqxsG3VrtZgxD86jrtvAIPFir2nF4e/F6PNjsFiRa3V7sgeb9SUWkTnc52WC5UmhVSVRq1FrdQgFSrRlNoolQra2/TX1ehVOHxGtAY1Ko0S/7AN/7ANq0uP0aoVwa4g7DAR+gqCIAiC8OFSycDLfwhv/DlIV6toJn4Cnvg98E11d2/CPePkUor//L05zoc6g3t0aiU/czjAL58YZLLH2uXdCYLQDbFSjD8690c8t/wcAD6jjz945A+4z3/flrXtdptsNsv09DQrKyukUimKxeKWdSqVij179hAIBLBYLJjNZkwmEy6XC5VqdwRmcrNNbSFLI1SkESpSXylAs71lnTZo7bRm6DWj7beg1L2z/cuyTDMapb60RH1pmcbqKlIkghSLIYXDyPXtq4YVWi3awUG0w8NohwbRDQ2hHRlBGwigtNl2PChvt1ukwyFmX/4x0fkrbCwt0JRuqoBVKHD3BzHZHehMZmweL8OH7yOwZ+qu9NuV2zL1apNqsRPkZuJlCqkqpUydxGqBprT1/+WN2m0ZhVKBp9+MM2DG4TPSM2rH1WtCaxCRkyB0k/gbKAiCIAjCh0N6CS79HZz6AtSvVk4FjsHH/gD6j3d3b8I945WFFH/0/AKvr2QAMOvU/OvHR/jM8QEcpp2vuhIEYfdptVv894v/nS9d+hJSW0KpUPKZPZ/htw7/FibN9R6v2WyWpaUlUqkUly9fplQqbXoehUKB2WzG5/MxNjaGz+fD7/ej1+vv9iW9rXajRX0hS3U6TXUmjVzbXK2q6TVheaQP3agdhVaFQq14R9W7cqNB7coVWvk81UuXaCwuUb18GWl9ffuTlEp0Y2PoxsdR6vXo906h6etHOxhE09OD4i6F4/VKheT6CvmNOMm1FTaWF9lYWUKqba52tvn8jBy9n8EDh3EG+jHZHXelardekchEy2Q3KoRnM6SjZarFBrWShHyb/romuw5v0ILBosXq1qM3adDoVbgCZswOPfWyJKp2BWGXEqGvIAiCIAgfbIlZeP4/wpXnrh/z74eP/B6MPQ27dIK5sHvIssy5UI4//Kc5Xl1MA6BRKfiF4wP85kdG8Vl3XyAjCMLOa7VbfG/1e3zp8pdYyC4AcNx/nM8f+TwHPAdoNBrMzMwwPz/P+vo6mUxm0/lKpRKfz8fhw4fx+/34/X60dyH8e6daxQb1lTztYoNWWUKKlWnl67RLEq2SBDfc0q+0aNFPOND2mNAOd/rxvl0VbbtcphEOU5udRYpEqE3PUH7tNeTKLXrZqtVoBwbQjY6iHRlGGwig9vegHehH7fOh1Onu9OW/rXa7RWxhnsUzpwhNXySxsowsb62K1ej09E3tY/z+h/AEh/AOjex4hXG92iS+lCcVLrKxUiC+UqBauH2PXY1Ohc1rwDNgwe41YrBo8A3acPTc/v+lTlTzCsKuJf52CoIgCILwwdNuwcIP4MyfweIPrx8fegyO/BLs/ZQIe4W3Va43+faFKF97fZ2L4c40d41KwWfvD/KvHh0mYO/+kCRBEO4+qS3x3NJz/MnFPyFSigBg0Vr4d0f+HftV+5k5NcPpjdPEYjHa7c0hYDAYxO12Mzo6ytjYGGr17nhJLrdkGpEizUSl06ZhvYgUK9/2HJVDh37CifGAB+2gFYXy9kGmlEjQymYpfOe7FL773W2rd1U2G0qrFf2eCfT7D6CfGMdw6BAqW3eHYrZbLWKL8yRWFoktzLF68RzVQn7TGrPDiTPQhzPQj39kHN/wKM5AH8p3MLjv3apXm2SiZTLREtl4BanRopSpk0tUKKSqcIvqXbOjMyzN02+hb9KBwaLFaNWiN2lQqcXPRYLwQbM7vsMIgiAIgiDcCZUMnPsqnPkS5NauHlTA5E/C478Lvr1d3Z5wb6g0mnz11Bp//OISuUpnCJBWpeQTB3v5N0+O0e8UQ/4E4cOo2W7y3PJz/OnFPyVUDAHgUDn4lPNT9NX7WPifC1yoXNh0jt1uZ3JykqGhIfr7+zEYuv9mkSzLNJNVpHiZZqKCFCtTW8oj15pb1mp6TKjsOpRGDdo+MyqHHpVZg9KiRWXV3rYCtJlOU5uepjY3R/GHP6R24eKWNUqrFd3ICNrBQTS9vZgfexT9/v1dHUrXajZJrC6RXF2hnM+Si8fIREKkwyGkem3TWp3JxODBo4wcPU7f1D4szp0Z4FkpNNhYLZAKFYnMZ8knqpSy2/cyBrB6DLh6TfSM2PGP2HD4jOjNmh3ZnyAIu5MIfQVBEARBuLfVS7B2Ei7+DVz5R2hefUGmt8PhX4T7fg2cw93do3BPqDdbfPdSnD/47iwbhc6L6aDLyGfvH+Bnj/ThMt/924cFQei+jfIG31z4Jt9e/jahQgiLZOGh4kP01nuRGzK5xRw5OkMdTSbTtZDX7/fjdDq7GmACndYM0RL15TxSrEwjWqJ9i1v9lUY1aq8RbZ8F7YAF3ZANleX27Saa2SyNlVXq83PU5uZoF4o0U6nOoLVweOvHsFrR79mD/Wc/hemRR1A7nXfsOt+rVlMiNj9HePYy4SvTROdmt4S7b9GbzPSMTeAfHadvch+BPXtR3aFq7WajRT5VJTqf64S6uTrFdJV8qkq9vDWQh07lrrPHhKPHhM6oxmjVYvcacfSYMFp3T6sQQRC6Q4S+giAIgiDce1oSrJ+C1/+0E/Te2EPPvx+O/zrs+zRoRUWm8PZqUou/fG2NP35hiXS5E4T0Ow187okxfuZwAPU7GD4kCMIHz6XkJb4681VOLpykp9TDYG2QA80D6JudPt5tOt97PB4PwWCQyclJgsHgrmjZ0Co2qM6kqZxN0FgrbF2gVqDxm9D4TGh8RrRBK9p+y21bNDSzWUrPP0/59GnKL71Mu15Hrla3XY9CgbrHj+HAQYzHjmF56ik0Pu8duLr3TpZlqsUCoelLLL3xGplomGwsQuOm69CbzPjHJjDZHNh9fpx9/Th7+3D29qG8Q4PhmlKL9csZMrESodks8aU87fY2E9UU4Owx4e434w1a8Q5YcPaa0BlF5a4gCNvr/ncjQRAEQRCEdyofgTNf7LRwKCevH7cNwMhHOv16A0ehy1VVwr0hX5X44svL/NXpdTJXw16PRccvPxjkf3l4CKNW/KgsCB8m7XabjeQGz888z+tXXkeRVWCRLDwpP7lpnUqlYmhoiBMnTuDxeLBYLF3a8WaNaInqpRT15fyWoFdl06IdtKEbtHaC3j4zSu318LJdqdBYWaaVz9PK5WkV8rQLBeoLCzRWVmmEwzTj8Vt+XHVPD7qREfSTe1DZbKh9PtQeL/qpSVRW645e83bkdptqqUhieZHE2grFdIro/Cy5eHRLwAtgtNnpm9pP3+Re+ib34e4bQHGHe//LbZlitkYhVWP9cppLL4RpSpt7Pmt0KryDFrwDVow2LVa3AZvHgMWlR6sX35MEQXh3xFcNQRAEQRB2v0oGXv5DOP0n0O70WMXohqFH4KHPQ+/h7u5PuKdkyw3+x/kIX/jxEqlSp41Dj03Pv31ynE8dEZW9gvBhUKlU2NjYYGNjg3g8zlJ4iUKmgKLdedPQgePaWqVSSTAYZN++fbjdbnp7e9Foul9h2czVaKwVkeJlpGiJ2nz2+vAuBajdBowHPRiP+lA79NfOk2WZVi5H5bVLlF55heq589QuXwZ5myrTG+jGRjE9+iiWxx9H7fWi9nhQGrtzV0271aKUSVNIJykkE8SX5slvxCkkE+TiMZrS1hYWbzG73Ew+9Bi945NYPV7cA8H3NWxNlmWkeotiukYhVaWcb9CoNqmVJfLJKhsrBRq1JlKttek8vUmDf8RG75idkcMeLC5919uBCILwwSFCX0EQBEEQdidZhtDrcOFrcPFvQap0jgcfggf+NYx/DFTdf9Et3Ds2CjW+9MoKXzm5Sr3Zqa4a9pj4nacneHrKJ8JeQfiAKpfL18LdaDRKOBwml8ttWadAQVPRpKKv4PV5efzg44wNjOFwOFDe4arPd6tdb9JMVGlmqkiJKpXzCVrprX1n9ZNO9BMODJMuVLZOH3JZkii99BKlF16genmaxuIi7Uply7lKiwWVw4HKakVls6E0mdAODqIbG0PtcaObmEDtcGw5b6e12y2SqytE52dJhdbIJzZoVCukwyEa1a3XcSNHTwDv4PDVYHcQ3/AoVo8Xjfbd92iX2zLpaJn4cp5MrIxSqaCQqpJPdn61bqravRWFUoHVpcfZa2Lifj/Dhz0i5BUEYceI0FcQBEEQhN0lF+oMZTv/15BZun7cvx8+8u9h4uPd25twT8qWG3zxlWW+9MoKtasvyvf2WvnUkT5+8YEBdOo7059REITukWUZWZap1WokEgni8TiRSIT19XXy+fwtzympS+S1efLaPJJR4sHxB3ly8kkOew93PYiTm20akRKN9QLV6TSNUBFaN1XiKhWoPQZ0g1bUTj36PU40PhOyJFGbn6f63Hkqp1+ncu4srWRqy8fQ9PVhevBBDIcPYzx+HG1f4C5d3e3lE3HCs9OsXzpPKrxOLh7bNtxVqtRYXC4sLg+e4BCuvn5sHh8WtweTw4neZH7XH79Wkogt5ylna2RiFcq5OrlE5R0FuyqNEmePCZNdh96oRqNXY3HpcQfM6C0aHD4jaq34niMIwt0hQl9BEARBELqvnIaF78PFr8Pyi1y7P1VjhKmfhkO/AIOPiF69wruyUajxl6+t8eVXVynVO5PPD/TZ+PxHx3hij7froY4gCO9cvV4nFAoRj8ep1WoUi0UKhQL1ep1SqUStVqPR2P52/rK6TE6bI6/Nk9PmSBqS6HQ6Hu17lI/3fJyPD30cg9pwF69os1ahQX01T30lTzNRobFeRL4pYFSaNKgcOtQuA7phG8ZDHpQ6dWc42fnz5L7xLSpn3qB64cKWAWsqpxPLU09huv84uvFxNP39KHXvvtp1J1SLBTaWF1mfvsjym6+TDq9vWaM1GAlMTOIdGsHu60FnNGHz+d93W4Z2WyYb61TvxlcKbCznyca3rx5WaZT4h614BqzIsozVpcfmNWLzGDBatWh0KvG9RRCEXUOEvoIgCIIgdEdmGa78I8x/H9ZPQbt5/bHBR+DgL8DUT4FudwzIEe4dZ9ez/MWrq3znUozm1UnoY14zv/NMp42DeEEuCLtbvV5nbm6ORCJBKpUimUySTqff8flldZm8Nk9WmyWjy5DRZzDoDRzxHmGvcS+TzkmO+Y/RZ+5Dq9Lu4JVsJbfa1BZyNJMV2mUJKVGlmajQTG0dLqY0adAOWNAN29BPulBf7ffaTKWonD3Lxv/9KtULF5AiEdql0uZzrVYM+/djvO8YhoMHMR49ikJ7d6/1dqRajejCFa68+hKzLz9Pq3n9ZwCFUol/eAzfyCgDew9i7+nF1df/nsLdptQin6hSztUp5+tUixK1skS9LFFI10isFmjc1GcXwO4z4vAbsboNnWFqXgN2rxGLU4dStAISBOEeIUJfQRAEQRDuHlmGlRfhpf8Kqy9vfswzCVOf7FT1Oga7sj3h3iTLMpFclVcXU3zt9RAXQtd7dR4fdPIrDw3yzF4/KqUIewVht8pkMiwsLBAKhZibm0OSpC1rdCYdWpeWvJwnK2cJN8OU22Wq6ipNZZOmoklb0UZSSQzZhphyTXHQc5Axxxj73PvQqe5+ZavclmkmKtQWc9SXctSX88j1rSEjCtD0mtH2W9AGOr+rfUbkRoPq+Qvkv/GP1JeWaCwvU5udhfZNVcBGI6ZHH8X0wP0Yjx5FOzKCost9iN9SzmUJTV8kFVojubZCbiNOfiO2Kei1enz4R8cZPXY/wQOHMVpt7+i55bZMJlYmGSoSW8xTytZpSS3aLZlWs006Wn7blgxqnQrfoAXfkA3/sA3/kBWDZfcE5IIgCO+VCH0FQRAEQdh57VZnGNupL8DGpc4xhbJT0TvxLIw+Ce7R7u5RuCcUahKLiRLxfI1Itsqba1lOLafJV68HRFqVkp861MuvnBhkX+CdBQeCINxdrVaLUCjE/Pw88/PzpFKbe86qTCrSpjQJEmwoN8hr89RV9c1PogG1Us2QbYhR2yh9lj6O+Y9xwH0As/bd93J9P+Rmm1ahgSy1qC3kkKIl2pUmjVCRdnlzgK0wqNEN2VBZtWg8BtReI5peMypTZzipLMtU33iDxH/+a0ovvbylihdAOzyM6aGHMN53DG0wiDYYRKnX35VrfSfqlQqzL/+Yiz/8Lsn11Vuusbg8BPZMcfDpZ+nbs/cdPW9TarGxXCATKxOZyxJZyFErbX2D4EY6oxqzQ4fRpuu0YNCqMNq0GCxafENWXL0mUb0rCMIHkgh9BUEQBEHYOeklePPLcPkfoBDuHFPr4cgvw4P/m6joFW6r2Wozt1HkYjjPpUieK7EC50I5ZHnrWrVSwVSvlacmffzC/QO4zbujV6UgCB2SJBGNRllbW2NtbY1IJEKtVru+QAGyXSatSXNZdZm0Lg03FOfrVXpGLaMEzAGmXFMM2YYYs48RtAXRKDV39VpkWaaVqdEIl6gtZJEiJZrpKnLj1hWlCo0S7ZAN/Ygd3YgNTa8ZxU13HkgbCXJ/820q585Rn5lFikavPab2eDAcPYp+zwTakRH0k1O7ZujaW2RZJhePsnrxHMnVZeZOvbJp+Jp7YJDAxCSuvgEcvX04/L1YPbfvrS7LMqVsnehCjuhCjsRagUykTLu9+ZuAWqPEM2DBG7Ri9xvRGdUolQoUSgU2rwFnj0m09REE4UNJhL6CIAiCINx54TfhzJ91qnvlq7exGpxw4rfh2K+CwdHd/Qm71lq6zA9mNnj+SoKz61lqt7gtt8emJ2A34LfpmfBZeHDExb6ADb1GTEQXhG6SJAlJkqjVamQyGUKh0Kbha+2bWhK01C2i+igRQ4SEIYGk6lRsqhQqHg88zhMDT7DXvRevwYtdb+/GJdGuSEipKs1kFWmjghQp0oiUkWvNrYvVChQqJdqAGd2IHaVZg8ZrRNtvQaG+XkkqyzL1xUXKp09Tn5unvrhI9fz5TS0bFEYjtp94FvunP41+3z4Uqt3x9U1utynlMuTiMZJrqxSScbKxKPGlBSr53Ka1zt4+Dj79LFOPPIHevH3ldVNqUcrUSUdLpCNlqoUG2XiZdKRMrby1itdo1eIKmOgddxAYd+ANWlCpRaWuIAjCzUToKwiCIAjCnbMxAz/6DzD/vevHRj4KR34Jxj8Gmt1z66nQfbIss5qucHo5zWvLaU6vZIjla5vWWPRq9gdsHOy30+8w8uCIiyG3qUs7FgThRuVymfX1dUKhEOvr64TD4duub6lbbOg3SOgSZHQZstosKDotGqacUxz1H+WA+wAHPQfxGD136So2k5ttaos5ajNp6it5msmtA9YAUCnQeIzohm3oRmyo3QbUHuOWCl4AaWOD+pUrlE+eonLuHFIsSiuZ2rLOcPQo5scfQz8xgeHIUVTm7n6tq5VKbCwvEpq5RHRuhnxyg0a1Sq1UvOV6hVJJYM8UvqFRBg8dJbjv4LW+wq1Wm1KmTrXYIBMrk4tXyCUqJENFSpn6LZ+v85wKPAMWesfs+IeteINWzA6dqNwVBEF4B0ToKwiCIAjC+5e4Ai/+J5j+H4AMSjXs/RTc/xvQd7TbuxN2kUqjyUvzSb4/3anmvbEXL4BKqeBY0MGj4x6e2etjyG0WA9gEYZeoVqtEo1EikQjLy8usra0h36LfikKloKlpktKliKqjZHVZGsoGZXUZFOA1ennY/zBHfEc45jtGv6UflbJ7lazNfJ36QrYT9s5mtgxaU1m1qD2dUFfba0bTZ0bjM6LYpg9sK5ejcv48pR89T/nUKaRbhOEKjQbDsaMYDhxEOzTYGb7W378Tl/eOFTMpNpYWWTn/Bivn36SYSm671uxw4hsZx+7vwe714+4P4hsdQ63RUitLlLJ15s8kWLmQIrFWoFpo0LzNQDW1ToXVpcc3ZMVo1WLzGHH3mXH4jai1u6PKWRAE4V4jQl9BEARBEN6bdhuWnu+0cZj/PnD1hf/UJ+GJ/xPcY13dnrA7NFttXl/N8OZqlnOhHK8upqg3r7/w16gUHO53cN+QgxMjbvb4LbhEP15B2BUkSSISiRAKhZi9Mks0Et2yRjbJlM1lcrocC8oFsmSRFdeDYJVCxbhjnP3u/ez37OeA5wBD1qGuVGrKbZnGaoFGqEAr30CKl2lmarRymytNlVYthr0udEM29KN2lMbb9wyuzc1T+M53KL92CikUppXJbF6gUqEdGsSw/wCmEw+i9vowHDzQtcFrsixTTCXJJzqtGSJzM6xfOk8pm9my1ubz4x8ZZ2DvAdwDQVRqDY7eAFJdSTFdo1aWyG1UmH+jzCt/f55cokprm3BXpVZisGiweY04e03Yr/bbdQXM6M0aUb0rCIJwh4nQVxAEQRCEd6fdhulvwov/D6Tmrx+f/AQ89n+Af1/39ibsCqFMhVcWU3znUozzoRzFm3pfBuwGPrbPzzN7/Rzqt6MVvRgFoetqtRrJZJJwLMxafI1IOEIpVUK+aWhWSV0iq8uS0WWIGqNUnOpk0wAAIABJREFUNJVNjzv1Tu7vuZ+9rr3sd+9n0jWJQW24m5eySTNXo76cp3opRX0lj1xrbV2kAG2fBd2IDf2kq9OD923uMGhmMpR+/GNy3/wHqm++ueVx7dAQxuPHsTzxEYzHjqE0da9VQ7VUJLGyRHxxnvCVaTaWF6kW8lsXKhS4Av30Te5j6PAxPMERamUNxXSNbLzC+R8VyMRyFDMh2s1bTNS8gcGiwWTXEdzrom+PA5Ndh9176/YXgiAIws4Qoa8gCIIgCO/c0vPw/d+DxHTnv3VWOPyLcPRXwTPe3b0JXbVRqPGVk6t851KM1fRNIZBJywPDTo4MODjUb+do0CEqugShi1qtFrPrs5ycPUkykUTKSsh5GQVb/15WVVXSujRJQ5KUJYXOqMOqtWLT2Rg3jTNoHaTP0oddZydgCRC0BLvSqqHdaNEuNpBSVVqpKvXVAo31TkXvjRR6FfpxByqHHo3LgNpnRO3SozJrb//8tRq1mVlqMzMUf/RDKqdfvz54Ta3G8pHHMX/kCfSTe9D09KCyd2fwnFSvEZ65TGRulnR4jcTqCoXkxpZ1SpUKs9ONszeAe2CQoUNH8Y2M0agqyUTLhOeyvPC1mVsOUgNQKDoD1XQmDXafEWePCXefGXe/GZNdh1oM1hQEQeg6EfoKgiAIgvD24pfh+78LKy91/ltnhROfgwd+A3SW7u5N6JpQpsK3LkT59oUoV+LXB/soFXCgz87Do24+ssfLwT4b6m16XwqCsDMqlQrrkXWWs8uEq2ESuQTFeJF2oY2+okclbw7lFCioqCoUNUXq+jo6hw6jx4jBYuAZ3zMc9x9nwDLQ9TdsWmWJVq6OtFG+2qqhiJSsQnObfrFK0PSY0e9xYph0oukxbduL90Zys0ltbo7q+fOUfvQjymfeAGlzAKqfmsL80SewffKTaPv67sTlvSetpsSVV19i/rVXCM9O06hWtqyx+fx4B4fpm9xHz+gEnuAQlWKLyFyO2FKOyy9L/OAv3qRWuukaTRpsXgMWlx7foBV3nxmzU4/FoUelEV/XBUEQdjMR+gqCIAiCsL30Evzo/4LZb4HcBoUKjv8reOx/B6Oz27sT7jJZlllMlJiOFviHcxFenN885Odo0MGvPTzEiREXduPtq+YEQbgz2u02iUSCtdAaM+szxBNxarkaivrWcNbA9TYLkkKiZWphcpowuowEggFG/COM2kdx6B138xJuSZZlmskq9cUcUqyMtFGmmarSrjS3PUehUaKy6VC7DWgCZnRBK9oBC0r97V/2topF6nNz1JeWaWXSSNEYhe9/n3ahsGmdyu1GPzGB6cEHsDz1FNpg8I5c63vRbDQIzVxi7eJZ5k6+vKkfr9nlJrjvIJ7gEN7BYVwDQzQqKtLREplomYsvlokvnaGUrW95XqVSgc1rwDNgYeSIl8EDbpSiJYMgCMI9SYS+giAIgiBsJdXgjT+H538fpKsVQ1M/DU/9B3AMdnVrwt2Xr0h881yYr58JbaroVSjgxIiLTx4M8OSUD6dJBL2CsNNkWWY2PcuL8y+ysrKCal2Frr55+OFbbRrKqjKoQK/QozVoMdvNDAwNMNg/yGT/JEaNsRuXcEtys019OU99KUd9tYAULSFvMxBMadGgsmjRjTrQDVjQ+E0ozRoUOtXbViI3UymqFy5Qm71Cfe4KtdkrSOHwLdcq9HqMx46h37cX68efRTc+1tVK50IywfLZMyyfO0N4dhqpVr32mNnh5MBTHye4/zCu/mEykQqx5Txnf5AhvnKWZn1rL2OFUoE3aCEw7sDs0OHoMeEfsqLWitYMgiAIHwQi9BUEQRAE4TqpBq99AU7/KZTinWODj8DT/xF6D3V3b8Jd0W7LRHJVzoVynFxMcT6UYyFRonV1mJNeo2TCb+VY0MEvPRgk6OrecCJB+KBry20ipQjRUpSZjRlmp2cpJUtYihYMLQNGOqFtmzZJfZKGoYHP68PtcXNw6CD7e/bjMXi63pLhVmRZpl2UqM6kqM3nqC/ntg5ZUyuuVuta0fhNqD0G1G4DyncQSsrNJlI8jhQOU19aonbpMtXz52msrt5yvbqnB934GGqPB5XFiumhhzA9+AAK1d0NQNvtFrl4jHQkRCGRILcRJRuLkomGKaY2311hdroYOnyMwOQ+rO79hK/keOnrGdLRV+CmOWsqjRJnjwlXrwlHjwm7z0hgwoHOICIBQRCEDyrxFV4QBEEQBCglO5W9Z74I5UTnmLUPHv0dOPLLoBR9+z7oTi6m+J/no3z3coxCbevt03v8Fv7ZsX4+faQPm1HThR0KwgdbRaqwkFvgSvoKcytzxBIxkqUkuroOX9WHRbJgvPoPgKyU0dl09I/3MzQ1RK+9l0HrIErF7vx6LTfbNMJFqhdTNCIlpI0K8k1fa5QWDfpxJ7rBTlsGtdOA4qa+sbIs08xmaSaStAt5pI0EUmidZjpDK59HikWRolGaGwloba1uBdCNj6OfmkI/uQfdxB70eybu2uC1SiFPfGmeYipJKZOmkEqST2xQKxWpVyvUy+VNFbw3UiiV9I5PMnjwKK6+KWSFm5XzKV79RhqpfnHTWoNVS8+wDd+wlYEpF85ek2jTIAiC8CEjQl9BEARB+DArp+DUF+D1P4PG1dv2rQH4yL+H/f8M1OJ2/Q8qWZa5FMnzjTfDnF3PcjlyvXelVq1k0GXk8QkvRwbs7PFbCbqMu7JaUBDuJY1Wg7XCGpdTlwkVQ6xn1mnkGpQzZdqFNpaGBXPTjLatxXf1nxupLWqCo0GO7jnK+Mg4avXuezknt2WaqSrNZIVmqtrpxxsvIyWq0L6p/FQBaq8R42EvumEb2j4LihuCyWYySX1pmerFi1TPn0eKxZBCIdql0jvai0KrRdPbi6a/H8P+/RgOHkB/4ABqx870LG5KEvmNOPlEnFq5REuSqJVLZKNhaqUSibVl8hvxt9+3UonN48M7OIzd34PJ6UVu2ylmTUTmq5z9QQVZTgCJa+fozRr6J50E97no2+PAaNWKr9mCIAgfcrvvpwRBEARBEHZePgKn/xjO/DlI5c6xnoNw4nMw9UlQiUrOD6pqo8XfnFnnKydXWU1fn/CuUir49JE+PrbPzyNjbtTvYLq9IAi3J7UlzsTOcCp2isupy0zHp3GVXTjrTmwNG56aBzNmnNw0GFMNNq8Nq95Kj6eHHn8PIyMjWK3W7lzINtrVJlKsfLVytxPuNjcq2/biVehVGCZd6CccnXYNruuVvHKrRX1+jtr0DLXpacqnTtFYWdn2Y6vs9s4vtwtt/wBqrxeVzYbK6UA3OIi6pxe1x41iB+5UaUoSsflZogtzZCIhstEIhVSCcj4Hsvy25zsD/dh9fiwuD2aHE3tPLwaLFZ3RhEqjQWtwU8xIbKzkiS7kmD6Zo9WsAbVrz6HRqzDbdQwecDNy2Is3uDkwFwRBEAQR+gqCIAjCh4Usw9pJePPLMP0P0L56W23PIXj438LkJ0Aphrd8UCWKNb56ao2/fG2NbEUCQKdW8sxeP09N+Tg+5MRn1Xd5l4LwwbCSX+GLl77IK6uvoC6qcdad2Bt2nqo+hUbe/KaaxqzBarcyHBwm2BPE7Xbjdrt3TRWv3GzTKjRoZmrU5jNIsTJyvUW73qKZqGzpHQug0ChR+4yonXo0fhOans4vlU13rfpUlmVqFy6Q/cY3qJ47j7S+jixJm59IqUQTCKCfnMRw6BDa4SG0/f1oAgGU+rv39UqWZbKxCGsXzxGaucT65QvUy+VbrtXoDdj9PRgsVtQaDUqVCvfAEAazGWffAP6RMfQmMwD5ZJXQTJp8qkEi1KRaqBNfTlDKLm95XrNDR9+Eg8GDbvzDNlHJKwiCILyt3fGThCAIgiAIO6eW7/TqvfB1SM1dPz74CJz4bRh7GsQLxw+s1VSZP3t5mb97I0yj1am+63ca+PVHhvnUkT5MOvHjoCC8X9FSlNn0LG9svMGZyBlKsRKBcoBHy4+iYvObaU6nk9HRUXw+HwMDA3g8ni7teiu51aa+mKMRKiIlq53K3W2C3beoHDrUHiPagPlauKt2GVAoFcjtNo21NSqv/4jSDxO0y2Ua4RCNxSVa+TytbHbTcymNRvT79nVC3sOHMT10ApXFssNXvZVUq5FcX2FjefH/Z+/O4+PM6wPPf+q+71v3Lcu327TddtMX3TTnEggZSDpDCEsCOWZZAmyY7MzOLDNZMhAmmVcg2YGZzTC5YDPZFxloGKCbpg/6tt2WLMuybqlKqirVfV/PsX+U27YsueluH1K3f+/Xq16ynvo9j75PSZaqvvV9vl+SC/MsT56mnElvWGN1uenatYdg/yCeSAeuYBi714fV5d6UjFVkhVq5RWG9yks/TpKOzVHK1MklqmxFq9NgdRkJ9bkIDzjpHvPi67TfsPMVBEEQ3pzEs3xBEARBeLNan4YX/xO89LcgXRgKY7DB3l+E238DOg5ub3zCDaOqKo+eW+c/PbXAC4vZi9sP93r4jbf28+CeMDpxGbAgvC6VVoUz6TOcTJ5kpbjCQn6BhfQCPeUeuipdjDXGNiR6XS4XPT09hMNhuru76erqQrvDhmNKuTqVFxNUXkyglFpbrtF5zRh7HJj6XehsBjQGLYawDa1Nh5TJIK2naK1OUx9Pt3vxzs1RPXECpVjc8ngAGrMZ5zsexPGud2EaGsYQCaPR3ZwrTlRVpZzNkFyYI7sWY31pgdTyIuVshmZtczJWp9fTuWs3PXsP0rV7H5HhEbRXXB1TKTSITefIrlXIJavkkxWyaxVqV3lMNRroGHHjCdswWvSYbQb8nXbCQy4MRnHljSAIgnBtRNJXEARBEN5MSgmY+H9h5kew/PSl7YFdcPSTsPeXwLyzekIK19ez8xn+3f84x3isALR79R4f9PE79w5xbNC3zdEJwhuHpEjM5GaYy88xl5tjJj/DfH6eVCmFq+nCX/cTqUbY3djNHvZs2NftcbN7bDd79+6lo6Njm85ga2pLaQ9WS1RoLBZoLBWRs5d6xWrtBsxDbvQBK4ZOO4aABZ3bhOZCn+/m8jLlJ39C9eRJqidPIKczr9jHVmMwYDlwAOPgIFqbDb3Xg2nXGDqnA9OuXWiNN35gqNRsUkglqeZzrM1MM/fis6SjK0jNxlX3sbrchAeHCfYPEh4coXffQfQXYlVVlWK6TjpaIhUtkVopk46WqBabVw9CAzankY4RD50jbhxeM/5uB1anGJgqCIIg3Bgi6SsIgiAIbwbJKTjxl+1+vS/36tVoYeRd7WRv/92ihcObXKHa4o9/PM3fPLcCgNWo49eO9fHrx/sIu0SvXkG4kqzIxCtxlovLKKpCvBJnsbBIspokVU2xWFyk0Gi/eeJuuOmodrC7uht3042Gzb9PI5EI+/fvZ2hoCL/fv2P6rcqVFs3lIs3lIo2lIs1YCeQrkrQaMPW7sN0RwdhroXFuktrpx6k8EUdKpdqVvKkUSrGIslUvW50OvdeLobMTfTCI3u/D0NWN9fBtmPfsQXOT+hOrqkp2NUY+GaeYXmf13FlWz09Rzma2XK/RavF19eDv7sUZCNI5uhtXMIzV7cZi39hWolJosDiRZGUyw+JEmkZV2nw8DTgDFrwRG96IDXfYiidkw+EzY7bp0YoBmYIgCMJNJJK+giAIgvBGlY+22zec/hZU1i9t7zoCu98Hu98P7u7ti0+4KWRF5R9ORvnSD8+TrbSrzB462sPvPTBCwGHa5ugEYfuVmiVOJE4wnZtmtbRKsppkvbpOtBSlpVy47F4Fq2TF0/Rgb9kxy2aGlCGsihVf04dO2nipvd1uJxKJMDw8TH9/PzabDavVug1nt5GqqEjrVZorJZqxEo2lYrsn7xW0Vj1ai4JGX0RjLKLRFGnOzVL8x7M0FxdfsXIXvR7rbbdhu/NOLAcOYBocQOfzobkJLStUVaVRqVAt5kkuzpNaWqBWKtKoVMgn1sgl40iNrat3DWYLdq8PdyjM0O3H6N69F4c/iN5g2LRWlhXic3lyiSqZ1TKx8+2WDZfT6jX4OuwEuu34ux0Eehz4Ou0YTKItgyAIgrAziKSvIAiCILzRxMfhqX8P5x4GVW5v0+ph5J3wlo/B0APbG59w0zwzl+bfPDzFdKIEwHDQzhd+YQ/HB/3bHJkg3ByqqqLRaGjKTUrNEuvVdRYKC6yWVxlPjbNcXGaluIJ6xSQye8tOT7UHT8uDX/ZjbpjRyVdP1ul0OgYGBhgbG2NwcBCXy3WjT+3nUlUVKVWjFS/TSlaRcw3qMzmUyub+sVqrAmSRs/M050/QnJt4xcSuPhLBeugQxv5+9AE/Op8PQyiE1u5AHwyis9tu2Dk1KhXyyTjplSUKqXWKqSS1YoHCepJiJnXVpO7F2I0mvJ1dOHwBAj299O47hLerG4vDuWX1dT5ZJR0rk09WKaxXqZZaxOfztOryxoUa8HfZCfY6Gb49RGTIhU5U7gqCIAg72LYmfZ988kn++I//mJMnTxKPx/nOd77D+9///ov3q6rKF77wBb7xjW+Qy+U4evQof/7nf86ePZd6ZjUaDT73uc/xrW99i1qtxv33389f/MVf0NXVdXFNLpfjU5/6FN/97ncBeN/73sdXv/pV3G73zTtZQRAEQbhW+Sj8+F/A1H+/tK3/bjj6W+2Ppps/4Vy4+VRV5em5DH/22OzFIW1Os55P3T/MR4/3YRBJCOFNQFEVlopLxEoxVsurJCoJZnOzTKQnqDQr6LQ6VFVFVmX0Wj0N+RUSgSqMmkbZpd+FW3IjJSXq+fqmZTqdDr/fTzgcxuFwYDQasVqt+P1+IpEIJtP2V86rqkorXqE2kaY2ldmyihe1hVJLIGcXaa2eQcnMozbLm5bpvF7M+/aiczjRGI0YOjuw7NuHec8e9L4b1/9bUWRya2vE587TqJRpVCu0Gg0y0WWSi/NUC/mfewyDyYw7FKZzbC82lxuj1YYrGMLb0bll9a7UksnFq+TXq5RzdSr5BpVCk/XlErn4Fu0qAIvDQKDHgSdkI9DroHevD7Ntc1WwIAiCIOxU25r0rVQqHDhwgI997GN88IMf3HT/l7/8Zf7kT/6Eb37zm4yMjPCHf/iHvP3tb+f8+fM4HO0Xtp/+9Kf53ve+x7e//W18Ph+f/exnee9738vJkyfRXZj8+tBDDxGLxfjhD38IwCc+8Qk+8pGP8L3vfe/mnawgCIIgvF6tGjz/H+HxL4FUAzSw94Nw12cgtOfn7i68Oaiqyk/OrfPnj8/x0ko7KWLUafnlI9185u0juK1iGJDwxpWupZnKTHEyeZKZ3AyT6Unyjasn/yT5Uj9VWb5Ukek0Ohm2D+Ov+QkWgmhrWhrlBq1mu/q1TDv5qdFo6Onpobe3l2AwiMfjIRwOX3z9sJOoartlQ20qS/VkEildu+xOGaWaRErPo9YKyOnzyJm5S1eB0B6kZt67F9PoCOaREUwjI5iGh9H7b/wVAdVigWatRj6xRnTqDPGZaeJzM684QA3A7HDi7+7BE+nEFQxjsTtwhcI4A8F2ktdiRVFUiukaUlOmUZGoV1vEFyQWJ9bIxivUik0aNYlKoUE514CrFDZr9Rr8XQ48YSvuoBWzvZ3sDfQ40Gp3Rl9mQRAEQXg9NKr6Sg2bbh6NRrOh0ldVVTo6Ovj0pz/N5z//eaBd1RsKhfjSl77EJz/5SQqFAoFAgL/+67/mwx/+MABra2t0d3fzgx/8gHe84x2cO3eO3bt389xzz3H06FEAnnvuOY4dO8b09DSjo6OvKr5isYjL5aJQKOB0iqnngiAIwk2gKHDqm/D4v4Nysr2t5zi85ysi2XuLmYjl+b++f47nL1T2mvRafuVID791z6AY0ibseKqqEi1Fmc/PEy1FkVSJXD3HanmVeDnOWmWNbD27aT+L3kKPo4dOeydhW5guRxe3BW/DZ/GhqAoAOo2OWqNGOVUmHo2zvLTM6uoqV77EMRgMhMNh/H4/nZ2d7NmzB4vFclPO/7VSahKtVBW50KS1WqI6kULOXkqSqnITKTmJtHYKKTkJrXa1r6GrC8v+fRi6urEc2I8+GMQQDt/QfruqqlJMJcknExd665bJrq2SXYuRia1QSqe23E9vMhHo7ccVCGGyWtFotXg7uwn1DxHo6cNgNqOqKqVsncJ6jWK6Rj5ZpZxv0GrI1IpNipk69fLmVhZXYzDrcAUsOH0W7B4TVpcRp89Czx4vJquo4BUEQRB2rtebk9yxPX0XFxdJJBI8+OCDF7eZTCbuuecennnmGT75yU9y8uRJWq3WhjUdHR3s3buXZ555hne84x08++yzuFyuiwlfgDvuuAOXy8Uzzzxz1aRvo9GgcVm/qGKxeAPOUhAEQRCuYulpeOzfwsqz7c9d3XDvP4eDv9oeDy7cEqLZKn/8o/N8d3wNaCd7f/3OPj5+Zz9Bp0j2CjuDqqqka2li5RixUoxoKUqsFGO9tk62niVZSVJsvvJzaQ0a+l39jHhG2Ovfy8HgQXb7dqNRNGSzWZrNJrIs08w1ScQS5HI5stksyWSSdDqNoigbjufxeNi1axcDAwO4XC78fj/amzBo7LVSFZVWskpjNkdjPk9zrYJSam5eJ7eQU9NI8ZdorZ5A73Fg7OvD9d6PYDtyBOPgIPpgcMuetddDs14jt7ZKKZthbeYcyYU5ytkMxfUkUmtzvBdpNOgNRvQGA/233U7n6G66xvbi6ehAq21XVSuyQrXYpJiukVmtMPfSCrl4hWy8QrXwCscGdHotRqses1WPyWrAbGt/dAUt2D1mTFY9VqcRV8CC2W64YY+PIAiCIOxEOzbpm0gkAAiFQhu2h0IhlpeXL64xGo14PJ5Na17eP5FIEAwGNx0/GAxeXLOVP/qjP+ILX/jCNZ2DIAiCILxmiUl49P+EuUfanxtscP//AW/5OOjF5fu3ikK1xdd+Ost/fWaZpqyg0cAHDnXy2QdH6XTvzOpE4c2j0qowmZ4kV8/ht/gpt8pES1EWC4ssFZdI19KYdWYacoOW0iJRSdBSXrni0qA10O/qp9fZi0lnwmVy0WXvImKP0GnvxKPxUM6WyWQyZKNZJk5N8HTp6S0TultxOBz09/dfvO3U2R2qqiJl6jSXi9RncjTm8lsOXlNqedRaBqWSQkqcAU0K21sO4v3wL2I7/hV0N2iQXK1cYuqJx1ibOYcsSWg0kF2NkV2LXXUfrU6POxzB6nJhttmxe/14O7sIdPfh7+nDbLfTakpUCy2ya2XiC01mTixRytTJxivk1iooytYXn2p1GlwBC3avGW/Yht1rwmjWY3EYsLlNeDts6A07ryWHIAiCIOwEOzbp+7Ir3419eULvK7lyzVbrf95x/uAP/oDPfOYzFz8vFot0d3e/2rAFQRAE4dVTVVh+Gp79Czj/A0AFjQ4O/Src9Tnw9G53hMJN0pBk/vrZZb762ByFWjsRdOeQjz941xh7O29Mkke4Na2WVzmXOce57Dnm8/OsldeoSTVKzRKZeuY1H0+r0RKxReiyd9HlaN9C1hAes4eQNUS3oxuzvl2dLssyhUKBWCxGbDLG4yuPv2IxhslkwmKxoNVq0ev12O12XC4XPp8Pn89HJBLB5XLt2CpOpSFRO5OmPpenFS0hZTYOkVOlBnJ2ASkxjpxbQimtYugIYdm/H/PxPVjf8nkse69vSx9ZkkivLBE7N0lmNUq9VCK1skg+mWj/TdqC2eHE4fUR7BukY3QXrmC7x67D60dvNKKqKpV8k7XZHOsrJVYfq7I2exJFVpGlV07ca7Qa7B4Tvg4bnoit3V83ZMPfbcdgFEldQRAEQXg9dmzSNxwOA+1K3UgkcnH7+vr6xerfcDhMs9kkl8ttqPZdX1/n+PHjF9ckk8lNx0+lUpuqiC9nMpl2xIReQRAE4U1MVWH+MXj8jyD24qXtI++E+/+V6Nt7C2nJCt85tcpXfzpLNNse0jQacvDP372Le0cCOzaZJex8qWqKifQEi4VFis0i6Wqas5mzLBQWXnG/sC1M2BomUU3gNDrpc/bR6+yl39VP2BamJrV/Ti16Cx32DoKWIAbd1n1RC4UC8+fnSSaTZDIZFhYWqNVqm9Z5PB6CwSBerxefz3exLYPb7X5D/R+Qy03qs3ka83la8QqttfKGIWKqIqHklpAys8iJM8i5RQw9ndiOHMF65J3Y7rwTvdd7XWMq57JEJ8dZPT/F+tIC60sLyK2tq7O9HV3sve/tGMztqwqcgQDBvkHsnksxSS2ZRlWikKox80KM+FyeVLRMsyZteUxoD0zzRmw4vGZsLhN2rwlXwEqwz4HdYxZD0wRBEAThOtuxSd/+/n7C4TCPPPIIhw4dAqDZbPLEE0/wpS99CYDDhw9jMBh45JFH+NCHPgRAPB5ncnKSL3/5ywAcO3aMQqHACy+8wJEjRwB4/vnnKRQKFxPDgiAIgnBTqSrMPQpPfgWiz7W36Uztyt6jvwWBVzdkVHjjU1WVhyfifOXH51nOtIcxBR0mPvvgCL90uBudSIIIr0FLbjGVnWIiNcFEaoLx1DjxSnzLtTqNjhHPCLt9uxlwDdDr7MVqsOIwOi5W6F6LZrPJ4uIizz//PAsLmxPMWq2WQCBAX18ffr+fXbt24XA4rulr3myqoqJUW8jFJnK+QWutTO1cltZqedNauZxAip1Azi0iZ2bRmvU4HngA6699HNvRoxguK3K55rhUlXwyzsqZcVYmx8nEVsjEVjatM1qshIdGiAyNYrbbCfT0E+jtw+pybzhWKVMnPlckHZsjv14jPl+gVty6165GA94OO50jblxBC8FeJxaHEZNVj9GiF4ldQRAEQbiJtjXpWy6XmZubu/j54uIip0+fxuv10tPTw6c//Wm++MUvMjw8zPDwMF/84hexWq089NBDALhcLj7+8Y/z2c9+Fp/Ph9fr5XOf+xz79u3jgQceAGBsbIx3vvOd/OZv/iZf//rXAfjEJz7Be9/73qsOcRNR25OBAAAgAElEQVQEQRCEG6K8Di/9DYx/G9Ln29t0Rjj8Mbj7c2Df3INeePMaj+b5Nw9PcXI5B4DfbuQ37xrgI8d6sRp37Pvywg6zUFjg6dWneTHxIk+vPk1T2ZiM02q0DLoH6XP24bf4CVlD9Dp7ORI5gtP46qc/b0VRFAqFAvl8nlKpRLFYJJlMEo/HyWQyqJe1CYhEIhereDs6OhgYGECne+Nctq80JBpLRRoLBZrLRaRMHaXShKt0LZDzK8ipc8iFKHJmFrWWQ+fzYTt+HNvxh7Dfew96z7Ul1lVFIb+eIJ+Ik4uvkl1bpZLLkliYpZxJb1ys0RDqH6RrbC/hwWGC/UN4whE0F4bbKbJCKVsnFa2RPxGlVm5STNdZm81TyTe2+OqABsxWA11jHrp3eQn0OvCGbegMO29gniAIgiDcirb1FcWJEye47777Ln7+cg/dj370o3zzm9/k93//96nVavzO7/wOuVyOo0eP8uMf/3hDFcCf/umfotfr+dCHPkStVuP+++/nm9/85oYnkX/7t3/Lpz71KR588EEA3ve+9/G1r33tJp2lIAiCcMurZuGZP4Pnvw6tdjUnBhu85WNw7J+B8/pVeAk7X77a5E8fmeGvnltGVcFi0PFb9wzyG3f1YzOJZK/wyhpyg5OJk5xaP8Wjy48yX5jfcL/b5OZA4AAHAgfYH9jPXv9ebAbbdfv69XqdhYUFpqenmZubo1qtXnWt3W5nbGyMO+64A5/Pd91iuNHkYpP6bA4pVUMuNWklKrQSFZC36nWrgqaFUk4j5+PIqWmk+GnURgHLwYNY7hzFNPA27Pffj6Gz85rbVFQLeeZPvcD5Z55i9fwUUmPrhKxWpycyPELvvkOEBoawebupFvUU0zUkWUtiUcPMi4vkE1Wy8QqFVA1ly/NrD1Pzd9kJ9DpxBSyE+hx4O+yYrPo3VNsNQRAEQbjVaFT1Kp36hQ2KxSIul4tCoYDTeW1VEYIgCMItID0H0w9D9HlYeAJalfb2jkPtyt7d7wPLtVV5CW8sk6sF/vb5ZR4ej1NqtPtefuBQJ59/5y7CLvM2RyfsRJlahqnMFLFyjLncHIlqghcTL17spwug1+g5GjnKgeABjnccZ59/H1rN9au0bLVazMzMsLCwwNraGvH4xnYRWq0Wl8uFy+XC4XAQCASIRCKEw+Ed3a5BVVXUuoxcbtKKt38/N2MlGjM5WomrJLJ1DdRqDCk1TXN+HLWaQ22WQG2X+2qMRqx3HMVy4ADu978fQ2fnNcUotVpEz04wf+I5kgtz5BJrNCqVDWu0Oj3ucARfZzeuUBij2Y3FFcLi6iG71iQTK5NZLVPOXaVa9/LTM2hxBy24glZsbhMWu4GOITeBXgdGs3hDShAEQRC2y+vNSYq/3oIgCIJwvdTycOL/gZkftZO9lwvthfv+BYy+q930ULglNCSZn5xb5+9PRHn8fOri9l1hB//yPbt567B/G6MTdppis8hkepKTyZM8H3+eidQEKpvrM4KWIIdCh7in6x7u6b7nmts0XE5RFJLJJAsLC8TjcWZmZmg2N7aMcLvd7N69m+HhYbq7u9Hrd/ZLClVSaCWrtOJlWmsVWutVWmtllOrVho6paEwNkFLI2STNxQmk1AJqZX3DKkNHB4auUUxDg1gO3Yb9vvvQ2V97VbWqqlTyOaqFPOVchvPPPEV8boZCMoEib47R19VD/6HjWN2jSC0X2XidUqbO2vNV5JYCNIDZDftoNOAO2/BGrCiyiiwp2L1mvGEbnrAVT8SG3W1CI3ruCoIgCMKbxs5+hiYIgiAIO11xDSb+vj2YLfYiSPVL9w2+Dfrvhr67ofM2key9RUSzVf7HZJxTy3memk1RacoAaDXw3v0dfPj2bo4N+MRAo1tQTaoxk5shVU0RLUV5af0lJlITFBoFNBoNLaW1aZ9B1yBdji6GPcP4LX4Ohw4z6hm9LpfV1+t1CoUCyWSSVCpFLBZjdXV1U5LX5XIxNjZGZ2cn3d3duN3uqxxxeyhNGSldQ87WkbJ15EIDpSohFxrIpSZStn6V1gygqhJqLYUqt1Byq0jJSeTUOdTmxmFsWocD+9vfjvX2t2AcGMQ0PIQhFHpd8aqqSjq6THx2mujZM6xMjlMt5Ldca3W5Gbr9GA7/ELLkIreuI7vWYvJndaB04XaJTq/F4jRgdRhxBtqD1EJ9DnxdDkwW8dJPEARBEG4l4i+/IAiCILwWqgorz7WTvMmz7Y+XJ2qCe9q9ekffDa5ru7RXeGNZSlf4xlML/LcTUVqXJZhCThMfvK2LXzrcxUDAvo0RCjeaqqqsllcpNUuUW2USlQRTmSmWikssFhZZK69tWbnb3rn9IWQNcTRylIPBg9zVeRdhW/i6xKYoCtlslrW1NWKxGIuLi6RSqS3XGgwG+vr6iEQiDA0N0d3dvWN6t6qqilJq0UpUaK4Uqc/naS4VudrDemnHJkp9HSk5h5JbQS5EUUpxkDcmuHVuN+a9I+iDQYw9PZgGBzDt2oVpePji0LPXqlmvkYmuUEglmT/xPEvjp6iXNyZrNVotFocTi8OFK9hFx+gRGjU76VU9CxMlpJYCXGo7odFAsM9JoNuBw2/GE7bhCljwhKyiWlcQBEEQBEAkfQVBEAThlakqlOKw+CTETrSTvLnFjWt6jsHY/9T+2HFIVPTeQmRF5YeTCf7x9Co/OZdEuZB4Ojbg484hH3ePBNjb4RJVvW9SDbnB2fRZnow9yUJhgTPpM6Rr6Vfcx2v20uXoImQNsd+/n4PBg4RtYRRVwWVyXdPQNUmSWFpaIpvN0mg0yGazZDIZVFVlfX2dxhZDv4xGI6FQiEAgQEdHB93d3QQCAbSvM8F5vSgNGWm9SitdQy40kNI1pEwNKVndui2DTkFjaKAUk0jxRZRSFqWeQ60XUKpp1Grm0lK3G+vhw5hH342huwd9IIDWasUQCWOIvL7BmoosUy3kqZWK5OKrJBfnWRo/RT4Rp1mvtf+WXEZvNOLvHsbq6cHmHUaRg6wvVyll6lQWYW0R4FL/XovDQLDPSWTQRaDbQXjAhVFU7gqCIAiC8ArEMwVBEARBuJzcgvg4rJ6CxDjMPgrlxMY1RjsM3gc9x6HvTogc2J5YhW0jyQr/eHqNrz42y3LmUvXdfaMBfvveIY70e7cxOuFGkBWZpeIS46lxxlPjzOXmOJc9t6klg0FrwGPyYNQZCVgD7PHtod/Vz4BrgH5XP16z95qqZlVVpdFo0Gq1qFQqxGIxlpeXKRQKJBKJTa0ZLqfX6wmHw3R0dNDX10dPTw92+/ZXn6uyQitRpRktUp/O0YqXkQtXPw9VVVCrGeTMHHJ+CSkxsSGp+zKdx4PGYMB2ZB+Wgwcw9vVhGhrC2NeH5hr7EMuSRCmTplYqMPfic5x57MfUioWrrjc7XNjcQcz2DhR1kELaRT6rIZ8F5gGyF9eabHpsLhOugIXevT7Cgy68EduOqbYWBEEQBOGNQSR9BUEQBKG8DsvPwNJTcO7hzUleNO0K3p5j7d68I+8E0/YnSoSbK5arci5e4vHz6/x0ep21Qrt/s8Ok558e6+X9BzsZDTu2OUrhWqmqSqaeYS4/x1p5jfHUOMvFZSbTkzTkzZWyXrOXI+EjHAweZNQzyr7APkw603WNSZIkzp8/z+LiIpOTk9Tr9auutdvtdHZ2YrFYcDgcBINBNBoNfr+fQCCATqe7rrG9Hkq1RfVMmsZCAbnQoBktbdlzV6kXUEoJ1HoepbKOUk62b8U10CjofT50fh+WfUNobQfQmk0Yh4aw33knxr4+dC7XdYm3WsgTnztPOrpCbi1Gdi1GankJqbnx50Gj0WKy2XD6wxhtQUy2XqpFJ7mkCtiolKFyWatgnV5LeNCFK2DB5jYRHnAS7HVithmuS9yCIAiCINzaRNJXEARBuDU1SvDS38DJb0JqeuN9Fg90vgU6DrY/9h4Hs3NbwhS2l6KoPHouyX9+apEXlrIb7vPajHzi7gF++fZu3FbjNkUovF6SIhEtRZnPzzObn2WpsESikmCpuES2nt1yH4vewh7fHg4EDjDkGWK/fz/djuvb71aSJOLxOIlEgmQySTKZJB6PI0kbWxpoNBp0Oh2hUIihoSH8fj9+v59QKLTtrRlepioqcr6BnK/TSuapnYvTXKqiNjf/f1GbFeT8MnJmFjl1Hrm0BkoD6+HD2O64HdRuTEP3YhoZQWuzoQ8G0VzHBHazXiO5MEdqeZFqoUA+GSe1vEg+EUeRt2gnAWj1BoxmG1ZXB3bfbbSkXkrZJsWCDFcU/er0Wpx+M56Ije4xL50jbtxB0X9XEARBEIQbRyR9BUEQhFtLfgWe/zqc+itoFC9s1EBwN/S9tX0bfhAM5m0NU9hehWqL746v8pdPL7GYbvfV1Gk1jIQcHOhycc9IgHtGA1iN4qnUThcvx1ksLpKv51mrrDGVmWKxsMhKcYWmsnULAa1GS4+jh4gtwi7vLoY9w+z27abX2Ytee32/55IkXRystrCwwNraGrIsb1rncDjYvXs3/f39DAwMYDAYdtTl/nK5SStRoTFfoLFYQFqvoNQlUK6MsZ3wlYurSKsnUCpplOIqqEVsx+7Acdch9MH7MHR0YBoeQWd//T2OX4mqqmRXY6SWF1iZHOfc008gbdHzuE2D2RHAYAqjqG6adScanQ+N1gsaDdUqVKsANQC0Wg3usJXwgItQv5OuUQ8Or1kkeAVBEARBuKnEKxVBEAThzU9RYOGn8NJfw9R3Qb2QUPENwx2/DXs+AFbRg/VWJysqp1Zy/MOJGA9PrFFptn9OnGY9Dx3t5aPHe4m4LNscpfBKVFUlWooylZliobDAI8uPMJefu+p6i97CgGuAQfcgA64BOuwddNg7GPWMYtZf/zd+Wq0Wy8vLLC0tkcvlSCQS5PP5TUlei8VCZ2cnoVCIUChEJBLB7/fvmCSvVGggpaq04lVaiQrNlSJSqrbFSg2qIqPWsqiNImozjc4lY+yxYbstiN73LkxDQxgiETTG618tryoKxXSK7GqUzGqU1NICuWScRqVCOZuhWatuWG91ejHZQ2i0TiTJTqPmRFW9aDQm0JppXfg26YygN2qxuU3Y3SZsbhPeDhu+TjuugAVnwIJOtzOqrQVBEARBuHWJpK8gCILw5rX0Mzj9LZj9EVRSl7b33wPHfheG3g475DJoYXsUqi1eiub4/kScH5yJX0z0AgwF7Tx0pIcP396NzSSeMu1E2XqW6cw046lxTiZPMpWZotQqbVoXsobocfbgt/gZ844x5B6iz9VHp70TrebG/Q5QFIVkMsny8jLz8/MsLS3RarU2rbPZbPT19dHX18fAwABe77UNe7seVEVtJ3QXC7TSNZRyC6UmIaVqyIWtK2KVSgo5t4S0fhalHMfYE8HYG8B27xFsxx7E0NFxzXEV0+vk4ms0q1Ua1QqtZoNGuYwsy7QadWqFPJnVGPVykVImjbJF1fTLdAYjDl8XBnOYRr2XRj1MrXbpcddoL1TtBi2E+p10DLuxuU0Ee52YrPpt/x4JgiAIgiC8EvEKRhAEQXhzqeXhxF/CxN9D6tyl7WYX7PsncPjXIbxv28ITdoYXFrN85cfneXEpi3rZ/CirUcd79kX4pcNdHOnf/sSbcEm5WebU+inOpM8wlZliOjPNem190zqj1siod5R+Vz8HAgd4Z/87cRpvbk/ueDzO1NQUp06dolKpbLjP4XAwMDCAz+ejo6MDj8ezI5K8L1PqEpUXEpSfWUPOb53cVVUFpbyOUk6gFKLI+RXkzBwag4r9rrvw/sovYjt6FL3f/7pikKUW+USC6NQZsmtRCskEhfUk1UKeWqn48w9wGa1OjysYwWQLouKhWnRQr4JGY0Oj81Jv6KlfOE2jWUf3bi+hPieugAV/tx2H14xWVO0KgiAIgvAGJJK+giAIwhufIsP8Y3D2O+32Dc0LlX46Ixx8qN2+oec46MWwrVuZqqr89Pw6X3tsjlMr+Yvbu70W3joU4AOHOrmtx41eJHi2naIqrJZXmc5Os1xc5tHlRzmbObvl2l5nL6OeUY5GjnIgcIAB9wAGreGmxFmtVkkkEmSzWfL5PLlcjlQqxfr6pWS0yWQiEokwPDzMwMAA4XB4xyR4VUVFSlWRcg1asRKN5SLNpQJq68I7IWoLObuAlJ5vt2doVVGrGeTCCkgNtFYrxsFB7O84hPXoJ7EdP4bW/OraYrSaDXJrqxSSCeqVMqqqsjZzjujZMxRTyavup9Fo8UQ6MNsdGK1W9EYTWq2ZZl2hUdOg1VpQcSDLVqoFI82GhVpdS61+6Ri6Cz8eJpueQLeDQI+DjmE3Xbs86A3XbzicIAiCIAjCdhJJX0EQBOGNSZFh+Rk4/wOY+u9QXL10X3A33P4bolevAEBLVnh0KsnXfjrH2bV2laBGAx+8rYvfe/sInW7Rp3e7NeQGZ9NneTz6OKfWTzGTm6Embe4R22Hr4Pbw7Yz5xtjt282IZwSb4cYM+rqSqqokEgmWlpZYXl6+2I/3anbt2sXY2Bh79uxBr9/+p9yqrCBl6xeGrWVpzKWRshIom9/kkItrtOYfpRV9DhQJjcGAaWwM08AAxr6jmEZHMe/Zgz4QeFUJbFVVKWVSrJ47S3TqDIn5WbKrUWRJuuo+epOJ8OAw4cER3KEIrmAIrd6GLDmoFFQyq2WSi0WSc6UN1fpX0mjaLRpcQQt9+/10jnqIDLjQGbRodZodk4AXBEEQBEG43rb/GaggCIIgvBZSA174Bjz/dShEL223eNrtG8beB31vbb/SF25puUqT//LMEn/z3DLZShNot2/4yB29fPyufoKO6z+oS3h1ZEXm1Popnow9yZOxJ1koLGxao9PoGPWOErAEuLPzTt7e+3b8ltfXLuD1ajabTExMXEz0lkqb+wV7PB78fj9utxuPx4PH46G7uxu73X5TY32ZKsu0olHqcys0l/I0YzXkihm0bjSb+hdrUaU6SiWDUowi5xaRM/OgFjCP7cL57t/Ace+9mMbG0L7KQWuqqlJMrRM7N0ns3FnyiTXS0WXq5c2PndnhxBOKYHY4qJVqmGwRHP4hTLZOVNVMq6GQTTZYPFOlWsyjqlsn2XUGLd6IDW+HDbPNgDtkxWwz4AlbsblMGC060aJBEARBEIRbjkj6CoIgCG8MzSqc+q/w9J9Baa29zeyC0ffArne3h7IZRBJPgFpT5j8/tcB/fGL+4mA2n83IQ0d7+J/v7MdjE20+toOiKpxKnuKHSz/kkeVHyNazG+53GBzc030PxzuOs8e/h25H901r0/CyWq1GIpFgamqKWCzG+vo68mWDwAwGAz09PQwMDBCJRIhEIlgs21sp3kquUzs7RfXFOZoreeSCgtbZi87ZAXgAD5oLHQtUqY5SzSJn50BKow8Y0Ll0mAZ9mEZ3YTn4yxg6O0Hz6itgVVUluxYjuTDH/InnWZkc3zLBq9Xp8Pf00b17Pw5/PxZHB426heRikcR8gUqhCRlIrgDktv5iGnAFLFgdRoL9TkK9TsKDLmxuE1qteKNPEARBEAThciLpKwiCIOxspQT87D/A6b+DRqG9zR6Gt/0L2PchkegVLqq3ZL7z0ir/4dEZksX2ZKbdESe/e98Q79gTEr16t0GmlmEqM8Wz8Wd5IvoEK6WVi/fZDDbu77mfu7ru4kj4CG6TG+2mStQbQ1VVqtUq8Xic1dVV1tbWiMfjFIubh4R5vV72799PT08P3d3dGAw3NxF9pVZyndpLp6ieOk99Noeq+ND7R9EYRtE6QOu4tFaVCmhNFQwdRnQOGa1Vi7GzB2PPW9vJ3deo3aYhzcrkOLn4KsXUOkvjpzYneTUaQv2DdO3ej8URQmcI0qw7WJ0pcfaZl9eubdhFb9ASHnTh9FswmHUYzXr0Ri12jwmHx4zDZ8Fk1WMwiZ67giAIgiAIr4ZI+gqCIAg7U34Fnvlau5UDFxo2unvhrZ+Gg78KetO2hifsHKqq8sPJBP/24SnWCu1pTV0eC7//zl28d19EVADeRHWpznPx53hs5THOZs4yl59DUZWL95t1Zh7se5B39b+Lo5GjN62St1arEYvFSCaTLC0tsbS0hHSVfrJut5vu7m5GR0eJRCJ4vd5t6/uqqiqt5WWq45PUTp+nMZNAadrQeQbQeW9DH7p8dROdU8bQ6cJ6qB/TgBud/bVVtcuSRLWYZ31xnmqxQDWfp1LIUc5kKGczFFJJqoXNLRa0ej3ejgHs3i583YeoVTyklqucfaZ+4dd36cKtzWjW4fCZcQet+LrsdI64CfQ6MRhFQlcQBEEQBOF6EUlfQRAEYWcpJeCxP2xX9qoXLquOHID7/xUMvA20olpTaJMVlR+dTfD1J+YZj7WrwCMuMx9/az8fOdaLSS8SSDeDqqo8u/Ys/zD7D/xs9WebBrD1OHo4HDrM8c7jHIscw2Vy3fCYFEVhdnaWxcVFlpeXicfjW67zer10dnbS0dFBJBIhHA5jNt/8qwekVIrSTx5DWk+CyYJakWitV2klFLTOIbRWP3AEfffle6noHBLm/RFsh7owdNjRvIY3OGSpRSYWJRdfJR1dYe38WdbOTyO1mq+8o0aDJ9KPzd2NipVWM0Qp56Jc0lEuQWJZBS617jBa9HjCVrwRG6F+J91jXhxe82uKVRAEQRAEQXjtRNJXEARB2BmSZ+HZP4eJvwel1d42cC8c+19g6H4xmE24aL1U57+diPGtF1aI5doJRpNeyyfvGeQTdw9gN4mnNzdDtBjl8djjfHv62xvaNoRtYd7W/TbuiNzBoHuQHmfPTYlHlmVSqRTnz5/n9OnT5HIb+8J6PJ6Lyd3h4WHcbjcm0827YkBVVVqrq9TPnKExO0tzeQUpmaR+fgZVNqDzDaMP70fnCaK1egHQhzecIVq7BlO/C8ueDoy9TvSeV5egruRzpFaWqJWKrC/OEzs3SWppAfkq1c6uYAhXMILe5KRa0CErNqSGmWrZBBovtZqB2sbcPja3CU/Yismqx9/tINzvxNthx+IwbFultCAIgiAIwq1MvCoSBEEQtlfsRLuyd+Gnl7Z1H4W3/Uvov3v74hJ2jIYkcy5e4vRKjqdm0zw+k0JW2i0/XBYDv3asl48e78NvFy0/bqRUNcWTsSeZSE9wKnmKpeLSxfuseiu/MPQLvH/o/Yx5x25Kkq/VarG6usry8jLLy8tEo1FardbF+00mE3v37r04eM3hcLzC0a4PVVWR1lM0zk9Tnz6PnEkDGupTUzRmZ5HzeTBY0PlGMEQOovPdgfU+PxrtlVXpKuiaGIIG7HePYB7xo7XqX/Xj2qhWWTx9gpXJcaKTE+STW1c6m2x23KEOjBYvJnsvaDupFIw0qpCOt1Au/D97mUYLepMOT8iKK2jB5jYR6nUS7HPi9JtFclcQBEEQBGEHEUlfQRAEYXvUC+1k7wvfaH+u1cPg/XD356D7yPbGJmwrWVF5aSXH6Wie5xez/Gw2Ta0lb1hzuNfDrxzp4d37wliN4unMjdBSWoyvj3MmfYbHo4/z0vpLqFxKAuo1eg4GD/JA7wN8YOgDWA3WGxqPJEksLi6ytLTE/Pw8yWQSVd2YlNTpdPT09HDgwAHGxsZuaCWvUq0iZXPUxk/TOHeO6qmXaMzNoVw2DE5j8aK1+tB5BzHtvx+N1YfG5NycHNVpMASsmHd7MQ26MXba0Zpf3c+1qqrkE2sk5mZIzM8Sn58hMTeDqlzqpYxGgysQxOzwYnEEMDv6qBS8FLNGCjkJNhRFX2rvYLLq6d3ro3PUg91twhOxYXebRGsGQRAEQRCENwDxKkkQBEG4uVQVJv8/+NH/DuVke9uBX4F7Pg/e/u2NTdgWqqpSakgspiq8uJTlr55dZiVb3bDGYzWwv8vN7X0e3rEnzHDoxldt3opy9RxLxSVOr5/m76b/jkQlseH+/f79HA4f5mDgIEfCR7Ab7Tc0nkwmw/z8PEtLS8zNzdFsbuw3a7fb6e3tvXgLBAJob0Dfb6VapfLCC9TPTFKfnKQ+M4O0qU+wBo3Vj6HvrRg6d6Pz7wLN1o+P3m/B2OvEst+PIWRD5zReNZEqtVo0qxXqlTLVQp5yNkNqZYnkwhyZ2ArlXLb9e/UKrmCE0OB+9KY+qmU/uXiLQlaikN1wdLRaDZ5Ie6Cav8uBK2DB4TVjthuwe0yielcQBEEQBOENSiR9BUEQhJunlISHfw/Of7/9uXcQ3vMVGHzb9sYl3FTxQo2ptSJnVguMR/O8uJSj3NjYW9RlMXB7n4dDPR7uGQmwp2OL6kjhmrSUFolKgmgxynOJ53h69WlmcjMb1rhMLg4HD3MkcoT7e+4nbAtf5WjXIZ5Wi4WFBaanp1lZWaFSqVCv1zescTgc9PX1MTIyQnd3Ny6X67r+XCjNJq1olObSEs3FRZrLyzRXotQmJlCvbGJrsKDz9GEaOYLONwo6HyhXxKLVoHMZ0QesWPb6MHY60LmM6OzGDcukVotiIkmtWKSYSbG+OE8+ESe5OEcpnfq5cWt1eqzuLgzmCIoSpFbx0mh5WJl+eUU7dp1BiztkxeW30DnqJtTnwtdlQ28QQw8FQRAEQRDebETSVxAEQbg5pn8A3/1nUM2Azghv/Qzc9RnQiz6sb3aqqnJ2rciPzib44WSC2fXyluu8NiP7u1zcPRzgl490i7YN14GsyMzl54hX4szl55jJzrBeWydajJKtZ5HUzYO8OmwddDm6eLD3Qd439D4sest1j0tVVRYXF5mfn6dcLhOPx8nlcht68gJoNBq6u7vp7e1l165dRCKR61bJ24zFaMzOUnvpdLt6d3oaOZvdvFCjRWsPY9x3N8a+29A6I6gtM2rzinUK7TYNERumHifGfifmES9a08aEqiLLZGJR0tFlVs6cJrEwS3plCUWWeSVGixWz3YXeZMFgCiLLfqpFJ7JsB40FSdEhXSiQ1+pAq9VgdRmJDLkJ9TuJDLrwdTlGagcAACAASURBVNrR6a9/JbQgCIIgCIKw84hXU4IgCMKN1azAo1+AF77e/jy0F97/f0Nk//bGJdxQqqoynSjx8MQa35+Is5S51K5Bp9UwGLCxt9PFvk4Xb+n1MhS0YzGKasNr0VJaZGoZ5vJznE2f5aX1lxhPjVNubZ1kBzDpTPgtfg6HDnO84zjHOo7hNXuva1ySJJFIJFhZWSGZTJLNZkmlUpuqeKFdybtr1y6GhobweDw4nU7MZvM1x6BKEo25OaovvED97FnqU+dozM5uuVZrd2Iaeyv68EE05gCqZAX1UgWvUrm0Vuc2Yex2YBp0Yep3oQ9Y0Wg1KLJMOZshNjtJOrpCtZCn1aiTji4Tn5mm1dh87nqTCZvLc2G4Wj9Gqx9JclEtulhfbgIamhI0JeCyGAwmLeFBF56IDU/IivvCzeG99sdNEARBEARBeOMSSV9BEAThxpAacOK/wFNfgcqFy5Pv+F144F+L6t43sViuysMTcf7hZIy5yyp6zQYt94wEeNfeCPftCuKyGLYxyje+ltxiJj/DS8mXmMvPMZ2d5nz2/JaVu1a9lV5nLyFbiN3e3fS5+uiwdxCyhghag2g116/yU1EUkskkCwsLLC8vk8lkyGazmwauARgMBnbv3o3b7aajowOv14vP57sulbxKvU7x+9+n/ORTNObmaK2uol6ZZNbpMA2NYNp1GEPPPtAGUJsGpGwTtdGuulUvFB5rjDoMEdvFm95vwRix0aJJYm6WpeiLxJ+bJrsWo1WvU0glNw5Su4LOYMLqCmF196IzdNFq+ajkTTRaKo08FPOXr24BGvQmHRpAb9QS6HHQt89PqN+Jv8uOVieqdwVBEARBEISNRNJXEARBuL5UFU7/HTz+R1CItre5e+G9fwJDD2xvbMINs5Aq87XH5vjH06soF/J7Rr2We0cCvGd/hAfGQthM4mnH66GoCqVmiZPJkzwXf46zmbNMZ6ZpKlf2FwCdRke3o5td3l0cDB7ktuBtDHuG0Wuv/2NfLpeJRqNkMhlSqRSFQoFkMkntyt63gNlspre3F7/fTygUwufz4fP5rk8Vb6tFMxqltbpK7fQ41eefpzY+jnpFqwit3YH50F2YBm9HYwqiSHbkbANVhWYUQLpwA63DgGWPH1OfE0OnHb3Pgiy1yMVXScRmWH18irXps6Siy1sOUQPQaPUYLW60OieK4kJq6dFoHWgNXWi0PlqyhkJmw5lc/JfNZcThs+DttBHud9I54sHpv/5tNgRBEARBEIQ3L/HqSxAEQbg+FAWm/hGe+veQnGxvc3TAPb8Ph/4p6ERl55tNodbiJ+eS/OBMgsemkxeTvW/p9fBP3tLFu/ZFcJrF9/21asgNJlITjKfGeSr2FOey56hJmxOpTqOT/YH9jHnHGPYMs9e/l4gtckMSvC/L5XIsLS1x6tQpotHolmsMBgN9fX0MDAwQDAYJBoPY7fZrHrimqiqt1TXkXJbGzCzlJ5+kPjVFKxbbnHjVGTGO3on16INo7RHUlgE5L6O2FKSLVbQNADRmPYaIFWOnA2O/E9UEklMmuxolu3qW6CMTFJIJcok15CsSyQAOfwi7twujNUyr4Saz2gKNCzTtc1YBjQ4MRnD6zBgteiwOI2abAavDiDvcHqzmDJgxWQ2ggsmmF4MLBUEQBEEQhGsikr6CIAjCtZEaMPH37Z69iTPtbQYr3P2/wR2/DQZRnfZmU2lIfP2Jeb7+5AIN6dIl7PfvCvK/PjDM/i73Nkb3xlNsFpnPz3MyeZLp/5+9+46S877ve/+e3stO25md7RWLLeiNVRQlUpRpWcVX98qx43ttX+tGiRNZ0lWO4+TGSmTpWElsn5zYimukuMhNUaUsdrE3gACxWGzvu9P7Tm/P/WNBgMsFKYoEuAvy+zoH5/B5nt/z/H4zPABmPvvF95ea5vH1x68a8rZb2znZdpKjrUcZ84zRYeu4rsGgoihks1lWV1dZWlpieXmZdDq9bczLVbt+vx+LxUJrayt+vx+t9tp8xFSqVcqzc2w+9CC5f/xHaiurOwdpTajtLvTd4+jaBlE7+2kWDdCERm7r11aLBFAZNegCVox9DnQBK5qAkfXlSeYvnmHliXNk/j5MrbzzvX+ZzmBEZ3JjdnSjNXRQq/go5LSk41fGqDSACnydNjqGXVu9dv1mnD4zepN89BZCCCGEEG8P+eQphBDizank4bmvwvN/Avno1jm9FW76NTj+q2C+tptBid1XrjX4q+dW+eqP5knkt1oL9Pus3DPq50MH2hhote3yCm8MyVKSx9cfZz4zz4vRF5lMTqKwvVLVY/JwyHeIA94DHPMfo9fRi1F7/TbmajabJJNJotEo8XicSCTC2toaxWJx2ziVSkUwGKSvr48jR45gt9uvyfxKvU49Hqc8NU3p7IuULlygMjtHI5ncPlCnQ9vSgq5rBMO+O1AUP81X7VP38rHGYUDfbUcXsKByaMjko4TTS2RjYYovZck+FCUd2rjqpmqoVLiDHRhtLRgsPVRKDvJpA+WihaZKRT63bShOvwVPuxVXm4W+Q16cvq0N3YQQQgghhNgtEvoKIYT4yTSb8NI34OH/APnI1jlbGxz/v+HwPwWLZ3fXJ665eqPJ355e46s/WmA9vVUF2e028/kP7OOeUb/8M/TXUa6XWc4ts5xbZjIxyZnoGS4kLuwIef0WP4MtgxzyHeKQ7xCHfYevexVvKpVidXWVlZUVFhYW2Nzc3DFOpVLh9Xrp7++np6eHzs5ODIa3thFjI5ulurpG+eJFypOTlF56icrc3NafLa+e3+hE2zaOYegAuvZ9qI0tNPI1GukKjVcuVwValxFduw19hw1tr4VofJGJ5x4kfGaa5PoainL1jdUsLS56Dh6hY2Qcsz1IPqsltlIivloguZ7f1jlCpYLOETfBQScWhx6zw0Brjx29UT5SCyGEEEKIvUU+oQohhHjjVp6Gf/zXEDm/ddzSDe/5NzDyEdDqd3Vp4vp4ej7BF753kZnoVsLWajfwL+7o538/1oleq97l1e2+ptJkKjnFTHqG5dwyiWKCcqNMpBBhI79BupzeEfACDLuGOeQ7RLutnbu778Zn9l23NdZqNQqFAsVikVQqxfT0NMvLy+Tz20tkdTrd5R68Pp+P9vZ2/H4/Ot1P3pdZURTq8TiVmVkqszPUIlHqsRjliQlqodDVb9LpMey7GX3/zahNfppV/cv7qgFQjwNcWrMajEMuzONejPtcNFRN4quLzLx0htUHzxNdmqdeqWx7vM3jxd83gLM1gFbvoNGwUC1bKeTMbCzkWZyo02ys71hWcMhJz7gXb6cNZ6sZs13+rBNCCCGEEHufhL5CCCF+vMQ8PPIftzZqAzDYt3r2nvgkaN9a1Z/Ym1aSBb78g2l+OLlVze006/jV23r5xVPdWAzvzo8PjWaDjfwGT4eeZjG7yEZ+gwuJC6TKqde9z2FwELQGGfOMMeoZ5aa2m65byJvP54lEIqyvrxOJRIhGozv68L5Mo9HQ1tZGV1cXnZ2d9Pb2vulevEq1SmVpifLUFMXnX6D4/PNbG6y9BrXdjml0BP3AKTSeHlQ6D9XVEs1iHRRovtxVQg26Vgu6oBWt24TWbURt0VJQb7KxOEXszI+If2uF6OLcjk3WLM4WOseOYnIMYrAEqZYNxFdyTD6Tp1l/OYiv8PKGbgBqrQpvhw1/n4NAn4PWbjvWluvXVkMIIYQQQojr5d35rU0IIcQbU8nDM38AT/wXaFQAFRz5RXjvv5M2Du9Q6+kif/HMCn/+1BK1hoJGreLnT3Ty6+8fxGl+91Q4ZitZXoi8wJnoGZZySyxnlwkXwjSv0iLArDVzwHuATnsnbdY29Go9AUsAv9WP3+zHZXRd81YNzWaTSCTC7OwsmUyGQqFAOBzeUb37Mo1Gg8lkwm6309XVxdDQEMFg8E1V8cJWJW9laorcD+8n/+QTVObm4VWhK4CuqxPTyAi6YBCNx4vG3Uuz7KaRqVML5aln69SzAFuV5GqLDtN+N4Z+Jzq/Ga3bhEqrplatEJqZYmN6kpmnnyAV2hko601mAgOj2H37UBQfuZSZ5YsFlKYCJLaNVWtUuINWfN123G0WvJ02LE4DZpsejU4q2IUQQgghxI1PQl8hhBA7NZsw/T24/99CdnXrXN+dcNd/hNaR3V2buOaK1TrfeH6Nv35uhYV44fL52wa9/OYHhxnyv/M3aIsVY5yPn+d8/DxnY2eZSEzQUBo7xmnVWg75DjHmGSNoDdLn7GPcM45O8+bC0zeiVqsRjUZJJpOsr68zOTm5Y4O1V3K73QQCAYLBIK2trfh8PqxW61tag1KrUV1dJf/Y42w+8ADl2VmUV61BbbNhGBrEuG8Yy6mTmI+fpLpRoTKbpp4qU1nJ0Zyq88oAVmXUYOhzorHrMY950HfZUWnU5OIxIusXiT+9xOqFl9iYubitklet0WL39qA1+NHo/eTTNup1B9E1FdE1gCYvt4Jo7bHjCljQm7X4umx4O2w4vCbUGgl3hRBCCCHEO5eEvkIIIa6obML5v4Pn/ggSM1vnnJ1w57+H0Y9t7WIk3jHmY3m++eI633h+lUxxK1DTqFWMBR38yzv7uWPI947cpK1ULzGTmmElt8JTG09xNn6WSCGyY1yvo/dywNtl76LT3onT4ESvuf4Vz7VajZWVFaamprhw4QKVV/Wnha0evH19fQSDQQwGA4FAAI/Hg8lkektzN6tVCk88QencOSpLSzRSacoXL6KUy9vGqfR6rLffhvXOO7EcO4bK5qG2kae2kaeyUSD3n19CqbwqONeqMe13YRxoQRewoPNbaNIkvrLExDPfIv63y6Q21snFozvWpdHZUWnaQN2JRj9AuWJ4ZWcGVCrQGjR4ghZ83XZau+209thxeM1v6f0QQgghhBDiRiShrxBCvNvVK3Dxu1v9eucfgvqlYEdv3erZe8uvg+GdX+n5blCtNzmzkuZHMzHun4ywnLxSqdnlNvOrt/Xy0wfasBuvX9Xq22l9c521zTWaSpN0Jc3G5gano6d5Mfoi1WZ121i1Sk2/s59x7zgHvQc55DtEp73zbV1vOp1mamqKlZUVlpeXtwW9ZrMZr9eL1+ulv7+ftrY2zGbzm+7B+2q1aIzCM09TePwJ8o89RrNQ2DFGZTJhHBrC8TMfwnzsGNqODpQylCYSpP4hSi28uOMetUWLcdiNvt2Gzm9G32FDUSnElhZZP/cMi2dfJDRzkUZtZ6itUjtQafyotW2odV2o1C2oVCpUKrB5TNjdRjqGXZhsOjztW5us6Qyaa/J+CCGEEEIIcaOT0FcIId6t8nE4/efwwp9CIXblvKsPjv0KHPw5MDl3b33imsgWazw8HeWHFyI8NZ+gUL1SeanTqDjZ6+YTxzu5e8SPRn1jV/Wub67zTPgZnt54mqnUFBv5jdcc6zV56bJ3MeYZ49b2Wxlxj2DWvf0VofV6ncXFRc6dO8fFixe3XbPZbPT39zM2NkZ3dzdq9VtrR6DU61Tm5qgsLlIPh6ksL1Odm6eysEDzVb2AtV4vlttuxTg0hMbpxLh/P/qeHpRKk/JCls2nolSWzqCUX1HJqwKtz4w+aEUXsKLvtKENmoksLDB1/glyL8bJxaIkN1Yo5ZLbF6cyoNZ2oNZ1o1a3oNJ40JusmO16zA49Tp+Z4KATb6cdh8+ERiutGYQQQgghhHg9EvoKIcS7TTkLj/8neO6PL23OBtja4NDPw74PQuCgtHG4wS0nCjw5n+CBi1Genk9QbyqXr3msem4d8PK+4VZuG/Rgu4GrenPVHI+uPsr3Fr7Hen59R8irUWnocfSgVWsxa82029rZ59rHzcGb6bH37ErrinK5TDweJxQKMTs7y+rqKrVX9Krt7u5mYGCAjo4O2tvb33TQ2yyXKV+4QOGZZ6ltbGyFvUtLO/rwXqZSYRwZwXzyVkxHbkIX7EWlUdMs1qmu5cg/V6F+30vUIgVQXnGfGtQeM9UOGyW3iUw2QSY8Q/KlafKpCMXMKkqzfJUJ9ai0PjS6HpyBYTpH+rF7zFhbjNg9JhxeE2b7u2fjQCGEEEIIIa41CX2FEOLdol6Bs38Jj34Jipc2UgoegZOfgv0/A9dxIypx/SmKwumVNP/tkXkem41vuzbYauUDI37uGvGzP2BHfYNW9IbzYc7EzjCbnuWZ0DNMp6a3XdeoNIx7xznVdopDvkOMukex6t/aBmZvlaIoRCIRNjY2mJqaYmFhYccYq9XK0NAQR48eJRAI/GTPr1Ypz81RmZ6mfHGK6voatdU1qktLVx2vtlgwDAyga2tD196OrnMYBR+NjIbqepFaok7t/hIw+ZpzqlsMlD1mljdLLC7Okt9YRHkxTbMeAiV/lTv0qHUdaPUt6EwuzHYXwaExOkf8tA06sTgMP9FrFkIIIYQQQvx4EvoKIcQ7Xa0Mz/4BPPtVKFwKAz2DcNdvw8D7par3BpfIV7jvfJg/f2qJlUs9ejVqFUe6Wrh90MsHRv30eXc3+HyzFEVhbXONx9Yf4+HVhzkTPbNjTNAa5Gf6foYD3gOMe8f3RMibTqdJpVLMzMwwOztLNpvdNsZms+H1eunr66Ovrw+fz/djK3ob+QLlyUmqS0vUYzHK09NUFuaprW9Ao3HVezQOB5ZbbsEw0I++txd9Zw8KLVQWN6nHijSyFQqnC8D2/r0qkxaNTQdNQKumZtez2WgS2QizFJpicyNMsxFDaSTZGvTKm9UYLR5snk5cwX66DwzTe2gEk9WA6gb9YYMQQgghhBA3Igl9hRDinarZgIl/gEe/CJnVrXO2wNbGbEd/SSp7b3DzsU3+7Mkl/u70Oo1L7Rsseg0/NR7gU+/pp9tj2eUVvnGKohAtRpnPzDOXnmM+M89sepbV3CrF+pV2BCpUjHpGGXINcdh3mFNtp/CYPLu48i31ep2VlRVmZmaYmZnZEfLqdDo6Ozvxer0cPXoUj+e119wslaiFQtTW16mur1OZm6P04lkqs7OveY/aZsM4Oo6hfz/aYA8auwe1rQWNzUUjU6GeLFOaKZN7LAqNyKtuBkN/C8Y+J4Y+BxqPkc3MJi89fI6VifOkw6vUqxFobrK9r8MWo9VB1/hBPB2dBIeG8fcNojMaf6L3TwghhBBCCHHtSegrhBDvNLUSnPsreO6PIHEpKLIF4I7fhLGfBZ1pd9cn3jRFUXh8LsGfP7m0rYXDWNDBxw4H+fixDsz6G+Ov9nqzzkxqhic2nuD+5fuZz8xfdZxOrWPcO877Ot/HHZ13ELQG3+aV7tRoNIhGo6yvr7OwsMDS0hLVavXydY1Gg9PpJBgMMjIyQk9PD3r9zv60iqJQW19n84EHyfzDP1CLRFBKpdecV+vzYRweRuvzouvtw9C1j2a9hVq0QXk6RX1ToX6540X60q/tNE4D2i4LVVOVXCFOhiSJ+GkKj+TJ/m2cfGoVlPpV59foTQT699M20Id/YIDWnj5sbu+u9EYWQgghhBBCvL4b45uhEEKIH69a2Ap6n/sjyF+q5jO1wE2/Bif+H9DfOJWfYrtitc53z4X40yeXmI9t9UxVqeD9w6380i09nOx17/IK35hyvcxToae4f/l+Hl9/nELtSlsBrUpLp72TgZYB+p39DDgH6HH20GHtQLeLVenNZpNCoUAoFGJtbY21tTU2Njao17cHoxaLhcHBQYaGhujt7d0R8iqKQj0cpjw9TXlqivLEBSqzs9RCoR1zqq3WrX67wXa0/h4M/WNoAz3Q0NPIVqjFilTXipRnakDsyo1aNRqzFrVZB3oVNarUqVLSF2noG2SqcRZnTxM/e/V+v9vWoDHhCg7TPjzAwImDtPgDWFpaUKs1b+p9FEIIIYQQQry9JPQVQogbXb0C5/4afvRlyEe3zjk64eQ/g0M/D0b77q5PvCm1RpPHZuJ8+9wGD0/FKNW2+rZaDVo+frSD//Ombjrd5l1e5Y9XrBV5cOVBHlt/jCc3nqRUv1LJatPZOOg7yF3dd3FHxx04DI5dXCmUSiXC4TArKyuEQiHC4TCFQgFF2dnWwGAwEAwG6ezspL+/n7a2NiiXqYXDVJ97jmIsRmVxkcrcHM18geryMo1UauekOh2m0VEcH/0IlhMnUOks1DdVlM4nKL0Up1FoUnwJeCm8814V6Dps4NewackRzSwTW14kPrtMMZehUau89otVmVBrvKjUTtRaE9YWBw5fC72Hx+g91I/jBu0DLYQQQgghhNgioa8QQtyoaiU483V46vdh81Ig5OyC2//1VhsHrWF31yfelEKlzv94aok/fnyRXPlKNWmHy8Q/PdnN/3G8A5txb/djLtaK3L98Pz9Y+gHn4+e39eUNWALc2Xknd3ffzZhnDM0uVI42Gg1WVlZIpVKUy2VWVlaIRCJsbm6+5j0ul4uuri46Ojro6OjAZbdTnZ6m+MILFL7xDeYnL9JIJH7s3IaBfgzDw5hGx9D39qNx99BIN6lFC6S/k6S2sbL9BhVoPSbUNj2YVTQMTUrqPOuhWVZWJkk+tUSj/hrhrsqESu1EpbYCalQqHWpdJ2pdJ63drQwe99M16sbhNckma0IIIYQQQrzDSOgrhBA3kmYTIufh/N/CxN9D4VJfV1sAbvqXcOxXQLuzd6jY25YSBU4vp3hiLsFDU1GK1a2qXpdFz4cPBvnQwTYOtDv2dO/URrPBheQFvjv/Xe5bum9b64ZOWycf7P0gtwVvY9Qz+ra/js3NTaamplhcXKRarRKJRCgWi1cd63A4aG9vJxgM0tHRgd1ux1SvUzl/nvLEBcoPPEh2ZobE+vpV71fbbOgCAbQeD/reXvQ93WicLWg8QTS2ADTVVEN5KnMZij/YhObczmc4dFQcNdKWBPHiBuvTFyikk9Qqr9XvV4NK40Gt8aDSeDFY/Vicdsx2P85WK3aPCaNFh9NnxmjV0eI3o9VLmwYhhBBCCCHeyST0FUKIva6Sh9Vn4aW/hvmHoJy9cs3RAbd+Bg7+E6nsvcEk8xWeXkjyV8+t8Ozi9n/23+ky89m7Brl3vA3NHq7AbCpNJhOTPLj6IN+e+zbpypWNwzpsHXy4/8Pc3HYz+937r3vQW6/XyeVyZDIZUqkUqVSKWCxGPB4nm83uGG8ymQgGg5hMJjweD729vXi9XoxGI/VEguLp0xT/x9dIvvAClbmdwSxsBbzmY8e2fh05jK6jE43VTqNQo7qao5EuU13Pk38hg1LOAbmdz7DoULfqKag2CSdXmV9/keTSPLCzpQQAKiMqlQW1NoDF1YvN3U73+CCuNismqx5PhxWTTX7wI4QQQgghxLudhL5CCLEXRSfhwjdh6XHYeBGUxpVreiv03QEHfx7674Rd3ORKvHHZUo2J9SxT4Rx/e3rt8oZsAGoVHO12MR50cO+BNsaDDtR7OOxNlBJ8Z/47fHPum6xtrl0+b9PZuKX9Fj428DGO+Y+hVqmv2xqKxSKxWIxwOMz8/DzLy8s0Go3XHB8MBhkcHMThcNDS0kIwGERJJKiurlJbXaV67hzJjQ1K516itrq64359VxfGsTFMY6MY9g1j6O9D7XTSTFcpXUyS+1GMWnjiNbNa1KB1mWhqm1S1VVJKgrn1C0TmJqlf2NlWQqXxoNL4UKlMGG1dmBw+7B4frV0u/H0OgoNODGb5vS+EEEIIIYS4Ogl9hRBiL1l7Hp74LzD7w+3n7e0wdA+M/W/QdkhaONwAmk2F0ytpfnghwqMzMZYShR1j+n1Wbh/08su39NDmNO3CKt+4SqPC8+Hn+db8t3h09VHqyla/YZPWxNHWo3x04KO8p+M9aNXX/qNFo9EgmUwyPz9PKBQiGo2SSCR2bLCm1WpxOBy4XC5aWlrwer34fD68Xi/6YpHiCy9QnZ6hurjA0gsvUA9dZXM0AJUKw+DgVgXv0aOYjx1F63ajNBSqKzlKMykKf7dOLTSNUmte/RkeLRV1iVw1S4oYa/EZ0meXadarVxmsRqXxojMGcbf34+4YxNsZwNlqJtDvwGSV3+9CCCGEEEKIn4yEvkIIsdsadZj8Fjz7hxB68dJJFez7KRj6IPTcBs6OXV2ieH2KopAqVDm7mmEylGNiI8PplTSZYm3buE6XmT6vhTv2+fjgWACPdW+35FAUhbOxs3x34bs8sPwAm7UrFanj3nF+duBnubv7bsw68zWdt1AosLq6evlXMpmkXC7vGGez2QgEAnR0dDA0NITX673cRqK6skLhmWco33cf0cmLlC9ehFdXAqvV6Nrb0Xd0oOvsQOfzYRwdxXTgABq7ncZmleraJvnnslTXNqiFCyiv2FwPABWoAgZSugSL8QkS4WWy6RDK0mtVHetQqe2otR6cgS7ah/fTOboPX5cLh0c2VBNCCCGEEEJcGxL6CiHEbnk57H38K5CY3Tqn0sCBT8AtnwbPwO6uT7yuRlPhwkaWH0yEuX8ywnJy58ZgNqOW9+9v5e4RPyd6XDjNe79iM1VO8XzkeZ4LP8czoWfYyG9cvuYz+Xhv53v52cGfZcg1dE3mUxSFdDrN6uoqKysrl0PeV9NoNLS2trJ//37cbjdtbW04HI7Lz6jOz5N94glKExMUn3ue6tLSjmcYBgYwDO9D39mF6cABzIcPobZYAGhWG1RXN2mky+QeiVFZnKUe27lxWl3dJNlMESquEt+cI1tcpbl4lWpflRGVxoNG50WjtWGyteDp6iHQ10NrrxN/rwODST6GCSGEEEIIIa4P+bYhhBBvt1oZzv0lPPVfIbOydc7kgpOfgqP/F1g8u7s+8Zo2yzUenorx0FSUp+YTpF9VydvtNnOky8Vgq5WTvW6GA3b02uvX1/atSpQSXExeZCIxwUR8go38Bsu55W1jdGod7+96Px8b+BhH/UevSZ/eXC7H4uIi0WiUmZkZUqnUjjFer5euri46Ozsvt2nQaDSXr9eTSTLf+jals2cpPPcstZVX9eHVajEfOYJpfAzD0D7MPe33KgAAIABJREFUhw6iCwZRFIVGqkyjUKOyVKKeTFOeS1NZyUJte7sIRVHYbGSJlzdIllZJVyNkqwkUXh3yalFrgxhsPdg9Xbg7OvH3+gkOtuDpsO3p/sxCCCGEEEKIdyYJfYUQ4u1SzsJzfwTP/wkUYlvnzG44+c/g+K+C0bG76xNXla/UeXgqyvfPh3lsNk61fiXwsxq0nOx18ZFD7dw26MFm3Lsba+Wrec7HzzOXmeNs7CwTiQlixdhVxw62DHLcf5yTgZMc8x+7Ju0bKpUK586d4/Tp0zv68arVaoLBIJ2dnXR2dtLR0YHZvH1OpVajePYsmw89TOGZZ6jMzsIrnqEyGjHu34/p4EFM42NYbr4Zjc1Gs1ynurpJaXaT/LNzVBYz1JM7W0UAFOs5stUEhXqGSGmZeHmdanN7ta/B4qclMIAr2I7D10ZgoB+714nDa0ar01z1uUIIIYQQQgjxdpPQVwgh3g6T34If/L9QiG8dOzrgpl+DQ78A+mvbD1W8Nc2mwsRGlkemY5xeSXF6OU3lFUFvr9fCPaN+7hjycbDDiVazNyt5FUVhOjXNw6sP80z4GS4mL1Jvbu9Hq0JFl72Lce84o55Rehw9DDgHcJvc12QNmUyG1dVVLly4wOLiIvX6lfmDwSBtbW10dnYyODiIwbCzv3Fjc5Py5CSbDz9C7r77aLyqItiwfxjrTTdhHB3FcsstqA0mKis5qiubZO/boLqep54swfYCXppKg2qzTLG+Sb6WJlWNECmukK3nUakMaI1eTDY3/v79eDoC+HuDBAbasblb0Gjlo5MQQgghhBBi75NvLkIIcT2VMlth78TfbR23dMMd/xZGPgyavVsV+m5TrTd5ZjHJ918K8ehMnES+su16t9vMveNt3HsgwFCr7fJmYXtNrVHjyY0neWz9MZ4JPUOoENp23WvyctB3kP3u/Rz0HmTYPYxFZ7kmc2cyGS5evMjc3ByZTIZSqbRj8zW3282RI0fYv38/Tqdz2zVFUaguLlI8c4bSuZconj5NbXV7ywZNSwvmkyew33035iNH0Lg8lMMZkmeWSP73M2hSoG7uDOHztQzJSojNWopsNU6ktERdqaHW9WD3HsC//04O97fR0mrF12XH4tzbG+wJIYQQQgghxI8joa8QQlwviz+Cb/9zyK2DSg23fAZu/zxoJVDaC1aTRV5YTvHYbJxHZ2Jslq9UoVoNWm7p93DLgIej3S17Ougt1op8e/7b3L98P+cT57dV8xo1Rk61neKOjjs45DtEt6P7msxZKpUIh8PE43HW19dZXV0lm83uGKdWq3E4HAwPDzMyMkJbW9vl97GeTFI6d47K3DyliQlKZ87QyGR2PEMXDGI6fBjHvT9Fc2gf60+dZ+O5MOZHHsOmcqFVbf3wRMdW2FusbxIvr5KpxshVk6SqEcqNAiq1C42+lZa2Pob776VnfICeA21o9dKSQQghhBBCCPHOI6GvEEJca/k4PPwFOPsXW8euXvjIH0HH8d1d17vcerrIxVCO55ZSPDoTYzFe2HbdazNw90gr94wGONbt2rMbsCmKwkJmgUfWHuGJ9Se4kLhAXbkS9LqMLu7puYdTgVMcDxzHpDW95TlzuRwLCwvMz88TCoVIp9M7xqhUKjo6OhgZGcHv92MymXA4HOhUKurhMKVz50h8839Rnp2hMjNLbW1t5zOMRkzj45gOHsR89AiNznYiEytsnN8g9t0QLZo6drUROz1cynhpNOsUG5ssF1aIVfNkmmo0hjZa/Edo7XGyL+jA0+nF2+HCaJHqeiGEEEIIIcS7g4S+QghxrTSbMPH3W+0cKpeqHo/9CrzvC2Cw7u7a3oUUReFiOMdjs3F+MBHmwkZu23WtWsXBDicHOpzcM+rncGcLavXeq+aNFWP8cOmHnIufI1PJsJBZIFXe3tu2w9bBJ/Z9gtvbb6fd1o5a9eYCa0VRCIfDRCIRYrEY8XicTCZDMpncMdbpdOLz+fD7/bS3tNCyskpzagplfWOrijeVIruyQj2R2Pq9cRWGgX4MQ/swDA1iOX4cff8g0ZcW2DgzQ+kHc1grEVyGABa64FJeW2mUSVTzxOpNkg0VecWExemi40Q/R3rtBAactLSaUe/RXstCCCGEEEII8XaQ0FcIIa6F+Ax8/9dh5amtY/843PM70HXT7q7rXWg2usn3z4f55pl1NjKly+c1ahWDrTbGgnbuGPJx84AHu3HvVH4qikK4EL7cizdfzRMqhHhy48kdG7AZNAYO+w5zV/ddnAicoN3a/qbaT+Tzeaanp4nH4yQSCUKhEKVS6apjA4EA/Z2dtDudONNptLEYjUiU4ne/t1XF+zrzqPR69P19GIeHMQ4Noe/pwTg6RrOsJXNxnezFCJm/i6Krp9GoNHjxAT4wQL1ZJ1pJkmhoSTaMNGwWgmMBeodaONltx+42YjDvnf+PQgghhBBCCLEXSOgrhBBvRWwaHv9PcOGbgAI6M9z6Gbj507JR29toPrYV9N53PsxcLH/5vEmn4VSfmzuHfXxgxI/bujf6KSuKwkpuhecjz7OSW+Fc/BxLmSU2a5tXHX/Ae4A7O+/EZ/bht/gZ84yh1+jf1NzpdJrp6Wmmp6dZXV1FUZRt13U6He3t7ThtNlpVKrQbG1jOnUPzwIM0UimaQOoqzzUMDmI6eBBNSwtatxtNixNdIEDD7SYTybG5GKeQrqNaV6GeymP+/lm0qq2PIQY0gAlUUG4UydQ2yTc15BUTOYsV/9ER2oNWbh5x4/CZ9mx/ZSGEEEIIIYTYKyT0FUKIN2MzAj/8DZj8FnApNBv6KfjAl6Gla1eX9m5QazR5bCbOj2ZjPLeY2hb06jQqbhvwcu+BAPeMBjDqdnejrnqzTqQQIVwIs5RdYiIxwXPh5wgXwjvGqlAx7B5m1D2Kw+DAZXRxwHuAMe/Ym5q70WiQTqcJhUKsra0xPz+/ox9vIBCgu60NcyaDK5vDOjdH7fHHqa2sbn/Wy2s0GtG1BzH09qH1eNB3dWK75x4261WWz00QPTuHaj2BtVnCpirh0ObQqnXYMQCvCN1VUGtWyFTjJKtZ0o06iquVlqEB3B376ApYcAXM2N0mVHuw7YYQQgghhBBC7GV7OvT9rd/6Lb7whS9sO9fa2kokEgG2KqW+8IUv8Md//Mek02lOnDjBH/zBHzAyMnJ5fKVS4XOf+xzf+MY3KJVK3HnnnfzhH/4h7e3tb+trEUK8QyjKVlXvP34eipf6nO67F27/PAQO7O7a3qEKlTpT4RxT4RzTkU0W4nmmI5tkirXLY3QaFbcOePmpsQDv29+Kw7Q7VdbVRpWl7BJTqSlm07O8GH2R2fQstWZtx1itWssR3xG6Hd0c9B1kwDlAr6MX3VuoEFcUhWQyyfr6OsvLy8zMzOxo16BSqWh3uei32wmGwqi+812qi4uXrxdfuUa/H+O+fVhOncR0+DCGvj7QGdhczxObWCMzvUJ5MoH+7A8xqYy4dV586kOX++++rN6ss1nPka8XKJCnblLQeK207Ouka/weRrxW9KY9/ZFECCGEEEIIIW4oe/4b1sjICA899NDlY43mSsXWV77yFX73d3+Xr33tawwODvLFL36R97///czMzGCz2QD49Kc/zfe+9z3+5m/+BrfbzWc/+1nuvfdezpw5s+1ZQgjxY2XX4b7Pwew/bh23jsFHvgr+N1eFKXZSFIXVVJEzK2leXE1zZiXDTCRHU9k51mM1cO94gBM9Lm7q97xtQW+lUSGUD7GYXWQiPsFkcpJ8NU++lidSiFBulHfco1Pr8Fv8dNu76W/p54T/BId8hzDrzG95PYqiEIlEmJycZGJigmw2u+26RqPB19KCq1YjEIngfOxxNJkMAK+MovW9vRj37cMwvA/TyAiqnkHqegvZ1U0ikyHq3wxjKIYwqYyoVWpMgAk7qO1gvPKcWrNOXl1jU9WkatGj8Tto6ffRe8iHxbE32msIIYQQQgghxDvdng99tVotfr9/x3lFUfj93/99fvM3f5OPfvSjAHz961+ntbWVv/7rv+aTn/wk2WyWP/uzP+Mv/uIveN/73gfAX/7lX9LR0cFDDz3E3Xff/ba+FiHEDWzhUfjmL29V96p1cNvn4JbPgPbN9VUVV+TKNR6fjXN6Oc3jc3EW44UdY/x2I8MBG/sCdgZ8VrrcZsaCTvRa9XVZU6FWYCO/QaKUIFFKsJhZZCo1xcXkRTKVzOvea9KaGHYNs9+9n/3u/Rz0HiRoC6JWXbu11mo1NjY2WFxcZGpqing8fvmaWq2mrbUVH+BfXMLx/PM0w9tbSWgcDrTBNozDw+iP30yxfYRCuczyuUXqc2ksF5axqMIYNQZsOgf2rVcGl15CQ6lTqOUoKAUaRj16dwu2Hh9tx7sxt1ul564QQgghhBBC7LI9H/rOzc3R1taGwWDgxIkTfOlLX6K3t5elpSUikQh33XXX5bEGg4Hbb7+dp59+mk9+8pOcOXOGWq22bUxbWxujo6M8/fTTrxv6VioVKpXK5eNcLnd9XqAQYm9rNuDJ34NHfxuU5lYLh4/+CXiHdntlN7SFeJ4fXojwyHSM8+sZao0rpbw6jYqxoIPDnS0c7mrhcGcLfofxdZ721tSbdaLFKNOpaV6Kv8Tja4+zkF143XtMWhOdtk5GPCOMekZpNbdi0ppwGV1027vRqK/tvyQpFAqEQiGi0SjT09OEQiGazebl6xq1mi6dju5UCu/pM/CKkLcJoNViGh1Fd+gomwMHWE1XCC8sk4sl0H3zEbpMF+iwDDKkd4PaCqYrcyuKQqYaI9VMUnGpsfW48Q630bv/GEaL9Zq+TiGEEEIIIYQQ18aeDn1PnDjB//yf/5PBwUGi0Shf/OIXuemmm5icnLzc17e1tXXbPa2traysrAAQiUTQ6/W0tLTsGPPy/a/ly1/+8o5+wkKId5nMGvzDL8H681vHh34BPvifQXf9Ash3slCmxLfObvDAxSgvrW2vlu31WLht0Mt4u4PbB724rde3DcDa5hqPrD7CI6uPMJmcpNKo7Bhj09lotbTiNrrpsncx5Bpiv3s/HbYO7Hr7datmVRSFRCLB6uoqa2trrK6ukkqldowzA77NTXyzswSXV9DXrjRraKo0VAeOUNt/jLjeQbmUQ5svYl7WoV25gFVjY0zjxmjvxKpzXrlPaZJX5ajYG+jbLNjaXVi6vbS2H0NvNO1YgxBCCCGEEEKIvWlPh7733HPP5f8eGxvj1KlT9PX18fWvf52TJ08C7PjSrSjKj/0i/kbG/MZv/Aaf+cxnLh/ncjk6Ojp+0pcghLgRNZvw4tfggf8PqptgsMPdX4LDv7DbK7vhJPMVfjAR5nsvhXl++UpwqdOoONXn4b1DXu7Y56PTZb6uLQGaSpO1zTWeWH+C7yx8h+nU9LbrWpWWXmcv+1z7uKntJm5uuxmn0fkaT7u2isUi6+vrhEIhQqEQa2trOzZfA7AWi1hyOYIbG7SFQpgLRV5+x9QWC+bb30u58yThTR2GvAqfzoEOPW1VQAM4rj6/goKmw4T9ZAfmEQ9q457+aCCEEEIIIYQQ4g24ob7ZWSwWxsbGmJub48Mf/jCwVc0bCAQuj4nFYperf/1+P9VqlXQ6va3aNxaLcdNNN73uXAaDAYNBNpwR4l0nuQDf+1ew/MTWcftx+NifQEv3ri7rRtBsKkQ3y1zYyHFmJc3ERoZnF1M0XrEL2/EeF/eM+rl3vA2v7fr9GVtv1rmQuMCZ6BnOx89zNnaWdCV9+bpGpeFo61Hu7LqTU4FTdNg6rnlLhldqNpskk0kikQjRaJRUKkU6nSaTyVw14NXU67hSKTyJBJ54AncyiaFaBUAXDKI5cCuV1gHKSgu6hgWjyoqi0mBKaegFeMVb21DqNFRNGmbQB21YXHaMPhtqux6NRY/Ob0Ztfns2wRNCCCGEEEII8fa4oULfSqXC1NQUt956Kz09Pfj9fh588EEOHToEQLVa5bHHHuN3fud3ADhy5Ag6nY4HH3yQj3/84wCEw2EuXLjAV77ylV17HUKIPahagBf+FB79MtRLoDPDe/8dnPgkXMcw8EZWbzQ5v5Hl3GqGR2dinFvLsFmu7xg3FnTwoQNt3HsgQMBx/VoE5Ko5ng8/z5MbT/LA8gNs1ja3Xder9Qy0DPChvg9xT889tBhbXuNJb42iKGxsbBAKhUin04RCIcLhMNVLoe3VmAsFXMlLIW8igatSwdTdja59EM3oCXTtQ9RVTvLREqoM6DCiU8AKW1W8l5TqeUrNAhVLDeuRVoLHR7C3tb7WtEIIIYQQQggh3qH2dOj7uc99jp/+6Z+ms7OTWCzGF7/4RXK5HL/4i7+ISqXi05/+NF/60pcYGBhgYGCAL33pS5jNZn7u534OAIfDwS//8i/z2c9+Frfbjcvl4nOf+xxjY2O8733v2+VXJ4TYEyp5OPM1ePwrUM5uneu5DX76v4KrZ1eXthfVGk2eWUjyjxfC3D8ZJVXYHmSqVdDrtXK0q4WRoIOb+9z0eq/fZl8ruRW+Pf9tLiQu8GL0RarNK+ux6W2cDJxk2DXMMf8xhlxDmLTXLnSuVqtkMhmKxSLRaJT19XUikQiJRAJFUXaM1yoK9lwOZzyBI5fFUihgyRewFApYBwbQ94+iG70btb2TSlahmaiCoqZRhMYsgIKRrX7S9WaNRCXMZqNG2WrCGLDiCDrpOnUQV5v/urbKEEIIIYQQQgix9+3p0Hd9fZ1PfOITJBIJvF4vJ0+e5Nlnn6WrqwuAz3/+85RKJT71qU+RTqc5ceIEDzzwADab7fIzfu/3fg+tVsvHP/5xSqUSd955J1/72tfQaKRyT4h3tVwInvsjOPM/roS9LT1w62fh0M+DhGaX1RtNnlpIct/5EA9cjJIpXtkwzGHScaSrhRM9Lm4Z8DDYakOnUV+3tZTrZS4mL/J06GnORM9wOnp62/UeRw9HW4/yge4PcNR/FLXqra+lVCoRj8cJh8OEQiESiQSbm5tsbm5eNdyFreLbQKmEMRbDFYnQkkpjz+VQXxqvCwYxHj6J5fjtqO1dbE6nIVyjFgNiW++vGjWKolBXahTrOdLVCOlaibzGimtsgH233sWBARc6g/x9JoQQQgghhBBiO5XyWt9YxTa5XA6Hw0E2m8Vut+/2coQQb1b4PDzz3+DCN6F5qRWBqw9u+TQc/CfSyuEVkvkKf/PCGn/17AqhbPnyebdFz92jfj44GuBEr+u6hbyKohAuhJnPzPN8+Hkmk5PMpGfYrF5p26BCxS3BW3hPx3sY8Yyw37X/LVW5KopCIpFgdnaWlZUVQqEQ+Xz+NcdrAXOjgTWfx7W+QUtiq4rXWCqjaTaBS5usHT2OYfwE+s79KIqD4mQaJbuz3UOqEiZeXiNZiVJQLGwqVgxWJ552F+3DvfQc7MHTYUOtlh9KCCGEEEIIIcS7wZvNJPd0pa8QQlwziTl46Ldg+vtXznXeBDf9Cxi8B9TXrzr1RrKWKvKj2Tg/mo7xxFyCamMruGwx6/ip8QAfHAtwvNuF9joFvbFijBejL3I6eponN55kI7+xY4zL6OJo61GO+49za/uttFnb3tRc1WqVfD5PMplkeXmZRCLBxsbGVUNek0aDT63GnsvhmJzEmEqjr1ax5vNcjl/VOjS+PgzjJ9H6u1E72lEbnDRrWhqpCtU1qK6VgSsBerlRIF2JEi2vESpvUje14ekaom3gLtoG/LR227E4ZVNRIYQQQgghhBA/GQl9hRDvXM3GVkXvC38Ga89unVNpYOTDcOqfQ/DI7q5vjyjXGnz/fJhvnV3nqfnktmvj7Q7+6alu7h0PYNRd2yrobCXLdGqaxewiZ2NnORc7R7gQ3jZGq9LSYe/gsO8wB7wH6HH0MOYZQ/MGK7IVRSGfz5NIJMjlcuTzebLZLKFQiFAoRPNSNe4rqVUqglotgWgU+/kJHPE42kZj+xizBcPIzejax1Bb2kBrpZFXQ125NC80MtCgAWzdW2tWydUS5KpJoqVlYvUkOmeQQP8B+o/9IrcNerC5jNKPVwghhBBCCCHEWyahrxDinafZhJn74Ee/A9GJSydVMPgBeN+/B9/wri5vr8hX6nzn3AZf/dEC6+kSsLUR25GuFt4z5OO9+3wMB956O5tirchidpFUOUWylOR84jwT8Qlm07MobO8wpFap6XX0cqrtFKPuUd7b+V6MWuPrPr/RaJBOpy+Hu4lEgmw2SyaTIR6PU6/XX/NejVqNTaPBm05jXVnBFQrjyGbRveIerdeLYWQcracLjacLlamDWqSJUmpuhbuXC4MVyo0im7UklUaJTDVOoZ6hUM+Sr2WpqHS0BPrpuXmcO97zEdxtgTf7lgohhBBCCCGEEK9LQl8hxDuHosDCw1ttHCKXwl6jA079Ghz6J2B/c20A3kkUReGl9Sx/f3qN75wLka9shZt+u5GPH+vgo4eCdHssb/r5pXqJldwKi5lFzsXPcS52jtn0LA2lcdXxHbYOOmwdHPQd5JDvEOOeccw682s+P5fLkUqlWF5eJhwOk0gkSKfTV63YfSWnxYJNpcKYz6OLxbGHw7jXVrHkC7yyrlZl86EffA/a4CDq1l4UtRXKalTVrRbQzQjA1ntWbZSJlldIVcLkaxny9TSZagxUJlQaF2qNB50hQGD0vZy6Y5SeA61or3G1tBBCCCGEEEIIcTUS+goh3hnis3D/v4H5B7eODXY49stw8lNg9e3u2vaAZL7C/3pxg78/s8Zs9ErP2m63mV841c0njndg1r/xvxJS5RQXEhc4FzvH+uY6oUKIptJkMbtIoVbYMd5tdOM1e3EanOxz7WPMM8bh1sN4TJ7XnadarRIOh1lYWGBpaYm1tbWrjtPpdNhsNhwWCy6VClM0hjEeQzc7i2l5ZVvl7ss0LX6U0WM0fN2oWtrQaF2YKjZUL8fAebYFwuVGgXwtQ7oSYb04T7wcAbURlcaFzujE1jrCULCfwEAnDq8ZZ6sZd9Ai7RqEEEIIIYQQQrztJPQVQtzY0svwwL+Fqe9tHat1cOxX4NbPgtW7q0vbbflKncdm4jwyHeN750NU61vVsAatmntG/XzkcDu39HvQqF87lCzXy0ynpplKTRHKh1jfXGdtc+2qrRleZtPb6LR1csh3iAPeAxzwHsBv8b/h8LPRaLC4uMjp06dZWFjY0Z7B4XAQCATo7urCns1hXl5CMzlJ5eFHqIVC28aWdBoyRj1NmxtDzzE09nYMWi8WlQuj5hUVzVda75KshMhVk+RqSTbrRQqNKsVmDa2lBbOzA3ffOH3BD3DUb8cdtGJzGTHZ9G/otQkhhBBCCCGEEG8HCX2FEDceRYH1F+CFP4WJfwClASo1DNwFd/02ePp3e4W7Zi1V5P7JCA9ejHJ2NUO1caXtwWjQzieOd3LveBsOk+7yeUVRiBQizGfmWcgssJBdIFKIkK1kX7c1w8ubqvU5+2i3tqPX6PGavAy7h1Gr1G9ovYqiUC6XCYVCxGIxlpeXdwS9ZrOZnp4eenp66GtvR3vhAtnv30fpD79KPpUkZjZQ0mlRVCpqrS3UWhxUHA7UejcmxUmrqYdWYxd6zfbewE2lSb6WJlvPUm7UKDTqxBuw2TSg0gRo6z9G734PwUEn/j4HGs0be01CCCGEEEIIIcRuk9BXCHFjiU5u9eyde+DKub73wt1feldu0LaeLvLIdIzHZ+NMbGSJ5irbrvd6LNw64OFDB4Mc7nRSqpd4IfI0c5k5VnOrrG6uMpOaIV/Lv8YM4DK6GPeM4zP76LJ34bf431Brhqup1+tsbGwQi8VIpVKcP3+eQmFnOwiz2czIvn3sczhxZ7OUz50j/7WvMxEPs2nQkTUZyLqMFAPdmLV2HDoPZq0Nh85Li8GPU+9Dq9Zte2apUSJWyZBrQKqhIltv0FRbUak70Bo0BPc7OTDgpLXbjrvNitGq27EuIYQQQgghhBDiRiChrxDixhA+D0/9Plz45pVz+z8MN/8rCB7evXW9jZpNhcVEgRdX0zy/lOK5pSRrqdK2MSoVnOhx8YERP7cNeunxWMjX8jy08hD//cEfcDZ2lkqjsuPZWpWWLnsXfc4++p39BG1BjBoj495xWs2tb6kvraIoRKNRzpw5w/nz56lUds5vN5vxKArOVAr/9AzWlRWUcpm00cS6u4281UHFPUCjdRiTxka73s243o9V17Ij3H1Zrdkk22gSr6uI1xXSDS3gwe41Eehz0Oc0YLLpaRt04g5aUb9OmwshhBBCCCGEEOJGIqGvEGLvatRh+v9v786j7KrqvP+/z53nW/M8Zp4DSSAEZBCQoUFAfGxQfijt8LT9iMrSx5/669VLsO3Wpatt19M2ttpKa9ur8emWoVsRDJqEBAJknqdKakjNc92qulV3Ovv3R4VKLpUBJFUVqj6vte5aVfvse86+12/te/1ks8+v4fUfQePLpxotWHI3vPf/g8KF0zq8yZTK2BxpH2RPcz/7W2I0dA9zqD1GfzyV1c9hwaqqXN67qIir5uSxoDhM2OdmKDnExuaN/P3eF3i59WVS9unnlYfKubzocqrCVVRGKpmXM4+50bm4nRdvZatt27S2tnL48GH2799Pf3//+DGfz0dleTnBVIqCpibyXtqM6eonXVBDKqcMcq8iXnEnHk+UQk8hJZbz/NcyhiEbRmzDiMPCURzA5PlxF/px+1yUB1zMDboJRDyEcr0Ec7y6uZqIiIiIiIjMaAp9ReTSkxyGnT+HrY/DQNNYm8M1FvZe/Tkou2x6xzcJjncNsa2+l0NtMfY0D3CwLTZ+47UzeVwOFpeEec/8AlZV5XLVnHyC3rGpvGWohf+q/y3b2rexuXkzSTs5/ry50bncMecObqy6kTnRORc99IzFYjQ1NdHc3Exrayvt7e0kk6ev77Qsqj1eFnR1UbCzHpOsJxMtxY6W4Vj+FwR9ReccU9JOkjGGuG1j8JAwFiOWhaMkgLv8/PokAAAgAElEQVQ4QKgiTG55iOqSAIGIR4GuiIiIiIiIzHoKfUXk0pBOwP6nxlb2ntgEycGx9kABrPkzWPNxiJRN7xgvop6hBIfaBvndwXZer+/lcPvghD5Rv5vl5VFWVkapLQixsDjMgpIQXtfpla+NsUb+49gGnqt/jkO9h7KeXxOp4daaW7m15lbm586/aGNPJpM0NDTQ2tpKa2srbW1tDA5OHL87laKkJ0Z1v01pJoortwJfdA3OJd6znncw1U88M8JAaoQ4PkaJMOryE6zMIVzgJ788RFF1mGihX6t1RURERERERM5Doa+ITJ/e+rGQt2ELNG2F0YHTxyLlcO0XYeWHwROYvjFeJKmMzfaGPjYf6+LFQx0c7ci+cZrTYXFlTR5LyiKsqIiysiKH6vzAhGAzlozxStMOXmt/jS0tW2iMNY4fc1gOVhWt4qrSq7i+8noW5i68KMFoLBajubmZtrY2WltbaWhoIJPJZPWxjCFnOEnBCBRYBeQ7CyjwVuLKcUNO9vkSmRH6k50MpvoYSKcZJcSAiWB7iyhbUElxTYS5c6JEi/xE8n04nI53/BpEREREREREZhOFviIytWwb6tbDaz+E47/PPhYqGVvRW70Oqq4G57t7ikplbF453sNTO5v5w+FOBkfTWcer8gKsqcnlliXFrKnJoyA0cQVsyk6xr2sfr7S+wta2rezv3o9tTm/74LJcrC5Zzc1VN3Nz9c0U+Ave0ZhHRkZoa2ujqamJ9vZ22lpbGYjFJvQLJqHY5FLkKKDAjpBvQrhdLghn9zsd8PYykIrTk4EholiOKC7fEuZcUcyc+TkU10bIrwjhVMArIiIiIiIi8o69uxMVEXl3SMbHVvO27IC9T0Jfw1i75YDqa2DBrVC1DkpXwkW8mdh0SGVsttR188yuFjYc7iR2RtCbF/Rw7fwCblxUxNVzCygMTwx546k4e7r2sLNzJ7s6d7G3ay8j6ZGsPjWRGlYXr+baimu5ouQKIp7I2x5nf38/zc3NNDc309/fT3dXF7GBAZLp9Fn759sh8u0wBSZMiZ1LrgliYWGnbVJ2gpHMAL2ZIUYzw/QnB4hlEgzaFiMmgMNVjtO9lKrLCrhsXg6RAj/RQj/5FSEcDm3RICIiIiIiInKxKfQVkckx3A37/hMOPgst2yFz+qZe+KJw+YNwxSchr3b6xniRNPfFebmumw2Hu3i5rpvBxOngND/o4c4Vpdx1WTmXVebgfFPImbEzvN7+Oq+2vcr2ju0c7D5I2mQHrzneHK4qvYqry65mXdk6SoIlb3ls8Xiczs5Ourq66OrqGv95eHj4nM8JGR/FdvTUCt4w+XYIL26SdoLBVA/D6WY60zG6RjvpSsawnXk4nCVYrjLcvhJKl+RTWuhnbtRLbkmAcJ6P/IoQbo/znNcUERERERERkYtHoa+IvHPD3dCycyzcbd4OffXQeyK7T6gE5lw/trJ3+f8AT3B6xvoO2bbhYFuMg60xXj7ezSvHe+gaTGT1KQh5uG1ZCfecCnpdZ2xZ0DPSQ0OsgcO9h3m97XX2d++nc6Qz6/klwRJWF69mVdEqLiu6jHk583BYF972IJlM0tjYSHt7O42NjbS1tZ0z3LWMRYEJU2CHyTFBIiZA2PjwGQ9WJkXbSD2dI/s5mB4lSYAkPjKOCKHcIsIlCwgX5FKZ62dRjpdwvo9IgQ9/2EMg7MHp1hYNIiIiIiIiItNJoa+I/HFibXDov+DAM2M3YcNM7FOyAi77CMy/BfLmwEW4qdhUiyfT1HcPc6A1xqajXbxS101fPJXVx7LgssocrptfyI2LilheHh3ftmAkPcKu9v1sbd3Ky60vc7Dn4IRrhD1hbqq6iStKrmB18WrKQ+UXHJdt23R0dHDixAlaWlro7++ns7OT9Fm2ZwjZPnJNkBwTJNcOnfo5QCaTIJ6OMZweoDfZxEnbQW8aklYuOcUlFCxdRWV1IbnFQSIFPiIFfnzBd/f2GyIiIiIiIiKzgUJfEXnr+hrhwFNw6L/H9uc9U8ECKFsFlVdAwULInwfhkndV0GvbhhPdQxxsG2TvyX62N/axr2WAjJ0daIe8LpaXR1lVncPa2nxWVecS8o5Np2k7zcHeA+MreTc1byKejmc9vzxUTk20hjXFa1hesJzlBcsJuAPnGJNNV1cX7e3t4zdZGxwcpL29nXg8PqF/0HgptqMUnXrkmiAmk6Y70Uxvop3O5H6a7AwjtouEFcRy5uGPVFC2fA0LFuVTXBslvyyIx6+PBxEREREREZF3K/2/ehE5t0wKDv8GDj4DPcehfW/28YorYek9sORuiFZMzxj/SLZtaOqN84fDnbxe30v/SJIDLbGs/XjfkBf0UJMf4Jp5BdywsJCVFdlbNgC0DLXwbN2z/OrYr+iMZ2/XkOfLY23pWq4pu4Z1ZesoChRlHU+n08RiMeLxOMPDw3R0dNDU1ERHRwfDw8Mkk0nOxmWclNq5lNo5hI2fiPHjSxlG0oMMpftoTR5nf6KP3oyF5SrH7Z9HpOJqSiryCOWNbclQsSiP3JIA1rsonBcRERERERGR81PoKyITddfBq/8I+34FiYHT7ZYDat4DSz8AC26HSOn0jfFt6hwcZevxHg61DXKgdYDtDX2MpDIT+vndThaWhFlREWVlRQ5Xzc2nPMc/oV/7cDv7u/ezqXkTuzt30xBrGD8WdAdZlLeINcVreE/5e1hZuHI8VE2lUtTV1XH8+HGOHz9OX18fqVRqwvnP5DIO8k0Yr3GTb8IEjId8O0y+CdOfaKd7tIWORDt7RxsZtdM43HPxBioorL2JuQuKuW5BDsU1EXwht8JdERERERERkVlAoa+IgG1D8+tw+Ndw8nVo3gbGHjsWLBrbl7fs8rFHbvX0jvVtGBxNseloF7/a0cymo128aZcG3E6LyypzeN+SYgpCXhaWhFlYHM5axRtPxdnZsZOjfUc50HOAk4MnOTl4csJqXoflYHXxaj44/4O8r/p9OIyDWCxGf38/2xq2MTg4SEtLC42NjWQyE8Nmy4DXtvDhI0yQEjtKoYniN24itp+h9DDxdD9DqW5iyW56MsP0JFoYzSQI5Mwlr2YpKxfdx5zL55BXGsIX0t67IiIiIiIiIrOVQl+R2coYaN4+tnXDvv+AoY7s4/Nvgav+19jKXue7J0DsHU7y3L42/ntPK9saerOC3qVlEVZV5bKgOMRllbksKg3jftM2DclMkj1dhzjUc4gtLVvY2rqVpD1xewULi0U5i1geWM7S4FJyMjl0tXbR9EITf9f/dyQSiXOOMWC7Kc/kUWEKyDdhfMaDFxcWp1fhDqZ66RltoWHkBB0jDSTtkfFjbm8+RXNWcfXV9zNv9VLC+cF38I6JiIiIiIiIyEyj0FdkthkdgL3/F3b9K7TtOd3uCcHCP4Hqq6H2OsifO31jfJuGEml+u6+N3x3sYOORTlKZ00lveY6fey4v44OrKphTGMp6Xu9oLye6TnBy8CR1/XUc6T3C7q7dJDLZgW1RoIiFuQtZnL+YKl8Vzl4nI50j1B2sI5FIsJc37XV8ihMHAdtNOOMjYoXINUHK7DxyTGA84B3JjDKY6qI11c1gqpf+ZCfdoy2kTRLLcuCP5FO0aCkFVVXMuWwlRbVzCObkXuR3UERERERERERmEoW+IrNF6254/cdw4ClIxcfaXH5YdMfYjdgW3Aou7/SO8W0YSqTZfLSLPxzu5L/3tjKassePLS2LcNfKMv5keSnluT7ah9vpHjnBs3X17O3ay/GB45zoP0Ffou+s587x5rAsuox5jnks9C7EnXDT0tTCwL4Bdg3syurrdXuIBMIEbT/hES+FcT85dgA/Xny4s1bvjmaSDKS62TH0Mr2JVmKpHjJm7MZxDqeT0nkLqVm2liur51BQXUO0sBiH0zkJ756IiIiIiIiIzGSWMcZcuJvEYjGi0SgDAwNEIpHpHo7IWzPSB4efg71PQv1Lp9sLF8Gqj8LKD0Mgb/rG9zbVdw/zH9tP8tv97ZzsjZM+Y++G2oIA1y+FypI+ElY79QP11A/U0xhrZDQzes5zlgfLqfXUUumqJDoaxTXgYrhvmKGhIWzbPutzclxhylK51KTyKbVzs4LdNyTsFB0jLfQlGulPdjCQ7GIkMzR+3B+OULZwMQWV1VQuXUHZgkW4vb538O6IiIiIiIiIyEzzx2aSWukrMhPFe+GV/wOv/fD0ql6Ha2xF75X/EyrXgjUxqLwUtQ2M8Nt97fzuYDs7GvtObd1g4/C2U1rYSUF+F7a7iaFMD7/q7IXOiedwOVwU+Yso9BdyWd5llNllmC7DQOsAvSd7SafTJEnSRVfW8wLeIGHCBJMuipNhCuwAURPAhweAjDEM22lskyGW6CKe6qYneZKOkUYSdnz8PE63m8KaGhbMXUBRdS1Vy1YSLSrGcmTvJywiIiIiIiIicjEo9BWZKewMtOw4tYXD02CnxtoLF8PSe8ZW9eZWT+8Y34J0xubVE728cKCdzce6aOiJAxmcoaO4Co5RmNOK7eogaY8wBAwlgVP3WXM73CzJX8LcnLnURmqpjdZS6illtHOUhvoGThw7QX9/P0c5mnVNh8OB3xPEY8IER0PkDwUpc3gpH82+QZoxhr5kB8dHTtA1cpLuRPP49gxncvv81C5aTdXyy6hZcTl55ZXapkFEREREREREpoxCX5F3u5ad8OrjcGw9jPafbi9dCdd/BRbefkmv6k1nbI51DlHXOcgLx7azpe0lRjIDONz9OHJbCRWMYlkZsMa2WhgFsCHgCrCicAVL85eyJH8JZcEycuwchvuHSSQSNJxoYHf9bjb0bZhwzWAgRNSVg6s7gDUUJpKxyHdmKPUECLp84B7rZ5sMvYl2ukZP0hI/RizVQ8pOYFkO3F4P/pwIbn+AUG4eRTVzKJ47n9ziUgpr5uB0aXoVERERERERkemhVELk3WiwA3Y8AQeega5Dp9u9EZj/vkt+C4eBkRS/3lfPr/Zv53DsFfAdx+HpxnKOQoRTmydky/PlcXPVzawuXs38nPnkkkt8KE5LSwt1m+vY076H4eHhs14v6vNTYjy4+xz4h/OIuiIUuQMEXD4IZPdN2ynaR+ppjdfRPnoCn9dBKC+fqjWXUbJgEcVz5pFXVqGtGURERERERETkkqXQV+TdwLaheRscewEaXh772WROHbRg+f+AKz4J5WvAeWn+WbfHBvjR9t+yoeklOlMHcHh6wQnO3NN9nHhZlruWKysWk+fLYUn+EgoDhbgsF0GCnKg7wfFdx/nvxv8mFotNuIbD4aAgFCYZG8I1mCA0YpFnRyj0FJPvKSTgCkE4+zkj6SGG0/2MMkgqN0nwsnJqll3HmqqP4nK7J/ldERERERERERG5+C7NdEhktkuNQNdhOLkNml6Bhi0wnH2TMcrXwJqPw4LbIJg/PeM8B2MMR7vb+M2hvbzS8hqN8QOMOI5hOdJggePUUl6vI8wVxVdxx9wbWZC3gOpINV6nF4B0Ok1LSwsHdx+kvr6e9vb2rGs4HA78Lh+elJNA0o+zd5hw2kWJN0KBdw5hd974Ng1vSNspBtLdxEw3VpmHyIpKyhYvZq723BURERERERGRGUShr8h0Mwb6G6HuRTj6AnQfG/vd2Nn9PCGYe+PY9g0110Je7fSM9xyOdPTyy72b2dm1jfrRLdjOntMHXWABDjvKovDV3LPwRm6bv5ZcXy4DAwP09PTQfqidxuFGenp66Onpoa+vj3Q6+yZpPoJ4R3Jg2E8046PYSlLs8VDkLcARzQ5tbWMTt0awol6cpR4CcyOUrZpPTdA3Be+GiIiIiIiIiMj0UegrMl266+DA07Dv/0L30YnH/XlQugJq3gOVV43t0es6226302NnSxNPH9zCoZ7DNA0fIe44huVIjR10gjEWThOk0r+CJflL+eCim7myYjHJZJK6ujpeeuElGhsb6e3tPec1nMaJa8RHdNRNcdpFgeUlxx0hJ1iM08oOeTMmQ8I5AsUeiq5eQGRpCY6AtmcQERERERERkdlHoa/IVBrpg73/AXt/CS3bT7c7XFB2OSy6A8pXQ8FCCBVdEjdiM8aws6mPox1DHOup5+X29bRntmO7W053OrWS12UiVPqXs7ZkHR9d8X4qc/NIJpN0d3dz8uRJfrHxF9TX12Pbp1cxW5ZFyBvAO+rAxA2upCGQcVBEkDJXHjmeIpyBiVsvZOwUMWc/Vrmb3CtrqVyzBIduriYiIiIiIiIiotBXZEoMtsOWv4edP4dUfKzN4RrbpmHZvbDkbvBFp3eMp9i24UjHIK+e6OHluh52tZ4g5tiDK7IHV6ARHIw9AJ9dQVlgAYtyF3LPoutYW7GEzs5OWlpa2LV5C79uaaGzsxNjTNY1ApaP3ESYyGiEIttPsdNPyBUaC23PsvtC0oySCiTxVEYIzS0iurgcd34Qyzn9obiIiIiIiIiIyKVGoa/IZBnpgyPPw8Fn4fjvIZMcay9aCivvH3uEiqZ3jKec7I2z9UQP2+p7efFwGzEO4Y7swRk4gaOs74wc1qImsIr3VryPDyy8mdq8YtLpNCdOnGDPa3v4w78+SyqVmnB+p20RSXupNEUsoIwcExw78KbdKhKZOCmSOHzgrAgTXVJOdGkFrlwf1iWw6llERERERERE5N1Aoa/IxWQMNGweW9F78NnTQS+M7cl73f87djO2ad6GIJWx2XOyn01Hu/j13jbqu4dxeDpw523BVXaQgGt4vK+FgyX5S/iT2tu5uepmPAkPXV1dHN+5j61tv6O+oYFUJjPe32EbgnEXIROm2Aoy31lBxApicTq0HUr1E0v1kDKjOAJO/PPzKV6zmNoVC7VFg4iIiIiIiIjIO6TQV+RisDNw8JmxLRza951uL1wMS+6CpR+AosXTNz7G9ubd3tjHv7/WxPMH2oknkziDJ3AG6gjOOYjD2zXeN8eby601t/DeivdS6aykZec+jv96P/86/E+MnCWUdWScRBO51CQjzHXmkuPOyTo+lBpggF5S0RT+ZXlUrb6MhVU1Wr0rIiIiIiIiIjIJFPqKvBPt+2DbT+DERuirH2tzB2HpPXDFJ6F81bQOD6BzcJQX9rfzL1uP0jC8H6evDUdhC+FQHThGxvs5LSe3Rtdxk/MqfHEfTVtOsmXwd4ycGcw6HFg2OFMe3LaL3LSHGpPDPFcFHod3fD9e29j0JtuwS1wUXFnL3KvX4va+aS8HERERERERERGZFAp9Rd4uY6BlB2z7Z9j7SzD2WLsvClf+T7jqf0Egb1qGlkzbHGqLcaRjkCOd3fy+YQut8RM4/U04c08QyE9n9a9NRPmT3nmUdvqJjUBzNMorvvrTHSwLbINr1OAbhULbTS2FlPlr8DmD4D7ddSQzRMzdi2tOiKJ1C1k6by1u71nuyiYiIiIiIiIiIpNKoa/IW5VOwP5fwdbHoeOMLRwW3wXLPwRzrh8LfqfYaCrD5mPdPLu7hY1HOolbjbijO3HnbMMKpvCeumeay3axNL6AlQOlhPqd2AmLfn+Ado+H9ggQOXXCjME5OoInPkiJnUO1o5wCbxk5gcIJ1467BkmXWoSWFVN1xSq8geCUvW4RERERERERETk7hb4iFxLvhe0/gdd/DEMdY20u/9hevWv/HMpXT9lQYqMpjnUM0do/QkdslNfre9lc10zKexhX6CCuqiMEXfGxzgZq0vO5cmAOgQE3Q3gwlsUwMOxjfCsGjI0jMYozPkRBwkO5yac8cBl5oVKc1ukpwmAwBQ58c3KJrCjDWxPFcummayIiIiIiIiIilxqFviJnk4xDwxZoeGlsz97UqSA1XDoW9K5+CPy5kzqEVMbmleM97GvuZ0/zAHWdQ9R3DwMZHL52nIETuAIncNYew+UY27bBlbFY1FXGiqFFWHaEUYeTDDB4alteKzmKczSOIzGCx3aQk/ZR5iimxL+EPH8xrkD2lOAq9ONbmIe3JoJ3ThRHwI2IiIiIiIiIiFzaFPqKvCGThqatsPdJOPAsJAdPHytZDus+C0s/AK6Lf0Oy0VSGPSf7ea2+l30tA5zsjVPXOUTaNkAGh6cHZ/Ao/ur9uPzNYI2FvIGknxVNpSzoL8TtzCHmj2A7nSQAHGDZNv74KPkpH1V2IWXucpyWF28wgNsx8c/fEXTjnRvFWxvFOzcHV6Ef68wbuYmIiIiIiIiIyCVPoa/MbsbAsfXw2j9B/Sawz7jRWbQSqq6CJXfDojvHbmp2kQwl0uxu6md7Yy+vnuhhZ3MbaasXyzWIw9ODw92Nu6wHv68Hy92LIYNlGxa351DRUEhuqgC3u5QRfxiA4TO2EvZkLEozURaZKkpMLm6X6+x/6Ra48v24iwN4F+TirY7gKg4o5BUREREREREReZdT6CuzU7wXdvwLHHgK2s+4KZs/FxbdASs/AlXrwHFx9qwdTY9ypOskrza08dzRXdT1HSfj6sDhimG5+/HOHcJ7Rn9XGqp7g5S1uikanY/XWUrGEybtdoMf0n5IAxhDTtpDKYXkEqbUziHHBLEYC25tl4VxOfCUhfDVRPBUhHEE3VhuB+7CAJZbe/KKiIiIiIiIiMw0Cn1ldulrhNd/BDt/DonYWJvLD2v+DFZ9FPLng/OP/7MYSAxwcvAkzUPNdAx3sLVlF/u79zCQ6s7q58gx5A1DaZebmoFCckcKiSa8GHeE0UCUoWAY47DAA3gY264BcBqLqO2nwEQpNjlUZPIJvhEXOy08VWE8lacfzlyvVu6KiIiIiIiIiMwyCn1l5kuNwNEXYPe/Qd3vwWTG2ouXwxUfh8V3QbDgLZ0qnopzrP8YG09u5Hj/cXpGexhKDjGYHGQoNcRIemS8rzNjCCTAlYGitEVZfy61vWFKh4MEUx76o7n05udDCBIh6HzTtRzGwoubAjtMrV1Evh0m1wRxcGp1btiFrzyCuySIb0kenvIwllMBr4iIiIiIiIjIbKfQV2au9n3w+o9h339Cavh0+5wbYM0nxvbpfdP2Dd0j3cQSMVqGWhhJj9A61MrxgeM0xZpojDXSM9qT1d+dMpT1wpw+Q0U3FMQMc1uchDJBYtEc+vLzaS8pYTgYGlu5mwcdednDDNt+8k0INy7Cto8CEyGQduJOZxjNDBEnTiDXQaAsQHT5HLwFITyVYRw+/fmKiIiIiIiIiMhESo1kZmnfB/t/Bcf/AG17TrdHK8duyHb5/wNFiwFIZVKcHGhgV8cudnTsYEfHDlqHWyec0pcwzG81rIhBfgwKBx3kx0I4TRSXy8VQNMpANMpwTpDeEj/di6yz3vTNZZzkmRBB4yVkfOSYIJWZfAJ4SdoJ2uMn6E000pqbofiyuZQvXkxVVS3h/Le2CllERERERERERAQU+sq7XXIYml6F+pfgxIbxoDcJ9Lm9NMy5hrqqVTS7PSQyCTr3/SN9o30cHzjO8Jmrf08JJi0WdXtZ1OOjsgvKGkfI6U2ScbkZ8fvpKiyks7ScIwvysJ3nvgma2ziJmAAldg6ldg6FdhSPbTGaGWI4HaMv0U5/6ihDPi+OsIvQomKqL7ucVQsX4wuGJuvdEhERERERERGRWUChr7y72Da074ETG+HYejj5OtgpUkC7y8mBYIjflcxhkxkkaTKQrIO6urOeypkx5CY8XOmay8pUGeW7+ih8ZSe2idNeEqGxuppXri4j5Tn7n4nPuMmzQ4SNnxI7h4jxE8ALto2dGiFlJxgiRjLcTlfNENF5pRRULaIsEsUbDOH1B7Ac5w6ORURERERERERE/hgKfeXSZgx0H4PDv4amVzFtu+mNd9HmcnHU42ZbfoSd/gBtTgvzxnPs/vGnV4QqmJ87nxpfOXldo+QfG8B9oJXQyV6ibW24MiMk3UeIRdo4WVHB9lv/hKFQAPOmLNZhLHy4KbQjlNp5lGQieNOGETNKwp3BUejBVe7DX5WLJz+ELxwmt6RUoa6IiIiIiIiIiEw5hb5yaUrG4cDTjG79Pntix9nj9bLd72VXvpfRwoqsrpZtqOowFMSdXNMaZv5gkELC+OMpEr39ZAZewplMADAYClFfU83JuQsYXbGG4YCXUZeZcPmg8VKbKaIqU4AzMcJIso/eVCcmNIBzvp+qu99LXmnplLwVIiIiIiIiIiIib4dCX5l2qUyKY/3HON5XR0PLVk627aRlsIk2B3QFXRAsHutoDKW9UNFjM2coyJyYj9puB9GmPqxEEshg6GHIG6MpOkxvfh7xmipSoRxSgQgpf4AhV+pNVx8LfP3GQ6mdS3WmAF8iw0i6F4osAmtDRMvmEC0qIZiTi9OlPxkREREREREREbm0KcGSKWMbmyO9R9jfs59DPYc40nuY/pFuWuOdpE0mq2/eqJPCGMwZspk/4GdFd5Cy5hFcfUMMh4IMhkIMhqPU5ZcwXBMl7neTcjlJOSHtPNcIUlgGyuw8ijNRTDqFI53GZRmixSUUL6+lYu0CvHmBSX8vREREREREREREJotCX5lUA4kB/vXgv7KtfRuHew8TT8ezjntShrkdUN2bYUW7TVkvFPR58Mf9JKIFdBcW05WfR2NlmAML3Aw7Mxhr4nYMb2YZyDFB8k2YYMaLy7awLfD4IoRrqihcWEL1imJ8IfdkvXQREREREREREZFpodBXLqpUJsXG5o1sadnCtrbXOTnUPH7MMoblzTbXNKdZ0G5T2GnhGnAxmFdGf9kcBooqaKkIUu92MuhIMOgYfdPZ0wA4jYOoCRAwHgK2G2fGwmO8+F0hfD4/kXA+odwwoaoI4Tk5eIsCePwqdRERERERERERmR2UhMk7Fk/F2d6xnWfqnuHl5i0kknGK+6G013BZDyzqyrC0K0Og30HGUUh/7Sq6KipoWuyi0xMnYaVPnckAQ1nnDme85KU9+NNuUsk0I2kXff48RnMjFC2u5rrr51GWH5zy1ywiIiIiIiIiInKpUugrf5T24XZean6JLa89ycjhY1R02qzoMry/w1AYc+DwF5AIlR4FWDgAABWQSURBVJMoXIDJKaa3yssxb5JW9wAxxwhwepsHt3GSawdwJ5KkU0kSqSR9GQdddogmVwR35TxWXlHLdYsKWVIaweGwpu+Fi4iIiIiIiIiIXOIU+spb1tRzgt3P/Zz+F1+gqH6QmnSUZZ4yTPR9pPJqyFTlwzw/cY+TQccovdYgvdYQ3Y5uUtbpG7VZBgIZN55RB7FRi+ZADm3FFeRWlFJVmkNh0MvqiJeFxWEKQl6FvCIiIiIiIiIiIm/DrAp9H3/8cb7zne/Q1tbG0qVL+d73vse111473cO6pCVSo/zu6b+H5/cSyczB5BUSKv0Y8QoP3Y4kQ9YoIyQZtWIkrN5znsdpO/CaII6iCspXXc7csgKq8gIUhRXqioiIiIiIiIiIXEyzJvT95S9/ySOPPMLjjz/ONddcww9/+ENuv/12Dh48SFVV1XQP75K045//hY4dHQzn5tJacdmpbRn6z/scy4ATB4FAgPKKUubMm0dFVRXFxcU4HI6pGbiIiIiIiIiIiMgsZhljzHQPYiqsXbuWVatW8YMf/GC8bfHixdxzzz1885vfvODzY7EY0WiUgYEBIpHIZA512g339/Mf3/gx7cEko1ZqvN0yEEx5cGbcZLxBvKEIxWXFLFxSTkl5Prm5uXg8nmkcuYiIiIiIiIiIyMzxx2aSs2KlbzKZZMeOHXzlK1/Jar/lllt45ZVXzvqcRCJBIpEY/z0Wi03qGC8lT/7tjzgZGrvRmtt2EEo6yM+PcvOH7qWgvASX2znNIxQREREREREREZFzmRWhb3d3N5lMhuLi4qz24uJi2tvbz/qcb37zmzz22GNTMbxLTuWCYnqaWsgbTvPhv/w0wbyi6R6SiIiIiIiIiIiIvEWzIvR9g2Vl3zDMGDOh7Q1f/epX+cIXvjD+eywWo7KyclLHd6m45ZMfY9mJRsrmVE/3UERERERERERERORtmhWhb0FBAU6nc8Kq3s7Ozgmrf9/g9Xrxer1TMbxLkgJfERERERERERGRdyfHdA9gKng8HlavXs369euz2tevX8/VV189TaMSERERERERERERufhmxUpfgC984Qs8+OCDrFmzhnXr1vGjH/2IpqYmPv3pT0/30EREREREREREREQumlkT+t5333309PTw9a9/nba2NpYtW8Zzzz1HdbW2MRAREREREREREZGZwzLGmOkexLtBLBYjGo0yMDBAJBKZ7uGIiIiIiIiIiIjIDPfHZpKzYk9fERERERERERERkdlCoa+IiIiIiIiIiIjIDKLQV0RERERERERERGQGUegrIiIiIiIiIiIiMoMo9BURERERERERERGZQRT6ioiIiIiIiIiIiMwgCn1FREREREREREREZhCFviIiIiIiIiIiIiIziEJfERERERERERERkRlEoa+IiIiIiIiIiIjIDKLQV0RERERERERERGQGUegrIiIiIiIiIiIiMoMo9BURERERERERERGZQRT6ioiIiIiIiIiIiMwgCn1FREREREREREREZhCFviIiIiIiIiIiIiIziEJfERERERERERERkRlEoa+IiIiIiIiIiIjIDKLQV0RERERERERERGQGUegrIiIiIiIiIiIiMoO4pnsA7xbGGABisdg0j0RERERERERERERmgzeyyDeyybdKoe9bNDg4CEBlZeU0j0RERERERERERERmk8HBQaLR6Fvub5m3GxPPUrZt09raSjgcxrKs6R7OpIvFYlRWVnLy5Ekikch0D0dmANWUTAbVlUwG1ZVMBtWVXGyqKZkMqiuZDKorudhmW00ZYxgcHKSsrAyH463v1KuVvm+Rw+GgoqJiuocx5SKRyKz4A5Kpo5qSyaC6ksmgupLJoLqSi001JZNBdSWTQXUlF9tsqqm3s8L3DbqRm4iIiIiIiIiIiMgMotBXREREREREREREZAZxPvroo49O9yDk0uR0OrnhhhtwubQLiFwcqimZDKormQyqK5kMqiu52FRTMhlUVzIZVFdysammLkw3chMRERERERERERGZQbS9g4iIiIiIiIiIiMgMotBXREREREREREREZAZR6CsiIiIiIiIiIiIygyj0FREREREREREREZlBFPrKBI8//ji1tbX4fD5Wr17N5s2bp3tIcon45je/yRVXXEE4HKaoqIh77rmHI0eOZPV56KGHsCwr63HVVVdl9UkkEnz2s5+loKCAYDDIXXfdRXNzc1afvr4+HnzwQaLRKNFolAcffJD+/v5Jf40ytR599NEJ9VJSUjJ+3BjDo48+SllZGX6/nxtuuIEDBw5knUP1JG9WU1Mzoa4sy+Izn/kMoHlK3pqXXnqJ97///ZSVlWFZFs8880zW8amcn5qamnj/+99PMBikoKCAz33ucySTycl54TKpzldXqVSKL3/5yyxfvpxgMEhZWRkf/ehHaW1tzTrHDTfcMGEOu//++7P6qK5mjwvNVVP5maeamjkuVFdn+55lWRbf+c53xvtorpIzvZUsQd+tLj6FvpLll7/8JY888gh/+Zd/ya5du7j22mu5/fbbaWpqmu6hySVg06ZNfOYzn+HVV19l/fr1pNNpbrnlFoaHh7P63XbbbbS1tY0/nnvuuazjjzzyCE8//TRPPvkkW7ZsYWhoiDvvvJNMJjPe5yMf+Qi7d+/m+eef5/nnn2f37t08+OCDU/I6ZWotXbo0q1727ds3fuzb3/423/3ud/n+97/Ptm3bKCkp4X3vex+Dg4PjfVRP8mbbtm3Lqqn169cD8KEPfWi8j+YpuZDh4WFWrlzJ97///bMen6r5KZPJcMcddzA8PMyWLVt48skn+dWvfsUXv/jFyXvxMmnOV1fxeJydO3fyV3/1V+zcuZOnnnqKo0ePctddd03o+6lPfSprDvvhD3+YdVx1NXtcaK6CqfnMU03NLBeqqzPrqa2tjZ/+9KdYlsUHP/jBrH6aq+QNbyVL0HerSWBEznDllVeaT3/601ltixYtMl/5ylemaURyKevs7DSA2bRp03jbxz72MXP33Xef8zn9/f3G7XabJ598crytpaXFOBwO8/zzzxtjjDl48KABzKuvvjreZ+vWrQYwhw8fnoRXItPla1/7mlm5cuVZj9m2bUpKSsy3vvWt8bbR0VETjUbNP/3TPxljVE/y1nz+8583c+fONbZtG2M0T8nbB5inn356/PepnJ+ee+4543A4TEtLy3iff//3fzder9cMDAxMzguWKfHmujqb119/3QCmsbFxvO366683n//858/5HNXV7HW2mpqqzzzV1Mz1Vuaqu+++29x4441ZbZqr5HzenCXou9Xk0EpfGZdMJtmxYwe33HJLVvstt9zCK6+8Mk2jkkvZwMAAAHl5eVntGzdupKioiAULFvCpT32Kzs7O8WM7duwglUpl1VlZWRnLli0br7OtW7cSjUZZu3bteJ+rrrqKaDSqWpyBjh07RllZGbW1tdx///2cOHECgPr6etrb27Nqxev1cv3114/XgepJLiSZTPKLX/yCj3/841iWNd6ueUreiamcn7Zu3cqyZcsoKysb73PrrbeSSCTYsWPHpL5OmX4DAwNYlkVOTk5W+7/9279RUFDA0qVL+d//+39nrYJSXcmbTcVnnmpq9uro6OA3v/kNn/jEJyYc01wl5/LmLEHfrSaHa7oHIJeO7u5uMpkMxcXFWe3FxcW0t7dP06jkUmWM4Qtf+ALvec97WLZs2Xj77bffzoc+9CGqq6upr6/nr/7qr7jxxhvZsWMHXq+X9vZ2PB4Pubm5Wec7s87a29spKiqacM2ioiLV4gyzdu1afv7zn7NgwQI6Ojr4xje+wdVXX82BAwfG/7c+25zU2NgIoHqSC3rmmWfo7+/noYceGm/TPCXv1FTOT+3t7ROuk5ubi8fjUa3NcKOjo3zlK1/hIx/5CJFIZLz9gQceoLa2lpKSEvbv389Xv/pV9uzZM76VjepKzjRVn3mqqdnrZz/7GeFwmHvvvTerXXOVnMvZsgR9t5ocCn1lgjNXQsHYH+Sb20Qefvhh9u7dy5YtW7La77vvvvGfly1bxpo1a6iuruY3v/nNhC8CZ3pznZ2t5lSLM8/tt98+/vPy5ctZt24dc+fO5Wc/+9n4TUb+mDlJ9SRv+MlPfsLtt9+e9S/5mqfkYpmq+Um1NvukUinuv/9+bNvm8ccfzzr2qU99avznZcuWMX/+fNasWcPOnTtZtWoVoLqS06byM081NTv99Kc/5YEHHsDn82W1a66SczlXlgD6bnWxaXsHGVdQUIDT6ZzwLxudnZ0T/hVEZrfPfvaz/Nd//RcbNmygoqLivH1LS0uprq7m2LFjAJSUlJBMJunr68vqd2adlZSU0NHRMeFcXV1dqsUZLhgMsnz5co4dO0ZJSQnAeeck1ZOcT2NjIy+++CKf/OQnz9tP85S8XVM5P5WUlEy4Tl9fH6lUSrU2Q6VSKf70T/+U+vp61q9fn7XK92xWrVqF2+3OmsNUV3Iuk/WZp5qanTZv3syRI0cu+F0LNFfJmHNlCfpuNTkU+so4j8fD6tWrx/9zizesX7+eq6++eppGJZcSYwwPP/wwTz31FH/4wx+ora294HN6eno4efIkpaWlAKxevRq3251VZ21tbezfv3+8ztatW8fAwACvv/76eJ/XXnuNgYEB1eIMl0gkOHToEKWlpeP/OdiZtZJMJtm0adN4Haie5HyeeOIJioqKuOOOO87bT/OUvF1TOT+tW7eO/fv309bWNt7nd7/7HV6vl9WrV0/q65Sp90bge+zYMV588UXy8/Mv+JwDBw6QSqXG5zDVlZzPZH3mqaZmp5/85CesXr2alStXXrCv5qrZ7UJZgr5bTZIpumGcvEs8+eSTxu12m5/85Cfm4MGD5pFHHjHBYNA0NDRM99DkEvAXf/EXJhqNmo0bN5q2trbxRzweN8YYMzg4aL74xS+aV155xdTX15sNGzaYdevWmfLychOLxcbP8+lPf9pUVFSYF1980ezcudPceOONZuXKlSadTo/3ue2228yKFSvM1q1bzdatW83y5cvNnXfeOeWvWSbXF7/4RbNx40Zz4sQJ8+qrr5o777zThMPh8TnnW9/6lolGo+app54y+/btMx/+8IdNaWmp6kkuKJPJmKqqKvPlL385q13zlLxVg4ODZteuXWbXrl0GMN/97nfNrl27TGNjozFm6uandDptli1bZm666Sazc+dO8+KLL5qKigrz8MMPT92bIRfN+eoqlUqZu+66y1RUVJjdu3dnfddKJBLGGGPq6urMY489ZrZt22bq6+vNb37zG7No0SJz+eWXq65mqfPV1FR+5qmmZpYLfQYaY8zAwIAJBALmBz/4wYTna66SN7tQlmCMvltNBoW+MsE//uM/murqauPxeMyqVavMpk2bpntIcokAzvp44oknjDHGxONxc8stt5jCwkLjdrtNVVWV+djHPmaampqyzjMyMmIefvhhk5eXZ/x+v7nzzjsn9Onp6TEPPPCACYfDJhwOmwceeMD09fVN1UuVKXLfffeZ0tJS43a7TVlZmbn33nvNgQMHxo/btm2+9rWvmZKSEuP1es11111n9u3bl3UO1ZOczQsvvGAAc+TIkax2zVPyVm3YsOGsn3kf+9jHjDFTOz81NjaaO+64w/j9fpOXl2cefvhhMzo6OqmvXybH+eqqvr7+nN+1NmzYYIwxpqmpyVx33XUmLy/PeDweM3fuXPO5z33O9PT0ZF1HdTV7nK+mpvozTzU1c1zoM9AYY374wx8av99v+vv7Jzxfc5W82YWyBGP03WoyWMYYM0mLiEVERERERERERERkimlPXxEREREREREREZEZRKGviIiIiIiIiIiIyAyi0FdERERERERERERkBlHoKyIiIiIiIiIiIjKDKPQVERERERERERERmUEU+oqIiIiIiIiIiIjMIAp9RURERERERERERGYQhb4iIiIiIiIiIiIiM4hCXxEREREREREREZEZRKGviIiIiMgf6aGHHuKee+6Z7mGIiIiIiGRR6CsiIiIiIiIiIiIygyj0FRERERG5gP/8z/9k+fLl+P1+8vPzufnmm/nSl77Ez372M5599lksy8KyLDZu3AhAS0sL9913H7m5ueTn53P33XfT0NAwfr43Vgg/9thjFBUVEYlE+PM//3OSyeR5rzk8PDzFr1xERERE3o1c0z0AEREREZFLWVtbGx/+8If59re/zQc+8AEGBwfZvHkzH/3oR2lqaiIWi/HEE08AkJeXRzwe573vfS/XXnstL730Ei6Xi2984xvcdttt7N27F4/HA8Dvf/97fD4fGzZsoKGhgT/7sz+joKCAv/mbvznnNY0x0/lWiIiIiMi7hEJfEREREZHzaGtrI51Oc++991JdXQ3A8uXLAfD7/SQSCUpKSsb7/+IXv8DhcPDP//zPWJYFwBNPPEFOTg4bN27klltuAcDj8fDTn/6UQCDA0qVL+frXv86XvvQl/vqv//q81xQRERERuRBt7yAiIiIich4rV67kpptuYvny5XzoQx/ixz/+MX19fefsv2PHDurq6giHw4RCIUKhEHl5eYyOjnL8+PGs8wYCgfHf161bx9DQECdPnnzb1xQREREROZNCXxERERGR83A6naxfv57f/va3LFmyhH/4h39g4cKF1NfXn7W/bdusXr2a3bt3Zz2OHj3KRz7ykQtez7Kst31NEREREZEzKfQVEREREbkAy7K45ppreOyxx9i1axcej4enn34aj8dDJpPJ6rtq1SqOHTtGUVER8+bNy3pEo9Hxfnv27GFkZGT891dffZVQKERFRcV5rykiIiIiciEKfUVEREREzuO1117jb//2b9m+fTtNTU089dRTdHV1sXjxYmpqati7dy9Hjhyhu7ubVCrFAw88QEFBAXfffTebN2+mvr6eTZs28fnPf57m5ubx8yaTST7xiU9w8OBBfvvb3/K1r32Nhx9+GIfDcd5rioiIiIhciG7kJiIiIiJyHpFIhJdeeonvfe97xGIxqqur+bu/+ztuv/121qxZw8aNG1mzZg1DQ0Ns2LCBG264gZdeeokvf/nL3HvvvQwODlJeXs5NN91EJBIZP+9NN93E/Pnzue6660gkEtx///08+uijF7ymiIiIiMiFWMYYM92DEBERERGZTR566CH6+/t55plnpnsoIiIiIjIDaXsHERERERERERERkRlEoa+IiIiIiIiIiIjIDKLtHURERERERERERERmEK30FREREREREREREZlBFPqKiIiIiIiIiIiIzCAKfUVERERERERERERmEIW+IiIiIiIiIiIiIjOIQl8RERERERERERGRGUShr4iIiIiIiIiIiMgMotBXREREREREREREZAZR6CsiIiIiIiIiIiIyg/z/LRZW8hCPd0YAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" + "" ] }, "metadata": {}, @@ -843,23 +488,12 @@ " ThompsonSamplingAgent(),\n", " EpsilonGreedyAgent(),\n", " UCBAgent(),\n", - " DriftingAgent(lr=0.1),\n", - " DriftingAgent(lr=0.2),\n", - " DriftingAgent(lr=0.3),\n", - " DriftingAgent(lr=0.4),\n", - " DriftingAgent(lr=0.5),\n", + " YourAgent()\n", "]\n", "\n", "plot_regret(DriftingBandit(), drifting_agents, n_steps=20000, n_trials=10)" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "> My implementation is basically Thompson sampling with two hacks that ensure it updates with the data. `probs` minimizes cross-entropy with the current distribution in the bandit using gradient descent. `scale` is a parameter that controls variance of the beta distribution (essentialy `scale=10` is equivalent to Thompson sampling with 20 samples). The plot illustrates that in the particular problem, the optimal learning rate is approximately 0.2. I zabeel to tune scale." - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -872,15 +506,15 @@ "\n", "> Contextual advertising. We have a lot of banners and a lot of different users. Users can have different features: age, gender, search requests. We want to show banner with highest click probability.\n", "\n", - "If we want to use strategies from above, we need to store somehow reward distributions conditioned both on actions and bandit's state. \n", - "One way to do this is using bayesian neural networks. Instead of giving pointwise estimates of target, they maintain probability distributions\n", + "If we want use strategies from above, we need some how store reward distributions conditioned both on actions and bandit's state. \n", + "One way to do this - use bayesian neural networks. Instead of giving pointwise estimates of target, they maintain probability distributions\n", "\n", "\n", "Picture from https://arxiv.org/pdf/1505.05424.pdf\n", "\n", "\n", "More material:\n", - " * A post on the subject - [url](http://twiecki.github.io/blog/2016/07/05/bayesian-deep-learning/)\n", + " * A post on the matter - [url](http://twiecki.github.io/blog/2016/07/05/bayesian-deep-learning/)\n", " * Theano+PyMC3 for more serious stuff - [url](http://pymc-devs.github.io/pymc3/notebooks/bayesian_neural_network_advi.html)\n", " * Same stuff in tensorflow - [url](http://edwardlib.org/tutorials/bayesian-neural-network)\n", " \n", @@ -889,13 +523,8 @@ }, { "cell_type": "code", - "execution_count": 27, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-03T22:55:32.725132Z", - "start_time": "2019-04-03T22:55:32.719599Z" - } - }, + "execution_count": 6, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -915,6 +544,20 @@ "print(\"State size: %i, actions: %i\" % (state_size, n_actions))" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "import torch.optim as optim\n", + "\n", + "from bayes import BBBLinear" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -926,55 +569,35 @@ }, { "cell_type": "code", - "execution_count": 28, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-03T22:55:33.607149Z", - "start_time": "2019-04-03T22:55:33.593883Z" - } - }, + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def calc_kl(model):\n", + " kl = 0\n", + " for module in model.modules():\n", + " if hasattr(module, 'kl_loss'):\n", + " kl = kl + module.kl_loss()\n", + " return kl/10000" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ - "import torch\n", - "import torch.nn as nn\n", - "import torch.nn.functional as F\n", - "import torch.optim as optim\n", - "import numpy as np\n", - "\n", - "from bayes import BayesianLinear, variational_estimator, kl_divergence_from_nn\n", - "\n", - "\n", - "\n", - "@variational_estimator\n", - "class BayesianRegressor(nn.Module):\n", - " def __init__(self, input_dim, output_dim):\n", - " super().__init__()\n", - " #self.linear = nn.Linear(input_dim, output_dim)\n", - " self.blinear1 = BayesianLinear(input_dim, 256)\n", - " self.blinear2 = BayesianLinear(256, 128)\n", - "\n", - " self.blinear3 = BayesianLinear(128, output_dim)\n", - " \n", - " def forward(self, x):\n", - " x = self.blinear1(x)\n", - " x = F.relu(x)\n", - " x = self.blinear2(x)\n", - " x = F.relu(x)\n", - " x = self.blinear3(x)\n", - " x = torch.sigmoid(x)\n", - "\n", - " return x\n", - "\n", - "\n", "class BNNAgent:\n", " \"\"\"a bandit with bayesian neural net\"\"\"\n", "\n", " def __init__(self, state_size, n_actions):\n", " self.n_actions = n_actions\n", - " self.model = BayesianRegressor(state_size, n_actions)\n", + " self.model = < Your network here> # Use BBBLinear instead of Linear layers\n", " self.optimizer = optim.Adam(self.model.parameters(), lr=0.001)\n", + "\n", " def predict_sample_rewards(self, states):\n", " return self.model(torch.Tensor(states))\n", + " \n", " def sample_prediction(self, states, n_samples=1):\n", " \"\"\"Samples n_samples predictions for rewards,\n", "\n", @@ -982,11 +605,11 @@ " \"\"\"\n", " assert states.ndim == 2, \"states must be 2-dimensional\"\n", "\n", - " return np.stack([self.predict_sample_rewards(states).detach().cpu() for _ in range(n_samples)])\n", + " return np.stack([self.predict_sample_rewards(states) for _ in range(n_samples)])\n", "\n", " epsilon = 0.25\n", - " def get_action(self, states):\n", "\n", + " def get_action(self, states):\n", " \"\"\"\n", " Picks action by \n", " - with p=1-epsilon, taking argmax of average rewards\n", @@ -1001,11 +624,7 @@ " # ^-- we take mean over samples to compute expectation, then pick best action with argmax\n", "\n", " # YOUR CODE HERE\n", - " chosen_actions = np.where(\n", - " np.random.random() > self.epsilon,\n", - " best_actions,\n", - " np.random.randint(0, self.n_actions, best_actions.shape)\n", - " )\n", + " chosen_actions = <-- implement epsilon-greedy strategy - ->\n", "\n", " return chosen_actions\n", "\n", @@ -1016,11 +635,16 @@ " loss_sum = kl_sum = 0\n", " for _ in range(n_iters):\n", " self.optimizer.zero_grad()\n", - " cur_actions = self.predict_sample_rewards(states)\n", - " pred_rewards = cur_actions.gather(1, torch.tensor(actions, dtype=torch.long).unsqueeze(1)).squeeze()\n", - " mse = torch.sum((pred_rewards-torch.tensor(rewards))**2)\n", - " kl = kl_divergence_from_nn(self.model)\n", - " ((mse+kl)/states.shape[0]).backward()\n", + " rewards_for_actions = self.predict_sample_rewards(states)\n", + " kl = calc_kl(self.model)\n", + "\n", + " # Prediction\n", + " pred_rewards = rewards_for_actions.gather(1, torch.tensor(actions, dtype=torch.long).unsqueeze(1)).squeeze()\n", + " \n", + " mse = torch.mean((pred_rewards-torch.tensor(rewards))**2)\n", + " \n", + " # loss = MSE + KL\n", + " (mse+kl).backward()\n", " self.optimizer.step()\n", "\n", " loss_sum += mse\n", @@ -1042,13 +666,8 @@ }, { "cell_type": "code", - "execution_count": 29, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-03T22:55:33.622446Z", - "start_time": "2019-04-03T22:55:33.609114Z" - } - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ "N_ITERS = 100" @@ -1056,13 +675,8 @@ }, { "cell_type": "code", - "execution_count": 30, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-03T22:55:33.631730Z", - "start_time": "2019-04-03T22:55:33.624908Z" - } - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ "def get_new_samples(states, action_rewards, batch_size=10):\n", @@ -1073,17 +687,16 @@ }, { "cell_type": "code", - "execution_count": 31, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-03T22:55:33.645631Z", - "start_time": "2019-04-03T22:55:33.633443Z" - } - }, + "execution_count": 1, + "metadata": {}, "outputs": [], "source": [ "from IPython.display import clear_output\n", "\n", + "from pandas import DataFrame\n", + "moving_average = lambda x, **kw: DataFrame(\n", + " {'x': np.asarray(x)}).x.ewm(**kw).mean().values\n", + "\n", "def train_contextual_agent(agent, batch_size=10, n_iters=100):\n", " rewards_history = []\n", "\n", @@ -1091,7 +704,9 @@ " b_states, b_action_rewards = get_new_samples(\n", " all_states, action_rewards, batch_size)\n", " b_actions = agent.get_action(b_states)\n", - " b_rewards = b_action_rewards[np.arange(batch_size), b_actions]\n", + " b_rewards = b_action_rewards[\n", + " np.arange(batch_size), b_actions\n", + " ]\n", "\n", " mse, kl = agent.train(b_states, b_actions, b_rewards, n_iters=100)\n", "\n", @@ -1103,7 +718,7 @@ " (i, np.mean(rewards_history[-10:]), mse, kl))\n", " plt.plot(rewards_history)\n", " plt.plot(moving_average(np.array(rewards_history), alpha=0.1))\n", - " plt.title(\"Reward per episode\")\n", + " plt.title(\"Reward per epesode\")\n", " plt.xlabel(\"Episode\")\n", " plt.ylabel(\"Reward\")\n", " plt.show()\n", @@ -1124,54 +739,9 @@ }, { "cell_type": "code", - "execution_count": 32, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-03T23:00:36.944085Z", - "start_time": "2019-04-03T22:55:33.650484Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "iteration #90\tmean reward=0.450\tmse=0.278\tkl=-28.015\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOydd3xb1d3/30fTtmzHNnaAhITEYYYNAVpmKVBKB7SUDrp+XdAB3ZO2tKWLDvrw9GmhtHTwFDqgFCh92LuUssImkEDshAxC4sR2EsuSrnR1fn+ce66uru6V5CFLdu779fLLtnR1dXQlne/5rs8RUkoCAgICAnZcQvUeQEBAQEBAfQkMQUBAQMAOTmAIAgICAnZwAkMQEBAQsIMTGIKAgICAHZzAEAQEBATs4ASGICAAEEJcKYT4fr3HMVaEEF8XQvx2ks/5OiHEusk8Z0BjE6n3AAJmNkKI1cDOgAmMALcB50kpR+o5rpmClPKH9R5DwPQn8AgCpoK3SilbgYOBQ4Dz6zUQIURdFz/1fv6AAC8CQxAwZUgpXwVuRxkEAIQQcSHExUKINUKIjUKIy4UQzdZ99wsh3mH9fYwQQgoh3mT9f5IQ4inr70VCiHuEEFuEEJuFEH8SQnQ4nmO1EOKrQohngKQQIiKEOEQI8YQQYrsQ4hqgyW/cQogPCSEeFEL8QgixVQixXAhxouP+WUKI3wkhNggh1gshvi+ECLsee4kQYhD4jsf5Q0KIrwkh+qzXcK0Qosu6b4H1us8RQrxiPccXHY/9jhDiauvvJiHE1dY5hoUQjwkhdrbumyOEuEkIMSiEWCmEONtxjmYrNDYkhHgeONw1vjlCiL8LIQaEEKuEEJ+p8FYHTDMCQxAwZQghdgNOBVY6bv4xsBfKOOwBzAW+Zd13P/A66+/jgH7geMf/9+tTAxcBc4B9gXmUTrhnAW8GOlCf+xuBq4Au4G/AOyoM/0jr+buBbwPX68ka+F8gZ43/EOANwMc8Hjsb+IHHuT8DvM16bXOAIeBS1zEnAHta5/6aEOIkj/P8P2AW6vXvBHwCSFn3/QVYZ53/TOCHDmP2bWCR9XOKdR5AGSngn8DTqPfmROBzQohTPJ4/YLoipQx+gp+a/QCrUbmB7YAE7gY6rPsEkAQWOY5/LbDK+vtE4Bnr79tQk+vD1v/3A2f4POfbgCddY/iI4//jgFcA4bjtP8D3fc73IY/jHwU+gMp/ZIBmx31nAfc6HrumwjV6ATjR8f+uQBaVw1tgXbd9HPf/BPid9fd3gKutvz9ivY4DXeefh8rRtDluuwi40vq7H3ij475zgHXW30e6x48K7f2h3p+t4GfyfoJ4ZcBU8DYp5V1CiOOBP6NW1cNAD9ACPC6E0McKIGz9/RCwlxXeOBg4DbhQCNENHAH8C0AIMRv4H+BYoA214h9yjWGt4+85wHppzWoWL1d4DV7HzwF2B6LABsdrCLmez/m3F7sDNwgh8o7bTJSR8TrHy8ABHue5CjXp/9UKjV0NfMMa56CUcrvrHEusv+d4nN85tjlCiGHHbWHggQqvKWAaEYSGAqYMKeX9wJXAxdZNm1Ghi/2klB3WzyypEstIKUeBx4HPAs9JKQ3UivcLQJ+UcrN1notQq+YDpZTtwPtRBqXo6R1/bwDmCsfMDcyvMHyv419BTaAZoNvxGtqllPv5PLcXa4FTHY/vkFI2SSnXO46Z5/HcRUgps1LKC6WUi4GjgLcAH7SO7RJCtLnOoc+/weP8zrGtco2tTUr5pgqvKWAaERiCgKnmv4GThRAHSynzwBXAJdaqHiHEXFf8+X7gPAr5gPtc/4PyAkaAYSHEXODLFcbwECqm/xkrcXwGysMox2zr+KgQ4p2oXMQtUsoNwB3Az4QQ7Vbid5Hl/VTL5cAPhBC7AwgheoQQp7uOuUAI0SKE2A/4MHCN+yRCiBOEEAdYieptqPCSKaVcizKgF1kJ5QOBjwJ/sh56LXC+EKLTyuN82nHaR4FtVrK9WQgRFkLsL4QoSigHTG8CQxAwpUgpB4A/AhdYN30VlTx+WAixDbgL2NvxkPtRE/2/fP4HuBA4FNgK3AxcX2EMBnAGKn4/BLy70mOAR1DJ2s2ohO+ZUsot1n0fBGLA89b5rkPF+avl58BNwB1CiO3Aw6jYvJP7UdfpbuBiKeUdHufZxXrubai8w/2o8BCovMUClHdwA/BtKeWd1n0XosJBq1BG7Sp9QimlCbwVFZpbZb3+36KS0gEzBFEc9gwICHAjhPgQ8DEp5TF1eO4FqAk4KqXMTfXzB+wYBB5BQEBAwA5OYAgCAgICdnCC0FBAQEDADk7gEQQEBATs4Ey7hrLu7m65YMGCeg8jICAgYFrx+OOPb5ZS9njdN+0MwYIFC1i6dGm9hxEQEBAwrRBC+HbPB6GhgICAgB2cwBAEBAQE7OAEhiAgICBgBycwBAEBAQE7OIEhCAgICNjBCQxBQEBAwA5OYAgCAgICdnACQxAQ4OLxlwd5/pVt9R5GwCTw2OpBlr8avJeVCAxBQICLb9+0jP+688V6DyNgErjgxuf47ztfqvcwGp7AEAQEuEhmTDI5s97DCJgERg2TdPBeViQwBAEBLlKGSc4MVHlnApmciZHL13sYDU9gCAICXKSyJrl8MHnMBIxcnqwZvJeVCAxBQICLVNYkG3gEM4JMLh94BFUQGIKAAAdmXmLk8oFHMEPI5PIYgVGvSGAIAgIcpLMqsRjkCKY/OTNvGfYgWVyJwBAEBDjQhiCIK09/MlZIyAjey4oEhiAgwEFKewT5wCOY7mhDkM0F72UlAkMQEOAgCA3NHHQvSOARVCYwBAEBDlKGtYoMJo9pTyarPYLgvaxEYAgCAhzo0JAZhIamPdoTyARGvSKBIQgIcJAKksUzBtsjMPNIGRj2cgSGICDAQcoIksUzBZ0jkDJ4PysRGIKAAAd68giSxdOfjCM3EHQXlycwBAEBDrRHkA06i6c9TgXZINRXnsAQBAQ40DkCKYOE8XRH5wgg8AgqERiCgAAH2hBAsIqc7hSFhoL3siyBIQgIcJA2CoYgSDBOb5yhocAjKE9NDYEQ4o1CiBVCiJVCiK953D9fCHGvEOJJIcQzQog31XI8AQGVcHoEuWAVOa1xegSBrHh5amYIhBBh4FLgVGAxcJYQYrHrsG8C10opDwHeA1xWq/EEBFRDcWgomDymM0ZQNVQ1tfQIjgBWSin7pZQG8FfgdNcxEmi3/p4FvFLD8QQEVCTtSDDuSHsS3Pbcq/QPjNR7GL6MZHL86ZGXx9QYVpwjaBwp6hWvbufe5ZvqPYwiamkI5gJrHf+vs25z8h3g/UKIdcAtwKe9TiSEOEcIsVQIsXRgYKAWYw0IANyhoR3HI/jydU9z2X199R6GL3e/sJFv3PAcfWMwVpmsM0fQOO/lJXe+yDdvfK7ewyiiloZAeNzmfjfOAq6UUu4GvAm4SghRMiYp5W+klEuklEt6enpqMNSAAIUzWbwjVQ2NGuaYJtmpRpeCbkvnqn9Mg1YN9Q2MFC04GoFaGoJ1wDzH/7tRGvr5KHAtgJTyIaAJ6K7hmAICylLkEewgVUNZayevvk0jDavJo4XjRsZpCBpFgTRn5lm9JVnkrTQCtTQEjwF7CiEWCiFiqGTwTa5j1gAnAggh9kUZgiD2E1A3dsTQkH7N29I5tiSNOo/GG53sTWbGYggcoaEG8QjWDaXImrLISDUCNTMEUsoccB5wO/ACqjpomRDiu0KI06zDvgicLYR4GvgL8CHZqEuSgB2ClGESDqmo5o6SLHaGw/oHknUciT86TDcyFkOQdZaPNsZ72b9Zhd9yedlQneuRWp5cSnkLKgnsvO1bjr+fB46u5RgCAsZCOmvSGo+wNZXdYcpHnV5Q38AIRyzsquNovBmfR5CnKRoinc03zAq8b1PB0Bq5PM2xcB1HUyDoLA4IcJDO5mlrUuujHaWhzGkIGrWEVK/ok0b1sfVMzqQ1HgUap49AewRQHLqqN4EhCAhwkMqatDWpyWNHSRanDKdH0JihIT2Rjyk0lMvTbhn1RgkNOa9vo3gpEBiCgIAilCForMmj1miPYKdErGE9Ap3sHWtoqNV6LxvGIxgYIR5R064zh1FvAkMQEGBh5iVGLk9bXIeGdgyPQE9Ii+e0s2ZwtKFCFhrbIxhj+WhrvHGM+tbRLJtHDPbepQ0IQkMBAQ1J2loZ2zmCHaRqSHsE+8+dRV7Cmi2jdR5RKeMKDWVNWmKN4xH0WfmBfXdRqjpBaCggoAFJ2YZA5Qh2mKohK0ew3xw1QTVinqCQLK7eEBhW1VAsEsJogPdSl+buu2vgEQQENCx6QtxRPYLFu2pD0Hh5AsPuIxhL1VCeeCRMPBxqCI+gf2CEaFiwx2zLEAQ5goCAxkOv0HY0j0CHxLrb4uzcHm/IpjItGjfWzuJ4NEQ0EmoI9dG+gRHmd7WQiKvegSA0FBDQgKQM9cUs9BHsGIZAe0LN0TC93a0N7RGMyRBk88QjIWLhENkGUB/tH0iyqKeVeCQwBAEBDUtqB00Wp3MmkZAgGg6xaHaC/oHGE5/LjidZbKrQUDQi6q41lDPzvLxllN6eVuJRq3w0yBEEBDQe2hC07mDloykjT3NUrVJ7u1vZls6xeaSxxOecHkE1RkpKVQqsPYJ6G4J1QykMM09vT6LQRxB4BAEBjUchWaw7ixvni1pLUlmTJkvzZtHsVqDxpCZ0sjcvqUrLX0+ysUiIaAMki7W0xKKeVmKBIQgIaFzcfQQ7UrK4yQpX9HYnAOjf3FgJY2dDWDXhIT3JxiMh4pFQ3RvKtNjcop5EIUfQQHsSBIYgIMCiJEewgxiClGHaoaG5Hc3EIyH6NjWmRwCQrKKEVMff49Gw6iNoAI9gp0SMjpZYEBoKCGhk0o4cgRA7VmhIG4JQSLCwO9FwHoFhFqQ/qqkc0jX68QYJDfUNJOntSdhjgsAQBEwRK17dzs3PbKj3MKYN2iNoioaJhkIzLjT0+MtD3P9i6QaAqaxJU7Sgi7+oZ3JLSDM5k1/f3zeh8IyRy9OZiAFjDw3FGiA01D8wQm+3yr8IIYhFQp5VQ3c+v5Fn120tuT1lmHz9hmd5dNVgTcYXGIIZzB8fWs0F/3iu3sOYNqQNEyHU5BEJixm3H8Ev73mJi255oeT2TNYs2iBlXlcL64dSk1ZC+lDfFi66dTlPvDw07nNkzYIhqMoj0KGhSJhoOFTX1Xc6a7J5xGD+Ti32bXGfcNV3/28Zv7p/Zcntm0cy/PmRNayukacWGIIZTDqbt8MdAZVJZU2aImGEEERCYsbtR7A9nWO7h3qnMzQESo46l5dsH0PNfjkGrX2QJ1LCaeTydLWoaq4xeQTR+nsEQ6Pq9XdZhgyUgfIyTinDtK+X1zk6HeeYTAJDMIPJ5MyGikM2OinHyjgarn84YbIZyeQ8RdvchkBPNsPJ7KQ8r57YJhQaMvN0tlQfGjKcoaE69xEMWddRjx/UuLy0hlKGaR9fdI5RdVtXIlqTMQaGYAaTyeUx83LGhThqhbOxSoWGZpZHkDRynmGVlJEn7jQE1sp7cHRymsqGrUnMGKfMg5SSrCnHGBrShiBcd4kJezXfUpjE49HSHIGUklTWtI8vOkdSnyPwCALGiP4yBF5BdTjr6SOhENkZVjWUzJhkTVkyAaV9PIIhjxDFeNAGZbxVWHo139GsQ0NVlI9mdY5Ay1DX773UHpEzNBTzyFsYZp68VIbDnZ8ZDAxBwHjRX4bAEFRHuig0NPM8Ah1Scdbh61Voc6wwFXRZk43XynQ8DE0wNKSrt+LREC2x8Bg9gvqXjw57xPfj0dIcQdoKFWVNWRL+Gho1CAlobw5CQwFjpOARBAnjanDGysMhMaP6CIxc3nO7x6wpMfOy2COwDIFX0nI8aIMy3nJcPe5YOERrPDL20FDdPQIVGutwTOIqR1DqmWl0OE0zNGrQ0RIjHBI1GWNgCGYwtiFooA0wGhlnPb1KFs8cj8A5eTpXm+lcoXdC09YUIRwSk+gRqElt/B6B1g0K0xqPVFk1pDuLQ8TCAiOXr5ui6tCoQXtThEi4MN3GI6WhIa11BaVGeCiZpaOlNt4ABIZgRmNYX4Z6Ky9OF1JGwRBEwgJzBpWPOidPZ+VQWu9F4OgjCIUEnS1Ru1JlougcQXac4RntEUTDgkS1HoGjs1iLvNWrHHgwaRTlB8C7fNQppudO1A8mDTtkVwsCQzCDCTyCseFMmkZCM6t81Dn5O42CnnycoSGAjpbYpCSLpZT2ecY7ETuVRBPxcJVaQ4XQUNRaidcrTzA0apTU/8ejIXuhpnEaAve19zrHZBIYghlMkCMYG84cwUxLFjtX0UkPQ9DkMgRdLbFJyRGMZHK2ARivZ2qHhqwcQTWNbobDeGiPoF6GfWjUKKn28QoNpR2hIbc3ps4RhIYCxkFQNTQ2UkahaigSCs2oZLGz5LLIEBjeHkFnIlqSsBwPzuao8dbyG0UeQbXJYpNoWBAOCdsQ1M0jSGY9DEH50JDTI1BeVTbwCALGR+ARjI10Ll+UI5ipyWKnzISvR5CITUpDmfMc4zWseiUfDY/FEORt3X8dGqrXgmho1CjpCPauGiqMz3ndRg0Tw8wHOYKAsSOlDHIEY8DMq60Nmx1VQzPKI0g7Q0OFCUh/NpzJYijkCCZaaeOsPBpvaMjpEbSNoWpIyz3H6xgaSmdNRg2TjipCQwWjHLJ7D6D2zWQQGIIZi/NLF4SGKpN2fAkBJTo3gzwCv6ohv2RxV8vkCM85QxzjvZ6GWRwayuTyFWVTMtm8HRKyk8V1MARegnNQMAROQ6vfizmzmovyM7UWnIPAEMxYnJN/EBqqjD0hzlDROR1OaW8qXlH75wgmR3hOT2iRkBj39XQ2lCXszWnKf6Yz1sb1+nEw/hzFRPBbzWttJ6dx0sniXTuainIrBYmKIFkcMEacibF67840HdATojNHMJNkqEeMHLFwiM5EzLtqKFY8FUyW8NzQqEE4JOhoiY3fEDg8gta4en9GPFRUnajQkGXUdbLYnPoF0bCtGlrqEUDxgk2/F7vOai4KqelzBKGhgDFT7BEEhqASaVeIJBIKzajQUDKTIxEPk4gVJ1vTPsniyRKeGxrN0tkStTaQH9/1dCeLoTjn4UUmlyceLfYIxqt+OhEKHkFpsliNqdgQRMOCnrZ4kfBckCMIGDfOioTAEFTGHSuPhscfymhEkhmT1qYIrVWGhiZLeG4oqWroJ3I93eWjUHlPgkzWERqK1D9HUNJQZnkrRR6B1dne1RIrEp6rteAc1NgQCCHeKIRYIYRYKYT4ms8x7xJCPC+EWCaE+HMtx7MjUeQRBLuUVSTtqp4Jz7AdykYyORKxSIlWTyprEgkJO6Gq0RPXRJvKBm1DMP6ci2F5EtGwoLXKDewNs1A+GqtjZ/GQh+AcYHsrxQs21dBY8MbUY2stOAc1NARCiDBwKXAqsBg4Swix2HXMnsD5wNFSyv2Az9VqPDsaQWhobLjr6WdasngknaM1HrHq8AuTTzqbL/EGQCWVJ0N4bng0S2ciSmQCIn72bmPhcNWGwFk+Ws/OYi/BOfDJEVgNjTqMpK99rQXnoLYewRHASillv5TSAP4KnO465mzgUinlEICUclMNx7NDUc/QUD4v+eU9LxXVQjc6hWRxY5aPPrNumOufWOd5383PbGDp6sGyj08aORLxCK3xcIlH0BQrNQRCVBae27gtza/u6yvbazA4qgTXYhMIDWWLksVjCA1FdfmoWknXwyPwEpwDn9CQtWe27Y1Z359aC85BbQ3BXGCt4/911m1O9gL2EkI8KIR4WAjxRq8TCSHOEUIsFUIsHRgYqNFwZxb1LB9dsXE7F9/xIncs2zilzzsRSpLF4VBDqY/+4cHVfP2GZ8l7jOnbNy3j9w+uKvv4kYzlEXgki708AlDJyXLJ4useX8ePb1vOuqGU5/1acK5joqEhl/ooVOMROEJDdc4ReNX/6zE5F2ypbJ6mWLiQn7Gufa0F56C2hsAroOX+FEeAPYHXAWcBvxVCdJQ8SMrfSCmXSCmX9PT0TPpAZyLFOYKp/QLoD/Bk7Xk7FZT2EYiG2qpyMGmQzubZsC1ddPvWVJbNI5mKq127aigeYdQwbYOSMsobgnI5gv6BJOCfUNaCc10tsQlJdhi5PCGhjHPCKh9NGpX6CEw7N1DXHIGH4Bx4h4bShklzNFTIEYxmHeeYvqGhdcA8x/+7Aa94HPMPKWVWSrkKWIEyDAETxOkFTHVoyPkBni64q2cioRBS0jBegQ6z9W0aKbq9f0D9b1SYZJMZ0woNWStqqw4/5din2U0l4bn+zeq5/cJHOtnZmZiYR5A183YyW8lKi8qhIWf5aB1F57wE58A/NNQcDRfyM5bER60F56C2huAxYE8hxEIhRAx4D3CT65gbgRMAhBDdqFBRfw3HtMOgP/RtVkv+VDJoJ7mmkSHIljaUQf2ki93oa6onfo1elbu17Z1IKUkaOdriqnwUCp25zl3Z3JQTnpNS2kbJ730eHC10xEbD4+/LyOQKchEAiXikch+Bo3xUG5F6vJcqR1C6mtdGyt1H0BwL2/mZwVGD5BQIzkENDYGUMgecB9wOvABcK6VcJoT4rhDiNOuw24EtQojngXuBL0spt9RqTDsSevJvb45OeY7ADg1NUJ5gKslkTYTAMXkoQ9AoJaR6dd2/OVl0u16Vl1vtjhomUqoJtFCHr86XzpolgnOacsJzW5IG26zJ2C98pD8HHRPsI8iaeTu8A5TkObxwdhbXyyNIZ01SWdNzNV8IDZlFx2uj3NkSY3jUsK9hrT2CSC1PLqW8BbjFddu3HH9L4AvWT8AkopNQbU1T7xHokNC0qhqy3HIhlAGIhKztDRvAIzByeTsU0ufyCPo2KcNQLv6uH6urhtRt6vNRLlnsFJ5rbype1TpDVH4hQFtwzUoWT0R91OkRVNq3OGfmycvCZBsJCYSYeo/AbiarMjTkfC90fqbcOSaToLN4hlLsEQTJ4kq4QyRROzRUf49AG9SQKISCNNV4BHrS1FVDUKi6SZWrGiojPKc9k5DwNwSDjtXsREJDWdNlCJoiRQqqbuxtKq3wixCqYS4zxYagnDRE3KtqyLFndmciylAyOyWCcxAYghmLbQiaIlPeWTyok8XTKUdgFDdW6QagRtiTQBvUfXZpZ8PWtD2Jm3nJ6s2jQPnVbtLhEbglGlJG3rOPAAqTj5dB7x8YIR4JsWCnRJFSphMtONfeFJmYxIQjWaxfx0gZ9VHnfsWaeDg05eqj+rp49hFEi6uGpJRFRlnnZ6ZCcA4CQzBjyeSUdEBTNDzlsVFtAIZT2YapuqlE2lU9E7Ha+RuhqUxPKEsWdAKwylqNrxsaxTDzREKirNdXCA2VduaWCw11tPgLz/UNJFnYnVATll+OwBKc0yvyifQROHMErfFw2RyBjrvHHV5ENBKacvXRQlindDWvX49+3wwrnKXzNR1WjmDLFAjOQWAIZiy6asJrb9Rao78AUsK21PRIGKdcSdN6Vpq40dfzsN2VIdB5Av27tydRwSNQE2CrwyNIZnL2KtSvfLSc8Fz/wAiLelrpTMT8cwTJQg19dCISE6a0paShcrJY983EHa8rFg5N/YKozIYykXCIcEjYRittqLHp0JAWnls7OFpzwTkIDMGMRdVRh4lHQ3WpGupuLW6Tb3TcjVVa4KsRqob0ivvQ+Z0IoVbjUMgX7LNLe9lEbNKRI2hr0qEhk6wpMfOyYo7AveLP5EzWDI6yqCdBV4u/IRhMFjpiJ6Y+ahJ3h4bKlI/qhU8s7DDskanfg1pfN7fgnEbtW6zG6la/1detf3Oy5oJzEBiCGYuR0x5B6d6otSSTM0kaJr09rcD0yROkc37J4gbwCKxruHN7E/M6W+xegr6BJF2JGLPb4lUni+MRtRIdyWR9N67X+AnPrdkySl5Cb08rHVZS06vEdGi0oJETmVBDmSQaKUyErXGVLPbTOPIKDdXFI0gazGqOlgjOaZzfzUJnuzpWh5P6B0ZqLjgHgSGYsWj1xakODenk1qKeBODfddpouD2CQvlo/T2CodEsrfEIsUiI3p6E7RH0DYzQ250gGik/yTrLR4UQJGJhkhnTLiLw6yPwE57Tz7+op5WulhiGmWfUQ/JhyFIehUJoqJxAnR/uHEEiHiEvC5OnG3fVEEAsEp5yrSGdI/EjHink79xaV9ojWD+cqnkzGQSGYMaiRbfiEbUSGs8XcDxod7i3e5p5BK7y0UgDNZQp0TE1oSzqaWXV5hHyeUn/QJJFPa3ErEnWS5AOVGhICGixJnxdh++3cb0TL+E5nZtY2JPwDR9pwTmdI4hN4Hp6lY+CvwKpnSNwVA3FwqIuOYJyjWDOsK1+L+KOHAGoPFutm8kgMAQzFq214i5TqzV60lg0W3kE0yZH4Kqe0cniRmgoG3RMqL09CdLZPMtf3c7mkQy9PYmC3r5PqavelEY3y6k9Cao3BO5Jvn8gyc7tcVrjEd+E8nYtOJcohIZgfB6WkSsuH9VNcX4b2OvqoKLQUAWvqRZUko92hobShrdHAAQeQcD40eqLXh2MtURP/HM7WohFQtPGI9CbgmgiDZQsHnYoWGpP6+4XlMS39gjAv6lMK49qEtoj0Hsw+ISGwFt4rn+zqhjS90OpR6Cb0DocVUMwPinoEq2hWHkpaq+qoWgdcgTDo1n79XvhDNu6jbLOzwB01LiZDAJDMGPRG3N4aZrUEh1P7kxErfjy9DAE6WzeFRpqnPJRvbkLFDytOy1DUOQR+Ky2tfKoptXlETRF/A2BW3hOi831WjkgbaDcxsIpOAeF0NB4rqdba6jS5jReDWWxyPglLsaLn+CcRnkExaEhvRjR+RkIPIKACaBzBIUNMKY2NNTZErPCCo2fLDbzEsPMu0JDjdVQpitHelrjtMUjPLNuK9GwYF5XS2G17bPiHcko5VGNzhGkKySLoZAj0DkmLTanPYIunxzBkKsRakKhIbNUfRTwLSH1bCibYo8gZfgLzmniUUf5qFEaptPXbipyBGVF54QQz1K6mYyNlPLASR9RwKRQqBqa2hzBYNKgrSlCNByiq0yzUSORdpXugaNqqM4SE1pwTq8KhRD0zm7l6U+t7V8AACAASURBVLXDzLeMQCV1TRUaKnzV9b7FaWsSqpQjcArPabE5XR7c3hT11BuyBecSxaGhcXkEuVKJCcBXb6jgERTnCKbSI3AK7vkRC4fYlip0eENxKa9tCKbAI6ikPvoW6/e51u+rrN/vA0ZrMqKASSGTK3QWq/+nJjTkjGd3tsR44dVtU/K8E8EradooonPDHt2pi7oTPL122J6M7T15fSa6kUyOeYkW+3+9b7HXKtSNU3iuvSlqi831dqvQUCgklFy1yxDYzVR2jqD8GMvh9ggqhoayhT2ONfEJ9DGMB309KucItAqsZZQd3pnOv9RacA4qGAIp5csAQoijpZRHO+76mhDiQeC7tRxcwPgxdPmoxwYYtWRwtLCbklJQbHyPQE+I8QYUnRscLQ6xACyarQyADs/EK3gEer9ija4aGtWr0Jh/hNgpPDd/pxZbbG5uR7N9TGdLtER4zik4B84qrLEZViklWVMW5wiaKiSL7dBQcRXYVIaGygnOaeLRwpgK+ZrC69SPbQSPQJMQQhwjpfw3gBDiKCBRu2FNPk/d9RfMp6+1/5cizC5v/Ra77Tkzo1t2+WgVoaE1W0b5x1PrOe/1e9glhuPFKS/R1RKzheeqaZFfunqQVZuTvHPJvIrHTibuZh4oVA3V2yMobPdYWBXq1bhO2FYKu3hVDeXy0taBKucR6BXtj259gZ62Jp54eYiF3QlCjvfTS3hu0NqiUX+eqgkN5fOSn9/9Eu87cj6z25uAggfhXN23RIv3VHCTyeURouCF6Mc730spJZfd18dpB81hXldL0eO3p7P86r4+PnfSXkXPOxbcyXIv3J3F0bAo6kLumMLQULWv8iPApUKI1UKIVcBl1m3TBmPrq8weWc7skeX0jCznkK13MfDA7+s9rJqRyZqu0JD/F/Bvj6/lZ3e+OCldwM6a985EbEzCc1f+ZzU/uX3FhMcwVrRb3uTZR1BnQ+CKtQMcsbCLY/bo5pg9ugHHDly+hqC0aghgYHsG8JeYANhzdiuHzO9g07YMy9ZvJR4J8fZD5hYd4xUa2rA1xc7tcfv/SBWhofXDKX5+90vc/vxG+za9YnZ6BKGQYKdEjE3b0p7n0fIqzkWN2yMYGMnw09tXcOtzG0oe/1DfFi67r4/nXtnqO9ZKbE+rz3xbU/nOYtsQGKVbhr5urx7ecuCuzKqx4BxU4REIIULAHlLKg4QQ7YCQUo7/CtWJI97xeXjH5wG1Glj2nUPoHH6uzqOqHbr22msDDDe6U9SvZX8sDDu6KbVBGKzQYVl4bLbiFoS1wKvKpCA6V+fQkIcM8U6tca7+2JH2/3qSzHoYeyOXxzDztMaKQ0MAm0cyREKiKBHrpq0pyg2fOtr3flCe3zPrhotu6xsY4eB5nfb/LTk1ZZQzrPrz5/wM6FW8c3UPyhtyb9Kj0RVzTmKRYkOgy129qun05DyRSjs7/1KmIkuJzvnvFHdk704c2bvTuMcwFip6BFLKPGrvYaSU26ajEXAjhODF8J7sPPICNMDGI5NNzsyTy0vikbAtMVzOI9BfqJSHXsxYSGeV4Jwd20z469l7MZg0GDVMX6mEWuFVZdIoyeLCvr/+q0It0ey1A5etPNpU6hFsHsmUDQtVS2ciViQ8l86arBtK2SEsnvs7R/ztcA4VL5YNDenPn9MQ2B6Ba2Lv7W61d2dzoyvmnMTCAsMsSK1oA+v1vbANwQQKLLzCjW6UxEQhNFTOaNSaakNDdwohviSEmCeE6NI/NR1ZjVkd34fm/AgM9tV7KJOOdr+rCQ2ZeWlvdJKeoEfg3k1Jl875bVziRocXym1DWAtsj8ArWVznhjItOOde4Top5xE4Bec0BUNglO0qrpbOliiGmSdpTeQvbxlFSiupPTIAN38JgeSt4YfKGgL9+Rsp8gjU8W6PYNHsBJtHDLZ6hDN1MyUAqWHIZUqa7oZsQ1D6mde3TaTkOpU1K3pb8UiYXF6SM/MloodTzVhyBOcC/wIet36W1mpQU8GrrYvVH+ufqO9AakBBdKtQY+63unllOFXQO5mgIXDvyKRXse6uUz+0wfDTkKkVhodH0CgSE07BOT/K5QicEtQanTieTI8ACpOrvWFOdwJu/TIYI6R22o+Tw497GiuNV2jI3lvAtcLXUht9Hl6BHRqSEq58M/z6OFqlWuxow6KTuV6VRPq2iVQZuTvVvXC+b+lc5eNrSVWGQEq50OOnt9aDqyWjs/YgRROsf7zeQ5l0CjK8YUeOwPtDrb+0MPEcgd1Nak0MdtdpFU1lKcO0x+1XH14rvENDjZEsdibf/SinNZQs4xEMj2YnxRC4hef0fgl7brkHlt0Ax3+F4QM+wm5iM81b/PNyadsQFD6HWbP0vYFCCa1ucHNih4Y2LoONz8HAck5e9hUi5OxrZOcIyoaGJuYRVJrYnd/NtOG/U9xUUPUzCyH2F0K8SwjxQf1Ty4HVmo7WJl5gIbwy8zwC5wpXhxT8qjX6HAm3ieYIBl0VLi2xcNXCc05jMeWGIFswnJpwSCBE/ZPFzgY9P6J22KOcR1BcPqqZUGhowzNwy1eYO7oMKHh0fQNJ9m7PEr/9K7DLAXD050j3vgFTCnrW3el7Or0Q2e6RI3CHWOZ1NhMNC7vBzYktUvf8jSBCcPJ3mTv4CN+L/IGs5RkPJg2aSXsWUejPw4RyBIZZ1KnuhTNs61a/nWqq6iMQQnwbeB2wGLgFOBX4N/DHmo2sxnS2xHg818shG+5CmFkI175Ea6pwNtRU0hrqn0yPYFQrTqprKYQou5Vh0WMdxmKqK4e8qoYAoqHx77M7WQyOGnYHsR/lPQL12twSE5rm8a5C1zwCf3onZLayL7/muthe5F86B1IJ3tJ/HReYT0NuGN7/dwhHibR285jch3033O17ypS1b29RstijjwBUDmf3nRJFn19NJpsnHhaw7EZYcAwc/VmeX7WWs1Zewfa7z4eY4Jxn7uKCpjX8afALwCHFj9c5golUDVUxsTsbAatKFm9eCd17jHtM5aj2U3AmcCLwqpTyw8BBQLz8QxqbzpYYT+d7EWZGuZAzCGeoIxwSRMPCd3XTNzBi13tPOEfgUerY0RKtSnhuqJ4egU8cOhIW9U8WOwTn/CjEmkuNlh0acpaPOiacccWl+++Hq94OiW741COMnvgDZjPEEUu/BDd+kkPTj7KhbX9499Wwq2rYjIQFt5tLmLX9JdjiXaDhWT7q4xGAykH0eZSQZnImvXItbHkJFp8OwEv7fZZ/mq+h7Zk/wDN/Y2NoZ9bJbo7YervH4ycnNFTRENgVfaZnH0ERW/rgstfAf3457jGVo1pDkLLKSHNWL8EmYFrnCLoSMZ7WaY4ZFh7Sk76eIMptV9k/kGT/ObOAQmPVeHEKzmmqFZ4brKtH4B2HjoREXZPFbsE5P8p5BNqotjnKRyPhkB2PHlM4IpuGp/6sPIHO3eHDt8LsfWg6+lxen72Ea/e7lC0fuJdDM79i6RE/h71PtR8aDYe4w1yi/ln+f56n96oayvh4BKCE717ekiwx1plcntem/w0I2Oet6vkjET6XPZf+d90JX13NBW0X8tfcCeyZWQbbXnE93iz6PR4qTuwUh4a8+giKuP0bEInDAWeOe0zlqNYQLBVCdABXoCqGngAercmIpojORIy1cja5eOeMSxg7q4b0b68P9fZ0lk3bM+w3px2YjNBQaTxb1Zg3eGjIet0x16ozOsVCZW68BOe8iJXJEXgliwFa48rLqGgIcgYsvwX+fjb8dBHc+EnYeT/40M3QtjOgOn3bW5p4OnIQK5iPJGTLX2ii4RDr6WFz2z6w/GbPp0qX8Qjc7w2ofbGzpmTtUKrodiOXZ8nov2D3o+0xxsIhTMKMtO8F4QhDSYNb80eoB7zwz6LHF3IEE6kaGkOyOGeW9yBW3gUv3grHfRnadhn3mMpRVY5ASvkp68/LhRC3Ae1SymdqMqIpQpU4CoY796d7/ZP1Hs6k4qwaAt3BWPqh1o1ki7UhmGCyeMghOKepdnMap7yFn4ZMrdBKrW6dJRUaqp9H4CU450U4JAgJf48gFgmVhFZa42E2j5RJFm94Rq3+n70WRrdAcyfsfwbs93ZYcByEi6eOzha1k1m/Y2N7J7oPoL/7BLpXXQ7bN9qTtKbQUFZ4//1yBFCQwu4fGGFhd8Hw7Gq8zK7Galh8rn2bO6E+NGqwXc5ldXh3Fiy7EY78uH3sZHQWp7P5qnME6azlEXi9F2YWbvs6dC6E13xy3OOpRLXJ4j8CDwAPSCmX12w0U4j+cm1s24/ulb8BIwmxaaWj54s7+RlziFs50Z2Ze8xuJR4JTUqOQAvOaaoVnhsaNZjVHGV7euplJrQhcBMJhXz3AZ4KvATn/PDT23crj2q0h+A5Wd3/E7j3BxCOwd5vgoPfC4teX7agQgvP9Q2M0BwNs4slGqfRhmhl1/EcsepXsOJmWFIsV6Y9UsPMWyWgYXviLvIINjwNT/6J/cKtHCFaWL1xD9i3YFSOzT1IHkFo37cWrk+40GGfNfNstza1+VfkaBas+Qtsf9Vebevvj977eDxUk/zVC7Xt6Rx56ZOveey3sHkFvOcvKjRUI6pVH70SOAb4hRCiF3gK+JeU8ue1Glit0SWOa5r2YT+ZVx+u3Y+q86gmB3fM26l77qRvU5JwSDC/K0FzLDzh0NBg0mDPnYtXglp4bmsqW1aSdzBpsFMiRl7KuiSL4x5fwmidPQIvwTk//GSW3cqjGl9DsO0VeOBnsM9b4LRfQEt1AgIdLTHWDo7SP5Ckt6dYnRQKDXqvxnthpz3gyT/BYR8Ghxfm/PwlM8oQFMpHBTx3PTzya1j7MESaaDINro3nMe7/Kaw9Wn1/dz+KE83/sK7tQOa372qfz9lZ7PRQ7wm/lg/yZxUeOuJsoOBZTbRqqGJDmWWctqbUeEqOHxmAey9SRtiRb6kF1TaU3QP8ALgA+C2wBKidnzIFtMTCxMIhXozuqW6YQR3G7rp4p6aJk/7NI8zvUpvMN0fDEw4NedW860msUnhoaNSgoyVqb6M4lXhp04AKudSzj8BLcM6PuK9HYBZVDGm0l1Cyar3vIsibcMoPqjYCoDw/7RF4lbsKoarXcnkJR34C1i+FtY8UHZMuMgTqM6An5bblf4PrPgwjr8IpP4QvroCvrOKnHd/i3uaTYNt6uOd78IdT2VOs5cWdXl90bmdCXTeTtcTCvGjOhZ59VKmpxWRUDaWrkIzQVUN6PPbxqSHllV16BGSTcMpFRQazFlRlCIQQdwMPAu8GVgCHSyn3qeXAao0Qgs5ElFeMdpg1b0YljDNmabLYa7XYP5C0hcGaoxPzCNyCcxqtqV4pYTyUVB6D3jRlKvELDalkcR09gioE5zSxcMhTviFZITRU9LoHXoQnr4bDPwadC8Y01k4rNLR+2CE258JOvh/8XpVz+M8viu53LkT0YkCXxLY8exV07w2ffgJeey40d0BzB1vmnczXMx+Ccx+BL/eTf/ef+HH2PSzf5fSiczu389QGdpdZTWqyX/w2ePlBGNkEwJ6jT/KNyNVgeIvaVYMKDVVqKNMegWUIYiFVHnrJ/io0N+8I+MgdMLv2U221VUPPAAawP3AgsL8Qorn8QxqfzpaYSsjNOxL671PlcTMAXQUTL1M+auYl/ZuTdqt+UzQ8ofJRt+CcplrhOV1xVBePIFsqWwz17yOoRnBOE/XxCJJGrkh5VKM7jYs8grsvhGgCjvvSmMfalYiSy8uC2JwHkZBQhjWWgCUfVdVDjp6ClI9HsEisJ/LKY3DI+yDkUiHtSbAlaagKq8ROGHucyq/M0wg1txUdV1CTzdsGdlfbEJwOSBUS++PbuHDoa5wduYVDtt415uugnyOXl1Uki9X9w5Yh6E6tgju+qeajT/4H3nsN7HbYuMYwVqoNDX1eSnkc8HZgC/AHYLj8oxqfLl3aeOgHIDUIy66v95AmBXeDlFf56CvDKYxcvuARxMITShYXwhjFq1ed6KwkPDeYVHsWtNbFIzA9q1IioVBd+wh0uKwaYj6lriOujes1re4cwdpHVX3/0Z9RjWJjxLk3r59HoHYJs8Z4xDkq+fzQpfb96WyetrjefUx9BrJmnjPD/0KKMBz4npJz6uok3VhWKJ0u3Y8ALI/AClPu0t6svhez94XuveCRy2HD01we/wgr83N47Yi/HEY57G0nqwwNaQXVvZdfpozkGVeoEt0ppNrQ0HlCiGtQSeK3Ab9HyUxMazq1/MHC49UH4dEr6j2kSSHjqr2OR0vLR1dqhUjrizTR0JBfzbtzcxo/tOBcZ0uMRDw85eqj/qGhOpePJo2qEsXgnyweSeeKNqXRlCSL7/4uJGbDaz5Vcmw1OJve3D0EzjHahqBtZzjw3fDUnyC5Gcwsb9l+LQ+Kj/LO8H32ZyCbNTgj/ABiz5NLyk3VcxVKSAEyprdciJ0jMAs5gl1mxcmaElMCp/4ETv4efPZp/hw+jevNY9jHWAZDq8d8LdLVGgJHaGhvsYbZa25R+ZPE1GxG46Ta0FAz8F/APlLKE6WUF1oJ5LIIId4ohFghhFgphPhamePOFEJIIcSSKsczKXQmoqp+XQg4/GzVYbxu+ucKdPJT18V7hYYK9d7qS9sUDU0oWewWnNNUIzzn3N81UZdksXfVkPII6ttQVu1+tX4lwskKHkFTLAybX4LVD8BR50G8vK6RH3oBMGdWEy0ehgdUqK0o5/La8yCXhlu/Cpcfw8fSVyJDYb4buZLQZrVl6bzBh9lZDMPB7/M8p1t8zt1MqXHnCBKxsN1UZ+TysOgE5Q01tZPJmdyUt3Zle/ZvY74WaUszyTc0NDIArz5nG6fhlMHnIn/HjLap/EcdqDY09FMgCnwAQAjRI4RYWO4xQogwcCnKc1gMnCWEWOxxXBvwGeAR9321pqslxvCogZmXcNB7INYKj01/r0DFvAtvrVdoqG9ghFnNUXviVjmC8RsCv8SmFp4rlyNwahTVJ0fgXTVUMnFNMYOjRkmozQ+v0FA+L0kaZpHyqKbII3jmWqXSecC7xj1WPc5yAnklndqz94E9T4HnrgNjlC+Ez+eH83/LKHGOeOIrkMuw36Z/Mkgb7PVGz3Nq8TktR+1uptQ4u6+HrDCks7PXSSaXZ53s4ZnwYnVt5Ng+A9qz9u0juOnTcPnRiNu/TnskR8/ICk4NP8bwQR8bU6XWZFJtaOjbwFeB862bosDVFR52BLBSStkvpTSAvwKnexz3PeAnwJRnajtaYuT15upN7coYPHe9clWnCZu2p/ne/z1f9AVzr3C9Vov9AyMs6knYXsN4QkOX3ruSs/+4lLP/uJQ/PvQy4F3q2FlBb8jOLziqhuQYv3zV8NsH+nlqbWlqyzD9q4bKeQT/enGAax5bU/F5n1u/lUvvXTm2waIqqarZ6xlK9+QFGM2WKo9qbEMQCcEz16jwqKPufqzoBcUin7AQ+OQx3vQTOPWncO4j3GkeQqxjDl/NnsNOIyvg5i+w99Z/c5s4DiL+12FRT4KH+7dw9h+X8s0bnwU8lGQd5aO6MCHus42r9ipuC78ONr8IG56qfAEc2IbAyyNIboGVd6peiocv4/rI1zkvfQVbZQupwz5eevwUUW1o6O3AaUASQEr5CtBW9hEwF1jr+H+ddZuNEOIQYJ6U0luFqnDcOUKIpUKIpQMDA1UOuTIlNe6HfwzMDDwxfdS171s+wO/+vYoXN263b3PXxXtJTGzYmmZuZ4v9/3iSxZfdu5InXh5i3VCKSDjEGYfM9VSJ3Lk9zivD/nZ+aLTYI8jl5YRquP34yW0ruPHJ9SW3+1YNhcrnCK5++GX+5+7KE/yfH13DT29fMaYKJC04N5bQkNt7GbW2/GzxMASHL+jkDYt3Zq/sCzD8Mhw4fm8AYFZzlDMP2423HDTH9xhPyY7OBXDkORBrIZ01aW2K8EDocJ6YfQY8eTURmeXWyOs9z6c5/eC57NbZwrqhFFtTOQ6d38HiXduLn9vaX8Iw8wxaUij2Xh2uz5quvrpDHqm6q5+5tsqroNAhVs8cwfM3QD4H7/xfeP/fmUWSw8Ryrsi9mXhr/Xb/rbaz2JBSSiGEBBBCVKPF4NUBYX8KhBAh4BLgQ5VOJKX8DfAbgCVLlkzaUrHTbQhm7wsLjoWlf4CjP1tSqtaI6Pi6syrHnfz06izWnbyasXoEum/gUyfswbknlNdI7+1u5eH+LeTzsqTjFAqhoS6raghUbHsyt+4zcnm1JaDXRiQ5xx63DiqJziWNXFU6SjqRmTRMZjVXt/YaHkNXMajEtntCKxer3nVWM7/54BK4+YsQaVadxBNACMHF7zyowhi9S1xB7Q2dNVXJZWs8wk07f4pDWU7/9hBrQovKnvdNB+zKmw4o782ohjb1/ENJg4U7tXiGhnJmXoWKgc1mC+x9Cjx7nUokh6ubLgvJYo/3+tnroGdfVRW0y/58MP7fHDpyP9eZx/GJabB5/bVCiF8DHUKIs4G7UB3G5VgHzHP8vxvg1HttQ/Ul3CeEWA28BrhpKhPGOq5ZpJe/5MOwdY0qp5sG6EnUGYM3csUr3HgkRF4WNmLXWivO1abuI8hXWS7p1zfgxaLZCdLZPBu2eXsFg6NZhFCryoRtCCa3ckiXpHoZO7/O4ki4vAz1SMZk1DArelI6MT+WsthqBec0MYcuj6ZsiAKUoNlz18M+b1Kh0RqjNvrxNgTpXMFoJeIRhrMROOc+fjHnx2U3gB8LcauySpXlFnIEzv4Z7YkKYYWIDnw3JDepPqMq8c0RDK+BNQ8pKWkrJJuJdfAn8yQyxGjy+AxOFdUmiy8GrgP+DuwNfEtK+T8VHvYYsKcQYqEQIga8B7jJcc6tUspuKeUCKeUC4GHgNCnl0nG8jnGhv2RFq7oFx6rf6x6bqmFMCG0AnK/B3qrPwh0LtSdxh5iZ/tBWG5Lx6xvwwt5o3GN/WTUeJTgXDgk7sTnZCWN9Pq/KqEzOLzQUKhsaGkmr61jOK9BS384xVEMhb1JdslhtPuRjCPw6XFferfpnJpAkHgvRiH+ozQ6nxMJW5ZgJkTjb83FPCerxPb+qjNueztGViNl5NOd103+3xSNkciZyj5NVF/Sjv6n6edJ+BvjZ69Rvx54C+nMXC4eITNLrHA9VP7OU8k4p5ZellF8C7hFCeNdzFY7PAecBtwMvANdKKZcJIb4rhDhtQqOeJOwcgbOipXU2dOw+bQyBlm8ecng17ioY5wYY6jGlq029Gqk2PFStVj4ojwDw3FYQrHp5ayy2R2DUyBC4Xp+UEsNlODWqE7ZMaMjyWobK7MDW79hBayyGQBvrakNDXlpDZWPVoJLEzV2wx4lVj2silAu1OSfP1ni40FlsSs/3ZjzEwiHbKPtVDem/25qiyosOxVSY+KXbYfWDVT2Pryf27N9U17BDvsPu/q/jxvVQwRAIIdqFEOcLIX4phHiDUJwH9AMVlxFSyluklHtJKRdJKX9g3fYtKeVNHse+biq9ASjUuJc0O+22ZNpoD+lJ3e0ROKuG3B/4wWRp/Fl7BNUaAr++AS96WuO0xSOeG43rsWuDog3BSHpyDYGeWNxJc7/dyaByaEifs5xHoKW+ncdXw1gE58B7kvVdmYJqlFpxC+z/jinbrzsSCnlupwnFk2ciHrEXAkbOnDSPIBYJsdEKT3a1OA2BwyOwPh96R7dMLq+avNrmwJ3fqqqU1Ond2GxcBpuehwPeWXSsHkM9N66Hyh7BVahQ0LPAx4A7gHcCp0spvUpBpxVCCLWhhntFt9vhSs1wa2mFSaPhlSMoSRbr0FBWh4Y8PALrg1htU9lYBNGEEPTObqXPxyMYSmbtEJNOFtcsNOQydOUMQbkVrJTSnqzK9Uj0bSoYv7EYgrFcX1Cr3ZJksTtWvfpB+Mt74eK94ecHgWkoAbgpIhbx127Sn7vmWEiFhtIFraHJ8giiYWEbgs6WqH3ejEeOoL3Z0WwWbYYTvq4UU18oWcOW4GmAn/0biLDa2MeBXrBV3Li+xlRKg/dKKQ8AEEL8FtgMzJdSbi//sOmDLTznZLfD1e/1S2HW3NIHNRCDnh5B+dDQoMeGJ/pDW20J6dAYksUAi7oTPNS/xedchr1dZsJRNTSZ6DBOqSGwJAk8O4vLxLSzJtpZGK7gEega/7HsvDYWwTlw6fg4xgjQFAmDmYPrz1Hl0YteD3MPgwXHTKmmTTnD6hxrm6OpMGtKWzBuosQiYTaPKMPcmYjZSWiv0FB7U7T4voPfq3SR7rpQbdZTxotKZU0iIVFIcufzKj+w6PUlOk7TxSOwl8pSShNYNZOMADiE55zscoCqH27wPIGZl7aEbZEhcNXFx1wfeK8cgV6RVGsIvDaqL0dvT4INW9MlE7yUskhTR+viTLZHkPRJFhtlQ0P+DWXO8Q2WyRH0bUraNe1j8ghGjaoTxSz9A3tue4isKYuqvoqqV166Hbatg7dcAmf8Rm3NOMXCZpGQv6y3bQisZLFTfXTycgQFg9LlyBE4PSnD9gis0JD2FkJhOOk7MNhXsc8oZeSL8zJ998DWtaph1YUew2SWSo+HSlf4ICHENutnO3Cg/lsIsW0qBlhrPD2CSBx2ObDhdYe2prJ2yLIoWeyqi3dXDQ0lDVpi4aIPn16RVJsj8NqovhxaJXKVK0+QyirBuQ47WazGMdnlo9uticVt6MqHhpTEhFeXs3N8fjkCMy9ZtSXJQbvNAsZeNVTV9d3wNPzf5zmp7yLCmEVbaxYlix+9Atrnwl7104qMRfyT72nDnSMwyeclWTM/aeWjToPS0RL17Cy2Q0O2R+AY716nwPyj4L4fQXqr7/OU7E722G8h0QP7ltbIxKaDRyClDEsp262fNillxPF37QuPp4DORNRbInm3w+GVJ1WtdYOiY9M7t8ddfQTeoSG92hn0mMTHnCPw2Ki+HL22XHBxnmDIro5RX7xIOERTNDTpVUN+fQR+ssWgVrAAzraeDQAAIABJREFUXvliZzLbL0egpb733bWdSEiMyRBUZWilhNvOh1CEtsxGTg49XrS6tWPV21ZB/71qa8gqm6JqQaRsH0Fx1RAoiQx3KfRE0AYlEQsTj4RLQqbqbys01OwKDYGq/X/jDyE5oIyBDxnnpjTDa5Q3dugHPWUy9BjqnSOob81SA1AkPOdktyWQS6lsf4OiY9O93a2ksoXGppI+AlfVkBLdKg47NI3VI0gadFWZyATYfacWQqKgG+88D1hhqtQQbOmjNR6xNxefLJyGwLnCL+QIvKuGAF+df42fR6ClvhfNbh3zzmtDo1VIUD//D7Wz1qk/YqRpDh+K3F5kCFJZk3BIEH3i9xCKqsmojkTD/n0ZKd0FbYWGQL1nWR8dqPGgvxN6AeNZPprVHoGjasjJnENU0+kjv4ZXn/N+LVnHNpWPX6l+H/Yhz2MLoaEGLh/dEehMOITnnOiEcQPnCfRKVOu/D40aSClLGqTcVUODo9mS1eZ4cgRj8QiaomF262wp6SXQr6EnkoLfvQEuey0nhZ+c9GSxnril9A4F+IWGAM8SUj2+7ta4ryHQPQS93Ykxq6oOJbPlK4ayabjzAth5fzjsw7y4+1m8JvQC0jE5pYw8XdEs4qk/w+LTPPX8p5JoRPhKTDg3c3FWjhmTGRqyztPlNgRlqoY8N7B//QXQNAtu+ZJnOaltCHKGyifs9UbomO85Jv3dbPQcwYzHs7sY1BuX6IF1U9raMCb0mHX8fTBp2F+0clVDXjr3haqh6jqLx5ojUONMFDVY6fNEybH3v86FwVXQ1cv3Mz9i38G7x3TuSjgNi9cX3zNZbIWGvEoedehqXlezb0NZ38AIHS1Ray/mcNXGTQvOdZW7vg9fqsIOp/wQQmHWLngHozJO0xMF5Zd0zuS08EOQ2aoEFetMWYkJhz5PIlboJTFy+UntLIbCbmpCiBJl3kLVUKTo/yJauuDkC5VchIcgXcqwcgQv3KTCSEs+6jsmOzQUGIL6UiI8pxFCeQXrG9cQ6GoV2yNIZj0nNq+GMnfYYSzJ4nRWaexU1fU6sgnuuABu/BTvlHfQtPlZ8tnCtR4ayfC9yO9pWf8gnPYL+OjtrIzuzccHfgBPX1P5/FXiLN10vsbC/s6lX8TCPrelqz69ut+ts6WMRzBCb7eS+lahoUnq2h5eCw/8lxKK6z0eANHSyY3m0bSsuB5GBwEw00neI2+F2Yth/mureu5aEg0rzauSMCxq8gwJtWp3h4aikxQaimuPwOFpuffqsCUmvJLFTg5+P8xdovYYdiWO0zpZvPT3qot4kb96aqOUj9Yvc9QgFDZX90oYL1Hdl6ODddswohzDowbxSIg5Hc2AMmZ28tOzszjvKTjnPKaaZHFVgnOjg/Cf/1Gx1FwGmjt40+gW3hQG+aMLYZf9YJcDOXTdMAdG7iN/7JcIHXwWAP+9y4/45IZvctANH4fO3WH+a6q8Iv44V+NFhqBC+SjgWUKqzzevs9kWnnO79/0DSY7fqwdgTHmPsl3bRhL+epbaSOYN37dvjoUFV5qn8F7zHnXN4218Y+XFtMshOOpyW+SsnkQjhZxL2KXsq8MpQgi7q3d7JkfWlJPnEYSLcwSgDUFpZ7GuGvLa/hOAUAje/DO44gS10DmtIL2Wyposya+GdQ/Cyd9Vx/pgG4IgWVxfdBzWcytFu7GsMctI9creua+Cnfx0TGzODsphV5WOJhQSNEVDVeUIKgrObV0HvzgM/v3fqvnm3Efhy308+fb7+bRxHuv3OAuiLfDc9Ry48QZu5WhCJ3zDfni0pZ2vxb+hjO+/L6nyapTHGZ93GrtCH4F3QxngmeDUHsbczoIRdqLF5nS1VCJWfbJ40K+rWEq48ZMqSXnm76GrsElgLBLiRTmP7bseBff/CO74BmujC/jqrJ+AZWDrTdSaEL3CQ6msaU+G2iPQntGk9RHoZHGL0xCEXaFCXTVUJjSkmXMwHPVpeOJ/YeVd9s3SSPKRgR+pPMLB7y87Jr1gq3eOIPAI/EJDoCoEELD2Edjz5KkdWBXoOH1Hs5bTNnxCQzpHYNqvs8O5ms+bsG191XsSVAxd/OcXkNkGZ98Dcw+1b57buw//zB/FYfMX86GjF4KUnH/V3TyyMcypjlVTazzMZiMCR52tJrVNy9W2hhMgmcnR3hRhWzrn7RE4qzasBGC5qqFkJkciFrb3dBhMGuw6q9m+304UW2G71qbqDYHOOZR4BPf/RFUKnfy9ks+jXu2uPfRLLH75T3D4x/jubYLKyjhTh5189zCsTo9K95Lo0uJaewTOBLaRyyNEwRhVVON93ddhxW1w02fgUw9BvJ0vpX/JrrIf3nddxY3oGyU0tMN7BL7CcwDxNph3hHqjG5BBqww0Eg7R3hRhKGl41sVHw2p3poy1cTe4Jpn/+zz8/CAOD79UVWiobOgiuRke/18lbewwAmCJzzU5xOeEYI3RSmdrvOi4RMzSmjnibIg0wUO/rDimSoxkcnS3qedJFxmCUg+Kv74Prv0AEeFfNTSSVpvC69WluxdFi83pRH5rPGI3tVVCG+uiZPHyW+C+H8KB71GrUBd6shzqPEh5C7sfRdpZxtgA6Fi/l2F1jlVXDWkvfbI9Aud1jUVCdp4ICjpd2ih5Vg05iTbB234F2zfA7d+A//yCU+SD3Dvn47DnSRXHNF06i2c8WnjOMzQEsPh02PgsbOmb2oFVwbCjDLQrEWNoNOtZNSSEUCufXL64bh+US/vE/wLwjdxlZDOpis9bVhDtkcshl4ZjPldylxCC3p5i8blBh+CcJhGPkMqamM07wcHvU3LJ21+tOK5yJDM5uhPKEDiNXcYdGsqm4KU74IV/smj1X9RNXn0ERo7WeMQ2hu6msr5NScIhwfyuFus1havei7lwfa33yMzBHd+A2fvBW3/uGe/Xk6xzdZtqNEMQKh2jJmUUQkPN0TAhUbimk91Z7Py8xaPhknJi1WxW2mPgy26HwVGfgSevgru+za35I3li/oeqGlMhRxD0EdSdzpaY7YaWoNvCn//H1A2oSgYdTUcdLTErWeyxwkVvV5kviMUlopAahn98Grr3hnddxe5yHSduvqry8yZ9ksXpbWoDj33eDD17ez7WXULqVcra6tyT4LXnqu7uMWwM4iaflyQNk+429TxpjwYie9X5ypOQz0LbHPZ+9ifsIdZ5hjKSmRytTRF7snaHFvs3j7B7V4t93kQ8Ql5WV547OGrQGo8UxvT8jTDYD6/7mlqBeqA9guLO4nzdk5BOdLLY63qmsqYSx0MtGBKxiH1NJ1trqDRZXOwhxiMhIiFBSFS/UROvOx923h/Zsy9fND5Oc6y6qHujlI/u8DkCUKvpR1cN8oHfPQKoZpKfnnkgLbEIdMxTZWLP3wjHfsF+TCZncuE/n+dzJ+7J7HbvLycoUbUL/vEcL28Z9bw/EYtw0RkHjKk5CwqCcx0Oj2DjtrR3zJvCB75IcO7mL8HIRnjP1TD3MO5tOpFTh/8Cr35CCe/5MDTqIzj3+B9UKZ3jOrlZ1NPK9U+st6/1pu2ZkhCTs3ywfadFsO9b4LHfwTFfgHhrFVenmFHLOHa3enkEJtGwIKz3Ul7zkPr9gRswf3cq/xO9lHT2NKCj6JwqRxBxFBsULyT6NiXt/AAUy2s7J+cbnlxHPg/vOGw3+7bh0Wyh8zufh39dDD37lN1XOO4RdlGaN42z1ouUTRbnmdVcWKkn4hGHRzBZ6qPFDWWgrtuIq8ckHg1ZXnS4ekMQbYKP3c12w2T0e/dVHeoJQkMNxNsOnktvT4KRTI4NW9Pc/MwGXtjg0NRbfLoS9xpcZd+0fMN2/vzIGh7s21z23Bu3Zbj64TWsGRxlJJMr+tkyYnDbsld52EeeuRxacE7XRHe2KBXVklCHRTwaIpNVOYKWWJimVXfBU1erEM7cwwC4pvOTjITa4B/nqXCED57NZNm0kuldeLx9Pi9O2ndnjljYZV+DQ+Z18Pp9ZhcdUxCes8Zw1GchPaxc73Hg7AIGd47A1bC05mE16c7eh5Wv/TGLQy+zy9KflZxzJGOSiCtj2N4UKfIItNicrhgC7CYpd8L4ygdXc/n9xWFH545trLgFBl6AY79Ytgwx6uURGKUlrfVEj9GrLyNtmDQ7jFYiHrbzLpMlMXHsnj2cdcR8ehw5qdKqocLnwZ0/qEi0ibQ5tiqg/XebxVsPmsPB8zoqH1xDAo8AeNfh83jX4fMAeHbdVt76y38X9xUsPk21879wk9q2jkLCtJLGvJZUuOjtB3DUHsVa5MlMjv2+fbvvzl3lKOxpqz2CKEOj2eLk55Y+2PAULH57ITSUNHh9/EX4+8Wq0ej4r9rnzDV1clnzJ/j6hh/Bg5fAcV/2fe4iD0ZKVeY5slFJHJdh713auPbj5ZubCqtn69rOO1ypPj74cyWc5hMe8UPX79segStZbPdc5POw5hHYX20esn3+iVyVO4kPPH8FrDgR9i4odyYzOVscrTMRK8oRrB9SYnOLehIq53DrVzjlpX/zI75YIjMxOGrw6tY0OTNv9y3YhlZKeOBi1ZS03xllX2PMxyOod8jBSSziX4XlHmtrU5SXt6jvxWTlCPbdtZ2Lzij2dL1DQ2H7Pj9JDD98t6n0ob0pyi/OOmRMz1ELAo/AhWdfQecCVUq67Eb7Jn1/pZJAnRh1rg41iXiEXWc1+W7qXg73ngIdLTFSWdOxigqrRpfrPgJXvpkF4lUyOZO9Bm7jkuyF0LYLvPcaJblt0RwLcxevgf3PhHsvUqtjD4ZHs4XuTDOrqo7u/5HafWnh8WN+LW5avTanOeF8VZnx+B/GfL6CR6CulRY4A7WCtlecAy8oOQarCzcSDvH93PvZ3rkfXP/xooKB0bShwmj/OI8948NFHkGfVTG0T9Mw/P4UeOKPtCTX8avYzxkdLQ4RDiWzZE3JuqFCkt4WnOu7R+Usjvl8RdVQt0eQNfPk8rKhDEG50FDa0UcAqoRY77UxWTkCL0oayhwS7tqLHgs6B9RIuZlqCAyBC9++gsWnwytPKH0XCjXOlQ1BkkQszM7tcc/7e3sS9E3AI+hKxIp+66344iIL/ffBnENh4zIu3fppPrLxB3xi80WsjC+Gj95eIoTVFAmRyuXV5iUd8+G6j9pyBe7n7kzE1H1Xn6Em52O+AO/4/aR0sOocQVEn7sLjYMGxSlrB8M63+KHfo/bmKLFwqKSPwDYEOj9gdTJHw4IMMZ4+6pdqY5Jr3q86e40k389dzCmv/hqe+jOXDZ3Dmzf/DjIjkDPYsvo53h56gANuPg0GV8NZ17Dm+EtYEnqROQ9/135urSkExXsbDyWz7NQcgvt/rPbKPahyQ1jMrhpSYZeiTWkahHKhIbeGfyIWsfXcJquPwIt4tLSz2N5Qfiw5AouxegSNQmAIXPj2FSy2tmh+/ibY9gq9L13JFdGLiW5dXfZ8fQMj9Pa0InwmyEU9rfRvGqmqrNCJu6lLewavblWGILHxMcgm4fivwLkPsyx+EEeN3std4WO5YveLobmz5JzNsbCKnze1q1r0kY1w06dLFBaHRg12jwwptdA1D8Pbfw0nfbtsDHsseHoEoPaNTW6Cpb8b0/n0ZNsaj5R0Txft5rbmYWjdBTp2Bwor2JHmXeHM38HAcvj72cjfncLJ4jEeWPg5+OzTPNd2HO9JXQMX7wU/2JkzH3o7l8R+Rah9DpxzL+z9RnL7ns7lubeyW9+flSKllGzbtJZjQ8+wt1hj722cyZmEMlv5f/1fVI2MJ3y9yGvzw101lHZuStMglAsNuXse9GcAmDStIS/ikXBRXiVj5otCQ1WVjzpINeB1r4YgR+DCt6+gq1ftWnbvD+GOb3ICEsIQ3XgDcIrv+foHkixZUDrpanq7E2zP5BgYyTC7rfrYt85h6KSiro1+VXsEq+5W220uPA5iCX4++/u0jvTzwFAHZ7R6V94UdRbPPVTppNx+PjzwM7XiD6lJtCe7no+s+AkwCh/8B+x+VNXjroaEs3zUye5HQe8JSrrisA9XXUGkz5OIRwrGzkLlCLRH8IjyBiyjXSQ6t+j1Sn747gsh1sZHs1/muEXv5diOef+/vTOPk6Qs8/z3icijqjL7qOouoKHv5pBGUbRFEHVQ8EARPEBEVEBdxoN1nJHd9dhRvHZGxFU/o4wygIrMiAPjKioeiIysgyI4IFeDdJVAN1dX09VHZXVVXu/8EfFmRkZGZGVWZWRGZ77fz6c/XXl05lvREe8Tz/V7uPHwz/D520/key8Yg8woX7unzFY5mL+/4B2VYSSZdIJLimdx+oE7WPHjv4GbPsnyfTv5jptq2XzHDbDhs+xRi7k+dTGH7H4aTr8Mjjmnqd+x4hFoQ6BDFDHakMJCQ4VSmUJJ1XoEHkMQqUfgzxEUSqTdxkN/2KgZvCqq+xP712o7RGhfwXHvh+WHwokf5eI13+bW0nPYuPvWQE1ycO4OHt+1r9JdGsSGA9zJXdtbCw9NuoJz2vXXoSHtESTGb4Y1J0DKKWFMJ20eKh3MnplyqFjcQNJmplCuzr097n1OyeKvPgP/eDzc932mHr2b61KfJlmehXN/1HYjALWllnW8/GMwvaOlvgKddM6k7ToZjUpoaPc22P1YjUpnnejcS/4aXv8Vnn7rjfx7+XmVdQ5nUtxeWM/Ma74Ir/g438odT+ngTTUTqTLpBGUsbtr4f+A5Z8CRp/LnF36Ss/Mf54vFt7By6l74p1ew7Fsv4yCZ5I6XXNG0EQCwLacEVm+yXn3/uBAWGpoJCKfUGIIO5Ai0R54vlivFA/6KomaIY0iuGYwhCCBwoD044l1/eSuc+L94sHAgvyhv4oDC407IIAA9n9dbT+5HJ5G9MeJm8EtJD3sMwRprB7LjITjsVZXX00mbp10j4Rec0+iTt3IXJAJvudoJEykF15/PsmtOoozw+xOvcUS3ImAgaWFJSP5l1bFw6CudCqKd4019Xq4mNGTXdRanE3Y1Me5ROtWic5WNSwRecB67hxyxN71ZefNKe2YKTHjE5jS6fPSZchbe+HU47R/YvPpsfls+iltXnMfrrMvg5IvZs/wY3pS/mPLalzX1u3lJ2tXBL9UNKT6XeDJEu8k7uF6jK7Ig6hyBjVLV/2NvzsjJH8wvNBQnT6wZ4nOWxIjhTMBAex+TuQK/KG1yHmz+ceB79Oa+fnm4R7Bi8QADSatuYMtc+DtytfDc3tkiJyX+6DzpNQQJq6J1szTEIwicSWDZ8Ow3O4JaZ1zFjrWncmb+E6RWHNnSelthTv3+1/y9I8P8nTfC3qfn/LypmSKWOL/fYMrvEZScO87HfgeprDPxyyURIpKmPRXd76DDcjtz+cr/4waf8bctYShVO5xGJ/w3rRnmsZzN7udfyH+8+Eq2qJV1o0SbIWVbldBQHGPVVY+g1hDM5OvDWJmO5QhqpSR0Z7F+zSSL+5jhoZCB9h4mp/NsZ5jN9hHw4I8C3zO2PYcIrFse4hEU9mE9citHLkvUDXWfCy04p9HCcwAnWnc7Ja/LNlRe9zblhA2UaTicxjUItz//EraqA5sbSrMAGo52XH4onHOdM/TmmjfXDQbxMzXrCMSJCAMJOyBZ7BqClZtqyjQrE8p88wi8HgZQIzw3Pke5sDfvoRP+m9Y4OaSxHVPBgnNNkvLUvQeFW7qN3tD9htU7uF6T7WCOAKpe8GyhOu875UskN8NMgHezP2AMQQChA+1dlFKVC/YWeZHTdeyWlXoZ3zHFwUsG6+OF+Wm47avw5aPh6tO4eu+7edkTV0Ku+Q7jyYC5wyOZFGnyvJD7HG/AU6nk7TQOyxHopGkjBdKGgnNtJJt2FUjDWLkJzvqOU/v/3bMDy1w1TvOXs7HUewRllsg0PH1f3RSvsAlludlq8hmoEZ4bm5giYQlrlg0F/04eL2dnrkA2neCIgxYBMLZ9ql5wrgVStkWh6A8NxWdDSrqhNn+TViWc4gljZTuUI0j5DUHRXzU0P0MQJwPcDMYQBBA60N5lyp2cBPBzHR568Cd17xubmKokgwFH9//3/wRfOdpVk3wWvPFyti8+mncVrkV96SinXHPr70MT0JrJ6fpxk8OZFMdaDzLIrBNH9+DVHprLI2g0nCZUcK7N+O+eAzn0ZKd09dHb4NLD4OrT4Y4r6gxqLl9kWaoA153HS2Z+XTeY5mV7fgwo2HBSzb+rJIt9G9den0fgFZ4bn8ixemQosBs2k7aZmqmeU5PTjle3amSIpC2M78jVC861QNLjEcQxVp0MOZ6VHEEiJFkcqUeg5aZLlMuKfKnsCw21mCMolEhY0rZu6E6xf622Q+hNLixPoAXGRhel2Zw/AEaPrMsTKKUYn8ixXoeFtt0Jl58IN17kaNmc/zOn6ua5Z3HfX3yDk2cvYfehp8O918OVr4SvvcjZ1AIMQrFUZvc+1yN44i4nVv7rL3BU4glebt3NLClY+5Kaf+O9mMLu5vXdYyNDECo412Yahoa8POcM+Mtfw/EXOpU/P/kwXHYcPH1/5S3TM3kunr0U7v9/vG37F8nmq/pQA4VdvHzHNXDYqx0pCw+VCWXlxh7BUk+OQPeNBOFMKfN6BE6eJ2lbrB4ZqngE88kPgC9HEMM70+o8gtrjGZQs7mTVEDheSkXCXXcWz6dqKF+OVV6mWYwhCEBX4OwKMwTu8yuHB8mXyhSPeC08dpszlMXlqT0zTOdLHDEsjgTDFSdDbgLO+KZbdlkNQ2wYzbJFreS2oy6Gi/7kDHFPL3I2tf/4St33a8G50VQBrjvfiW/f8lk++8R7OM/+Ofcmj4ZUbWhCn9xDKTv0RG1mgH2g4FwEaP3+pljxXHjlp+DCO+G/3QJWAr75Wtj2B1CKc3Z8mU35O+ClH8ZWRT6QrzaknVf+N9KlaTj54rqPDUtu5nzJYi0898xUnkeema5LFGv8xs2b8N8wmmV8R47J6cK88gPgbJgFX44gHaNNKRESGpoJ8F60t2UJVWXYCNDXxWyhXCfY6O86bgZ/h/T+gjEEATQcaE/VU1g17Gy2ufWngCrDn6qTzMYncmyQxzn9znfCnd90ehAuvAOe/aY6GQadTB6fmHIMwPPfCe++yanW+eUnHS/BgzZELx27FCYfcUbiffghfrrmf3BT+QX8NPOGujXrk7vRJq5P4EY5gjrBuYhoWDUUhojTCPeun8LgUrj6NPjB+3nlvp9x49K3wUmf4LaDz+VV6jZ4+Jcw+Shn83PuH30dHLix7uNsy5nsVl81VCJlWzV5l5FMinsf302+WA4tF/aHu7zzJNaPZnn0mRwTe2fnfXyTdnXjimOsuhoaCvYIaquGnJ+j9AbAO8a1XDetTovOlUNyhUE4mkn737ZqOosDaDjQ3vP8qhFnRu2eJRtZsmQ1/OxjMP5rR6Xywa3ckPoc6XwW3vF9pzM1hIr4nLeE1LLcEXhPOQPLF62AtSc43z9d4BTrdtY89n1Hnth9fnztW/nCQ8dwQrZ+Tqo+uRuFHXRoqJFHsGu6UBFvi5KmQ0NBDK91Qm/feQP88V/4qXUivzzoAl4L3L3qXFZt/THrbvww6qDnohDuWPdewqYvJC0rMDSUSddusEuHUtz3uFO9FNZA6J9bPJkrVM61DaMZCiXFn57eW0ket4rXI9hXKGFb0jYt/3Zgu8NewvoIakXnnK0p6hCkt3y0Oua1GhoCx4MZsJozqPvy8VJ8bZb9z3R1gIYD7akKzmmPYCpfcoa7HHkqjN0M15/PCfd9gs2sw3rfbxoaAc2G0Wyl9LBCIg1nXeNsbNe+zRle/uBPKG29k79LXsH08qOdyUi+dftnETjPuYaggUfQXLK4kx5Bc6MdA1m8As67EU77B/5WXUDW7bNIpAf5ePFdyOQjWJt/yFWlUyhmV4R+TMKWuuRmzi1H9TKSSVUMRliOwGvctOCc9j71vymW1bxDb7V9BGUGk3aoxlW3SNpWvSEI6HnQx7ddswjCqCaLPaGhSmdxNWzULDNFYwh6hoYD7XE8AtsSVix1PILcbNGJU7/hMrjoYTj/Z3xt2Uf5zLJLkMUHN/Wd690RjnUb39CIUzO/ZBXc8jm49m0cd/OZpCiy53VfB7t6h683kKCLR5/cjer/ByqGIPzE71SOIJtOUCyrlmO0NWSWwfPfye68VDaWwaTNb8tHMfuccyhnV/D14usbVqUkLKnzCKY85aiaYY/mU9gxzqQSzBTKFEvlOtFAb14hrPN7LhyPoKo+GsdYdcq26pLF+v/Yu4EmbYt0woq0Ygg8OQJPaMg7mAZgttR8iHJfzIYBNYsJDQUgIowMhchM4MR2h4eSwZo4lg1rjudfcvvYtHZx099ZEZ/bO1s/+nJ4LbzvN47M8cSD3HLrLVx2r8XVhzyr9m1umCHQELTgEYSFhmYKJabzpcibyaBWb2ghF9ZssUShpGr6CAB2nnQpFPex59LfNUyoBt3BTgV4BPrYh3kD4J28VqrcZHhnTi/LpHgml59XD4GzVvGIzsUzVp2wJdAjsKR+JGU2nYi0qxiqm/5ssVQ35nVeHkGh1BGPud1EepRF5DUi8pCIbBGRjwS8/jci8oCI3CMiN4vImijX0wpLh5KhyeJJ92INE0drRmzOT0V8rpHURDoLKzfx26Wncm9iY12z0EJDQ/o9Ycli3W3dmaqhECnqFtEJ50yqdkj4TFGRF8fgNgo/OKGhoByBzxAE3Nn7qZwv+WJFXsJbyqvPl/ka2lTCrukjiGOIImlbdZ3aejqZP4yVSSc66xH4cwRJn/ZWE+wrlGr6IfYXIjvKImIDXwNOATYCZ4uIvzTjLmCTUupo4HrgkqjW0yojmVTD8tGRoVT9bF2XisZQg03Bj76TbEZqQtef+9GbkX9wPVSNQ6Owg2VJnV6//3uhevcbJVp0bN4JYxd/zb+3MipsvrOXhGVRKNd7BIsCcgQwl0dQNW7aqHo3fX2+tCNHMFOMZ4giaVvki/VVQ0Ed0Hq4nWu6AAAaHElEQVQmdJR4G8qqVUO+HEELTWVhv0vciTI0dCywRSk1DiAi1wKnAw/oNyilbvG8/3fA2yNcT0sMZ1K1A+w9TOYKrF0+VD9b16UqPNa8R6DF5y67ZQs/vPtxANYuy3DJGUfX3SlNhhgCLTwXdBeVqlQNNd5k/DLNNd/ri2tHSXXTbK2E9Po/bCM3W+TcF68FaofSQG1lVKpcGwIIItgjKNVVDen/j/VhulLUhrsqE+aG6g3B/D0CqfEI4mkI6kNDMyFrzabtwGlm7aSmoazorxqqlZ9oBtNQVs8hwFbP423uc2G8G/hp0AsicoGI3Ckid05MTLRxieEEDqdx2ekmTMPCF3pc5MFuMrkZLEt4719sYO3yDEnbYnK6wHV/2MbE1Gzdex/ftY8VS+qH2CRsiw+edBinPOegutc2rljMWzat5Pj19aWlXgZ9Ms013+vO1Q367nazxDVqu0NkPsL41m1/5vJbq/LUFUPgCvINuBf3jPcOsMEQESdZPHfV0IvWjXDGC1Zy/Ibw46vXkJstBmoKnfLsFZx97KpwkcI5SNm1DWX7W2jIz9uPW8M5L1pd93w78eYB9IY/4Oks1q81S1yP+1xE6REE1a0FmncReTuwCQicfK6Uuhy4HGDTpk3R3iK4jAyl2L2vQKmsajoblVJOR2gmVals8BuCnbk8CUsqaqDN8qGTD6/8fOufJnjnVb9nbHuuZnJZqawY35HjpYctD/yMv3nl4YHPD6ZsLjnjuXOuYSAV7hGMTUyRsi1WDtcLqrWbYY9+T7NoWY/pfMmJkadsj2S0zyPwGLtGoaGkr8pFKUUuH1A1lElx6ZmNj6+eSZCbLTI5XajTFFo1MsTfvenoZn7V0LV6JSZWxHBDSrQQGjr9eY3uG9u3HtsSt2qovrMYWgsNxTVJPxdRrngbsMrzeCXwhP9NInIy8HHgNKVU/e1vlwgTntOCc9qlD2p8mpx2kskLqeHWyWP/wJondu0jXyy3FHZqBUemOfgOaGwix9rlQ5G2/Gt0+CnMKwtCy3pAdSiQXzLaWxnl7yQNwt9HsK9Qoqyo8wiawRtK1IJz7cTfUBbHWHUqKDTU5VJXLS4X1FkMzYeGCqUyxbLaLz2CKA3BHcBhIrJORFLAW4EbvG8QkWOAb+AYge0RrqVlKtLCvjtSLTinNyrd+OR/z3xrwTU6Z+AfYbmlgd59O/DP9PUyPjHVcMhOO8mkbFJ2eC9HEN5jpZPuocnigqeTtGFoqLaz2O9htIK3uGBnLj9vTaEwtPdSLqvYxqqDQ0PdXauWm65WDdk1fzc7kyCO40GbJTJDoJQqAhcCPwc2A/+qlLpfRD4tIqe5b/sCkAWuE5G7ReSGkI/rODp2668cqiRM3cqZTIBHsLMNTVeWJaxfnq3zCMImYLWLsGRxoVTmsZ3TbDggmu/1IyIsHUqyK6SENwjvsdLHSSfys6na0JCTI3Au8EYliv7kpp6RkE23frFnPMli7TW2k5Qn8RnXWHXCFgq+0NBMvsRgF4e9a5XRyvkwT49gJoZT4Zol0oYypdSNwI2+5z7h+fnkKL9/IYQJz+30Vc5k03Z9aCiXb0voZv1ohnu21U7fGp+YYslgePfqQhlI2pWKFi+P7ZymWFYd8wjA8cpa8wimyKRslg6lKkbBrxTqldHw14sHkbBqG8qqfQmtXzrphEXCkoohaHd4T/8+BdcQDHRxcw0jaVvsLfj6brpstFK+0FC9IWguRxBH6e9mid+ZEhN0/NYfo570lf0FqWROTrdHj2f9aJatk9M1oZqxiSk2jGYi05AJCw2NbXc21ppBOxEz3KC7O4jxHTk2HJBlwwHZmtBQOmFVhsxU+wjqywWDSNhCISA0lG2xEAC8s5iLTObqJ8wtFF1zP50vxTZWnQqrGupiPqMSGiqWSdpSyYG1WjUUx6lwzWIMQQhhw2mqTVXVZLE3R+CMsVx4jgCc8I9S8Ogz05XnxidykeUHAAaTVmBoaNxNvrbSJLdQhjPJlqqG9CCg9curuk17Z4ss8mzatiWkbMtNFs9tCJK2Rans9Qhqk8+tkk0nmJwuMDVbbHtjnr6T1QUOcdyQwkJDXc0RJKs5Am8FmbfruBniOBWuWYwhCEELz/k3ol3TBWxLKpuLv2poz0yR0gIUJL3o0IFWJd07U2D73tlIN+PBZLBHMD4xxfJsmsUD0XcVa4aHUhWl17mYzhd5fNc+1o9m2TCaYTpf4qk9M4E1/7p7urnO4tqGMj1PYD7JYnDOl22TjmFvd2Oe9gh070UcY9VJu75Tu9uhobQ7pD5fKtXcFHh1iJpBV9vF8bjPhRGdCyFMeE4Lzlmu++ivGpr0eQwLQTcW6TDHfDqWW2UgJFk8NpGLLEEdhpb58PdyBKHLRTeMZit32uMTOccQ+OL5gymnaW62UEICxM68+EXn/J3KrZJJ2zy202nMa3eep+IRuHOR43hnmvIdT11y2f2qoZLrEVQNgeV6j00ni01oqDcJEp6b9KlDOlOnSpUpRpM+VcmFoAfWaAOgDUKUG/JA0ukj8E9lGm8wizcqhoeCezmC0GJ960czlXWOT0wFSkbryqjZonPhN8q3JOxaGWp/OWqrZNIJdrjd4mGzo+dLyjVou/ej0FAcJql5cwT+woF0wmo5RxDHJP1c7H8r7iBBwnNacE6jywh1yEAbgnZd5BtGs4y5d7vjEzlsS1g9EmFoKFWvuLgzl2dyutBxj6CSsG8iTzA+MYWI40UduDhNJmUzNpEL1AUaqDEEjTeghGXVhIZ0+ejQPDcur1GKzCPY56wxjh6Bv48gaHB9p6mWj5bq8kVO/qDJqiGTI+hNhgPKFydzhZqOUL84mvYg2nWRrx/NML59ypFP2DHF6pGhSOe4Bs0kGK94Ip33CKA5QzA2keOQpYMMuHLG60edyqGgHIGujAq68P0kLF8fwWyJTMquhAZbxbuWdjeUpWzn/057UI0a5bqFVwYDYCZfP5Sm0+jNXnuINa+5+YNmMOWjPUpYjsC7yftnEvgnTy2UysCaqVnGtucaqlu2g2BD0PmKIfB0dzfRVDY+MVVjqDa4E9/CQkMzbmfxXEY1KDQ0n9JRjXct7W4oS/pDQzHckJwGverxjMPmqfMAQedDKtF6jqCb3s18MYagAcNDSXa5wnPglob6cgTZdFVIDKqCc369+vmi6/a3PD3Fn5/JRV7HPxAgytZJsTkvzXoE5bJyy2qrhmr9aJbHd+1jlyvu5qUSGirV3wH6qUsW5+s9jFbQa/ELzrWDumRxDDeksNBQN4XaKuWjxVJdqFAnkpvBhIZ6lOFMCuVJVk7NFimWVY1L75eibofgnBed+Lz14R3ki+WOeQS1TWydE5vz0qzw3FN7ZthXKNUks7VRyJfK9aGhpK4aaiZH4CsfDfAwWkGvpd2Cc1BfPhrHDSnh6iHp2dxBg+s7jZMjCAsNteARFEskLIl8mE4U7H8r7iB+4Tm/4BzUh4baITjnZcXiAQaTNjc98BQQfWevrniY8eUIOp0fgOaF54L0l7zrDfIIZnRycI44esJ3BxtUjtoKurig3fkBqDbGxTlZrCubdHhophgHQ+CtGqrPETRdNRRTob9mMIagAToEpO9Id/oE56BWSEy/p53SAZYlrFueqZZHdjhHoMXmOp0fAKeXYzgzt/DcWEAye93yDNopq08WWzXlo43QMW19Bzs1W1pQaEj/23bnByCgoSymoSGgYlxnYhBOSSdsimXFvnxAaKiVqqEuy2kvBGMIGjBSiVEX3L/rE8H+ucVhYyQXgvYClg5FJzan8c70harYXDc8AnDyBHN7BFNk0wkOWJSuPDeQtDnEnRDnLx+thIaaLB8FKnkiJzQ0/4tdG4Io/h/3h4YyrfmkewnikCzWXsDemcLCQkP76VAaMIagIX7hOb/gHNQOG4H2Cc550V7A+uXRic1pvDN9oSo21+lmMk0zwnNjbqLYf2z0mgOrhopOZ/Gc5aNuKENXDk0FlKO2gl5Lu28WoFZryI5prLoSGipXB+hAdxPb+hzY6woU1r5mt6Q1FEfj2wzxO1NihD9HUBGc82z0g0kbS5w7xXYKznnRYZlObMb+ZHE3xOa8jGRSc1YNOQNz6tenn/Nv3OmkjVKwd6bYUIIaqiWZXkPQjmRxu88RqIZd9s4WY7shVTwCPUktJsliAKXqJcnTCaulPoK4Hve5MFpDDRhMOsJzV/7mz/zknid5es8Mtm8WsZYWnpottlVwzosOy3QiPKNP5K/88mGu+d1jPLl7H6OLOis252XpULKh8Nx0vsgTu2cCj40OqQV5BOD0fDQaSgPV0NCZX/8tCUvIF+urkFohG2GOQN/NKhVf4bOkLzQ0EwNZBq8XMFdn8b8/tJ0v3fQnfAosgHNDctQhSyJbZ5QYQ9AAEeH9J26oDIcZXZTmqIMX14UgtBR1OwXnvDzroEWcf8JaTj16RVs/N4ilQ0necdwaHt/lCKONLkrz0sOWR/69YWiZj3JZBXbzVpvd6g3Bq486kC1P7+XwAxfVPK/DELn83FVDLzt8lFdtPLDiEbxy44GcfOSB8/pdANYuG+JdJ6zjpCMPmPdnhOENBcU1Vp30hYae3D3D4oHEnAY5Srz9HP51+EXnfvTHJ3l4+xTHrV9W9zmji9Kc9tyDo1tohBhDMAcfOvnwOd+jPYJ2Cs55SdgWn3z9UW39zDBEhM+84dkd+a5mqAjPzRQC76J16CpohOYBiwb41On1v4vXfZ8rR3DoAVkuf+emVpcdSsK2+MTrN7bt87zYljNUpRTToTTg8Qjc0ND4hNMkGXXuqxE1HoG/fDRZWz46vmOK561aylXnvbBj6+sE8bxt2M/wG4J2J4v7marMRHCeYGy7Iza3dlnzOYyBGkMQzw1zvug77tgbAjc0NDYx1dHxp0GkG5wPurNYKaeEeGz7VNfyZVFiDEEbyKZtcrPFiiZOuydP9TNaxTUsYTy+I8fK4cGWYuLeCpW5PIL9DR3aiG+OoBoa0oOWgry5TtIwR5CwKCunWOCZXJ49M8WulVJHSW9dBV0i684tbrfgnGFu4bnxedxR1oSGYqjQuRBS7h1tfA2B9gjK1fxOtz2CRqEhPbe4WO56KXWU9NZV0CV0aKjdgnOGxsJzQWJzzeCtUOm10FBqfwkNlRxZdYh20FIz1MwpDugsBpgtlKql1BF393cDYwjaQDadIJcvtl1wztBYeE6LzbXqqreSLN7f0BUwcVQehWqDXqFcrg5aWtZZVVs/6WTj0BA44oVj26dIJ6xKx3ov0VtXQZfQc4t35vKRNAr1M42E5+Y7J2Gghw1BMuY5gpQnNDQ2McWq4cGue2W1OQJ/stgNDRXKjO/IsW55Zt5DieJMb10FXSKbTlAoKZ7aMxuJdEA/00h4TovNHdqqR+C5W45y2ls3qHgEMTUEVdE5J6wXh8Srd/MPGkwDbo5gYipy9d9u0VtXQZfIuBvLtp3TkYvC9SNhwnNabG7UIzbXDIM9XT6qQ0PxvLR1aGjGjbnHoRQzNUfVEDiCdFt3TrOhB/MDYAxBW9CSA8/4ppcZ2kOY8NzYRI4NAWJzczHQ01VD8fYIdGjo0WemyRfLMfEI5q4a+tPTU5RV9PNAukVvXQVdYpFHe8jkCNpPmPDc+MTUvEr5bEsqG2av5Qj07xPXHIH2WB56ai8Qj1LMhjkC1zA88KQjM9PtUteo6K2roEt4RchMjqD9DGfqhee02Nx8S/kGKoYgnhvmfIl7sliHhh58ag/QPVVbLyLhNwb68eYnHcO1LgbrjQJjCNqAMQTRMjxUFZ7TVMZTztNV1wnjXvMIdOglrqEhbage3TnNksEky2KSU0uHGgLnOD745B4OWjywIAnyONNbV0GX8J4cJlncfrzCc5qFzknQG2U35Y+jIBnzPgItMaEUgcOEuoXe8IPmEYCjVBsH7yUqeusq6BI1HoExBG0nSHhuPmJzXnTopNdCQ/uLRwCdma/RLKEeQTKe6203xhC0gWzK4xGY0FDbCRKem4/YnJeeDQ0lnDvs2OYIPM1YcbrDTictLKldH9TeKMRpve2mt66CLuEdjr7UVA21nZGKzIQnNDQxtaA7NH3H3HMNZXa8Q0MiUgkPxekOO2VbpBJWXajKe37Eab3tpreugi6RsC0GkpYRnIsInYDXTWUVsbkFlPL1bGioUj4a30tbh4e6LTbnJZ20A88Fr8doPIJ5IiKvEZGHRGSLiHwk4PW0iHzPff12EVkb5XqiJJtOMJwxgnNRMOITntNicwu5MHvVI0jGPEcAzhptS1g9Ep+NNZ2wAsOECUuwxDGsBy/pPbE5TWRXgYjYwNeAU4CNwNki4p/R925gUil1KPAl4PNRrSdqMumEGUgTEUM+4blK6egCXPWBpE3SdkY79hJx7ywGp3Jo9chQrIxwOmEFdpmLCOmEzbrl2Z4Um9NEGcc4FtiilBoHEJFrgdOBBzzvOR242P35euCrIiJKKcV+RiaVIDtgwkJRoIXnrv39Vn61eXuljHQhoYXBlNVzYSGoGgJ/GWScSNpW7DT904ng0BA4ieReDgtBtIbgEGCr5/E24EVh71FKFUVkN7AM2OF9k4hcAFwAsHr16qjWuyA+8PJDYyv01Qtc+PJD+e34M5XHq0cyLYvNeTnzBas44sBF7VharDjl2StQChbH+KbkQycfxpp5lv1GxbkvXhM6F/uiVx3BkSt671zxIlHdfIvImcCrlVLvcR+/AzhWKfXfPe+5333PNvfxmPueZ4I+E2DTpk3qzjvvjGTNBoPB0KuIyB+UUpuCXovyFnYbsMrzeCXwRNh7RCQBLAF2Rrgmg8FgMPiI0hDcARwmIutEJAW8FbjB954bgHPdn88AfrU/5gcMBoNhfyayQKIb878Q+DlgA1cppe4XkU8DdyqlbgCuBL4jIltwPIG3RrUeg8FgMAQTaUZJKXUjcKPvuU94fp4BzoxyDQaDwWBojClzMRgMhj7HGAKDwWDoc4whMBgMhj7HGAKDwWDocyJrKIsKEZkAHp3nP1+Or2u5zzHHoxZzPKqYY1FLLxyPNUqp0aAX9jtDsBBE5M6wzrp+xByPWszxqGKORS29fjxMaMhgMBj6HGMIDAaDoc/pN0NwebcXEDPM8ajFHI8q5ljU0tPHo69yBAaDwWCop988AoPBYDD4MIbAYDAY+py+MQQi8hoReUhEtojIR7q9nk4iIqtE5BYR2Swi94vIX7nPj4jITSLysPv3cLfX2klExBaRu0Tkx+7jdSJyu3s8vufKp/cFIrJURK4XkQfd8+T4fj0/ROSv3evkPhH5rogM9Pq50ReGQERs4GvAKcBG4GwR2djdVXWUIvBhpdSRwHHAB9zf/yPAzUqpw4Cb3cf9xF8Bmz2PPw98yT0ek8C7u7Kq7vAV4GdKqWcBz8U5Ln13fojIIcAHgU1KqWfjSOi/lR4/N/rCEADHAluUUuNKqTxwLXB6l9fUMZRSTyql/tP9eS/ORX4IzjH4tvu2bwNv6M4KO4+IrAReB1zhPhbgFcD17lv65niIyGLgZTjzQVBK5ZVSu+jf8yMBDLpTE4eAJ+nxc6NfDMEhwFbP423uc32HiKwFjgFuBw5USj0JjrEADujeyjrOl4H/CZTdx8uAXUqpovu4n86R9cAE8E03VHaFiGTow/NDKfU4cCnwGI4B2A38gR4/N/rFEEjAc31XNysiWeDfgA8ppfZ0ez3dQkROBbYrpf7gfTrgrf1yjiSA5wP/qJQ6BsjRB2GgINw8yOnAOuBgIIMTUvbTU+dGvxiCbcAqz+OVwBNdWktXEJEkjhH4Z6XU992nnxaRFe7rK4Dt3VpfhzkBOE1EHsEJE74Cx0NY6oYDoL/OkW3ANqXU7e7j63EMQz+eHycDf1ZKTSilCsD3gRfT4+dGvxiCO4DD3Mx/Cif5c0OX19Qx3Pj3lcBmpdT/9bx0A3Cu+/O5wA87vbZuoJT6qFJqpVJqLc658Cul1DnALcAZ7tv66Xg8BWwVkSPcp04CHqA/z4/HgONEZMi9bvSx6Olzo286i0XktTh3fTZwlVLqc11eUscQkZcA/x+4l2pM/GM4eYJ/BVbjXABnKqV2dmWRXUJETgQuUkqdKiLrcTyEEeAu4O1Kqdlurq9TiMjzcBLnKWAcOB/nRrHvzg8R+RRwFk613V3Ae3ByAj17bvSNITAYDAZDMP0SGjIYDAZDCMYQGAwGQ59jDIHBYDD0OcYQGAwGQ59jDIHBYDD0OcYQGPoeESmJyN2ePw27akXkvSLyzjZ87yMisnyhn2MwLBRTPmroe0RkSimV7cL3PoKjcrmj099tMHgxHoHBEIJ7x/55Efm9++dQ9/mLReQi9+cPisgDInKPiFzrPjciIj9wn/udiBztPr9MRH7hCrt9A4++kYi83f2Ou0XkG650usHQEYwhMBgcyWFvaOgsz2t7lFLHAl/F6Uz38xHgGKXU0cB73ec+BdzlPvcx4Gr3+U8Cv3GF3W7A6dhFRI7E6WQ9QSn1PKAEnNPeX9FgCCcx91sMhp5nn7sBB/Fdz99fCnj9HuCfReQHwA/c514CvBlAKfUr1xNYgqP5/yb3+Z+IyKT7/pOAFwB3OPI2DNIfAm+GmGAMgcHQGBXys+Z1OBv8acDfishRNJa0DvoMAb6tlProQhZqMMwXExoyGBpzlufv33pfEBELWKWUugVnyM1SIAvcihvacUXtdrjzH7zPnwLoGcA3A2eIyAHuayMisibC38lgqMF4BAaDmyPwPP6ZUkqXkKZF5Hacm6azff/OBq5xwz6CM9N2l4hcjDPt6x5gmqqU86eA74rIfwK/xlH0RCn1gIj8b+AXrnEpAB8AHm33L2owBGHKRw2GEEx5p6FfMKEhg8Fg6HOMR2AwGAx9jvEIDAaDoc8xhsBgMBj6HGMIDAaDoc8xhsBgMBj6HGMIDAaDoc/5L0hj1Q8qi6dBAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Q(s,a) std: 0.000;0.000;0.000;0.027;0.013;0.000;0.000;0.000;0.000;0.002\n", - "correct 0\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "bnn_agent = BNNAgent(state_size=state_size, n_actions=n_actions)\n", "greedy_agent_rewards = train_contextual_agent(\n", @@ -1189,13 +759,8 @@ }, { "cell_type": "code", - "execution_count": 33, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-03T23:00:36.949294Z", - "start_time": "2019-04-03T23:00:36.945467Z" - } - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ "class ThompsonBNNAgent(BNNAgent):\n", @@ -1205,59 +770,55 @@ " This is exactly thompson sampling.\n", " \"\"\"\n", "\n", - " reward_samples = self.sample_prediction(states, n_samples=1)\n", - " best_actions = reward_samples.squeeze(axis=0).argmax(axis=-1)\n", - " return best_actions" + " # YOUR CODE HERE" ] }, { "cell_type": "code", - "execution_count": 34, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-03T23:04:11.672929Z", - "start_time": "2019-04-03T23:00:36.951886Z" - } - }, + "execution_count": null, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "iteration #90\tmean reward=0.740\tmse=0.090\tkl=-27.795\n" + "iteration #90\tmean reward=0.360\tmse=0.590\tkl=0.038\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ - "Q(s,a) std: 0.000;0.002;0.001;0.000;0.000;0.000;0.006;0.001;0.003;0.000\n", - "correct 1\n" + "Q(s,a) std: 0.000;0.028;0.277;0.000;0.044;0.059;0.063;0.093;0.000;0.018\n", + "correct 2\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.5/dist-packages/ipykernel_launcher.py:32: FutureWarning: pd.ewm_mean is deprecated for ndarrays and will be removed in a future version\n" + ] } ], "source": [ @@ -1267,13 +828,8 @@ }, { "cell_type": "code", - "execution_count": 35, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-03T23:04:11.677959Z", - "start_time": "2019-04-03T23:04:11.674863Z" - } - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ "class BayesUCBBNNAgent(BNNAgent):\n", @@ -1287,60 +843,55 @@ " This implements bayesian UCB strategy\n", " \"\"\"\n", "\n", - " reward_samples = self.sample_prediction(states, n_samples=100)\n", - " best_actions = np.percentile(reward_samples, self.q, axis=0).argmax(axis=-1)\n", - "\n", - " return best_actions" + " # YOUR CODE HERE" ] }, { "cell_type": "code", - "execution_count": 36, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-03T23:09:17.506026Z", - "start_time": "2019-04-03T23:04:11.679581Z" - } - }, + "execution_count": null, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "iteration #90\tmean reward=0.710\tmse=0.009\tkl=-26.576\n" + "iteration #90\tmean reward=0.630\tmse=0.354\tkl=0.047\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ - "Q(s,a) std: 0.000;0.015;0.000;0.008;0.000;0.002;0.002;0.002;0.015;0.019\n", - "correct 8\n" + "Q(s,a) std: 0.067;0.027;0.093;0.069;0.014;0.148;0.173;0.026;0.043;0.101\n", + "correct 5\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.5/dist-packages/ipykernel_launcher.py:32: FutureWarning: pd.ewm_mean is deprecated for ndarrays and will be removed in a future version\n" + ] } ], "source": [ @@ -1350,24 +901,17 @@ }, { "cell_type": "code", - "execution_count": 37, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-03T23:09:17.964523Z", - "start_time": "2019-04-03T23:09:17.509546Z" - } - }, + "execution_count": null, + "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -1387,13 +931,6 @@ "plt.show()" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "> UCB and Thompson sampling work better than Greedy, but the two of them show similar performance." - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -1421,13 +958,8 @@ }, { "cell_type": "code", - "execution_count": 32, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-03T23:09:17.977179Z", - "start_time": "2019-04-03T23:09:17.966324Z" - } - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ "class RiverSwimEnv:\n", @@ -1511,13 +1043,8 @@ }, { "cell_type": "code", - "execution_count": 33, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-03T23:09:17.988800Z", - "start_time": "2019-04-03T23:09:17.979066Z" - } - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ "class QLearningAgent:\n", @@ -1545,24 +1072,14 @@ " pass\n", "\n", " def update(self, state, action, reward, next_state):\n", - " next_value = \\\n", - " (1 - self._epsilon) * self._q_matrix[next_state, :].max() + \\\n", - " self._epsilon * self._q_matrix[next_state, :].mean()\n", - " \n", - " self._q_matrix[state, action] = \\\n", - " (1 - self._lr) * self._q_matrix[state, action] + \\\n", - " self._lr * (reward + self._gamma * next_value)" + " # YOUR CODE HERE\n", + " # Finish implementation of q-learnig agent" ] }, { "cell_type": "code", - "execution_count": 34, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-03T23:09:18.001578Z", - "start_time": "2019-04-03T23:09:17.991247Z" - } - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ "def train_mdp_agent(agent, env, n_episodes):\n", @@ -1586,20 +1103,22 @@ }, { "cell_type": "code", - "execution_count": 35, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-03T23:09:19.218252Z", - "start_time": "2019-04-03T23:09:18.003126Z" - }, - "scrolled": false - }, + "execution_count": null, + "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.5/dist-packages/ipykernel_launcher.py:6: FutureWarning: pd.ewm_mean is deprecated for ndarrays and will be removed in a future version\n", + " \n" + ] + }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "" ] }, "metadata": {}, @@ -1627,13 +1146,8 @@ }, { "cell_type": "code", - "execution_count": 36, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-03T23:09:19.224687Z", - "start_time": "2019-04-03T23:09:19.220203Z" - } - }, + "execution_count": null, + "metadata": {}, "outputs": [], "source": [ "def plot_policy(agent):\n", @@ -1649,19 +1163,14 @@ }, { "cell_type": "code", - "execution_count": 37, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-03T23:09:19.555096Z", - "start_time": "2019-04-03T23:09:19.227460Z" - } - }, + "execution_count": null, + "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "" ] }, "metadata": {}, @@ -1679,13 +1188,6 @@ "As your see, agent uses suboptimal policy of going left and does not explore the right state." ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "> Life is hard and sad." - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -1727,12 +1229,7 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-02T20:29:57.407894Z", - "start_time": "2019-04-02T20:29:48.154Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "def sample_normal_gamma(mu, lmbd, alpha, beta):\n", @@ -1797,15 +1294,32 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-02T20:29:57.409097Z", - "start_time": "2019-04-02T20:29:48.158Z" + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.5/dist-packages/ipykernel_launcher.py:7: FutureWarning: pd.ewm_mean is deprecated for ndarrays and will be removed in a future version\n", + " import sys\n" + ] }, - "scrolled": false - }, - "outputs": [], + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ + "from pandas import DataFrame\n", + "moving_average = lambda x, **kw: DataFrame(\n", + " {'x': np.asarray(x)}).x.ewm(**kw).mean().values\n", + "\n", "horizon = 20\n", "env = RiverSwimEnv(max_steps=horizon)\n", "agent = PsrlAgent(env.n_states, env.n_actions, horizon=horizon)\n", @@ -1822,13 +1336,19 @@ { "cell_type": "code", "execution_count": null, - "metadata": { - "ExecuteTime": { - "end_time": "2019-04-02T20:29:57.410286Z", - "start_time": "2019-04-02T20:29:48.160Z" + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" } - }, - "outputs": [], + ], "source": [ "plot_policy(agent)" ] @@ -1860,61 +1380,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.7" - }, - "nbdime-conflicts": { - "local_diff": [ - { - "diff": [ - { - "diff": [ - { - "key": 0, - "op": "addrange", - "valuelist": [ - "2.7.15" - ] - }, - { - "key": 0, - "length": 1, - "op": "removerange" - } - ], - "key": "version", - "op": "patch" - } - ], - "key": "language_info", - "op": "patch" - } - ], - "remote_diff": [ - { - "diff": [ - { - "diff": [ - { - "key": 0, - "op": "addrange", - "valuelist": [ - "3.7.2" - ] - }, - { - "key": 0, - "length": 1, - "op": "removerange" - } - ], - "key": "version", - "op": "patch" - } - ], - "key": "language_info", - "op": "patch" - } - ] + "version": "3.7.6" } }, "nbformat": 4,