{ "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, 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 = 2.0 * K.mean(symmetric_sigmoid_kl_divergence(iso_true, iso_pred), 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\"\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", " 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": 7, "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": 26, "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.9997387\n", "score_pred = 8.24955416390158\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.98985773\n", "score_pred = 4.580849710435554\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.9925268\n", "score_pred = 4.88893466959267\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.9996215\n", "score_pred = 7.878943680412399\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.9983671\n", "score_pred = 6.415745773591156\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.99798536\n", "score_pred = 6.205299582863292\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.9995992\n", "score_pred = 7.821692976944289\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.9994081\n", "score_pred = 7.431624527050216\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.9980155\n", "score_pred = 6.220413405158073\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.9986023\n", "score_pred = 6.571507852910035\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.99982417\n", "score_pred = 8.645796034942176\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.99949217\n", "score_pred = 7.584852753051714\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.9988172\n", "score_pred = 6.7386918653932595\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.99899757\n", "score_pred = 6.904324379360118\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.9997647\n", "score_pred = 8.354332586055849\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.9989984\n", "score_pred = 6.9051580027657\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\"\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": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "N Sequences = 10\n", "Number of unique sequences = 10\n", "Duplication rate = 0.0\n", "N Sequences = 100\n", "Number of unique sequences = 100\n", "Duplication rate = 0.0\n", "N Sequences = 1000\n", "Number of unique sequences = 1000\n", "Duplication rate = 0.0\n", "N Sequences = 10000\n", "Number of unique sequences = 10000\n", "Duplication rate = 0.0\n", "N Sequences = 100000\n", "Number of unique sequences = 100000\n", "Duplication rate = 0.0\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "\n", "#Estimate duplication rates\n", "\n", "def get_consensus_sequence(pwm) :\n", " consensus = ''\n", " \n", " for j in range(pwm.shape[0]) :\n", " nt_ix = np.argmax(pwm[j, :])\n", " \n", " if nt_ix == 0 :\n", " consensus += 'A'\n", " elif nt_ix == 1 :\n", " consensus += 'C'\n", " elif nt_ix == 2 :\n", " consensus += 'G'\n", " elif nt_ix == 3 :\n", " consensus += 'T'\n", " \n", " return consensus\n", "\n", "f = plt.figure(figsize=(5, 4))\n", "\n", "n_sequences_list = [10, 100, 1000, 10000, 100000]\n", "\n", "ls = []\n", "\n", "save_figs = False\n", "\n", "dup_rates = []\n", " \n", "for n_sequences in n_sequences_list :\n", " n_sequences_ceil = int(n_sequences / batch_size) * batch_size + batch_size\n", "\n", " print(\"N Sequences = \" + str(n_sequences))\n", "\n", " sequence_class = np.array([0] * n_sequences_ceil).reshape(-1, 1)\n", "\n", " noise_1 = np.random.uniform(-1, 1, (n_sequences_ceil, 100))\n", " noise_2 = np.random.uniform(-1, 1, (n_sequences_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", " max_onehots = sampled_pwm[:, 0, :, :, :]\n", "\n", " consensus_seqs = []\n", "\n", " for i in range(max_onehots.shape[0]) :\n", " consensus_seqs.append(get_consensus_sequence(max_onehots[i, :, :, 0]))\n", "\n", " consensus_seqs = np.array(consensus_seqs, dtype=np.object)\n", "\n", " #Sample first n_sequences\n", " max_onehots_kept = max_onehots[:n_sequences, :, :]\n", " consensus_seqs_kept = consensus_seqs[:n_sequences]\n", "\n", " n_unique_seqs_kept = len(np.unique(consensus_seqs_kept))\n", "\n", " print(\"Number of unique sequences = \" + str(n_unique_seqs_kept))\n", "\n", " dup_rate = 1. - n_unique_seqs_kept / n_sequences\n", " dup_rates.append(dup_rate)\n", "\n", " print(\"Duplication rate = \" + str(round(dup_rate, 4)))\n", "\n", "\n", "l1 = plt.plot(np.arange(len(n_sequences_list)), dup_rates, linewidth=3, linestyle='-')\n", "plt.scatter(np.arange(len(n_sequences_list)), dup_rates, s=45)\n", "\n", "ls.append(l1[0])\n", "\n", "plt.xlabel(\"# Sequences\", fontsize=14)\n", "plt.ylabel(\"Duplication Rate\", fontsize=14)\n", "plt.xticks(np.arange(len(n_sequences_list)), n_sequences_list, fontsize=14, rotation=45)\n", "plt.yticks(fontsize=14)\n", "\n", "plt.ylim(0, np.max(dup_rates) * 1.10 + 0.001)\n", "\n", "plt.title(\"Duplication rate curve\", fontsize=14)\n", "\n", "plt.tight_layout()\n", "\n", "if save_figs :\n", " plt.savefig(model_prefix + \"_dup_rate_curve.eps\")\n", " plt.savefig(model_prefix + \"_dup_rate_curve.svg\")\n", " plt.savefig(model_prefix + \"_dup_rate_curve.png\", transparent=True, dpi=150)\n", "\n", "plt.show()\n" ] }, { "cell_type": "code", "execution_count": 28, "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": 29, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "mean proportion = 0.9988\n", "std proportion = 0.0009\n", "mean score = 6.9727\n", "std score = 0.7776\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 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": 30, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Mean NT Entropy = 1.7952\n", "Std NT Entropy = 0.4183\n", "Number of unique hexamers = 3216\n", "Hexamer Entropy = 9.0669390768423\n", "Mean Binary Hexamer Entropy = 0.1278\n", "Std Binary Hexamer Entropy = 0.1806\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": 31, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "mean distance/nt = 0.4656\n", "std distance/nt = 0.0547\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": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEUCAYAAAB+uqLOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzsnXl4VNX9/19n9kz2fQ8hLAm7QABBkFXBpS5gi7u2LlW7uLS1Wmtrra2t32prf3VD69pq3autGyiuILsCsgdICGTf19nP7487GWYmM0kGEgj0vJ5nnjD3nnvOuTdkPnPOeZ/3R0gpUSgUCoVisKE73h1QKBQKhSIUKkApFAqFYlCiApRCoVAoBiUqQCkUCoViUKIClEKhUCgGJSpAKRQKhWJQogKUQqFQKAYlKkApFAqFYlCiApRCoVAoBiWG492BwURKSorMz88/3t1QKBSKk5qNGzfWSSlTeyunApQf+fn5bNiw4Xh3Q6FQKE5qhBBlfSmnpvgUCoVCMShRAUqhUCgUgxIVoBQKhUIxKDnuAUoIcZMQYr8QwiaE2CiEmNVLeZMQ4l7vNXYhxAEhxI/9zl8thJAhXpaBvxuFQqFQ9BfHVSQhhFgKPAzcBHzh/fmeEGK0lPJAmMv+BeQA1wN7gHQgKqhMBzDM/4CU0taPXVcoFArFAHO8VXy3Ac9KKZ/0vv+REGIRcCNwZ3BhIcSZwHxgmJSyznu4NES9UkpZNQD9VSgUCsUx4rhN8QkhTMBkYHnQqeXAjDCXXQCsB24TQhwUQuwRQvxVCBETVC5KCFHmLfNfIcTE/u29QqFQKAaa47kGlQLogeqg49VARphrCoCZwARgCfBDYBHwrF+ZXcD3gPOBSwAbsEoIMSJUhUKI64UQG4QQG2pra4/sThQKhULR7xzvKb5I0QESuFRK2QwghPgh8IEQIl1KWS2l/BL4susCIcRq4GvgR8CPgyuUUi4DlgEUFxfLgb8FhUKhUPSF4zmCqgPcaCIHf9KBcOtHlcChruDkZYf3Z16oC6SUbmADEHIEpVAoFIrByXELUFJKB7AROCPo1BnA6jCXrQKygtacRnp/hrTOEEIIYDxacFMoFArFCcLx3gf1EHC1EOJaIcQoIcTDQBbwOIAQ4nkhxPN+5V8E6oFnhBBjhBCnocnUX5NS1niv+bUQYqEQokAIcQrwd7QA9fgxvC+FQqFQHCXHdQ1KSvmyECIZ+CWQCXwDnC2l7BoN5QWVbxNCLAD+H5qarxH4N3CHX7EEtDWlDKAZ+Ao4XUq5biDvRaFQKBT9i5BS6QK6KC4ulsrNXKFQKAYWIcRGKWVxb+UinuITQuQKIZ727jFyCCHmeY+neo9POZIOKxRHy/aKFn7zn2386YNdVDUfe+MQj0fy6oZy7nxjC69tPIj68qdQHB0RTfEJIYYCawCL92dm1zkpZa0Qohi4Fm36TaE4ZuysauGCR1fhcHkAeG3jQT78yWxizMduFvv37+7gqS/2A/DSunL21LRy51mjjln7CsXJRqQjqN8BHmAscBkggs6/i7aRVqE4pry+8aAvOAFUtdhYubPmmPbhxXWB9pEvrg1nJ6lQKPpCpAFqAfColLIcbcNsMGVoRq4KxTElxmzsdiz2GI6etD4Etnes21coTjYiDVBx9LyfyMSJ506hOAm4dFoeOYmHTe1PLUji9JGpx7QPP1tYiPDOKegE/HRh4TFtX6E42Yg0mJQDY3o4fypQcuTdUSiOjNRYMx/eNptPdtVgNRmYOTwFnS54Bnpg+XZxLsX5SXxd3sikvESGJEcf0/YVipONSAPUG8ANQoi/c3gkJQGEEEuAbwO/7r/uKRR9x2LUs2hsZu8FB5ChKdEMTVGBSaHoD45EJHEQWAv8Ay043SGE+BJ4BdgMPNivPVQoFArF/yQRBSgpZQswHXgKKEZT8Z0BFAKPAnNV5lqFQqFQ9AcRCxq8Qepm4GYhRCpakKqValeiQqFQKPqRo1LcSSlVhj+FQqFQDAg9BighxOlHUqmU8rMj645CoVAoFBq9jaA+IfSG3N7QH8E1CoVCoVD46C1AfTfovUBLnT4S+Cew3Xt8DHAJsBv4W392UKE4GZFS8kVJHdUtduYVpZEUbTreXVIoBh09Bigp5XP+74UQNwOpQKGUsiLo3G+BL4HY/u6kQnGy8cMXv+KdrdpWwjiLgVdvmEFhhvrTUSj8iXQf1A+BJ4KDE4CU8iDwBNoIS6FQhGFnVYsvOAG02Fw89fm+49gjhWJwEmmAygU6ejjf7i2jUCjC0OFwdz/m7H5MofhfJ9IAtR+4XAhhCT7hPXYlUNoP/VIoTlom5iYwLjve916vE1w2Ne849kihGJxEGqAeAiYC64UQNwgh5npfNwIbgPHeMn1GCHGTEGK/EMImhNgohJjVS3mTEOJe7zV2IcQBIcSPg8osEUJs957fLoS4MML7VCgGDCEEL143jbvOHsW1M4fyxo0zmDE85Xh3S6EYdES0UVdK+aQQIhq4D83aqEuCLoBO4GdSyif7Wp8QYinwMHAT8IX353tCiNFSynDZ3v6FlnPqemAPkA748iwIIaYDL6OZ1r4BLAZeFUKcJqVc29e+KRQDSazFyHWnFxzvbigUgxpxJA5FQoh44Eyg6y9sH7BCStkUYT1rgS1Syuv8ju0BXpNS3hmi/JnAq8AwKWVdmDpfBpKklGf4HfsQzY7pkp76U1xcLDds2BDJLShOEsobOnhoxW7K6ts5a2wm184aihDHNl1HKNbuq+fxT/ficHu4ano+Z47JON5dUiiOGiHERillcW/ljsjqSErZjBYojhghhAmYDPwp6NRyYEaYyy4A1gO3CSGuRBu1vQf8QkrZ5i0zHfh/Qdd9gKZAVCi64fFIrnx6Hfvr2gHYdKAJIeDaWcd3hHOwsYMrnl7nS2W/em89r90wg8lDEo9rvxSKY0Wka1D9SQqa40R10PFqINzXxAJgJjABWIIWdBYBz/qVyYiwTsX/OLuqW33BqYsPtlUdp94c5uNdtb7gBCAlrNge/F9boTh56c2LbyXaOtNCKaXL+743pJRyfr/0rjs6b38u9Y7iEEL8EPhACJEupYz4r1cIcT3aehZ5eUpJ9b9IZrwFk0EXEAwGQzbc/GRrn44pFCcrvY2gCoChaCII//c9vfo6L1IHuNFEDv6kA+G+vlYCh7qCk5cd3p9d0aUqkjqllMuklMVSyuLU1NQ+dl1xMpFgNXH3uaMxG7Q/h+FpMdyyYMRx7hXMHJ7CxVNy6VoKm1+UxoWTso9vpxSKY8gRiST6rXFNJLFZSnm937HdwOthRBLXA38B0rrWnIQQ84EPgXQpZY1XJJEopTzT77rlQL0SSSh6ornDSXWrjRFpMYNCINFFZXMnTpckT42eFCcJfRVJHM81KND2TF0thLhWCDFKCPEwkAU8DiCEeF4I8bxf+ReBeuAZIcQYIcRpaDL116SUNd4yDwPzhBB3CCGKhBB3AnPRAptCEUBzh5M91a1IKYm3GhmZHtun4FRS00ZDu6NPbbTbXeysasHl9vReOASZ8VGDMjiV1bdT3aISaCsGjohUfEIIN3CFlPLFMOeXAi9KKfuUbkNK+bIQIhn4JZAJfAOcLaUs8xbJCyrfJoRYgKbSWw80Av8G7vArs1oIcTHaXq17gb3AUrUHShHM81+Wct87O3C4PIxMj+HZ704lKyGqx2vq2+x899n1bDnYjFEvuGXBSH4wd3jY8u9/U8XPXt1Mq91FZryFv181hdFZcf18J8cWm9PN91/YyKe7a9EJuHRaHvddMO54d0txEhLpCKq3r5YRz4tIKR+VUuZLKc1Sysn+yQ6llHOklHOCyu+SUp4ppbRKKbOllD+QUrYGlXlNSlkkpTRJKUdJKd+ItF+Kk5uGdgf3/XeHTxixu7qNhz/c0+t1T3y2jy0HtSVQp1vy4PJdlDeEtqd0uT388t9babW7AKhstnHfO9tDlj2ReGVDOZ/u1pJpeyT8Y80B1u6rP869UpyM9PcUXx7Q2mspheI4U9HUiSNoyq20vj1Mab8yQXJ0jyRsgGq3u6lrC5wGLKvvyWv5xKC0rvs9nAz3pRh89DrFJ4Q4Hzjf79D13mm2YJKABWiWRQrFoGZUZhx5SVYO+AWXRWN73yq3cEwGy/32IqXEmJkUZuNsvNXItKFJrN3fEHD9ic6ZY9J5ZvV+uvRVFqOO2YVKAavof3pV8Qkhfo3mawfaHqRw03htwBrgJillSb/18BiiVHz/W5TVt/PnFbs50NDB2eMyuWZm3+yN/rm2jDc3HSI9zsLNC0YwMj18osH6Njt/Wr6bHZUtzBqRwg/nDcds6NMS7aDm3a2VvPBlGVaTnhvnDKM4P+l4d0lxAtFXFV9EMnMhhAe4PJxI4kRHBSiFQqEYeAbKi28oUHtkXVIoTgwqmjr517oDeCR8pzg3Yol3eUMHL68vRydg6dQ8sntRBgKsL23gva1V5CRGMT4nnkc+KeGbg80YdIKFYzO5fVEhVtMRWWd2Y19tGy+uPcDumjay4ix8e0puv/v7ldW388qGcgw6HRdPzSUzvvdn0Fee+HQvb39dwdDUaH57/hgSo839VrdicHGkbuYCLS+Uv5v5V/J47vrtB9QISlHfZufMP39GvXePU5zFwPu3nN6r/LyLqmYbC//yGc2dTgCSok0sv/V0UmLCf4h+uL2a617YQE9/PUUZsbx/y+l9v5EwlNW3c85fv6DNqywEbc7+6e9OYW5h2lHXD1qAPvuvn9Nq09pIiTGz4tbTSYw2HXXdd7y+hX+tL/e9T4gysv6XCzDqj/eWTkUkDNhGXSHEIrS9RevR8i697P13iRBiYaT1KRSDiXe3VvqCE0CLzcVbX1f0+fq3Nx/yBSfQ5Oz/3dzz9f9YW9ZjcALYWdVKSc3RC2Rf33QoIDiBtrD8zzVloS84At76+pAvOAHUtdl575v+Md9986tDAe+bOp2sKgmZeUdxEhDpRt3TgLeBdjTHhm3eU2OAq4G3hRBzpZSr+7OTCsWxIirENJrV1HdRQ5Sxe9nepuZCXRMKSx/LHUlboe77SAnVz0ieYU8Y9YKg+Eq0uf/6rhhcRDqC+hWa6epoKeVtUsq/e1+3oQWpam8ZheKE5JxxmRRlHFblFaREc8HEvhu0nj8xm2Gph53QC9NjOXdCZo/X3DB7GNF+H+AGXXcl4cLR6eQkHr3d0XeKc8hNCpyujDbp+X4/Zve9aHJOgOv6mKy4Pkn4+8KP5wWa+A5Pi2GKUhCetESq4msC/iSlvC/M+buBn0gpE/qpf8cUtQalALC73KzcUYNbShaMSo945GJzuvlwRzU6IZhXlNan62tabXyyq5bcRCujMmN5aZ3mzmDQ6VgyOYezxvUc5CKhw+FixbZqSuvbSYszc8bojB7XyI6ETof2DIx6wbyidEyG/lsj+upAIy+tO8DY7HgunzYEXYiArhjcDJTMvAO4U0r5cJjzNwP3SykHn7NlH1ABSqFQKAaegZKZ7wAuFkI8IqUMmAkWQhiApRzOz6RQ9Dv//uoQf1q+i1abi0un5XH7wsJjkhrjlQ3l/GXFbjqdbq6cns+tZ4zst7rf/6aSP7y3k/p2B9+enMtd54zikY9LeHZ1KWaDjpvnj+DiqYd9kz0eydXPrOPzPXUIAWeNzeCRyyaHrPv5L0v528oSPFJy7awCbpg97Kj7K6XkT8t38Y81B4gxG/jpwpFcODGnx2uWb6vi/vd2UtnUiV4nMBl0XDE9n9v68TkqTj4iDVCPAcuAj4QQDwBdzpdjgJ8B0/Bmp1Uo+puy+nZue+VrPN5B/2Of7GVEWgyLJ/X84Xi07K5u5eevb/Ep7R7+aA+FGbGc3Q/TbjUtNn700lc43VrlT6/aT6fTxUvrDkup73hjK+NzEnwu6A9/tIfP9mjKNSnhna1VzFp3ICCIgTYV9qu3tvne/+G9nYzOjOP0kUdnS/TW1xU88vFeAJo7nfzklc2ckpvI0JTQWYjr2uz88KWvAjIWtzvc/PWjPYxMj+Hc8VlH1R/FyUtEE8NSyqeA/wNmoqn5Sryvt7zH/k9K+ff+7qRCAbCxrNEXnLpYX9oQunA/sqG0sZsMvL/a/aq8yRecuvD37utiY9nhY11O4v6s8PMH7CJUH/uj3+uC6vBI7XcTji0HmwKCkz8bSsNfp1BEvHIppfw5MAq4E3jC+/o5MEpKeUdP1yoUR8MpuQkEz+ZNzOtfB4RQTMzrrvnpr3Yn5CR0U+1NDlG3f3unDU/udn5OiE22k0LUE+pYpATXIYT2uwnH2Ox4TGE20oZ6tgpFF0ckrZFS7pZSPiClvMn7+pOUcnd/d06h8KcgNYY/Lh5PSoyZKKOe7502lIsGeHoPNOfz314wluRoE1aTnu/PLuBb4/tHVZcRb+HB70wgI86CyaDjsml5/P7Csdw0R5OeJ0Wb+M15YxibHe+75rYzCpk6VJNWC2B+URpXTB/Sre7i/CR+cXYR8VFGYs0GblkwgrlFR+8WsXhiNtfOHEqUUU9KjJn7LxzH8LSYsOXTYi38eekpZMVb0OsEZoNOe46nF3DeBDW9pwjPkVodRQPTgXTgQyll9/mFExCl4lMoFIqBZ6BUfAghbgTuB+LQXFLOAKqFEGnAAeBHUsonI61XoYgUl9vD53vqcLo9zC5MHbA0FrWtdp74dC9pcRauOS0ffZjpqna7i5U7q9lb00aHw82M4SkMS41hQ1kD47LjGZ4WPi2HP98caqakpo0oow6HWzK7MJU4i7FbuZoWG6v31jMyPRadDnZWtnJqQTIZ8ZZuZbdVNLOnuo0Zw5Ipre+gusUWtt6+YnO6+WRXLVaTnpnDU3rdj9Rud/HJrloSo41ML0gOUF921RXlrUuv9jYpiNzqaAnwCJoo4j/AU13npJQ1Qoj3gQsAFaAUA4rN6WbpE1+y2Zt+fXhaDG/cNOOoPnBD8dWBRpY8ttonznj8071suGtBtw/jiqZOLnx0FdUtdt+xZZ/vR6B9iwO49/wxXDk9v8f2Hlqxm79+FJh6PjnaxKs3TKcg9fA02qqSOr737HrsQeIDk17Hk1cVM9tPqffwh3v484faDLxO4LuXRKuR126cwbDU8NNz4ahvs3Pho6t9CR+nDk3ixWunYQgTvA81dXLhI6uoadWez/yiNP5+9RRA8ytc/OgqSr1ZeafkJ/LidacqA1hFxGtQPwM+llJeiBakgtkAjI2kQiHETUKI/UIImxBioxBiVg9l5wghZIhXkV+Zq8OU6f61UnHC8sG2Kl9wAiipaeONjQf7vZ173t4WoBxsaHfw3Jel3co992VpQHDqwn8C/cHlu3EHyxD9aO508vgne7sdr2938NQX+wOOPfzhnm7BCcDh9vDnFYeXg1ttTh755HD+UP/mGzucPPnZvrD96YmX1h0IyEa8bn8Dn+wKn4nn2VX7fcEJ4KOdNWzwqgFfXl/uC04A60sbWbmz5oj6pTi5iHSKbxyaYi8clUCfV2GFEEvRTGdvQksVfxPwnhBitJTyQA+XjgH8ta7BfxkdQMCORCmlra/9Ugx+WmyubsdaQxw7Wtod7m7HGv3cziNpu8PhwuXxoNeFnoq0u9w43KHl2MH1t9icIcsBAW7ldpcnrMQ7VL19JdR1wS7pvZXvOtYa4l7aBuB3qTjxiHQE5e7lmiw0p/O+chvwrJTySSnlDinlj9CC3I29XFcjpazyewV/isig8/3j9a8YNJw1NoMkv/xC0SZ9RKaufeX6IBNVg05w7azuxqrfKc4NafLqz0WTc3pcJ0uLtbBgVHq34zoBl0zJDTh22bS8buW6uNRvw25KjJmFY7rX2VXvxVNzQ57rjSWTczD7+eulxZqZPyr8d9PvTAl8PkOSrZw2PAWAxZOysRgP15Uaa2bB6NB9VvxvEakX3+dAi5TyHCFEMtrIZYGUcqUQQgd8DRySUp7Vh7pMaCOdS6SUr/odfwQYK6WcHeKaOcDHQBlgRnOyuE9K+bFfmauBvwMHAb23T3dLKb/qrU9KxXdiUd7QwT/XHsDl9nDx1Lwepc5Hw+sby3ny8/3ERxn5zXljKMqMC1luy8EmnltdyvaKFtweybSCZAozYtlW0cy47AS+U5wTdo2mC5vTzYtrD7Ctohm3RxJrMXLBxCwmD+nu2L18WxUf76plWGo0QmjTnLNHprJobGa3Ol9ad4Dd1W1MzU/kUFMn1S12zjsl66icwHdWtfDy+nKsJj2Xnzqk16y5m8ubeGPTQRKsJq6YPiTAoHZXVSsvry8nyqTjsmlD+pwgUnFiMlBmsUuBl4DfAc8Du4AzgXLg92gCiXOllO/1oa4s4BAwW0r5md/xXwGXSSkLQ1xTCMxFS5BoAq4AbvDW8bm3zHRgJLAZiAVuBs4GJkgp94So83q89kx5eXmTy8r6L3GbQqFQKLozIAHKW/F9wC8AD9p0nwdtv6AA7pFS3tvHeiIOUGHqeRdwSSnPC3O+axT1sZTyxz3VpUZQJzYOl4dHPynxZViVEjLjLdicbnbXtGHQ6Th9ZAq3zB9JvPXo1X7Lt1XxjzVlVLfYMeoFxflJ3Dx/REBq88Z2Bw+u2MV7W6tod7hItJrIS7Ji0AsuOCWbc8Zn8tePSth0oJHiIYn8aN4IovqQ3K+yuZO/frSHrQebcUtJWqyZq2bkM68onapmGw9/tJuvDjTh9ngoSInhhjnDONjYySsbykm0mvjB3OFkxFn4y0e72VbRwszhKdw4Z1iAcq7T4eZvH+9hfWkjk/IS+fH84VhNBmxON49+spc1++qZkBPPj+ePINZipKrZxkMrdrGqpA6DTseC0encvGBEr8rK9aUN/PqtbVQ2d5IUbcTtgZpWOwadjsWTsrnnvDE43R6WfbaPf391iA6Hm9GZcdy8YASNHQ6eXVWKTidYMimbT3fXsr+unUVjMrhqRv4xMRJWRM6ABShv5ZOAy4AitMC0B3hBStnnT/cjmeILU8+vgYullKN6KPMMkNHb1KMKUCc297y9jWdXl/ZabtaIFF64ZtpRtbVmXz2XPLmmm0ff9IJkXrr+VN/7S59cw+q99WHrmTwkMcDHbsmkHB78zoQe25ZSsugvn7OrOjAFvE7AqzdM5xdvfNPtnEmvCxBgJFqNjMqKY3XJ4b5dO3Movzx3tO/9T17ZzOubDisjz5uQxV8vmchdb27ln2sPa5gWjknn8csnc9bDn7OzKrDdBaPSeeqq8J9DZfXtzH/wU1w9qBtvnj8Cm8vNE58GKg6jjHocLjddVob+kn6AX54zKuR6oeL409cAdaRWR5uklD+RUp4jpTxbSnlzJMHJW4cD2Ii20defM4BIUsafgiasCInQvkKN76mM4uTgna19+xV/vqeuRxVcX3hva2W34ATw5b56n8qvqcPRY3AC2BRksvrO1ope295b29YtAIEmIf/X+vKQ54LVgY0dzoDgpLUd+PzeDfM++PiK7dXsrGrtFpwAPtpZjc3ZXQnZxYc7anoMTqClWAluE6DTeTg4QWBwCtVPxYnH8d4J9xBwtRDiWiHEKCHEw2hKwMcBhBDPCyGe7yoshLhFCHGBEGKEEGKMEOJ+tHWvv/mV+bUQYqEQokAIcQqaYGJ8V52Kk5ecxL4trKfEmLBGmCW3e1uhc3ImWo1Em7XdG9FmA4m9TCXGWgJ3euT2Ia17aowlQEHnz/DUmLDngkmI6rnt4OfZ9T743jPiLGTGh+5Temz4voZqIxQZ8RZyEiLPgRrud6Q4cejxf7IQ4ldH8Lq7r41LKV8GbgF+ibZONBM4W0rZpVTI8766MKGl+9gCfO4tf46U8g2/MgloOat2AMuBbOB0KeW6vvZLcWJy97mjSfau/3StPARb5liMOn5z3the1XS9ccm0PKYGKeAsRh33nDfGl97cqNfxm/PHYtSHXgcpTI/lvgvH+oJUnMXAb84b02vb8VYjvzh7VDeH8BnDkrlyej53nTOqW5vnjs9kvNdwVie06bzfLx6P1bvelRJj4q5zAmfJf3PeGOK8fYu1GPjN+doe/F99a7Qv8MaYDdx7/lgSrNr1/lLyKKOee88f0+M60IJR6czvwcA2yqjngYvG84uzR5Ecc3htTwBLi3OYW3jYMWNMVhxGb/u5SVEqGeJJQI9rUEKI8Dv8wiOllANjijbAqDWoEx+b082uqlZyk6I42NhJXpKVDoebWq+LwdDU6H61Q9pV1YpRL2i1uchPiSY+qnvdzZ1OdlS2UNdqJz8lmtRYM3VtdkZnxiGEoN3uoqSmjZHpsX0SSHRR32anoslGrMWA0+1hRHpst3NGvcBqMpCXrI0mdlS2EB9l9Mm4W2xO9te2U5QZG3KPVqfDze7qVoanxfhGhnD4OQ9LiyHG73hDu4P9te3odJr9VGwfn/W+2jZ2VbUyKS+RmlY79W02Opwezhqb4QtwDpeHHZUtOD0e0mMt5CZp91RS04ZBJ8hPifbd9+isOOXnN4jpF5GEEKK7h38f8BsBnVCoAHViUNNiQ6cTAftoKps7sRj02FxuzAYtTYXT7eFgYyc5iVEY9TrKGzqIizLS0ukk3mrEoBPUtNgZkmxFCEFFUydWk54Eq/ZNvc3uoqHNQVyUgVabC5dHkpVgwWzQd6sbNPPaAw0dSAmpceaQgdDl9lBa347HA1kJFrZXtDIkxYrFoGd/fTtIyYj02IBgANoHv93lJsZsoLHdSV6yFZvTTWWzjSFJ1gBvQKfbQ3lDB3lJVlptLmwud697lMKx+WAje6rbOG14Cnuq2pBCMjQ5xhfweqKyuZPKZhsxZj3ZCdZu9+SPzemmqtnm+134U9tqRyJJjTFTVt9BWpwZq8mAxyMpa+ggI9ZMVaudJKuRhg5nt+ehGHz0i5v5iRpoFCcnLreHW1/ZzH+3VCCAi6fmcfc5o/jBi1+xcmeNT8Vl0AnOHpfBmn0N1LTaSY01kRJjYUdlS0AZvU5gd3kYlhpNUoyZ9fsbMOoFN8weRlqchd+/s4POoAX+RKuRH8wdzrLP9lHTaic9zsyjl03GoBNc//wGqr0jNaNe8PNFRQEqss3lTVzz3Hrq2rpbJflj0Al+d+FYlk7RZrd//+4Onv5iPy6P9Jm95idbqW93aCO3ZCtPXTWF4WkxrC9t4KYbe/0cAAAgAElEQVR/bqK21Y7VpMfuFRLML0rjkcsmYenj2pvbI5nxh5VUt4R2CBuVGcvz35tGaqy52zmn28M1z63ns911vmNmg457zx/juyd/3v+mkttf20KLzUVBSjRPXVVMQWoMHo/kzje28urGcqSEGIv2RSHGbOAHc4bx4voDlDd0+p5J1+82L8nKU1cVMzK9b+7xisFLpBt1DYBVStkS5nwc0CGlPCGNtNQIanDz5lcHufXlzQHHLp2ax4vrerJtPDIMOghnYWfQiQDlWVFGLGaDLsC8FrS1ni9+Ps83nXb+377oViYcJr2O9b9cwN7aNhY/2ruodW5hKs98dypnPPQpe2raQpa551ujufq0oX1q/8/Ld/HwypIey1w5fQj3nt/dG/qNTQe57ZXN3Y6b9IL1d50RsAfN4fIw7fcf0thxWFXZJU3/cHs11z4f+u9RLwTuHj67+mMrgWLgGCiZ+YNojuXhWA/8McI6FYo+sa+2u83jrqqQ35WOmh78VbvJovfVtrM3RN88Ekrr2gPK9RWH28Ohxk72hgk2wXS1v68ufBuh+hiOjQcaey2ztzZ038Idd7glB5s6Ao41djgCghNo61E91QP0GJyAPj83xeAm0gC1EHi9h/OvA7368CkUR8K8ojT8lycMOsFFxaHNTo9mCcJq0pMW033qqgt/k1qAM0ansyCEUWpytIlJQxJ97yMxQM2Kt1CYEcusEal9ko2f4a07VD+OpP3rTu99g+sZIYxtAeaHOZ6bFEVRRqCPYXqchXF+6ezh8L3MLUoLK3QIJUYJVYfixCbSdBu5QPeENYfZ5y2jUPQ7E/MSefTSSTy9aj96nbZWNKcwDYNO8OK6A7TbXUipfeh997R8Vu6sYWNZI1Pyk8hOjOLdrZV0Oty+Mga9oLbVzoLR6WTEmXl5w0Hio4zcPH84cRYjf1q+iz3VrXiklnZDL2DmiFRumjuMv3++n41ljRTnJ3L7oiJ0QhAfZeS9b6pwuT2Mz0ng9kVFAWs+v71gLNEmPe9urcQtJSa9jla7C6vJQJRRR02rHYFgQm48f1wyHr1OkBFv4bnvTeVvK0uoa7dj1OmQSGaPTKOisYOd1ZpB7K1njADggYsmkByzk01ljV6RhBOby8Nl04YEJDHsjdkj07jmtHyeXV2GW0rf+o4A4qIMfH/2MK6akR/y2kl5ifxl6Snc/+4OGjocmAw6puUn8ctzR4cMOE9cMZkH3t/Jruo25hamcssCTR4+Mj2WJ6+czBOf7sMjJelxFvbVtlOQGs3N80bwysZyPt9Th0dKHC4PHikxG/TMLUpTEvOThEjXoBqBh6SUvw1z/pfAz6SU8aHOD3bUGpRCoVAMPP2i4gvB18B3hBB/9FoV+TdoBJaibaJVKI4JG0obWLGjmmEpMVwwMZu9NW3c9e+tVLfYWTQmg58sHInVdPi/ud3l5t9fHWJ/XQdnjE5nst8U3HOr9/PKhoN4pCQ30UpGvIWzxmZSnJ/IXW9uZcX2alxuD1avQ8TiSTlcOm0Ir24op77NQVa8hfe3V9Fuc5OTFMWpBcksnpSN2aDH45H8Y20pz6wqwyDgtjMLOWtcJh/tqOa9b6potTk5tSCZbxfnEmM2sLOqhf9sriA1xsxF3mOgSexfWFPG2n31VDbb0AnBqMxYzj8lm0V+e4bKGzp4Y9MhdAJ0OlhVUk9mvIVLpw7hq/JGWjqdXDAxW1O8fb6P5durGZ0Zx88WFuFwe3h1YzlOl+Si4hyyvSIPt0fyzKp9vPdNNSPTYvjpwkKSQ0yF2l1uln22j7e/rsBsEEzITSDKZGBMZhy1bXba7G4WT8wmPyU64DqPR/KfLRVsr2jx5YpasaOapnYnBalWLpqc69v79NWBRp78fB+7qlqxGPUUZsSyaIx2/+tLG5iUl8iisRn9+D9NcTyIdAS1BHgV+Ai4Ey0YSWACWrqN+cClXoeIEw41gjqxeGdLJT98aZPPE2/W8BS+KKkL8GQbkRbD8ltP931wX/f8BlZsrwZACHjsssksGpvRzQDVn9QYE7VhpOHxUQaaO8OLVucVpfH01VP4xRtbu6kNF45J54Nt1QHHxufE8+tzR3PJk2t9/nnjsuN56wen0dzp5Iw/fxpWpn7jnGH8fFERBxs7OPvhz0NmHfYnyqjnlLwEvvTzC0yONmHQC1/6+vgoI+/dPIushCh+8M9NAX59CVYjX/x8XsBGXYBLlq3hy309exBGm/S8/aOZDEs9nMPr7n9/wwtrwu9sibUYePfHs9hd3cq1z23o5r0XzI/mDecnZ/YpKYLiGDMgKj4p5evA/WiBaC2aG3mH998LgAdO1OCkOPF4bnVpgGHr50HBCWBPTRtflzcB2qiiKziBlo7j2dX7AXh140HCES44AT0GJ4CVO2vYWakl9gvGvy9dbDnYzF9XlgSYu2491Mz60gb+u7Wyxz1U2vOQvL7xUK/BCTSz1S+DzGzr2x2+4ASaC8abXx2ixebsZr7a1OFk+bbAZNXlDR29BifQ1vRe8XsmnQ43/1rf83aBVpuL1zYe5NnVpb0GJ4BnVpX2oZRiMBPpFB9SyruEEP8GLgeGew/vBl6UUq7vz84pFD1hClK3Badb6KLLwsdk0CEEAUGt65x+gPIGCQEWkw6dDtxBpt46IfCEmMGwhFDtmY16zL34B2r3J7o9lx77R+hnFlCvXodeCHQ6gTtIYh9sjxRJ2/7qRCHAoNPhDH5IwdcYdX02w42kL4rByZGm21jvTbFxjvd1qwpOimPNjXOGBRimXjgxm+DPpFMLkhidpUmb0+MsXOznZGAy6Lhh9jAAbpgdWlatF9o0YThyeklN/u3JOeQnx3DTnGHdzl02rburwpzCVH66sDDA5Xz2yFROyU3gnPGZFKSEtxj60TxNyfft4hyy4i0hy/iL6JKjTXxrQmB6+IKUaEamH77f7IQolkzOIdps4Iqg/uYmRrFgdKCsPT3OwnkTssL2sYvUWDOX+NVnMep9vwvwZkAN+s6QFW/h25Nz+f7sYQGmtOG4ef6IXssoBjdHlLDwZEWtQZ14HKjv4NPdNRSkxjBjWDINHQ7uf3cHZfUdfKc4h8WTcgOkzVJKVpXUs7+ujTmFab5Fd4BVJbW8sOYAegH5KdEkRZuYW5hGQWoMz67azysbyrE7PSTHmEiwmrhkWi6zhqeycmcNdW0ORqbH8PbmCmxON7lJVibkJDBrRIpv/Wt1SR2Pf7oXo17ws4VFFGXGsaOyhZU7amhzuJiUl8g8796f2lY7K7ZXkxprZm5hqs99vdPh5p0tFWw60EBZfSd6nWBCTgILRqczITfBdy+tNicfbKvGpBdEGQ2s3FVNTqKVxROz+bq8iRabkzNHZ5AYbWLF9ir+u6WSibkJXDptCB4p+WBbFU63ZOGY9ADD10921vDW5kOMyYrn8lOHhLROklLy/jdVvLaxnCiTgVMLknB7YEJuPIcabbTbXSwckxEyq/GG0ga2V7YwvSAZgM/21NJqc5GdEMXCsRk+f8NDTZ28su4Amw82Ex9lZGR6LLMLUxECNngzAI/LOSHFxP8TDEhGXSHE030oJqWU1/S50kGEClAKhUIx8AyUzPzqPpSRwAkZoBSDk3a7i5+9uoX3t1XikZqnW1yUkfo2B2aDjilDk9hR2UqC1ciU/EQ+211Hu8NFm82F2yPJiDdjMuipabHhdEskkBZrpnhIIsu3V2N3edDrBLmJUdxx1iifPLnD4eLON7by7tZKPB4YmR7DQ0tPYVRmXM8dDsEH26r4vw92Uddqx6gXIYUXozJiWXZVMf/3/i4+2VVDUUYcd50zimWf7eODbVW4PdLXz1sWjOTDnTV8uquG5BgznQ5t7abV5qTd+28BjMuJJyvBwpp9DQxJsvKrb43hUFMn97+7g9o2Owad4PwJ2WQmWHhp3QGijHpuWTCShnYHj35cQmOHA7fUXDsMOhibncDlpw7h/vd2UNNiJ8oo0Ov1tNpcCDT3hw6Hi+0VLUweksi6/Q2+/mTEmXG4JQ3tDhKtRh69bDLTh2kjpU6HmyWPrWZHZQsGvSDabKDJa4EkgO+fXsDiyTn88s1v2FHVQozZQGunA5cEm1MTlFgMWlp7rR/pLLtisnI1P8E56ik+IYQeKAB+CowDFoUzkx3sqBHU4OSet7fx7OrSY9KWUS/47Pa5ZMZHce9/tvP0qv0B5/OSovjkp3Mj+uCrarYx64GVON29/61lxluobD7sIB4fZaS5s3t6+i4H70hJtBpp6nD2KIzoTThxpG0HE2XUs/WeMzHodXz3mXV8vKu2x/JZCRYqmkK7q4fitjNG8OP5ylFiMDJQZrHdkFK6pZR7pJTfB+pRZrGKfmZNH2TL/YXTLdlQqhmlrt3fvd0DDZ1UhklBEY4NZQ19Ck5At/QWoYITHHmAaOwlOEHvqr7+CE6gydzLGjTz2C19cHmPJDgBfLSz54CnGPz0tw7zfWBJP9ep+B9nQk5C74X6CSHwmZeOD9FuWqyJ9BA5kHpiXHZ8N0VaOLqSJXZhjSDDbl+I7of6+mvSzKTXkZOoqSCH96CU7CI5yKS3N6YNTey9kGJQ098BKgno/X+aQhEBPz+riOIhgcHC6lWPCbS1G6NekBRtYl5RGlaTHqNe+D5IYy0GYi2GgA/WaLOeqflJAYEjPsrI7y8c57PguX1hITO8ayQAGXEW/nbpZJ+irq8MSY7m/gvHkRRtQq+DKGPo6zPizPzjmqm+NgtSonn0sklMzU8KKJcQZeSuc0b5lG6J0UasJj0Wo66bzD4rwcLkIYkIoUnG/3bZJO751uiAQDW3MJVLp+ViNuiIsxi4+9zR3DRnGEa/acyufw1NieaOs4p81+vQ1gS7GJsd5ws2YzJjA+TgMd4+grYH6s9LJ/j2UT122SSyEiy+tvzrBDj/lCyWXTmZglTtdxPnleH7F/OfdT0lN4GfnlnU/SErTij6RWYuhEhAc5JYBmyTUs6K4NqbgJ8BmcA24BYp5edhys4BPg5xapSUcqdfuSXAb4FhaO7rd0kp3+ytL2oNanDjcHlwut1EGQ3odIJ2u9P3b6fb020zqU5Ah8NNtFlLD+6RmkBCSolBp/OVtbvcGP02o4ZqF45+46fHI3FLiVGvw+Hy0OlwEWXS4/JIBIIov6DhcHkC2nO4PEgkOiEC+tlVzu2R2n3pdbR2OhECTAa9r47g+rqeh0cevi+X24POr26X24MQArvTjcWo9dO/jna7C6tJjxCCpg4HMSYDBu95u8vtCz5NHQ7MBr3v/tpsLmIsofVZ7XYXUUZtw7HD5cHm9BBjMQRsFei6l6422mwuTAaBUa/D5fbgkdrGZsXgZUBUfEIID+GnqAXQANwWQX1LgYeBm4AvvD/fE0KMllL25HsyxttWF77JZiHEdOBl4NfAG8Bi4FUhxGlSyrV97ZticGF3uVlVUkeM2cjUodqI4lCjjT9/uIv0OAt5SVaizQbmFqWRFnt4k2q01ydOpxPoQkxO6XUiwEy2tK6d7ZUtFOcn+urx/1C2u9w8/sle1u1vYHZhKtfOHEpZfQf//voQQgiKMmKZPTKNKJMem9PNh9ureeOrgxxq7GTplFzmFaWzZl89HimZVpCMsVPHpgONlNW3U9tqI9FqxmrW09zpJCPOQkqMiVa7i8pmG4sn5pAUY2J1SR15SdEMTYnm2dWl7K5uJTnaxGXT8thQ1si+2na+NzOfGIuRA/UdvLapnC/21DEmK45bFowkOcaMTifYWt7Ef7dUotMJhqdGs62iBYfTTUFaLN+dkY/N5WFVSR1Z8VHYXG6aO5wkWk0cbOqgusWGyyO5cGI2/9lcgcst+e5p+VQ22NhysJmMeDNr9jWQGmvmW+OzfMFJSsm2imbaHS5OG57C7qo2Kpo7KcqIZVtFC4UZsTS0O2jpdKLXCdaXNjJzeDKjMuO47787cEkPs0akML0gxZep2D/YGQ0qMJ1MRLoP6lm6ByiJFix2Ay9JKVsjqG8tsEVKeZ3fsT3Aa1LKO0OUn4M2gkqVUtaFqfNlIElKeYbfsQ+BWinlJT31R42gBid1bXaWPLaasnptQX1uYSozhifzu3d2ditr1AueumpKRLmPunjhy1J+9fY2pHdUseyKycwpPOyUUNNqY9YfVmL3EzxYDDpsQel30+PMPHb5JG54fiM1PXjnHQlRRj2dTk22rRcQTnshBFw9PZ9ngtSPAnjxulN5Z2sF/1gT/jtgtFmPUSdo6sVr0B+DTiBl92y3CVFG/vOjmWQnRPG959bziVetF2s20Grve/3+6AX89ZJJnDM+s/fCikHHgIygpJRXH3GPghBCmIDJwJ+CTi0HZvRy+QYhhBnYDtwnpfSf9psO/L+g8h8APzyK7iqOI/9YU+YLTgAf76plVUloZZ/TLXlw+a6IA5TT7eGBD3b5fPocLg8PLt8dEKAeeH9nQHACugUngOoWO796a1u/ByfAF5wgfHACzW/wuS9Lux8H7v3PNnZW9fw9st3esydeKFxh5H1NnU7+/sV+5o9K8wUn4IiDE2j3/sAHO1WAOsk5nm6KKYAeCLZ0rgbCJXKpBG5EUwouBnYBHwkh/Ne8MiKpUwhxvRBigxBiQ22tkqUORro2bPrj8nQPDF00dkQeGJxuDx2OwA/l4HrqIwg4rRGMPAaKcHLwxnZ7n9zA+5OmDgeNIX6PR0Nje/9/AVAMLo4oQAkhRgghzhZCXCGEuDL41d+d7EJKuUtK+biUcqOU8ksp5U1o0vafHUWdy6SUxVLK4tTUyKeFFAPP4knZGP3kWmmxZk4blhK2/NLi3IjbsJoMnBv0bTy4nhtDGL6GQifgqhn5/SbHPlJGZcaGPH7t6cMoTA99biAQwLeLc5lXlEZqhBL9nlg6JfLfs+LEIlKRRDrwHNC1vhPqb1ACz/ehujrADaQHHU8HqroXD8ta4GK/91X9UKdiEDE+J4FXvj+dVzYcJNZi4KoZ+WQnRHHry1+zYnsVOiFIiTGTHGPi4il5LJmcc0TtPHDReMZlx/syui6elB1wfurQZJ66spi73/qG+jYHGfFm/rBkHKtKGvjvlgpcbg9jsuK4ZmYB0wqSGZcTz/+9v4NN5c24PZL0WDOLJ+awvrQBt5QsGJWOQS9YubOGsvoOOh0uTAY9Br3A45HEWAykx1qoa3fgcns4a2wG43ISWLG9mrwkK9mJFh5dWUJli50Ys4HZI1PZX9dOfbudpVPy+N5pQ3nhy1Ie/WQvTR1OrCYdty8axRXTh/Dtybn83/KdrNhWjUQSbTbS3OnA6ZbkJEZx9zmjcXok/91cQazFgMcDLTYnBr3gUFMnFU02TAYd04YmsqG0CbeU/GDucJo6HGwqa6Td4aKsvoP4KCO3LRjJdG+G3DdvmsHzX5bRanNx9rgMNpQ2UtHUSXKMiZoWO9mJUXQ4XNS1OWhod3CosZPxufFkxVn457oDON2SkekxfKc4j4tVgDrpiVQk8Sra1NpjwEo054huSCk/7WN9a4HNUsrr/Y7tBl4PJZIIU8ebQLyUcp73/ctAopTyTL8yy4F6JZJQKBSK489AmcWeATwupewvwcFDwAtCiHXAKuAGIAt4HEAI8TyAlPJK7/tbgFK0/VImtKSJFxDoXvEw8JkQ4g7g38CFwFxgZj/1WXGM8XgkT6/az8vry+l0upmQE0+b3c3u6laEgESriVMLkvnh3OEket0GWmxOHvm4hB2VrcwansL3Zg7F6fZwybI1fFPRTLTZwA2nD+XNryupb7MzKjMOs0FHu93FgYZObE4354zP5DfnjfGly2i1Ofn561t4f2sVHsCgg8w4C+0ONwlWE2lxZqJNejaUNdHhcJEVb0EIQafTzcIxGSyelM3v3tnBvto2EqPNJEebsLvcHGroxGjQUZAajRCCxg4HFU02shMsLC3O4U/L99DucDE+O55/XX8qRoOeNruLRz8uYeuhZvKToympaaWkph2JJMqo12T1QlCYEcsNs4fR3OnkkZV72FXdhhBwSk4CFqPeZ7x6wSnZfG/mUPTevWHPrNrPiu3VlNW30+l0MyYrnqHJVlbuqsVi1HH9rGEB+Zze3VLBL97cSnOnC52AuCgjUkryU2J45LJJpMea+fsX+3l3ayUtNidtNhdNnU7MBj23LBjBacNTuP3VzeyuaUUIQZLVhMu7t2va0GR+9a3R7Klp44UvyzAbdcwdmcpjn+6jts3OnMJUHvz2BN77porXNx4kOcbETXOG+zZcK05cIh1BtQA/lVIu67cOaBt1b0fbqPsNcKuU8jPvuU8ApJRzvO9vB64DcoBOtEB1v5Ty3aA6LwLuQzOx7dqo+0ZvfVEjqMHJn1fs5uGP9vRabkp+Iq/eoAlAg81Hb5ozjA93VLO7ui2itq+ekc89543x1rmWj3eF3N3QJ/rDZHVMZhzv3DyL657fEDJlfCjMBp13o2/P3DhnGD9fVMRDy3fx15Ulvdb7xyXjWDoljzX76rl42Zqw5RKtRpZOyePxT/eGLWPQQQhBpI/cxCgONXWGfX5T8pNYX3p4a2RarJnPbp8bMl+V4vgzUGaxnwMTjqxLoZFSPiqlzJdSmqWUk7uCk/fcnK7g5H3/gJRyhJQySkqZJKWcFRycvOVek1IWSSlNUspRfQlOisHLfzZX9Knc+tJGKps7ae50dnPGfntzRcTBCeC/W7S22+yuowpO0D8mq9srW+hwuPhwR9+CE4C9D8EJ4O2vtXt9u4/Pu6vcW18f6rFcY4eTNzaV91imp+AEUN4YPjgBfHWgMeB9Tav9mJoMKwaGSAPUbcCFXishheKYkBEmfXkw0SY98VGaL11iULbWrPioACVgX+kyKLUYdMT2s3HrkWA26jAb9BEbp/aFLi+8zPie09h30VUuu5e09wLISgifqr4v9JbdJNRIKauXfikGP5EGqMeANuAVIUS5EOJTIcTKoNdHA9BPxf8wd5xVRHxU9/Tg/hh0cOfZo7CaDBj1On71rdE+i6IEq5E7zi7irrNHBVwTbEjavU7BHy8ar/1br+O+xeOO+B4MOsGkvMhd2YONZX997mj0OsGvvjUGs/f+evOunVuYyvicnpMsxkcZudP7fO44q4ikEAHQ31g3JcbEj+eNAOCK6flkxIX/EnHJtDzuPneUz+A1mGiznvmF4bd4CODWBSMDTHNTYw7L1fUC/nDhWEZ4TWqFgO+dNpSRx1BKrxgYIl2DKqX3dDFIKYceRZ+OG2oNavBic7rZVNZIp9PN2Ox4Oh1utle2kBJtAgFDU2K67bFpaHdQUtPGuOx4nxdcQ6udJz7fx7ShScwblc7Gskb21bZx5ugMyhs7MBt0NLY72F/fzgUTs32Gp100tjv459pSNh1o4rwJWYzLjmfN/gamDU2iscPJkCQr31Q0s2F/I1fOGMLe2jbq2x3MHplGfJSR3dWtbC5vYlJeIg0dDrLio1hf2kBClJHCzFgqmjrJS7LywbZqiockUpQZx4fbq9lQ1sANs4cFpONobHewp6aNsdlxHGjoYF9tGya9nrgoLRC43JKUWLPvg3rrwWYONnbQZncxpzCNNruLgw0dmAw6xuckBJjV2pxuth5qxqQXbDnYzILR6ViNBlbtrSPWYmB6QXKAq7uUkk931/DRjhqSok2cMz6TNfsamDEsmeFpWvudDq1Oj5QYdILV++rJjreweFIOQgh2V7eyckc1qbFmshOtICWVzTamD0vxjaK/OdSMxahjeFosWw42seVgM4snZmP1GgJvPthEcrSZvOSjG7EpBpa+rkH1i5v5yYIKUIMXKSUVzTbSY80Y9Do8Hklli/Zeoq05xJr1ON2SpGgTlc02bE43lc2dnDZc+3bedU1GnMXnjl3Z3ElStAmzNyV8rMVIq82Jyy2Jthh8I7fmTicVjR202JwMSYmmzeYmJdpEh9MNSBKsJqwmAy63h80Hm8lKMLOprJkhyVEMT4vF7vJQUt1KZkJUt6knl9tDaX07MWYDZoOOmhYHBWnRGP3uMyPOgt3lps3mIiXGTGWLjermTkxGPcNTY2jscJAZH0VFUydGvaCkpo3hqTGkxllobHfQZncRbdb619zpJD9Fq78Lm8PF+rJGCjNiA8x2u6hqttFic1Dbaue04anUttoprW8jNcZCrMVAotXEruoW0mItJHtHN26PpMrb9w6Hi6pmGxnxFhwuj+Y07/SQGWeh1ebCIyXRZgN1bXbf8+l0aErNUZlxmAw6mjuctNqctNhcFKRGYzboqGy2kRprprHDQbTJQKfDxfbKFqYOTcJijFSkrDhWDJTMXKE45uyubuX7L2xkf107abFmbjtjJI99upey+g4SrUY88nDmWQFYzfoALzm9Dh78zgQeWr6HAw0dZMZb+PW3RvP/VpawraKF+CgjabFm9tS0BaQ71wvBNbOG0mF38Y+1PZnra8n3zhmXwdtbKn3pPsIxKTeBV2+cgV4nWLe/gWueW0+rLdAayWLUcceiIp76Yj8HGzuJjzJic7qxuzyY9AJHCCM+i1GHzRmoNkiLNVPTau9WNtqs54nLi5k5IoWnPt/H797Z4bvvqUMTeem66eh1gpoWG9e9sJHN5U093pNeB25v0wtGpXPT3GH86MWvONTUSYxZT7vDTajvwrEWAx12Fx60Z2h3eRiZHsPpI1N5+ov9eKQ2PXpqQRKrSur9fjeQFG2its2BUS9wumU3leTd5xRxzay+uX8oBidqBOWHGkENTi5e9iVr9h2WEJu8sulIMOhEgJlpjFlP2xEYovYX910wlstPHcLMP67kYGNnyDJ6Ibo5g/cnabFmPrptNhPuXd5NIffwxadw/inZ3PH6Fv61vmcFXihyEqPC3texQidg+72LlNR8EDJQMnOF4pizJ0geHmlwgu5O28czOIEmi7a73D1+iA9kcAJtWrSkpi2kfHvrwWZAG70eCYeOc3ACbTRV09J99Kg4cVABSjHo8U95AfzJpaQAACAASURBVByRxDo+SEGWm9g3CbJeJ/ps+hqJiH3JpBzMBj2nFiSFLRNjHtgZ+PE58YzPTcAaQj5/1jjNOHdu0LPvK11JJY8UfW+68j5gNenJTVJS8xMZ/T333HO8+zBoWLZs2T3XX3997wUVx5TThqdo9jh2F6eP1GxtnB5Ju8PFtKHJFKRG0+5wYzXpyUmMojAjllabE7t3pFWQEs1bP5xJu91Nh8PF3MI0/nLxKRj1Opo6nRQPSWRuYRqtNidxUSYtrbpOMCwthj8uGc+547NYu6/Ol45DLwQGnZY80GzQYzbomJATz93njWF7RQvNnc4AqWtmvBmdEDjcHiwGHbeeMYIlkzWj09kj09hT00p1ix2jXmDUa22fkhvPE5dPxuWRdDjdTMxLJD3OjMWgJzspitbO/8/eWYfJVZ1//HPu6M66uyabZOPugoQAQUIpNHhpcQpF2lKgxWvUHStWCsXdPZ4Q92STdXefHT+/P+7sZGZn1pJs2fC7n+eZB66cc8+9O7nvnHO+5/u6vKniVcl3arSZ7PhwQGJzepBSbd+KqWl0O9w4PR7CjaoFkl4RzMmL4+8XTycqzMBJYxL5eF8t3Q43Jr3C3cvHcdbkNABmZMcigcLaDt/zjA83oghVJagISI4ykxJlosvhJsqs5/5zJnDr0jE0dzmwudxMSo9GAnanm+gwA/ERRgw6hWiLgelZMcRYDMRajGTEWgg36ThvWjo/PWMcG4ub6Ha6GZUYwa1L86lottJhd6EIQV5iBIvyE3C6PaRGm4kKU+votLuQUm3ji9fOJakf+bvG18cDDzxQc//99w/oSKTNQfmhzUFpaGhoDD/HTcUnhPgl8LqUcutxaZmGxnGivsPGM+tK+eJAPdFhBhaMjmddURNF9Z3YnG4KUqN49LIZxEUEro9yeyQf7Klhe1kLpU1W7C4PGbFhFDd0MTE9iluXjuG93TWUNXZxsLaDA7XteID0GDOKUEiOMnPX8nFkxFqob7fxxvYqdIrg/OkZIRe4AqwqbGBLaTPTvb01UHsU9761hw1FTYxOjmBcShQCqGm30dbtZPnEVM6blu4b7vriYD3by1oYlxpJY6eDDpuLFVPTyIhV1/xsKW1mdWED41KjaLc6eXJdCWa9woLRCZgMOpZNSGZCWjSgzuM9t6GMLw7WMyEtihtOGkV0mIG3d1bz2tZKqtu6CTfquXRuNokRRp5ZX4qUarmSxk6MBh0T06MxKgrrDjfS2u1ArxNEhxkZlRjBZXOyeHR1MR02FzcsyeM7s7JYdbCeJ9aU0G5zEhNmIDnKTIRJ71t/FRtuxOX2oAjBmRNTWFfUREOHnZnZsWyvaCXCpCcr3sL2shbcUu09xoUbKW3sosXqZHZOHJFhBoobOpk/OoG5efHH/0un8T9lwB6UEKIFiAKqUN3B3wRWSSm/3lnmYUDrQZ041HfYOOPPa2geIKuqQSc4+NAZKMqR6dafvrqLl7b0rUwz6RXfcFZ/9b5+w3y+98xmGr2ZdtOizXxw6+Ig14tHvizi4Q8P+LZvWzqGW5bms+A3n1HVauv3OudPS+ePK6fy988P8fuPC4OOR5r0vHXTAraXt/KjV3b2W5dOETz53ZmcNDaJix7fGOBVlxhp5PTxKQPK6Y+WxfkJrD40eC/D3qrLo+GX35rIpXOyj6kOjeHheKr4EoEzgHdRc0F9CtQLIf4thDhPCKHNQmr8z3lze9WAwQnA6Zb8e2OZb7vV6uCVrf3LpgcKTj31PvDOXl9wAqhus/H+7pqgc/+1pjhwe20xB2s6BgxOAG9sr6Kx084Ta0pCHu+wu3hxcwX/Whv6uD9uj+SpdaUcru8IMlJt6HDwwlfDE5yAIQUnCFZdHg3/6uOZaZw4DBigpJQuKeUnUsobpZQZwHzgX8Bs4HWgUQjxpjfd+7FJdzQ0BokiBq/yMvk5JgghhlS2P/QhTPBCqc+UXvt0ikAZ5NIcIfCJNvpCp4gB/fh60CsCnRL65K87Rf3x5ngoATW+XoYsM5dSbpRS/lRKOQ6YAPwKSAeeAWq9hrE3CyFSjm9TNTSOcP70jH4NSnsw6RUu9hvmiQ4zcNnc/od9QsmuQ9X74LkTSPNzWs9NCGe5V57tz00njw7azk+KZNQgEupdMieLuHAjP+hVRw+xFgOXzM7ixpNGD+j4bdQpXLMoj9yEcE4ZFygfz4gJ46qFw2ehefbE4OfSH8bBRtw+EELNAaZxYnPcVHxCiEzU7LUrgMXAQ1LKB49L5f8jtDmoE4s2q5OXt5bz6b56Yi0GloxNZPXBBg7WddBldzM9O5bfXziF8F7riaSUrD7UyM6KViparFjtbkYnR7Cnso1pWTFcsyiPT/bXUdls5VBdJ7uqWvFIVa7ukWr6j9tPG0N8hIk2q5P3dtegVwTLJ6f2uXZpW3mLKpLIimWm15Xb7fbwx08K+fxAPRMzoslPikQRUNdmo9nq4MyJqZxakOTL6Lu1rJmtZS1MTI+mrt1Gp83FmZNSSfCKQA7UtrOmsJFxqZE4nB7+8eVhLEYdS8YkIoTg1IJkcr1B0e2RvLW9ik/31zE5I5rL5+UQbtKz6mA9r22roqrFisWk47vzc4kLN/DMujIE4JYe9le3E2bUMy0zBr1e4csDddS02bEYFGIjTIxNieKqBdn85bPDtHY7ufWUfE4Zn8z28hb+taaEDpuTuHBvBmKTnjCDDo+E+AgjTpcHECwbn8zGElUkMSsnju3lLYSb9OQlhLO5tAUhwCMlyVFmiuo7abY6mJUTR0yYgcK6TuaNimdievTwfPE0jpmv1SzWO9QXL6UcOA3qCEILUBoaGhrDz9dqFiulbAaaBzxRQ2OQON0efvPBAd7bVUNylIkIk57C+k6mZMRwakESz64vpa3biVEnaOhwgIA4i4HadpsvW2tWXBi1bXYcbg8GRZCfHEl9hw2TXke304XV4faZrQqhmrr+95q5vLS1kqfWlqBXBIvyE1h3uJHylm5sDjcS71yHlOh0gpgwI91OVeAaH2HkgukZbCxuZldlK512l89WSBGQGWfh9xdOYZa3R7WxuJGbXthOU6cDoVapzlcJVZQhve0KN+qIsRipaun2LQjuSdBo0utwuj2MSozgnrPHMylD7UWUNXVx2b82UdnajUERWIx6ZmTHcuHMDB5dVcz+6nYcXrdXo15h8ZhEfn5WAU+sKebjvXXkJYazeHQij64uotPuIjchnOuXjOKZ9aWUN1t9C2RNBoVIk56WLgcSNRfXXWcWcOHMTJ5eV8Iz60tp73bS2u1ESvX4kvwE1h1uwi0lXXZ1AbIiYHJGDL+9YApx4UbufWsPm0qamZIRzQMrJvLkmmKeWV/qe55GnWD5pFQqW7qpbOlm+aRU7jxznC8nmMaJibZQ1w+tBzVy+dtnh/jDJ8Ey6+Fmdk4sX5W2DHziURJu1LH550vRKwqTH/goyI38WEiOMrH2p6dg0Cks+M3nVLUG++PpFNGn+/rxNHy95+wCHnp3/5DLjU6KID8pgg/21Pr2TUqNYndN+4Blbz9tDD88NX/I19QYfk4Ys1ghxI1CiBIhhE0IsVUIsWiQ5RYKIVxCiD299l8phJAhPprnyQnMuqKhyZSPF3uqB34RHgtdDje7K9sorOs4rsEJoK5dNYMFqA4RnIB+U4McTzfyD/0CzFA4XN/JmkMNAfsGE5wA1h7+er4zGsePrzVACSFWAn9BVQJOA9YDHwghsgYoFwv8G+grvbwVSPX/SCkHXnSiMWLpcUD4X5MeM7zL/PTeocachPDjLouONOnJ9maWjbEYQp7T3xVj+yhzNEzPij2qcsmRJib2+tunxwzut+aEtP7T3GuMfL7uHtTtwDNSyieklPullDcDNcANA5R7EngW2NDHcSmlrPX/HMc2a3wN/PDUfE4em4gQ6ss2w+tGPioxnO8tyCHCpEcnBGGGI19pY69vt/8xOPLSNnv3935ZJ0eZ+O81c7hyfg5GnUKYQcfC0QmE9yNDN+qEry6TXnDulLQ+g1yYQeEP31HnWCJMen5x3kT0gwxS5l730lPO5J1zSY4y8ceVU7EY1Wnmf146nbBeeZHyEsL58eljiAsPDkR5ieH889LpzB+l2gWlRJk5Z3KqT8oeYdJz9cJcIs36oOem89uhCLh2cR4/PWMcl8/NxqhTAuTwOkUwIS3S9//+JEaY+PNF0/jV+ZMYnxrla/Ojl830tcufCWlRJEaqisaTxiZy66ljgs7ROLH42uaghBBG1J7OxVLKV/z2/wOYKKVc0ke5G4FLUaXs9wAXSCkn+h2/EjWAVQI6YAdwj5Ry+0Bt0uagRj5ddhdmgw6dImi3OYkyqy9Xh8uD2yMx6RWsTjcCMBt0uDwealq7iTYbiI0wYXW46Oh2EhVmIMyop8PmJMKkx+pwYzboaOpU5dLdLg+JfqnPbU43QqgihJ5rOd0eOmwuUqNNtNtc6HUKFoMOq9ONXhG+8z1e5/Uwg46K5i6So8KwuzxEhRmCXspuj6Shw05ihJHGTgex4Uacbg8S6LQ5iTQZkEINEO02J102J2FGNTV9l8Ptu36Y9xn1prrVSkpUGJ0OF5EmPUKoc1A2p9vnjo7A91wBOu0uLAbVCd3p9tDc5SAp0oQQ6rbLLZFS0mJ1+NzDux1u3B6JxaQ6vvs/R0UI3B4Pte02chMiAq7R6XAhAI9HEhVm8EnsgYC/N4DV7qKhw05UmAGjXiHcpMftkXQ73cOeqkTj2Bg2FZ8QIhK4DVgGJANXSCk3CCESgBuBl6WUB/qrw0sCagCp67W/Dljax7UnAfcBc6WUbhHaEeAg8H1gJxAJ3AKsE0JMCSV7F0JcC1wLkJXV78iixteI3enmmfWlxIYb+M5M9e/U87LaXdnKppJmClIjmZeXgNst2VLW7Et3XpAaRVlLN2uLmjDpFWZkx7KtrJVtFS2cMzmVSLPBt1aq5wXb0mzlk321dNpcVLRYSY8JY1pWLKnRYWwobqSuzUZrt5P4cANflbWyeHQCMRYjOgXaul3sq2knKzYMi0nP5pJm2q0Owkx6Lp2TjcWkx2KCimYrB2rbae5y0GJ1ctbEFN7YWYXTJTl5XJJvWKxHiRZh0lNY18FXJU0kRZqZNyqeww1dxIQZickw+l7KPf91uDxsKmki1mL0rQmKsRh5fHURRY1dzMiKZdGYRJIiTby1owqHS3LW5BR2V7WRHWehrNnKVyXNSKmm3dAJQUZcGJ12F8UNXczJjcOgUzDo4P3dNRQ1dHLF3GyiLUZqrDa2lrXQYrUTYzGydHwyUWYDhXUdbCtrQRGC7HgL4UY9b+6owqhTSI8JY3ZePFFeL8M3t1dR09bNovxEGjrs6HWC1YUNJEWaWDkriz3VbVS1dFPb1k19hwODDiLMBr47L0cLUN8QhtSDEkIkAmuBPOAwMAY4TUr5ufd4EfCWlPL2QdSVhmpAu0RKudpv/73ApVLKsb3ONwHbgV9LKZ/z7rufXj2oENfp6UV9IaX8YX9t0npQI5PSxi6W/Wm1TwadEGFkw12nYtAp3PzCNt7ZdcT/LjvOQn2nnW7HES9jAfT3Lb/zzHFcv+SI68BzG8u49809IcuEGRS6j1HMcNGsTApSo3jgnb0hs9n2sHhMIk9fOcvXE3ro3X086ee5pwh85c+enMrfL5nuO1bfbuPCxzZQ1mQFYMXUNG4+ZTTL/7IGh/vIRYVQXRsG4z/Ym0np0bx47Vy+9c91FHqzHisCLpmdxfObygOen9mgMD0rlvVFTaEr8xJu1PH092Zx28s7jzorrwAev3wGp03QzGxGKsOl4vsFkALMARYRPGz/FnDqIOtqBNyovTB/koFQc0apQAHwtFe95wLuBSZ4t5eFuojXdX0LoOlNT1DufWuPLzgBNHY6eHx1MdvLWwKCE0BZszUgOEH/wQngj58UYnepZewuN7/94ECfZY41OAG8uLmChz880G9wAlhd2MAXB+oBtbf1VC9DWP/y7+6qYWvZkaWHT68v9QUngLd2VHP363sCghOoa62OJjgB7K5q4zcf7PcFp5429Q5OADanZ8DgBKqq8Y7Xdh1TyngJ3P/O3qMurzFyGGqAOhv4p5RyG6H/3RcDmYOpSErpALYCp/U6dBqqmq83VcAkYKrf51HUntzUPsog1HHAyajiC40TkKYQruVVrd00dQ7sZj4YHC6PT+Jtc3rodLiOS739YXUMLltNU5fd+1/HgIHW31m9qdMedLwhxL5jpbw5OJAc66x2a5fzGGuATvs3LhvQ/0uGGqASUANCX3iAoaw3+iNwpRDiaiFEgRDiL0AaauDBm9Lj3wBSSqeUco//B6gH7N7tTm+Z+4QQpwsh8oQQU1EFE5N76tQ48ehtYiqA6xfnsTA/wafa6kE3OBFcAHNy43w5nKLDDCwb37tTf3zJiA3j1IKkAc+LMutZWqC2ZXJ6NPlJEX2emxxlYnF+om/7W9MyAtRyqdFmbliSd/SNDoFRr/DTM8YGKQ8zY0OrFvtTP/pzxdzsAY1vB+LsyUMzp9UYmQx1JrEW6M8ieBow6KQyUsqXhBDxwM9Rh/D2AMullD0JfI5GtRADPI46FNmGOm+1WEr51VHUpTECOH96BlaHiyfWlGA26LjnrAKy4lXT0zdunM8fPi5ke0ULOXHh/GjZGPbVtLOqsAGHy4NeUciOt9Buc7Knqo0Ik8HrDtFMeXM3i/ITuO+cCQHX+/PKaTy1roT1RU1UNFvpsruIDjNwxsQURidF8PaOag7Vd+D2SOwu1R4pLtxIflIEDreksdNOfbudyDA9OgS17TYcbg9GncKi/AR+8+3JhBl1PLVWvUZ5UxdCCDLjLBTWdeDySOblxfPj08cS7zWCVRTBf6+dy18/O8T6okbiwk2cNCaBw/VdRFsMfH9Bri8zLcC8UfH856o5vLq1khiLkasW5ZIeE4ZbSv7wcSEdNifx4SYunpNFZqyFf3xxGLdHMjs3jk6vUrKovtO30Dcl2kxSlIn0GAtujwedIrhsbjbj06J5+6YF3Pn6bpq7HFwwI4OrF+XxxOoiPtpbR4vVQXy4kSsX5DIvL54/fVrIltJmXB7J6KQIkiPNbCpuxuZyk5cYzrenZ3DhzEwWj03kvrf20trtICc+HJNBR127jYpmK+EmPcsnpVDbZmdfTRtNnQ7sTjcICDcZuHBGBnctL/gffTs1hpOhiiQeQU1aOBVwAA3AUinl50KIOcBq4M9Syp8OR2OHG00koaGhoTH8DJfM/AHgXNReyduow83fFUJcgxq4qoGHh1inhka/dNldPLaqiI/31SElnDIuifzkCD7eW0dKtJnrluQRZtDxyKoiNhQ14fFIZubEcf2SUaT45WvaW93G0+tKcbk9XD4vh4pmK69traSh0056tJn0OAsHajtoszpIiwnDpFdwuiWKIqhp7UZRBLNz4ihrtrKjopXc+HAeWDGeN7ZXs7W0mfoOO1aHG4+UhBl0zMiKxWhQqG23ISUkRZqINOtZc6gJIWBGViw7KlqoabNhNujQKwKTQcflc7MYnRTJS5srqGnrJtyk56SxiXxvQS4Gb56kdYcb+e9X5Rh1AoNeR3OXg2Xjk7lwZiYOl4cn15awtayFKZnRKEKwvbyF6dmxLBqdyG8+2E9xYxdjkyNp7LJzoKYDISAnzkJ8hAmPlKTHWpiWGc3fvjhMe7eLKRnR/Obbk3lqbQmf7q+ny6H2KnPiLSzKT2T5pFSeXFtCbZuNc6emkRBh5AfPb6fd5mRKRjTPXT2HnRVt/GtNMdvKW+iyu4gw6RmbEkllSzetVidxFiOXz8/iu/Nysbnc3PX6bjYWNZERZ+Fnywt4cm0Jm4qbUBRBQWoUVy3MZW5ePE+tK2FLaTNWh5vSxi4sJj13nD6WZZqK74RnyAt1vXmf/g6cxZE5LAm8D9wgpaw8ri38H6L1oEYm1/57Cx/v671c7ghZcRYSIoxsK28N2J+bEM6nty9Bpwhq22yc+ocv6fKKE3RC4D4Oi9R1AtzHXs2guGJeNg+umMiW0ma+89iGkCrA+88Zz8G6Tv7bR/p2nQLuoxQi6hXRZyr2SLOeDlvf4pLsOAtVrd2DSuV+69J81h5uZIufSW+opQIC9cfKZ16lY29evX6eL/eWxshi2MxipZQVUsoVQByq3HwukCilPOdEDk4aI5NOu4tP9vcdnADKm61BwQmgpLGLHRXq/o/31fqCE3BcgpNaz3GpZlC8sb0KgLd3VvcpUX9jRzVvbO/7n+HRBieg3+DSX3ACVf4/mOAE8Pq2yoDgBKGVgRL4srAhxBGVl7ZUDOp6GiOXo/bik1K2Syk3Sym/8uZ/0tA47pj0ik9h1x+h8v4IoQ6rwZH/nsgke10u+ruX5EiT77yRxFBUecmR5iCvwb7ozzEiLXp4jX41hp8hBSghxMoe2Xcfx58VQlxw7M3S0FAx6BR+trwgQD4uCHTnvmphLj9eNiboJXjtojwy41Q376UFySwZc0SGPT41MkiiPpiXaO9TClIihvTyHcypJp0go5fBbJhBx8+8yrTL5mYzLiUyqFx8uJHbThvDz88a7zON1SsCg+6IkWyocn1h7KXZn5oZ2lHebFA4Y8IRaX56TBipUYHP9qZTRjE5Y2BHerNB4c7l47jzjHEB+7O8f0d/xiRFcP85E3z36k9ylIkr5+cMeD2Nkc1QVXxrgCIp5ZV9HH8KGNWX0etIR5uDGrnUt9vYWdmKlDAxPZrESBNbSltIjjKRl6iuD6pssXK4vhOJJCc+gtyE8KB6dle24fR4mJYZg93lYVtZC063B7NBR0FqFLsq27C53CREmLAYdbR0OUiINFHe3IVAMDpJDUjv7KhhQX48E9NjqGi2UtrYhcPtpqrFRlSYHrvLw/xRCdicbpq7HBh0AiHU8p8fqEcnBAvzE9hR0cpOr+BCInF64KxJqRh0gq1lLQihOj1MSo8mxmL03YfHI9la3kKESU+kWU9Zk5XpWbE+qXlLl4M91W2+VBV7qtuYkBZNXLiRHeUt7KxsZcGoBNxS8sz6UqLDDJw1KZUOmwuTQUERgmlZsbyzo5qNpU3csDiPjLhwDtd3UljXTkmDlSmZ0Ujwta24oZPadhszs+Mw6hXe3VnNhqJGbjhpNBlxFqSUbCtvobq1m6KGTrLjwpmaFcuBmnYaO+3ERxhZPCbJ1yuqbrHy3u4aZubEMS0rlrKmLr44UE+MxUBajEX1B1SE717zEsJZXdhIbLiRZeOTUY5z+hKN48dg56CGGqAagYeklH/p4/jNwL1SysRQx0c6WoAa+XTaXSgCXxoJACklTV0OwgwKHgkutyTCrPcp3vqipctBhFmP0626k0f6OWW73B7aup2+dUh90dRp95rEhn4ZNnbYcXk8pESH+doZH24McOkORZvVicmgeNdaeVAEAQGqutVKe7eLcanHlvOoqL6T9NgwbF4H9A67y9c+p9tDp81FbLh63VarA4tRj0EnfPchpfrDwGLSY9Sr6d7979HmdGN3eXzDtB02J3pFodvpBiQWox6zIXgBb117N4oQAY7y/kgpKWnsIi3GjNkQOMzX2GknzmLUAtQIZrhk5uGo/nl9IVEdxDU0jituj+Tnb+7hlS0VKIrg6oW53HHGOPZUtXHTC9so9fOdAzXZ3v3nTmDF1PSgupo67dz4/DY2lTRjNii4vEqHC2dm8ovzJrK6sIE7XttFQ4edqZkxPHLZdFJ7zWeUN1m5/j9b2VfTTmq0mT9cOIX5oxN8x1u6HFz6r03s82Z/TYo0YTIoVDR3kxNv4W8XT2dSiCGvboebW1/azsf76nyquZ7fkEvGJPLwtydz4WPrqfBaDJn0Cm/ftICxKUMLVLsqW7no8Y0Blks95rM58RZWzsriiTXFNHc5mJEdg1GnY0NxExEmPWFGhYYOBylRapoR/zosRgWrw0NuQjhLC5J4YVM5Vqeb08cnE27S8+b2ajwcuSejTuHW0/K58aTRALR1O7ngkfUc8i4QHpcSySvXzwv48bCtvIXL/rUJq0NNgfKDk0bx49PHUdLYxQ3/2cqB2g7SY8L408qpzM7VVHwnMkPtQe0DdkkpL+rj+IvAdCnlCZkpTOtBjVze2lHFLS/uCNj34rVzeejdfeztIy272aCw6e6lQSKLn7+5m/9sDC3D/sOFk/nl+wdo9vP/O3dKGn+9eFrAeVc/u5lP9x+RN6dGm1n701N8Pal739rDvzeU0RcFqVF8cMuioP3//PIwv/3wYJ/lpmREs7OyLWBfdlwYq+44pc8yoVj48Of9pnQXAv6XqeLe/+EixqdFhfzbfH9BDvf6uX3M/dWn1LYH+gpuuvtUfvLqLlb7qfoy48JY/ZOTB+ytavzvGS6Z+RvAhUKIq0Jc8PvAhcDrQ6xTQ2NA9td0hNjXzoHa4P092JweShu7BlVXD1vLWgOCE8CB2uAA2LuOmjYbrdYj5fZUtfUuMmCdAAf6aRtAcYj76f2yHgz1A5T5X+cx7XkeOyuCn9vOisAlBPUdwW0vrO1gf03gM61o7qbTPvzGvxrDx1AD1G+A/cDjQog9Qoj/eD+7gSdQkwX+6ng3UkNj8ZiEgG1FwMLRCSzKT+ijBCRGmigIMUfjb6ram7Mmp5CXGCiuCHV+7/ZMTI8KmK86taB/w9lFfbShv/sBWDAq+HiPEGIoDKTmMw4wfzcYBjsFZFAE87wp3M8I4f5w5qRA49exyYFt1ymCadmxQX+naVkxAUODGiceQ5qDklJ2CCEWAL8GVgLjvYdagEeAn0spQ/801NA4BuaPSuA350/iqXUlGPUKPzhpNPnJkfz+wik88M4+1h1uxO1RV6HqFIWC1EjuOrMg5PqoG08ehdXh4v09NYQb9bjcEkWB7y/IZcHoRJ64Yia/eHcfh+o7OXVcEj8+fWxQHT8/azygZngtSI3ivnPGBxy/bnEeVS3dvLG9Co+ULBidgMWgsL2iVTydjwAAIABJREFUjWlZMUEGtT1cODOThk47r2xRF9t2O1y0dbuwGHVcOjebH548mltf3s77u2vxSMhLsPDsVbOG/Dz/fdVsLn5iIwdrO9R06V7RiaII5ubFc9GsTB75soiy5i7OmJCiqvJ21ZAQYSLcqKOooYtxKZHUttvUXqyURIcZSI0Jo9XqZEZ2LGdOTOGJNcW0Wp18Z1YmkWY9T68tpcXqoNvpRkrIirdw55njfHN81580iuLGLt7dVY0AVkxN5/sLAt3sn7tqDpc9uYlD9Z1Ehxn47QWTiDDpue/c8egVwdrDjUxIi+K+c0M/Y40ThyFbHfkKqgO7PT/nGuXRVjSC0OagNDQ0NIaf4VLx+fAGpL59RjQ0jjPFDZ18tLeOaLMeq9NFUUMX8eEmFuYnUFinpr8IN+pp6LQzIyuWfTXtmAwKekXw9o5qDHqF2TlxnDMlzbeAtz8qmq18sKeGuHATZ09ODSmH7qGksYsP99SSFmPmzImptFod/OaDA7TbnNyyNJ9J6TGAOje1qrCB0UkRnFaQTE27jfd31dBuc6JTBJMzojl5rJor6vMD9Ryo7SAlykRtu52xyZGcWpAUMOm/qrCBJ1YX0eVwc+6UNKZnxfLs+lJcHslFszIpaerC7vRwzpS0gIXJm0ubeWVLBW63JDvBgk5RWDImkYnpgcOFW8ua2VDUxKSMGJaMSaTd5uTN7VWsKWyg3eYiPzmCpEgTM3PimD8qgbWHGtlR0UJChInXtlXSZXdz8exMOmwuDtZ1kBNv8a7VEqpK0S0xGxW6HR6WTUgmPSaMZ9eX8sb2KpKjzJw9OYW6djuzcuKYkxcf9NyrWrt5f1cN0WEGThmXxMf76uh2ujlncipJI9BRQ2NoHFUPSgiRj5pCPZ4Qi+OllH26TYxktB7UyGVrWTMXP7EJx1GmJ/fHYtTxyvXzmNDP3M3+mna+/ch6n4R6RnYsr14/L6QibGtZCxc/sdHXtvmj49lS2uLbFsB/r5lLa7eDG5/f5vPRWz4pldWFDUET+VcvzMUj4al1gSneAa6cn8P93qGrZ9aVcP87+wZ1zwkRRt69eREp0Wae21jGPW/uCTpHEfD3S6az3Dvn88Kmcu5+Y7fv+HWL8/h4Xx0lIYQaoM4Jrj3cOKj2hMKoU8iMDaOoj/rvOXt8QPLKw/UdfOsf6+nwPj+TXvGlr48LN/LOzQtJj9HsjkYiw6LiE0IkCyE+BA4A7wDPAs/0+jw9tKZqaAzMU2tLj0twAjXd+nP9SMAB/r2hLGB9z9ayFr4qCW05+fS6koC2rT/cFLAtgYc/PMBjq4sDTF4/2F0TUmX27PpSnttYGvJaz28qo8OmpkT/+xf9JbcOpLHTwSte89RHvywKeY5HwuOri33bj64KPO/pdaV9BifgmIITgMPt6TM4hWrPfzaW+4IT4AtOAM1dDl7arJnFnugMdYjv78BpqIKIz4Gm494iDQ2NkO7dGhr/3xiqlvQ04FEp5U1SytellKtCfYajoRr/v/negpyQiryjIcyg4/J52f2ec/ncbCx+KdRnZMf26UrwvQW5AW2bPyouYFsAd5w+jmsX5QVIr8+clBLSjfuK+TlcPjd0+y6ZneWTTv/g5NH93oM/8eFGLpyZCcD1S/JCnqMIuHbxkWPX9TrvygU5If0Ne1g4un+J/EAYdQqj+qn/+iWjArYvm5sV8Pz8TWNjLQZWzso8pvZofP0M1UmiHfixlPLx49YAIW4EfgKkAnuBW6WUawZRbiHwJXBASjmx17FvAw8Bo4Ai4GdSyjcGqlObgxrZDCSScLk9RJgMPpHE3pp2zMcoknh/dw3xEYMXSaRGm1k+aWgiifd2VdNhUz0Gp2TGBIgk9nutlPoSSawubODxHpHE5DRm5MTy9NoS3BKfSMLm9HDucIsksuOYPzq0SOKSOZm0dw8skjh9QjJpQxRJVLd2814vkYTV4eLcKWmaSGIEM1xmse8BpVLKHxxL4/zqWwn8B7gRWOv97/eA8VLK0F40arlYYCtwCEj3D1BCiHnAGuA+VFeL81FT1S+QUm7qrz1agNLQ0NAYfoYrQI0FvgBullK+dgzt66lvE6q33zV++w4Br0op7+qn3OvATtTRkwt6BaiXgDgp5Wl++z4FGqSUF/fXHi1AnTgcru/gF+/tp7BOXWjqdHmYkhmD3elmQ7EqZpibF88vzptIarSZR1YV8eqWSuLCjayclcnbO6spa7KybHwyd5wxTq3D7eH3Hx3k5S0V2JxusuLCufusAlqtDh5dpYoHrlucx3nT0vnrZ4d4bHURDpeHGdmxRIXp2Vfdwdy8eO45ezwGneCSJzaxp6qNcJOeh86bwLlT0qlotvLAO/s4UNvO7Nw4DtZ2cLC2gwiTnnvPGc/50zPYWNzEwx8c4HB9J4oiyE2w0O30IKXkyvm5XDInC4DaNhsPvruXXZVtTEiLoqHDzr7qdvQ6hQtnpPOt6Rn87qODlDVZOXNiCj8+fSwGncKTa0t4YVMZkWYDt502JiBPVm/e3F7FY17hxPVL8kKa7/amzerkoff2sbG4CaNOobq1G4+EUwuS+MtFU3l8dTGvbasiMcLET84YyyxvWvaWLgcPvruPr0qaiQs30mV3Em4ycNMpoznd6zCxr7qdX3+wn5LGLixGHV12F1MyY7j37AmEGXX88r19rC9qYlJ6NPeeMz7I5FdjZDBcAepzIAN16KwaKCbY3VxKKU8dRF1GwApcLKV8xW//P4CJfeWU8g4JXgosBu4hOECVA3+TUv7Ob99PgJuklP1OPGgB6sTA45Gc8ocvgxzMQzE9K4aLZmdxx6u7fPsEgSKEH54ymtuXjeVPnxTyl88OBZTXeR2+e84XAu49ezwP9CPvXjE1jcYOO+uKjmiIFAG77zud7zy+oU9zWwG8fdMCVvZyGe/N81fPYcHoBL7z2IY+lYWgZpv1VwneujSfscmR3PD8Nt8+o15hzR0nh8zCu6OilW/9c53Pl08IeOsHC5icEdPnNQFuemEb7+6qCXls0eh41hw+8lwiTHrW33UKUWYD1z23hY/21gWV0SmCT25bTGachUUPf0Ftuy3onNm5caRFm3lzR7Vv36ycWF65fn6/bdX4ehgus9g8wACUAy4gC8jt9Qk9AxtMAqADen8j64BgQy5ACDEJdejuMillX/+CU4ZSp8aJR1mzdVDBCWBbeSuf7w/8OvT+SbbK64C95lDwunO3DDxfSnhjW1W/11xV2BDkOO6R8Oq2ij6DU0+7Xt5S2W9w6qnf5nT3G5yAIAn76sIGVve6R4fLw4ai0GLctYcaAkxjpYQ1hwaWkvs7ivdma3mg8Wun3cXWshZvudB1uz2SdYcbKazrCBmcAL4qafb9HXvYXNpC9wDPUmNkM6QAJaXMkVLmDvQZjoYKIUzAS6gijeAVjEdf77VCiC1CiC0NDZoxxolAarQ5KIVGX2TFWYIm/nvTYyg72OR/U7P670EUpESRHhPcIzlpTBIpA0zcLxgdz0DZIQpSIzEbdOT1o3gDNd27P+NSoxgXIm/UuNTQxrGhzi3o49ze1+mL3gtndYrwmb/21Q71ulFkxVkClJX+5CWEBxkDHxFkaJyoHB/d7tHRiDo82Nv2ORmoDXF+KlAAPC2EcAkhXMC9wATv9jLvebVDqBMp5eNSyplSypmJiSdkIuD/d5gNOn5/4RQSvO7hRp36Is6IDSMx4kjW2aRIE7+/cApXLcxj2fhkhFCHlFbOzCTemyV2Vk4sP1qmmsHeftoYZuXE+sob9Qp3nD6W7y/IxaATGHSCK+fncM9ZBSz2cx2PCTOQEqW2JT8pgofOm8A/L5tOlFmVQAvginnZZCeE84fvTPEFqdz4Iy9cAVwyO5MzJqZy/zkTsPgpBiNMOgw6gU4RrJyZyblT1Hmg3104hYxY9YWfFmMm3O9lPCUjmofOm0ic9z5n58Zx+2ljuHh2FudMSfNmJdbx0zPGhQxEoM4ZXTk/x3fv31+Q61MY9scvz5tIflKE929z5BWTERvGU1fOZGmBWkekSc/9504gzRu0fn3+JJ+TfIRJjyJU6fjNp4xmZk4ckWYDv71gsu+ewgyKr97fXTiZB1dMZEyyet30mDB+f+GUAduqMbI5arPY43JxVSSxU0p5rd++QuC13iIJIYQB6G0rfSPq2qxvoaoLO70iiVgp5TK/sh8DTZpI4ptFT1r2WIuRpi4HiZEmPB41rbqUkoQIU0Da75406maDDqfbQ3sfKd2buxx4pCTCdCQdeZfdhYSAdTctVgedNieZceG+6/pLuQGK6jtIjjYTYTrS43N7JC1WBwkRJqSUlDZaSY4yYfGr2+Z0Y3d6cHo8xFqM2F1uXB5JVK/0Ef7Xdbk9NHbZMep0vpe40+2hw+bybfueRbcTk17pVzrfQ6fdhQDCQ6zZ6o+GDjvx4UZarA5sLk9A76nV6sBs0AVdX0pJY6eDhAgjHXYXekVgMQZe1/+eeq7h/3cOtU9jZDFsZrFCiFHAbcAcIJbgXpiUUo4KKhiaPwLPCSG+AtYB1wNpwKPea/3bW+EVUkonEGAgJoSoB+xSSv/9fwFWCyHuBN5EDV4nAwsHfZMaJwR6nUJ8hImKZivbylqoau1myZhEJqRHs728hTd3VLFiaho1bXYUQcDkfmOnnbWHGqltt7F8YiqjvL/4gaCX+aqD9Rxu6OTiWVkB+2MtRjptLt7aXkW0xcDcEOt0RiUdGbYqbuikrt1OeoyZipZuzBkKB+s6CDPofcFpX00b6w41sWxCMtnxR4bwer+kexACKlus1LbZGJsSSXFDF2nRYb57MOgU4sKNdDvcbCtvISchHLdbUtlqZUZ2LE63h0e/LMLp9nDTyaMxGnR4PJJt5S1EmPWMS4kiwqRHSsn28hZq22yq+nFCMnmJ6jNr7LDx9s4a8pMi0CmCzDgLseFGDtZ2kJ8c4RNgVLd2s6W0GbNBwajXoQh1LZQQ6o+ClOgwJqRGcqiuA5vTEnKtmsvtYVtZC/ERRuLCjUE/CICQ+zROTIaq4puEul7JhJqccBLq4tp4VBFCEVAppTx5CHXeCNyBOoS3B7hNSrnae+xLACnlSX2UvZ9eKj7v/guAX6AKNnoW6g6Y6VfrQZ14/OOLw/zuo8AU6UmRppBZVxeOTuCpK2fx0uZy7n1rb4D44aqFudxz9vigMmf/dQ17vMIGnSJ46dq5zPTKov/++SF+/3Gh79xYi4EXr53H2BDJAB96dx9Prg2cOtUJVYQBcObEFMwGhTe2H1Gh9agL+6Lb4ebyJzexxSsy8DdLvX7JKO48cxwAe6vbuPzJr4IyBceHG2i1On1tUAS8ev187n5jty9T8blT0nj425MDrtPDdUvyGJscyY9e3hkkPOlpi14RPLhiIjanm4fe2zdgpl69InB5JELA7UvHcPOp+b5j9e02Lnp8oy+r8MWzs/j1+ZP6r1BjRDJcMvM3UHsiC1F9+OqBpVLKz4UQ16Bm010ipRycxfIIQwtQJxZNnXbm/OpThuIh+7sLJnPfW3uwOgMLKQJ23rcsIAPrmkMNXP7kVwHnjUmO4OPbltDYaWfOLz/1vdx7WD4phX9eOiNgX0ljFyf//svBN9KLToGd950e0g4J4L9flXPX67tDHhMCVv/kZDLjLFz97GY+3V8/qGsmR5mo65UO/ppFuTyxJliXpBOCMKNCp71/pVyESY/D5WKogjq9Ith496m+ucZff7Cfx1YVB5zz3g8X9utKrzEyGS6Z+ULgcSnlQfyWhgBIKZ8APkBNC6+hMey0WB1DCk4AlS3dQcEJVBl4uy1Qll3UEOys3WpVncRbuhxBwQkIermD+sv/aHB7oL3b2efx+hDX6kFKaOi099mmvuiwBburV7R0h26flHQNEJxAncM6GrW3yyMDen2h7jdUT1njm8NQA1Qk6pAZQM83x1/rug5trkfjf8TopEgmDSAh9yfMoOOCGRkhTU0zY8OCJNArZ2YESbXPm5YGQH5yJBPTg9Vv500LdlqYnh1L1gDef1FmPTG9pPOjEsN9CrdQnDU5JUAl509eYjhTvHNuodrUF9+elh5gaBtrMXDt4ryQ18mJt3DKuIFVfUvGJPZptNsfE9KiGJN8ZLh0xdS0gOMpUWbmhZj30/jmMNQhvjLgMSnlr7zbHcADUsrfe7fvBO6SUp6QfW5tiO/Eo6nTzt+/OMz7u2qwOt2MT43itqX5/O7jQiqarYxLiSTGYkSvE3xvfi6TMqJptzn566eFvLG9GrvLw4zsGP68ciqx4cGT69vLW7jr9d20WB2smJLO3WcV+I41dtr58yeFrDncSKRZz5Xzc7lgRkbIdla3dvP46mIqmq0YdAKXB3ITLNS22bAY9Vy9KJcIk54fvbKTw/WdTM2M4XcXTCHa0v96r61lLTy3oRSdopCfFMH2ihbSYsK4fsmoAHeIlzdX8Mn+OlKjzUgpqe+ws3xSKsUNnfxrbQlSwmVzsrj7rPGsPdTIi5vLiTTruXpRHqMSI9ha1sKTa4rZWt6C3eVhSkYMf7t4Kka9jvvf3ssXB+sx6RXSYsKYkBpFYpSZLaUtFKRGcu3iPDwe+MtnhXx+oB6XRxJuVEUSBp2CyyOxOd1kx1uYkBZFYV0n2fEWrlsyyje818Nn++t4bZtqWXXd4lGDMv3VGHkM1xzUW4BbSnm+d/tdYAqq9ZCCavxaLKVcfFSt/prRApSGhobG8DNcMvMXgB8IIcKklN2oXnirUA1kAbqBu4dYp4bGoHG4PDy7vpQdFa3MyYvj0jnZ6LxjUi63h/9sLGNzaQvTsmL47vwcDH0MgQEUNXTyzLpSbE43l8zJYlpWLDanm6fWlbC3up2FoxO4aFYmQgje2lHFJ/vqGJUYwVWLcoPWIw2ExyN54atyNhQ3MTk9misX5GDSH1kD1Nbt5Mm1JRQ3dLJsQgrnTknrp7bBcaC2nWfXlyGl5PJ52T4xwabiJl7aUkFzpwOdIihIjeLqRblUtnTzn41lCCGYnRvL+sNNmA06vrcgxycpHwztNidPrimhqKGTpQXJgxpifHVrJV8crGdsciRXLcz1rblyeyTPbypjU0kzqVFmdlW2UVjXQVSYgcvmZpEZZ+GD3bWkx4Zx9cLckOvaNE5cjnmhrhAiE3WtkRv4QEpZPECREYvWgxr53PHqTl7eUunbvmZRLj87S5WHP/DOXp5eV+o71p8MuanTzil/WEWbV4Rg1Cm8ffMC/vrZId7ffcR05Nal+cSFG7n3rb2+fXPz4njx2nlDavfDHx7gEb9U69+als6fVk71bX/n0Q18VXrEW+8X503ksj6SFg6G6tZuTvvjKrq86gSzQeGjWxfT2OngO49twO0J/HdfkBLpyx3VmxiLgS9+dBKxvdaH9cVFj29gY/GRe3lwxQSumJfT5/lPrC7ml+/v920vGZPIs9+fDcCv3t8fkIa+PwpSo3j/hwsD8mVpjEyGS8UXhJSyQkr5VynlP07k4KQx8nF7JG9sDzRqfXVrZcj/B3htWyV9/QD7dH+dLzgBONweXt1ayYd7Ah2xXt1aGVTvxuJmKlsGZ1bbV9ve3lmN3aUGj/Ima0BwCnX+UHl/d40vOAHYnB7e3VXDG9srg4ITwP7ajpDBCVTl4if7g13GQ1HZYg0ITjDwvfQ+vqqwgQavOm8oz2F/TXu/ZrwaJx5DClBCCLcQ4pJ+jq8UQmj2wRrDgk4RxFoCf8X7D+n0nlCPDzf2+Ws6PoQgIinSFLTmKD7C5PPt68GoVwLWSw2G3nXEhBkwKOo/v6gwfZBKLiFicL2Vvuj9LHrqDHXfAAO5Ag22PZFmQ0C6ewi+997E96o7zKDzeRQOVNYfRQS7gGic2Ay1BzVQ31nrW2sMKz87q8An/TbqFe48Y5zv2J1njvO96A06wd3LC0LWAXDyuCQW+yXqK0iN4qLZWdx5ZoHvZR1m0PHT08dy22ljjhi/Crjl1PxBu6n7t83kfXHrFMFdywt8XnExFiM3nzLa52IeHWbg1qVjhlR/b86clMLsnCPS7qmZMZw7JZ0r5mWHdEG/bnEeUzOPWEGF+XnknTQ2kSVjBpaTg9r2W07N991LlFnPbaf1fy8/WjbG98NACHW7Zw7qzjPHBQW8HhSB7+8CcPWivH5l+RonHkNV8XlQczG90MfxO4C7pZT95yMYoWhzUCcGtW029lS1MTUrJqin0NBhZ2dFK5MyokMm4evNtvIWbE43c3LjfWKLyhYrB2s7mJEdS4y3x9Zhc7K5tJm8hAhyBkhz0RfNXQ62lbUwIT0qZKbXksYuSho7mZ0b36d7xFCQUrKlrAWPRzIrJ84XEJ1uD5uKmzHoBFaHm6x4C6MSI/B4JJtLm1EUwbTMGL4qbcZs0DE9K3aAKwVT2thFcWMns7wu5APR1u1kS2kz+UmRZMUHSscbO+3sKG9lQloUB+s62FzSTFq0mdMnpRJu1LOxpImMmDDykwdOBaIxMjhuMnMhxApghXfzSmA1aibd3sQBS4G1UsozhtTaEYIWoL552JxuFCF8v8Lbbc4+FXgOlwePlINy+AY1aEWY9Lg9ErvLM2S376Fgdbgw6JR+VYn94fauNRpqG21ONw6XG5NBF6A67DkmBEH74cizGaxgob+6eiOl9CVjHMo1NEYOx1NmPhU1MIFqb7TY++lNJ7AeuGmQbdTQGDZcbg8/f3MPr26txGzQsXJWJqsKGzhc38m4lEj+dvG0gF/c//zyMP/4/DAOt4fvzMzkwRUTfT2q3pQ2dnHTf7exp6qdpAgTdreHdpuTU8cl8+eLph6X3k8PNqebn7y6i/d2VRNpNvDTM8ZxyZysgQv68eGeGu55ay8NHXaWjEnkrxdNG3ABsJSSB97Zy783lOGRqi/ezafkc8vSfKSUPPjuPp7fWI5OEVy7OM83jFfS2MVNL2xjb3U7eYnh/Hnl1H5TxHs8al0vbFLrun7JKG5Zmt/n+bsqW7np+W2Ue+2XUqPN/HnlVOZojhLfSAb8OSalfEBKqUgpFdQ5pst6tnt9oqSUy6SUh4e/2Roa/fPatkpe3FyBy6P+2n5ybQmH6zsBOFDbwZ1+Jqu7Klv57YcH6XK4cbolz28q583tfad1//mbe9hTparF6jvttHU7kVJVBj7y5fH9+j+7vpR3dlbjkeow2M/f3D0kBWGHzcmPXt7pU8WtKmzgz58VDlAKPthTyzPr1eAEqi/enz4tZHNpMx/uqeXpdaU43B66nW7+8tkhNharaeN/9sZun5KuuKGLH728s9/rvLe7hmfWH6nrT58WsqW071T2t7+80xecAGrabNz20o6QykSNE5+hjhfkouZY0tAY0fQEkL7YW93W77n9yZX3+JUd6nWHyp5e7fBI2F/TMejyJY1dAXJzgL2DaOOeqtD3uLeqLeT995zfu9yh+k6fnD7kdfqpqzc2p9v3I8Of6jZbUCoRjW8GQwpQUsoyKWXAzzchhF4I8W0hxDVCiJTj2zwNjaNjwej+h3wWjDpiGDs3Ly5oOK+/8v5lh3rdobJgVGB9ZoPCjOzBixbGpkQGScTnD6KNC0IY6gpg3qiEoPsXAuZ79/UuNzM7tt95pd51KUK9RijMBl3Iex+bHKklKfyGMlQV32+Bk6WUs7zbAtXmaBHq97cJmCulLOq7lpGLJpL4ZvH46iKe21hGuFHPd+fn8PmBeraXtzIrJ5YHV0wMeKm9t6uGv352iG6nmyvmZXP1orw+623pcnDv23vZUNREVlwYNqeH5i4HK6am8ZPTx6I/SiFDKKSU/OnTQ7y6pYL4CBM/OX1sgDx+MOyoaOUX7+6josXK8kmp3HVmQZ/SbX+e21DKnz4ppMPuIj7cxF3Lx7Fiarrv2JNrS9DrFH5w8ii+NU01yW3ucnDvW3vYWNzMlIxoHlgxgYzY/g1dn11fylPrSjDqFG46ZbTvGqGobLFy9+u72VSiDgNOy4rhl9+axKghWDFpfP0Ml1nsLuBTKeXt3u1zUYf8fgvsAP4GvCmlvOaoWv01owUoDQ0NjeFnuMxiM4FDftvnACVSyju9F52A6myuoTGsOFwePtpbS1OnnTMmppISPfCaJ1DnMT7cU0uHzckZE1OPemjI5nTz0d5a2rqdnHkM9fiztayZbWWtzMyJZVo/a4++KmlmZ0Urs3PjmJLZ/5LDr0qaeWlzOdFhBr63IPcblZ6i2+Hm/d01dDvdLJ+UqrlIfAMZag+qC7jVmz0XIcRh4DMp5XXe7e8B/5RSnpDLubUe1ImBlJKLn9jo83yLNOl57cb5AcntQuFye/j2I+vZWalOwsdYDLz9g4VBC0MHwu2RfPuR9eyoaPXV8+aNC456AS/Av9YU84v3jhimPnDuBL47PyfovH98cZjffXTQt/3r8ydx8ezQsvMn15bw0Lv7fNt6RfDSdfOGNIc1UrG73Kz4+zoO1KqCkYQIE+/cvCDkAmiNkcdwmcVWAPO8F5gA5KGm2+ghCXU91KARQtwohCgRQtiEEFuFEIv6OXeJEGK9EKJJCNEthDgghPhxr3OuFELIEJ/B/cTWGPFsLWsJMCTtsLt4dn3pgOXWHG70BSdQTVCf/6psyNdfe7jRF5x89Wwaej3+/P2LQHn6P74Ilqt7PJJHvywa8Lwe/vrZoYBtl0fy5Npvhp/zZ/vrfcEJVLeJlzZXfI0t0hgOhjrE9yJwjxAiCZgAtAPv+x2fxpGU8AMihFgJ/AW4EVjr/e8HQojxUsryEEU6gb8CuwErsAB4TAhhlVL+0+88KzDKv6CU0jbYdmmMbFwh1ry43AOPBLhDnDOYckH1eIJdv0O1aUh19mpHqHU9MsR1+lv/43KHaOdR3O9I5Gi/AxonFkPtQf0aeAa1FyWBK6SUrQBCiGjgXOCzIdR3O/CMlPIJKeV+KeXNQA1wQ6iTpZRbpZQvSin3SilLpJT/AT5CVRH2OlXW+n+GcpMaI5vZOXFMyYj2bZv0Cpdltn9RAAAUZUlEQVTPGzh30uIxiYxJPqL2Cjfq+hwe649F+YmM9RtODDfquOQo6vGnt2rwqkW5QefoFMH3F+YEnrcw+Lwerl8S8BsNRcCVC3JCn3yCcVpBMjl+Q7NRZj0rZ2V+jS3SGA6OOWGhryIhFCASsEopnYM434ja07lYSvmK3/5/ABOllEsGUcc04APgfinlo959VwJPApWADlVdeI+UcvtA9WlzUCcOVoeLN7ZX0dTp4OzJqYPO+Nphc/LG9irau52smJp+1KKBDpuTN7dX0dbt5Nwp6UOexwrF5wfq2F7eysycOJb0IyX/ZF8duypbmZMbz8L8vtdkAXy8t5aXNlcQYdZzw0mjGJcSdcztHCm0WZ28vr0Sq8PNt6ala07mJxDDIjM/nggh0oAqYImUcrXf/nuBS6WUY/spWwkkog5RPiClfNDv2DxgDLATNWDeAiwHpkgpD4Wo61rgWoCsrKwZZWXHNpegoaGhodE/x0VmLoRYDNATQHq2B8I/4AwTi4AIYC7wsBCiREr5nPfaG4ANPScKIdaj9qJuBn4Yoq2PA4+D2oMa5nZrHEf217Tz2w8PUNXazVmT0rj5lNG+lBI9bC5t5o5Xd1Hd2k1KtJlfnz/J53rQF89tLOO/m8qJNOu5ZWl+wPllTV08+M4+Npc2I4RgyZhE7jl7/AnrZPBVSTN/+qSQ1m4nK2dmcOWCXLodbh7+8ABrDjUwLjWKny0v+J/2Th5fXcTr26pIjDRx+2lj+pXc93CoroPffHCA8mYrZ0xM4ZZT84/rgmmNr4eBRBJfAlIIESaldPxfe/ceHlV9JnD8++ZGgAQigYSbGLmpCKgVtWChRcXiZVsvbb10F1Croiyt29qu7tpVW/Wp7dZHW3Vtbb1A3dZibRUr9bJYiyDE0JUVAnKVWyAkISaEXCYz8+4f50yYmWQmM2EyF3g/zzMPOWd+88t7wvPkzTnnPe8vsB1lvLjvx7JeQS3gA0rD9pcCUe8ZqeoO98uPRKQUuA9YHGGsT0QqgMgtkk3G8Xj9zHmmvKMJ6ubqzfTvkx1yL6f+sIev/2oNHq9TLLCzrpm5z5Sz8q4LKCnsuqjzjQ37+f6f1nds3/jcB6z43gUMKeyDqnLT8xUh/eBeXVdF3eE2XvjGZ3vjMHvVwcMe5j1bTrPbq+++pZUMLuzDmu0HWbzauZKwreYwe+pbeGXB+UmJ6fcf7Oah1zcBTlPfdbs/ZdXdF0btEO/1+Zn37Afs/dRpIrtl+Vbyc7NZMHNsUmI2vae7PzFudF+Be0o3BO3r6hV4v1tuwlsLzAp7axbOsh2xygIi/vnqtmOajFN8YY4R66saOpJTwDsfHwjZXrOjriM5BbT7lFVb6yLO+86m0Dla2/2s2lYLwO6DLV02K125tY7W9sgNUdPVmu11HckpYPmmAywP+xms2/1p0pqxhv8fNrZ6o3Y3B9hc3dSRnALCj8FkpqhnUKr6XNj28wn+/o8Ai0WkHFgJzAeGA4GCh0Xu953jbi8EdgCBJxVnAHcCHSXmInIvsBqn48UAnMt6k4lQGWgyU1lxf/Kys/AElVKPKwl9UHdsSdcP7o4rjVxQ0dWqrIEHgEsG9GFg31waWkJrgMqK+8W8yGE66ernML60kPrDnpBf+KUD+oQsrd6rMZUUsCxoO0tgbEn0ApiRg/rSNzeblqA/EsZH+T82mSOlF2lV9UXgDuAenPtEnwMuVdVApcIo9xWQDTzsjq0AFgB3Af8WNKYI557SRuBNYAQwQ1XLe+9ITLIN6p/HA1dMpNC99DPlpBNYeEHoJZ2xJQV8Z9Z4ArelsgQWzBzD6cMHhk/X4evnjeLiCc5V57ycLP7lovGcNsypfMvPzebhqyeF/LIeXJDHw1dPTuShJc3YkkK++8VT6OM2jr3w1BLmTi3j+5dP6EgKgeNL1v2cm2eMZrpbmdg3N5t7LpvQbbPZAfm5PHTVRArd/5czTyzqWEDRZLaoVXyxFkWES0KRRK+wMvPM0+Lx0dDSHrUXX1Obl731LQwvyqcwwnLv4WoOtZGfm9Xl+Davj9pDbSBCaWGfjL8Z39TmpcXjCyn0UFWqGloZUtAnps7niXagsZWC/Bz65cV+5tba7qO+2WPtjjJAQsrMRcRP9KKILqlq5l3vwBJUOmvz+vhoTwOjivtFLHCIVVObl8qqRk4pLex26fNY1B/2sOVAExNHDAj5her1+Vm3p4GhA/MZ0YMquETHGW793gbyc7MiXgoFJ1F/UneYSSMG9ugy5ubqQ3h9yoThx87zV+boJaqb+Q3h8+KUa48HXgACnShPB64DNgOPxxeqMdFtrj7EP/5qDQcOtZGTJdxz2WnMOz9yB4VoVm2r5dZFaznU5iU/N4tHrzmL2RN7vs7m0nVV3LlkHW1ePwPyc/j1vHM4p2wQe+qbuf7pNew62EyWwMILxsV12WnV1lpuXXwkzseuPYsvnp6Y9UBbPD7mPlNOuVt8cOmkoTx+3Wc6lej/tnwX//HKetp9yuCCPJ674Vwmjoh8eTSY1+fnthf+zluV1QBMG1PMM/POych7dSZ1op67q+rzwS9gIM4Dsqeo6nxV/Zn7uhWYgFMiHr2ltDFx+s83PuaAW7Hn9Ss/+ssmGlu7bVbSpR++tpFDbV7AqdC7f+kGevqwus+v3L90A21upWBjq5cH3Y7kT7yzlV0HncWn/Qo/X76FqrBKs2h+8FplSJz3vbqhRzF25aW1uzuSE8DrH+3n3c01IWNaPD4e/PNG2t3+drVNnpAu6t15e2N1R3ICWLWtjlc+3HuUkZvjTbwXl/8Z+IWqVoW/oap7gF/gnGEZkzD7GkL7/La2+6nvYdnzvobQJHHgUFvUhqvReLx+6sLiCMxf9WlozH6F/Y2x9ysOP+YDh9q6bP7aE1UNneOoCvu5NLa20+QmyI4xcSTY8OOPtM+YaOJNUCfi9M+L5LA7xpiE+dIZw0O2zxg5kJOKe7b20j9MDp1r9sShPS5y6JuXzYWnhj5nHpg/POay4n6cMTL64oLBwj9/yVHEGe6yScPIDrqc16+L4ygdkM+5Jw+KGlM0syaUkp97JN7cbOGSSYm5RGmOH/EuWLgRd5mL8OUr3PWW3gfyVfW0hEaZJFYkkZ5Uld+s2cXbldWMHtKfBTPHMrigZ62FPF4/T6/YzurtdZwxsojbZ46Jq1IsXFOblyfe2cr6vQ2cP3Yw3/jcyR2J5OW/72HpuiqGF/Xl9plj4yqUCI7zzBOLuO0LRxdnuFVba1n0/k7ycrK4efpoJo3sfG+p/rCHJ97ZyuYDTcw8ZQhzp5Z1uk8VzYe7P+XX7+3A6/Mzd1oZnx1dnLD4TWbrlWaxInIzzmW8DcATHHlg9lScZ5JOA+YHVtzNNJagjDGm9yWqii+Eqj4tIv2BB3C6NwSymwAtwHczNTkZkwx+v/L7it2U7zjIWaOKuO7cUTFfumtsbef5lZ+w82Azs08fykUTwttYHp23Kqt5Y8N+yor7MXdaWczPjKWTZR/t4+2NBxhT0p+5U8voH6WHn0l/PVpuw12c8GKcJd8BtgNvBRYvzFR2BmV624+WbeKpd48sOn39eaN46MpJMX32q0+t4oNP6ju2H/naGVz1mZEJiesPa/fwnSXrOrbPKTuBJfOnJWTuZHlhzU7+/Y9HGv1OHzeYxTedl8KITCSxnkH16K6rqjao6hJVfdh9Lcn05GRMMrz4wa6Q7ZfW7sEfQxXhtpqmkOTkzLU7cXFVhM71wSf1bK/p3Bg3nYX/PFZsqe1UtWkyS2b3aDEmwxT1ywvZHpCfG1PhQWF+TkjlnTNX4i7BFfUNnSs7SzLuEt/AsGPIy85KaGGJST5LUMYk0fe+eAo5bqLJEvjX2REXjg5RUpjPN6Yf6Z5RmJ/DwgsSt8TZNy8c19FsFeDm6aMzbhHGOy4aT/+8I50qFswc2ylpmcySsiXf05HdgzLJsK+hhb/v/JTJIwdy4qDonbrDVVY1suvgYaaOGZzwX74NLe28v62Wk4r7d3RwzzT1hz2s3l7HmJKCjmVSTPrplTLzY50lKGOM6X29WiRhjDHG9La4EpSIzBGRsijvl4nInKMNyhhjjIn3DOpZINrDEee5Y4wxxpijEm+C6q4eNhdITMtlY4wxx7We3IPqsqpCRIqAy4B9RxWRMcYYQwwJSkTuFRGfiPhwktNvAtvBL6AO+Brwu3gCEJHbRWSHiLSKyFoRmR5l7OdFZJWI1IlIi4hsEpE7uxh3tYhUikib+++V8cRkjDEm9WJ5zPpDYBHO5b05wAqc3nvBFGgCVgO/jfWbi8g1wGPA7cB77r/LRGSCqu7q4iNNwM+Aj3CX/QB+ISLNqvqkO+dU4EXgXuBl4CpgiYicr6prYo3NGJNcO2oPs2JLDeNLC21pDgPEv9zGO8ADqvo/CfnmImuA/1PVm4P2bQFeUtW7Y5zjZaBNVa9zt18EBqnqrKAxbwM1gTGR2HNQxqTG8k3V3LJoLV63L+GtM0Zz96UZuayciUGvPAelqjMTmJzygLOBN8PeepPolYLBc5zljn03aPfULuZ8I9Y5jTHJ9/jyrR3JCeDZlZ/Q2NqewohMOkjlg7qDgWygOmx/NRB1bWgR2SMibUAF8KSqPhX09tB45hSRW0SkQkQqampq4onfGJMgHl9o8a/X78fnsy43x7uoCUpE/CLidc92AtudCiTCXt4kxD0dmALMB+4QkX/q6USq+ktVnaKqU4YMGZKwAI0xsZs37eSQ7SvOHMEJ/fMijDbHi+6KJBbhFED4wrYTodadN3xZ0FJgf7QPquoO98uPRKQUuA9Y7O7b35M5jTGp85WzRzKiqC9//fgA40oLueLM4akOyaSBqAlKVedF2z4aquoRkbXALGBJ0FuzgD/EMVUWELwuwPvuHD8Jm3NVD0M1xiTB1DHFTB1j1XvmiFSv5vUIsFhEyoGVOJfshgNPAYjIIgBVneNuLwR2AB+7n58B3Ak8GTTnY8DfROQu4E/AlcBM4HO9fTDm2LCtpomfvvkxuw42c8nEYdz2+TExLSpojEmslCYoVX1RRIqBe4BhwHrgUlXd6Q4ZFfaRbOBhoAzwAtuAu3ATmjvnKhG5FngA+IE75hp7BsrEwuvzM/eZcvbUO0uFr9/bSF52FjfPGJ3iyIw5/kR9DkpE/MR/z0lVNdVnZj1iz0GZ9XsbuPzn74XsO/fkQfz+1qkpisiYY0+sz0HFWiQR7GxgIs5lto3uvgnAeJwzoLXxhWpM+hh5Ql/ycrLweI+UPY8ZUpDCiIw5fsVVJCEis4CvAFeo6qth712BU0n37QTHaEzSFPXL4/4vnc4PX6uk2ePj9OEDuOOicakOy5jjUrytjlYD76lqpwat7vs/Bc5X1c8mKL6kskt8JqCpzUtdUxsnFfdPdSjGHHN6a8n3yThFB5FsBSbFOacxSbe/oZXKqkYi/YFW0CfHkpMxKRZvMUM9cDHwXxHenw00HFVExvSyH/9lE0+9uw2/woRhA1h807kUF/Tp/oPGmKSK9wzqv4Evi8ivReQ0Ecl2X6eJyDPA5cALiQ/TmMTYVtPEk391khNA5b5Gnl6xI/qHjDEpEe8Z1D3AWOAGYB5HlnfPwlkvaqk7xpi0FHi+Kdju+uYURGKM6U5cCUpV24ArReRi4MtA4OnF7cArqhq+zIUxaeXcskEMLuhDbVNbx77LJw1LYUTGmEh69ECtm4gsGZmM0zcvm9/dch6PL99KbZOHq88ewSWWoIxJSwnt+CAi/YChqhq+JLwxaWNsSSGPXntWqsMwxnSj2yIJEfG4ve0C24Ui8qqIdFVOfiWwJZEBGnMs232wmR8t28SDf65k64GmVIdjTFqJ5Qwqh9BElodTrfdor0RkzHGitqmNLz3+HvXNztLmvy3fzbJvTefEQf1SHJkx6SGVS74bc1xbtn5/R3ICp3vFKx/uTWFExqQXS1DGpEhhn84XMArzc1MQiTHpyRKUMSkye+JQJo8c2LE9tqSAKz8zIoURGZNeMnLdJmOOBfm52bx82zRWbKml3efnC6eUkJdjfzMaExBrgrpURIa6X/fDWSPqqyJyZti4sxMWmTHHgZzsLGaeWpLqMIxJS7EmqOvdV7BbI4yNdwVeY4wxppNYEtTMXo/CGGOMCdNtglLVd3szABG5HfguMAzYANyhqisijL0KmA+cBeQDlcCDwav7isg84NkuPt5XVVsTG70xxpjektI7siJyDfAY8BBO0lkFLBORURE+8nlgOXCZO/514I8iMj1sXDNOwut4WXIyxpjMkuoqvm8Dz6nq0+72QhGZDdwG3B0+WFW/FbbrfhG5DLgCWBE6VPf3RsDGGGOSI2VnUCKSh1P1F94V/U1gWhxTFeKs9Busr4jsFJE9IvKaiFhnUGOMyTCpvMQ3GMgGqsP2VwNDOw/vTEQWACOBxUG7PwZuxFmv6jqgFVgpIuMizHGLiFSISEVNTU18R2CMMabXZOxTgSJyNfAT4HpV3RnYr6rvq+rzqvqhW2xxDbANWNjVPKr6S1WdoqpThgwZkpTYjTHGdC+VCaoW8AGlYftLgaj3j0TkKzhnTXNUdWm0sarqAyqALs+gjDHGpKeUJShV9QBrgVlhb83Cqebrkoh8DSc5zVPVl7r7PiIiwGRgX8+jNcYYk2ypruJ7BFgsIuXASpxnnIYDTwGIyCIAVZ3jbl+Lk5zuBP4W1H7Jo6oH3TH3AqtxFk4cAHwTJ0HdlqRjMsYYkwApTVCq+qKIFAP34DyvtB64NOieUvjzUPNxYn6U0AUT3wW+4H5dBPwSp9CiAfhfYIaqlvfGMRhjjOkdomqt8wKmTJmiFRUVqQ7DGGOOaSKyVlWndDcuY6v4jDHGHNvsDCqIiNQAO7sdaIwx5micpKrdPtdjCcoYY0xaskt8xhhj0pIlKGOMMWnJEpQxxpi0ZAnKGGNMWrIEZYwxJi1ZgjLGGJOWLEEZY4xJS5agjDHGpCVLUMYYY9LS/wP13rDpJoyppwAAAABJRU5ErkJggg==\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": 32, "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": 16, "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": 17, "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": 18, "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": 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 }