diff --git a/.gitignore b/.gitignore index 66a5d065..3616d5a1 100644 --- a/.gitignore +++ b/.gitignore @@ -2,3 +2,5 @@ data/ *.DS_Store *~ +*.svg +*.png diff --git a/hw1/cs285/infrastructure/pytorch_util.py b/hw1/cs285/infrastructure/pytorch_util.py index bc7a4081..d7cf79fa 100644 --- a/hw1/cs285/infrastructure/pytorch_util.py +++ b/hw1/cs285/infrastructure/pytorch_util.py @@ -47,8 +47,33 @@ def build_mlp( # TODO: return a MLP. This should be an instance of nn.Module # Note: nn.Sequential is an instance of nn.Module. - raise NotImplementedError + # raise NotImplementedError + # build the sequential model + model = nn.Sequential() + + # 1. add input layer + model.add_module('input', nn.Linear(input_size, size)) + + # 2. add hidden layers + for n in range(n_layers): + model.add_module('hidden'+str(n), nn.Linear(size, size)) + model.add_module('activation'+str(n), activation) + + # 3. add output layer + model.add_module('output', nn.Linear(size, output_size)) + model.add_module('out activation', output_activation) + + # 4. assert nn.Sequential model is a nn.Module + assert(isinstance(model, nn.Module)) + + return model + + ''' + Another method is to use list = [('name', nn.Linear()), (), ()] , then nn.Sequential(collections.OrderedDict(list)) + Or list = [nn.Linear(), xx ,xx] and nn.Sequential(list) + + ''' device = None diff --git a/hw1/cs285/infrastructure/replay_buffer.py b/hw1/cs285/infrastructure/replay_buffer.py index 60148e79..fde1f4eb 100644 --- a/hw1/cs285/infrastructure/replay_buffer.py +++ b/hw1/cs285/infrastructure/replay_buffer.py @@ -77,8 +77,19 @@ def sample_random_data(self, batch_size): ## HINT 2: return corresponding data points from each array (i.e., not different indices from each array) ## HINT 3: look at the sample_recent_data function below - return TODO, TODO, TODO, TODO, TODO - + random_indices = np.random.permutation(self.obs.shape[0]) + self.obs = self.obs[random_indices] + self.acs = self.acs[random_indices] + self.rews = self.rews[random_indices] + self.next_obs = self.next_obs[random_indices] + self.terminals = self.terminals[random_indices] + return self.sample_recent_data(batch_size) + + # idx = np.random.permutation(self.obs.shape[0])[:batch_size] + # return self.obs[idx], self.acs[idx], self.rews[idx], self.next_obs[idx], self.terminals[idx] + + + def sample_recent_data(self, batch_size=1): return ( self.obs[-batch_size:], diff --git a/hw1/cs285/infrastructure/rl_trainer.py b/hw1/cs285/infrastructure/rl_trainer.py index bb27972e..d1171fe6 100644 --- a/hw1/cs285/infrastructure/rl_trainer.py +++ b/hw1/cs285/infrastructure/rl_trainer.py @@ -8,6 +8,7 @@ from cs285.infrastructure import pytorch_util as ptu from cs285.infrastructure.logger import Logger from cs285.infrastructure import utils +import pickle # how many rollouts to save as videos to tensorboard MAX_NVIDEO = 2 @@ -87,6 +88,8 @@ def run_training_loop(self, n_iter, collect_policy, eval_policy, self.total_envsteps = 0 self.start_time = time.time() + mean_list = [] + std_list = [] for itr in range(n_iter): print("\n\n********** Iteration %i ************"%itr) @@ -127,13 +130,21 @@ def run_training_loop(self, n_iter, collect_policy, eval_policy, # perform logging print('\nBeginning logging procedure...') - self.perform_logging( + mean, std = self.perform_logging( itr, paths, eval_policy, train_video_paths, training_logs) + mean_list.append(mean) + std_list.append(std) + if self.params['save_params']: print('\nSaving agent params') self.agent.save('{}/policy_itr_{}.pt'.format(self.params['logdir'], itr)) + print('mean : ', np.round(mean_list)) + print('std : ', np.round(std_list)) + + # self.perform_expert(expert_policy) + #################################### #################################### @@ -162,11 +173,16 @@ def collect_training_trajectories( # (2) collect `self.params['batch_size']` transitions + if itr == 0: + with open(load_initial_expertdata, 'rb') as f: + loaded_paths = pickle.load(f) + return loaded_paths, 0, None + # TODO collect `batch_size` samples to be used for training # HINT1: use sample_trajectories from utils # HINT2: you want each of these collected rollouts to be of length self.params['ep_len'] print("\nCollecting data to be used for training...") - paths, envsteps_this_batch = TODO + paths, envsteps_this_batch = utils.sample_trajectories(self.env, collect_policy, batch_size, self.params['ep_len']) # collect more rollouts with the same policy, to be saved as videos in tensorboard # note: here, we collect MAX_NVIDEO rollouts, each of length MAX_VIDEO_LEN @@ -187,12 +203,12 @@ def train_agent(self): # TODO sample some data from the data buffer # HINT1: use the agent's sample function # HINT2: how much data = self.params['train_batch_size'] - ob_batch, ac_batch, re_batch, next_ob_batch, terminal_batch = TODO + ob_batch, ac_batch, re_batch, next_ob_batch, terminal_batch = self.agent.sample(self.params['train_batch_size']) # TODO use the sampled data to train an agent # HINT: use the agent's train function # HINT: keep the agent's training log for debugging - train_log = TODO + train_log = self.agent.train(ob_batch, ac_batch, re_batch, next_ob_batch, terminal_batch) all_logs.append(train_log) return all_logs @@ -202,6 +218,8 @@ def do_relabel_with_expert(self, expert_policy, paths): # TODO relabel collected obsevations (from our policy) with labels from an expert policy # HINT: query the policy (using the get_action function) with paths[i]["observation"] # and replace paths[i]["action"] with these expert labels + for path in paths: + path["action"] = expert_policy.get_action(path["observation"]) return paths @@ -267,3 +285,16 @@ def perform_logging(self, itr, paths, eval_policy, train_video_paths, training_l print('Done logging...\n\n') self.logger.flush() + + return np.mean(eval_returns), np.std(eval_returns) + + def perform_expert(self, expert_policy): + print("\nCollecting data for EXPERT !! eval...") + eval_paths, eval_envsteps_this_batch = utils.sample_trajectories(self.env, expert_policy, self.params['eval_batch_size'], self.params['ep_len']) + eval_returns = [eval_path["reward"].sum() for eval_path in eval_paths] + mean_exp = np.mean(eval_returns) + std_exp = np.std(eval_returns) + mean_exp_max = np.max(eval_returns) + mean_exp_min = np.min(eval_returns) + + print('mean exp: {}, std exp: {}, mean max: {}, mean min: {}'.format(np.round(mean_exp), np.round(std_exp), np.round(mean_exp_max), np.round(mean_exp_min) )) diff --git a/hw1/cs285/infrastructure/utils.py b/hw1/cs285/infrastructure/utils.py index d894480b..d26e2889 100644 --- a/hw1/cs285/infrastructure/utils.py +++ b/hw1/cs285/infrastructure/utils.py @@ -7,7 +7,7 @@ def sample_trajectory(env, policy, max_path_length, render=False, render_mode=('rgb_array')): # initialize env for the beginning of a new rollout - ob = TODO # HINT: should be the output of resetting the env + ob = env.reset() # HINT: should be the output of resetting the env # init vars obs, acs, rewards, next_obs, terminals, image_obs = [], [], [], [], [], [] @@ -27,7 +27,7 @@ def sample_trajectory(env, policy, max_path_length, render=False, render_mode=(' # use the most recent ob to decide what to do obs.append(ob) - ac = TODO # HINT: query the policy's get_action function + ac = policy.get_action(ob) #TODO # HINT: query the policy's get_action function ac = ac[0] acs.append(ac) @@ -41,7 +41,7 @@ def sample_trajectory(env, policy, max_path_length, render=False, render_mode=(' # TODO end the rollout if the rollout ended # HINT: rollout can end due to done, or due to max_path_length - rollout_done = TODO # HINT: this is either 0 or 1 + rollout_done = done or (steps >= max_path_length) # HINT: this is either 0 or 1 terminals.append(rollout_done) if rollout_done: @@ -60,8 +60,9 @@ def sample_trajectories(env, policy, min_timesteps_per_batch, max_path_length, r timesteps_this_batch = 0 paths = [] while timesteps_this_batch < min_timesteps_per_batch: - - TODO + path = sample_trajectory(env, policy, max_path_length, render, render_mode) + paths.append(path) + timesteps_this_batch += get_pathlength(path) return paths, timesteps_this_batch @@ -74,7 +75,10 @@ def sample_n_trajectories(env, policy, ntraj, max_path_length, render=False, ren """ paths = [] - TODO + # TODO + for n in range(ntraj): + path = sample_trajectory(env, policy, max_path_length, render, render_mode) + paths.append(path) return paths diff --git a/hw1/cs285/policies/MLP_policy.py b/hw1/cs285/policies/MLP_policy.py index c8e1fd7d..687b55b7 100644 --- a/hw1/cs285/policies/MLP_policy.py +++ b/hw1/cs285/policies/MLP_policy.py @@ -81,7 +81,9 @@ def get_action(self, obs: np.ndarray) -> np.ndarray: observation = obs[None] # TODO return the action that the policy prescribes - raise NotImplementedError + # raise NotImplementedError + action = self.forward(ptu.from_numpy(observation)) + return ptu.to_numpy(action) # update/train this policy def update(self, observations, actions, **kwargs): @@ -93,7 +95,21 @@ def update(self, observations, actions, **kwargs): # return more flexible objects, such as a # `torch.distributions.Distribution` object. It's up to you! def forward(self, observation: torch.FloatTensor) -> Any: - raise NotImplementedError + # raise NotImplementedError + if self.discrete: + action = self.logits_na(observation) + else: + action = self.mean_net(observation) + return action + + ''' + if self.discrete: + return distributions.Categorical(logits=self.logits_na(observation)) + else: + return distributions.Normal(self.mean_net(observation), torch.exp(self.logstd)[None]) + + loss = -action_distribution.log_prob(actions).mean() + ''' ##################################################### @@ -109,7 +125,21 @@ def update( adv_n=None, acs_labels_na=None, qvals=None ): # TODO: update the policy and return the loss - loss = TODO + # question, why not run many iterations? + + # convert inputs as torch.tensor, and predict actions + actions = ptu.from_numpy(actions) + predicted_actions = self.forward(ptu.from_numpy(observations)) + # predicted_actions = self.get_action(ptu.from_numpy(observations)) + + # get loss and train + loss = self.loss(actions, predicted_actions) + + # get gradient and backpropagation + self.optimizer.zero_grad() + loss.backward() + self.optimizer.step() + return { # You can add extra logging information here, but keep this line 'Training Loss': ptu.to_numpy(loss), diff --git a/hw1/cs285/report_plots.py b/hw1/cs285/report_plots.py new file mode 100644 index 00000000..acee3126 --- /dev/null +++ b/hw1/cs285/report_plots.py @@ -0,0 +1,106 @@ +import matplotlib.pyplot as plt +import seaborn as sns + +import numpy as np +import pandas as pd +import os + + +def plot_mean_std(ax, iterations, mean, std, mean_expert, mean_bc): + mean = np.array(mean) + std = np.array(std) + + ax.plot(iterations, mean_expert, 'r', label='expert') + ax.plot(iterations, mean_bc, 'g', label='naive bc') + ax.plot(iterations, mean, 'b-s', label='DAgger mean') + ax.fill_between(iterations, mean-std, mean+std, alpha=0.2, label='DAgger std') + + +def set_plot_env(iterations, mean, std, mean_expert, mean_bc, exp_name): + + plt.figure(figsize=(10,5)) + style = "whitegrid" + sns.set_theme(style=style) # background color + ax = plt.gca() + plot_mean_std(ax, iterations, mean, std, mean_expert, mean_bc) + + ax.legend(loc='center right') + ax.set_xlabel('Iterations') + ax.set_ylabel('Return') + ax.set_title('return of ' + exp_name +' experiment') + ax.set_xlim([-0.5,10]) + + exp_dir = 'plots/' + if not os.path.exists(exp_dir): + os.makedirs(exp_dir) + plt.savefig(fname=exp_dir + 'figure-2_' + exp_name + '.png', format='png') + +def plot_DAgger(mean, std, mean_expert, exp_name): + iterations = np.arange(len(mean)) + I = np.ones(len(mean)) + mean_bc = mean[0] * I + mean_expert = mean_expert * I + set_plot_env(iterations, mean, std, mean_expert, mean_bc, exp_name) + +def plot_changing_ep(ep_len, mean_len, std_len): + plt.figure(figsize=(10,5)) + style = "whitegrid" + sns.set_theme(style=style) # background color + ax = plt.gca() + + mean_len = np.array(mean_len) + std_len = np.array(std_len) + I = np.ones(len(mean_len)) + mean_expert = Ant_exp.mean_expert * I + + ax.plot(ep_len, mean_expert, 'r', label='expert') + plt.plot(ep_len, mean_len, 'b-s', label='bc mean') + plt.fill_between(ep_len, mean_len-std_len, mean_len+std_len, alpha=0.2, label='bc std') + ax.legend(loc='upper left') + ax.set_xlabel('num of traning steps') + ax.set_ylabel('Return') + ax.set_title('return of ' + 'Ant experiments with varying traning steps') + + exp_dir = 'plots/' + if not os.path.exists(exp_dir): + os.makedirs(exp_dir) + plt.savefig(fname=exp_dir + 'figure-1_varying_train_step' + '.png', format='png') + + +class Ant_exp: + mean = [4274., 4648., 4746., 4619., 4447., 4356., 4731., 4739., 4581., 4834.] + std = [1128., 53., 85., 103., 854., 1030., 124., 135., 336., 109.] + mean_expert = 4710 + + ep_len = [100, 300, 500, 700, 990, 1100, 1400, 1500, 1700] + mean_len = [567, 1505, 3849, 3296, 3774, 3570, 2227, 4236, 4249] + std_len = [7, 1250, 1299, 1604, 1363, 1392, 1740, 1151, 901] + +class Hooper_exp: + mean = [ 523., 1700., 2453., 3763., 3778., 3790., 3388., 3771., 3537., 3788.] + std = [ 75., 607., 725., 4., 3., 4., 671., 3., 160., 3.] + mean_expert = 3779 + + +if __name__ == "__main__": + + # figure 1 + exp = Ant_exp + mean_len = exp.mean_len + std_len = exp.std_len + ep_len = exp.ep_len + plot_changing_ep(ep_len, mean_len, std_len) + + # figure 2-1 + exp = Ant_exp + mean = exp.mean + std = exp.std + mean_expert = exp.mean_expert + plot_DAgger(mean, std, mean_expert, 'Ant') + + # figure 2-2 + exp = Hooper_exp + mean = exp.mean + std = exp.std + mean_expert = exp.mean_expert + plot_DAgger(mean, std, mean_expert, 'Hooper') \ No newline at end of file diff --git a/hw1/repot_plots.ipynb b/hw1/repot_plots.ipynb new file mode 100644 index 00000000..aecced82 --- /dev/null +++ b/hw1/repot_plots.ipynb @@ -0,0 +1,68 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "variable-diary", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnkAAAFSCAYAAACOisnJAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAABtx0lEQVR4nO39d3xUddr4/7/O9Jn0TugQigGUHkRpBhULEoqIsrq7rr2vLq6sBbhRuL9R78XbW1mWXXU/68+yIkgEUVCD2BEQaQm9Q0hITyaTqef3R8hIIL1MSa7n4+FDMu8557yTk8lc8y7XpaiqqiKEEEIIIdoVjb87IIQQQgghWp8EeUIIIYQQ7ZAEeUIIIYQQ7ZAEeUIIIYQQ7ZAEeUIIIYQQ7ZAEeUIIIYQQ7ZAEeUKIoHT48GGmTp3K0KFD+fe//+3v7rRLp0+fZujQobjdbn93RQjRDBLkCSEa5Y477mDFihX+7obXP//5T1JSUti+fTu//e1vL2qvrb+bN29m3Lhxvupi0OvcuTPbt29Hq9X6/Nr9+/fn2LFjPr+uEO2JBHlCCFwuV9Bd4/Tp0/Tt27dVz+kPvvjZN0eg9ksI0XgS5AnRQaWmprJ8+XJuuukmhgwZgsvl4pdffuHWW29lxIgRTJkyhc2bNwOwZMkStm7dysKFCxk6dCgLFy7k5MmT9O/fv0YwcP7o2apVq7j11ltZvHgxKSkp/N///R9z587lv/7rv7j33nsZOnQoM2fO5Pjx43X28csvv+TGG29kxIgR3HHHHRw6dAiA3/72t2zevNnbnyNHjjTrZ5Cbm8v9999PSkoK11xzDR988IG3zeFwsGjRIsaMGcOYMWNYtGgRDocD+HVEcNmyZYwaNYrU1FQ+/vjjGsemp6czYcIErrjiCubNm0dlZWWNY5cvX86VV17JX/7yl1r79uGHH3L99dczcuRI7rrrLk6dOgXA8uXLueWWW7w/93fffZcbb7wRu93uvSf/+c9/vP1+8803vef0eDwsX76cq6++mlGjRvHYY49RXFwM4D12xYoVTJgwgd/97ncX3eM77riDJUuWcOuttzJ06FDuv/9+ioqK+NOf/sSwYcOYMWMGJ0+e9F7v0KFD3HnnnaSkpDBp0iTWrVvnbavvd+E3v/kNAGlpaQwdOrTGcUKIJlCFEB3SVVddpU6ZMkU9ffq0arPZ1DNnzqgpKSnqV199pbrdbvXbb79VU1JS1IKCAlVVVfX2229XP/jgA+/xJ06cUPv166c6nU7vY+c/Z+XKlWpycrL673//W3U6narNZlOfeuopdeTIkeqOHTtUp9OpPvHEE+of//jHWvt3+PBhdfDgweq3336rOhwOdfny5erVV1+t2u32Wvtzodraf/zxR3Xs2LHer3/zm9+o8+fPVysrK9WsrCx11KhR6vfff6+qqqq+8sor6syZM9X8/Hy1oKBAnTVrlrpkyRLveZKTk9XFixerdrtd3bx5szp48GD10KFDqqqq6gsvvKDed999alFRkVpWVqbed9996ssvv1zj2BdffFG12+2qzWa7qO+ff/65evXVV6sHDx5UnU6n+vrrr6uzZs1SVVVV3W63Onv2bPXVV19Vjxw5oo4YMULds2dPjXvy+OOPq1arVd27d686atQo9bvvvlNVVVXfeustdebMmWpOTo5qt9vV5557Tn388cdrHPvkk0+qVqtVtdlsF93j22+/Xb366qvVY8eOqaWlper111+vXnvttep3332nOp1O9cknn1Tnzp2rqqqqWq1Wddy4ceqHH36oOp1Odffu3WpKSoq6f/9+VVXVBn8X+vXrpx49erTO+yuEaJiM5AnRgd1xxx0kJiZiMpnIyMhg3LhxjB8/Ho1Gw5VXXsmgQYPYtGlTs88fHx/PHXfcgU6nw2QyAXDNNddw2WWXodPpmDJlCtnZ2bUeu27dOsaPH8+VV16JXq/nrrvuorKyku3btzf6+i+88AIjRozw/nf//fd723Jycti2bRtz5szBaDSSnJzMzJkzycjIAGDNmjU89NBDxMTEEB0dzUMPPVRjtA7gsccew2AwkJKSwvjx4/n0009RVZUVK1bw9NNPExkZSWhoKPfddx+ffPKJ9ziNRsOjjz6KwWDw/lzO9/7773PvvfeSlJSETqfj/vvvJzs7m1OnTqHRaEhPT+ftt9/mgQce4O6772bAgAE1jn/ooYewWCz079+f6dOns3btWgD+85//8Pjjj9OpUycMBgMPP/ww69evrzEa+8gjj2CxWGrtF8D06dPp3r07YWFhjBs3jm7dunHFFVeg0+m47rrryMrKAuCrr76iS5cuzJgxA51Ox8CBA5k0aRLr16/3nquxvwtCiObR+bsDQgj/SUxM9P779OnTfPbZZ2zcuNH7mMvlYtSoUc0+f6dOnS56LDY21vtvk8lERUVFrcfm5eXRuXNn79cajYbExERyc3Mbff1nn32WmTNner/evHkzTz75pPf8ERERhIaGets7d+7M7t27a71+586dycvL834dHh6OxWK5qL2wsBCbzcb06dO9baqq4vF4vF9HRUVhNBrr7Pfp06dZvHgx6enpNc6Rm5tLly5d6Nq1K6NGjWLTpk3eqc3znX9fu3Tpwv79+73nfeihh9Bofv18r9FoKCgo8H5d2z073/n3z2g01nk/T506xc6dOxkxYoS33e12M2XKlFrPVd/vghCieSTIE6IDUxTF++/ExETS0tJ44YUXGnVsdYBTWVnpDZTOnj1b5/mbKj4+3hucQFWQk5OTQ0JCQrPPeeH5S0pKKC8v9/b//PPHx8fX2NyRk5NDfHy89/jS0lIqKiq8P4ecnBz69u1LVFQUJpOJTz75pM6+NvRzSUxM5P77768REJ1v06ZNbN++ndGjR/Piiy+ycOHCGu05OTkkJSUBVYFddb87derE4sWLGT58+EXnrF5L15J7duH3MHLkSN56661WOZ8QoulkulYIAcCUKVPYuHEj33zzDW63G7vdzubNmzlz5gxQNepy4sQJ7/Ojo6NJSEggIyMDt9vNhx9+WKO9pa6//no2bdrEDz/8gNPp5M0338RgMDB06NBWOX9iYiJDhw7lr3/9K3a7nb179/Lhhx9y0003AXDjjTfyt7/9jcLCQgoLC3n99de9bdX+7//+D4fDwdatW/nqq6+47rrr0Gg0zJw5k8WLF3tHyHJzc/nmm28a3bdbb72V5cuXc+DAAQDKysr49NNPASgsLOSZZ55h0aJF/H//3/9HZmbmRVPqS5cuxWazceDAAVatWsUNN9wAwG233cYrr7zi3cRRWFjIF1980YyfXsMmTJjA0aNHWb16NU6nE6fTyc6dO72bZxpy4e+bEKLpJMgTQgBVQc/SpUv5+9//zujRoxk/fjxvvPGGd5rxt7/9LevXr2fkyJHe0b7nn3+eN954g1GjRnHw4MFWC8AAevfuzUsvvcTzzz/P5ZdfzsaNG1m2bBkGg6HVrvHXv/6VU6dOMXbsWB5++GEeeeQRrrzySgAefPBBBg0axJQpU5gyZQoDBw7kwQcf9B4bGxtLeHg4Y8eOZc6cOSxYsMA7evbkk0/So0cPbrnlFoYNG8bvf//7Ju0Avuaaa7j77rt54oknGDZsGJMnT+brr78GYN68eaSmpjJ+/HiioqJYtGgRzzzzDEVFRd7jq3cL//73v+cPf/gDY8aMAaruYWpqKn/4wx8YOnQot9xyCzt37mzxz7E2oaGhvPHGG6xbt46xY8cyZswYXn75Ze8O5YY8/PDDzJ07lxEjRsjuWiGaSVFVVfV3J4QQIphUr+2rDrwCxcmTJ5k4cSJ79uxBp5PVOEJ0dDKSJ4QQQgjRDkmQJ4QQQgjRDsl0rRBCCCFEOyQjeUIIIYQQ7VCHXJnr8XiwWq3o9fpWywklhBBCCNEWVFXF6XQSEhJSI5l5QzpkkGe1WmskWRVCCCGECHT9+vUjLCys0c/vkEGeXq8Hqn5YrZlzqza7d+9m0KBBbXoN0TrkXgUHuU/BQe5TcJD7FBwcDgf79+/3xi+N1SGDvOopWoPBUG/9yNbii2uI1iH3KjjIfQoOcp+Cg9yn4NHUJWay8UIIIYQQoh2SIE8IIYQQoh2SIE8IIYQQoh2SIE8IIYQQoh2SIE8IIYQQoh2SIE8IIYQQoh2SIE8IIYQQoh2SIE8IIYQQoh2SIE8IIYQQoh2SIE8IIUSrUVUVm92JWzFQYXOiqqq/uyREh+XzIO+1116jf//+7N+/H4AjR44wa9YsJk2axKxZszh69Kj3uc1tE0II4VuVDheFpTZO5pVx+qyV3IJycgqsHM8to7DURqXD5e8uCtHh+DTI27NnD7/88gudO3f2PjZ//nxmz57N+vXrmT17NvPmzWtxmxBCiLZnd7goKqusCuzyyikssWN3eKgevFNVcDo9FJbYOZ1n5VReGSXldpwuj387LkQH4bMgz+FwsHDhQubPn+8tsFtQUEBWVhaTJ08GYPLkyWRlZVFYWNjsNiGEEG3H7nBRXFbJqbwyTuVZKSiupNLuxtPArKxHVbHZ3ZwtsnEit4wzBVbKKhy4GzpQCNFsOl9d6H//93+ZMmUK3bp18z6Wk5NDQkICWq0WAK1WS3x8PDk5Oaiq2qy26OjoRvdp9+7drfgd1m3btm0+uY5oOblXwUHuk+9otVpURYvLrVBR6cRmd+J0uRt1bPbe7HrbNRoFg15HqMWAUaegwY3b3bhzi9Yjr6f2yydB3vbt29m1axdz5szxxeUabdCgQRiNxja9xrZt2xg+fHibXkO0DrlXwUHuk284XW4qKl1YbQ4qHR48HpWoJhyfvTeb5EuSG/18RQGDXkOoxYDFqMNo8NkYRIcmr6fgYLfbmzUw5ZNX0ZYtWzh8+DATJ04E4MyZM9x111385S9/ITc3F7fbjVarxe12k5eXR2JiIqqqNqtNCCFE8zhdHmyVTqyVTmx2Nx4fTqWqKtgdHuyOSoo0CibDuYDPpEenlUQQQjSHT1459957L99++y2ZmZlkZmbSqVMn3njjDW644QaSk5NZu3YtAGvXriU5OZno6GhiYmKa1SaEEKLxXG4PZVYHOfnlnMgtI6/IhtXm8mmAdyGPR6Wi0k1eYdX6vbxCK1ab0699EiIY+X08fMGCBcydO5elS5cSHh5Oenp6i9uEEELUze32UGF3YbU5sVW6Anrzg9utUmp1UlbhRKfVEGrRYzHpMBv1/u6aEAHPL0FeZmam999JSUmsWLGi1uc1t00IIURNbo9atXGi0om10oXbHbiBXW1UtWo6uajUTnGZHaNBS6hZj8Wkx6DX+rt7QgQkv4/kCSGEaBtuj4qt0kWF3YHVFnyBXV1UFSrtbirtbjQaO2aj1rthQyvr94TwkiBPCCHaEY9HxWZ3UVHppNzmxONWaR+hXe08HhWrzYXV5kKrVQg16wkx6zEbdd6crEJ0VBLkCSFEkPN4VCod5wK7Ciduj0pHLBnrdquUlDsotTrQ6zVVAZ9JL+lYRIclv/lCCBGEVPXXETurzYXL7emQgV1tVBUcDg+FDjvFpQ6MRg2h5qp0LHqdTOeKjkOCPCGECBKqWj1i56Lc5sTlksCuIR5VxVbpxlZpQ6OpJMSsw2Kq2rCh1ch0rmjfJMgTQgg/uGPBZxSX2S96PDLMyNsLrqvxmM3uxHYu5YnDKYFdc3k8KmVWJ+VWZ9X6PUvV+j2TQdbvtQdNeU11FBLkCSEC3kV/vN89CQT3H+/a3ozOf7x6xM5qc0hg18pUwOVWKS5zUFLu8JZTC5F0LEGtoddURyRBnhDtTHv8NNvWf7xVVcXtOfefu6pO669fq7g9Fz7mwe1R8ahV7VVtnhrH1HjMXfW457zn1OdkXhkOhwePRHZtrmY5NTsmg/ZcwuWqcmrt8fUkOg4J8tpQXuZX2FdnsGtVhr+7IhrBXlbWLu5VcWXtxcaLy+zsemZes87pUcGDghvF+383Ch71vH9f+H+1luej4FZreayBYyC2zr499uTbeM6d89f/8B7rOXdeD1z0nOp/qwTWVN3p9P/2dxdaLKzCSqElxN/daDZFAa1GodidUmt7S15PgaQ9/N0rU3VkuSOBHv7uSsCRIE+IDuSfjr51BlLVAVhtAZuvgiAFFQ0q2nP/r/53fdyqggYVPR7vMRo4798qGuXcY4pa8/ELn+e9NjWOVc57TOs938Xn0F5wPq3Cedev+fwXHEPr/J6OEkZPylrrxyqaQVWrpnTr41ZBG1ifD9o3tSo1kIpKkcfAHk8U2Z5IjhEGAfZBLVBIkNeG4lMncCIijEuH1z6yIgLLtm3b2se9+lPdn8p1Xbqj1SpoNRo0GgXduX9rz/u/TqOg1WrQahTv4zptddu5/2t//X/Vf1XH6KqPOe/xX59T/TwtOq2CXqtBq9Og02gw6DXea9bmpnq+p9devr3FPzK/qOd7epsB9OseyfWje9EzMdyHnWo9uXuz6XpJsr+70WxOl4fNe3Jg48E6n/PfyiguTYplaP84hvWLJyzEiFYLGo3G+zoKdIH0d8/tUXG5PbjcHjxuFZfHg9vtweny4HR7yDlrZceBfHYcOMvx3KoPQYmxIUxKimXEgHgWvbXFz99B4JEgT4gO5H/+ON7fXRDnRIYZa13rFWrWM3Fkd77ccpz//c92BvSK5obRvegSH+qHXnY8DpebH3flkLn1BCVWR73PvTQplj1HCti85wwaBXp3iWBg7xgG9Y4lIdoCCuh1VR9eqj8YVX/A0lb/d+4DUEfgclcFbe5zAVx1QOdyeXC61arqLOdG6lS1aq1sToGVnQfz2Xkwn5x8KwDdEsK48cpeXNYnli5xoUSGGQm1GOp8TUWGGX39rQYMCfKEaEc8DSzoD1bt8Y93bYv2XW4POfnl2B0eRg9K5OtfTpK59QQvv7uNIX3juG50z6rgQbQ6h9PN97tOk7n1BGUVTpK6RPCb6y5h6cqddR7z5ztGUFxeye6DBew6VMCewwVkfH2YjK8PEx9lYWDvaAb2jqFnYsRFo9SKAgoKKFX/Pn/Uu65gUKtRAjbVi6qquNwqLrcbtxvc54K46pE4R3VOR7WqzF5de4pUVeVEXjk7D5xl58F8zhbbUICencOZOi6Jy/rEEhVuQqdViAg1Eh5i8I6YykaYi0mQJ0Q74XC6+Xlvbp3t7SUg2rZtG8MDZHqptem0GmIjzeTkV2A0aLkmpQdXXtaZr34+yabtJ9lx8CwjLkng2st7EBth9nd32wW7w813O0+z8ecTlFc46dstkt/e0IM+XSMBCLPoKatwXnRcZJgRg15LfFQIY4aYuKxvLKVWJ/lFNnYfqQr4vt5+io3bTmIx6UjuWRXwXdIjGrNR5x2xql5y6nar2PFcdJ26gkHvEotzAaBGo6BTFLS6tgkGPeemUquCt6od5t6ROLeK81wQp6pNL6nnUVWOni5lx8Gz7DqYT1GZHY0CfbpFMn5YVy5NiiU8xACAVqsQEWIgPNTYYUZAW0KCPCHaAavNSV5RBe+s30eoRc8L940mqWuUv7slmsFs1BMVZqSgpBIAi0nPDVf0YtyQLny59QTf7TjNtn15XD6wE9ek9Ajq4N2fKh0uvt1xmq9+PonV5qR/9yiuvbwHvTtH1Hjeq3+aQGxk/aOnBr2W2EgL4SFuwkP0xEaZGTekC5V2F3uPF7HncAHZRwrYtjcPrUYhqWsEA3vFMLB3DDENBOtNCwar/qEAWp3y6zrYC4NBjVK1blCroNNVhQFuj4rL5cblUWtdD+d2VY/AtU5dZLfbw8FTJew8cJZdhwooq3Cg1Sr07x7FpMt7Mqh3DCFmvff5Go1CeIieiFAjep3kMmwsCfKECGKqqlJYVklJqZ0f95zhaE4pt13Tn7io4E1dIapGiSodbqy2X0eQQi0G0sYlMX5YV7746Tg/7s7hp6wzXHlZZyaO7E6YxeDHHgcPm93FN7+cYtP2k1RUukjuGc21o3rUusHFbNIRHd74EdPzg71Sq51SjcKQvnEM6RuHx6NyNKeUPYcL2HOkgI82HeKjTYfoFGPxBnw9OoWjaWapNbU6DjwXgbkdKo5GBIP5pS6OnSm9aD1cW3C5POw7XsTOg/nsPpxPRaULg07DJT2jGdwnjgG9ojEZa4YlGk1VZZLIUKMkqm4GCfKECFJOl5v84kqstqqSV2u+PUyPTmGMurQTISZ5aQczRVGIjTRhd7guSuMRGWrk5tS+XDW8Kxs2H+frX07xw+4cxg3pylXDu2Ix6es4a8dWUenk619O8fX2U9jsLgb1juGaUT3onhBW6/O1WoXYCFOzgq6Lgj1rVbDeu0sEvbtEcNPY3uQX29hzuIDdhwvY+PNJvtx6glCzngG9qqZ1+3ePxmho/aDmwmCwotKB03lxMNha7E43e48WsvNgPnuOFGB3uDEZtAzsHcNlfeK4pEdUrcGbRoEQS9XInckgf8+aS35yQgShikonZ4tt3j/O6388irXCyb1plxJx3kJkEbz0uqpAIbfQWuvISkyEmduu7c/EEd347MejfLHlON/uOMVVw7sxbmgXeWM8x2pzsmn7Sb755RSVDjeXJsVy7ajudI2vPbiDqtGumAgzxhb+DM8P9krK7ZRVOL2bo2IjzYwf1pXxw7piq3SRfaywKug7VMBPWblotQp9u0YysHcMA3vFEBVualFffMlmd5F1pIAdB/LZe6wQp8tDiEnHkL5xDO4TS9/uUXWup1MUsJh0RIYZMRvlA0tLyV8BIYKIqqoUl9kpKrV7S17lFFj55pdTXD4oke6dwmQkpx0JteipdBgoLqs7lUd8tIXf3jCAq0eW8+kPR/n0h6N8/cspJo7oxpWDO2PooOuXyiscfPXzSb7dcRqH081lfeO4NqU7neMaTkUTHmLwLvRvDQa9lrgoC+EhLkqtjhrBHlRNCw/rH8+w/vG4PSpHTpdUTeseLmDlxoOs3HiQzrEhVQFf7xi6JYShCbBdtuU2J7sPVaU62X+8CLdHJTzEwKiBnbisTyy9u0TWmQcTqoI7k1FHVKgRi1n+hrUWCfKECBJOl4eCEhvl5+30U1WVVRsPYjLouOHKXhgNWgny2pmocDN2hxub3V3v8zrHhXLXlEEcO1PKp98f5eNvDvPVzye5JqU7lw9K7DA7EcusDjb+fILvdp7G6fQwpF8c14zqQWJM49apmoxaotto57LRoCPOoCM8xEWJ1UH5BcEeVJVS69M1kj5dI0kbl0ReYQV7zu3W/WLLcT7/6ThhFoN3Wrdf9yiMflqrVlJuZ9e5wO7QyWI8KkSHmxg7pAuD+8TSPTG8wWBUAYxGLZGhJkLMuoBNEROsJMgTIgjY7FXTsw5HzbUzvxw4y8GTxdx8VV9CzXpC5RNwu6PVKMRGmjmdb8XdQJktgB6dwrl/+mUcOlnMJ98fYeXGg2RuPcGky3syIjmh3tGUYFZitbNx6wm+35WDy+1hWP94rknp0aS8ghqtQlykuc1/RkaDjniDjoh6gr1q8dEW4qMtXDW8G9ZKJ3uPVk3r7jhwls17zqDXaujTLZJBvWMY0DuGyNC23W1dWFLJzkNn2XEgn2M5pahAfJSFiSO7c2mfWLrGhTY6UDMaNESEmgiz6CW4ayMS5AkRwFRVpaTcTmGp/aI3AbvTzcdfH6ZLXCijL01Eo1FqpBwQ7YfRoCMm3MTZYlujdz4mdY3kkZlD2HesiHU/HOX9z/fx5dbjXHd5T4b0iwu46b7mKi63k7n1BD/uysHt8TD8kgSuTulOfFTTkkYrCsSGm1q8Dq8pmhLsAYSY9Ay/JIHhlyTgcns4fKrEu1t3RWYhZB6ga3yod7du1/jGB1z1ySusYMfBquTEJ/PKAegSF8p1o3tyWZ9YOjVylLSaXq8hKrSqSkVzdxOLxpEgT4gA5XKfm561Oqntz/4XPx2nuNzOHTcko9EoWEw6yR/VjoWHVqVVKW2g1Nb5FEXhkp7R9O8Rxe5DBXz6w1He/jSbL7Yc5/rRVbnIgnUEpaiski+3nODHPTmoKoxMTuDqkd2JjWzeVGuYpSrBrj/UCPbKHZTb6g/2oCpxdr/uUfTrHsXU8UnkFlZ4d+tu2HyM9ZuPERFiYMC5gK9v98hGr89UVZXT+VZ2HqwascstrACgR6cwbhrTm8v6xDbr56zTKkSGGatq/Epw5xMS5AkRgGx2J/nFNuyO2lMbnC2qYOPPJxiRnEDvzhEoQKhZ8qS1d9ERJuxOV52/F3VRFIVL+8QyMCmGX/ad5bMfj/Lmmj10Twjj+it60r97VNAEe4UllXyx9Tg/7TkDQMqATkwc2a3BpML1MRo0xET4f/eq0aAjPlpHhONcsFfh9G6wqo+iKHSKCaFTTAgTR3anvMJB1rlp3Z/35fHD7hz0Og39u0cxsHcMa787UiMHI5/lAVW7WkcN7MSug/nkl1SiKNC7cwRXTOjDZUmxzU68rdUqRIQaCA+RKhW+JkGeEAGmpNxOQWklnnrWX3206RA6rYbJY3oBoNNpsEhuvHZPp9UQE2HmTH5Fo978L6RRFIZdEs/gfnFszT7D+h+P8fePdtG7SwQ3XNGTpC6Rrd/pVpJfYuOLn46zJTsXRYHLByUycUS3FqcW0Zxb8xhIaYeqg73wUBel5XbKK1xNut+hFgMpAzqRMqATLpeHg6eKvbt1dx8uqPO4ikoXm7afol+3SFJHdGdQUkyLkmxrNNXBnUFmGfzEZ+8KDz74ICdPnkSj0WCxWHjuuedITk4mNTUVg8GA0Vj1CWHOnDmMHTsWgCNHjjB37lyKi4uJjIwkPT2dnj17NtgmRDByuz0UlFRSVuGod93VnsMFZB8tJG1cbyJCql43oRa9rG3pICwmPVHhv5Y9aw6tRmHUwESG90/gxz05bNh8nNdW7OCSHlFcP7on3TtdXP3BX84WVfDFluNszc5Fo1G48rLOpA7v1irl3BQgOjxw87GZDDpM54K9knI71iYGe1D1AfCSHtFc0iOa6RP6kJNv5aV3ttX5/OfvHd3iHfoajULYuUTGUqXCv3wW5KWnpxMWVpV88osvvuDpp5/mo48+AuDVV1+lX79+Fx0zf/58Zs+eTVpaGhkZGcybN49///vfDbYJEWwqHS7yi21UNpAmw+ny8NGmgyREWxg7uAtQNTojGy46ltrKnjWHTqdhzOAupAzoxHc7T/PlluMseX87lybFcN3onnSObTinXFvJLazg85+O8fO+PHRaDWOHdOGqEd28H2xaQ3VFhUBXHexVtiDYg6pp3YbyBLYkwNMoCqEWHRGhRp9uYBF189ldqA7wAMrLyxtc/1FQUEBWVhZvvfUWAJMnT+b555+nsLAQVVXrbIuOjm67b0KINlBqtZNfUv/0bLWN205QUFLJ/dMv804vGY0aqW7QwdRX9qw5DHotVw3vxuhLE/l6+yk2bjvB7kPbGNo/nkmX92jyTtWWOFNg5fOfjrN9Xx56nYYJw7py1bBuhLVicmIAg0FDbKQ5aNYiwq/Bni3ESanV0exgr7VVVanQExlmCNhR0Y7Kp+8MzzzzDN999x2qqvLPf/7T+/icOXNQVZXhw4fzxBNPEB4eTk5ODgkJCWi1VUO9Wq2W+Ph4cnJyUFW1zramBHm7d+9u3W+wDtu21T00LgKLL++VTqejwqFQVGrD7Wl4IX2Zzc2GzQX0SjDiqThD9t4z5xZch3LmuN0HPQ4c8po6R2sgt7ACt7v1ao92i4BbxkSx82gFOw/msX1/Hv06mxjWJ4Qwc9Om3rL3Zjf6uYVlLn4+ZOXwGTt6rcLgXhYu7WXBbHBw8sShpn4b9dLrtCREWTh7MnhfN1qtFlXRYq10U1bhwOWqfxagsZpyz7QaDSEWI2FmHWW4OO1unT6I1uPTIG/RokUArF69mhdffJF//OMfvPPOOyQmJuJwOFi0aBELFy7k5Zdf9kl/Bg0a5F0L2Fa2bdvG8OHD2/QaonX48l7Zz03P2uxu4jo17ph/fbIHjUbDHTcO8S4212oVuiWEdagda/Kaqim/uKLesmfNNfQyKKtw8MWW43y/8zQHc+yMvjSRq0d2b9QUZ/bebJIvSW7weafyytnw0zF2HizEaNByTUp3xg/t2qZLEGIiTEFVC7YhNruTknIHFTYnDWReASDs6yLKKi6e6g+z6Bt1zxQFTAYtkWEmWSriI3a7vVkDU36Z45k6dSrz5s2jqKiIxMREAAwGA7Nnz+aBBx4AIDExkdzcXNxuN1qtFrfbTV5eHomJiaiqWmebEIGurMJBfrGtUdULqu07XsSOA/lcP7pnjTenELO+QwV44mKNLXvWHGEWA9PG9+GqYd3Y8NMxvt+Vw+bdZxgzpDOpI7q3qMLKidwyNmw+xu7DBZgMWiaN6sG4oV3avCxfiFnfKps2AonZqMds1Dc62Ft47xXefzc2GK9mNGiIDDMRapYqFcHAJ0Ge1WqltLTUG4RlZmYSERGB0WikrKyMsLAwVFVl3bp1JCdX/bLFxMSQnJzM2rVrSUtLY+3atSQnJ3unY+trEyIQuT0qRaU2Ssrr3z17IZfbw6qNB4mJMHHV8G7exxUFKWMmmlz2rDkiw4zcMrEfqSO6sf7HY3z180m+35nD+GFdmDC0G+YmpO85llPKhp+OkXWkEItRx/WjezJ2cJcmnaO59DoNsZGmdhucnB/sFZc5qKh0NulvTX0MBg2RoUZCzVKlIpj4JMiz2Ww89thj2Gw2NBoNERERLFu2jIKCAh555BHcbjcej4ekpCTmz5/vPW7BggXMnTuXpUuXEh4eTnp6eqPahAg0Dqebs8U2bJWuJh/7zS+nyCuq4O4pg9Drfh21M+g1mI2y4UI0r+xZc8RGmPnNpEu4emQ3Pv3hGBs2H+fbX05z1fBujB3aBWM96TKOnC5hw+Zj7D1WRIhJx41X9GLM4M6YfPQ7rFEgLtLcIfK1tWawJ1UqgptPXl2xsbF88MEHtbatXr26zuOSkpJYsWJFk9uECCRlFQ4Kim3N2gVZYrWz/sdjDOgVzcDeMTXaQi2GdjsiIZquOWXPmishOoTf3ziAU3nlrPvhCJ98f4RNv5zE6fRgd543bXyukoJWo+D2qISa9Uwe04srL+vs8x3hEWFGLB1s5Ls62KuodFJSbqei0tXoYK+qSoWRiBBDQCWKFk0jwwBCtBGPR6WorJLiMnuzP0Wv/fYILo+HqeP71Hi8qlZtx3rDEg1rbtmz5uoSH8o9aZdyNKeUdd8f4cCJ4lqf5/aoTBnbmysu61zvaF9bsZh0RIW1n40WTWUx6bGYGhfsabUK4SFVJcjOnzkQwUnuoBBtwOF0c6bASlFp8wO8w6dK2Jqdy1XDuhF3QTFws1HrlzdLEdiqy55pfDzC2zMxnAdnDK73OVcN7+aX31mdtmrNoqwjqwr2EmNDSYwNIcSs4/xfE41GITLMQJe4UGIizBLgtRMykidEK7PanJwtqmhRklqPR2XlxgNEhhq5OqX7Re2hLagnKdo3i0lPZLiRwhaUPWsvFAViIs1SWusC54/snQo1Ex5qICLEIFUq2iEJ1YVoJaqqUlBqI7fA2uIqBN/vOs3pfCtp45IuGv3QaWWqVtQvKsxIiFnesCNCDYTJB6I6WUx6ws0QH2WRAK+dkrsqRCtwutzkF1e2uJYoQLnNyaffH6Vvt0gG9429qD3UopddbqJeiqIQE2HG7ihvlbJnwchs1BIdbm74iR2cW6pUtGsykidEC1VUOjl91toqAR7Auu+OUOlwMW1Cn4t2zyoKkmFeNIpBryUm0owvl+eFWWr/3azr8bailXV4QgAykidEs6mqSlGZneJSe6sVCT+eW8aPu3MYN7QLiTEhF7WbDFopAC4aLcxiwO5wtUnZs9q0pJJCa1EUiIkwy/SjEEiQJ0SzOF0e8ottrTZ6B+BRVVZtPECoRc+ky3vW+hzZcCGaqi3LngWiqvQf8joRAmS6Vogmq6h0klNQ3qoBHsDWrFyOnSnjpjG9a61koZXceKIZqsueabTtf+rSZNQSHSHr8ISoJkGeEI2kqirFZZWcKajA0crJZm2VLtZ8d5ieieEMT06o9TkhZp3krhLNYjToiA03+XR9nq9ptApxkWbZlCTEeeQdQ4hGcLk95BVVUFBcicfT+rsVP/vxKNYKJ9Ov6lNrItuqDRcyBSWaLzzU2G6n+xUFYsNNsg5PiAvIK0KIBtjsTvKLbW1WKion38q3O04x+tJEusWH1focnU6DxSQvV9EyMefKnrX2SLS/hVkMhIca/d0NIQKOjOQJUY+Scjs5+RVtFuCpqsqqrw5gMuq44YpedT4vzKK/KJ2KEE2l02qI9UPZs7ZkNGiIiei4dWmFqI8EeULUwu32kFdYQX6xrU2mZ6v9sv8sB0+WcMMVverMf6dRFEJkw4VoJdVlz9oDzblNJVqtvJUJURuZ/xHiApUOF/nFNirbOOWE3eEm45tDdIkLZfSgxDqfZzZpZa2RaFVRYUYq7S4qKl3+7kqzKUB0uFHyRgpRD/n4I8Q5Wq2WUqud0/nWNg/wAD7/6Rgl5Q5mXNWn3sz8suFCtDZFqRoB0wVxWpUQi54IWYcnRL0kyBMC8HhUKpwazhbZ8Pig1mdeUQVf/XySkckJ9OocUefztFqFENlwIdqAP8qetRaDQUNMhFnWqQrRAAnyRIenqir5JTYKSypopepkDV7vo68OotNpmDymd73PDbPoZb2RaDNhFgMRocE1UqxRFGIjzJIzUohGkFeJ6PAKSyspK3eg+iLCA/YcLmDvsSKuu7xnveWXFAWpcCHaXFS4GZNR6+9uNFpkuFFeF0I0kgR5okMrKbdTXGbHN+EdOFxuPtp0iIRoC2MHd673uUaDVt7MRJvTaqoqRQRD2bMQs56oMFmHJ0RjSZAnOqyyCgcFxTafTNFW27j1BIWllcy4qk+D07ChdaRUEaK1GQ06YgK87JlepyE20iTr8IRoAgnyRIdUUenkbLGNNkyBd5HCkkq+3HKCIX3j6Nstqt7najRKnXnzhGgLEaFGQi2B+TunUSAu0oxeFzzTykIEAgnyRIdjd7jIK6zwyS7a82V8cwhFgSnj6t9sAWAx6eQNTfhcTIQZgyHw3hYiwoxY5EOPEE0WeK9mIdqQ0+Umr6gCl48DvL3HCtl5MJ+rU7oTFVZ/CSZFgVDJjSf8IBDLnllMugZfM0KI2kmQJzqM6lJlbVWHti4ut4ePvjpIbKSZq4Z1a/D5Oq0Gi+TGE35SVfYsMD5k6LRVSZvrSxYuhKibz4K8Bx98kClTpjB16lRmz55NdnY2AEeOHGHWrFlMmjSJWbNmcfToUe8xzW0T4kIej0pekQ2bDypZXOibX06RV2Rj2vgkdI3I7RVm0cubmvCryFCT3z9oKArERJox6GXZghDN5bMgLz09nY8//pjVq1fzhz/8gaeffhqA+fPnM3v2bNavX8/s2bOZN2+e95jmtglxPlVVyS+2YbU5fX7tknI76388xoBe0QzoFdPg8zWKImuPhN9pNP4vexYRaiDMEhgjikIEK58FeWFhYd5/l5eXoygKBQUFZGVlMXnyZAAmT55MVlYWhYWFzW4T4kKFpZWUWh1+ufaabw/j8niYNr5Po55vNGowGWSqVvifP8uemY1aosLNvr+wEO2MT99NnnnmGb777jtUVeWf//wnOTk5JCQkoNVWDcdrtVri4+PJyclBVdVmtUVHRze6P7t37279b7IW27Zt88l1RE0ajQanqiO/qAK3p3Hr8LL3Zrfa9XMKHWzbW8zQJAtnzxzl7Jn6n68oCp1iQjlz3N5qfWiv5DXlGxqNhkq3lvwia7OOb87ryWDQEx9p5MwJ/3ww64jk9dR++TTIW7RoEQCrV6/mxRdf5LHHHvPl5S8yaNAgjMa2zZ6+bds2hg8f3qbXELUrq3CQV1hBdFzjnp+9N5vkS5Jb5dpuj8rad7cRFWbk1uuGNWpdkVar0C0hDJ3Uqq2XvKZ8y+1Ryckvp7KJ61mb83pSFIiLstRb7k+0Lnk9BQe73d6sgSm/vJtMnTqVzZs306lTJ3Jzc3G7q/54uN1u8vLySExMJDExsVltQsC5ZMdFvq1mcb4fdp3mdL6VKeOSGr1wPMSslwBPBBztufV5vih7Fh5ikABPiFbkk3cUq9VKTk6O9+vMzEwiIiKIiYkhOTmZtWvXArB27VqSk5OJjo5udpsQldXJjn1ZzuI85RUO1n1/lL7dIhncJ7ZRx1TlxpMNFyIwmXxQ9sxk1BIdLvnwhGhNPpmutdlsPPbYY9hsNjQaDRERESxbtgxFUViwYAFz585l6dKlhIeHk56e7j2uuW2i43I4/ZPs+HyffH8Eu9PN9Al9Gl1n06DXYDbKhgsRuMJDDNjsLsorWn+XuuZcPryG6jkLIZrGJ+8qsbGxfPDBB7W2JSUlsWLFilZtEx2Ty+0hr6gCh4+THZ/v+JlSNu8+w/hhXekUE9Lo40ItBim8LgKaoijERJhxuNyt+hpTFIgNN8muciHagHxsEu2C26OSV1jR5MXhrcmjqqzceJBQi4FJo3o0+jiNRiHEJFO1IvDpda1f9izMYiA8tG03wAnRUUmQJ4JedbLjikqXX/uxJesMx3PLuGlsb0xNmHo1G7WS1V8EDYtJT0QrlT0zGjRER8g6PCHaigR5IugVlNgo81Oy42q2Shdrvz1Cr87hjLgkvknHhkpWfxFkolqh7NmvVTXkbUiItiKvLhHUikorKSn3f9LUT388irXSyYwJfZu0tk6nVbDIVK0IMi0te6YA0eFGzEb53ReiLUmQJ4JWqdVBYWml33LhVTt9tpxvd5ziiks70yU+tEnHhlr0aDWy4UIEn5aUPQux6ImQdXhCtDkJ8kRQqrA5yS/2X7Ljaqqqsuqrg1iMOq6/omeTjlWUqgTIQgSrMEvTkxcbDBpiIsyym1wIH5AgTwQdm91JbpH/kh2fb/u+sxw6VcINV/Zq8g5Zk0Er01Ui6EVHmDEZG7dxSKMoxEaY0evkrUcIX5BXmggqVcmObbj9mOy4mt3h5uNvDtE1PpTLBza9pJ5suBDtQVPKnkWGG2UNqhA+JEGeCBpOl4fcQitOp/+SHZ9vw0/HKLE6mHFVXzRNXFen1ciGC9F+mAw6osOM1PcqCDHriQqTdXhC+JIEeSIouD0qZ4sqsPuxmsX58gor2PTzSVIGJNAzMbzJx4eYdTJlJdqViFAjIZbaP7jodRpiI02yDk8IH5N3GRHwVLUqwPN3suNq1Zst9DoNk6/s3eTjqzZcyFStaF+qy57p9ZoLHofYSDN6nST8FsLXJMgTAa+gxNYmRdGba/ehAvYdL+K60T0Ja+LOQgCdTtPiRLJCBCK9TkNchJnzVy9EhhllF7kQfiJBnghohQGS7Liaw+Vm9deHSIwJYczgLs06R5hFL9NWot2ymPVEhBlRFAWLSUdUmJQtE8JfZDhBBKzScjtFAZDs+HyZW09QWFrJQzMGNyuJsUZRmpxqRYhgExVmIircUrXrVpJ9tzmPx0N+fj7FxcW43e4mHavT6cjOzm6jnommMplMdO3aFb2+dd4nJMgTAclqc5JfHFgBXkGJjcwtJxjaL44+3SKbdQ6zSYvRIC870b5pNAqhRhWDXtbh+cLJkydRFIWePXui1zdtpsBqtRISEtKGvRONpaoqBQUFnDx5kl69erXKOWW6VgQcm91JXlEFnkCK8ICMrw+hKDBlbFKzzyEbLkRH4XIFxkapjsBqtdKlSxcMBoMsBQliiqIQExNDZWVlq51TgjwRUOwOF3mFgZHs+Hx7jxay61AB14zqQWQzc31ptQohsuFCCNEGNBp5O28PWjtIl98KETCcLg95RRU4XYGRC6+ay+1h1aaDxEWamTC0a7PPE2bRo9XKS04IIYRvyDuOCAhud1WAFyjJjs+3aftJzhbZmDY+CV0zExgrClLhQggh2lh2djbr1q3zdzcChgR5wu88HpW8Ihu2AEl2fL7icjsbNh9jUO8YknvFNPs8RoNWgjwhhGhDLpeL7OxsPvvsM393JWDIAiHhV6qqUlBiw2oLnGTH51vzzWE8HpW08c3fbAEQKslghRA+kpf5FblfZjbquW63G6228bugEyamEp86ocHn7dixg5dffhmr1QrAo48+yp49e8jOzua1117DZrMxc+ZMnnzyScaPH09qaio33ngjP//8M3l5efzud7/j9ttvB+Dw4cMsXryYoqIinE4nv/vd75gxYwYA/fv358knn2TTpk3069ePL7/8kvLyctLS0hg5ciTPPvtso7+39kiCPOFXhWWVlAZQsuPzHTpZzM/78rh2VA9iI8zNPo9Go0jGfyFEh1FaWsr8+fNZvnw58fHx5OXlcfPNN/Pxxx/zxBNP8Pbbb5OVlcW4ceMYP36897j8/Hzeeecd8vPzmTp1KiNGjKBPnz7MmTOHl156iaSkJMrLy5kxYwZDhgwhKanqw7fH4+Htt98GYODAgXz11Ve8+uqrfvneA40EecJvSsrtFJfaCax9tFXcHpWVXx0kKszIxBHdWnQui0kndTuFED4TnzqhUaNt0DZ58rZv387Jkye55557vI8pisKJEyd46aWXSEtLo3Pnzrz77rs1jrv55psBiI2NZcKECfz000/odDoOHTrEE0884X2e0+nk8OHD3iBv2rRprdr/9kSCPOEX5RVOCgIs2fH5vtt5mpx8K3dOHtCihK6KAqGSG08I0YGoqkr//v155513LmrbsWMHGo2GkpISKisrCQ0NrfMciqKgqipRUVFkZGTUeT2LxdJqfW9vZOOF8LmKSid5xYGX7LhaWYWDz344Sr/uUVyaFNuic+m0GiySG08I0YEMHTqUY8eO8eOPP3of27lzJyUlJcyZM4e//vWv3HjjjTz33HM1jvvoo48AKCws5OuvvyYlJYVevXphMplYvXq193mHDh2ivLy81muHhoZSVlbW+t9UkPLJu09RURF//vOfOX78OAaDgR49erBw4UKio6NJTU3FYDBgNFYlmJ0zZw5jx44F4MiRI8ydO5fi4mIiIyNJT0+nZ8+eDbaJwFWV7LgCT4AlOz7fJ98dwe50M31CnxYnpgyz6KV2pxCiQ4mIiGDp0qW89NJLLF68GKfTSbdu3dDr9cyYMYMRI0YwdOhQfv/73/Pee+9x2223AZCYmMjs2bM5e/Ys9913H/379wdg2bJlLF68mDfeeAOPx0NMTAyvvPJKrdcePXo0b775JlOmTCElJUU2XvjiIoqicPfddzNq1CgA0tPTefnll1m8eDEAr776Kv369bvouPnz5zN79mzS0tLIyMhg3rx5/Pvf/26wTQQmp8tNXlEFrgAO8I6dKWXznjNcNbwrCdEtmwLQKLLhQgjRMV122WXezRC10Wq1F7Vfc801PPTQQxc9t2fPnixfvrzW8+zbt6/G12FhYbz//vvN6HH75JPp2sjISG+ABzBkyBBOnz5d7zEFBQVkZWUxefJkACZPnkxWVhaFhYX1tonA5HZ7yCsMzGTH1VRVZeXGg4SHGLh2VI8Wn89o1GA0yFStEEII//D5O5DH4+G9994jNTXV+9icOXNQVZXhw4fzxBNPEB4eTk5ODgkJCd78PVqtlvj4eHJyclBVtc626OhoX39LogHeZMd2t7+7Uq99Jys5kVvG7dddgqkVgrMw2XAhhBCNkpnZuLx+oml8HuQ9//zzWCwWb5LDd955h8TERBwOB4sWLWLhwoW8/PLLPunL7t27fXKdbdu2+eQ6gUir1VLh1FBYYg3InbRvZ57F5qjZsf/fZ3tZmbmPO1Ljmn1eo0FPeaQBtyswkzwHu478mgomcp98Q6fTeZMON0dLjhWtz+FwtNprp9FB3okTJ3jllVfIzs6moqKiRttXX33VqHOkp6dz7Ngxli1bhkZTNVOcmJgIgMFgYPbs2TzwwAPex3Nzc73ZuN1uN3l5eSQmJqKqap1tTTFo0CDvho+2sm3bNoYPH96m1whkBSU2ikrtxHfyd09qZ/ssr/bHHSrJlyQ3+7zhoQbio2Rbf1vo6K+pYCH3yXeys7ObneuuLfLkiZYxGAwMHjy4xmN2u71ZA1ONDvLmzJlDt27deOqppzCbm579f8mSJezevZvly5djMFRNY1VUVOB2uwkLC0NVVdatW0dyctUba0xMDMnJyaxdu5a0tDTWrl1LcnKydzq2vjYRGIrLKikus/u7Gz5XlRtPNlwIIYTwr0YHeQcOHOC9997zjsA1xYEDB1i2bBk9e/bk1ltvBaBr167MnTuXRx55BLfbjcfjISkpifnz53uPW7BgAXPnzmXp0qWEh4eTnp7eqDbhf2UVDgpLAjfZcVsy6DWYjbLhQgghhH81+p1o5MiRZGVlMWjQoCZfpG/fvhdtc652foLDCyUlJbFixYomtwn/qqh0crbYhifAA7yf99U+VdtSoRZDi/PrCSFER7Nr1y7+9a9/8T//8z+tcr7NmzeTnp7OqlWrWuV8wajRQV6XLl246667uPbaa4mNrVkF4LHHHmv1jongFAzJjgF+yjrD+5/X/sGjJTQahRCTTNUKIURTXXrppa0W4IkqjZ57tdlspKam4nK5OHPmTI3/hABwON3kBniyY4Dvd53mvQ376Nstqs61c2GW5gVqZqO2RbVuhRCiPejfvz/Lli1jxowZTJw4kfXr13vb/vSnPzF9+nRuuukmHnroIUpKSoCqkbfp06cD8PTTT/P//t//8x6zf/9+Jk6ciKqqlJeX88wzz3DzzTdz00038cILL+B2156iy+Vy8Ze//IVp06Zx8803c/DgQW/bhx9+yJQpU5gyZQozZswgPz+/LX4UftWokTy3202nTp144IEHvJsmhDify+0hr6gCRwAnOwb4evtJPtp0iOSe0dw5eSB63a+fc7L3ZrdoRy1UTdUKIYQ/bTryIxuPfN+o51ZnqWisq3pdwfhelzfquaGhoaxcuZJt27bxxz/+kUmTJgHwzDPPeDdKLlmyhH/84x/MmTOnxrHTp09n0aJF/O53vwNg1apVTJs2DUVR+O///m9GjhzJokWL8Hg8zJkzh5UrV3LLLbdc1Id9+/bx7LPPkpKSwkcffcSf//xnVq1axebNm/n73//Ou+++S1xcHFarFZ2u/a2lbtR3pNVqeffdd3nkkUfauj8iCLk9KmeLbFQGeLLjzK0nWPPtYS5NiuW3NySj07ZuwRedVsEiU7VCCAHADTfcAFRVucrLy8Nut2M0GsnIyGDNmjU4nU4qKipqrTs/YsQIrFYre/fupU+fPqxdu5b//Oc/QFXi5J07d/LWW28BUFlZSUJCQq196NGjBykpKQCkpaXx3HPPUV5ezldffUVaWhpxcVX5UNtrGplGh61Tp07lvffe4ze/+U1b9kcEGVVVKSi2YbUFdtLfDZuP8ekPRxnaL47fTLoEbSsHeAChFj1ajWy4EEL41/helzd6tK0t8+RV56GtHil0uVzs2rWL9957j/fff5/o6GjWrFnDBx98UOvxaWlprF69mpSUFJKSkujSpQtQ9b6zdOlSunXr1ib9bk8a/U63c+dOFi9eTGpqKrNnz+Y3v/mN9z/RcRWU2Ci1OvzdjTqpqsq674/w6Q9HGZGcwO3XJbdJgKdRIERy4wkhRL1KS0sJDQ0lMjISh8PBypUr63zutGnTWLt2LStWrPCu1QNITU1l+fLl3nV4hYWFnDhxotZzHDt2jK1btwKwZs0a+vXrR2hoKFdddRUZGRnedXhWqxWHI3Dfy5qr0SN5t9xyS63z3aLjKiqtpKQ8cF8Uqqry8TeH+ernk1w+qBMzJ/ZD00apTYwGLWajBHlCCFGfcePG8fHHH3P99deTkJDAoEGD2LVrV63P7dy5M3369OGnn37ir3/9q/fxp59+mpdeeom0tDQURUGv1/P000/XOrJXXThh8eLFaDQaXnzxRQBSUlK49957ufPOO1EUBYPBwLJlyy7KHhLsFFXteOlqq8uDSFmz5iu1OjhbVBGwyY49qspHXx3k2x2nGTO4M9Mm9GkwwGvJxou4KDMRoW37uySqtNfXVHsj98l3srOzvdWimkrKmgWe2u5nc+OWRo/kffjhh3W23XzzzY2+oAh+doeL/GJbQAd4K77cz4+7zzBhWFemjO3dpsmJtRrZcCGEECLwNDrIy8jIqPF1fn4+J06cYOjQoRLkdTBlFQ48AVrOwu1Ref/zfWzNzuWalO5cP7pnm1efCDHraqRiEUIIIQJBo4O8t99++6LHPvzwQw4dOtSqHRKBzelyU1YRmDtp3W4P76zfy/b9Z7l+dE+uHdWjza+pKBBqltx4QgghAk+Lhh+mT59e784Y0f6UVThxB2BFC5fLw/9bl8X2/WeZMra3TwI8AJ1Og9nU/hJoCiGECH6NfnfyeGpWMrDZbHz88ceEhYW1eqdEYHJ7VErL7f7uxkWcLg9vrd1D9tFCpk/ow9ghXXx27TCLvs2ng4UQQojmaHSQN2DAgIvezBISEli4cGGrd0oEJmuFI+Dq0jqcbt5Ys5sDx4uZObEvV1za2WfX1mgUQmTDhRBCiADV6CDvyy+/rPG12Wz21p4T7Z+qqpRYA2sUr9Lh4p8Zuzl8uoRbr+1PyoBOPr2+2ajFaJCpWiGEEIGp0e9Qb731Fs8+++xFjy9atIhnnnmmVTslAk+5zYnD6Wn4iT5is7tYvnoXx8+Ucvt1yQzrH+/zPoTIhgshRJC6Y8FnFJdd/ME9MszI2wuua/H5U1NTMRgMGAwGbDYbffr04Z577mHYsGE1nnfzzTfjdDovyuAhWkejN16sWrWq1sc//vjjVuuMCFylVnvA5MWzVjr526qdnMgt43c3DvRLgKfVKoTIhgshRJCqLcCr7/HmePXVV/n444/5/PPPmTZtGvfeey87duzwth84cICCggJsNht79uxptes2RnVJtPauwXep6iTIbrf7ooTIJ06cIDIysk06JgJHRaWTSntgvCDKKxz8bdVO8ooquPOmgQzsFeOXfoRZ9G1SA1cIIVoqc+txPv/peLOP/8vSb+tsuyalO6kjujf5nNdeey07d+7kjTfe4NVXXwWq4ou0tDQMBgMrV65k4MCB3ucvWbKEdevWERkZSUpKCj/88IN3sKm+to8++oh3330Xt9tNaGgoCxYsoHfv3qxatYpPPvmE6OhoDh06xKJFi2pUldi8eTOLFi3isssuY8eOHeh0Ol588UVee+01Dhw4QGJiIv/3f/+HxWLB4XCwZMkStmzZgtPppF+/fixYsICQkBDWrFnDv//9b5zOqlRjTz31FKNHjwaqRjfT0tL4/vvvOXv2LH/4wx+4/fbbm/yzbIoGg7zqIdQLh1MVRSE2Npb09PS2650ICGUVjoAYxSux2vnbyp0UllZy15RBXNLDP2tCFQVCzLLhQgghmmLw4MFkZmYCVTHFmjVreP/999Hr9UydOpW5c+diMBjIzMxk48aNZGRkYDKZePTRR73nqK9t69atfPrpp7zzzjsYDAY2bdrE008/zfvvvw/Azz//TEZGBt271x6kHjp0iPT0dF544QX+67/+i7vuuosPPviATp06cc899/DJJ58wc+ZM/vnPfxIWFuYd+HrppZdYvnw5jz/+OGPGjGHy5MkoisLhw4f5/e9/z9dff+29RmVlJf/5z384efIkN910E9OmTWvTsnINBnnVSZCXLFnC448/3mYdEYHJ7nBhtbn83Q2Ky+wsXbmDEqude9MupU+3SL/1xWjQYjZKkCeECEypIxoebbvpT3WvgfvvB8e0dpeAqg181TZu3EivXr28AdeAAQP4/PPPufHGG9m8eTPXX389FosFgKlTp7J06VKAetsyMzPZu3cvM2fO9F6vtLTUe81hw4bVGeAB9OrVyzu6N2DAAE6fPk2nTlUb+gYOHMixY8e81ykvL2f9+vUAOBwOLrnkEqBqhvNPf/oTubm56HQ68vPzOXv2LHFxcQDccMMNAHTt2pXw8HDOnDlDUlJS836gjdDoRUWPP/44RUVFbNq0ifz8fO6++25yc3NRVdX7QxDtTyCUMCssqeT1lTuoqHRy/7TL6NU5wq/9CZVRPCGEaLJdu3bRt29fAFauXMnBgwdJTU0FoKKigpUrV3LjjTeiqmqd+UcbapsxYwaPPfZYre0NjZgZDL9uptNqtRiNxhpf2+1273Xmz5/vnYY93xNPPMHcuXO5+uqr8Xg8DB482HsccNE523ptYKMXFf30009cd911rFmzhtdffx2AY8eOsWDBgrbqm/CzQChhdrbYxv99+As2u4sHpvs/wNNoFJmqFUIEvcgwY5Meb6kvvviC9957jzvvvJO8vDy2bNnCl19+SWZmJpmZmWzatIndu3dz+vRpRo0axWeffYbNZsPj8dTY4FlfW2pqKhkZGZw5cwao2kuwe/fuVv9eUlNT+de//kVlZSUA5eXl3hKvZWVldO3aFahac+hwOFr9+k3R6JG8xYsX88orrzB69GhGjhwJVM2v79y5s806J/zL3yXMcgsrWLpyB263h4dmDKZLfKjf+lLNYtKh12n93Q0hhGiR6jQpVqu1zdaEPfroo94UKklJSSxfvpwhQ4awfPlyxo0bR2jor3/TjUYjEydOZNWqVTz88MNs376dtLQ0EhISGDx4MCUlJQBMnDixzraRI0fyxz/+kQceeAC3243T6eS6665j0KBBrfp93Xvvvbz22mvcfPPNKIqCoig8/PDDJCUl8Ze//IUHH3yQhIQEUlJS/L45VVHVxi2pHzlyJFu2bAEgJSWFn376CY/Hw+jRo9m8eXObdrK12e12du/ezaBBg2oMnbaFbdu2MXz48Da9Rltwe1ROnCn1W4WL0/nl/G3VThTggemDSYxtu4Wp1bL3ZpN8SXKd7YoCCdEhhFpkJM+fgvU11dHIffKd7OzsGjtFm6Itg7yWKC8vJzQ0FI/HwzPPPEN8fLx3X0B9be1BbfezuXFLo0fykpKS+Oabbxg7dqz3se+//55+/fo1+mIiePizhNmJvDKWrdqJXqvhwRmDiY+2+KUfF9JpNVgkN54QQrS5p556ilOnTlFZWcnAgQO55557GtUmamr0O9bcuXO57777mDBhApWVlcybN4/MzEzvrpb6FBUV8ec//5njx49jMBjo0aMHCxcuJDo6miNHjjB37lyKi4uJjIwkPT2dnj17AjS7TbSMP0uYHcsp5e+rd2EyaHlwxmBiI81+6Udtwix6NJraF/wKIYRoPdVr/5vaJmpq9MaLIUOG8PHHH9OnTx9mzJhB165deeWVV/jnP//Z4LGKonD33Xezfv161qxZQ7du3Xj55ZcBmD9/PrNnz2b9+vXMnj2befPmeY9rbptoGX+VMDt8qoS/fbQTi0nHwzOHBFSAp1Fkw4UQQojg0mCQZ7PZeOWVV7j//vt58803ue2227jzzjvZsWMH99xzDzExDVcciIyMZNSoUd6vhwwZwunTpykoKCArK4vJkycDMHnyZLKysigsLGx2m2g5f5QwO3CiiL9/tJPwEAMPzxxCdLjJtx1ogNGowWiQqVohhBDBo8F3rYULF5KVlcWYMWP4+uuv2b9/P4cPH2batGk8//zzREc3reqAx+PhvffeIzU1lZycHBISEtBqq3YrarVa4uPjycnJQVXVZrU1tT+iJn+UMNt7tJA31+whJtLEA9MHEx5iaPggHwuzBF6fhBBCiPo0GOR98803ZGRkEBMTwx133MGECRN4++23vWlUmur555/HYrFw++23k5WV1axztJa2yJ9Tm23btvnkOi2l0WiwOhSKSm0+u+axPDufby8hKlTHtYMtnDpxiFM+u/rFsvdmX/SY0aCnvNCA2+XfnIHiV8Hymuro5D75hk6nw2q1Nvv4lhwrWp/D4Wi1106DQV5FRYV3SrZTp05YLJZmB3jp6ekcO3aMZcuWodFoSExMJDc3F7fb7c38nJeXR2JiIqqqNqutKSSFSk12h4tTZ6108lGFix0HzvL5L9l0jQ/j3mmXEmLy75q3ulKohIcaiI8KjB2+IrheUx2Z3Cffyc7OvigNis3uxO5oeFamstKOydT498HGlnVMTU3FYDB48+T16dOHe+65h2HDhtV43s0334zT6SQjo+4ya/60efNmnE4nY8bUXurt5MmTzJgxo1VTyRkMBgYPHlzjseoUKk3VYJDndrv58ccfa9Scu/Dr2kp7XGjJkiXs3r2b5cuXe0uHxMTEkJyczNq1a0lLS2Pt2rUkJyd7p1yb2yaax5clzLbtzeXd9Xvp3imce6deitkYmOvdFEXKmAkhgo/d4Sa/uLLB59kqbZhNjf+7HxtpanTt7ldffdWbZm3Dhg3ce++9vPHGG94A5sCBAxQUFKDX69mzZw8DBw5sdD9aqnqQqCE//fQTFRUVdQZ5ga7Bd9aYmBiefvpp79eRkZE1vlYUhS+//LLecxw4cIBly5bRs2dPbr31VqCqOO/rr7/OggULmDt3LkuXLiU8PJz09HTvcc1tE03ndHl8VsJs854c/vP5fpK6RnD3lEsxGgK3goRBrwnYAFQIIYLFtddey86dO3njjTd49dVXgaqyX2lpaRgMBlauXFkjyFuyZAnr1q0jMjKSlJQUfvjhB1atWtVg20cffcS7776L2+0mNDSUBQsW0Lt3b1atWsUnn3xCdHQ0hw4dYtGiRTUSDh8+fJi//OUv3nJp06ZNY8yYMbz//vt4PB6+//57brzxRu69917eeecd/vWvfxEXF0dKSooPf4pN1+C7V2ZmZosv0rdvX/bt21drW1JSEitWrGjVNtF0ZRUOn5Qw+27naT7MPEC/7lHcddNADPrADfAAQi2GOothCyGEaLzBgwd7Ywqn08maNWt4//330ev1TJ06lblz52IwGMjMzGTjxo1kZGRgMpl49NFHveeor23r1q18+umnvPPOOxgMBjZt2sTTTz/N+++/D8DPP/9MRkYG3bt3v6hv7777LuPGjeOhhx4CoKSkhIiICG699VYqKip46qmnANi7dy9/+9vfWL16NbGxsSxYsKCtflytotF58kT75faolJa3ffLjTT+f5MPMAwzoFc3dUwYFfICn0Sh+XycohBDtxfnLvDZu3EivXr3o3r07iYmJDBgwgM8//xyoWgd3/fXXY7FY0Gg0TJ061XtcfW2ZmZns3buXmTNnkpaWxv/8z/9w5swZb/uwYcNqDfCgqnTrypUreeWVV/jhhx8IDw+v9Xk//fQTEyZMIDY2FoBZs2Y198fhEzIPJXxSwuzLLcdZ+90RLk2K5bc3JKPTBv7nC7NRG/CBqBBCBItdu3bRt29fAFauXMnBgwdJTU0FqjZ5rly5khtvvBFVVeucQWmobcaMGTz22GO1ttdXo3fSpEkMGTKE7777jn/84x+sXLnSW7ThwmsEk8B/pxVtqq1LmKmqymc/HmXtd0cY2i+O3wVJgAdVU7VCCCFa7osvvuC9997jzjvvJC8vjy1btvDll1+SmZlJZmYmmzZtYvfu3Zw+fZpRo0bx2WefedfHffzxx97z1NeWmppKRkaGd/TO7XY3ekfqsWPHiIuLY/r06Tz00EPs2rULgNDQUMrKympcf9OmTRQUFABV6woDmYzkdXBtWcJMVVXWfX+EL7acYGRyArde0z9oar/qtAoWmaoVQohme/TRR70pVJKSkli+fDlDhgxh+fLljBs3jtDQUO9zjUYjEydOZNWqVTz88MNs376dtLQ0EhISGDx4MCUlJQBMnDixzraRI0fyxz/+kQceeAC3243T6eS6665j0KBBDfb1008/Zc2aNej1ehRF8W4wvfrqq8nIyCAtLc278eL+++/ntttuIzY2lgkTJrT+D64VKWqwjT22gup8M5InD06dLcNW2foVLlRVJePrQ2zaforLByUyc2JfNAG+geH8PHmRYQZiIyU3XiAK9NeUqCL3yXeys7Nr7BQF/+fJa6ny8nJCQ0PxeDw888wzxMfH8/jjjzfY1h7Udj+bG7fISF4H1lYlzDyqyqqNB/lu52nGDunCtPFJQbVDVaNAiOTGE0IEMbNR36hgzKpxExISWLXCAZ566ilOnTpFZWUlAwcO5J577mlUm6hJgrwOrKzCQWuP43o8Kh98uZ/Ne85w1fCu3DSmd1AFeOC7T6pCCCFq9/rrrzerTdQkQV4HZXe4sNpcrXpOt0flvQ172bY3j2tSunP96J5BF+CBbLgQQgjRPkiQ10G1dgkzt9vD25/tZceBs1w/uifXjurRauf2Ja1GNlwIIYKPx+NBowmOzAWibq29TUJ+Izqg1i5h5nJ5+NcnWew4cJYpY3sHbYAHEGLWodfJy0IIETxCQkI4deoUDocj6PK4iV+pqkpBQQEmU+utkZSRvA6oNUuYOVxu/rU2i+yjhUyf0IexQ7q0ynn9QavREGqWqVohRHDp2rUr+fn5HDt2DJeractwHA4HBoP83QsUJpOJrl27ttr5JMjrYFqzhJnd6eaNj3dz8EQxMyf25YpLO7fKef3FYNBhNslLQggRXDQaDfHx8cTHxzf52G3btjF48OA26JUIBPKO1sE0t4TZvOXf1znFe9u1/UkZ0KmlXfO7MIshKDeKCCGEELWRxUcdSEtKmNW3hq89BHhajYJBK2tZhBBCtB8S5HUgbVnCLJjptAoJMRZUT+umlBFCCCH8SaZrO5BSq73Vkx8HO7NRS1yUBYNeK7vShBBCtCsS5HUQbVXCLJiFhRiIjTCh1cqAthBCiPZHgrwOoi1KmAUrRYGocCNRYSbZaCGEEKLdkiCvA2iNEmZ6rQan++L1fGGW4KoOodUqxEaaCZPSZUIIIdo5CfI6gJaWMNt7tBCn28PEEd2YPKZ3K/bMt4wGDXFRFkwG+bUXQgjR/sm7XTvX0hJmlXYX//lyPwnRFiZd3rP1OuZjFpOOuCiLlCwTQgjRYcg7XjvX0hJmH397mJJyO7de0z8oAyRFgcgwA51iQoKy/0IIIURzyUheO9bSEmYHThTxw64cJgzrSs/E8FbsmW9oNAoxESYiQo3+7ooQQgjhcxLktWPNLWEGYHe4ef/z/cRFmrn+ip6t2zEf0GkV4qMtWEzBtTFECCGEaC0yf9VOtaSEGcDa7w5TVFrJrdf0x6DTtmLP2p7ZqKVzXKgEeEIIITo0Gclrp1pSwuzQyWK+3XGasUO60LtLRCv3rG1JgmMhhBCiik/eCdPT00lNTaV///7s37/f+3hqairXXXcdaWlppKWl8c0333jbjhw5wqxZs5g0aRKzZs3i6NGjjWoTVUqtzUt+7HC6ef/zfcREmLjxyl6t37E2oigQHWEiPsosAZ4QQgiBj4K8iRMn8s4779ClS5eL2l599VUyMjLIyMhg7Nix3sfnz5/P7NmzWb9+PbNnz2bevHmNahPVJcyal/x43fdHyC+pZNbV/TDqg2OaVntu/V10uFSwEEIIIar5JMgbMWIEiYmJjX5+QUEBWVlZTJ48GYDJkyeTlZVFYWFhvW2iSnNLmB05XcLX209xxaWJ9O0W1fodawNGg4bE2BCpYCGEEEJcwO9r8ubMmYOqqgwfPpwnnniC8PBwcnJySEhIQKutGknSarXEx8eTk5ODqqp1tkVHRzfp2rt3727176c227Zt88l1ADQ6PbmFdpyupo3kudwqK78vJMSkoV+Ck+y92W3Uw9ahKAoRoSbCzBryTjY/2fOFfHmvRPPJfQoOcp+Cg9yn9suvQd4777xDYmIiDoeDRYsWsXDhQl5++WWfXX/QoEEYjW2bQ23btm0MHz68Ta9xvvziCsKiHU0+bs03hymxurlv2qVc0qNpwbKvKQpEhBqIDjej0bTe9Kyv75VoHrlPwUHuU3CQ+xQc7HZ7swam/LpCvXoK12AwMHv2bH7++Wfv47m5ubjdbgDcbjd5eXkkJibW29bRNbeE2fEzpWz8+QSjBnYK+ABPo1GIjTQTG2lp1QBPCCGEaG/8FuRVVFRQVlYGVOV0W7duHcnJyQDExMSQnJzM2rVrAVi7di3JyclER0fX29bRNaeEmcvl4b3P9xEeYiBtXFIb9ax16HUaOsVYpIKFEEII0Qg+ma594YUX2LBhA/n5+dx5551ERkaybNkyHnnkEdxuNx6Ph6SkJObPn+89ZsGCBcydO5elS5cSHh5Oenp6o9o6quaWMNvw0zHOFFRwT9ogzEa/L9Gsk9moJS7KgiFIdvwKIYQQ/uaTd/Vnn32WZ5999qLHV69eXecxSUlJrFixosltHVVzSpidzCvjyy3HGZGcwIBeMW3Us5aTBMdCCCFE0wXu0I1otOaUMHO5Pby3YR8hZgNTxwfmNK2iQFS4iagwo+S/E0IIIZpIhkbageaUMPtyy3FO51uZObEvIQFY41USHAshhBAtIyN57UBTS5idzi/n85+OM6x/PJcmxbZdx5rJaNAQF2XBZJBfTyGEEKK55F00yDW1hJnbo/Lehn2YTTqmTejThj1rnhCznthIM3qdDDILIYQQLSHvpEGuqSXMNm49wcm8cmZc1ZdQc+BM0yoKRIYZSIi2SIAnhBBCtAIZyQtidocLq63xo3hnCqx8tvkog/vGMqRvXBv2rGk0GoXYCBPhkv9OCCGEaDUS5AWxsgoHHk/jhvE8HpX3P9+HSa9lxoS+bdyzxtPrNMRFmbEE4OYPIYQQIpjJvFiQamoJs03bT3LsTBnTJvQhLMTQhj1rPLNRS2JsiAR4QgghRBuQkbwg1ZQSZnlFFXz6/VEG9Y5hWP/4Nu5ZwxSqEhzHRJrRSv1ZIYQQok1IkBeEmlLCrHqaVqfTcPPEvn7POScJjoUQQgjfkCAvCDWlhNk3O05x5HQpt13bn4gQ/25s0GoV4iIthFpkelYIIYRoaxLkBZmmlDDLL7bxyXdHSO4ZzcjkhDbuWf2MBg3xURaMkuBYCCGE8Al5xw0yjS1h5lFV/vPFPrQahVsm9vPr1KgkOBZCCCF8T4K8INPYEmY/7Mzh4MkSZl3dj8gw/0zTKgpEhBqIDjejkQ0WQgghhE9JkBdEGlvCrLC0kjXfHqZf9yhGDezkg55dTBIcCyGEEP4lQV4QaUwJM1VV+c8X+wGYdbV/pmklwbEQQgjhfxLkBYnGljDbvOcM+48XcfNVfYkON/mgZzWZjVrioiwY9FqfX1sIIYQQv5IgL0g0poRZcZmdjK8P0adrBKMvS/RRz6pIgmMhhBAisEiQFwQaU8JMVVU++HI/Ho/KrKv7o/HhNK2iQHS4iUhJcCyEEEIEDAnygkBjSphtyc4l+2ghU8cnERtp9lHPJMGxEEIIEagkyAtwjSlhVlJuZ/WmQ/TqHM7YIV181DNJcCyEEEIEMnl3DnANlTBTVZUPMw/gcnm49RrfTdOGmPXERZnRaSXBsRBCCBGIJMgLYI0pYfbzvjx2Hy5gytjexEdZ2rxPkuBYCCGECA4S5AUwq81VbwmzMquDVV8dpEenMMYP7drm/dEoCrGRkuBYCCGECAYS5AWwEqu93uTHH248gN3prpqmbeNRNZ1WIT7aIgmOhRBCiCDhkwVV6enppKam0r9/f/bv3+99/MiRI8yaNYtJkyYxa9Ysjh492uK29qKhEma/HDjLzoP5XDeqJ51iQtq0Lyajls5xoRLgCSGEEEHEJ0HexIkTeeedd+jSpebOz/nz5zN79mzWr1/P7NmzmTdvXovb2ov6SpiV25yszDxA1/hQrhrRrU37EWLW0ykmRCpYCCGEEEHGJ0HeiBEjSEysWYGhoKCArKwsJk+eDMDkyZPJysqisLCw2W3tRUMlzD766iA2u4vbru3fZtUlFAWiwo10irHIDlohhBAiCPltTV5OTg4JCQlotVUjRFqtlvj4eHJyclBVtVlt0dHRTerD7t27W/ebqsO2bdsa/VxFUbB7dOQXWWttP5pr5+d9JQzvE0JJ/glK8lurl7/S63TERJooPeviqKfujR/tUVPulfAfuU/BQe5TcJD71H516I0XgwYNwmhs252i27ZtY/jw4Y1+vtPl4WReGXEJF8/VWiudvPf1VjrHhnDb9cPQtsEIW0feYNHUeyX8Q+5TcJD7FBzkPgUHu93erIEpvwV5iYmJ5Obm4na70Wq1uN1u8vLySExMRFXVZrW1B/WVMFu96RDWSif3Th3UJgGeyaglPsoi6++EEEKIdsBvi61iYmJITk5m7dq1AKxdu5bk5GSio6Ob3Rbs6ithtudIAVuzc5k4ohtd48Na/dqhFj2JssFCCCGEaDd8MpL3wgsvsGHDBvLz87nzzjuJjIzkk08+YcGCBcydO5elS5cSHh5Oenq695jmtgWzukqY2ewuVny5n04xFq5N6dGq11QUiAwzEh1uQvFRSTQhhBBCtD2fBHnPPvsszz777EWPJyUlsWLFilqPaW5bsKqvhFnG14cotTr4w+SB6HStN/iq0ZyrYBEiFSyEEEKI9qZDb7wIJHWVMNt7rJDNe86QOrwb3TuFt9r19DoNcVHmDrnBQgghhOgIJMgLEKW1lDCrdLj44Iv9xEeZuW50z1a7ltmoJU42WAghhBDtmmS5DQAVlU5stZQwW/PNYYrL7Nx6TX/0rTRNGxYiFSyEEEKIjkBG8gJAbSXMDpwo4vtdOYwf2oVenSNafA3ZYCGEEEJ0LBLk+VltJczsDjfvf76f2EgzN1zRq8XX0GgVYiPMhIcYWnwuIYQQQgQHma71s7IKBx5PzWG8T74/QmFpJbde3a/F06p6vYbEGIsEeEIIIUQHIyN5fuR0eSircNZ47NCpYr755RRjBncmqWtki85vNuqIizLL+jshhBCiA5Igz48uLGHmcLr5z+f7iQ43MfnK3i06d1iIgdhIM1qNrL8TQgghOiKZrvWT2kqYffrDUc4W27j1mn4YDc0bfVMUiI4wEh8lAZ4QQgjRkclInp9cWMLsaE4pm7afZPSlifTtFtWsc2q0CnGRZsIssv5OCCGE6OgkyPODC0uYOV0e3tuwj4hQI1PGNG+a1mDQEBdpxmyUChZCCCGEkOlav7iwhNn6H4+SV1TBrIn9MBmbHnebTToSY0IkwBNCCCGEl4zk+cH5JcyO55axcdsJUgZ04pKe0U06j0LVBosY2WAhhBBCiAtIkOdj55cwc7k8vL9hH2EWA1PHJTXpPIoCUeEmosKMUsFCCCGEEBeR6VofO7+E2edbjpFTYGXmxH6YTY2Pt7Vahfhoi5QoE0IIIUSdZCTPh84vYXYqr5wvtpxg+CXxDOwd0+hzyAYLIYQQQjSGBHk+VF3CzO328N7n+wgx6Zg2oU+jj7eYqipY6HVSwUIIIYQQ9ZPpWh85v4TZl1tPcOpsOTen9iPE1PCInAKEhxpIiAmRAE8IIYQQjSIjeT5SXcLsdH45GzYfY2i/OC7rE9vgcZrqDRbhJh/0UgghhBDthQR5PlBdwsztUXlvwz7MRh3TGzFNq9UqxEVaCLXI+jshhBBCNI1M1/pAdQmzjdtOcDKvnOlX9SG0gdJjRoOGxNgQCfCEEEII0SwyktfGtFotJVY7uYVW1v94lMv6xDKkb1y9x1RtsLCg10kMLoQQQojmkSCvjalosNvdvLdhHwa9lpuv6ltnbjtFgfAQAzERZjRSwUIIIYQQLSBDRW1MBb7afpJjZ8qYPqEPYSG1T9NqFIiJMBEXZZEATwghhBAtJiN5beCOBZ9RXGa/6PGMrw8x/JKEix7XahXioyyEmGX9nRBCCCFaR0AEeampqRgMBoxGIwBz5sxh7NixHDlyhLlz51JcXExkZCTp6en07NkToN42f6stwAO8efLOZzRoiI+yYDQExK0QQgghRDsRMJHFq6++Sr9+/Wo8Nn/+fGbPnk1aWhoZGRnMmzePf//73w22BbJ/7F7u/bdWo6DXaZHys4GhrKyMNSWb/N0N0QC5T8FB7lNwaK/36apeVzC+1+X+7obfBeyavIKCArKyspg8eTIAkydPJisri8LCwnrbgoVOq0GvlwBPCCGEEG0jYEby5syZg6qqDB8+nCeeeIKcnBwSEhLQaqvKeGm1WuLj48nJyUFV1TrboqOjG33N3bt3t8n3Up8JpgnERJgxaNy43W6fX1/UI8LfHRCNIvcpOMh9Cg7t9T4VwrbCbf7uhd8FRJD3zjvvkJiYiMPhYNGiRSxcuJDf//73bX7dQYMGedcBtqp3T9bZNO7yobLBIkBt27aN4cOH+7sbogFyn4KD3KfgIPcpONjt9mYNTAXEdG1iYiIABoOB2bNn8/PPP5OYmEhubq53tMvtdpOXl0diYmK9bYEgMqz2wDEi1CABnhBCCCF8wu8jeRUVFbjdbsLCwlBVlXXr1pGcnExMTAzJycmsXbuWtLQ01q5dS3Jysnc6tr42f3t7wXXef//8y046d0siNtKMThsQMbUQQgghOgC/B3kFBQU88sgjuN1uPB4PSUlJzJ8/H4AFCxYwd+5cli5dSnh4OOnp6d7j6msLJBoF4iXBsRBCCCF8zO9BXrdu3Vi9enWtbUlJSaxYsaLJbYHE7XJKgCeEEEIIn5P5QyGEEEKIdkiCPCGEEEKIdkiCPCGEEEKIdkiCPCGEEEKIdkiCPCGEEEKIdkiCPCGEEEKIdkiCPCGEEEKIdkiCPCGEEEKIdkiCPCGEEEKIdsjvFS/8QVVVABwOh0+uZ7fbfXId0XJyr4KD3KfgIPcpOMh9CnzV8Up1/NJYitrUI9qBsrIy9u/f7+9uCCGEEEI0Wr9+/QgLC2v08ztkkOfxeLBarej1ehRF6soKIYQQInCpqorT6SQkJASNpvEr7TpkkCeEEEII0d7JxgshhBBCiHZIgjwhhBBCiHZIgjwhhBBCiHZIgjwhhBBCiHZIgjwhhBBCiHZIgjwhhBBCiHZIgjwhhBBCiHZIgrw2dOTIEWbNmsWkSZOYNWsWR48e9XeXxAWKioq45557mDRpEjfddBMPP/wwhYWF/u6WqMdrr71G//79pWpNgLLb7cyfP59rr72Wm266ieeee87fXRJ12LhxI1OnTiUtLY2bbrqJDRs2+LtLAkhPTyc1NfWiv3PNiSkkyGtD8+fPZ/bs2axfv57Zs2czb948f3dJXEBRFO6++27Wr1/PmjVr6NatGy+//LK/uyXqsGfPHn755Rc6d+7s766IOrz00ksYjUbva+qxxx7zd5dELVRV5c9//jMvvvgiGRkZvPTSSzz11FN4PB5/d63DmzhxIu+88w5dunSp8XhzYgoJ8tpIQUEBWVlZTJ48GYDJkyeTlZUlo0QBJjIyklGjRnm/HjJkCKdPn/Zjj0RdHA4HCxcuZP78+VKOMEBZrVZWr17NY4895r1HsbGxfu6VqItGo6GsrAyoqukeHx/fpJJZom2MGDGCxMTEGo81N6bQtVkvO7icnBwSEhLQarUAaLVa4uPjycnJITo62s+9E7XxeDy89957pKam+rsrohb/+7//y5QpU+jWrZu/uyLqcOLECSIjI3nttdfYvHkzISEhPPbYY4wYMcLfXRMXUBSFV155hQcffBCLxYLVauXvf/+7v7sl6tDcmEJCdiHOef7557FYLNx+++3+7oq4wPbt29m1axezZ8/2d1dEPVwuFydOnGDAgAGsWrWKOXPm8Mgjj1BeXu7vrokLuFwu/v73v7N06VI2btzI3/72Nx5//HGsVqu/uyZakQR5bSQxMZHc3FzcbjcAbrebvLy8i4ZgRWBIT0/n2LFjvPLKKzJdEYC2bNnC4cOHmThxIqmpqZw5c4a77rqLb7/91t9dE+fp3LkzOp3OO6U0ePBgoqKiOHLkiJ97Ji6UnZ1NXl4ew4cPB2D48OGYzWYOHTrk556J2jQ3ppB3szYSExNDcnIya9euBWDt2rUkJyfLVG0AWrJkCbt37+b111/HYDD4uzuiFvfeey/ffvstmZmZZGZm0qlTJ9544w3GjBnj766J80RHRzNq1Ci+++47oGo3YEFBAT169PBzz8SFOnXqxJkzZzh8+DAAhw4dIj8/n+7du/u5Z6I2zY0pFFVVVV90sCM6dOgQc+fOpbS0lPDwcNLT0+ndu7e/uyXOc+DAASZPnkzPnj0xmUwAdO3alddff93PPRP1SU1NZdmyZfTr18/fXREXOHHiBE8//TTFxcXodDr++Mc/Mn78eH93S9Ti448/5h//+Id3k8yjjz7K1Vdf7edeiRdeeIENGzaQn59PVFQUkZGRfPLJJ82KKSTIE0IIIYRoh2S6VgghhBCiHZIgTwghhBCiHZIgTwghhBCiHZIgTwghhBCiHZIgTwghhBCiHZIgTwgh2tDQoUM5ceKEv7shhOiAJMgTQrRrqampfP/996xatYrbbrutTa91xx13sGLFihqPbd++XertCiH8QoI8IYRoBJfL5e8uCCFEk0iQJ4Ro9w4dOsT8+fP55ZdfGDp0KCNGjADA4XCQnp7OhAkTuOKKK5g3bx6VlZUAbN68mXHjxrF8+XKuvPJK/vKXv1BSUsJ9993H5ZdfzsiRI7nvvvs4c+YMUFUeb+vWrSxcuJChQ4eycOFCAPr378+xY8cAKCsr489//jOXX345V111FUuXLsXj8QB4RxrT09MZOXIkqampbNq0yfs9rFq1iokTJzJ06FBSU1P5+OOPffbzE0IEJwnyhBDtXlJSEv/1X//FkCFD2L59O1u3bgXgpZde4siRI6xevZoNGzaQl5dXo6Rdfn4+JSUlbNy4keeffx6Px8P06dPZuHEjGzduxGg0eoO5xx9/nBEjRjBv3jy2b9/OvHnzLurH888/T1lZGV988QVvv/02GRkZrFy50tu+c+dOevXqxY8//sjdd9/NM888g6qqVFRU8MILL/CPf/yD7du38/7775OcnNzGPzUhRLCTIE8I0SGpqsqKFSt4+umniYyMJDQ0lPvuu49PPvnE+xyNRsOjjz6KwWDAZDIRFRXFpEmTMJvNhIaG8sADD7Bly5ZGXc/tdrNu3Tr+9Kc/ERoaSteuXbnzzjtrjMh17tyZW265Ba1Wy7Rp0zh79iz5+fnevhw4cIDKykri4+Pp27dv6/5AhBDtjs7fHRBCCH8oLCzEZrMxffp072OqqnqnTwGioqIwGo3er202G//93//NN998Q0lJCQBWqxW3241Wq633ekVFRTidTjp37ux9rHPnzuTm5nq/jo2N9f7bbDYDUFFRQVxcHEuWLOHNN9/kmWeeYdiwYTz11FMkJSU187sXQnQEEuQJIToERVFqfB0VFYXJZOKTTz4hISGhUce8+eabHDlyhA8++IC4uDiys7OZOnUqqqo2eP2oqCj0ej2nT5+mT58+AOTk5NR57QuNHTuWsWPHUllZySuvvMJzzz3Hu+++26hjhRAdk0zXCiE6hJiYGHJzc3E4HEDV9OfMmTNZvHgxBQUFAOTm5vLNN9/UeQ6r1YrRaCQ8PJzi4mJee+21Gu2xsbF15sTTarVcd911LFmyhPLyck6dOsVbb73FlClTGux7fn4+X375JRUVFRgMBiwWS4Mjh0IIIUGeEKJDuPzyy+nTpw9jxoxh1KhRADz55JP06NGDW265hWHDhvH73/+eI0eO1HmO3/3ud9jtdi6//HJmzZrF2LFja7T/9re/Zf369YwcOZIXXnjhouOfe+45zGYzV199NbNnz2by5MnMmDGjwb57PB7eeustxo4dS0pKClu2bGH+/PlN/AkIIToaRW3MPIMQQgghhAgqMpInhBBCCNEOSZAnhBBCCNEOSZAnhBBCCNEOSZAnhBBCCNEOSZAnhBBCCNEOSZAnhBBCCNEOSZAnhBBCCNEOSZAnhBBCCNEOSZAnhBBCCNEO/f8BzOuSD3aUfaAAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "run ./cs285/report_plots.py" + ] + } + ], + "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", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}