{ "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.keras as iso\n", "\n", "from seqprop.visualization import *\n", "from seqprop.generator import *\n", "from seqprop.predictor import *\n", "from seqprop.optimizer import *\n", "\n", "from definitions.aparent_all_libs import load_saved_predictor\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", "import warnings\n", "warnings.simplefilter(\"ignore\")\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", "#Define target isoform loss function\n", "def get_isoform_loss() :\n", " \n", " def loss_func(predictor_outputs) :\n", " pwm_logits, pwm, sampled_pwm, iso_pred, cut_pred, iso_pred_score, cut_score_pred = predictor_outputs\n", "\n", " #Specify costs\n", " iso_loss = -1.0 * K.mean(iso_pred_score[..., 0], axis=0)\n", " \n", " #Compute total loss\n", " total_loss = iso_loss\n", "\n", " return K.reshape(K.sum(total_loss, axis=0), (1,))\n", " \n", " def val_loss_func(predictor_outputs) :\n", " pwm_logits, pwm, sampled_pwm, iso_pred, cut_pred, iso_pred_score, cut_score_pred = predictor_outputs\n", "\n", " #Specify costs\n", " iso_loss = -1.0 * K.mean(iso_pred_score[..., 0], axis=0)\n", " \n", " #Compute total loss\n", " total_loss = iso_loss\n", "\n", " return K.reshape(K.mean(total_loss, axis=0), (1,))\n", " \n", " return loss_func, val_loss_func\n", "\n", "\n", "def get_nop_transform() :\n", " \n", " def _transform_func(pwm) :\n", " \n", " return pwm\n", " \n", " return _transform_func\n", "\n", "class ValidationCallback(Callback):\n", " def __init__(self, val_name, val_loss_model, val_steps) :\n", " self.val_name = val_name\n", " self.val_loss_model = val_loss_model\n", " self.val_steps = val_steps\n", " \n", " self.val_loss_history = []\n", " \n", " #Track val loss\n", " self.val_loss_history.append(self.val_loss_model.predict(x=None, steps=self.val_steps)[0])\n", " \n", " def on_batch_end(self, batch, logs={}) :\n", " #Track val loss\n", " \n", " val_loss_value = self.val_loss_model.predict(x=None, steps=self.val_steps)[0]\n", " \n", " self.val_loss_history.append(val_loss_value)\n", " \n", " #print(\"mean(\" + self.val_name + \") = \" + str(np.mean(val_loss_values)))\n", "\n", "#Sequence optimization monitor during training\n", "class StoreSequenceMonitor(Callback):\n", " def __init__(self, seqprop_model, sequence_encoder, run_dir=\"\", run_prefix=\"\", store_every1=5, store_every2=100, swap_iter=100, val_steps=1) :\n", " self.seqprop_model = seqprop_model\n", " self.val_steps = val_steps\n", " self.sequence_encoder = sequence_encoder\n", " self.run_prefix = run_prefix\n", " self.run_dir = run_dir\n", " self.edit_distance_samples = []\n", " self.store_every1 = store_every1\n", " self.store_every2 = store_every2\n", " self.store_every = store_every1\n", " self.swap_iter = swap_iter\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", " sampled_pwm = self.seqprop_model.predict(x=None, steps=self.val_steps)[2]\n", " \n", " seqs = []\n", " for i in range(sampled_pwm.shape[1]) :\n", " for j in range(sampled_pwm.shape[0]) :\n", " seqs.append(self.sequence_encoder.decode(sampled_pwm[j, i, :, :, 0]))\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.val_steps) + \"_steps.txt\", \"a+\") as f:\n", " for i in range(len(seqs)) :\n", " f.write(seqs[i] + \"\\n\")\n", " \n", " def on_batch_end(self, batch, logs={}) :\n", " \n", " if batch > self.swap_iter :\n", " self.store_every = self.store_every2\n", " \n", " if batch % self.store_every == 0 :\n", " seqs = self._sample_sequences()\n", " self._store_sequences(seqs, batch)\n", "\n", "#Function for running SeqProp on a set of objectives to optimize\n", "def run_seqprop(run_prefix, sequence_templates, loss_funcs, val_loss_funcs, transform_funcs, n_sequences=1, n_samples=1, n_valid_samples=1, library_context='simple', eval_mode='sample', normalize_logits=False, n_epochs=10, steps_per_epoch=100) :\n", " \n", " n_objectives = len(sequence_templates)\n", " \n", " seqprop_predictors = []\n", " valid_monitors = []\n", " train_histories = []\n", " valid_histories = []\n", " \n", " for obj_ix in range(n_objectives) :\n", " print(\"Optimizing objective \" + str(obj_ix) + '...')\n", " \n", " sequence_template = sequence_templates[obj_ix]\n", " loss_func = loss_funcs[obj_ix]\n", " val_loss_func = val_loss_funcs[obj_ix]\n", " transform_func = transform_funcs[obj_ix]\n", " \n", " #Build Generator Network\n", " _, seqprop_generator = build_generator(seq_length=205, n_sequences=n_sequences, n_samples=n_samples, sequence_templates=[sequence_template * n_sequences], batch_normalize_pwm=normalize_logits, pwm_transform_func=transform_func, validation_sample_mode='sample')\n", " _, valid_generator = build_generator(seq_length=205, n_sequences=n_sequences, n_samples=n_valid_samples, sequence_templates=[sequence_template * n_sequences], batch_normalize_pwm=normalize_logits, pwm_transform_func=None, validation_sample_mode='sample', master_generator=seqprop_generator)\n", " for layer in valid_generator.layers :\n", " layer.name += \"_valversion\"\n", " \n", " #Build Predictor Network and hook it on the generator PWM output tensor\n", " _, seqprop_predictor = build_predictor(seqprop_generator, load_saved_predictor(model_path, library_context=library_context), n_sequences=n_sequences, n_samples=n_samples, eval_mode=eval_mode)\n", " _, valid_predictor = build_predictor(valid_generator, load_saved_predictor(model_path, library_context=library_context), n_sequences=n_sequences, n_samples=n_valid_samples, eval_mode='sample')\n", " for layer in valid_predictor.layers :\n", " if 'aparent' in layer.name and '_valversion' not in layer.name :\n", " layer.name += \"_valversion\"\n", " \n", " #Build Loss Model (In: Generator seed, Out: Loss function)\n", " _, loss_model = build_loss_model(seqprop_predictor, loss_func)\n", " _, valid_loss_model = build_loss_model(valid_predictor, val_loss_func)\n", " \n", " #Specify Optimizer to use\n", " #opt = keras.optimizers.SGD(lr=0.5)\n", " #opt = keras.optimizers.SGD(lr=0.1, momentum=0.9, decay=0, nesterov=True)\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", " def get_logit(p) :\n", " return np.log(p / (1. - p))\n", " \n", " #Specify callback entities\n", " measure_func = lambda pred_outs: np.mean(get_logit(np.expand_dims(pred_outs[0], axis=0) if len(pred_outs[0].shape) <= 2 else pred_outs[0]), axis=0)\n", " \n", " #train_monitor = FlexibleSeqPropCutMonitor(predictor=seqprop_predictor, plot_on_train_end=False, plot_every_epoch=False, track_every_step=True, measure_func=measure_func, measure_name='Isoform Log Odds', plot_pwm_start=70-50, plot_pwm_end=76+50, sequence_template=sequence_template, plot_pwm_indices=np.arange(n_sequences).tolist(), figsize=(12, 1.25))\n", " valid_monitor = FlexibleSeqPropCutMonitor(predictor=valid_predictor, plot_on_train_end=True, plot_every_epoch=False, track_every_step=True, measure_func=measure_func, measure_name='Isoform Log Odds', plot_pwm_start=70-50, plot_pwm_end=76+50, sequence_template=sequence_template, plot_pwm_indices=np.arange(n_sequences).tolist(), figsize=(12, 1.25))\n", " \n", " train_history = ValidationCallback('loss', loss_model, 1)\n", " valid_history = ValidationCallback('val_loss', valid_loss_model, 1)\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", " store_seq_monitor = StoreSequenceMonitor(valid_generator, acgt_encoder, run_dir=\"./seqprop_samples/\" + run_prefix + \"/\", run_prefix=\"intermediate\", val_steps=1)\n", " \n", " callbacks =[\n", " #EarlyStopping(monitor='loss', min_delta=0.001, patience=5, verbose=0, mode='auto'),\n", " valid_monitor,\n", " train_history,\n", " valid_history,\n", " store_seq_monitor\n", " ]\n", " \n", " #Fit Loss Model\n", " _ = loss_model.fit(\n", " [], np.ones((1, 1)), #Dummy training example\n", " epochs=n_epochs,\n", " steps_per_epoch=steps_per_epoch,\n", " callbacks=callbacks\n", " )\n", " \n", " valid_monitor.predictor = None\n", " train_history.val_loss_model = None\n", " valid_history.val_loss_model = None\n", " \n", " seqprop_predictors.append(seqprop_predictor)\n", " valid_monitors.append(valid_monitor)\n", " train_histories.append(train_history)\n", " valid_histories.append(valid_history)\n", "\n", " return seqprop_predictors, valid_monitors, train_histories, valid_histories\n" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "#Specfiy file path to pre-trained predictor network\n", "\n", "save_dir = os.path.join(os.getcwd(), '../../../aparent/saved_models')\n", "model_name = 'aparent_plasmid_iso_cut_distalpas_all_libs_no_sampleweights_sgd.h5'\n", "model_path = os.path.join(save_dir, model_name)\n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "import random\n", "\n", "def set_seed(seed_value) :\n", " # 1. Set the `PYTHONHASHSEED` environment variable at a fixed value\n", " os.environ['PYTHONHASHSEED']=str(seed_value)\n", "\n", " # 2. Set the `python` built-in pseudo-random generator at a fixed value\n", " random.seed(seed_value)\n", "\n", " # 3. Set the `numpy` pseudo-random generator at a fixed value\n", " np.random.seed(seed_value)\n", "\n", " # 4. Set the `tensorflow` pseudo-random generator at a fixed value\n", " tf.set_random_seed(seed_value)\n", "\n", " # 5. Configure a new global `tensorflow` session\n", " session_conf = tf.ConfigProto(intra_op_parallelism_threads=1, inter_op_parallelism_threads=1)\n", " sess = tf.Session(graph=tf.get_default_graph(), config=session_conf)\n", " K.set_session(sess)\n" ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Running optimization experiment 'Alien1 Max Isoform'\n", "Optimizing objective 0...\n", "Epoch 1/1\n", "20000/20000 [==============================] - 334s 17ms/step - loss: -73.6884\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoAAAACsCAYAAADrPB1HAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzsnXd8HMXZ+L/P9VO1ZEmWXGTZcu+4YeOC6Z03ECCBUAyhhZAAbyCFkDdA4JcEkpBCSCAUEwid0DHdBowx3Q132bJlFavXO12d3x+zJ51Op2ZLlmz2+/msfTszuzu7mtl9ZuYpopTCxMTExMTExMTkm4OlvytgYmJiYmJiYmJycDEFQBMTExMTExOTbximAGhiYmJiYmJi8g3DFABNTExMTExMTL5hmAKgiYmJiYmJick3DFMANDExMTExMTH5hmEKgH2EiFhE5H4RqRIRJSJL+rtOhyoi8qqILOuizEYRufXg1MjEZGAjImkisk9E8o39JcZ7KKOTY7os043r/lBEXtnf400GHiJyq4hsPEjXKhSRG7so0ygiSw9GfQ53TAHQQESWicirvXjKU4FLgTOAHGB1L557v+iNF/wBXHuYiDwgIntFxC8ixSLyLxEZfrDrYtI3GH1IGVtARHaKyB9EJNHILxWRW2KOucUof05M+uMi8qHxO9Ju60UkIabcxKhrdibcRNctelvTg/vLM46Z3d1j+pGbgdeVUgU9OGY1+l1VBSAiS0WksYfXfRCYJSKLenicSQ+Ias+/iknvt3d8T+hEqJwD3HcQrj9dRF4SkTIRaRaRPSLyvIiM7OtrDyRMAbDvGAOUKqVWK6XKlFL+/TmJiNh7uV4HHREZBXwOTAEuQT+bC4HJwGciktdvlTPpbd5BCxGjgVuAa4A/GHkrgCUx5Y8BijpIfy8mrRY4Nybt+8CeHtYteju1m8d2GxFx9PY5e3j9BOBy4KGeHKeU8hvvqv2ODqCU8gFPAD/e33OYdJtm4CYRyezvivQWSqkKpZSnL69hPK93gUbgNGACcBFQAKT05bUHGqYA2AEiMlVE3jVmHRpFZJ2IHBOVv1hEPjFGD/tE5J7Ii99YrrwHyDVGY4VGulNE/myUbxaRNSKyMOqckdHbqSLyqYj4gZMioyURucSYIm8SkUdExCEi14hIkbHU/CcR2e+/qehl618Z5/OJyAYR+Z+YMkeKyJdG/b8y6trVEvffgTBwvFLqXaXUHqXUCuB4I/3vUedPMEa3jcZzujlOPbOM0ZtXRHaLyGVxylwlItuMelaKyJsiYtvPR9PriIhLRI4RkUuNv+G5YizXHeL4DCGiSCn1BPAf4FtG3grgqKh+4gSOAn6LFvgw0scBQ2kvAC4DLosqZ0e/uJf1sG7RW3XU+ZSIXCkizxp9bKeIXBh1/C7j/8+MsiuN45aJVlP4mYjsBfYa6Wki8qiI1Bht9R0RmRx1vaVGOz8jqq2uEJHRRn6eiIQlZsZRRK4w2nRHguapgAI+ipM3T0TWGtf6QkRmRZ23ZfbI6M+PAInSOlt6q1HubBFZb9xTtYi8LyJDoq7xMnCmxMzWmvQ6K4BC4FcdFZA4M4ISZyZbRCaIyMsiUme0yY9FZGon571URDYZ7WibiNwQ/e0RkVwReUFEGoztv2Ks9ohevv01MDmqbS018tosAYvIGBFZaVxnq4icHqcuw0TkKaOf1YjIayIytpPntgBIAy5VSn2hlCpUSr2vlPqpUmqDcc6nROSfUde4w6jnvKi0osj7QUTmiMhbRr+sF5FVIjI/pp5KRK416ucR/e26MKbM/xnpPtGzk//u5D4OHKWUuekB7zLg1aj9DcDj6NHBGOAsYL6RNwxoAv4JTAROB8qAPxr5qcBt6JmNbCDTSP8LUIoedUwE/oUeheQY+UvQL+4NwInoWZRM4Faj3H/Rs2gnGftvoF/SE436BYBvd3KPkfNndJB/A1APXACMA24HQsAMIz8JqECP8CcDJwBfG+dc0sE509FC3s0d5P/SyE8z9u8Dio17nAI8a9RpWdQxrxvXXQAcAaw0nsetRv5sIAh8DxgJTDfuzTYA2tkC4BnAa9SxCi0weIxnvR24CUju77oeaB8y0v4KVBq/xxhtZbGxf7TRRxIBHzDESL/KeB7OmHY7znhu+Ub6WehR+zGdteuO6hanjDL+Fhcadf0t4Adyjfw5RpmT0P06PercDWhhdwow1Uh/CdgCLAamogWjIsBt5C9F99nPo9ryB8BaQIwybwL3xdTzY+CeTu7jL8DbMWmRZ7glpm+VAgkxZTIAB3Ad+j2XbWxJxv9+4CdAnnGeyyN/O+M8CUZbPq6/2+ThukXaM1rY90f1iZa/Ybx9Iy3PSJtt7A8FKo32OtfoZxfS+t6/FdgYdfwVRrs5BxiFVnMqA6418i3AV2iVgtnGtsZo5wK40asCW6LaVqRPFAI3Rp1ng9EnjjD6yOdGn1ka1da2Gc9jGvp7/SCwO9Ku4zy7ecb9XxDpZ3HKXA1sidpfhf72/dzYj7zLhhv7x6IHoxONOtwL1ACDo86h0O/7q4xnHPn2Rf4O30Z/604Dco3ndm2ftqP+bsgDZaO9AFgPXNJB2TvRH2pLVNpS9Ecs8jK9ESiMyk9Ed9SLo9Ks6A/YHcb+EqORfDvmereiP3ypUWnPGQ3SEZW2Eri3k3uMnL8jAbAY+L+YtJXA48bvq4DqSGc10i6gcwHwSCP/rA7yzzLy56I/MD7ge1H5Seilv2XG/jij/IKoMiPRH5xbjf2zgToGmBCFFgCKgbuBRdHP0cgfjV4ifwP9gj2hv+vcw/uL7UNz0R+Wp6PS9gC/jmrXkba1GviO8fsp4J147RZ4GrjTSH8VvczcabuOqlsQPVCI3n4fVUYBv43at6EF0QuN/TyiPpwx567AEFiNtLFECbtGWqrRLi839pd20paPN/bPQX9IXMb+ROOYKZ3c64vAozFpkWcUr29dHlMmI6p+jTHnmWmUGdlFW6gGvt/fbfJw3aL7Gnom8KkO/obt+kZsO0Z/z3YT9S2JudattBUA9wAXxZS5Hthk/D7BaMN5UfmjaV0FanfOqHKFtAqAJxrnyY3KX2jUfamxfxn6WyxRZaxoQeu8Tp7fnWhBsgZ4C60zOzIqf4JxnRy0kOkDfga8aeRfDuzo5PyCfodfGJWmgH/FlHuH1nfg/wJbAfvBakfmEnDH/Al4UETeE5FfisiEqLyJwBqlVDgqbRV61Dymg/PlA3ailmWUUiH0aH5STNnP4xy/RylVF7W/D9im2uoW7gOyOrmnDhGRFPRIMHbZaFVU/SagO603Kv+T/bleB+Sjn+HHkQSlVCN6FBhhIvpF8mlUmd1ASVSZt9EvtF0i8h/RS+fJvVjP/eUNYJRS6ial1IcxzxGl1E6l1KNKqZPRy+OHIicbS0jN6L/jB8CPovJX0Lrcewx6gIHxfyR9iVEuHg8BF4vICPSHZlkP6vYBMCNmuzumzPrID6VUEC3YdadPbVRa/y1CpJ1Gt+U6dFuO7u8dteVImZfQA8ezjf3LgE+VUp1ZZbrR+mHxiNe3Yt8/nbEO/dHaKFpp/gcSXwfNa9TDpO/5GXBu9HJ+DzkCWKW6oadu/K1HAPcb/bxRtKHQ79Dvb9Btv0QpVRg5Tim1k7btujtMBIqVUtE6vp+g+0yEWehZyIaoutShl3g7VKlRSv0SPfN4JboPfB/YJCLHGflb0LOaS9BqKgXowecC0aonS2h9d0XUku43lsPr0CsCWeiZvGg+jrMfeSbPAi70d+sh0WpBzo7uoTcwBcAOUErdiv7DvIhuAOsljq5ZvEP353Ix+01xygTiHBMvrS/+pvtzTxF2GMd31PEnGfk7eqtOSqkG9EzFeejR6i+ALSIytIfX6FWUUvd15yVrlP1aKfV2X9epD4gIWePRs1ZnK6XKo/JXoPXQ0tCzwyuN9PeBJSIyERhCe/2/CO+gPwD/Bt5TSu3tQd08SqkdMVtlTJn97VPx+mxHxLbdztpyAH2vl4nWYb2Iro07KtEfwF7HGLSeaGzr0R/O7SIyPaZoOlp4PqiIiFtEjpdvkDWnUupT4HngrjjZEWFJotIOxLAw0heupu1AagpaLagrDuRb0lF91tJ+YDcOuL/TiihVpZR6Vin1E7SwWUhbfcr30YPSJcAKQ6CtRKuCHE2UAAg8aqTfgJYXZqDVSbptEKaUKkK/N69Cr0D+EfhCDC8KfUG3hAXRxgHRCp7ZInK5iCzoq4oNBJRS25VSf1VKnYZ+6V5uZG1Gf8Sin99C9Ei9I7cLBUZ+yzMTESswH9jU23XvKUqpevQILfZvupDW+m0BpohI9Mh+bhfnrULrMV0TqxRu7P8QWK60Mn4B+gMcrWibiH65RNiCbrdzo8rkomcvo68bVEq9p5T6BVo3JBGtqzkgEJHM6JkT0UZHd4jI+f1Zr14gImTtNoSXWFYATrQOWYVSKiL4f4QesX8PvTT7WbyTG7Puy9Av5R5ZufYCEeHd2o2ym9HttEUR3Jhln0rb/t5RW94cVeZB9IfoGiAZvUTeGV/R8YArXt/a3EFZP3HuVWk+Vkrdhv7olQDfiTpvPnom48su6nnAiDbAucb47UDPpr4FbBWRU/r6+gOIm9FqJSfHpEeE8JyotBkxZb4CFko3rNeVUvvQf+/8OIOpSF/eDAyVKO8Oog2bhtLa9uO2rRg2A8OM2f4Ic2krt3yJXnWrjFOfarqJMTAvQKtFRFhJqwC4MirtCmA4bQXAhcDflFKvKaW+Rs8ARj/zCPPi7Lf0P6VUs3GOG9B9azLtv8m9Rndni17DWMYRkST0EuXdwEoRubiP6tZvGKPIv4u2oMoTkSNpKwjdh27M94n2Q3Yaegr8XtWBCbtSqgn4B/B70ZazE439IRwEv0cxTBGRGTGbBf03vVFEzheRcSJyO/qlEnHj8QRaJ+NfIjJJRI5Hv3ig85HdtWh9qndE5FgRGSHayvBt9Mj0WmhZknoI/YxOEG0x+TBRLwql1Fb0Uur9IjJfRGagBYKW5VQROV1ErhORI4yZgAvQH86OPnT9wTNo5WlEW+h9gNaH/KeI/KQ/K9aXGEucu9BuQt6PSm8EvjDSPzSWXzviDrRx1H97eHmnMXiN3nriQqMc3c5OEpEhIpLaUUGl1Hb08u39IrJItEXl4+iR/RNRRYPAn6Pa8qNoA6d3os61Fa2KcTfwnDFY64w3gYkiMjhO3i0xfcsfU59oCgGXUT5DtIX+PNG+G+cYwuqZ6CXBaKF2EbDTeAZ9zUloAwOMuiSjl/ZuNbZvBIbw9QDacCeaHWjDo1uNd/qJaL3ZaO5DCz7PGH/XMcY3IFZQjPBr4KeiLX/Hi8gUEblYRH5h5L+Dnh3+j4jMFm1t/B+0sBaZ2S8ERorITKNtxVvqfAc94P+38Y2aj/auEf1u+A9a9eklETlaREaJ9tDxR+nAEtj4Pjxu/D/OuIcb0QY1L0QVXYkWLufSVgC8ECiIWX3YBlxofBfnoAdp8VZ7zhZtxT/WeF7HAX826rXUmFibKtp12qXoCZG+60fdURREjyIilm0Xozu7Ha0kvL63FRP7Y6OtUq0D/VIsRCt/lqA7V0pU+cVofQQfugHeQ1sl8DZGIEaa0/hj7zOOWwMsjMpfQhxlduIozKKtjFbGpD2F/kB0dI+R88fbktADgl+hXxh+tG7Et2LOMQ89YvQZ/3/bOP7ILp7vCLTVczG6UZegZzaGx5RLRC95NaI/uL9CK/sviyozBG1Q4TXqejmwkVYjkIXomaYqo8xGtMl/v7ezqHuoAiYZv68GPjN+/w9at7Pf63ggfaiLcg8ZbebymPTfGek3dtBuOzJe6jQ/qm7x2v3eqDIKOCfmuMLo+hhtbQ96ILSys/tGL8M+ilY096I/aJOj8pca7fx/0C95H1ooHhPnXBcTY1TSxTP+GPhhnGd0Jvrj7EN/kOd09hzRg9RKI/1W9FLZclrfYTuAn8Zc+00Ma8mD0OaaabXEfJBWTwx5QEN/94k+vO92bQ6tc9YQ5294FHqZ1Gu0i9OIMWZCzzS9brTHBrRR1hQj71baf3/ON9pPs9G+VwHfjcrPRatPNRjbC0S969HfwueMY6ONOmL72zijT/iMPnKmUcelUWWGoL1hlBvldqEHNx29L0ajPXhsQatu1BnP53pirILRhhzRBjB5Rn0fjCk3HS0PeNEziRcR9U0yyij0ZMcbRrk9RBmaot1lfYw2zGpCr4Kc3pftKOJqoFNExAuMU0oVicjjwG6l1C+NEeBmpVSfrVGbDGxE+wl8AchS7fWpTDpARDzABKXUHhF5DlinlPqNsdyxTSllKtAf5oj2fXavUiqpG2V/hraqHdfNc5+MdgczSWm9vYOCiExBO9kdp9oarfXV9QrRA6i30cLDlUqp5UY9PlBKpfd1HUxMuoOIKOBcpdRz/V2XCN1dAt6Dtn5JRE+5R5TT09FuEky+IYi2qF1kLI2fjp7RfMUU/nrMdvRywAi0Qv1bRvoQ9AjQxAQRSTKWa69DC3TdQin1BtrB+sEOtTgU7eqqz4U/g4fR1pkb0bOy7xrpR6JneExMTDqgu5ER/gQ8hp563Y3WVwK9DLqho4NMDkuGoJ1c56DN5F9DuyEw6Rm3AU+iLb3eVUpF3OmchF5aNzEBrepxPlrloVOrxliUUn/tkxp1fs23ui7Vq9e7XUS+Ri85PqtareyDwO8PZl1MTA41urUEDGAoco5Ae5hvNNJOA2qVUvFCDpmYmHSC6PBZQ9HLv2Ej7UigTmk/VCYmJiYmJn1CtwVAExOT3kNE/g/4g4qxGhftYucmpdTt/VMzE5NDCxGZiVbgj7i+2YwOldfnbmhMTA5lOhQAjQ9UtxhoH6uMjAyVl5fX39UwGaCosEIsEj9P6XyLVed/8cUXlUqpnrgK6RYiEkLHgC6PSR8MlCuluuNr7qBi9iuT3qQ3+paIfA/DKTitURbmoWOzLlVKPX5gtTw4mH3LpLfoSb/qTAfw3Jj9keiYeJGQW0PRBiCFwIASAPPy8vj883jR1EwOZcKhMA3VPlIztYFsyfZa9u2qJ31oIulDE3En22ms8bH+3SI8DX5OuHQyJdtrSUh1sH7FXsYfOYSkNBeP3fIxSWlOGmt82guhgoRUB566VrdNkfwvvjhudx/djnHldhyBjqM64DD7lcmBoJTC7/fj8XjweDwMHz68N/rWncCvlFL/LzrR8LF2B9r34oDH7Fsm4bCivsLL/q7KbvqolEBzkGMunNjtftWhAKiUmhr5LSKXov1QXaKMuHyGC5hH0I4YTUz2m3XvFrHxg2LOvmkmrgQ7O74sJyc/FavNQl2ll61ryhg8LIkdn++jeFst4+YOYdun+7o8b8GXK9vsb1rVGi64scYI22r0tWjhr01+LyMiET9dCthpuAaIYEVHUPhnn1zcxKQXCQQCLcJc3K2hgabaWpoaG/E2N+MNBukDfzSZaKfqsTxL27BeJiYDjlAozLvLNuPzBNnzddVBv353rYD/D+0QuCUos+G/7Cdob/cP90XlTA5fGmuaaar1M2RUCque1Y7OH75xFRaLEA53PgLqjvA3gLkWPfv3MPBLtBPSCH608/DYgOEmJoCeRfP5fDQ1NdHY2Njm/6amJgKBAFarFbvd3m4LiZXmIHhD4AuBL6jwBsEbVHgCYTzNfjzNPhp9jTT7Ggn6PYSDXiTox66COFQIuwrjUGEcSnX749FSd0CFBYUNJa7eeiQr0A6sY2OJLyEq0oyJSX9TWlBHTWnbkOErHm9v65eU5sTm2D8NoJSMnvWr7vbhIUA8x7QuIKNHVzQ57PHU+9m0qoRJC4eSkNIaXjLgD1GyrZZX713X4bFdCX+HOkqpRwFEZBewWsWPl2vyDSYUClFZWUlxcTFlpaXUlJfTUFdHk8eDx+/vi1m0FpzGFg+/1YbH6aLB5qDZ7sBvsxOyOAnanPhtTvx2J36bA7/Nhs9mx2+1ErRYCFgFv8WCzwpKonRve0dxaDnwW8NLRSQk3DzgbHT4s7MjBZVSPQ0daGLSbZRSvP3wJgrXt3eJG/B13GsVYdKHu5h1Sh6pmW5SMg4wBsCPu1+0uwLg2+j4r1egw5ModHy8+2l1Cm1iAsCb/9pIyfZaPnl5J1f+5Wg+eWUnDZXN7Fxb0fXBhzEikq5aA5RvAJJFOjJG6X4gc5NDm+bmZnZt3UrB+vWUlJRQ7vESjN8sALAGg7j8QVyBMO6g4AoL7pANNw4sVhcN7gTq3W7qXQ7qnTY8NiseuxWPTQtjCoWEwwhhLOEwjqAfVzCAIIQtNgJWO16niyaHizqXixqXk2qXgyb7gdsl2cIKZziETYXppXn8vxn/X2ls0dwb9VsRFVPcxKS3eeo3n1Jd0tRluYkLclp+h8JBvix5g0pfE9te6cvaxae7AuDl6JiWq6FlAGpBx3y8og/qZTJA8e/eTfGNN5H54x+RuGAhnno/L97zFdOPG8GUxcMAKNnRGsjiget6fxUmYGvEErZjDXc0VzFgqRCRiOVvJL5qLBHjEPNjdRhTXlrKhhUr2F5QwL5gsO3MmEBiUxODG3yk++0kWVNJcqaT5EhHuTLYl5jI3sEWylzCTpeFMrdQ4rZQ5rJQ5+hEcjxA7KEQaV4fiT4/bl9zy+Zq9uLye3HTQJKjniRHA0nuepLc9bhdjThd9TgdDTjEj1XCLS37+F6ok1Kqu9GsTEwOiOrSJmr3aa9dezdXUxUl7Pm8wRbhL31oIjOWjmd3ld73BcM8vmY3NquFNO8uCotaY2e4Ag1YVRCAkNgIHuQVsG4JgEqpCuBUERkHTDCStyiltvVZzUw6RSlFR7NHPaW2tJ7KEi/5M7PanXPr1q2kJKeSmZmJzW6l5Je3sNbvJ/DnV6h7Poy/WY8H3n9iK2NmZeHzBuKLNfuJMv4VhIAVijIUuDZTmjqYsYVjSG9spnhwAjnVQRwhCFv8NKRsw+FPx9Gcjsdhw+esI7kZmt1lJNXnYw27jLNGbDEshtSlryb02Uf0WFotfI/pq4uYDDyUUhStW8eGDz5g+75yau2tr15Rioy6JgYHE0m2DGGYfQjptkx2DbeydpCVbSkWChMt7E60UOXsXN4RpXD7fIZw5sXl8+LwN+Pw+7AH/ViDIZQIIYsdZbEStDrwOV14nW4EwRZSOANhkrwBkrwhUj0hUpv9DA41kWptwu72YnN5cCV7ScxsxDWsEnHsI6TK6bzjC3b7IOz2dOP/NOCBXnm2Jia9TdnOOsp316MUrHuniIbwPrz+RrwJJS3fiXZkgMUq1LlsfP7ge22ycgGXBLBLOO6hO0KDWRUY3bIvAhOyU3rrdjqkR3q8hsDXK0KfiCwGbgRmoV3KXKqUWhaVL8Cv0dP6acAnwA+VUl/3xvUPVZRSFP3pH/jfeJHA3XdR6/Uyf/78duWCFRWU+Xwsf+YZpr32GtPvuw/X+PEovx9xOFDhMHuWXoolJZnn5TiaknZzet1xTD92KnvffRd3cjL+zEyefPJJAAZXHMn/LFI8n3E6DWM2A5BZFkIRpjFpNyqcwUM/+VAvLxkClEIRsAXYkWMnaHEyvtjPjhwHic1h3H5FZYqVCXv9lKTbsIUU1nCYsK2cfalJpHv3IYR5bu4UGtyxiq0nAfDeREhq9tDoSgBg7s6vSfQ3k1vdyKNHLY4qnwXAiOoUitKHtKSmeJtIavZQkqbjxQ9urKMqKRWA+Ts2sCVnZA+Db3WOUur9eL9NDk9UKMS+NWv46v0P2FxfR73LaMd2G3Z/gGyPhQzJZZx9FKFkF5tTLHyeauXhQVbWD7LSaG8/ELEGg6TVVzGovo6URi8pTX5SvWFSG8MM8igS/Das4gZxI+IESQBSEIkRHCWE1dmAzVWHI7ECe0Id9sQ6/X9qA7Yh9Vgc9Yi1FiwdW8SHwZD7LLhcw3C7huN25+J2j8DlGobTNRSXcyhOZxYWiz3m6N4RAEUkDTgF/Z11ROcNNB+1Jr1Pc2OAYKCtYNXc7OWDtz6hrr7rsOrVTWU0NNcAoh3BxhJpUd2wrwgDeCC5i3np2Sec1TLNICIcnzGEH1q1OJbqtjMxJ7nDCZ6q4iI2vBc/4uKgijTe6LqaLXQoAIpIty17lVKX9eCaEZLQAbz/bWyx/BT4CbAU2Iq2RH5bRMYrpRr243qHBR8+tY0N2ycwyZfN+y++CMCYMWPIzMxsmRUsufmX1P33vzzz3e+ggOJFiyj56a3Y/Lnk7X6DkkFuPCk51GfmMGJDAbXHaDueV955iw+fe5zKLDcKGFQVojI3nSSfh71Dv+KxdW5SHYOIPPzdIz5BUHw8egrbsnM5ccNXFKensitjGB6nk3O+WMFXI8ZSkJXdgztMM/4f1q3SEeEP4NPRkzstGy38AdS7E6l3J7bsR4Q/gI/HTKWvEREXcAGtEQw2AU8qpbx9fnGTPkEpRfOmTax74QXW7ttHWXq6Hs67XDibm0nz2kh0jMWemc/2kXbeSbWwJcVKqbv9FyOloZZh+yrIrmkgKwC5Nhfj04cxZOhoErMTCQXC+JuDBJpDBINhxOLB4qzG6mjAYq9DbGVgqUNJLWGpJaxqCIVrCYbqCAZr6O5UvcXixOHIwGEfjMORgd2h/3c6h5DgzsPtzsXlGhpHwOt7RGQeOh65D+0Sphgdp9zHAPRRa7J/hMNhtm7YRbPHT01ZE1XFjQDsK2wg6Au2lPM7q2l27yNs9Xd0qk5QdLb441M2dobSqVVuisOdz87ZrRaevmI+GcltxiNYLBZSU1P3e/VOhcMs+98ftF5HHExJW4TblgRARmLP/Kp3NgMYe6bFaAE3soA9Ba0H+EGPrmiglHodeB1ARJZF5xmzf9cDv1NKPW+kXQKUoz+YvTgvc2ix4f1iAHaMPgPQk6Frrr4Wz+KFbKupJSFshWY/40YvavN6X3fEeFDCF0eeRcBixRYOoRAK8odgMUoGHQ1UZrlZnT+FrUNysYZDeJytFknjyvYwrLaC3GoHroCffx91Spu6vTX1iDb7z80yVzk7wghf9QrauXqkT10G3Ckip5lhrA4tVDhMwxtvsPWxx/k0bRAVWVkweDCWcJhkb5jSlEk0jBrJhxkO1g+yEoyJRGMP+MmqLCO7uo7B9XWMcClnGiCLAAAgAElEQVRmTh7H0WefQMbgQfoaKkRzcwkezy48np14vIWEvEUEmksINpcQCjW2njCMdirUIYLdPhinIcg5nENwOrNwOrJwODMNYU8LelZrUq+pm/QBd6N90V4H1KPVLJqAJ4GH+rFeJvtBOKx476tSKgvrQUGw3k/1llo8bKI5oaz9AUnG1gEq6GZfIKvL64aUlTp/Jgqh3qLYbg+hYpq8MqTDa5bkMyhBD3YsIpw8JZuc1LaWuxahT/pMXbk2nbKJg1OmXUlCfWIXR3ROZ46gz4j8Nryqe9HLtE1GWiK6g22If4YDYhSQDbTMcyqlvCLyAXAU30ABMBgMUvNhq6f4+rRW7yFfTJ1IoK6WTcPyqHMnsmjHer6YqxuGAmoSkilLTWdnxlDsoRC7Moe2O/9FHy8n0e/Da3ewfviYuHXYlp3Ltuzc3r2xby4PAB/Rvk89bOTN7se6mXQTFQ7T8M477P7n/XyRnEThuLEggi2s2Jk2hm2Z+ZRluWi0t87wiVLkVJSSU1ZERm097uYqLMl15M0cy9FL5jMrexZWoLFxM7V1L7Ch9Euamnbg9RYSDncs1VksLlyuoTjsg41ZusHG73Tjdzp2e5qxpWOx9NST34BkGvB9pZQywis6lVI7ReRnwBN0I1CB8X07GxiPnjlcA/xCKbUxqkyXKknGUvRfgTONpJeBHymlul6H/AbT5Atw9zMr2bCjCEsgzFxf7Eyyojm5VfgLB5IRoFEMLW4BX9TsXRhhQ3AoJeEULbSJnoQ/YsSgbtUnEZgBXLpgFJYYIW5CTjL5mZ1InH3MuneWA3DE0OPaCH+uCekkzDQE3d93/3zdfQP8GDgu8qECUEo1ichvgHfR4Xh6k8iaYayngH10sDYoIi1uAHJzB7aQ8nWjlweKKjg/JZlksTB5aGq7Mm88uYnfWgsZU7qLETUV7E4fQmKzMDLBTXNCGSFb6yphwGLloUUt8jpTSnaR7mmgKjGFXRk5fJ43scs6PTb/FOzBAAHbwV/G+YYyGbg4Tp+6HTBjQg1wlFI0rlhJ2b33stYibJk0kZDNRkCsfDxkMmU5Q6lOaVUaymnyk7d3F1l7ChjUVEfx4BJCk0LMX7yIY3JPZ3TSEOrr11Jbt4r1a/9Cff16wuHmdtd1OLJISBjVurlzcbmG43RmY7enDeSZur4iWiLehw5ZuhloROuWd4clwH1oF2eCXjZ+R0QmRblj6o5K0hNoPcSTjf0HgceA1pfzNxylFPe8vY1qjx+pLUZqi7HUFgEwVQAHNDk6Pv7Ui36A3d5JgTgku2zkZ/bvLLYKhgnWal3aQFEDvt31XR4TaPYSDrXqNioUanUDswafwGjHNADs2QlkXjUdi3v/BnPdPSoJ3Zk2xaTnoJew+h2l1AMYWsWzZ88e0N6Ej/9sKwp49uudOD5vYstvTsZlt+L3N/P6X+6mOOjmtZwRbB05nq2ZQ7l49XKWT9WGHle//2K789UkJLfZf2/qDCpdg3tcL1P4O6hsoeM+ZVrXD2D8RUWU/fpWSjduYPX8o6hLG0SdK5E1ORPYm5NDwLDwTfeFObmwmhGbP6HaX8q2EVWE5ycwbcyx/Hj4j0hWNVRWraCy4Od82NB+ISUhYTSpqTNJTZ1JctJEEhJGYbMltyv3DedLYA66z6wE7hCRIcCFwPrunEApdVL0vohchI7QswB4pTsqSSIyES34LYxE8hGRq4APDSFx64He6KFKQ0MDL7/8MsGwYl1RLXXeAEniJ83SVtU5IHZSGrSe9oiJ6WTmtm3r+fn5jB7dVo97oBOo9BKqaabyoY1dlvVZ4OtUa6c+QMmbA8Cnxm76WXls83r1+ux+0F0B8HngERG5ibbe1n8P9IV39ch87xBgT1T6kKi8Q5aIdGpNakQpqKlp4JM1K/nyyy9I3vE1TWOm4Y0a5Xw4dnrL78ePPJFGVwKjK4qZVbyJ8SlrKfe21b3bH+HPpO8RkfSo3VuAvxozftF96hbg5we7biZdo5Si9plnKfv97ynIzuark06iLiGJj3MnsTNneIsvv2k1Ic4srCdl51rezvyKTXP28j9TzuEH+d/CHSyirOxFdq67F7+/vOXcFouDlOTppA6apYW+lCNwONI7qopJK78EIpLCLWiDwr+hBcJL9/OcyWj99hpjvzsqSfPRs46ro87zEVof8Sj0rOFhS2lpKaWlpRQUFFBRoR3+B0JhPP4QvoaalnIpQEqMh9OMSfMYM3Y805LSeOGPWvX52xcsxrmfs1oDBf/eBsrvXdsmzTbYcEEWDJO0aDhiFcLhEEVfb+C8nFSqkno4n7az6IDq2N0n/APgj8AyIDJNFETrAN54QDWIzy60oHcCelo+YjG5CLipD67XLwyut+E6IsgRG3fx/bUbsGOlacy0duWidfYiVq87M4exM3MY+hGZHCLEOn8W9LKRitoHHV/bdAQ9gAjW1FB68y+pXrWKz+fMZseofL4YOZ6NQ0cRtlqxhhWnlgQ4d3cz3upN3J/7MuNPzeSq6VcyMz2f8n0vUbjxIrzewpZzOp3ZZGQcS8bgY0lLm4fVeoAhoL6BKKU+j/pdgXYHc6D8BVgLRGJyd0clKRuoUKrVj4ihl1gedXwbDiW1pXiEw2G2bNnCRx99RHFxcZfl7Z4cbL40rBbBYbUgWHAGU5HVVopW76GgeRcANrvlkBf+AHyFrcu8zjGDSJieiWPaIBp9fvxKsc0X5KxNexG/j3BeBgFj0meERZElCovVijOh50Yez/egbHcdQXuBa4wZwHwjuSBaf6mniEgSELE2sAC5IjIDqFZK7RGRPwM3i8gW9GjuFvQI64n9veZAw5eQQFmiNievTB7ESOsOlk88ihmFsXHNTQ4TTLPoQxDPZ59R/JMbKQuF+PiUk9mYm8+qMdNaLORPLA1w9Q4f4inlkdz/MO+4eTw67SHwfE1JyWOs2bYCpbTDdKczm5zss8nKOoWkpInfRJ29XkVELgBWKKVKe+l8fwIWopdy+zLs8iGlthRBKUVlZSX19fU89thj7fLL/ZkMCVkZ1DSUaJ8qlrAdS7i97p42ZWz7mM+8bkbvVroPCQUDVJcUt/EfqEIKVRsg8Go5PgtsmpvMK8MslG3/iK0ladSlxMzsR632jbJb+Hhh+0mgntCTN0q3xWwRSQXGGrs7DkT4M5gNrIjav83YHkUr2t4FuIG/02p1deKh5APQE/BgExtVuz1sfnY5Rybcz/bvPRe37EszFqEnOGH7mPEHsZYmBwvT+fOhhVKK6ocfpvyPf2JXbi4rFi7iw/EzKMzQM/JTagL8bIufUfXNPJf9KuO/NY17xt5HWenTbPnyrJYlXhEbmZknMjTnPAYPXoyIObnbi/wOGCYiBWgdwJXASqVUSU9PJCL3AN8FjlFK7YzK6o5KUhmQKSISmQU0dAezOAzUlgBqPX6efv4lSgtiYjGE7CQ2jcDtGUZmjPhhs1sYMSmdjBHJuJPsjJs7RJvkdoDdYcFiHVjR/VQojG9XHaHmAJV7dhMOBdm7eSNNTR4+9Xnx2aLEKIHJg47iw0wbe2e7+WywkdcYgJz8Nud1+psJWayctvo1FrmtnHLN/5KeeHBNKroUAEUkFy2EnUKrcKlE5HW0ifvu/bmwUmolnQirRie61dgOGTwBD3aLnfdXv8/rK9/EGc4iIRAmrXI2T8+4jJfW720pW5PY96FeTAYOIjJKKbWrm2UFGK6UOjAlD5P9QgWDlN12OzXPPsv6qVN56diT+GjMNPw2O+5AiB9tD3BOUYC1KZvYdG4610y4luKih/lkzV0opQ1TExJGMTTnPLJzzsbpyOjnOzo8UUrlisgYtCXv0bQVCFcopa7qznlE5C/Ad9DC35aY7O6oJH2MNpacT6se4Hy0V5FovcABTWNjI1u2bCEc1tanW7ZWsqNgHSElhMMKp7U1Kow16CaxPh+nv3VGKzk7AQmGmX3qKMYfOWTACXPx+LyuifUNnpb9UChI+c4CQkEd1tS93YaVaANJgcSp3DWnG6FBDDIaa5lUvodRVlh86umcnJmGNSIInzCnl+6k53QqAIrIMLSCehht9h6xWJwMXAOsFpE5+zPaOhyp8FRw9b8vZXrDRMJNiayZuISdWcM4+8uV+J37eGn8gU3tmhzyfCwirwEPRiwFYzF8iX0X7Xrp78C9B7F+JkCosYniG26gbvVq3jnuOJ49+hRD3xYW7Qvw880+nKF6th0TZPH8hRQXPcRnn9yMfk0KmZknMmL4pQwaNMdc4j0IKKV2ADtE5BFgLnAF2gr4cqBLAVBE/g5cBHwLqBGRiM5eo1Kq0dDl61QlSSm1WUTeQFsEX2kcfz/w6kC2AG5ubua1115jw4YNWCyWFsEvGgvasXG0VnJG2UIEC0nDE7G7rIybksERJ+Ri7SWBz1/UgGdjZY/iyisU1ShCwGprkO0SokngKZsfWwfn6djiNqlVOprUURmjZEgxyxd13wLWJAfudBdLh2YwPtFFlnNgetjoagbw1+jRz/Ex4aleNKbL3zLKdGuUdTjz6s5X+cWHv2B54X086HqHxMRqdmbpj8bm7JFsHjqqn2toMgCYgLZafE1EwsAXQAnQjFZzmARMRFv5X6+UerO/KvpNJbCvnKKrrqK2sJBHz7+QV2YvweN04QqG+NlmP6eXBNmeV8r4MzIJVT7BF5/roO8iNrKHnMXIkVeTmDi6i6uY9BYiMhc9+3cM2m1LJfA+Wghc2c3TXGP8/25M+m20rkB1RyXpArQFcqTfvgxc28069AsPP/ww5eVaVSFa+HM0Z2AJtQot1rQsRmXk4LJZyMpOZ9zsoSSkOHC4DtxYQ4XCBEqb2O3zU7KzllBNM76C7vnOrnJYeG2YDVsY3s7pWMjq1LWKwbl7OnayHkoK48xPw2qzYXM4W9Lz3U6uGNGz8GsDia7+eqcC34sXm1Qp5RGRW4DH+6RmA5hAOMDXlV8zJWMKNsOb/vIVL3BjyWVUSgOZmYVMmLgKHdkLU/jrBrmqkD2St1/H5qttFMi4Hh2To4oplVaf4peoB3lULgcgUTXQJMmcrZ7mH/tVo/gYEQFuEpH/A05DK5uPRH9YKtH6r29GRyAwOXj4d++m8JKllPn9/OmaG/hkzFSUCFOqfdy5MYArXEfNt+tItbzMlq2fATpO7tCc88jNvQK3u3vxq016lTVABfAH4Cql1J4uyrdDqdigX3HLdKmSpJSqQc889js1ZU1U7m1sk9ZY7WPbZ2VYbRaUClMRLKA8qIU/mz+F1JpJiLIBgiBst4XYbQ/xuxvnM35Y+2AFB4o/HObNz/dS+VExrwyzszrTpiWSTCBz/0Oc2UIhEv0BbKEwx+woRJTiiL1lDG7ytCvrcCWgUFT5C/GEtdWuxWpj8fcuZdy8BUYpQaz9M5MfCNRTU/MxSgW7LrwfdCUAZgIFneTvoH3M4MOWx9fsJjvFxZr6f/HB6ucJzvoNN02cT+LeTxhfdy7/mKA4ZsvnHD9xVX9X9ZDjXJ7kj/yiZf8v6ioe4IcMoZT3RPtpdasmHuRivifa0P0S9SAWQixmBe+rY1nWsvIC16h7yGIfL3IO2ZTxKfOoFq2H5VJefsUtXMMjLeWP5l0+U0cyj484jrcJK8GC6lUBMIIxoHrO2PYbEVmMdsM0C+1U+lKl1LJOyuehZ/RjOUUp9caB1OVQx19UxK6LLmF9ajJ/uPgadmfkAHBxgYdrCkLsHf8VtimfUFuvXTbabKkMH34hI4ZfjMPU7+tP/h9a9+83wCUisoJWQ5Cq/qxYX1JX4WXn2gp2ra2grrLt/IwKK7wNgXbHKGM91ZtQTFPKzjZ5g6qnIwh+FOXWMGtcQXbZw1y2YNQBCX+vlNeyp9nP06XV1AWDkYqgAmHKMWYcZ7R1fzS5IUDIHqapqZYw7ZekYwlZLIzZvoG0ukpS62uYmRonVJsbmiKXEUjNyuaYpVeSkNL7gu2B0NRUQGXVe4RDPvYUPUgw2Lc2r10JgOVoVy17O8gfa5Q57Cmu9XLLi3piZp77SeZXnsr9Rwzn0q+LuOmf93H31XcA8OaMuYxlBY2YHvtjuUPdSB672EcOydRxpbS6EUig1aj8AXURiXi4mdsIYaFSZZFGNRfHxHafzpcMMVxzncCbnKDepIxsnPhIM3y43sRvAbiIR/ie4SEpjIVU6rGqICHRXcCJn18ag/s9n8/Eku3F5WoA2r4oBxhJwEa089t/9+C4k4F1UfvVHRX8JuDfW0zBhRfx9th8/vmti6lOSsXtD3DnBh8zvEUUn/gKPvUJvnqwWpMYmXs5I0YsNaNyDACUUrcAiIgb7XB5CXAd8B8R2aqUmt7J4YckHz6zjfXvdfRJbkv+zCyqvSVUeHZR42vvKScxIZnXK/LxJfnxiqLGqjhtag7fGZ7KorEZTMrpvqFiWCmKmv0o4M3KOv5dXEWB19flcblNYZL37UAFmjjp/Rexhfff+86V/1hGcvrAHJAppfD5SgmHtXBeV/8V9XVr8QSbCIXD1FW0j/IVod6STV1IUemt7NU6dSUALkeH1jlOKdXmL2lYQf0GeL1XazTA8If83PXZXYxPXtCSNneboiC/NdrGtqMvbvldkjSEm/nTQa3jQGaBep+P5OiWfQGy0S+iP6preZCrOYtnGc9mTlcvMJoCEmmdqrcS5mfc0eac96nLqCGtRfiLJrsTjwtHqQ9YLYtZwAcA3MrNPNZ8OceXrNK+/g0mqVks3xmJw/pBD+/44KGUeh2j/4nIsh4cWqWUOixcUxwogZISdnzvAp6bOYtHTj4Pr8NFdmMz//iqGUa+QFnumygVwGJxMWLEpYzMvQK7fWDNGpgAOshEBtrtSjbgMPYPKzz1/jbC36RFQ0lOdzFhXk477yoJKQ72Fu/loYfaLjSICK7EZLLmnMptywsM444wfzv/CM6Y3t3wybDH6+OLeg/PlFVjF+Gtqo7j215UESSnIsgx5a1LmaWeApoa97KnutUezpmYyNRjWyPzZY4cRe7k7hlPupKSsTl6Fif4QNhXvpyS0udp8DcQVl3NVCpCjV91+9wfNtjwK9jhs7LDZyGgIs9W6x9ae8mVVFcC4K3owPQ7RORedPxS0Mrq1xjHf6dXajJAeWrLUzy99WngaeB3DHZVkZB1HAX5rYreL03smf7Z4ciJ6jUCOFghJ3CG+i+vyNkAnMorfIQWABNoq4ORTSm38OuW/fO7qU465/NEts0u7HEdb0+ZyYeh58hr0i/E0RRwZdUjFOyd3SIANjamMeKss+GJw8bfeDz+awzgtgP3KKUOaCn6UCWwbx9bzv8uz8ydz+PHn4XX4WJKlYe7CgpomPMAQWcJKMjOPov8/BtxOeMGdDDpR0TkH+gl4PHoyBzvo6NWrRzI1rf7SyRUGsDV9y7BauvY6jYYDPLQQ62rJjvd41lTk4Afm44du7xVu+uM6UN7JPytrmnk7LXxAxak+0K4QoqkoPDd3X5OLAviipKPnt11N2HCpA7JBjsMGT2WyUcfS9LgDMbOmd/tOhxsQiEflVXvEgp5CAYa2L7jjq4PinceBTUhLa3bgPcabICFVGcKpUEXNQzivPHnATAl5lin1cmJeSeS7Oh49UEu6b6+YqcCoFKqRESOAu5D61q0+AFEWzpdq5TqOgbMIUyFt6LldwJe7lp8G+VksVa+34+16nvsyk9AOh5NXawe5N+G0QTAKHaymJVcrv4JwCtoAVAh/ET9PyrJjDtjtz8Mv/YlQvuepGBXz2Zap8xeyBjfGD766MmWtFDYilJWjl68nn37duN0DqampuOR7CFOI1pn8CN0KMczgadF5BKlVFzp+1APV9URgfJyNn33PJ5esIinFp+B1+FiRpWH22ufp2b2yyBh3O48Jky4g/S0gftRMmEQOnTbYSnwxRL06+XRuWeMahH+gsEgwWCQTZs2UV+v313r1q2jpqY1Bu97/jHsaW5dzh2blcTgJAe+YJirj87nxElDOr2uCilUQF/72S+LuM5X15I3rTrAseUhRnjCjGwKk+dp63Ol2ldKowqzJ7yVUHqYIePGccIV15KZm7f/D6IDmgJNREXj6xCFYvmu5VQ1d6AmqsJYVFs9SnfVYwyztLdOXlbpIMGRSlZCVpfXzUwaw9ThZxBd8gcJmUzJiBX1Dg5d2nArpQqBUw3/ZNGRQL4RekNKKbLrR2FVAea5tA7g3/hJP9eqb8lQ5fyZH3BhnKiC89UqjuNN8tnONjWBNbIQAIlx2DRS7WS3jGYoexnVi3p0Tmc2kpAOlp65H0hO1h1Mz+JYwFAuLtozlZSUFGy2RIYN0w6fEg+Cg24Rsam+Mu3qAKVUJXp2JMLnIpIB/JQOrPkPxXBVXRGsqmLT+d/hyQVH88zCU/A4XcyobuQmy500jN4GCLm5lzN61A1Yrd139mpy8FFKnd/fdTiYNNZoTazpx40AYO/evSxbtoxgsONXyZZgJnvCabz244UIQlaKk4wkZ4flA83N1JW3aoio5hDNj5QgCjamWrhuXquF7iNrmpha1zq9V2ErpixVEcoWRk49Akmyku0ahjslhRnp393v++4MT8DDCzte4Hef/q5dnlsUqYYTQIcojkrs+pXrssCMhDh6iMZkqycMG71WlIItwQxOmHw1F0++uH35Q4Buf0UNE/dP+7AuA5K6ag/f+vp6GpN34E3U/q7L6Xy0dKjzG37WYYiWa7kHgLIvL+BHM+9hDVoAzKCiTbk7+CkhZcVO+w7naD4Zv6t7RqepqTOZPu1BPvhwJgAuV09dbWhhLzV1VkvK4PSFVFV/wKBB87jooqvJymo7cnO73fz85z+n8a093MZtPbxetykVkUeBh5RSm/vqIt3gE+DSfrz+QSXc1MSmiy7gqXkLDOHPzfS6em5w/xxc+3A6s5k86U+kpR3Z31U16QQRGQGkKKW+jko7BvgV2jjqv0qp9hLBIYy/ufVdandqHbDt27cTDAaxWCzYbDaSkpKYMkUPdpNSBvG1J5llr2/DabMweWjXuqvFWzbx1K9/2rKfaBvE6SOuQoBVGVaun9UaquyPL69k5KixDDp3DpZUB47UBIZ3Uwev3FPOlurYgCvxeXXnq1Q3x59vUkrxaVlbscRmseG0Osm0Brk+sybucd0lRNv7CdoyWTD7eRZbHdgtdhLsBzd0W29z4F4cD3NydqeRllFA/rF/xGJMLTfK4W39l4JeRrg79L/cZfkZFdJe4FUhGyFfCrc7f0plwvFMC5QRiJoxt6CwxBH+Nj2RzyW/u5XP1rcVAEVs5GSfTUnpM23SZ0x/uI21pRjDsKE551JQcFebsvmjb6Rg5x9a9o89ZjvNzXvZt+91RoxoHaFNnvwnSkv/S3b2WTgcMYG5DVwuF64z+1S382a04HWDiHwKPAg8rZRq7PywXmcG0N488DBEhUJsueoKXpw0jecWaOFvakMV1yX+BJu1gdTUmUyd+g8zbNuhwZ/QLsp+Di0hS18BCo3020WkSSn1t36rYS+za522ALVYBBGhrq6O99/X4cWPOeYYFi1a1FL21pe/ZtlbhUS6dnZq1zPZHy9/lQdWryEwaS4AYwfPxCoZPAs8OdLBnsRWfcO7VA1Lrj6JYeMndnneL/d9yR2f3IE/pB0tK6XY09Bjd42dkucIMS0lnTPzz2RY0jCqa1ZRUfFWS35i4ljj2mEGpc4iNfWIzk8oFganH43TeQh5ufPWwOZXenSIKQB2gr+wkjN3zmD7vNs4X54GgT+oAe3YvVN+q27gF6Jn8K5Rf+Y+ub4lLz+0iwKrtoTITDmH5FeOYpw/hXnOSs5bHGzjNBnA4bIybtSjjLS8QN7IS/nk02fb5LvdI5k44Xd8+VXrCk3avTZ+8PRr2Ox20tMWUF3zUUvegqNWYbcPaicARoQ/pzMbn6+M1EGz9fUd6QwfdhF7i7UrmfzRN5KX94MWAVDEhogFtzuXvLyr25zTbk8jN7d/dTiVUv8C/iUiE9Eew+8A/iwiz6JnBT/q9ASAiCSh3TSBnurMFZEZQLVSao+I/BaYq5Q6zih/CRAAvkKvgZ8B/BD4We/e3cBk929uZ3lqGi8uOJEGdyJjmiu5Puk6nDSTnX0WEyfcicXS8dKYyYBiLvDXqP3voaWdGUqpoIjciB5gHTYCYHOTHmGnZrmprKzk3ntbo0SOHj2aykYfX+yu4ZYXN1LR4GMQggDjhiVz8aJRlFW3NcLzrCvH3+Bl+5ef8fSwdN4ZMxyOPacl/50O6rFy7nhGOrW+XUduSco95fzo3R9R7u3cS9zCYQuNWnZOmiuN00adQrB6OSrUdowcbt5J2LMJKKWx5H5iFUGnT3+IjMFLurxGr6IUfP4w1B64oFv+8nqq3tumrbwPwEVOPEwBMA6fbS1i9Ke/oqQqkTS+S4m1VSfsRhnYoVm/q/7NU9JeH+Fk9Qq5tDZGKyHyVAGFkg+A/R0XM5YIV8wYwbTs37P3uQ91Od9gtMlYW446J5/hw6YB2kR/9Kjr2Lqt1aLXbh+E3ZHWsj9t241Yv52Cza7D9Uye/GdKy/5L2qAjSUgYjc2m9Up2v5dDzpwKHMltZw9nz36eysr3yMn+dktaRubxLQJgbq6OupKQkI/HU9Ay4hvoGMu/N4nIz9GW9XejHdpuB/4MPKBUhz4GZgMrovZvM7ZHgaVADpAfc8wt6OgjIXRM08s6MgA5nKh65ile31vM60tOpWRQJoNCjVzn/AUufIzJ/ym5uVeacXsPLbKA3VH7S4AXo/RqX0aHXTws2PZpGZs/0rN5yaP9bYS/sXOPZcHf1rbs52HhBVJossIP5iTwfqqV92sqoSaOsJYMHN3WzcqU2hDj67WgYU114pqQDgLjEmxsL7yP21bsYGNVz4IVWcTCjbNvZNGw1lnKoUlDcVg7XzJWKkxj0zbCYR/btt2Gt35dp+WHDbug5beIndGjrsdu73udbgAayqCuGFQIXrgKqjvWffm2cLkAACAASURBVA8HhYqNyQQ9XcdOrt+jl5n1+mPvvqNMATCGQCjM2/+5k1OTt/B58FvMmPQQ4cSKrg8cICzkA56ivQCYTAN1ASGi0tBYNRpaXRlSSJhLfFa+nd1+SfRbVc/w8OCrOX3dc4w4bSn7yl9jSNZpbcoMH34hGZnH4/UWsXPnPUyccCcJCaPIz/8pCe48MqN8O4GewRuZezmx1GwfRO2uFKZ/v+04zuXMZnhU5waty3fk3Ndxu3NbZm5mTH+I3Xv+xcjcQyM8tYg4gLPRs4DHAquAh9CRPX6F/rDF1Z5WSq2kkzeCUmppzP6jaOHwG4X3q694+eVXWbnoeL4eNhqbCnK95Q4yLF6mTP4nmZnH93cVTXpOLfoNFhnVzsEwVjJQHCbft5Lttbz98KaW/X2NrcF8AtmzeesDL0uMWz1JHCxS+vddE11sSm31F5fmix1HKpRShAmB1coMm4s7JInsNCuVI+v5ZdFv9IDdkGOWV6wllnRXfBUaAG/Qy/Uzr+fccedit3Ycp7cj/P5qPlw1J06OhfzRbQ0xrVYXQ4eeh9V6kHXyXrgaqncSrKrGs7UoJtNYdp96bpvU+s920vBFvIBMnTP+3kvBIjB8DgyfFb+QxQbu7j+DbnUQI+RUPBQ6kH3B4WAVrJRi66oVPDnrXP6acjV/3LqJuuH/oozZ/V21HqD4j/p2S7i0CKfwCk/X21tco2YEx7ez3D11ak67szmsDo4PH0/yw7ejAlbG3fAqY8feEne2xOXMxuXMZtbMVh96eSN7Jogds/Qqdq5dDe0m8uOTlDS+zb7bPYIJ42/v0TX7AxGZiRb6zkcvy/7/9u47TMrqeuD498z2xtJ7712kFyuIqNi7RtRojErsJv6iJsYaNbHFKLFFEdFoLIlGrCiCoiJFpSgivcPSy/bd8/vjzu7ODltmd6funs/zzLMzb73Avsx573vvOdNwaZVW+GzzLi4Pp6mlgq1bmfHne/lq9DF80d31dFzOP+iXsJdBg14nI6P6MUwmKs3DjZ+9DDgHSAM+9VnfE/D/Rq5UdWUVvYnWL/Fvg6qO9NkmCVeT+AJcfe9PgMmqGljZjgoU5BWVy/034co+TH/bJacfIb0ZsNZvYoe6L2UF5jR3AV/znVu5+M0pxBUf+iAhNbMxVz59aBGhMdNOqrRNo9qM4txe5zK67egaT4LIz9/Btm3vUuyXAGHPnvns2/c94pPgOC+vbCZyXFwaaandEE8ihw96MXyz8/MOwOLXoMCvjvDOlbBwaunHte+0pCC7kmB47ieVHj51xAgan3NOpetLJPfri6dLl2q3q6lA75A+g9JowTcXYMnnYhF5B5ikqgeJQbkFRaz7dj5vTH+RrAtvAuDmXn15SYWH5dZq9o4eFXUHXaWP025HNg9NnEe3Gb9jeUE/BuZm0qhVG/64Hc5v1Zibb+lJh6ZlF3Pzy/qz698/0fSC3qxbsAYtKLswQ/mobPCJpzBowonM+uzf1W8c2+YDH+Fy7L1dSUqYtcCr4WxUfVKck8OXv7mSL4eO5qN+wyj2eDhJ32ZC0loOH/wGKSk1nVFuosgduAArBzf+9c/eTBUlzsd9bwUqkLKKM4FJPp/z/dY/BpyGCwB34iaqvCsiQ1S1VoO3Fry3tvT9ubcNY83WsoQBnXLLAo7N2aso0kLWNUrh5rF9KPKUPVo8/cNXiCsuZtCEk+k9+igKigtYuG0hK/es5PndHzBlWuXV8v4w4g/0bFo2Ga5xUmO6ZNYuENmzZwELF9W8bkSXLjfQtcu1tTpnOdt/hAUvVL+dr2+ernaTfbs7UZDtxmemjhhOXGbjaveJy2xEixtuIL5Zs2q3DaVAA8CJuLFJ9+HuvABGALcCf8INKH8UeAAIwr9UeOUXFtP7jx/QL2MzC73BX4lJEltFEpLJPWRZP5aQMez3tEhrTdqbuxnCF8j4E7mi3+mc3D2f1okJhwR1yT2b0Ob2EYgIA5ucyIL//YdBJ5wclj+DxxPP6FGzEKkXT3Aq01VV11W1gfdmqsGkaAkmVeWnm37DzH6D+LD/CHITkhmo33JpwmyGDH0ttmb3mUOo6mLvBKoxwFZVnee3yavAD4fuWenxAimrmFdZCUURyQQux/UcfuxdNgk3TvE4XOGEGsk9WMCiD91/ER36NqV5h3Sef8l1crYtaork5/DOlhfYkJnB7BFjyUlOY0urDmVtQmkfX8SEmy7hvW0f83bxD7y+8TvmbvKZX+ZTUcx3MoaIcGKXEzmvd+0LfeXlZZGdvZotW9+ioGAPO3aUTStp2XLiIZV1xJNAu7bnIVL2uDg+Pj04Nbe3/whTRla/XWU6jHCPXoHCfbnkbd8PCIWNh7D5nkdLN+v0YmyNsAn0G/Ze4HpV9e3LXC0iWcCDqjpERIpwM65iLgDcedAl11zTr1c1W0aPHrqcn6U3AJfrU3RiDbkkk0wun+2Pd5UxgUnr9zCw0fl07uRmvYrHgxYX06qrmyTRJqnyQbglQWFG0+ZcN+0NxFP9gNVgSUmpP1UnKlIS/InIWFxpRYAf/a4xU0s7X3qOd1Kb80n/4exMb0wb3cRNnukMHzbdgr96wpvY/O1K1s0IwSmPEJHtuPGHs4HbVbVkmusQIAHXq1/Shg0i8iMwmhoGgAV5RfzzZjcRT4AhfZqw4IH3ySlwN/i9i9rzfNIS1h07gTndBx2yf+a2+0nM+4FcYHIlcxFapLTgkn6XMKD5AAa3GlyT5pWzc9cX5Oe5v4bs7NVk7ZgJCAcPrqhw++HD/kdGRt8K14XMhz7zgY65FZIP7aXLWbWVA4vXsG/+SiTeJzKOT4bv04EfobCQvJ9/9tmrrFZ8p5djby5doAFgX6Cikm+bKPvyWoIrwh0UInIn+BSKdbapatALcuYfKCAj/gBZmdH9SOh4ncFnHEeP/XBbxu2gsI9GpXn7AHZLa/67Zx8TM9+lx4/HccG6ONL7n4jH4wK9Xz3+HBuXL6P3mMqGdVYsnMFfQyAiXYA3cdOoN3sXtxWRJcBZqhq88ikNTP7qlbw1Zz6fjzmW1S3akaoH+Z08yZHDniE5OfB6p8b4+AB4C1gDdMZ1inzqfbybh/vuKwL8p9puo5LvxarKLM7+lxsDHQ9MbJzAgU9WMCO5LOHxjQOT2NSq/BOZtN0vEVewncS8HxF1nRqDWw5GRBCENmltGNdpHIJwWIvDaJZS+8ePe/YuZO3aKezc+Vm12zZuPJzExBa0bnUyGRn9634N5nnTwGixG5+XswctyEbnPAGJaRXvk7MHEBh/NwwrnwLswNy5bLru+ho3I3WomxugBQU0mTSJlMG1D6IjJdAA8AfgdhH5lfeXvWTA622UdbN3ACrsHq+Dn3CzIEvUOQnOggULWL5sGWdPmEBy69ZkbdjPB3+ez71jn+JKHq3+ABFUmJPMJQs+4MRdTcg5zS3zDf4Axg19gWbdNjGy7Uh2fnDo/IFGLVrSt0X1NQtNyP0T2I97FLweSpPZvohLCj02gm2LWVpQwGe3/x9fjDmeBZ37IFrMNfp3Jg65j7Q0/4w4xgRGVX3H4i4RkYW4x7sTcYFhbY5ZaZnFFfPcV+nRLZMhv4gPEsvSn3zavgebWrnOCtFCErPnkbbndeKKdnJqt1Pp3fR4hrYaSqdGnUJSqUJVWbjw3HLL4uLSaNFifMkGpUn2U1O7ExdXeW7N/I2b0NxD04yVs387xctmsOejr2HHzxVusmd1GqUzHCuU4n68+Q/gH1WertEpp5B5ysnEN6/8eIldu+JJjv0ykYEGgJNxWdY3iUhJAqD+uLF/JbchXYEpwW0ehZWNuaitd999F4CZl13OqOnTufP9RZzQeRupzYKbmTwUdu9qR2LxCn6O6097v3UJB1szdOy/SE3ryLEZ5StYxLeI7XI19dQoYGRJ8AfgTd58I/BV5JoV21b9+TbePWwUs/q4u/ELdDoXDbis+sz/xtSAqm4WkY1AScLRrbgRdc2hXF3MVsDnNTw2qtA72UN6vuvzOEg2Crw5cAw7mpQNYWi24ZcIcELnE7hj1B1kJIa+StXPK/9c+r5rlxto1+4CEiuonlOcn0/O/EVovs9cGVV2v/oampfHwW++gSpqGFeskh4+L0lKBE9cFRtUPIFR8/Lo/NprpPTvV8P2xLaAAkBVned9ZHURUDJQ7hXglZLSVapa2cypuugqIpuBPNzkk9uC9WisKFH49XfTmNvjaD5VuCwGUr1osQcPws64Yv773TXc0u9Z0vYdpNuIj0hM7kBCWvlAr9WNg8levIOMo/3DRRMF1lN6W1pOMjVIX2HKZC/6ipezk/hgxAgKPAkcoZ9xbZdetGx5fKSbZuoZEWkOtKOsjOJCXDqn8bjvRkSkPdAH+LImx96zLZsUD/RKdoHMQXLJ9xTzQ5vOpcFfsijp668onbbxl6P+EvJE5kVFeWRlfciGDc8DkJHRny5+s3P3vf8+O6ZMQQuLyF8TeK67xG4+vfMFOVDoHmFzwKf/Jy6J1EEDSD58KDQ+dIx46uGHk9QjNgoARIuAp1l6ZyRWPyc6eObhqhksx2V9/wPwpYj0U9Wd/htXNZ6iIvFHbGeuHA3AbmnGw0R/qpdESWBC/iBujStg854+jDp+mSsNE1fxP2NCqzQyx1d9x2Qi5mbgcRG5DpcSRnHlrR7zrjM1oAUF/PuJZ3j71AvYl5RBN13B7U220rnL/ZFumgkxEUnGPYnqBjytqntEpBuwO9D8tFWVVfS+7sSN2d2CGwN4P7Ad+A+Aqu4VkX8Cf/FOFClJA7OYyquqHUJVWfW3RRzfqGwm7L+ZCaSwpnlZntb0dZciuLx+x3Y4NixVbDZumsbKlQ+Ufh7Q/8ly6/M3bmLTjTf570ZCx44ktvfJMStCYru2pHdPJW7RkyQ3K0LE+89UeGgWCwCu/gpahXniSAMQcAAoIgNxiTL74r6sfgD+qqo1qwkTIFV93+/8X+Nykl+Cu7D8t690PIWv+Pg8OnX+jnfaxkavQJ+fvyeraSt2NGvNrROP45ofPmcrxaRLvOvOriT4M1HvX0ASMBcoydDqwY1zfdn3P3RVDVMto9i18K4bmDbuZDZntqSx7uIPce9y2GHPWXm3ek5EugMf44qaNQZex83Svdr7+dByQxWrqqzi1cAA4GLvMbd4tz1XVff77HMDUAi8Rlki6ItrkgPw4LwttPb59vp09/8oauOe7OwvdkFh+s5nS4O/x455jHGdxgV6+BrJy8siL891cG7bPoP1658rXder1z2kpJQ9WVJVtj9wX+nnzlcNxJMcR1wSxK+rZEL2atzfZmV/O0MudT9bD7DgL0QCrQRyKm6g6+dASWB2BPCtiJypqv8LUftKqeoBEVlG2ZiLgOx6YwWS4KHJae7mrlv3b2jZci0fckcomhlUZ+S9SfdPvqUgLp6zn3uV7qnJbC2pCGjfa7Humkg3oL448N0XPNx6MD+07UaC5vO7oqcYe8SU0pnvpl57DBcAXo0L/Eq8AwSc9be6sorAhCrWlRwjD5cGrdap0HZ/sLa0Ea+vfYh9fQaDKnlx8ext7hI/xxVupVFiI87ueXZQgr8DB1aQne0e1xYX57Fh41SKirI5eLDiCRfDm/4JPl7PvuI/k79xOwdmzyF3aw4lYW6THgdJ2fPBoTumVjDrOD4FTp8CHYb7LBRIiP0JFrGgJnkA71PVcmlZRORu77qQB4Debv7elL9Lq1JxfhHZC7YB0OS07mxYtpPU1L0A5EpFw68i79Yvnuf+Iy4DwOPt3cuWVLqnlr8gLP6Lbd66vKaOtLiYKdP+wxcTXcLay/UZzh56O0kVDEo39dJo3GSqIr/e3vW4km4xQ4sVyXVR1MzNL3Hcjb/nzfdd+sA3DyurvnFh12P40/DgpNstKNjDvG9OrHKbDG2KHthNcR50eSeHjQsqH1YhccU0O6INjPgNNC1ps0CnUZBpY9GjTaABYE/gpQqWvwTcErzmlBGRh3CB5XrcGMA/4qYABf7FqeWfBC+b/ombexklrtOHmMblPLdkBW9nHM6QoW3J6FN2JxSfmMCHLcaxIaU9/tVtPR4LAWOdN5XSLygbVrEM+FdJqiVTvVkPXc9bR06gwJPICJ3LZR2OIbNJ5aWtTL2UUMGyjsDecDekLvI3Hyh9v7tgOzO+X8OmzOa8P2Akhd7OgD4JWdw+9OqgnXP1msdK37doUTYsKjNzMJk/fI289S6b5yRS8le82+evOqVjGvGp8WixknlEHxKHTCBp9IlISvWl0Ex0CDQA3I7LdL7Sb/kQXKLLUGiPGydVMq3+a9ydXpXlsyr16b18nVTI4UAhVUwTD6OhzGNE8Td03vJPrt+SR/Oj05FTzmHE3OeYJ2M4Mu5b3k6/tMJ9G6dU9H+eiRUi0heXXLYRLok6wBXAXSJygqr+WOnOBoCsDd8yPakfaxu3J1UPMJnldOjxeKSbZcLrI+AmXBk2ABWRRrjxe6GoBhIyOxe7HNL5Rbns7zGKbRs38e1hA0uDv8bxcbw7aizxVaU5qYGCgn1s3Oj6dZo1O4aBfR6j4Ju3KZg9DTa+Rd5eD1sWNC23T+MzT8aTnEKjU88kZdChFUhMbAk0AHwWeNo74LZkSvsY3KSQv4aiYap6ft0P4vN+zl/Jjb+FzxOOZLpcUudD19ZjehWr6Ubu/tbEZRTTuMnwcuuTkpK4lke4Sp+gkefQJxhvTR7NA+8v597T+4erySY0/gZ8C0xS1X0A3i+u6bhxTdWOOWrIVJVnH5/K7AkuIe0v8t9k3HH326SPhucmYJaI/IRLofQabjbvNuDcqnaMNutnL6S9tGJb7jqWNi4ku21XNjZtBcC4xCW8PGZS8E6WvYv1i39f+rHvN8vZcV9XshaXzDcrH/h1mzmTxPbRXSnL1FxNxgAewKWnuMe7bDOuVFtM3HJ/n9WaqWdPDPt5fWv2ArQgixZk0WbpEBLPv5YOHS4i63XX2VPy3SVAIvmIKB/deBQpCWV3fIM7NuHfV0bRc2xTW2OAYSXBH4Cq7hOR23G93aYK7/33z8waOZqDcWn01aXcOOQS4uPTI90sE2behMyDgAuAwbiZ9M8AL6tqNSUmokt7ccHeVjnAnNHlv6ueHHZBlfuqFlNcnMe+fUvYu9dVgNqw8UVUiyveIXsnBQnuC6dlVh7ZX6wia3GT0tUp3VtCUiNISKfVH/9gwV89FWgiaAUeBR4VkQzvsv3ibrdTgOzQNbEOFHLiQBTeTAx/h0ofXcpt3MUkXi/frKI4eiYsI77bv6s9Rs9Woc/sbiIiF5cEwV+md52pxN79W/hoZTpLhvYiQfO4XrbRtMVFkW6WiRBvoPe89xWTcveXZZO5+aSymrKt2cZTA/rQONF9VasWk5Ozjs1b3qCgwE16Li7KYeu2t2t2Qm/w5ykGz7+asGV5WUWOXou/x5NoM+gbghonkfPLezQQWARRMqjOV0EOC+Y8yKnHnQ5Ai/1nhL0JHViPh7I7sAH78xmxbB+efA/xaRV99/s/vqo0naGJff8DnhWRKyjr8RuFS7b+TsRaFQOeePxBPh5+CgBn5HzEKSdGfxJ3EzwicnGg24aoQlXQFR5w875yPZCd5B7D9tm4jlmTTivdRrWYT2dVnQXNIwmoFtHxQAtQJSM/hcwDqeRuyUVVYZtP2l6FbUu7o1tcEua4pk3p+MILFvw1IPU3i/Ccv3Jf1nvQzgWAWRlNqtkh+BQhflcT8KY/GtmzDemLvHURK8qJdOgBTP11PW5G++eUpUL14IK/GyLVqGg3e9GrLOg+iF3xzeioa/nDsLPxeOrvf2OmQk/6fS6ZpuqbUL0AV0I0JgJACpS9CTBubNkTnzEHypIBrFhxDxs2Ti39nKjJpO3ZR8sd7vtEVGm2u4DkvGIObEmi4OABdv2UzgFRdu3znTBYfmyfK3ICiV270u29mJozY4Kg/v7PuWkhV7Xfz7wINiFpTw+OOusbpu3czytbdvLbbm3g8pnw6d1w0sOHbC8Jngi00kSCqu4BTvNOrOrjXfyjqvrPtDdeuQU5vP3RGr4ePgHRIibvWU7LlqdHulkmzFS1NEoSkYm4Mm03QOl/9yNw1aLuOWTnKPZEj6TS9wM2rmTIMDdBcN36Z8sFfy1SDmfghx+X7ZjcGNoNZuMHm9i/3PcBXXlJXdsTn5kOCamQUJYHN3ngAFr85jfB+4OYmFE/A8CCHLbuwSWSiaALmgxGxMPxzTM5vnmmW9hhGFxSPm925ildKdh8kIT2bhB7SkoncnLW0SjTptnXRyKSAGwAxqnqMg5Nr2Qq8I9X72b24CNQ8XBizqdcfPpvI90kE3kPAZep6lc+y+aKyA3AVODdiLSqhhLjUvhPB/fotcOubfT5eRUnnHcGqlqu/u6Y4TNJfsh9LxTlC/mn/RfSW7D5t78jf01Z8OdJS6PRSSeR3K8fqUOHEN+8OXGNLT+fKa/KAFBE/PuL/UXlb1TejtU8te9MhrMi7Oc+a9smshMKue+kE2mbEthYiowx5WdYDT78ZbZufZt27S4MRRNNhKlqgYgUEISH/CJyFC4d0xBc5YNfqurUavYZADwBDMc9A3oauMc72Ssqbdyxgu+KO7IpoR0tdDs3Nj3MHv0agM7AwQqWZ+OSQcecc3e+SbPBq/hh6Xfs2fNN6fIjmt5Okjf427chmU1zm8Jb5ZNCp44cSYen/oEn2UqpmepV98xxBy4Jc2WvgMuyhdPy9C48NeYsZhOaItlVufBr+H1xn4CDv4okJ7ehc+erSEhoVP3GJlb9HbhVROoaxaQDS3FjCqtNe+HNNfgxLk/aMO9+v8PlU4taT7z0Tz7vMBCAizZ+xcCR4b+2TVSaBzwuIqV30d73j1KDdEoicpSIvCMim0REReRSv/UiIneKyGYRyRGRz0Skn982TUTkJRHZ6329JCIBdZLkeMomCw7u/gmdGq0tF/ylF6WT9N8bAdj8dWMX/Hkl9e1DUt8+NDrpJDpNfcGCPxOw6r58jg1LK0LkRflV2M+56MB+xrZOC/t5Tcw5Ejga2CQiS/HrxVDVUwM5iKq+B7wHICJTA9jlF0AqcIk3fcZSEekN3CQij0RjL+D3K2byU9fuZEsa/QuXMfkkG69kSl0O/BdYKyKbvMvaAT8BNRkgWnIjNY2KJ47cgsuDe6n32HcAH4tIL5/MGK/geh1P8H5+Dlcu9ZTqTr4rUUgAktRlgGq+M59mu/JJyy4kvlBJ2LyHbasbkbMjkZydZZ0L3WfPJqFVyxr8MY0pU2UAqKqzw9WQWNUqfxu7EhpTIEkkFOUBQqNmKdXuZxq8HcCbETjvKOBzvyS5H+IGzHcG1kSgTVV65b3ZzBt4Oh4t4tKVW8kY3zzSTTJRQlVXichAYDxQknH/R2BmTW5mqrqR8ua7vQF4QFXf9C67BFci9UJclaw+uMDviJLxiCJyJfC5N0j8qarz58UpCcAQvqH5jjwO+8HFlFoMO35IZ+PSQ58GWb4+U1c2iKaObnpnDplnvcvbehb9Fv3EsRc/QPs+4U85Y2KLqv4yQqduDWz0W7bNZ125AFBEfg38GqBjx/APqZrzzass6t2TYonjmP3zufDKG8PeBhPdvIHeR95XKHTBXRulx1fVHBGZA4zGjaEdhauW9aXPfnNxPfujcb2GlcqLiycdGMvH9F++n9ycpuSN+Rtbbv8DWlBQul2zq68ioVUrMk85xYI/U2cWANbRjh3f054DXMSLND/6dvqP6BDpJpkYICKfAmd608H4Lm8E/FdVx0amZeWp6jO40loMHTo0rI+HVZV3Fi5nSe/TSdJcfr03FY/HUiU1dCJyEzBFVXO97yulqo8E4ZStvT+3+S3fhnvcXLJNlm+vo6qqiGz32b8c35ur+J4uE1SX/ZvYOLMZ2duT4O3/K902rnFjOr/+bxI72PeLCR4LAGuol/7AT9K3wnXN2maGuTUmhh2DS2DrLxk3PjBUtgKt/Ja18lkXNWbMfJovehwGwMSshYydZGP/DADX4pKo53rfV0Zx+QCjku/NVUKvvgrQ+YudZG9PLd2m0cSJJHbqRIvrqvpjGlM7FgDWUD8W8xMVB4Bx8f6l3IwpT0QG+3wcKCK7fD7HAROATYTOV8CDIpKsqiU1h8cDm4G1ITxvjRQXF/Hx5u2s7TiSTN3DNZm9q9/JNAiq2qWi9yFUcmPUCljvs7yVz7qtQAsRkZJeQO/YwZYEeGPVTLPIW59MCi6PX88F83GHMCY07HlKDY3ZVH6MvCfOYmhTIwuA+bjeiY+8n0te84BbgbsDPZiIpIvIIBEZhLueO3o/d/Suv19EPvHZ5RVcjrSpItJfRM4Efg9E1QzgV//zELPau0oIZ61bSt8TLO2LOZSIXCwiSRUsT6xJzeBqrMEFceN9jl/SU18y5u8r3EziUT77jQLSKD8usFKH8S2Ja1zA12PuFxb8mZALOHoRkTNwaWFa4hc4quq5QW5XVEnUPDqzmpP4H/NXDSpXYeS6aa+zZNnV7Nw5i2bNjo5cI02s6AIIsBqXiDnLZ10+sF1ViyrasRJDKZ+P8y7v60Vcyoo2QLeSlaq6V0TG4+qpLgB2Aw8TRY/KCgrz+KKogO2e1rQq2s7V/ey6MpV6AfgANyPXV4Z3XUC1gEUkHeju/Vh6IwXsUtX1IvIYcJuILAdWAH/ATfp4BUBVfxSRD3Azgn/tPc7TwLvVzQAu0ZelxO0TiI+3XH4mLAIKAEXkYdxYi7m4ga81+YKKaS/rWaXvX/3hTChKov/GVSxt3417urcjLj6BwwY+i2o+Hs8hN6LGlKOq67xvg9L7rqqf4QLKytZfWsGyJcBRwTh/KEz919180u44AM5fvpIO1xwf4RaZKCZUXFGnI7C3Bsep7kbqL0AK7sapCa63/nifHIDgUsL8HZdWCeAd4JpAGyAH4wBIaGl5/Ux4BNoDeAlwjqq+HcrGRLuZG4/iuISfOWLVEoatW84VeF89nAAAGJ5JREFUx94OgIhQwVMIY6okIu1xgVhFvepR0yMXTjm5+/k6M4290oQu+Ru5ekK1OXRNAyQiS3CBnwKzRaTQZ3Uc0AlvXr9ABHAjpcCd3ldl2+wGLgr0nP6a5+0EoOPz/6ztIYypkUADwGxgeSgbUhkRmYwrVdUGWAbcoKqfh7sdXXs8ysAfmzKkVX+2Lv2SLi1bhLsJph4RkV8AzwOFuMfAvr0YUT17MZSefeVOPu18JgAXLt5E4wknR7hFJkq94f3ZH5iBexxbIh83oSkSidZrLX99Exqfcw6JnTtHuimmgQg0AHwAuEVErlTVwmq3DhIROQ/4GzAZ+ML7830R6auq66vcOci6dDiVt38DxcXFrBvSg7Zt24bz9Kb+uRs39u6PNRzzV2/t35/FvNbtyJE0+mev5rJLzo50k0yUUtW7AERkLfCaz4z2mJVUnEebewKe/2VMnQUaAD6Lq2e4SURWAAW+K0OYtPYmYKqqPuv9fK2InABcjZstGRLpudkcSE4lqbiQjK0jiSsoq+3r8Xjo0iUcmQdMPdcKeM6CvzJP/et+Zne/AIALv9tO2sRmEW6RiXaq+iKAiIwF+uJ6z5d5H+nGFNHU6jcyJogCDQCfAo7AzbbaRsWDboNKRBKBIcBDfqs+wpXWCZl+65bTem8iV+R0pnXuVXhSLdWLCbr3gBG42cANXtbO9XzZqQeFksCIfcu5cPIFkW6SiQEi0g74D+67YrN3cVsRWQCcoaqbK905yrROstJuJrwCjWzOw11MH4eyMX6a4wbzVlR+5zj/jSsqqxOobrqC3TRll7gi8422bWDR3l60TnRxbnyrtKp2N6Y2PsYlZO4HLOHQXvW3ItKqCHnqrcf5utuFxGkhFy3dTfJpVlXHBORxXFaK7qq6BkBEugLTvetiZhxBahOb/WvCK9AAMIvQVieos4rK6gRqPB/QnRXclfcozXZnkxO/h6zEjJC00xivp70/b6tgneJufhqEDZt/4PPOA1DxcMzOpZx+fbDy95oGYDxwTEnwB6Cqq0XkOuCTyneLPs0b2U2PCa9Ac5H9CbjbmywzXHbg7uwqqlsatJqlZ+jrjGEObdjC5Ol3cPWM5Xy7byxtM8sScYqVeDNBpqqeKl4NJvgDePr9F1kcfxhJmsvFK/NISLced1MjFd3wR01Vm0A1SrMA0IRXoD2AvwM6A9tEZD2HPq4aGOR2oar5IrIQd4f3us+q8QRpen97Xc/ZvFr6ubjQw8knJHHUyWNp3SgZft7NvpnraXJ69yqOYoypraU/fsWsTkMBOHHrUsbfdEmEW2RizCfA30XkAlXdAOAtg/gYMdQDKChpjVtHuhmmgQk0AHyj+k1C4hHgJRH5BleF5CqgLW5SSp09yI0AzP3iAkSUy649gaajj6BZSQ3Gfs1J6dc8GKcyBgAR+RI4SVX3eD/fD/xVVXd5PzcHFqlqxwg2M2xemPcBqzqdQYbu45L9GXgSbSC8qZHrcBU3VotI6SQQ3LjamJlJJEBKpv/DLmNCq9oAUETiccXr56nqztA3qYyqviYizXB1F9sAS3Ffnuuq3rNmiovjiU9Kpd2YI4N5WGMqMhLwjXJ+g0uztMv7OQ5oF+5GRcKcue8yq8NwAE5bt4SRV1wd4RaZWKOqG0RkMG5iYG/v4h9VdWYEm1ULSlJ6k0g3wjQw1QaAqlooIm/hLq6wBoDe808BpoTi2Lt2tWVvVjf2NR3LPb8eEYpTGFOdBjvA9OW1P7C57fE0L87i8sY9EE9QyiObBsZbpu1j7ysmCUp8qk08NOEV6P+43wP1biDcsqXjOPBjGx657ijSkq2WrzHh8vJbU5jZxqXzvHDFd/Q54/gIt8jEKhGZLCLLRCTbmwIGEfm9iJwbxHPcKSLq99rqs16822wWkRwR+cyb4imw46N4kpKr39CYIAo0ALwTeFhETheRDiLS1PcVwvaFXGLHBjHUykSPkgL2/ssajMKiAt6Mi+egpNOn4Cd+OXxipJtkYpSI3IAbIvQM5XvTNwHXBPl0P+GGIpW8BvisuwW4GbgWGAZsBz4WkcC79TwJQWuoMYEIdBLIDO/Ptyj/ZSXEaM6yDoUbABg0fEiEW2IaGAGmi0ie93My8KyIZHs/1/uu6AemPshXXU7Co0VctGglbX5/XqSbZGLXVcAVqjpDRO71Wb4ICLgHLkCFqnpICjIREeAG4AFVfdO77BJcEHghZTk/KyUoxNkEKBNegQaAx4a0FWF2uT7FuA0ZNMk7hkFHDot0c0zD8qLf5+kVbDMtHA2JhKxdG3m/fV9UPIzb/yXnXhnsThrTwHTCTQ70VwCkBPlcXb0zjfOAecBtqroa6AK0xpUpBUBVc0RkDq5safUBoAKemOtHMTEuoABQVWeHuiHhdAwzabv8L/ywfxeHS4Mdg28iQFV/Gek2RNJdb73Mqm4TyNC9nLnaQ8aplvzW1MlqYDDgnxniJOCHIJ5nHnApsBxoiXvs/KV3nF9JAr+KypZWOqPft3xpao9uYN9FJswC7QFERFrhUlb0xT32XQb8Q1X9f+mj3qIFJ7F43fMkZlwY6aYY02DMmf8xM7u4tC9nbP2K0669JcItMvXAQ8ATIpKKG14xSkQm4cbkXRask6jq+76fReRrXPB5CfB1LY9ZWr40vWe3BjUO2ESHgCaBiMgYYCVuPEMOkAtcBPwsIqNC17zgaa7bS98n7mhNQvqZeOIt87ox4aCqPLVqDXs8TehSvJpJbccRF2dpX0zdqOoLuEmKfwZSgZeAK4DrVPW1EJ73AK4TpAdlpUlDWrbUmGAL9H/gh4B/AT1VdZKqTgJ6Aq8CD4eqccF0Li+Xvt+UPYS4hM4UJFiXuzHh8ORLTzK75WAAzv/pWwYcY2NvTXCo6rOq2gn3aLa1qrZX1X+G8pwikozLjbsFWIML9Mb7rT8S+DKg4zWsRAAmSgT6CHgQcKmqFpcsUNViEXkE+DYkLQuy0XzBrhWX07RnK15LLWR4rpDS18YfGRNquXk5/Kd5C4oknjF5X3HZpN9HukmmHlLVHaE6tog8BPwPWI8LNP8IpAEvqqqKyGPAbSKyHFiBGyN4AHglwDOEoNXGVC3QHsC9uJlO/roAe4LXnNBpM+shenxbyB3H9uKgB2alFpCfYo+gTOzzJsJdIyK5IrJQRCqtaSgix1SQ0FZFpHdl+9TV3c8/ybKUXqToQc7dmE9GRlqoTmUaABFZIiKLA3kF8bTtcU/BfsKlQ8sDRvqUJf0L8CjwJLAAlyfweFXdH9jhrQfQhF+gPYCvAv8UkVso69IeAzyIuyii3sZ9TcjYvxaACf1a8eGybZw3zJJAm/AKNHG6qu6qfisQkfOAvwGTgS+8P98Xkb6qur6KXftRVn8YICuQ89XUt4u+5t0eLl/uxB2fc+7l/xeK05iG5Y1wn1BVz69mveLGIt5Zm+Nb/5+JhEADwFtwv6PP++xTAPwDiInnOU2/vJ92B7cAlzLlF0PYsjeH9k1SI90s0/BUF2jVNLn6TcBUVX3W+/laETkBuBq4tYr9tofykVmJJ1fMZ3urI2lbvInJvU5ALNWFqSNVvSvSbTCmPqg0ABSRo4AvVbVQVfOB60XkVqCbd5NVqppd2f7RptOFJ5LUrSsAcR6x4M9EiuBylk0FZlOHZz8ikggMwU3S8vURLgFtVRaISBIuV9q9qjqrtu2ozJSnHuPDnq4Z5/w8n77jrOSbCS5vHr44VV3st3wgrnJHMHMBho49ATYRUFUP4CzcOIbtIrIaGKaqO4ElYWlZkLW88YZIN8EYcHk0L8f10F0EvIDrwdtci2M1x/UUVpSA9rhK9tniPfd8IBGYBHwiIker6uf+G/smq+1Yg7rZWzds5l9d21MgiYzMXsDvLv9DwPsaUwPP4Mbd+Y/364urBXxE2FtUC9YvbiKhqlkQuymb+NG5mm2NMQFQ1eWq+jvcoPJbgFHAahGZISJnhOH8P6nqU6q6UFW/UtXJwAfA7yrZ/hlVHaqqQ1u0aBHwee777FV+TuhOI93L9UktiU8IOOe8MTUxEPimguXzgQFhbksdWBegCb+qgro3gdkisgb327lARFZX9ApPUwPXjg08q5PoqzHZWWkaAO/Qiv+o6ilAd1zd0jcCnSTitQMoou4JaOfhEtoGxfNTHuN/7UYCcO7aLzj2uFODdWhj/BUBFeXzaoJ1rBlTpapuy68C3sF9MTyCe1QV4JT2yEoin1Syiacw0k0xplIi0gVXrupi3E3WPbiUSwFR1XwRWYhLQPu6z6rxuBu4QA3CPRqus6z1a3m5a0tyJZXDcxfzx4us3JsJqdnA7SJyjqoWAYhIPHA7MCeiLasBi1RNJFQaAHqntc8AEJHDgIcDz2kUHdQuKxNlvBUCzsGNAxyOu8n6FTDTe83V1CPASyLyDTAXd+PWFnjKe75pAKp6sffzDcBaXBmrRNw4xNOBs2r9h/JSVe79/FWWtT2BVD3IDSlNSUpMqOthjanKLbj0RytF5AvvsiOAdOCoiLWqxuwRsAm/gAbmqOovofTLqzvut3WVquaGqmEi8hlwtN/i16rLx+Srb/4mliQNormNPzLRYysuefpUXOBXkouviW+KlEDzAKrqayLSDFd5oA2wFDjJJ0Gt/8yNROCvuDGIObhAcKKqvlebP4yvh578E2/2PQWAc9bPY8KlN9X1kMZUSVV/8s74vQbXkw3wMjCllhOrjGkwAoqMvF3q9+MuskRcj3WeiPwduF1VC0LUvheA23w+59Rk57OSPmFIm18yvkvz4LbKmNpr5H3dgSsn5a+meQBR1SnAlErWHeP3+S+4qgVB9fqLT/Bi3yMolASO3LuABy34M2Giqltwj3xjlj2rMpEQaNfYX4ALcI+XSrrZj8QFhR7gt8FvGgDZqlqTwezlJKYmcXHvtsFsjzF1dWykGxBsc2ZM5/F2LdghLelUuI6/jzgx0k0yDYSIDK5qvaouCldb6sSeAJsICDQAvBC4zO8x0SoRyQKeI3QB4Pkicj4ur9n7wF2xNg7RGF+qOjvSbQimWe9M594U+DmuF02Kd3GXJtK6TbtIN8s0HAtw4ZNvJ5pvOBVwT3okiUWAJgICze2XCayqYPkqoHHwmlPOK8AvcD0m9+AGqVc6s1FEfi0iC0RkQeky61g3UUZEZovIHSJyhIjE9AyJp567k9+mZbIsvj/pup9bd23nhOOt98+EVRegq/dnF6AncD6uYMHJkWiQiEwWkTUikisiC0XkyEi0w5jqBNoD+D1wHfAbv+XXA98FejIRuZfqx2ocq6qfqeozPsuWePMNzhORwRV163u3fwagV68ku50y0WoDrrLGnUC2iHyJq7rzKTBfVYsj2LaA/PetF3k9bj9zup5IgSTRumgLt+0/wLnnBDw/y5ig8Jns5GuliOwF/oR7chQ2InIe8DdgMm641GTgfRHpq6rrw9kWY6oTaAB4C/CeiBwHfO1dNhKXbqImt/yPAdOr2aayi2QBLulnDyCwcR1WeN5EGVW9CEBEegBjgWNwN1f3AftF5HPgE1V9NGKNrMTKvTsY/fFbrGncHxX3ZG3k3sXc1+Uw+h13WIRbZ0w5ayibFRxON+FKOz7r/XytiJyAK794a2U72TeViYRA08DMEZGeuB7A3t7Fr1PDqfaqugNXvaA2BuDGc1SbsDYxsSUAXbpcV8tTGRNaqvoz8DPwNICI9MYNebgOd1MVdQHgQU8qq+O7EqeFHJazmBPWbOe634Rq+K8x1augco7g0iHdCfwU5rYkAkOAh/xWfQSMDmdbjAmE1C73bGiJSDfcl+F7uICxL/AwLg3MsJKM71Xsv58wX/ym3uqlqhmhOLCItMD1AB7r/dkdWAh8pqqV9hZEil1XJsjqfG2JSDGHzqEV3FCL81T160P3Cg0RaQtsAo5W1Tk+y+8AfqGqvfy2/zVuOAhAf1wOT2PqKuDrKtA8gEcDuao6z/v5UlwS22XAzap6oJYNrUw+MA43xjAddzHPwM0CrjL48/pJVYcGuU2mAfKdVBSk452JC/bG4hPwATcAc1X1YDDPF2R2XZmgCdK15Z9WqRjIAlaqalTXAvUdty4iC+zaMsFQk+sq0DGAj+G61BGRXrjHVv/Eldz5K258Q9Co6gYOrQJiTH3wBm6c6/3ANFWtUXJzY0yZKEurtAM3Tr2V3/JWuApAxkSVQNPAdMdNqweXjuVjVZ0MXAGcEoqGGVNP3QGsxI3xWy4i00TkMhHpGuF2GRMzRKRpIK9wtklV83E9+uP9Vo0HvgxnW4wJRKA9gMWUJdQcB/zH+34r0CzYjQqCZ6rfxJiABPV3SVXvBe71DhgfhXscfDHwpIhsB2YDs1T1hWCeN0jsujLBVJffpx1UXz9DCfw7LlgeAV4SkW+AubjqWW2Bp6rZz64tEywB/y4FNAlERGYCm4GPcY9++6jqKu/YwBdU1XovjKkDEWkM3IybBZyuqjFRwcCYSPB+91TmBNz48UJVbRSmJpUSkcm41GltcBM7bvSdFGJMtAg0AOyPq8zRCXhEVe/yLn8CaKKqvwhpK42pZ0QkHpdL81jvaySQjMtfNktVfxXB5hkTc0TkcNyY9CNx49TvUdWsyLbKmOhVpzQwIpIMFKlqQfCaZEz9JSK34R77jgZScTPcZ5W8rFqAMTUjIl1widTPAd4CblPVikqXGmN8RGUeQGPqKxHZTPmAz76ojKkFEWmGm1R1FW683f+p6vzItsqY2FHlLGAReSeQV7gaWx0rwm2CRUSO8v5+bxIR9ea+rDNVbauqv1DV52Ip+LNrywRDsK4rEbkdWIVLF3aaqo6NxeDPrisTDLW9rqpLA7MzwFfE+RTh/jNwOG7a/fsi0jGiDTOxKh03gPt6XAWaoBCRFBF50nuhbheRV0SkebCOHwp2bZkgCtZ1dQ+QAGwEJkd750RF7LoyQVSr66rePAIWkXnAYlW9wmfZz8Ab0VhWy8QOETkAXKOqU4NwrL8Ck4GXgVzgAlzpt3PqeuxQsWvLhEJdrisRmUr1aWBQ1V/WvGXhYdeVCYWaXFfhzpEUElaE28SQM4HLVfVVABGZDswVkbgAyxyGlV1bJhqp6qWRbkNd2HVlokGglUCiXXNcouptfsu3Aa3D3xxjKtUB+Lzkg6p+AxTiksVGI7u2jAk+u65MxNWXANCYWBEH5PstK6Se9MYbY4yJDfXlS8eKcJtYIcB0EcnzWZYMPCsi2SULVPXUsLesYnZtGRN8dl2ZiKsXPYBWhNvEkBdxZRV9Z9FPxyWEjqqZ9WDXljGhYNeViQb1pQcQal+E25hDiEg60N370QN0FJFBwK66VOuI5lmJVbBrywRFqK6rGGXXlQmK2l5X9SYNDFgRbhM8InIMrlqHvxdjfQZibdi1ZYLBrqvy7LoywVDb66peBYDGGGOMMaZ69WIMoDHGGGOMCZwFgMYYY4wxDYwFgMYYY4wxDYwFgMYYY4wxDYwFgMYYY4wxDYwFgMYYY4wxDYwFgKZGRERF5OxIt8OY+sSuK2OCz66rqlkAGENEZKr3F9r/9XWk22ZMrLLrypjgs+sq+tWnUnANxUxgkt+y/Eg0xJh6xK4rY4LPrqsoZj2AsSdPVbf6vXZBaXf3NSIyQ0SyRWSdiFzku7OIDBCRmSKSIyK7vHdpmX7bXCIiS0QkT0S2iciLfm1oKiKvi8hBEVntfw5jYpBdV8YEn11XUcwCwPrnLuAdYBDwDDBNRIYCiEga8CFwABgOnAGMBp4v2VlErgSeBl4ABgIn4WpU+roDeBs4DHgNeF5EOobuj2RMxNl1ZUzw2XUVSapqrxh5AVOBQtwF4ft60LtegWf99pkJTPe+vwLYC2T4rD/Gu1937+eNwANVtEGB+30+xwPZwEWR/vuxl71q87Lryl72Cv7Lrqvof9kYwNgzB/i137I9Pu+/8lv3FTDR+74PsFhV9/us/xIoBvqKyD6gHfBJNW1YXPJGVQtFJAtoGVjzjYlKdl0ZE3x2XUUxCwBjT7aqrgzBcbUG2xZUsK8NJzCxzK4rY4LPrqsoZn8J9c/ICj7/6H3/IzBARDJ81o/G/R78qKrbgU3AuJC30pjYYteVMcFn11UEWQ9g7EkSkdZ+y4pUNcv7/kwRmQ98BpyNuzhGeNe9jBt0O01E7gCa4AbQvuVzl3Yf8KiIbANmAKnAOFV9OFR/IGOigF1XxgSfXVdRzALA2HMcsMVv2Sagvff9ncBZwONAFvBLVZ0PoKrZIjIBeAz4BsjFzY66vuRAqvoPEckHbgYeBHYB74XqD2NMlLDrypjgs+sqiol3ZoypB0REgXNU9Y1It8WY+sKuK2OCz66ryLMxgMYYY4wxDYwFgMYYY4wxDYw9AjbGGGOMaWCsB9AYY4wxpoGxANAYY4wxpoGxANAYY4wxpoGxANAYY4wxpoGxANAYY4wxpoH5f1iZ5h354GJ5AAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2IAAABSCAYAAAA2PWeiAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJztnXm8VVX1wL8LEHFAVEDAEZD3xAkh55xLSzPNHDKvmfM8mzZYv3LKykytzJwqLbuaZU6ZiKLmbCiKiDOI5oCoOAGiAuv3x9r7nf3OO3d4z/cug+v7+ZzPvfess89Z59x99t5rr7X3FlXFcRzHcRzHcRzHaRzdFrQCjuM4juM4juM4nzXcEHMcx3Ecx3Ecx2kwbog5juM4juM4juM0GDfEHMdxHMdxHMdxGowbYo7jOI7jOF2EiPQRkRUXtB6O4yx8uCHmOI7jOI7TdXwXmCYiF4nIqgtaGcdxFh7cEHMcx3Ecx+k65gJLAAcDz4vIVSIybAHr5DjOQoAbYo7jOI7jOF3HHGAe0BPoBewNTBSRS0Sk3wLVzHGcBYobYo7jOM5nHhHpJSKvicgvkn3bi8h9IjJbRGaIyK0iMjDIjhGRl0Tko5CunKTTgm35OvX4gYi8HNI8mZNdUem8IvJfEbmhynl3EJHHReRDEZkejICeIjK4gr4HiMiyInKHiMwUkWtEpFs419dF5LYa97GmiPxDRN4RkVlBv62S5/NktfSLCiKyjIhsICJ7isipwdt1u4iMF5EXReRt4Ixcsh6YQbY/MFVEfigiSzVcecdxFjg9FrQCjuM4jrMQsC8wCLgMzAgDbgNmAz8D3gZ2BQaIyErAb4F7gR8DKwOb5M73CnBK8ntWKhSR04DBqnpALt0SwFXADyro+RZwbMF5LwUuFZE1VXVyQborgJWCTrsDhwH3Af8E9kmO+xGwLjAeKAGfA34CnAP8QUTuAX4OfL2CfgRj9QGgf9DrEWBTYAT2zBZ5ROS7wKnAMlgeAVia9rWrlgzbWcC7wO8wY/diLC/OAg5CdXblUziOsyjjHjHHcRzHMaPjaVV9Ifz+CVZHHqqqZ6rqRaq6IzARGB6OeQb4u6r+TFXzhslM4I6w3aaqn9SjhKqeoaqnVjlkFvAv4G+qek1y3psBAb5RIV03zGC4A3g67HtXVWeF81wD3A2sBTyoqk9gRsZ7Ic1HwLLACcAYVX2qio5HY0bfpap6hKperqqHAr/PHxhmFPxj8NK9JSKXisgyQXaBiLwZvI5TROTwsP+c4FX7XPh9VPi9u4jsl3gqp4nI70WkezhuhIhMFJF3ReSskObuWnpUYAVgufDMJexT7H9/Bcsn/wH+AdxJzhDHxo3NCc92a+CisH8DzAgjPP/NqujgOM4ijhtijuM4zmea0FDfDBiX7N4wfI5Oj1XV+cB/McPkUOA9EblXRPKG2HDgzbA9Fq7TTUT6hXFBSwNLxt8x7K8OVgc+AGaLyIUxnaq+AfwP2KpCuv0wg2Ei5g27XFVvzh1zMObRiQbTDUAf4HFgOjAJOAIzUqtR7dnluSDodgVwedAhhvI9DfwQOBl4A/idiKwO/DXI9wyfe2EepVswj+G5wPHA2KDvN8NxVwBrYx7OEe3Qo4h/hO0M7Hl+Aeivqr1VdTVVHaGq26rqXpiXNd57NMD+AoxQ1R1U9V5V1SDfIXedravo4DjOIo6HJjqO4zifdaJh9FqyTysci6pOFZEtscb+DsCWwBYisr6qTgqHTcUMNYAPw+fqwIu500UjYUhIU407gbswo+NkzPP0MNaoJ+g/uELaUzBjYB9gZ+AQEblFVW8AMxKDvm8Dfw/3+aKIrIl5yZ4Efg38CthWRH6OGaNHqWo+3LDisyvgq1hbJA3jjMbIUOAY7L+JrKOqo0VkErCHiFyAGZ9/VNWPRKQPFtY5KEmzftg/CrhfVX8hIk3ALnXq0QZVfZTK3sc8c7AQxA+BG4Hvq+pLbY4S6Q1snts7CpHlUH2/zms5jrMI4R4xZ6GlYBD5jDBgvO+nPO/JcTB6+D1VRGbWSPN5ETlNREZ24Hp7huud1jGNHcdpEJJ8fzR8fqnVAebV6qmqj6jqfliD/4qQdp3k0FmqekfY7g/7pmGN+x0w42lM8ntaLeVU9c+qeqWq3oiN2SJ3TSlIhoj0D/fxSAhBvCSIUkNjR2AN4ApVnZNc8x1VfQhoBjbGvGUXAWdiHqFzaEvFZ1fh1tLnsgNwtIgMx9bfeg4zHP8Yju0VPq8KOv0E6B5+g3m2lsVmJjw+lwaqG4lt9KhybHt4CntWG6rqPoVGmLEtbTvIuwFbdJIejuMsZLhHzFkUeAz4JRaGsjcWa39weoCIdFfVeR08/7HYtMLV+DxW4U/FwnQcx1l8eAvzVqyc7DsdM5QuC96TtzEPyqnAEBH5AXA9FjI3CmvgT0rS9xGRbya/R6vqu9iYIIJHbb6q3pEqIiJbYwYGwAoicggwXlXHi8hdwK1B32PCMQ8nyVfGPFd5ZmBjvTYXkWPIDKRnk2MOD/dwCcVcAHxHVeeFUM6dsMk4itoRvwvnO0JEwAyzjYEnyMZCRf4FHIBNhDIBC2ucD1wY5EsBqwHb59KVgbOBI4GXaD0JSE/My7lb3KGq74nIY+EZnELbEM5KenzqyUVU9TlsMpjK2INKDeMpmEcQLDzx1k+rh+M4Cx9uiDm1EcmPI+g8VHepfRCvqerVIvI4NtvXpiIyFWsEXIlVcNuE6X/PA9bHQnR+oqpXg3nBgO9j4xzG5c7/W6zSvk5EemINsBI22HwcNivaL8OxfxKRP2FhREsBv8FmA3sHuEBVzw/XK2EhPB9jFbzjOAspwbh4ENgo2TdWRHbEOmB+hL3LD2OG1yeYcXMisDw2OcNRuQksVgWuTn6Por5OnIOwac3BDKvLsDJpPPA81nHUH3gVOCkJLRwQrpk3dOL9fQP4BebB+gAzuC4OaVfBvE53qurz+fQh7TuqenvYdTJWvs0h1ykWrveGiGwRrlfCDJxnyMZ2pZyAjZv6Rrj3Z4FfquozInI+Nv7qGMwQOTy5xssich9mUJWTMVYnYiGUP8ZmbNwuudYBQYeTMUMOLMyzoh4F+nYVQ7F6BSyvnYN5HwVYF5G+qL7dQH0cx2kAkpVdjlOBBWSIichgbDzFGOBbwCFYD+itWDjOGli8/S1hm4gZWn/GKt8vYr2aijWAJmGG00+wBs6BqnpFMOr6qeqyIvJjrNFzK3AdZtSdjRl4+2INl/8E+ThsVqvfYwO/98J6U/+Lec5mhHMdh00HfbqqntbBJ+U4ThciIgcBfwCakpkTFxmC5+xSTP+i6es/84jItsAAzLt5AFamH6uqF1ZJ1hhEjgS+En7dhep5iJwJxHD4PxCMbsdxFh/cI+YsCnwJM7DAeoFPxWbzAtg/hJzsDKwYtrOTtF8AYsji+ar6BxFZDevhLmIXzHDbW1U/iDuDN25f4GFVvUZE1gWagvjMJP0OWEx/L2zw+KUiMg+bhctxnIWXv2LrOR0KfG8B69IRDgNuciOsKn2xTrV+WF1yOgUexIZjkRjbJHtiuOo9ZIbY1mT1nuM4iwluiDm1qS98sCt5GJvCeAbwVJgZC2ww/Hu5Y/9MNoMYmGdq5/Bdcp/toZLr+DZsquTINGDNTrie4zgNRFU/ovUYsUUKVc0vKO3kUNXrsEiHhY3NsOgKsDpkYvj+IHAU1lZrQmQQqq8vAP0cx+ki3BBzFgXeUtWxNY55EDPUdsRCBntg0xGfiS1SCnBCmLXrwCrnuRkbJ/I3EfkHts7LCdgYMICdRGQ28E9svMaW2Fo1s7HB5Ndjxtkc4EAReRkLTXQcx3GcItLZJe8gjhlRnYnIo9g4ZLDxcNc2WDfHcboQn77eWSxQ1RmY4fUC8HPMgzYbmKqqE7C1YQZiA93/U+VUPw/beljIyufC/puwmb/2wAaGzwW+BtyPhTmeCfQGJoaFVQ/G3q/vAQ912o06juM4iw8iKwEbhF+Kdeyl3JN83wbHcRYrfLIOx3Ecx3GcBYHIvmSLej9KfkInkV7YGmlLhj3Hojq1Ueo5jtO1uEfMcRzHcRyn0ViofLo+2h1tjrHFtdO14vLrnzmOswjjhpjjOI7jOE7j2QCbwRFsbbeHKxyXhiduHRZ/dhxnMcANMcdxHMdxnMazQ/L9LlQ/qXDceGBW+D6QbOkUx3EWcdwQcxzHcRzHaSQivYHNkz23VzzWDLQHkz1bd5FWjuM0GDfEHMdxHMdxGoHIEoisjy3AHZcQer6OCTjS2X63CuPLHMdZxPF1xBzHcRzHWTyw8VPdsfbNfGAeMJ9qU0RnaboDAnyM6vxO1GcINh5sJLY0Ss/cUZW9YRkTgfeAPsCKwLpkCz87jrOI4tPXOyBy3oJWwXEcx1ks6OhEElKwdUtklc6/BGZ09Qzfe1bQYV6yzceMrm4hbZF3aS7wMfBR+PwYqDSGi3COqEu6Rb0qMR2bkn52lWMMkSOAncOvt4EZRUcFXeKW/gZbq0yxZxA/0/0pmvtsL97AdD4L/ArVVzua2D1iDvjAX8dxHGfxJnq86iUaUkt3gS6vA4+HbXyYor4e7iEzxPqGzXGcBUvew90u3BBzHMdxHGdxQjHvlWDtnHq8dNFbBubB6swp4t8DJmCG1wRUp3fwPE9j4Yjrd5ZijuMsWDw00XEcx3Ecx3Ecp8H4rDuO4ziO4ziO4zgNxg0xx3Ecx3Ecx3GcBuOGmOM4juM4juM4ToNxQ8xxHMdxHMdxHKfBuCHmOI7jOI7jOI7TYNwQcxzHcRzHcRzHaTBuiDmO4ziO4ziO4zQYN8Qcx3Ecx3Ecx3EajBtijuM4juM4juM4DcYNMcdxHMdxHMdxnAbjhpjjOI7jOI7jOE6DcUPMcRzHcRzHcRynwbgh5jiO4ziO4ziO02DcEHMcx3Ecx3Ecx2kwbogBIqJhG7ygdXEcx3Ecx3EcZ/GnoYaYiAwVkX+KyHQRmSMir4jIaBFZs5F6LAqIyFIicr2IvO6GouM4juM4juMsXjTaI3Y98HVgIvAn4DFgc2BQg/VYFOgJbAiMW9CKOI7jOI7jOI7TufRo1IVEZEVgBPAusL2qati/JNA9fB8E/A1YB+gTjr0NOEZV3w0eoRfDKY8DfggIcDIwGzgfWAr4lar+PJzzCmB/4GJgMLAN8BRwiKo+XkHXvsDZwJeBvsATwPdV9d4gLwE/AoYAHwLPAqeo6n0F5xoGHFPl0Vyoqi/kd6rqe8DqIrI88E6V9I7jOI7jOI7jLGJIsIe6/kIiSwAzgGWBCcCdwD3A7ao6KxzTDPwVeBIzcLYHmoBLVPWInCE2JRy3K/ARZqyMBUpBPlxVn0sMMQX+CayMeeFeBYap6hwRiQ9hCPBy0GsL4F7geWAvYAlgZJC/B3wCXA0sCXwOOEdVryy4722Bu6o8mu1U9e4qzy01xIao6tQq53Icx3Ecx3EcZxGgYR4xVf1ERA4GLgU2CNuJwBsisouqjguG02HADsBKwCTMEPtCwSn3Bx7CDLYlgTNV9SIRWRszjDYAnkuOv1FV9wwG4SvAKsAXgVty590QM8I+AMaHfS8Ao4ADgbMwD9504AbgKVWdIiLdK9z33ZjXbqFHRAQYDsxW1Zc66ZxLAWsBz6rqh3UnLMsgzBv5FCWd3xm6OF1MWQRYA/iQkr7RgOv1AvoDr1BqUI9SsR49gNWB1ym1I487jvOZQ4TVgG6qdEod2yWUZRWgN/Bs3WVrWboBzcB7lPT1TtJjOaxOeY6SftQp53TqRoRuwIrA26q0zgdlWR6rfyfn22giDAT6qPJsm5OWpQmYS0lfzO3vhrU/32mTf8rSM8hepaRv52RLY/luMiX9oN03uRDQMI9YywVFemHhgVsBh2IG182ququI7AOUC5K9q6or5Dxi/VT1bRF5Fwtj3F5Vx4rI3eH8B6rqFYlH7GeqemrQ4UFgM+AIVb0k5xHbGLi2gvrXBWPuMOAnmHcNzLDbr8iz1dHQxCR9QzxiwUC9GDgo7Po7cICqzg7yq7BQzfNV9eywrzDzqKoE+arAaGBd7BntpKpP1kpHWfYHLsO8kJOAPSjps3JohXSXhXQiZwCHAdejemTNe65yvkbKOkKjdawlC8bIhcDhmPf5CuBIuYs5FdNEREZjle3JqN4C1f8bAMryeeBGoB+WR0qU9Ima6dpJHXoMBG7Cyo33geMp6RV15NWhwB1h9whUZ2YXlS2BXwNvofrl1grJAcCpwKOo7vNp9O+SfGA6fgn4I/AmqqNy+h8JnAY8jOquOdkvsLL6alRPrKV/0f7c+ZbEOuME2BHVpxLZcCzyAWAIISojyHYCrgTeQHX9lt217/tXwH7AX6P+2SnlemBL4CxV/XVONgGrSw5S1ZvDvlpl69qJ/mvEcjrIdsbev9dVdUTuWscCPwbuV9XdaC08H9gXuArVk3KyG4DPA2egemFO9hg2zvtAVG+FBZTvOoo9/wHAAaiOTvYvA0wOv7ZG9blEth72/iowGE2MBJGvYvXXK6hu3PpSHIu924INpfhOmwZuF1NHmXY08BtsDoFxWP37vxrlfy8sz+0ddl8GHC138XHVa1WjLJsAN2NtxDeA/Sjp7XXoPxh7tn2wCKs/VjMmq9XL1fRc2NsI1ajnfRJhEOaoGAXcB+yuypsAlOWrwDXAMlj9+w1KVr6K8A3gL9g8B9cC31LlE8rSHTgPG1YE9t/uS0k/CMbUVdgcEgpcAhxLSedSlpWwOnZTYC5Wf5xNSZWyNAP/BtYEZgFHUdI/mx6yIrQYghunbWcR2Qi4FYtsW01V54X9tcrd7wPfAcao6r7pMSJyadD/ElX9UdF5KtGwyTpEZAkR2VJV56jqbUHRnwVx7/AZX+JLMC9X/F30Msyr8TvP2lEPYGjY90rBcVPD5+tAL1WV8CcsTWZQXamqq2CV5/HAqsD/VbjuquGYStuqNfRuFGeRGWFg4Zg7Jb83xBq9rSr2SohIN+BfmBEGdp/VDFKjLF/ACvQlwp51sTGA9TAKq1A3rPN4p/P4KWaEgb2vB2KGe3VEemCe6eFY6G9trKIdi+VHsDzyy3bo2jlYxTIaM8IAlgP+FHr2ajEc6/gZAgzLyUZhXv0vIbJ0TrYhFiWwTUfVbgDrYREHIxFZNicbgTWsNm6Tyu55QPjsDNbEPJWrEcr/hOFYb25/2j7/dcP+9UJjvF5GhXSjCmQbYfl1/XSn2P87IsjWace1hoc0/bD7TFk3Xkva5p94raIyspb+/cmX/3b+kdj/tm7bZAs5lj9HYPrnn/+wsH8AFtWRMjzsH0jWnoisF/ZvGDoDwqXYFTNwYnvmRBa2icrK8nWsQy2WYRtTT70NvyVrr4F1sm/xKfRYCTN0Vwp7BgDn1pFuGPBfYDdgO+Bysoa/Uyci9MCefywLtgSOBqAso7BO0Fg2ros5JhBhQ8xA6xlk3yAra35A6/9iF2D38P0izIgBez+OADYNUTbXY0YYWBTfWUB/yrJU0DGWf8tg+TDSTFZGNuduce2wfxBWR9TLBiFdUR31uSDboB3nAxoYmogZVveKyNPYbImzyR787eEzhjN9BWuIf6UTr7+riPwDM55WAl7DxqnleRR4EBtHNk5EHsAK1W2wgvMKLJzy7nCOWLG+W3TRTxOaGLx5PZNd54rITOBkVX2rI+escJ1lqFLYhrDLmNmb6jztF+lAhgRO6UCaSHPLp4jQaHfvZ5Wy9AaO7WDqwWTlUL6wrMRJQK/cvgUR/rsTHcvj0Ppem4F04qD0HRuGTRaUTzcIkd7oQhmKkde/6N4GFujfnPvsTD3y5VZeNqGCbFhOVs/1Wl0rGEOrFslobUTVW7bmj23CZiIukq1ZQbaqiCydetKooH8wtlapoGNqxHbW/9ZIqumff0eryZ4ukAn2/KMn9tPUbY3ie+1OYUbTgZ2sx1FkHfTt4QyswyBl4TJ2Fw12o23HRDTOT6GyE+ckiupiCy08sc1+k62MRRIUsQXmiS9iH6yTrRL5MnJMFVnrMMna51xTRLonnjShUvlZB400xOZg7uLtMANrKcwjdRFwTjjmdOwmNses6LOxHqTO4CKs0TcSG/t1aNGYJVWdLyJfw17onYADMAPxFmxMGpjhuGmQzwqy73SSnin7537vET5PAzrNEMMmRVkaMyZ3xMIx0vCTNcg8VE0iImpEd61CElpoxLCX+4CdsXF+26XHtUlXlmWx8YFgDfvLsZ6RtSFxmQeXei68rQdZz2QfrGfizWo3Xe18jZa13MahopXCIfKyhUb/suyBvc/vAF8F/kfIP2n6CvdW2Fiu8axiL9rvsTCrPcN1az9jkVOAnwPj82FDRdTQP+oxDutUGoKFV9TzX1czEvKNvCcqHDsM69SqqX+D83F7jEzT38aSxkq1yEjrCO0xxKrJJkDN8ic1tlZGZNkk3DRt7NelR42yFdpnJEysIMuMfPMMxVD7VRBZJgnXbL/+XZzvPnU4Yg39O1n2lAj9MK+CAt/EOoGvare2nUCVcnxlMs/DAcA/sGiUpfPpWj3/shyEjZufhkVBzMBCE+uq8yoQO+mvxIyy7YMu1fTvTVYmX4d5bY6u83rtZlFoI6T723mt+Bz/A3wby7PLhiEIMaT8DOBXQb65CN0xLxfACVh4evRQbYWNNZuJ1dVPhLSENN0wx8aXsBD/y4MstiOfwNqmy2OT5AF8LXyOxjxv62NzUETaU0aOgerlbjC2YrolsHbxlPC7PxYRAzBURHqo6lzqpJGTdczFrOVqx7xG24k5fpvIp5KztlV1+dzvbSuc/m1VLey1z1dyqvomUHGMkaruVUnWmRRUvl3FeuHzfFV9GEBEvkXWMIoVy6tYz+gArNCt55zfUdX3gRtEZHy1BFj4R3fgIUot4xAuCOEGtVgDy89RxyZqGGJOpxH/6/Mo6QMAlGUvsl70asSCbRr19KiXpW847zRsPNYnwMWU5Z7qCVsYhRX66yOyBKqftEhE9sPKn/tRvbxC+pToDT+ckr4KvEpZaodjGs1YZ8oKFFcS0zHPfSazMKc1sHsfGGRVDbEFRBMW2j2ItFFqxtbqZO9oqv+aWNmevr/jP0VDDqrnrWasg61/BVmqYz3EMiqmSz2BrcpPEemtmZHZnMja41Fqwu5rAMWGQPocARAztgblZNHIL9I/egKbW8laG2kd1X9hoZr+zcB8rB7Jy4rzeJbuNcywjeli2OYYVRuDLsI+1B5S0UiijrdSapkB+vQ66t9Y/v+Uklp+KsvuZKHj7cMa+2tjndxHU9LZwE2U5enqCRmBRV5NwMYszacs12JGXEXq6Cz8LBJDkA9T5WXgHBGaMWfGMsAzwGlh7N2FlOV2rGzvjXmAf6OKinAYZoBlw45K+h8AynJIOF/0lJ1BSScF2dexujHmrRPDBB6vU5YdsYi6KDssTNLxAGVJx702YTOqz6TOMrIGK4X7S9NFQ6x1GWn19OT8CSrR6AWdnYWT4eFzbNyhqnNVW2a1iRn19tzvaqyFvQCPJud8uU497mi1t1R5MpOE+CLcnvvtdD1t/7eSftxmVqRiYl66A+iLDbCtRhyrcVcwwuL1nio+vA1xHNqStB33cSjWE3xUzbNY7PpawNukHp+SPlvnLJ9N2EDil2htrERj606s9zx914ZiZXZ73sPGknm27sQasfkwOSjWvyNlTC1iY/nJgvM1YY2Jl2n9/JfBKtKxtH3+ta4F1e8thsYUeZjuAAaKSL3hWE1YONz/KDa2xibHReJ1xxTI6tE/yor0H4t5Atszpm5hoAn7n+8EVs2NyWzC8sczFBtbk8gbcCLLYQ22WBY2JccD3B0PVeUdVd7vjJvII4eKFm01ksXycGyrvbXr37bpSvohJf1fe3ROGIx5HB6klEyiU9Lna6SL40BvaCmDS/oRJc3PjO1UIXi2hgGvqGYzj4fvWV2fToBS0mfJ8sF/4gQ0qnysyjSK2wjzKekUCtqflHR26NwcjhlT9yeyadikHUOw2TT/l8jSvBpDDl+gdRkZwwjHY97b9pbx7S0/a+KGmANZJfFEDXlRBmyDWGU0AJgUY2g7SY9qdEVDzqmPWAAXLpBeg2asMIwGe63/LeaR9l8rW0ohdgiMTGRLYBMSAIyoo0E5EOsdm9DuqfNt5tjVsR6zKbTuNIjGVmxkF4VXRCNhYexsiI30avpHIzOVdcX7a1Ma2zYgNJLTMLyi55/q/wr1P+NqHUHxe75xHr+/hjXq0+tXJBhrgyjWP567rZHQVo96n3+tdK+SjYOqJ3phYaIJ+5+jtyU/Zm9K2DIjTaQP5kmNsqIG2UTMY5k3xDpStzWKqGO9YyLTdB9jBuuC1CM26B/uJD0+q6xO5lnMU63+jXm9KI9XkzVj3s/WHqRySz35TMHSBUOxCIrC9ykJI4xl5JAwUR9Y27Q3xeVnNfLt4KLys642cp5GjhFbIKjqAVgvt1OZ5bEQiZlh4o4vhv0vqupELFPNJCvgamXcPuHznapHFeuRpSvLF7H49FmUtGhilZSY8e/GekvcEGscywNzKOmcMM5vq7B/KiWtFU7SRNZYjr+rVaQrhM+YRzbEQh+Ukt5RKVFgPczIuRoblL4B2TiN9bFxbk+G4zYkmx68iHxeHUL2XjzSZq2T1sQwvMnEhetFVkR1RnKO+EzSWfZinn4KazwujHk86hT1H1EgK9K/WmO//Vg5tjJmWMTwkSbM4I/GwhSs3PsCIn1QfS/RaUrQv96ZAFPPVvo7fn+dbKxW3jh6jiz/1xNuGvWfjOWjbUVkuRACnn/+qdc3yp7EjL/2GFvRs5i/t2asAZ7q394G9IKkGbuvVP+JSLJGEi3rfcUxdekz7glslYRr5t/f+Lt1eVGACL2wsmcO8LRqx8MWOxjSmy/Tvox5pt6lpPdVSbdCOEYpywpksyU+RymZ8r9+8nqMIgtzH0NJC6fExxrYQMsU66tg78fHlHR6B/T4rBKjUmYUyPL/zRbY2KiPQavl8UxWliWxsWBgnXXLk+WfvmSTc7yB/X/xWquTTY4lLecz2dpk5eI9WF2+LPYOvo8NeTEPWuv3dxCwp4gsoekwhWJiunHhnPlycC6Zx7td9Zd7xBywGeg+UJtlcBA2yPVGLFQLssbyy9Rn5MTB8r6aAAAUL0lEQVQpe2dWPapYD7DFtMGWMbgJW9+sFrFX5XVsCYKF0VuwuLIk2X+9Graux7+BQ6qmMs9QHPCaNoRqXQuyPPILrBfq33XoGT1gt2Mhhel0+ZuFz4tzv+vVYw9s0PBoas+kGO8xve+m3OcLYeuHyAq5dPlG3sJEquMUWuufNxLyxspbqE7HPCyf1shMjZVKz7geWf/QKK9FEzA96P86be9tCtnMXE3QKnKgKB/Uuha5dMMqyAZI9ARmshcp9uS8EfSfViCL/2d2HvMMrUTxc1z4sXzZj/bnkfx7CG2ff5StHDywPcP+wjpRhO9i+WYcZrB3xID5tOTr3zK21tOvig9vYckkTXNIczM2q11HyJetJyfnrBapEPWP4Z5PYg39Gzuox2eVau23vOw3WN1brpGuF9bpNQczvG4K2/FBFv/rtRNZnJwuyr6YyDbMyfZLZEMpLiPz73aURSOtFk3hHl6muPx8CSs7i8akVcUNMQdsUbv8dOAAiEhPLJNOCROutB7TUvl8VDpnF6SD2FgwY3IKMAxzTztdz1xaL7NQLzG8YDK5RmqNa9HB60XDayJWSY9M8shm2Jimv2KVRS1DLOqxZNWjimlvIy+tQN7DegEnAysi0rcD1+9Kat3bDFTfxd7RdExgc3J8e8JFKlH0HOO+VMf8YOu8IZkeX+t6bfRPjK3JarMovpGcLzUW23utjujfDEwPE4UUGWmp/m2NLUuXTlxR7Tk2HpGLEXkQkd8VyNZHZEtE0gmE6s0H9eSf/Ps7JZENIysv2tRtIuyEdSg9gzUw18I6IRtNrH/bW6bNpQN1dpVxbB0tW6MHcbGP9OpiqtWx1f6bau23TzCDp3sFWVGa+H8WySq+T4H2lpH1lFvNwEvBczYZC3fsGdbMHYaV8bH92bmGmIgMFZF/ish0EZkjIq+IyGgRyS8iuUgixo9F5IVwf9NF5DoRGVwjXV8RuVREponIRyLykogcnTvmMBF5MshniMiYRHaaiGjB1i/I764gn9oFj2EW0CsYXTNp3YM0BMsn00VkIKG3OmS+SsS1aZarckwlPdJ0/6bC+mytyCY4eA2ROKPjMvj6IY1iFtA7LGT8AbacQz3Ewm86FkpQz8yJ+bx1H9aTXA8jgTdDr/+TWG94nLJ7U+DpYCQ8DmxWw5DP6/EcNvi3HuI9RqMq3deMvYPzyNZVTGUvY6EjcdbShc0D0YTlgR6Y1zHui5+vhHd0ess+G/M0EHg9yF7HjMxaE7fU0gOs/Hg/ty8+z5nYf5DX8X2soTEjJysmM1ZS/aMnMKZ9M5Sf6biz+DkDK6/S0NR67m1Wwb01Yfe8dIH+TcArQY83W/ZlYXip/iuF+2rRP8heyZ0v6t8rXHfB5EeR7bEF5d8HjkJk20TWF1t65l5sSu1Iqn9PWocbxc/3yHr487JZZPVTKnsb+z/T/F+tTvx2+DxSlfGqPKfasqRPI4n1bxxacAOZ3rXSxfuagUUF1EQvU8lPpx5+59sBD5M1mKsRdY36P4SNXTPKMoyy/IiyXE5Z/kxZzqpzRubPGvnnmJL/b+4gK0uq5fE03UfY8gKpLKZ5C7gtfP8kSQMW6fRA+P5xTjaR4mVePqDy+zuHtu9vIYmx9WooP6dj7eIhWBtiaWx94YFY2Pfg0J6ui3p6Dq7H4vzvxBobqwJbkw0W7lTqjNXsTPbH1i+bg/WGfx5bQ6EftohzG8Qa/mOxEKSJmOEygGSgsoh8H/gZVrj/DWtYbV5wuuuwyi0S1zb7B60HRG6PjVeoZwbB9vIi9h8PVdVnROQQsjUaYsPg8LBFVsHc/kW8hWX+9hrr0Sti6Up6HGX5PLUNujjBwY60nla/GXspnK7lRSykYA1K+iJlOZT6nnss/C4IG8AyNRbjjnnE1owr6WmUZT2ytU2KsYJ0A+ADRH5BNvZnJCJzsLzyCCIHYBXAIKysq5THX8He6ajHTWFh08uq6mHE+55UsK8Ji22f0UqWTTCxMq3XEGwCHhJhHSz/D8LehRdVW60F2CiasYHQb7TaZ56XgWHLv6OxUt2NbN0YqD1esJYe0LpTIO/ReKpA1oyVN3kdqxHPtzvZ+jtxfywDv0Oy1qS0NtIuJFu3sT0esaJFhJux0J+0c6JZsjC8fnkZWYfsHmThQFGXeN6TwxZvYPlE14vCVq/+nYtIdyx87mmsHJgInIfIRqjOx2ZBXRr4A3AwIiNRfTzR9WKykOR8Y61oEdj4TNLwwWayCQKWp3X+aaJ13dZ6VsJsmZhOb0+1k7RsvY+SHkw5MWirp9uSsvSnpM9TlhP4dBN35Mv431CWtag9m+3U8LkGNuPiTpTFzmXTml+HGQ6/wwzsZqzdVrlNVZbuWCddHIv8CdYZfU3BBBKLC1PD59ACWf6/+R5l2Qgb29i6/dY23RbAUEr6CGXZl6yseRHYlLKsQEmfoSwnY+vRfYTVg0Mpi1DSuyjLucA/yTryYlvxasqyKtmaxPEdvTvRId8BNrVAVolVsM7irWhbfkZDbz9aL0w9lDrfg6oeMbEeyRGY1bi9qh6pqrtgvX/jk+M2E5ExIvKmiMwUkYckzDAkIiOCB+2tIL9ZRNZK0k4Nnp4fisgkzCCKHqdLgvwDEblfRLaiAiKyiYhcUGWr1LsaM80tqnowtmo42BSqlfgW1qi7Cxipqoer6m6qemLQZTng/7AGxiaq+m1VPVBVhxec60JVPSHZZgGoast+4LtkAyg7a4HrlGfDZ9EK5pUq1ooVbnDPPoetmbN63B8M2I7qUY126+h0KvF/27Kd6YoKv95kg66rXau9eWRNrJd6IPY+bRv2jwQ2Cd83Av5ENtlI5fBEGzA+BVibcrs9N0X33ZxbVDd/fKWe22YRjsKMuoFYSNP5ZM+pcWRheHmaqKx/2tjP82nC3Ire/Xwju7Usmw2vnnPVI2/qgKxvlbqq2vWagrFVFKraET3qkRX9P/WOqetMDiBbQ+pRrIN5FLBfmCn1OMyg+i7W0Rnr+CL94+yald7ROPV1nibs2RfdezPZ+9jSGStCNxF6khl0I/IJG0zUcYuqR1VO194yuRLxeWwRlgmpl9joLaqHTsHau9/AjLGtsLKq8lpndu04/nga8BfgWswIWGzDH1WZiRmbG4hkY/JEWJLqeaQwH7QjXZGj4lmsTM7XHzOxDskNw+yKeSqVkdGzVc/x9chrlZF1USs0Mbr1lgceE5HzRGQ3oIeqzgYQkfUwq3MHrEfqb1jm7ikig7CVub+MuYkfw1bVvluyAdyR07GerH+Gh3UjcBgWinMtNnvYmNSIy7EONvCv0lbJq/IXrPd2ZxH5A/BLLP70p1WeS5xVsAfwooi8FwzMwWH/ZlgP3FvA5SIyS0QmicieBee6QURmi8gEESlVuN7eWE/3C8C/qujVUWIBdmQwoNPCr1JmqtVIiuc8HiC4bKsu6J2k+SplieevpyCuqyFXxzoqTseIBemRoVCst/LsSAH2EtZTtilliRVuPdeL48PmYOXaB8n+aHCNw2Zceij8rjVOLObXE+rWIwvDy1OtQG+uImvCIhQArlTlBVVeUW2ZhryRVDO2urQiqzPtCogMobKx1VE9OnJvzVQutypeLxhpnW1sVSs/G/2/tQ8zjEZiHRDDUF0Py4eXAp/DjLR+WPvhDmzZhL2xurq997YSFopUydiqdr5YVuwuwhrh+3eCbnHx+D+JsKcIO4rw+wrn6kqijnuFGeqgvrI1pjuOsixRZ5rK2Nph/8M8W1/vgB57hxkT03QxtHE9LJLheeBMoKhNFlkS84bFCT/6Aedhk4bsUoc+izLPYOO5jgYQYSgWERWN5C9SlvwMhs9j46y3EWFUSPdNrFMk/jeHUpbetP4/0/zTo4LspGAY52U9yTylAjDrI4Tiumg1zEtVr+FWj7xTOhKrGmIhRPBgzI27AbYC9vXAZBHZOBx2BJZhb1LVrYNXaS0sJG8/rNC6W1W/qqpfwsLtBgJ75S53tqp+U1X3wtzAW2CNpfHh8wXsAR5YQdcrVFWqbFMr3ObLmMu6F3AQthbFROC/VR5N7EXZAhuj8hxmYF6fk68czntDOO81IhJne5mLNfr+hsWujwD+KiJfLrje8eHzN6p1LRbbXmKoxEZYYzQfzjMXu5cBZI2+Whk3ToN8koiMxeJ316hyPGHl9KcwF/ADlGU0rWe2q0TUZeOg4xq5/TZY2z4Xi7GNCxnxv94cyz831Zku9hTHkLVDk/3FlHQeFiYNMJqy/Av4Sh3XivloW1SXQ3U5LDQhGmJzgW1Q3QbrUZ1FbUMs3vf/UZbbgZ/UoUcajhbv+1rMExjL1JMS2ThaN9q/nsjeDvtPwqbkv1GEsgh/EOGGOnTpbKKOJ2Lv4QDgEVrr/7VE9k5Otn7Yv1bufFVps1htNubppuRavwzS7cLnrxPZdVg9Fcvm4xPZY2SekFr3vW6B/s1Y/TUwyHYKstjYfyK51tGJrBJRdn6S7nosYuJzQXZsInuc1s9450T2Pq0NiHXC/rgwbmxkvJ+k2Tl3bxMS2bG559H1qCqqx6J6BKqWD1Tno3o49l6cjLUddsHKl72xBuaJZEsFRP2PC2fdCBsfc10ii6HT24bPcxPZTVh+iw3ToxLZxHCdKVh5sxzwgAj3EMKoVHnA9NKPgL8DtwLDKUt3ynI8ZfktZfkaZdmFshxEWQ6jLP07uGhzNZ7BQspXAB6iLGOobza5WA5+AWs3/a2ei4mwtAg7Jr9PFGmJRojnvCaU8d+q45STgv79gHFB/9gWOAX7n8ZiHq54vsrT2pd0DrD1vPndHp/10dK3T3+///ffnd1nqU/m9niYbEmDxZXYkfcLEUZjnuZ+lHQm1lHZA7ibstxCiCBRZQ7WHu4GjBXhdmw2RTBnzTysjHyErA6H7L/+MhaK/tcC2RHhHOcW6PgrynIrIfT7z/cyAGt3l8new4sxQy0ONzorkY0BVhfznlcilmnbhjSDsDDVtPwcHGRxPdK6O6RquldV9VoRuSncwFZYYTYAC73blexFfShJMw8g8RClsezPYI2ffKP8/uR7TNebzAiJFPa6isgmQCWPEsAZauv05DkdKzhvAvbFCuwy8G8RWa3CgsRxcOJoVd1XRPpjL/TIEIr3ZnLsV1T1TbHGwVewiuxR4Keqelai/9XAN7ExBrcl+7fCGgjvYWFTnY6qviwio7ExJuvkxE3AVFV9PegzK9lfjeuwl2ZFrICul8uwRkZf7MWshyasIf04NrMjiNgUzCIrYeGc2+rlnAM8hshFwOmofljphE47KOlkynIn9j+vV1caC8MbBIxD9Y2wL66fVCtvXYo1aJchaxjWGlcaG0npuKwnQ/oZwK0t+UF1HlbmrY1IdyovSl4Gzg56bF/j+pF4bxOT+45jlaIh9ngiezbsj2FLjySyF4B19So5FBsjdu6r76z8Uc/uH2/Yf7m3XqbMljXW/+ls4r09HiZEAZHnsIoprof2aCKL61x9jA30noSqIvImVt7VrshEercskiDSjGq6TsxTybXiGl6xkpyYyGL9lD7/VP9RWOMuLdfz9z0Lm+wl6v/+/Cwkc7KG/0xEYkj/uljZeKeGa4nIhOR8lWjJP0m6pzEDPd7b44nsOay+jWMiH01kk4FmBRGLfHkm0T9OwdyEzZgYn0fUfz3MeB2TyOrRv3GsyRLsxr2sxPKsSh+s93wYE7iMO7mfRzgOeLZA//gc0/zzZE6Wzz+7Upx/ngfWV6SPoJdi5UUc69mCIu/MRwZOY+DNyzJzs+X44HTMu/Ay7zGIe9mWbsxmAP3YgLn04L96Od2ATeQQa3vp5ewL3MhlQFmWJh3jY9EDb1LSyiHLJZ1PWS4HfoyVzfVOdjUB6zDamPo6ThGhB7EsvlyHYkZqd7J1Ii/DOt2XICvjq1PSeZTlYuCMnP5KSacBX6Msfdb7L+8+uQkbAPtR0qqTgcm+ehz23+6PjeHrBvRSXewXjf4LcBpm0OTbYZdinZSxTZuXbY39j1mdWNK3KMv1mAcy31HzCNZhNJKsMylyI1bu9idzAkSuBH6E5ZEWg/7eZ4je3ElJWRfr/fiOPpHInsHWNVuTbK3EPLFMezTMfkuYOK8JKyunqepLYf8M2ruWrXUoFW/hBrfM7TsBc+/fFX5fGH7fkBzTDbM+vxtkdyay8WHfYeH31PB72+SYjcO+14Alk/1LAQMr6HpASFNpG1wh3b+C/PTwe0iSpm/Ytybm0Vo2/P5ekN8SfvdP0qyIDeybG373D8fcEn6fFH4Py+lxdZD/Prf/urD/3Gr/1afZajw333zzzTfffPPNN998863Ore42eI0G+rLhhE9h7sLLsHFPCpwajokrwSvmOrwM84Atj/X6vBtkN2HTmio28HHFKoZYN2yaSsVCNy7GwvveAQ7oZCPkB+E672Ox2hPC76eTY6KOu4XfKwRd5oXnMi7Ib07SXBn2jQvHzMNCVAYH+YvAg1gPQnwu84BtknMMxgy6ucAaboj55ptvvvnmm2+++ebbwr3V2wavFZo4BwsT2w5zQS6FTdt8ES3xzfqk2JodZ2IhHBtjcdEfq+q7IrId8HNsPJVinqFTtDhMkHDO+SLyNczFvBPm7XojpH2oUroO8ksstGgfLG74fczo+24V/d4RkS9hAzd3x0KbLgG+nxx2FPb89sDCb+4DvqfZWLXLsHj1fTAD7AFsnNx/knMcg7nrr9Pg9uwKVLXa+AfHcRzHcRzHcToZCR4Rx3Ecx3Ecx3Ecp0HUmr7ecRzHcRzHcRzH6WTcEHMcx3Ecx3Ecx2kwbog5juM4juM4juM0GDfEHMdxHMdxHMdxGowbYo7jOI7jOI7jOA3GDTHHcRzHcRzHcZwG44aY4ziO4ziO4zhOg3FDzHEcx3Ecx3Ecp8G4IeY4juM4juM4jtNg/h+nhdgms63ccAAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "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" }, { "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" }, { "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" }, { "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" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "\n", "run_prefix = \"seqprop_apa_max_isoform_simple_20000_updates_non_normalized_retry_2\"\n", "\n", "seq_template = 'TCCCTACACGACGCTCTTCCGATCTNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNAATAAANNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNAATAAATTGTTCGTTGGTCGGCTTGAGTGCGTGTGTCTCGTTTAGATGCTGCGCCTAACCCTAAGCAGATTCTTCATGCAATTG'\n", "library_context = 'simple'\n", "\n", "rand_seed = 1177#14755\n", "\n", "#Run SeqProp Optimization\n", "\n", "K.clear_session()\n", "\n", "#set_seed(rand_seed)\n", "\n", "print(\"Running optimization experiment 'Alien1 Max Isoform'\")\n", "\n", "#Number of PWMs to generate per objective\n", "n_sequences = 10\n", "#Number of One-hot sequences to sample from the PWM at each grad step\n", "n_samples = 1\n", "#Number of epochs per objective to optimize\n", "n_epochs = 1\n", "#Number of steps (grad updates) per epoch\n", "steps_per_epoch = 20000\n", "#Either 'pwm' or 'sample'\n", "eval_mode = 'sample'\n", "#Normalize sequence logits\n", "normalize_logits = False#True\n", "#Number of One-hot validation sequences to sample from the PWM\n", "n_valid_samples = 1\n", "\n", "sequence_templates = [\n", " seq_template\n", "]\n", "\n", "losses, val_losses = zip(*[\n", " get_isoform_loss()\n", "])\n", "\n", "transforms = [\n", " None\n", "]\n", "\n", "seqprop_predictors, valid_monitors, train_histories, valid_histories = run_seqprop(run_prefix, sequence_templates, losses, val_losses, transforms, n_sequences, n_samples, n_valid_samples, library_context, eval_mode, normalize_logits, n_epochs, steps_per_epoch)\n", "\n", "seqprop_predictor, valid_monitor, train_history, valid_history = seqprop_predictors[0], valid_monitors[0], train_histories[0], valid_histories[0]\n" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "\n", "def load_data(vae_encoder, vae_pwm_start=0, vae_pwm_end=1) :\n", " \n", " #Load cached dataframe\n", " n_test = 1000\n", "\n", " seqs = []\n", " with open('vae/apa_simple_seqs_strong.txt', 'rt') as f :\n", " for line_raw in f :\n", " line = line_raw.strip()\n", " seqs.append(line.split(\"\\t\")[0])\n", "\n", " seqs = seqs[-n_test:]\n", "\n", " print(\"len(seqs) = \" + str(len(seqs)) + \" (loaded)\")\n", "\n", " x_test = np.concatenate([np.expand_dims(np.expand_dims(vae_encoder(seq[vae_pwm_start:vae_pwm_end]), axis=0), axis=0) for seq in seqs], axis=0)\n", "\n", " print(x_test.shape)\n", " \n", " return x_test\n" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "len(seqs) = 1000 (loaded)\n", "(1000, 1, 96, 4)\n" ] } ], "source": [ "#Specfiy problem-specific parameters\n", "\n", "vae_path = \"vae/saved_models/vae_apa_max_isoform_simple_strong_len_96_latent_100_epochs_50_kl_factor_1125_annealed\"\n", "\n", "#VAE model path\n", "saved_vae_encoder_model_path = vae_path + \"_encoder.h5\"\n", "saved_vae_decoder_model_path = vae_path + \"_decoder.h5\"\n", "\n", "#Padding for the VAE\n", "vae_upstream_padding = ''\n", "vae_downstream_padding = ''\n", "\n", "#VAE sequence template\n", "vae_sequence_template = 'N' * 45 + 'AATAAA' + 'N' * 45\n", "\n", "#VAE latent dim\n", "vae_latent_dim = 100\n", "\n", "#Oracle predictor model path\n", "saved_predictor_model_path = '../../../aparent/saved_models/aparent_plasmid_iso_cut_distalpas_all_libs_no_sampleweights_sgd.h5'\n", "\n", "#Subtring indices for VAE\n", "vae_pwm_start = 25\n", "vae_pwm_end = 25+96\n", "\n", "#VAE parameter collection\n", "vae_params = [\n", " saved_vae_encoder_model_path,\n", " saved_vae_decoder_model_path,\n", " vae_upstream_padding,\n", " vae_downstream_padding,\n", " vae_latent_dim,\n", " vae_pwm_start,\n", " vae_pwm_end\n", "]\n", "\n", "acgt_encoder = IdentityEncoder(96, {'A':0, 'C':1, 'G':2, 'T':3})\n", "\n", "#Load VAE models\n", "vae_encoder_model = load_model(saved_vae_encoder_model_path, custom_objects={'st_sampled_softmax':st_sampled_softmax, 'st_hardmax_softmax':st_hardmax_softmax, 'min_pred':lambda y_true,y_pred:y_pred})\n", "vae_decoder_model = load_model(saved_vae_decoder_model_path, custom_objects={'st_sampled_softmax':st_sampled_softmax, 'st_hardmax_softmax':st_hardmax_softmax, 'min_pred':lambda y_true,y_pred:y_pred})\n", "\n", "#Load data set\n", "x_test = load_data(acgt_encoder, vae_pwm_start=vae_pwm_start, vae_pwm_end=vae_pwm_end)\n" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "from scipy.stats import norm\n", "\n", "def get_z_sample_numpy(z_mean, z_log_var, n_samples=1) :\n", " \n", " n = z_mean.shape[0]\n", " m = z_mean.shape[2]\n", " \n", " epsilon = np.random.normal(loc=0., scale=1., size=(n, n_samples, m))\n", " \n", " return z_mean + np.exp(0.5 * z_log_var) * epsilon\n", "\n", "#Evaluate VAE Likelihood (ELBO) on supplied data\n", "def evaluate_elbo(vae_encoder_model, vae_decoder_model, sequence_one_hots, pwm_start=0, pwm_end=-1, n_samples=1) :\n", " _epsilon = 10**-6\n", " \n", " if pwm_end == -1 :\n", " pwm_end = sequence_one_hots.shape[2]\n", " \n", " #Get sequence VAE encodings\n", " z_mean, z_log_var, _ = vae_encoder_model.predict(x=sequence_one_hots, batch_size=32, verbose=False)\n", "\n", " z_mean = np.tile(np.expand_dims(z_mean, axis=1), (1, n_samples, 1))\n", " z_log_var = np.tile(np.expand_dims(z_log_var, axis=1), (1, n_samples, 1))\n", " z = get_z_sample_numpy(z_mean, z_log_var, n_samples=n_samples)\n", " \n", " #Get re-decoded sequence PWMs\n", " s_dummy = np.zeros((sequence_one_hots.shape[0], 1))\n", " \n", " decoded_pwms = np.zeros((sequence_one_hots.shape[0], n_samples) + sequence_one_hots.shape[1:])\n", "\n", " for sample_ix in range(n_samples) :\n", " _, decoded_pwm, _ = vae_decoder_model.predict(x=[s_dummy, z[:, sample_ix, :]], batch_size=32, verbose=False)\n", " decoded_pwms[:, sample_ix, :, :, :] = decoded_pwm\n", "\n", " sequence_one_hots_expanded = np.tile(np.expand_dims(sequence_one_hots, 1), (1, n_samples, 1, 1, 1))\n", " \n", " #Calculate reconstruction log prob\n", " log_p_x_given_z = np.sum(np.sum(sequence_one_hots_expanded[:, :, :, pwm_start:pwm_end, :] * np.log(np.clip(decoded_pwms[:, :, :, pwm_start:pwm_end, :], _epsilon, 1. - _epsilon)) / np.log(10.), axis=(2, 4)), axis=2)\n", "\n", " #Calculate standard normal and importance log probs\n", " log_p_std_normal = np.sum(norm.logpdf(z, 0., 1.) / np.log(10.), axis=-1)\n", " log_p_importance = np.sum(norm.logpdf(z, z_mean, np.sqrt(np.exp(z_log_var))) / np.log(10.), axis=-1)\n", "\n", " #Calculate per-sample ELBO\n", " log_p_vae = log_p_x_given_z + log_p_std_normal - log_p_importance\n", " log_p_vae_div_n = log_p_vae - np.log(n_samples) / np.log(10.)\n", "\n", " #Calculate mean ELBO across samples (log-sum-exp trick)\n", " max_log_p_vae = np.max(log_p_vae_div_n, axis=-1)\n", " \n", " log_mean_p_vae = max_log_p_vae + np.log(np.sum(10**(log_p_vae_div_n - np.expand_dims(max_log_p_vae, axis=-1)), axis=-1)) / np.log(10.)\n", " mean_log_p_vae = np.mean(log_mean_p_vae)\n", " \n", " return log_mean_p_vae, mean_log_p_vae, log_p_vae\n" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "#Load final sequences\n", "\n", "run_prefix = \"seqprop_apa_max_isoform_simple_20000_updates\"\n", "\n", "folder_path = \"seqprop_samples/\" + run_prefix + \"/\"\n", "file_path = folder_path + \"intermediate_epoch_19900_1_steps.txt\"\n", "\n", "seq_template = 'TCCCTACACGACGCTCTTCCGATCTNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNAATAAANNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNAATAAATTGTTCGTTGGTCGGCTTGAGTGCGTGTGTCTCGTTTAGATGCTGCGCCTAACCCTAAGCAGATTCTTCATGCAATTG'\n", "\n", "seqs = []\n", "with open(file_path, \"rt\") as f :\n", " split_on_tab = False\n", " for l in f.readlines() :\n", " l_strip = l.strip()\n", " seq = l_strip\n", " if split_on_tab :\n", " seq = l_strip.split(\"\\t\")[0]\n", "\n", " if seq_template is not None :\n", " seq = ''.join([\n", " seq_template[j] if seq_template[j] != 'N' else seq[j]\n", " for j in range(len(seq))\n", " ])\n", "\n", " seqs.append(seq)\n" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "#Evaluate ELBOs\n", "n_z_samples = 32\n", "\n", "#Evaluate VAE Likelihood on test data\n", "log_mean_p_vae_test, mean_log_p_vae_test, _ = evaluate_elbo(vae_encoder_model, vae_decoder_model, x_test, n_samples=n_z_samples)\n", "\n", "#Evaluate VAE Likelihood on generated data\n", "x_gen = np.zeros((len(seqs), 1, 96, 4))\n", "for i in range(len(seqs)) :\n", " gen_seq = seqs[i][25:25+96]\n", " \n", " for j in range(len(gen_seq)) :\n", " if gen_seq[j] == 'A' :\n", " x_gen[i, 0, j, 0] = 1.\n", " elif gen_seq[j] == 'C' :\n", " x_gen[i, 0, j, 1] = 1.\n", " elif gen_seq[j] == 'G' :\n", " x_gen[i, 0, j, 2] = 1.\n", " elif gen_seq[j] == 'T' :\n", " x_gen[i, 0, j, 3] = 1.\n", "\n", "log_mean_p_vae_new, mean_log_p_vae_new, _ = evaluate_elbo(vae_encoder_model, vae_decoder_model, x_gen, n_samples=n_z_samples)\n", "\n", "#Evaluate VAE Likelihood on random data\n", "n = x_test.shape[0]\n", "\n", "x_random = np.zeros((n, 1, 96, 4))\n", "for i in range(n) :\n", " random_seq = ''\n", " for j in range(len(vae_sequence_template)) :\n", " if vae_sequence_template[j] == 'N' :\n", " rand_letter = np.random.choice(['A', 'C', 'G', 'T'], replace=False)\n", " random_seq += rand_letter\n", " else :\n", " random_seq += vae_sequence_template[j]\n", " \n", " for j in range(len(random_seq)) :\n", " if random_seq[j] == 'A' :\n", " x_random[i, 0, j, 0] = 1.\n", " elif random_seq[j] == 'C' :\n", " x_random[i, 0, j, 1] = 1.\n", " elif random_seq[j] == 'G' :\n", " x_random[i, 0, j, 2] = 1.\n", " elif random_seq[j] == 'T' :\n", " x_random[i, 0, j, 3] = 1.\n", "\n", "log_mean_p_vae_random, mean_log_p_vae_random, _ = evaluate_elbo(vae_encoder_model, vae_decoder_model, x_random, n_samples=n_z_samples)\n" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "#Compare VAE Log Likelihoods (ELBO), With random background\n", "\n", "def plot_joint_histo(measurements, labels, colors, x_label, y_label, n_bins=50, figsize=(6, 4), save_fig=False, fig_name=\"default_1\", fig_dpi=150, min_val=None, max_val=None, max_y_val=None) :\n", " \n", " min_hist_val = np.min(measurements[0])\n", " max_hist_val = np.max(measurements[0])\n", " for i in range(1, len(measurements)) :\n", " min_hist_val = min(min_hist_val, np.min(measurements[i]))\n", " max_hist_val = max(max_hist_val, np.max(measurements[i]))\n", " \n", " if min_val is not None :\n", " min_hist_val = min_val\n", " if max_val is not None :\n", " max_hist_val = max_val\n", "\n", " hists = []\n", " bin_edges = []\n", " means = []\n", " for i in range(len(measurements)) :\n", " hist, b_edges = np.histogram(measurements[i], range=(min_hist_val, max_hist_val), bins=n_bins, density=True)\n", " \n", " hists.append(hist)\n", " bin_edges.append(b_edges)\n", " means.append(np.mean(measurements[i]))\n", " \n", " bin_width = bin_edges[0][1] - bin_edges[0][0]\n", "\n", "\n", " #Compare Log Likelihoods\n", " f = plt.figure(figsize=figsize)\n", "\n", " for i in range(len(measurements)) :\n", " plt.bar(bin_edges[i][1:] - bin_width/2., hists[i], width=bin_width, linewidth=2, edgecolor='black', color=colors[i], label=labels[i])\n", " \n", " plt.xticks(fontsize=14)\n", " plt.yticks(fontsize=14)\n", " \n", " plt.xlim(min_hist_val, max_hist_val)\n", " if max_y_val is not None :\n", " plt.ylim(0, max_y_val)\n", "\n", " plt.xlabel(x_label, fontsize=14)\n", " plt.ylabel(y_label, fontsize=14)\n", "\n", " for i in range(len(measurements)) :\n", " plt.axvline(x=means[i], linewidth=2, color=colors[i], linestyle=\"--\")\n", "\n", " plt.legend(fontsize=14, loc='upper left')\n", "\n", " plt.tight_layout()\n", " \n", " if save_fig :\n", " plt.savefig(fig_name + \".eps\")\n", " plt.savefig(fig_name + \".svg\")\n", " plt.savefig(fig_name + \".png\", dpi=fig_dpi, transparent=True)\n", " \n", " plt.show()\n", "\n", "plot_joint_histo(\n", " [log_mean_p_vae_random, log_mean_p_vae_test, log_mean_p_vae_new],\n", " ['Rand', 'Test', 'Gen'],\n", " ['green', 'orange', 'red'],\n", " 'VAE Log Likelihood',\n", " 'Data Density',\n", " min_val=-80,\n", " max_val=-50,\n", " n_bins=40,\n", " figsize=(6, 4),\n", " save_fig=True,\n", " fig_name=run_prefix + \"_likelihood_w_random\"\n", ")\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 }