{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Using TensorFlow backend.\n" ] } ], "source": [ "import keras\n", "from keras.models import Sequential, Model, load_model\n", "\n", "from keras.layers import Dense, Dropout, Activation, Flatten, Input, Lambda\n", "from keras.layers import Conv2D, MaxPooling2D, Conv1D, MaxPooling1D, LSTM, ConvLSTM2D, GRU, BatchNormalization, LocallyConnected2D, Permute\n", "from keras.layers import Concatenate, Reshape, Softmax, Conv2DTranspose, Embedding, Multiply\n", "from keras.callbacks import ModelCheckpoint, EarlyStopping, Callback\n", "from keras import regularizers\n", "from keras import backend as K\n", "import keras.losses\n", "\n", "import tensorflow as tf\n", "from tensorflow.python.framework import ops\n", "\n", "import isolearn.keras as iso\n", "\n", "import numpy as np\n", "\n", "import tensorflow as tf\n", "import logging\n", "logging.getLogger('tensorflow').setLevel(logging.ERROR)\n", "\n", "import pandas as pd\n", "\n", "import os\n", "import pickle\n", "import numpy as np\n", "\n", "import scipy.sparse as sp\n", "import scipy.io as spio\n", "\n", "import matplotlib.pyplot as plt\n", "\n", "import isolearn.io as isoio\n", "import isolearn.keras as isol\n", "\n", "from genesis.visualization import *\n", "from genesis.generator import *\n", "from genesis.predictor import *\n", "from genesis.optimizer import *\n", "\n", "from definitions.generator.aparent_deconv_conv_generator_concat import load_generator_network, get_shallow_copy_function\n", "from definitions.predictor.aparent import load_saved_predictor\n", "\n", "import sklearn\n", "from sklearn.decomposition import PCA\n", "from sklearn.manifold import TSNE\n", "\n", "from scipy.stats import pearsonr\n", "\n", "import seaborn as sns\n", "\n", "from matplotlib import colors\n", "\n", "class IdentityEncoder(iso.SequenceEncoder) :\n", " \n", " def __init__(self, seq_len, channel_map) :\n", " super(IdentityEncoder, self).__init__('identity', (seq_len, len(channel_map)))\n", " \n", " self.seq_len = seq_len\n", " self.n_channels = len(channel_map)\n", " self.encode_map = channel_map\n", " self.decode_map = {\n", " nt: ix for ix, nt in self.encode_map.items()\n", " }\n", " \n", " def encode(self, seq) :\n", " encoding = np.zeros((self.seq_len, self.n_channels))\n", " \n", " for i in range(len(seq)) :\n", " if seq[i] in self.encode_map :\n", " channel_ix = self.encode_map[seq[i]]\n", " encoding[i, channel_ix] = 1.\n", "\n", " return encoding\n", " \n", " def encode_inplace(self, seq, encoding) :\n", " for i in range(len(seq)) :\n", " if seq[i] in self.encode_map :\n", " channel_ix = self.encode_map[seq[i]]\n", " encoding[i, channel_ix] = 1.\n", " \n", " def encode_inplace_sparse(self, seq, encoding_mat, row_index) :\n", " raise NotImplementError()\n", " \n", " def decode(self, encoding) :\n", " seq = ''\n", " \n", " for pos in range(0, encoding.shape[0]) :\n", " argmax_nt = np.argmax(encoding[pos, :])\n", " max_nt = np.max(encoding[pos, :])\n", " seq += self.decode_map[argmax_nt]\n", "\n", " return seq\n", " \n", " def decode_sparse(self, encoding_mat, row_index) :\n", " raise NotImplementError()\n", "\n", "from keras.backend.tensorflow_backend import set_session\n", "\n", "def contain_tf_gpu_mem_usage() :\n", " config = tf.ConfigProto()\n", " config.gpu_options.allow_growth = True\n", " sess = tf.Session(config=config)\n", " set_session(sess)\n", "\n", "contain_tf_gpu_mem_usage()\n" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "\n", "class GenesisMonitor(Callback):\n", " def __init__(self, generator_model, sequence_encoder, run_dir=\"\", run_prefix=\"\", n_sequences=32, batch_size=32, input_tensor_funcs=None) :\n", " self.generator_model = generator_model\n", " self.batch_size = batch_size\n", " self.n_sequences = n_sequences\n", " self.input_tensor_funcs = input_tensor_funcs\n", " self.sequence_encoder = sequence_encoder\n", " self.run_prefix = run_prefix\n", " self.run_dir = run_dir\n", " \n", " if not os.path.exists(self.run_dir): os.makedirs(self.run_dir)\n", "\n", " seqs = self._sample_sequences()\n", " self._store_sequences(seqs, 0)\n", " \n", " def _sample_sequences(self) :\n", " n_batches = self.n_sequences // self.batch_size\n", " \n", " self.input_tensors = [self.input_tensor_funcs[i](i) for i in range(len(self.input_tensor_funcs))]\n", " gen_bundle = self.generator_model.predict(x=self.input_tensors, batch_size=self.batch_size)\n", " _, _, _, _, _, sampled_pwm, _, _, _ = gen_bundle\n", " \n", " seqs = [\n", " self.sequence_encoder.decode(sampled_pwm[i, 0, :, :, 0]) for i in range(sampled_pwm.shape[0])\n", " ]\n", " \n", " return seqs\n", " \n", " def _store_sequences(self, seqs, epoch) :\n", " #Save sequences to file\n", " with open(self.run_dir + self.run_prefix + \"_epoch_\" + str(epoch) + \"_\" + str(self.n_sequences) + \"_sequences.txt\", \"wt\") as f:\n", " for i in range(len(seqs)) :\n", " f.write(seqs[i] + \"\\n\")\n", " \n", " def on_epoch_end(self, epoch, logs={}) :\n", " \n", " seqs = self._sample_sequences()\n", " self._store_sequences(seqs, epoch)\n" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "\n", "#Define target isoform loss function\n", "def get_isoform_loss(target_isos, fitness_target=1.0, fitness_weight=2.0, isoform_start=80, isoform_end=115, use_start=0, use_end=70, use_target_bits=1.8, cse_start=70, cse_end=76, cse_target_bits=1.8, dse_start=76, dse_end=125, dse_target_bits=1.8, entropy_weight=0.0, entropy_loss_mode='margin', similarity_weight=0.0, similarity_margin=0.5, punish_dn_cse=0.0, punish_up_c=0.0, punish_dn_c=0.0, punish_up_g=0.0, punish_dn_g=0.0, punish_up_aa=0.0, punish_dn_aa=0.0) :\n", " \n", " target_iso = np.zeros((len(target_isos), 1))\n", " for i, t_iso in enumerate(target_isos) :\n", " target_iso[i, 0] = t_iso\n", " \n", " masked_use_entropy_mse = get_target_entropy_sme_masked(pwm_start=use_start, pwm_end=use_end, target_bits=use_target_bits)\n", " cse_entropy_mse = get_target_entropy_sme(pwm_start=cse_start, pwm_end=cse_end, target_bits=cse_target_bits)\n", " masked_dse_entropy_mse = get_target_entropy_sme_masked(pwm_start=dse_start, pwm_end=dse_end, target_bits=dse_target_bits)\n", " if entropy_loss_mode == 'margin' :\n", " masked_use_entropy_mse = get_margin_entropy_ame_masked(pwm_start=use_start, pwm_end=use_end, min_bits=use_target_bits)\n", " cse_entropy_mse = get_margin_entropy_ame(pwm_start=cse_start, pwm_end=cse_end, min_bits=cse_target_bits)\n", " masked_dse_entropy_mse = get_margin_entropy_ame_masked(pwm_start=dse_start, pwm_end=dse_end, min_bits=dse_target_bits)\n", " \n", " punish_dn_cse_func = get_punish_cse(pwm_start=74, pwm_end=dse_end)\n", " \n", " punish_up_c_func = get_punish_c(pwm_start=use_start, pwm_end=use_end)\n", " punish_dn_c_func = get_punish_c(pwm_start=dse_start, pwm_end=dse_end)\n", " \n", " punish_up_g_func = get_punish_g(pwm_start=use_start, pwm_end=use_end)\n", " punish_dn_g_func = get_punish_g(pwm_start=use_start, pwm_end=use_end)\n", " \n", " punish_up_aa_func = get_punish_aa(pwm_start=use_start, pwm_end=use_end)\n", " punish_dn_aa_func = get_punish_aa(pwm_start=dse_start, pwm_end=dse_end)\n", " \n", " pwm_sample_entropy_func = get_pwm_margin_sample_entropy_masked(pwm_start=70-60, pwm_end=76+60, margin=similarity_margin, shift_1_nt=True)\n", " \n", " extra_sim = np.ones((len(target_isos), 1, 205, 4, 1))\n", " for i in range(len(target_isos)) :\n", " extra_sim[i, 0, 70-4:76, :, 0] = 0.0\n", " \n", " def loss_func(loss_tensors) :\n", " _, _, _, sequence_class, pwm_logits_1, pwm_logits_2, pwm_1, pwm_2, sampled_pwm_1, sampled_pwm_2, mask, sampled_mask, iso_pred, cut_pred, iso_score_pred, cut_score_pred = loss_tensors\n", " \n", " #Create target isoform with sample axis\n", " iso_targets = K.constant(target_iso)\n", " iso_true = K.gather(iso_targets, sequence_class[:, 0])\n", " iso_true = K.tile(K.expand_dims(iso_true, axis=-1), (1, K.shape(sampled_pwm_1)[1], 1))\n", "\n", " #Specify costs\n", " iso_loss = fitness_weight * K.mean(K.maximum(-K.print_tensor(iso_score_pred[..., 0], message=\"iso_score_pred=\") + fitness_target, K.zeros_like(iso_score_pred[..., 0])), axis=1)\n", " \n", " seq_loss = 0.0\n", " seq_loss += punish_dn_cse * K.mean(punish_dn_cse_func(sampled_pwm_1), axis=1)\n", " \n", " seq_loss += punish_up_c * K.mean(punish_up_c_func(sampled_pwm_1), axis=1)\n", " seq_loss += punish_dn_c * K.mean(punish_dn_c_func(sampled_pwm_1), axis=1)\n", " \n", " seq_loss += punish_up_g * K.mean(punish_up_g_func(sampled_pwm_1), axis=1)\n", " seq_loss += punish_dn_g * K.mean(punish_dn_g_func(sampled_pwm_1), axis=1)\n", " \n", " seq_loss += punish_up_aa * K.mean(punish_up_aa_func(sampled_pwm_1), axis=1)\n", " seq_loss += punish_dn_aa * K.mean(punish_dn_aa_func(sampled_pwm_1), axis=1)\n", " \n", " entropy_loss = entropy_weight * ((masked_use_entropy_mse(pwm_1, mask) if use_target_bits is not None else 0.0) + (cse_entropy_mse(pwm_1) if cse_target_bits is not None else 0.0) + (masked_dse_entropy_mse(pwm_1, mask) if dse_target_bits is not None else 0.0))\n", " \n", " extra_sims = K.constant(extra_sim)\n", " extra_sim_mask = K.gather(extra_sims, sequence_class[:, 0])\n", " extra_sim_mask = K.tile(extra_sim_mask, (1, K.shape(sampled_pwm_1)[1], 1, 1, 1))\n", " entropy_loss += similarity_weight * K.mean(pwm_sample_entropy_func(sampled_pwm_1, sampled_pwm_2, sampled_mask * extra_sim_mask), axis=1)\n", " \n", " #Compute total loss\n", " total_loss = iso_loss + seq_loss + entropy_loss\n", "\n", " return total_loss\n", " \n", " return loss_func\n", "\n", "class EpochVariableCallback(Callback):\n", " def __init__(self, my_variable, my_func):\n", " self.my_variable = my_variable \n", " self.my_func = my_func\n", " def on_epoch_end(self, epoch, logs={}):\n", " K.set_value(self.my_variable, self.my_func(K.get_value(self.my_variable), epoch))\n", "\n", "#Function for running GENESIS\n", "def run_genesis(run_prefix, sequence_templates, loss_func, library_contexts, model_path, batch_size=32, n_samples=1, n_epochs=10, steps_per_epoch=100, n_intermediate_sequences=960) :\n", " \n", " #Build Generator Network\n", " _, generator = build_generator(batch_size, len(sequence_templates[0]), load_generator_network, n_classes=len(sequence_templates), n_samples=n_samples, sequence_templates=sequence_templates, batch_normalize_pwm=False)\n", "\n", " #Build Validation Generator Network\n", " _, val_generator = get_generator_copier(generator)(batch_size, len(sequence_templates[0]), get_shallow_copy_function(generator), n_classes=len(sequence_templates), n_samples=n_samples, sequence_templates=sequence_templates, batch_normalize_pwm=False, validation_sample_mode='sample', supply_inputs=True)\n", " \n", " #Build Predictor Network and hook it on the generator PWM output tensor\n", " _, predictor = build_predictor(generator, load_saved_predictor(model_path, library_contexts=library_contexts), batch_size, n_samples=n_samples, eval_mode='sample')\n", "\n", " #Build Loss Model (In: Generator seed, Out: Loss function)\n", " _, loss_model = build_loss_model(predictor, loss_func)\n", " \n", " #Specify Optimizer to use\n", " opt = keras.optimizers.Adam(lr=0.001, beta_1=0.9, beta_2=0.999)\n", "\n", " #Compile Loss Model (Minimize self)\n", " loss_model.compile(loss=lambda true, pred: pred, optimizer=opt)\n", " \n", " #Randomized validation tensors\n", " val_random_tensor_funcs = [\n", " lambda i: np.array(np.zeros(n_intermediate_sequences)).reshape(-1, 1),\n", " lambda i: np.random.uniform(-1, 1, (n_intermediate_sequences, 100)),\n", " lambda i: np.random.uniform(-1, 1, (n_intermediate_sequences, 100))\n", " ]\n", "\n", " #Standard sequence decoder\n", " acgt_encoder = IdentityEncoder(205, {'A':0, 'C':1, 'G':2, 'T':3})\n", " \n", " #Build callback for printing intermediate sequences\n", " random_genesis_monitor = GenesisMonitor(val_generator, acgt_encoder, run_dir=\"./samples/\" + run_prefix + \"/\", run_prefix=\"intermediate\", n_sequences=n_intermediate_sequences, batch_size=batch_size, input_tensor_funcs=val_random_tensor_funcs)\n", "\n", " #Fit Loss Model\n", " train_history = loss_model.fit(\n", " [], np.ones((1, 1)),\n", " epochs=n_epochs,\n", " steps_per_epoch=steps_per_epoch,\n", " callbacks=[random_genesis_monitor]\n", " )\n", " \n", " train_history = None\n", "\n", " return generator, predictor, train_history\n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "#Specfiy file path to pre-trained predictor network\n", "\n", "save_dir = os.path.join(os.getcwd(), '../../../aparent/saved_models')\n", "saved_predictor_model_name = 'aparent_plasmid_iso_cut_distalpas_all_libs_no_sampleweights_sgd.h5'\n", "saved_predictor_model_path = os.path.join(save_dir, saved_predictor_model_name)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "#Maximize isoform proportions for all native minigene libraries\n", "\n", "sequence_templates = [\n", " 'TCCCTACACGACGCTCTTCCGATCTNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNAATAAANNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNAATAAATTGTTCGTTGGTCGGCTTGAGTGCGTGTGTCTCGTTTAGATGCTGCGCCTAACCCTAAGCAGATTCTTCATGCAATTG'\n", "]\n", "\n", "library_contexts = [\n", " 'simple'\n", "]\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "scrolled": true }, "outputs": [], "source": [ "#Train APA Cleavage GENESIS Network\n", "\n", "print(\"Training GENESIS\")\n", "\n", "model_prefix = \"genesis_apa_max_isoform_simple_25000_updates_similarity_margin_03_weight_50_earthmover_weight_01_target_14\"\n", "\n", "#Number of PWMs to generate per objective\n", "batch_size = 64\n", "#Number of One-hot sequences to sample from the PWM at each grad step\n", "n_samples = 10\n", "#Number of epochs per objective to optimize\n", "n_epochs = 250\n", "#Number of steps (grad updates) per epoch\n", "steps_per_epoch = 100\n", "\n", "#Number of sequences to sample and store for each epoch\n", "n_intermediate_sequences = 960\n", "\n", "K.clear_session()\n", "\n", "loss = get_isoform_loss(\n", " [1.0],\n", " fitness_target=14.0,\n", " fitness_weight=0.1,\n", " use_start=25,\n", " use_end=70,\n", " use_target_bits=1.8,\n", " cse_start=70,\n", " cse_end=76,\n", " cse_target_bits=None,\n", " dse_start=76,\n", " dse_end=121,\n", " dse_target_bits=1.8,\n", " entropy_weight=1.0,\n", " similarity_weight=5.0,\n", " similarity_margin=0.3,\n", " punish_dn_cse=0.0,\n", " punish_up_c=0.0,\n", " punish_dn_c=0.0,\n", " punish_up_g=0.0,\n", " punish_dn_g=0.0,\n", " punish_up_aa=0.0,\n", " punish_dn_aa=0.0,\n", ")\n", "\n", "generator_model, predictor_model, train_history = run_genesis(model_prefix, [sequence_templates[0]], loss, [library_contexts[0]], saved_predictor_model_path, batch_size, n_samples, n_epochs, steps_per_epoch, n_intermediate_sequences)\n", "\n", "generator_model.get_layer('lambda_rand_sequence_class').function = lambda inp: inp\n", "generator_model.get_layer('lambda_rand_input_1').function = lambda inp: inp\n", "generator_model.get_layer('lambda_rand_input_2').function = lambda inp: inp\n", "\n", "predictor_model.get_layer('lambda_rand_sequence_class').function = lambda inp: inp\n", "predictor_model.get_layer('lambda_rand_input_1').function = lambda inp: inp\n", "predictor_model.get_layer('lambda_rand_input_2').function = lambda inp: inp\n", "\n", "# Save model and weights\n", "save_dir = 'saved_models'\n", "\n", "if not os.path.isdir(save_dir):\n", " os.makedirs(save_dir)\n", "\n", "model_name = model_prefix + '_generator.h5'\n", "model_path = os.path.join(save_dir, model_name)\n", "generator_model.save(model_path)\n", "print('Saved trained model at %s ' % model_path)\n", "\n", "model_name = model_prefix + '_predictor.h5'\n", "model_path = os.path.join(save_dir, model_name)\n", "predictor_model.save(model_path)\n", "print('Saved trained model at %s ' % model_path)\n" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "scrolled": true }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/keras/engine/saving.py:292: UserWarning: No training configuration found in save file: the model was *not* compiled. Compile it manually.\n", " warnings.warn('No training configuration found in save file: '\n" ] } ], "source": [ "#Specfiy file path to pre-trained predictor network\n", "\n", "save_dir = os.path.join(os.getcwd(), '../../../aparent/saved_models')\n", "saved_predictor_model_name = 'aparent_plasmid_iso_cut_distalpas_all_libs_no_sampleweights_sgd.h5'\n", "saved_predictor_model_path = os.path.join(save_dir, saved_predictor_model_name)\n", "\n", "saved_predictor = load_model(saved_predictor_model_path)\n", "\n", "acgt_encoder = IdentityEncoder(205, {'A':0, 'C':1, 'G':2, 'T':3})\n" ] }, { "cell_type": "code", "execution_count": 32, "metadata": { "scrolled": true }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/keras/engine/saving.py:292: UserWarning: No training configuration found in save file: the model was *not* compiled. Compile it manually.\n", " warnings.warn('No training configuration found in save file: '\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "iso_pred = 0.99992216\n", "score_pred = 9.460730176906258\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "iso_pred = 0.9999484\n", "score_pred = 9.871595805921642\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "iso_pred = 0.9998156\n", "score_pred = 8.598127868527877\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "iso_pred = 0.9998999\n", "score_pred = 9.209478595154613\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "iso_pred = 0.99985677\n", "score_pred = 8.850915857482432\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "iso_pred = 0.99946165\n", "score_pred = 7.5264647334956445\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "iso_pred = 0.9998665\n", "score_pred = 8.921167665271463\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "iso_pred = 0.99983126\n", "score_pred = 8.686978293339108\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2UAAABkCAYAAAAGwphrAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJztnXnYHEXRwH+VO1wJIQmRN4Fw35cIiKAgKgoiyA0LCoJyiAIqityogNygCKIoCshyqVyigNz38RGOcMllCCQhhEQC4QiB1PdHdb8zO+/M7OzmTd5A6vc8++zu1PRMT89Md1VXdbeoKo7jOI7jOI7jOE7P0KunM+A4juM4juM4jrMg40aZ4ziO4ziO4zhOD+JGmeM4juM4juM4Tg/iRpnjOI7jOI7jOE4P4kaZ4ziO4ziO4zhOD+JGmeM4juM4zlxARGoicrmIrNrTeXEcZ/7GjTLHcRzHcZy5w8rATsDDInKjiKzf0xlyHGf+xI0yx3Ecx3GcucN7wGxgIPAl4HYRuVNE1urZbDmOM7/hRpnjOI6zQCMiA0RkooicnNr2RRG5W0TeEZFpIvIvERkRZN8TkZdEZGZIV0+l05zP4Ir5OFxExoc0TxTsc1FWLiJXiMgjJcc9LidP6wTZYSLyqoi8LyIvi8hxYXsvEblMRGaIyM0iskjYvp6IjBWRPiXnGy4ifxKRySLybth/+yAbJyIzqpTHRwkRGSwi64bnZmcR2U9EDge+jBllAAIsBGwC3C8il4pIR0/l2XGc+YvCStVxHMdxFhB2Bz4BnA9mkAE3Au8AvwSmAtsAS4rIcOBs4C7gGGApYIPM8V4Bfpz6/3ZaGAyf0aq6VyZdX+AvwOF5mRSRLYDtc0S/B/4tIpur6q0l17lb6ve48D0FOB671h8Bx4rITcAiwI7AT7Dr3A0rn7OAH6nqBwV5HAjcAawCXA7cDKwOrAf8vSRvHxlEZG1gW2Bt7DqXBvoD7wKKdXj3AfoBvfMOgXnOdgR2EJGaqv41HPy7wJbA48BRqOpcvRjHceYb3FPmOI7jLOjUgKdV9fnw/1isffyOqv5CVc9V1a8AYzElHOAZ4EpV/aWqbpc53gzMGLkZuFFVZ1XJhKr+XFWPyJOJyELAecDROeLbgbeAXZqc4tqQ58tU9Y1wzguAC0Ne/xv2mw0sDMwM298AFhGRXYA3VPWmknPUsDK6UVV3VdU/qOoP8vItIv1E5DQRmSAib4jIlSIyLMh+EryQ74vIKyJybNj+3eDpi563rcL/HwYv1fMi8p6IvB48fYuG/UaJyD3B83dK+B7XLB8FHAAchxnIq2EGrKTkmvk9M+cY7wMfADcAj4YCGQJ8JcjXApYpyYPjOB8z3ChzHMdxFlhEpDfwaeCh1Ob1wvcN6X1VdTbwIKZkfweYLiJ3iUjWKFsF80BNAR4J5+klIkNFZCgWwtY//heRKm3xL8LxfpUVBK/Vo8BnmxxjBvBumA1wodT2i4GXgK8Cp6vq/cCt4XyPAYthnsPjgR82OUdZ2WU5HPPOXYd54LbEDE+Al7FrPgTzGh0nIhsDV2DGzI5hv52AD4FLw/WdCxwU/u8SfoOV22cwL+dQzOisko887sOMsOlY+VwKHAXsDXwN2BhYAVgU88K+n0r7LuaV/B2wsqpuk+oM2JRG427Nkjw4jvMxw8MXHcdxnAWZaCRNTG0rDBlT1XEisglwMDZxwybAxiKypqo+GXYbhxltYEo4WIjbf2lk1/C9LEk4YRdEZCXMuNgZWC5s7iciS6vq+PB/IvCpgkOMAfYL++wTjvMEZvSAhSdejBkn+4nIBar6lIisAawB/Af4HnANMEJE/o6F6/1UVbMhia2E220dvvdLbftS+B6OeSwXT8nWVNV7RORGYOswzm0b4FZVnSQiqwDfBZZPpwnfnwcmqOrhIjIA2LNiPvK4CPM4vlN+eSAi72Ed4DMx4/Es4BRVnZ6z++aZ/2tghqLjOAsAbpQ5juM4TqOH4mHM67QF5pmxHcyj1UdV/w/4hogIcAGwFxbGFo2yt1X15szxXyVR9L8JLAmcmpKVsRTWXqcNoBUxb9YKOflvQFWvTV3DS8DXQ36j/HHgcRFZLFzPVsBTqjoDm5CiA/gWsA5wE1Ym44Fz6DpO7OHwvQVmgMTz9irwln2AGUUfhv+9RGRh4AxgQjjvBsARwICwz18wr97JwJDwH2z833KY4TkDG9MW00C5wdglH0U7qo3zamqQBd7ADNjzgWNVdUruXiKjgdGZrWsiIj6uzHEWDNwocxzHcRZkXse8WUultv0MMz7OF5EVsYk+voYZBsuGWfWuAiYD62LK/pOp9INEZNfU/xvCGK6bAYKnbXbWcBORzwErhb+Li8i3MS/Xk1iYXuRKLLzve6ltS2EhiF0QkSux8XDjgT3C5geC7PqQrxkkoYlPZQ5xEvBLVX0zhHt+DgttzNMhLsUmOdlSbFbKW4BVsanhj8rs+w/Mu7dnyMNqmNfwXqxM+wMjSDxZkWtDfg/AjKO0YSiY93PLTJrbgO1E5IRwzLTRVZSPsrFzVbkDGBbH8JWQ9ZKBhT8uQ4kX1XGcjw8+psxxHMdZYFHVD7ExQp9KbbsFm3BhLGZInIzNjDgZeBaYBvwAG3e0KPBdVU0bMiMx4yR+RlfMzt6EGSAxI+t8YBtVnaKqf42fIH9TVW8ACNPTrw3cWXDcpzFv3nmY0fdLbGwV2KQeR4f/vYEfquo/Y0IR2RAzUv4YNh2FGVlbAIdmT6Sq72Jjoy7EPIPnYJ63MTn5+iXmLfws8BvMkLojeOh+QgiRJGMchbDBqzAD7JqwP5jR/DIWhvlo5lyHYPf5AGws2CzMi1WYj5z8toyqzm5qkJkHdtPUlv+lfvu4MsdZQBD3ijuO4zgLMiKyN2Z0rJiadOEjQ5jC/9/A5qp6W0/nZ34krMu2FhYS+VXMqD5dVbsYlvMcy1sc3zcdCw+NYxLvRfWXPZIvx3HmKe4pcxzHcRZ0LgEmkSjCHzX2BR51g6yUhbGw1H9hoaBnYxOczA+kQxfvoNHLZ+PKHMf52ONjyhzHcZwFGlWdSeOYso8UqrpzT+dhfkdV78HGic1f2EyQG6W23IaFYL6JLUXg48ocZwHBPWWO4ziO4zg9w0YkM0S+DLwQZlscm9pnjXmeK8eZC4jI6LDYe/xMC4u8LzGHxz00HG+v8H+ciMxokuYzInJcCG1u9Xw7hvMd116O83GjzHEcx3Ecp2f4fOr3banp79NGmU/24XzceASoYZ7hXYBTsjuEmV7b5fs0rkWYx2ewtRBbNsrmFh6+6DiO4ziOM68RGUKjQnh76nejp8zXK3O6E5G5tyi56tcq7DVRVS8VkUeB7YENRWQcMAybuXV3YFMRGYitWbgmMBFb6+9SMO8YNjvra8BDmeOfjS2N8TcR6YeNJ61hi9I/hI0njetE/klE/oSFNw8Efg1siM2CepaqnhnOVwNOB97HltHodtxT5jiO4ziOM+/ZlGTR77E0Liwdx5WBjS1bel5mzHHmMn1FZBi2kD3YGooAC2Hjew/FjK1/AIOBE7BxlX8RkXVEZG3MqHoVW6T+iyXn+mn4PImt7TgGW4vxkiA/D9gNM8KuwZYAOQVby/EMEfmaiCyJzdA7O+QlvYRFt+GeMsdxHMdxnHlPY+hiGlVFZCywcdiyJgWLgzvOR5AtMKMLbJmKI4Crw/89VXW6iHwVGBI+J6bSbg58GH6fqap/FJFRdF2cPvI1bDH6XVT1rbgxeOl2Bx5Q1ctEZHVgxSD+RSr9lzAn1gDgAlX9vYh8CPyh1YtuhhtljuM4juM43YnIV7BwqaeAC1GdlJGPJpkN8n3gnpyjZI2yuRIy5SyAVAsxnJs8ABwJTAOeUtWZYeWHt1V1embfi4CLU//HYWsNQuJpbmfZiKJw4BuB01L/XwWW74bzNcWNMsdxHMdxnO7CQp32w3SsjYENwxiey1F9O+yV9pI9gOo7OUd6IvXbx5U5HydeV9VbmuxzH2a0fQUbB9YH2BrzYt0e9jlERHoB3yo5znXAp4DLReSvwFqqeggWrgiwpYi8A/wdeA7YBLgFeAcLi7wKM9TeA74lIuOBg6pfanV8TJnjOI7jOE73sSeNnd59gO2A3yHyFUT6AJul5EWLfo/Hx5U5CyiqOg0zwp4HTsI8a+8A41T1MeDHwAhspsU7Sg51UvisAZwLfDJsvxZ4GNgBqKvqB8C2mNf6KMz4WxQYq6qTgX0wu+kw4P5uu9AU4p0ujuM4juM43YDIyjSGPr0ILJfZawo2yxzAdGAvTCHMO97h2NTdAOehen33ZdZxnPkJ95Q5juM4juPMKTYo5tupLXcDh2CzxL2e2j4s9fvOQoPM8PXKHGcBwY0yx3Ecx3GcOWdjYJXw+wNsgg9F9U5gf2wK7pmZNLc2OWajURZmQ3Ac5+OHG2WO4ziO4zhzgkhfYK/UlutQfbXzn+pMVC/DjLPbMOPsJuCFJkfOjisb1U05dhxnPsONMsdxHMdxnDlja2DJ8Pst4IrcvVRfR/UMYCdUz246m6LJ07Mwegij43xMcaPMcRzHcRynXUQWBXZJbbkU1RmlaVqbZc3HlTnOAoAbZY7jOI7jOO2zG7Bw+D0R+Fc3H9/HlTnOAoAbZY7jOI7jOO0g0gFsldrypyazKbaDjytznAUAN8ocx3Ecx/noI9IHkeGILNx8525jL6B3+P0E8EC3n6HruLI1uv0cjuP0OH2a7+IsUIis0NNZcBznY8lHKeSqlfE+Hyfy7pGUyIr2yUujOd+KdQ73znziNjL7pu/LEth6X8NTn8U7zynyDrZIc/bzHvBhzmd2k+vqC/RPffcDhgCfTu1/QYtjxVphLMki0p9DpDcwNPMZDLwLzMAmG0l/3sHKtF/4pK+lTybdjNTnbZL7JKnv+Ht2+KTLMX4vqO/R3MLLc/7nbVQntZtY5l794XwkEbmup7PgOI7jOB8xbguzKs4dRJYBfjPXju84TndwL6q/bDexhy86juM4jvNxQIH/Ae/P4/O+B1w0l88xHpg2l8/hOE4P4uGLTpZmC1k6juO0SzuhGdJmunb5KIVZzg204HeV/3Fb9hjpMhUawwKzYW/ZcMLs/vH3G8BrWEjia+EzFdUPwuyEi2HhjenPUCxkL4ZH9qExfLLsut7P+czEDLJ7UH09J033oaqInA5sj5XN6+EzFSuDqViZ9AMWwa5/EWDR8FkY+CDkOXsdHwADU/svkvq9EI3ho7NT32D3Ix1yGn+32+nf7P1rtw5ph3ld95SxoNdLHxUmz0liD190HMdxHMdxHMfpQTx80XEcx3Ecx3Ecpwdxo8xxHMdxHMdxHKcHcaPMcRzHcRzHcRynB3GjzHEcx3Ecx3Ecpwdxo8xxHMdxHMdxHKcHcaPMcRzHcRzHcRynB3GjzHEcx3Ecx3Ecpwdxo8xxHMdxHMdxHKcHcaPMcRzHcRzHcRynB3GjzHEcx3Ecx3Ecpwdxo8xxHMdxHMdxHKcHcaPMcRzHcRzHcRynB3GjzHEcx3Ecx3Ecpwdxo8xxHMdxHMdxHKcHcaPMcRzHcRzHcRynB3GjzHEcx3Ecx3Ecpwdxo8xxHMdxHMdxHKcHcaPMcRzHcRzHcRynB3GjzHEcx3Ecx3EcpwdxoywHEdHwGd3TeXEcx3Ecx3Ec5+NNjxplIrKciPxdRF4TkfdE5BURuUFElu/JfM2PiMhAEblKRCa50eg4juM4juM4Hx962lN2FbAdMBb4E/AIsBHwiZ7M1HxKP2A94KF5dUIR+YaIHCIiK7aYblsReVREThGRnn7G5i11OZy6PEFdTqEu/SqlERFEDkbkEESG5sgOCZ8luiblIBEeF+H7ObJDguy7ObIfBtn+ObJDg2zfSvmfE+rSi7qcTV3GUpcfUxdpId1vqMuj1OXgyunmBiJDEfk+It9DWsiHyJLhvn5vLubOARBZJZR1LUe2WpDtliNbPch2bfF8a4V0O3UVydqhXt0xR7ZukO3Q2ulkvZDu6zmy9YNs2xzZBkH2tVbON19Rl3WoywPU5UbqsnqDTGSzcB8275JOZPMg+3yObENE9kDkU61kRYShIpwnwjEi9M2R9xKhax1Rl89Sl/+jLtdQl2Urn7Aum1OXMdTlKuqydAv5XE+Eh0S4WISFK59vfqIuO1OXx6jLxdS7to1N0j1EXX5PXQbNxRzOGSJ7h+ez+vMwR6djDxEeC89u4zNalx+FNvpM6tI/k26voC8ckU0nwj5B9tOcYx4RjnkKdembSbd/SPfDLhmty7Eh3YnUpU8L1xd1pQMbt0ufUAceIiKDM7K+Kdli1c8l/VPpFqmaDkBUtZX9uw0RGQJMBd4AhmjIiIj0B3qr6jsi8gngcmA1YFDY90bge6r6RvAU/Tcc8iDgSECAQ4F3gDOBgcDpqnpSOP6fgT2B84DRwKbAU8C3VfXRsE8slGVVdZyYMnwi8GVgCeBx4KeqelfYvwYcBSwLvAv8B/ixqt6dc90rAGVK2G9U9fmSchsM/C+dv5JjzREi8iqwJHCAqp4XtuU+MKoqQb4WcB+wUBAdrqonNUtXmIfvFKQ7v/10lY4pchrQHzgT1Rcr5aUu3wIuSIkupKZ7NU3XeE8/j+rtqXwsAbwe/n2O8MyZiK8B10BnZbe9KlcF2bbA1anTbavKtUG2PfC3lGxrVa4Psp2AK1KyLVW5IS//VahQZj8Hjk6JjqWmP6+Q7kTg8JToMGp6SqV7W5fewGBqOrVyPsswpe7W8G8wqtObprF0X4bOsl0I1XcrpSs63Jxcw0cFK7OfAeNR3Tkj2wI4AhiH6l4Z2cHAWSHdMhnZD4HTgf+iulxG9mPgFOB5VDs7pyq800cBvwCeQrXBUBCRY4HjgLGqulZGFt+HR1V13bCtsJFO1bsnAYcBD6rqhpljnoq1ifep6mcysjOAHwB3q+pny66t4fq6kbLzlaHnq1CXEcCDwKiweSqwDjV9xQ4udWA34Mqc5+VyYGfgMlR3y8iuBHYELkb1m83yqeerBCPsRiAaeb9VTTrERNgCuBKYiNXHzwJQl+WBBzDdAmB8uIb/hYSXAlsDZ6Ga1JV1WRm4H4iK5IvAJ+U23miSzyWB/wNGhs0Xq/LNeX3fy6hQ/28E3Ia10WDXszE1fb/0wHX5TEgXO0zvAjaX25hVer426AYd5C1gEWBPVC+ak2M2O58InwFuh86OhANUOQ+AutSAS1LJLqemu4Z0nwNuAaJxtI+q6UAifB74N9A7yPZS5cJwzL2BP6aO+Wdq+q2QbgvgXyROo5oql4Z0BwDnptL9jpruX+H6tsF0pch2qqYfiUgH8ErYvqGqPhh3EpGlgZfC30+p6sNhezM9eAXgubB5LVUdm7d/Hj3pxXgLmIFVKI+IyBmhl6+Pqr4T9lkUM6quA87HFNfdgZNyjncIVrEND/v+BrgTq+hOFJGVMvvvB7wNPIp5oP4hIgOyBw2enmuAfbHK8gpgTeAmEVlZRAYCfwaWwR7c64HFgKIQzJHAwSWfkQXp5iki0hcrS4COFpKeTmKQgRmyHy1EFgJ+hBnPa1dKU5eFgV9ntm5X8YwdBb8LZSL0As6Bht6nLYKsd5CRI+uDvRtFsrPzZHMF6xE+OrO1eZnVZSUaDTKAap6FunRgleXr1OVf1GVIpXTllN2/ltPJd0TzPnOcy7mByOcReRSRm7uKGCzCbSKMF2HnvORtsAawIfn1ytpYJ1ue1yeW71J09d6nZVklrKPzuxUvaDpd98nmp/PNLxxDYpCBtfebpP7Py3I5gMQgA/hO/CHCSphBthiwCo0dXyeTGGQASwOfTP1fAVPOsx6TU0kMMoDlMN2kGUfQqGd89Npoa8PSHptP0exeWTTFeSQGGcBnsY7n+QvzykQPy7x4N38FDZ5da/frMoCu+kK6jT6bxCDrTBe8Yr8hMcjSx1wknK/LMUO6c2i0TWK6QcAZmXTbF11QJOhKuTpPoGX9qwLtpus5o0xVZwH7ANOxxvQHWDjjCyKyftjnWcwYehrzfD0ZkncNRTDv1w7AB9jL+gtV3QMLiRS6KtfXqOqOWCP+GlZwX8g57nrAxpgROSZ8Pw8MAL6FPXS9MYPxauBYtZ7RvxRc9+2qKiWf2wuKbF7zCRKFv9JDJSIjyC/Djxrp661qJG9LUonOyfmqVgob06iMpPlcznEim1EcHvwF5m0Dtfs8TWdhFzeSKDdfobHXrV2K75/IsBDW2CWEtDTdR4dVsbr180gSghI6Bq7CnrdRwCUirJ57hNaI7+NidA0nibIhoWMlTSzfPsCwAll/GpXjtGwgjQpwM2K6QYhkw8OibEjo1MuTDQtRI62eb4SI9C6QLZUTTp6WzX1viMjuiFyKSJdw65ax0KWuIaeNzEujbM8S2WGYQRZZBYiK5jZNjts1Lxaut1ULeQM6FdRmZdbsGIuE97tnqMtqNBqtnTTp0FqLakbr/MA8axtCh0FRmO5WwOIF6dbAyjSPtbAItzzKdKX1sU6IPHbA9O5W+SzFuhK4UZagqlcAIzDl6ATMOFqS0HsuFuM/ButJ+hEQ4+WzjSrA06r6Aeb9AgshBDOigC5x00+HPMzC3P6Qr4CPDt+Lkniz1g3bVlDVGVgPmWAevRdE5GXsQeiCiKwgImeVfIoeyHlNOw/VpiSG3APAq92ao3nHyILfZaSN0VtIQg6r0E6lkO6YuJXkOYfG3tpbMY90nuyWEtnNJO9SJUTYVYQ/ilTueY3XMBsL45tRsm+aWNYfAjdhHTZV2Am6GAbVnm2RlRG5L3yyYwXL7t96WG/iOWTi1Zukm68Q4ZMibCdC1oiI41h6AUultn8VM8gifSiOHmiF9PuYLbMyWbsN79xolNP/lyqRtTK2OqbrTdeOlXYN0kJEEBG+KMLmuWOkitkK2BULDZxTPkliKL+AhbClMykUeUhNFsu+0Qtq+yWyCogwlMRQeAOYlpL1ofh6NyHxUDyFja9PH7gvpiNB4/P9ORIvxBMkHdbNWIPkGXiKJMSqEiIcDbwJjBNhg1bSdiPptvZBEv2tlXQPAy93W466n3nZNqR1ibuxEOBIusxuw3T0vHR3kQzByMruzMjSx7yZRl0prYPcjjlt8o75b1LvWBOy+tBbGfl8ZZRVHiTX3YTwuA3DuKsbgRtF5HVsHNiiYbddwvfvsDFjX8fGmOU1Ah82+Z9l1VQ+4jiCV3L2Gxe+J2FjuGaGdAOxcW4AF6rq78MYuJ0w1+zR2EOVJYYvFnE15onraXIfqlTMrKb/B2IlPQYzSocT3NRN0hXSGRMceruqxniXpatwzHTjN6piunjt51PTfUOY3E0Vz9dOpRDPdyX2nnwK+GZGdpkqu4mwIUnvaJRdosoeIZZ8x4zsIlX2FGETko6QUkQ4BHt3AfYWsZjtwmu3UJJ4viOp6UnUZU1C2GVJul5YbxrYOLLTqcu6WNhss7IuDKGrcI9WBT4dfi9N4ztadv9GZ34/WjFdy7T7rjRDhL2xkPBewFgRNlPtbBDTPZCjSOLv56g3voRsh8nTJbK0wpkt6zElssdKZE9AW+/0syWyF0pk49J1ZV79KY3GR0w3sUQ2OSVbKiNr2pmUCgc6IGyqi/ANVWY3S0vyPsTvhrKT74gWPbddZPXOCXJew9qbV2kM216cpGe9LzCURKkcShLG1h+IY9zBjJaoGy2CyGKovlmWT/kDXw0/38cMplcwZRRgHRIv2blY+f80/I914AvAZ7COqXrqGtIRKyMREWz8fUz3bEj3LiEkskk+vx1+Tg75fBf4Rzpd0TMdJoX6eWde4CKix6+bqdjW3ot1/PTFlPRmxLGWd2GGwQDM0KhUd4qwHNZWPl5lnPUc6iD5+lebx6xYnrdj5bI8ybCCKLsY8wQPB+7IyP6NhcCuAvwkI7sB64hZDTon7Yiy31HT/dO6Ukp2LaZ7rEVSz0TZ2dT0oDCxTZVnN6a7QpVdQmfCHil5y/pXBX32o2eUYRXhXSLyNBZi+A5JrGp8wSaH762wF69ld30J24jIX7FGaTjWiN2as9/D2MQVGwEPici9WM/VpljI5Z+BySJyezhGdI/nDrYN4YltKUthkpJ0L/1pIjIDOFRVW/HMVCE+SG9R/aGKvea/Ch7ICSJycjfna16QVjSresritR8PQE0nUJcDi3dvoKysi2TxfKeposBDqb7eThmAKg+IdCpMWdm9Ip2DnLOyu0WY2SzzIiyNjW9I82kaJxrJMgTzXs8gxpfXdCx1OabJ6YZj78B04vi3mj4SJgwpxoy5zcK/y4D9gQOBLZucL7Js5nfWKHsL60zK3r9suqxRVpSu+6nL2lh9NQILLfwpNX2zLIkI69A4IHtNrMfyr+F/esa3pUMaIekNvQp7J7JjHNtlJKBYHZp9N/NliWHStawTwyRP1qtQVkYyHrdLuhCSOLRANhAzJFp9JhbD3qV0ujhLbzRM0rJokEbDJC17rIKRtC+JogRQA35MMASbMDp8j0SkL9ZOtEt89s6nppMAmyUuGaqQrjvj9b1WIotGWXx23sbKdSTmVSpjdPi+UtW8XamZ42KI16PAQap8KNLZjsdrOJtamCCoLvuntsd8fojdx8UxD0GcrOYsavpWSLcviVetiHjcP6na9Yp0GoiFhHDFozKbe2rWxnjtJ1HTWcAs6rIXZhCXEa/9xFS6PbEhL6UERf567J1BhJ+pclwbea9KO/pXu8RyOSN0rDwn0jm2PMp+QU0VmByez7Ts9KCDPC3SORwgK3tShPNCZ2y8f3m6UjbdYyL8MaSLshNCuvHU5aAWri/qNQ9mArWr6F8zcmRldGDv7PstpuvR8MX3sJ71mZix9Q3MkPkFNtsV2Cxbt2E9V+thMyB2F+dihuE6WCP1Nc2Z/UxVZ2MxsOdhjd9eWPji9djMR2BG5CexMXKrB9mPujGvkT1p7IHeIWxrdyxTGfFBGgMMlq5jNPKIjVnntP2qOs+m8O9G4nX8lypGWV0Ww56NidR0fOf2WuXxgR3Ye/AU+ZVCnNEzLRuJvfSdSr5qZ7mPBGaR6vFX5aGgLI8M5xpbIHuXVChM6phlfJOkg+e1sh0z+Qd4lFrqvWteZtFgHtMw01bzdCMw5esdYF9qOp2angj8oWJ+lyv4DXYvpkoGAAAgAElEQVRfnia/Ah5d8DumexwL32zoDc32cs6x18u8kPdg9d0ITKnODprOo9nYn1HYMxN/gxncw7DnbB9VxmA9zFXDTPMR6YN5DmJoetrw6lsosxC3gSTGSPoeLYG1A3my6DHJk5URvRt56aJnKk/WUSIroyxdu7IyqihCXTGDNIZk9mrhfEXEe3xf55aavktNY7s8p+XySI6siPjs35PadnNG9lfVzgieUzOy9DX8j5rGujte45OZ/3nX/jo1faJJPnPaaB4s2DfNRiTlcD2JZ6MniNdwf+eWmj5HTSc0qTtH5aR7kppOpoQQfvoXgkEWmNuTo6SfzxGh7ptb5D0TD4Ux2MOxzoqkEzJpa/PTlcviBCavdM6Qmn/MhzPphmL19IsN96uajjUSM7zTulL6me/AbI9x5Otfr2Ohrq0aZZOxjqqPhlGmqh+o6g9VdV1VXVxVB6jqCqp6TBgbhqpOVNXNVXWgqq6jqmeHyTAGB/m41AQZb4Rtg9MTZqjqZuH/nzNZmKqqX1PVhVR1PVUdk8pbPOa48H+Kqh6gqqNDPpdR1T1U9Zkg30lVl1bV/qo6RFW3nhtT1ZdMDtLt56K9hik+/PND+OWcMBJTsMdi4w2avSexImnWIBbRgYXeTAI+kTlfR9g+iTA7XFhXZjDwvGpj76AIi2HGx3OqXXoAB2MzYz6bUg4iUTl9pmIYUpo4k9GfMYX/azTvfcwqG1Vpt6xj79x9nT3LxkUV02c9XoZNqvAJrPKdRL5RNiP1O6brhzV4E7DKe273hv6Mrj3bpZ05wVCPMxn+HjNGr0jt0Bu7H3EsT+yRHB2+71e1sQSqTCCECs0BS2LjaOL50obXCMwQypPNa6OlXYW/nTq36jG75fpEWIEQ+o95m9emMdyzjFHYPYoeqdEV05UdD4rrkDm97w/nyIqIz1tnOG3o6U/n8/GUbHomXZEnLsqzz/VIrDPnmQp5K81nRTYO37djndRfwSIOuoUweUhzw8MiHszjWdMplU9Q7+zQeYWaFi4ZUMDmQFwOYyzzZqx8B9aGPoHp6XNlAq5UZ+wbJJFp6TwAPBm8ZNl0HcBrqVD2KIsRBpNSz3mksN0P3uMlgZdUu4xnb0tfEGFRbJjRc6r5yx7QqGPlGWVFsjLaTdfji0c78y+x9+C/qf+FSKKcvqxzFpIyPzASU7InYOE9Q8t376wwqg44zpJ+gfuQLEWQlcW8xHuRd74yWVk+5+Qa4riCw1VRVf6BjUEqIyoqrZ6v3XTRYHi0YWumsSlhWWz8xoc0GmjDMUOhqAIeHc45k0YlNHoM2qq4W8JmeNs6/LsAG3/zp4Z9RNZA5Nc0hhsPx7xFU7Gwq/9iXtE4PmoEdu2PYZ7ZeG+iAfw4KXI6AlolURKsPLOeYzClaRb5RtmzmLcuTwF/OueY6fPNovo9ivs9hoVT5h3z0cz/9O92jbJ5YXTG8PwbVfmdKo9j01I3DXMmef7vzfxvl2iYjC+Qz8tyic9+XodkrHsaDS8LyRqFGRhFkxx1NRATw2QiNX2vQt7yjtdq/RmjAy5Q5cNgcB4bhWHil11E+JsI54p0GjGliDBKhH9ioWNTwri1MoZh7WCr+R+B6bvttG/RK/ZPLCJqJbKTynQ/0dMyIfV/bhBDn19MdSJEynSCGPqcJxuO6TF5srL2O0YYtJqujCrPe9SxXgUWiYtEp8bjxjZ6kHSdSbcLkoS9x3QtzaTbk2PKnPmb9MMY/5exCKagVZ1Bb34mThIQx0hYw1lMnPCl9WtPxp/cS2NZv0oy/uT2jCyOR8g73+C5ICtEhEFYQ/mcatKDqNo54UMRscyyMyE1o92yjoZC615cq5yXxe7DABrDF+N7MQlr+DfsHCtjIb/DsVCfETQqoel0k4C1EOmFhUs3y08v4sxr1TpA1sTG5I4Fvk1Nlbrcgw30j3yVGKoo8mtUJ5D0Dt+pakp3+I7GVlQ2X8aUh/g/lnV6covuICoJE7B3M2+W1Few8swzyvIM4CqyiViD3aqR9ArJcitZ2UuYsZsn+y/WIdbq+eaF0Rmfic516VQrK0rxubgH88AuU7JvFQYBb1MrfGfmpVEWpw3PG6MZx3llPTu9sciFMs9LfI7HpP4PIBkL2CqDgQ/i+9wCcebUdDhaOhz599A5iQjAF4GVShc0FvpjdWPs1BuMjdM/ryQf7bYbbbVvgegZPi1En7wlwmFtHKcVOrB6rqr+1S5l5VLW1rarS5Tdv3bTlVF63yVZDy6r675JEvY+ieTd7aB5uxbD3ieRhPZ/gmTSwFIWOKNMVffCxoU5BaR6CLKGQhnRUGhpGvX5DltAfBg2w1A0ykaSinHOofHa67IPdM7GdSg1LVNaYu9QtlJ4mGT8ycSMLIYE5JV12X2oImt13E9srKuGMOWfry5HkKyV8g1qWvQcZcv6GJKB/TVqWqRstFupg4VUDMQU6UVoXH8la5RJ+H6ZROkcj93LT6VmT0sr/NFDOoyuISR57ISFDs1GZAm0aThOVCr+0ekZtO87Uvukp7deH1MIogKenqkwTey9nBA+8TyxISydRKQNooI6MXxWyZHF9yjtzcwaXmvkyOJ9WKlENrpiPrPpigy9VmRzer7uMjqbPRNljA7f92T+t0timNhMbGeF7TdR0/Ow6/kQU6Ky4z07MEP0P1iYWFb2fpBlPZ1leYH8+rN/gSxbl61BMrvhX6lpPZz7fyQzdKY75WLduQ62iDbApdT0yib5bKeNXg4ri+eygjBLbzTILsXqsvUqHHNn7B2eik0UM5Dma1Bmr/0L2IRNAOdQ01uapItlvQXJ4t5nU9M78xIFVsaekQfihoxB2r3Y+LElMW/c3DbKqusLdfkmYTbmg7985gW/uvGQaunyZfH+fZswgd9OG15+4ZUP7Fw13f4kwyYOaRjLX5auK9m6M257msa6sxWjLJ3u3dS2cU3SAQugUeZUIt1DULVSiGutdJkspRJ1WQ5bRHMkZnTcB9zSQnhZd5F+SdNGWRnxxY/XvhbJTKLHVzxfXlkXyWIFk1fW2bykKbtH7d6/uOZN1TVDsueL17IRSYhd3667F6bbmKRyLlvQtNG7WJe/k4yT6KCmZWPgomdsHBbq8dk4TTaNz0vsEe/AjLJoGESjbHOS2dOK7m0Voyyu19IL83Zd22T/aLyUTdqyPnFMo/2+miTEsshLHD1j0Sjb2BZK1tIOmjAeYSOsN30hLKzrbznjCLJkjbKNERmITdCUlW2ISH9sCZNsWW+CyEKovpMj2wiRAai+lyPbAJF+qDab5S2bbk1EeqP6YY5sZRHpFSaUyso2FhFRbVoHxnSTQ7q1MzLF7uEkEsM5yj7EFI5JVFtHrtkzUcbo8P0EZkyNLtyzGv1I6qtFSerctAI1GdUPEMkanRaNoPohItkxnRYlYt7urKezLC+zcsbxghll7+fIsnXZ0NQ1pCf2mIQZLh+E/9l0w1PpYuhrEX1pr40eBLxVEIK8ffg+VtWMyrAMS7OpymM9dogqfwnp/l4h/5Bc+zIk1/6PFtLF6e0BrilKFMa5LYuNc5p7hlgjMdSyFf2rXcra/awusQahrActNP2ajKzqMbP3Ye0WjxnTrUty34/uunulvEB1/WtKZlsZeUZZdj3KQnxMmZNH2YNaRKysyxTqfGy9meextVtGYwrbVTRO/z+vyCp36W1FtH/t7RllZeebG7IyYi9wqx6ods/XbrrYARUV6sUxZWZ4/u4NROPqJZJ1uOK2svs3OnyPJxn3MjqzTzsN7+YkC59uXrZjII6JtGUz6rIqdVmbuthC2ra+4ijMEJtO4jVrdm+jp+wVkjUeR5GUdRevZRgEfiXmLfk6plQdQeNC00XkvZsdJbLsAsDRaElv68DGJb2WkqXTfYCVW5RVWdC5A5tdeHpI15vkOesA3lbVt4Isrp8VZW+qGYuTSNbPqnK+19WMxUnAoiKyaEr2Wpg8axKNM+l2AJODQTgJWEIsUqCM+EwUekFFWFOEn4pwmAjrpkTLAG8Fz27ak9wuH1JeD5hxZeR5CduRleWlT8FC2kVGdXldJqmxY8k9Gtk0XfN8tpMuLquQR1y/sXOcqmriVSphA+zd6+xUSofAFzCv240BWPRDdsKKucmctA2t0pZO0Lf3rG7XM/r0+mB2kazJMctolq4d/asZc3T/mhplIjJORFREvp7adlbY9ueqJ/qoICIDRORsEXlNRN4VkXtEZMMmaVYTketE5HUReUtErhaRZTLHPFFE/isi74nIEyKyQ+YYXxWRB0RkhohMFpFfpxtIERktIn8L+XpPRJ4XkWNCqGF30/lQBQUh7REoIiq7ra1dUpfFgZMxL8RK1HRHaroVphjNaulY3UN63MqEzLYi4rVXWTYgSzuVQllZzyyRlaVr9xpiHdLqjI3tnm9ep4PEU5Y2yuK2eWuUiSwNrIB1WjxPNaMs1iNRkb4Wm2girssYF+N+GOtpX79h3FrxTJpZT1ncVlbWX8GW8rgEWE+V3TDvze0VriMu2fAmSZmlZ6ObgRk72c6UDuB1EqMlbovfrwUvVp5sckohTsvKiJ4WLThmWuGvKmt+vtaPmSdr1qNb+EyEyR5+i405/CVwEjBGpNMgHU3SmfAyMGoOp/p+n6L32cbjDqPx+hZHZCC2HtyQjGwoIv3N08uglGwisGQY+9ssL0LyrmVl/XJmF2zWZg7FlMn4PMfpteekLnu/5HxlxPX/8lgFmK7aeW+rsiw2e18rYc7t6RntpyuLPJlbpNuG6CGdW0ZZWzrBwgPeju9/u3pGF9lC/d6ZVSRrcswymr0rHz2jbAHkLOB7WK/q1ZjX5t8ikjsDn4gMxtYp2xoLubsJmzL2ekmmNj8DOBwzMi7CeluvFJGNwjE2wlzoa2OLso7DBt2fmTrVn7EwgamYQtOBTXO91xxfcVfiAyQisiKN4VZFxEqr1YZi/ZDmBmr6JnXZhrr8Cfg1tuZbOSK9ETkYkR8isnKL584j3eM+DXupRxXvDiTXHiuMG6mmZEJSrv1Jxj1lK4X+2CxJcVtZWc8NWRlx9q9W18rLltllVBuXlk13CdWmx89W6v+j2oxx0NxTpti965vaBokB9jL5RtkHJIpXOl0Znw/fd4bPmog08/bFBrTI8xyNsjGYUTYIM/xi+RTd21HAtBA+mPaUxbLOS7dp+P57nO0rzNhZZZyLzYpqxk7W8BpJo/KalnUA/8PqMlLb4vcbQaYtyPJJxuNOD+liZ0WHJAtVvxnq1Q9Tsl5Fsian64uNP3krpIv3ukMSwyRPFg2TGUEWFaJmz2B83xfNkX0Jmyb/cczQHhz+fxCMmg6S92A85lGtHNaTw7sk7/MU4PSULHo03wv3Iea7I3XOKEuHGMXrfweR0VgIbhwnWkY8fl79ObNANgu7z/EaXqJxkov4/E4JY51fAwZzfKdhHNO9SPPZbiPvAgOCx7oVZpJ/z8Guq9Vp5qHc+1ZEtv5/lGpT82fTjQH+ViFdWSenTdFfly9Tl1Ooy8XU5ffU5WDqMidRPvEZ7I2FFFfRv9qlik4Qr/3m8GHIItOKnulWj3kDYWzzoIWmVzlmTHc9cHfOfq3kBZJyHUDSXmX1r4Gp87ZilC2UOu+8NcpEZHERuTJ4it4LHqHfBVlfEfm3iLwqIu+LyBsicq2IjEql30RExorI2yJysYhcFjxxZ6X22UZEHhSRN0XkJRE5vWxB4+BFOqvgUytIMxzYG2tIv6Cqu2FK36KYoZbHxlhlPi6se7YDplyuThLzulP4/o6q7ostkC1Y2A6YsdUbuDRMRPLlsH0fEYmNQYz3/7Gq7oM9lDDncfl5xAfodGxQ42jgE1KyXpfaGIxpYb9WvHdxbEJsKKdhoWV7Ue1B3hYzpE+jexYXjw3hdVhD04/mnrLoJbB7VdN/AkUDjrPEa/w7ydox2UrhWpIxBh2p8+WFUs2prFUlKTbGg0v3Kj5fLLNLqDZ5QDbdRVQz5uJYrcVDuu1pPhYrEr1ie5FM4BK3LYW9y89gnThxG9h7o9h7dEBqG9h97INNJnBFalszomfsbuCu8HuzJmliHH40+u+iMRxnA0xBfJLkHmxA83s7ClgUkccxb3fcFss6L/Qu9hwunSMrJgnlWh4RJVlfbiSJQbMSIrNJwqg6UuvBrYjVZb9MyQZg6/OtEmQnpGQLYde9epD9vFNWThyPu05IF8c7dJCsBfjJIDsiJYszdq0fZIelZGXEyWU+E9L9MJUuvuefDbKDU7L4jG4aZN9PycqIz03eMxHH6BymyjOqTA/T5k/D6tBewCqIXBzyC3MWwjgB6E9dBlPT10ieQUiuY0fs+nZNbY+yXYJs5xzZ7tgsmDulZGXEjoA84y0+842dJ7XOzoVh1KU3Nf0v8JvUHrHd+RGmXNqagU8zAnvHlqQuQk2fB37bJH+RxvqzOtOgcC2xd2m9/gerl1pNF8sy1v9jMB2t1XQPYpOSNOM9rDOjKJ9XYIZFP6wNvwWr45uFAZcRn7VzsOdzOC0o9S0yBbu+Mp0gltlNWIczW6x501SsbctLVxbqnT3m9QRdaYs1b4q6YJV019I4UVURzfSaWK430HUpkvh9E62tWRj3uY1kofJ57in7EVb5PYc1iE+TVLq9sEK+EevNeRGrXM6HTk/TddggwgexB3Cn1LERkS9jnqRlsbCdV7DG55ySPO2NNUJ5ny0K0qyO9VqPV9X4gMT1KNYpSBN7yJYQkeVEZCTJA7B2Zp9Phh7KtQvkK4cpOmPPdV+Smd5Ox4zFU0XkD5hy+BLmQetu8h6gODtcGa9gHp0q4y4ij2Eexm2py+FYRf2fSinN+DsM80ScBWyHyErliZoSG8KFSLxTIyk3NKOXYNWSfYrIqyyWaiKbivXgrZozhmEKpmDnyV7Fembz8jkJq2RbvYY4xfwapXt1JZbZaqV7dSVWsq3mM3q4Wj0fJF6xE0gU2+yYsjRpT5lgM5Nt17kt8aZkKTeILd0XSMZh/CRIvlCaLllr0AzJmu5NXDPJjrk+1in0Aol3fgOSe9vVY20GzXCsjlqTxNhcmqSs8zzdf8GMvaNF2FuEz4jwfZHU7I8ivRDpkwlti+viZBlJsi4ONIZYjaRY+VyK4npqKYrvRbNOi7J07crmp/MVPxPJzIx5nuvRqe89UulH5+xblbJ6t+z6ihSkMlkzpSqG7uXlJcry6h4zLBtnC212zg7s2heheRRHlnbbqhexdyvvGp4BBom0bDg8CwwVaapXJNT0fcwgXZ569bWfwjpwbwArhYWkKxEmNnkBGBmWf0moy1pYKPbV1PQQTO/themxg2ifvGd3EZJxot1GuL6JwDIiXbyBhc/KJwa/+gHhPoSlDdLHfA/TQ1YQ6TKWq/CYn17xgThUZmWRLpN2tfvcvo5FbuTpQ9Ce/tWMvH3muVEWC/4BzCjbmWDEqM1+tR2mfL+NrZUDsGnwqGyN9UK8CGyuql9O7RM5KHw/goUdxZ7xPYu8Zao6WlWl4LNXwXXEVdPTaxrEsJqixv0ObND6otjL+zKJ8RLTRA/OGZjRsVdGfj728GyE9UTelDp+3OcWrFxWAfbBemKuZ+6sLt9uwxRfnLjAKCJSXuFab+G2wPkoPwQeRtkf67lotqbU5zDl8Rws3FGBQ5ukaUZeI9cf6+Uu4jWst2nllhoKI69MB4ee+jzZEor0xxrzRUl5HEQYpspsrJIdnE4fZHHczBIiiUIaZLOwZ2l4agwIDQ2myCcQ+UH4xPNOxZ7Z1UU6jVhEmk5QEI2rtcIiqlWJz9haLaSBJGyqqHMlH/O05D0Ty6XGn2TpCLK8Z3805q3L60lt9n6tGPbphT33sYFqNq7smfC9SY5s+ZCfXpgRE8O01yeZ/nqjdIJwb4u8x6NIjLKGshZhsCqvA5v04sObhNmngP4b+AaxnrVF6P+B9cy/h0gM1yyrk4ryMrJJunZlZXzczxefidjpiggDgkIXQ9HyvAqjC45XtL0KZXXBvC6XLnkR6XyXxufIFi9Kl6LsuU7qz9aI6VJtdCWjKE7J39l5krqG6A3YMyWLy5uU8RBm6HV2wos0LHNRxCtYJ1KrCvorWMdOqx23z2D57Kw/Q5klM39aGzYE877WSTrW26HdZ7Bd4jPR2dESrm86Vi8vTz130eQJWLuxaiZdlPUhtWxJkEVdaZUCXekVTN9aIZMuet9Wo950fGcnQR+agHWwp6LzOvOZV6YjxDoE82SlEWMlx+xWoyw+eOleyliYMSzmLMwT9l3MMHsDuEhEeonIZ7EehNOxtSi+GdIMwAoqZvY/qal/YxhXZHT4/hLWUx1DgYTGhVw7aSd8kSTsJj0WIv7ONX7CrFafx3r/TsRi6OtBPCXs81tgQyyU5RiSNT2ifDz28H4/HGN7kkpwipiicgPmWdsdU8avxcr7ZwXXMifMacO0C0DI94+bnq2mU9idn7EHg/kGsAenUtMtQ1hGGdFT8AuSXqo9SUI+26FM2czHFi+dgL0j2xful6XYYwLlCsJSdClrBpG8F1nZ4thzmScbAuxXIFsC2DfkdQAWnrc3sBtwHSKLhHFBz2Jl/8OQbk3s2SwjeuZGY+9GVWIDsjJ1+WQL6aKhsD71lsYeLk3+APfRFD8rHRQrm8vS/vsVja9vY3XAolj4zAopIzmPWJ9uR71zXFW8pqhk/QFTqvbEvGjrnsd+EzCv62oitj6NCLuFfBSdL+0pW0fElEYRNiMsVq3Kkx/SZ9xsei+h9OqryLaqneG5x2P1/JbY83ZlGNtTpqC6UTbvzhejGHYSYcXQ+3wq1jkROxP3jjuLMFiEARSHKc5J+GKsr3bN6diZ1+USvWE7pEL8DsvIdkrJfhq+4zXslnPMsue6LF0ZMd3OqXFlh1dIF9viA4IR3odkDN9V4ft4Ef4swiVUG+f1r/B9hgg/E+FU4PIK6eb02nct3asrT4XvY0RYRIRlgLOo6XNYGXwBC13ciCTqaU6Y10ZZtt3vD/wgdJi/grXtO1dINxA4pEC2EHAwNY2euX4k0SNlx1wE+H7KQ7oQMYy3/esbDBwQDK88XTGGyueN1e5TsB07tgwkWUg+TeVw1ipGWTQO4qQUvUmUqPiiTlPVr2BKwtrY2IQaNt5qB6xX43pssFxaARMSJWuF1PZsb8m48H1w2uMFLK+qRYP82wlffApTQpYWkeg1iz0ej4XrHyQiq4gpCp3XoaqXqOqR2MsZj39zSNNPVR9U1eNV9RdYjH9aLsB0Vf1NOMYbWA/221gv1OIkLtH7VHUGNsAV2guZa0YH9uLUwudXqe1lxHvxLRH5EXAx1XuMDgT6MJungAPD7FnFiKyJLTp4Ada7vyQ2Fq8fSYhZa5hXZEnsOnYPn78EabNxZfHaf0Nd9gh5a8YgrJL5P5Kyjgt/rop1fjyYksWByR0k3uTjRPg2jetKxbz8XIR9sEZzyYzseBH2DumGZWQnivAtLGR4iWA8no8p8GOwd2Et4MIwnifO4nesCLdjz2z5xB81nUViLFxMXXYn35OTTfcuSZ1Upy41Mp6cgnRvYPWIAFdTl/1IpnIuI3b6nIn1sK6EeXIGkPQ2/5XkHj2E1XPpsOPVwuffWLnE+u2yVLpHiLPDFbM88B9GcDuXMJhLGMkw7sAU5bIe82dIFr6+j7rcRGKMJUaZ6kWoXoR55fvvx+9Xw+LiAS4T4QGSDqfYSXEm9qxvFc4zSpF3SLxzfxPhaNKD6s2LuB/2HPUldiaI7IIpq1di7cZ4rC68huQ+/ApTxnbD2o60UXZmShanD4911hkkZR3XpYqy01KyKRnZKSnZVKobSSem0k3PHPP4lOytjOznKdnbLZzvmFS6uDZblB2Vks3KyI4I23fHQpubnW8Mdk8WA+7F2vo43rqOKUA/EOEWEf6C6QiDSDoptsI8qNGTEre3Q6yvNsPes/S473gd38Wub9/U9ijbP8j2z5HtG2TfTcmq5GU14BwRjiGJ8Hk8fK8F/FaEE1KyWI/vSF2OJemwTZ/zGyEvh6a2x3Q16nIkFj1ThZhuI+BUEU6h+YLNkIzf+SQ2JvURrPMEVe4ELsTq1j1DXqusL3od9gz1x57fQ6mmvMayPjQsp1PUyZ4lXvvh1OUAqhtncf2zDbA66TmSUPBDmcpa3Egf7mVbnmEaNsPsPyseO48OLOQ8vrPnpbbPDWK5HCzCgZhhHNuoWNZnhsWjv5aT7lARDsDq7eUzsp+IsD/WRsYQ3XjMc4KutGXqmFF2hAj7Yvp0bGviMc8L6Yr0+CzxmD9L6UMjMJ2oFxbpFss6jjNfC3ue70rJ4nNQdh+i7LZUuhsq5hOotnj0+dj4pUNEZGPMQFgBi/2MAyV/KiLbYIX2PklFO53E+/Rp4GyS2bci/8Aq+RVF5GbMtZlVMM7BKvOTw0yF74Z9liA/FhtVHZ23vQxVnSw2zf93gFtE5Amsh2AGyQDc7bAQzcdIwnNuEpGp4Tq2xIyE61U1KjTfEZHdsfJZAwv9mI55eMCUuGdE5FbsnsQehOPCejZvicizmEJ4tYg8SLD6qTYDTWUkGRh/p6peGrZNwgydZpXCnanfp4Xv2yucdCFMSbsZq4D+il3fRYVpluc5DuRgFufr9ONc4HVmo7zJnziwc8B+q0TD9zFU6yFvYF7QZkbZndh7MgQzRqsQy3MMoawRGYSFc0Sl/uGUbAimrHaE8x2ITSpwftg3KsJ3YuW5EOYBgaRiuhNr+BcG/hi2PZKSfQtT3i8I2x4EPvUe/Qdez1ePPotDXplNr967cenkGvW1h/C/jbGB1rFXOPt+l3FnuM4VSIzfqumWB1am2iDvyM3Yta9C4yxnZcT65RFULXRL5Eks7DoaZTen7tFmWEdErMMeRvXpIHsKU2Riun+n0m2BLYjZQVHY7iX8EnsO78cM4Vc5i2HAVdS0eOHUmip1ORebCGGJkAcwxen59+n7u5V4dshLZogvdCS/mPoTTg2G1kgAAAnnSURBVLlgMd7qgylbW2CK0wapo0ZP2U2o3hCuYT+sbJfAvCarYPf25zTyDawd2QPzpB+AyIl8nRf4JH9kOYYgvAPM5HX+you8wK86xyv9HdU7U+fbNJWXv6F6T5B9F+sUHJmS3RtkB2FGQXz//orqA0H2A+zeRdmVqP5fkB0KrIqIULygc0x3OaqPh3RHYIpFlF2mqk+aSI6m0Ri4VFWfCbLjqG6UXaKqL4Z0J2aO+RdVfSnITs7ILlbVV4Ls1GbnU2WWCBdjUR1DScJdUWWaCJsMZcoJ0xn0JUVW/YC+12C6wmjsebs1LOgNtmjz6CbXV8Y9JFO1/yAj6wiyP4RFoHthk2HE65sdZB+GsYtR1g/TQf6I6uzQUXcuze/D41ibPojEAIyzXT6akkWjK840l24zj8sccyQwFVWrG63+Py1sT4+nP75J3tLcH/LVh2RSmCoLgY/B6qUVSAzq6IHgWI771msM/+B2NtvoA/qMe46VftSZUmSQWofUYvxBTkL1p2DjmU7Y+chd/3THt858edqoLw7o+97UTVa++9fUt+5DTYuW4QArsyMxhfrsSledpPsxdu3ntpDuPqyzbX3yvCAHsSOm992Pza1wbFh8vnVsToFFgLtTbcObWMfB3DLK4jPYm0TPvSol2wF7di8sSJcuz8tTssOxTrc4CU09JduKfF3pTuy57A/8Lmz7c0r2RawTuaqOFdMdgOlKUR96mqQ8H0rpup8AtiHRvx5MyUZi7X4HycQfWeIx70+lWx4z1CvR1FOmqtdgjecYrJEdhL1gX1DVGOc5BnvRv46FJ04GDlJrlM7GeuMHYuErJ2SO/wZmfT+B9d5MIbFWZ4Z9/kkyLm0rLERsNokHpzs5GHvAlgzXcz+whapOKUnzONbL/02sHE4mmYkKrDIbgvUirYkZohurdobnzcLG1G2DvQDPA99W1dNSx9gGK8cRmFIzBauM0/t0B9HbMjG1repaC4+TeDFa4ZtY+YzHemBnAT8onVzj56zLkvyKfoyjpnsA19GLWQxmBpe0Pc1yeo2ySNUFpK9qIs8jlmdeWa9YIuvAel+KKv5/Ujzd+/UkU5Zn+Qc5a8MJOm0g7311R/62xd189up7dOM/fp/fHLcE0/ZA9S5VxtJ10p0qz8HfK+zTnemyjQpYWZT16kYPzbjUthieF8MgJ6VkkzKy8SlZ/B3HNLT6jh2F9e7uS013wRqbW0jCa8r4NdbZEXkbOEDQe/rz/vYvMfqwkL87TuCouwfx5i+DoXIFyUyvYOX1LI0LR5P5PYrEqG/ElOODseczhuEOBXZnJw5iefZBOImaHgVMYygdbMBqJJ7edJlNxBTyvHdlIta+LZ8jm4QpEssVyNITL2RlAymfMa7onR7UJzEes7IhJOWZlQ2T8qiBjtS+6XQjUrJXM7I4oYWSdJp2yirMnnsCjZMxjceWAOilyM5TGL7l+/Q/fRb9VJHpiszGwhRf7TTIknRL03yMRj41nUbiyc3SAUxB1eozW2su7SGdHNamAxuC8FpK9mrYn7C2XfSeFhLG615dIrsiT4bVk9kx9HEhhfQyD5As49GBKZXVJsRqzMvbtNhzH9IpyWyhkdfjj+P42Y/P5cC9nmL1J55l5S8oDWOQzsE6dP4GHIbIDmEq+fqRXz9x7PNnrvjgzAsH1Kb/YfBB1/94ayU//CvNHVhZtMotlCx6XkS49l1Iyns2sUNTZD3MQLwUM0IGAec2mRisjDKdYG4ZZfdSbJhfTXH7eCc29jeP2yleJqFMV7qZxjkd0rTb7v+LfF1pTvSvIsqOWYlKlWEIzVtPVRdT1eGquoXG3kOTX6eqG6rqYFUdoKorqerZQTZDVbdT1YVVdUVV/VMqBDHetLGquqaqLowZLtF1+mzqHFer6qdVdVA4zwaq2jllfnehqu+q6oGqOixcy2dU9b6U/M8h7+ukth2kqkuqal9VXVpVf6qpnhJVvVFVVwnHWyxMnf9kSj5TVT8Xrqt/KIs/kkJV/xPKcclwnOVV9WiNDUv3kdfIT8zIcgljAk/ObJ6Qt28n1iD/AKtkR2DG7FOYF3KzkpSPYMbzF6jLWZixuyLWo5S7plwF0muUkfldbpRZfHl23ZNHyGtwE8rKepkSWUdYcDPb2zcBQJU36OoJirJpwO8LZK+T9CR1yvQS+d8tR2x+zJHbHv/sThteccSuG1127C6fvuzIY7c/blsARGQWfW7cnr/dtjQvvbwV1//hWI7LHiePW7EeyDTX0jhdex43koTvRq6k+QKf99D1+r4f4tyLmBzy9Fxq28NhW5zYJO8eDQ5p/puSPRO2jShJV/aORaVgozBI+lUsDOrXJWkQYV3ZXS/q841ZL1523y4n3vT4l07f+tTr9pLd9X4s3HwYpujcqsoTqtwS863IgBksfO+2XH3XZ7jn+WP42WGKjCUxMNJGWecC0qo8RmMP/kSsx3kLrH5/EpvgZzB2vw9hJodOfWvI6a+9Oexnz5y2yh+emrDqatNmLL7sOzMHxklI0uWU/l32rowO36/myGK6yQUypVFZqXKPOrCOjanZdH3smDNpVFbS53uHxnWboqxsNtsO4A21teLS6Xpj92iqNhpCEy0rjAKmaDRajGiQFk5qJN8R5dvyKrsPX5mVz4dVzoNdRy3NPjKDRTmQxfki6/Nb1qEXa/FrlmB5FuUYrPf/aeqyMHUZTF0Wpw/PY50DSxadrwIn06g0Kh9yMVYuWWVoIsnMk3myDqysJ2Zkk4COCor2GTQqf+nFlE+m0ZCw9t/G7ZyUOc77PMk/sGiGJC/J+nwjC9K9R7Hxl+ZUkvXzoFkbHU+P/LvGJb/vx8wZQ5j63FCmWNigyJewpSYexhT8mcDfERmGyDew8MgXsHrvTeB8/shqWFv/AjYnwUQsKuk4kmVH8qnpTKys00ylsfMoL9274VxpXqOZkSrSR5HaFIb2+jXfv/UR1nlSkQfDEIsLSdY03RFrF3YkiWRqlbb1r3YJk3xlO/ftnDUdT+LhijwJPKxK3n2IusR7dC3rCeGYz9LVwBoDPBE6DbLtWUz3JEkIYeRBmnROqDKdrktGTKB1/asVoyzvmJWQ4iiMeYeIXIl5mJ7GwlE2xy5k9ZTh5swDxNYAchzHcRzHcRxnDgnzYDSlu6bEn1PGYOF/R2KhPZcDm7pB5jiO4ziO4zjOx535wlPmOI7jOI7jOI6zoDK/eMocx3Ecx3Ecx3EWSNwocxzHcRzHcRzH6UHcKHMcx3Ecx3Ecx+lB3ChzHMdxHMdxHMfpQdwocxzHcRzHcRzH6UHcKHMcx3Ecx3Ecx+lB3ChzHMdxHMdxHMfpQdwocxzHcRzHcRzH6UHcKHMcx3Ecx3Ecx+lB3ChzHMdxHMdxHMfpQf4f1Y0I7QOnbw4AAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "iso_pred = 0.99933237\n", "score_pred = 7.31110613983558\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "iso_pred = 0.99996555\n", "score_pred = 10.275924012688163\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "iso_pred = 0.99990296\n", "score_pred = 9.240327745806175\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "iso_pred = 0.9999031\n", "score_pred = 9.241557121481756\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2UAAABkCAYAAAAGwphrAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJztnXfYHUXVwH8nPSGQUBNIgICh9yZVEBSkqigKXBRBQAVUUEDKRwdpUkXpzcKlShGUIiXSa+i9BRICIbQIpMP5/jgz7+7dd+/evfdtAc7vee5z792zMzu7O7szZ86ZM6KqOI7jOI7jOI7jOD1Dr54ugOM4juM4juM4zpcZV8ocx3Ecx3Ecx3F6EFfKHMdxHMdxHMdxehBXyhzHcRzHcRzHcXoQV8ocx3Ecx3Ecx3F6EFfKHMdxHMdxChCRH4jIVSKyYk+XxXGcLyaulDmO4ziO4xSzNPA94CERuU1E1u7pAjmO88XClTLHcRzHcZxipgOfAgOBTYA7ROQ+EVm1Z4vlOM4XBVfKHMdxnC8EIjJARCaKyImpbd8UkXtEZKqIvC8iN4nI8CD7pYi8LiIzQrpqKp3mfIaWLMfBIvJGSPN0RnaNiLwpItNE5EkR2Sxs7xO2n16Q75hMeT5MyZYLSsIMEXkhle8IEXlYRD4SkVNT+/9GRM5rcB5riMjNIvK/8PlvOM6ocPwby1yPzxMiMkREVg315gci8nMRORjYAvgs7gYMAtYB7hORK0Vk0Z4qs+M4Xwz69HQBHMdxHKeT2AlYGDgfTCEDbgGmAscD7wHfBoaJyELAmcDdwOHAIsBXM/lNAA5I/f8kLRSRI4FRqrpLJl1f4O/AwTllXBX4EzADOBb4h4gMV9VPRORi4DcicpiqflTnHJ8Djg6/Z6a2XwYsBvwW2BO4SkQWA/YG5gdOBQ4XkbOBD4B9gLXqHAMRWQG4K5zLacArwDeApYAn66X7PBHmh20LrAIsCywO9AemAYopX32BfkDvvCwwy9m2wLYisrOqXhYy3x34DvAscDCqn+WkdxzHacMtZY7jOM4XhQrwnKq+HP4fgbVze6jqMap6lqpuDjyFdcIBngeuUtXjVXXbTH4fA7eFzy2qOqtMIVT1aFU9pI542XCsU4GbgMGYMgBwA2aB2bog+3eAf6nq5ap6DYCIrIYpFpep6p8xBWweYDtgLuBt4PaQfjBwDHCmqk4uOM5BoSyHq+qBqnqeqm4PtLOOBWvcP0Tkg2BxPEFEegfZVWH7dBF5VkS2DduvFJHZIrJg+H9SsL6tLiK/C/nMFJEJInJE6libiMirIvKOiPwhpLmkUTnqsDtwJPB9YIVwbSSzj6a+p+fkMQuYDdwKjA2F7AdsGeTLY4qs4zhOIa6UOY7jOJ97Qud7HeDh1OY1wvfN6X3VrBYPYdaqPYApInJ3VBhSLAtMDp/HwnF6icgCIrIAprT0j/9FpGGbqqozQz5DgLWBt4CoRD6GdfC/VpDFhkB0J/y/sG2J8P1m+J4QvpfELGirAf8FHgnbNwL+2KCoRdcuy9+BTYEzgH8CBwJ7BdnDwO9IrIZ/FZEBwKWY9Sle8+0whXosMB5THPfFrHJHisj6ItI/pFswyNdrohx5PIj1g6aE41yOWU13wyyq62MBPuYGfkCtZXIaZoE9H1hOVbdS1ReCbAXMwhbxeWeO4zTE3Rcdx3GcLwJRSZqY2qZ19kVVx4nIBpgb36bABsD6IrKSqj4TdhuHKW1gnXAwF8HXMtntEL6XCGkKEZHBmNKwALB5VNRUdaaIvAeMqpP0H8C5mHXmKOBYEbkr7xCp83xARJbArHGPA//GlKSfich+mMK5q6o+m8mj7rXLOZeNwjGPSIk2FZGzMAVlB8wFMDIKsxK+D2wnIo9i1y4qmQuFvOZNpVkJs1wOBy5V1TNF5HnMQlVYDsxNNY/LgetVdWqJ85yOKXAzsYAfZwLHq+qHObuvlvP/ikbHcBzny40rZY7jOM4XibT72aOY1Wkz4Mq2Hcyi1UdVHwF+LCICXATsgrmbRaXsE1W9LZP/21hHH2BnYBjwh5SsuHAic2MKyZrA91R1TEH5a1DVNuVCRBbGrF3LY1Y/gJHhe0T4fjWkext4W0S+iyl0d2LWoY2BnwKHATtmDvdoyHszTJmLx82zBgrwBLB/atsU7DrtjLl/ngz8CtgKGBAU0Kswq9TPMCXwUhGZC3O/fBPYFZvndwgwIH0p8q5PQTlyUVXFrF1l+BCbP3YR5tJZdK+zlrFlERmI6rTcvR3HcXClzHEcx/li8C5mzVokte0ozJJyvogshQX62Abr5C8RoupdC0zCrBlKopABDBGRHVL/bw6WkdsAgqXts6ziJiIbYm5vAPOKBX0YG1zzbsXcLC8B5gn536Gq7wT3vPmA17MnF9wd/xnKOw1z7fsMeFhVHxORJ4EdROQZLNDHR5hlLabvhwU7+R5m8RHgh9hctFdyrueJ2FyrY0RkXkzB+zpm8WkL9KGqH4vIGMyt8muYMrUBNldvbNhtLmxe1fqZY1wK/ByzRt6jqq8Hi5diATeGUzu/7nlM8f2OiOyNzSEsU460S2ur3AcsqKofFO5lETqXyGztjVn6HmqfwHEcx/A5ZY7jOM7nHlX9FLgfs0DFbbcDMbDHoZii0RdTwl7E3Od+A5yDzRvaK+PGNxKbkxU/o0oW56eECJCYkng+NkcJTCEDs8rFfJcP21bFBkvzXBJnYK6GBwGnY0Endg6KHpiC8gJmZeoH/DDjWrcvcKuqPhciOx6KWbEGY8paDcGFc0NgDGbhOg1zgXw5uy/wI+Aa4JeYRewrmALyH8xFcFXMhfGWTLp7MAVUsPlgqOrHmHtl/3Cut6bKNAOLsPlekEULXjzPeuXoMGoUK2TGKnW2+7wyx3EKEbPeO47jOM7nGxH5KXAhsFQqAuPnBhE5FlOeFi4Iif+lRkS+gylx07Dw/5sB26jqnLFmmsi+2NIBYFbXFcLvCaju2TOFchzn84BbyhzHcZwvCpdi0Qz3aLTjnIaI9MHmUF3gClkhi2GWx+sxy90v5yCFTKi1iF2KzeEDGIlF7HQcx8nFLWWO4ziO4zgdRWRR4Kzw7xPM1fJIEkXtj6j+pwdK5jjO5wC3lDmO4ziO43SctJXsCWye42N15I7zpUNERoUF3+PnfRG5XETm72C++4f8dgn/x4nIxw3SrCciR4pI08+liGwXjndkayXOx6MvOo7jOI7jdJz0+mSPZ74BVkVEcBclx3kMW0pkO2B7zLK8W3oHEekdAji1wq+oXRsxj/WwNQ3HUfuc9hiulDmO4ziO43QEmxO4UmpL7OS9hq2VNgSYB1iS/CUIHKf7ELmhy/JW3abEXhNV9TIReRxbpmNtERkHLAj8BXP93UhEBmIRZVcCJgJHqOplYNYxLArrO7Rf9uJMYAHgH2E5kKOwCLULhX0PJ1lf8mIRuRhbymIgtv7j2sAHwOmqelo4XgU4BVtAvkvmsbr7ouM4juM4TsdYlmSB60movgUQrGLpUfjVcBynr4gsCHw3/H8jfA/ClhHZH1O2bgSGAr/HLFp/F5FVRWQVTKl6G1si5JsFxzoofJ7BlssYCzyLBeIBWxJlR0wJux5bouQk4EHgVBHZRkSGYZF9Pwtl2agD514Xt5Q5juM4juN0jPS8lMcyssdIOnGrAVd3S4kcZ85lM0zpAlvo/RDguvD/J6o6RUS2AuYLn+NSaTcBolvjaap6oViQnUPrHGsbbEH67dORbYOVbifgQVW9XERWwBa5BzgmlX5TzIg1ALhIVc8TkU+BC5o96Ua4UuY4juM4jtMx0kpZdn5K+v/yiPTHFsJ2nJ6hnIthV/Ig8H/A+8CzqjrDVpTgE1Wdktn3r8DfUv/HAVuF35L5boZ6cztvwRafj7yNLUTf0eM1xJUyx3Ecx3GcVhEZDCwd/inwZI1c9T1ExgOLYv2uFYFHu7OIjjOH8a6q3t5gn/sxpW1zbB5YH2BrzIo1Juyzr4j0wtZ4rMcNwJrAFSJyNbCyqu6LuSsCbCEiU4FrgJeADYDbgamYW+S1mKI2HdhVRN4Afl3+VMvjc8ocx3Ecx3FaZ2WSkfOXyV/8e2zqt4fGd5wGqOr7mBL2MnACZlmbCoxT1SeAA4DhWKTF/xZkdUL4rIitI7h62P5PbHDk+0BVVWcD3wHuxVwhjwHmBp5S1UlYdMhewIHAA512oil88WjHcRzHcZxWEdkL2CL8uxLVv+XssyYWfhvgdVR/2U2lcxznc4JbyhzHcRzHcVqnaD5Z5Glgdvi9OCLzdWoJRASRuQgTcxzH+fzhc8ocx3Ecx3FawUJlLxz+zQCez91PdToiz5GsZbYKcGcHjjs3No9taWCZ8D038DAix6M6q+W8HcfpEVwpcxzHcRzHaY30umNPN1CGHiNRylajWaVMZFnMTXJZbC2nPNYCfoPIH/D5KY7zucKVMsdxHMdxnNYoWp8sy+PAzuH3aohIKcVJZB5gF2y9pDJ8DXgXuKjk/o7jzAG4UuY4juM4jtMsFop7ldSWevPJIq8AH2FuhkOBxbE1l+rlL1hI7l1DmjSzgdeAF4AXw/c2WLQ6gG0RmYzqDSXOxHGcOQBXyhzHcRzHceohMhcwAwuZneYrwODw+33gjcJ8VD9D5AlsHSQwF8ZxdY45CtgLWC4jeRC4GngV1ZmZNOcDCwDrhC17IPIeqvcVlstxnDkCV8ocx3Ecx3HSiIwE1g+fJQBF5APMLXBy+B6eSvFEyTlcj5EoZRshMg34FPgs9VkKs3qlI2S/A5yL6kN1czal72Tg91jwDwH2Q+QDVJ8rUTbHcXoQX6fMcRzHcRxHZDESRWzxJlOfimrjwB0iCwEXNpHvbOBa4ApUZ5RKYXPQ/kASDOQj4ABU30ztMwBTNpcK+00BJqU+73mgEMfpXlwpc2oRGd3TRXAcx3F6hGbWuJI6v+vtK5jlR3L+98psg8brqKYtS59Sa23qA/QLn75A/9T3QGBA+B4UvgcC85OEts/yaaqMecwEdkf1gwZlNkROxZShRjwNnIXq+FL51h5jYUwxGxK2TAKux1wulwIWpfi+zQ5pJgOzsOtK+NbUZzowDVsOYFrm/6dhn/S90dTvvPzip7MpyrPM8Zpd/21O6lzPSWX5ovMJqm+1mtiVMqcWEZ8U7DiO43zZmQk8AtwbvmcC8wELhs8C4XswcBeqD5bO2dY22zyk7ZX59MaUmIeBuztkrRJZCjgeU0Ydx+l67kP1+FYTu1Lm1OJKmeM4jvPlZCamDN0DPILq9B4uT8cRWQs4jPaWHgXGAy8Dr2PRHYcDw8Jnnm4speN8UeiQUuaBPpwsr/R0ARzHcZweo1U3r0ayrJta2n2tnqxenmlXx97h0yv1PRtTsNKfGZgb3rTUZzowNfX/jdLztj4vqD6MyAlYqPx3MSXsZSx6Y32lU2QgppwtgF1XqHXhjJa9/iTuoGn30AEk9yPtphq3kflOu7W2lSJbKmrrRFH9KPpfluzxuppWy9ndeTr1mdSRxG4pcxzHcRzHcRzH6UEaTaR1HMdxHMdxHMdxuhBXyhzHcRzHcRzHcXoQV8ocx3Ecx3Ecx3F6EFfKHMdxHMdxHMdxehBXyhzHcRzHcRzHcXoQV8ocx3Ecx3Ecx3F6EFfKHMdxHMdxHMdxehBXyhzHcRzHcRzHcXoQV8ocx3Ecx3Ecx3F6EFfKHMdxHMdxHMdxehBXyhzHcRzHcRzHcXoQV8ocx3Ecx3Ecx3F6EFfKHMdxHMdxHMdxehBXyhzHcRzHcRzHcXoQV8ocx3Ecx3Ecx3F6EFfKHMdxHMdxHMdxehBXyhzHcRzHcRzHcXoQV8ocx3Ecx3Ecx3F6EFfKHMdxHMdxHMdxehBXynIQEQ2fUT1dFsdxHMdxHMdxvtj0qFImIkuKyDUi8o6ITBeRCSJys4h8pSfLNSciIgNF5FoRecuVRsdxHMdxHMf54tDTlrJrgW2Bp4CLgceAdYGFe7JQcyj9gDWAh7vrgCLyYxHZV0SWajLdd0TkcRE5SURK1zERthPhCRGOE6mtmyJsH2THiiAZ2Y5BdlSObKcgOyJHtnOQHZYj+0mQHZIj+4YIV4jw/bLn1iGqciRVeYqq/J6q9OmWYzaLyABE9gyfQV1+vKr0oip/pCqPUZVfUxVpnKjLytKXqlxCVZ6gKj8rnU5kGCL7IvLLHNnCQbZ3exG9RDhbhLEibJqR9RbhXBEeFeEbObLzg2zjjKyPCBeK8IgIXy99DpZ2SRE2yj4nhVRlHqpyA1V5mKp8t5njdToiyyGyDyI7dGKeK4f794P2IlklvFe3y5GtFmRNvVtEZI2Qrt21FJG1guw7ObKvBtk2OZkujsjXEVmhmbJ0CVVZmao8SFVupSordcPxvhrq5r+pyjJdfTgRlhPhPhGqIsyTka0owv0iXJaVtUxVNgvvzqupysgmyrl2eEdcIsLATilLq1Tl61TleqpyLFUpX5aqVKjKk1TlL1Rl3ibSDaIqG1GVYa0Ut9sQ2SO8exbrvCzb+kqHtnvPV+V3oX9yClXpn0m3mwhPinBQTrpDQrqTqErfJsqyV8hz33bCqhxFVZ4OdaJUX0lE+oR34L4iMjQj65uSlX72RKR/Kt3gsukARFWb2b/TEJH5gPeAD4H5NBRERPoDvVV1qogsDFwBLA8MCfveAvxSVT8MlqLXQpa/Bv4PEGB/YCpwGjAQOEVVTwj5XwL8BDgHGAVsBDwL7K6qj4d94kVZQlXHicj8wHHAt4D5gSeBg1T17rB/BTgUWAKYBrwAHKCq9+Sc92igfScs4U+q+nLBdRsKfJAuX0FeHUJE3gaGAXuq6jlhW26FUVUJ8pWB+4HYMT9YVU9onI7VgXuBAUG0nyqnBtmawD1AfOD3VeWMIFsbuAtTWgF+pcqfgmxdYExKtpcqZwfZ+sCdQHwZ/FyV84Lsa8AdQHyod1flwiBbHngAmBtQYEtVbpY96pzf+VrYUW2Yrip7AX9Oic6honsWpeuyshQmlqWxeg+wIqrPNEzTkbJU5ffAISnRgVT0pA6dQytlMWXwbODnKdFeVPTshmUR+RZwc9g8CNVpyUFlK+DG8G8AqjMSEUcBh4e/04CVVXk5yI7F3oNg78CVVHk1yI4HDgqyT4AVVRkXZCcBBwTZx8AKqryRV/40IqyKPbeDgEuBH6uiDa5Zb+AGYIu4GdiKit7UQ3X3t8ApwGuoLtlw/zLHEzkUOAZ4FtUapUZEjgCOBJ5S1ZUzsqOBw4DHVXW1sK1uI516754AHAg8pKprZ/L8A9Ym3q+q62VkpwK/Ae5R1a/VnqScDOwH3IbqpkXn3VWE+jIMeAiIncz3gVWp6PhW8iw6h3C8kdjg5/Cw+e1wvEmt5FmEnq8iwlDs/OLg5zWqNuAnwnyhLLFeXq1KO0W/KaqyAtZGzx22vAisIXfyUYNyLgw8SjJofqEquze8nl1BVZbF2uEhYctNwNZyJ58WlqMqGwK3kbT79wMbyp3MapCuP3ArsCH2zt2Ril7f3e1NifeOhPL1B3ZA9YqO5inCBlh/KF6zn6lyPgBV+RHwt1SyKhXdKaTbGPgP0DvIdlHlLyHdT8H6VIFLqOiuJcqyOfBvaFPwtlflypDn3mB9v8BZVHTvxnnKCGBC2Ly2qj4U9xFTbF8Pf9dU1UfD9kb94NHAS2Hzyqr6VN7+efSkpewjrPEfCjwmIqeGUb4+qjo17DM3plTdAJyPKSM7ASfk5Lcv8CCwUNj3T1hnfX7gOLFOY5qfYx2TxzEL1I0iMiCzD8HScz3wM+AN4EpgJeBWEVlGRAYClwCLY52SfwHzAPVcMEcC+xR8So9adSUi0he7lgAjmkh6ColCBqbIluE0EoUsm+50EoUsT9avjuyMAtkfSV4yWdmZJApZVnYeSWMmmILfNVRlKHY902zbkSxlD9G8T0fyDIyo87tBgaQvIuuFTzkrYFWWolYhAxpbLRueu8g8iOwUPmUb1TWoVcig/D0qumbp/4skRWRRrNMeGQhsEGSLkyhkYM/h+kG2JIlCBjAXsF6QjSZRyAAGYx4LhYgwCPgnyfO+E9Ra4OrwfRKFDOw5amfF6UbitV6kifteNs+8Z6FVWXcfb2Tmu6c4lEQhA5gP6xw3RISBIuwXRuzLehkcQ6KQEX6vUzJtKxxAopABbJ76/TsShQzKt6dFnELShgEsjQ18N+Jwar2YSpdFhLVEuEmEk0Vq2vJWOZdEIQN7nyxemMIG0M6itt1fFxt4bsRpJHVuIFClKnMX7N9TzE/SV2r2HVKPbF9pM4BgnfxTZt9tAYJV7E8kClk63WCsb9YuXREhzz9DjcUt5jkv7ftK32uUZ6BsO9zM9Ww1Xc8pZao6C9gNmAKsgo3WXQu8IiJrhX1exJSh57BR3zj6vklOlj/BGvvZWKU8RlV/hLlESjhGmutVdTvMUvYOduG+QXvWwDo2HwFjw/fLmAKxK1bpemMK43XAEWojo3+vc95jVFUKPmPqXLLuZmGSyl+qUonIcPKvYYN0LEqdRlaEUYSOZY5sSeo0liIsBaxVR7YssHod2Qq0rytRNrpeWbqI71OrqM7JtPoSGo1ZWu6ltuNVxI+ayL8ZVsae278DC5ZM8+MOHK+VxmAHqOsmuGPBsYpklQJZEd8DFs1sG5K3Y4aOXLOuIF7f/linpjPzHILIXHVk84VBvTzZgsFrpNnjDReR3nVki+S4k6dl2XrVqoLYeZhVtaX6GZSwy4CTgQuwAbVGxxsI/LCV47VC6Gjmnl+RrGWqMpzYkW2CcC23b+WQIiyNWTc2xyyvZ7eSTxtVWZKSSnmGVYHmXXGrMj/WV00ziDmzbW5ZGchDhOWA1eqIt6b++35l6iv638EG/pplHWoHKNJsBy0r+66URVT1SmwUanPg95hyNIwwEiwiO2KK0InYwxz95fM6TM+p6mzM+gWJK1U0yWcbxudCGWaBufeQPyI4KnzPTWLNipV0tKp+DOyJdZRuwJTK8cDXyEFERovI6QWf0XnpeoBWKtVGJB3GBzG3jzJ8PfX7fqwe5MnuAyan/m+ckb1bR3ZvgewezI02klb478ZcZSLfTP1+DfJdHupSlWWoys7B9aIMaQX31kxZ5jRafQktVud3EfEefYq5R0wr2LcZWilLvEczMFfEGQX7ZmmlMYh1dyZWJz7Lkc3Aros2KZseZGX5dhP7Gubnv1H4NwU7h57xoU/o1I5MiTxzraA5smbmVsd0vWk/8h9lfWjfdhYppFE2N9JjVoFVMcsYWDvdfk61yDcRORCRLTKSvai1wO5awkrzVRLL74vYoG5XMoqkj/EySb8FzNsmDnq8mJG1SrqNfoLQDyrBqkCcf/U08EoTxzwRWCD1vxWFKk16Hu2rlG8X0237g2Cu2yXYglqPm6YQ4dsi3CLCMSKt51OSzn6XFfWH0v2TO6jtm6XT3UUy5Sab7jZq+2ZFpPttY4D/1TnerZnjNWKOUsp6LGhAcI9bO8y7ugW4RUTexczEsQGIIzPnYnPGvovNMcsbKc76Euf6FqdYLlWOqH1PyNlvXPh+C5vDNSOkG0gySvAXVT0vzIH7AWaaPQyrOFmi+2I9rsNezj1NbqVK+cxq+n/gq+F7LKaULkQwU5dM9yD2wh4BnJSR3R9ki5K4r0bZPZjytjhwbEb2X+yBXRKbx5GW3YkpWqMxF5m07DbMPWNpErev6NL1EOYytg7Bda3NPzm4w7XzKa/Kt4BrsAZfqcpBVPSkBuliWf5IRfehKotj7mKNj9f9tPoSWjzvd93zq0ovEgvoQVT0ZKqyOjYa3tHrklXKHmlQlsEkI697U9ELqcoGhPpSoiytNAaxThyiyikiNa6TUXaQKqeLsBe0jbhH2QGqnCnCr3Jk+6lylgi/yZQFEUZiSsKjqm2KYOxcXYu5k14Q9y+4ZiuQvN+/T0VvpyrbExrcVu9fB+979lo/0QnHy+b5YoHslQLZuPS7Mu/9GSxc2XQTC2STUrJFMrJ3Y6Y5sufT5yl7iNa7zp0mq8qe4ddkrE15C3OnSvNzbKT839jcosgeeccoPIeqRDfeCZhXxPvUzn3JpdXrIhe09XE+xNqw97BOJSTP5ftB9gHJHNTGiNyKKTAnohrbsJjns9j5zcSe38I6LRfYuwR4E3vuZ2F9leJ0Nieu+cGbYmI7/GT4PRBryxs9l+k+wTexgYg7ShwvDiJ9CGyF9RfOK3E8RPgeNuWlN2ahXAAbxK9LUZ6ttikdyDNeszuwupSeOhBll1DRXYMV9s6M7GZgS8xq9tuM7Fwq+guqMoJQ50uW5TrMS2NVkmc8yk6nor+hKqMoUT+z14mS7XCD/myjPAvpyUhu/YG7ReQ5bDRqKolfaRytjRNrt8R8WrfsxON/W0SuxhqehbBGLO8BfRRTCNYFHhaR+zDr3kaYy+UlwCQRGRPyiJGhPsw7aHBPbKkDHYKUpEdaThaRj4H9VbXsaENZYkX6iPKVKnZqzwgWyDdF5MQm0p2uymzgdZE2/+AoO02VT4FxIhYAJEf2qginZ2Snhk7kyyJtjXmUnRJkL4q0+UZnZc+LcFbYNip8/16VWcDdpUa+bKL6tdAWrUqwjvtJBWl6hbIoZkWGir5OVYoUeqD1F3AHO7aLYAMhs2g/+l9Es9aphbB3xxRi56yiY6nKMY0Slji/ZssSLetvYtFjoaL3UJWTS6QFe64+wpSUvMagRibCXJg1Yxq01cnzgdVDVLah2Hv0nCA7B3PTHRLy+ZjEhessEivEIGzUMSpVZ5Jy4RXhB5hLZz/gHhG2wurwMOye/0KVd0SoACs2OOd4Xe+jorcDUNErqErdIApdSqJ81LsPreQZ5+O2yzO4JC5QRzYQs0Y0W5Z5ME+QdLpoUZoXc7NKy8YG2QLYPU3LokIa56ZMD+lHAM+XLE9nEuvLhVR0IhAVp7RL1ZKZ7+gSH+viLZhF5RcljhcHhs6hEtrUqvyKMIjbBcTzu1SVNwFE2uZ3RtnfVXkryH7XRN7R6yY9vz2e36lU1LyKqrIbiTWyUTkvVDUrhEi7eb15bEzikbU/5rbWUffzeA5HU9GpwNQQcKLRQHxMdzwVnQ3Mpiq7ArMbtA0x+uaBVPQ+4L4wIFdIsMqeSe28qjJHqpG1AAAgAElEQVRz9zpCK/22IrL9oRdSfaV4Pa3trejbqUGUdDoFnhHhnDCvL6Y7NqR7MwTpKFuWk0Oej4lwcegrLYr1lY4LeY6jKu2jM+ZTdM3i/49zZI3y/BQb9PjcKGXTMavYxpiyNRAbnTqLpLN6FKaZr4vN7TqO9qNkrXIW1sleFWuk9tB09LOAqn4WQgkfjZmxd8GUxX9h0X/AlMi1g/yTINuvk8qZJhtUIgY3OJLyJuCyxIo0FthIRAalArDUI3ZS21xMVLVMCP+cdDyUkT3Uoqwoz1Zl96XKXmakbQ9oOnzwgthAxMtUNHHnrMwxcw6zxBH4GXSt+2J05xlLRWe2ba3onfm7N8Xi2Is93XAUEevDg1Q0cSMsf49GkIz25jUGT2Cj2dm5PU+rmstmaCgfCb7/AE+qMj0ji53TJ1TNvTIMYjwq0qZ8Pa7KzCCbjQ1GIcJq1HonbICN+Ea3p0dVzd1YlTdEGrosx/t3f83WnqvXUfl4ABto64yOTJyPOzYnzzhgkScbUSAroihdq7JYtx/HPAJ6KthHPG5SXyo6ve2/KdVR6VgCkV6ofgasGba9CnxPlakipdzc8o73MV23FE1eG/ZggaztdyEi/UjeYekpEXnnN4lkALxROfPaxSJidNGqqg20itS4neXSIGJefIfc2yao6JMllkWJ5/BA25aKPtuoLKnj3Zjadi61ylYem5A8769Sfp5yR0g/0+sgInQsxHrefX+YqgzCFPl3qOirbXsn7/E66RiCKeYTqOiEnHSNyqIkg0oxz+FYX+klKpq4UDbXDn8IjCe/HX4Xs9Q3q5RNwgZQPx9KWZj/9dsG+0ykfVCPM1PycWSsTqo6NPP/63Wyf09Vf1XnuNk8J1NgclbVjoWoLUmOibQriRXpMZIG+6UGaUZigVaadb8ciSnp4+rIpmIPTJ7sI8xSkSebQmZeW3DXGom5hEzOkY0AJqvWzDNLp3tXNVGAw4hNI6L7xh3AzljUu0bWlPhS61Bo+W4kukzNpP5k3DwWx+YQ9qc5RejppkpXjsWwOr4kzSmIzd8j6zQthLk4TyL94jaLyXxYnU83BvHc8+aBRFleJ6NVGdg7Ou+9k3vuUbErYE6r160qQq3mmfdeLSMrc7yiPFtV2B7FlLLOuC6t0OgZm5dkGkF/rBM8gcSr4SpV4mDi8Vj7VER3188yz3TZeV9pFiexUH0l1TkfiXkzNGrLO6sso8L3taltbUu8iK1HujfWLo4HDlcteLeb4jUSc/OsVSQrBcqHzWVdGFMGppQuvQWaicd7K3WsT2lsmYtz0O8Jv+cnP3J4ZzIC60s9jz3T89PigH2qz/Oeam1fieR90O45Cfd0EeAtVbLXuqXnS4QBmFL7ahyQ7GieKUZg9/YtQkTiHNlkzDDUbJ7TSCytpZgzF6J15gTi6MFrqf91X+Qh4tfCwBvBdbEUwcS/EPB8GL1PywZiL5VnUvNYomww5q71ZFYxCq5ccwOP5ShNQzF3rWdzZHHU/FXaE119mlM4rRFZAQvI8OPggnMVVZnYIGXsjOSVpWcQmZfEUn0Aqm+H7b2we/84ppSti0hfVGeVWMdlMawT1Z/mFKGuuC6LYaPSZcsSG4NWyhKDOMTGIM+akpUVHa/TZaFxjQMKh2EDCdFNNN6HZoMPzGn1Ol7b52jeytsozyewkd08ZefxzP/078dyZGWONzbzv6tk3Umsn+PqyJdMyUeF/2mlrC1Qh2pbELAiFsUGAd9ptGMn0epz24hoHZuCKa0LUpX3sffOOCrl2+hAvP/jmkwXB9ra5mlmBm7OBXYPv9fEOrBFERIXwN7PjxcqYe1ZGFNSm72Ww7B+8nNNHg9sPjrAccFDYWKT7qetkFYw4v9Wvaii63PeGltF7/GFsGuWJ2v1/Z+2OHZWnpERWLv/NjBYROZR1f+l5uPejSllQ0RkLlUtfI+ECLeLYF4w04ANRKS/ptYaLaJHoy86czR5D3cRgzFz/sdNHieukp6XbkiLsqFdIIuRpxq6XmRYBFMCn26bEwFQ0XvrpjCKzq+nWAubD/Ajatexii/hWF+E2nV+8pG2Ucjx4bNYiXWiuua6iAzB6uKE8CmjlHWkLPF5itdsEZJw5XkyoWvqdZFsJHZNXsc6FtMJCxSTrGHYTJQrSK5Z3YVqu5nste5MpWwCyXIrWdnr2Oh7nuw1bECsWaXsRUyhyMszT+lMj3bPqiN7AhtQ6imlbAgwNVgm8oiui2My/6My0Ozo+RDgoxY64K1S5tkso0xmybsug7E+XyvP3lBganbgtASLY9bJvEGfVUkUsiexAc8+YIN22fnO4X9sh5s9h1bfO62+5yBRjNvcJVVLR6RulWb7bUUU1c1W+1+t3oeuyBMRmQd7LvKu2VBs2kmz13NBavtD0EQk3S+dpUxVd8HmhTl1SI0Q3Ef5yhgDXjTbgMR0efPVOirLK0tHZY3m1WWJi4I+0mS62rJUZS8Sd4hf1/hjdx9fzfyOLinpju3M1LbxDSZQL4y9g6KlbCA2Epp1lUiTvS6HkQSl2IlKudGoHGInbkIox/qIDCRnnmlBWU7E7venVBq6NMdrNhG7bjFc+aQcWQxX3mr9bFUWl24YEy3V4fuNVICbjj3vVbkEU/wmUtFfNplXeaqyIvBT7FreB1wV5iRmlbKl8zNoiuz9y1N2mpV19Hh5Smc63dt1ZONpr1h2J/1Inq+RJJb626non0ksZWOwdj3+j53p8suImFdDP5K6OZpkfvuNVPSiYD3eKnymAf9Q5Z7mTqmGfpjSm+f22w+YFYJKNUtUCO7AlgUYTRLlM57fmiSR9P5GRdMuhnllaUU5nA/4qI4yF9+Rl5GsXZg7pSRFXMQ41okNseca4CIqeleddNn3zregLXLtGVT0vw3SxeOtQrLc0S1UNNd7SITeWF0cHwOjdDkiA7B2orOUsvJ9parsQvCq+PkmZ1987h2/aJQu3ofdSQL47V8zP635ssQ89yYJu9+or5R9d8Ztz1H77pyckqUj6RblGd0X47ZxDdIBX0KlzClFKyME8WXZ7JpRRenmJFmrSlm0GBUpGnlky7IaSXTS/2syr85iLcxffRq1C3PXU8oaEa1RUSmL24quVbwu8T7EwBNg8xJaJZZlPMmioItS/AKOdSLeo69jymqjeSvQvrMct00qkHV3nY8KypM5suy5lyX7HG2JKaONGrrWqcpvMdfLOCCwFxaZ72DaN8rrIjIA1eklXG/rkb1/KyHSG9VPc2TLiEgvteAUWdn6IiLaeKJ+TDcppFslI1NMsXqL2iiCI7B5MZODLB2lL84PfjfIeirQRz+SSMaDSd6BUdmKSth/M/9jPWvGit0LqyOxbg5NHe+N0NH+J7VRoPehYx5HfYFpdeYm96X1NRi/glk/7039zz57w0nO70GK6UudiNIN6E99V9DVw/dpKaXt9Dr7RrLnMJokANpd4ZNHtt1YguTcrylxvKgMbERY5gdbsqnelI65QtruUciMrNs7dEwpa6bdWIlwPYcMmnJ9iXTxPqxCch+KIiiXKUvMM91XahQhtF5bm5VNzmwrm2csb+mI1O6+6ORRVFHrEV+qfQv3ai7d50VWROzgm9tjVY6hKuPCpyg8bqvH60rWwtyZxgJr5rjbZUebGpG2Tk3IbKtHV12XtII4IbOtK8pStjFIy7q7XkdXobyORexENht8qHvrdVWWwBav/QzrTO0OXJU6/oggi0oLNLekQx5xsv2UkGdvEsvNCOATVf0oyPqSLKw7AvhfiHIbLaSNQpXHdO+q6syQbm5JFnseAbwTAmu9BQwVkUEp2aSgEL4FzC822t4mI5ENC6H+u5tPKa4rX8E6Y69jHaeoWMY005s4Vpy3XO94P8QUskcxK/IiJOtitkrR+TU69yJGA2+QzIEeTceevVbL0gdzm81jFazT+miT5aCFsrSartX3XHyOutNNu5V+WxEttRt9es/uin5UV+QJrbXDHcmzIQ2VMhEZJyIqIt9NbTs9bLuk7IE+L4jIABE5U0TeEZFpInKviKzdIM3yInKDiLwrIh+JyHUisngmz+NE5DURmS4iT4vI9zN5bCUiD4rIxyIySUT+mGogEZGRIlIVkbdFZKqI3CEiK9M1tFWq0EH4H40rVbSQzNXksWK6QV0gyytLR2V5xysihs2N1pP5MMVjcYpfIq0er2sQGYG5G44NnyEkLjKtvoTS1qnxmW316Krr0oqC2JGytNIYtFo/W5VF62WetaHV5z120LqrXm+NdQxPp6L7UtELqegPSaKgjQDeCVasmvtQMK+lETavwyxcefc2bmtG1vh4zeeZJ1skJYtzYCdSdp5o5zOT4rqyJDAuXOtxJJay6PJXfikSm0c2i/p1OvaB9lHlBVXeUuXw0vnnMxPoJ5LrtTQTGBhcJstjc3WXBF5DdQo2qDKajj17M2n+WQe7nvXuwfxYNOPP6sjrlYMWytLd6SLdNTcRatuNSbQPMtQsLbU3c/X/JD57zfaxOlqWVu7R508p+xJyOvBLrFJfhwU0+I+ILJC3s4gMxdYp2xpb++NWzIf7X5JYEk7FXGVmAX/FOrdXici6IY91geuxkaOrscblV9g6bjGy4b+BHbFoZ/8ANgRuS42IdiaxAomILIW5ijSqVNFM2+wLvyjdnChr9sGPI7XN3qfs8W6EDs1d6ChxPtljJBHN4rZYNwaQjBB2laUse10upXPC47diKcuW5ULKh5oegSnqC1BrtYnfM7HIX2lZd9f5OJCQt0B6rNetPu/xmp1M56+xmGbD8H15zda4MLBd1w8RGU3SgWq9I5PMx52CvTtjh3OEJAtV/y+8Vz9NyXrVkzU4XF+snnwU0sV7NiIsVL1gHVlcduHjIIsdqREki1h/iMjCJEp5T8wrm0ZSV94D/tAmsWUlFiWZqzEOWBBrE1vtqKWP9xaJqxoki1E3Y9kpczzIV1yibECOrIgR2DMbIye/hlkQs8/eS8BFJfOcRmvK3AzM7TSPIitaUTlIleUpit0Ps+niuT+K9bUaEd9zMd0L1K5TWo94Xl3RP6tHfD57Y+6ZzQQLyqOZ/tB/CGu2zjvXB0XKfzbdzSSux51VlhtIr2FXTLrvMjizLX4PTOXdjFI2iKS83auUici8InJVsBRNDxahc4Osr4j8J1h4ZorIhyLyTxFZNJV+AxF5SkQ+EZG/icjlwRJ3emqfb4vIQyLyPxF5XUROSblh5JXp8GDRy/tU6qRZCJs0+hnwDVXdEev0zY0panmsjzWm41R1G1X9PubitQKJX2uc0LqHqv4M850VEn/X72EP0mUhEMm3wvbdRGQ45iqxEtbQfFNVf4x10hcEflbvGnSAWIFOweZ6jAIWTimZ7VDV6ZjytrA0jqCX5iOs0c9zGfoQe+DyIte8h12PPNlkrAOSJ5uEdXjyZG9jHbN6Mmh+tDiu0xEjBJ2HLcbbiLj2mh2votdT31++O4hzyMaSKGVxW6wvd5NEmmrGUnYq5mKW3laP7HX5K6lwyx0gHvdqknkNzZblPMqHiB+BdUpeAK5MbYvf/YLsstS2eLy8+hllec9Rq7Looz9PjiyOAC6UIysie81OomvDj8fn1RTtqtxKVcZQlfNSE+OXxTqovw/7dqQjE+fjroq9Ow9L5RmX3Fg9yA5JyWLErrWC7MCSZRmOtSXrhXRx7c9o2QYLTPAiNv8pyuL93ijIfpWSxWNuilnJ9i1Zlq7gTaAPVZk/LAybXucprsU1DJGDSOa9LUlSp+Zv4XhDqMpAKvom9m6KRKW9MwezyzzT+ZHbqrIkVfkFVTmKqhxOVX5MVeYh7cEgsifRRXantjlOw6mKUNEXsPaobDn7iJA7OF3AO8DcqcBAaT6hnHtumtp2uKIPAxeXSBetvul0l9fdO6H2PVfRW4A/lUj3CdYHGdJoxxKLXpclPp/nY8/0vHTsmZ2E9YWL6ma8njdjBgm+tfItcY3XMun+BdxeoixlnpN0X+nuEnlCcn1upv1SJPH7VpKBmGaUsjtprj8EdN7LZT9gO6xhuxiLXBIXYYtrGN2CVZZXgW3C72hpugEbhYqhlmsil4nItzBL0hJYxLcJWOPzZ+rzU6wRyvtsVifNCtgL7A1VjS/1GDVv1Tpp4kjK/CKypIiMJGnwVsnss3oYoVyljnyZEKIzdnb7Asun5H2BVUVkPpIXb3pSd2eRV4FidLgiJmAduNLhP8ME5wnAAtkXfko2XKQtJGpWNiKsS5aWfYY9qIuF9czSsuimNCqsg5aWzcJeREuGxQrTsumYsjdapCnf5ejTb2uvVPQJyi3AGa01yxXu1X3EOnkjYUSM9kpZmmaUsm9jlub0tnrEF3BnX5d43I2xxXLLlKW1e5RYU7LE0Pd5ClJcFLfe8bpCNi58j8qRRXfTonmReXTV/atH1tr3NUwRWYP6c8c60pGpl+ciHZB19/HqBfXoiWAfRfUzuiqugS0MvW5q+7jwu9n6OQFTcpfJkcW15QqnM7RwPGj22azKoVg0xU3C98thv5Ek8+q2BM7CBnQJ2ydgnfVmB1NabY9ex/qAedfzBWA+kSYGOi267jvAaKqSp+jVS/cJppAuHRaSLst7WP9ruWaUJ1VmY3VwcZEca1lV1qMq11OV8cDTVOUpqvIoVWnWKpom75meH7OYN004h7eAJbJ9JQrqw5ILvTaT+n2lVuvRFEzRXTbHnbcjfaV6bW0jWbN5drtSFi/8g5hS9kOCEhMWTNsWG83+hGQhuo2CRWVrbHTxVWATVf0W7Rer+3X4fgx7sOLI+E/qWctUdZSqSp3PLnXOY1j4Ts+hiFF36r04/ouZSufGXo7jSZSXmOa48H0qNvq8S0Z+PubCsy5W+W5N5T9cVV/BrCuCKa7vkSyw2BV+/vUqUKOKFR+O2AggIo0UuTrp2q5hGdmKBbIV6sikQNaL1AOekfUhCRVOiZHDV7HRprWoNjVRPo7sLd9kI9L52HO6Zvg3nETpXi1M/s9XyhpbTPNcFRu5L8b72nnzKe0c8l6kXVWWuChnlhHUujNmZW3Pgkgy8TzUz66QRatfHGCLsj4kStnKGVmjke/Ov3/FRHfS+DwvQrF1sGh7GYrena3Kuvt4rZalKyiqL1/J2Ra3jwu/Y4Q/RJi7ztytsseLbnJ/FmE9EVYUKWU1KXO88m1fVQYDR2KDe9tjfZBhWEc4bSnLMpqk7jf7/MV0eeUsYlz4Xi2VLlqP4sLkqXgFdcueZjzmWdRsJ/xNbHCm/LIXNs9wAta/G9Xk8V7G+hltkYpFmJeqDMeMFKOB1ajoClR0JcwyPSs3p3LUez478j57EzuHtsGNcN/fx5TVpajm9sHNwl3bV1oQU6hnA8tSLa8spgbhB5IMxsQ8Y19phRb6SnnXbLiI9KkjK/QYK8izU5Wy6K+ZHpWIFzO6t5yOVbK9MMXsQ+CvItJLRL6GvTxOAQ4gCVs9AHuBxMK+kAr9m7UkjArfm2KWrj3DfyF1g9K04r6IWUmg1gc6/s5d9C9EtdoYW1D3OOAXQDWIJ4d9zsZG1w4DDidZMDHK38Aq769CHt8jWVMkhuLcEVNujwV+Q+JW0Wyo9TJ0VCnbHtrmwh1Q4niZdPRNpYuyHVKy/evI+mFW27w8+5O49mRlAwpkA7HrXU8WXXvysbWQXsNe6nHfxs9dMiI4mMSK1FOMxgZO7gR2C5+bsGd4DfJdNAbV2W4kizVnWTDMaalH7BwsQ1VWL9ivGUaQf08WpfgFHOvDWmFNo2aOV297kew9bK7CMMJcqbAA6xbYe2AW1gCvH2SrY67Q0WV3UYIVUIS1sHXv3sYGDUYROg8irIONwL+EuWytJ2KdMRHWCMdrG51MydbDrFBFxHSbU5VmXZeMqvSmKv1KjlzfGb5/TVX6UNEPaDxfK9ku8l29gIv1Ak4vMcjQKE9Xyponece3v9+5bT+1lrIfirTNBzmUJPBSo+PtmHO8a7G2fTlsIPYprL3vCPF4Pwgh9wEOKpAdjHWGJ2LWrgWxd0I/rE+wKbXKajrQRLSUAdTrAzUq5/apwZuDS6R7PXzvLIKEtDE4SpxLdJIIe4mwP+VcCpN71BytposDUM2mi8t87CdC76CMHo/Vz8HAI1T0XaqyE1V5HntPb97kMdJ0xXOb11faN6Ws9sa85BqlGwTsExaBn4jV121z0jVTlrmBvanodMyoMRhbP7AUQfHKM2r0wq5ZnjW5T53tMc84HzdLaQtoGa3yFUxhWBe4MnS0o/k+uma9r6qbh4nFywB/wx76c4DvYzfuX5gFbUWSNTGEpJOV7tQsSy3jME19H1WNi0ciIkuq1l1s7qfUH+n+C4nilOZZrGOzmIgMU9VJJKMcT4RjDsEsBdNVdVwsiqpeGuQLkoTJvS1s66eqD2FWLiSJWhnlAkxR1T+F/xtjL9BPSHxS+6rqdcB14caPTefRyYzAHpyo/KyNKcONHu4YcGFXEXkG67CXcWWM6X4mwvPYyPyQjGxPEV7E3I8GZWR7i/AStk5Uv5Rse2AfEV7FFhOUlGw74DcijMPcWaOb01PYyN1+IryOuYBMS8m2AX4nwvjwu0zI29uw+3kSVdmW8i6nT2Od43OpylzUd7vtamJAj2tQtYnhIp9infNvBtkdwAXh908wZcCCKOQTn81/pdL9HGuUFqPe3KyKTqMqr2DXs0pVjiZxW2qV6Kb4V+zdALYW3CbYCzh3QAZTmidjHaMrqcqppEbmC4jP0eXYukdggxCrYS7aYO+nG8PvA4FVFOkn6NPYc3WBCMcCRwBHq/KZCM9gHgoXinB8kB2uyqciPIuNcl8swgnYSPshqswKz9zywCUi/AE4CjhAlakiPEBbsCP+jT03P1VlWnjmlgIuFeGMkK7R4q/PYh3FocDlVOVyrC68WZiqKlthc7BeBB7GGs4BVOUZKnpTQcobsPu3JfBsqDsjsEY83oeTSd6nZ7RtNwvqadi8pLkxD4aiY5HK8ziS99PZ1Co7x2LXAeDcjOxo4Pnw+3zKK2WHk7THF2fyPBSz2IPV77TsEKx9Faz+jyAZnDwYC6suWJveE0pZvIZfw+5FenmGqJQtgQ1YDCS4n5NMOxgFXB/e87tBw2iJ8XibYx3oNqUmjNbv9GfZe+IYvv61jxk88Wa26Gj0xXi8lYEzRXgPew/ul5KtBpwhwhRgNyr6W6ryfWxh65ewcx2MDZJPxPpcnwBzo6qILI29T0eTrDm4C1V5gfLWn+i9tCFwQhgA3Y5kMLMe8T58A6uXg7F31H5YwLKjsXd5nIpSZr3Cp7FgavtTlQlkLPkNzmFz4CCqMhF7v5dNtzFwBFV5n2TOfyPuxLy8tsSCwI3AntEHsMBtFaoyDpuvdDvWd25tflni9v4S9t4HO7/d6dhz+xRmJPhteIY2Jwli8jRWp86gKkrt4PFT4f/vRJiATVH4IJVuMeDPwbK1RcmyPI3Vo8NEeAfr341LHW9jrK80GBucaMQwrB25l6T+7RDKujJ2L+7G3t9gOs3W2PWs1ydIzyc7P/zemSaU7TJK2fmY9rmviKyPaYGjsTDpcRL6QSLybezCzCR50KeQvODXAc6k/UjqjVjHbSkRuQ3rHGdN63/GKvaJIVLhtLDP/CSdmBpUdVTe9iJUdVJQmPYAbheRpzFF8mOSyZ3bYi+XJ0jmmd0qIu+F89gCc0H6l6rGUdo9RGQn7PqsiL1EppAsljcX8LyI3IHdkziCcGRYzwbg4qAQTsQq32jMnfPSZs+zCLGIVgsBd6nqZWHbW5RTytKBKE4O32NKHDamE0LESRIXzrQsBmC4KSPrBURl/cYc2Znh9/UZWW+S+3pNRtYH88cHW9coyg7B3MvOCdvKjOxdgjW00JwCcReJYvD3JtJ1NtOwKF13pLbdHbZFq/l9hPoSItlFpewZRAa22YZFBqI6jUQRuhcbbABb4qFYKTPuwhryZeic+h/Lch+qd4SybIVd+8Wo9wKuqFKVu7FGazWs4wqNF4+Oz9F/Utdss5BHdBO5NSXbAlPkF8HOfQ3s+b8kk+9d2DtpadpPfr8LU8qWqSNbHrMAZKOxXYTV2WHArhnZfzGlbCUSxbqYik6hKvHduSnlGk+wuTJLYw3oiyHdLzClob6iVNGPqcp3MYVj6VDeqVjbFe/DVdigGYj8Blg5dHJ2wNqyCmaFOKTwWEbM8wpUnwx5HoJZKduUcVV9xkRyGLVK0mWq+nyQHUl5pezSOEApIsdl8vy7qr4eZCdmZH9T1QlB9gdqlbJLUH07nMOpJcrSFdyLWXJ7kQQqicSBy9dDSPyPEHkH+IoqE0R4EusnfKOJ46UDBBzYTiqy9t6w/96c9QLm0n1YB6Oej8Xq4yASD6DogfQI9u4dCOwdtll/oKIPI7Iz/biZoXwFZQLzMJxX+BgbWHiVxPPodayQo6kNUnF8E+W8j+Q+/C5sm1B/9zbuSp1DXOT5FQBVZoiwDdaGrhzKeFleJjl5/h/Wfp/ZYN9sugOobdvLMAZTrvqRdNDLcCs2WDA/yeD+y1T0M6qyNa+wBePZh8F8g8G8yrL8gHKRCPOIQYSeTbUb0+m4UpbuK0XF5eqU7LvYANtfc9IdjPWV4jWrpmRbYkFe/kZ57sLeAf1JAtRcmJJtjLVTZftK8bo8nOrrLowpZbEdfiglG0milNWLwBrzfCCV7is0oZQ1dKNS1esx17yxmAVrCBb+8huqGiPTjMU6It/FtMJJwK/VGqUzsdDyA7FRlt9n8v8Qszg8jTX+k0lGj2eEff5NMi9tS6wTFBcD7Wz2wR7YYeF8HgA2U9UiN8EngQ2wc5+NRZJLm3RfxirgT7AOzI3A+qoaRzZnYSOZ38ZGuV4GdlfVk1N5PIV12nbBRm3Pxe7BTDqXaNmamNpWdq2FJ0ncLpvhUaxzlcfD1B9Ff4CkbFnuI+lcZLmH+m6fd2Ev0jzGkL+QbjEVfYD2L/MbSUbL61Em1G/Xo7k7pRkAAAXDSURBVHoNqruh+qzsISp7iKL6Kqq7kShP6fuQ1Bdz//ubXsBEvYA3gb+Gbek1yiJlQ9F39nVJh+aPjM/IOrMs8TnKe8aWKpCNaHC8rpD9BYtMFZlJYpG5sv3upWj+mlX0XHZlZfZleY5kbw5lC07gCCa3zXUsSvsgsMKGY2FDs4cNp6Ink9yHbN3tjw2sHYQNtL2BtXkbILJBg6PVu7dD+iT1OiubD1Pa8mQLSvFE/XrnMDwlezsjWyTIlNp35FvAImoK8GfUviMnAiNLunB2HhWdQl50NltoIK7FldaKxgGjMI+espEF08d7C7NqtMfeW3/ClJwNsHbizI5ckxBc6p91ZDNJBhmzZRkK3MRM4B22ZzLL8QqXYe33XCTh8MHm9U/ElNgnamTlyzmFFrxyVJlKvleSyZGh0+k/6l7Wm/QqSzymyCltQpFBegEH6QUcQe26rv/F5jQ1y+2YMaFZbqmTrlAbD+eeVezNnXMnRnM4Z3A+gziNKziGHdmJxdkpd03IMhS1KR1Ryu6h/pIl1xakG0N9L5midEXcShLjIUt3t8Ot5FmKUoE+VPVSVV1DVedR1YVUdTNVfSQlv0FV11bVoao6QFWXVtUzg+xjVd1WVedS1aVU9eJUwI14055S1ZVUdS5McYnuiy+mjnGdqq6jqkPCcb6qqm0h8zsLVZ2mqnur6oLhXNZT1ftT8ktC2VdNbfu1qg5T1b6qupiqHhRCxEf5Laq6bMhvnhA6/5mUfIaqbhjOq3+4FheSQlVPUNURqtpPVYer6i9UtXkFoTF5jfzEjCyXMCfwxMzmYrck2qIlnpSXLkRLLJL9oY5sNom1Liubhc1xzJPNpDYMclo2I+d442mEiPAjbuN27uU1nucuruZstqeixZN6K/oU5uaQ5gHKuXh0F43qy/HYQMMVWCd+O8y1K08Rir8bKUK3kERCi1xF4mbaLB1REK+l/f34S96OKYqu2eIFshGY5eCeTH7xGbub9mvoRNkYErfxrOwObPCjVibSW5F1pzLwxe9y7U1f586nL+EnZykS3zu3U2sdV8p1+C6kfUNffM1ENmYmtzOZd3mJy3iNv/EUP2ZfTkOkcC0qEfrKTjrv3VPg7ikgO+ngMDc13oe0YhKvdQUbLX0be48shSmkjebRjMAG2dIDOxMB+ti9nUFtZyV936dS6w4dZUUu4COAD9Wsz+l0vbG6+14ItpWW9cGUwMmqNe+gt4D+n5ns7bCgdlo2gPz5El3NSdR2gJUpXP4mi1x0CT+5V4QfirChCOtfz7dv+ZReJ2CDwOdgLnKR88I7vBHZNuxTzCL/U8w61h8bqBBsdD5vTk0znEJtgIc3M7LZNTLzZrkcU74uwuaQ/gFTFA+/nB8evR1XvS/Cj0TYVIRvns0vzgD2ZSfy2uiplFuzK3sfGrbtgQOpjRNgz7p5Rvy7PzOfX4/7f70E45YFrkNkALY80Z3Yc/gGcCkiRyIiYb51tm2fTD0FNlLRabQfyH+H2kGnvHRTqV2KAWxgqpHVHEUe+BV/vGYhJr25Ko+N+R7/2AeReT9h0FEvstRDl1K58Tq+02sMGx3zIUO2pok5URla7rcVlt/6Q9m+kuVb0XG09xR6Cng8RKvO9s/fDOlepL0SNZYG642q1nisZfN8kvb3436K1w1tth1uRinLy7MUUjvI1DOIyFXYi+c5zL1xE+xEVkgpbk43ICI9XyEcx3Ecx3Ec5wuAqpayqHfmIogdYSw2yvN/mN//FcBGrpA5juM4juM4jvNFZ46wlDmO4ziO4ziO43xZmVMsZY7jOI7jOI7jOF9KXClzHMdxHMdxHMfpQVwpcxzHcRzHcRzH6UFcKXMcx3Ecx3Ecx+lBXClzHMdxHMdxHMfpQVwpcxzHcRzHcRzH6UFcKXMcx3Ecx3Ecx+lBXClzHMdxHMdxHMfpQVwpcxzHcRzHcRzH6UFcKXMcx3Ecx3Ecx+lB/h+20MUOHh98ngAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "iso_pred = 0.99987984\n", "score_pred = 9.026541534063414\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "iso_pred = 0.9997962\n", "score_pred = 8.498225134751246\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "iso_pred = 0.99990547\n", "score_pred = 9.266467393808759\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "iso_pred = 0.99985945\n", "score_pred = 8.86982269471123\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "#Load GENESIS models and predict sample sequences\n", "\n", "model_prefix = \"genesis_apa_max_isoform_simple_25000_updates_similarity_margin_03_weight_50_earthmover_weight_01_target_14\"\n", "batch_size = 64\n", "\n", "sequence_template = sequence_templates[0]\n", "\n", "save_dir = os.path.join(os.getcwd(), 'saved_models')\n", "model_name = model_prefix + '_generator.h5'\n", "model_path = os.path.join(save_dir, model_name)\n", "\n", "generator = load_model(model_path, custom_objects={'st_sampled_softmax': st_sampled_softmax, 'st_hardmax_softmax': st_hardmax_softmax})\n", "\n", "n = batch_size\n", "\n", "sequence_class = np.array([0] * n).reshape(-1, 1) #np.random.uniform(-6, 6, (n, 1)) #\n", "\n", "noise_1 = np.random.uniform(-1, 1, (n, 100))\n", "noise_2 = np.random.uniform(-1, 1, (n, 100))\n", "\n", "pred_outputs = generator.predict([sequence_class, noise_1, noise_2], batch_size=batch_size)\n", "\n", "_, _, _, optimized_pwm, _, sampled_pwm, _, _, _ = pred_outputs\n", "\n", "#Make predictions using black box model\n", "\n", "fake_lib = np.zeros((optimized_pwm.shape[0], 13))\n", "fake_lib[:, 5] = 1.\n", "fake_d = np.ones((optimized_pwm.shape[0], 1))\n", "\n", "iso_pred, cut_pred = saved_predictor.predict(x=[sampled_pwm[:, 0, ...], fake_lib, fake_d], batch_size=batch_size)\n", "\n", "for pwm_index in range(16) :\n", "\n", " print(\"iso_pred = \" + str(iso_pred[pwm_index, 0]))\n", " print(\"score_pred = \" + str(np.log(iso_pred[pwm_index, 0] / (1. - iso_pred[pwm_index, 0]))))\n", "\n", " pwm = np.expand_dims(optimized_pwm[pwm_index, :, :, 0], axis=0)\n", " cut = np.expand_dims(cut_pred[pwm_index, :], axis=0)\n", " iso = np.expand_dims(iso_pred[pwm_index], axis=0)\n", "\n", " plot_seqprop_logo(pwm, iso, cut, annotate_peaks='max', sequence_template=sequence_templates[0], figsize=(12, 1.5), width_ratios=[1, 8], logo_height=0.8, usage_unit='fraction', plot_start=70-49, plot_end=76+49, save_figs=False, fig_name=model_prefix + \"_pwm_index_\" + str(pwm_index), fig_dpi=150)\n" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [], "source": [ "#Load GENESIS models and predict sample sequences\n", "\n", "n = 1000\n", "n_slack = 0.05 * n\n", "\n", "n_ceil = int((n + n_slack) / batch_size) * batch_size + batch_size\n", "\n", "sequence_class = np.array([0] * n_ceil).reshape(-1, 1) #np.random.uniform(-6, 6, (n, 1)) #\n", "\n", "noise_1 = np.random.uniform(-1, 1, (n_ceil, 100))\n", "noise_2 = np.random.uniform(-1, 1, (n_ceil, 100))\n", "\n", "pred_outputs = generator.predict([sequence_class, noise_1, noise_2], batch_size=batch_size)\n", "\n", "_, _, _, optimized_pwm, _, sampled_pwm, _, _, _ = pred_outputs\n", "\n", "pwms = optimized_pwm[:, :, :, 0]\n", "onehots = sampled_pwm[:, 0, :, :, 0]\n", "\n", "#Make predictions using black box model\n", "fake_lib = np.zeros((optimized_pwm.shape[0], 13))\n", "fake_lib[:, 5] = 1.\n", "fake_d = np.ones((optimized_pwm.shape[0], 1))\n", "\n", "iso_pred, _ = saved_predictor.predict(x=[sampled_pwm[:, 0, ...], fake_lib, fake_d], batch_size=batch_size)\n", "\n", "prob_pred = np.ravel(iso_pred)\n", "score_pred = np.log(prob_pred / (1. - prob_pred))\n", "\n", "sort_index = np.argsort(score_pred)[::-1]\n", "\n", "pwms = pwms[sort_index][:n]\n", "onehots = onehots[sort_index][:n]\n", "score_pred = score_pred[sort_index][:n]\n", "prob_pred = prob_pred[sort_index][:n]\n" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "mean proportion = 0.9999\n", "std proportion = 1e-04\n", "mean score = 9.2797\n", "std score = 0.6145\n", "-------------------------\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/scipy/stats/stats.py:1713: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n", " return np.add.reduce(sorted[indexer] * weights, axis=axis) / sumval\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEYCAYAAAAJeGK1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzsnXd4lFX2xz93Jr33kEpCSAKhht5BqqIiFiy4KvZedi2ru7q6uuVn2dXF3tZeELEgKAJSpYcOgVRCQnrvyWRm7u+PmQyZzCSkYQJ7P8+TZ/e9733fORnMe957zznfI6SUKBQKhULR19D0tgEKhUKhUNhDOSiFQqFQ9EmUg1IoFApFn0Q5KIVCoVD0SZSDUigUCkWfRDkohUKhUPRJlINSKBQKRZ9EOSiFQqFQ9EmUg1IoFApFn8Shtw3oSwQEBMioqKjeNkOhUCjOa/bu3VsipQw80zzloFoQFRVFUlJSb5uhUCgU5zVCiJMdmae2+BQKhULRJ1EOSqFQKBR9EuWgFAqFQtEnUQ5KoVAoFH0S5aAUCoVC0SdRDkqhUCgUfRLloBQKhULRJ1EOSqFQKBR9ElWoqzjvaNQbeGZlMqsO5RHm48pfLk1gUkxAb5ulUCg6iVpBKc473tyUwRe7s6lu0HO8oJo7P9lLnU7f22YpFIpOohyU4rxj94kyq+PqBj3H8qt7yRqFQtFVlINSnHeMjPCxOnZ30hIX7NFL1igUiq6iHJTivOO+mQO5dEQoWo0g3NeVpdcl4uni2NtmKRSKTiKklL1tQ59hzJgxUqmZnz8YjRKNRvS2GQqFohVCiL1SyjFnmqdWUIrzFuWcFIpzG+WgFAqFQtEnUQ5KoVAoFH0S5aAUCoVC0SdRDkqhUCgUfRLloBQKhULRJ1EOSqFQKBR9kl51UEKIaUKIlUKIXCGEFEIsaXX+CiHEz0KIYvP5GR2873QhxF4hRIMQIlMIcdfZsF+hUCgUZ4/eXkF5AEeAB4F6O+fdge3AHzp6QyFENPCj+bpE4J/Aq0KIK7ttrUKhUCh+M3q13YaU8kdMzgQhxId2zn9iPteZXgl3AXlSyvvNx8eEEOOBR4AV3TJYoVAoFL8Z52M/qInA2lZjPwM3CSEcpZRNLU8IIe4A7gCIjIz8bSxU9CmklLy8LpVPd2Xj7qzlD3PiuDwxvLfNUij+5+ntLb6zQT+gsNVYISZnbLMSk1K+I6UcI6UcExgY+FvYp+hjrDyYx9IN6ZTV6sgpq+fhrw5yoqS2t81SKP7nOR8dlELRKfZkWfePMkpIajWmUCh+e85HB1UABLcaCwb0QMlvb46irzMywtfOmI+dmX2PnLI6Xt+Yzsc7sqhqaDrjfIXiXOJ8jEHtAC5vNTYHSGodf1IoAK5IDCM5r4rPd5/E3cmBP8yNIzbYs7fNOiOZxTVc9to2qhtN7ew/3nGS1Q9MwdlB28uWKRQ9Q686KCGEBzDQfKgBIoUQI4EyKWW2EMIPiASaX2cHCiEqgAIpZYH5Hh8DSClvNM95C7hPCPEK8DYwGVgCXPcb/EqKcxCNRvCXSxN46pLBCHHutOj4ck+OxTkBpBfVsCmlmHlD+vWiVQpFz9HbW3xjgP3mH1fgr+b//6z5/ALz8Ubz8bvm45aFt5HmHwCklCeA+cA04ADwZ+ABKaVKMVe0y7nknAC0dvpdOageWIrziN6ug9oEtPkXJaX8EPjwDPeYYWdsMzCqW8YpFH2cxeMi+XJ3NuV1pp3roWFeTItTmaiK84fzMQalUJyXfLc/l/d+zUQrBHfPiOHCoSGs+8N0fjqcj4eLAxcNDcFR29ubIgpFzyGklL1tQ59hzJgxMikpqbfNUChs2HuyjCvf3GE51gj46cFpxPfr+8kcCkVrhBB7pZRjzjRPvW4pFOcAm1OKrY6NEramFbcxW6E4P1AOSqE4B4izs1KKOwdS4RWK7qAclEJxDjB/aAjXjo1AqxE4agW3TI5WCRGK8x4Vg2qBikEp+jqVdU0IDXi5OPa2KX2O5mfZuVYu8L9IR2NQKotPoTgHMBolK/adYl92BeOifVk4Mkw9iM1IKfnnT8f5cHsWWiG4f+ZA7rlg4JkvVPR5lINSKPogRdUNvLwujdTCai6ID6S0VscH27IA+GJ3NmmFNTx24aDeNbKPsOpgHu9sybQcv/BzCkNCvZgeH9SLVil6AuWgFIpuUlTVwI7MUuKCPRkc4tUj97zj470cyKkAYO/JchuFiM92ZSsHZWbloXybsY93nlQO6jxAOSiFohtsTy/h5g/30Kg3AvDI3DjumxnbrXsWVDZYnFMzrUPFHs7qT7eZSF83m7EAD+desETR06gsPoWiG7yyPs3inABe3ZBObQsB167g4+aIp4u1A4oN9qA55KQR8Mi8uG59xvnEQ3Nirb4vJwcNd04b0IsWKXoK9RqmUHSD1j2YdAYjjXoj7t14gXdx1PLcZUN54pvD1DcZCPNxZel1iWg1ggPZFYzu70tUgHs3Le85dHojTg69967r6eLIL3+Yzhe7c2jQG7hqdDgDAj16zR5Fz6EclELRDRaPj+Qv3x+1HF84pB9+7k7dvu/CxDBmDg4ip6yO+GBPHMwaezF96MF7srSWB788wIGcCoaEevHvq0f2mvRSkJcLD87u3taqou+hHJRC0Q1unBhFkKczm1KKiQv2ZPH4yDNf1EG8XBwZEurdY/fraR5fcdgSKzuaV8XDyw+w6v6pvWyV4nxCOSjF/ywfbc/i7c0ZANw1I4YbJ0Z16T4XDg3hwqEhPWhZ3+eL3dnszCy1GjuSW4XBKO32qVIoukKHHJQQwh+4DJgBDAGCAAkUA0eATcBKKWVpG7dQKPoUu0+U8fTK01tzf/n+KINDvBgb5deLVploMhgpq9UR7OXS26bY5fCpSp745rDN+Jj+vso5KXqUdh2UEGII8CfgCsAZaALygEJMjQb9MLVSvwFoFEKsAP4hpUw+m0YrFN1l9wnbd6ldmaW97qA2pxbzyPKDFFc3MqifJ2/fMJr+/n0nIQJgl53vLsLXlZevGdkL1ijOZ9pMvRFCvAMcBCYD/wKmAt5Symgp5Rgp5WgpZTTgZT73MjAFOCiEeOvsm65QdJ0RET4dGvst0RuMFucEcLygmudWHevy/XR6I9mldRiN1kVUqw/lc9nr21j4+jZ+Omxb5HomRtr5np66JIEIP9t6JIWiO7SXGzoeWCSljJJSPiml3CalbGg9SUrZYD73JyllFHAtMPEs2atQ9AhTYwN5aHYs7k5aPJwd+P3sOKbG9q46eHldk8U5NZNaWN2le21OLWbiP39h2osbmfmvTaSZ73P4VCX3fbGPgzkVHMip4N7P93E0r7JT9x4T5ccfLxyEp4sDbk5a7pkRw9wh/bpkZ0/S0GSgulXav+Lcps0tPinliK7cUEq5AljRZYsUit+Ih2bH8YBZ9UHTB2IngZ7ODAn14mhelWVsRnznnabRKHl8xSFKa3UAZJXW8eyqZD65dTybU4usVCmMEjalFHc6W/DuGTHcOW0AEs5q3KleZ8DFUXNGYdw3N2Xw6oY0GpoMLBgRygtXjejV2ixFz6Cy+BT/0/QFx/TGpnS+3nsKf3cn7poew+pD+RwvqGJ6XCCPXzS40/erbtSTX2m92ZFWWAPAwKCea3zY+rtrMhhx1PaMUyiqbuCBL/azM7OMCD9XXrhyBBNj/O3OPZZfxfNrjluOvzuQx+goP26Y0L9HbFH0HspBKRS9yPKkHF5YkwJAZnEtR/Oq2P74THzcul7s6+3qyNgoX/ZklVvGZg02CafOTQjmunGRfJWUA8C1YyOYPbh7oqpbUov583eHOVVez6xBQfzr6pF4u3avX9U/Vh9jZ2YZADll9Tz45X62Pz7TUrDckmP5VR0aU5x7dNhBCSFSzzBFAvVANrAWeF9KWd8N2xSK857NqcVWx3U6A0lZ5cxOCO7WfV9fPIp//nSco3mVTBkYyKPz4gHTquefVwzjjxeajrvjCMEU93ngy/1U1JliP+uPFfHvtSn89bKh3brv4VzruFhRdSMFVQ2E2xGGnTDAH0etoMlweu9yWmxAtz5f0TfozAqqCOgHDABqgCzzeBTgAWRgclLTgUuAe4QQ06SUJT1lrELRW2xKKWL53lP4uTnh7ebI+uRCfNwceXhufLdS0weHeLGqRbsIjej6llszFXU6Vh7MIybQnUfmxRPm42ozp7uOqZmTpXUW59RMayX2zmAwSv6zPpWSGutkkSh/N7u/B0Cojyvv3DCGV9anUt2oZ/G4yP+5wunzlc44qLuBDcADwDtSSh2AEMIJuAt4ErgcOAbchynt/K/AvT1psELxW7M1rZibP9xj0/IC4Kb/7u7Wltwtk6PZn13O+mNFuDlpeWxePJH+XU/Xrm3Us+C1bWSX1QHwzpZMVj8wtVsp4OuTC1m+NwdfNyfunB5DdAuh2ugAdwI9na2yDycMsB8r6gjvbMlk6YZ0y7FGwJgoX567bFi7iRIXDArigkGq/9P5Rmcimv8CvpZSvtbsnACklDop5VLgG+BfUkqDlPI/wJeYVlJtIoSYJoRYKYTIFUJIIcSSVueFEOIZIUSeEKJeCLHJXDzc3j2XmO/V+qdvluUrOkROWR0f78hiS2ox0p6nOIt8uz/XrnMC05bcrhNlXb53aW0j6UWmBIZGvZFanaHL9wJYf6zQ4pwAqhr0LDfHm7rCltRibvs4iZ+PFvLlnhwWvbWDOt3pdiJODhrevmE0I8K98XJxYNHocB6a3fVWIBtTiqyOjRKeunhIr4nQKnqXzqygJtJ++vgB4PoWx9uAK89wTw9MUkkfm39a8xjwMLAESAH+AqwTQsRLKdsrEKkDYloO2KvhUpwb7Mgo5aYPdqMz9126dmwE/3fl8N/s84M82363EQJig7quMP7ahnSySk0OxWCU/HtdKleNDu+yzJGDxvadc8PxIiYPDGB8F1Y2Kw/mWR2X1DSyLb2UOS1iZKMiffn+vimdN9YO8cGe7G7h8F0cNUSqAuD/WTqzgtIBo9s5P8Y8pxknTLGqNpFS/mgu8P0aMLY8J0zr+YeA/5NSrpBSHgFuAjyBxWewVUopC1r+nGG+og/z1uYMi3MCWJaUQ0Hlb/e+ccuUKKttrRBvk/NwcdTw+IWDutV7KLfCOo/IYJTd+t1mDQ6yaTt/JK+K697daSPu2hH62XGUzb//2eDB2bGM7u8LgKeLA39fOAxvt+5lBCrOXTqzgvoBuMWczfd6c4aeEMIVU8xpCfBpi/kTgPTWN+kE0ZiSMtY2D0gp64UQW4BJwNvtXOsqhDgJaDGt7J6SUu7vhi2KXqSlcwJT+/Mmg7GN2T1PkKcL634/jT1Z5fi5OxHfz5OSmkZcHbW4n6H1ek2jnk92nCSrpJa5Q4KZNdg6O++S4SFsTTudRxTl78bQsK632HBx1PLtPZN4eV0qb2/JtIwbJSxPOtXp+NDNk6NYm1xAqrmO6rpxkd2y70wEeDiz4u5JFFU14OXqiIuj9qx9lqLv0xkH9QgwCngB+JsQ4pR5PBzTaumoeQ7meI8BeKMbtjVrpxS2Gi8Ewtq5LgW4BZOOoCfwILBNCDFCSpnWerIQ4g7gDoDIyJ7r5aPoOZZMjmLniVJLHGhOQvBvrvvmoNVYFYr6uztRVN2Ii6O2XSWF2z9KYod55bIsKYd/LRrBlaPDLeevGRuJQPDDoTzCfV2594KB3VZmcHHUMn9YiJWDAvDtwkrE38OZNQ9OY39OBT5ujj3SMFGnN/LNvlOkF9Uwc3AQk2JsU8KD+qiSu+K3RXQm4CyEcAbuxJT8EG0ezsK0unqnO3EeIUQNcJ+U8kPz8SRMcaz+UsrsFvP+C4RJKed18L7Nq6iNUsoH2ps7ZswYmZSU1MXfQHE22ZddzrrkQqL93VmYGNarMjbHC6q459N9ZJbUEurtwtLrEtEbJcuTTuHt6sitU6MJ83HlZGkt01/cZHXt2Chflt816Tex877P91lS2EO8XVhx9yRC20jVtsfxgir+vTaVwupGFo4M5ebJ0We+qAPc+9k+VrcQqX3lmpEsTGzvnVNxviGE2CulHHOmeZ1SkpBSNgJLzT9nm+a4UTCm4l9aHHc4piSlNAghkgDVD/ocZlSkL6MifXvbDACe+u4ImSW1AORVNnD/F/sprGqgWTT8x8P5bHxkBu7ODmg1AkMLNfHuKix0htcWj+KWKeV8sSub7Rml3Pjf3Tw4K5ZLR4Se8dqGJgO/e2+3pR7pYE4F7k4OXD02ols2FVU1WDkngA+3Z/WYgzIYJTsySpFIJsUEqP5U5zhdfg0VQvgIIc5mf4ITmBzRnBaf6YKptcf2jt7EnGwxHOh8XwGFwg4pBdYJpPmVp50TQEFVA1vTignwcOb2qQMs4x7ODtw387d9T0rJr2b53lPkVtSTXlTDg1/uJ6O43dwlwLRibV0suza5+7lGjloNDq2chotjz6yGG5oMXPHmdn73/i5ueH83C1/fRn030/YVvUun/ssQQvQTQrwvhCgFSoFSIUSJEOI9IUSn9faFEB5CiJFCiJFmWyLNx5HStPf4CvBHIcQVQoihwIeYMgM/b3GPX4QQ/2xx/LQQYp4QYoD5vu9jclCqR5WiR5gRb10QGu5ru23m7+EMwOMXDWLV/VN4bXEiWx+7wG4vpbNBQ5OBJR/s5olvrTvfGiUdyuaL8nen9eLjTNmKRnOa/LQXNrLore3sPWlbH+br7sRNk6Isx05aDfdeMPCM9rSHwSgxGCWrDuVzsIWKxeHcSlYezO3WvRW9S2e0+MKBnUAoptql5uy6BExJCfOEEBOllKfauIU9xgAbWxz/1fzzEaaswBcAV+B1wBfYBcxtVQMVA7SsRPQB3sGUZFEJ7AemSSl3d8IuhaJNnls4FFdHLTtPlDI83Ie7Zwzg7k/3cdJcz3Tx8BBLqvSuzFL+u+0EAIEezl2qReoKy/bksCml2O65YR3Iwgv1ceWJiwbz4toUdHojIyN8uGt6TLvXfLLzJEt/MeUhZZfVseSDPex4YhYerTIdn7okgbkJwaQX1zAtNrBbCS9Lf0nj7c0ZSGBUpK3zL69T/aHOZTqcJCGE+ABTe/erpZQrW527FFgOfC6lvKXHrfyNUEkSiq6i0xvZmVmKt6ujpTNvelEN8/+zFZ05Jd5Jq+Gnh6b2SCbcmXhm5VE+3J5lM37TpP78dUHHhVwr65qoqNd1qO38bR/tYf0xayWIz24bz+SBHRNuraxv4te0EsJ8XTu00tyeUcLid3dZjbk6aKg3lyW4O2n5+ffT7ArMKnqXs5EkcSHwRmvnBCCl/EEI8SambroKxf8cTg4aQrxdWHUonyN5lVyRGM665EKLcwLQGYz8fLSAe2Z0b0urI8wdEmzXQSXnda4NhbebY4cLZQeHeFk5KAeN6LDKRkpBNde8s8MiPLt4fCT/uHxYu9cczLHtBLxobAQaIZBScv2E/so5neN0xkH5Au213Egxz1Eo/ufYl13OtW/vtDikb/blcuNE24Z5v9UDc1JMAC8tGs4jyw9ZjTfLKp0N7pwew9G8KjYcL8LLxYE/Xzy4w/VMb23OsFJF/3xXNndNi2lXOHf8AFsV+fnDQrolVqvoW3TGQeUC02g72WCqeY5CcdaobmjiuwN51Ov0XDoilBDvjtf19BRrjhTwn19M7cVvmNCfW6ZE88mOk1arpb0ny/njhfHMHhxkWVXMHhzERUM7nUvUKXR6I1UNTQR4OHPV6AhWHsxnS4ueUxcOOXuf7+HswH+XjKWyrglXJ22natUq621jRVUN7cePRkX68vfLh/LmpgykhNunRivndJ7RGQe1HHhUCJEBvNCcqCCE8MAk6notpqQGheKs0NBk4PI3tlvUv1/fmMGKuyahl0ai/N3blMVZdSiP9389gYNGcNf0GBu5oc5wsrSWez/fZ6ltenZVMpF+bnbrbVwctbx301jSi0w5PfbarXeV9KJqnl+TQk5ZHRcO7cf9M2NZfTifv3x/hIq6JsZF+fHG70bxn2tG8u91qRzOrWRSjD8PzDr7ae4d2RIsqWnk8RWH+DW9hCGh3kwd6M+G46e3B6P83RgS6tXOHUxcP74/149Xrd3PVzrjoJ7D1Izwz8BjraSOHDFl+D3Xs+YpFKfZeLzI4pzA9NZ96Wu/Ut9kwM/didcWJ9rI5uzLLuf+L/ZbZJL2Ze/l54emdtlZ7MgotSq8Bfg1vYRbJkfz0+F8S7uMaXGBDA83Bfp70jEB6A1GbvrvHovQ7HFzXdY7WzKpM3/+7qwyXlmfyhMXDeaOaQN+c2moM/H090ctK8u9J8ttasuqGvTojRJHbccKbXefKGNzahFxwZ5cMjxUFeieJ3TYQUkpa4UQU4HbgYWcljraCHyHqcW7yulUnDXs9aurbzI9kMtqdTz53RE2PDzD6vym40VWvZwMRsmmlOIuO40EO2/1CaFeJIR6sf7h6aw9WkiQp7NVO4qukFdRz0c7sqht1HP1mAiLswNIKay2UUFfe7TQ4pya2Zpawrf71lOrMzAi3Jt3bxrTbuuQ35LdWdY1UjWNeqvjslodJTWNHdrCXbH3FA8vP2g53pZewgtXjegZQxW9SqcKdaWUeinlm1LKeVLKOPPPhVLKt5RzUpxtLhgUxKB2GtedtJMAEGMni2xgN/o3DQ/34dF58bg5aXHQCK4dG8GVo0ziryHertw0KYqLhoXgoO26OkJNo57L39jG25sz+XRnNle9uYMjuacz1sJ93WzUF4aFedu0xjhVUW9Z0R08VWmpUeoLtK5Zai0BFR/s2eH4YnOdWTMr9uVSqeqfzgs6pcWnUPQmzg5avrlnEqsO5lOr07PrRBlrjpyW35k3xHbVcsnwUDanFvPd/lyEECweF8n0uMBu2XHvBQO5bWo0BqPEzann/4Q2Hi+isOq0zJDOYGTFvlOWNhfero78beEwnll5lJpGPcPDvXl4bhxLJkfxjx+PkVNWx+j+vqzYZ52z1Lw9WlnXxMqDuRglLBgRiq9719rVd4dnLxtKbaOBbRklJIR48dxlQ/n+QC4bU4qJC/bkyYsHd/herV8GNALs9G1UnIO0+dclhDhTU0C7SCk/P/MshaJruLUQLL16TAThPq7sySojMdKXh+datxpfn1zIF7uz8XBx4LPbxjOon1ePPYydHc5enyJ7grI+rtZ2XzU6nIuHhVBWpyPMrFAe5OXCJ7eOB0z9snZklJLXovnhrEHBVNY3MX/pVssW4ZubMvjxwan4deF7kVIi7O27duCaYC8XPr1tvNU9RvX35a+dtgLumRHDPZ+dTlxZMikKTxfV5PB8oL3Xv08BCXTmv0BJC508heJs4u7swJOXJNg9tyOjlNs/SbLEnzYcL2LrYxeQU1aHh7NDr6waOsqUgQFMiwu0pIdH+rlx/QTbXmWuTlrCnOxvgzlqNXx0yzhe+DmFU+X1XDysH7dOiebz3dlW8auCqga+25/LLVM63krju/25/OPHY1TUN7FodDh/XTCkzS3Nk6W15JTVMyzci7+tOsZ3B3IJ9HDmyUsSmD8spNMOzh6Bns5MHOBHfmUDCxPDuP83FuRVnD3ac1Bz2jmnUPRpVh/Os0qOqG7Qc/XbO0gtrMFRa0o3f3hufKfueaq8jve2nqCsVseVo8Pb3CrU6Y3U6wxdblWeWVJDSbVpiy/Sz403rx9FgFl8tjPEBnvy7o1nVJOh4x3hTMkbDy8/aFmtfLYrm9ggD5bY6RX1n/VpvPJLKlKCu7OW2kZTPCyvsoGHlh1gXLRfh3+vZXuy+SrpFL5uTjw0O9ay3VlQ2cD17+6yJMu8vC6VyQMD+kxrFkX3aNNBSSl/+S0NUSh6kjAf27Tq5rblTQbJqxvSuXh4CIP6nbnWBkw1WFe/tcOyZfbDoTyeujiBr/eeIqu0lnlD+nHPjBj+8eMxtqWXojMYuSA+kKXXJXZ6u+nRrw+RnG+SJMouq+PJ74/w7T2TO3WPtrh0eChvbsqwrKL6ebmwcOSZ+0M1c+hUhU2a/f6cCpa0mldc3cirG9IsLwnNzqkZnd5Icl4V0zoQD/zpcD5/XHFalX33iVK2PT4TTxdHNqYUWZwTmNTa1xwpUA7qPEElSSjOO4qrG7l2XAQ/Hy3ggLn9QnSAGydKrLP8MotrO+ygdmRax3OkhOfXHKfRLEz67f5cfjqST0PTaTWJjSnFvLkpg8cuHNQp+w+fqmz3uKuU1jSyJ6uMN65P5OCpSoxGyYKRYZ2KPyVG+uKoFTQZTjupsVG2kkNltTr0xrbXZi6Omg6pqgP8fNS6D1VVg56dmWXMSQgmwo50VF+r+VJ0nfaSJKZLKTd35aZCiBlSyk1dtkqh6AIZxTXc/eleUgtrCPV24ZVrE3Fz0uLp4sDxgmru/GSvZa6HswOTYjouixNoZyuq2Tk109I5NXMsv3PirAATBvjza3qJ5XhiJ+xsi+3pJdzy0R6LjX+cF8/dbfRhOpJbydrkQiL93FgwItRKsijYy4Wl1yby/JrjlNXquGZsBNeNs46PFVU1sDGliGAvZ6tsxEkD/DicV0WgpzNPXjy4w3HAqABbJfXoADeMRsnWtGIrhzllYACLRod36L6Kvk+b7TaEEHpgA/BvYK2U0vavz3q+FpgPPISp/9I5l0aj2m2cWzQ0GXDSatCYVQNueH8XW9NOP9gj/dzY/OgMSyB+2Z5svtyTg4+rIw/MiiWxk9tAjy4/yPK9p8z3dqWqXk+FHQ25ljx9aQI324nPtEd+ZT1PfnuEvdnljI705e+XD6Ofd/cKbK94Yxv7siusxoaGejEkzJsgT2dumNCfIC8X1hzJ597P91u28eYkBHcojtVMUVUD85dupaRGB5haXkwY4M+CkaFcNrJrbd2rGpq47cMkdmeV4aAR3DMjhj/Mjbcp0NUI2PDwDLsOTdG36Il2G6OBl4EfgUIhxFpgN5ABlGHK7vMDYoEJwGzAH5NTG9Ut6xWKdqhp1PP7ZQdYf6yQAA9nnrl0CBcPDyEpq9xqXnZZHUkny9mVWcrAIE8WjY7gmrG22XDltTpWHswD2q8LenHRCG6ZEk1ZrY5x0X7sySrjyW+PkFVay+zBwZTUNFqcgINGsGRyFDdNjOLXtBI+3H4CdydGdrknAAAgAElEQVQHHrswnrB2FM0NRomfuxPvLxnb1a/HLhV2CleP5FVxxNx+48vd2fi6O1nidM2sSy7kZGlth/pBgWmrs9k5AdTqDMwaHNxl5wTg5eLI0usSeer7I2SV1NJoMNLQZCDppPW/t1GapK2Ugzp/aC9J4iAw0yxvdA9wFXADtkk/AqgFvgXelFLuOEu2KhQAvL4xnXXJhYAp3vTw8gMkhHpZBcubufrtHZZA/TVjInj+quEYjJLn1xznm325+Lk7UlLdSJn5Af725gxWPzC1TSc1OOR0zGpSTAAbHplhqeUxGCXb0ktoaDIwLS4QF0ctqw/lc+/n+yzXrDqcz5oHpxIbbKuI8cmOLF5am0qdTs8VieH8/fKhOGg15FbUsz29hAGB7hzJrSKlsJoZcYHM7YQy+aIxETy/5nib54trdBS3cCwt6Yyunb25Dj2gi3fXp3st8cS0ohpSC6qJtBNr6uyqWNG3OWOShJRyK7BVCOEIjMXU4j0Qk6MqxtT+PUlKaft0UCjOAi1lf8AU+0kpsB/rabmDvSwph7K6RgYEePDOlkzApKrdkrzKBlYezOOmSVFtfn5pTSOvbUwno7iW2YODuGGCSU1bqxE2WWnvbs2wOjYYJU9+d8SSXn3z5CjGRPmRUVzDX1Yetdi7LCmHoeHeRPi6cvvHSVZJCWDqlzQ9LgCjhPHRftwxLabN9hbVDU1IJOOj/difXWHVFuRMXJ4Y1qkeVleMCueDbVmWLMEBAe7MHx7S4evtUVrTaHFOzWw0t7P3cnGgqkFv+f/ldTqiUSuo84XOiMU2AdvNPwpFrzFhgL9VrMnLxYFpcYFMGuDP9szSdq9dl1yEVhS1O+dMtaO3fpRkeWBuSS2mXmfgzukxduc6aW0VJ/ZkldGc4LYuuZCfHprKkdxKWoeDD5+q4Jt9p2ycUzObU03fwda0ErJKa3lp0Uj79prjN82E+bhQ3aBHpzfQoLd/74GBHjx+0SBmDgqye74t/Nyd+PHBqfx4OB+tRjB/WAgezt1LFvZ2dSTAw8lq67CZZufU/P+f/v4oP9w/pVufp+g7KMUqxTnHHdMGcMvkaAI9nRkR4cN7N43FzcmB/948lskDT2e8uTnZlyNq43kPQJiPKwtGtF0XlFNWZ/M23xy/ssef5g+i9Q5Xy+xrncHImiMFjI3ys2ktMSkmgNpWKt9t8fXeXBa9tZ3SVivC9KIaG+Xw3IoGqhr0BHm5EuFrrUThqBXMTQjm89vHMzsh2JKA0hm8XR25blwkV4+J6LZzApPW3v9dMRyfDhQ+ZxbXnHGO4txB1UEpzjkctRr+cmkCf7nUWubIxVHLZ7dN4PWNabz4c6pN+4mWTIrxZ9eJMnzdnPj9nFhL1tqCEaH4uLWd/uzj5oiro9Yq3hXq07bq9shIXzY8PJ1/rU3FICVxwZ68st5aVTzMx5VQH1deWzyKf69NpbK+ievGRbIwMYzqhiae+v5ou99HM3uyyln6Sxp/vWyoZczTxQGNsHaKzWSX1TFvSDDRgR4cPlXBxBh/nrtsKP4dVHc4mlfJqfJ6Jg8M6BFH1B6zE4LZ+cQsDuZUcNvHSVSbV06ta7I6E5dT9H3aTDP/X0SlmZ8fzHhxI1ktWm+0fkCPDPfm23sn02SQOGhEp1cJH+/I4tkfktEbJYGeznxy67gOF/w2GYzc/nESm8wxlGlxgbx34xir+JHRKPl4RxZb0kqI7+dJQogne7LKie/niZSSJ79r22FNHODPF3dMsBp7blUy7/96oo0rYOm1I1nQySy7v/5wlA+2ZQHg6+bIsjsnEmcn8aO6oYk9WWXEBHqcMROwtlGPQUq8zqC8kVVSy5d7cmjSG1mQGMLypFMcyKlgbJQfD8+NP+vOUtF9OppmrhxUC5SD6tukF9WwNrmAcF83LhraD8dWAqW5FfWsPpTH25szKa09Ha9wcdCwZHIUh3OrmB4XyB3TBnTp879KyuGXY4UMDPLgilFhlNU2MTzcu0vK5nuySnFx0DIs3Mfm3CvrU61WWdPiAvn4lnEAfH8glwe/PNDmfe+cFk1Vg4HaRj3XjYu0FPkePlVJSmEVf1uVTEW97bbhBfGBvLp4VIce7qfK65j6wkarmNnCkaG8cm2i1bwDORXc8P4uqhv0CAG/Gx/J8YJq8isbuGxkKH+YE2/J+nt+zXHe//UEBqNk0ehw/n75sDazB4/lVfLgsgOkFtbg6+bIs5cN5dJ2tmUVfY+eqINSKPoMPx8p4J7P9lriR60LSD/ensWzq5LtyussTAzj8Ys63l/IHu//eoLnViWbbDlaSFJWOcvunGh3rtEo+WzXSballzIk1Ivbpg7A1RwPK6vVce9n+9iRWYq/uxPPXjaUi1tkuUkpeW+r9WpnS2ox5bU6fN2dmBEfhK+bI+XmtHiNgBERPlQ36Jk1KIivknIs51YfzufruyaSGOnLsHBvhoV7E+LtwvXv7baxeWNKMe9szuAP7Qjo6g1Gqhv0VNY32SR0lNups/r3ulTLVpyU8MnObMu51zdm4OfuzK1TotmRUcqbm05nO365J4eJMf52a6e+2pPDH785ZPn88rom/rjiEDPiAzlZWkdto54xUX6q5ft5gnJQij7PkdxK7vl8n1Vyw7rkQjKKa4gJ9GDt0QL+srLtba/1x4poaDLg4tj1Hk7f7DtldbzrRBm5FfWE+biSUVzDe1tPUKczrVp+TSvhtY3pAKw5WsCxgireuH40YFLb3mHONCyt1fHQsv1sSStm9uAgEiN9OZJbadP+3MVBg5uzyXZvV0eW3zWJ97ZmUt2o57qxkUyJDQBMbTBaOgqDUfJVUg6f7cpmR0YpQ8O8ePrSIVw3LoIvdufY/I67T5TZjDWzPrmQx785TElNI2P6+zIw0J304lrL+ZhA2y7FrRM2WrM1rZhbp0Rz3E6JwPGCai5rcbz3ZBlb00p4Z0umjXOs0xm4+9N9Fnmo+GBPlt05od1YouLcoEsOSggRBQQDyVLK6q5+uBBiGvAIJtWKUOBmKeWHLc4L4GngDsAX2AXcK6VsN2oshLgSeA6IwaR88Wcp5bddtVPRu7y5OcNGQbsl37TqHNuaErNI6tTYrnfSDfS0ThxwcdTg5eJAZV0TV7253eIYVh3Kx7dVw8E1Rwqo0+lxc3Kw0eZrMkiW7clh2R6Tw+hvp/h0wgB/yzailJK0wmqCPJ25cnS4Rai1yWAkpcD2T/FgTgXJ+abx3Ip6Smt0fH33JC4bGcrNHyRZJXvsPFHGQ1/ut9mqa2gy8PDyg1SaZZ2STpYT5W9t55d7snloTqxV/OjKUeEczUu2HAusq/wTzEXPU2MD0GqE1b/xtBb/Vsv2ZFupmbfG183RSrswpbCaz3Zlc28bWoOKc4dOpZkLIS4SQqRgeuhvx1S4ixAiSAhxXAhxeSc/3wNToe+DQL2d848BDwP3mz+rCFgnhLCNxp62cSKwDPgMGGn+3+VCiPGdtE3RR7CXaj1hgJ/lrb2182iNENhVHegMj8yNt6Q5C0yZe39ffYwV+07ZrFpat/j0dnXEyRwvO5OTPFlWZ5WWrhHw0JzTnYKfXnmUuz/bx9IN6Sx6awdfJZkc2wNf7OfNzdZFwTGB7pwstVZwTzpZTp1Oz4QBAXx62ziCPKxXGd8dyGN/trWEUF5FvcU5NVNUbb06qtMZONlKLf6WKdG8fM0ILh4ewl3TBxAbfHqVNSLcm7tnmGrHBgZ58vriRIaFeTOonycvXDncSiD37c2Ztl+UmQg/V7sxxaKqBjuzFecaHXZQ5tXOSkyyRn+nxZ+hlLIIyAGu68yHSyl/lFL+SUr5NWBV3m5ePT0E/J+UcoWU8ghwE+AJtNeO/iFgo5Ty71LKY1LKvwObzOOKc5Drx/e3Kp4dEOjOJ7eOp8lgRErJndMHWNqeA4yL8mVIqOnt3EEjeGhWXIe15Jopqmrgsa8Pcvkb21j6SxqD+nmy/fGZXDkqDImpVceXe3J4q5VTAJg9ONhSg+WgETwxfzCHciu57aM9bM8oYeagQEK9XdpsVR0b5MkF8YFMHujP0msTOVlay6pDeZTVNPLF7myruW9uSudUeR0/HbFuSdHfz43ssjpqW6XaR/m74Wre6vRzd7ZIPLWkdUFslL87EX7WqfTN328zQZ7OxPezfW+8PDGc1xePorpBb6Xzl1ZUY5XkMqq/L1/cMYE1D03j6rER1jdp9UVpBcwZHMRzC4ey+ZELuH5Cf6uWIVqN4LLErmv/KfoOndni+wtwGNNKxhd4stX5bZi0+nqKaKAfsLZ5QEpZL4TYAkwC3m7juonAq63Gfgbu60HbFL8hcxKCWXbHRH48nE+4ryuXJ4bx8FcHWX04Hz93J566JIGNj8xg94kygjyd2JddwbaMUibF+LNkcpTd5oVn4vaPkzho7sO0P7sCnd7IgpGhfLvfejuxqLqRhBBPyzbaoH6ePHHRYJ64aDD7c8oZ1M8LrUYw/cWNVnVZn982nl/TS3hjk62Di+vnQaCHC3HBHrz483FOlpk2F2KDbOM8J0rquP7dXTbjJTWNNgoUYT4u/OvqERZ19+VJOTZJJd6uDkwZGGA1ptEI3r9pLM+tSiazuJY5CcE8MjeOVzeks/pwPpF+bvxp/uA2pZaav8OW1OkMfLrjJIsnRHLvZ/vYmFKMs4OGB2bF2mzN3TU9hse+PmQ5NkiTasTFw0LQaARaIfhwyVg+3nmS+iY914/vrxoWnid0xkGNA56RUhqEEPYCAqcwOZSeovleha3GC4H2Xo/6tXGNXduEEHdginERGWmrdK3oG4yL9mNctCne8uovaRb1huLqRh756iCTnvBnSmwA/16XytJfTqdoZ5XU8e5NHW8XAaY24gdbNQlcc7SAJoPRbsFrenENn902HgeNYGyUn6WuakZ8EElZZfz528M2RcNrjhbw7GVDmTukH1tSi9mWXkJBVQNBni78cDDfrl1pRTXMiA+01FA1c7LMemvNQWMqWm65etJqBOt+Px23Fmnk9tLjH7twkCXjsCVxwZ58cqv1LvkT8wfzxPyOZUdG+LpaugQ388WebGp0eouuXqPeyIs/p5BbUc/AQA+uGhOOl4sjV4+JoK5RzzM/nI5n7TpRxj9/PEagpzPvbs20OGMXBw1DQr2ZFGPtZBXnJp1xUFrsx4maCQDab47TB5FSvgO8A6Y6qF42R9EBWjsPncHIsfwqpsYG8lWrLbB1xwo5UVxLdGDHt/h83BytREjBtDXm3kaNkE4vSS2stun7VFLTyI3/3W1X0SIpq5yBf/qRSH83/nbZUB6YFQvA2L+vb9e22YOD0QrBL8fb1hN8ZsEQ8isbeH3j6dXZFYlhVs4J4NpxEXy++6SlqeDwcG8WjW61vdZDPDg7lp+Trd8bM4pr+WqPbTbh57tM/4YvrDlGg14iMCWltGb1oTzqWjWJbNAbeWFNCjMHBXW4eFrRd+lMksRxoD0VxvnAoXbOd5bmTfXgVuPBLc61dV1nr1H0YaSUfL33FL9fdoD3tmYypr91caubk5bh5oJXjdY2srP6cNtaefZwcdTy3MKhljhSuK8rj180iOvGRRLua1/WKKuk1mZse0apXeckgOT8KvRGSWZxLfd8vo8GczadvQdxM4GezswfFsKtU6PbFLTVagRPfneUtzdnMm9IMNeMieC5hUP5xxXDbOYGeTrz+zlxTIsN4O7pMSy/a6LNNp3BKNmVWcrRvO61nU8I9eZBsxNuSV5l28kMzUK2Eqi30624tXNqib2MRsW5R2dWUB8AL5sbF642j0khhAvwD2AysKQHbTuByanMAfYAmD9rKvBoO9ftMF/zYouxOSgV9nOW1zem89LaVMDUEO/S4SHcOiWa7/bnEuTlwp/mD8LbnNp98bAQ3m1V6Orq1PlqistGhjFzUBC5FfXEBnkigM1pxdx7wUD2Z5fzVZJ1XVR2eT3VDU14tkizjmlj1dZ6mV5R10RmcS0JoV48NCuOR74+aKn1cdAI9EaJl4sDS69NxM/diUkxAbz9u9F8vjsbJ62Gijode06W4+HsYCmM1RslPx8tZP0fpjPQTuwK4NlVyRa5oi1pJfi5O3F7i4y4ijod17y9k5RC08P+4mEhvLY40RLD6iy/nxPHuuRCm62+QA8n/D2cqajTUVDVfu1UR3By0DBhgP+ZJyr6PJ35y30dkxP6ACjH9Hf2KaatPUfgYynlJ535cCGEB9AcEdUAkUKIkUCZlDJbCPEK8CchxHEgFVNiRg3weYt7/ALsllI+YR76D7BFCPE48B1wOXAB7a/+FH2YZUnW20CrD+dz+Jl5PHVJgs3c38+J45djRWSaVzQRfq5c0cWMLk8XRwb1MzmcJR/stsR+fN0cGRLqxdG80w/ajceLuPOTvXx++2kdvCGh3sQHe1oe8G3h5+7EALMzu3J0OMPDvdmWUcLzPx23rByqGvQ8svwgWo0gIcSLpy5N4MObx1nuodMbeWT5AVa2il9ll9VaHFRqYTX/WZ9GcXUjC0aG8tku6+3QD7adsHJQn+48aWX76sP5/C6zv1UKeGd5ZsEQrn1nh1Usr7hGxz0zBjI9PpAFr22zKVRuxtvVkblDglne6uWgJaE+Ljx/5XCCvVy6bKOi79CZflASuE4I8Q1wPTAY027FAUzOaVkXPn8MsLHF8V/NPx9hWo29ALhico7NhbpzWxUHx2BKcW+2c7sQ4lrgb8CzmGq2rpFS2qY6Kc4JfFydyGkR/nR3drDR4QOTjNCXe7KZOSiIqz2dCPRwYd7Qft0WD917sswqMaG8rglPFwc8nR2obvEw3Z5RalGXaCbCz82ug9JqBA4aiA7w4K8LhlipXMQGe1LTqLfZ1mpuAphdVkd+VQPf3zuZhiYDy5NyOFFSx4BWag4+bo6MizY5k4YmA4vf3WVp0Lg7qwznVtt5rZU2iqttVzPFZ1CHOBPjov24cGg/fjxsveP+tx+PMSzcm+gAdw7n2m4nRge48/fLh5IQ4sXOzFJyzJmNbk5ayzbq2ChfPrttQrvZhIpzi07/5UoplwPLe+LDpZSbsKlysDovgWfMP23NibIz9jXwdXftU/QNHpkXzx0fJ9GoNyIEPDov3uYh1NBk4Io3tllUzJ0dNHx372SLc6puaGJjSjE+ro5MGRjQKQXzep1trCO7zDZfyMlBY+MMF4+P4JfjhTbyPAajJMrfnSGhXqxLLuRoXhWLxoRbtghbp7O35mBOBZV1TTzw5X42p5qcZ7Mga0phNf7uzjwwKxZ3Jy2rDuXx4+ECm+7B/f3dLLVJQsD9s6zTuxeMDOOTnSctqx0/dydmxHddjQNM8cQ7pg5gfXIhuhZp8Aaj5NGvD3HCTiwPYG5CMJtSiimubmT1/VNZm1yIg0Ywb0g/dmWWklFSw6XDQ5VzOs/okIMyb8WVAs+aC18Vit+M6XGB/PrHmSRllTE4xAtfdyfe//UEVfVNLEwMIzrAnS2pxVYtNhr1RpbtyeGZBUM4VV7HFW9st6gfTIsL5KObx3Y4ljJhgB+xQR6kFbXdDE8IeHBWrCUW1szMQcF8dut4lm5IY2emtdZdRnEtGS307JbvPcWq+6eg1QgK2kkeAFMPqfI6ncU5gUmQNb24huV3TbKM/W1VMu+10WrjgvggXrhqBIdPVTB+gL9Nu4zR/X157MJ4/rM+nfomAzGB7ujb6/Z4BjamFPHkt0csK8HWtOWcAN7eclpNwtlBQ4i3C4/OG8Qrv6RalCZe/DmFj24ex3gVfzpv6NDrhpSyBlPsp+RMcxWKs0GgpzMXDQsh1MeVK97YxnOrkvnPL2nM/89WUgur7dbuNI99vOOklTTPltRi/vvrCfSGtrPAWuKg1fD1XZMYGWHbGgNgWJg3Gx6eYVf7bekvadz+cRL7s8ttttRacyy/il1mIdmFreJmId4uxJljSf28XHhx0XBcnbQ23XrdWiSE6A1GPtl5sk2b75g2gJERPtwwMYq4YFOvqTrd6S3LhiYDb2/OtOj17ckq58Wfj7dpf1JWGVe/vYOZL23itQ1ptGzlU68z8NCXB+w6J42AJROj6NfBuFGj3khWaR0Pfrmf91o4roYmo0WkV3F+0Jktvs2YMujaUnBQKM46W1KLrVYd9U0GvtidzVMXJzC2vy97Tpp05AI8nLhhQn8Au0H351Yf44s9OXx150QrmZy28HZz5KVFI7jyze1WunQujqbuvtEBthl7OzJK+fe61BYjZ159OJvTzOcPC+GN60fx7f5c+nm5cNeMGMJ8XCmqbsDf3RmtRqA3GJkaG8Dm1BKLLfeY9e0AhBA4aTU06k874ghfVz64eSwDg6xXS1vTinl8xWFyK+qZFOPP0usSqahrsmmjcehUJdmldby3NZPDeZVE+btz65Ro+vu7cfMHeywxuZfWpuLn7szi8abi9+yyOhs9v2bcnRz4cEcWAA5agd4gCfJ0pqSmEaMEJ62w2g5sxl5rleoG+wkWinOTzmzYPgLMEEI8JYTonLCZQtFDONpZhTg5aKjR6a2aFHq7Olq2264ZE4Gjnfqo9KIaPrWzwjAYJe9uyeS6d3byl++PWGI3/f3dmBobgEaAk1bDRUP7semRCyyK4q05nFthdxxMD93WTIrxZ3T/0/eaPyyEd28cw3MLh1oSL4I8XSzK34vf3WVxTl4uDnx1x0TGtLBFqxHcN/P0qk4IeGh2nI1zatRbr262Z5Tyfz8dJ8rfjRBv61XNsDAv5i/dysc7T7I/u4Jv9+dyxRvbWHUo3yphBEwvE80MCHQnyI6or7uz1uo6vUHy6Lx4dv95Nr88PJ1Fo8Pb1FHUCJg4wPq7/535pURxftCZFdQa8/xngKeFEAVAXas5UkrZdsczhaKbTBkYwKhIH/aZtd383J343fj+fH8gz5JaDqb4zupD+Vw9NoIRET58e89kXlqbYiMT1DJx4GRpLSsP5vHW5gxqG03bWjsySzmSW8k390zmyz05rDpkSuPWGYz8dKSAB2fHEuzlbDee1V4tTmKkL7ta9V+6vBPp8P/4MZndWaevr2rQsza5kOGttiFvnBiFRiMoq2nkssQwG3WF7/fn8n9rjls5dzD14HLQanjnhjH89YejZJbUMjchmEBPZ5sVqc4g2ZxaZNMyI76fJydKavnbqmTSimoYG+VHbnkdJ0pqcTZnDMb382RrmnXkQGde8b26Id2qlcrwMG9CfVzYkFKMl4sDj104iAUjQvlydzYZxbXMTghmelz3kjgUfYvOOKgiTJp2aWeaqFD0NAdyKnhzUzp1OgO3TInmVgRVDU3MG9IPP3cn6nW2Wzst4ylDw7x59bpELnhpk0WtW6sRXDYyjPJaHbd8tMdG0LSZfdkVFFQ2kJxn21jvH6uPsTurDA9nBx6ZG8+1407rOQ4P9+GFK4fz+qZ0CqsaaDCnjffzciEx0sfGQTXobWNieRX1bEsvIb6fp0UtY1dmKe//mmXn97VWrcgqqWXR2zss6eIV9Xr+2UJR4oeDeTy4zH77+GYtu2Hh3nx99+mkiwe+2Gd3/uaUEv588WBeXptKdaOemYOCuG1qNAtf32bZks0uq+PmyVHkVzVY5JWKqhutUsXdnbRcMcrkqFcfsq7pOl5Qzcr7p2A0SqsszCWToympaSSnrI4mg9FuCYLi3KQzdVCq0FXRKxRXN7L43Z2Wh9iv6SV8cfsEq1bpC0aE8camDCrMMRN/dycuHh5qdR9PF0dW3D2J1zamc/hUJZF+bmg1gre2ZLTpnAA8nR3wcXNkamyAVbsLrTApMAA0NOl44tvDxAZ7sPdkOU0GyeWJYVw9NsLSPmJPVhlltTqmxQZSXqfj813ZFr0/P3dHLh4WYvW5W9OKufXDJHTmZI4HZsXyhzlxbEmzXgWCSXHimlZtKt7ekmlVy/TF7mxunRJtKdz9/oB9CajpcQE8Mi/O7rmaRlvpJjDFAt/YmE6kvxv3zxzIhUNDOFVeZxUvBPjlWJHFOTUTG+TBtLhAdHojV4+NsGzphfu6Wl3fLDPVukTgk50nefaHozQZJCHeLnxy6zibbUzFuYlq+a7o82xOLbZaHUhp6lLbcgutn7cLP9w3ha+SchBCcO3YCLuNDEO8XUnKKudESS3HC6rZcLyIUZH2s/PAFLR/6tIEXBy1zB8Wwp/nD+azXSfxcHHA393JEgNqtuu2j5IsiQXvbs3kpwenEuJterC2jFW5Ormy+oGpvLohjXXJhZTVNrH43Z28tjjR8nB9eV2qxTkBvLU5gzumDbArgvqPy4da+jH9fLSAfdnlpNhppV5Rd3orr5+37ffjqBG8tGikVTZgS6IC2m5dUlKjo6RGx++XHWTigACCPF3wc3eirMX2YUKIF8XVjVadfIeH+/DwXOvIQEOTgTkJ/Ti17QSNeiOezg48s2CIzWdWNzTx99XJFjXz/MoGXvo5lbduGN2mnYpzh047KHO79wVAsyZKJrBSSpnVY1YpFC2w1w3X3liEn5vNg641OzJLrept9EZpN7fOw1nLwsRwHp4Th2+LLL/bpw2wyAF9u/+UlYMSYJX1VlHXxDf7cttsPR7h58ahU5WWa44XVPPEN4dZftckqhqabBQVdHojOr2Ri4eFsD2jlK+SctAKwc2To7h6rGlr8aWfU9pMtR4Y5EFiiz5J98wYyOaUYnLKT6syPH/l8HY7FN83YyCf7si2cpwagZV0UX2TgX3Z5VwwKIh/LRrBo18foqSmkeHh3jwwayAFVQ0czKlAYlJQf2i2tYiswSi55p2dHMwxrWo9nB1YducEEkK9bewpq9VZtk6baavOSnHu0SkHJYR4GpMeXuuik38JIZ6TUj7bY5YpFGaa5XHWmLvGjunvy7XjbNtC5FXUk1JQzahIX7zdHG3OA3Zlj4aH+3DJcFMzwiBPZx6cFUtCqNcZC3kXjgwjvaiGz3dl4+HiwLTYQBt9O4d2FCsMRsnxVqrbzfp+qw/l2zQcTMJQ6bsAACAASURBVAj1sqTE//OKYTwxfxBaISxtQKSUfLDNuijX08WBuQn9CPZy5pYp0WjN9hzNq2RnZhmPXzSIfdkVRPi5cf34yDPGb/w8nPnolnHc9/k+Smt19Pd344L4ID7cnmWZo9UIBoeYVnkXDApi5xMzKa9rItDTmfs+38eBnNPbqVKCv4e1Q/w1vcTinMBUJvDNvlwSQr3JLq3jl+OFRPqZPre/vzvDwrytnHnLrV/FuU2HHZQQ4ibgaUx6eC8CR82nhmBKQX9aCJElpfy4x61U/E9z6FQFG46d7n9UUtNoedA28+XubP783REMRombk5b3bhzDpIG2TetG9/dl9uBg1h8z9SYK9HRmyaQoIvzcuGlSVKfsEkLw6LxBPDpvEGBKyth9osyiOBHk6cyCkaFtXv/LsdZ9NbF0szXYqfFZMML6wevlYu2EhRCmNPwW26Eezg786+oRVvNW7D1lpZjezPrkQj69zbopoT0mxviz60+zKKxuJNTbhUa9keKaRn46nI+3qyNPzB9Mvxbp6Q5ajWVVttNciNzM4dxKahr1Vi8ORju/u0FKdp8o43fv77Jk+V2eGMbL14zk/SVjeHldKmlF1Vw8LJQlnfx3VPRdOrOCuh9T24tpUsqWFXcpQogfgF+BBwDloBQ9yrI9OVZbSlmldfyaVsKswaa2X00GI//86bjloV6nM/D8zym85OnMZ7uycdAIfjehP1HmYtp3bxzNjsxSymubmBEf2GYjws7i5uTA9/dN5uPtWby/LYui6kYuffVXXlo0ghnxQZZ5+ZX1nCip5bUN1ltxQsCfzB1qLxkewhsb0y39kgI9nbly1JmbCd4/M5bnViVbHbfm9Y3pNs4JTCuX/dnlVtuAbeGg1Vhqs1wctbx89UhunRzNwCB3vFxPb4n+eDifP644RE2DnqgAd+IC3S1ZlGCqLWu9qp0SG8Cgfp6W1aW7k5brx0fyzx+PW5wTmPQK/zAnjs2pxaw8kEetzoAGDQtHhlltyyrOXTrzlzkY+HMr5wSAlLJJCPEFoHT6FD2OPQfSckynN1LdYP2fZUFFPQtf32Zpe7587ynW/2E6gZ6mmqWz1RLczcmBHZllluy5khodf1xxiO2Pz0KrEXyw7QR/W30Mg1HarAIFJgVyAB83J1Y9MJVv9+diNEoWJoaRWljNrR/tobRGx2UjQ0kI8UJnMDInIdgiMnvrlGhG9/dlf3Y5Y6P8GBpmG7dpMrYt8dR6W7EjHMip4LaPkiipacTdScvS6xKZNTgYnd7I/V/st7w4nCiptUrSAPv/to5aDV/fPYnv9udSWd/EghGhRPi50WRnZVVU3cAzK49aVCV2Z5XxxqZ0/nyxbSsWxblHZxyUHmg7hQfczXMUih7lpklRfLc/10rsdXy0Hzq9kdWH88gtr2fywACrgs8BgR7saLGdVFnfxDf7TnHn9Bib+3eV4wVVlNXoGBvtZxW7SW8lKltY1UhVfROODhqeX3N6pdd6G+/KUeH4uJ1+8/dzdyLU24VdJ8pYl1zAsz8kW2ql3th0up17qLcL3983xbKNNjLCp03dQIBbJ0fzzA/JNuMjInyI8HWlpKaRAI+2EyVa8+wPRy0Fz7U6A/d8to+9T87mSF6lze/YWjopOa+KnZmlbEopxsvVgevGRuLr7oSHs4ONKsTNk6P4Na3YkpAxa1AQBqOt5FGzQrvi3KczDmoPcKcQ4l0ppVUhhhAiALgd2N2TxikU/D975x0mRZm97fvtNDnnHBgmMGSGnIOgGBHMitlV17Tqmtaw5qxrVsSAYgYjCiI5DmHIMITJOTA5p67vj5ru6eqqHphd3IXf1/d1cV10hZ7qhqlT7znPeQ6yc/ea+6ew5nAFPm5GJiYEIoTgls93WJ0hjHpZWl7f2sH4hEA6uyRFgAJYfqD0lAWoB5bstU7VjfZ357tbx1qH5E1NDmJxeo9YIjVcdmAvrm1RKc5iA9w5d3AYiSFenGfXt/Xm6mN2Xn7alNS18u3OQodqQYCqxjZe/v0IB0vqGZcQwMfXjmRnfjVBXiZqmzvw93AhPaeKsS+sQSfgytHRPHxOMluzqwnzdSVVQ0FnwT4gt3WaWbgxV7OO5mrQKRqSPV0NXPvxdqtf4JKdRay4Z5Lm2IypScH8fMcEfj9YRpS/OxcODUeSZN9F27Th9JRg1blOzkz6EqCeAf4AMoUQHwKWR7BU4EbAB7j21F6eEycyni4GLhjScwM/Wt6gsC3q6JKobmpnwfw0AOpb2nni54OK97DUNMxmiaqmdupbO9h07Dj9QzytKb9tOVVUNLQxOSlIJUKwcLCkTjHyvaC6mQ835PBo94TfS0ZE8dX2QusNurKhjaa2TiJ83RgV66+wKLpydDS3TNIOmp9tzTuZrwaAb3cWsuZwBQPDvfnbWYmKlRjAnV/tZku2HLD3F9fR3NbF0xcNtO5fmlHE8m6VpFmCxekF/LK31Grwes2YGMXxFrrMkqIuZOFQab1ViGKLQa/DS6+joa0TN6OepBAvMroNfgFyjjex8Viltb4Ick9Ua0cXvu4mBkb4qNKWi24YxSu/H6G0rpULhoZbTYKdnPn0xUlinRDiEuBt4EFka2ZLEr0YuFmSpPWn/hKdOFGjpd7W2cjCvd1MqhlOiSFeZORXc9dX6rEPt0yKp7SulV/2yu4K/h4mltw6VjWlFmB/kXri68JNufy2v5QnL0xle261YvVQ0dDG6sMVXDAknAXzR/De+myyKxqZlhzCFRpyeQv2qwh3kx6DDupb1W4O+VXN5Fc1k5FfQ15VM4tu6BkH39jWaQ1OFn7eW8w9M/pbJd45x9VpMVv38c/T87lxQhyxgR5IkkRTWxerD5dTXNOiadGUEubFykPqAGXx8Xvh4kHkHm9SzHmy4GYz2Xdxej4vLj9stU9664phqrpVargPn1w/yv5tnPwfoE/yJUmSfhRCLANGAnHdm3OAHZIkaXugOHFyitmZV82CDTmK1I7JoOPGiXGK416cN5g7vthFSV0rkX5uPHvRIO7+erdmI+fHm3Kwvc9WN7Xz4cZchXedBUe9QiV1rdz8WQaRNiPfLVj6oXzdTTx8TsoJP+NPe4qpalQKCh6YlURCsCdXf9R7Jn390Uoe+/EA989MwsfdiLtRT6i3K2X1PUMQ61o6mfjSWj6/cRQjYvyZlhzCu+uyreo+gXo4SE1zO+nbq3jp9yPUNLVb92sd+8ehclUDry0F1c2agxSFkHuj3luXzcqDZezpbugFWHO4gg835nDPDG0bJguHy+ox6XWaDxdOziz+nZHvncDW7j9OnPxXqGvuYHteNV4uBq79pKdmoRNy8fyaMbFWGbmF4dF+bHxwGmX1rYR5u9LeZVY4ntuiNbvQXhloYVxCAAad0JxHBFCkEQAf/+kAA8N9iA7oTWckj75YtreER344oJjjNCkxkOvGx1Fe34pewInEdp+n53OwRHZh1+kEz108kLu/3qOYl9Tc3sUbq7P4+No0duXXMDDch6rGNiL93BjTL5A3V/f4QieFeMk9Tj/sV0nULakU282HSpUNyPbEB3pq1qgkCR75cT/5VfaDEmRWHChjaJQvkxODVI3UrR1d3LhoB5uz5NXieYPDePPyYSrvPidnDidt+yuEmCKEeKaX/U8LISafmsty4qSHnXnVjH9xDTd/tpPLP0xX3LjNkjzwTieE5mBCvU4Q4euGTidwNeoZHac9u+ni4REkh/YYjOoEXGHjTG5LmI+bqvn1RBxvbOfjzeoVgy3m7hlP9323T/EZAetqqqimGU+b2pgABoR5Eeip7vvZVVBLRr5c75qWHMJPfx2vOqa+pYNnf8vk2d8y2V9cR0ldK6E+btx7ViKfXj+Si4dH8Nep/fjy5tHsL67T7J8CHDp3WAj1ccXHzYivu5GHzklmXlokQyK1hRcFDoITyHXE6z7ZwSM/HFDt+35XsTU4ASzbV8q6oxWq45ycOfRlBfUw0NtjURIwAnnyrhMnp4xXVx7VDD4Wlu4q5s01WZj0gtQIH2alhnLt2FjNMfBvXD6Mp5YdZF9RHQlBnsQFeTA40ocLhkTQ0NrB4nR5PPwFQ8IVw//smZIU3OsqSosDRbV8s6OA8vo2Zg8Ks7qKW9iSXaUQDNgyo1s08MCSfYrakIS8WvF21f5Vfu7XTJbeLgem+CDZNdx2kOCVo6J5YYVyjPuv+0t59VK5udi2wTgt1l/zM7sZdVw/LpbXVzmexDMi2o93rhqu2Pbp9aN49Y8jfJFeoFh9ncw3+s2OAu6ekcCazEp+P1hGY1snnRrL4OIapy/fmUxfAtQQ4JVe9qcDf//PLseJEzXVdsP0bAnzcbXWlNq7JHYX1LK7oJadedUsvHak6vhQH1fevUrb6drX3cQdGs4LWvi4GblydDSfbVVP5HXE0YpGHly6H4C312bxzS1jFK4N7Z3qMq6/h5FrxsRy57QEOrvMqvEVFuodjDrPqmwiq6KBp5dlkl3ZyOTEIB6clURBTTMzUkKYnhLCx5tzFd+xu1FPUU0zcYHKABrhK68c7/l6jyKI+LmbuHtGIkOj/XhheSaZdum9AA8T981U1438PEy4GvQnFZDsMUvw5uosvrTzPrTFzahXqAGdnHn0JUD5Ar11wDUDJ/ZIceKkj8wbEcmzv2Wqtn9+4yjeWH2M0rpW1b5VmRUn1XAqSRI/7y1hd0EtI2P9T2g0erS8AW9XI6E+rjx5QSqT+gdxpLyBpBAvvt5RyJHyeoZH+zFzQAh//XK34lzbINLeaeazrfmKALXWbtqvUS/48uYxivEa4/oFqBR5vTElMZCbFu0krztt9sW2Am6ZFM/zFw+2HvP3WUncujjD6iLR0NbJ1FfWc/WYaJ65SCkSKaxWp99cu1eqkxODGBPvz/vrclh7pKI7iEcxPTkEgwNhie3Yjb5wVkoIP+0u1tzn725ibL8AbpoYR7iGYMXJmUNfAlQJMKyX/cORJ+46cXJKuXZcLN/sKCDLZvUwNSmI5FBvsiu0n5lcjTqFXNmWivpWXl91lGPljegEbM+T02qfbsnjaHl//naW+mm/rqWD6z/Zzq6CWnQCbhgfx82T4jne2MbQKF/G9QtgxoCep3WzWeKSEZX8sKeYzi6JkbH+7MhTTtC1lcU3tXXy9Q7laiDKz101++nNK4Yx970tChGBvUAhJcyL1g4zY+L9uXpMDOe+uUnxHhuOVjI1KZi8qiYmJwbxzY5CTYujxekF3DG1v9X4dWlGEa+sVDcO3zlNbhA+Wt7Asn2lBHu58NXNYzRTrPZcMSpa5QBvQa8TeLsaVO4T0X5urMosd7jyqm5u59bJ/RjkoMbl5MyhLwHqN+AWIcRXkiSts90hhJgCXAd8dMquzImTbhZtyVMEJ52Af16QyuL0fNXNy8I9MxIdmsDe/NlO9mr0MoGsfvvbWYmsOlTOdxmFeLsauW9mEt/tLGRX99RdsyT3PX22NY/27ht7tL87X9w0mqjuOVW3fJ5hbVT1cjXw3JyBPLXskMKO6UBJndWcVWhotbXcFAI9XVhz3xR+2F3M7oIaUsO9iQ3w4OlfMympbeGCIeE8dt4A67lyg6vROmkYZKeHKz5MB8DFoFMJMmypaGi1BqgVB0tV+x87L4U5wyLJyK/msg/SrfWpxen5LL974glHlgyM8GFacjBrDqvFDF1miSg/N8W/sV5AwUnUlUrrWpwB6v8AfXWSmAus6u6F2tO9fShwHlAJPH1qL8+JExTzg0AOEFkVjdQ0q2tTN0+M47KR0SoBgiRJ7Miroby+1WFwAlnVds3CbWzM6gkkP+0tYWJCgOrYdptVR0F1M9d8tI2190/hYInSRaGhtZOPN+fy8XUjufPL3aw4KDs2HClr4ObPMtjy0DRcDHpcTXo6bNKAtqpCW/Q6wbwRkcwbEWndtvzuiZrHuhr1vHrJEB76fj+VDW0MjPDmUEnPpN3egpOLQcf93+4lKsAdo07HH4eUQUSIHvHGB+tzFOKJw2UNLNtXwvlDIhy+v4U3Lh/KiysOs3x/GVV29cYDJcqpwFryepNep3C7D/Q0MaH/n2MG7OS/S1+cJMqEEOOAD5An6l5gs3slcLskSSWn+PoQQnghB745QDCwG7hbkqQdDo6PBbT0vOdIkrTiVF+fkz+fUXH+/Lq/5+ndZNAxNMqXAE8XvtxWYL0xhni7aK6c2jvNXPPRNrblyik2rcZSC51mSRGcLOevPqysD+l1QtXHk1fVTO7xJs26Skt7F0a9jspuU1ULxxvbOFregBAoepQASmrVtbWTJe94ExuOVdIvyJPpKSFsfSiI+tZOmtrkBt0T4etmoLalk6MVjRzVSKPqdZAc6s2lH2xlcIQvR8vVAt+t2dWcPySChRtzWJyej4eLgXtmJHLWAKVwwcvVyDMXDeL+mUlc/N4WcrpXy9H+7hTY1byMeqFKR146MpIpicF8u7MQP3cTf5kc73BkvZMzi746SeQCM7vNYS1yp2OSJB3v5bT/lIXAYGSfvyLgauRV3ABJkrSrpDJnA3ttXlc7OtDJ6c3VY2IorG5m6a4iAjxdeOjsZAI8XQjwdOHT60exaEsukX5u3DSpn2Zab+WhMmtwAmVwivB147HzUrht8a6TVpON7xfAjJQQnlymdAT3MOkJ8XYl2s+d2AB3qzABILXbP25QhI9CSu7lYiC4e26VfeCMC/Rgd0ENVY3tjE8I7LWm09jWyZ6CWhJDPMksa+CmRTusN/Jrx8bw5IUD8fcw4e9hYnpyMKs1Umq26HS9t0gKhHX67x/12qXn1AhvPtyQzbO/9cjYb1ucwdr7p1hToeX1rRwrb2RotC++7iZW3D2JzVnHcTXqqW5qUwlNUsK8OVxaT3uXhKtRx9WjY3jg7GRMBp2iBujk/wb/1mNGd0D6M4MSAEIIN+S04lybutc/hRDnA7chj593RJUkSWV/8iU6+S+g1wkePW+A1YzVwurMcu76ajdN7XKd5ZxB4dYherY4kqk/fHYSN06Mx6DX0T/E86THNOwqqOX+WUm8c9Vw/vH9fmpbOjDpBTdNjMfDxcAtn+1UBCeAl1cc4ZyBofxtRiL5VU2sO1pJiJcrz1w0kLu+3k16jvL5Sa8TlNa1MOfdLQB4uxr4+c7xxAZ4cqikni+25WPU65g/NoaqpnZu+HQHDa2dGHRCnp1ks8pYvK2Au6b3+O69c9Vw5r63xRpgtPBzN/Yq7z9R/1diiCcrDpQpam6W87blVhPl785X2wt47McDdHZPQY4P9KC4toXJiUE8eeFAPF0MXDS0nJ/2llgbhPd1p2fvmpbA3TMSFTO12jvNrM4sp7Gtk5mpofi49d487OT0R0iOWsNPdKIQo5CFERHI49/fkCTplKr4utN79cDZkiT9brN9E9ApSdIUjXNikVN8hYArcAx4XZKkJSf6eWlpadLOnTtPybU7+XORJInxL6yxTpwFGBjhzbI71bWY8vpWJrywmg6Ncsus1BBeuWQIR8sbuePLXZTWtRLh68bfZyXx2dY8imtbKK9vU503rl8AX948hj0FNVy5cBvN3YMRLxwSzk97tTPdL84dxGUjZXeKlvYuXAw6CqqbmfLKupP6zP2DPfngmhHMfnOjdWyHj5uR2AB3RV1NB9h+VCFg28PT2ZpTxRfbCvByMXD2wFAe++mAavyHFjoB/YI8OFbRI1RxM+odSsSfvSiVZ3497HD/b3dNpF+wB2nPrFKlNS1cmhbJS/Nkt468403MfH2Dos4UH+TBmvumWF93dpmZ9/5Wa70y2MuFn++YoBg97+T0QQiRIUlS2omO63UdL4S4TwhRIYQIttt+ObAZuBU4H3gI2N6d+jtlSJLUgOz596gQIkIIoRdCXA2MBRw1rDQC9wOXArOB1cA33eepEELcIoTYKYTYWVlZqXWIk9OQTrOkMD8FKHKg7grxduXx81M19/1+sJx/rTrGiBg/Nj4wlU0PTmXjA1O5aFgE398+nm2PzOChc5JV55V3/+x31mVbgxPAz/scl2H7h/SIHtxMenQ6gbvLiaXYFrIqGlm6q0gRVOpaOlR1GvuQMys1hMNlDdz99R6251az+nAFT/x8kNkDQ0/q55olePz8VM5ODcXDpGdkrB9vXTGUxBC1GeuQSB/+OFTRa3/TM78eIu94k8PgBChmeYX6uGIvBtTZbVh/tFIhpqloaOPL7Y6beJ2cGZzIi286sFeSJGvCWghhAF4HuoDbkfufngYi+XOcJK5B/p0rAtqAu4CvUP8eAnL6UZKkVyVJSpckaackSY8jCzsecHD8AkmS0iRJSgsKCvoTLt/Jn4FRr2PmAOUN9txB6meW3QU1/Ly3hAn9A3HQK8rewlpaO7r4ansBCzfmkm436PDWyf2YaKcKmzNMVqfVtyhl7o4SEmkxfgyPVvexuxr1qtHvjnAx6hAa7z8mXq0wtOXcQeGsPKTMdje3dzk0ztXi0y15lNa3MmtgKG9cPowZA0JZ+bfJ7HnsLJ68YABTk4KYOSCEA8X1rDva+4PeluwqXl15lKlJjn/fBkf0TAR2Neq5cUKPU70QcJvd4MmWdnVAbPs3m4CdnD6cqAY1AFhst20SEAK8I0nS+93b9gghhgLnIM+KOmVIkpQNTBZCeADekiSVCiG+QR7zcbJsA64/ldfl5H/PK5cOIXq1O3sLaxkdH8Ck/oH88+eD+LgZuXpMDG+uPsbn6bIVkay6036f0fH+3PjpDjZ3OzR8uiWPR89N4aaJ8dZj3rlqOAvW53C4rIEpSUFcNVpO1V05OlohwOgX5KGyI/J21VsHKdqSU9nIvPe3arp6axHu48bbNqPeAUbF+vP6pUMprUtXyfEtBHiaiA3wUG3vH+zFnkLHkntbVmfKz6h7C2vJLG2wytp9PUxcOy6Oa8fFMefdzXRpROgwb1dK7Va7ewprWX3fZBZsyCGztIHYAHdWZZaTV9XMqDh/HuuuN9Y2t/PYTwfZnHWcgeHejE8I5LzB4aoep+xKZf1QJ+CSNMeztpycGZwoQAUBeXbbxiGLjX60274WmHZqLkuNJElNQJMQwg+YhYMVkQOGAuouQydnFM3tnbR1mPHzMJFZWo9ZksivauJAcR31rR28u/aYdabTdxmFCpm2VhAw6ARzh0cyd3gk76xV3vhfX3VUEaC8XY3cPysJkF0fftwjC0hnDghl0Q2jWHGgjNgAd84ZGMrUV9YrbtStnRILNuTw4NlJisbVDzfm9ipEsHDh0HBGxPjy+E9K1aCfu5Frxsawq7DGYXACSA3zJtzHld8PlrEjrwa9TnDt2FimJAXxXUaR4lg/NwMdZno1580sraewutmqxMupbORYRaNmT9UH1wznrJRQZr+50TrRGGBknD9e3U3QFh49bwCtHV242jiAPPHzQesQyeqmdhDw8Gz1PK1f9il/vc0S1LWc+Lt1cnpzogDVAtg/eo1CDlDb7LbXnsT79RkhxCzkVORhIAF4ufvvn3Tvfx4YJUnS9O7X1wIdyP1SZuQa2V85xSs7J/9d3l2XxZurj9HWYcbbzahw9AZUBqUn00MU7e/Oi/MGs+6IWnLd1NaF2SypZgnVt3Zw4dubye1Oj8UFZvHTHeOZnCinq9JzqlSriPZOM++vz2ZwpA+zbdKQ9Q7mTdkS6uPKG5cP463VaqfwmuYO7vxqNzG9zJhyN+p4/KeD1trYzAEhPHlhKmE+btS3dKik7eF+7vx610Se/y2ThZtyNQO7l4vB6nH43rpsXvr9MJIEJr3yu/J1NzIhIQidTvD2lcN4+Pv9HCypZ3xCIE9eoF0TdLWzp7L3HTxQXE99awferkqFXpCnC1l2/VqP/XSQ3+7SbmB2cmZwohpULjarIiGEKzABOCBJkr0mNwTZTeJU44M8Zv4w8BmwCZglSZLltzsM6Gd3zqPATmAHcDlwgyRJr/8J1+bkv8DR8gZeWnGE1g4zEqiCkyM8HVgdWegf4klpXQufbslT7fNyNfDhxhy67PKCP+8psQYngNzjTfy8p0cYoVULsbA4PZ8mm5XJ5SOjNEfX21JW10pFQytn9yJoyK9qdljHmpIcbJVpSxKsPFTO3u7VVkZBjar362BJPd/uKOCv0xK4dXK8+g2BpFAvPtiQzSebc3lpxWFr3a3droG2trnDKlRICPbiu1vHceips/lwftoJTXwtDI5QpvLiAj3w0vh3vXpMjGrboZJ6mtsdrwSdnP6caMWzGHhNCPECsAZZsOADfKtx7HhkSfcpRZKkbx38PMv+6+xeLwIWnerrcPK/40hZ79NZLdi6O7gadb2mqUBW8K3OrNDsnWpo7eT55Yd5b102y++ZSJiPfEy7RhrLdtv4hEDiAj0UQczCluwqZry2non9A5meEsKs1FC+uGk0D3+/X9U3ZcHdpMfTxUCwlysvzxvMCysOU9fcoepDcjfqadD4vFqiDUuNrMFBoH9g6X7eW59N7nHta9qZX8NOB3Or7Hl15RGmJAZZFYzf7ypk5aEK4gI9uHliPP4e6kGLFiob2ojydyPQ08TxxnbiAz147bKhKn+/mqZ2HvtJPcAwMcTT6ShxhnOiFdQHyKuQB4DlwFXAPuAN24O6ZegzkSXdTpycUsbEB+Bq1P6vauheOSSHevHlTaOZ1F9OtWn191gyULaLjU6zRGmdY/PR2pYOrl64jVHPruLyBVtJClVOrw30NHH+kHDra5NBx9LbxhHspb1CKK1r5dudRfzl8wy+2JZPZmmDKjhZLk+vEzx4drL1Juti1BPgYSLE21WVTtMKTgDTU4IVqyu9TjA9Re4a6c1Nwj44WZzF+0prh5n31mUjSRJXL9zGvd/uY8WBMt5bl83VC9Nx1IfZ3mnmkve38OmWfI43tqPXCV6YO5ihUb6qY//ILFfV8gI8TPzrst6GLzg5E+j1f5wkSa1CiAnAxcjWRtnA95Ik2Vcfw4EngK//lKt08v81QV4ufHztSP61H9FqsgAAIABJREFU6hi1Le0khXpxuLQBPw8Tj583gAFh3tZa0S2fZzh+IyGYmhjA+qN2XntaDqQ2WFYcFQ1tFFbv4+c7JvD9LllcMG9EFEF2wcjfw8Qjs1P427d7HMrOAb7aXkBCkLqXSEJ2jhACXvn9MEfLG7hyVDT3fL0b24XThUPDOVLWoBAfWNAJuGZMDPNGROHnbuLDjbLo9ZZJ8dYRHlqrQUckBHmQW3XysnRbaprb+eNQOZvsPA4PlTawK78Wg16QFOqlqD+l51QpAneXWeLTLbmMilNOOe4ySxRorPSmJwczINxbtd3JmcUJH4kkSeqklxRb9zF76HE3d+LklDMuIZBxCYFkVzZy8btbrHWoV1ce4ZPrR1mPC/NxdVij6jJLrD3ynzl0Fde20NzedcLJuxcNi8DbzcBdX+1xmGr0cTMyIsaPH/eom3tthxt+sa2A0rpW7PUKod6utHV0qQKUi0HHxgemEuwtuyhM756ca0tNUztbHQw+1AsQQjna/cgJbKAEMCTKR1O2ftnIKE0zWYBrPpZdOHzdjSy4Js0agLw1bIpWHCjjQHEdA23qUjcu2sG6I+rS9xEHP8/JmcWJUnxOnJxWfLwpVxGA1h5ROgg8dt6AE4oj/hN83Y1E+p3clNbtuTUOg5ObUc9d0/pT0aC2UdKiqlF9XFVTG9ePj1Nt7x/iaQ1Ojlh5qIxau0DeL8iD2YNCGRUfcEKvPYAom+9BAg6VNCCQV2+JwR6MjffnqtHRDIr0ZVJiEPYyDneT3urCUdvcwZO/HNR8bwtmCT7ZnGd9vaugRjM4AarP5uTMxBmgnJxRaPUN2SrnxicEsvXhaXx9yxhSQtXpM3ts6zOuRh0JweqGVguh3q68fulQlRTa8bWqg8oT5w/gzSuGsfHBqYyOD3C4irFnUmIQA+1SVksyign3deOVeYOt04ODvFy4bGQUH2/OUcx9ssfTRb1CuWJUNM/NGcSB4pNr3i20s5Zq75JVlmYJjlY0sTWnmi+2FTDj1fUIBG9eMUwesBjoziPnJNNq5/RgO07edryKLV3mnrSk/fm2jD2Bu4aTMwOnxMXJGcGx8ga+3lHIWrvCfr8gT1VdwsvVyJj4ACYlBpFZ1ntqqssscdvkfkxOCmJEjB9GvY57vt6tSLt5uRpYe99k/D1cVH1RvXHx8EiWZBRZU3PhPq5cMSpaEeAGRvgoFHFuRj1uJh3VTR1WMce5g8O5ZVK8tY5ky+GyBualRRHi48qiLXnszKvmsR97ViJPXpDKteNiVeedNSCEYdG+7O6eEhwf6MElI6J4fdXRXj3y/h1aOrr4eHMur182VCEo2V1Yy/IDPRZMRr2OB5fs476ZiXRq1AWFgPk2n2V0XACRvm4U1SoDpYdJz00T1CtLJ2cezgDl5LTnQHEdc9/boulUMGNAsMMeoG93Fmlut8fLzaDws7M1dQX5xujlZlQEpy6zxDc7CtldUMPIOH8uGRGpkj+PiQ9g8U2jWZJRhJ+7iRsnxKlWX3+bkUheVRPrjlQS4u3CUxcOZGpSMAXVTUT7e6DXCfQ6QUVDq0qZKICRsX6k51Rx7cfbVTUqgJdXHNYMUCaDjq9vHsOirXl4mAzMS4vExaDvddWlRZCniaqmds2fbYt9yrCxrZPkUC9yjjdRUd9KTXMHVU3tfLOzkG92FmIy6NAJrO9r1As+u2G0ws9QrxP4ehhVAaqpvYv31ufw6qVD+vRZnJx+OAOUk9Oer3cUOBxNHuihVNC1d5pZd6SC4toWaprVdQhXgw4hoKX7Zh/gYWLu8EjFMbbeegD1LZ3sL6ojLbZnpfbULwdZtFX2+fsuo4jc4008eLba9Xxcv0DG9XNs8u/jbuTT60fR3N6Jq0FvDYIJwcogGezlSlKIp0KsMDU5GF93E0ttVmn2NHd0IUmSKniW1LZwxYfp5Fc1I4ScrnvonGSGR/uxPe/kZ3smh3mx8ZgyTWnS64gL9LAKFUx6HdeN62mkbWzrZNor63qtv1kUhgKYOzyCO6f3J0bDT7CjU/uDb83+08fVOfkv4AxQTk57XA3aNZ/YAHcuSesJLi3tXcx9bwuHSh2vAlptAp27Sc/7V48gxE5QkBDkyQYbR26jXihujpIk8fWOQsU5CzfmsOpQOeP6BfDA2cmak31742QaSgdF+loDlEkv+OvUBAD8eml2jQv0UAUngPfXZ5PfLeOWJPn1laOiGRLlozq2N+yDE8DE/oG8c9VwftpTTFldG7MHhSpWpQ8u3XfS4hAJWLKrmLYuiZfmDrZOFe7oMmPQCeaPi+EfP6ibdO3NZJ2cmZz0b1G3SWugJEnHbLbFAPcA/sDnkiStOvWX6OT/d+aPjeXTLbnYLqLG9wvgo+tGKlJmv+0v7TU42dPc3sXSXUWMtKth3TEtgX1FtezMr8HdpGd6SjCz39xIe6eZ68fHcs+MRLxcjbTZKOs6uiSOVcimqdVN7aSEeyNJMHd45CkZmlda12LtvQK5d+uTzbmMiPHj+vGx/LqvlOJadcPx8xcPcvB+aq/CpbuKuCQtUpFas6e3fQADwrx44vxUXI1663BGs1li0ZY81h2pIDHUix256hWai0HQ5mA1BPDL3hJiA9y5fUoCf1+yl+UHygjydOGJ8wew6IZRfLejkPTcKo43tjMq1p9/OvD6c3Jm0ZfHvDeBZGAkQPf4i43Ic6AArhRCTJMkaeOpvUQn/7/j7qLHPsN3sLReVc9pcuC7Zm+IaktNs1oV6O9hYslt4yipbaGopplLP0i37vvXqmMcLWtgZmoIX20r0HzfX/aVWt21312bxdq/T+FIWQP7iuoYEx/AiBj1XKgTUd/SqQoMR8sbaO80E+bjxur7JrMms4K/L91LU1uPus2RzH32oFD+OKQcgL38QCl/OyuRpy8ayIvLD9PY1omvu4nmtg7aOiWrQs8ReiH4cH4aEX5K89q312bx2h9HAbktwM4EAwF8cdMYXAx6nl+eqTKItbBoSx6NbZ0s6/5uy+pbueebPaQ/PJ22ji6CvF1ICfVm3ojIPolZnJy+9CVAjQW+sHl9GXJwugC5Sfd3ZEskZ4ByckpZZXcjBejsNLPiQClnD+xxB589KIx/rTqmkqLPGBDCuiMVdNgpw4SQm0gdEe7rxpIMtdDit27l2eyBIYxLCOS1P45S3aTdd9PU3sWtn2ewq6CnV+u5OYO4snue1MmSFOrF0ChfRc/X0fJGrvtkO1/ePAZXo56m9k5FcAL4dV8ZU5OCSc+ppr61g8mJQbga9ZouEpbv56rRMVyaFkV7pxkPFwNfbsvnEbs0WoSvK96uRjJtmoS7JIm5721l5b2TFG7jP3WPJuk5rufvHiY9t03px4gYP4QQ1knFWtS3dlpHb1ho6zRz3lsbKbZxrz9QUsdTFw50+D5Ozhz6EqBCAdsZyucAGZIkLQMQQnwC/O0UXpsTJwCaQ/Aa27u4dfEu7jsrkTun96e908z+4jqemzOQ7bnVbM6uosssMS05mHvPSux28i5DJ+Qbe1ZFA51mWL6/DD93E2E+bqw9UkG0vzvj+gUghGDVoXLe1BhzYeG3A+X8dqBctSKwZ2+Rsq/o/fXZfQ5QAItuGMXlC7YqRotsya7i+d8ySQrx4uHv96vOifRz5fpPe9wWInzduGdGfx5cqj72+vGx1r8b9TqM3SOItTz7Gtu6+OXOidz82U4ybGTyZfWt/H6gjEu6A1yn2Uyoj6tqiKOFpvYuXll5lN0FtXx03Ugq6nuvTbXZKRn1OqEITgBfby/kH+em4OKgdunkzKEvAaoDsG3vnow8/sJCNeDsjnNyyjl3UBhvr8nSrJss2prP5aOimff+FmvRf0ZKCCvunqgSB1w4VB7TXt3UzrRX11HbrfL7YXcxep2wKgUvTYvkpXlDeH555kk5KpzAyk/loNDUpr3aau3oIj2nikBPF4WdjwUfNyNBni5korTx+WCD9nDpgeHeDAz35Y3VWdZtxbUt/GvVUdWxd09PYP7YWM330RohUtfSwVPLDiqCkwU3k55PNufy2sqjNHd0MTEhEB9XPXWtjhtrVx+uID2nijBfVxpslIpuRj0tNg25DW2dBHm60N7VRbivOwXVTapVo0kv0GsIQ5ycefTFSeIYMEfInIccjGzdy6OQg5QTJ6cUX3cTy+6cwCPnJKtczd1MOj5Pz7cGJ4BVmeWk5zj+r7gqs9wanEDu0bGVsX+XUcRv+0vIsXvqP9myhhBg0Mnpq0fPTbG6PFiwHz3f1NbJ88szGfbUSq77ZAfnvbWJv3+39+R+WC98fP1IzdWn/YoD4JxBYRwtb+Dxnw7w+E8HOGbjZTfaTkRiYU+BeopvXKA7/YI8ePKXQzS0ddJlllh3tJJ+drJ5k0F961mVWc5RO8+/py9KZWSssmZX2djGZSOjWX73RNJi1Nd214z+GPROk5z/C/TlX/FdYCryUMKlyKPgbVV7EwG13tOJk1NAgKcLt0zux0M2vUZCwD3TE6nVEDpoiR8s2I7L0EKSYNGWfJUA4pxBYYQ7UORZbrj+HiY+mp/GsWdnc/Cps7lpYrx6wq5dhLr9i118sD7H2psFcpC0b5rdcLRS5QjuiGnJQQR7uTI5MUhz3pUtc4ZF4OliYM47m/lsaz6fbc1nzrtbKK5t4eXfD/P22izVOSaDjgHh6lXe+1enkVWhTuftsgtmMf7u1lEpIKcetZzfm9q6uPesJNX2zcfklOUzF6UyMEK2gAr3ceWty4dxyyT7+aVOzlROOsUnSdKnQs6ZXATUAc9YptoKIQKAIOTJt06cnHIWbsxhwYYchIBbJ8cT7e/BqDg/EoK9iA/y4MttBdZ0XIi3i3UEuxaTE4OZnBjE+qM9dZmS2hZrQJrYP1BTRDAsypc/DqoFGwL47IZRjIz113S1mJwYpLD0uWBIOBn5NewrqiUh2NN6HfbYiz0+3JhzQscGy3W+c+UIQE63fX/7OK78MN1hHejCoeH8uq+Upnal+m/B+mxrM7KFMfH+JIV4cenIKEpqWll1qMw6ruTq0dEkhXrh627EqBN09HKxRr1gyW3jWJJRiK+bifljYzhS3sBHm3Ktx+gE3fVA9fmHyxuoamzj1sW7OFhSj14nmDsikvOHhqsPdnLG0qduQkmSPgE+0dheBTh9RZz8KWzJPs4zv2ZaX7+/Poelt421ui0Mi/bjm7+M4dsdRXi7Gbh2XGyvjbJ6nWDRDaPIyK+htLaFH/eU0NjWib+7kUvTorh+QhzP/ZapcJTQCXjht0xsW3UEsqfdg+ck009jrhNAZ5eZXXZ1moMldXz9XqH1PWwnAVsw6XVszTnOqDh/zXRYb0xNDrY2tAIU1bTQ6MBfLybAnXH9AjXFCT/aqe8A9hbWcff0ROICPbhq4TbFLC1L3SzE25ULh0VoKiAtuJsMDI3yZWiUL2azxAcbcvj9YBlDIn2obmrHw8XAnGER1DR34OeuNrbtMsPZb2ygsqG9+7XE22uzuHh4JHGBjg1/nZxZ/MdOEkKIIciNups1Bhk6cfIfs12jsXNbbjUjbOoPI2L8Fa9PhhExfly58oi176aupYOd+TXcNjVBNb/ILIH9mmpC/0AWzE/r9WcU17ZQbueacKC4J3UnAV4uBtV4iPYuM++szaa1vQtvNxObs47j7WbotafLwrvrsrhpYhzuJgNms8RdX+1WXQPIQxGX3DoOk0HH+UPCeXvtMQqqe5p961rUQa2lo4sHlu7l3hmJijoewOfp+cxMDeW53zIdrgot1Lf2nPvBhhxeXHHY+rpfkAdJoV48v1zelhjiib+HUSXltwQnC5IESzOKCPJyYVZq6ClpkHbyv6UvThJ/AyZLknSRzbbPkMfAA2QJISZKkuR4jrQTJ/8Gw6LVja1ao7/NZonX/jjKD7uLCfJy4aFzkhkU4cNTvxxi3dEKEkO8+OcFqdbVjiRJbM1RNoVuzj7OpmPHKahST2m1d1GwpBHrWjpwMeg0x3BE+rkT7uNKiY0C0T7AuJn0LLx2BCsOlLPQJsUF8MmWPMXPjAv0IPe4MlUX5uOqUDi2dpj56xe7OVhSx+BIH02HCYDrxsdZpwG7mfTcPLEfj/104jJyYXUL936rFnEcLKnnnDc2UK6xGnMx6BRClIn9e1Kwvx8sUxybXdmkSEceLW/kmjHRfJ5eQG8Y9cJaL3tpxWGW3DaOlDDnVN0zmb6soK4EdlheCCGmAFcjT9s9ADyM3Kh7/ym8PidOmJwYxN9mJLJwYw4IuG1KP00D1sXb8q03qOLaFq78MB03o95aWymvb+Mvn2ew6t7JgDw1dkCYNwdtxAhhPm5c/dE2zeu4aGgERysaKKtr46Kh4Vw+MorbFmew/IDcXyWEYHScPy/OHUyUv+ymoNcJ3rt6BI/+eIBDJXWakvTx/QK4cuF2zbqXfRnHPjiBLCe3DVABHibWHpGfE1dlVigGA1rwdjVwz3TlVODZg0J57Y8jmia79jhaxdkHJxeDjk+vH0Wgh4lnfsskq6KRacnB/H1Wj/AhLtBD0YBs1AtVU7VZ0rZZmjMsgrK6Vgx6wcZjPQKSpvYuPt2cx4vzBp/wszg5felLgIpD2fc0BygDrpQkydzt1Xc+zgDl5BTT3mkmzNeV+eNimJUayuBI9eoJYNMxpcLNLKEo/ANkVTRSVtdqTf+8cskQ7vpqN8cqGkkO9cKkIU8O8DBx0bAIHjw7WVEPWrAh2yp+MEuAJLElu4oHl+7jy5vHWI8bEuXLL3dOYObr61Uyal93I1tzqjWDkxa+bkbqWjqsAUIA5Q1tzEgJxtvVyIBwb579LVNxTqe9rh2sKycLDa0dPP7zQZraujQDmoWEIE+yKnufsWVLcqgXY/vJ7ZGLbhilecy9ZyWyr6iW7MomXI06Hjo7mbfWZFHVLRLRCbmHbUlGkcrV/s5pCcQHebIzr1oRoAA6zCf3nTo5felL9dUDsH18mwaskiTJ8r/gID2+fE6cnDJu/yKDB5bs45212Vz0zmZWZyqVdNVN7d3zhU4unZNjc4NNCfPmzun9mTkghGnJwSpncL1OsPyeiTx23gCVWMH2qd+WnXnq5lWQU3H2TEsKorJRverQQgD3z0rig2tGMCrOn2AvFyRgX1EdqzIraG7v4qaJ8aTYfQ/2bu0gp9FWH65AkiTeW5fNxBfX8uu+Utq7zDS3d+Fq0GneHAI9TXi7ntxzrYdJzzMXDUKSJNYcLuedtVns1fjOovzd+fYvY/nr1H7ce1Yic4ZFcvvUfsQFepAS5sWH89MYFefPNWNiFOfNSg0hvjtdOyLGj2HRPQ8uJoPOYeOxkzOHvqygSoBBAEKIaCAVeMNmvx9wch76TpycJPlVTazK7ClrmiX4dEse01NCKKhu4s4vd7O3qA4Xg47h0dorK3uOVTQyLkFOES7cmGNVCK48VI6PmwFXg846lmP+2BiCvdQ3+F/3lbJSQ3IOKG6U767L4uNNuRh0Oto77RwPDDrumNYfk0GvGN9xaVoU7i56PtmUq1DJWYLRS/MGMzM1lKFPrVS838pDZXR0mXn5ksFc/kE6Dd1GsVoCCfl7aOB4Y5tCoGChtdPMp9encd0nOxXbXYx6FlyTxjUfb1Ol4WxTcIGeJr6/bRzRAR48veyQVT7+ysojvHbpEOYM63mWPd7YxnlvbqKs24fvnbXZ1NmIRr7bWcT0lBAemZ1CUqgXuwpqGRnrx5xhEdZjhBB8edMYfthdTEVDK+cNDichWFtZ6eTMoS8BahlwW3cv1BigHfjVZn8qkK91ohMn/y5ajgAGnWBL1nHmf7zd2vvU1mlmay/uERb0OsH4hJ761cd2ooS6lk7+OrUf8YGexAZ6EOHrxoHiOlLDva3WSZIk8dSyg5o2SAad4B/npgCw9kgFL6044vBa2jvN/POXQyycn0ZsoAe78msYGevPdeNjMep1TE0K5vIF6Ypzlu4qwqQX5FY10WGXugvzccOo1+HtarQGJ8vPifZ3Uyj0BDA1KZjX/1DbHgEEerowrl8QFw+L4PvdstzcqBf8ZVI8hTXNquA0MNybl+YNoaWjk+ON7UzqH4SbSU9zeyef2/RSSRJ8sD6HOcMiyapo5L5v96i8CuvsFI0rDpZxoLiWgRG+XJIWxSVp2ga/bib9v+Vx6OT0pS8pvieBbcBdwDDgXkmSSgGEEK7INal1p/oChRBeQoh/CSHyhRAtQogtQoiRJzhnkBBifffxxUKIx4XW1DYnpz0Rvm5cPLznSdlk0HFJWhSP/XTgpHzyAK4dG0tyqBeDI31458rhiidro0Y6rb6lk7kjIll7uIJxL6zmvLc2cc4bG6nsXol0miWON2p3VHSaJQ4UyzdcrblH9mw6VonJoOPWyf1YMD+NmyfFW01a02L8iPZXjq7oMkss3lbA5qwqhQedh0nPk90zkFo71PJw+5rSjAEhpIR5kxTqpToWoK6lncsXpJMY4sUHV4/g0XNT+P2eSYxLCCTQ00V1/Mg4f7IqG4kN8GBWaqiiD8sR9323VxWcHGFvbptT2chPe4oprO5RW+YdbyKrosH+VCdnMH1xkqgGJneLIZolSbLNGwhgBn/OCmohMBi4FihCVg6uEkIMkCRJ1UkohPAG/gA2IM+uSkZuLm4CXv0Trs/Jn8wr84Zw/uBw8qqa8DAZuOfrPSq7oN6YMSCYa8fFsP5oJR4ueusI9NaOLuYOj7TOKrJw7uAwfthdrLD4OVzWwIIN2fzj3AEY9TpmDwpTjX6w8O66bM4eGKYpj7dXqPUmgzbodXxx02iuWpiuWP3Yc924WO6flYSLQcfD3+/vXmXprN+RAKrsAuq+olq6zBJBXi4qmTrIozd2FdSwq6CGmybE8cDZyaw8VMaW7CrOSglhalIQa7sd0v09THyyOY9PNuehE/IqKTnMm5fmDmZQpA9Xj4nh483ySlUIuGVSPJIkadajHHGwpJ66lg583Ix8tb2AR37YjyTJK+J/XTaU3w+WWedETUoM4sP5I5xu5v8HEJKWAdZpghDCDWgA5kqS9JPN9gxguSRJj2qccxvwIhAiSVJL97ZHgduASKmXD5yWlibt3LnT0W4npwEXvL2JfRpP3T5uBtyMBmsdw8LwaF/+OjWBv3yeYV1xXTs2hguHRXDTop1UN7Vj0usI8XYh0NOFmyfFoxNw2+Jdai++gaG8d7VsIZRb2cQ767LIqWxgX1G9ajV33uAwnrt4EAs35PDx5jwMesEdUxOY0D+Q2xfvIud4E/GBHrx5xTBN53Jbvt1RyANL9zncv+CaEcxMDVXU00CuCV0xKpoLh0Zw+xcZilXfkChfUsO9+XJb771FAH7uRhKCPdnRLf7wdTfyw+3jqW1up7y+lb9+uVvlhAEQG+DO2vunALDmcAWZpfVM6B9k7WGb885mdp9kkHIz6XnknGSuHBXNyOdWK2ygQrxcVHW2l+YO5tJeZn05+d8ihMiQJKn3Lnf66CQhhPBETvHNBEKA6yVJShdCBAK3AEskSdJOav97GAA9YG+/3AJMcHDOWGCjJTh18zvwNBAL5Gqd5OT0Z19RLSUaTafTkoKYMSBENVTvkdkpXDsuhnnvbVUEkM/T89lbVGe9ybV3mWnp6OK7W8di0Ou4amG6Zp/PuYPl4YgfbsjhhRWH6TJLGHRCM9W4bF8p649U8ukNI7l3ZhJVjW08tewQn27JY0SMHx/OTyM+yMNa18qqaOSbHQUY9TquHB1NpM1U2kvSIqloaGVJRhF+7kZMBj3bcqsRAuYMjWBGSgiA6mZvluQ606g4fx4/P5X7v9tLe6cZb1cD985I5MZF20/iW5fZYaNMrG3u4KONuTwzZyCF1c2awQkgr6qZ6qZ2AjxdmJ4SwvSUED7ZnMvdX+/GxaAj0k9tYuvtasAsqScBt7R38dhPBymubVHt05oaXFijbrR2cubRFyeJAGAT0B/5Jh8PuANIknRcCHETsuXRKeuDkiSpQQixFXhUCHEAue/qCuQgpLZYlglFTgXaUm6zTxGghBC3IAdXoqOdBdbTlXfWZvHy79qCgzVHKmnXuElW1LfiYtCTVaF0BTdLcr3CluON7dy+eBcGg6BEYxzFPdMT2FNQy897SlhzuMJ6U+6tDtbQ1slLK47wzV/G8sCSfdbBfxZvvI+uk0up+VVNXPj2JmvP1jc7Cvnj3sn4d0vehRDcMa0/d0zraawtqmlGJwThNk7lI2P8+LU7zQWyn9+Q7tXKBUPCmZAQyNHyBqqb2rn/u72cZOuVShABclP08gMl3D09kYn9A1U9SADxQR7WzwCw7kgFT/5yyPr6WLm6n+qBs5MUx9jz/a5iLkuL4vP0nmrCvBGRfL2j0NojpdcJZqWGntyHc3Ja05cV1DNABHJwyAXsLY1+RK5DnWquAT5GDjpdwC7gK2DEqXhzSZIWAAtATvGdivd0cmpp7ehyqDazoJW5/S6jiNQIb1o61Pvsve8AVmZqy8avGBXFz/tKVfOhTgZLj9OGY0pvOtvXP+4uUTQUVzW18/vBMq4YJT8wFde28Mj3+9lVUENajB/PXTxIscKycPWYGPKrm1mSUUSgp2z1ZNuQ6+9hYli0L2OeW31SbhEWGts68XUzqr6zqia5uffx8+W63Bq7ybuPnJOiGBpp8Ty0IKGUpgd7urCvqE4zIFoI8HThnxekkhLmzd7CWkbH+zNnWAQXDA1nwYYcOrskrh0Xe8K0qZMzg74EqPOBdyVJ2tG9mrInF3lo4SlFkqRsZHGGB+AtSVKpEOIbQHuMqLzKCrHbFmKzz8kZRpdZOqFi79xBYWSWNihqE3UtHTy9LLOXs3pnTLw/f5uRiEGv46vthQ6PM+mFol/JlrnD5X6fpFAvhUmsrXrOU6Px1dPGjf3+b/daPQPXHqnkgSX7+PzG0apzDHodT5yfyhPnpzq81oLjzX0KThb6h3gS6evGD3vUwpBle0uICVA7iHfaOTmkhqsFIbb/rAYKwJiyAAAgAElEQVS96NUB3WQQPHROMnqd4MrR0QpJ+YgYf966wrfPzu9OTm/68q8ZhDxV1xGddKf8/gwkSWrqDk5+wCzgJweHbgUmdkvfLZyF3Gic92ddn5M/Dw8Xg8q9wKATeJj0GHSCy9KiuDQtStG4CRDh50pDa99vxhZc9DpGxwcQ5OmimknUP9iT+CAPwnxcCdCQXcvXref2KfLwvBcuHkyMv5yOiw1w54WLZY+4rIoGjDpBsFdPKmxwpA8zU3uesbblKlce206i38sRT/2qnT6L9O35dTHqBEF2n+nsgWH8/exk1fh6kIPpxP5Kb0RXow4/dxN3frWbqxam8+PuYs4fHM78sTGY9DrcTXpiApS3i5K61l7nXc0dHqk556uivpVL3ttC4qPLGf/Cas0x9E7OTPqygipHrjs5YhhwYklQHxFCzEIOpIeBBODl7r9/0r3/eWCUJEnTu0/5EngC+FQI8QyQCDwEPNmbgs/J6c2zcwZy99d7rDewB89O5rrxsXSZJVyNsnT8+vGxdHR2sfqwbPtTXKOuJfWFYTGyTDw6wJ0bxsdZ3RBCvFwYGuXLd7087YMsUBBCYDZLfL+rmLL6NtyMOsJ93SiubWFfUR3/+HG/apJs/2BPhUR6cKSvwlZpcOS/l77KrmzUrBWBLA1/96rhFNU0c9aAUMySxKsrj1BY3cLsQWFcPy4WnU5wzdgYPrNpvNUJ+Me5KSSFelNe38Z3Owsx6gXnDAzj1sUZ1tXa5qwq9DrBUxcO5JHZKeiE4IEle8nXcI13RGeXRFtnl0o+ft93e9nRHZSKa1uZ//E29j8xC53G8EgnZxZ9CVC/ATcKId5EXi1ZEUKkAfOBt07htVnwAZ5H9vmrRh43/w/LNF8gDLDOeJYkqU4IcRbwDrATqEHuf3rtT7g2J/8lzh8SwaAIX7blVjEwwofU7nHjRj0cKWvgti8yyKlsIsrfjXMGhrJwU94J33NKUhAB7iaW7lYP5tPrBFfbeL/NHxtDflUT+4vrOd7Y1mtwMhl0nJUSwlMXDgTg570l1j4gkGsxW7KrcDPqNMec/7C7mEdmp1hXZq9cMph7vtnDgeJ6Iv3cGBLlS05lo9WH7mTRMsK1UFzXyvh+gfjYDAd896oRHCiu46llh1i0JY9ZqSE8MjuZEG9XlmQU4u1q5PHzU0nq9v67bUo/DpbUsWxfKUfK1cmWp345yPlDwq1jSe6Y1p9NWVUcbzw5h7QfdhfzXUYRw6N9+eCaNGt9zd77sKmti0OldQyMODnrKyenLyfdByWECAcykGubPwJ/ARYBRuAS5BXW8O7pumckzj6oM5N5721hp01ax0UvaOul0A5w/pBw3Iw6vt2pHWj6B3vyR/dYji6zxNRX1lFQ7fhpXwCLbxpNtL+7ddTGtpwqco83kZFfc8LVli16nWDnP2aojGsv+2Crdcqvi0HH17eM0WwG7o37vt3L0l3a17L63sn0s3HZ6OgyM+HFNYoRGndOS+C+mUlap7OroIaL393S689fde9khZNHdmUj019d3+s5Wu7qc4aG8/rlwwAY9ewqKuz6oFbeM5HEkzQPdvLf52T7oE66BiVJUgmygm83cnASwHXIc6LWAhPP5ODk5MzlSJnS3qa34JQU4sXnN44iyNPkMDgBVDS0cd5bG9l8rJJDJfW9BieQR6ePTwi0Bqd//nyQyxak89D3+zVHp4Nc9Nfi8pFRquC0t7BWMYK+rdPM3V/vJq+qiTdWHeOfPx9kX9GJm15fuWQwn90wioRgpahBrxOqn5lV0aia77QpSztFCFDT1PtAbQEqCyRPF4OqvmeLu0lPuK/arNf2u7APmAPCvJ3B6f8IfWrUlSQpDzhXCOEPJCH/n8tyTtF18r9kUmIQv+4vPfGBwJHyBuZ/vF0ztRbq7UKQlwv7i2VbnbriDq76aDv3zOivOUTPlpGx/tz/3V4mJAQyPiGQz7bmWfd1dEnEBrhTXt9GS4fNSkASPH5eCtmVjUT6uaMTEv1DvJiaFMzSjCL+OFTOwEhvbhwfr3kTL6huYcar660Kx8Xp+Xzzl7GMiHG8qhJCMCkxiDcuH8ZVC7dZx7Z7uxp4a80x7p+ZhEe3gjAmwB0vF4PCeFZLiWdhfEIgEd31NZDrUwZdj+XS5aOiiPBVNueGeLty+chovtpeYD3HVihx/8wkdhfUkFWhlPi7u/QEustGRhHi7cLy/WVEB7hzzVjlWA4nZy6ntdXRfxtniu/MpLa5naeXZbIttwpPFwOHy/49w9CXLxnMz3tKVEICIeCuaf15b1027V1mfN2MxAW5E+bjRrivG0fLGthgc84tk+JZsEHZBTEy1o8RMf68vz5bsf35iwcRH+jBtzuL8HYzcMP4OL7cns9763rOHx7ty/e3j+eitzez5wSrpP7Bnnx361h83ZUNsu+uzaa1s4vrxsVycbf0/cXlh3nP7nouGhLOv64YZn298mAZj/54gIqGNib2D+TNy4fh52Fie241h8vqGZ8QSD+bWlhpXQufbM6jpqmduSMiiQ/0YN3RSqL83K2DC+2RJIlNWcfJO97EhIRANmUdZ0t2FdOTg2nrMrNsb4nKqX5AuBdj4wNZf7SS5FAvHpmdomhadnJ6c7Ipvj4HKCGECxADBIBadSpJUu9J6NMYZ4A687n32z18v0s7pXYiYgLcmZESYlXr2fLp9SMZEunL3qJaimqaCfBwISO/hqyKRtYfq1SsyCL93EgK8bI6RwC8dcUwqpvaeeLng4r3fWR2Mi+uOGJ1pgj2cqGxrYPmdmUP0c5/zKC2pYMZr/VerwGY2D/Q2ieVX9XEjNfWK1Z/X908huExvgx98g/liq6bi4dF8PzcQfy6r5R/rTpGS0cXl4+MsqbSXv79MO+slQObXid496rhRPm5s3hbPjoB88fGkhii7ZJ+Ig4U13H1wm2ajdS2eLsaqG/tWdkNjvTh5zscuZ85Od045V583catLwM3AiatQ5AFFE4LYSf/NUrrWli0JZ/61g4uTYtiSlLwvx2g8quaSQnzIiXMi8zSnlWYl6uBETF+7C+u45bPMk7opO7jZuSdq4azJKOI3ONNzEgJYWy/AJrbO/llb4lV0HHuoDDyjiu97Coa2jDq1fm82pZ2EoK9OG9wKMv29fSbB3qaVKM/Nh47bnX+3nDsuCo1ufZIBcOifR166H2/uxh/DxMfbc61Bt631mSRGu7DxP6BfLixJ4B3mSVe++MoBVXN1mD34+4S/rh3EmE+fV/RPPvroRMGJ0AVWPcV1bHucAVTkoP7/DOdnL70pQb1L+BmYCWwBnAKIpz8T2lu7+Tid7dYR0V8t7OQpbeN49FzU/h2ZyGdXRJGgyDKz50bJ8TR0tFFhK8bm7OO8/2uYmqaO6z1Egv/r72zDo/i3v7wO2vZuLs7hCRYCO5OC1Vq0JYabSl1ubV7b9tbudV7K3Drpa7UaNHi7paEBBJIiLt7duf3xyabnZUIpW3Ib97n4XmY2ZnZ2QTm7Dnfcz4fV3sNq+8Zz+sbT7HqaAE+zloemhmLs1ZtLPF1hUap4KEZsWjVSkmbOoCDRsV3d47heF41WrWCaF9nHvz6iMU1hoa4s8+kCcDTUUNTq47FnxygsqGFxRMi0On0jI/xZmKMN3Ne384Jk7Kmh6MGh/ZmhGgrrrLB7vY89XMqdiqBFssECjA0IZgXV/aeKWdMlKdFYCuvk66t1TW3sfp4EbeMC7d+8S7I6aYZpYNgdwdOm+kpLlqxX6I4L3Ph05sAdTnwtSiK1/5RNyMj0xu2ZJRKfIxadSIrD+bx9CXx3Dre9kz5s7+eIKWgxmJ/fIALG08U8/SqVAb4OfPhohESCZ8mW09zDGW1q5KCSQ73wNfFsuvMlIT2QdtfjxVazGDNjvfjtauG8PB3R9h4ohRPJw3/uiSe697bayxp7c+u5O2Fw5gUa8gWXrwykZtX7KesrgWtWsFT8wYZTQ9HRXhy2/hwVuzKpk0vMjrCk+dXp1st7ZkyLtqL4/lSW5MhwW64aNVcMSxQ0gE5Idrb6LrbgaejtSJL98wdHMA7Wy1VzBSCITNtbtNz2dBAFo0J487PD5FZIhWcXZNSxP7sCkaEeZzT+8v0LXoToBwwZE4yMn0CN3u1xT5XK/tMySyptWiCGODnzNIpUezMLDNq7uVVNpJX2cja+yYYj/N3swcrMjreznb8/eK4Xq+7mHb6dfD4nIFUN7ayM7OcxlYdeZWN3P/1Ecl6C8C61GKmx/nxy7ECThbX8vo1Q3G0UxHu5WjxM3jiojiWTo6msbWN6z/c12VwUikEbh0fwcMzYvFxtuO/v52iuU3HwpGhzBscAMALlycyOtKT9MJaJsR4MyzEnazSOqM77pAgV2YnnJua+MMzYqlramPloTyaWvWEeTqwcFQIs+L9LQRyN9w/gfu/PsKPZvqA5T0c/JXp+/QmQB3ERLFBRuavZnSkp8TZNdjDnoXdtBirragphHo6cHFiAC+tldp5pBfVUlLbhI+ztn3bMuv638JhTI71Maoj9AbzcxQC2KkVrDyYLxF0tbYmE+bpyKMrjxkHgJdtzuK1qwbj7qDm9fbGhuuSQ4zZ2q6sMp78MYVyK7NKAnDJkABi/JxZOCoUF60hwN00NpxFY8LQtzvXdqBUCAz0dyHcy4nBQa4IgsAXt45iwQd7OZJbRVphLcs2Z/HA9Jhe/0xUSgXPXZaASiHw8e4csssbeHfbGaYNtAx4zW16Fo4KYdWxQmPZ0dfFjglW9PpkLkx6E6AeA34UBOFrURQP/1E3JCPTHakF1aTkV5Mc7smHi0aw70wFtU1tjIv26jZQhHo6Mm9wAD+327XbqRQsnmAoBw70d5YM5Pq62OFh0q7t66LlpImHkaNGyaQYH7afKuO1DSepa25lwchQ7pjYs+9xSyZFsud0udHHaMHIUHyctVYVuacN9GFLRiltepERYe5cNiyQSS9vlhzz7rYsSmpbjIruKw/lsWrpOILc7Xn4u2NWjf1UCoGnLxnEgpHWA7sgCJj2bOj1Iks+P8TaVEOjxtAQNz67ZSSf78sx6gW26PS8sfEUs+P9urS0t8WZsno+NtH7K6lt5u2tWfxjbhx5lY24O2h44JsjbD9VRqCbPY/NHkB6US0uWjU3jwvDQdOr8U6ZPkxvfpM3ArnAPkEQtmOw1zCvFYiiKN5+vm5ORsYcU1tzpULgjWuGGp1ue8p/rx7CpUMDyK1oZOpAH2Pp6MmL4sivaiQlvwY/Fy2vzB+MyiTjemTmAFLy91LZ0IpKIfDonIGU1zdz52eddvL/XpNOiIcDcxK6v6eREZ5sfmgSW0+WEubpaJwTunxoIB/tPENepaGBI8rHidevGUpjq47apjbCvRypaWpFqRDQm3To1TfrJHYjLW167vr8EHdMirAITk52SuYPD+buqVF4OFpXY7fG1lOlxuAEcPhsFbd9sp+aRsvgl1lSR1OrjgPZlQwLdWN4qGFdaH1qEf/bmkWbTuSWceHMHRzAJ7uz2ZVVTkKgK15W1OHTCmsY+dxGapvbcNQojf5Z+VWNLNucye7Hpp5TFivTt+mNFl9P/DdFURQv2H8l8hxU36ZNp2foMxskygammnl7TpdTWtvMxFhvY5mqJ5wpq2dHZhkD/JwZEeZBeV0zbg4aSVmrg8YWHYdzK4n0dsLXRcvKg3k8+O1RyTHDQ91ZeecYi3OrG1o5W9HAAH9nq6VGU2qbWlmbUoRKKTBrkL+FRBDAs7+k8X77zJZSIXDHhAiWbcmyOE6tFHC1V0va0e+ZGn1OJbiv9p3l0e+Pd3ucg0bJ3VOieNGkbHr50EASglz51y9pErWIS4cESNaRzGecAAtFC3PMNf5k+jbnfQ4KgyisjMxfhk4UjeWwDjpERJd+cYhf2u3OPRw1rLxzDOFeliZ6plQ3tvLmplN8uOOM8YF51+RIHp45wOY59holYyI7vY8GBVqWsA6frWTpF4e4YXQohdVN+Lvac7aigSd+OE5zmx5/Vy0f35zcZVOFs1bN/KSu/T+fvDiOyQN8yCgyNCuEeTpwJK+KnZnSCZBWncjseH/OlNWTXV7P7Hg/lk6OsrheVUML2eUNxPm72DT+mzLQp9tgEevrxLOXJbD0i0OS/d8fzrfo9gOMv7cOzIOTWil0+X4BrlocNUo2pRczOMjNpj+XzIWHLHVkgpxB9X2e/PE4n+3ptB3726wBhlmgN7ZLjrtuZAjPX5Zg8zpZpXXMf3u3pCQGBquMw3+fbtSj6wnD/rXB4jrmqBSCxBV4QpQnYd5O1DS2ct3IUDydNKxNKcLPRcvFg/0tPI96wsniWjwc1Hy29yz//U1qd/HylYldBryVB/N4vD2A+jjbseKmZOJs6O6dKKxhyeeHOGM2h9TB32bFcuekKJKe3WAxRNwTzPX4pg30obqxlf0mthqxvk6U1bUQ7uXI5AE+/Pe3k7TqROxUCpZdN4xpceam2jJ9iT9CSaIFuEEUxa9svD4f+FwUxXMbgJCR6QFPz4tncJAbKfnVjI70Yla8H7usKGwXVTXx1qZT+LpoJR5EHby//YzVoNITe3lzbhkXzsvrMro8xvya2zPL2dae6fx4pEASwFYeyiPG15lVRwvwd9PyxJw4mzp2AGV1zdz44T5SC2pQKwWWTo6SdDeOifRkbnuLeAc55fU4aFR4O9vR1KrjqVWpxuy0pLaZf69N55Obk62+X7iXIx/cmMRV7+yx8HJSKgSmDPDhpbXpBLrb2wxQAgaNw6RQd/aZ+TkND3XHw1HD4bNVjAj34Ol5gxBFeGVdBulFNQwJdiPMy5EIbycmRHsx+oVNRrWM5jY9L6w5IQeofkJvSnwqurbnUCLLHMn8Qej0Iss2Z7I2pYhQTwcenhlLVWMrX+8/y382WJrjbTtVwqYMgxbedwfzWHFTMh/uPENqQTVjo7xsWsFfNjSw21kqc+6aHIWvi5YPdpyWSCR1hXkINA1gHYaGAOX1LSz+9AB7HptqM6t7e0sWqe2Dx606kdc3nmLrw5OpbWpDL4rEB3Y68NY3t3HbJwfYlVWOQoBbx0dw6/hwas3KagezK/hwxxluGB1qbBRpaGnjoW+PsjalCA9HDY/MisVVq2ZNahF7sipwd1Tzz4sHccvHB4wNHgoBZgzy5be0Eosg/f2dYwj2cGDiy1skTRz3T4+RlFE7ePHKRPadqWDhB3tpaQ+m84cHUV4vDZLnkrXJ9E3OZz9mMHBuMtIyMt3w9tYsXttwEjB0dG1MLzE+pKxh+tLeMxXc/PF+drc/9FcfL+LSIdKMwlWr4omL47h8aKBxX0ubntc3nmTjiRKifJz426wBRr8nc64cHsTMQb5c/8E+iT17B+4OaslsU2+obWojtaCG5HDr6gjm8kB6EXIrGyQP+c/35vDO1tMGG5H2uSq9CO9uO83cxACSwzzYl90pr1TfouOZX9I4W9HAU/MGAfDO1tOsPm7o4Cura+HJH1LZ9dgUZsZ3dixuPFFsDE4d7+HuoGFCjBeb0kuN+0WgoqGFISHufHnbKP63NZPapjYWjAy1Gpw6eHtrluT3/t2hPC5KkOoTXj4s0NqpMhcgXQYoQRDmAnNNdt0iCMIkK4d6ADOBC1bJXKZv883+s5LtroKTNfZkSRsHNqVLLcxcHNRcOSwIhUnn3n9/O8ny9q649KJaThXXse7+CdjCWavmx7vGkpJfjZOdipLaZn45VoC/qz2rjxdS2VBt89yu0KgEYnxtd6jNGuTHhrRi47a3k4ZhJk67B7IreOKHFJvnv7I+g9evHcKV/9tFflWT5LVvD+Ryuqye1PxqVGZdjS06PRlFtXhFdTYlWMs+BcGgcWiKo0ZJcrihbJkQ5Mqy64aRVVqPr0vXDQ7mv3dRhPumxpAQ6MaR3CpGhHlwg+wH1W/oLoMaBtza/ncRmNz+x5wmYA+w9PzdmoyMge8P5ZFT0dj9gSZolJ1GeWOjPElpNyHswLzclFvRSGZpnaSzzjyIZRTXklvRYDOL6qCjpBbm5cjhs5V8sjuH+hbrXWhOdkrqmrvWxXtyTpzE38mcK4YHkVVWx/vbztCi01PX3MbC9/cyPc6Xm8aGGzNHW2w9WcoHO85YBCeAVr3ItpOlVs4yuOEmBrlK9iWFeTAjzpf17QHTy1HDyoP5Ft2X9S06fj1WwNUjQsitaOCmFfvJLKnDQaPk6XmDbDZ0JAS5Slx9VQoBUTD8PgcFuDAnwV8yuyZzYdNdgHoGeBbDmmYLcAPwpdkxoiiKvfs6KyPTC349ZumWa9rp1eHzIggQ7unI/dNjGBLsxrrUInxdtMyK9+O7g3k8+WMKOr2Ig0bJ8FB3iSafg0aJv6tU5DXS20lifuiiNTQV9JT1qUW8sCbduC0ASoWh/KhRKbhnShSvb7RcPzMl2seJ60aGdPteu7PKjQG5sVXPgZxKDuRU8u3BXGbHdz80fCzPenZnnrHYq5U4a1X4uWp5bPZAnK3Mm717QxL7syuorG/hpyMFNt2OV+zK4eoRIby6PsMo+trQouOfP6cyK97P6rWLa6RBtE0vcsXyXcbW9I92ZrPmvvFGeSqZC5suA5Ro6EHXAQiCEA0UiaLY9dc9GZnzTKC71FdIIcCyBcNYl1LEqZI6Y4OAKEJ2eT1DQ9wIcneQKJpfmxzChBhvMopqGBbiTkOLjls/PkBaYQ3OdiqevmSQxQPx0dkDOFVSy8niOly0Kl64PLFXagW7T0szFxF45pIEpsX54KhRsd2KV5M5p0rq+HJ/LteP6rpslWWm6t1BZkk9b27KxNNRY1WHr4O5iQHsz+602OgI+uaMivDgo5usd/eZ0qEm/uMR295cWrUh0zFvV29o0fHpnhxunxBpMSwd7mk522Y6N1Ve38LPRwq6VLOXuXDocZOEKIqWI+oyMn8CSyZFsSurnMySOpQKgbunRDE73p/Z8f7c9fkhY4ACQ1Z1srjWQvkaINDNnsB2W3A3B1h973hyKxrwcrKzUGrIq2wgt7KBn5eOo6SmGR8Xu15L6ZiXvwDi/F3YmVnG53vOUmpFdTvO35k0s07AI2erug1Q0wb6Wh2C7UBlZoLo7WyHTqdHoRC4Y2Ik148OxdfFjo93Z6NRKtiSYVnWSwh05ZlL4ru8D1NOl9ZZbRgBQ2muY1h4epyvUQm9g5fWZpBT1sCLVyZK9i8aG8b2zDL2nalApRAYH+1lbKfvwNaQscyFh80AJQjCuxi+RN0piqK+fbs7ZC0+mfOOn6uW9fdNILWgBh8XO4nf0oQYL0kJyVGjZHhIz72ArK0nLd+SySvrMtCLhgf5l7eNPCedt0sGB3LkbBWf7T2LTi+iEOCuLw5aXesBiPR25OUrB3PJsp2SNbKRER78dCSft9t9km6fEMGlQ6Wdas9cGo+zVsVvaSUUVDdaZD8+zlpenT+En4/m4+dqz6IxYXiYeTbNGOTH6EhP1qUWWTz0Ad64dmi3629tOj2vbjjJ6uOF1Da2UmHSuehop2T5dcPIrWxkXJQXYe1KH3dOikIQBN7YeEqyVrXyUB5/nxuHk0l7vbNWzTe3jya7rB5nrQqNSsEly3ZyurQzC0srqEGvFyUNLzIXJjaVJNq190TAXhTFFlmLT+avQqc3GBEey69iVIQnFyd2toiLomE+6ruDeXg52fHQzFhGRdgeau2OivoWRj7/m6T0dlGiP8uuG2Zx7Kb0Yl5am0FlQwtXJQXzwPQYBEH6UMwsqWXaa9u6fE8XrYp3rk9iRJg7KqWCNccLeXldBlWNrVwzIpiZg3y5dPmuzvKbAK9fPQQfFy1Joe4WTQEV9S08v/oE37VbcaiVAm8vHM7UgV0Prx7Pq2bB+3sspIYAPBzVHPr7jC7PB1i2ObPLoeV9j0/Fx4ah40VvbJdkw1q1giP/mNHtl4NdmWVc9/5eyb7XrxnCJUPkdvO+yvlQklADmKw5yVp8Mn8J//w5xShv9Nmes2SX1bN0SjRgsINYOiXauP17Ka9rslgXKqmxzHhKa5u547NDxiaCNzdlEuRuz9UjpA0NqVace82J9HGSKEXMTvBntoka+rLNmRL7dVGEe74yWMUHuGr54rZRxmwEDFqEr8wfzKIxYZworGF0pCdB7g5UN7ZSWttMpLejRSAFQ1u9teAEdKlPaIqtjj8wlAhtBSeAu6dEc9cXh4zeTrdPiOxR5ppZarn+llpQIweofoDNAGXeDCE3R8j8FbTq9HyzP0+y77M9Zy0C0p7T5axNKSLYw4Frk4PP2RPImhW8tcHRgzmVFh1uu7PKmR3vz7cHcjl0toqEIFdmx/uhVgo2myHc7NU8NXdQl/c00N+2qGxBdRPT/7PVaoYUH+hqbHn/ZHc2z/16guY2PQP8nHn+sgQ+2Z3NmbJ6psf5cuekKJtNFO4OagupJNv36sLeM50DvyqFQLiXI3EBLvxtVtdBbla8H0/PG8RHO8/g5qBhXLTtgV1TRkd4Wuj3jY3q2bkyfZvuBnWTgUxRFCu6Ou6PQhAEJfAUsBDwBwqBz4GnRFG0+lVPEIQwDF5V5swWRXHtH3KjMn8YCkFAq+6caQLDWoYpa1MKueOzTuXsjSeK+eK2Uef0fodyLBf1zbsIAQYFuFg8FPMqGxnyzHrjvl+PF3KyqJb/LRjOqxtOUtPYylVJQfi72ZNdVk9CoCvT4ny7td6YHOvDTWPD+GxPDnpRRGdWbG/Vifzjp1SbJbzyumae/eWE8WeYXlTLNe/tMQbYjgaF+UlBkqYGV3s1k2K9uWtylGQdqCvunRpNRlEtu0+X4+6g5ql5g3qcyRw6W8nff0ppzxbrWfj+XjY9NMnY2GKLaF9n/nvNUN7ceIoWnZ6bxoQxUXbV7Rd0969uN3A98AWAIAhOwLvAs6Iopv3B9wbwN+AuDGaJx4FE4GOgGfhXN+fOAkyNev6SICvz+1AqBB6YHsNTq9KM2/dPj6G6oZVdWWVEeDtJ1M3BoB/GMTYAACAASURBVGWXVVpHpHfv/YEKqiwHgoeHdqoyHMyp5MU16RTVNDEp1odDORXUNesYGuzG/pxKi3N/OpLPvy6NZ03c+F7fSweCIPDPuYN4aEYsja06LnpjO8U10g7AwupG2nR6q0OqBVVNkgAPlvNN61KLWXX3OFy0ajakFRPh7cjN48J75asF4O6o4cvFo6iob8HJTtWrjrp1qUWSUmZzm55N6SXddjACzBscwLweZnkyFw7dBSjzQrUdcA3wPvBnBKgxwCpRFFe1b2cLgvAzMLIH55aLoljU/WEyfZ1FY8MZHenFsbwqRoZ7UtHQwtgXNxkFRiPMfJ8EwTBQ2lsq6lvYaraGEuPrZAx09c1t3Lxiv1GR4mxFA7dPjECtULBil7WkHXQijH9xM09dMuh3P0Ad7VQ42qn49vYx3PLxfk6ZzD6FezlysrjOqkXGQH9nAty0FNjoHuw4H2Du4IAel/MAUvKr+XDnGdp0IjeOCTW65pp3CPaEUA/LGacwz667BmX6N+dTLPaPYAewRBCEAaIopguCEAdMAV7owbnfC4KgBU4B/xFF8TtrBwmCsBhYDBAS0v3EvsxfQ6yfM7F+hrWYp1alStSvz1Y0YK9W0NhqyAquTQ4hwM2euuY23tmaRVpBDeOivbhxdJjV1uPqhlZ+PJJPaW2zhQSSqYL40bwqiVwSwLtbT1sdaDWloqGFR747ysRob1wdfn+vUYinA6vuHsfyLVl8tOMMtc1tZJXWM++tHXx+60iKapp4/bdTNLbquH50KEsmRXFtcgivrj9p9XqR3o48PDO21/dRUNXIVe/sNppGrk0p4o6JEfx8tAClQmDJpCiuGB7U4+tdPiyQDWmGFndBMCiVj7OxlnSisIbf0ooJ8XRgToJ/t2VSmQuTvh6gXgScgTRBEHQY7vc5URSXd3FOHfAQsBNoA+YBXwuCcKMoip+ZHyyK4rsYypYkJSXJ7o0XAFUN0sX8Nr3Id3eOIbOkjhAPB6Pq971fHmZju57exvQSKupbeHCG9EFc19zGvGU7yCk3KIKbrystGNlZXor2cbZoeLD1D0arVtDU2llGa2rVc6a8niEObr3+vNavr2T6QF/eMJFKatOLLN+SxfZTpcbP8NLaDJztVCzfbDln7+mo4eObkxkU4GK1q6871qcWGYMTGMRj39iUadx+8NujxPo5S+w+uvtMH92UTHZZPRqVggAba09bT5Zy84r9xm6/tSlF/G/h8F7fv0zfp69/7bgag/7fdRiEa2/AkFHdYusEURTLRFF8VRTFPaIoHhBF8R/AO8Ajf8ody/zhXD1CKiQ6JtKTIcFuXDk8iORwD3IrGnjyx+PG4NTBD4fzLLTc1qUUGYMTSIPTzEG+XGmSAXg72/HcZQm4aA3f6zy7KGP5mmnBeTlpuuzGOxfUKivZYGMrZkkg3x7Mo7FV2oTrbKfil3vGER/oek7BSRRFDlpZczOnO6Faa4R5OVoEp7rmNo7mVtHUquODHWeMwQlgTUoRuWaWIzL9g55kUHMEQfBr/7sDhi+N8wVBGGLlWFEUxf+ct7uDl4FXTFx8jwuCEAo8BnzQi+vsBW46j/cl8xdy9YgQXO01xsX8G8eEGV+rbWrlsuW7LJxeAYqqmxn5/EYSg1x55/rh+Lva09WzOSXfsuX8qqRgLh0SSGOLjrTCGm78cJ9FAwLAuGgvZmlV/HqskCB3ex6fM/CcbNy7YoCfC9PjfI1WGw4aJdeMCLaQFwpyt7cQg3W1V+Pv2nV3XFd8tvcsq6yI+JozKNC6bXxv2HiimHu/OkJdcxvuDmpCrejxyfRPehKgrmv/Y4otOSMROJ8ByoF2sVoTdPQ+8xuCoUVdpp8wK96PWfF+Fvs3pZdYDU7QabFxLK+al9dm8NrVQ5gV78dbmzMlUjkdhJot0Nc2taJSKLDXKNGoFIyO9GTNfeN5bf1JidySs52SME9DFvDA9JjzEpiaWnWsSSmkrLYZJzsV3s5aJsZ68/bC4WxKL6GoupHpcX68t/205Dy1UuDhGbGsSy2WZB15VY0U1zShVSupa27rtpXbHGsDuW4OaqpMpI1c7dVdmg/2lH/81LnmWNnQiptDq6TUOndwQLcSTDIXJt0FKGveT38mq4BHBUE4A6QCQ4EHgE86DhAE4QUgWRTFqe3bNwKtwGFAj8Fw8S4MLesy/Rxr3WOzB/myJrVYsi+j2CDI6qBR8fPScfxytIAjuVWsOlpAfYsOPxctT1w0EDDoyz3+w3FWHspHpRC4fWIkD0yPAQyWHB3X6qC2Wcdzq08ABsHYlXeO+V2L+Dq9yDXv7rHIjAYHufLNHaOZHtc5/3QsT3pMq06krlnHxBhvib+Vl5OGL/edZfnmLFp0esZGefLO9Uk9nnca4OcsMUlUKQTunRrNs7+eQKcXUSkEXrg84Vw+rtn96ymslrb+l9U1M3mADxlFtYyL8uqVgK3MhUV3dhtb/6wbscHdGOadlgM+GLKg9zD4VHXgD0SanfckEIoh2zoJ3GytQUKm/zE20ospA3yMD+MIL0f+dVkCJ4pqyTZZa5oU2znI6WSn4prkEK5JDuHvF8dxtqKBaB8n40zRj0cK+OaAQc1Cpxd5Y+MpJsZ4G+ejbOlZgiFb25RewsxBltleT9mZWWZVFfxoXjW/pZVwUWKnLNLIcE/2Z3euDXk4aoj2deKfc+PIr2wko7gWT0cN90+L5okfU03eo5yPdpzh7qnWJaPWphTyzjZDdrZ4fASLJ0RwPL+aLRmlONupeHTOABaMDGXGID+O5VYxNMQdP9dz82Tac7qcVUcL8HPRcv3oUKbH+bLO5AuGXhRZ376dU34WLycN90/vfReiTN+nT3fxiaJYC9zX/sfWMYvMtj/GMMwr8/8QhULgw0UjONg+QDsm0hO1UsEHi0bwwuoTnC6tZ1qcL/dOjbE4t02nx06lYKC/dN0kvdByLepEYY0xQN0+IZJHVh6zeU9NrT1TCSuva+bnowWolQrmDQkwDsnqugiAdc3StvelU6KoaGhhzfFCgj0c+OfcOLRqJaGejqy7fwKF1Y14OtqxJaPE4lpZVjTtAFILqlny+SFj88VdXxzi56XjWHFTMhX1LTholEbNPFNLk3NhS0YJN63YbxzYXZNSxFeLRxLikcnRvGpCPRz49qBU+ur1jZlszijlk5uTu3Qelrnw6NMBSkbmXOkYGO0g0tuJ928cYfP4Nzee4u2tWehEkUVjwnl0dqdu3PgYb97f0TmIq1QIEq23q0YEE+njxM7MMrycNDy/Ot24ZhLkbi8pwZmi14t8cyCX/dmVRPs68v72M5TVGVro39t+ml/vGY+TnYpoG4oY3s52zBokdcvVqpXMifcn1MOBsVFeFi3eHY0RIyM8cbZTUWsyTzbNxn1uySiVdAbqRUMgiQ907XIgt6qhBa1a2Surkq/25UrUJNIKa3h1w0kemBaLq4Oaouomvj+cL1lPA0Om+tHObO6fbvnFQ+bCRQ5QMv2erSdL+eVoAf5u9tw0Jgx3Rw2nS+v4ZHcOOr1IQpArr27oHGJ9e2sWw0PdmR7nS3pRDT8fKSA+wIXKhhY8HO24e0qUUXmhg+Gh7saMamyUFysP5mGvUXFVUpBN4doX1pzgve3WFShyyhtYc7yQ+UnBlFkRcfV20vD9naMtBn9fWpvO8i2dM0+JQa4M8HNm8YQIonw629xd7dV8cksy//3tFJUNLcxPCpbYmJgS7WMZIE2vZU5DSxv3fHmY306U4GSn4pFZsdwwOszm8aa42Fv+rD7elcOuzHJW3zseP1ctD86IMfp1mZJbKbea9zfkACXTr1mXWsTtnx40bv+WVsxHi5K4dNlOo7WEWmnZa34sr4phIW7Mf3s3te3HKRUCyxYMZ0hw18O2oZ6OPDCj+zWRr/bl9ugzJAS6Eu7lKLFGL61rYfGnh/jujtFGtYuOGSHp56jmWF4161KL2PTQJDwd7YyvDQ1x5+Obu7dvnzbQl2uTQ/jmQC6iKHJVUjAzbGRbAB9sP8NvJwwlxLrmNp76OZUpA3wIcnegoaWN7w7mkV/VyEUJ/iQGSX+WVw4PZl1KEdVmth+nSurYmVnGpFgflkyKYk68P/Pe2iGxB7k4UZpNylz49PVBXRmZ38U3+6VBIK2whg93ZksebNasMEZHerIpvcQYnMDQIPHL0YLzdm8u9rZlj4I97I2eUEqFwN8vjrOY2TpRWMNPR6T3Y2u5qrqxjcmvbLG69mSLVp2ezJJajuRWUVrbzKAAFx6fM5B/X5HYpVttepG0q1Evwsn2TsdFH+7nHz+l8s7W01y2fBc7TpW137fIoyuPcc27u6luasPH2c7iuqalwjAvR769YwzzBgcwPtqLN68dypQBXRsyylx4yBmUTL/G2qK5j4vlw+/SIQEcOluFTi9y6/hwxkR6sf2U5azPuXamWeOK4UESqSJTbhgVJmn53pJRYjX4mGoDatVKFo4K5cOd1suGNY1tPPjNUXY/NrVblfGjuVUs/vQAxTXNCHRKOh3Lq8bf1d7YOVhQ1cjGE8UEuTswMcYbhUJgYoy3ZC7MUaNkeKgHKfnV7MvuNBXQ6UU+3ZPNuGgvtmSU8pXJl4mS2mYc7ZTUNxsaTEZHeDIyXLquGOvnzBvXDu3yc8hc2MgBSqZfc+ekCDZnGHT4AK4fFcrCUaGsPl5klOoZ6O/Cs5clWMwAjYvy4qJEf35tV0xwtVfT0qanVadHrVRwurSOZ389wamSWqbE+vDYnIG9agjYnG47mymplUoyOVqZT9KqFcwdLC1r/f3igYyK8OBgTiVrU6UyTgDl9S2U1DYR5N71YOtTq1KNlh7mcXF9WhEXJfpz6Gwl1723x6g5OG9wAG9cO5T5SUGU1jWz8mAenk4aHp45gNqmVp76ORVzOn5e1joIr0sOIdrHGTcHNVMG+FhIMq1PLWJ9WjHhXgY1kZ7OcMlcOAhdzXD8fyMpKUk8cODAX30bMueZuuY2dmaWEehmb+xq0+tFXlqbzlf7c2lq03HNCMMMlNJK6eruLw+zyqS0t3BUCP+6JJ5pr20ly0SB4pZx4fz94rge31fSsxuMXXvmLJ0ciZ1KyewEP6J8nCmoauSy5TuNQcPfVcsn7etHn+3Jab+vUKJ9O5sX9HqRe746zC8mkkSR3o789sDEbvX3hjyzXqIKYcp906K5b1oMd352kDUpUkebLQ9NktjPd3D1O7slTrtgyKy+vn008YGuZJXWMfM/24xqH4IAPy4Zy2Ab633fHsjl4e86W/tHRXjw1eLRXX4mmb6DIAgHRVFM6u44+SuHTL/HyU5lMSibV9nIu9tPGzvBVuzKJtbPmWuTLS1XNp6QqlB8dzCPOyZGSoITWJf/6YqLEwNYsSvbuO3tbMcAP2dKa5t5q119/M1NmXx+20hGhHmw8cFJbEovwdVezfgoLwprmpj5n23GlvaVh/JZd/8E4xySQiHw8pWD8XDUsPFECTG+Tjx5cVyPxGGnD/S1mDcCSA7z4OZx4YCl6SFgVZcQkJT2wKA8semhSfi6GEqmkd5OfLhoBG9vzaJNL3LLuHCbwQnga7O1xT2nK8gpr5d1+voZcoCSuWDQ6UV2Z5UjCIY1ia4W6ruiqVXHqmP5Fm3Kh3IqrQYoTycNDRWdcjuejnb4OGvxcNQYS4eA0a+qpzw+ZyDeznbszionIciVpZOjyC6v56I3dhiPadHpWbErmxFhHjjZqSSmh6uPFUp8seqa21h5MJcpA3wZ4OeMSmnQDXzmknieuaRXt8bYKE+LABXgquXz20ZyKKcSXxctN44JY8vJUuNM0rgoL2J8rf8MEoPcOGqihjEsxN0YnDqYEOPNhB5atbuZtderFIJc4uuHyL9RmQuCxhYdV7+726jKPTjYja8Xj+rVmg/ArswylnxxyGr5akSYh5Uz4PHZA7n3qyO06PRolAqeuGggGpWCV+cP5pGVxyitbSYxyJXH5wzs1b1oVArumhzFXZOjjPsUVrIba/vA8iENhozrtQ2nCHDV8tFNyb0Omh18vvesxb6i6iamvLKF3EpDsF48IYIfl4xlTUohQe4OXD4s0Ob1Xp2fyH1fHyElv4bBQa68eGXiOd1XB3dPiWbv6QrjoPHiCRF4Olk2v8hc2MhrUCbIa1B9l6/3n+VvK49L9r0yf7DEr6knTH11i6Q0p1IIOGiUXJscwt9mDbCZlZXWNnMsr4qEIFd8TLye2nR6qhpb8eri4XiyuJbnV5/gbHkDM+P9eGB6TJfisTd9tI/NGYZyoVat4MvbRjE0xN3iuKZWHVe/s5uj7UFbKQgSWaRJsd6suKn7OSdrXPvuHnaflno5BbvbG4MTGNaJtjw0iVBPR6obWmlu0+Hj0nWXY0ubvtsOwp5S3dDKrqwywrwcLeSpZPo28hqUTL+i0krGY+6s2xNyK6TK2AqFwLGnZnZ7nrezHVMHWs7ZqJSKLoNTm07PTR/tJ7/K8L7/25KFVqXk3mnWRVkB3r0hifWpxRRWNzIjzo8QT+sdd1q1ku+XjGV3VjlVDS0s/fKw5PWzFQ2cLW9gz+lyBvq7kBDUM2dbgDsmRbI/u8LYtBDn74Kfq1YSoEQRimua+Xp/Lu9tP02rTmR6nC9vXjvUZmZ7voITgKuD2jgr1kFji470ohqifZ3lkl8/QP4NylwQXJTgz5sbT1HfbjHuZKdiTkLvlQNmJ/hJhlvnWPGUMmdDWjF7T5eTGOzG3ET/HjvQVta38NbmTGNw6mDLyZIuA5RaqZAolHeFUiEwLtqgC/jRrmyJy+0AP2emvLrFGGQenhkrKSd2xcQYb9bfP4EtGaVE+jgxIdqLNSlFEsuOEA8HVAok0kob0oq596vDeDnZMWOQHxN7uKZ0PtidVc4dnx2kurEVJzsVb147lMkDfP6095c5/8glPhPkEl/f5mRxLZ/tyUEArh8d2qUenC3qm9t4Y+MpDuRUkhTqzj1To63OGHWwfEsmL63NMG7fOi6cJ3vQSt7cpmP2f7dzuszSCPGaEcH8+wrrazDfHshlTUoRIR4OLJkU2W3JzJTS2mb+89tJThbVMinWmzUpRaQWdCqx26uVHP7H9F6v25my+nghPx7Ox89Vyx0TI9mdVc6D3x61efx/rh7MZUN7V4Y9V2b9d5tExSLYw57tj0z5U95bpnfIJT6ZfkeMr/PvNqdztFPxWC+aGT42aQMH+GxvDo/NGWh1XsqUbSfLrAanYSFuPDDDuuL2F3vP8vgPnetse06Xs+be8T3O2Lyd7Xj+sk6TwO8P5Uteb9HpadOLiKLI4dwqnOxUNrvubDEnwV+SuY6L9sJOpaDZSss5GD7TnxWg8iulmWpBVRN6vXjO3Z4yfz2yFp9MvyOnvJ7TZsoEB7IrePjbozyzKo3cip6rXptnGxqlgp487rRqy/9aN4wO5fslYyVNFqb8dEQaUNKLai3cenvD9aNDJdsz4nzR6UXmvrWDy5fvYsZ/tnHPl4e7NFzsDl8XLR/dNIIxkZ4M9HfGPBb0dB0ov6qRl9el8/zqE2SWWPel6g7zsuiseD85OF3gyBmUTL9B166c0CFNNG2gD8sXDCeloJqr391jnNdZdayALQ9Nsijtter0rEstoqi6iVnxfgS5O3DPlGge+u6oUQfvnqnRPXrojY30YkSYu9Hd1stJw+IJEV2eY67zp1YKXTZgdMdVScEs25xpVKvYkVnG/7ZkkpLfWfb7+WgB1yQHMybSy9ZlumVMpJfx/Od+TTNaiDholCydYnutrYPK+hYueWsnZXUGlYzP9+Tw011j+eloARtPlBDp48QjM2MJ9uhGnmneIHyc7dh7poIhIW7c04P3lunbyAFKpt+wIa3YGJwAfjtRwi/HCjjcLgLbQWltM1sySi2+cd+8Yj/b29W1X11/km9uH80Vw4NICHJl75kKBge5WthD2EKhEPjitlFsPFFCTVMrM+J8u3V7vXdqNPvOVFBY3YRCgPumxfyuALUhrVgipVTb1MaurHKL44prmiz2nStPXBTHxYkBnCmrZ1y0V4/uf11qkTE4AdS36FjwwV6jrFNaYQ0ni2pZd/+ELq+jVSt7ZHMic+EgByiZfkOeFcO6M2X1FJh10QEWTrDbT5YagxNAY6uOj3ae4bWrhxDj69ztWk16UQ0NLTqGBrsZ14zUSgWzetAl2EGEtxNbH57MkdwqAt1/n3V6x/ubMyjAhZT8aqOKhqu9msmx1jvdRFGUrH+16vRsSCumpKaJGYP8CLBxf4OD3UgMcmVXVjk76wweTq5dWIs4aS0fQx3BqYOM4lrOljfYbLmX6Z/IAUqm3zB1oC8vrc0w6sGpFAIHcirZbZY1zIjzZVREp2pEm07Po99Lh4ABydCrLURRZOkXh432EolBrnx+60ictbYfyF2hUSlIDreuaNFbpsX5EOfvQlqhoaTn62LH/dNiuCghgC/25eCoUbF4QoQks0svquF/W7LYfqqUqoZWZsX78eIViThr1ZIM8+V1GXxzx2gGBVifrbr904OsTzNoGHo6anj/hiRyKhqI8Ha0yEKnx/kyOFgqhWSOs1aFtxWPKJn+jRygZPoN4V6OfHpLMu9tP4NeFJk3OID7vj4iOcZRo+TJi6SCqfuyKyxmlRQC3DgmrNv33JFZJvE+OpZXzVf7crmtm/WmPwM7lZLvl4xhXWoRza16Zg7yw9VBjY+L1jg7ZcqB7AqufW+PxMBx9fEiWnUid0+JkmSY9S06VuzM5uX5gy2uczS3yhicwGDxMf+d3cZ5rNsnRvDY7M5OSjuVkpV3jOay5Ts5brI+ZsrzlyVgrzn39niZCxO5i0+mXzEywpP3b0ziw0UjGBPladFVVt+i496vpYoLLlaynbmDAxgW4k6rTs+yzZkseH8P/16TLhFnBctSlGHf+VvTORfSCmqM9vBatZJLhgRy1YhgXK1o95nyye4cq+7CG9KKyS63bJlvM1fbbafe7Gdkfuz7205TXif9uamUCp67LMFqKTDQTcvbW7NYviUTvY33lOmfyAFKpt/i46zlupGW6uSHz1bR3KYzbscHujLXRCXc29mOB6cbFtufX32Cl9dlsDOznLe3ZvGAWUY2ZYAPLiZrKEqFILnWn0lDSxtXvb2bOW9sZ/IrW7j/6yO9aiHvSh+wpKaZ4aGdeoAapcKijb2D5HAPIr1t217oRLj1kwM0teok+xOD3Nj16BTevX44148KZXSkQcE9v6qJ1IIaXlqbIbEnMaW4polvDuSyz8xzSubCRi7xyfRrnr00gaO5VZLS0QA/Z+xU0nLRm9cOZdGYUEprmxkf7W1sQV91tFBy3Pq0YnZllRnbqj0cNXx7xxje336ahlYdC5JDuvQx+iP5en+uxHfph8P5XDk8iLFRPWshv2VcOGtTCo1yUqZE+jjx2S0j+eFwPiW1TVyc6G9VyaOsrpltJ0uNNiR2KoHEIDdju30Hh89W8f2hfMkXiPK6Zp5fnc7hs5WMCPPgrknRLPxgr+S8304U4+Nix6/HCglyt2fxhEjOVtSz4P29RmffG0aH/u6Bbpm+gRygZPo9yxcM596vDnPobBUD/Jx57aohVo8bHmrZnBDoppW0QAPcsuIAWx+ZZBy4jfVztroWcy5UNbTw9tbTZJXWMX2gL1eNCO7y+LzKBtwdNDjaqSyUFDpe7ylxAS5semgSa1KKWHO8kH3ZFSgEgWtGBDMpxhtBEKxmpB28vC6dt7eelrT0N7eJFsGpA/Puyoe+PWpUcT9dVk9ZfTMapUJigigAS7/oLNFuP1WGv6vWGJwAPt2dw+x4P0b/jtkumb5Bnw5QgiAogaeAhYA/UAh8DjwliqJlobvzvATgLSAZqADeAf4lysKD/RK9XmRjegk55fVMGeBDhLeT5PVgDwe+XzL2nKwenrw4jgXv7ZU8JBtbdWw7WWbV6qNVp+fjXdkcyK5kWKgbN40N77J0Zs6tHx/gQLvg64a0Yuqa24wOtqaU1TVz68cHOJJbhYNGyRMXDWROoj8f7jxjbCF31Ch7LZbq66Jl0ZgwFo0Jo7S2GYVAj3yW0otqWLY5q9vjOlApBGYndLbgi6LIFjNH4l2Z5fxzXhzP/XqChhYdiUGuFute6UW1qJXShUYRWPjBPj5aNKLHBogyfZM+HaCAvwF3ATcCx4FE4GOgGfiXtRMEQXABNgDbgBHAAOAjoB549Y+/ZZk/m4e+O2rUnXv21xNcnRRs1RDvXKweRoR58OCMGF5Yky7ZH+5lfR7nmVVpfLonB4C1qUWcKWvghcsTrB5rTm5FgzE4dfDD4XyrAeqtTZkcaW/LbmjR8fTPaex+bAofLhrBZ3ty0KqV3D4h0qasUk/oTVt3dln3mZpCgJmD/BBFuGFMqKRFXRAEorydOGUicxTj68SCkaFcMiSQyvoWgj0cLNYABQwDyObo9CLv7zgjB6gLnL4eoMYAq0RRXNW+nS0Iws/AyC7OWQA4ADeKotgIpAiCMAB4QBCE1+Qsqn9RUNVoIYr69YFc5g0J6PHaizVE0WAvX9PUyvzhwezMKmfbyVJj+7m1ciDAykNSm/TvD+X1OEC5OqgthFd9XawHCXO9uhadnpyKBibF+jDJxuDtH8noSE+ctSpJsHB3UEt8vC4dEshrV1svrwL8+4pE7v7iEAXVTQR72PNcu/Ctk53KqOm3dEoUO7PKjN2TIpBd3vMypsyFRV8PUDuAJYIgDBBFMV0QhDhgCvBCF+eMBra3B6cO1mHIuMKAM3/Uzcr8+ehtfN84mFN5zgFKrxdZtGI/20xKTmOjPPn5rrH4uWm7zEq8ne3IMXlgmmYhZXXNvLQ2nZT8GsZGefLA9FjJbI+LVs1DM2J5Yc0J9KKhAeP+6daVz6cO9GFHZudckq+LHfE2hmb/DFzt1Xxx6yje3HSKqoZWrhoRzJXDg1h9vJDtp8qI83fmmmTb61cAw0Pd2f63KRTVNOHvorWqedihtnEgBc8kpQAAA4xJREFUu5Ifj+Tz3cE8K1cylBBvtZJ5ylxY9PUA9SLgDKQJgqDDcL/PiaK4vItz/ADzf7XFJq9JApQgCIuBxQAhIV3/B5LpewS5O5Ac7mHRXpwUammR3lN2ny6XBCeAnZnlfOySw6tXdd0M8ficgdz95WHDepdSwRMm1h73fHnYqIWXVlhDfYtOYo8BcNuECOYk+pNdVs+wEHebw6k3jg6jsVXHqqOFBLrZ8/DM2PPqVnsuJAS58u4NUosfc3uO7lAqhG4lnrRqJeOivcipqLcIUPdNi0atVDA9zrfXViIyfY++HqCuBm4ArgNSgSHA64IgnBFF8YPz8QaiKL4LvAsGw8LzcU2ZP5fPbx3JQ98cZX1aMWqlwF2ToxjzO8p7tU2W9vIAh3Otd6OZMnOQH7sfncKx/GoSAl2NYqn1zZZCrRvSii0CFECgW/c6fAqFwJJJUSyZ1DOH3P7IlcOD2Jxeym8nilEIcP2oUO6bZj3jlLkw6esB6mXgFVEUv2rfPi4IQijwGGArQBUBvmb7fE1ek+lnqJUKXr926Hm73sQYHwJctRRUSxUhksN6ppHn6WRnIcBqr1bi76ql0OSaEV62h1llusdOpeT9G5PIr2pEo1TIWn39kL6uJOEAmE8N6uj6vncD4wVBMF0omA4UANnn9e5k+iX2GiU/3DWWq5OC8HTUoFEpmJPgJ9GP6y0KhcALlyfg3i43FOhmzz/nDjpft/z/mkA3ezk49VOEvtzUJgjCCmAacDuGEt9QDOW4T0RRfLD9mBeAZFEUp7ZvuwIZwBbgWSAGWAE8LYpil23mSUlJ4oEDB/6IjyIjA0BTq478qkbCPB27tY2XkemvCIJwUBTFpO6O6+slvrsxdN8tB3wwDOq+Bzxjcow/ENmxIYpitSAI04FlwAGgEsP802t/0j3LyNhEq1YSaTZILCMjY50+nUH92cgZlIyMjMwfT08zqL6+BiUjIyMj8/8UOUDJyMjIyPRJ5AAlIyMjI9MnkQOUjIyMjEyfRA5QMjIyMjJ9EjlAycjIyMj0SeQAJSMjIyPTJ5HnoEwQBKEUyPmr70NGRkamnxMqimK3bpJygJKRkZGR6ZPIJT4ZGRkZmT6JHKBkZGRkZPokcoCSkZGRkemTyAFKRkZGRqZPIgcoGRkZGZk+iRygZGRkZGT6JHKAkpGRkZHpk8gBSkZGRkamTyIHKBkZGRmZPsn/ATtjemysDFh0AAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import seaborn as sns\n", "\n", "#Target vs. Engineered Isoform Log Odds\n", "\n", "save_figs = False\n", "\n", "print(\"mean proportion = \" + str(round(np.mean(prob_pred), 4)))\n", "print(\"std proportion = \" + str(round(np.std(prob_pred), 4)))\n", "print(\"mean score = \" + str(round(np.mean(score_pred), 4)))\n", "print(\"std score = \" + str(round(np.std(score_pred), 4)))\n", "print(\"-------------------------\")\n", "\n", "f = plt.figure(figsize=(6, 4))\n", "\n", "sns.violinplot(data=[score_pred])\n", "\n", "plt.xticks([], [])\n", "plt.yticks(fontsize=14)\n", "\n", "plt.ylabel('Fitness Score (log)', fontsize=18)\n", "\n", "plt.tight_layout()\n", "\n", "if save_figs :\n", " plt.savefig(model_prefix + \"_fitness_score_violin.png\", transparent=True, dpi=150)\n", " plt.savefig(model_prefix + \"_fitness_score_violin.eps\")\n", " plt.savefig(model_prefix + \"_fitness_score_violin.svg\")\n", "\n", "plt.show()\n", "\n", "f = plt.figure(figsize=(6, 4))\n", "\n", "sns.stripplot(data=[score_pred], jitter=1.)\n", "\n", "plt.xlim(-0.25, 0.25)\n", "\n", "plt.xticks([], [])\n", "plt.yticks(fontsize=14)\n", "\n", "plt.ylabel('Fitness Score (log)', fontsize=18)\n", "\n", "plt.tight_layout()\n", "\n", "if save_figs :\n", " plt.savefig(model_prefix + \"_fitness_score_stripplot.png\", transparent=True, dpi=150)\n", " plt.savefig(model_prefix + \"_fitness_score_stripplot.eps\")\n", " plt.savefig(model_prefix + \"_fitness_score_stripplot.svg\")\n", "\n", "plt.show()\n" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Mean NT Entropy = 1.6129\n", "Std NT Entropy = 0.5337\n", "Number of unique hexamers = 2065\n", "Hexamer Entropy = 8.714980405681253\n", "Mean Binary Hexamer Entropy = 0.1628\n", "Std Binary Hexamer Entropy = 0.221\n" ] } ], "source": [ "#Calculate average/std nucleotide entropy\n", "\n", "nt_entropies = []\n", "for j in range(onehots.shape[1]) :\n", " if sequence_templates[0][j] == 'N' :\n", "\n", " p_A = np.sum(onehots[:, j, 0]) / n\n", " p_C = np.sum(onehots[:, j, 1]) / n\n", " p_G = np.sum(onehots[:, j, 2]) / n\n", " p_T = np.sum(onehots[:, j, 3]) / n\n", "\n", " nt_entropy = 0\n", " if p_A * p_C * p_G * p_T > 0. :\n", " nt_entropy = - (p_A * np.log2(p_A) + p_C * np.log2(p_C) + p_G * np.log2(p_G) + p_T * np.log2(p_T))\n", "\n", " nt_entropies.append(nt_entropy)\n", "\n", "nt_entropies = np.array(nt_entropies)\n", "\n", "print(\"Mean NT Entropy = \" + str(round(np.mean(nt_entropies), 4)))\n", "print(\"Std NT Entropy = \" + str(round(np.std(nt_entropies), 4)))\n", "\n", "\n", "#Calculate hexamer entropies\n", "\n", "hexamer_encoder = isol.NMerEncoder(n_mer_len=6, count_n_mers=True)\n", "\n", "hexamers = isol.SparseBatchEncoder(encoder=hexamer_encoder)([\n", " acgt_encoder.decode(onehots[i, :, :]) for i in range(onehots.shape[0])\n", "])\n", "\n", "hexamer_sum = np.ravel(hexamers.sum(axis=0))\n", "hexamers_probs = hexamer_sum / np.sum(hexamer_sum)\n", "n_nonzero_hexamers = len(np.nonzero(hexamer_sum > 0)[0])\n", "\n", "print(\"Number of unique hexamers = \" + str(n_nonzero_hexamers))\n", "\n", "hexamer_entropy = -1. * np.sum(hexamers_probs[hexamer_sum > 0] * np.log2(hexamers_probs[hexamer_sum > 0]))\n", "\n", "print(\"Hexamer Entropy = \" + str(hexamer_entropy))\n", "\n", "\n", "#Calculate average/std hexamer entropy\n", "\n", "nonzero_index = np.nonzero(hexamer_sum > 0)[0]\n", "\n", "hexamer_entropies = []\n", "for j in range(n_nonzero_hexamers) :\n", " p_on = len(np.nonzero(hexamers[:, nonzero_index[j]] > 0)[0]) / hexamers.shape[0]\n", " p_off = 1. - p_on\n", "\n", " hexamer_entropy = 0\n", " if p_on * p_off > 0. :\n", " hexamer_entropy = -(p_on * np.log2(p_on) + p_off * np.log2(p_off))\n", "\n", " hexamer_entropies.append(hexamer_entropy)\n", "\n", "hexamer_entropies = np.array(hexamer_entropies)\n", "\n", "print(\"Mean Binary Hexamer Entropy = \" + str(round(np.mean(hexamer_entropies), 4)))\n", "print(\"Std Binary Hexamer Entropy = \" + str(round(np.std(hexamer_entropies), 4)))\n", "\n" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "mean distance/nt = 0.4111\n", "std distance/nt = 0.061\n", "-------------------------\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/scipy/stats/stats.py:1713: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n", " return np.add.reduce(sorted[indexer] * weights, axis=axis) / sumval\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import editdistance\n", "\n", "#Calculate random pair-wise edit distances\n", "\n", "save_figs = False\n", "\n", "seqs = [\n", " acgt_encoder.decode(onehots[i, :, :]) for i in range(onehots.shape[0])\n", "]\n", "\n", "shuffle_index = np.arange(len(seqs))\n", "np.random.shuffle(shuffle_index)\n", "\n", "distances = []\n", "for i in range(len(seqs)) :\n", " if i == shuffle_index[i] :\n", " continue\n", " \n", " seq_1 = seqs[i]\n", " seq_2 = seqs[shuffle_index[i]]\n", " \n", " dist = editdistance.eval(seq_1, seq_2)\n", "\n", " distances.append(dist)\n", "\n", " import seaborn as sns\n", "\n", "distances = np.array(distances) / np.sum([1 if sequence_templates[0][j] == 'N' else 0 for j in range(len(sequence_templates[0]))])\n", "\n", "print(\"mean distance/nt = \" + str(round(np.mean(distances), 4)))\n", "print(\"std distance/nt = \" + str(round(np.std(distances), 4)))\n", "print(\"-------------------------\")\n", "\n", "f = plt.figure(figsize=(6, 4))\n", "\n", "sns.violinplot(data=[distances])\n", "\n", "plt.xticks([], [])\n", "plt.yticks(fontsize=14)\n", "\n", "plt.ylabel('Edit distance / nucleotide', fontsize=18)\n", "\n", "plt.tight_layout()\n", "\n", "if save_figs :\n", " plt.savefig(model_prefix + \"_edit_distance_violin.png\", transparent=True, dpi=150)\n", " plt.savefig(model_prefix + \"_edit_distance_violin.eps\")\n", " plt.savefig(model_prefix + \"_edit_distance_violin.svg\")\n", "\n", "plt.show()\n", "\n", "f = plt.figure(figsize=(6, 4))\n", "\n", "sns.stripplot(data=[distances], jitter=1.)\n", "\n", "plt.xlim(-0.25, 0.25)\n", "\n", "plt.xticks([], [])\n", "plt.yticks(fontsize=14)\n", "\n", "plt.ylabel('Edit distance / nucleotide', fontsize=18)\n", "\n", "plt.tight_layout()\n", "\n", "if save_figs :\n", " plt.savefig(model_prefix + \"_edit_distance_stripplot.png\", transparent=True, dpi=150)\n", " plt.savefig(model_prefix + \"_edit_distance_stripplot.eps\")\n", " plt.savefig(model_prefix + \"_edit_distance_stripplot.svg\")\n", "\n", "plt.show()\n" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "\n", "plot_n_seqs = 100\n", "plot_start = 70-49\n", "plot_end = 76+49\n", "\n", "save_figs = False\n", "\n", "flat_pwms = np.zeros((pwms.shape[0], pwms.shape[1]))\n", "for i in range(pwms.shape[0]) :\n", " for j in range(pwms.shape[1]) :\n", " max_nt_ix = np.argmax(pwms[i, j, :])\n", "\n", " flat_pwms[i, j] = max_nt_ix + 1\n", "\n", "flat_pwms = flat_pwms[:plot_n_seqs, plot_start:plot_end]\n", "\n", "cmap = colors.ListedColormap(['red', 'blue', 'orange', 'darkgreen'])\n", "bounds=[0, 1, 2, 3, 4, 5]\n", "norm = colors.BoundaryNorm(bounds, cmap.N)\n", "\n", "f = plt.figure(figsize=(4, 12))\n", "\n", "plt.imshow(flat_pwms, aspect='equal', interpolation='nearest', origin='lower', cmap=cmap, norm=norm)\n", "\n", "plt.xticks([], [])\n", "plt.yticks([], [])\n", "\n", "plt.tight_layout()\n", "\n", "if save_figs :\n", " plt.savefig(model_prefix + \"_diversity_seqs.png\", transparent=True, dpi=150)\n", " plt.savefig(model_prefix + \"_diversity_seqs.svg\")\n", " plt.savefig(model_prefix + \"_diversity_seqs.eps\")\n", "\n", "plt.show()\n" ] }, { "cell_type": "code", "execution_count": 57, "metadata": {}, "outputs": [], "source": [ "#Get latent space predictor\n", "saved_predictor_w_dense = Model(\n", " inputs = saved_predictor.inputs,\n", " outputs = saved_predictor.outputs + [saved_predictor.get_layer('dropout_1').output]\n", ")\n", "saved_predictor_w_dense.compile(loss='mse', optimizer=keras.optimizers.SGD(lr=0.1))\n" ] }, { "cell_type": "code", "execution_count": 58, "metadata": {}, "outputs": [], "source": [ "#Load GENESIS models and predict sample sequences\n", "\n", "batch_size = 64\n", "\n", "n = 4096#10000\n", "n_slack = 0#0.05 * n\n", "\n", "n_ceil = int((n + n_slack) / batch_size) * batch_size\n", "if n_ceil < n :\n", " n_ceil += batch_size\n", "\n", "sequence_class = np.array([0] * n_ceil).reshape(-1, 1) #np.random.uniform(-6, 6, (n, 1)) #\n", "\n", "noise_1 = np.random.uniform(-1, 1, (n_ceil, 100))\n", "noise_2 = np.random.uniform(-1, 1, (n_ceil, 100))\n", "\n", "pred_outputs = generator.predict([sequence_class, noise_1, noise_2], batch_size=batch_size)\n", "\n", "_, _, _, optimized_pwm, _, sampled_pwm, _, _, _ = pred_outputs\n", "\n", "pwms = optimized_pwm[:, :, :, 0]\n", "onehots = sampled_pwm[:, 0, :, :, 0]\n", "\n", "#Make predictions using black box model\n", "fake_lib = np.zeros((optimized_pwm.shape[0], 13))\n", "fake_lib[:, 5] = 1.\n", "fake_d = np.ones((optimized_pwm.shape[0], 1))\n", "\n", "iso_pred, _, dense_pred = saved_predictor_w_dense.predict(x=[sampled_pwm[:, 0, ...], fake_lib, fake_d], batch_size=batch_size)\n", "\n", "prob_pred = np.ravel(iso_pred)\n", "score_pred = np.log(prob_pred / (1. - prob_pred))\n", "\n", "sort_index = np.argsort(score_pred)[::-1]\n", "\n", "pwms = pwms[sort_index][:n]\n", "onehots = onehots[sort_index][:n]\n", "score_pred = score_pred[sort_index][:n]\n", "prob_pred = prob_pred[sort_index][:n]\n", "dense_pred = dense_pred[sort_index][:n]\n" ] }, { "cell_type": "code", "execution_count": 59, "metadata": {}, "outputs": [], "source": [ "#Save sequences to file\n", "with open(model_prefix + \"_4096_sequences.txt\", \"wt\") as f:\n", " for i in range(onehots.shape[0]) :\n", " seq = acgt_encoder.decode(onehots[i])\n", " \n", " f.write(seq + \"\\n\")\n" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Upsampling = 1X.\n", "mean proportion = 1.0\n", "std proportion = 0.0\n", "mean score = 10.7245\n", "std score = 0.7505\n", "-------------------------\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/home/ubuntu/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/scipy/stats/stats.py:1713: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n", " return np.add.reduce(sorted[indexer] * weights, axis=axis) / sumval\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "mean distance/nt = 0.3829\n", "std distance/nt = 0.0562\n", "-------------------------\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Upsampling = 10X.\n", "mean proportion = 1.0\n", "std proportion = 0.0\n", "mean score = 12.0131\n", "std score = 0.2657\n", "-------------------------\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "mean distance/nt = 0.3379\n", "std distance/nt = 0.0603\n", "-------------------------\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Upsampling = 100X.\n", "mean proportion = 1.0\n", "std proportion = 0.0\n", "mean score = 12.5776\n", "std score = 0.1731\n", "-------------------------\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "mean distance/nt = 0.3039\n", "std distance/nt = 0.062\n", "-------------------------\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "\n", "#Load GENESIS models and predict sample sequences\n", "\n", "n = 4096\n", "\n", "upsamples = [1, 10, 100]\n", "\n", "for upsample in upsamples :\n", "\n", " print(\"Upsampling = \" + str(int(upsample)) + \"X.\")\n", " \n", " n_ceil = int((n * upsample) / batch_size) * batch_size + batch_size\n", "\n", " sequence_class = np.array([0] * n_ceil).reshape(-1, 1) #np.random.uniform(-6, 6, (n, 1)) #\n", "\n", " noise_1 = np.random.uniform(-1, 1, (n_ceil, 100))\n", " noise_2 = np.random.uniform(-1, 1, (n_ceil, 100))\n", "\n", " pred_outputs = generator.predict([sequence_class, noise_1, noise_2], batch_size=batch_size)\n", "\n", " _, _, _, optimized_pwm, _, sampled_pwm, _, _, _ = pred_outputs\n", "\n", " pwms = optimized_pwm[:, :, :, 0]\n", " onehots = sampled_pwm[:, 0, :, :, 0]\n", "\n", " #Make predictions using black box model\n", " fake_lib = np.zeros((optimized_pwm.shape[0], 13))\n", " fake_lib[:, 5] = 1.\n", " fake_d = np.ones((optimized_pwm.shape[0], 1))\n", "\n", " iso_pred, _ = saved_predictor.predict(x=[sampled_pwm[:, 0, ...], fake_lib, fake_d], batch_size=batch_size)\n", "\n", " prob_pred = np.ravel(iso_pred)\n", " score_pred = np.log(prob_pred / (1. - prob_pred))\n", "\n", " sort_index = np.argsort(score_pred)[::-1]\n", "\n", " pwms = pwms[sort_index][:n]\n", " onehots = onehots[sort_index][:n]\n", " score_pred = score_pred[sort_index][:n]\n", " prob_pred = prob_pred[sort_index][:n]\n", "\n", " #Save sequences to file\n", " with open(model_prefix + \"_4096_sequences_upsampling_\" + str(int(upsample)) + \".txt\", \"wt\") as f:\n", " for i in range(onehots.shape[0]) :\n", " seq = acgt_encoder.decode(onehots[i])\n", "\n", " f.write(seq + \"\\n\")\n", "\n", "\n", " print(\"mean proportion = \" + str(round(np.mean(prob_pred), 4)))\n", " print(\"std proportion = \" + str(round(np.std(prob_pred), 4)))\n", " print(\"mean score = \" + str(round(np.mean(score_pred), 4)))\n", " print(\"std score = \" + str(round(np.std(score_pred), 4)))\n", " print(\"-------------------------\")\n", "\n", " f = plt.figure(figsize=(6, 4))\n", "\n", " sns.violinplot(data=[score_pred])\n", "\n", " plt.xticks([], [])\n", " plt.yticks(fontsize=14)\n", "\n", " plt.ylabel('Fitness Score (log)', fontsize=18)\n", "\n", " plt.tight_layout()\n", " plt.show()\n", "\n", " \n", " seqs = [\n", " acgt_encoder.decode(onehots[i, :, :]) for i in range(onehots.shape[0])\n", " ]\n", "\n", " shuffle_index = np.arange(len(seqs))\n", " np.random.shuffle(shuffle_index)\n", "\n", " distances = []\n", " for i in range(len(seqs)) :\n", " if i == shuffle_index[i] :\n", " continue\n", "\n", " seq_1 = seqs[i]\n", " seq_2 = seqs[shuffle_index[i]]\n", "\n", " dist = editdistance.eval(seq_1, seq_2)\n", "\n", " distances.append(dist)\n", "\n", " distances = np.array(distances) / np.sum([1 if sequence_templates[0][j] == 'N' else 0 for j in range(len(sequence_templates[0]))])\n", "\n", " print(\"mean distance/nt = \" + str(round(np.mean(distances), 4)))\n", " print(\"std distance/nt = \" + str(round(np.std(distances), 4)))\n", " print(\"-------------------------\")\n", "\n", " f = plt.figure(figsize=(6, 4))\n", "\n", " sns.violinplot(data=[distances])\n", "\n", " plt.xticks([], [])\n", " plt.yticks(fontsize=14)\n", "\n", " plt.ylabel('Edit distance / nucleotide', fontsize=18)\n", "\n", " plt.tight_layout()\n", " plt.show()\n", " " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Environment (conda_tensorflow_p36)", "language": "python", "name": "conda_tensorflow_p36" }, "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.6.5" } }, "nbformat": 4, "nbformat_minor": 2 }