From 754647054f498ae876415cf5abfce004e1cff7c6 Mon Sep 17 00:00:00 2001 From: Avanti Shrikumar Date: Wed, 2 Dec 2020 08:30:17 -0800 Subject: [PATCH 01/30] ported over code for exemplar hit scoring --- .../hit_scoring/exemplar_based_hitscoring.py | 360 ++++++++++++++++++ 1 file changed, 360 insertions(+) create mode 100644 modisco/hit_scoring/exemplar_based_hitscoring.py diff --git a/modisco/hit_scoring/exemplar_based_hitscoring.py b/modisco/hit_scoring/exemplar_based_hitscoring.py new file mode 100644 index 0000000..39cb723 --- /dev/null +++ b/modisco/hit_scoring/exemplar_based_hitscoring.py @@ -0,0 +1,360 @@ +from __future__ import division, print_function +from collections import defaultdict, OrderedDict +import numpy as np +import time +from sklearn.metrics import average_precision_score, precision_recall_curve + + +def flatten_seqlet_impscore_features(seqlet_impscores): + return np.reshape(seqlet_impscores, (len(seqlet_impscores), -1)) + + +def facility_locator(distmat, num_exemplars): + exemplars = [] + current_bestrep = np.inf*np.ones(distmat.shape[0]) + for i in range(min(num_exemplars, len(distmat))): + candidate_newbestrep = np.minimum(distmat, current_bestrep[None,:]) + candidate_objective = np.sum(candidate_newbestrep, axis=-1) + next_best_exemplar = np.argmin(candidate_objective) + exemplars.append(next_best_exemplar) + current_bestrep = candidate_newbestrep[next_best_exemplar] + return exemplars + + +def compute_continjacc_sims_1vmany(vec1, vecs2, vecs2_weighting): + sign_vec1, signs_vecs2 = np.sign(vec1), np.sign(vecs2) + abs_vec1, abs_vecs2 = np.abs(vec1), np.abs(vecs2) + intersection = np.sum((np.minimum(abs_vec1[None,:], abs_vecs2[:,:]) + *sign_vec1[None,:]*signs_vecs2[:,:])*vecs2_weighting, axis=-1) + union = np.sum(np.maximum(abs_vec1[None,:], abs_vecs2[:,:])*vecs2_weighting, axis=-1) + return intersection/union + + +def compute_pairwise_continjacc_sims(vecs1, vecs2, vecs2_weighting=None): + #normalize vecs2_weighting to sum to 1 + if (vecs2_weighting is None): + vecs2_weighting = np.ones_like(vecs2) + assert np.min(vecs2_weighting) >= 0 + return np.array([compute_continjacc_sims_1vmany( + vec1=vec1, vecs2=vecs2, + vecs2_weighting=vecs2_weighting) + for vec1 in vecs1]) + + +def make_aggregated_seqlet(seqlets): + seqletsandalignments = modisco.core.SeqletsAndAlignments() + [seqletsandalignments.append(modisco.core.SeqletAndAlignment( + seqlet=seqlet, + alnmt=0)) for seqlet in seqlets if seqlet not in seqletsandalignments] + reconstructed_motif = modisco.core.AggregatedSeqlet(seqletsandalignments) + return reconstructed_motif + + +def get_exemplar_motifs(seqlets, pattern_comparison_settings, + seqlets_per_exemplar, max_exemplars, + affmat_min_frac_of_median): + """This identifies the exemplars among seqlets + + Args: + seqlets: A list of :class:`modisco.core.Seqlet` that are already + aligned relative to each other + pattern_comparison_settings: determines which tracks to fetch, + as well as normalization settings. + Instance of modisco.affinitymat.core.PatternComparisonSettings. + seqlets_per_exemplar: determines how many exemplars to + look for by looking for the total number of seqlets and dividing by + this; number of exemplars will be capped at max_exemplars + max_exemplars: caps the maximum number of exemplars + affmat_min_frac_of_median: Kick out seqlets that have poor + within-cluster similarity relative to the median within-cluster + similarity. + + Returns + motifs: Exemplar motifs, sorted by number of seqlets (only exemplars + for the passing seqlets are considered) + affmat: Pairwise affinity matrix for all the *passing* seqlets + filtered_orig_motif: The result of kicking out weak seqlets from + the original motif + sum_orig_affmat: For visualization purposes, can plot the + distribution of the sum of the within-cluster similarity for + each seqlet in the original motif. Is a vector. + """ + print("Numseqles:", len(seqlets)) + #seqlets should already be aligned relative to each other. + # Extract the importance score information. + fwd_seqlet_data, _ = modisco.core.get_2d_data_from_patterns( + patterns=seqlets, + track_names=pattern_comparison_settings.track_names, + track_transformer= + pattern_comparison_settings.track_transformer) + #flatten the fwd_seqlet_data (they are aligned so it's ok to flatten + # them before doing comparisons) + fwd_seqlet_data_vectors = flatten_seqlet_impscore_features(fwd_seqlet_data) + #compute the affinity matrix + orig_affmat = compute_pairwise_continjacc_sims( + vecs1=fwd_seqlet_data_vectors, vecs2=fwd_seqlet_data_vectors) + #Let's kick out seqlets for which the sum of the affmat across all + # neighbors is less than affmat_min_frac_of_median + sum_orig_affmat = np.sum(orig_affmat, axis=-1) + median_sum_affmat = np.median(sum_orig_affmat) + passing_mask = (sum_orig_affmat > + affmat_min_frac_of_median*median_sum_affmat) + + #get a new affmat and seqlets that are subsetted + affmat = orig_affmat[passing_mask,:][:,passing_mask] + seqlets = [seqlet for seqlet,is_passing in zip(seqlets, passing_mask) + if is_passing] + filtered_orig_motif = make_aggregated_seqlet(seqlets) + + + #convert to distance matrix + distmat = 1/( np.maximum(affmat,1e-7) ) + #get exemplars + seqlet_exemplar_indices = facility_locator( + distmat=distmat, + num_exemplars=min(max_exemplars, int(np.ceil(len(seqlets)/seqlets_per_exemplar)) )) + #aggregate over the similar ones, return the aggseqlets + representive_exemplars = np.argmax(affmat[:, seqlet_exemplar_indices], + axis=-1) + exemplar_to_seqletsandalignments = OrderedDict() + for seqlet, representive_exemplar in zip(seqlets, representive_exemplars): + if (representive_exemplar not in exemplar_to_seqletsandalignments): + exemplar_to_seqletsandalignments[representive_exemplar] = [] + exemplar_to_seqletsandalignments[representive_exemplar].append( + modisco.core.SeqletAndAlignment(seqlet=seqlet, alnmt=0) ) + exemplar_to_motif = OrderedDict([ + (exemplar, modisco.core.AggregatedSeqlet(seqletsandalignments)) + for exemplar,seqletsandalignments in + exemplar_to_seqletsandalignments.items()]) + #return the list of motifs, sorted by the number of seqlets + motifs = sorted(list(exemplar_to_motif.items()), + key=lambda x: len(x.seqlets)) + return motifs, affmat, filtered_orig_motif, sum_orig_affmat + + +def get_exemplar_motifs_for_all_patterns( + patterns, pattern_comparison_settings, + affmat_min_frac_of_median): + + print("Getting the exemplar motifs") + #Take each pattern + #Identify some number of exemplars and aggregate around them + exemplarmotifs_foreach_pattern = [] + #indices that mark when the exemplars for one pattern starts + # and another pattern ends + exemplarmotifs_indices = [0] + withinpattern_affmats = [] + filt_patterns = [] + for pattern in patterns: + (exemplarmotifs, patternaffmat, + filtered_orig_motif, sum_orig_affmat) = get_exemplar_motifs( + seqlets=pattern.seqlets, + pattern_comparison_settings=pattern_comparison_settings, + seqlets_per_exemplar=30, + max_exemplars=10, + affmat_min_frac_of_median=affmat_min_frac_of_median) + exemplarmotifs_foreach_pattern.append(exemplarmotifs) + exemplarmotifs_indices.append(len(exemplarmotifs_foreach_pattern)) + withinpattern_affmats.append(patternaffmat) + filt_patterns.append(filtered_orig_motif) + + viz_sequence.plot_weights(pattern["sequence"].fwd) + plt.hist(sum_orig_affmat, bins=20) + plt.show() + print("After filtering: numseqlets", len(filtered_orig_motif.seqlets)) + viz_sequence.plot_weights(filtered_orig_motif["sequence"].fwd) + + return (exemplarmotifs_foreach_pattern, exemplarmotifs_indices, + withinpattern_affmats, filt_patterns) + + +#gets the shifts of the provided coordinate - everything except 0 +def get_shifts(seqlet_coordinate, shift_fraction, max_seq_len): + shift_size_in_bp = int((seqlet_coordinate.end- + seqlet_coordinate.start)*shift_fraction) + coordinates_to_return = [] + for shift_size in range(-shift_size_in_bp,shift_size_in_bp+1): + new_start = seqlet_coordinate.start + shift_size + new_end = seqlet_coordinate.end + shift_size + if (new_start >= 0 and new_end <= max_seq_len): + coordinates_to_return.append(modisco.core.SeqletCoordinates( + example_idx=seqlet_coordinate.example_idx, + start=new_start, + end=new_end, + is_revcomp=seqlet_coordinate.is_revcomp)) + return coordinates_to_return + + +def get_coordinates_and_labels(shift_fraction, patterns): + """ + Get coordinates from shifting the seqlet instances by shift_fraction, + and get labels for shifts that align with the original seqlets + """ + print("Getting labels") + all_coordinates = [ + coor + for pattern in patterns + for seqlet in pattern.seqlets + for coor in get_shifts(seqlet_coordinate=seqlet.coor, + shift_fraction=shift_fraction, + max_seq_len= + len(one_hot[seqlet.coor.example_idx])) + ] + + patternidx_to_positivecoordinates = OrderedDict([ + (patternidx, set(str(seqlet.coor) for seqlet + in patterns[patternidx].seqlets)) + for patternidx in range(len(trimmed_patterns)) + ]) + + #get the labels for the coordinates depending on the patterns + # the very last column is the 'no pattern' class + labels = np.zeros((len(all_coordinates), 1+len(trimmed_patterns))) + for patternidx in range(len(patterns)): + labels[:,patternidx] = np.array([ + 1 if str(coor) in + patternidx_to_positivecoordinates[patternidx] else 0 + for coor in all_coordinates ]) + + return all_coordinates, labels + + +class FeaturesProducer(object): + + def __init__(self, motifs, pattern_comparison_settings, onehot_track_name): + self.motifs = motifs + self.pattern_comparison_settings = pattern_comparison_settings + self.onehot_track_name = onehot_track_name + + #Get imp scores data + (allexemplarmotifs_impscoresdata_fwd, + allexemplarmotifs_impscoresdata_rev) =\ + modisco.core.get_2d_data_from_patterns( + patterns=all_exemplarmotifs, + track_names=pattern_comparison_settings.track_names, + track_transformer=pattern_comparison_settings.track_transformer) + #Flatten the importance score data into vectors + self.allexemplarmotifs_impscoresdata_fwd = ( + flatten_seqlet_impscore_features( + allexemplarmotifs_impscoresdata_fwd)) + + #Do the same for per-position IC (for weighting exemplar sim + # computation). First, get the one-hot encoded sequence data + allexemplarmotifs_sequence_fwd, allexemplarmotifs_sequence_rev =\ + modisco.core.get_2d_data_from_patterns( + patterns=all_exemplarmotifs, + track_names=[onehot_track_name], + track_transformer=lambda x: x) + #compute the per-position IC, then tile (for ACGT) and flatten to + # get it into vector form. + self.per_position_ic_allexemplarmotifs_fwd =\ + np.maximum(flatten_seqlet_impscore_features(np.array([ + np.tile(modisco.util.compute_per_position_ic( + ppm=x, + background=background, + pseudocount=0.001)[:,None], + (1,4*len(pattern_comparison_settings.track_names))) + for x in allexemplarmotifs_sequence_fwd])),0) + + def __call__(self, coordinates): + print("Getting impscores data") + allcoordinatesseqlet_impscoresdata_fwd, _ =\ + modisco.core.get_2d_data_from_patterns( + patterns=all_coordinates_seqlets, + track_names=pattern_comparison_settings.track_names, + track_transformer=pattern_comparison_settings.track_transformer) + #Flatten the importance score data into vectors + allcoordinatesseqlet_impscoresdata_fwd = ( + flatten_seqlet_impscore_features( + allcoordinatesseqlet_impscoresdata_fwd)) + + start = time.time() + print("Computing fwd sims") + features_matrix_fwd = compute_pairwise_continjacc_sims( + vecs1=allcoordinatesseqlet_impscoresdata_fwd, + vecs2=allexemplarmotifs_impscoresdata_fwd, + vecs2_weighting=per_position_ic_allexemplarmotifs_fwd) + print("Took",time.time()-start,"s") + + #We ignore the rc because we want to annotate seqlets as + # matches *for a specific orientation* + return features_matrix_fwd + + +class InstanceScorer(object): + + def __init__(self, features_producer, classifier): + self.features_producer = features_producer + self.classifier = classifier + + def __call__(self, coordinates): + features_matrix = self.features_producer(coordinates) + if (hasattr(self.classifier, 'predict_proba')): + return self.classifier.predict_proba(features_matrix) + else: + return self.classifier.predict(features_matrix) + + def compute_precrecthres_list(self, coordinates, labels): + """ + Prepare the attribute self.precrecthres_list which, for each + pattern, has (precision, recall, threshold) as returned + by scipy's precision_recall_curve function. The + precision recall curve is computed accoridng to + coordiantes and labels. The last column of labels + corresponds to the "no pattern" class. + """ + preds = self(coordinates=coordinates) + precrecthres_list = [] + for pattern_idx in range(labels.shape[1]): + precision, recall, thresholds = precision_recall_curve( + y_true=labels[:,pattern_idx], + probas_pred=preds_proba[:,pattern_idx]) + precrecthres_list.append((precision, recall, thresholds)) + self.precrecthres_list = precrecthres_list + return precrecthres_list + + +def prepare_instance_scorer(patterns, + trim_window_size, + pattern_comparison_settings, + affmat_min_frac_of_median, + classifier_to_fit_factory, + shift_fraction=0.3, + onehot_track_name="sequence"): + + #start by trimming the patterns to the lengths of the original seqlets + prefilt_trimmed_patterns = modisco.aggregator.TrimToBestWindowByIC( + window_size=trim_window_size, + onehot_track_name=onehot_track_name, + bg_freq=BG_FREQ)(patterns) + (exemplarmotifs_foreach_pattern, + exemplarmotifs_indices, + withinpattern_affmats, + filt_trimmed_patterns) = get_exemplar_motifs_for_all_patterns( + patterns=prefilt_trimmed_patterns, + pattern_comparison_settings=pattern_comparison_settings, + affmat_min_frac_of_median=affmat_min_frac_of_median) + + + #get the flattened list of exemplar motifs and make FeaturesProducer + all_exemplarmotifs = [exemplarmotif + for patternidx in range(len(filt_trimmed_patterns)) + for exemplarmotif in exemplarmotifs_foreach_pattern[patternidx]] + features_producer = FeaturesProducer( + motifs=motifs, pattern_comparison_settings=pattern_comparison_settings, + onehot_track_name=onehot_track_name) + + #get coordinates, labels and their features + all_coordinates, labels = get_coordinates_and_labels( + shift_fraction=shift_fraction, + patterns=filt_trimmed_patterns) + features_matrix = features_producer(all_coordinates) + + classifier = classifier_to_fit_factory().fit( + features_matrix, multiclass_labels) + + instance_scorer = InstanceScorer(features_producer=features_producer, + classifier=classifier) + instance_scorer.compute_precrecthres_list(coordinates=all_coordinates, + labels=labels) + return instance_scorer From cf8ed7b2ab75890991e3567bf24dfa591f8de5a1 Mon Sep 17 00:00:00 2001 From: Avanti Shrikumar Date: Wed, 2 Dec 2020 10:25:01 -0800 Subject: [PATCH 02/30] hit scorers functioning for tal-gata case --- .../TF_MoDISco_TAL_GATA_hitscoringdev.ipynb | 1383 +++++++++++++++++ .../hit_scoring/exemplar_based_hitscoring.py | 152 +- 2 files changed, 1480 insertions(+), 55 deletions(-) create mode 100644 examples/simulated_TAL_GATA_deeplearning/TF_MoDISco_TAL_GATA_hitscoringdev.ipynb diff --git a/examples/simulated_TAL_GATA_deeplearning/TF_MoDISco_TAL_GATA_hitscoringdev.ipynb b/examples/simulated_TAL_GATA_deeplearning/TF_MoDISco_TAL_GATA_hitscoringdev.ipynb new file mode 100644 index 0000000..745fe7f --- /dev/null +++ b/examples/simulated_TAL_GATA_deeplearning/TF_MoDISco_TAL_GATA_hitscoringdev.ipynb @@ -0,0 +1,1383 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "view-in-github" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "oPV0Wsfg9OBZ" + }, + "source": [ + "# TF-MoDISco on the TAL GATA simulation\n", + "\n", + "### Note: we are still refining the multi-task version of TF-MoDISco. If you encounter difficulties running TF-MoDISco with multiple tasks, our recommendation is to run it on one task at a time.\n", + "\n", + "This notebook demonstrates running TF-MoDISco on importance scores obtained from the TAL-GATA simulation used in the DeepLIFT paper. See Generate Importance Scores.ipynb for a notebook demonstrating how to produce the scores. There are 3 tasks. Task 0 is positive when both TAL and GATA motifs are present in the sequence. Task 1 is positive when GATA motifs are present in the sequence. Task 2 is positive when TAL motifs are present in the sequence." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 541 + }, + "colab_type": "code", + "id": "CLiK1j6A8YrA", + "outputId": "50383cd1-4015-4627-893c-01c859c3791e" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: modisco in /Users/avantishrikumar/Research/tfmodisco (0.5.8.1)\n", + "Requirement already satisfied: numpy>=1.9 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from modisco) (1.18.5)\n", + "Requirement already satisfied: joblib>=0.11 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from modisco) (0.16.0)\n", + "Requirement already satisfied: scikit-learn>=0.19 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from modisco) (0.23.1)\n", + "Requirement already satisfied: h5py>=2.5 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from modisco) (2.10.0)\n", + "Requirement already satisfied: leidenalg>=0.7.0 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from modisco) (0.8.1)\n", + "Requirement already satisfied: tqdm>=4.38.0 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from modisco) (4.47.0)\n", + "Requirement already satisfied: psutil>=5.4.8 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from modisco) (5.7.0)\n", + "Requirement already satisfied: matplotlib>=2.2.5 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from modisco) (3.2.2)\n", + "Requirement already satisfied: scipy>=0.19.1 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from scikit-learn>=0.19->modisco) (1.4.1)\n", + "Requirement already satisfied: threadpoolctl>=2.0.0 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from scikit-learn>=0.19->modisco) (2.1.0)\n", + "Requirement already satisfied: six in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from h5py>=2.5->modisco) (1.15.0)\n", + "Requirement already satisfied: python-igraph>=0.8.0 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from leidenalg>=0.7.0->modisco) (0.8.2)\n", + "Requirement already satisfied: cycler>=0.10 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from matplotlib>=2.2.5->modisco) (0.10.0)\n", + "Requirement already satisfied: python-dateutil>=2.1 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from matplotlib>=2.2.5->modisco) (2.8.1)\n", + "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from matplotlib>=2.2.5->modisco) (2.4.7)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from matplotlib>=2.2.5->modisco) (1.2.0)\n", + "Requirement already satisfied: texttable>=1.6.2 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from python-igraph>=0.8.0->leidenalg>=0.7.0->modisco) (1.6.3)\n" + ] + } + ], + "source": [ + "!pip install modisco" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "en15RxNL8YFE" + }, + "outputs": [], + "source": [ + "from __future__ import print_function, division\n", + "%matplotlib inline\n", + "/\n", + "try:\n", + " reload # Python 2.7\n", + "except NameError:\n", + " try:\n", + " from importlib import reload # Python 3.4+\n", + " except ImportError:\n", + " from imp import reload # Python 3.0 - 3.3" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 86 + }, + "colab_type": "code", + "id": "uVOSJpXV8aIG", + "outputId": "3fa7a2eb-987f-49d6-8e8c-307a93d580b8" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "TF-MoDISco is using the TensorFlow backend.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages/tensorflow/python/compat/v2_compat.py:96: disable_resource_variables (from tensorflow.python.ops.variable_scope) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "non-resource variables are not supported in the long term\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/avantishrikumar/anaconda3/lib/python3.8/site-packages/sklearn/utils/deprecation.py:143: FutureWarning: The sklearn.neighbors.kde module is deprecated in version 0.22 and will be removed in version 0.24. The corresponding classes / functions should instead be imported from sklearn.neighbors. Anything that cannot be imported from sklearn.neighbors is now part of the private API.\n", + " warnings.warn(message, FutureWarning)\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import modisco\n", + "import sys\n", + "import os" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "ROG0LVF_9ZZs" + }, + "source": [ + "## Grab the input data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 443 + }, + "colab_type": "code", + "id": "bZ8jaBDZ8fmm", + "outputId": "87734ddd-01e6-4433-9650-5f5e0ef01b97" + }, + "outputs": [], + "source": [ + "#grab scores for tfmodisco\n", + "#!/usr/bin/env bash\n", + "![[ -f scores.h5 ]] || curl -o scores.h5 https://raw.githubusercontent.com/AvantiShri/model_storage/23d8f3ffc89af210f6f0bf7e65585eff259ba672/modisco/scores.h5\n", + "![[ -f sequences.simdata.gz ]] || wget https://raw.githubusercontent.com/AvantiShri/model_storage/db919b12f750e5844402153233249bb3d24e9e9a/deeplift/genomics/sequences.simdata.gz\n", + "![[ -f test.txt.gz ]] || wget https://raw.githubusercontent.com/AvantiShri/model_storage/9aadb769735c60eb90f7d3d896632ac749a1bdd2/deeplift/genomics/test.txt.gz" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "_ShCbHRM92_y" + }, + "source": [ + "## Functions for one-hot encoding sequences¶" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "KawKTu5P8-c6" + }, + "outputs": [], + "source": [ + "#Functions for one-hot encoding sequences\n", + "import gzip\n", + "\n", + "def one_hot_encode_along_channel_axis(sequence):\n", + " to_return = np.zeros((len(sequence),4), dtype=np.int8)\n", + " seq_to_one_hot_fill_in_array(zeros_array=to_return,\n", + " sequence=sequence, one_hot_axis=1)\n", + " return to_return\n", + "\n", + "def seq_to_one_hot_fill_in_array(zeros_array, sequence, one_hot_axis):\n", + " assert one_hot_axis==0 or one_hot_axis==1\n", + " if (one_hot_axis==0):\n", + " assert zeros_array.shape[1] == len(sequence)\n", + " elif (one_hot_axis==1): \n", + " assert zeros_array.shape[0] == len(sequence)\n", + " #will mutate zeros_array\n", + " for (i,char) in enumerate(sequence):\n", + " if (char==\"A\" or char==\"a\"):\n", + " char_idx = 0\n", + " elif (char==\"C\" or char==\"c\"):\n", + " char_idx = 1\n", + " elif (char==\"G\" or char==\"g\"):\n", + " char_idx = 2\n", + " elif (char==\"T\" or char==\"t\"):\n", + " char_idx = 3\n", + " elif (char==\"N\" or char==\"n\"):\n", + " continue #leave that pos as all 0's\n", + " else:\n", + " raise RuntimeError(\"Unsupported character: \"+str(char))\n", + " if (one_hot_axis==0):\n", + " zeros_array[char_idx,i] = 1\n", + " elif (one_hot_axis==1):\n", + " zeros_array[i,char_idx] = 1\n", + "\n", + "#read in the data in the testing set\n", + "test_ids_fh = gzip.open(\"test.txt.gz\",\"rb\")\n", + "ids_to_load = set([x.rstrip() for x in test_ids_fh])\n", + "\n", + "fasta_sequences = []\n", + "for i,a_line in enumerate(gzip.open(\"sequences.simdata.gz\",\"rb\")):\n", + " if (i==0):\n", + " next\n", + " a_line = a_line.rstrip()\n", + " seq_id,seq_fasta,embeddings,task1,task2,task3 = a_line.split(b\"\\t\")\n", + " if seq_id in ids_to_load:\n", + " fasta_sequences.append(seq_fasta.decode(\"utf-8\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "m1xkAlvW97vL" + }, + "source": [ + "## Prepare the data for input into TF-MoDISCo\n", + "\n", + "You need a numpy array of importance scores and hypothetical importance scores for every task." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "xahZGqrA9Jpq" + }, + "outputs": [], + "source": [ + "import h5py\n", + "from collections import OrderedDict\n", + "\n", + "task_to_scores = OrderedDict()\n", + "task_to_hyp_scores = OrderedDict()\n", + "\n", + "f = h5py.File(\"scores.h5\",\"r\")\n", + "tasks = f[\"contrib_scores\"].keys()\n", + "n = 100 #since this is just a test run, for speed I am limiting to 100 sequences\n", + "for task in tasks:\n", + " #Note that the sequences can be of variable lengths;\n", + " #in this example they all have the same length (200bp) but that is\n", + " #not necessary.\n", + " task_to_scores[task] = [np.array(x) for x in f['contrib_scores'][task][:n]]\n", + " task_to_hyp_scores[task] = [np.array(x) for x in f['hyp_contrib_scores'][task][:n]]\n", + "\n", + "onehot_data = [one_hot_encode_along_channel_axis(seq) for seq in fasta_sequences][:n]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "hQEQgz1w-QhL" + }, + "source": [ + "Double check by plotting" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 405 + }, + "colab_type": "code", + "id": "Ky6nlCFs-NcP", + "outputId": "1319f738-704a-4241-a804-ab54e6d3246b" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABI0AAACPCAYAAAB3TyssAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3wU1drA8d/Zkk1vpNF7ERAFBRVQFFEBsSuWa0HFiq+o1ytcG6AUO1fk2q/92gEFAUVERGlSQwmdBBJSSEjfZLNt3j/OJrubbCga9SrP9/OBbJmZndkyM+eZ5zxHGYaBEEIIIYQQQgghhBCBTH/0CgghhBBCCCGEEEKI/z0SNBJCCCGEEEIIIYQQDUjQSAghhBBCCCGEEEI0IEEjIYQQQgghhBBCCNGABI2EEEIIIYQQQgghRAMSNBJCCCGEEEIIIYQQDTRJ0Egp9ZZS6qBSaksjzyul1Ayl1G6l1CalVJ+meF0hhBBCCCGEEEII8dtoqkyjd4Chh3l+GNDZ9+924JUmel0hhBBCCCGEEEII8RtokqCRYRjLgOLDTHIJ8J6hrQLilVLNm+K1hRBCCCGEEEIIIUTTs/xOr9MSyA64n+N7LO9wMyUlJRnt2rX7DVdLCCGEEEIIIYQQ4viybt26IsMwko803e8VNFIhHjNCTqjU7egubLRp04a1a9f+luslhBBCCCGEEEIIcVxRSu07mul+r9HTcoDWAfdbAbmhJjQM43XDME41DOPU5OQjBr2EEEIIIYQQQgghxG/g9woazQVu9I2idjpQZhjGYbumCSGEEEIIIYQQQog/TpN0T1NKfQScDSQppXKACYAVwDCMV4EFwHBgN1AF3NwUryuEEEIIIYQQQgghfhtNEjQyDOPaIzxvAGOa4rWEEEIIIYQQQgghxG/v9+qeJoQQQgghhBBCCCH+RCRoJIQQQgghhBBCCCEakKCREEIIIYQQQgjxV1OyEQpX/tFrIf7kJGgkhBBCCCGEEEL8lRxaC4v6w5LBkLfoj14b8ScmQSMhhBBCCCGEEOKvJP1h8FSDxwHr//5Hr434E5OgkRBCCCGEEEII8b+kphiyPgRX+bHP6yyFg8v89yt2N916ieOOBI2EEEIIIYQQ4jj33Irn6Daz2x+9GgLA64LFg2DVLbDkfDCMY5s/50swWX+bdRPHHQkaCSGEEEIIIcRx7vV1r7Pj0I7fZuFet+4mJY5O7tdgzwJvDZRtBaWObf6C78Fd6b/vlfde/HISNBJCCCGEEEKI45zH8Bz1tE//9DRRU6OObuKi1TA7FT6Lh52v/MK1O87snOkP+rjtxz7/oTVNuz7iuCZBIyGEEEIIIYQ4zrk8rqOeds72OVS5qho8fu3n17Jw18KAhVbCskvAWayzZjZIQeYjclXCwaUBDxxj1zTDgMo9+nbry6HDLU21ZuI4ZfmjV0AIIYQQQgghxO/IWQZ530Dz8yEsHoBqV3XwNGlpUFAQ/FhqKuTnU+IoqZsnwhpR9/THWz9mV/EuhnUeph/YORNcZf75pYvakZWmgzkcvM5fNn91HigTxHWHM97Xj9UGkYT4BSTTSAghhBBCCCGOF14XLOoPK2/Sf31Flu0u3Q2qxl2jp6sfMAp4LLc8F4DM0swGk7i9bv+dPW/qQFHrK6DrvWCSnIUjKt7gDxipX9Bcr9wDpjDocKt+v03h0Pmupl1HcVyRX60QQgghhBBCHC/2z4Kq/bo4clV2XZHlarfONCpxlJAWnXbYRVS6dL2dvSV76Z7cPeg5p8cX8KjOg6ocaDkCzngPUBDdqWm35a/o0CodaOs8BvrO1MG9Y1GxWxceb3uNDh4BtLyo6ddTHDck00gIIYQQQgghjhcZ0wKKLFc2eLrUUXrY2Y2A4d/3FPu7PXm8upB2Xa2jgqU6aNHvDbBEgiUCOo7+det+PCjdot+3k5/S9/u8cGzzV+WAMkN4UsCD3iZbPXH8kaCREEIIIYQQQhwPqgugfMdhJympLjns84eqD9XdzijMqLtdG2wqrynXD5Rvh5guYDnKUdaEZs/S2Vm1gZ5j7dLnKID47uAOKFTuPfqR8YSoT4JGQgghhBBCCHE8OLQKzLbDTlJb5LoxgdlFa3L9Q7sXVxcDUOn0ZS+VbYPUQWCy+me2+ItmixDcVTr7K20IWKL1Y+ZjDLo5DkJMZ51tVMsc3nTrKI47EjQSQgghhBBCiONB4XIdlEgZBEN+1H/rOVKm0d6SvXW3N+RvqLtdGzRyeV36gcpdEN9LAhbHouYQmGyQ1N9fBPtYM41qiiC6s+4SWOsIgUIhDkeCRkIIIYQQQghxPCharUdLO/0dSBmo/xIwYhpHzjTaVbwLgDZxbQB/LaPaoFGdqhyI7do06328cBaDskB0h1+3jOh2wZlGQvwKTRI0UkoNVUrtUErtVkqND/H82UqpMqXURt+/x5vidYUQQgghhBBCHKXybdD8fLA10/dtiUBwoKgu0yg1teH8qalsObgFgI4JHQE4UHEACK51BIDbDpGtmnDljwPOYgiL94969ku4ysCW3HTrJI57vzpopJQyA/8GhgHdgWuVUt1DTPqjYRgn+/498WtfVwghhBBCCCHEUfI4wXlIF1murZNj1nVzArukFdgL9I38fJ2VVMswID+fxXsXA7AqZxUAS7OWAsGZRoZhgOHRXa0aUVMD6elQXNzoJMefmmKIaA4ex9FNn5YGSgX/O7ivLhgoRFNoikyjfsBuwzD2GobhBD4GLmmC5QohhBBCCCGEaApOX72clLPBVFsvR/8NzDQ6aD942MXUTlvtrgZgSeYSAA5V+TONqlxVOsikApqbs9PgQwUfmikshJ49YeBAaNMGfvjh127cn8OWLfDii5CT08gEzmKwxgJGIxPUU1DQ8LEwA8ISfukqCtFAUwSNWgLZAfdzfI/Vd4ZSKl0ptVAp1aMJXlcIIYQQQojj0qpVcN55cM01UFT0R6+N+MMZBmQ8B0sugN1vhp7GUahHMovp2OCpwEyjvIq8Rl+muKphWtC2wm16vkr/fMXVxTpgZAQM9e7QAQ6PVweL9u2Dykqw22H48MNu3V/C8uXQrx+MGwc9eoDHE2IiZzFYYn7dC1nxBZ6EaBpNETRSIR6rHxpdD7Q1DOMk4CXgi0YXptTtSqm1Sqm1hYWFTbB6QgghhBBC/HWsWgVDhsDixTB7NpxxBni9f/RaiT9U+j9h8wTIXwTrxup6QvXVFEF4WsgkllJHad3t2hpFIV+mIB0AkzIRZY0Kmj63IrduukPVh3SAytkwyPTF2kvJzYW+feGbb+C++3RXtb+ymhq46iqorta37XYwh6pT7SiEsDhdDDuU8h2wsDcs7KNv16fQn68lqgnXXhzvjnH8vpBygNYB91sBuYETGIZRHnB7gVLqZaVUkmEYDa6LGIbxOvA6wKmnnnqUeXlCCCGEEEL89Xm9MHKkbnTGxoLDAfv3+3sbiePQoTWw4yXwVOn7nqrQQYOaQrAlgdcJRAQ9Fdg9ra6mUQiVzkoABrUdxNjTxnLpJ5dis+i6Rdll/s4nxdXFuhhz5V6I7Ra0jOkL76d9e1i0CKKiYMAAsDRFq/R/2Pz5OquqVsgsIwBnKYQlhi6E7XXB90PBvk/fXxoiPcuEDho1FnQS4hdoisPLGqCzUqq9UioMuAaYGziBUipNKaV8t/v5XvdQgyUJIYQQQgghGrV4MZSWwq23QmGhLmnSpcsfvVbiD5XxNHhroP8HcLUDej9f99TkZZPp/5/++k5NEVjjCJVqVFvE2mqy6npEjdhTsgeAPs37cF7H8wB/d7bADKXiat+w72UZYPjS4MJT8XoVa/b2ZfJkCA/XD0dFwYQJv2TD/zzefhsqKuDVV3W20X33NTKh4dafkTlE0Gjny+A4iP78DKgOEdyrDRqF7AwkxC/zq4NGhmG4gXuAb4BtwKeGYWxVSt2plLrTN9mVwBalVDowA7jGMAzJIhJCCCGEEOIYvPMOtGoFM2ZAWJjONvr66z96rcQfxlMDufPhhIeg1aVgtkGn2+uenr5qOitzVuo7jkI9nHuIJmBt8evEiMOPurW1cCsAbeLaEGmNJMISQbW7muLqYt0lzae4uhhiT4Ci1eD2pdhcns/egx0ID3MxdGhw96xGM2/+ArxeWLoUrrgCrr9eB8umTGlkYsOtu/WFsvs1fzYZgMcOqanB09R+tCpEMz/USGtK6ceFOIwmyVszDGMBsKDeY68G3J4JzGyK1xJCCCGEEOJ4tXo1/OMfYPW1K00miPmVdXPFn1jFTj0i2gkP+rukWaPrnrY7A2obOQ+BrVnIoERt0Cg5MpkCewEujwurueF0GQczAGgR0wKAZpHNOFB+gL0lewFICE+gxFGiR1JL7gLZs4O6Wm3OPpGuXQ0cDh30rBUR3FvuLyUrS9cp/+c/dVYVgM3WyMReN5hCNNEdB6FyD0Q0h6HrAUPXNcr3FR9XvsyiSjt8Vi+bbHaaLkLeWK/DUCOwCRFAej8LIYQQQgjxJ+DxQHY2DBvmDxoBREc3Po/4iyvLgLgeoQMNQI1HV5h2e906IGGNDVkvp7BKD0AUHx4PBBfGDpRVmoVZmeuCRmnRaSil2HVoFwApUSmAry5Ss77groID88HjACC/LI2OncIaFG4PC9Eb669i715ITISePf2PhSyCDehgT0ATfXYafKj0X1M4nP4u2BIhrBmc8U7D2ZVZL8MIeIMdEhQSv44EjYQQQgghhPgTyMyEyEho0SL48d+8CLajEL7uCx9ZYNGA4Aap+GOVboboDkec7ED5AV1IWVlCdl2qrWmUEJEABBfGrmUYBiWOEgwMWsW2AqBjQkcMw6irdVQbdMqvzNdBI8MJq2+F6jxwV1PjsmGLUMdV4fbMTOjWTdcyCuWzrZ/x2JLH9B1lBiOgr15dwMfQAb+UM3XQzxwGKYMaLkyZfL/PEJVg4hpZwfpd3ISo5zj6uQohhBBCCPHnVVICbdr8zsOTu+3w9SlQkq4bs8VrQ9dLEX+MykyI7QqWhulmgSVk95Xt89fLUQ2LJO88tBOAr3frAllbD25tMI1SiuUfRfDTG17axLcFpZh50yfM+6/BxXdOB6BZRDPA193NZIXmw8BVBnM7wKdRWM0uPG7dXet4sXu3DvQ2ll107axrmfzjZH1HmfXnFErz83S2WC2vq+E0tZlGnhA7iZcJfuMNQ//Lzz+azRDHMdnjCyGEEEII8SfgculuPPW79hyRPRsynoEdM8BVcWzz7pgBNYeg+fkw4BNIPfsYX1z8IqGKFocqWOxx6AyUEIG8wGyhfaX7ABWcxVLb9elDMw637j7m8gUiagte19d7azFn5PjvJ1XBhbugxK4zlfIqdY2dzNJMPUG3B8Ac6ZvaIC6yjAPZrgZBo79yIey9e6F9e50lGIrH95kU2gt1JpinOvhzqpU6OKheFdYQxcyUCTD5i48L0QQkaCSEEEIIIcT/Ak8NFG+Ayr0hn7Zawek8xu5ouQthfndIfxQ2joN5XUJnKIRieGH7dB0wGvgptB0JZ84+hhcXv1io4sShHlMqOHskIBCkA0VaVmmWzvwxPP7uhXVdnxpGIQvsx1YH54d2+u+G/A0A7C/brx9IGYjR5hrcROIxwjihcwXbdkXVFYSuZbdzWFFToxj2wbBjWqcmZxhQlQPOhl33Dsfh0PG+UJlGeRV5dbeXZi3Vo985i8HjbDhxbJeje0FLBDhD16QS4pdoktHThBBCCCGEEL/C/s/h5zvB69TdUxL7wrlLwORvaSYk6ELYjY68VJ/jIPw0EmxJcOIEcJbB5gmND+ldX2WmLmR86ktg8aVJWKIOP4/4fVmiwZGnA4Ema1AgaF+ZP2i0vWg7tInXgUnDE5SZVBUic63IXnRMq5Ffr3ec1xeYcrvhb9Nfo2VVb5rH5fJR+oMUFUFGBpx0kn/6IxXCrnJV8c2eb45pnZqU1wXLr9VFvTGg36vQYdRRzepyBReuD/R91vd1txfuXshV7VtDxS4wXEC9IeUiWx3dulqijzmwJcThSKaREEIIIYQQv6PMTD389qhR8O674MpeDKtGQcebYXi6DhYZnqCAEeguLnY75OUFL6/R7moZz0B4cxi2EdpdD53v0LfRo2mpSYr309/X04bqDjWkE1g7gDW+SbdfHIVQxYlDPRbXA8p36uBePYGZRpsPbgZzODgPNah3sy9E4llRVSNBo0aKJh9s1jCS6fV6mTIFvppvYfr8e3jow6ls2ZlIu3YwaRJU+npQVVfDl1/q206nvv3BB3DggG/Z9oMAGKGKO/9eVt4EuQvA6wBvDawZc9SzWiyN/0bn75pfd/u/m/8Ltma6C2moYvNhSUf3gtY43aW0VviRC1273bBkCSxcCBXH2INV/PVJ0EgIIYQQQojfyWuvQY8ekJ6uG5NPPQVq3T3Q8zE4cSJEt4ek02Fww6wKsxlatYKvv9aNvFqVjZUvyfkCek3QWUImiw4ahCcD/sLHdbVrQnV9ageknkzIkZjEbys/v2HR4lAFi+O6Q8VOPaIWBAUIdhXvqrudUZihn6spaVAvZ3+IusuNBo1q16veuhWec1qDSXOKi3juOUhJgR07oLgYzjkH7r4bvvkGpk3TRd1XroRbbtF/27SBG26Ae+6BTp30d3vNgTV1y6x0/gG1esp36t9SZGs4ZxGc9iahuvQ1JixMb3uowNEnWz4BIMISgdPjJNthB3dA1CYw4GM+QjpW3QsmBGScAZcfvtD1ihXQrh1ceilcc43exzQ20ps4PknQSAghhBBCiN/Bpk0wfjx89x188gn861+w/sd9WFx50OX/grt+mcJDLqNfP3jxRZ2RAbohGrIejKsc7PuhxfDg7mi+19iYrzOO0vPTG1/heCC2Y8iRucT/iLjuuhuh3Vd4OiBAsKNoBwCtY1vjMTwYYc30SGa1QUBfQCLPF0MyKRM2s84YCiyifTRqs4EC/Xd2KWYzfP89dOigu1fOmQOjR+sA6NSpEB4O556rY1BDh8KIEboLZlERvP02REfDqpxVdctcn7f+mNarSex6WWfbXbBKF6Nuey2cNfeoZ2/VSo+gVj8QsypnVV0R7Gq3fnJe1k+6a5nyVZGp/TyVOXT2UShhiTqQGGoEtXqys/X7fv75sGuXvj9uHEREHHFWcRyRoJEQQgghhBC/g5kzdRZFr14QE6MbxBHuXRDXy1fDJIAp9Pjco0bpht0DD+jAUWUlDPPVB3Z5XCQ8nUB2WTZUHYCIFmAO3fpbnbMagBU5K/QDobodWdDz1w7RHlBkOaSjHfFLNJ2odjqTbP39DbqoZRRmABATpkfZKjUsvoCErwnoC0ik+O6elHoS959+PwCtYo6yfo5PeU05AJHWSEy+5a9YrjjzTEhM1Fl1oP/GxMCCBRAZ5cVqNYiM1MHQ/v11QDQuTk93ySV6nq93f133OrXf299V3jfQZYwO5JrM+v1OPuOoZ+/SRXe1c9X7iS/fvxzQWUZxtjgAtpTk6t+uuV53v3p1qA77WwxPhordehS2I3j2WRg8GF56Se8CYmNh7FhC/5bl93zckqCREEIIIYQQv4Nly+CKKwgeOUpZwWP3ZxbAYRuE552nG3avvabbb6mpuqgw6MZ1qaOUtze+7auJZA3OTghY7tydOlOivKYco7brU/1uRzeO1qMw1Y62Vtvl5W5v6Abl0Y74JZqOUtDhFij4AVbcADn+DJjcylwAdhbrrogrCndBdV6DQGKZ7yM/Oe1kRvYYCfgzX45W85jmAEwYNIFeqb0A2LMphREj9Pe1Vm3B64EDoeqmE4m4YAqffKKDKvfeG/zbiIgAwzBYm7eWCIte58DC0b8Lr0ePZtjuWj0qWa1GMgFDad8e9uzRWVWBVh3QGVQvX/gya29fC0B6SbaumVRTGGJdAqJOhxn5jvBUKN+us5OO4JNPdGZR4Ptef2S7o1aVA7lfQ/G64P2I+NOToJEQQgghhBC/A6s1RP2hxFOgLKOR0Y4aNgjNZt3Qi4w0KCkBt9tLq1a6gTbtp2kAPLP8Gd1FpTovODvB19A0DC9ZpVlE+kZECxxlK0hMFyjfAe56/d/Kjripfo0UTha/QuEKWH07rP0/KNsG3e7TNatyZsMynZ5z0JJcN7nbq4sWpZce0PVy6g3HXuLrnpYYkUiMTWclHWv3tNpaQ5d1u4zuSd0B2L83gtMaljoCoLi6GFIyKD/1MUaMgIMHda2v+mrrGdV24wrMOvpdVO7VmUWRrYMfNx39IOTt20NubnABe8Mw+D5TB8B6p/WmQ0IHbGYbO+2HMLxOKN3ccEE1RzmiXXgK2PeB6cjDLBYVQffuIZ4IVVOrsbpazjJYOgIW9tXF91eOgi/b65EgxV+CBI2EEEIIIYT4HVxxBbzzTr3AkTUaml8Aq27R3Ys8Trhod9B8+fmwebO/dtGANnNY9M8LGdT9Ry7uM5dVU86ltLqElTkrSQhPwO6ys8dRrQtfF6/zL8hXwybXFyTo0qwL4K9v1EBibyjb4u8qU1uUN66RDUxNPbrizbUOLoPFg2FWKizsA/s/lwyFwzEM+PlOWHIe5C+C/bPh6z5gjaXylHk4vZFUu6NxGjH8fNJbDWZPL83VDfnS4DpWxb7vQ5wtrq4rW0XNsQ2hVerQgagYWwyJEYkA1DhMtGgRevrarlkAXsNLVFTor8qHWz4EwOnRAQgDg22F2+rmq3EfuW7Pr+I8BJHtwOP4xYvo2FF3JX35Zf9vuKDETqWzkuiwKE448D6mOa041WZQ7AHD8EDBsoY1iaoO+G8fbkS06A46YFSyIcT2BER8N00iLMyg7FiCwKH8MELXPbtkF5w1Gy74GU560l+cXfzpSdBICCGEEEKIX6MqF9Y9AF92gNkt4bshkP1FgwDI7bfrUaNmztRFcSsrIScH6PcalGzEWNgbNj8O6/4PgINlyVx4oR7ZaOBA3R2tat9yWHE9A4Z1YenPbZj1dTtSUhRP/PAkAGG+EZYeXPQgpJ4Nmyb4M4V8NWxW+noexYfHA4fp8hN/MtizoGiV7qZTW5T3ZUKOoHW4AJHdrgvt7tgB5eXAnrdh2eXQrC8M/FgXF17/IDSXukiN2veJDqydOQsu3AaX7IZTZ7JmQxQtep/D5a/9zCtrXuaC6RvIKs0GwKzMdd+JPZW+TJW8RUFBkCJf0CjWFkt0mC56Xuk6tlHKKpwVdcuoDRp5vQpzIz2kvsv8ru72loNbGDEC3nwzuKi7xwPrcnXQ02a2YfFl99TO+9zy5wifEs6+0kYy5ZqC1+UrJB/wXa/r5mnS7+X3w2B+T1h5s84arMdmgz59dOH7HTt0AOmHb6PJ+b9tZHdpRljuPOgyhm+HPMD+7q0whadCzpwGo9xRGRBMPtyIaNEd9frufh1clcEBry/bQIIVEiOhaCVndVnMf/8bXKTbHWI0vUYVr9cF909/WweOwuJ1N77Wlx/DQsT/OgkaCSGEEEII8UuV74SFJ+tRrC7aDpft10GglLP8BaR9WrSAbxcZ/OsFJ107ORg00EHXLm6M8DTezN/Kf+afR+6KD9j+02oKK1M4c/IKvF7YulV33/n0U4jMGAtd74OTpkBUW0g4GQbN5bX1rwH+Uazm7pyLccI4KFoBa8boLkm+TIWXfb2TamuqvJf+XuhtC0+CuJ6w+jadceE6tuwTgLIyPVrWhRfChx/CZ5/BrTeWYay5B87+Ck6cAKnnQNf/g/N/AtQRl/ln5nA76DazG8VVxcc+c8ZTcOJE/d2yRIA5gqqkqxk2TA9R/9miHtw6+QYW/NgRq1k380b3Gc3HV3wMQKQ1CiLbwL6PCAyCFPhiEzG2GCKtkXXr6fHWC1o0wuP1UOXSRbgjLBHEhetUNJPZQ1VV6Hlqh5oHWLZvGXffrb8fCxbowFF5uY5B1hbY/vjKj7nvtPsAKLTrej+Tf5wMwNPLnz6q9fxFTDZdUDqwPlBdPSEDVt0GSadDryd1Rp6tWcjFjBqlg0f9++sA0nXXQdLOF4iPaQ3D1kH3h4joNYGWl2yG2K5Qvk2PgOYNiODkL2nYVTSU6I56nfd/Cq7S4IylnhPgYAkcPARnfsbYv8cyfTps2wYVFfp9LzpcL7iJE4MDuledAgn9GnZFs/zSwkjif9HRd8YUQgghhBBCBFt3H/R6Atpd5++OEdMRHIWwbbquCWSJ0AWpvW5Oq9rFgTdyWVz4JIfsKfRt/T1TpzzMfz9M5t13Z5J88kwS3DorKbYFzJoFkbodz5AzC2H+VhiyJKhRllVRQJWrinBzOFPPncrTy5+mwF7AymoX/TuOhj1vQea7ddOnuxRg4HDrDITarkUh9ZoEy6+B+d2hWSMFag7jiiv0KFgvvqgbzUqBa8csVMFZENdD14sB3ZUuLMGfrVQbcPuLdVd7L/09dhzawcw1M3l80ONHP6OzRBc37nCj/z0Dvvommk6d4NFHdeHo2qHS95TsAaBrs670SNHFgrLLsqHTKZA9SxfM9mWDFPpiQ9Fh0SilCLeE43A7KKspq8saOpyyGt2/KdISiVKKWJuufB0WW8qWLSm0rlcOqNJZSb49n9YxrcmuyObzjM+5Z9Q9PPUU3HijQadOkJioSN/soep+3RXt3PbnolA8t/I5lmQu4bITLqPCWYHNbOOVta/w7HnPEhX2GwQqIlvoukahikqHJcDQVWBNAEs4pJ2nu5uGcOWVesTDmhodBFbKC1kfwLmLdYYOAFZdGD/xFF3Y/IdLoOu9/oXkL+Kocj6s0WCN04HeeV396x57AnS+M+g3N/za7ly1GgYNgtNO0yM6LlsGxdnZsHWqf5k/XAZ44Z5H/IEjgLc/gx0zg9+f2Wm+wJoJrju6wKP43yaZRkIIIYQQQvxSpZt0F6vahlht15V5naHVRdDnWZ1N02sSNDsVaooxD1/JBbdcxHVjB9B88P1MnWZi7lydgWC16oZ/Xh7cdJN/tCkAq2MvxHSl/in8e5s+AGBEp8s4Q93PuQmjAeje61zo+xLMsEMOsAd4AuyGFdDd05Qvs6fI3kh6QYsLofWV4K6G3AX6scPVUwngdsN33+ntiIrSw6ibzRDuydZ1V1S969d/8ewEr+Hljq/uAGDC0gl1BaoBlmUtY8HOBUHTby7YTH4U2BNjdKVskF0AACAASURBVBAyPLVBnZj582HoUP29CbTj0A4AUqNTSY3Sn1eBvQCSz9Qjf626WdeiAYq9oFB19YzCLeEoFCXVR1cMu7i6GIUiwqojVrXLiWy9nR9+AEe9ckCvrX3Nvz7AD/t+wOv1cs89cMFz49kS/jKxSRVMnLkNj+EhITyBGFsM3ZK6YVIm0gvSGfnZyKBljlkw5qjWNUj5Dtj7Duz4N+x8FXK+DK75AxDRElB62lq13/9Ot4M1XgeMIChgtDF/I8uyltXdT0yEl/5lJzJCB1E6pu3XRerjewW/nskMiX31b6FqP2x40P9cTbGuUeZ1BY+kFkq8r6q4p0oXPwdIG9xwOmsM/56VxpeVg4n4bh4VXy7mTXUZxrcDodNtkJqi/53xDpz2hg6IB2pxoa6dVLQSXPWzoEKM7Cb+lCTTSIg/I69bHzQcvpENbEn6hNV85FESjmuuCj0cqLdGDzcb1e7Xv2dVuXBojf+ADGCJ0Z9HZCPVH8VfQ+EK2PGirw9/HLiq9EhFnW+DliP+6LUT/0uqC8Ce6eviYIXwZN194BhG3/mfUJ0PFbt0fQxLpM4SCYv/o9fqj9f8AsierYM5gVkG4ak6MGIAJpP/6vuAj8EcqRuHwJoNUfToocv2BNZ/KS6GTp10oKWOyaIbgabgq/rtCwpoUdGWXe89wLar4KzYUawy/4hFbQAcsAL9DyizQY3XSZQ1ipJxJQx4awArslew6eAmBrcP0ahs3hwKCuB8oAeQDny06ajeGotF12L69FO45hqdxQDgUM0Jt68BwwVE1L03hgFz113KGzvn8JVvGUOH6kylW27RmUpNraiqiHb/akfr2Nak35VeV//nWLg8LhbvXcwFnS7ApBq/Jv+f9f8BoH18ezJLM5mxagYP9H+AWRmzuPKzKwF45cJXuPPUOwG4Yc4NpP8DoAK3CsPsKieo+97sNKq3zyD2pJENagftLdkLQGpUKrG2WCwmCw63A3vciUSZwsBdruvxAKUeUErVjZwWaYmkXJUf9QhqxdXFKKXqurbF2mJRKKzt1zBr1llMmOCftqICZm+bDYAzoEvTd5nf0a9lP74segZGQHGrDznpjMl4d3mJqezD8OEQl9ABU8coKj1Odjl3AVDj63r18ZaPeeuSt0K//xMnwqRJ/vs24OV2cPYkaHOVDsQpk6/7ppeyMj3amdMJkZGKjrHdMO16FXo/q3/jl+frwHDiqTqL0PdZ1GbXFF1aQO/XegOwfcx2uiZ2gvTxjGqzCiY9xWcLu/DQ9UvRn2Xw56mXofR5an1eJ6y8HoZvOnIGXlJ/OPgTQYGbmkNguOu9FuCAwRQwGF9ts35AwtW6m1x+Qd3slZV65MaMDHje99i4RyLonfYZI5ddCZ1uw5R8OkaPh1Hrxh5+/Y6Fuxrclbq2lCUmeP8nfhdNcrailBoKvAiYgTcNw3iq3vPK9/xwoAoYZRjG+qZ4bRGCYegTOq9T7wTN4Q361P+iZdYU6gaR16mvDNmaQWSr4KFcf2v2bJ2a63HoNEhbEsSf6N9h/1k5SyB7ji4kV3uy4qmhSrVnn/dSKmri8Xr1x9iq5i1aeGahej6q+7SDHlazZRsoONhw2ampkJfruyJh+A+MvwX7Pji0Vp/QYqKuv3xUO2jWz79tjTEMKPwJchfqNH6l9Pctso0+qP/SIEzRz7B5IrS/AZIHgDlRB5AMN/rMoZ6KPVC8Vn/PDEOvhyVab0NUQI717jd1ocKz5+tAXu1v7lgagmlp+mS8vtTUw48405Tcdt3gKd/pu1KudOPWHAGtLtZ1Oo7kGLcj8IQMdEOiVavfpkHQKMPQw9fW1gewROl9SmCXiMb2nQVLYcNDMPhbQOkTGcOt90ve33gkl9/Bvn2wcaO+Ohz4djRrptPXY2L+2PVrwFkGJem6dkNdnQ6l0/MTTgoObFQd8NWFqPSl0xu62Kg5AlLOhJhOwcsu3+HbH7h95/YKYrvpAsHOg/pk1hwGtpSGx6LyHfDTSBjwEST01kFqwwuuMpjwKEyuV4dj4j9h9ACozvVth0l/t6La+oqZVqMbACa9L6pdZlMzvPp4767U21tTBOmPQcdRkHquPq9wlfuKw9af14ADc/UxLTxZv69uuz7Otb0Gmp8fPH3pFjj4o++44WOOgOSBkFDvCvzvrKoKsrJ0Q8kwdMZPy5aQnFxv13Dy0/DtAL2NncfA+atgbnv2Z9pJWHg5kV2vRMV0RHmc+itkS/Y3emanEZbekeryhZhMsUGv37UrLF+uu43UdjkiridUZesLFgFX/LOXjudcywRe+Syc8HAwmztxs/MHwh4NWKBvpTftWAbvnEXbuLYA9EzpyYrsFWzM3xg6aFRrke8fQK9eIfftmzbpANFk3/2//11nT336KcyZA+eeqwNj6T9fwVsX3w+Vmbph6nPvuzMwOt7Gp5+Ct73O5pgzx3d9LNRXPdSx5xiOn99nfs/g9/Q2bz+0naipUWSNzaJlbMvDz+h16f2H73zq6s+vZs72OYzpO4aZw2fy44+wdKnO/omM1OtfXg6TvfcDkFmaCcA/l/yTuPA4Rs8bXbfou+bfRV5FHn2a9yG9IJ3UqFQK7AU8veG/PGwO0zWqks+q+w717fgzK366hNtuswXtm3MrcjErM2nRaSiliLPFUeooJZM4ehrB9WfKDYVJmeoyhKLColB2nWlkGMYRq0wdqjoEUBd0irXFYlImjE7zObDg70yfDmPH6q/gli06yARwS+9bSM9PZ13eOjJLMnlh5QsAJIQnsCJnBduyDtHyozzefyuBPuPA7bbyjDOHZ1c/yUvrn+P6E69nxrAZ9H2jL3tK9uBKScJWFCLQlZoKVfkQ6Suovu192PKE7upXa3YaP2zoyrPL/sONYxI47TRISICSEnClXYVt91PQ9R4d8K8tUF20EloM1+dOvgCM2+vl5FdPrltsz5d7UnLp40Tbs1GDv+bmIRHc/A8TuK+G2ffqwtkN9nWGXmbgfjE8VZ+LVu6Bz4/cZZCWI2DnTN9+3OfAPDD+rffxgV4Grgs45/loEyy7Qh93DA9kPAtbJ3PGuE08+/oJXHedBe8H+vc5fjxMmXI+yzZuYvwVL5OU+xI1phaEexLIKe/Cktd0jSqPRweR734yDVvJUZwvepyw6RF9ft1iGEQ01+fZxet1m+AoL1i43fqcprhYr4PVqvfjqanH1jx2u3XXQqX0vqixAu9/Vb86aKSUMgP/Bs5DJ76uUUrNNQwjsHT8MKCz799pwCu+v389HocvrdGrAythCQ0bkIahf/Bl23TjwkB/A81ReqfxSxvGJZtg8xPQ5kp9kmyJBHc1xvPvo56c2mDysvsmEPvCxOAfTKiDbydgeje4YI1ebiBnid7GWl6X3oF6nXqHZOA/ycakty88+di3reqAHpmg3yu+wpK+A7Wz2Fd4LfhEvbBQj05Qe6IH+sednAzdu9c78Qi1zR2Au3rCZQ9AdDtdBM9t143q8m2Udf4/XNZmJEUl6RPePW9DXDeIbK2DBp5qOPlaKApRMNJkAm/AztoEvAlctQfCm9elm34+28q/X4vg+8ABTbwe+PhWuOIQ2AIOGGEJhCwceSNw94064EdAyy8sTp/017MqexUPf/cwmaWZXNXjKh7s/yApUSl4DS8ZBzOID4+nVVwryJmnG1HJA6lroJVvhx0z4OLgYYIpXKFHkCnbAhEt9O/BWa5Tbr0eOOF+/7psHK8PEr2n+Ud6UCbdmA/Vl9zj1NlWbrv/AJ79JZitOp3YGqc3e8tUaH0JtLtWTxN4JWfgZ3obapefPUdf+Rzwkf5ued1gCsP9+GQsU64MevncbmlEPdGV2KI1ENsZMp5FZUyF2VaYFZw2fJBk3h3xOd3vPEvHdT36OzmkBhp+EuByg3LXu8J8GFWuKqYsm0Kv1F6M7DESVfgjZP0XYntAXFe9P6rO0xlqkW2g21h/8HDJBfp+r0n6vVQm/ftt3RkK/hn8QknAxW1h3EO+xqpJf2c9DStdfs/ZfNH+aS5a7E+br6iAyy/XBV1POCF4eiM1DQ7+8pP/Rrkq9LZ7avzByNWjddHVttf6TzwcBbD6LohqoTPFrLH6hCl5QMMaBYdW69Rvc5hu4AZesbsbCMxujwXuaAY3j4cEPTQynhoo26qX0+VuXb8A9OPZX4DXAaiAoIYX8OgGe1SbX/d+1OP16iBeVZW+nZurr+yXhDjvNtLSUPX3l92SYMEM8PqGXjF8/9ma6ZGbAk/sqvP1drur8B8glH5PEk4MPp40xlmiT7JdlYAHMMHSYXD5wYbHF8PA5VZUl1MXeI9d2Al14Rbd4DYMvR7KBA+PhWm3BM//CHDTG9B5tK8AsKGP8Wv/D5qfB2lDfJ+nU9eLcVfrTTKH6+2qzNTBlag2+vfitsPWp2DrZDj9JNjxCnS9S79WxvOwfTqkjNe/V69TL2P9A/oCTa9JevmGR38fGwvURkWCvd7v8dkRMLirznoJT9HLqMzSx4a2V+vvO+jtWH4NpJwNrUb4umAYentbDIV2f/PvN8IS9ONxPfSw7Mqs38+sD/V++Yx3fPtPq96Wyc/BExcEr9c5wOMXwdlzfedO+jtRWhXHunU0GAY6LsZN7x5FJEZX+n7LJujcHw4WNnwfUlMge4/OAvW6fceSSN9xod6Fk9pAnqt2uXDVDamcMTCcBx6oN+mEiagnJtFAXCR0fwX6vgIRsDH8JK56fxVbt4VTVXYQmyrDc84GLJmvYNn9BiqpX10dk9M6rSY3x8Xq1XDGGRDuOyhcfz2MGQP33quPF2FhYHfYiGp5sR52fdAX+vzk4r0snfATV/5fOJGR/oZQWCPXaTbk62G4uybpYE3P5J4A/LT/Jx4444GGMxxljaE5c/SocHPngvcN3aB87DGImz4R9e0kikkgZ0ErPJi5lgMwbiLG90NRXcfC2QugeB2v33gjWe/adA2nAv26EcCuQ7uY9u00NuRvwGa2cVX3qxjTb0zo46dhoaxIjwZV+7u3WiFp5kSsU/2fXUk4DB4fPK/b66bV9FYYE+pto9elz7E91Tq4HJ6mHyvbwl0ZPzNn+xysJiv/XvNvnPkd+PKfD1BQoI/1Sum3bGPBOh5/w05MWAzjB47nhZUvcKj6UF3AaMbQGURaIxk9bzRPLHuCSF93x9ouXI98/yjjRjyAed19MGSZ77PfwzUHujHpoSfZsUMfV6OioLTcRamjFLMykxqtP4ukyCRKHaVkVeTRs+21kPl+3cUOu7Jiwls3clptbaACewGn/+d0vvT1GtyW+T3ntD+nwXteGwSqDTrF2GIwKRPV8evp2RMeeQTWr9eH9DffqcEzTmcJzRw2k4+2fMStc29lzvY5fL3na/3Z+DKcHnzlW87peAWnnKSI8q1DPLHkVWcR4YZ77v2AhAMf8FAfGHMhuMtLGl4K7AeM7wwVOyA1GVD6/LXDLXiW/w1aXwHR7TB5XTw55zFufKgjV13l/7qnpQGOW2DnJPjmdOh8N1Tn6Cf3vOmrOZSs95eOAsYdggMVB/zfKcPNhk0vceYp4/T5gjIFnzOsvw8GzdOf5yX74RPfFnS8DbY/r/ef5gid3ZTxtO97WC+YFErSGbobIr6gkTkCmg/X7am+r8BlufoYNc93oSR7Tt2s9vy9fJL+FEOKrqV11xYYkW1Qne4kNa6Affu6YjYblO/Qv8+v5hmkpyvmzWtLeLi+EBKJ3m9ZrfDEE/r77/Xq/Zh3YujVraqG3N06uxKAQ6vgwFcwYpt/otr37ec72Th4HU8vf5onz3mSTom+mQyvzqbyHT+f+lciGdvDee896OiLsbvd8OSTEBenH4uL8/0+N+p91/DhOiYeHq7Pg0aP1nXlBg0KPie326n7Th4PmiLTqB+w2zCMvQBKqY+BS4DAoNElwHuGYRjAKqVUvFKquWEYecf6Ytt2r6HAXoIJBcrAbDKTpNy4KvYQHtcCk9mKYXh1X9xDP+KOSMQarU+wlVKYMLMm+yfW2u3YMRNni6N/y1Ppm/kcYV3vwdysLyjdu9tVvAnzI/dh+SAraB0GT4zmeyr1uY2hsyleaJvG/Z0HwJmfQYT/EGZMmIB64omg+b1XgenBO6Dfq8GPPz4R05PDgh5zdLcS/lxPGBacmFW1dBThzbqgOt1Mbb/28u1zweMipu1I/f5sepzKzZPp/FIun/80hQEDqBuytCg9iw/7jWfMiwqz77hot4LT24z6p+z7XK2JKYsmoSpHn7hunYrKmEaFFzyzLMR/EVDVvyUwIw0uz8Ph0FkElm1TqNn+KBH3Qnh5wIIj0OHE2eDESg02zHgw9alGtW+Dbdb+4OW+1Bwj6XTwulDuStj6FM6Mp/HOSyL8E38//GxacUJUNpX1Rgr9ea2T3DuepPeayUGPuyIisAJeFDXYMOElrL8TNfgC6HiznmjTRNgyifg9UOYF3G+A2wbK4LFUO0+cdovu9xswbU21tcGBqyQGcHuJrwYnYdRgI9yopjwvnsSitag2l+qT+a1T6HfwPbZ2f4J33r2ZiHATFgvYXQ5OdI+n17p/YDr5SYhIg80TWfPFAq5L2s7aHTHEd9VXx+z795D99mV0S2zvP6Bsmog7/Un2VyXQ4qIvCItuAUphd1Vx0Ucj+KEoq25dn13xLM/+MAOsOmvCpiBMgceA91JSOb/faGKanweAkT6B8k1PELvahmr2CLQ7Szcodr8GmW/B6e/6r+bMTqOsuJrEO8ooLYWYgFiQp2wLNL8Ys2HohticFuAowP05WPzHMgAqL40kevzf4LTX/Q/WHMK+aQLmqysJ9/Uvd258jJqDK4lesBl1aRa0PydgFAkD2lzhn392Glv3xNGiYxvii36G2C6Q8QwqYxrWZ+yUVIwjPjoC0tJwK4OP797Ndx+5mXeJgak6D9qOxL7zVaZa78M2eTwXXWimd2+9gZ+8nMEHryaRfmHwdrSMzOWjL02cdRb+IYUPZGEaOxKzNTgQuJp+2Hq15eRNn/nfMwW3jO3Fe/H+rgLXzLqGqu7JhA/+CtWsX9224SiAWcBsAH/DIOvqNrS+bymmtCE6eL1lEmrrVJx2C/XbHO7bwDL6iaDPs7q8jEvbvc9tr1/ElZf7939f3jqNGks/hgzxz++oNvhb/3f58stRdO2qD8CGAaXVFfSrqSCu3uuVOMpJqHcpyGGBrWd04ZQfdwY9fnLrrTz8XHdGBpQ58O5+C1PO57pBEqDUUUK8ORIvFj3M7OYpROx+FNXldtSJjwe9Z5NyY3mm2kGV14lCYWDQy9KLzxMtdIh8HlOnW8B3JfbN72/lGtcXRHPI/571NGEZ2htOeFCf0Pi+19O/vZOum2IZvv7UummruocT+UwnuHCzf2Vnp7F0cxtM85M5a80t/mx2L2zp1ZuemzYEbVvNULA17w5vBxyGFXjObY55cfBhd1z0ZKpGPcJLL+krqgAtEgqYdsUUnn9uOonNzMTE6JO9776DaSUQdH0zHphYBe19AVlfdlaNu4bdhZspzVmNMrwoFLFhEfT48Wx9NTNA1n43O0c+zPnLBgU9vrdXXzpsWhP0mDEI1KQR+gQ7wNDnZ/FR17dIiE8CcxTurE9ZvLiAsfPmk7EhhthY/TusdFYy6btXGJM4k+ROvSGiBUbme3j3vE/lWQOInuzG3ELvQ6uy92L9bjAWs80XcjcwtkyDjKdQaedClzE68G0yw+w0XPZCrBf8ACkD/Y1qpeDLMBgbA+1iID4WalyUXRmGuf+jRLe7ElInYtQcpHjVOKIi07DVlOp9u/LC1qlU734LW8ebUY5ClC0RtflJ2DIJd5W54UncZcD46/XIXbX7kx3fw+KzoM+8oOy5alc1WWNHccIr/fzzRwNv2DDO/BylTDq4t2UK5C/CKMvQwfi0c2D7i6htT+M1wDQiA0/0CVRXg9oyhYjdL6I6XK/fM5MVtk6DLZOYsGUKMc96Oe88OOlkfd7y831f0cs+DZt9v76KvGkiKmMqiX/zkJ1jomVAskfl7m+J3jUOWgSfD/nyroJ1AP4V6ysG6w/43nJnFnERCUyfHvCdKtuOWnwWxuUHcXgScLn0tZ0BZxpk/pzPxnVJ2CJMmEyKGodB6l2PY7t/IvEJ+n0sKzVwepyE9WpF3MoqWKlPD71WO66UEg4WJREbnUKVN4Uadw3W9veQ+NMAWPeADgRevBvLpzG8MXo0I0fO4fHHdeHokhJ4/78u+pxq0L+/lfvvV/ToAZ9/bjBt8jSsi/ph+7oftL8Bp+Mg9128nkdmDmTYsEji4vRv1moFrHYsJgs2iz4jcZl0rRWA3mkng8dB1/hWKBS7inf5stUDGqTuKl9D178f9nrBtPlxHYRrdVHd4zm78khJSsZqteDOzicsDKJc4Hh0HMajD5FojSTRt5xvvy9nzPVeNn3ZlfDtk2DrFLzhqVx+egwv//tyHn4kDKdTv+zuTBenfNEF0OchNgWP5a7mwXEOxlyZz8yZgEWBBXIyKujSM5qqpOCvxNx1P3Nf3FwyJ4IxGTDDxc+P4JFtVQydu4SBB8AIgy87gh2Fa/FgrD8FXLXrBLzQCS7a5f8dzU5jRUkBr/riBy7fRb83Msdz6ZBrmTAhjeHDFcnJ4PEY3PPpGwBc2fpeRsQ9TFEHK9O3PsSMtd246dvtxE66F8LgGgssbANXXV1FQngCL14wnZdWPMOawgxed7bkDmclan4PVNtrwFNFi8Qc/n7pwwwd9gI3j1IMGACzFxWTHA3hTheJ0clggbOGQVYviLn6Rlj6E8a+j1EeN25lpcZdQ5g5zJ8pFBaL1/By9/y7qXBW0PwfvvfhvcEsvOYLhna5OOg7UVxdjGEYxNnisduBGp1pVOms5PkZlQwbEs2sWYDyEtZtKV7DS8uY5kQYTk5K7IhCsSRzCQB3nHIH9582luEfnMfeNnNZ//FL7N4dRocO+q03DLi45jPefD6NuOoCMMHtW+D29eCIT+Wqi/P57HP/79P0wwCM7rcRm3IW5OXDnBaUzm7PK2XwcDEkmj4kzgQuYOzDGXw7L5WszO70O81EZCTsPVDO30bGY+05EbZMgm3PAODwwgFHDa0XnIKl4yhMJz+Fc/nNvOCrKZ8xehdx1ghOeLM7D+YUsiz6TcJaXYoKTw4OvJbvgEX9dX0kTw1eAyq8ENvhFtSOf+n9VG22V9exult8te83GtESLssJ/rLXHpeUSbdjdrwEeNnuuYu7nhzPR2OfIHXRQAxlodrjRHmAwd8Q2fJ8SE3Fi8HbPwzhq3VubnrkEn3K4S6n2mviy6kD+MnxAs89dz5eL3i9Blm5leQciPa1+xQ2mw7MfPutwcyZYDarukD490vcjG65k+3FEVhb6sx9R04WuV+PI3nuj3TqXHu0hfJIiHnqTEzLr8Voc7W+8Ox1sc8Fp+z3UrxLd//7eMvHnBjXgg0tqjFfuDHowlpiMy+OaoPCQp2taTLpkeGmTVN1me61PvhAZ0L+4x/+a/teL5xSsYQDmQMoOTGsLo95z+4qXnylmJtvSCHCZsYwDKo8Fey/8Vlu3f+U7nsVpjekzGviupFD+K7jKrxmBx6vmzPTzmVU53uZsXUaG4p1v+GUqBReOH86kSqO/2x8gzx7LhaThSHthnFZ++Gsy1vJttIM3F43KVFJDG45iKoS2OPYSzVuzCYLLaJakOpNYn9xHtZIsFjNmFAkRyTRKaEN4eE24psfXT26+pTxK0ckUEpdCQw1DGO07/4NwGmGYdwTMM1XwFOGYfzku/8dMM4wjLUhlnc7cDtAmzZtTtm3b1/Q8xPVRCYSfIXni38M4tKbhkIP3+UCX6MdCD453TSRnvdGc86JD/LSS/6HnTVebOGmBhdOpk+/g/Ldf2PAZWfh2bkbAwNnnJdLb2pHbo6t7nwM4J1Xp3F+mwWk9H8VkzUGtX06ase/6JwFfRNa0j6uNf+8ex0ADz/Zlqvikzm1322EJXTBtPcd1N43eSA/jPwWQ7i2952cP/AmatwO7h53HlO77qD52Z9hsiWhtj+HafsL/FQNA4d8Am1H1m3bO/Pf4mZnNhHmMC5v3ZuMsjw2lOznxrUT6dTn75w1OJq4OL2PX755MWP26AZ/6woTZWEG5TaDeHtzSqPymHDmk/R8+Dkmn1pJumoPSbvpldSbqYPuZ2/JXu5dMpHplYOISnuF6BYncOld+s14bWI+b83YxIuv96BDJxO2cJ3RP/q2V5i7ajzWUn/mzSFTIhf0fYub/jacgQMsxMXp7IrRn/Vh7d6W9Ejox6LXnkOhuPi2aWzJXcqsu1M4p0VPvAZsLczgxdUv8db+tsQ4erDnfX1w73vzSJJKHVzQ5Q6aN+tAmDUMlMGcHz/mvp7FXDAiDgw9yoHX5GTqw3s42HwK5w720qo1eDyKf7z1McuaX8cZFRZGmFL5MczO18pO2r/X8f6nJwY1gsf9Zx6zCy6mb0w8XRLaYjPbuMe7ntjd/mBa3rP6b/8721G2/EXuv/h8zj7TRky0QXmF4oZbK3hvxnbO6rwVZryAWxksP2kvZ++vJt5j4l5POzZE5jPPXYXljTXMebEtI075DsbfDQoW9WnHBVXBDUcAZr/L1Kuv459jD/iycbzkfjGclvuyG0w6oWIAZw5tz5nn/Icwcxh5P/+dVatfpV9iCi0unAsxnX1TKpqNP5uS6FVEuKCZAw5Eg6Eg65kwcqpOZV+zPngTmqFcTp5KLWfX0Fd5zN6MU+LasDB6PTMOWVFfvc5L913AbX/vRVjxQZyJKZx/9ZPcHHOQGy/bh4rpAFunYbgq+HjlNexKepdmRglxyWF4PQaLdz3Pef0/5/Tuo4i2xhJT8DXR+V+h9MUr2rosmE1m9pprIGsAtFvOS/PhnjWwoBNceJ1i8AeTOf/yUZx8TjKJSWYMw8uMhQv5r7qYWBM0N4NVwZJWkKJLA3BJs3EkhbXi7bz78aI/44E7UhmbPpJ1rXN4z+9V+AAAIABJREFU6ow5dPniI7595DvadIiByA6AorxwNXFL3kd5bOS94MIAmo+Jg40381CvIdw4YCdJCS6UCbZklXDu3ql1v89Kq5eScBhvbs6KpDhGnHgL91wyBafHSd9b2rIrdjsKRf/W/Sl1lLK1cCunhcNjrdszsPvfiEw8Ccvq28g8kMCJX/yDxe+fzOl9LwMM/p+98w6Polr/+Gd2N72ShCSEkgQINfQoofciXZAiShGwISqiiHBVglwUkQsIIkpRRFFRQOlIbwLSq3QIPYGQENJ3s3t+f5ytKYii3vvD83mefXZ39kw/Mzvznff9viu2zmHexGpUCQzi/dd2wsih4KaHjqn0vHyHwdH1afP0UTRNx62Noxi1fSHead48Wr0JtTzCCLrzLtk5Ar/LWfa+Hp4FyT7Q4y2YXakmvtU+I6JRO8jP5do7JXjFdIVWFdozaNBWPNNyyA808PJTcTxU/RQda/QnJCQeDN4Y827y9uoh9K8zhIjweAL0IYCFicvXUq7kehrVeI5yliAweJDilkP4gFzGPtqfAY/7Ui6uDAKYM/MrdnySwuMDmuLm54nAjKbL49F544l3e4MhPSOJsXbtjatSCEmdyuBBerSAarJEtek2bc6UYANpLsdyqadiIOQMVd2hoSf46yDTAtt+HkRgnJlvn0sgNLY+y8vlMrlnfULz1/NYmVjqloojNuk7DJZsei59kQ+fyCGiZgPwrQianqsX0uj6ZAX2bbngKF+7+ynGrO3I6CcD8avxhExt0fTk3E5j0KJ69K7QnE4eddC8/bnkk8/s5dsQ194ntFoDyoZkY3DTSEtPZ3ByKQCCcjXMGqR7CAZl1qG6NolKTVtjNILIScbdeJ7s/Ka0azwV35A4dAYvOP0xCQsvMt39Nt8/P556LZ/gcJCJt4dVpfWhIEYMrIZPWBM09yA4N5ep310hcHE8g664ivStqm9g5aLLeHkb5AXtpSVM33iCnHKp1K86kEadPwLg0JoRtG31Ase3HSUi+DbUk0/i1858CU/LV8TFvY1nQCV0579Ad262/bjvfPsxShkime/9EUEWA0mGeyhNDJTI9yLNkENprwA+bTSUQ+dX8ub5o2D0ZvD6R6hUojv68pURmo48TvJrxb48XT6e6mWa4u4ZjN/xd2h3zI8XY4OIr/QYPgGVcb+ylEv7D9Jp5gFW/hRAhUbWi4akJCqNepQz3j+ypNFTdC/3EC+tfZkZ1z0xeGbwkCfE+QUS4hVMrsXIsoUv0Cb2VaaNP+Pwo9jeA+14KhF6OPI+BGdCqh881q8BB8L38WWHD2hcJp7Nv4zlqUM/8YQ/vFitI9FRnTF4l0ZL/IpXPzPQrmoVHulWEhqOkhcHez4m5NMX6GCuTteqtairD0RYBHMO/8IUn20sXmOiczYcCoFH2kCleQnENR/KI08GU7q0hhCCD5fuJM+nCa9ExRJTri0Gd38MJyYR/s0TtOxQkvmD3sKzTBTfVMzhgzbdOa7Np64HVPXyxs/dh3d8b9Ju8yM0CBhJpQo1CPSTdxunzl7AeHof704OgjoDZWTbjDx8NzSj7I0x9G5Un1oVvNB0sPfALdb8kMfn35YjOlqTwXpAvQEjebjEW0yZ6EvJGlKR+nnxefoNtLBzu6+LSNVrRjDfp6YybhM0uAIf1of1leV9QP+HhjLjqe+xIGg3qSb7r+8nPS+dr+t24vGn9zKi4R2m1soBAeE3g3hy7/foI/z5sEYr8snh5vMnCEz6BPZMAQ8BnnrwCObnsCTGttjGL6Y6eGl5RL8xlT2G92H/M7BjFOQEQ/kNGJ7oSRnfUlyo3xyu/EiN89mcN5pZZYhnypqPyfephqe3gZu3UtnXNhJvNy+uv3od99LlqN3zFvml8nkvpBJtGr6AZ0RjhM6TLYlbWb9tKB7VXmN0iwm4ly5HTn4uT/4rl35JvZi6ewHL94aj08GIx5OY0akBH+39lM+W1uTn87Jvd6m8mUGdt7P5dGeiq4TiH6CRlSkYa5U3K5SowC9vXcJkNlFqSCSUuEij0A4s6b6KoykHabckDku+Hg71o8HtGcREe2MSRm5c28dnj42hTPthaEE1ZPSxxUS1IbOZWus2bRuloAXVA5075rRf2bThKL5NVhHXMxYE/PLp1wxbN50RD62hZ/XeeIU1B50HlttH0GWeQwtrDiUbSkNjkU/UmLfIDf+OKp7u/Dg+Hw0YPCGQkPxUXqrSjvJRnTB4l0b/y1MMv5rO9HT4usfXPB77OPMOzHNJNcPoBSYf0MxwrjVxHv3Y/kUbPMtEYdQJ1m+eR4OsXQSZbkF4K5nOL/KZsnsqbx1extb4rsSl/oQlP4ukfAulLwgCdTA+GJ70g3xgSpoU9AeGT2P3tJdJNO4nt9/DpEzVE1zTBN0N2BWXs+exDLzKB/PCSNs9jdEdxzJhzZssavIRQgjOvnQW99LleKN+Bssb5HEiz0zzyOYMCPmYieP8OVV5MJE1d5P42k0Z8dJMnuMn/bsnbySvYHTTN5jQZixZxiwqf1SZ5KxkdOj4vukZXuxfjhvV38ZSfzw6DZ6q9zwfd/yYHFMOlT+qTFbmZVqm6Zm7z0zAUyDcYPM1iO6azuTp/iQdvUS9GmdIyq3Aik1RdOuQxtR+I+H0PNAg17sGj014l5XfXoJG1ijpXf+h1uzFHPH5iW/jutK7QksmbRrJqJtG+/5pt70tWZn+7ChvpGaNFRwhm1d/hqF7NKbW1/iooYUXaw1herc58JgftM2EPB0f1xjJC1vfJ94TNiWBPhjyysHcXY/zxJMlCa3YDTzDyTRmMmX3NL479jULoiOpHVoJs84T/bU1mA0hzDx/mIhbb9Ox+reYhZ5vMjN5LtXI83HP83HFapgOvcHgq1l8+Hwqq5aU4IfPDjGth6x6N3zJDyz+wRPtwCvQYwOgg0UPQ9MfZUZCfjZ8EAAegrcjpzL+2Eu8/NBrTGszlpsphyn3WWvcLHkY0XG+1xwiQqozYsVgpp49C2651DD3440qCzD4pdH/YBl8tRxuCzjUbTqxpeszatUQJl04AtfqUvLoO3Su1p6gIEjPyuWAXw2O7xpOt5je1IsNxNNdx6krR/nIox4+uhK8WW4jd8zJvHf5EUqkR5IWcBFvgwfht0xc9LNgzgmm4bfLeX1KHNVr6vDzyiZfuPGvpe35In0bwfpIynnU4kLeXkyW6/wQYaBRqy/xLCmTmbSTHzJp94e8cQvandLT8WgAK6vlsq5aNmnl3EmsfI4bmWUwm0F3fRXHLo1h9NH69Cj3HDVKVyBfGEm6c4vxq6oS3K4yNGkFAeEgBO9tPMQYCjzNBnZ7V6R+7/ehXHf7sNXrF9FxZ597uhYJzQ7mhvetwj+Y3UDvmsGgs4ClCLcR3QdJbF0bRuPG9zRLNE3bL4SI+812f4Jo1BNoV0A0elgI8aJTm1XAewVEo9eFEPvvNu24uDixb18hXakQ+fnSd8FsdijQmgbJb85AW70SnZd8uqIBF42hXOj7JpValUFDKrcWi8amf22mZj0DweUDEEJD0wTfbArDGFKazz93zMtkkiVQW7eGGjVs6wc/ndjOyBNNCy2biKGQcPXuhDzO+rzHZ5+5tq02tRQn7hROw6iXY2C/V749kr/UHdi+vwYVth51aWfWoPPbFVmjOdKDdJoOizVvNSaoIkGeJfjlmnxyOzSsFB8nO546+7j5MLPdFAZaqzrYqKgHfSacKmDVEDX5EB98XovHnDJ29u6Fvn3hzBnXtrdX9iCwQgP5pN26HbYv3sizi7fzq/VhuO2JUseOgief1OjvlGack2fCe2IRcdZLFjLxib6MGuU0LDcFfigFjzsdXDYh8aFZstSkEHB0HGc2LKT+v8+QmupqX3Ii+Txxc2uR7ZQHrJndqb4ylXfH+dC+veMhQWoq7NghU9/iH5UXTju+u0ZDQ09EaCO8SrcHvTcaglFv+mHUgpk61TVyQhsnv3uZwN0M6VZFvrEoyw7NVeD5sP2H6DQdg+sMxsvdm5/Lwg+zX6Gtl5GcpM3UKdMET48AhMVEoF5jWXoOX1y/wIKhG3HTu5Fy7ii3c2/z9IqnOZx0GICBtQfSWTeTSxc8qFwZmvUORwB7v9pKY3NntNabZJSZdVveOTyOapfduWpyyPTt/IdzYtoUDh4EXz/Iy5WK/hf7vueFLb0L7bpLaU9T9sM5LsO+oTdftPuW5cvBrZzclqe2JNG4sXwy4MyplFN0nNGQc7pU+7Cyt+HfAd0YoP3o0nZqmxm8sv5F1wmYPGFCDllZjlLGIM8Jnx1YwMgNr/DreCkUTFryCp1iOtHqy1YukxhUexDfHvuW7HzHU1k3IKeyB/ou52VajsG7cOlRpxB/sak9IuIRtJjn0CxGQJD7YwzPX85lfoYjNM9N50bniHiWXtnuuh65/ow8P4bGT4yi3QC53zYtTOKrrwQBARqzZjmapqaZCZ5efIDpw1egRjJsiobSEbC9elXo9KvLU9Xu731M66e6M3So04jCQurBseSnHSKkfG/pv2Ixod3agxbznNwORaU1OD2lFNt6QmgjmaYArqHbBc6heQffxaN8VxnZaR3GsXGwJhK+cn3QsJgefNRsMVu2OIbl5cmwY6NRRjrZFmPvxeM8PD+20HaZvNmdV7caCw3/fGwXBmnL7d9rh9WmvE8AS89vLdR2X6QHa8u/xdAu76ChY+Our+h+8iW0Zitlao/zepRsBm22IKxPJrSkJNjSEUp3lucva1txdBxaYHXoeMxl+8R3b8/o/8TTtatj1wkh+PboIvr+8LjLcq3vu5X4z5bjO/E/LsOvjx1Bn8h9LHpxG+FZkOrvxo9rxzN4XYFcjmIwnGlP3Lk1bNrk5MUC3L4tSBOJHEw6yCNNBuGmM6DbPQ1d4gJouc51OwD0MTp8c5aGk5edzGepHswyVGPDqMOgwdgvX6Jj5dZ0XuRqPt43ti+9q/fm6RVPcyNb+r31r9mfSW0m0farthxJltF5OnR80e0Lpu+Zzt5rrpFNEfNy+OYrD5o21eypUh4ecCL1EM+ueoblr+wFDd5aOIRp7aex9MRSZu2bxbJX9uCmc2PV8g08ubkxvgZ//tP2P1zPvE7CtuJLbJ8cepLZB2Yzutd0AOasfIc442ts2eRGq1bQ6DHZJ/Z+u49G6TXQupyRPlxW5s8sx1MphR8KTG01k1kHP2Tr6NOEZ8FNPz153/ekTFgU1H7Pvt1Tdn1EmZdT7JWO8q3PPtad3kLH7wukpOQEoE26bX8ia7ZmCGcaM3hh5XAW/uq4yKkeVJu0nEtcy0mlIOvKePCRdzvmPrsSDY3FGz/i2dPD0LqcdPhL2frEMDdIc71w9iabXy94ERXlGHbkiCxvvXu3rFjkzOFHE6j1o+Ph41kq8HjMfuYtDnCkRQA/nVxF9xWufcoXacxZsB5QPXfYX/gUQbBXMLdybjGh5QSSM5OZvmc6D0c8zC9P/yIb/MZ50ZJzk6Pru1EhOAafiLYIgy+mjET8l7yG0Wwk6dUkfN198X3Pl8/DYEDjCWhVXpHeWtZzaPWL8KsRvnz0SyqUqEDDzxoyK8zAc/Ejofa73Ew2c2HDPCrnjKT89UxSLQXW7kRXml79llVr5IWJp6e85h46VKZ1TJrk8KbzPj8BN+MlqP+pdUckwLFxXPKvT9T+PegRxHrIh/DNa73Apwe/INPkGhY+pM4Q5h6c6zKsk78nK6pUdUTdHxkr/WhAmopHdHRElC0JgyEpcLvAekwA+q+UkXJO/8sWn0ocLneKI0fAaMxHn7SOliUGE9VyBFQbaR/95ufVqfbKDvYeKuHS18i8wM3TBzhzLZq0Z2diNugxPJ5EaJn93ChXmSqlHsLLIxiEhRIGPZ6aRRqnV6wDPsChg7CxGfR0ysV0/v/zKgNVXoGQeNjUhu2ZQczx68iF22f5ceR2dOgYNe955hyfSuvyrVnfbz0f7v6Q4T8N54tKsfQP8oEmS2T0Nhosj+aZT6aw9VI//v1vmQ65ezcu1/L2PpifB2kHSc/0oGyNGmRk6vF2z+LObRP6Qy/Dpe+lyGXw5sTRLJ5dtIZps6Oo3V6ep1J/TaLeFxW4knWRn55cS+vyrWmzoA0bL2xgfvsP6B/7OJS3ev+sfkJG0GjuDrN3kFFuJ16HD8fBWORBqEfaOrxRVdot1BoP3mUQq+rwTZ4/ldquIi5C3gNvXhDEzvQ03kyV11FxEXHsurILgH9vXcRPmZ15M8FATBU9JqPgqx8vMj6vQHUwoFNMJ2JDY3mvjbTtfbs5HHvuURZ2X4iXmxeXtHKkEELU1dUEbY+G3tZ0bYsZjo7j1pHxhJ+H/ALT7XwsldCAEnz4obzH1DS4mZ1MzOxwCjIk7xiHN1Rn6VLsQQB3ki4TcbQBNF4EgbVktsKKSvLH7q5ppbP3fcpzK5+jZXRLNvTfwP5r+2kwrwFmq73D2ifW0qZCG+Jmx7H/+n40NMoFlCNxeCLbL26n2fxmeBm8yM7P5v3W7/N6o9eJmhbFxfSLVA2pyomUEy7L+2Hb/7D6zGp+urDR/sBt2gQ4kAfrc1zXbXLryczYO4OL6Y5ruCa+A9ietohmFRrw75bvkJufy+sbXufyrHcZ90x71+tQwPz2W+jHuz6ouuoPFUboycNsH2YATkfCiYaraBzfE/+0bHKDAzl3dCP15saT51SVLlgHKRUNrveU1uPznBEWRo/j2I1jlPYrTa/qvYg/NQatwmCZ9o2Ao+NlOvrqsrDQ9b/56qulKD14hMu9McfGYTkbgK7qy2DwAOMGMG/GvC4O/ReFNRHRtBnatsLXnIwdK83f74G/UzRqACQIIdpZv48GEEK859TmU2CLEOIb6/dTQPPfSk+7V9Hor8ZikX+ItlxMd3eX//S7Y0yDrCtWfxYLoGG26DifVptbaQZMTn2wfn1Ab+Sbo99wI+sGz9R7hgDPgskav83OyztpNr8Zvav3ZsGjCzhx8wQ1ZtVA4NjXrzV4jffbvE9GXgZvbHiDDjEd6FxZhhin56ZT/ePqXM24ypJeS+heVaql3x//nl6Le+Gh9+DCyxco5VeK1FSZ6m4yyWsevR6qVIFLl2SpWLNZCgcBAVJk08w51qfn0kPmxBlfdu3W7GarOp0UYSpUcHwHOe32HfJ5Y8twZu6dCcB7rd6jhdvrbN6sIzQU/P3l/HNzoWunXLzFJeklYfMwyUuD9KNWPwh/QI8w5zJ/x9McOOxJbCxERMhlPnNGioP7bm1kyPIhjG02lgG1B6BZd7wQ8mJa0+Q8tXEJrlUZdMB8L+i0y+EDdSSBmztnMmX7x+iiehIbK81/MzKgbrMr1Pq8Akaz46rz046f8kzcMyz+dTE9v+9JdGA0x4ce56EJkRzXXP0bBvnD3Dqd0JqvkJ4Xy6MdFxz2dCQnijuZFKwuYWv79ltgvOUwQXfzB4M3v1z5hbkH5jKh1QTSr4XSvj1s3iwLrZhMctvo9aDTW5h3YB6f7PuESW0m0ap8q8LzLohtW1sEy5fLSg0+PlLgsVjkdnv2WbkNLRYLOp1DbjdbzIzZNIb03HQ+bP8hHgYPlp9aTtdvu9rb/KfNfxgWN4KjR2UftvkO6PXQpo01rL/ABX3i7USiP4wGYFnvZXSp0oUdl3bQ5PMm9um+GPcC03W7IXaMNEc058KKypB3o+h9scADuh6WPkMGL8fNkd4H0SuDbRe3ERMUQ4S/w+vs5M2THLlxhA4xHaT/QBH7bQKjOT9wPJ/M1rnYtlxMtHDCspr3drxHiFcI41qMw2Qx0ejT+uQ7pQqWT4eDGd74D3sFStQG92DY3oMrSd7sSOyKiJuJTic3TZDYQxvvx9G6nnNMoFA6nBM+PjIZ3JlwYHAZ6PO8NLffPUCePwE6nrBWCpTnUHQGWY4276bV0NwsVy6gCkV6XyHP4ZmZDi+pdetg/Xp5wVy+vGxz9qygRKPFDFs9zC4yDKw1kJkdZ9orwhSFOSwUnaaT4g6w4dwG2nwlIzl7V+/N3C5z8X13cuFjqyww7hF4qJFMR0Ivj7OvU+DfEynE+FdgSEcnzzgNLNaKbZrB6p8nSLzoztIDfckX7vj7y/NoTg4MHgw+PoKNFzbi6+5LfJn4YtfJjvOfnRBcvXOVXt/3YueVndQNr8vS3kuJDIzkTt4dvjn6DXnmPJ6s+SRBXsWYdBZ1jgF5nnlzlJM/mQ6urYKcq1Kwdg+CXf2l0XUx57TLrwym3DQZlr6w+0L61uh711Uzmo0YIsrISjtJSVgsFnot7sWSE0sA2DVoF7PHxlO6NAwfLtP3hJD/MT4VivMTcu3bFg0Gvl2TLzXXSlNLe/3Ap/s/4adzP+Gh9yDPnMek1pMY2ch6k1pQTCjoX+QLJPjD49/J40XvIb2STk7miMmTWolS9fHQe3Dg2QNUm/ld4e2uAf8eCgM7S88fLJhMOoa9156oaAMtWkBIiFyEy5dhn8ckRm1wPKHpG9uX18ovZO1aubg28T0zUxre+vhYPbDAvn17fN+DH09KUb+kd0n2Pr2XyMDIwutsMUHGWXkOERbsvnO1+hTa7msCH2d5n6+pWVMey5oGV6/KFC9/V1/pe8L5AdKdvDvEzY7jTOoZJrScwOjGozELMwN/HMjCowsBmN5uOi/Gv8jAHwfyxeEvcNe7YzQb+bjDxxxNPsqs/bNcpj+l7RQal2tMXEQcmk6HWYO9l3ZRKbiSPG6cj7lN7WSp++j+0j/Nel5teBl25cKaJ9bg7+FPo88aMbV0SYbHdoGHZsjttzwG8m4wMRVGF3hw3adyJ76J68a3SwMYktAFvV6g0wmuJ7nRb0UfFu/bAkf7EuwTSCuPN6gQ6cW4ca7edEFB8t2WdgLw1b6ZDFr9EuOqNGd049e4nJdHjW+fpEpIZXbVbYbp8jIsYS1wd/NCl7yVOSUH88ya4fYHnCU8S5AyMoX4efHsvbbXng68rPcyukQ3lga4RqvZvabB3qHQfKW8WdZ7OP4/C/rKgczIHjQFKj8r+9TyCly55ka7Kbv5ZEEE9etr9v+HnDOr8cnegiH0ISnKXljA7WM/0n3GGt6Y3IDatR2H5sSJkJNtYcZHcr9ZzGDIPYt+/cPQ08kYzrZsh4KhghGqdQNDCcg6y8bzvVm06SHKVK1I2XJ6zKZ87iTuY1i19rh3PSDPgXpPWa0LHA9SrH3l3K2zVJxRkZLeJbkx8ga9vu/F8hPfkxHjjlu3S+BlTUdZGs7pC/40HH+Ioye8KVlSPjixrbedAuefKVOkN1V2tuwDxqQDsL6xNICvMBiwwHd+jmVzGr/z151ZeWYl87rMY1CdQVSaUYmzqWfZMnALTSObFjju82X6tt5TCl3eZWBZtPQhc/OTxVZslb80N3l93XqLjDwDcr/S8HK6DHEmSAepTjpidG43dN//wLFjrn04Nxe2XF7LI1877EKW9lpK30W9yNXySZwKHmYo9Rq4mWHNimcZengEpeqXI7ykmV9PG9i+6hABuVvkyM0nyPfNb7DdO46mXzp83d6P/5x3egwkNbWw/9ir615lyq4p9mMjyrcSKQmnOHFCFg2xc3CU1Uf1fRex2L4vnPbn2jNr6LCwA1VLVuX40OOsPrOaTl93wt/Dn/S8dGZ2mMnQh4YSPCnY7lEFYHzTyNwDcxm6eiitolqxMXEj/u7+VA+tzq4ru/A2eJP0WhJVZlbhWsY1AF6q/xIftv/QsZxO+znfkk/dT+ty9IYMfngh7gU+6iijjH+58gtTdk1hctvJlPIrRbWZ1WTarBP1vLvzTvUlZGY6bGKFkBUWnfelDYuwMHztcGbsmcGg2oOY3Xk2+nfGF3stsrJvHEOWD2F049G89PCLaOfmQOZZCKghr9V29AFTGqBB34KPELCvp+yrmvzvut+CVH8h9yoaIYS4rxdSsDsPRCOjdg8D1Qu06QisQV6ixAN77mXa9erVE4o/B4vFIuYfnC+eXfGsSM9N/28vzn2RY8wRuabc//Zi3Bs5N4VI2SvEjR1C3PhZiFv7hLCYi22+4tQKMWHrBJGXn+cy3Gw2C4vFYv8+cftEQQKCBMRDsx8S1y/9JMTah4VI3ipEfo4QS8KEWIj1pfvLVq8g+flCHDokxJIlQixaJMTixUKsXy+EufhVLszYsbaAQcdr7Ng/Zfl2XtopSEDM+GXGH16GbGO2yMjLcGm+4dwGQQKi9qzacoDZKMTlZUIcGCnEwdFCHHxDiP2vyX1TkIwL1t9HCHH8AyGOTxbiwOtCGP/+43TLhS2i39J+IjEt8feNaMoWYnMXIY5NFCLrshCmLCEWhxbf/8LCCm9fkMP/C1gs8vWHsS2/yzQtwmQ23d+C/Tcp6hhwOg7Mv+ug/vvINmaLtOy0uze6y7pZLBYxZ98ccSz5mL35nTtCbNsmxLJlQixdKsS6dUJYfmcf3nxhs/2cfSX9ihBCiHxzvvAc7ylIQDy74tm7L5uPT9HzsljkuSLnhhC5t4TIz7VPe/fl3SLfnP+Ht6XZLEROjhB5eY7jY+WplYIExKtrX/3929jad9adXSem7pzq+E/7C8/5fxZF9ffjycft+1IIecyXfrWroFt/0X74D2LJEiGupWTY9zsJiJKTSooW81sIxiK+rybXdcZDCMYi+o6NlRNy3g6nZwmxrbsQeWlCGDPs59WXp8rp+b3rJ/zf8xckIPp+/7gQV1cLsWuIEEHeQgR7C7FnqLiTccU+f904nSABsffqXrFlixDe3rJr1aolhLu7nP0vvwjhH2gUbu75wtNTiJDSd0RE/HaxZUeOyMkR4vZtIbae2i/8/M3i3DkhTE6nuUVHFzv+Cy0W8fWh+YIExPfzQ4XY2V/+N5gyhDBlynVZEiaGrxluX77rGdeFEELkmnJFxHhE98mIDZuGCHH716JP0mlHhfipsRC/fiBE6iEhbh8T4uL3Re/E/DwhzswV4ud+Qhx4TYgDr4utsz4Q1avL6WZny2bGwP7eAAAgAElEQVQmk+s6/Ravvy7ECy/Izzk5QmRlyWshkbxNiFOzhDj9sRBnZgtxZo4Qu58RYm0DIfJShTDeESI/R1ycVUf4+8vx85wu/fL3jxGWn/vJdjZs13U2rP3EYrEIj/EeggRElRlVhNs7biJsPML8racQFqdzwJIwkdD9bdH/SaO44zTZQjj9p1ksQkREuHZLsXeYEJsekfuyqGVzGn/s5rGCBMRbm94SQgjh+66vIAGRnJlcqK24vFyI70oIkZkohO3/0zbdRb5CbO4oRPpJIc7Ok8POLxDCdo6zXvce/wz7tiABEf5BuEjJShFX71x1ORb3HsoUkZFyv+c7baKsLPm+7uw6QQJi0/lNQgghnlzypCABETgxUJSYWEKQgGg1eZgIDRVi1y75P3H7tmP8oralEEJsTdwqSECM2TBGpKQI4eXl6HsFafJZE/vyXriaLtzciuibxycJsXOAPD84bQeXay/rMhy/cVyQgAj7QP5PfX7wc0ECIvbjWEECYujKoSLbmC1IQLiPdxdRU6MECYiEzQmi0bxGggTE7H2zXbYjCYg6n9QRQgiRkZchPMZ7iBbzWzjmXcz5PS8/T4R+ECpazW9V9Mo78fOln+UyvePu8t/8e/lfvW75bwPsE/egy9x3pJFVoeoATEMGDH4mhJigadpzVlHqE02GZ3wEtEdG9j4livAzKsj/SqSRQvG/iNFsJC8/z25aiBCQlSgN9cw5sgqDT6Qsl/4/rHA/KKTlpOHr7oubvogS1P8UTBnWsufWUtxepWRlpQe1/90tauYew4IV/xxs11ua0/Fw8uZJ3tz8Jt/0+Ob/zbmjYGSnQlYc7NYNWrQQ9O4j8PbSOHFCo0kT+ObcDF5a+xIgI4PWnVvH1N1TGdlwJJPaTKLP4j4sOr6IyW0m82rDVwtF95F1SVYQajgKELB5FAvyIxiwfIjLMtwtUm30htFM/FlGL7aObs26fuupXl1Gl2zcKKPErl+XZaijomRk4ssvy6iLqUffwNJwEk0YRfCh90j33cvmCvUJSGmD16HXmD2qDU2awLm0M3y+eTMzLz+LQWcg7808hq8dzsw9MzDG6ND3uCErKoJLNISxdx5pgZ54u3njl5opLQZ+7o3FrQSi7KPo9F5oN7dC9bfAs4C7tY3MRGtFVqOMDAqsdc//Oxs2wMqVMiLeZvqflCSrK91rZaS0NFl5KT3dahKug44dHZFZdtY3kSnGUU/Yt0NeRhrN/72VoW/H06OHjPzR6cCyoS3ulR6H8k8V2mYFI0gQgtJTStujPGxY6sag1Z0KYdaUPGDIYBNlyrrd/S/KabqXL0OlSthTVgHEsopQd6qLCbpLFJTT+N8d/47ei3vTq1ov5nebj/e73ngZvMgakyXPhc599cCrkHUZ4ufJyCLn6QY/BK02y6ii/Gz4zgc6HpfXuM7tAPG4hem/TKeUbyl6xToqY4xcN5LJuyaz6LFF9KreiwULYOZMGUlarZpMXf/xR3i3cMFpdl/ZTYN5DVyGtTxwjdbxpRgx4h6qMoOjGqzNFDcpiZEjZbXn+fMd6fJ37shj8Vb2LUI+CGFOpzkMrjuEGjXkJUf79o6+mZWejc+2OhA9gPSIEVy+rKd0aQslYiMhORkLGhtojQk3Grr/RNAYMx56D3LfzGXijomM3jiaXtV78d3x7/AyeBHmG0bi7URK+5amhFcJjt08hrveHZPZhECwof8Gpu+ezvLTy4kOjObC7Qts7L+RltEtHetuXTfF/w/uNdLoz6iehhBiNbC6wLBPnD4L4IU/Y14KhULirnfHXe8Uz6pp4BstX4q/nRJe91Aq/EHHzU9WjvqnkJCgxCHFPaMVcRNbpWQVFvda/F9Ymj+OEowKM2CA9Pjp2VPDx0fu55gYKcoMCRhiF43aVWiHyWxi6u6p/HJF+hodTJJFLJpGFvbFBGQloEpD4Zb1MrrGW/TJNzJg+RA0NPSannyRz+A6g4tdvmEPD7OLRm83e5uzZyExUQodoaGyTXQ0fPyx/Hz0qLz3EwI810Ux4ZDAt+JhfhgLC4+cZvMPgozQDaS3WcemQ6f59tsYVkR2JsPjFH7ufmQYMwh6P4hMY6Y0RtC5yYdZhdDhrncnLFMA1rTOnU9AmUfRlR/o8Cna+zxcXOTwaCmIb5R8/QFat8aluMkfoUQJaNHit9vhVxnunJZpuNaUKg83I7vGNeJCAzPLl8sUME2DR7zdCTdlOVQoO0Uff32q92HK7il4GbzIyc+hcnBltEZfw+ZHMMeM4OfLvdDrBdHeFzh+uhV37txb+uYvv0jxKzdXvptMyAeUIU7pzUsL++/YiAqMAmD56eXU+kTaNfh5+BV5PuTGVlnO3iYYOU+35r+lvxHYBTAyLzhEI2u5e9ChaRovx79caPLvtnqXLpW70LicvE7p31/6sO7dCxcvSuFncDGHUXyZeNqWb8u68+vs3y1bShERUUAwuhecBKVJk+Drr6XovHSXXN/+TZNYtQqCvYMRs8Jg1puQNITXZmxnyAgLrxxvRrducDnzPPPX7efLUftIePk0MxaAXpdHvtlAZiCAxgC+4Adk4ZPGxp/xNnQnOz+HHFMOV+7IqmtxpeL47vh35OTnkHg7EZDXtC2jW3Ls5jHMFrPd4qRFZAv83f1Zfno5F25fkMOinDp/UWKZ4oHgTxGNFAqFQqFQKBSKfyIXL0rRxdn03eYR4+XmxeLHFhPsE4ymaTQq1wiAny//TKN5jTh96zQAUY06kn3tJjb3tCw3yPXWCPYPK/TU3t3gTrPIZmy9uJV8kU+1kGoEeRfjIwaU9i8NKTFwtC/b3Rrj7w8PPyz9B20YDLBoETz/vBSSbN4gTSvHMuEQnE+TJURtN4qVgytzIuUE5rgZ9OnVhq+/PYWn3pOqIVXZc20P6XlOpkI1xsHOfrJ4geYGnU5Knw+bOOBM8iZo+KVDMFoaLj0BHwRqT4R18YAOKj0PXc5D9hXwr0Q0sg/ZOf0IXF0F5QeCzrd4wczKsIeHMWX3FGJDY9l7bS9vNH4Dgupi6fArT/a8xYqN4YBG51Zm1uwQpKTIMuju7tLzr6Cnjo3du6VP2XPPwaxZ8O67FhBmh3DjQmFBq2IJ6S6fm59r96bx0BejsmQmuopRtsgqTQehzeS7Myf/A2HNpQDXPQnMedLbqhjc9G40iWziMsxgkN6G98KEVhPsotGk1pM4JaTg89hjjsgfkwncfkeUjabBE0/IF5pc340bnRpYRRizxcwLu9qT3S0bQ8gFxo6NYkOVjmR6niT3mUSO7ajHnM+geXPYuRN0jyUxcSIsHS+FSIBtXu0J8wkjMT2R82nn7cdytZLV7N5JNk+2hmUbMuzhYUzfM52owCjOpZ2jZmhNdDqd3WQc4O2mbxctACoeONTjIoVCoVAoFAqF4g8ycya8+CIcPixTXLKz5Y22jR7Ve9A8qjkAQV5B6DU9ZmFm55WdAHgaPAkfeJNa1uKIAqg8DMJGwlUfM0VhK1IC0LN6z99cPs95p9BtH0tCgsaIEVCrlrxhtmGxwMGDMvLCuaLoQ5HVAbiacRWA4zePA/BIRWkUPGPPDLot6gZA7VK1GR4/HIBSvlKRqhFaA32116H8ANjQErZ0gK1d4KdijPhDm8HlpVCgqtoDccviGQIdfwX/SrDvZdjWFU7PAHMRpffKPiYjb66tktvCbJRpWcVgi+jZf00Wprb1t/GTglm+uRJZuV5k5XqybHNFnn7WQouWgjlzZFTZ7DlmWa3TOV0MQNPYM30XBgNMsPo5Dx+uk8Kf0UkU7J4k09L6Fu6rQd5BaLiKCrGhhauUAjK90FCEkOgXYy2iY8UWgZS8WUah5d6QJtrXVhce908kLiIOrtWFrWPYu6QxjzwiheKOHeGnn+Tx/913f8289To9HSp2AEDELuTNmfvJ9DyJW2Ykm5aW46efoGdPWdCnWzcpBE6cKKMF58yBr76SQnCeOQ+A2p/WZs2ZNYCsnt08sjkA1UJk5Nbzcc8TExwDwIU0KS71jpWVkDVNo3FZGa3Vr1a/v2aFFf9zPABnYIVCoVAoFAqF4r9DmzbSF+fLL+HRR2Xltn79XH1gnKkUVAlAVu4D4iPicTN4cDYYbmQmcyktkasB4OnhQ0SWvtCNPOHhtIp2VCFtW6Ftsct2+DCMHAmP9dC4eFHjyBHp3VOlimtkVHKyjI6yVZO0UcKrBL5uvmQaM5n+y3R2XpZCV5/qfewRI246ad7zryb/oke1HgCYzLI88Cvxr8hlLj8QOh6BlhugxRrodFzmwBVct+4b4duX4Jdn4NJieHi2LEldhCDx/xK9O0Q9Do2/gZbrIW6GHFYQrzB46FPY/RQ3VzzFoe9mkLGsvWObFdhuWqlSdIrphAVZzSkqMIqcHJg8WVZHGz9e2u3lxn7KZG8D9V5+lw8+gDptTvJisjeaLa3IE2gBtAS84aSpAl27ugqMBFSVEWGimMpRBQj1kTmQngYZvlZsBV2dASx5ju+e1qpvvuVldJONXKcUqLQjssLakmBZYfMvwmyG3r3B66t91E3/N7Nna8TEwMKFMkt96VJ48004flxWV/4r6FlNisNvb3mbhp81BKDU5WG0aqURHu7w0DIYZHVYiwVWrJBRTI89Blu3gr+HzEnMt+TbU84qBlekY6WOAPbKsbFhUthrFd3K3qdsaX0A77R4hzphdagYVPGvWVnF/xxKNFIoFAqFQqFQKO6DcuVkafLVq2HNGvjhh6LLPwOMbjIakKbUAGOajqFRWZm29sHPHzBl1xT5e/nWFJf4Ua1kNfvnhyIeKna53n5bilqffCJLdVepAvXrF26Xm3sX42frQoxaP4pL6ZcAiAmJYVKbSYCMXgj3DadTpU64692pGVaTlJwU+zq4YPCy+/kUyR1gZhDUeU8KBaY7EN3fbur9T8JY5kmGrb9Iuce/otngZynVb13xnjHJyXbBrnZ4bUD2RU2DZcvgtdfg9ddh1HOyXvtpj29ITIQpy9aB3khagAeUBj4A+gFPgmWSxi1dSVq3dvgfeXsDER3h1AxXn6r8zKJFQE3jsd13AGhSTqaGda7kZKDtjGcYpB1yfO+eBPXngt4XnI8Em5iEDjocgvZ7ofkaePT63TbnfTF+vPQAO3xIY+tWjYMH4fPP5THTvDl8+qkUaN59t4DA9ifSvZqMLrQIC0ZrdFoMnYiNLXzsrlvnONa9vKTvUmQkRYo8ZfzLULdUXQCuZVwjyCsIg06uhPO+ck5LaxHdggPPHXBMpJh9bzfGVvy/R4lGCoVCoVAoFArF34TN9Ppw8mEAGpRtQJWQKgBM3zOdWftmAVA1pKr0MypYtDopycVHxF55r8CNm0XTsWlFJhMmuN5URkTIik3OkVBeXq4pdc5EB0qznVyzHEFDI9AzkCdrPmlv807zd+yfB9YaaP9cNqBs8RuiqHWzrh8+kRDZG6KfhMAaD24Vzrvw7LPww5qSfPAfDzZt9+Wl4Z6yAldRhIXZU9JsqUYrVkBsLDRqJAVMb294rXtrNDSO3zzOp/s+Ze6BuQBs+vkLmBkFJb2g9utQdwy33QJx0xlp1KjAvCo+A+lHYd8wmTJnMcKJqQ5BqzIwGrDaB9VMlOKSzb+rfIkC4Ww2SjaB6+ukUbgNnYdVnHISDQumwwVUg5INHT5YfzJmM0ybJiucRUeDr688Xjp1+ktmVywGnYExjcfYv7vr3YmLqszt24WjGvftkxFGztGE/v4QEyRTznRWCUCvSfM1m9AI0DGmo/1zw7IN7Z+93YrysbJyFzFT8WCgRCOFQqFQKBQKheJvIjIwEoDkrGQ89B74uvvywsOyOprRbMRkkaldzz/0/F2nk/tRCUQCjqf5BW7QLhCNp5dGpUqu4zVtKqMmTCbHMJsWcfp04fnYxAibN01Jn5KA9GcyaDIioU9sH3t7W7pc1ZCqd11+RfGcOgVLlsg0o6efhnr1ZPrT3YS2qMAokiZrvN9/ASA9qp56qoBw4O1pTxd7ee3LHL1xFID2httgSof2B6BGAsS+RUpGCG4GY6GURXyjIPYtuPgd2QsjSP8iEn6dKDtRCDAKiAWeAmpD1bnLALiYfhEdOnsUSyFCm8LVldKfyIZ7Ccg4I8UjZyx/X7ri0aOyQl6dOq5RRMVG5v2FDKozyP45oVkC7dppbNxYWFM9dQri4x2G/Da6VukKOESi6iWlZ1mgZ6C9jS0izLldqHfo3RfsLmKm4sFAiUYKhUKhUCgUCsXfSHwZaQQ9oNYAQKablfMvZ/+9RmgNygWUK3JcGx4pafKDTSwqcIOWjTclAiyFPFbi42WZceciT2YzxMXBggWQ5RTokZkJ/WpKs9tOMTK0YlBtx43r0j5Lefnhl/HzcBgY21LnXEpxK34XS5dCu3ZQtqyjpLv3XQI9bIRlCtxvpgJw/rysDOYsHLi5Ofqc2eoTFOodik/SKojqBz5lZQqh3pOUjBBCgi2FhAcAqo9ml8dqSj1/mbBnL/DdtcVw/Tos7gqe1hE8gLHlqBLjKE/WoOxdSpWV6SbTEbd2lu8WI9zaA1kXQJhc2+YXExb3F5CVBUFBriLrf4sKQRXsnwfUHkDTptJ4/5VX5Ht6ujxmb92CmJjC41cKlgqyj5tUvOpF1LP/FughhSNbqho4ohjbVWx39wW7W9Sg4oFAiUYKhUKhUCgUCsXfiM0rxPlm7Ol6T9s/O0cU3DMFbtwCLh7lZo5foZv+mBjpb9KjB9y8KW8yExNl5bS5c+Xn7Gx5s3z4sEMEOpV6CnBNZelcqTPTHpnmMn1N0xBjBTM7zvz966AAYNs2aNVKmpb/EdLTZSW/QlFCODy1InwjAHi31btw82eZCmjzm1oaTkpGCMEhOvLyCk/DZILeLzXjTo4feSZPBr/9iIxUur7G1bQ6+zIhax3V0mzeXUXi5gvVx0DqflgSKqukHZ8Aeh+48JVrlTnt77uFrVBBRu4UxHJvPuB/OoNqD8Lfw58Ivwhu593ipdmL+GZZCjVrwoCBgkod1qLTCXyLyNYL95VRiZfuSG8ym4gE2KulFaxuJ8YKFjy64C9aG8X/F5RopFAoFAqFQqFQ/I3YIo2cKxJ1q9LN/rlL5S73PY+yZUGng/37XYebTDBzJpw9K0WFZs2k982AATKVqW5dGDEChg2TJr8+7lJIOHPrDHCXkumKPw2zuXgj9XshO1uOX9Q0Aj0DqRxc2S4cdKnYVgo+AdUdjXKTSckIIbCEvkhx5KuvIDXV8d1kApLWyzQy9xJQ8TnwrQAItLwb9na/2XeqvwExz0tRyGIC/6oQ0V6KR6Z0mZaWnw0HX7v3jXGfhIdDtWrSDNvm+2WxQE7O3cf7q5jXdR7p07wgPJwZe2bw+p4+dPvoDfr1g1T3g1xv0gOLKDp9z1ax0WZoHxkQaf/NJuh5GDwKj6j4x6NEI4VCoVAoFAqF4m+keVRzkl5NsvvLgMNfBO5iFvw70DTo2BFGjnSknOXny5vdFi1kVJHFIsUjT0+ZBrV2LYSESFHg+++l8S9AnfA69hLdtogExV9HzZqwfXvx5uS/hcUi/XeKKzr3cv2XAXDTuVHSKwDQgc7d0cAzjJSMEPxLuBfpQT5/vmsaY14ecO0nyM+ARt9CvWnQepv996iAKAC74XuxaDqoO1l6K7VYB+33Q9VXwXgb1taV3kk/94Fzn/3mNvgzmT0bPv5Y+kvt3ClNxlv8N7Mvk5MhOZlKwZXQ0Dh35wRjx8JLY8+DIReEvti+ExUYZT+Wbf5qAFPbT0WM/edVKVTcG0o0UigUCoVCoVAo/kZ0mo4wX1cPIk3TKOdfjsrBlf+0+YwfL1PMWreGTZvkzW5dq2VJ377S92btWpmSBjLi6ORJeYM8ezYcOSKHtyrfyj5Nd707ir+Wxx6DNWtwSQ37PZ467u6FK2o5YzNEbl+xPeg8AbNr1bLuSWTGTCIoyFCohLzJBLt3S5Hx559lfwkLA25skWbWIQ1B7wHuAfZxbF48lUPusW8HVIGSDUDvDkH1oHQnyEuFI29Ks2zDH8zb+4PUrg1bt8KlS9CkCfTsCbVq/YUzLKqEfRHl62NDYxEILt6+CMD5tPOgs+Dhm8XZs0VP2jm99Ld80xQKG0o0UigUCoVCoVAo/ge4+MpFTg47+adNLzISFi+WN/Zdu0L//q5eLGFh0iw50FE8CT8/2a5vX0d6U53wOsCfEwGl+G3q15f7rnVrWQUtLw/Wrbv38QMDpbhTnA9xhF8EqVM9WPLyTinMeEVA6l6XNvn5srx8QdHo0CEpGL35phRToqPh008EZF+CyMdBby3XZnCUFwvyCgLA38P/3lfCmYZfQ2QfGQ3lGw3t9/yx6dwH9epJkSw3V77mzPkTJmoThwoKREWVqi9imE1gvpZxDSEEJ1PkuaN0dBa//CLTHAviHNFYyrfU/S2/4h+DEo0UCoVCoVAoFIoHlPbt4cIFeZO7YEHRpr6/hc2LxvmGU/HXoWmwfLl8b9pUVu/q2fPex3dzk3rEiRPFtymRnofbzVvyS2hzODMLTI6cJlOeEYOhcDn3vXtl2tvw4bKim7s7tGuZDmhQqi3oCpdbm9VxFrkflSgyWuae0Okhfh70yYMu58Cv4h+bzp+Am5v0CvtTKEoccuIMFfmQl0gkssjfPQwehHiHIBC8vv51NpzfAEDdema+/trVdykjQ75HBUbZh+mL2FcKRVEo0UihUCgUCoVCoXiACQyEPn3g0UflTf7vxRbRoCKN/j5KlpQm5j/8ANOmwY4dv2/8atWkL5Wzt41NOChE+YHSk+jaKikcmTLJv3MFna6waHTunExjdI5YM2deBYMveBed7hTsHYxHStpviiQKB0eoQW0O8TrvU4Mj5CelFN3QakM0eddkLt+5DEDH9h4cPy77T24uGI1wWf6kUtIUfwglGikUCoVCoVAoFIpi8TB4UNa/LD2r/Y5wF8V9o2kyRe3ppx1eVPdK06YyNdFZ3CnWFymspfQO2tkPtjwC27qgv/YDFkthM+2zZ6FRI1fx0Ue7KlPcLHkofgdhYUUOtoSG07PSEbLxwYgn2Tp/DGHBRbatVrJaoWF9Hw1G06BDB1i0CJYtk15M4BCNQrxD/px1UPwjUKKRQqFQKBQKhUKhuCuXXrlEo3KN/tuLobhHeveW6UkdOkB2tow4ateumMaaBs1+5BK96fj6v2g/YjQZVMRsLiwaXbokq7vZ/K4AyLkGnqFgsapSS8Ph6yLKrilcSUqSG7jAa/t317l2zdHMWfgrSNsKbQEw6KT5VEnvkri7y6qJAAMHQq9ejlQ1m2gU7vMHUwUV/0iUaKRQKBQKhUKhUCgUDxAVK8ropJ07wd9fpigeOFB8+4y8ErR8awFrj7Rj3dHWfL2tCzk5hc2Ur1+X5tcu5N0Cj1DAKhTlqjS0++HLLyErC159Fa5dg2eeKb5tj2o9AGge1RyAvrF9Gb1hNClxr9CxsxkfH/Covha/p/pwMuUk3m7eAAR6BRY3SYWiEEo0UigUCoVCoVAoFIoHjM8/h4AAKfxYLNJQuzjGjIErVzQsFg0hNLKzNVJTC6e0paVB6dIFRhb54OYHugKl1oqjqJLyxZSVf2Aoap2LWd/Vq+Hhh+Gdd6BUKZg6tfjJVgySpuAnbkrX89qlavPBzg+Yufcj3v/4Kt9+CzEDJ3Ez9Ds2X9hsHy8yoGhzbYWiKO5LNNI0LUjTtPWapp2xvpcopl2ipmlHNU07pGnavvuZp0KhUCgUCoVC8Y+l4M0nPPg33Iq7U4wgERMD27dD8+bQooWMOioKkwnmz5fC0rRpMGsW6PWQnl44PS0/vwjxyWICTY890ui3KM4Q+0E2yi5q3YoYlpYGt25JEc9bBgXh4YFjHxfYz4aIMnjoPbiacRWAmmE17X5FKTnJdOoEZq8kNE0jMlAKRWKs4KvuX/2pq6d4sLlHObhY3gA2CiEmapr2hvX7qGLathBCFGP7rlAoFAqFQqFQKH6Tf+INt+Lu3EWQiI2FzZsL/+zMtm2yjPzcudCzp9QlLlyArVtdNQohpLDk5lZwChqyjJdVYfIMc0pRU4ktv4fERPDxkQboNvR67nrct4x+hDVn1wBQNaQqZf3LciPrBkmZSQCkZKcghFDRRYo/zP0exV2BL6yfvwC63ef0FAqFQqFQKBQKhULxN7FunYwe6tkTvLykyXWrVpCa6lolzWyWIpKu4B2kzgDCyTW7exL0FdZXAVMkxV1JTISYmMJeUsVVWiMsjMblGtu/erl5USGoAgJBcpYUmm7n3kYg7JFGCsXv5X5FozAhxHUA63toMe0EsE7TtP2apt3Fygs0TXtG07R9mqbtu3nz5n0unkKhUCgUCoVC8QBxl5tHxT+Uovb97+gPhw9D9+6FR79xwxrlYkWvl7pQIUFDM4DxjhSOFPdFYqL0MSq0jYuptEZSEjVCawAQ7BUMyGgjgOTMZDKNmZgsJrzdvPF19/0b10TxIPGb6Wmapm0AikqS/tfvmE8jIcQ1TdNCgfWapp0UQmwrqqEQYjYwGyAuLk4U1UahUCgUCoVCofhHkpT0314Cxf8a99knTp+Gl16SUUY2SpWCvDy4fBkqVJDDbFFGRmOBCXiEQN4N7OlpNvJzwOCFAqnCFUwxK0LYO3tWGo07R3j9FrGhsQBUDq4MQFRgFACX0i+RnCnnGe6rPM8Uf5zfFI2EEK2L+03TtGRN00oJIa5rmlYKuFHMNK5Z329omvYD8DBQpGikUCgUCoVCoVAoFIq/HiFkWfdKlVyHBwVJ0WjvXodoBNKU+ebNAmbY3qUh9wboCpgdWYxAEaJRUQKKbfiDyj0KexkZULmywwT7XrClnZUNKAtAkJfcOV8f+5qNFzYC4K77HSqUQlGA+01PWw4MsH4eACwr2EDTNB9N0/xsn4G2wLH7nK9CoVAoFAqFQqFQKO6DvDxZPS0iwnW4wQB+frBxI2RlyWEmEwQHy6kC0VEAAA0gSURBVOgjF7xKQ851uFdh4i6pVv90jEbpKfV70Gk64svEMzRuKAABHgEAZBozOZd2zt5Gofij3G/vmQi00TTtDNDG+h1N0yI0TVttbRMG7NA07TCwB1glhFh7n/NVKBQKhUKhUCgUCsV9YDRKr6Ki0qFiYmDxYkcFtfx8KS6dP1+goXdpyM+ErETX4So17XejabJC3e9l1+BdNI1qCkC9iHqFfq8YVPF+F03xD+a+RCMhxC0hRCshRIz1PdU6/JoQooP183khRC3rq7oQYsKfseAKhUKhUCgUCoVCofhrqFcPbt+GefOkYLRuHURGwv79jugjAIvOT6od19aCxcnB+fbxv3+h/5/j7g45OY5CdH8EH3efQsMqhVQqoqVCcW+oODWFQqFQKBQKhUKh+Afi7i4jW0ymwr/Fx4OPD4wYAc2aQZ8+ULEi7NjhKmpkZGrgEw0XvwZLrhyYnwnnP/97VuIBIihIpv9lZ9/fdEK9ZVHzcB9pgN22fNv7XTTFPxglGikUCoVCoVAoFArFP4HwcEe+GeDhpaEzG7l+vXDT+P9r7/5j7CrrPI6/v8yUSkttYVvoj+m2UCvdolBRGlRcFFFgNYAaCKYQIqRGo6JkWbZdkiWb+Ic/9pfGH1kibI0QGtotSKSAXYFtohYEFKUipcJSpj+Wko2Lu0vpln73j3PqXObeW3pnpr3n9L5fSTP3POfcuc/k03vnnO88z3POKL7u2QM/+Qns2lUsmP3cc68taowfDxz/PnhxA2xfB6/ugl074elvH9yf5TD0pjcVC5O3KuJ1YvHAYgBOPOZEABZNXzTarqmHWTSSJEmSpF4w7K5lAcxiK5s2NR960klwxLCrxX2FpGuvLaaovfwyfP3rwIwPQv8k+OnlsOETsO49wCjmWPWouXNh61YYN+51D92vBVMXAPDs754FYOqEqaPsmXqZRSNJkiRJ6lHzeZoHHyxGEu2ze3dRMFq6dGiR7IhipFEEfO978I1vwG23wQ03ANPPgb2vFNPSnlsJL2+FvqOaRjYRUbSppblzi4XGd+8e3feZd8w8ALb/93b6oo9ozEDqkEUjSZIkSepRp/I4q1e/dp2ifdOjrr56aLTRUUcVjz9YLo+zbBlcdVVZbBo3CQY+CtEwROYN05tGNgGt2wQURaNdu+DOO+HVck3xkRSQ5kye84fHC6ctHJvOqWdZNJIkSZKkXnD88U1N50x5lJ074e67i+lmu3bBj39c7Jszp5h+NmkSXHdd0bZ0abFA9j4TJpQPTvs7OKIcltQ3ARb/08H7OQ5TEycWhaMvfrHIAoa+dmLOlKGi0anTTx2bzqlnWTSSJEmSpF6wY0cxpKjh33t3rGTPHrj8cli5EtasgY99bOgpS5fCSy+V09CAc8+Ft751aATS5MnlgRNmwgfWwx9fDO+6BaaffUh/tMPFRRfBli1wySVw773FdqcaRxot+KMFY9g79SKLRpIkSZLUo8aPh8sug7174corYcmS165vNFwErFoFb387zJ8Pa9c27Dz2NDjzdpj9kWK7xcimlm36gyVLinWk7rkHzj8fHnyw8+8x8cihoWBzp8wds76pN1k0kiRJkqQe9uUvF7WcfeslH3vs/o8fGICHH4ZNm2DR/u7m3mJkEzt2jFm/D0ennFLcpa6/v9jetxD5SDVOVZNGwqKRJEmSJPWwKVPggQfgzDOLgsX993e7R70rAm65pSjcTZwIxx03su8z7ohiUfLGqWrSSPR3uwOSJEmSpO6aNw/Wr+92LwQwYwb89rfw6KNw+ukj+x7TJk5j2++3MXPSzLHtnHqOI40kSZIkSaqQo4+Gs85quDtdhyaPL1Yo7zuibwx7pV5k0UiSJEmSpMPIydNO7nYXdJhwepokSZIkSYeRVZes6nYXdJhwpJEkSZIkSZKaWDSSJEmSJElSE4tGkiRJkiRJamLRSJIkSZIkSU1GVTSKiIsjYmNE7I2Id+znuPMi4qmI2BwRy0bzmpIkSZIkSTr4RjvS6Ango8D6dgdERB/wTeB8YCHw8YhYOMrXlSRJkiRJ0kHUP5onZ+aTABGxv8MWA5sz85ny2JXAhcCvR/PakiRJkiRJOngOxZpGs4DnG7YHy7aWIuKTEfFIRDyyc+fOg945SZIkSZIkNXvdkUYR8a/A9Ba7rs/M7x/Aa7QahpTtDs7MG4Eby9feGRHPDTtkKvDiAbyuqsfs6snc6svs6snc6svs6snc6svs6snc6svs6qldbnMO5MmvWzTKzHM67dEwg8Dshu0BYNuBPDEzpw1vi4hHMrPtotuqLrOrJ3OrL7OrJ3OrL7OrJ3OrL7OrJ3OrL7Orp9Hmdiimp/0MmB8RJ0TEkcClwF2H4HUlSZIkSZI0QqMqGkXERyJiEHgncHdE3Fe2z4yItQCZuQf4LHAf8CRwe2ZuHF23JUmSJEmSdDCN9u5pdwB3tGjfBvxZw/ZaYO1oXqvBjWP0fXTomV09mVt9mV09mVt9mV09mVt9mV09mVt9mV09jSq3yGy7JrUkSZIkSZJ61KFY00iSJEmSJEk1U6uiUUScFxFPRcTmiFjW7f6otYiYHREPRMSTEbExIj5fth8bEesi4uny6zHd7quaRURfRPw8In5QbptbDUTElIhYHRG/Kd977zS76ouIa8rPySci4raIeIO5VVNE3BwRL0TEEw1tbbOKiOXl+cpTEXFud3otaJvdV8vPy19GxB0RMaVhn9lVQKvcGvZdGxEZEVMb2sytItplFxGfK/PZGBFfaWg3uwpo81m5KCI2RMQvIuKRiFjcsM/cKmAk196dZlebolFE9AHfBM4HFgIfj4iF3e2V2tgD/Hlm/glwBvCZMqtlwI8ycz7wo3Jb1fN5ikXr9zG3evgacG9mLgBOpcjQ7CosImYBVwPvyMy3AH0Udxg1t2paAZw3rK1lVuXvvEuBk8vnfKs8j1F3rKA5u3XAWzLzFGATsBzMrmJW0JwbETEb+ACwpaHN3KplBcOyi4j3ARcCp2TmycDflu1mVx0raH7PfQX4m8xcBPx1uW1u1dLRtfdIsqtN0QhYDGzOzGcyczewkuKDRxWTmdsz87Hy8e8pLl5nUeT13fKw7wIXdaeHaiciBoAPAd9paDa3iouINwJ/CtwEkJm7M/N3mF0d9ANHRUQ/MAHYhrlVUmauB/5zWHO7rC4EVmbmK5n5LLCZ4jxGXdAqu8z8YXmHX4ANwED52Owqos17DuAfgOuAxoVZza1C2mT3aeBLmflKecwLZbvZVUSb3BJ4Y/l4MsV5CphbZYzg2rvj7OpUNJoFPN+wPVi2qcIiYi7wNuAh4PjM3A7Ff27guO71TG38I8WJ2N6GNnOrvhOBncA/l1MLvxMREzG7SsvMrRR/ad0CbAf+KzN/iLnVSbusPGeplyuBe8rHZldhEXEBsDUzHx+2y9yq783AeyLioYj4t4g4vWw3u2r7AvDViHie4pxledlubhV0gNfeHWdXp6JRtGjz1m8VFhFHA/8CfCEzX+p2f7R/EfFh4IXMfLTbfVHH+oHTgG9n5tuA/8EpTZVXzi2/EDgBmAlMjIjLutsrjRHPWWoiIq6nGNp/676mFoeZXQVExATgeoopMk27W7SZW7X0A8dQTJ/5C+D2iAjMruo+DVyTmbOBayhHtWNuldPBtXfH2dWpaDQIzG7YHmBoeJwqJiLGUfynvTUz15TN/xERM8r9M4AX2j1fXfFu4IKI+HeK6Z9nR8QtmFsdDAKDmflQub2aoohkdtV2DvBsZu7MzP8D1gDvwtzqpF1WnrPUQERcAXwYWJKZ+06Yza665lEU2R8vz1UGgMciYjrmVgeDwJosPEwxqn0qZld1V1CcnwCsYmgak7lVSIfX3h1nV6ei0c+A+RFxQkQcSbF4011d7pNaKP9qcBPwZGb+fcOuuyg+eCi/fv9Q903tZebyzBzIzLkU76/7M/MyzK3yMnMH8HxEnFQ2vR/4NWZXdVuAMyJiQvm5+X6KeejmVh/tsroLuDQixkfECcB84OEu9E9tRMR5wF8CF2Tm/zbsMruKysxfZeZxmTm3PFcZBE4rfweaW/XdCZwNEBFvBo4EXsTsqm4bcFb5+Gzg6fKxuVXECK69O86uf2y7fPBk5p6I+CxwH8UdZm7OzI1d7pZaezdwOfCriPhF2fZXwJcohqJeRXGxdHGX+qfOmFs9fA64tSyqPwN8guIPA2ZXUZn5UESsBh6jmB7zc+BG4GjMrXIi4jbgvcDUiBgEbqDN52NmboyI2ymKt3uAz2Tmq13puNpltxwYD6wrzrfZkJmfMrvqaJVbZt7U6lhzq5Y277mbgZujuJ37buCKcoSf2VVEm9yWAl8rb9ixC/gk+J6rmI6uvUeSXQyNxpUkSZIkSZIKdZqeJkmSJEmSpEPEopEkSZIkSZKaWDSSJEmSJElSE4tGkiRJkiRJamLRSJIkSZIkSU0sGkmSJEmSJKmJRSNJkiRJkiQ1sWgkSZIkSZKkJv8PdhCQsyYQhxkAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import modisco.visualization\n", + "from modisco.visualization import viz_sequence\n", + "\n", + "viz_sequence.plot_weights(task_to_scores['task0'][0], subticks_frequency=20)\n", + "viz_sequence.plot_weights(task_to_hyp_scores['task0'][0], subticks_frequency=20)\n", + "viz_sequence.plot_weights(onehot_data[0], subticks_frequency=20)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "uuvSgm62-Whl" + }, + "source": [ + "Run TF-MoDISco\n", + "TF-MoDISco first identifies seqlets, then splits the seqlets into \"metaclusters\" according to their pattern of activity across all the tasks, and then performs clustering within each task. Since there are 3 tasks, there are 27 possible metaclusters (consisting of a +1, -1 or 0 for each task). Consistent with the simulation, the [+1, +1, 0], [+1, 0, +1], [0, 0, +1] and [0, +1, 0] metaclusters turn up motifs.\n", + "\n", + "To demonstrate customization, the code below has slight modifications from default settings in the following ways:\n", + "\n", + "- Because the TAL and GATA motifs are relatively short compared to something like CTCF, it uses a sliding window size of 15 (rather than the default of 21) and flanks of 5 (rather than the default of 10). The sliding window size and flanks should be adjusted according to the expected length of the core motif and its flanks. If the window size or flank sizes are too long, you risk picking up more noise.\n", + "- During the seqlet clustering, motifs are trimmed to the central trim_to_window_size bp with the highest importance. trim_to_window_size is set to 10 rather than the default of 30. After the trimming is done, the seqlet is expanded on either side by initial_flank_to_add. This is set to 3 rather than the default of 10.\n", + "- The final_min_cluster_size is set to 60 rather than the default of 30. This is used to filter out small clusters with relatively weak support (in this case, fewer than 60 seqlets).\n", + "- It uses kmers of length 5 with 1 gap and no mismatches to compute the \"quick and dirty\" affinity matrix across all seqlets. The \"quick and dirty\" affinity matrix is used both for noise filtering and as a first pass to speed up computation of the continuous jaccard affinity matrix (the latter affinities are only computed between seqlets deemed to be close together by the \"quick and dirty\" method). I made the kmer length smaller to keep memory usage down when testing on my macbook pro. The default is to use kmers of length 8 with 3 gaps and 2 mismatches, which tends to run out of memory on many systems (I would change the default but want to avoid breaking reproducibility for older users)\n", + "- target_seqlet_fdr controls the noisiness of the seqlets. For a particular task, \"significant\" seqlets are identified by first smoothing importance scores with a window of size sliding_window_size and then fitting a laplace distribution to the left and right tails. This laplace distribution is assumed to represent the null distribution of window importance scores (note: as an alternative, it's possible to supply an empirical null distribution; see examples/H1ESC_Nanog_gkmsvm/TF MoDISco Nanog.ipynb for an example). A threshold is then identified such that the false discovery rate (computed as the ratio of the expected fraction of windows with a certain score in the null distribution relative to the observed fraction of windows with that score) is less that target_seqlet_fdr. Note: if the number of sliding windows that pass the FDR threshold is smaller than min_passing_windows_frac (default value 0.03 at the time of writing) or larger than max_passing_windows_frac (default value of 0.2 at the time of writing), the threshold will be adjusted." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "colab_type": "code", + "id": "--8gp-i2-TOm", + "outputId": "b39814f5-cb17-4eb6-b4fc-11638426529a", + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MEMORY 0.435310592\n", + "On task task0\n", + "Computing windowed sums on original\n", + "Generating null dist\n", + "peak(mu)= -0.02237087196292123\n", + "Computing threshold\n", + "Thresholds from null dist were -1.0124836564064026 and 0.8997364044189453\n", + "Final raw thresholds are -1.0124836564064026 and 0.8997364044189453\n", + "Final transformed thresholds are -0.8494086021505376 and 0.8402150537634409\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Got 198 coords\n", + "After resolving overlaps, got 198 seqlets\n", + "Across all tasks, the weakest transformed threshold used was: 0.8401150537634409\n", + "MEMORY 0.43532288\n", + "198 identified in total\n", + "1 activity patterns with support >= 100 out of 2 possible patterns\n", + "Metacluster sizes: [195]\n", + "Idx to activities: {0: '1'}\n", + "MEMORY 0.43532288\n", + "On metacluster 0\n", + "Metacluster size 195\n", + "Relevant tasks: ('task0',)\n", + "Relevant signs: (1,)\n", + "TfModiscoSeqletsToPatternsFactory: seed=1234\n", + "(Round 1) num seqlets: 195\n", + "(Round 1) Computing coarse affmat\n", + "MEMORY 0.43532288\n", + "Beginning embedding computation\n", + "Computing embeddings\n", + "Finished embedding computation in 0.09 s\n", + "Starting affinity matrix computations\n", + "Normalization computed in 0.0 s\n", + "Cosine similarity mat computed in 0.01 s\n", + "Normalization computed in 0.0 s\n", + "Cosine similarity mat computed in 0.0 s\n", + "Finished affinity matrix computations in 0.01 s\n", + "(Round 1) Compute nearest neighbors from coarse affmat\n", + "MEMORY 0.455811072\n", + "Computed nearest neighbors in 0.01 s\n", + "MEMORY 0.455811072\n", + "(Round 1) Computing affinity matrix on nearest neighbors\n", + "MEMORY 0.455811072\n", + "Launching nearest neighbors affmat calculation job\n", + "MEMORY 0.455831552\n", + "Parallel runs completed\n", + "MEMORY 0.45723648\n", + "Job completed in: 0.55 s\n", + "MEMORY 0.45723648\n", + "Launching nearest neighbors affmat calculation job\n", + "MEMORY 0.45723648\n", + "Parallel runs completed\n", + "MEMORY 0.45723648\n", + "Job completed in: 0.55 s\n", + "MEMORY 0.45723648\n", + "(Round 1) Computed affinity matrix on nearest neighbors in 1.16 s\n", + "MEMORY 0.45723648\n", + "Filtered down to 191 of 195\n", + "(Round 1) Retained 191 rows out of 195 after filtering\n", + "MEMORY 0.457252864\n", + "(Round 1) Computing density adapted affmat\n", + "MEMORY 0.457252864\n", + "[t-SNE] Computing 31 nearest neighbors...\n", + "[t-SNE] Indexed 191 samples in 0.000s...\n", + "[t-SNE] Computed neighbors for 191 samples in 0.002s...\n", + "[t-SNE] Computed conditional probabilities for sample 191 / 191\n", + "[t-SNE] Mean sigma: 0.233285\n", + "(Round 1) Computing clustering\n", + "MEMORY 0.457252864\n", + "Beginning preprocessing + Leiden\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 0%| | 0/50 [00:00" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "metacluster_0\n", + "activity pattern: [1]\n", + "metacluster_0 pattern_0\n", + "total seqlets: 82\n", + "Task 0 hypothetical scores:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Task 0 actual importance scores:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "onehot, fwd and rev:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "metacluster_0 pattern_1\n", + "total seqlets: 75\n", + "Task 0 hypothetical scores:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Task 0 actual importance scores:\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIEAAACMCAYAAADr57kMAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3wc5Z348c8zs1VdslXcJDdsY8AQbDAlBELPXQjpCSQkIQmEy5Fyl4TLpSeEkHa5HPfLpVyOcskFuAuhmRKMKTYY4wLGvRe5yZasXrbNPL8/nt3VjnYlrRo29vf9es1LmtmZZ54daWdnvvM830dprRFCCCGEEEIIIYQQJzbrWFdACCGEEEIIIYQQQow9CQIJIYQQQgghhBBCnAQkCCSEEEIIIYQQQghxEpAgkBBCCCGEEEIIIcRJQIJAQgghhBBCCCGEECcBCQIJIYQQQgghhBBCnAR8x2rH48eP11OnTj1WuxdCCCGEEEIIIYQ44axZs6ZJa12Z67VjFgSaOnUqq1evPla7F0IIIYQQQgghhDjhKKX29veadAcTQgghhBBCCCGEOAlIEEgIIYQQQgghhBDiJCBBICGEEEIIIYQQQoiTgASBhBBCCCGEEEIIIU4CEgQSQgghhBBCCCGEOAlIEEgIIYQQQgghhBDiJCBBICGEEEIIIYQQQoiTgASBhBBCCCGEEEIIIU4CEgQSQgghhBBCCCGEOAlIEEgIIYQQQgghhBDiJCBBICGEEEIIIYQQQoiTgASBhBBCCCGEEEIIIU4CEgQSQgghhDiBOa6Dq91jXQ0hhBBCHAckCCSEEEIIcQIL3xHm96/9/lhXQwghhBDHAQkCCSGEEEKcoNqj7cTdODtbdh7rqgghhBDiOCBBICGEEEKIE9TWpq2en0IIIYQ4uUkQSAghhBDiBLW5aTMAW49KEEgIIYQQEgQSQgghhDhhrT+yHoD97fuPcU2EEEIIcTyQIJAQQgghxAlqzcE1AHTGOmmNtB7j2gghhBDiWMsrCKSUuloptVUptUMp9fUB1jtHKeUopT44elUUQgghhBDDkcoFpFBsadpyjGsjhBBCiGPNN9gKSikb+BVwBbAfWKWUekxrvSnHej8B/joWFRVCCCGEOKG1boTmVRBvB38JVCyAstOHXVzciXO46zAKhW3ZbGnawnmTzxvFCgshhBDirWbQIBBwLrBDa70LQCn1AHAtsKnPel8AHgLOGdUaCiGEEEKcqFwHDi6CDT+Eto2gLHATYPlAu1A6F077Fky6Bix7SEXvaN5B2B+mK9ZFwk2k8wMJIYQQ4uSVTxBoErAvY34/sDBzBaXUJOB9wKVIEEgIIYQQYnDxdnjuShP8SXR6X3Oj5mfzGnjlBhMMeuczECjNu/jNTZuxMnr+p/IDCSGEEOLklU9OIJVjme4z/0vgn7TWzoAFKXWzUmq1Ump1Y2NjvnUUQgghhDix9ByCp+ZDy9rsAFBfiU5oeQOeng/dB/PexabGTXTFu9LzMky8EEIIIfIJAu0HpmTMTwb6XoEsAB5QSu0BPgj8h1LqvX0L0lr/Tmu9QGu9oLKycphVFkIIIYR4C+vaC0+eBV17elv8DMaNmu2eOgs69+S1yZqDa3Ayns81djUSTeS5PyGEEEKckPIJAq0CTlFKTVNKBYCPAo9lrqC1nqa1nqq1ngr8Gfi81vqRUa+tEEIIIcRbmevA0vdD7CjoxNC21Qmz3bL35bX6xsaNnvkCfwE7mncMbZ9CCCGEOKEMGgTSWieAWzGjfm0G/ldrvVEpdYtS6paxrqAQQgghxAlj80+hfSsM3IO+f9qF9m2Dr6Y19W31nmVKKTY3bR7efoUQQghxQsgnMTRa6yeBJ/ss+00/635q5NUSQgghhDjBtKyDDbeD0zOycpzuQVfZ374fS3mf9XXFutjU2HdwVyGEEEKcTPLpDiaEEEIIIUZCa3j5I+BE3pTdbWnaQsAOeJY52pERwoQQQoiTnASBhBBCCCHG2oFF0L2f7AFWx8amxk1EEibgpDP22TdPUL9qakCpsZlqasbiLQshhBAiD3l1BxNCCCGEEMOkNay9bfCh4H2FMOFqCI6D6FE49DQkugbeph9rG9YSdcxIYAErQMyNAVDfVo+r3ayuYlkOHx7WfvMylmULIYQQYkASBBJCCCGEGEuNL0H3vv5f9xXCmT+CGZ8BNwGWz4wiZtmw82544xuDB5D6WHt4bfr38nA57dF2ehI9+G0/+9r2UVdWN9x3I4QQQoi3MOkOJoQQQggxljbeCYl+kjmHquCqVTDzZhMMCpQmf5aYnzNvMq+Hqoa0y10tu9K/TymZks4P5Lf8MkKYEEIIcRKTIJAQQgghxFiJNsPh58iZCyg4Hq5+DYpmgB3Kvb0dgqLp8K61EKzMa5ctPS30xHtHIJszfg6udgGIJCJsadoy1Hdxwvrzxj+zdO/SY10NIYQQ4k0jQSAhhBBCiLFy8Emw/LlfO/8PJhDUZxSvLHYAAhVwwR/z2uWWpi2E/WEAQr4QZ9acSU/CBIWiTpTXDr2Wd/VPdH/35N/xtWe+dqyrIYQQQrxpJAgkhBBCCDFW9vxP7nw+0z4JlW8HO5hfOXYQxl8A028cdNUtTVtwXAeAgB1g1rhZnuHi1x1el98+T3BxJ05zdzM7Wna8OTvUGpItsoQQQohjRRJDCyGEEEKMBScKR17IXu4rhgX/Dv6ioZXnL4L5d8G+hwZcbd3hdXTFzahiWmvqSuuoLqxmd+tuAHa27Bzafk9Q64+sx8WluaeZjmgHxcHi0d2B60DTyyYQuO8vpmsgLlhBqDgbpn8aJr8XQuNHd79CCCHEAKQlkBBCCCHEWDj8PKgcXb3mfAkGG6K9P8qC2V8ecJU1h9akf48kItSW1lJbWpteFnNiHO0+Orz9n0CW71ue/n3VwVWjW/iRZfBoLbzwbtj5e4g2AclWQG4Uml6B174Mj0yGNV8GJzK6+xdCCCH6IUEgIYQQQoixUP9nSHR4l1l+mPMVM/LXcPgKYM4/DrjKtqPbenenLMpCZcweNzu9LOQLSXJoYMnuJenfX65/eXQKdSKw+gvw/FXQc9D8/fvrApboMgGhHf8Ji06FZsnVJIQQYuxJEEgIIYQQYiw0LiVrVLDJ7xt+K6AUpfp9KZKI0NTdlJ6vKqxCKcUp407Bn0xQ7biODBMPvLLvFRTmWD6769mRF+hEYPFFsPO/wOkZfP30dt3Qtcdse2jxyOshhBBCDECCQEIIIYQQo82NQ+ee7OXTbgB/ycjKHmD7Hc07KPAXpOdT3cDqSusI+cww9F3xLtYfXj/wPqqrR1bHY1V2nhq7GmmJtKSDQK81vIbWepCtBuAm4MVroW3j0AJAmZxuWPa+4ddBCCGEyIMEgYQQQgghRlv7luyRv6wAVF82prvd3Oht4TOzYiZggkFWRgukzLxBOTU0JEezGmDqz2DbNTQM+/2NlhX7V6SDYgCudoefMFtrWHEjNL40/ABQSqJrZNsLIYQQg5AgkBBCCCHEaGt+PXtZ9SXgxsZ0txsbN6ZHBrOVzaxxswATBIo60fR6mXmDjmd3v343195/7aiXu6x+GR3R3nxNlrJ4Zd8rwyts9x9h38OmJY8QQghxnJMgkBBCCCHEaDv6KiQ6vcsmXgO+IQ4LP0RrDq7BTSYiDvvDTC2bCkB1UTUJN5Fer7mnmZ74CFutvAnuef0eFm1fRNyJj2q5S3YtQWfka+qMdfLC3heGXlCkEVb/PTiDtOApngVTP26GhZ9wlRkmXgghhDgGfMe6AkIIIYQQJ5ymFdnLqt4Olj2mu93YuDH9u63sdE4gS1mMC4/jcNdhAAr8BWw7uo0za84c0/qMhNaatYfX4mqXVQdXccGUC0alXMd10sdJKZXO3f3inheHXtjrt5kRvvoz9eMw73YIVYFOABZox4wSt/9RWPMliDYOfb9CCCHEMElLICGEEEKI0da9v88CBSWzc646Wlztsr+9d79xJ05daV16flLJJM/6x/sw8TtbdtIZM62p/rrjr6NW7oYjG/DbZqQ0v+0nYAUAqG+rpys2hJw8bVug/sHcXfwCFfDOv8I5v4aiqeArMAm9/UUQKDXzU94P12yDSdeMwrsSQggh8iNBICGEEEKI0RZv884XTjUtQMZQfVt9OrgBEHWiTCiekJ6fUT4j/XtXvMvTauh4tHhn73Dpj2x9ZNTKXbF/Ba5rusw5rkPQZ7pmhf1hVh9cnX9BW//VjALXl68IrngJqi42QZ/+2EEIlMGF98Pk9w7lLQghhBDDJkEgIYQQQojRFO/MDviUnwnu2AaBNjduxm/1BoHKQmX4rN6e/3PGz0kPie5qd2gBj2MgFfixlc3mxs3pVkEj9eyuZ+lOdKfLjicDOZFEhFf255kcOtFtEkLrhHe58sE7nzZBv76jw/XHVwgX/BEqL8rzHQghhBDDJ0EgIYQQQojRFDkMdsi7rGBy/kGBYdrctJmeRG+y50nF3u5fU8umUuAv6F2/z3DyxxPHdXip/qX0fNgfZunepaNS9vL9y9O/TyufhqXM5XDMifHMzmfyK2Tvg6ByXEaf9g0oPwt84aFVylcIF/0FfMVD204IIYQYIgkCCSGEEEKMpshhUH0SQIcnQjL3zFh57dBrxJze/DTTy6d7Xq8rrfO0DDrQcQBnjFsnDdfahrXYGcewM9bJU9ufGnG5zT3NNHU3peffVvM2Tze5NYfWoLXOtanX5p9nj/5WOBXm/pMJ6AyHrxDO+tHwthVCCCHyJEEgIYQQQojRFGkA+gQSCqflbjkyitYdXueZnz3em4i6trQWJ6ObWsAOsLdt75jWabie2fkMUad31C1XuyzavmjE5b66/1VCPtNKK2gHmT9xPmfVnJV+Pe7E2dO6Z+BCIkegc0f28rf9DJQ/e3m+fGGY/pnhby+EEELkIa+rEaXU1UqprUqpHUqpr+d4/WNKqXXJablS6vgdb1QIIYQQYizFWrPz/xRMyr3uKNrdurt3d/6CrJZAU0qn0BPv7S5mW/Zx2yXs4S0Pp1s1pfIYHeo4xOHOwyMqd1n9snRuoZAvxOlVp7Ng4gKCya56PsvHiv0rBi7kyFKw+nT3C46HSe8GewRBIAClRra9EEIIMYhBg0BKKRv4FfAuYC5wnVJqbp/VdgMXa63nAbcDvxvtigohhBBCvCXoBOB6lwXKx3SXTd1Nnq5gfstPbWmtZ52QL0RhoLerUiQRYXPT8RcE6on38MbhNwCTuFklAyMBO8Bzu58bUdlLdi3B1eZvE3NizK2cy9zKuenWQR2xDl7Y+8LAhRx8ChLt3mXTPz06o7/1zSUlhBBCjDLf4KtwLrBDa70LQCn1AHAtsCm1gtZ6ecb6K4DJo1lJIYQQQoi3DDcBffPKWPlccg3fhiMb8Fm+dCAo5sSob6vnrzv+6lmvOFBMe7Q9vc5L9S/x1Qu+OqZ1G6rl+5YT8oWIOTEK/AXp99QR6+CxrY9x3RnXDatcV7usO9LbZU6jmVQ8CUtZnq5nL+x5YeCCGhZnL5v1+eHnAhJCCCHeRPlckUwC9mXM7wcWDrD+Z4CRZ+4TQgghhHgr0g5ZOYH6JooeyF9qTHLpAVlwfW/Lk3tev4fueHd6vifRw9cWfy3dlSqlK9blmX96x9P51+tN8tSOp9JdtqJOlNOrTue1Q68B8MyuZ9Bap1sHDcXmxs2exNjTyqahlGJC0QTPcdrdspueeA9hf44RvmKtyZxPGUJVEKoecn2EEEKIYyGfnEC5vmVzDpuglHonJgj0T/28frNSarVSanVjY2P+tRRCCCGEeKtQdnYS6KF0FRo0AAR9u5u93vB61hrt0Xbaom2eKaETnnWiThTXdbO2PZYe3/Z4ustWcaCYS6ddmh7GPZKIsKM5R1LmPLyy/5V0uQDzqucBoJTy5E8K+8PpoFOWzt1g9wkOVV0CGV3xhBBCiONZPkGg/cCUjPnJwMG+Kyml5gG/B67VWh/NVZDW+nda6wVa6wWVlZXDqa8QQgghxPEtV9cvN5G9bBQNOqLVAI6nvEAtPS2e93JmzZksnLSQQn+yq5WGZ3c9O6yyn9v9XLq1VMAOcM7Ec9KvZY4QFklEWL5vedb2AHTlGE2t5grwFw2rTkIIIcSbLZ8g0CrgFKXUNKVUAPgo8FjmCkqpWuAvwA1a622jX00hhBBCiLcI5SPrEivWPKa7THWfGo7hBlXGwvN7nu8dqUv5uLjuYs6ecHZ6aPvuRDePbH1kWGUvq1+W/j3sC3Na1Wnp+cwRwmJOrP9j0rUXMvIHAVA+L7vllxBCCHGcGjQnkNY6oZS6FfgrYAN3a603KqVuSb7+G+A7wDjgP5J9tBNa6wVjV20hhBBCiONUoDw7B1D3/jHbXVN3Ezp3T/28rDywchRrMzKLti2iI9YBQEGggHMmnsO0smmedV6qfwnHdbCt/PMstUZaPcPLp0YGS0mNEJZKEL3y4MrcuYc6toPbJwhUMAUhhBDirSKvxxZa6ye11rO01jO01nckl/0mGQBCa/1ZrXW51vqs5CQBICGEEEKcnEI10Dd40LkH9Njk3lmya8mItl/bsHaUajJymYmqo4ko8yfORynlCdjYys6ZA2kgKw+s9CR6drXLlJLe4M1plaelRyED0yVsf3uOwF3Xnj4LFATHD6kuQgghxLEkbVeFEEIIIUZTuDo7EXTkUHY3olHy8r6XR7R9fVv9KNVkZOrb6mmJtKTnC/wFVBVWAfCO2nekR/CKOlGe2fnMkMp+uf5lz8hoU8umelr5TCye6GlN5bf8vLL/leyCnIh3XoaFF0II8RYjQSAhhBBCiNEUqs4OFnTvA3dsRpDqdySrPHXFuwZf6U2wZNcS7IxudJnJmhdOXkhxoBgwXbke3vLwkMpevGtxOq8Q9I4MlqKU8nQ764x1snTv0uyC+v4NLf/QRn4TQgghjrFBcwIJIYQQQogh8BWanECZw7G3vJF71LBRsLVp64i212gOdx6muqh6lGo0PI9sfSQdkLKVzcV1F6dfmz9hvmd4+3WH19ET7/F08eqPq11P9zGf8lFXWpd13KaXT0+PlKbR/bQ26tPNT+vsZQP5Sw1EDg+ykgXXS2BJCCHE2JAgkBBCCCHEaAuUeW/2u/YwpGDBEGR2oRquZ3c/y8fO+Ngo1GZ4tNY8v/v59HxhoJBzJvUO4T69fDpa93bXCvlCvLzvZS6ffvmgZS/euZhIordlVkIn+NWqX/HbNb/1rJeZEwhge/N22iPtlIRKehdaAW/hbjQ7CfhABg0AAYxN7ighhBACpDuYEEIIIcToK5icvax9y6jvJpaIebo5Ddfy+uWjUJvh23BkgycnTzQR5ewJZ6fn+yaH7ox1epJID+T/Nv1f1rKeRA8dsQ7PFM2Rs+l/N/2vd4G/yDvv9ICO51UPIYQQ4nggQSAhhBBCiNE2/nyyWv40LgM3kXN1j1D+3bK2Hd2WTpicolAE7WC/ky9Ht7SGzoa89zkWFu9aTNzpDaaE/WFqimo861xUd1H6vbra5bGtj+VV9vN7nh98pX4s2rbIu6B4ZvZKPfm07hFCCCGOD9IdTAghhBBitI1bCL57IdHZu2z/4zDtUxAoHXjb9+cIyPwpd1eyPW17KA4W0x5tTy/70Gkf4sEPPthv8Uv3LuU997+HtmhbellHrGPgOo2x+9be52mJU1VYxd2v3+1ZpyfeQ9AOEkkm3d7VsiuvXEYjGf1s+b4+LaSKZoAdNi2AUrrroWjqsPchhBBCvJkkCCSEEEIIMdrK35a97MiLo54celPjJnrivQEJhWLOuDkDblNXWkfc9XZhSiVEPhY6Y52sO7LOs2x3y26++NQXPctc7aYDQACOdvj58p/zsyt/1m/ZB9sPksin9VU/mrqbvAsK60xeoMwg0NGVMP6CMUv8LYQQQowm6Q4mhBBCCDHaSmabpMGZdAIOPTuqu3nt0GuegE6Bv4CpZVMH3GZi8URPomQw3cFGEiwZifvW3pe1LO7G6Yp3eaaeRE/Weo9seWTAsu/fcP+I6qbRrDm4pndBYR3oPombG56FRNeI9iOEEEK8WSQIJIQQQggxgBsfvZHKn1XSGescfOUUyweF07OX7/lviLdnLx+m9YfXe+Z9lo+6sroBt/HbfspCZZ5lITvErpZdo1avofjThj8Ne9tdrQPX+YntTwy77JQHNjzQO1M4FRxvAI3Gl00XMSGEEOItQIJAQgghhBD9WHVgFfeuvZem7qas7kmDqr6YrEut/Y/llxw6D1pr9rTt8SxLuAlqS2sH3XZi0UTPvGVZbGka/dHL8uFpaTNErnZ5qf6l/ss+NPyyUxbvWtw74yuAklO8KyQ6oW1DfoUNIem3EEIIMRYkCCSEEEIIkUNPvIcP/t8HAbCUxYMbH2TxzsWDbJVhygfB12dIcZ2ATT8Zle5DR7qO4Lje4eEjiQhTSqYMuu208mme+e54N5saN424TkO1v31/zqHZh+L3r/0+53KtNV2x7ONc5C/qdyrwF+Sso8fEvwVs77Itv8ivhdf7G+B63TsJIYQQbzIJAgkhhBBC5HDb4tto7GoETMLl7ng31z10HW2RtkG2TKq6GHQ8e/n2X4F2spcP0eamzYR8Ic+ywkAhQV9w0G1nj5/tmU+4iRG1yBmu36353YjLeGrHUzmX72zZmXUsZlbMpOMbHf1Onf/cSdD2btMebSfmxHoX1FwO/kLvzur/DOQewU0IIYQ4nkgQSAghhBCij2V7l/Ffr/8XPYkeCnwFWMpcMnXGOvncos/lV4gdgOrLspcnumDl57zDxw/DlqYt3uAE2d28+jOjfAZhnzePzYbGPLs0jaLHtj6WtSzsC1McKO536utI1xHcvsmagVf2vZL+u6WcUXXGgPVRSmXlVAr5QrzR8EbvgsoLoW+SajcKO34Die4ByxdCCCGONRnLUgghhBAiQ2eskw//34fTo1GF/CFunnczv1n9GyJOhMe3Pc5jWx/jPbPfM3hhU683Q8MnOrzL9z4AdR+FCVeBHcq97SDWNqzNGjFrsKTQKbWltfhtv2f7Pa170Fqj1JvXoqXvEOx+y88vrvwFFQUV/W5z2+Lb2Nu2Nz0f9oXZcGQD86rnedZ7Yc8LnmTePsvHuZPOHbROZ1afybaj29LzcTfOiv0rOGfSOcmCCqHqIjj8nHfD9bfDjM8C2V3KhBBCiOOFBIGEEEII8ZamNTQ2QksLxOOQSJhlfr+ZysqgqgryjW186akv0RptBaDQX8gPLvkB151xHb977XfgmPw5n3zkk+z4wg7GFYwbuLCJ7wI3lvu1FTfC1a9BeALYA3Th6idnztqGtVnL5oyfM3B9kupK69A6OydNQ2cDE4on5FXGSDV0NmQFgcL+MJ9b8LkBA1HL6pfxq5W/QmPq72qXxTsXZwWBXtz7ome+wF/AaZWnDVqvcyaewyNbHiHumq58kUSExbsW84WFX+hd6dSvwtFV3uBeogNevRnOvyc7F5QQQghxnJAgkBBCCCHeEmIxePVVWL4cNm2Cbdugvt4EgCzLBHyU8gZ7tO4NDFVVwZQpcMop8OtfQ1GO+/TFOxfzwMYHiCTMMOBhf5ib5t9EwA7wpYVf4pcrfklPoofueDc3Pnojj12X3Z3JI1BmWvsceBzoE3SJtcDT8+HSZ6FkDvhyDDOe6IGO7TmL3t7sXR60g8wonzFwfZJqS2uzWhEF7SCbmza/aUGgJbuW4Lf9nsTQZ1SdMWhLpPMnn899a++jI2YCMFEnysNbHuYrF3wlvU5XrIv6tnrPdo7rMLdy7qD1mls5l7A/TDzam89pxf4V3pVqrjSBu74tvPb9GSrfDjM+A/5RCgRFm6F1PbRvgchh6N4H3Qcg0gDRo+B0g3Z780wpG5QFdiEEx0G4BgomQ3iy+b1kDpSdYf43hRBCnHQkCCSEEEKI41ZPDzz6KPzXf8GyZRAMmmWOA2eeCVdcAVOnwqmnwowZUFoKvuTVTSIB7e2wa5cJGu3ZA+vXw5/+BH/4Q/a+2iJtXPfQdXTHTV6XQn8hd1x6BwE7AMBtF97GXa/eBUDMibFk9xIe3PAgHzn9IwO/iblfh4Yl4OQYESzWDIsvgNO/DbNuNVErZZmbeqVg269hw/ezNut0TcLiTEFfMO/uYMXBYgJ2gETGcPVRJ8qWpi1cOu3SvMoYqUe3PurprmVhcXHdxYNuN3/C/KxWTKsPribmxNJ/q9UHV2cFcmJOjKllUwct/7Sq0zzHBcyxPtx5mOqi5BDvlg2zvgibfgROxFvAa/9ggi2T3m26jg3Hvkdgzx/hyDKIt4IdNkGc8jOg5FSY/F4TzPEXgRUA5Qcr+Y/vxs2k4xDvgLZN0LwG2jbCKbdAqHJ4dRJCCHFCkCCQECeoWMzc9GzZYqa9e+HIETO1tpobKNcF2zZPz22792l5ankwCBUV5ul5TY25wZozB+bONTddb2LaCCHESWjpUrjuOhPI6UzGCubOhdtug3e/25yrlIKCAnPO6s/8+eac191tYiz9rXv5f19OS09Lel5rzZamLXz1ma+ml82rnsfKAytxtEN3vJsbHr6B06pO4/Sq0/uvwPjzoGg6tK3P/boTgTe+Cet/ADWXQmCcCQ41LDEJh3PYGjPdm/oGgmpLa/uvRx9VhVXsad2Tno8kIjm7mI0FrTVLdi3xLCsKFuWVs+eUcaeku2qlBH1BVuxfwTvq3gHA8n3L6Yl7WzpNKZ2CbQ3wj5JUW1qbFQRKlX/tnGszKnILbPpxjhI0LL8e5nwVzvguWEETNOorPkBi8Fdu6E0cXvthOOsnJnjjOiawNND7yMwxFaqG4pkw8W9MENJf2v92QgghTgoSBBotsVbo2AFdu03T3FiLabIbOQyRJvNFrhPmyR462VTXNl/UwfHmSzpUBYEKMxXWQvEpZrncaYs8HT4M994Ld98Nu3dDKATl5fDOd8LChTBvngneVFX1BoFc19wUaW3+1SzLTLZtAkIHD8KOHbBqFXz606Y8IYQYaw88YM45PRn38d/6FvzzP5tzmzXE8U1tG4qzB5bqLXvJt1h9aLVnWXeim39d8a8Dlht347zjnnfQ9LUmrP4qpRS87Sfw0ofMyGD9caNwMPdw531tjpE1IlYkERlSEFtYi+YAACAASURBVKi2tNYTBAJ4/dDreW8/EtuObiPSpwVNzIkxf+L8Qbe1lMXscbNZd2Rdell3vJu/7vhrOgi0eNfirEDRvCpvzqCByq8rrfN0t+uMdrKsfpk3CBSqhNO/BRt+aLpkZdIubP6p6QZ46ldhygdMSx3tmpY7retg+6/7r0QqAFR5EVzwP72tfIbL8oElASAhhBASBBq+nsNmZI/6/4O2DWZI0PBEqLzANNMtmQ0TrjR9sO1C8+Wb6qONMv22U5MThZ5D0LkLOraZ5sMB+aIWQ/Pcc3DNNSaYk7ppuuMOuPVWE8wpLPTeNPn9g5cZCMDMmWa6/PLeLhZjTmvzmejYaoKrnXtMQDV6JJn/IJJMtKpNE3hlA655QqodUD7zlNRfAsFKE2ANTzBP4otnQunc4TfRF0K8Kf7hH7wBoAUL4OtfN61+Rtv2o9v50Us/Gvb2LZEWPvv4Z7n72rv7X2nC1eYc1LqBrNxAw7AhavLeZFIoykP5R+pnjZvF0r1LPct2tuwccd3ysXjX4qwuXX7Lz6TiSXlt//bat3uCQAk3waNbH+WOy+5Aa82aQ2s86/uUr3d0rzycUX2GJwjk4ma1XAJgzj/Cjt9C197s1wDaN8Orn4GVN0FBrQkARQ5DvC2/inRsha56E3DyDxDFBPhLjSl7QBZc7+S3byGEECckCQINx9b/B69/zQR0nG5zw3nh/SZ440STzXQHObTKApJ34b5CCFZA2WmmWcZQH28KATzzjAn2xDIGofn4x83T73COXKNDNZQAkKtd9rXvY0rJFCyV5/+zE4H9j8GO/4SjK8BNmM9G9SUwbqHpIlE4DcLV5iI61bJOa9I3VEoBlvl8Kb+5yO45YJKq1lwx+AX0W53WvXkg3IwJDZbfTMqf8buca8Txq6ICGhp651taxq5h7If/78PpkaZSAlZgwK5DfZMq37v2Xr5/yfeZUjol9wZKwYUPwtMLsluNDMOaKFl1riysHNLw7rMqZuG3/J4WMx2xDtqj7ZQES0Zcx4E8suWRrGN4etXpedf//Cnn89/r/tuTU2h783bao+0c7T5K3PG2AioI5DcyWMo5E8/h8a2Pe47NpqZNJNwEvsxrPDsIFz4ASy4FpydHSUnaha49ee+f4lOge79JDP74TJj8Hqi7Dsafbx5qOJFkIujUd57KM7boDr6KEEKIE9qJGwSqqTF9Y8bCd4CZQOraMFAOtR80LRPyacEz6JOaMX5KM5bHBqC62nvl/maItZiWVKmueKkp0gjx9mTAwMHTFc9XaLrbBcozpmRXvFDNgHcbjuvwRsMbbG7azBUzrqCqsOrNe6/9+P73TRDod78zVe/uNnkw/v7v4VOfgsrK3qfq4bBp5TOY7m4TVErlBxpom7gTZ+nepdy/4X7ue+O+dD6FT535Ka474zoumXpJOmFnFicGT84zrX9STeDHLYRLnwE02EU58h/k0ZQpWJEMsJ4x+Loj9WZ8rg7uN4k92zZC+zYT3OrcBT0HAQvClRCuNcEuOwAqALbfvObGeqd4J/Tsg8gREyR612umW6oQx5E//AEuvdSct2Ix2LkT3vUu+POfTXewgbp2DcWDGx5k69GtnmUTiyay8qaVAwaB/mPlf/DzV36eDmRYyuKjD32Ul258qf9ARumpMO92WPed3Emih2BLwqLvDX1tSf5dwQDqyuoI+ULEY72BjgJ/AVubtg6p1cxQOa7D8n3LPcssrHRXrnzMnzA/K+gR8oV4cc+LdMY6vYGa5D5Pq8o/CHR61elZiaWDdpD1h9fztglv8648/jx428/NA8JRCPAB8O6t0F0PjS9D43I4uhJW/R3E29GWH7doJk7RTFy7EJ+vAMsOoaZ9AoU23QpT5/s9f/LmlQpVj079hBBiKFwHok2mVX+sBWJtJul9rM1c+6fuz1KpU1I/URkPeZPfrW7MpFTxl5pRDlM/g5XmHGcHj937fIs4cYNAY+kXwA1heGfA/IMmuuGxmTDzFphyLRROTT6BjwFW8uY19aRm8ISE8pRmEE4MDj1t+tk3vQqdOwEN5Webbj4FU6BkFlTMNzfDKpDsC+8HlLelRKLHPJnr2A6Nr8C875ugQR+udll3eB3P736ex7Y+xgt7X/C8Xhos5YNzP8jVM6/m4rqLqSx880feCAbh5z+HH/0IXnwRVq6EZS8m+M/far73PZuSYpg122HGdM3UqYoJExSBgCIYhFBY4fNBNALRqCYShUiPpn6vZs9uzY6dFtt2WEQi3pYjR7uP8tDmh3hkyyM8v+f59JDKADPLZ7KjZQf3vnEv975xLyFfiIvrLua9c97LB079gPcY6QT0NCQ/M6k3NM5050r0DJwAE078JvATgPe3w0Pjki2fMIGtGZ+BmjvNU+H0OUf1djtNf2mSTPzU54vV8icTlspXwcmqvq2el+pf4pmdz3DfG/cBcNPZN3H59Mu5cMqFTCrJr2vOWDj7bJOP7Kab4KmnTCPZpUth+nT4wAfgE5+A884zDWgTCROszpUg2nVNQDuRMC0abdsMM3/JJdDQ2cDNi272tEgp9Bfyi6t+Meh7//pFX+eulXelt3W0eTjw69W/5vPnfL7/Ded82XQlb17VO6T3UCibRPnZNOx8nb7XCzMrZg6pqNrS2qzWmq522dy0eUyDQGsOrckK0hQFi1g4aWHeZcwaNysr509HtIMntj+B1jo9fHxKzIkxrWxa3uXPrZyL43r/Pgk3wSv7X8kOAgHM+rz5HtvyLyMPBKXyQRbW4Yan8JxTxctdlbze+jorD75KV3cDVfaG5AQFlnku6VdQWVBJXfkMJpfWcWrNAmZe9rzpShaqAl+x5JkUQrx5El2w6vPQtAI6d5v74NK5sOAukzolOD7ZSt8ywerUA3udo1lj6tyl7GRrdtvcI9jhwe8TRmIsH/Iei4YTSapvf+ycKyl1NfBvmO+Y32utf9zndZV8/W+AbuBTWuvXBipzwYIFevXq1QOtMvb6+yLM45gAJqLZ+ga0vAEta6F1vXkqH+8wQ3YWTDb5R/xl5qm8FTRdx1TqqXwyELHjN94mxKFqeH/yH0K7piVLotMEm5zu3p9uAnN3l6yzSnWNUcmbvmTEVGECqXYA7ALwFfT+9JeY33Mdi1zL8j02Wptob+SI+RlvT76PdtNlzo33HgutQfX9wKduZDHvU2kTzGnbBLvvM3Vzesw6835oRuhIBdjsgqHf1KaCef4is0vtsnL/Sm589Ea2NW/LSr6Zj+JAMR8+7cPcedmdvQGP733PNNkZCwq48xNweYUJknXvMwur34ke/3barXkc7ZlEc9d4jraXcLQlSFu7heNaOAnXjAjms7AtF79PU1HhMq60m3HFrVQUNjEuuIvw7A/QGm1n0bZF3PDwDSOu8r3X3ss1s6+hIlxhWgFt+w/Ydbf5n0klTa/9sOnKVXqqmXcT2aPlPD7bPFkYzPUjz8MxIsM95zxxGrRtJv3Yu3gWXLPVnING64tP62T+pR2mZVGksTdvhZsw+/YVgq8o+dlMPZFJnmDS70GbbgrxDnOes3zE3RCH2qfTHJlIS2QCLZEauphKXBeaHmyuGZnOtr29YTMPS+ahc12T2NzvN+srZX4Ph03i8vJy05Wopsa0GBlLCTfBvrZ97Gndw7rD61h9cDXnTT6P06pOY1rZNCaVTMq62T1WYokYD21+iCe2PcG6I+vYenQrMSc24DZhX5jZ42czr3oe186+lvfMfs+Q30/cibPm0BoWbVvEmdVncsnUS4YcKN+/H/73f83Q7uvXm7+r1hCNwsSJUFdnkt5PmwbjxplWi5YFkQg0N5tE+Xv3miHiDxwwr7e3a674wxUs3bvUE0yYWjaVnV/cmVdX1l+u+CXfeu5bdMV7W/UU+AtYd8s6ZlTM6H/D7gPw14XmO1LH+1+vL+WHUCVbz/kTC/773XRmjC5lK5sfvPMHfOOib+Rd3KGOQ8y4a4YnCKZQfOWCr/CzK36WR32Gd067/cXbuX3p7Z7jHvaF2XLrliEltp7363msP+IdcW1KyRTC/jDbjm7zLJ9WNo1dX9qVd9mudgn9MJQVaHr/nPfz0Eceyr2R1rD6Vth179ADQVYQ/KU0v+NpVrQeYvm+5Ty761lePfDq0MrJ4bKpl3P59MtYOHkh5046l8KA5MQTQuSnJ97D9ubtbDu6jed2P8fGIxu5eubVnFVzFrPHz6autK7/VrM9h+DhieZ3X5G5nqy5DC5ZZJY50eQ1vUrm80ymKkh9/47gIa/W5loxFjPXmJkD4WidfY2ZOVmWuU4IBMCe9NYNAiml1mitF+R8bbAgkFLKBrYBVwD7gVXAdVrrTRnr/A3wBUwQaCHwb1rrAR/nvNlBINd1efXAq6w8sJKle5fy7K5n2XpHOzV9WmM3FMKlPzmVd059J+dPOZ+Lai+irqwuu8B8buZ9QGFyCgDJ+yYU5uGdCySAruSUuq9d8h5oeKy3nMA4ExTKdeGdTjCdkRclLRlIsbzdZp591lwMd3aaKRYzF9Fa995QKQWfvSn74u6B+80+Mj9IjmM+XFpDtfUyVwavJaDacLFxdADrjG/gO/0fTf0sH8p1zEWvdpItEgaS+kQmTwxPzTeJuFPvtaAW3ru3d2irwQxyMvlzB/w2fDnL9y+nO559AaeSQbdcTf211ln5GVJqS2u5asZVfPfi7+b3ZH04AbiNd8Ib38D8kyWP67X1UDhlVIIFy/Yu47bFt7Hy4Mp0UEyhsC2bScWTuGzaZZxaeWrOG6fUMMtLdi9hX/s+HNdJHyuFYv7E+fzksp9w6fRLzQaRRhNgbd9qAn/t28xwybFWsEIQLE+Orhc0+YGsgPl/cuPmC0XHoekV08IoJVhluj05EfOF40TMPzKp/8PkUGmpoGn6T9AnOEnG65pk1MLqTfyuLHMxbwdNICtQ3puEerhBoF33wdp/MsFgJ3mimHe7aQnkK+gNqvrC2a0N130PNgwWeLTMk5RU66DiWXDePVA0zZTrRno/q6kAUPr9pN6T7j0PpZvwQkeXn5IK7w3HF74Ad92VuyaJRO/hyBUEUirP/FSuk+wGmki2/nPwBKpynS9TP1Pvy/LhaItD3Y3sbt3Hnra93PbsbTR0Dv8Lu660jh9e+kOmlU1jatlUJhRPyD9v1hBprXlu93Ms3buUp3c+zaoDq/o9R+XLVjbnTT4v3erxorqLstbpjnezYv8KXtjzAou2LeL1huzRpkqDpbxn9nu4csaVvKPuHblv/J0ItKyDltdNct2uenAiRHQNr+8+ld2HJ7O7oZoteyeyvX48+w4V0tHlw3EsHAdAYdsa23YpKkgwZUI3p9Q2MafuANNqjtB9ZRf/sPhLngBOob+Q+957Hx+Y+4G8jkckEWHiv0ykJdI7rLylLM6qPotVN68a+G8baYRnL4GuXea9DsYKmc/k5S/w6J5X+MQjn/AMD18UKOI3f/sbPjbvY3nVHUygI/jDYNZw6JdOvZQln8yRBLmvYZ7T5v9uPq8d8j4rLAoU0f719iHlNPr8E5/n16u9I2wFrAAubtZ7umbWNTx23WMMxcy7ZmYlyq4prOHQVw8NvOG+h2HFjebhUj5BPrsAJl0D5/6Wby+9i1+s+Blxx8HVGtd1sd0wVbELmOZewYzQeZSHi6kYB2VlEAyYr3c7ObVEm1jf+jKrWv7K9s7XSLhxVPLiU2kfd19zDx+b//4hHQchxLFz+DAsXgxtbdDRYX6Wlpou0anRfMH8DAR6r5FS93PgDXq4rrn3S11vuS7EEy5HE/VsOLyZ50NfoJ39JEgOwJInhaIoUMTFUy/m6xd+ndnjZzO+YDzUVINzBOqACqAMqPDDhBqYOAnKK6G4FEKlECxJ9t6wzPXnjp+A09nvPg+3VVHzee993Q9/CN/8Zt7VHrbMe+BwQe7vrZbm5L1OnyCTbZuHlz7f2DbOHGkQ6Hzge1rrq5Lz/wygtb4zY53fAi9ore9Pzm8FLtFa9/stOdZBoEgiwuqDq1m2dxk/Xf5TWiOtIyrvqhlX8ZHTPsKFtRdySsUp+V2kDPeGb+XnYdc9yZstF1QQ/mZtspuSCexoSN50+kEpVPJCU6/7LmrDDwau1se8+//wh+HBB3Os2Lf5Wz7Ryobn4LkrTL19RaaOZ/7INJOG5Ghokf4DQBt/DJt/MvA+SAa2rIBpZlh9iRmdo/qd5mU3Zo6dHc4KgA0WBPr187C0xbustg0+ugHOasiICwygyw9PzIInToFYxv240nDnrE9Q+43v0hbrYvWRzfx521Ps72zgaE8r+9r3cbDjIBrNoZ/hCVA2FMKEr8GEognUltYyLjyOySWTee+c93Le5PMoC5WhWtfDmi+YLnJ20BzfSdfCrL8zXeMgGUDQyWCFD0/XoQ23w8Yf9vu+XuyGP65XsLv3/6c8Ap9+HeY05XFgkrZXwN1vg6Y+I/z8c/sZTH9xfe6NclGYQGuyxxMaE/vSmOBqX//TZ37OV+Dsn+e/v9EwktaHWpucEA1LzM/2LeZ/OVAKpfOgsM60Piyablr4WYHk5yR5kDKTRT9/Ve59+EvM53PcQrgiOWJQLHnuVLYps28/60E+UwnH5lN/uY0d8U/Q3Oij6ahmXHmAj3+gnOICHzXVfkqLLYoKLQoLFaGQxkr2orWST2NcF1ydjOtoiEQUXV3Q3e3ib3uVy/73AvjL4IdwOM65CVb3E7f1WT5CvhB+y4/f9mMrG4VCo3Fch7gbJ+7EiSQiJHSuf0r407pZXPeXbTlfGykNnH6roiWg0Rk5Y+cdhuvXw9U7oGKQ2MORAnjyFPjTGbAlmTZKAZY258ZXFlXTsnszL+97mS899SV2tebf0iKXX171S66ccSVzxs9BPT3fBICUbb4z7BB8JNliRbtmWXrUzSHQLgknRsXPqoi7cfzJ7wlXu0wsnsjWW7cOKRDxq5W/4rZnb8POCMB2xjp58IMP8qHTPjTwxokueOFvoXlNbz60XHxFUP42uORJ8Bdx57I7+c7z3/H8X5UGS1l0/SLeXvv2vOsOUP3zao50eVtSTiyeyIF/PDD4xsM4p3XHuym9szTrM3He5PN45TOvDL7PDH944w/c8sQtnoc2ATuArWxP6yZb2Xz34u/y7Yu/PaTy3/fA+3hk6yOeZQE7wN4vHqBQjScaNTdTqRsqx+mdVKyRyQf/jpLORWgVwHa93dNcAqBsEr4qDtT8G+0l12LbcPXVprWabZtyystNazZIngvd4Y/UmeoSKU48rgubN0NTk2kB2dNj/t6ZuRxTN/ypB76DyQwcZN7ARqO9rW9DIXO7MGvW2LyvsZZ6j6nPVq6HUH1lHrt06+WaGvzNY9Na5IdF3+DbnXd4luXbMSMfk38xmQMdeZzvh6nrrhIKmtsHX3EYGuwSThn3DIlgEQlHk0i4fOBvy7nt1vEm2GIplFIoFMpSWMr7nFcplR6lMtWeoLelkOYvD1nc/gPvSXPPHtP62CNXl7Fj2NUrZaRBoA8CV2utP5ucvwFYqLW+NWOdRcCPtdYvJeeXAP+kte43yjOWQaDNu95g7r3ngJ3x9EUrQr4gZ1UuYOGktzN33BkE+kka1dzTxNojq1l+8EV2t+3M6go0qftvOFDw5KD16HsjD7038wP50VNT+OdX9/UuUJgcuAEgmPEz1aoodRMM4Et2r3J078PurwIZCTTVFh90VUKsKDkV49OFFNqlFAdKCVtFBO0wQV+AgM+PQmEpC4WFpSw0Gle7aMwUTzhE4jGibjft0TaqHn878xvjjBvfTHFJO6dfEmTuRQXYqhufL0og6ODzOVh+P5btRynd2+AHjUahtfkUutqi4uhPsbQ5kN/ZOI/bn7+BilAXl0zaydnjD/De01uYFG6giKPY4UqcwpnooumoglrTCsMOouxkywwscCNoJwZOBHvdN1EDRJixAvDRaPbyYX7Y1ffHvi9+QMH8IMzww1Q/1Plgkg8mF46nqqiGooJq7FAVlr8Uy7JRyoeyfFjKxnUTaJ3A1Ql8u+5BZXRT3NNYx/JtF6a7zCk0VRf/I+HxySf42ry3Cy7OPX7z8qUZXR5znHfe950nObIqmRRUmxPzvu3lBPzKE32rrMzdoulok5NVdOZe/udTNl/ehPks+YHCIEyqhXDIXMUE/RDwg+0zU+YVT/V2qNpOf57cNZef/ulXFAa7CAd6CPkjfPs7NrPnBDH/3MnPY10/rQvqMyMYqTfrpr+RLvlyiEv+spLvkaNFj415qjIOKEjO25gAWep3BTiY4JgDfAbTQjFp/81h4lYVvpkJrGoXu9IhUK3wTyjHP2Eidvk4rMJiVKgcFaxIdm81rfPUG98w3TwHoPo/dF4a83+kLe+k3D6TTh+mipYZfGnGTjI6xzJt8qVMnXgRNhpbgY3GSrbjMzf3qVZoMOHoC0xoXppVlZQfPPwNEg/ZfLfodnOMi0AVmsZeFAehchyUF0NJMYSLwOcH20o+nkteaScccF2066ITCejpNI/zWjo4b8nThMNHKQm3UxzuoKKog//3H8m+7qlWVa4Ds27OXcGd9+K5pEkFRwCUD+fcL2M35zkU9RA9PHsG/3D9Pvbq7C5lFcFSZldMY0ZpLSXBIjwfYkw3uvr2g2xt2U19x8Hkd0qvsmAxN1ZPYnbPFs4Pm/NYkaVwZ94M489HFU1DhWtQ/hKUrxDsMMryJS/mXFj3fdTG2wes/zNPWbS87v1+P28/1A3xcCUsE/SP9Lm5/uhG73nu+uvhf/oGo8F8zg8vgQ13mJERlb83wKXjUHEunP5N0y02efdxxb+/i2cbl4Dbu1Of32Hnl7cPqTsVwILfLWDDkQ3pVksazXldVbwQrO8tGwj4wpQESykJllAcLKY4WMzzn3ohZ5ln/+ZtdEQ7aI+10x5tJ+EkPEGfc9t9dES8QaBvLoOPDeE5AMChIrj2OujMeN7TGYB9JQrc3oXKdnj2k89w6bRLh1T+b1b/hlufvNXT1SG2+np49B7PegNeSsc74eCTJkFz117QMZPEdMJVprtz6ame1Z95Bh56CJYvh/p6k8/qlltg4ULT5bGmBoqKoLDQ3ISngjqpm1gwp5/UzWkiYQICXV3mtPOOf5lAw4QGprbA9BYY1wW17bDgIJx9CCYMcEkE0BGAddWwZgJsrIL2IOwph53lEEkdcq2gexzECyguVpw5bQq1pbVUF1RTHi6nLFxG2Nc7bKnWmq54Fy09LbREWjjUcYi9bXs51HkIW9m0RdtojbRSV1rHE9/sxNc9jg6K6aSITlWMU1qBW1yKLirBCReigyGsoB/ls0EptMo4IMk7POWa87IbS6CjMexIF08dPJMftX6OqkCjudYOYK4XfEA4CIUhCAfMtYI/2efUymhukeJmNJVPxCEah54YPzl4Bf/En73lVo6HokIIBc0U8JnvkcwmAn3Lz2yKn0hAPM6RjiKqF73sWe3RR+E97xn475mvH97/DN/elnyAFCsA10dRoU1N6TgqQhXm7xoqo9BfSEGgAL/lx9EOPfEeuuJdtEfaaY4009LTQlN3E93xbmzLTrdm/FrkM+zcVIXP9WO7fpS2ueqm6xlfWkrYLsJWA0cvtdbEdYwep5Oo04PGJaHjRJ0eom4Ph+64jO+t6BiwjOFq8hdSFozg6xybvJNrrofpl5TR3FlBR08xHZFius55ioQqwnF6u8i7rgkep3Mnu8mgRtNqVPOrgIvCBe3iJhJoJ4qPLuq23kX3K90UZXyVF0dhWqt54JOvqA3bx5nvRDBXJo2FcPV1IbRv8Nau/T0AH0gA6HsFojQUxKEoCkXJn4VxCCcgkABXQdQHPX7zfdGZ/NkRhFiff7M5+85hy4vfM4W6Nmibr39uOuefXWqeRdumdbylFJaV7C2Scb3jCTJh7p0cN9V7xOXSC0sJBsZupN6RBoE+BFzVJwh0rtb6CxnrPAHc2ScIdJvWek2fsm4Gbgaora2dv3fv3uG/qwE0Hemi8lRvI6Sbb7L49Z1Th9zsviPaweEu783+vz+wibtevwMSYYiHoaiB6TMTVJUXUegvNFOgkAJ/AYX+QgJ2gLgbpzveTVesi664mbpj3XTGOnG0Q11ZHd3xbnriPbS+cTFbu19GxYvQ8QIo3cP584upLKqgNFhKWaiM4kAJBf4Cwv4wPuUj6kToSUToinXSGmmlLdpGW6SVlkgLQV+AkmAZXbFOuuJdzIjtpj3WQaXPptRSBIIV1M75DBMLq5lYVEN1wTj8dvKbPBUSTUps+y2N2+/mYAIOObA3AT0udGhodKCleSIv3emNJt97L3zyk0M67P264Uvb+eNdp3iWef6FnVgy03zGCGGJ7oyWR7r3ybEVNEGiYEV6dLDv3naIF546SNAfI+iLEvBF+eMDRfh9ZluFNh9mlfpg9+7a2vsHrPpcV/gZ9X/m03R11eB3TaKSkqoqrn7fVVT4J2BbVlb3F8989Cg62ojWmuZEE22JlvRNU8TtoTHWQOUDP+PzT+eRG2cYbpnwa3576BbPspynj2EGyE67ZBObXpybnleq94J2NMqv/MK1dOpGlBtEqyiq9CA1lSGCVpCAHSRghwhYAR6/bRkV7b1fKUdLArzrxwuJOhFibpSYEyXqRKgKTyRoB4m5Uc5yffxXxTLvDlNd8fKp+zO3DNhl62frz+WnL30SAqUoFO3Rdj73vrnMmGJGI1SYv8VnPncZhW1HPdt2lY7j7t895+kGZCnLjNSmAaX53AfmeLbJfPI8Kv7U5wJ2ygfgoj9nr5er9eEgx2Z/ewXfXPFFApM+iF8XoLCoq1OcOr2YsF2CL3nzNlCPUa01UbeHzkQriWTXjbgbI+J0csa+n3Fe2f0A9MQLSLh+im/s07LUSY7Ek0+S3z75q37cDJtiMN0PE31ghWsoO/ffmVc9jxnlM3pvPnP975RZ8CuXZgfWRWFn3PxJO1zYFYetHUUs/k4HSrkUhTopCbdz+3c6uPGGczmtWwAAFZFJREFUHtPiK5WfTcfhbR+Hxoz3VVkGr/+RZJ9HsywdP9Og/Gzasp3Xtt3qqZJv1ud5xznfZGLxxN6Fg/zfx7RpaXi4z+HbGYc/dIfosEvoiHYQTfRQZkGpBaW2eftlFgQVyWAf+CwLv7KxlYWFIq4d4toh4brcVQllma0z+7SKPeUU2JarUdYwzznfK/sU32u7b8B1slQB04Aw0APsAXI8XH5q5jQ+WX0jKprqmqu56spavveJj5EZcEu9w77fJ5m2tm5kTZP35nHnG8+xOPEE7TpBxwCDVQzlYZeN+duV2fBvkSs5pbz3jVnBAmZcf0/WNmr221FHvE1NdUUY9e8DDMUO3Pno3+P0mOOgtaJs9gLOuPL9ePvyJvfh+S7XJlDTvcc0oNSaHjeSPH+a7bZ3HGLO1x6koNtHlCAxAlhTJuGrLEcHghAM4tp+tM+P5fclH9ZZ6Mwbeq1R6SYHLjrhoBMOlhNHxaJcemEU309Ng3sHi1bKaKOUNkpppYxWyogQwsXCwcZRPrNP25cOcFhOHFsnsM0ahIhQRitf+cFEXnPvH/D4DVeFv4aejgglha2Mt0lPxRaU+UJUFY5nfKiUskAhIX8Rfl/IfFYtK92S0tUurnZxkj9jiR4i8U5aol08+sT1PHX/NwFN0B+lJNzOkQOdyfNZpPe8pjMfC6S6KWc0aSFzcs1PO8C/3v8RFkUbqLahymdiNBPO+TmTiicxqWQSE0smUuDL/aBLa017rJ0D7Qc40HGAA+0HaHrjdiKJHo44cDgBS/tcEjDuXLgqz5xPg7S6dTV0RYo42jmOSDxETyxMz6RbcGd8Lh0gTAULcsWUUnK9Zlmwbss9XBj4LK7lYiXPtxPO/CYlk9+V7I2QbHGRal2eKi9HG/rM6xGtTVCi/F/eTazgaNa6o+UC/yz2JpqIkaBbR+kixwPeIQjho9gKE1T/v71zD7arLO/w855bcnKSQK4QSJR7pDrIRRhUBAuUAiKUMlirztjajpdKBaxaHDpe6jDjjda2dqAKtB1RCwJadKYVKqJ2LCC3YELCrQRNIAlJSGLI5dze/vGtnbOzs9c64ax3JV1n/56ZPXvvc06e9Wbt/dvft779rW91M8O6ePzwlk7Taz4KJ167d7JxTtu/bzssuaWXD9z9CtaPgz1PX8hpAz7/F7/gwZ+tTF/AA2bOzbfNZ2of7Fouoek0/91kz34DVt5cWMar7nk763yIrp1zscEZzJgB77/0CA4eOJR5/Qcxr/8g+rNctbZVg6M72bD9RdZtW8O67WtYueVpBkcG2Tmyg4071jMyvJl7Blr630f/GZz8j7v/bIL9759vh4+vh5ld6bZpBHrmv4mDZ72GeQPzmN0/mxl9M5jeN50pPVN2vd8HRwbZOriVrc/dzsbVd/PiCKwZhq2jcFAPbBlNtw8seg3vedfywv1Xho48HUwIIfYpIzvTYsgj28duPjw2k8NHSA0pTX3T1rVpmk/gzv7OsqsLzjlpz9MbgxgchHXr0v3OnenWmBad13Fsnjabt4RV49voE05IU8dryVNfhyf/AQY3pDVcGIXTboUZR6d1PPoOyE49nZLtkMYV2IClfw3LrinUL15pPDkUOK+7iX5g29EtPzzmw/CGr05c2nog0nwhgzzKnAZZ4WL6T132d6w45yO8/DLZ6YVpjZWurrHSGu/7xpoLzesrtHs+PMyuRSUvuSTN1JjMDI4MsnnHZrbs3MKBUw9k5pSZY18iTWaqvFoMVHsagTtsW5XW2dr+PC9teorVG5YzMrIjndJoRm93H1P6ZtDdM53urm7Muuiybrq7uunp6qXLjG4zerv66AVsdHtq44Y2w1NNazRZDxx3Dbz2E7vX0Dg1eY8Dy1YM7jxy18D5yzv6GZjaMgB4wRPpirAToeXz7IPrp/BPL5UbHCjc3CG9XPyOR8cWwx3ZQTbayK4DbR9tGqiCXfvnv/8Ahl5qL25mwbnZPxuFA4+DV13KnlcdzmZH4Y2VLuHpr8EzN7yy/9DvPgBz9vIqguOtTzjvDPide1Pp7mwd3MrGHRvZNriNHcM72LxzMxu3b2TDtg1s3L6RodEh+nv6mdM/hznT5uw6GJ/aO5XpfdOZNXUW/b2T/ANYiHEoOwjUQ1oY+ixgNWlh6He5+7Kmv3kbcBljC0P/vbufUuTVIJAQQojaMbw9HegMb02Dfo370Z3ZiBjZVP3mgxtLsw+tcTK6pVNNe2fA3DfuGtx7aftL3Pb4bTyy5hHWbF3Dyk0rWbpu6R5XJ2pm4cyFHDv3WA4aOIjFcxdzzhHncPKhJ6fT3kaH02LxQ5thcHOaGdk3GxZelA7AunrTOjtdU6Anu981W9bSAcF4BwV39MDt7dc7CuHTn04DQUKI8gxthe9k6wM0LrM851Q4+8djfzM6NHZFyOZZHdYF31u0F1fqIa1DuHNDWlNu9omw+PJ0gYSp89P6Vt3T0mdPdx+7zcoZZ23CRDcsfHtaT2toMyw4P23DLJvp3ZO5+5suqJJ9Bj95HTx9Xb66awpcuin9+4xNOzaxassq1m9bz9qta1mxfgUPv/AwD6x+gIHeAbq7ujnpkJM44eATOGr2UcybNo95A/NYNHMR0/razxqatOzW9jVmXzXawV3fbO0+yNV8JSghRCilBoEywfnAV0iz/25y92vM7IMA7n59don4rwLnki4R/8dF6wGBBoGEEEKIvWV4dJhVW1axcdtGjppzFDOnzNzfJQkh6sboMDz+BVj/c9i0LM1w7JkOr78G+g+B/gXZWorT0tUmGzMcG4MoE71c8+hQGrQZ3prdvzw266V5BgyjY7NfLVvw0rKrb/YMpFv/Ag0aCCHEXlB6EKgKNAgkhBBCCCHEfmR0BEZehqEtaVbj0BYY/k0aMNo1SDMytui8pYVQd62v2HjeM5BmNx7w2qYZOEIIIfYXRYNA+pQWQgghhBCiE+nqhq6Z0KvZhUII0SloPqUQQgghhBBCCCFEB6BBICGEEEIIIYQQQogOQINAQgghhBBCCCGEEB2ABoGEEEIIIYQQQgghOgANAgkhhBBCCCGEEEJ0ABoEEkIIIYQQQgghhOgANAgkhBBCCCGEEEII0QFoEEgIIYQQQgghhBCiA9AgkBBCCCGEEEIIIUQHoEEgIYQQQgghhBBCiA5Ag0BCCCGEEEIIIYQQHYAGgYQQQgghhBBCCCE6AA0CCSGEEEIIIYQQQnQA5u77Z8NmLwLPVbiJucD6mvrrXHvd/XWuve7+Otded3+da6+7v861191f59rr7q9z7XX317n2uvvrXHvV/jrXXnd/nWuvu7/q2l/t7vPa/WK/DQJVjZk96O5vqKO/zrXX3V/n2uvur3PtdffXufa6++tce939da697v461153f51rr7u/zrVX7a9z7XX317n2uvurrr0InQ4mhBBCCCGEEEII0QFoEEgIIYQQQgghhBCiA5jMg0Bfq7G/zrXX3V/n2uvur3PtdffXufa6++tce939da697v461153f51rr7u/zrVX7a9z7XX317n2uvurrj2XSbsmkBBCCCGEEEIIIYQYYzLPBBJCCCGEEEIIIYQQGZNuEMjMzjWzJ8zsaTO7qgL/TWa2zsyWVuBeZGY/NrPlZrbMzC4P9k81swfMbEnm/2ykP9tGt5k9YmY/qMC90sx+aWaPmtmDFfgPNLPbzGxF9hq8MdC9OKu7cdtiZlcE+q/MXtOlZvZtM5sa5c78l2fuZRF1t8uRmc02s7vN7Knsflaw/9Ks/lEzK7USf47/S9l75zEz+66ZHRjo/lzmfdTM7jKzQyJrb/rdx8zMzWxupN/MPmNmq5ve/+dH129mf5599i8zsy8G1n5LU90rzezRyNrN7Hgzu6/xuWZmpwT7X29m/5N9dn7fzGZO0N22fYrKbYE/JLcF/tK5LXCH5DbP3/T7UrktqD8kt0X1l81tQe0huS3wh+S2wB+V27b9vojcFrijMpvnj2pr8/xRuS3sc5fJbUHtUZnNrb1sZsepPyq3ef7SuS1wh2S2aTu7HU9FZHYcf2QfudUdktkCf1gfuZ2/6eel+8g59Yf1kV8R7j5pbkA38AxwBNAHLAF+K3gbpwMnAksrqH8BcGL2eAbwZGT9gAHTs8e9wP3AqcH/h48C3wJ+UMH+WQnMrfD986/An2aP+4ADK9pON7AGeHWQ71DgWaA/e34r8EeB9b4OWApMA3qA/wKOLuncI0fAF4GrssdXAV8I9h8LLAbuBd5QQf3nAD3Z4y9MtP4c98ymxx8Bro+sPfv5IuCHwHNlcpZT/2eAjwW9H9v5fzt7X07Jns+P3DdNv78W+FRw7XcB52WPzwfuDfb/Ajgje/w+4HMTdLdtn6JyW+APyW2Bv3RuC9whuc3zZ89L57ag/pDcFvhL57Zo3zT9zYRzW1B7SG4L/FG5bdvvi8htgTsqs3n+qLY2zx+V29w+d9ncFtQeldk8f1RbO+7xSMnc5tVfOrcF7pDMNm1nt+OpiMyO44/sI7e6QzJb4A/rI7fzZz8L6SPn1B+S21d6m2wzgU4Bnnb3/3X3QeDfgIsiN+DuPwU2Rjqb3C+4+8PZ498Ay0kH+FF+d/et2dPe7Ba2KJSZLQTeBtwQ5dxXZCP2pwM3Arj7oLtvqmhzZwHPuPtzgc4eoN/MekiDNc8Huo8F7nP3be4+DPwEuLiMMCdHF5EG4sjufy/S7+7L3f2JiTr3wn9Xtn8A7gMWBrq3ND0doERuCz7D/hb4RBn3OP4QcvwfAj7v7juzv1kX6AbAzAx4B/DtibgL/A40vjE8gBLZzfEvBn6aPb4buGSC7rz2KSS3ef6o3Bb4S+e2wB2S23H6BqVzuw/6Hnn+0rkdr/ayuS3wh+S2wB+V27x+X+nc5rkDM5vnj2pr8/xRuS3qc5fKbdX9+QJ/VFtbWH9AbvP8pXNb4A7JLOQeT4X1kdv5o3Kb4w7JbIE/rI9ccCwb0kf+/3SsPNkGgQ4Fft30fBWBHZl9iZkdBpxAGmGO9HZn0yvXAXe7e6T/K6SAjAY6m3HgLjN7yMzeH+w+AngR+Odsit4NZjYQvI0G76TEgWQr7r4a+DLwK+AFYLO73xXlJ80COt3M5pjZNNK3J4sC/Q0OcvcXIHWMgfkVbGNf8T7gPyKFZnaNmf0aeDfwqWD3hcBqd18S6W3hsmy67k1lpzG34RjgLWZ2v5n9xMxODvYDvAVY6+5PBXuvAL6UvbZfBj4Z7F8KXJg9vpSA7La0T+G5rar92wt/6dy2uqNz2+yvIrdt9k1oblv8obnNeV3DctviD89tiz8stzn9vpDcVtyn3Bt/qczm+aNy284flduCfROS2Rx/WGbHeW1L5zbHH5LbHHdkW9vueCqyra3yeG08d9l2tq0/sK3dwx/c1ubtnyr7yG2ZbINA1uZnYSPj+wozmw7cDlzRMrpZGncfcffjSaOwp5jZ6yK8ZnYBsM7dH4rw5fBmdz8ROA/4sJmdHujuIZ1GcZ27nwC8TJpuGYqZ9ZEaie8EOmeRviE4HDgEGDCz90T53X05afrm3cB/kk6zHC78Rx2MmV1N2j/fjPS6+9XuvijzXhblzQb2riZ4YKmF64AjgeNJA5XXBvt7gFmkKdkfB27NvkmM5A8JHLxt4kPAldlreyXZbMRA3kf6vHyIdLrJYBlZle3T/vRH5LadOzK3zf6s1tDctqk/NLdt/GG5LXjfhOS2jT80t238Ybmtqt9XtXs8f0Rm8/xRuW3jP46g3ObUHpbZHH9YZsd575TObY4/JLc57pDMVn08VaV/PHfZzBb5IzLbzh/ZRy6ov+o+clsm2yDQKnYfeV1I7GkxlWNmvaSOwDfd/Y6qtuPpVKd7gXODlG8GLjSzlaTT8M40s5uD3AC4+/PZ/Trgu6TT/6JYBaxq+ibiNtKgUDTnAQ+7+9pA59nAs+7+orsPAXcAbwr04+43uvuJ7n466XST6NkQAGvNbAFAdj+hacb7EzN7L3AB8G53r2oA+luUmGbchiNJA4hLsvwuBB42s4OjNuDua7NO0yjwdWKzCym/d2TTtB8gfcNSauG+ZiydZvn7wC1RzibeS8ospMHh0H3j7ivc/Rx3P4nUqX5moq6c9ikst1W3f3n+iNzuRe2lctvGH5rbdvVH5jZn/4TktuB1Dcltjj8stzn7Piy3DVr6faHtbQV9ykJ/dFtbUH9Ie9vkb3xhF9beNtdeRVvbsm/C29o2r21oe9viD21vW/Z9VGbzjqeiMlvl8VquOyize1N7mczu4Qe+QVxm29a/D/rIbZlsg0C/AI42s8OzGRfvBO7czzXtNdlo+o3Acnf/mwr88yxbkd3M+kmDBysi3O7+SXdf6O6Hkfb7Pe4eNhvFzAbMbEbjMWmRsbArtLn7GuDXZrY4+9FZwONR/iaqmE3wK+BUM5uWvYfOIq0rEIaZzc/uX0VqnKuYEXEnqYEmu//3CrZRGWZ2LvCXwIXuvi3YfXTT0wsJyi2Au//S3ee7+2FZfleRFipdE7WNRscl42ICs5vxPVJjjZkdQ1rYfX2g/2xghbuvCnQ2eB44I3t8JsEDrE3Z7QL+Crh+gp689ikkt/ug/Wvrj8htgTskt+38kbktqD8ktwWvbencjvO+KZ3bAn9Ibgv2fVRu8/p9pXNbZZ+yyB/V1hb4o3Lbzv9IRG4Lao/KbN5rG9LWjvPeichtnr90bgv2fUhmC46nQtraKo/X8txRmS3wh2Q2x39JVFtbUH/VfeTcgibVjbReyZOkEdirK/B/mzRVa4j0RviTQPdppNPXHgMezW7nB/qPAx7J/EspcZWbcbbzVoKvDkZas2dJdltW0Wt7PPBgtn++B8wK9k8DNgAHVFD7Z0kfektJo9ZTgv0/Iw2KLQHOCvDtkSNgDvAjUqP8I2B2sP/i7PFOYC3ww2D/06Q1yRrZnegVRdq5b89e28eA75MWnQ2rveX3Kyl3dbB29X8D+GVW/53AgmB/H3Bzto8eBs6M3DfAvwAfrOh9fxrwUJat+4GTgv2Xk9rEJ4HPAzZBd9v2KSq3Bf6Q3Bb4S+e2wB2S2zx/y99MOLcF9YfktsBfOrdF+yYitwW1h+S2wB+V27b9vojcFrijMpvnj2pr8/xRuR23zz3R3BbUHpXZPH9UW5u7b4Jym1d/6dwWuEMy27KttzJ2BamwPnKOP6yP3MYdktkCf1gfuZ2/5ecTyuw49Yf1kV/JzbKNCyGEEEIIIYQQQohJzGQ7HUwIIYQQQgghhBBCtEGDQEIIIYQQQgghhBAdgAaBhBBCCCGEEEIIIToADQIJIYQQQgghhBBCdAAaBBJCCCGEEEIIIYToADQIJIQQQgghhBBCCNEBaBBICCGEEEIIIYQQogPQIJAQQgghhBBCCCFEB/B/MfJrAgHA2GgAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "onehot, fwd and rev:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from collections import Counter\n", + "from modisco.visualization import viz_sequence\n", + "reload(viz_sequence)\n", + "from matplotlib import pyplot as plt\n", + "\n", + "import modisco.affinitymat.core\n", + "reload(modisco.affinitymat.core)\n", + "import modisco.cluster.phenograph.core\n", + "reload(modisco.cluster.phenograph.core)\n", + "import modisco.cluster.phenograph.cluster\n", + "reload(modisco.cluster.phenograph.cluster)\n", + "import modisco.cluster.core\n", + "reload(modisco.cluster.core)\n", + "import modisco.aggregator\n", + "reload(modisco.aggregator)\n", + "\n", + "hdf5_results = h5py.File(\"results.hdf5\",\"r\")\n", + "\n", + "print(\"Metaclusters heatmap\")\n", + "import seaborn as sns\n", + "activity_patterns = np.array(hdf5_results['metaclustering_results']['attribute_vectors'])[\n", + " np.array(\n", + " [x[0] for x in sorted(\n", + " enumerate(hdf5_results['metaclustering_results']['metacluster_indices']),\n", + " key=lambda x: x[1])])]\n", + "sns.heatmap(activity_patterns, center=0)\n", + "plt.show()\n", + "\n", + "metacluster_names = [\n", + " x.decode(\"utf-8\") for x in \n", + " list(hdf5_results[\"metaclustering_results\"]\n", + " [\"all_metacluster_names\"][:])]\n", + "\n", + "all_patterns = []\n", + "background = np.array([0.27, 0.23, 0.23, 0.27])\n", + "\n", + "for metacluster_name in metacluster_names:\n", + " print(metacluster_name)\n", + " metacluster_grp = (hdf5_results[\"metacluster_idx_to_submetacluster_results\"]\n", + " [metacluster_name])\n", + " print(\"activity pattern:\",metacluster_grp[\"activity_pattern\"][:])\n", + " all_pattern_names = [x.decode(\"utf-8\") for x in \n", + " list(metacluster_grp[\"seqlets_to_patterns_result\"]\n", + " [\"patterns\"][\"all_pattern_names\"][:])]\n", + " if (len(all_pattern_names)==0):\n", + " print(\"No motifs found for this activity pattern\")\n", + " for pattern_name in all_pattern_names:\n", + " print(metacluster_name, pattern_name)\n", + " all_patterns.append((metacluster_name, pattern_name))\n", + " pattern = metacluster_grp[\"seqlets_to_patterns_result\"][\"patterns\"][pattern_name]\n", + " print(\"total seqlets:\",len(pattern[\"seqlets_and_alnmts\"][\"seqlets\"]))\n", + " print(\"Task 0 hypothetical scores:\")\n", + " viz_sequence.plot_weights(pattern[\"task0_hypothetical_contribs\"][\"fwd\"])\n", + " print(\"Task 0 actual importance scores:\")\n", + " viz_sequence.plot_weights(pattern[\"task0_contrib_scores\"][\"fwd\"])\n", + " #print(\"Task 1 hypothetical scores:\")\n", + " #viz_sequence.plot_weights(pattern[\"task1_hypothetical_contribs\"][\"fwd\"])\n", + " #print(\"Task 1 actual importance scores:\")\n", + " #viz_sequence.plot_weights(pattern[\"task1_contrib_scores\"][\"fwd\"])\n", + " #print(\"Task 2 hypothetical scores:\")\n", + " #viz_sequence.plot_weights(pattern[\"task2_hypothetical_contribs\"][\"fwd\"])\n", + " #print(\"Task 2 actual importance scores:\")\n", + " #viz_sequence.plot_weights(pattern[\"task2_contrib_scores\"][\"fwd\"])\n", + " print(\"onehot, fwd and rev:\")\n", + " viz_sequence.plot_weights(viz_sequence.ic_scale(np.array(pattern[\"sequence\"][\"fwd\"]),\n", + " background=background)) \n", + " viz_sequence.plot_weights(viz_sequence.ic_scale(np.array(pattern[\"sequence\"][\"rev\"]),\n", + " background=background)) \n", + " \n", + "hdf5_results.close()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "UFQSYr9q_qI9" + }, + "source": [ + "## Load the saved hdf5 file\n", + "Load the results object from the saved file" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "WVtrMZ9o_mu0" + }, + "outputs": [], + "source": [ + "import h5py\n", + "import numpy as np\n", + "import modisco\n", + "from modisco.tfmodisco_workflow import workflow\n", + "\n", + "track_set = modisco.tfmodisco_workflow.workflow.prep_track_set(\n", + " task_names=tasks,\n", + " contrib_scores=task_to_scores,\n", + " hypothetical_contribs=task_to_hyp_scores,\n", + " one_hot=onehot_data)\n", + "\n", + "grp = h5py.File(\"results.hdf5\",\"r\")\n", + "loaded_tfmodisco_results =\\\n", + " workflow.TfModiscoResults.from_hdf5(grp, track_set=track_set)\n", + "grp.close()" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Getting the exemplar motifs\n", + "Numseqles: 82\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "After filtering: numseqlets 82\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Numseqles: 75\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "After filtering: numseqlets 74\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Getting labels\n", + "Getting impscores data\n", + "Computing fwd sims\n", + "Took 0.113922119140625 s\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Parallel(n_jobs=10)]: Using backend LokyBackend with 10 concurrent workers.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Getting impscores data\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Parallel(n_jobs=10)]: Done 1 out of 1 | elapsed: 0.1s finished\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Computing fwd sims\n", + "Took 0.12588191032409668 s\n" + ] + } + ], + "source": [ + "from modisco.hit_scoring import exemplar_based_hitscoring\n", + "reload(exemplar_based_hitscoring)\n", + "\n", + "instance_scorer = exemplar_based_hitscoring.prepare_instance_scorer(\n", + " patterns=(loaded_tfmodisco_results\n", + " .metacluster_idx_to_submetacluster_results[\"metacluster_0\"]\n", + " .seqlets_to_patterns_result.patterns),\n", + " trim_window_size=25,\n", + " task_names=tasks,\n", + " bg_freq=background,\n", + " track_set=track_set)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[(array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n", + " 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n", + " 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n", + " 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n", + " 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]),\n", + " array([1. , 0.98780488, 0.97560976, 0.96341463, 0.95121951,\n", + " 0.93902439, 0.92682927, 0.91463415, 0.90243902, 0.8902439 ,\n", + " 0.87804878, 0.86585366, 0.85365854, 0.84146341, 0.82926829,\n", + " 0.81707317, 0.80487805, 0.79268293, 0.7804878 , 0.76829268,\n", + " 0.75609756, 0.74390244, 0.73170732, 0.7195122 , 0.70731707,\n", + " 0.69512195, 0.68292683, 0.67073171, 0.65853659, 0.64634146,\n", + " 0.63414634, 0.62195122, 0.6097561 , 0.59756098, 0.58536585,\n", + " 0.57317073, 0.56097561, 0.54878049, 0.53658537, 0.52439024,\n", + " 0.51219512, 0.5 , 0.48780488, 0.47560976, 0.46341463,\n", + " 0.45121951, 0.43902439, 0.42682927, 0.41463415, 0.40243902,\n", + " 0.3902439 , 0.37804878, 0.36585366, 0.35365854, 0.34146341,\n", + " 0.32926829, 0.31707317, 0.30487805, 0.29268293, 0.2804878 ,\n", + " 0.26829268, 0.25609756, 0.24390244, 0.23170732, 0.2195122 ,\n", + " 0.20731707, 0.19512195, 0.18292683, 0.17073171, 0.15853659,\n", + " 0.14634146, 0.13414634, 0.12195122, 0.1097561 , 0.09756098,\n", + " 0.08536585, 0.07317073, 0.06097561, 0.04878049, 0.03658537,\n", + " 0.02439024, 0.01219512, 0. ]),\n", + " array([0.65678624, 0.89705327, 0.93625358, 0.95313614, 0.95494318,\n", + " 0.9556915 , 0.96611831, 0.96639921, 0.97099519, 0.97261431,\n", + " 0.97608759, 0.97744753, 0.97891236, 0.98174708, 0.98207847,\n", + " 0.98316659, 0.98370227, 0.98505885, 0.98531423, 0.98581885,\n", + " 0.98619415, 0.98755134, 0.98756805, 0.98814205, 0.98868663,\n", + " 0.98894266, 0.9890422 , 0.98916952, 0.98978332, 0.99024676,\n", + " 0.99076272, 0.99120682, 0.99129641, 0.99178473, 0.99211901,\n", + " 0.99290701, 0.9929094 , 0.99303012, 0.99308176, 0.99343159,\n", + " 0.99364083, 0.99389209, 0.99435999, 0.99458476, 0.99475498,\n", + " 0.99532409, 0.99553223, 0.99558805, 0.99573062, 0.99580233,\n", + " 0.99582343, 0.99655394, 0.99663574, 0.99683224, 0.99685669,\n", + " 0.99703242, 0.99712932, 0.99723375, 0.99723838, 0.99725946,\n", + " 0.99727703, 0.997686 , 0.99771562, 0.9978073 , 0.99781418,\n", + " 0.99784923, 0.99806169, 0.99817138, 0.99820317, 0.99839801,\n", + " 0.99857778, 0.99867491, 0.99878419, 0.9987898 , 0.99883347,\n", + " 0.99887053, 0.99891155, 0.99899106, 0.99903135, 0.99904085,\n", + " 0.99915221, 0.99918308])),\n", + " (array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n", + " 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n", + " 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n", + " 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n", + " 1., 1., 1., 1., 1., 1., 1.]),\n", + " array([1. , 0.98648649, 0.97297297, 0.95945946, 0.94594595,\n", + " 0.93243243, 0.91891892, 0.90540541, 0.89189189, 0.87837838,\n", + " 0.86486486, 0.85135135, 0.83783784, 0.82432432, 0.81081081,\n", + " 0.7972973 , 0.78378378, 0.77027027, 0.75675676, 0.74324324,\n", + " 0.72972973, 0.71621622, 0.7027027 , 0.68918919, 0.67567568,\n", + " 0.66216216, 0.64864865, 0.63513514, 0.62162162, 0.60810811,\n", + " 0.59459459, 0.58108108, 0.56756757, 0.55405405, 0.54054054,\n", + " 0.52702703, 0.51351351, 0.5 , 0.48648649, 0.47297297,\n", + " 0.45945946, 0.44594595, 0.43243243, 0.41891892, 0.40540541,\n", + " 0.39189189, 0.37837838, 0.36486486, 0.35135135, 0.33783784,\n", + " 0.32432432, 0.31081081, 0.2972973 , 0.28378378, 0.27027027,\n", + " 0.25675676, 0.24324324, 0.22972973, 0.21621622, 0.2027027 ,\n", + " 0.18918919, 0.17567568, 0.16216216, 0.14864865, 0.13513514,\n", + " 0.12162162, 0.10810811, 0.09459459, 0.08108108, 0.06756757,\n", + " 0.05405405, 0.04054054, 0.02702703, 0.01351351, 0. ]),\n", + " array([0.77684711, 0.83341283, 0.90725741, 0.91377449, 0.92101767,\n", + " 0.95534211, 0.96754378, 0.96835405, 0.9685044 , 0.9688225 ,\n", + " 0.97561621, 0.98190854, 0.98233506, 0.98283539, 0.98409881,\n", + " 0.98441852, 0.98470097, 0.98471698, 0.98563756, 0.9884187 ,\n", + " 0.99077162, 0.99199793, 0.99244273, 0.9925711 , 0.99259755,\n", + " 0.99263917, 0.99315988, 0.99319414, 0.99387562, 0.99390085,\n", + " 0.99401059, 0.9945448 , 0.99545792, 0.99550508, 0.9955907 ,\n", + " 0.99603051, 0.99607055, 0.99613181, 0.99633447, 0.99669391,\n", + " 0.99673971, 0.99687127, 0.99709408, 0.99740961, 0.99747868,\n", + " 0.99748133, 0.99762514, 0.99767821, 0.99769793, 0.99773233,\n", + " 0.99787421, 0.99801789, 0.99810313, 0.99810556, 0.99813886,\n", + " 0.99830408, 0.99831698, 0.99838589, 0.99839679, 0.99851889,\n", + " 0.99852858, 0.99860751, 0.99867825, 0.99870549, 0.99873476,\n", + " 0.99884999, 0.99902065, 0.99908039, 0.9991059 , 0.99925669,\n", + " 0.99928319, 0.99938742, 0.99957424, 0.99961321])),\n", + " (array([0.99954107, 0.99954086, 1. , ..., 1. , 1. ,\n", + " 1. ]),\n", + " array([1.00000000e+00, 9.99540863e-01, 9.99540863e-01, ...,\n", + " 9.18273646e-04, 4.59136823e-04, 0.00000000e+00]),\n", + " array([0.26942209, 0.33525055, 0.37973795, ..., 0.99814724, 0.99836229,\n", + " 0.99865282]))]" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "instance_scorer.precrecthres_list" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "include_colab_link": true, + "name": "(On Google Colab) With Hit Scoring TF MoDISco TAL GATA.ipynb", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/modisco/hit_scoring/exemplar_based_hitscoring.py b/modisco/hit_scoring/exemplar_based_hitscoring.py index 39cb723..92043cb 100644 --- a/modisco/hit_scoring/exemplar_based_hitscoring.py +++ b/modisco/hit_scoring/exemplar_based_hitscoring.py @@ -3,6 +3,13 @@ import numpy as np import time from sklearn.metrics import average_precision_score, precision_recall_curve +from .. import affinitymat +from .. import aggregator +from .. import core +from .. import util +from .. import visualization +from matplotlib import pyplot as plt +import sklearn def flatten_seqlet_impscore_features(seqlet_impscores): @@ -42,11 +49,11 @@ def compute_pairwise_continjacc_sims(vecs1, vecs2, vecs2_weighting=None): def make_aggregated_seqlet(seqlets): - seqletsandalignments = modisco.core.SeqletsAndAlignments() - [seqletsandalignments.append(modisco.core.SeqletAndAlignment( + seqletsandalignments = core.SeqletsAndAlignments() + [seqletsandalignments.append(core.SeqletAndAlignment( seqlet=seqlet, alnmt=0)) for seqlet in seqlets if seqlet not in seqletsandalignments] - reconstructed_motif = modisco.core.AggregatedSeqlet(seqletsandalignments) + reconstructed_motif = core.AggregatedSeqlet(seqletsandalignments) return reconstructed_motif @@ -82,7 +89,7 @@ def get_exemplar_motifs(seqlets, pattern_comparison_settings, print("Numseqles:", len(seqlets)) #seqlets should already be aligned relative to each other. # Extract the importance score information. - fwd_seqlet_data, _ = modisco.core.get_2d_data_from_patterns( + fwd_seqlet_data, _ = core.get_2d_data_from_patterns( patterns=seqlets, track_names=pattern_comparison_settings.track_names, track_transformer= @@ -121,13 +128,13 @@ def get_exemplar_motifs(seqlets, pattern_comparison_settings, if (representive_exemplar not in exemplar_to_seqletsandalignments): exemplar_to_seqletsandalignments[representive_exemplar] = [] exemplar_to_seqletsandalignments[representive_exemplar].append( - modisco.core.SeqletAndAlignment(seqlet=seqlet, alnmt=0) ) + core.SeqletAndAlignment(seqlet=seqlet, alnmt=0) ) exemplar_to_motif = OrderedDict([ - (exemplar, modisco.core.AggregatedSeqlet(seqletsandalignments)) + (exemplar, core.AggregatedSeqlet(seqletsandalignments)) for exemplar,seqletsandalignments in exemplar_to_seqletsandalignments.items()]) #return the list of motifs, sorted by the number of seqlets - motifs = sorted(list(exemplar_to_motif.items()), + motifs = sorted(list(exemplar_to_motif.values()), key=lambda x: len(x.seqlets)) return motifs, affmat, filtered_orig_motif, sum_orig_affmat @@ -158,11 +165,12 @@ def get_exemplar_motifs_for_all_patterns( withinpattern_affmats.append(patternaffmat) filt_patterns.append(filtered_orig_motif) - viz_sequence.plot_weights(pattern["sequence"].fwd) + visualization.viz_sequence.plot_weights(pattern["sequence"].fwd) plt.hist(sum_orig_affmat, bins=20) plt.show() print("After filtering: numseqlets", len(filtered_orig_motif.seqlets)) - viz_sequence.plot_weights(filtered_orig_motif["sequence"].fwd) + visualization.viz_sequence.plot_weights( + filtered_orig_motif["sequence"].fwd) return (exemplarmotifs_foreach_pattern, exemplarmotifs_indices, withinpattern_affmats, filt_patterns) @@ -177,7 +185,7 @@ def get_shifts(seqlet_coordinate, shift_fraction, max_seq_len): new_start = seqlet_coordinate.start + shift_size new_end = seqlet_coordinate.end + shift_size if (new_start >= 0 and new_end <= max_seq_len): - coordinates_to_return.append(modisco.core.SeqletCoordinates( + coordinates_to_return.append(core.SeqletCoordinates( example_idx=seqlet_coordinate.example_idx, start=new_start, end=new_end, @@ -185,7 +193,7 @@ def get_shifts(seqlet_coordinate, shift_fraction, max_seq_len): return coordinates_to_return -def get_coordinates_and_labels(shift_fraction, patterns): +def get_coordinates_and_labels(shift_fraction, patterns, track_set): """ Get coordinates from shifting the seqlet instances by shift_fraction, and get labels for shifts that align with the original seqlets @@ -195,42 +203,47 @@ def get_coordinates_and_labels(shift_fraction, patterns): coor for pattern in patterns for seqlet in pattern.seqlets - for coor in get_shifts(seqlet_coordinate=seqlet.coor, - shift_fraction=shift_fraction, - max_seq_len= - len(one_hot[seqlet.coor.example_idx])) + for coor in get_shifts( + seqlet_coordinate=seqlet.coor, + shift_fraction=shift_fraction, + max_seq_len=track_set.get_example_idx_len(seqlet.coor.example_idx)) ] patternidx_to_positivecoordinates = OrderedDict([ (patternidx, set(str(seqlet.coor) for seqlet in patterns[patternidx].seqlets)) - for patternidx in range(len(trimmed_patterns)) + for patternidx in range(len(patterns)) ]) #get the labels for the coordinates depending on the patterns # the very last column is the 'no pattern' class - labels = np.zeros((len(all_coordinates), 1+len(trimmed_patterns))) + labels = np.zeros((len(all_coordinates), 1+len(patterns))) for patternidx in range(len(patterns)): labels[:,patternidx] = np.array([ 1 if str(coor) in patternidx_to_positivecoordinates[patternidx] else 0 for coor in all_coordinates ]) + #fill in last col as a 1 if nothing else is + labels[:,-1] = np.array([1 if x==0 else 0 for x + in np.sum(labels, axis=-1)]) return all_coordinates, labels class FeaturesProducer(object): - def __init__(self, motifs, pattern_comparison_settings, onehot_track_name): + def __init__(self, motifs, pattern_comparison_settings, + onehot_track_name, bg_freq): self.motifs = motifs self.pattern_comparison_settings = pattern_comparison_settings self.onehot_track_name = onehot_track_name + self.bg_freq = bg_freq #Get imp scores data (allexemplarmotifs_impscoresdata_fwd, allexemplarmotifs_impscoresdata_rev) =\ - modisco.core.get_2d_data_from_patterns( - patterns=all_exemplarmotifs, + core.get_2d_data_from_patterns( + patterns=motifs, track_names=pattern_comparison_settings.track_names, track_transformer=pattern_comparison_settings.track_transformer) #Flatten the importance score data into vectors @@ -241,39 +254,40 @@ def __init__(self, motifs, pattern_comparison_settings, onehot_track_name): #Do the same for per-position IC (for weighting exemplar sim # computation). First, get the one-hot encoded sequence data allexemplarmotifs_sequence_fwd, allexemplarmotifs_sequence_rev =\ - modisco.core.get_2d_data_from_patterns( - patterns=all_exemplarmotifs, + core.get_2d_data_from_patterns( + patterns=motifs, track_names=[onehot_track_name], track_transformer=lambda x: x) #compute the per-position IC, then tile (for ACGT) and flatten to # get it into vector form. self.per_position_ic_allexemplarmotifs_fwd =\ np.maximum(flatten_seqlet_impscore_features(np.array([ - np.tile(modisco.util.compute_per_position_ic( + np.tile(util.compute_per_position_ic( ppm=x, - background=background, + background=bg_freq, pseudocount=0.001)[:,None], (1,4*len(pattern_comparison_settings.track_names))) for x in allexemplarmotifs_sequence_fwd])),0) - def __call__(self, coordinates): + def __call__(self, coordinates, track_set): print("Getting impscores data") - allcoordinatesseqlet_impscoresdata_fwd, _ =\ - modisco.core.get_2d_data_from_patterns( - patterns=all_coordinates_seqlets, - track_names=pattern_comparison_settings.track_names, - track_transformer=pattern_comparison_settings.track_transformer) + seqlets = track_set.create_seqlets(coords=coordinates) + impscoresdata_fwd, _ =\ + core.get_2d_data_from_patterns( + patterns=seqlets, + track_names=self.pattern_comparison_settings.track_names, + track_transformer= + self.pattern_comparison_settings.track_transformer) #Flatten the importance score data into vectors - allcoordinatesseqlet_impscoresdata_fwd = ( - flatten_seqlet_impscore_features( - allcoordinatesseqlet_impscoresdata_fwd)) + impscoresdata_fwd = (flatten_seqlet_impscore_features( + impscoresdata_fwd)) start = time.time() print("Computing fwd sims") features_matrix_fwd = compute_pairwise_continjacc_sims( - vecs1=allcoordinatesseqlet_impscoresdata_fwd, - vecs2=allexemplarmotifs_impscoresdata_fwd, - vecs2_weighting=per_position_ic_allexemplarmotifs_fwd) + vecs1=impscoresdata_fwd, + vecs2=self.allexemplarmotifs_impscoresdata_fwd, + vecs2_weighting=self.per_position_ic_allexemplarmotifs_fwd) print("Took",time.time()-start,"s") #We ignore the rc because we want to annotate seqlets as @@ -287,14 +301,15 @@ def __init__(self, features_producer, classifier): self.features_producer = features_producer self.classifier = classifier - def __call__(self, coordinates): - features_matrix = self.features_producer(coordinates) + def __call__(self, coordinates, track_set): + features_matrix = self.features_producer(coordinates=coordinates, + track_set=track_set) if (hasattr(self.classifier, 'predict_proba')): return self.classifier.predict_proba(features_matrix) else: return self.classifier.predict(features_matrix) - def compute_precrecthres_list(self, coordinates, labels): + def compute_precrecthres_list(self, coordinates, track_set, labels): """ Prepare the attribute self.precrecthres_list which, for each pattern, has (precision, recall, threshold) as returned @@ -303,30 +318,52 @@ def compute_precrecthres_list(self, coordinates, labels): coordiantes and labels. The last column of labels corresponds to the "no pattern" class. """ - preds = self(coordinates=coordinates) + preds = self(coordinates=coordinates, track_set=track_set) precrecthres_list = [] for pattern_idx in range(labels.shape[1]): precision, recall, thresholds = precision_recall_curve( y_true=labels[:,pattern_idx], - probas_pred=preds_proba[:,pattern_idx]) + probas_pred=preds[:,pattern_idx]) precrecthres_list.append((precision, recall, thresholds)) self.precrecthres_list = precrecthres_list return precrecthres_list -def prepare_instance_scorer(patterns, - trim_window_size, - pattern_comparison_settings, - affmat_min_frac_of_median, - classifier_to_fit_factory, - shift_fraction=0.3, - onehot_track_name="sequence"): +def prepare_instance_scorer( + patterns, + trim_window_size, + task_names, + bg_freq, + track_set, + affmat_min_frac_of_median=0.6, + classifier_to_fit_factory=( + lambda: sklearn.linear_model.LogisticRegression( + class_weight='balanced', + multi_class='multinomial', + verbose=5, + random_state=1234, + n_jobs=10, + max_iter=3000)), + shift_fraction=0.3, + min_overlap=0.7): + + onehot_track_name = "sequence" + score_track_names = ([task_name+"_hypothetical_contribs" + for task_name in task_names] + +[task_name+"_contrib_scores" + for task_name in task_names]) + + pattern_comparison_settings =\ + affinitymat.core.PatternComparisonSettings( + track_names=score_track_names, + track_transformer=affinitymat.L1Normalizer(), + min_overlap=min_overlap) #start by trimming the patterns to the lengths of the original seqlets - prefilt_trimmed_patterns = modisco.aggregator.TrimToBestWindowByIC( + prefilt_trimmed_patterns = aggregator.TrimToBestWindowByIC( window_size=trim_window_size, onehot_track_name=onehot_track_name, - bg_freq=BG_FREQ)(patterns) + bg_freq=bg_freq)(patterns) (exemplarmotifs_foreach_pattern, exemplarmotifs_indices, withinpattern_affmats, @@ -341,20 +378,25 @@ def prepare_instance_scorer(patterns, for patternidx in range(len(filt_trimmed_patterns)) for exemplarmotif in exemplarmotifs_foreach_pattern[patternidx]] features_producer = FeaturesProducer( - motifs=motifs, pattern_comparison_settings=pattern_comparison_settings, - onehot_track_name=onehot_track_name) + motifs=all_exemplarmotifs, + pattern_comparison_settings=pattern_comparison_settings, + onehot_track_name=onehot_track_name, + bg_freq=bg_freq) #get coordinates, labels and their features all_coordinates, labels = get_coordinates_and_labels( shift_fraction=shift_fraction, - patterns=filt_trimmed_patterns) - features_matrix = features_producer(all_coordinates) + patterns=filt_trimmed_patterns, + track_set=track_set) + features_matrix = features_producer(coordinates=all_coordinates, + track_set=track_set) classifier = classifier_to_fit_factory().fit( - features_matrix, multiclass_labels) + features_matrix, np.argmax(labels, axis=-1)) instance_scorer = InstanceScorer(features_producer=features_producer, classifier=classifier) instance_scorer.compute_precrecthres_list(coordinates=all_coordinates, + track_set=track_set, labels=labels) return instance_scorer From 9173b80c3bceea1bd8f3366791564a3d6fcfeb29 Mon Sep 17 00:00:00 2001 From: Avanti Shrikumar Date: Wed, 9 Dec 2020 08:56:21 -0800 Subject: [PATCH 03/30] wrote code for variable len stuff --- modisco.egg-info/PKG-INFO | 2 +- modisco/coordproducers.py | 154 +++++++++++++++++++++++++++++++------- setup.py | 2 +- 3 files changed, 128 insertions(+), 30 deletions(-) diff --git a/modisco.egg-info/PKG-INFO b/modisco.egg-info/PKG-INFO index 13bca3a..ed2092c 100644 --- a/modisco.egg-info/PKG-INFO +++ b/modisco.egg-info/PKG-INFO @@ -1,6 +1,6 @@ Metadata-Version: 2.1 Name: modisco -Version: 0.5.9.1 +Version: 0.5.10.0 Summary: TF MOtif Discovery from Importance SCOres Home-page: https://github.com/kundajelab/tfmodisco License: UNKNOWN diff --git a/modisco/coordproducers.py b/modisco/coordproducers.py index 169f802..54dde72 100644 --- a/modisco/coordproducers.py +++ b/modisco/coordproducers.py @@ -304,6 +304,121 @@ def __call__(self, score_track, windowsize, original_summed_score_track): return np.concatenate(window_sum_function(null_tracks), axis=0) +def get_null_vals(null_track, score_track, windowsize, + original_summed_score_track): + if (hasattr(null_track, '__call__')): + null_vals = null_track( + score_track=score_track, + windowsize=windowsize, + original_summed_score_track=original_summed_score_track) + else: + window_sum_function = get_simple_window_sum_function(window_size) + null_summed_score_track = window_sum_function(arrs=null_track) + null_vals = list(np.concatenate(null_summed_score_track, axis=0)) + return null_vals + + +def get_isotonic_regression_classifier(orig_vals, null_vals): + from sklearn.isotonic import IsotonicRegression + pos_orig_vals = np.array(sorted([x for x in orig_vals if x >= 0])) + neg_orig_vals = np.array(sorted([x for x in orig_vals if x < 0], + key=lambda x: abs(x))) + pos_null_vals = [x for x in null_vals if x >= 0] + neg_null_vals = [x for x in null_vals if x < 0] + pos_ir = IsotonicRegression().fit( + X=np.concatenate([pos_orig_vals,pos_null_vals], axis=0), + y=([1.0 for x in pos_orig_vals] + +[0.0 for x in pos_null_vals]), + sample_weight=([1.0 for x in pos_orig_vals]+ + [len(pos_orig_vals)/len(pos_null_vals) + for x in pos_null_vals])) + + if (len(neg_orig_vals) > 0): + neg_ir = IsotonicRegression(increasing=False).fit( + X=np.concatenate([neg_orig_vals,neg_null_vals], axis=0), + y=([1.0 for x in neg_orig_vals] + +[0.0 for x in neg_null_vals]), + sample_weight=([1.0 for x in neg_orig_vals]+ + [len(neg_orig_vals)/len(neg_null_vals) + for x in neg_null_vals])) + else: + neg_ir = None + + return pos_ir, neg_ir, pos_orig_vals, neg_orig_vals + + +def valatmaxabs(arrs): + idxs = np.argmax(np.abs(arrs), axis=0) + return arrs[idxs, np.arange(len(arrs[0]))] + + +class VariableWindowWidthPercentileTransform(object): + + def __init__(sliding_window_sizes): + self.sliding_window_sizes = sliding_window_sizes + + def compute_percentile_transform(window_size, score_track, null_track): + window_sum_function = get_simple_window_sum_function(window_size) + original_summed_score_track = window_sum_function(arrs=score_track) + + def fit(self, score_track, null_track, tnt_results=None): + pos_irs = [] + neg_irs = [] + for sliding_window_size in self.sliding_window_sizes: + print("Fitting - on window size",sliding_window_size) + if (hasattr(null_track, '__call__')): + null_vals = null_track( + score_track=score_track, + windowsize=self.sliding) + else: + null_summed_score_track = window_sum_function(arrs=null_track) + null_vals = list(np.concatenate(null_summed_score_track, + axis=0)) + window_sums_rows = window_sum_function(arrs=score_track) + pos_ir, neg_ir, _, _ = get_isotonic_regression_classifier( + orig_vals=list( + np.concatenate(window_sums_rows, axis=0)), + null_vals=null_vals) + pos_irs.append(pos_ir) + neg_irs.append(neg_ir) + self.pos_irs = pos_irs + self.neg_irs = neg_irs + + def transform(self, score_track): + percentile_transformed_tracks = [] + for sliding_window_size in self.sliding_window_sizes: + window_sums_rows = window_sum_function(arrs=score_track) + transformed_track = [] + for row_idx, window_sums_row in enumerate(window_sums_rows): + transformed_row = np.zeros_like(window_sums_row) + + pos_val_indices = np.nonzero(window_sums_row > 0)[0] + pos_vals = window_sums_row[pos_val_indices] + transformed_pos_vals = pos_ir.transform(pos_vals) + transformed_row[pos_val_indices] = transformed_pos_vals + + neg_val_indices = np.nonzero(window_sums_row < 0) + neg_vals = window_sums_row[neg_val_indices] + transformed_neg_vals = neg_ir.transform(neg_vals) + transformed_row[neg_val_indices] = -transformed_neg_vals + + #add padding to make up for entries lost due to the sliding + # windows + transformed_row = np.pad(transformed_row, + pad_width=( + (int(sliding_window_size/2.0), + sliding_window_size-int(sliding_window_size/2.0)))) + assert len(transformed_row)==len(score_track[row_idx]) + transformed_track.append(transformed_row) + percentile_transformed_tracks.append(transformed_track) + #ultimately, return the result of taking the value that has + # the maximum absolute value over all the different transformed tracks + return [valatmaxabs( + np.array([percentile_transformed_tracks[i,j] + for i in range(len(percentile_transformed_tracks))])) + for j in range(len(score_track))] + + class FixedWindowAroundChunks(AbstractCoordProducer): count = 0 def __init__(self, sliding, @@ -387,42 +502,25 @@ def __call__(self, score_track, null_track, tnt_results=None): if (self.verbose): print("Generating null dist") sys.stdout.flush() - if (hasattr(null_track, '__call__')): - null_vals = null_track( - score_track=score_track, - windowsize=self.sliding, - original_summed_score_track=original_summed_score_track) - else: - null_summed_score_track = window_sum_function(arrs=null_track) - null_vals = list(np.concatenate(null_summed_score_track, axis=0)) + + null_vals = get_null_vals( + null_track=null_track, + score_track=score_track, + windowsize=self.sliding, + original_summed_score_track=original_summed_score_track) if (self.verbose): print("Computing threshold") sys.stdout.flush() - from sklearn.isotonic import IsotonicRegression orig_vals = list( np.concatenate(original_summed_score_track, axis=0)) - pos_orig_vals = np.array(sorted([x for x in orig_vals if x >= 0])) - neg_orig_vals = np.array(sorted([x for x in orig_vals if x < 0], - key=lambda x: abs(x))) - pos_null_vals = [x for x in null_vals if x >= 0] - neg_null_vals = [x for x in null_vals if x < 0] - pos_ir = IsotonicRegression().fit( - X=np.concatenate([pos_orig_vals,pos_null_vals], axis=0), - y=([1.0 for x in pos_orig_vals] - +[0.0 for x in pos_null_vals]), - sample_weight=([1.0 for x in pos_orig_vals]+ - [len(pos_orig_vals)/len(pos_null_vals) - for x in pos_null_vals])) + pos_ir, neg_ir, pos_orig_vals, neg_orig_vals =\ + get_isotonic_regression_classifier( + orig_vals=orig_vals, + null_vals=null_vals) + pos_val_precisions = pos_ir.transform(pos_orig_vals) if (len(neg_orig_vals) > 0): - neg_ir = IsotonicRegression(increasing=False).fit( - X=np.concatenate([neg_orig_vals,neg_null_vals], axis=0), - y=([1.0 for x in neg_orig_vals] - +[0.0 for x in neg_null_vals]), - sample_weight=([1.0 for x in neg_orig_vals]+ - [len(neg_orig_vals)/len(neg_null_vals) - for x in neg_null_vals])) neg_val_precisions = neg_ir.transform(neg_orig_vals) pos_threshold = ([x[1] for x in diff --git a/setup.py b/setup.py index d805d62..0c43c38 100644 --- a/setup.py +++ b/setup.py @@ -6,7 +6,7 @@ description='TF MOtif Discovery from Importance SCOres', long_description="""Algorithm for discovering consolidated patterns from base-pair-level importance scores""", url='https://github.com/kundajelab/tfmodisco', - version='0.5.9.1', + version='0.5.10.0', packages=find_packages(), package_data={ '': ['cluster/phenograph/louvain/*convert*', 'cluster/phenograph/louvain/*community*', 'cluster/phenograph/louvain/*hierarchy*'] From 50dbf76058e43630fcdcd790c9f08477869c5713 Mon Sep 17 00:00:00 2001 From: Avanti Shrikumar Date: Wed, 9 Dec 2020 09:49:14 -0800 Subject: [PATCH 04/30] bugfix --- modisco/coordproducers.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/modisco/coordproducers.py b/modisco/coordproducers.py index 54dde72..d5277e0 100644 --- a/modisco/coordproducers.py +++ b/modisco/coordproducers.py @@ -354,14 +354,14 @@ def valatmaxabs(arrs): class VariableWindowWidthPercentileTransform(object): - def __init__(sliding_window_sizes): + def __init__(self, sliding_window_sizes): self.sliding_window_sizes = sliding_window_sizes def compute_percentile_transform(window_size, score_track, null_track): window_sum_function = get_simple_window_sum_function(window_size) original_summed_score_track = window_sum_function(arrs=score_track) - def fit(self, score_track, null_track, tnt_results=None): + def fit(self, score_track, null_track): pos_irs = [] neg_irs = [] for sliding_window_size in self.sliding_window_sizes: From 6fa123c3e508173e00b359695ef0522f54e427c2 Mon Sep 17 00:00:00 2001 From: AvantiShri Date: Wed, 9 Dec 2020 12:31:40 -0800 Subject: [PATCH 05/30] periodic commit --- modisco/coordproducers.py | 72 ++++++++++++++++++++++++++------------- 1 file changed, 49 insertions(+), 23 deletions(-) diff --git a/modisco/coordproducers.py b/modisco/coordproducers.py index d5277e0..e7e39c0 100644 --- a/modisco/coordproducers.py +++ b/modisco/coordproducers.py @@ -318,11 +318,25 @@ def get_null_vals(null_track, score_track, windowsize, return null_vals -def get_isotonic_regression_classifier(orig_vals, null_vals): +def subsample_if_large(arr, subsample_cap): + if (len(arr) > subsample_cap): + print("Subsampling!") + sys.stdout.flush() + arr = np.random.RandomState(1234).choice(a=arr, size=subsample_cap, + replace=False) + return arr + + +def get_isotonic_regression_classifier(orig_vals, null_vals, + subsample_cap=100000): from sklearn.isotonic import IsotonicRegression - pos_orig_vals = np.array(sorted([x for x in orig_vals if x >= 0])) - neg_orig_vals = np.array(sorted([x for x in orig_vals if x < 0], - key=lambda x: abs(x))) + orig_vals = subsample_if_large(orig_vals, subsample_cap=subsample_cap) + null_vals = subsample_if_large(null_vals, subsample_cap=subsample_cap) + pos_orig_vals = ( + np.array(sorted([x for x in orig_vals if x >= 0]))) + neg_orig_vals = ( + np.array(sorted([x for x in orig_vals if x < 0], + key=lambda x: abs(x)))) pos_null_vals = [x for x in null_vals if x >= 0] neg_null_vals = [x for x in null_vals if x < 0] pos_ir = IsotonicRegression().fit( @@ -334,7 +348,8 @@ def get_isotonic_regression_classifier(orig_vals, null_vals): for x in pos_null_vals])) if (len(neg_orig_vals) > 0): - neg_ir = IsotonicRegression(increasing=False).fit( + neg_ir = IsotonicRegression(increasing=False, + out_of_bounds='clip').fit( X=np.concatenate([neg_orig_vals,neg_null_vals], axis=0), y=([1.0 for x in neg_orig_vals] +[0.0 for x in neg_null_vals]), @@ -349,7 +364,7 @@ def get_isotonic_regression_classifier(orig_vals, null_vals): def valatmaxabs(arrs): idxs = np.argmax(np.abs(arrs), axis=0) - return arrs[idxs, np.arange(len(arrs[0]))] + return arrs[idxs, np.arange(len(arrs[0]))], idxs class VariableWindowWidthPercentileTransform(object): @@ -357,24 +372,26 @@ class VariableWindowWidthPercentileTransform(object): def __init__(self, sliding_window_sizes): self.sliding_window_sizes = sliding_window_sizes - def compute_percentile_transform(window_size, score_track, null_track): - window_sum_function = get_simple_window_sum_function(window_size) - original_summed_score_track = window_sum_function(arrs=score_track) - def fit(self, score_track, null_track): pos_irs = [] neg_irs = [] for sliding_window_size in self.sliding_window_sizes: + window_sum_function = get_simple_window_sum_function( + sliding_window_size) print("Fitting - on window size",sliding_window_size) if (hasattr(null_track, '__call__')): null_vals = null_track( score_track=score_track, - windowsize=self.sliding) + windowsize=sliding_window_size) else: null_summed_score_track = window_sum_function(arrs=null_track) null_vals = list(np.concatenate(null_summed_score_track, axis=0)) + print("Computing window sums") + sys.stdout.flush() window_sums_rows = window_sum_function(arrs=score_track) + print("Done computing window sums") + sys.stdout.flush() pos_ir, neg_ir, _, _ = get_isotonic_regression_classifier( orig_vals=list( np.concatenate(window_sums_rows, axis=0)), @@ -386,7 +403,10 @@ def fit(self, score_track, null_track): def transform(self, score_track): percentile_transformed_tracks = [] - for sliding_window_size in self.sliding_window_sizes: + for sliding_window_size, pos_ir, neg_ir in zip( + self.sliding_window_sizes, self.pos_irs, self.neg_irs): + window_sum_function = get_simple_window_sum_function( + sliding_window_size) window_sums_rows = window_sum_function(arrs=score_track) transformed_track = [] for row_idx, window_sums_row in enumerate(window_sums_rows): @@ -397,26 +417,32 @@ def transform(self, score_track): transformed_pos_vals = pos_ir.transform(pos_vals) transformed_row[pos_val_indices] = transformed_pos_vals - neg_val_indices = np.nonzero(window_sums_row < 0) - neg_vals = window_sums_row[neg_val_indices] - transformed_neg_vals = neg_ir.transform(neg_vals) - transformed_row[neg_val_indices] = -transformed_neg_vals + neg_val_indices = np.nonzero(window_sums_row < 0)[0] + if (len(neg_val_indices) > 0 and neg_ir is not None): + neg_vals = window_sums_row[neg_val_indices] + transformed_neg_vals = neg_ir.transform(neg_vals) + transformed_row[neg_val_indices] = -transformed_neg_vals #add padding to make up for entries lost due to the sliding # windows transformed_row = np.pad(transformed_row, pad_width=( - (int(sliding_window_size/2.0), - sliding_window_size-int(sliding_window_size/2.0)))) - assert len(transformed_row)==len(score_track[row_idx]) + (int((sliding_window_size-1)/2.0), + (sliding_window_size-1) + -int((sliding_window_size-1)/2.0)))) + assert len(transformed_row)==len(score_track[row_idx]),\ + (len(transformed_row), len(score_track[row_idx])) transformed_track.append(transformed_row) percentile_transformed_tracks.append(transformed_track) #ultimately, return the result of taking the value that has # the maximum absolute value over all the different transformed tracks - return [valatmaxabs( - np.array([percentile_transformed_tracks[i,j] - for i in range(len(percentile_transformed_tracks))])) - for j in range(len(score_track))] + bestwindowvals = [valatmaxabs( + np.array([percentile_transformed_tracks[i][j] + for i in range(len(percentile_transformed_tracks))])) + for j in range(len(score_track))] + #return both the best window values AND the idx of the window size, + # as I think the latter is also helpful to know + return [x[0] for x in bestwindowvals], [x[1] for x in bestwindowvals] class FixedWindowAroundChunks(AbstractCoordProducer): From 6353c7713a964dde858785460b40b8b293241da0 Mon Sep 17 00:00:00 2001 From: AvantiShri Date: Sun, 13 Dec 2020 17:17:55 -0800 Subject: [PATCH 06/30] comitting code for variable-length seqlet identification --- modisco/coordproducers.py | 2 +- modisco/util.py | 13 ++++++++++--- 2 files changed, 11 insertions(+), 4 deletions(-) diff --git a/modisco/coordproducers.py b/modisco/coordproducers.py index e7e39c0..83c8bd1 100644 --- a/modisco/coordproducers.py +++ b/modisco/coordproducers.py @@ -339,7 +339,7 @@ def get_isotonic_regression_classifier(orig_vals, null_vals, key=lambda x: abs(x)))) pos_null_vals = [x for x in null_vals if x >= 0] neg_null_vals = [x for x in null_vals if x < 0] - pos_ir = IsotonicRegression().fit( + pos_ir = IsotonicRegression(out_of_bounds='clip').fit( X=np.concatenate([pos_orig_vals,pos_null_vals], axis=0), y=([1.0 for x in pos_orig_vals] +[0.0 for x in pos_null_vals]), diff --git a/modisco/util.py b/modisco/util.py index 42e7f58..a3a6eb9 100644 --- a/modisco/util.py +++ b/modisco/util.py @@ -377,9 +377,11 @@ def get_betas_from_tsne_conditional_probs(conditional_probs, def convert_to_percentiles(vals): to_return = np.zeros(len(vals)) - sorted_vals = sorted(enumerate(vals), key=lambda x: x[1]) - for sort_idx,(orig_idx,val) in enumerate(sorted_vals): - to_return[orig_idx] = sort_idx/float(len(vals)) + argsort = np.argsort(vals) + to_return[argsort] = np.arange(len(vals))/float(len(vals)) + #sorted_vals = sorted(enumerate(vals), key=lambda x: x[1]) + #for sort_idx,(orig_idx,val) in enumerate(sorted_vals): + # to_return[orig_idx] = sort_idx/float(len(vals)) return to_return @@ -475,6 +477,11 @@ def rolling_window(a, window): return np.lib.stride_tricks.as_strided(a, shape=shape, strides=strides) +def sliding_window_max(a, window): + rolling_windows_a = rolling_window(a, window) + return np.max(rolling_windows_a, axis=-1) + + def compute_masked_cosine_sim(imp_scores, onehot_seq, weightmat): strided_impscores = rolling_window( imp_scores.transpose((0,2,1)), From d587523ff90e7893c991989825fc1e5a6e9a4612 Mon Sep 17 00:00:00 2001 From: Avanti Shrikumar Date: Mon, 14 Dec 2020 17:20:56 -0800 Subject: [PATCH 07/30] periodic commit --- modisco/coordproducers.py | 28 ++++++++++++++++++++- modisco/value_provider.py | 53 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 80 insertions(+), 1 deletion(-) diff --git a/modisco/coordproducers.py b/modisco/coordproducers.py index d5277e0..8900e67 100644 --- a/modisco/coordproducers.py +++ b/modisco/coordproducers.py @@ -392,7 +392,7 @@ def transform(self, score_track): for row_idx, window_sums_row in enumerate(window_sums_rows): transformed_row = np.zeros_like(window_sums_row) - pos_val_indices = np.nonzero(window_sums_row > 0)[0] + pos_val_indices = np.nonzero(window_sums_row >= 0)[0] pos_vals = window_sums_row[pos_val_indices] transformed_pos_vals = pos_ir.transform(pos_vals) transformed_row[pos_val_indices] = transformed_pos_vals @@ -419,6 +419,32 @@ def transform(self, score_track): for j in range(len(score_track))] +class VariableWindowAroundChunks(AbstractCoordProducer): + count = 0 + def __init__(self, sliding, flank, suppress, target_fdr, + min_passing_windows_frac, max_passing_windows_frac, + separate_pos_neg_thresholds, + max_seqlets_total, + progress_update=5000, + verbose=True): + self.sliding = sliding + self.flank = flank + self.suppress = suppress + self.target_fdr = target_fdr + assert max_passing_windows_frac >= min_passing_windows_frac + self.min_passing_windows_frac = min_passing_windows_frac + self.max_passing_windows_frac = max_passing_windows_frac + self.separate_pos_neg_thresholds = separate_pos_neg_thresholds + self.max_seqlets_total = None + self.progress_update = progress_update + self.verbose = verbose + self.plot_save_dir = plot_save_dir + + def __call__(self, score_track, null_track, tnt_results=None): + + + + class FixedWindowAroundChunks(AbstractCoordProducer): count = 0 def __init__(self, sliding, diff --git a/modisco/value_provider.py b/modisco/value_provider.py index f727195..739626c 100644 --- a/modisco/value_provider.py +++ b/modisco/value_provider.py @@ -67,6 +67,59 @@ def from_hdf5(cls, grp): val_transformer=val_transformer) +class VariableWidthPrecTransformedValueProvider(AbstractValueProvider): + + def __init__(self, track_name, window_widths, pos_irs, neg_irs): + if isinstance(track_name, str): + self.track_name = track_name + else: + self.track_name = track_name.decode('utf-8') + self.window_widths = window_widths + self.pos_irs = pos_irs + self.neg_irs = neg_irs + + def __call__(self, seqlet): + val = self.get_val(seqlet=seqlet) + return self.val_transformer(val=val) + + def get_imp_around_central_window(self, seqlet, central_window): + flank_to_ignore = int(0.5*(len(seqlet)-central_window)) + track_values = seqlet[self.track_name]\ + .fwd[flank_to_ignore:(len(seqlet)-flank_to_ignore)] + return np.sum(track_values) + + def get_val(self, seqlet): + vals = [] + for window_width, pos_ir, neg_ir in self.window_widths: + imp = self.get_imp_around_central_window( + seqlet=seqlet, central_window=window_widths) + if (imp >= 0): + val = pos_ir.transform([imp])[0] + else: + val = -neg_ir.transform([imp])[0] + vals.append(val) + return vals[np.argmax(np.abs(vals))] + + def save_hdf5(self, grp): + grp.attrs["class"] = type(self).__name__ + grp.attrs["track_name"] = self.track_name + grp.attrs["central_window"] = self.central_window + self.val_transformer.save_hdf5(grp.create_group("val_transformer")) + + @classmethod + def from_hdf5(cls, grp): + if isinstance(grp.attrs["track_name"], str): + track_name = grp.attrs["track_name"] + else: + track_name = grp.attrs["track_name"].decode('utf-8') + central_window = grp.attrs["central_window"] + val_transformer = AbstractValTransformer.from_hdf5( + grp["val_transformer"]) + return cls(track_name=track_name, + central_window=central_window, + val_transformer=val_transformer) + + class AbstractValTransformer(object): def __call__(self, val): From 6f096e90c9e49390f96600a77fc9e48f12330ef9 Mon Sep 17 00:00:00 2001 From: Avanti Shrikumar Date: Tue, 15 Dec 2020 12:40:50 -0800 Subject: [PATCH 08/30] in progress --- modisco/coordproducers.py | 194 +++++++++++++++++++++++--------------- modisco/util.py | 14 +++ modisco/value_provider.py | 29 ++++-- 3 files changed, 151 insertions(+), 86 deletions(-) diff --git a/modisco/coordproducers.py b/modisco/coordproducers.py index 9c696e2..2c480ac 100644 --- a/modisco/coordproducers.py +++ b/modisco/coordproducers.py @@ -327,6 +327,35 @@ def subsample_if_large(arr, subsample_cap): return arr +class SavableIsotonicRegression(object): + + def __init__(self, origvals, nullvals, increasing): + self.origvals = origvals + self.nullvals = nullvals + self.increasing = increasing + self.ir = IsotonicRegression(out_of_bounds='clip').fit( + X=np.concatenate([self.origvals, self.nullvals], axis=0), + y=([1.0 for x in self.origvals] + [0.0 for x in self.nullvals]), + sample_weight=([1.0 for x in self.origvals] + +[float(len(self.origvals))/len(self.nullvals) + for x in self.origvals])) + + def transform(self, vals): + return self.ir.transform(vals) + + def save_hdf5(self, grp): + grp.attrs['increasing'] = self.increasing + grp.create_dataset('origvals', data=self.origvals) + grp.create_dataset('nullvals', data=self.nullvals) + + @classmethod + def from_hdf5(cls, grp): + increase = grp.attrs['increasing'] + origvals = np.array(grp['origvals']) + nullvals = np.array(grp['nullvals']) + return cls(origvals=origvals, nullvals=nullvals, increasing=increasing) + + def get_isotonic_regression_classifier(orig_vals, null_vals, subsample_cap=100000): from sklearn.isotonic import IsotonicRegression @@ -339,23 +368,12 @@ def get_isotonic_regression_classifier(orig_vals, null_vals, key=lambda x: abs(x)))) pos_null_vals = [x for x in null_vals if x >= 0] neg_null_vals = [x for x in null_vals if x < 0] - pos_ir = IsotonicRegression(out_of_bounds='clip').fit( - X=np.concatenate([pos_orig_vals,pos_null_vals], axis=0), - y=([1.0 for x in pos_orig_vals] - +[0.0 for x in pos_null_vals]), - sample_weight=([1.0 for x in pos_orig_vals]+ - [len(pos_orig_vals)/len(pos_null_vals) - for x in pos_null_vals])) + pos_ir = SavableIsotonicRegression(origvals=pos_orig_vals, + nullvals=pos_null_vals, increasing=True) if (len(neg_orig_vals) > 0): - neg_ir = IsotonicRegression(increasing=False, - out_of_bounds='clip').fit( - X=np.concatenate([neg_orig_vals,neg_null_vals], axis=0), - y=([1.0 for x in neg_orig_vals] - +[0.0 for x in neg_null_vals]), - sample_weight=([1.0 for x in neg_orig_vals]+ - [len(neg_orig_vals)/len(neg_null_vals) - for x in neg_null_vals])) + neg_ir = SavableIsotonicRegression(origvals=pos_orig_vals, + nullvals=pos_null_vals, increasing=False) else: neg_ir = None @@ -445,6 +463,7 @@ def transform(self, score_track): return [x[0] for x in bestwindowvals], [x[1] for x in bestwindowvals] +#sliding in this case would be a list of values class VariableWindowAroundChunks(AbstractCoordProducer): count = 0 def __init__(self, sliding, flank, suppress, target_fdr, @@ -454,6 +473,8 @@ def __init__(self, sliding, flank, suppress, target_fdr, progress_update=5000, verbose=True): self.sliding = sliding + self.percentile_transformer = VariableWindowWidthPercentileTransform( + sliding_window_sizes=self.sliding) self.flank = flank self.suppress = suppress self.target_fdr = target_fdr @@ -467,9 +488,78 @@ def __init__(self, sliding, flank, suppress, target_fdr, self.plot_save_dir = plot_save_dir def __call__(self, score_track, null_track, tnt_results=None): - + if (tnt_results is None): + self.percentile_transformer.fit(score_track=score_track, + null_track=null_track) + transformed_score_track =\ + self.percentile_transformer.transform(score_track=score_track) + + +def identify_coords(score_track, pos_threshold, neg_threshold, + windowsize, flank, suppress, max_seqlets_total, verbose): + + #cp_score_track = 'copy' of the score track, which can be modified as + # coordinates are identified + cp_score_track = [np.array(x) for x in score_track] + #if a position is less than the threshold, set it to -np.inf + cp_score_track = [ + np.array([np.abs(y) if (y > pos_threshold + or y < neg_threshold) + else -np.inf for y in x]) + for x in cp_score_track] + + coords = [] + for example_idx,single_score_track in enumerate(cp_score_track): + #set the stuff near the flanks to -np.inf so that we + # don't pick it up during argmax + single_score_track[0:flank] = -np.inf + single_score_track[len(single_score_track)-(flank): + len(single_score_track)] = -np.inf + while True: + argmax = np.argmax(single_score_track,axis=0) + max_val = single_score_track[argmax] + + #bail if exhausted everything that passed the threshold + #and was not suppressed + if (max_val == -np.inf): + break + + #need to be able to expand without going off the edge + if ((argmax >= flank) and + (argmax < (len(single_score_track)-flank))): + + coord = SeqletCoordsFWAP( + example_idx=example_idx, + start=argmax-flank, + end=argmax+windowsize+flank, + score=score_track[example_idx][argmax]) + assert (coord.score > pos_threshold + or coord.score < neg_threshold) + coords.append(coord) + else: + assert False,\ + ("This shouldn't happen because I set stuff near the" + "border to -np.inf early on") + #suppress the chunks within +- suppress + left_supp_idx = int(max(np.floor(argmax+0.5-suppress),0)) + right_supp_idx = int(min(np.ceil(argmax+0.5+suppress), + len(single_score_track))) + single_score_track[left_supp_idx:right_supp_idx] = -np.inf + + if (verbose): + print("Got "+str(len(coords))+" coords") + sys.stdout.flush() - + if ((max_seqlets_total is not None) and + len(coords) > max_seqlets_total): + if (verbose): + print("Limiting to top "+str(max_seqlets_total)) + sys.stdout.flush() + coords = sorted(coords, key=lambda x: -np.abs(x.score))\ + [:max_seqlets_total] + + return coords + class FixedWindowAroundChunks(AbstractCoordProducer): count = 0 @@ -699,68 +789,16 @@ def __call__(self, score_track, null_track, tnt_results=None): transformed_pos_threshold=val_transformer(pos_threshold), val_transformer=val_transformer) - neg_threshold = tnt_results.neg_threshold - pos_threshold = tnt_results.pos_threshold - - summed_score_track = [np.array(x) for x in original_summed_score_track] - - #if a position is less than the threshold, set it to -np.inf - summed_score_track = [ - np.array([np.abs(y) if (y > pos_threshold - or y < neg_threshold) - else -np.inf for y in x]) - for x in summed_score_track] - - coords = [] - for example_idx,single_score_track in enumerate(summed_score_track): - #set the stuff near the flanks to -np.inf so that we - # don't pick it up during argmax - single_score_track[0:self.flank] = -np.inf - single_score_track[len(single_score_track)-(self.flank): - len(single_score_track)] = -np.inf - while True: - argmax = np.argmax(single_score_track,axis=0) - max_val = single_score_track[argmax] - - #bail if exhausted everything that passed the threshold - #and was not suppressed - if (max_val == -np.inf): - break - - #need to be able to expand without going off the edge - if ((argmax >= self.flank) and - (argmax < (len(single_score_track)-self.flank))): - - coord = SeqletCoordsFWAP( - example_idx=example_idx, - start=argmax-self.flank, - end=argmax+self.sliding+self.flank, - score=original_summed_score_track[example_idx][argmax]) - assert (coord.score > pos_threshold - or coord.score < neg_threshold) - coords.append(coord) - else: - assert False,\ - ("This shouldn't happen because I set stuff near the" - "border to -np.inf early on") - #suppress the chunks within +- self.suppress - left_supp_idx = int(max(np.floor(argmax+0.5-self.suppress), - 0)) - right_supp_idx = int(min(np.ceil(argmax+0.5+self.suppress), - len(single_score_track))) - single_score_track[left_supp_idx:right_supp_idx] = -np.inf - - if (self.verbose): - print("Got "+str(len(coords))+" coords") - sys.stdout.flush() + coords = identify_coords( + score_track=original_summed_score_track, + pos_threshold=tnt_results.pos_threshold, + neg_threshold=tnt_results.neg_threshold, + windowsize=self.sliding, + flank=self.flank, + suppress=self.suppress, + max_seqlets_total=self.max_seqlets_total, + verbose=self.verbose) - if ((self.max_seqlets_total is not None) and - len(coords) > self.max_seqlets_total): - if (self.verbose): - print("Limiting to top "+str(self.max_seqlets_total)) - sys.stdout.flush() - coords = sorted(coords, key=lambda x: -np.abs(x.score))\ - [:self.max_seqlets_total] return CoordProducerResults( coords=coords, tnt_results=tnt_results) diff --git a/modisco/util.py b/modisco/util.py index a3a6eb9..4965973 100644 --- a/modisco/util.py +++ b/modisco/util.py @@ -53,6 +53,20 @@ def save_seqlet_coords(seqlets, dset_name, grp): dset_name=dset_name, grp=grp) +def save_list_of_objects(grp, list_of_objects): + grp.attrs["num_objects"] = len(list_of_objects) + for idx,obj in enumerate(list_of_objects): + obj.save_hdf5(grp=grp.create_group("obj"+str(idx))) + + +def load_list_of_objects(grp, obj_class): + num_objects = grp.attrs["num_objects"] + list_of_objects = [] + for idx in range(num_objects): + list_of_objects.append(obj_class.from_hdf5(grp=grp["obj"+str(idx)])) + return list_of_objects + + def factorial(val): to_return = 1 for i in range(1,val+1): diff --git a/modisco/value_provider.py b/modisco/value_provider.py index 739626c..1775aa3 100644 --- a/modisco/value_provider.py +++ b/modisco/value_provider.py @@ -1,6 +1,7 @@ from __future__ import division, print_function, absolute_import import numpy as np import scipy.stats +from modisco import util class AbstractValueProvider(object): @@ -103,21 +104,27 @@ def get_val(self, seqlet): def save_hdf5(self, grp): grp.attrs["class"] = type(self).__name__ grp.attrs["track_name"] = self.track_name - grp.attrs["central_window"] = self.central_window - self.val_transformer.save_hdf5(grp.create_group("val_transformer")) + grp.create_dataset("window_widths", data=np.array(self.window_widths)) + util.save_list_of_objects(grp=grp.create_group("pos_irs"), + list_of_objects=self.pos_irs) + util.save_list_of_objects(grp=grp.create_group("neg_irs"), + list_of_objects=self.neg_irs) @classmethod def from_hdf5(cls, grp): + from .coordproducers import SavableIsotonicRegression if isinstance(grp.attrs["track_name"], str): track_name = grp.attrs["track_name"] else: track_name = grp.attrs["track_name"].decode('utf-8') - central_window = grp.attrs["central_window"] - val_transformer = AbstractValTransformer.from_hdf5( - grp["val_transformer"]) - return cls(track_name=track_name, - central_window=central_window, - val_transformer=val_transformer) + window_widths = np.array(grp["window_widths"]).astype("int") + pos_irs = util.load_list_of_objects( + grp=grp["pos_irs"], obj_class=SavableIsotonicRegression) + neg_irs = util.load_list_of_objects( + grp=grp["neg_irs"], obj_class=SavableIsotonicRegression) + + return cls(track_name=track_name, window_widths=window_widths, + pos_irs=pos_irs, neg_irs=neg_irs) class AbstractValTransformer(object): @@ -131,6 +138,12 @@ def from_hdf5(cls, grp): return the_class.from_hdf5(grp) +class IdentityFunctionValTransformer(AbstractValTransformer) + + def __call__(self, val): + return val + + class AbsPercentileValTransformer(AbstractValTransformer): def __init__(self, distribution): From ff7abee0eebb8fb25c64bd6c659ebf304faa8755 Mon Sep 17 00:00:00 2001 From: Avanti Shrikumar Date: Tue, 15 Dec 2020 17:37:31 -0800 Subject: [PATCH 09/30] periodic commit --- modisco/coordproducers.py | 382 +++++++++++++++---------- modisco/tfmodisco_workflow/workflow.py | 51 ++-- modisco/value_provider.py | 163 +++++++---- 3 files changed, 370 insertions(+), 226 deletions(-) diff --git a/modisco/coordproducers.py b/modisco/coordproducers.py index 2c480ac..556b6af 100644 --- a/modisco/coordproducers.py +++ b/modisco/coordproducers.py @@ -2,18 +2,74 @@ from .core import SeqletCoordinates from modisco import util import numpy as np -from collections import defaultdict, Counter +from collections import defaultdict, Counter, OrderedDict import itertools from sklearn.neighbors.kde import KernelDensity import sys import time from .value_provider import ( AbstractValTransformer, AbsPercentileValTransformer, - SignedPercentileValTransformer) + SignedPercentileValTransformer, PrecisionValTransformer) import scipy -class TransformAndThresholdResults(object): +SUBSAMPLE_CAP = 1000000 + + +#The only parts of TransformAndThresholdResults that are used in +# TfModiscoWorkflow are the transformed_pos/neg_thresholds and the +# val_transformer (used in metaclustering with multiple tasks) +#TransformAndThresholdResults are also used to be +# able to replicate the same procedure used for identifying coordinates as +# when TfMoDisco was first run; the information needed in that case would +# be specific to the type of Coordproducer used +class AbstractTransformAndThresholdResults( + + def __init__(self, transformed_neg_threshold, transformed_pos_threshold, + val_transformer): + self.transformed_neg_threshold = transformed_neg_threshold + self.transformed_pos_threshold = transformed_pos_threshold + self.val_transformer = val_transformer + + @classmethod + def from_hdf5(cls, grp): + the_class = eval(grp.attrs["class"]) + if (the_class.__name__ != cls.__name__): + return the_class.from_hdf5(grp) + + +class BasicTransformAndThresholdResults(AbstractTransformAndThresholdResults): + + def save_hdf5(self, grp): + grp.attrs["class"] = type(self).__name__ + grp.attrs["transformed_neg_threshold"] = self.transformed_neg_threshold + grp.attrs["transformed_pos_threshold"] = self.transformed_pos_threshold + self.val_transformer.save_hdf5(grp.create_group("val_transformer")) + + @classmethod + def load_basic_attrs_from_hdf5(cls, grp): + transformed_neg_threshold = grp.attrs['transformed_neg_threshold'] + transformed_pos_threshold = grp.attrs['transformed_pos_threshold'] + val_transformer = AbstractValTransformer.from_hdf5( + grp["val_transformer"]) + return (transformed_neg_threshold, transformed_pos_threshold, + val_transformer) + + @classmethod + def from_hdf5(cls, grp): + the_class = eval(grp.attrs["class"]) + (transformed_neg_threshold, + transformed_pos_threshold, + val_transformer) = cls.load_basic_attrs_from_hdf5(grp) + return cls(transformed_neg_threshold=transformed_neg_threshold, + transformed_pos_threshold=transformed_pos_threshold, + val_transformer=val_transformer) + + +#FWAC = FixedWindowAroundChunks; this TransformAndThresholdResults object +# is specific to the type of info needed in that case. +class FWACTransformAndThresholdResults( + BasicTransformAndThresholdResults): def __init__(self, neg_threshold, transformed_neg_threshold, @@ -25,26 +81,23 @@ def __init__(self, neg_threshold, # transformed distribution used to set the threshold, e.g. a # cdf value self.neg_threshold = neg_threshold - self.transformed_neg_threshold = transformed_neg_threshold self.pos_threshold = pos_threshold - self.transformed_pos_threshold = transformed_pos_threshold - self.val_transformer = val_transformer + super(FWACTransformAndThresholdResults, self).__init__( + transformed_neg_threshold=transformed_neg_threshold, + transformed_pos_threshold=transformed_pos_threshold, + val_transformer=val_transformer) def save_hdf5(self, grp): + super(FWACTransformAndThresholdResults, self).save_hdf5(grp) grp.attrs["neg_threshold"] = self.neg_threshold - grp.attrs["transformed_neg_threshold"] = self.transformed_neg_threshold grp.attrs["pos_threshold"] = self.pos_threshold - grp.attrs["transformed_pos_threshold"] = self.transformed_pos_threshold - self.val_transformer.save_hdf5(grp.create_group("val_transformer")) @classmethod def from_hdf5(cls, grp): + (transformed_neg_threshold, transformed_pos_threshold, + val_transformer) = cls.load_basic_attrs_from_hdf5(grp) neg_threshold = grp.attrs['neg_threshold'] - transformed_neg_threshold = grp.attrs['transformed_neg_threshold'] pos_threshold = grp.attrs['pos_threshold'] - transformed_pos_threshold = grp.attrs['transformed_pos_threshold'] - val_transformer = AbstractValTransformer.from_hdf5( - grp["val_transformer"]) return cls(neg_threshold=neg_threshold, transformed_neg_threshold=transformed_neg_threshold, pos_threshold=pos_threshold, @@ -67,8 +120,9 @@ class SeqletCoordsFWAP(SeqletCoordinates): """ Coordinates for the FixedWindowAroundChunks CoordProducer """ - def __init__(self, example_idx, start, end, score): + def __init__(self, example_idx, start, end, score, other_info={}): self.score = score + self.other_info = other_info super(SeqletCoordsFWAP, self).__init__( example_idx=example_idx, start=start, end=end, @@ -86,7 +140,7 @@ def from_hdf5(cls, grp): coord_strings = util.load_string_list(dset_name="coords", grp=grp) coords = [SeqletCoordinates.from_string(x) for x in coord_strings] - tnt_results = TransformAndThresholdResults.from_hdf5( + tnt_results = AbstractTransformAndThresholdResults.from_hdf5( grp["tnt_results"]) return CoordProducerResults(coords=coords, tnt_results=tnt_results) @@ -318,11 +372,11 @@ def get_null_vals(null_track, score_track, windowsize, return null_vals -def subsample_if_large(arr, subsample_cap): - if (len(arr) > subsample_cap): +def subsample_if_large(arr): + if (len(arr) > SUBSAMPLE_CAP): print("Subsampling!") sys.stdout.flush() - arr = np.random.RandomState(1234).choice(a=arr, size=subsample_cap, + arr = np.random.RandomState(1234).choice(a=arr, size=SUBSAMPLE_CAP, replace=False) return arr @@ -356,11 +410,10 @@ def from_hdf5(cls, grp): return cls(origvals=origvals, nullvals=nullvals, increasing=increasing) -def get_isotonic_regression_classifier(orig_vals, null_vals, - subsample_cap=100000): +def get_isotonic_regression_classifier(orig_vals, null_vals): from sklearn.isotonic import IsotonicRegression - orig_vals = subsample_if_large(orig_vals, subsample_cap=subsample_cap) - null_vals = subsample_if_large(null_vals, subsample_cap=subsample_cap) + orig_vals = subsample_if_large(orig_vals) + null_vals = subsample_if_large(null_vals) pos_orig_vals = ( np.array(sorted([x for x in orig_vals if x >= 0]))) neg_orig_vals = ( @@ -377,7 +430,7 @@ def get_isotonic_regression_classifier(orig_vals, null_vals, else: neg_ir = None - return pos_ir, neg_ir, pos_orig_vals, neg_orig_vals + return pos_ir, neg_ir, orig_vals, pos_orig_vals, neg_orig_vals def valatmaxabs(arrs): @@ -385,12 +438,29 @@ def valatmaxabs(arrs): return arrs[idxs, np.arange(len(arrs[0]))], idxs -class VariableWindowWidthPercentileTransform(object): - - def __init__(self, sliding_window_sizes): - self.sliding_window_sizes = sliding_window_sizes +#sliding in this case would be a list of values +class VariableWindowAroundChunks(AbstractCoordProducer): + count = 0 + def __init__(self, sliding, flank, suppress, target_fdr, + min_passing_windows_frac, max_passing_windows_frac, + separate_pos_neg_thresholds, + max_seqlets_total, + progress_update=5000, + verbose=True): + self.sliding = sliding + self.flank = flank + self.suppress = suppress + self.target_fdr = target_fdr + assert max_passing_windows_frac >= min_passing_windows_frac + self.min_passing_windows_frac = min_passing_windows_frac + self.max_passing_windows_frac = max_passing_windows_frac + self.separate_pos_neg_thresholds = separate_pos_neg_thresholds + self.max_seqlets_total = None + self.progress_update = progress_update + self.verbose = verbose + self.plot_save_dir = plot_save_dir - def fit(self, score_track, null_track): + def fit_pos_and_neg_irs(self, score_track, null_track): pos_irs = [] neg_irs = [] for sliding_window_size in self.sliding_window_sizes: @@ -410,93 +480,81 @@ def fit(self, score_track, null_track): window_sums_rows = window_sum_function(arrs=score_track) print("Done computing window sums") sys.stdout.flush() - pos_ir, neg_ir, _, _ = get_isotonic_regression_classifier( + pos_ir, neg_ir, _, _, _ = get_isotonic_regression_classifier( orig_vals=list( np.concatenate(window_sums_rows, axis=0)), null_vals=null_vals) pos_irs.append(pos_ir) neg_irs.append(neg_ir) - self.pos_irs = pos_irs - self.neg_irs = neg_irs - - def transform(self, score_track): - percentile_transformed_tracks = [] - for sliding_window_size, pos_ir, neg_ir in zip( - self.sliding_window_sizes, self.pos_irs, self.neg_irs): - window_sum_function = get_simple_window_sum_function( - sliding_window_size) - window_sums_rows = window_sum_function(arrs=score_track) - transformed_track = [] - for row_idx, window_sums_row in enumerate(window_sums_rows): - transformed_row = np.zeros_like(window_sums_row) - - pos_val_indices = np.nonzero(window_sums_row >= 0)[0] - pos_vals = window_sums_row[pos_val_indices] - transformed_pos_vals = pos_ir.transform(pos_vals) - transformed_row[pos_val_indices] = transformed_pos_vals - - neg_val_indices = np.nonzero(window_sums_row < 0)[0] - if (len(neg_val_indices) > 0 and neg_ir is not None): - neg_vals = window_sums_row[neg_val_indices] - transformed_neg_vals = neg_ir.transform(neg_vals) - transformed_row[neg_val_indices] = -transformed_neg_vals - - #add padding to make up for entries lost due to the sliding - # windows - transformed_row = np.pad(transformed_row, - pad_width=( - (int((sliding_window_size-1)/2.0), - (sliding_window_size-1) - -int((sliding_window_size-1)/2.0)))) - assert len(transformed_row)==len(score_track[row_idx]),\ - (len(transformed_row), len(score_track[row_idx])) - transformed_track.append(transformed_row) - percentile_transformed_tracks.append(transformed_track) - #ultimately, return the result of taking the value that has - # the maximum absolute value over all the different transformed tracks - bestwindowvals = [valatmaxabs( - np.array([percentile_transformed_tracks[i][j] - for i in range(len(percentile_transformed_tracks))])) - for j in range(len(score_track))] - #return both the best window values AND the idx of the window size, - # as I think the latter is also helpful to know - return [x[0] for x in bestwindowvals], [x[1] for x in bestwindowvals] - - -#sliding in this case would be a list of values -class VariableWindowAroundChunks(AbstractCoordProducer): - count = 0 - def __init__(self, sliding, flank, suppress, target_fdr, - min_passing_windows_frac, max_passing_windows_frac, - separate_pos_neg_thresholds, - max_seqlets_total, - progress_update=5000, - verbose=True): - self.sliding = sliding - self.percentile_transformer = VariableWindowWidthPercentileTransform( - sliding_window_sizes=self.sliding) - self.flank = flank - self.suppress = suppress - self.target_fdr = target_fdr - assert max_passing_windows_frac >= min_passing_windows_frac - self.min_passing_windows_frac = min_passing_windows_frac - self.max_passing_windows_frac = max_passing_windows_frac - self.separate_pos_neg_thresholds = separate_pos_neg_thresholds - self.max_seqlets_total = None - self.progress_update = progress_update - self.verbose = verbose - self.plot_save_dir = plot_save_dir + return pos_irs, neg_irs def __call__(self, score_track, null_track, tnt_results=None): if (tnt_results is None): - self.percentile_transformer.fit(score_track=score_track, - null_track=null_track) - transformed_score_track =\ - self.percentile_transformer.transform(score_track=score_track) + pos_irs, neg_irs = self.fit_pos_and_neg_irs( + score_track=score_track, + null_track=null_track) + precision_transformer = PrecisionValTransformer( + pos_irs=pos_irs, + neg_irs=neg_irs) + (precisiontransformed_score_track, + precisiontransformed_bestwindowsizeidxs) =\ + precision_transformer.transform_score_track( + score_track=score_track) + + subsampled_prec_vals = subsample_if_large( + precisiontransformed_score_track.ravel()) + + #Pick a threshold according the the precisiontransformed score track + pos_threshold = TODO + neg_threshold = TODO + + pos_threshold, neg_threshold =\ + refine_thresholds_based_on_frac_passing( + vals=subsampled_prec_vals, + pos_threshold=pos_threshold, + neg_threshold=neg_threshold, + min_passing_windows_frac=self.min_passing_windows_frac, + max_passing_windows_frac=self.max_passing_windows_frac, + separate_pos_neg_thresholds) + + tnt_results = BasicTransformAndThresholdResults( + transformed_neg_threshold=pos_threshold, + transformed_pos_threshold=neg_threshold, + val_transformer=precision_transformer) + else: + precision_transformer = tnt_results.precision_transformer + (precisiontransformed_score_track, + precisiontransformed_bestwindowsizeidxs) =\ + precision_transformer.transform_score_track( + score_track=score_track) + + #TODO: look into padding situation + assert False #look into padding situation...identify_coords + #is expecting something that has already been processed with + #sliding windows of size windowsize + coords = identify_coords( + score_track=precisiontransformed_score_track, + pos_threshold=tnt_results.transformed_pos_threshold, + neg_threshold=tnt_results.transformed_neg_threshold, + windowsize=max(self.sliding), + flank=self.flank, + suppress=self.suppress, + max_seqlets_total=self.max_seqlets_total, + verbose=self.verbose, + other_info_tracks={'best_window_idx': + precisiontransformed_bestwindowsizeidxs}) + + return CoordProducerResults( + coords=coords, + tnt_results=tnt_results) + +#identify_coords is expecting something that has already been processed +# with sliding windows of size windowsize def identify_coords(score_track, pos_threshold, neg_threshold, - windowsize, flank, suppress, max_seqlets_total, verbose): + windowsize, flank, suppress, + max_seqlets_total, verbose, other_info_tracks={}): #cp_score_track = 'copy' of the score track, which can be modified as # coordinates are identified @@ -532,7 +590,10 @@ def identify_coords(score_track, pos_threshold, neg_threshold, example_idx=example_idx, start=argmax-flank, end=argmax+windowsize+flank, - score=score_track[example_idx][argmax]) + score=score_track[example_idx][argmax], + other_info = dict([ + (track_name, track[example_idx][argmax]) + for (track_name, track) in other_info_tracks.items()])) assert (coord.score > pos_threshold or coord.score < neg_threshold) coords.append(coord) @@ -559,6 +620,60 @@ def identify_coords(score_track, pos_threshold, neg_threshold, [:max_seqlets_total] return coords + + +def refine_thresholds_based_on_frac_passing( + vals, pos_threshold, neg_threshold, + min_passing_windows_frac, max_passing_windows_frac, + separate_pos_neg_thresholds, verbose): + + frac_passing_windows =( + sum(orig_vals >= pos_threshold) + + sum(orig_vals <= neg_threshold))/float(len(orig_vals)) + + if (verbose): + print("Thresholds from null dist were", + neg_threshold," and ",pos_threshold) + + #adjust the thresholds if the fall outside the min/max + # windows frac + if (frac_passing_windows < min_passing_windows_frac): + if (verbose): + print("Passing windows frac was", + frac_passing_windows,", which is below ", + min_passing_windows_frac,"; adjusting") + if (separate_pos_neg_thresholds): + pos_threshold = np.percentile( + a=[x for x in orig_vals if x > 0], + q=100*(1-min_passing_windows_frac)) + neg_threshold = np.percentile( + a=[x for x in orig_vals if x < 0], + q=100*(min_passing_windows_frac)) + else: + pos_threshold = np.percentile( + a=np.abs(orig_vals), + q=100*(1-min_passing_windows_frac)) + neg_threshold = -pos_threshold + + if (frac_passing_windows > max_passing_windows_frac): + if (verbose): + print("Passing windows frac was", + frac_passing_windows,", which is above ", + max_passing_windows_frac,"; adjusting") + if (separate_pos_neg_thresholds): + pos_threshold = np.percentile( + a=[x for x in orig_vals if x > 0], + q=100*(1-max_passing_windows_frac)) + neg_threshold = np.percentile( + a=[x for x in orig_vals if x < 0], + q=100*(max_passing_windows_frac)) + else: + pos_threshold = np.percentile( + a=np.abs(orig_vals), + q=100*(1-max_passing_windows_frac)) + neg_threshold = -pos_threshold + + return pos_threshold, neg_threshold class FixedWindowAroundChunks(AbstractCoordProducer): @@ -656,7 +771,9 @@ def __call__(self, score_track, null_track, tnt_results=None): sys.stdout.flush() orig_vals = list( np.concatenate(original_summed_score_track, axis=0)) - pos_ir, neg_ir, pos_orig_vals, neg_orig_vals =\ + + #Note that orig_vals may have been subsampled at this point + pos_ir, neg_ir, subsampled_orig_vals =\ get_isotonic_regression_classifier( orig_vals=orig_vals, null_vals=null_vals) @@ -674,50 +791,15 @@ def __call__(self, score_track, null_track, tnt_results=None): >= (1-self.target_fdr)]+[neg_orig_vals[-1]])[0] else: neg_threshold = -np.inf - frac_passing_windows =( - sum(pos_orig_vals >= pos_threshold) - + sum(neg_orig_vals <= neg_threshold))/float(len(orig_vals)) - - if (self.verbose): - print("Thresholds from null dist were", - neg_threshold," and ",pos_threshold) - #adjust the thresholds if the fall outside the min/max - # windows frac - if (frac_passing_windows < self.min_passing_windows_frac): - if (self.verbose): - print("Passing windows frac was", - frac_passing_windows,", which is below ", - self.min_passing_windows_frac,"; adjusting") - if (self.separate_pos_neg_thresholds): - pos_threshold = np.percentile( - a=[x for x in orig_vals if x > 0], - q=100*(1-self.min_passing_windows_frac)) - neg_threshold = np.percentile( - a=[x for x in orig_vals if x < 0], - q=100*(self.min_passing_windows_frac)) - else: - pos_threshold = np.percentile( - a=np.abs(orig_vals), - q=100*(1-self.min_passing_windows_frac)) - neg_threshold = -pos_threshold - if (frac_passing_windows > self.max_passing_windows_frac): - if (self.verbose): - print("Passing windows frac was", - frac_passing_windows,", which is above ", - self.max_passing_windows_frac,"; adjusting") - if (self.separate_pos_neg_thresholds): - pos_threshold = np.percentile( - a=[x for x in orig_vals if x > 0], - q=100*(1-self.max_passing_windows_frac)) - neg_threshold = np.percentile( - a=[x for x in orig_vals if x < 0], - q=100*(self.max_passing_windows_frac)) - else: - pos_threshold = np.percentile( - a=np.abs(orig_vals), - q=100*(1-self.max_passing_windows_frac)) - neg_threshold = -pos_threshold + pos_threshold, neg_threshold =\ + refine_thresholds_based_on_frac_passing( + vals=subsampled_orig_vals, + pos_threshold=pos_threshold, + neg_threshold=neg_threshold, + min_passing_windows_frac=self.min_passing_windows_frac, + max_passing_windows_frac=self.max_passing_windows_frac, + separate_pos_neg_thresholds) if (self.separate_pos_neg_thresholds): val_transformer = SignedPercentileValTransformer( @@ -782,7 +864,7 @@ def __call__(self, score_track, null_track, tnt_results=None): print("saving plot to " + fname) FixedWindowAroundChunks.count += 1 - tnt_results = TransformAndThresholdResults( + tnt_results = FWACTransformAndThresholdResults( neg_threshold=neg_threshold, transformed_neg_threshold=val_transformer(neg_threshold), pos_threshold=pos_threshold, diff --git a/modisco/tfmodisco_workflow/workflow.py b/modisco/tfmodisco_workflow/workflow.py index f505861..5af68d4 100644 --- a/modisco/tfmodisco_workflow/workflow.py +++ b/modisco/tfmodisco_workflow/workflow.py @@ -166,7 +166,7 @@ class TfModiscoWorkflow(object): def __init__(self, seqlets_to_patterns_factory= seqlets_to_patterns.TfModiscoSeqletsToPatternsFactory(), - sliding_window_size=21, flank_size=10, + sliding_window_size=[5,9,13,17,21], flank_size=10, overlap_portion=0.5, min_metacluster_size=100, min_metacluster_size_frac=0.01, @@ -222,18 +222,32 @@ def __call__(self, task_names, contrib_scores, plot_save_dir="figures"): print_memory_use() - self.coord_producer = coordproducers.FixedWindowAroundChunks( - sliding=self.sliding_window_size, - flank=self.flank_size, - suppress=(int(0.5*self.sliding_window_size) - + self.flank_size), - target_fdr=self.target_seqlet_fdr, - min_passing_windows_frac=self.min_passing_windows_frac, - max_passing_windows_frac=self.max_passing_windows_frac, - separate_pos_neg_thresholds=self.separate_pos_neg_thresholds, - max_seqlets_total=None, - verbose=self.verbose, - plot_save_dir=plot_save_dir) + if (hasattr(self.sliding_window_size, '__iter__')): + self.coord_producer = coordproducers.VariableWindowAroundChunks( + sliding=self.sliding_window_size, + flank=self.flank_size, + suppress=(int(0.5*max(self.sliding_window_size)) + + self.flank_size), + target_fdr=self.target_seqlet_fdr, + min_passing_windows_frac=self.min_passing_windows_frac, + max_passing_windows_frac=self.max_passing_windows_frac, + separate_pos_neg_thresholds=self.separate_pos_neg_thresholds, + max_seqlets_total=None, + verbose=self.verbose, + plot_save_dir=plot_save_dir) + else: + self.coord_producer = coordproducers.FixedWindowAroundChunks( + sliding=self.sliding_window_size, + flank=self.flank_size, + suppress=(int(0.5*self.sliding_window_size) + + self.flank_size), + target_fdr=self.target_seqlet_fdr, + min_passing_windows_frac=self.min_passing_windows_frac, + max_passing_windows_frac=self.max_passing_windows_frac, + separate_pos_neg_thresholds=self.separate_pos_neg_thresholds, + max_seqlets_total=None, + verbose=self.verbose, + plot_save_dir=plot_save_dir) custom_perpos_contribs = per_position_contrib_scores if (per_position_contrib_scores is None): @@ -250,7 +264,6 @@ def __call__(self, task_names, contrib_scores, custom_perpos_contribs=custom_perpos_contribs, other_tracks=other_tracks) - multitask_seqlet_creation_results = core.MultiTaskSeqletCreator( coord_producer=self.coord_producer, overlap_resolver=self.overlap_resolver)( @@ -275,12 +288,14 @@ def __call__(self, task_names, contrib_scores, print("WARNING: you found relatively few seqlets." +" Consider dropping target_seqlet_fdr") - if int(self.min_metacluster_size_frac * len(seqlets)) > self.min_metacluster_size: + if int(self.min_metacluster_size_frac + * len(seqlets)) > self.min_metacluster_size: print("min_metacluster_size_frac * len(seqlets) = {0} is more than min_metacluster_size={1}.".\ - format(int(self.min_metacluster_size_frac * len(seqlets)), self.min_metacluster_size)) + format(int(self.min_metacluster_size_frac + * len(seqlets)), self.min_metacluster_size)) print("Using it as a new min_metacluster_size") - self.min_metacluster_size = int(self.min_metacluster_size_frac * len(seqlets)) - + self.min_metacluster_size =\ + int(self.min_metacluster_size_frac * len(seqlets)) if (self.weak_threshold_for_counting_sign is None): weak_threshold_for_counting_sign = weakest_transformed_thresh diff --git a/modisco/value_provider.py b/modisco/value_provider.py index 1775aa3..c95a881 100644 --- a/modisco/value_provider.py +++ b/modisco/value_provider.py @@ -42,16 +42,32 @@ def __call__(self, seqlet): val = self.get_val(seqlet=seqlet) return self.val_transformer(val=val) - def get_val(self, seqlet): - flank_to_ignore = int(0.5*(len(seqlet)-self.central_window)) + def get_imp_around_central_window(self, seqlet, central_window): + flank_to_ignore = int(0.5*(len(seqlet)-central_window)) track_values = seqlet[self.track_name]\ .fwd[flank_to_ignore:(len(seqlet)-flank_to_ignore)] return np.sum(track_values) + def get_val(self, seqlet): + if (hasattr(self.central_window, '__iter__')): + vals = [] + for window_width in self.central_window: + imp = self.get_imp_around_central_window( + seqlet=seqlet, central_window=window_width) + vals.append(imp) + return vals + else: + return self.get_imp_around_central_window(seqlet=seqlet, + central_window=self.central_window) + def save_hdf5(self, grp): grp.attrs["class"] = type(self).__name__ grp.attrs["track_name"] = self.track_name - grp.attrs["central_window"] = self.central_window + if (hasattr(self.central_window, '__iter__')): + grp.create_dataset("window_widths", + data=np.array(self.window_widths)) + else: + grp.attrs["central_window"] = self.central_window self.val_transformer.save_hdf5(grp.create_group("val_transformer")) @classmethod @@ -60,7 +76,10 @@ def from_hdf5(cls, grp): track_name = grp.attrs["track_name"] else: track_name = grp.attrs["track_name"].decode('utf-8') - central_window = grp.attrs["central_window"] + if ('central_window' in grp.attrs): + central_window = grp.attrs["central_window"] + else: + central_window = np.array(grp["central_window"]).astype("int") val_transformer = AbstractValTransformer.from_hdf5( grp["val_transformer"]) return cls(track_name=track_name, @@ -68,43 +87,92 @@ def from_hdf5(cls, grp): val_transformer=val_transformer) -class VariableWidthPrecTransformedValueProvider(AbstractValueProvider): +class AbstractValTransformer(object): - def __init__(self, track_name, window_widths, pos_irs, neg_irs): - if isinstance(track_name, str): - self.track_name = track_name - else: - self.track_name = track_name.decode('utf-8') - self.window_widths = window_widths - self.pos_irs = pos_irs - self.neg_irs = neg_irs + def __call__(self, val): + raise NotImplementedError() - def __call__(self, seqlet): - val = self.get_val(seqlet=seqlet) - return self.val_transformer(val=val) + @classmethod + def from_hdf5(cls, grp): + the_class = eval(grp.attrs["class"]) + return the_class.from_hdf5(grp) - def get_imp_around_central_window(self, seqlet, central_window): - flank_to_ignore = int(0.5*(len(seqlet)-central_window)) - track_values = seqlet[self.track_name]\ - .fwd[flank_to_ignore:(len(seqlet)-flank_to_ignore)] - return np.sum(track_values) - def get_val(self, seqlet): - vals = [] - for window_width, pos_ir, neg_ir in self.window_widths: - imp = self.get_imp_around_central_window( - seqlet=seqlet, central_window=window_widths) - if (imp >= 0): - val = pos_ir.transform([imp])[0] +class PrecisionValTransformer(AbstractValTransformer): + + def __init__(self, sliding_window_sizes, pos_irs, neg_irs): + assert len(pos_irs)==len(neg_irs) + self.sliding_window_sizes = sliding_window_sizes + self.pos_irs = pos_irs + self.neg_irs = neg_irs + + #I have the transform_score_track function in addition to the __call__ + # function because in the case of the transform_score_track function, the + # total importance for a given window size doesn't have to be retained + # until the very last step; it is computed and immediately subject to + # transformation. + def transform_score_track(self, score_track): + from .coordproducers import get_simple_window_sum_function + percentile_transformed_tracks = [] + for sliding_window_size, pos_ir, neg_ir in zip( + self.sliding_window_size, self.pos_irs, self.neg_irs): + window_sum_function = get_simple_window_sum_function( + sliding_window_size) + window_sums_rows = window_sum_function(arrs=score_track) + transformed_track = [] + for row_idx, window_sums_row in enumerate(window_sums_rows): + transformed_row = np.zeros_like(window_sums_row) + + pos_val_indices = np.nonzero(window_sums_row >= 0)[0] + pos_vals = window_sums_row[pos_val_indices] + transformed_pos_vals = pos_ir.transform(pos_vals) + transformed_row[pos_val_indices] = transformed_pos_vals + + neg_val_indices = np.nonzero(window_sums_row < 0)[0] + if (len(neg_val_indices) > 0 and neg_ir is not None): + neg_vals = window_sums_row[neg_val_indices] + transformed_neg_vals = neg_ir.transform(neg_vals) + transformed_row[neg_val_indices] = -transformed_neg_vals + + #add padding to make up for entries lost due to the sliding + # windows + transformed_row = np.pad(transformed_row, + pad_width=( + (int((sliding_window_size-1)/2.0), + (sliding_window_size-1) + -int((sliding_window_size-1)/2.0))), + mode='constant') + assert len(transformed_row)==len(score_track[row_idx]),\ + (len(transformed_row), len(score_track[row_idx])) + transformed_track.append(transformed_row) + percentile_transformed_tracks.append(transformed_track) + #ultimately, return the result of taking the value that has + # the maximum absolute value over all the different transformed tracks + bestwindowvals = [valatmaxabs( + np.array([percentile_transformed_tracks[i][j] + for i in range(len(percentile_transformed_tracks))])) + for j in range(len(score_track))] + #return both the best window values AND the idx of the window size, + # as I think the latter is also helpful to know + return [x[0] for x in bestwindowvals], [x[1] for x in bestwindowvals] + + #In the case of __call__, val is a list of the total importance for + # different window sizes + def __call__(self, val): + assert len(val)==len(self.pos_irs) + transformed_vals = [] + for (a_val, pos_r, neg_ir) in zip(val, self.pos_irs, self.neg_irs): + if (a_val >= 0): + transformed_val = pos_ir.transform([a_val])[0] else: - val = -neg_ir.transform([imp])[0] - vals.append(val) - return vals[np.argmax(np.abs(vals))] + transformed_val = -neg_ir.transform([a_val])[0] + transformed_vals.append(transformed_val) + return vals[np.argmax(np.abs(transformed_vals))] def save_hdf5(self, grp): grp.attrs["class"] = type(self).__name__ - grp.attrs["track_name"] = self.track_name - grp.create_dataset("window_widths", data=np.array(self.window_widths)) + grp.create_dataset("sliding_window_sizes", + data=np.array(self.sliding_window_sizes)) util.save_list_of_objects(grp=grp.create_group("pos_irs"), list_of_objects=self.pos_irs) util.save_list_of_objects(grp=grp.create_group("neg_irs"), @@ -113,35 +181,14 @@ def save_hdf5(self, grp): @classmethod def from_hdf5(cls, grp): from .coordproducers import SavableIsotonicRegression - if isinstance(grp.attrs["track_name"], str): - track_name = grp.attrs["track_name"] - else: - track_name = grp.attrs["track_name"].decode('utf-8') - window_widths = np.array(grp["window_widths"]).astype("int") pos_irs = util.load_list_of_objects( grp=grp["pos_irs"], obj_class=SavableIsotonicRegression) neg_irs = util.load_list_of_objects( grp=grp["neg_irs"], obj_class=SavableIsotonicRegression) - - return cls(track_name=track_name, window_widths=window_widths, - pos_irs=pos_irs, neg_irs=neg_irs) - - -class AbstractValTransformer(object): - - def __call__(self, val): - raise NotImplementedError() - - @classmethod - def from_hdf5(cls, grp): - the_class = eval(grp.attrs["class"]) - return the_class.from_hdf5(grp) - - -class IdentityFunctionValTransformer(AbstractValTransformer) - - def __call__(self, val): - return val + sliding_window_sizes =\ + np.array(grp["sliding_window_sizes"]).astype("int") + return cls(pos_irs=pos_irs, neg_irs=neg_irs, + sliding_window_sizes=sliding_window_sizes) class AbsPercentileValTransformer(AbstractValTransformer): From a7baf0f48df572a8343fc6d670927fb2b991dd07 Mon Sep 17 00:00:00 2001 From: Avanti Shrikumar Date: Tue, 15 Dec 2020 19:38:53 -0800 Subject: [PATCH 10/30] periodic commit --- modisco/coordproducers.py | 26 ++++++++++++++++---------- 1 file changed, 16 insertions(+), 10 deletions(-) diff --git a/modisco/coordproducers.py b/modisco/coordproducers.py index 556b6af..9afe4e8 100644 --- a/modisco/coordproducers.py +++ b/modisco/coordproducers.py @@ -494,6 +494,7 @@ def __call__(self, score_track, null_track, tnt_results=None): score_track=score_track, null_track=null_track) precision_transformer = PrecisionValTransformer( + sliding_window_sizes=self.sliding, pos_irs=pos_irs, neg_irs=neg_irs) (precisiontransformed_score_track, @@ -505,8 +506,8 @@ def __call__(self, score_track, null_track, tnt_results=None): precisiontransformed_score_track.ravel()) #Pick a threshold according the the precisiontransformed score track - pos_threshold = TODO - neg_threshold = TODO + pos_threshold = (1-self.target_fdr) + neg_threshold = -(1-self.target_fdr) pos_threshold, neg_threshold =\ refine_thresholds_based_on_frac_passing( @@ -529,12 +530,15 @@ def __call__(self, score_track, null_track, tnt_results=None): precision_transformer.transform_score_track( score_track=score_track) - #TODO: look into padding situation - assert False #look into padding situation...identify_coords - #is expecting something that has already been processed with - #sliding windows of size windowsize + #Need to remove padding because identify_coords is assumed to + # operate on a scoretrack that has already been processed with + # a sliding window of windowsize (and assumes that partial windows + # were not included) + left_padding_to_remove = int((max(self.sliding)-1)/2) + right_padding_to_remove = (max(self.sliding)-1)-left_padding_to_remove coords = identify_coords( - score_track=precisiontransformed_score_track, + score_track=precisiontransformed_score_track[ + :,left_padding_to_remove:-right_padding_to_remove], pos_threshold=tnt_results.transformed_pos_threshold, neg_threshold=tnt_results.transformed_neg_threshold, windowsize=max(self.sliding), @@ -543,7 +547,8 @@ def __call__(self, score_track, null_track, tnt_results=None): max_seqlets_total=self.max_seqlets_total, verbose=self.verbose, other_info_tracks={'best_window_idx': - precisiontransformed_bestwindowsizeidxs}) + precisiontransformed_bestwindowsizeidxs[:, + left_padding_to_remove:-right_padding_to_remove]}) return CoordProducerResults( coords=coords, @@ -556,6 +561,9 @@ def identify_coords(score_track, pos_threshold, neg_threshold, windowsize, flank, suppress, max_seqlets_total, verbose, other_info_tracks={}): + for other_info_track in other_info_tracks.values(): + assert other_info_track.shape==score_track.shape + #cp_score_track = 'copy' of the score track, which can be modified as # coordinates are identified cp_score_track = [np.array(x) for x in score_track] @@ -715,7 +723,6 @@ def from_hdf5(cls, grp): max_seqlets_total = grp.attrs["max_seqlets_total"] else: max_seqlets_total = None - #TODO: load min_seqlets feature progress_update = grp.attrs["progress_update"] verbose = grp.attrs["verbose"] return cls(sliding=sliding, flank=flank, suppress=suppress, @@ -736,7 +743,6 @@ def save_hdf5(self, grp): grp.attrs["max_passing_windows_frac"] = self.max_passing_windows_frac grp.attrs["separate_pos_neg_thresholds"] =\ self.separate_pos_neg_thresholds - #TODO: save min_seqlets feature if (self.max_seqlets_total is not None): grp.attrs["max_seqlets_total"] = self.max_seqlets_total grp.attrs["progress_update"] = self.progress_update From e0ea93020c7fae9a7b45efb4764da02380f67ef9 Mon Sep 17 00:00:00 2001 From: Avanti Shrikumar Date: Wed, 16 Dec 2020 13:19:18 -0800 Subject: [PATCH 11/30] the code seems to be working --- modisco/coordproducers.py | 163 ++++++++++++------ .../tfmodisco_workflow/seqlets_to_patterns.py | 18 +- modisco/value_provider.py | 15 +- 3 files changed, 129 insertions(+), 67 deletions(-) diff --git a/modisco/coordproducers.py b/modisco/coordproducers.py index 9afe4e8..0a0f136 100644 --- a/modisco/coordproducers.py +++ b/modisco/coordproducers.py @@ -11,6 +11,7 @@ AbstractValTransformer, AbsPercentileValTransformer, SignedPercentileValTransformer, PrecisionValTransformer) import scipy +from sklearn.isotonic import IsotonicRegression SUBSAMPLE_CAP = 1000000 @@ -23,7 +24,7 @@ # able to replicate the same procedure used for identifying coordinates as # when TfMoDisco was first run; the information needed in that case would # be specific to the type of Coordproducer used -class AbstractTransformAndThresholdResults( +class AbstractTransformAndThresholdResults(object): def __init__(self, transformed_neg_threshold, transformed_pos_threshold, val_transformer): @@ -227,8 +228,8 @@ def save_hdf5(self, grp): def __call__(self, score_track, windowsize, original_summed_score_track): #original_summed_score_track is supplied to avoid recomputing it - window_sum_function = get_simple_window_sum_function(windowsize) - if (original_summed_score_track is not None): + if (original_summed_score_track is None): + window_sum_function = get_simple_window_sum_function(windowsize) original_summed_score_track = window_sum_function(arrs=score_track) values = np.concatenate(original_summed_score_track, axis=0) @@ -392,7 +393,7 @@ def __init__(self, origvals, nullvals, increasing): y=([1.0 for x in self.origvals] + [0.0 for x in self.nullvals]), sample_weight=([1.0 for x in self.origvals] +[float(len(self.origvals))/len(self.nullvals) - for x in self.origvals])) + for x in self.nullvals])) def transform(self, vals): return self.ir.transform(vals) @@ -404,14 +405,13 @@ def save_hdf5(self, grp): @classmethod def from_hdf5(cls, grp): - increase = grp.attrs['increasing'] + increasing = grp.attrs['increasing'] origvals = np.array(grp['origvals']) nullvals = np.array(grp['nullvals']) return cls(origvals=origvals, nullvals=nullvals, increasing=increasing) def get_isotonic_regression_classifier(orig_vals, null_vals): - from sklearn.isotonic import IsotonicRegression orig_vals = subsample_if_large(orig_vals) null_vals = subsample_if_large(null_vals) pos_orig_vals = ( @@ -430,12 +430,7 @@ def get_isotonic_regression_classifier(orig_vals, null_vals): else: neg_ir = None - return pos_ir, neg_ir, orig_vals, pos_orig_vals, neg_orig_vals - - -def valatmaxabs(arrs): - idxs = np.argmax(np.abs(arrs), axis=0) - return arrs[idxs, np.arange(len(arrs[0]))], idxs + return pos_ir, neg_ir, orig_vals #sliding in this case would be a list of values @@ -446,7 +441,7 @@ def __init__(self, sliding, flank, suppress, target_fdr, separate_pos_neg_thresholds, max_seqlets_total, progress_update=5000, - verbose=True): + verbose=True, plot_save_dir="figures"): self.sliding = sliding self.flank = flank self.suppress = suppress @@ -460,17 +455,57 @@ def __init__(self, sliding, flank, suppress, target_fdr, self.verbose = verbose self.plot_save_dir = plot_save_dir + + @classmethod + def from_hdf5(cls, grp): + sliding = np.array(grp["sliding"]).astype("int") + flank = grp.attrs["flank"] + suppress = grp.attrs["suppress"] + target_fdr = grp.attrs["target_fdr"] + min_passing_windows_frac = grp.attrs["min_passing_windows_frac"] + max_passing_windows_frac = grp.attrs["max_passing_windows_frac"] + separate_pos_neg_thresholds = grp.attrs["separate_pos_neg_thresholds"] + if ("max_seqlets_total" in grp.attrs): + max_seqlets_total = grp.attrs["max_seqlets_total"] + else: + max_seqlets_total = None + progress_update = grp.attrs["progress_update"] + verbose = grp.attrs["verbose"] + return cls(sliding=sliding, flank=flank, suppress=suppress, + target_fdr=target_fdr, + min_passing_windows_frac=min_passing_windows_frac, + max_passing_windows_frac=max_passing_windows_frac, + separate_pos_neg_thresholds=separate_pos_neg_thresholds, + max_seqlets_total=max_seqlets_total, + progress_update=progress_update, verbose=verbose) + + def save_hdf5(self, grp): + grp.attrs["class"] = type(self).__name__ + grp.create_dataset("sliding", data=np.array(self.sliding)) + grp.attrs["flank"] = self.flank + grp.attrs["suppress"] = self.suppress + grp.attrs["target_fdr"] = self.target_fdr + grp.attrs["min_passing_windows_frac"] = self.min_passing_windows_frac + grp.attrs["max_passing_windows_frac"] = self.max_passing_windows_frac + grp.attrs["separate_pos_neg_thresholds"] =\ + self.separate_pos_neg_thresholds + if (self.max_seqlets_total is not None): + grp.attrs["max_seqlets_total"] = self.max_seqlets_total + grp.attrs["progress_update"] = self.progress_update + grp.attrs["verbose"] = self.verbose + def fit_pos_and_neg_irs(self, score_track, null_track): pos_irs = [] neg_irs = [] - for sliding_window_size in self.sliding_window_sizes: + for sliding_window_size in self.sliding: window_sum_function = get_simple_window_sum_function( sliding_window_size) print("Fitting - on window size",sliding_window_size) if (hasattr(null_track, '__call__')): null_vals = null_track( score_track=score_track, - windowsize=sliding_window_size) + windowsize=sliding_window_size, + original_summed_score_track=None) else: null_summed_score_track = window_sum_function(arrs=null_track) null_vals = list(np.concatenate(null_summed_score_track, @@ -480,7 +515,7 @@ def fit_pos_and_neg_irs(self, score_track, null_track): window_sums_rows = window_sum_function(arrs=score_track) print("Done computing window sums") sys.stdout.flush() - pos_ir, neg_ir, _, _, _ = get_isotonic_regression_classifier( + pos_ir, neg_ir, _ = get_isotonic_regression_classifier( orig_vals=list( np.concatenate(window_sums_rows, axis=0)), null_vals=null_vals) @@ -503,7 +538,11 @@ def __call__(self, score_track, null_track, tnt_results=None): score_track=score_track) subsampled_prec_vals = subsample_if_large( - precisiontransformed_score_track.ravel()) + np.concatenate(precisiontransformed_score_track, axis=0)) + + from matplotlib import pyplot as plt + plt.hist(subsampled_prec_vals, bins=50) + plt.show() #Pick a threshold according the the precisiontransformed score track pos_threshold = (1-self.target_fdr) @@ -511,16 +550,17 @@ def __call__(self, score_track, null_track, tnt_results=None): pos_threshold, neg_threshold =\ refine_thresholds_based_on_frac_passing( - vals=subsampled_prec_vals, - pos_threshold=pos_threshold, - neg_threshold=neg_threshold, - min_passing_windows_frac=self.min_passing_windows_frac, - max_passing_windows_frac=self.max_passing_windows_frac, - separate_pos_neg_thresholds) - + vals=subsampled_prec_vals, + pos_threshold=pos_threshold, + neg_threshold=neg_threshold, + min_passing_windows_frac=self.min_passing_windows_frac, + max_passing_windows_frac=self.max_passing_windows_frac, + separate_pos_neg_thresholds=self.separate_pos_neg_thresholds, + verbose=self.verbose) + tnt_results = BasicTransformAndThresholdResults( - transformed_neg_threshold=pos_threshold, - transformed_pos_threshold=neg_threshold, + transformed_neg_threshold=neg_threshold, + transformed_pos_threshold=pos_threshold, val_transformer=precision_transformer) else: @@ -537,8 +577,8 @@ def __call__(self, score_track, null_track, tnt_results=None): left_padding_to_remove = int((max(self.sliding)-1)/2) right_padding_to_remove = (max(self.sliding)-1)-left_padding_to_remove coords = identify_coords( - score_track=precisiontransformed_score_track[ - :,left_padding_to_remove:-right_padding_to_remove], + score_track=[x[left_padding_to_remove:-right_padding_to_remove] + for x in precisiontransformed_score_track], pos_threshold=tnt_results.transformed_pos_threshold, neg_threshold=tnt_results.transformed_neg_threshold, windowsize=max(self.sliding), @@ -547,8 +587,8 @@ def __call__(self, score_track, null_track, tnt_results=None): max_seqlets_total=self.max_seqlets_total, verbose=self.verbose, other_info_tracks={'best_window_idx': - precisiontransformed_bestwindowsizeidxs[:, - left_padding_to_remove:-right_padding_to_remove]}) + [x[left_padding_to_remove:-right_padding_to_remove] for x in + precisiontransformed_bestwindowsizeidxs]}) return CoordProducerResults( coords=coords, @@ -562,7 +602,8 @@ def identify_coords(score_track, pos_threshold, neg_threshold, max_seqlets_total, verbose, other_info_tracks={}): for other_info_track in other_info_tracks.values(): - assert other_info_track.shape==score_track.shape + assert all([x.shape==y.shape for x,y + in zip(other_info_track,score_track)]) #cp_score_track = 'copy' of the score track, which can be modified as # coordinates are identified @@ -636,12 +677,13 @@ def refine_thresholds_based_on_frac_passing( separate_pos_neg_thresholds, verbose): frac_passing_windows =( - sum(orig_vals >= pos_threshold) - + sum(orig_vals <= neg_threshold))/float(len(orig_vals)) + sum(vals >= pos_threshold) + + sum(vals <= neg_threshold))/float(len(vals)) if (verbose): print("Thresholds from null dist were", - neg_threshold," and ",pos_threshold) + neg_threshold," and ",pos_threshold, + "with frac passing", frac_passing_windows) #adjust the thresholds if the fall outside the min/max # windows frac @@ -652,14 +694,14 @@ def refine_thresholds_based_on_frac_passing( min_passing_windows_frac,"; adjusting") if (separate_pos_neg_thresholds): pos_threshold = np.percentile( - a=[x for x in orig_vals if x > 0], + a=[x for x in vals if x > 0], q=100*(1-min_passing_windows_frac)) neg_threshold = np.percentile( - a=[x for x in orig_vals if x < 0], + a=[x for x in vals if x < 0], q=100*(min_passing_windows_frac)) else: pos_threshold = np.percentile( - a=np.abs(orig_vals), + a=np.abs(vals), q=100*(1-min_passing_windows_frac)) neg_threshold = -pos_threshold @@ -670,14 +712,14 @@ def refine_thresholds_based_on_frac_passing( max_passing_windows_frac,"; adjusting") if (separate_pos_neg_thresholds): pos_threshold = np.percentile( - a=[x for x in orig_vals if x > 0], + a=[x for x in vals if x > 0], q=100*(1-max_passing_windows_frac)) neg_threshold = np.percentile( - a=[x for x in orig_vals if x < 0], + a=[x for x in vals if x < 0], q=100*(max_passing_windows_frac)) else: pos_threshold = np.percentile( - a=np.abs(orig_vals), + a=np.abs(vals), q=100*(1-max_passing_windows_frac)) neg_threshold = -pos_threshold @@ -783,29 +825,40 @@ def __call__(self, score_track, null_track, tnt_results=None): get_isotonic_regression_classifier( orig_vals=orig_vals, null_vals=null_vals) + + subsampled_pos_orig_vals = ( + np.array(sorted([x for x in subsampled_orig_vals if x >= 0]))) + subsampled_neg_orig_vals = ( + np.array(sorted([x for x in subsampled_orig_vals if x < 0], + key=lambda x: abs(x)))) - pos_val_precisions = pos_ir.transform(pos_orig_vals) - if (len(neg_orig_vals) > 0): - neg_val_precisions = neg_ir.transform(neg_orig_vals) + subsampled_pos_val_precisions =\ + pos_ir.transform(subsampled_pos_orig_vals) + if (len(subsampled_neg_orig_vals) > 0): + subsampled_neg_val_precisions =\ + neg_ir.transform(subsampled_neg_orig_vals) pos_threshold = ([x[1] for x in - zip(pos_val_precisions, pos_orig_vals) if x[0] - >= (1-self.target_fdr)]+[pos_orig_vals[-1]])[0] - if (len(neg_orig_vals) > 0): + zip(subsampled_pos_val_precisions, + subsampled_pos_orig_vals) if x[0] + >= (1-self.target_fdr)]+[subsampled_pos_orig_vals[-1]])[0] + if (len(subsampled_neg_orig_vals) > 0): neg_threshold = ([x[1] for x in - zip(neg_val_precisions, neg_orig_vals) if x[0] - >= (1-self.target_fdr)]+[neg_orig_vals[-1]])[0] + zip(subsampled_neg_val_precisions, + subsampled_neg_orig_vals) if x[0] + >= (1-self.target_fdr)]+[subsampled_neg_orig_vals[-1]])[0] else: neg_threshold = -np.inf pos_threshold, neg_threshold =\ refine_thresholds_based_on_frac_passing( - vals=subsampled_orig_vals, - pos_threshold=pos_threshold, - neg_threshold=neg_threshold, - min_passing_windows_frac=self.min_passing_windows_frac, - max_passing_windows_frac=self.max_passing_windows_frac, - separate_pos_neg_thresholds) + vals=subsampled_orig_vals, + pos_threshold=pos_threshold, + neg_threshold=neg_threshold, + min_passing_windows_frac=self.min_passing_windows_frac, + max_passing_windows_frac=self.max_passing_windows_frac, + separate_pos_neg_thresholds=self.separate_pos_neg_thresholds, + verbose=self.verbose) if (self.separate_pos_neg_thresholds): val_transformer = SignedPercentileValTransformer( @@ -840,7 +893,7 @@ def __call__(self, score_track, null_track, tnt_results=None): plt.plot([pos_threshold, pos_threshold], [0, np.max(hist)], color="red") - if (len(neg_orig_vals) > 0): + if (len(subsampled_neg_orig_vals) > 0): neghistvals, negbins = zip(*[x for x in zip(hist,bincenters) if x[1] < 0]) negbin_precisions = neg_ir.transform(negbins) diff --git a/modisco/tfmodisco_workflow/seqlets_to_patterns.py b/modisco/tfmodisco_workflow/seqlets_to_patterns.py index 1bd8085..d550e8f 100644 --- a/modisco/tfmodisco_workflow/seqlets_to_patterns.py +++ b/modisco/tfmodisco_workflow/seqlets_to_patterns.py @@ -737,14 +737,15 @@ def __call__(self, seqlets): if (self.verbose): print("len(seqlets) is 0 - bailing!") return SeqletsToPatternsResults( - patterns=None, - seqlets=None, - affmat=None, each_round_initcluster_motifs=None, + patterns=None, patterns_withoutreassignment=None, + pattern_merge_hierarchy=None, cluster_results=None, total_time_taken=None, - success=False) + success=False, + seqlets=None, + affmat=None) if (self.verbose): print("(Round "+str(round_num)+ @@ -896,12 +897,15 @@ def __call__(self, seqlets): if (self.verbose): print("No more surviving patterns - bailing!") return SeqletsToPatternsResults( + each_round_initcluster_motifs=None, patterns=None, - seqlets=None, - affmat=None, + patterns_withoutreassignment=None, + pattern_merge_hierarchy=None, cluster_results=None, total_time_taken=None, - success=False) + success=False, + seqlets=None, + affmat=None) #Now start merging patterns if (self.verbose): diff --git a/modisco/value_provider.py b/modisco/value_provider.py index c95a881..045ab00 100644 --- a/modisco/value_provider.py +++ b/modisco/value_provider.py @@ -64,8 +64,8 @@ def save_hdf5(self, grp): grp.attrs["class"] = type(self).__name__ grp.attrs["track_name"] = self.track_name if (hasattr(self.central_window, '__iter__')): - grp.create_dataset("window_widths", - data=np.array(self.window_widths)) + grp.create_dataset("central_window", + data=np.array(self.central_window)) else: grp.attrs["central_window"] = self.central_window self.val_transformer.save_hdf5(grp.create_group("val_transformer")) @@ -98,6 +98,11 @@ def from_hdf5(cls, grp): return the_class.from_hdf5(grp) +def valatmaxabs(arrs): + idxs = np.argmax(np.abs(arrs), axis=0) + return arrs[idxs, np.arange(len(arrs[0]))], idxs + + class PrecisionValTransformer(AbstractValTransformer): def __init__(self, sliding_window_sizes, pos_irs, neg_irs): @@ -115,7 +120,7 @@ def transform_score_track(self, score_track): from .coordproducers import get_simple_window_sum_function percentile_transformed_tracks = [] for sliding_window_size, pos_ir, neg_ir in zip( - self.sliding_window_size, self.pos_irs, self.neg_irs): + self.sliding_window_sizes, self.pos_irs, self.neg_irs): window_sum_function = get_simple_window_sum_function( sliding_window_size) window_sums_rows = window_sum_function(arrs=score_track) @@ -161,13 +166,13 @@ def transform_score_track(self, score_track): def __call__(self, val): assert len(val)==len(self.pos_irs) transformed_vals = [] - for (a_val, pos_r, neg_ir) in zip(val, self.pos_irs, self.neg_irs): + for (a_val, pos_ir, neg_ir) in zip(val, self.pos_irs, self.neg_irs): if (a_val >= 0): transformed_val = pos_ir.transform([a_val])[0] else: transformed_val = -neg_ir.transform([a_val])[0] transformed_vals.append(transformed_val) - return vals[np.argmax(np.abs(transformed_vals))] + return transformed_vals[np.argmax(np.abs(transformed_vals))] def save_hdf5(self, grp): grp.attrs["class"] = type(self).__name__ From 51b59c21e000961581bbd06cd68a13380462db1a Mon Sep 17 00:00:00 2001 From: AvantiShri Date: Wed, 16 Dec 2020 13:56:10 -0800 Subject: [PATCH 12/30] bugfixes --- modisco/coordproducers.py | 38 ++++++++++++++++++++++---------------- 1 file changed, 22 insertions(+), 16 deletions(-) diff --git a/modisco/coordproducers.py b/modisco/coordproducers.py index 0a0f136..f3f4249 100644 --- a/modisco/coordproducers.py +++ b/modisco/coordproducers.py @@ -225,11 +225,11 @@ def save_hdf5(self, grp): grp.create_dataset('percentiles_to_use', data=self.percentiles_to_use) - def __call__(self, score_track, windowsize, original_summed_score_track): + def __call__(self, score_track, window_size, original_summed_score_track): #original_summed_score_track is supplied to avoid recomputing it if (original_summed_score_track is None): - window_sum_function = get_simple_window_sum_function(windowsize) + window_sum_function = get_simple_window_sum_function(window_size) original_summed_score_track = window_sum_function(arrs=score_track) values = np.concatenate(original_summed_score_track, axis=0) @@ -359,12 +359,12 @@ def __call__(self, score_track, windowsize, original_summed_score_track): return np.concatenate(window_sum_function(null_tracks), axis=0) -def get_null_vals(null_track, score_track, windowsize, +def get_null_vals(null_track, score_track, window_size, original_summed_score_track): if (hasattr(null_track, '__call__')): null_vals = null_track( score_track=score_track, - windowsize=windowsize, + window_size=window_size, original_summed_score_track=original_summed_score_track) else: window_sum_function = get_simple_window_sum_function(window_size) @@ -504,20 +504,26 @@ def fit_pos_and_neg_irs(self, score_track, null_track): if (hasattr(null_track, '__call__')): null_vals = null_track( score_track=score_track, - windowsize=sliding_window_size, + window_size=sliding_window_size, original_summed_score_track=None) else: null_summed_score_track = window_sum_function(arrs=null_track) - null_vals = list(np.concatenate(null_summed_score_track, - axis=0)) + null_vals = np.concatenate(null_summed_score_track, + axis=0) print("Computing window sums") sys.stdout.flush() window_sums_rows = window_sum_function(arrs=score_track) print("Done computing window sums") sys.stdout.flush() + + orig_vals = np.concatenate(window_sums_rows, axis=0) + from matplotlib import pyplot as plt + plt.hist(orig_vals, bins=100, density=True, alpha=0.5) + plt.hist(null_vals, bins=100, density=True, alpha=0.5) + plt.show() + pos_ir, neg_ir, _ = get_isotonic_regression_classifier( - orig_vals=list( - np.concatenate(window_sums_rows, axis=0)), + orig_vals=np.concatenate(window_sums_rows, axis=0), null_vals=null_vals) pos_irs.append(pos_ir) neg_irs.append(neg_ir) @@ -572,7 +578,7 @@ def __call__(self, score_track, null_track, tnt_results=None): #Need to remove padding because identify_coords is assumed to # operate on a scoretrack that has already been processed with - # a sliding window of windowsize (and assumes that partial windows + # a sliding window of window_size (and assumes that partial windows # were not included) left_padding_to_remove = int((max(self.sliding)-1)/2) right_padding_to_remove = (max(self.sliding)-1)-left_padding_to_remove @@ -581,7 +587,7 @@ def __call__(self, score_track, null_track, tnt_results=None): for x in precisiontransformed_score_track], pos_threshold=tnt_results.transformed_pos_threshold, neg_threshold=tnt_results.transformed_neg_threshold, - windowsize=max(self.sliding), + window_size=max(self.sliding), flank=self.flank, suppress=self.suppress, max_seqlets_total=self.max_seqlets_total, @@ -596,9 +602,9 @@ def __call__(self, score_track, null_track, tnt_results=None): #identify_coords is expecting something that has already been processed -# with sliding windows of size windowsize +# with sliding windows of size window_size def identify_coords(score_track, pos_threshold, neg_threshold, - windowsize, flank, suppress, + window_size, flank, suppress, max_seqlets_total, verbose, other_info_tracks={}): for other_info_track in other_info_tracks.values(): @@ -638,7 +644,7 @@ def identify_coords(score_track, pos_threshold, neg_threshold, coord = SeqletCoordsFWAP( example_idx=example_idx, start=argmax-flank, - end=argmax+windowsize+flank, + end=argmax+window_size+flank, score=score_track[example_idx][argmax], other_info = dict([ (track_name, track[example_idx][argmax]) @@ -811,7 +817,7 @@ def __call__(self, score_track, null_track, tnt_results=None): null_vals = get_null_vals( null_track=null_track, score_track=score_track, - windowsize=self.sliding, + window_size=self.sliding, original_summed_score_track=original_summed_score_track) if (self.verbose): @@ -934,7 +940,7 @@ def __call__(self, score_track, null_track, tnt_results=None): score_track=original_summed_score_track, pos_threshold=tnt_results.pos_threshold, neg_threshold=tnt_results.neg_threshold, - windowsize=self.sliding, + window_size=self.sliding, flank=self.flank, suppress=self.suppress, max_seqlets_total=self.max_seqlets_total, From 54e524e9d8b922cdef4698476f12cf27f6a697be Mon Sep 17 00:00:00 2001 From: AvantiShri Date: Wed, 16 Dec 2020 16:05:37 -0800 Subject: [PATCH 13/30] small fixes --- modisco/coordproducers.py | 5 ++++- modisco/tfmodisco_workflow/seqlets_to_patterns.py | 11 +++++++---- 2 files changed, 11 insertions(+), 5 deletions(-) diff --git a/modisco/coordproducers.py b/modisco/coordproducers.py index f3f4249..3869880 100644 --- a/modisco/coordproducers.py +++ b/modisco/coordproducers.py @@ -34,7 +34,10 @@ def __init__(self, transformed_neg_threshold, transformed_pos_threshold, @classmethod def from_hdf5(cls, grp): - the_class = eval(grp.attrs["class"]) + if "class" not in grp.attrs: + the_class = FWACTransformAndThresholdResults + else: + the_class = eval(grp.attrs["class"]) if (the_class.__name__ != cls.__name__): return the_class.from_hdf5(grp) diff --git a/modisco/tfmodisco_workflow/seqlets_to_patterns.py b/modisco/tfmodisco_workflow/seqlets_to_patterns.py index d550e8f..f9fdc62 100644 --- a/modisco/tfmodisco_workflow/seqlets_to_patterns.py +++ b/modisco/tfmodisco_workflow/seqlets_to_patterns.py @@ -570,10 +570,13 @@ def from_hdf5(cls, grp, track_set): patterns_withoutreassignment = [] cluster_results = None total_time_taken = grp.attrs["total_time_taken"] - pattern_merge_hierarchy =\ - aggregator.PatternMergeHierarchy.from_hdf5( - grp=grp["pattern_merge_hierarchy"], - track_set=track_set) + if ("pattern_merge_hierarchy" in grp): + pattern_merge_hierarchy =\ + aggregator.PatternMergeHierarchy.from_hdf5( + grp=grp["pattern_merge_hierarchy"], + track_set=track_set) + else: + pattern_merge_hierarchy = None return cls( each_round_initcluster_motifs=each_round_initcluster_motifs, patterns=patterns, From a055b617e84803931a1c46864ff11acfe718de89 Mon Sep 17 00:00:00 2001 From: Avanti Shrikumar Date: Sun, 20 Dec 2020 19:18:41 -0800 Subject: [PATCH 14/30] ir to probpos transformation and fig saving --- modisco/coordproducers.py | 199 +++++++++++++++++++++++++------------- modisco/value_provider.py | 4 +- 2 files changed, 134 insertions(+), 69 deletions(-) diff --git a/modisco/coordproducers.py b/modisco/coordproducers.py index 3869880..a881c18 100644 --- a/modisco/coordproducers.py +++ b/modisco/coordproducers.py @@ -385,33 +385,76 @@ def subsample_if_large(arr): return arr +def irval_to_probpos(irval, frac_neg): + #n(x):= pdf of null dist (negatives) + #p(x):= pdf of positive distribution + #f_p:= fraction of positives + #f_n:= fraction of negatives = 1-f_p + #o(x):= pdf of observed distribution = n(x)f_n + p(x)f_p + #The isotonic regression produces a(x) = o(x)/[o(x) + n(x)] + # o(x)/[o(x) + n(x)] = [n(x)f_n + o(x)f_p]/[n(x)(1+f_n) + p(x)] + # a(x)[n(x)(1+f_n) + p(x)f_p] = n(x)f_n + p(x)f_p + # a(x)n(x)(1+f_n) - n(x)f_n = p(x)f_p - a(x)p(x)f_p + # n(x)[a(x)(1+f_n) - f_n] = p(x)f_p[1 - a(x)] + # [a(x)/f_n + (a(x)-1)]/[1-a(x)] = (p(x)f_p)/(n(x)f_n) = r(x) + #p_pos = 1 / (1 + 1/r(x)) + # = [a(x)/f_n + (a(x)-1)]/[a(x)/f_n + (a(x)-1) + (1-a(x))] + # = [a(x)/f_n + a(x)-1]/[a(x)/f_n] + # = [a(x) + f_n(a(x)-1)]/a(x) + # = 1 + f_n(a(x)-1)/a(x) + # = 1 + f_n(1 - 1/a(x)) + #If solving for p_pos=0, we have -1/(1 - 1/a(x)) = f_n + #As f_n --> 100%, p_pos --> 2 - 1/a(x); this assumes max(a(x)) = 0.5 + return np.minimum(np.maximum(1 + frac_neg*(1 - (1/irval)), 0.0), 1.0) + + class SavableIsotonicRegression(object): - def __init__(self, origvals, nullvals, increasing): + def __init__(self, origvals, nullvals, increasing, min_frac_neg=0.99): self.origvals = origvals self.nullvals = nullvals self.increasing = increasing - self.ir = IsotonicRegression(out_of_bounds='clip').fit( + self.min_frac_neg = min_frac_neg + self.ir = IsotonicRegression(out_of_bounds='clip', + increasing=increasing).fit( X=np.concatenate([self.origvals, self.nullvals], axis=0), y=([1.0 for x in self.origvals] + [0.0 for x in self.nullvals]), sample_weight=([1.0 for x in self.origvals] +[float(len(self.origvals))/len(self.nullvals) for x in self.nullvals])) - + #Infer frac_pos based on the minimum value of the ir probs + #See derivation in irval_to_probpos function + min_prec_x = self.ir.X_min_ if self.increasing else self.ir.X_max_ + min_precision = self.ir.transform([min_prec_x])[0] + implied_frac_neg = -1/(1-(1/min_precision)) + print("For increasing =",increasing,", the minimum IR precision was", + min_precision,"occurring at",min_prec_x, + "implying a frac_neg", + "of",implied_frac_neg) + if (implied_frac_neg > 1.0 or implied_frac_neg < self.min_frac_neg): + implied_frac_neg = max(min(1.0,implied_frac_neg), + self.min_frac_neg) + print("Adjusted frac neg is",implied_frac_neg) + self.implied_frac_neg = implied_frac_neg + def transform(self, vals): - return self.ir.transform(vals) + return irval_to_probpos(self.ir.transform(vals), + frac_neg=self.implied_frac_neg) def save_hdf5(self, grp): grp.attrs['increasing'] = self.increasing + grp.attrs['min_frac_neg'] = self.min_frac_neg grp.create_dataset('origvals', data=self.origvals) grp.create_dataset('nullvals', data=self.nullvals) @classmethod def from_hdf5(cls, grp): increasing = grp.attrs['increasing'] + min_frac_neg = grp.attrs['min_frac_neg'] origvals = np.array(grp['origvals']) nullvals = np.array(grp['nullvals']) - return cls(origvals=origvals, nullvals=nullvals, increasing=increasing) + return cls(origvals=origvals, nullvals=nullvals, + increasing=increasing, min_frac_neg=min_frac_neg) def get_isotonic_regression_classifier(orig_vals, null_vals): @@ -428,12 +471,12 @@ def get_isotonic_regression_classifier(orig_vals, null_vals): nullvals=pos_null_vals, increasing=True) if (len(neg_orig_vals) > 0): - neg_ir = SavableIsotonicRegression(origvals=pos_orig_vals, - nullvals=pos_null_vals, increasing=False) + neg_ir = SavableIsotonicRegression(origvals=neg_orig_vals, + nullvals=neg_null_vals, increasing=False) else: neg_ir = None - return pos_ir, neg_ir, orig_vals + return pos_ir, neg_ir, orig_vals, null_vals #sliding in this case would be a list of values @@ -520,14 +563,23 @@ def fit_pos_and_neg_irs(self, score_track, null_track): sys.stdout.flush() orig_vals = np.concatenate(window_sums_rows, axis=0) - from matplotlib import pyplot as plt - plt.hist(orig_vals, bins=100, density=True, alpha=0.5) - plt.hist(null_vals, bins=100, density=True, alpha=0.5) - plt.show() - pos_ir, neg_ir, _ = get_isotonic_regression_classifier( + pos_ir, neg_ir, subsampled_orig_vals, subsampled_null_vals =\ + get_isotonic_regression_classifier( orig_vals=np.concatenate(window_sums_rows, axis=0), null_vals=null_vals) + + + make_nulldist_figure(orig_vals=subsampled_orig_vals, + null_vals=subsampled_null_vals, + pos_ir=pos_ir, neg_ir=neg_ir, + pos_threshold=None, + neg_threshold=None) + show_or_savefig(plot_save_dir=self.plot_save_dir, + filename="scoredist_window" + +str(sliding_window_size)+"_" + +str(VariableWindowAroundChunks.count)+".png") + pos_irs.append(pos_ir) neg_irs.append(neg_ir) return pos_irs, neg_irs @@ -551,7 +603,9 @@ def __call__(self, score_track, null_track, tnt_results=None): from matplotlib import pyplot as plt plt.hist(subsampled_prec_vals, bins=50) - plt.show() + show_or_savefig(plot_save_dir=self.plot_save_dir, + filename="final_prec_vals_dist" + +str(VariableWindowAroundChunks.count)+".png") #Pick a threshold according the the precisiontransformed score track pos_threshold = (1-self.target_fdr) @@ -598,6 +652,8 @@ def __call__(self, score_track, null_track, tnt_results=None): other_info_tracks={'best_window_idx': [x[left_padding_to_remove:-right_padding_to_remove] for x in precisiontransformed_bestwindowsizeidxs]}) + + VariableWindowAroundChunks.count += 1 return CoordProducerResults( coords=coords, @@ -694,6 +750,12 @@ def refine_thresholds_based_on_frac_passing( neg_threshold," and ",pos_threshold, "with frac passing", frac_passing_windows) + pos_vals = [x for x in vals if x >= 0] + neg_vals = [x for x in vals if x < 0] + #deal with edge case of len < 0 + pos_vals = [0] if len(pos_vals)==0 else pos_vals + neg_vals = [0] if len(neg_vals)==0 else neg_vals + #adjust the thresholds if the fall outside the min/max # windows frac if (frac_passing_windows < min_passing_windows_frac): @@ -703,10 +765,10 @@ def refine_thresholds_based_on_frac_passing( min_passing_windows_frac,"; adjusting") if (separate_pos_neg_thresholds): pos_threshold = np.percentile( - a=[x for x in vals if x > 0], + a=pos_vals, q=100*(1-min_passing_windows_frac)) neg_threshold = np.percentile( - a=[x for x in vals if x < 0], + a=neg_vals, q=100*(min_passing_windows_frac)) else: pos_threshold = np.percentile( @@ -721,10 +783,10 @@ def refine_thresholds_based_on_frac_passing( max_passing_windows_frac,"; adjusting") if (separate_pos_neg_thresholds): pos_threshold = np.percentile( - a=[x for x in vals if x > 0], + a=pos_vals, q=100*(1-max_passing_windows_frac)) neg_threshold = np.percentile( - a=[x for x in vals if x < 0], + a=neg_vals, q=100*(max_passing_windows_frac)) else: pos_threshold = np.percentile( @@ -733,7 +795,48 @@ def refine_thresholds_based_on_frac_passing( neg_threshold = -pos_threshold return pos_threshold, neg_threshold - + + +def show_or_savefig(plot_save_dir, filename): + from matplotlib import pyplot as plt + if plt.isinteractive(): + plt.show() + else: + import os, errno + try: + os.makedirs(plot_save_dir) + except OSError as e: + if e.errno != errno.EEXIST: + raise + fname = (plot_save_dir+"/"+filename) + plt.savefig(fname) + print("saving plot to " + fname) + + +def make_nulldist_figure(orig_vals, null_vals, pos_ir, neg_ir, + pos_threshold, neg_threshold): + from matplotlib import pyplot as plt + fig,ax1 = plt.subplots() + + orig_vals = np.array(sorted(orig_vals)) + + ax1.hist(orig_vals, bins=100, density=True, alpha=0.5) + ax1.hist(null_vals, bins=100, density=True, alpha=0.5) + ax1.set_ylabel("Probability density\n(blue=foreground, orange=null)") + + precisions = pos_ir.transform(orig_vals) + if (neg_ir is not None): + precisions = np.maximum(precisions, neg_ir.transform(orig_vals)) + + ax2 = ax1.twinx() + ax2.plot(orig_vals, precisions) + if (pos_threshold is not None): + ax2.plot([pos_threshold, pos_threshold], [0.0, 1.0], color="red") + if (neg_threshold is not None): + ax2.plot([neg_threshold, neg_threshold], [0.0, 1.0], color="red") + ax2.set_ylabel("Estimated foreground precision") + ax2.set_ylim(0.0, 1.02) + class FixedWindowAroundChunks(AbstractCoordProducer): count = 0 @@ -830,7 +933,7 @@ def __call__(self, score_track, null_track, tnt_results=None): np.concatenate(original_summed_score_track, axis=0)) #Note that orig_vals may have been subsampled at this point - pos_ir, neg_ir, subsampled_orig_vals =\ + pos_ir, neg_ir, subsampled_orig_vals, subsampled_null_vals =\ get_isotonic_regression_classifier( orig_vals=orig_vals, null_vals=null_vals) @@ -883,54 +986,16 @@ def __call__(self, score_track, null_track, tnt_results=None): val_transformer(neg_threshold)," and ", val_transformer(pos_threshold)) - from matplotlib import pyplot as plt - - plt.figure() - np.random.shuffle(orig_vals) - hist, histbins, _ = plt.hist(orig_vals[:min(len(orig_vals), - len(null_vals))], - bins=100, alpha=0.5) - np.random.shuffle(null_vals) - _, _, _ = plt.hist(null_vals[:min(len(orig_vals), - len(null_vals))], - bins=histbins, alpha=0.5) - - bincenters = 0.5*(histbins[1:]+histbins[:-1]) - poshistvals,posbins = zip(*[x for x in zip(hist,bincenters) - if x[1] > 0]) - posbin_precisions = pos_ir.transform(posbins) - plt.plot([pos_threshold, pos_threshold], [0, np.max(hist)], - color="red") + make_nulldist_figure(orig_vals=subsampled_orig_vals, + null_vals=subsampled_null_vals, + pos_ir=pos_ir, neg_ir=neg_ir, + pos_threshold=pos_threshold, + neg_threshold=neg_threshold) - if (len(subsampled_neg_orig_vals) > 0): - neghistvals, negbins = zip(*[x for x in zip(hist,bincenters) - if x[1] < 0]) - negbin_precisions = neg_ir.transform(negbins) - plt.plot(list(negbins)+list(posbins), - (list(np.minimum(neghistvals, - neghistvals*(1-negbin_precisions)/ - (negbin_precisions+1E-7)))+ - list(np.minimum(poshistvals, - poshistvals*(1-posbin_precisions)/ - (posbin_precisions+1E-7)))), - color="purple") - plt.plot([neg_threshold, neg_threshold], [0, np.max(hist)], - color="red") - - if plt.isinteractive(): - plt.show() - else: - import os, errno - try: - os.makedirs(self.plot_save_dir) - except OSError as e: - if e.errno != errno.EEXIST: - raise - fname = (self.plot_save_dir+"/scoredist_" + - str(FixedWindowAroundChunks.count) + ".png") - plt.savefig(fname) - print("saving plot to " + fname) - FixedWindowAroundChunks.count += 1 + show_or_savefig(plot_save_dir=self.plot_save_dir, + filename="scoredist_" + +str(FixedWindowAroundChunks.count)+".png") + FixedWindowAroundChunks.count += 1 tnt_results = FWACTransformAndThresholdResults( neg_threshold=neg_threshold, diff --git a/modisco/value_provider.py b/modisco/value_provider.py index 045ab00..de2fbb5 100644 --- a/modisco/value_provider.py +++ b/modisco/value_provider.py @@ -101,7 +101,7 @@ def from_hdf5(cls, grp): def valatmaxabs(arrs): idxs = np.argmax(np.abs(arrs), axis=0) return arrs[idxs, np.arange(len(arrs[0]))], idxs - + class PrecisionValTransformer(AbstractValTransformer): @@ -136,7 +136,7 @@ def transform_score_track(self, score_track): neg_val_indices = np.nonzero(window_sums_row < 0)[0] if (len(neg_val_indices) > 0 and neg_ir is not None): neg_vals = window_sums_row[neg_val_indices] - transformed_neg_vals = neg_ir.transform(neg_vals) + transformed_neg_vals = neg_ir.transform(neg_vals) transformed_row[neg_val_indices] = -transformed_neg_vals #add padding to make up for entries lost due to the sliding From fbaa374da9147b0561211edfb0b6e50f0ad81128 Mon Sep 17 00:00:00 2001 From: Avanti Shrikumar Date: Tue, 22 Dec 2020 09:32:31 -0800 Subject: [PATCH 15/30] hit scoring code --- .../TF_MoDISco_TAL_GATA_hitscoring.ipynb | 2261 +++++++++++++++++ .../TF_MoDISco_TAL_GATA_hitscoringdev.ipynb | 1383 ---------- modisco/coordproducers.py | 31 +- .../hit_scoring/exemplar_based_hitscoring.py | 125 +- modisco/util.py | 16 + modisco/value_provider.py | 5 +- modisco/visualization/viz_sequence.py | 16 + 7 files changed, 2413 insertions(+), 1424 deletions(-) create mode 100644 examples/simulated_TAL_GATA_deeplearning/TF_MoDISco_TAL_GATA_hitscoring.ipynb delete mode 100644 examples/simulated_TAL_GATA_deeplearning/TF_MoDISco_TAL_GATA_hitscoringdev.ipynb diff --git a/examples/simulated_TAL_GATA_deeplearning/TF_MoDISco_TAL_GATA_hitscoring.ipynb b/examples/simulated_TAL_GATA_deeplearning/TF_MoDISco_TAL_GATA_hitscoring.ipynb new file mode 100644 index 0000000..ba3ae7d --- /dev/null +++ b/examples/simulated_TAL_GATA_deeplearning/TF_MoDISco_TAL_GATA_hitscoring.ipynb @@ -0,0 +1,2261 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "view-in-github" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "oPV0Wsfg9OBZ" + }, + "source": [ + "# TF-MoDISco on the TAL GATA simulation\n", + "\n", + "### Note: we are still refining the multi-task version of TF-MoDISco. If you encounter difficulties running TF-MoDISco with multiple tasks, our recommendation is to run it on one task at a time.\n", + "\n", + "This notebook demonstrates running TF-MoDISco on importance scores obtained from the TAL-GATA simulation used in the DeepLIFT paper. See Generate Importance Scores.ipynb for a notebook demonstrating how to produce the scores. There are 3 tasks. Task 0 is positive when both TAL and GATA motifs are present in the sequence. Task 1 is positive when GATA motifs are present in the sequence. Task 2 is positive when TAL motifs are present in the sequence." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 541 + }, + "colab_type": "code", + "id": "CLiK1j6A8YrA", + "outputId": "50383cd1-4015-4627-893c-01c859c3791e" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: modisco in /Users/avantishrikumar/Research/tfmodisco (0.5.8.1)\n", + "Requirement already satisfied: numpy>=1.9 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from modisco) (1.18.5)\n", + "Requirement already satisfied: joblib>=0.11 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from modisco) (0.16.0)\n", + "Requirement already satisfied: scikit-learn>=0.19 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from modisco) (0.23.1)\n", + "Requirement already satisfied: h5py>=2.5 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from modisco) (2.10.0)\n", + "Requirement already satisfied: leidenalg>=0.7.0 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from modisco) (0.8.1)\n", + "Requirement already satisfied: tqdm>=4.38.0 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from modisco) (4.47.0)\n", + "Requirement already satisfied: psutil>=5.4.8 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from modisco) (5.7.0)\n", + "Requirement already satisfied: matplotlib>=2.2.5 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from modisco) (3.2.2)\n", + "Requirement already satisfied: scipy>=0.19.1 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from scikit-learn>=0.19->modisco) (1.4.1)\n", + "Requirement already satisfied: threadpoolctl>=2.0.0 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from scikit-learn>=0.19->modisco) (2.1.0)\n", + "Requirement already satisfied: six in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from h5py>=2.5->modisco) (1.15.0)\n", + "Requirement already satisfied: python-igraph>=0.8.0 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from leidenalg>=0.7.0->modisco) (0.8.2)\n", + "Requirement already satisfied: cycler>=0.10 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from matplotlib>=2.2.5->modisco) (0.10.0)\n", + "Requirement already satisfied: python-dateutil>=2.1 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from matplotlib>=2.2.5->modisco) (2.8.1)\n", + "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from matplotlib>=2.2.5->modisco) (2.4.7)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from matplotlib>=2.2.5->modisco) (1.2.0)\n", + "Requirement already satisfied: texttable>=1.6.2 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from python-igraph>=0.8.0->leidenalg>=0.7.0->modisco) (1.6.3)\n" + ] + } + ], + "source": [ + "!pip install modisco" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "en15RxNL8YFE" + }, + "outputs": [], + "source": [ + "from __future__ import print_function, division\n", + "%matplotlib inline\n", + "/\n", + "try:\n", + " reload # Python 2.7\n", + "except NameError:\n", + " try:\n", + " from importlib import reload # Python 3.4+\n", + " except ImportError:\n", + " from imp import reload # Python 3.0 - 3.3" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 86 + }, + "colab_type": "code", + "id": "uVOSJpXV8aIG", + "outputId": "3fa7a2eb-987f-49d6-8e8c-307a93d580b8" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "TF-MoDISco is using the TensorFlow backend.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages/tensorflow/python/compat/v2_compat.py:96: disable_resource_variables (from tensorflow.python.ops.variable_scope) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "non-resource variables are not supported in the long term\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/avantishrikumar/anaconda3/lib/python3.8/site-packages/sklearn/utils/deprecation.py:143: FutureWarning: The sklearn.neighbors.kde module is deprecated in version 0.22 and will be removed in version 0.24. The corresponding classes / functions should instead be imported from sklearn.neighbors. Anything that cannot be imported from sklearn.neighbors is now part of the private API.\n", + " warnings.warn(message, FutureWarning)\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import modisco\n", + "import sys\n", + "import os" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "ROG0LVF_9ZZs" + }, + "source": [ + "## Grab the input data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 443 + }, + "colab_type": "code", + "id": "bZ8jaBDZ8fmm", + "outputId": "87734ddd-01e6-4433-9650-5f5e0ef01b97" + }, + "outputs": [], + "source": [ + "#grab scores for tfmodisco\n", + "#!/usr/bin/env bash\n", + "![[ -f scores.h5 ]] || curl -o scores.h5 https://raw.githubusercontent.com/AvantiShri/model_storage/23d8f3ffc89af210f6f0bf7e65585eff259ba672/modisco/scores.h5\n", + "![[ -f sequences.simdata.gz ]] || wget https://raw.githubusercontent.com/AvantiShri/model_storage/db919b12f750e5844402153233249bb3d24e9e9a/deeplift/genomics/sequences.simdata.gz\n", + "![[ -f test.txt.gz ]] || wget https://raw.githubusercontent.com/AvantiShri/model_storage/9aadb769735c60eb90f7d3d896632ac749a1bdd2/deeplift/genomics/test.txt.gz" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "_ShCbHRM92_y" + }, + "source": [ + "## Functions for one-hot encoding sequences¶" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "KawKTu5P8-c6" + }, + "outputs": [], + "source": [ + "#Functions for one-hot encoding sequences\n", + "import gzip\n", + "\n", + "def one_hot_encode_along_channel_axis(sequence):\n", + " to_return = np.zeros((len(sequence),4), dtype=np.int8)\n", + " seq_to_one_hot_fill_in_array(zeros_array=to_return,\n", + " sequence=sequence, one_hot_axis=1)\n", + " return to_return\n", + "\n", + "def seq_to_one_hot_fill_in_array(zeros_array, sequence, one_hot_axis):\n", + " assert one_hot_axis==0 or one_hot_axis==1\n", + " if (one_hot_axis==0):\n", + " assert zeros_array.shape[1] == len(sequence)\n", + " elif (one_hot_axis==1): \n", + " assert zeros_array.shape[0] == len(sequence)\n", + " #will mutate zeros_array\n", + " for (i,char) in enumerate(sequence):\n", + " if (char==\"A\" or char==\"a\"):\n", + " char_idx = 0\n", + " elif (char==\"C\" or char==\"c\"):\n", + " char_idx = 1\n", + " elif (char==\"G\" or char==\"g\"):\n", + " char_idx = 2\n", + " elif (char==\"T\" or char==\"t\"):\n", + " char_idx = 3\n", + " elif (char==\"N\" or char==\"n\"):\n", + " continue #leave that pos as all 0's\n", + " else:\n", + " raise RuntimeError(\"Unsupported character: \"+str(char))\n", + " if (one_hot_axis==0):\n", + " zeros_array[char_idx,i] = 1\n", + " elif (one_hot_axis==1):\n", + " zeros_array[i,char_idx] = 1\n", + "\n", + "#read in the data in the testing set\n", + "test_ids_fh = gzip.open(\"test.txt.gz\",\"rb\")\n", + "ids_to_load = set([x.rstrip() for x in test_ids_fh])\n", + "\n", + "fasta_sequences = []\n", + "for i,a_line in enumerate(gzip.open(\"sequences.simdata.gz\",\"rb\")):\n", + " if (i==0):\n", + " next\n", + " a_line = a_line.rstrip()\n", + " seq_id,seq_fasta,embeddings,task1,task2,task3 = a_line.split(b\"\\t\")\n", + " if seq_id in ids_to_load:\n", + " fasta_sequences.append(seq_fasta.decode(\"utf-8\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "m1xkAlvW97vL" + }, + "source": [ + "## Prepare the data for input into TF-MoDISCo\n", + "\n", + "You need a numpy array of importance scores and hypothetical importance scores for every task." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "xahZGqrA9Jpq" + }, + "outputs": [], + "source": [ + "import h5py\n", + "from collections import OrderedDict\n", + "\n", + "task_to_scores = OrderedDict()\n", + "task_to_hyp_scores = OrderedDict()\n", + "\n", + "f = h5py.File(\"scores.h5\",\"r\")\n", + "tasks = f[\"contrib_scores\"].keys()\n", + "n = 100 #since this is just a test run, for speed I am limiting to 100 sequences\n", + "for task in tasks:\n", + " #Note that the sequences can be of variable lengths;\n", + " #in this example they all have the same length (200bp) but that is\n", + " #not necessary.\n", + " task_to_scores[task] = [np.array(x) for x in f['contrib_scores'][task][:n]]\n", + " task_to_hyp_scores[task] = [np.array(x) for x in f['hyp_contrib_scores'][task][:n]]\n", + "\n", + "onehot_data = [one_hot_encode_along_channel_axis(seq) for seq in fasta_sequences][:n]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "hQEQgz1w-QhL" + }, + "source": [ + "Double check by plotting" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 405 + }, + "colab_type": "code", + "id": "Ky6nlCFs-NcP", + "outputId": "1319f738-704a-4241-a804-ab54e6d3246b" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import modisco.visualization\n", + "from modisco.visualization import viz_sequence\n", + "\n", + "viz_sequence.plot_weights(task_to_scores['task0'][0], subticks_frequency=20)\n", + "viz_sequence.plot_weights(task_to_hyp_scores['task0'][0], subticks_frequency=20)\n", + "viz_sequence.plot_weights(onehot_data[0], subticks_frequency=20)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "uuvSgm62-Whl" + }, + "source": [ + "Run TF-MoDISco\n", + "TF-MoDISco first identifies seqlets, then splits the seqlets into \"metaclusters\" according to their pattern of activity across all the tasks, and then performs clustering within each task. Since there are 3 tasks, there are 27 possible metaclusters (consisting of a +1, -1 or 0 for each task). Consistent with the simulation, the [+1, +1, 0], [+1, 0, +1], [0, 0, +1] and [0, +1, 0] metaclusters turn up motifs.\n", + "\n", + "To demonstrate customization, the code below has slight modifications from default settings in the following ways:\n", + "\n", + "- Because the TAL and GATA motifs are relatively short compared to something like CTCF, it uses a sliding window size of 15 (rather than the default of 21) and flanks of 5 (rather than the default of 10). The sliding window size and flanks should be adjusted according to the expected length of the core motif and its flanks. If the window size or flank sizes are too long, you risk picking up more noise.\n", + "- During the seqlet clustering, motifs are trimmed to the central trim_to_window_size bp with the highest importance. trim_to_window_size is set to 10 rather than the default of 30. After the trimming is done, the seqlet is expanded on either side by initial_flank_to_add. This is set to 3 rather than the default of 10.\n", + "- The final_min_cluster_size is set to 60 rather than the default of 30. This is used to filter out small clusters with relatively weak support (in this case, fewer than 60 seqlets).\n", + "- It uses kmers of length 5 with 1 gap and no mismatches to compute the \"quick and dirty\" affinity matrix across all seqlets. The \"quick and dirty\" affinity matrix is used both for noise filtering and as a first pass to speed up computation of the continuous jaccard affinity matrix (the latter affinities are only computed between seqlets deemed to be close together by the \"quick and dirty\" method). I made the kmer length smaller to keep memory usage down when testing on my macbook pro. The default is to use kmers of length 8 with 3 gaps and 2 mismatches, which tends to run out of memory on many systems (I would change the default but want to avoid breaking reproducibility for older users)\n", + "- target_seqlet_fdr controls the noisiness of the seqlets. For a particular task, \"significant\" seqlets are identified by first smoothing importance scores with a window of size sliding_window_size and then fitting a laplace distribution to the left and right tails. This laplace distribution is assumed to represent the null distribution of window importance scores (note: as an alternative, it's possible to supply an empirical null distribution; see examples/H1ESC_Nanog_gkmsvm/TF MoDISco Nanog.ipynb for an example). A threshold is then identified such that the false discovery rate (computed as the ratio of the expected fraction of windows with a certain score in the null distribution relative to the observed fraction of windows with that score) is less that target_seqlet_fdr. Note: if the number of sliding windows that pass the FDR threshold is smaller than min_passing_windows_frac (default value 0.03 at the time of writing) or larger than max_passing_windows_frac (default value of 0.2 at the time of writing), the threshold will be adjusted." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "colab_type": "code", + "id": "--8gp-i2-TOm", + "outputId": "b39814f5-cb17-4eb6-b4fc-11638426529a", + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MEMORY 0.32499712\n", + "On task task0\n", + "Fitting - on window size 5\n", + "peak(mu)= 0.00486588878557086\n", + "Computing window sums\n", + "Done computing window sums\n", + "For increasing = True , the minimum IR precision was 0.2954850349262155 occurring at 5.7220458984375e-06 implying a frac_neg of 0.41941626448668695\n", + "Adjusted frac neg is 0.99\n", + "For increasing = False , the minimum IR precision was 0.35928651361524633 occurring at -5.638343282043934e-06 implying a frac_neg of 0.5607600296390388\n", + "Adjusted frac neg is 0.99\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAakAAAEJCAYAAAAuMNi1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3daZhcVbn28f/dncQMEhBEhQRkkEFFwhAhCIJMCsggiooKCg4cFAXkqIieV5TjgAMqeATMYVQG9QhIVBBQgogyJSGMAcQAIYBE5hBCSKfv98PalVQ61dW7u6tq765+ftdVV9WeVzehnl7Ts2SbEEIIoYw6ii5ACCGE0JsIUiGEEEorglQIIYTSiiAVQgihtCJIhRBCKK0IUiGEEEqrNEFK0ucl3S3pLkkXSxpddJlCCCEUqxRBStIE4Ghgsu0tgE7g4GJLFUIIoWgjii5AlRHAGElLgbHAY/VO7ujo8JgxY1pSsBBCaBcvvviibZeigpJHKYKU7Ucl/QCYBywGrrZ9db1rxowZw6JFi1pSvhBCaBeSFvdx/BxgX2BB1rLV87iAU4F9gBeBw2zPakZZoTzNfa8CDgA2BNYFxkk6pMZ5R0iaIWlGV1dXq4sZQgjDwXnAXnWO7w1skr2OAM5oZmFKUZMC9gAetP1vAEmXAm8DLqg+yfZUYCrAuHHjBpR0cNGSLp5e9PLgStsP66w+mhGdpfhboKYFz7/Ekq7uoosRQuiH8aNHsvrYkU25t+3rJW1Q55QDgJ87JX69SdIaktax/XgzylOWIDUPmCJpLKm5b3dgRjMedM09T3Dsr2Y349Y1HbTtRH7w/kkte15/TL93AYefd2vRxQgh9NPRu72B4965WVGPnwA8UrU9P9vXvkHK9s2SfgPMArqA28hqTI229fpr8P2DtmzGrVdx6p//wZMvLGnJswZiwcKXAPjqPm9kjSb9VRZCaLw3rjN+MJePkFRdCZiatVLlpRr7mracRimCFIDtE4ETm/2c1681jtevNa7ZjwHggpsepswroSzLWvn2m7Qur1s9pqWFMEx02Z48iOvnA+tVbU+kj9HYg1HezpLQdN1ZBO2IfwUhhPymAR9VMgV4rln9UVCimlRbUq1acXksD1IlL2cIoXUkXQy8A3i1pPmkFq6RALbPBK4gDT9/gDQE/fBmlieCVJOVuLWP7u5Uus4IUiGEjO0P9XHcwFEtKk4EqWYq41f/VXf/i29fMYdum4UvpblmUZMKIZRVBKkmc8lGTsx46GnmP7OYAyatC8CEV41h/Jj4ZxBCKKf4dhpKpn8Hdj1hULfo6jZjR3Xyww9u1aBChRBC88S4riYqYytad7fp7ChhwUIIoYYIUsNMV7cZEUEqhDBERJBqojKGgmVRkwohDCERpJqsZOMmUpAqYztkCCHUEEGqiVTCYLCs23R2lq9cIYRQS4zuazKXZDrvAwte4JFnXuSx5xYzIvIghRCGiAhSTVSm+spBZ/6dZ19cCsCk9dYouDQhhJBPBKkmK0uf1KIlXbx3mwkcOuX1LcsCH0IIgxVBqonK1CXV7bRK8Nbrv6roooQQQm7ROdFkZalJdduRoy+EMOREkBom7HKONgwhhHoiSDWRSjJ0opLkthylCSGE/EoTpCRtJml21et5SccWXa7BKsMQ9EqTYzT3hRCGmtIMnLB9H7AVgKRO4FHgskILNVgliQmVFXgjRoUQhprS1KR62B34p+2Hiy7IYJVh4ET38ppUseUIIYT+KmuQOhi4uOhCDFZZYkKlyTEGToQQhprSBSlJo4D9gf+rcewISTMkzejq6mp94QagBBWp5bW5iFEhhKGmKUFK0qskvVnSRpL6+4y9gVm2n+h5wPZU25NtTx4xojTdab0qS1CIgRMhhKGqYd/0klYHjgI+BIwC/g2MBl4r6SbgdNvTc9zqQ7RBU1+ZdMcQ9BDCENXI6shvgJ8Db7f9bPUBSdsCh0rayPbZvd1A0lhgT+A/GliuwgiVYuREpQRRkwohDDUNC1K296xzbCYwM8c9XgTWalSZQhJD0EMIRZG0I/B14PWkmCPAtjfKc30jm/u2qXfc9qxGPWsoKcVk3u70HqP7QggFOBv4PKmisqy/Fzeyue+UOscM7NbAZw0JZYkJlUAZ86RCCAV4zvaVA724kc19uzbqXu2kBF1SyyfzRowKIRRguqTvA5cCSyo787auNbK57731jtu+tFHPGipKU5PKImVHVKVCCK23ffY+uWpf7ta1Rjb37VfnmElRNBTgxZdTM3D0SYUQWm2wrWyNbO47vFH3ahdCJRg2AV+7/C4AxozsLLgkIYThJptDeyKwc7brL8BJtp/Lc33D0zZI+lqt/bZPavSzQj5LutLwvv0mrVNwSUIIw9A5wF3AB7LtQ4FzgbpdRBXNyC20qOrzaGBfYE4TnlN60or+oCJ1dZspG63JK0ZETSqE0HIb235f1fY3JM3Oe3HDg5TtlYaiS/oBMK3Rzwn5Les2o6KpL4RQjMWSdrJ9Ayyf3Ls478WtyNI6Fsg1s7gdFV+PSjWpzhjZF0IoxqeB87O+KQFPA4flvbgZfVJ3suK7uRNYG4j+qAIt6+5mRASpEEJOkvYCTiV9h59l++Qex1cHLgDWJ8WRH9g+t9a9bM8GJkkan20/35+yNKMmtW/V5y7gCdtDY/GnJihBlxRdy6ImFULIR1In8FNSsu/5wK2Sptm+p+q0o4B7bO8naW3gPkkX2n656j6H2L5A0nE97g+A7R/mKU8z+qQezn7I12b3X1cStuc1+lllV5Z5Scu6zYjOcpQlhFB62wEP2J4LIOmXwAFAdZAysJrSl9wrSU14PSsj47L31QZTmGY0932ONCb+CSBLbYqBLRv9rFDfr26dx6WzHuWRZ15ks9cN6t9JCKF9jJA0o2p7qu2pVdsTgEeqtuezImtExf+QBsQ9RgpCH7QrqawT2z/L3r8xqMIO5uJeHANsZvupJtx7SBHFDpy4fPZj3PPY80yauAb7vCXmSIUQAOiyPbnO8VrNLj2/yt4FzCalNtoYuEbSX2v1N0n6HvBN0oi+PwKTgGNtX5CnsM1YPv4RINdM4tBcNmy+zmr86j92iCAVQshrPrBe1fZEUo2p2uHApU4eAB4ENu/lfu/Mgte+2b03Bb6YtzDNqEnNBa6T9AdWznibq5OsnSgt7VXY843T6sAhhJDfrcAmkjYEHgUOBj7c45x5wO7AXyW9FtiM9N1fy8jsfR/gYttP96e/vhlBal72GpW9QkFsYn2OEEK/2O6S9FngKtIQ9HNs3y3pyOz4mcB/A+dlU44EHG/7yV5u+TtJ95Ka+z6TjQZ8KW95mjG6b8CdZJLWAM4CtiC1gX7c9o2NKlurFd0nFTEqhDAQtq8Aruix78yqz48B78x5ry9L+i7wvO1lkhaRRgvm0ow+KSR9qfq9H04F/mh7c1Ln2rDM+dcwLs+aViGE4UXSbtn7e4FdgQOyz3sBb8t7n2alRToY+F7Ve5+y2cg7k6XLyCaFvVzvmrIrep6Uoy4VQijOLsC11F5rMPcag83O3defb8iNgH8D50qaBMwEjrG9qP5l5VZkxgmbGDgRQiiE7ROz90GtNdiU5r4BGgFsA5xhe2vSkh9frj5B0hGSZkia0dU1bDMt5WaiuS+EUCxJ387GG1S2XyXpm3mvL1OQmg/Mt31ztv0bUtBazvZU25NtTx4xohUJ3AcnDZwocAi6HUEqhFC0vW0/W9mw/QxpOHoupQlStv8FPCJps2zX7qycKyr0U+qRiigVQihUp6RXVDYkjQFeUef8lTSrOnJd9j69n9d9DrhQ0ijSxLBBtWUWLa3MW9zzHaP7QgjFuwD4s6RzyaYWAefnvbgpQcr2cdXv/bhuNlAvp1TohxKsEhJCGOZsf0/SHcAepF6Q/7Z9Vd7rm5EFfSzwn8D6tj8laRNSwtnfN/pZ5afG1aSmf6f/19iFD4MPIQTSnNcu23+SNFbSarYX5rmwGX1S55Jy9u2Qbc8nZcANLRazpEIIRZP0KdJAuJ9luyYAv817fTOC1Ma2vwcsBbC9mGH6XVl0JSb6pEIIJXAUsCPwPIDtfwCvyXtxn819krawfVc/CvRyNnrD2fUbU5UNfbh5+KlFHHp2GlX//snrsf+kdVv6/IhRIYSCLbH9cqXrQdII+tFlnqdP6sxstN15wEXV4917cSJpYav1JF1IiqCH5S1QO3nXm1/Hky8s4YUlXdz7+EJGdna0NEiZ6JMKIRTuL5K+AoyRtCfwGeB3eS/uM0jZ3ikb/PBxYIakW4BzbV/Ty/nXSJoFTCH9IX9MnRTube2gbSdy0LYTATjgp39jWXdrx9ultEghhFCo44FPAncC/0HKrn5W3otzje6z/Q9J/wXMAE4Dtlb6E/0rtldKEiipkiXi8ex9fUmrAw/bHra5jEZ0qJggFVEqhFAQSR3AHba3AP53IPfI0ye1JWlS7buBa4D9bM+StC5wI6tmsj2dlM7oDtIf8ltkn9eSdKTtqwdS0KGus0N0dXe39JkpJEaUCiEUw3a3pNslrW973kDukWd03/8As4BJto+yPSt7+GPAf9U4/yFg6yzH3rbA1sBdpIlcuZbtaEcNq0n1Y75U5O4LIZTAOsDdkv4saVrllffiPM19l9r+RfUOScfYPrXn/szmtu+ubNi+R9LWtucO5078zg7x4sutzwExfH/jIYSSGPBq7ZCvJvXRGvsOq3P+fZLOkLRL9joduD9LMLh0IIVsB9EnFUIYjmz/BbgPWB0YD9yX7cul15qUpA8BHwY27FE1Ww14qs49DyMNMTyW9If8DcAXSAFq17wFazedHR10tTpI4ciCHkIolKRPAl8jrdIr4CeSTrJ9Tp7r6zX3/Z00Qu/VwClV+xeSBkLUlGWYOKXHNRUv5ClUO0o1qRYPnIgMsyGE4n2RNE7hKQBJa5Hiy+CClO2HgYdZkYMvF0k7Al8HXl99f9sb9ec+7aazUwXUpKK5L4RQuPmkyk3FQuCRvBfXa+67IZvIu5CVU1gIsO3xvVx6NvB5YCawLG9B2l0xfVIxui+EULhHgZslXU6KJQcAt0iqLOn0w3oX16tJ7ZS9r9bPAj1n+8p+XtP2RnR00LWsgJpU9EmFEIr1z+xVcXn2niu25JnMuzEw3/YSSe8AtgR+XieH33RJ3ydN8l2eWLYyv2q4KqImFWt1hBCKZntQQ9DzzJO6BJgs6Q2kprxpwEXAPr2cv332Xr3CroHdBlrIdlBYn1RLnxhCCI2VJ0h12+6SdCDwY9s/kXRbbyfbHvAwc0kPkTrVlpFWcWybpeSLGd0XWdBDCENbniC1NJsz9TFgv2zfyHoXSHo38GZgdGWf7ZNylmnXdsyannL3RcaJEELojzxB6nDgSOBbth+UtCFwQW8nSzoTGEuauHsWcBBwSwPKOqQVMrqPGIIeQiiGpJ9QZ3FD20fnuU+faZFs32P7aNsXZ9sP2j65ziVvs/1R4Jmsw2wHYL08hSH9QFdLminpiJzXDAmdHR0s6erm5Cvv5eQr72Xmw083/ZmxnlQIoUAzSFORRpNWxvhH9tqKfkxPyjO6r+fk3Mo8qd4m576Uvb+YLefxFLBhzvLsaPsxSa8BrpF0r+3rq8pyBHAEwKhRo3LeshzeuM5qjOwU5/ztQV7u6ub+JxZyzmFrNvWZsTJvCKEots8HkHQYqRtnabZ9JpB7yaY8zX39nZz7O0lrAN8nLfFhci52lS3/ge0Fki4DtgOurzo+FZgKMG7cuCGV9OeArSZwwFYT0ucWrdIbNakQQgmsS5oTVWk+emW2L5c8QSr35NxsFcY/Z3OoLpH0e2C07edyXDsO6LC9MPv8TiDvYItQg2MMegiheCcDt0manm3vQmqdyyVPkMo9OTdbhfEUsnx/tpdUX9OH1wKXZc1TI4CLbP8x57VDiqjTm9jwZ0WUCiH0j6S9gFOBTuCsWuMQsuQOPyaN9n7S9i617mX7XElXsmIO7Zdt/ytvWfIEqf5Ozr1a0vtIiyXm/i62PReYlPf8oUxKc5iaLXL3hRD6S1In8FNgT1Jy2FslTbN9T9U5awCnA3vZnpeNI6inE/g3KeZsKmnT6vEG9fQZpAYwOfc4YBywTNJi+k5IG5okWvtCCAOwHfBAVnFA0i9JSWHvqTrnw6SKyDxI4wh6u5mk7wIfBO4GKhkNTNV4g3ryjO57LfBtYF3be0t6E7CD7bNrnT+AhLTDTqsCR6zMG0IYgAmsvJTGfFa0qFVsCoyUdB1pUMSptn/ey/3eA2yWdf/0W57l488DrmLFaIz7Savu9krS/pJ+kL32HUjB2pmklixIGCvzhhBqGCFpRtWr55zUWl8aPb+xRgDbAu8G3gX8P0mb9vK8ufSRpahuYXOc82rbv5Z0AkCWx6/XoeiSTgbeClyY7TpG0k62vzzQQrYjt2DoRNSkQgg19JUXdT4rJ2CYCDxW45wnbS8CFkm6njSm4P4a93sRmC3pz6w8+C5Xxok8QWpRttyvASRNAeoNKd8H2Mp2d3b++cBtQASpTMua+4ggFULot1uBTbIUeI8CB5P6oKpdDvyPpBHAKFJz4I96ud+07DUgeYLUcdkDNpb0N2BtUj6+etZgxcSt1QdauHaVRvf1/7ob5z4FwE1d9/P5PXurWa/QiibFEEJ7yVrLPkvq5ukEzrF9t6Qjs+Nn2p4j6Y/AHaTBEGfZvquX+50/mPLkGd03S9IuwGakSsB9lfQWvfgOKyZuCdgZOGEwhWw3ojV9UjG+L4QwELavAK7ose/MHtvfJ2UWqkvSg9SYGlontd5Keg1Skt7by6FNU8e/L6110PbF2YiPt5K+IY/vz8St4SL6pEIIw0R1/9do4P1A7sSl9WpSlbWjXgO8Dbg2294VuI6UgaIm248ziDbIttfCwBExKoRQJNtP9dj1Y0k3AF/Lc32vQcr24QBZ/r03ZYEHSeuQZiOHAUqzm5v/nBg4EUIomqRtqjY7SDWr3PNp8wyc2KASoDJPkCZyhUFoRZeUHfOkQgiFO6XqcxfwEPCBvBfnCVLXSboKuJj03XowML3+JaGe/ozu+9E1adrBlHk9a8x9i5pUCKFoA0itt5I8K/N+FjiTNFFrK2Cq7c/lfYCkOdnrswMvZnsRaklVKtaTCiEUTdLqkn5YleHiFEm5pyblqUlh+zLgsoEU0PYbJb2aVXM/DWutGd0XK/OGEAp3DnAXK5r4DgXOBXobQb6SXEFqsGw/CfyhFc8aCgY6mbe/Yi5vCKEENrb9vqrtb0ianffihgUpSQup870YS3Ws0LLKTcyTCiEUb3GWv/UGAEk7AovzXpxnqY59gSsqufh6U1miQ9JJwL+AX5C6RD5CP4YbDgdCrRndR6zMG0Io3JHAz6v6oZ4BPpb34jw1qYOBUyVdApxre04f57/LdnX/0xmSbga+l7dQw0GszBtCaHfZKr+H2J4kaTyA7ef7c488o/sOAbYG/gmcK+lGSUdI6q12tEzSRyR1SuqQ9BGg16U9qmXX3JZNIG5brQockbkvhFAk28tI605h+/n+BijIt+hhJfJdAvwSWAc4EJglqdZQ9A+TRnE8kb3ez6pp3ntzDNBXTa0ttGYyb/RJhRAKd5ukaZIOlfTeyivvxXn6pPYHDgc2JvUzbWd7gaSxpIDyk+rzbT8EHNCfnyB7zkTSKo/fIi0P0tZatjJvRKkQQrHWBJ4CdqvaZ+rkf62Wp0/qIOBHtq+v3mn7RUkf73mypLWBTwEbVN/f9irn9vBj4EsMg0EWUosGTsRk3hBCwSp5YAcqT5B6vGeAkvRd28fb/nON8y8H/gr8ifx9UfsCC2zPlPSOOucdARwBMGrUqDy3LqX+Bo4p86YO6DkeyMNCCKGBJJ1WY/dzwAzbl/d1fZ4+qT1r7Nu7zvljswD2a9uXVF59PGNHYH9JD5H6vXaTdEHPk2xPtT3Z9uQRI1oyD7l5WjSbN4aghxAKNpqUUu8f2WtLUhPgJyT9uK+L6y16+GngM6Rl4++oOrQa8Lc69/y9pH2ylR1zsX0C2eq9WU3qC9mowrak1qTuCyGEMngDsJvtLgBJZwBXkypAd/Z1cb3qyEXAlaTl4L9ctX+h7afrXHcM8BVJS4ClVJZPiowTy7Uu4UTMkwohFG4CMI7UxEf2eV3by7I4UVe9IGXbD0k6qucBSWv2FqgqmScGyvZ1pJV/25ak1rT2xcCJEELxvgfMlnQd6StpZ+DbksaRxi7U1VdNal9gJqvOCzWwUa2LJO1ca3/PwRfDXUuyoBPzpEIIxbJ9tqQrgO1IceQrth/LDn+xr+vrLR+/b/a+YT/LVP3Q0VnBZrLyGPlhrWXNfbEybwihYEqTNXcHNrJ9kqT1JW1n+5Y819cbOLFNb8cAbM/qZf9+Pe6zHpG3byWtXKojalIhhIKdDnSTKionAQtJGYzemufies19p9Q5ZvLXjOYDW+Q8d9iIPqkQwjCxve1tJN0GYPsZSbknutZr7hvQuvSSfsKKEdYdpPHxtw/kXu2rNRkn0qMiTIUQCrU0y4ae8gukrER1l36qVq+5bzfb1/aWCNB2b3mXZlR97gIutl1vXtWw04q4UVkKJEJUCKFgpwGXAa+R9C1Sqr3/yntxvea+XYBrgf1qHOs1OaDt87Oq3KbZrvvyFmY4afZ6UpXbR0UqhFAUSR3Ag6S8rLuT/m5+T451CZer19x3Yvber+SAWcaI84GHsgKtJ+ljMQR9hVbEjUoIjNF9IYSi2O6WdIrtHYB7B3KPPnP3SVpL0mmSZkmaKelUSWvVueQU4J22d7G9M/Au4EcDKVy7amlzX8SoEEKxrpb0Pg1w3aA8CWZ/CfwbeB+pLfHfwK/qnD/S9vImPtv3AyMHUrh2JQaXcSJPVvQVNakQQijUccD/AS9LWpi9cq/QmyeV+Jq2/7tq+5uS3lPn/JmSziYtkAjwEdJk3lCl2Rknok8qhFAGg02VlydITZd0MPDrbPsg4A91zj8SOAo4mvSH/PWkyVwh04rJvJUgGCvzhhCKlq3wXkmZd53t3+e9tt4Q9IWsyNl3HFBZ36kDeAE4scY1HcBM21sAP8xbiOGmNX1SzX9GCCH0RdLJpOwSF2a7jpG0k+0v17lsuXqj+/pdRctGctwuaX3b8/p7/XDSqhgSFakQQsH2Abay3Q0g6XzgNlZeAqpXuZa3lfQqYBNSwligblbzdYC7Jd0CLKo6f/88zxoO0sCJ1oSpGIIeQugvSXsBpwKdwFm2T+7lvLcCNwEftP2bOrdcA6gs77R6f8rSZ5CS9EnSQoYTgdnAFOBGes/d943+FGBYamFzX9SkQgj9kaUw+ilp5dz5wK2Sptm+p8Z53wWu6uOW3wFukzSdFetJnZC3PHlqUseQ2hNvsr2rpM2pE4hs/yXvw4cr0fzmvlasVxVCaEvbAQ/Yngsg6ZfAAcA9Pc77HHWymUvaMUuJdylpIdu3kr7+jrf9r7yFyTNP6iXbL2UPfYXte4HNeju5Mga+x+sRSZdJqrlQ4rDU7NF9lZpUcx8TQmg/E4BHqrbnZ/uWkzQBOBA4s859Tsveb7T9uO1pti/vT4CCfDWp+ZLWAH4LXCPpGeCxOuf/MDt+Eek78mDgdaQcfucA76h1kaTRpOHqr8jK9ZtKaqZ2IzU/C/ryybwRpUIIKxshqToR+FTb1RkCan1r9PzK+jGpRrSszjSXpZLOBSZIOq3nQdtH5ypsXyfYPjD7+PWsTXF14I91LtnL9vZV21Ml3ZStyPiVOtctAXaz/YKkkcANkq60fVNfZRxqWpK7b3kW9IhSIYSVdNmeXOf4fGC9qu2JrFoxmQz8MgtQrwb2kdRl+7dV5+wL7EEavzDghA55R/dtA+xEiqZ/s/1yndO7JX0AqIz0OKjqWK8VCKdv1ReyzZHZq207VpqeBT17j5pUCKGfbgU2kbQh8CipNezD1SfY3rDyWdJ5wO97BChsP0kKZHNsD3hNwTwJZr9Gymq+Filiniup3logHwEOBRYAT2SfD5E0BvhsH8/qlDQ7u/Ya2zfn+imGGKkFAyfaNryHEJrJdhfpu/oqYA7wa9t3SzpS0pEDuN+gFr3NU5P6ELB11eCJk4FZwDd7KdBcaq9BBXBDvQfZXgZslfWBXSZpC9t3VY5LOgI4AmDUqNyrD5dOSyo3y4egR1UqhNA/tq8Aruixr+YgCduHNbMseUb3PUTVJF7SwIZ/9naypE0l/VnSXdn2ln3UvFZh+1nSkMW9euyfanuy7ckjRuRqqSytluXua+5jQgihqerl7vsJ6e/xJaQMEtdk23tSv0b0v8AXgZ8B2L5D0kX0UvOqet7awFLbz2ZNg3uQJoq1nTS6L7KghxDal6Tj6h23nSu/a73qSGWI4kzS+vQV1/Vxz7G2b+nRzNSVoyzrAOdns5g7SO2guTPlDiWiuTWpl7u6mfP488ufFUIIBajkf92MNJF3Wra9H2m6US71EsyeX/ksaRSwabZ5n+2lde75pKSNyXpFJB0EPN5XQWzfAWydp9BDXpMjx0+u/Qc/ufYBAMaOGtrNoiGEocn2NwAkXQ1sY3thtv110iKIueTJ3fcO0ui+h0hfr+tJ+lidBLNHAVOBzSU9CjxIGvEXqjSzJvX84qWMG9XJ6Ydsy5SN1mzeg0IIoW/rA9XTll4GNsh7cZ4/s08B3llZEl7SpsDFwLY9T8ya6j5tew9J44COSvQMK7Rigu2oER3ssunaTX9OCCH04RfALZIuI7WwHQj8PO/FeUb3jawEKADb95Mm2q4iG0K+bfZ5UQSo2iR49NnFXHlnn62gAxJTpEIIZWH7W8DhwDPAs8Dhtr+d9/o8NamZks4mRUNITXf1UlzcJmkaqc2xej2pS/MWqt29cZ3xAHz9d3ez91vWacozYn5UCKFExgLP2z5X0tqSNrT9YJ4L8wSpI0n9TEeT+qSuB06vc/6awFOsvN6USenaA/CJnTbkgQUL+dOcBU25f2SbCCGUhaQTSbn+NgPOJbXEXQDsmOf6ukFKUgcw0/YWpOzmfbJ9eJ7zhrsO5Vudd8q8qX2eE0IIJXYgaeT2LADbj0larf4lK9Ttk8rWpL9d0vp5byhpYrZ21AJJT0i6RNLEvNcPFx0Sy7qbV+WJxr4QQpnX2pUAABN3SURBVEm8nCUQr0xLGtefi/M0961DyjhxCyv3Me3fy/nnktaSen+2fUi2b8/+FKzddXY0L0jFqrwhhBL5taSfAWtI+hTwceCsvBfnCVK9LhXfi7Vtn1u1fZ6kY/t5j7aXmvuKLkUIITSX7R9I2hN4ntQv9TXb1+S9vl7uvtGkQRNvAO4Ezs5SuPflSUmHkOZSQcqi/lTeAg0XHYJlTYpSduTsCyGUg6Tv2j4euKbGvj7V65M6nzQi405gb9Kk3jw+DnwA+BcpHdJB2b5QpbNDdEdVKoTQ/mp19eyd9+J6zX1vsv0WgGye1C31blQVGbev018VMpLo7m7qE5p58xBCqEvSp4HPABtJuqPq0GrA3/Lep15NankS2ZzNfPtIGgmckPfhw1lnB4OrSU3/Tq+Hon4WQiiBi0gZz6dl75XXtrYPyXuTejWpSZKezz4LGJNtp5Um7PE9zv8j8CQwrvq8OucPax1S0/qkQgihaLafA54jjUtA0mtIC+i+UtIrbc/Lc59ea1K2O22Pz16r2R5R9XmVgGP7i7ZXB/5QfV5v5w93ldF9eSb0DkQMnAghlIGk/ST9g7Qixl9IK2pcmff6PAlm+8X2AY2+ZzvqyKJIM6ZKRQUthFAi3wSmAPfb3hDYnQb1SQ2YpF9Xv4dVdWa/+br9UnX6nfoSFakQQkkstf0U0CGpw/Z0YKu8Fzdr2dY3ZO+bNOn+Q14lS/mybjOys9F3j6pUCKE0npX0SlJy8gslLQDyDMYDmlSTGghJ60maLmmOpLslHVN0mZqpsyMFqeMvuYPjf3MH8556seAShRBCUxwALAY+Txpg90/SKL9cmlWTGogu4D9tz8oy5M6UdI3te4ouWDNMmrgGG6w1llsffJrHnnuJzV63Gh/facOG3T8GToQQysD2IgBJ44Hf9ff60gQp24+TMlRge6GkOcAEoC2D1A4br8V1X9yV5xYvZdI3rm7ovWPgRAihLCT9B3ASqTbVzYrpSRvlub5ZQWpQf8dL2oC0/sjNjSjMUBBxJYTQpr4AvNn2kwO5uFlB6vs93nPLOtguAY61/XyPY0cARwCMGjVqsGUshUqzXCPnS9mgGN8XQiiHfwID7nRvSpCyfVH1e15ZWqVLgAttr7LcvO2pwFSAcePGReUjhBDK7wTg75JuBpZUdto+Os/FDQ9SkjYFzgBea3sLSVsC+9v+Zh/XCTgbmGM711L17aBZ9Z0YOBFCKImfAdeSVtTod1rtZtSk/hf4Iqlg2L5D0kWkWcf17AgcCtwpaXa27yu2r2hCGdtarMwbQiiRLtvHDfTiZgSpsbZv0cp/yvc5ccv2DQzDRAmV31OMyAshtKnp2XiC37Fyc9/TeS5uRpB6UtLGZAPWJB1ENrQ8tM6wi/YhhLL6cPZevYxToUPQjyINbthc0qOkzLe51w4ZbirBpJFNdFErCyGURZZUdsAaHqRszwX2kDQO6LC9sNHPCH1TjJwIIRRI0m62r5X03lrHa43grqUZo/u+1mO7UqCTGv2sdrBinlTj7hkVqRDCYEjaCzgV6ATOsn1yj+MfAY7PNl8APm379h632YU0qq9Wnj4DxQQpYFHV59HAvsCcJjwnhBBCg0nqBH4K7AnMB26VNK1HHtUHgV1sPyNpb1IXz/bV97F9YvbxJNsP9nhG7ibAZjT3ndKjMD8grXEfaqhkhojaTwihJLYDHsi6bpD0S1Im8+VByvbfq86/CZhY536XANv02PcbYNs8hWlFgtmx5BzFERojBk6EEOoYIWlG1fbULJtPxQTgkart+fSoJfXwCWosBy9pc+DNwOo9+qXGk1rZ8hU274l5SbqTFRWDTmBtUgbcUMOg+qSmfwd2PaHv80IIYYUu25PrHK816qrmN5SkXUlBaqcahzcjdfeswcr9UguBT+UranNqUvtWfe4CnrCdexXGMHjGkRYphDBQ84H1qrYnAo/1PClLeXcWsHe2PPxKbF8OXC5pB9s3DrQwDVuZV9KaktYkRcnKazEwPtsf6ohURiGEkrgV2ETShpJGAQfTY1yBpPVJo/MOtX1/H/c7UNJ4SSMl/VnSk5Jyz51tZE1qJqlK2FtVMfqlWihqUiGEgbDdJemzwFWkLptzbN8t6cjs+JnA14C1gNOzaUb1mhDfaftLkg4k1dLeD0wHLshTnoYFqcHOKh6umjFPKiplIYTByBJ7X9Fj35lVnz8JfDLn7UZm7/sAF9t+uj/JBpoyui8bybET6evyr7Z/24znhBBCKL3fSbqX1P3zGUlrAy/lvbhhfVIVkk4HjiStHXIXcKSknzb6Oe2iWSvoxsq8IYQysP1lYAdgsu2lpFV6D8h7fTNqUrsAWzhbD13S+aSAFXL60TWpH3LKvFUGzOQSrX0hhKJJ+pLt72Wbe9j+PwDbiyR9FfhKnvs0vCYF3AesX7W9HnBHE57TFlb0STU2tMTAiRBCwQ6u+txzQudeeW/SsJqUpN+R/ohfHZgj6ZZse3vg7/WuDY3V6IAXQggDoF4+19ruVSOb+37QwHsNG8vXk4q4EkJoL+7lc63tXjUySF3vPv6El6TezpF0DilbxQLbWzSwXKXWrHWforUvhFCwSZKeJ30djck+k23nzt3XyD6p6ZI+l81EXk7SKEm7ZQMoPlbn+vPoRztlu4lpUiGEdmK70/Z426vZHpF9rmyP7PsOSSNrUnsBHwcuztYKeZYULTuBq4Ef2Z7d28W2r5e0QQPLMyREjSeEEHrXyIwTLwGnk9JkjAReDSy2/WyjntHOejaCTpk3tfaJOcXy8SGEdtCUjBPZhK3HG31fSUcARwCMGjWq0bcvxPIh6A1spItBGCGEdtGMeVJNY3uq7cm2J48Y0Yr1GoeuqEeFENpBfNMXrNIs19/az41zUzaKm7ru5/N7brrSsahIhRDaRWlqUpIuBm4ENpM0X9Inii7TUDDYvqsQQiiz0tSkbH+o6DIUqeG1n2jvCyG0gdLUpELjRFqkEEK7iCBVAhIrOqWmf6f/N5j+nVWui4pUCKEdRJBqQ1GPCiG0iwhSJSAisIQQQi0RpEqoESP2IuNECKEdRJAqAUmNzRIR1bIQQpuIIBVCCKG0IkiVQOqTavDy8Q29WwghFCOCVBtqdMALIYSiRJAqAanxmctj3EQIoR1EkGpDkXAihNAuIkiVgFBqoBtItokQQmhjEaRK4tHbr+XGuU8tX4JjQKqCnGLoRAihDUSQKoMGx5No7gshtIsIUm0qBk6EENpBBKkiZc1zg83dV2kmrDQVxhD0EEK7iCDVbmLwRQihjZRmZd7h6Ma5T3FT1/0s6zaOgQ4hhLCK0tSkJO0l6T5JD0j6ctHlGapunPsUTz10F0++sKToooQQhqi+vo+VnJYdv0PSNs0qSylqUpI6gZ8CewLzgVslTbN9T7Ela6EmdCP96Jr7+zzn83tu2vgHhxCGrJzfx3sDm2Sv7YEzsveGK0WQArYDHrA9F0DSL4EDgLYLUpXAUb1mVKeXNuVZU+ZN5ab1j1j+Xq88jRbBL4QhK8/38QHAz20buEnSGpLWsf14owtTliA1AXikans+TYrKrVLry3/KvKmQBY3qfVP1dq58diJ/em7dhjz7ZXew/itWnhScJ2A1UrOCX5n0DMTVP3OeIN3f80NokTzfx7XOmQC0bZCqNWpglQYwSUcAlW9YS1rcoOePALoadK8+nJJzX025y/kg8LZV7n1Kj/emaeHvc1AGVc7jBnhsAOcPi99nCw33co6RNKNqe6rt6uXA83wf5/rOboSyBKn5wHpV2xOBx3qelP0iB7+2eg+SZtie3Oj7NlqUs7GinI0V5WysAsuZ5/s413d2I5RldN+twCaSNpQ0CjgYmFZwmUIIYTjK8308DfhoNspvCvBcM/qjoCQ1Kdtdkj4LXAV0AufYvrvgYoUQwrDT2/expCOz42cCVwD7AA8ALwKHN6s8pQhSALavIP3gRWh4E2KTRDkbK8rZWFHOxiqsnLW+j7PgVPls4KhWlEWOlNkhhBBKqix9UiGEEMIqIkhlJL1f0t2SuiWVbuTPUEgbJekcSQsk3VV0WeqRtJ6k6ZLmZP/Njym6TLVIGi3pFkm3Z+X8RtFl6o2kTkm3Sfp90WWpR9JDku6UNLvHMOzSyCbG/kbSvdm/0R2KLlORIkitcBfwXuD6ogvSU1Wakr2BNwEfkvSmYktV03nAXkUXIocu4D9tvxGYAhxV0t/nEmA325OArYC9spFUZXQMMKfoQuS0q+2tSjwM/VTgj7Y3ByYxdH6vTRFBKmN7ju37ii5HL5anKbH9MlBJU1Iqtq8Hni66HH2x/bjtWdnnhaQvgQnFlmpVTl7INkdmr9J1IkuaCLwbOKvosgx1ksYDOwNnA9h+2fazxZaqWBGkhobeUpCEQZK0AbA1cHOxJakta0abDSwArrFdxnL+GPgS0F10QXIwcLWkmVkGm7LZCPg3cG7WfHqWpHFFF6pIwypISfqTpLtqvEpXK+mhZSlIhhNJrwQuAY61/XzR5anF9jLbW5Fm9G8naYuiy1RN0r7AAtsziy5LTjva3obUdH6UpJ2LLlAPI4BtgDNsbw0sAkrZB90qpZkn1Qq29yi6DAPUshQkw4WkkaQAdaHtS4suT19sPyvpOlKfX5kGpuwI7C9pH2A0MF7SBbYPKbhcNdl+LHtfIOkyUlN6mfqh5wPzq2rMv2GYB6lhVZMawiJtVANJEqnNf47tHxZdnt5IWlvSGtnnMcAewL3Flmpltk+wPdH2BqR/l9eWNUBJGidptcpn4J2UK+Bj+1/AI5I2y3btThsuWdQfEaQykg6UNB/YAfiDpKuKLlOF7S6gkqZkDvDrMqaNknQxcCOwmaT5kj5RdJl6sSNwKLBbNhR5dlYTKJt1gOmS7iD9oXKN7VIP8S651wI3SLoduAX4g+0/FlymWj4HXJj9d98K+HbB5SlUZJwIIYRQWlGTCiGEUFoRpEIIIZRWBKkQQgilFUEqhBBCaUWQCiGEUFoRpMKgSVqraij3vyQ9WrU9qse5x0oam+Oe19XKRp+liWlpMlhJX2nl83o8u6E/r6TJkk7r5zVfl/SFRpUhhP6IIeihoSR9HXjB9g96Of4QMNn2k33c5zrgC7YLW04hm/Qr4HnbryyqHEXr679pCM0UNanQFJJ2zxJk3pmtM/UKSUcD65ImqE7PzjtD0oy86yVV17AkvSDpu1my0D9J2i47PlfS/tk5h0m6XNIfldbjOrHqXsdV5W88Ntu3QbaGz+nALFJmijFZrfDC7JzfZs+8uzpJaVaebymt/3STpNdm+18r6bJs/+2S3pbtP0RpvajZkn6mtCRLXz/vKvfvcf6dSusRSdJTkj6a7f+FpD0kvUPZmk9ZDemcqt/Z0VX3+Wr2+/oTsFnV/q2yZ9+R/UyvkvQaSTOz45MkWdL62fY/89ScQ+hNBKnQDKNJa0t90PZbSDkiP237NFLOwV1t75qd+9VsXZ8tgV0kbdmP54wDrrO9LbAQ+CawJ3AgcFLVedsBHyHN3n9/1uS1LXA4sD1pTalPSdo6O38z4Oe2t7Z9OLA4W3/oI9nxj2fPnAwcLWmtqvLclK3/dD3wqWz/acBfsv3bAHdLeiPwQVLC062AZVkZ+/p5a92/2t9IGTXeDMwF3p7tnwLcVOP8zYF3Zb+jEyWNzH43B5Oyw78XeGvV+T8Hjre9JXAncKLtBcBopWUm3g7MAN4u6fWk5LMv9vFzhdCrCFKhGTqBB23fn22fT1ojp5YPSJoF3Eb6Yu1P/8vLQCWtzZ2kQLA0+7xB1XnX2H7K9mLgUmCn7HWZ7UXZmk2XsuIL/WHbtb7QK45WSq1zEynx7yZV5amkLZpZVYbdgDNgeVbz50g52bYFblVaimN30jINff28te5f7a+k3/XO2TPfImkC8HTV2lTV/mB7Sdb8uoCUOujtpN/Ni1l2+GkAklYH1rD9l+za6v+ufycFx51JaXx2zu7z1z5+phDqGlZZ0EPLLMpzkqQNgS8Ab7X9jKTzSLWwvJZ6RadqN2klW2x3S6r+t92z49XUXv6kotfyS3oHKdHrDrZfzPrOKmWuLs8y6v//JeB82yfUOaenPPe/HjgKWB/4KqlWeRC9B4slVZ+r79nfzuq/koLS64HLgeOze0SuwTAoUZMKzTAa2EDSG7LtQ4HKX98LgdWyz+NJAeG5rH9l7yaVZ09JayplEn8PqUnseuA9ksYqZcQ+kN6/yJcqLe0BsDrwTBagNic1o/Xlz8CnYfkihuOzfQdJek22f82seWxQbD8CvBrYxPZc4AbSHwL9qdFcDxwoaYxS1vD9sns/BzwjqVLjrP7vej1wCPAP292kFZr3If2uQxiwqEmFZniJ1N/zf1mN5lbgzOzYVOBKSY/b3lXSbcDdpP6TZn2h3QD8AngDcFFlxGBWc7slO+cs27cprdTb01TgjqxZ8uPAkUoZqu+jdj9PT8cAU5Wywi8j9c/dKOm/SKvEdgBLSTWghwf2I67kZlKTK6Tg9B3S7yAX27Mk/QqYnZWnOsB9DDgzGwwxl/TfGdsPSYIVazPdAEy0/cwgfo4QYgh6aG+SDiMNef9s0WUJIfRfNPeFEEIorahJhRBCKK2oSYUQQiitCFIhhBBKK4JUCCGE0oogFUIIobQiSIUQQiitCFIhhBBK6/8DRyoLpTsFZRUAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting - on window size 9\n", + "peak(mu)= 0.0019212778508663174\n", + "Computing window sums\n", + "Done computing window sums\n", + "For increasing = True , the minimum IR precision was 0.31974367348777494 occurring at 6.765127182006836e-06 implying a frac_neg of 0.47003410483096586\n", + "Adjusted frac neg is 0.99\n", + "For increasing = False , the minimum IR precision was 0.4258213778275138 occurring at -2.9428978450596333e-05 implying a frac_neg of 0.7416183072374903\n", + "Adjusted frac neg is 0.99\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting - on window size 13\n", + "peak(mu)= 0.014580504179000855\n", + "Computing window sums\n", + "Done computing window sums\n", + "For increasing = True , the minimum IR precision was 0.3469747405521833 occurring at 1.621246337890625e-05 implying a frac_neg of 0.5313343328335832\n", + "Adjusted frac neg is 0.99\n", + "For increasing = False , the minimum IR precision was 0.11749949829420027 occurring at -1.7642974853515625e-05 implying a frac_neg of 0.13314383172256963\n", + "Adjusted frac neg is 0.99\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting - on window size 17\n", + "peak(mu)= -0.03528579294681549\n", + "Computing window sums\n", + "Done computing window sums\n", + "For increasing = True , the minimum IR precision was 0.4006572406407763 occurring at 7.033348083496094e-06 implying a frac_neg of 0.6684943371454617\n", + "Adjusted frac neg is 0.99\n", + "For increasing = False , the minimum IR precision was 0.41327328308403144 occurring at -4.0531158447265625e-06 implying a frac_neg of 0.7043709978920574\n", + "Adjusted frac neg is 0.99\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Thresholds from null dist were -0.85 and 0.85 with frac passing 0.17035\n", + "Got 318 coords\n", + "After resolving overlaps, got 318 seqlets\n", + "Across all tasks, the weakest transformed threshold used was: 0.8499\n", + "MEMORY 0.352284672\n", + "318 identified in total\n", + "1 activity patterns with support >= 100 out of 2 possible patterns\n", + "Metacluster sizes: [298]\n", + "Idx to activities: {0: '1'}\n", + "MEMORY 0.352301056\n", + "On metacluster 0\n", + "Metacluster size 298\n", + "Relevant tasks: ('task0',)\n", + "Relevant signs: (1,)\n", + "TfModiscoSeqletsToPatternsFactory: seed=1234\n", + "(Round 1) num seqlets: 298\n", + "(Round 1) Computing coarse affmat\n", + "MEMORY 0.353816576\n", + "Beginning embedding computation\n", + "Computing embeddings\n", + "MAKING A SESSION\n", + "Finished embedding computation in 0.15 s\n", + "Starting affinity matrix computations\n", + "Normalization computed in 0.0 s\n", + "Cosine similarity mat computed in 0.01 s\n", + "Normalization computed in 0.01 s\n", + "Cosine similarity mat computed in 0.01 s\n", + "Finished affinity matrix computations in 0.02 s\n", + "(Round 1) Compute nearest neighbors from coarse affmat\n", + "MEMORY 0.407293952\n", + "Computed nearest neighbors in 0.02 s\n", + "MEMORY 0.407527424\n", + "(Round 1) Computing affinity matrix on nearest neighbors\n", + "MEMORY 0.407527424\n", + "Launching nearest neighbors affmat calculation job\n", + "MEMORY 0.408334336\n", + "Parallel runs completed\n", + "MEMORY 0.43649024\n", + "Job completed in: 1.38 s\n", + "MEMORY 0.436494336\n", + "Launching nearest neighbors affmat calculation job\n", + "MEMORY 0.436494336\n", + "Parallel runs completed\n", + "MEMORY 0.438632448\n", + "Job completed in: 1.42 s\n", + "MEMORY 0.438632448\n", + "(Round 1) Computed affinity matrix on nearest neighbors in 2.89 s\n", + "MEMORY 0.438632448\n", + "Filtered down to 286 of 298\n", + "(Round 1) Retained 286 rows out of 298 after filtering\n", + "MEMORY 0.438816768\n", + "(Round 1) Computing density adapted affmat\n", + "MEMORY 0.438816768\n", + "[t-SNE] Computing 31 nearest neighbors...\n", + "[t-SNE] Indexed 286 samples in 0.000s...\n", + "[t-SNE] Computed neighbors for 286 samples in 0.002s...\n", + "[t-SNE] Computed conditional probabilities for sample 286 / 286\n", + "[t-SNE] Mean sigma: 0.232937\n", + "(Round 1) Computing clustering\n", + "MEMORY 0.438870016\n", + "Beginning preprocessing + Leiden\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 0%| | 0/50 [00:00" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "metacluster_0\n", + "activity pattern: [1]\n", + "metacluster_0 pattern_0\n", + "total seqlets: 83\n", + "Task 0 hypothetical scores:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Task 0 actual importance scores:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "onehot, fwd and rev:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "metacluster_0 pattern_1\n", + "total seqlets: 81\n", + "Task 0 hypothetical scores:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Task 0 actual importance scores:\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIEAAACMCAYAAADr57kMAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd5wcdf348dfM9r3e71Lu0gMkkBAIASE0RUEE+QqCgGIB/SqCDQuKBRQB/YqKXyvyVX+oCEhHwEAohhRCeiDJpSd3KZdryZXtu/P5/fHZ23K7d7fXSELez8djcjezM5+d7O3Ozrzn/Xl/DKUUQgghhBBCCCGEEOLdzTzcOyCEEEIIIYQQQgghRp8EgYQQQgghhBBCCCGOARIEEkIIIYQQQgghhDgGSBBICCGEEEIIIYQQ4hggQSAhhBBCCCGEEEKIY4AEgYQQQgghhBBCCCGOAfbD9cTl5eVqwoQJh+vphRBCCCGEEEIIId51Vq1a1aqUqsj22GELAk2YMIGVK1cerqcXQgghhBBCCCGEeNcxDGN3X49JdzAhhBBCCCGEEEKIY4AEgYQQQgghhBBCCCGOARIEEkIIIYQQQgghhDgGSBBICCGEEEIIIYQQ4hggQSAhhBBCCCGEEEKIY4AEgYQQQgghhBBCCCGOARIEEkIIIYQQQgghhDgGSBBICCGEEEIIIYQQ4hggQSAhhBBCCCGEEEKIY4AEgYQQQgghhBBCCCGOARIEEkIIIYQQQgghhDgGSBBICCGEEEIIIYQQ4hggQSAhhBBCiHcxy7JQSh3u3RBCCCHEEUCCQEIIIYQQ72LuH7v54+o/Hu7dEEIIIcQRIKcgkGEYFxqGsdkwjG2GYdzaz3pzDcOIGYZxxcjtohBCCCGEGIrOUCcRK8L2g9sP964IIYQQ4ggwYBDIMAwb8BvgIuAE4GrDME7oY72fAAtGeieFEEIIIcTgbW7dDMCW1i2HeU+EEEIIcSTIJRPoNGCbUmqHUioMPAx8OMt6NwOPA80juH9CCCGEEGKINrVuAqC+rf4w74kQQgghjgS5BIHGAo0p83viyxIMwxgL/Bfw+5HbNSGEEEIIMRxvN78NwJ7OPYd5T4QQQghxJMglCGRkWdZ7iIlfAt9SSsX6bcgwPmcYxkrDMFa2tLTkuo9CCCGEEGIIVu5bCUB3uJuOYMdh3hshhBBCHG65BIH2AONT5scB+3qtcyrwsGEYu4ArgN8ahnFZ74aUUvcrpU5VSp1aUVExxF0WQgghhBC52NymawIZGImuYUIIIYQ4duUSBFoBTDUMY6JhGE7gY8AzqSsopSYqpSYopSYAjwE3KqWeGvG9FUIIIYQQOYnEIhzoPoCBgc20Ud8qdYGEEEKIY519oBWUUlHDMG5Cj/plA/6klNpgGMbn449LHSAhhBBCiOHy74ND6yDSCY5CKJ4F3jFDbm5b+zY8Dg++sI+oFeWt5rdGcGeFEEIIcTQaMAgEoJR6Hni+17KswR+l1KeGv1tCCCGEEMcApaBlMWy8B5peAZsLlAWGCbEQVJ0HM26FivlgZCvT2Lf61nrMlKTv1ftWj/TeCyGEEOIok1MQSAghhBBCjLCoHxb9F7Qu0b+jwAqmr7P/39CyCMrPgLOfAntezs1vaNmAL+JLzMsw8UIIIYTIpSaQEEIIIYQYScEWWDAPmhdB1EfmwKs9lH68ebFeP9ic81Os2reKWMrArS2+FkLR0PD2WwghhBBHNQkCCSGEEEK8k/x74IXZ0Lk5M/OnL1YQOrfA87PB15DTJhtaNqTNex1etrVvG+zeCiGEEOJdRIJAQgghhBDvFCumu4AFD4CKDG5bFYFQs95+oFWVoqEjPVhkGDJMvBBCCHGskyCQEEIIIcQ7ZdNPoWMTpHTTGhQVg86Ba/vs7dqLaaSf5vnCPja1SBBICCGEOJZJEEgIIYQQ4p3Qvgbe/hHEfAOv25+Yf8BVNrVswmlzpm+mYqzcv3J4zy2EEEKIo5oEgYQQQgghRpuyYPGVEAu8I09X31pPMKrrDamUotMbmjf0tUm66mo9JP1oTNXVo/FfFkIIIUQOJAgkhBBCCDHaGp+AYNM79nSr968mFNMjgTnNZEZQY2cjlrIGbuDAgdHatdFtWwghhBD9sh/uHRBCCCGEeFdTCtZ8E6Ld/a/nroRxl4GzFMLtsOepQQ0Jn2rdgXWJ30s8JXSGOglEA9hNO40djdQV1w2pXSGEEEIc3SQIJIQQQggxmpoWQqil78dd5TD3NzD2El342XSBFYZTfgl7n4MVN/a/fRbbD25P/D6ucBzb2rcRiAZwmA7qW+slCCSEEEIco6Q7mBBCCCHEaHr7R31nAeVPhovWwtjLwOYBez6YDrDn6fmxl8IH10LBlJyf7lDwEIFIsvbQ8eXHJ7qABaNBGSZeCCGEOIZJEEgIIYQQYrQEmqDtzeyP5dXBhSvAXQ29RvJKsDnBVQUfWAl5E3N6yvrWejwODwBuu5tZ1bMIRHVQKBQLsaZpzaD/G0IIIYR4d5AgkBBCCCHEaNn7DBhZet8bJsx/HOwFYNr6b8O06cyg+U+AMcC66OHhY1YMAKfNybSyaWnDxa9rWtfXpsecF7a+wIq9Kw73bgghhBDvGAkCCSGEEEKMlp0PQsyXufyE70DBdDBzLM9o2nWXsJnfHXDV9c3r8UWSz1lbVEtVXlVifsfBHbk95zHguqeu4+YXbh69J/A1wqZfwAunwBM18FgFPD0R3vgMNL0CVnT0nlsIIYTIQgpDCyGEEEKMhkgntGXJMnFXw4xvg907uPYc+XD8N2HbH/tdbfW+1Ynfg5EgdUV11BbVsvPQTkB3CWvzt1HmLRvc87/LRGIR2v3tWJY18o13boVln4CDa3XWVyxZo4lwK+z4f9DwOKBg1l0w7YtgGCO/H0IIIUQvkgkkhBBCCDEa9v1bj/TV28zv6cDAUBg2mPn9flfZ3LY5ubphUOwuZlrZtMQyj91DfWv90J7/XWTdgXVYWLQH2+kIdoxMo8qC+vvghVnQvgKsUHoAKMGCaCdEu2DtrfDSWTprSAghhBhlEgQSQgghhBgNDY/qi/xUjiKY9CmwuYfWps0FE6/r8+FQNERboC0xX5lXiWEYTCubhsN0ABC1ohIEApY0LEn8vnzv8uE3aMVg0WWw7jYd+FE5ZhjFfLp4+HMzoF2KdgshhBhdEgQSQgghhBgNbVkCCxOuyT040Ke+t9/avhWP3ZOYH180HtB1gXqW+yI+1h9YP8x9OPot2L4g8fui3YuG15hSsPx6aHo5ew2oAbeP6oDhy+cPbz+EEEKIAUgQSAghhBBipEX9enj43iZ+Utf2GQ57Xp8PbWrZlDY/tXQqAHVFdRgpNWdW7V/V/3NUVfX/+HAMom1f2MeB7gOjshtv7HkDA/2avLj9xeE1tu470PBPiPmH106kc3jbCyGEEAOQIJAQQgghxEg7tD6z8LOjCEpmj+rTbmzZmBgZzGbYErWAaotqCcfCifW2tm/tv6GmJp3d0t/Ul4G2a8oSHOvD5579HJN+NSnn9XPV2NFIIBpIBIHWH1hPzIoNrbG9z8PmXw0/AAT0l+UlhBBCjAQJAgkhhBBCjLT21WBF0peN+aAuFDyKVu5biRXvbuZxeJhQPAGAqvwqIin70+ZvIxDJVrD4yLJ873L8Ef+IZwMtaVySqJEE4LQ5eav5rcE3FOmEZdcNHABylkDVeVDzASiaOfjnEUIIIUaIBIGEEEIIIUZay+LMUaHGfggchaP6tBtbNyZ+txk2aotqATANk1JPaeIxr8M7cDbQYRaMBhPD2r+y85URbfvVna/SFU4W7Y5aUZY2Lh18Q+tvh2g/NYCq3gsXLIH/2g/zn4AzH4b3L4OPHIBZ94DN2/e2QgghxCiQIJAQQgghxEhrX525rGzeqD6lpSwaO5LDjEesCHVFdYn5cYXj0tbvXT/oSPPGnjcSWU3PbX1uRNt+ZVd6UCkQDQy+LpBvN2z7HVjBzMdsXpj3f3DO01DxHj2qm7NYT458cFfC9Jvhki1QfsYw/idCCCHE4EgQSAghhBBipIWa0+dNJ+SNH9WnbOhowGFLdnEKRUPUFNQk5ieXTE787ov42NCyYVT3Z7gWbNOjdxkYwy/cnKI73M3uQ7sBnSHVY9CZQPX36WHhezOdcP5LUHd1v0W8sXvBO1avW3nO4J5bCCGEGCIJAgkhhBBCjCRlZY7yVDQDoqNbg6e+tT6tzk2xuxi7aU/MTy+bniiEbClr4BHCDrNntjwD6EBNd7ibnQd3jki7K/auwOPwAGC32fHY9e+doU72de3LrZFYCLY/AKpX3ScMOOsxXQA83u6A7HlwzrOjXjRcCCGEAAkCCSGEEEKMrPBBMOzpy4pmgDG6p10bWzamFXseUzAm7fGJJRPxOrxp6x+pukJdbG1L1iwyDXPE6gK93vA6/ogu5ByJRRKBMqfNybLGZbk10vhk9uXTbobq8zJHhhtITyDI5h7cdkIIIcQg5XQ2YhjGhYZhbDYMY5thGLdmefxawzDWx6elhmHMGvldFUIIIYQ4CgSadJegVJ4aXRdmFK1pWkPYSg4DP6kkfWj12qLatMygvZ17hz4s+ihbtHtRIlsHdPe1pzc/PSJtL9i+gKgVBXS2VCCeodUd7ubVXa/m1sim/4FoV/oydzXMvgvs+YPfKcMEZynM+N7gtxVCCCEGYcAgkGEYNuA3wEXACcDVhmGc0Gu1ncA5SqmTgB8B94/0jgohhBBCHBWCTZlZP97azMDQCFvXtC5t/rjy49Lm64rqiKlk0Mdpc7K7Y/eo7tNQvbDtBbpC6UGW/+z+D0qpYbVrKYs1+9ck5o+vOJ4yTxkACsXLO18euJFQO3RkGU5+9t2ZGWCDYffCcV8Z+vZCCCFEDnLJBDoN2KaU2qGUCgMPAx9OXUEptVQpdTA++wYwDiGEEEKIY1HwgK4LlCqvLvu6I6hnOHXQQ8BPLJ6Y9vj4ovFp3cXspp361vpR36+heH7r8yh0wKeneHPMig27C1t9az020wbogtPzxs7jhIrkvc3t7dvTXqOsmheB2avej6MI6q4a9WwvIYQQYrhyCQKNBRpT5vfEl/XleuCF4eyUEEIIIcRRKxYA1aublacm+7ojpM3fRjiW7ArmMB3UFacHntx2N3nO5GhVgWjgiBwmvsXXwt6uvQC4bK7EMPExFcstU6cfSxqWJNrLc+Yxu3o288bOSxTM9jg8rNy3sv9Gml7M7Ao28TqwrOzrD8ZgawkJIYQQg5RLEMjIsixrLq5hGOehg0Df6uPxzxmGsdIwjJUtLS2576UQQgghxNHCipJxqjTKF/dvN7+dNjJYOBZmb+deFu5YmDYVOAvS1nm94fVR3a+heHXXq7jiGTUuu4sCl97nYDTIk/V9FGTO0Us7XkoUhTYwmFk5k1nVs8h35ieeY0njkv4b2fcCGX/f6TeDo5/h4IUQQogjRC4dl/cA41PmxwEZ42cahnES8ABwkVKqLVtDSqn7idcLOvXUU4fXqVsIIYQQ4kikotC7do1hG9Wn/PPaP+OL+BLzgWiAr734tUSGS4/UdQAWbFswqvs1FM9tfY6usM608Uf8nF13dmJksOV7lhO1omkFrgdjccPixO/+iJ/jyo/DlvK3CcfCLNi+gFvPyhgHRYt0gn9v+jJXma75JIQQQhwFcvkGXQFMNQxjIrAX+BhwTeoKhmHUAk8An1BKbRnxvRRCCCGEOFpkLV6cLbG6D09U67pC/TLhmmSXs9X7V2es0RnqHPCpgrEglmVhmqM7fP1gvLjtxcTvNfk1nD/hfBbtXpQI/qzev5rTxp426HZbfC20BZL3KSvzKnHb3Uwvn54YIQxg5b6VKKUwjCx/s+6dYPNANJJcVnkOxIJSD0gIIcRRYcBvfKVUFLgJWABsAh5VSm0wDOPzhmF8Pr7a94Ey4LeGYaw1DGOAztRCCCGEEO9Sph16BxBUNPftBwwAAaTXn9l1aFfu7fdyJBWHbuho4FDoUGL+lDGncMqYU/A6dHe6UCzES9tfGlLby/Ysw213J+ZnVMwA9Chp1fnVieVKKba2b83eiG93Zjyv+v1gL8i6uhBCCHGkyem2j1LqeaXUNKXUZKXUj+PLfq+U+n389xuUUiVKqdnx6dTR3GkhhBBCiCOWYScjUhAbYMSpYeoOdw952+EWWx5Jr+x8JdE9y2VzMb92PidXn0woGgJ0d61nNj8zpLZf2/VaYth5E5N54+YlHjux8sS0dZc09FEXyLcbUgpwA1AyC46gTCohhBCiP/KNJYQQQggxkmxuMHqdYgX2j9rTtfvbE8OpD8Ube94Ywb0Znmc2P5OoW+S2uzml5hSq8qsSmUAAaw+sJRgNDrrthTsWJl6nPGceJ1WdlHjstLGnJYJPvoiv78BY11awej23d3z2dYUQQogjkASBhBBCCCFGkrsqsxC0b/eoPd3CnQuHtf26A+tGaE+GRymVKAANunDz7OrZAJxYlczUcdvdLGtcNqi2w7Ewm9s2J58LxczKmYn5k6pOIi9ldK9Fuxdlb6h7R+Yyd8Wg9kUIIYQ4nCQIJIQQQggxkjzVmcWhfQ1gRbKvP0ypI14Nxe6O0QtQDcbmts1EUl6jMk8ZRe4iAM6uPTuRqeMP+3lx+4tZ2+jL6v2r0+oBBaNBppZOTczPrJyJpZJ1lpq6m2gPtGc2FOuVBWSXYeGFEEIcXSQIJIQQQggxktzVYPWqGxNsygwgjJA1+9cMa3tf2DfwSu+AhTsWolKCZyfXnJz4fe7YueQ5dcAlqqI8s2VwdYGWNCxJ1BUCGFswFofNkZifXDKZUCz5uMfhyd5Nrvff1XSCsjLXE0IIIY5QuQwRL4QQQgghcuUqA9Ur66dz06gFC+rbhje6l0LR3N1MZX7lCO3R0Dxd/3RiqHaH6eDsurMTj82pmUM4pSDz1ratdIY6KXQV5tT2i9tfTAvypHYFA7CZNsYVjmPnoZ2ADowt2r2ID079YK+Weo/6pjKX9eeJ6hxGfzPhmljubQohhBCDIJlAQgghhBAjyTAzhww/9BbYvdnXH6aDgYPDbmO4dYWGK2bFWLpnaWLe6/BySs0pifmxBWOxm8l7lx6Hh9d3v55T20qptKweE5M51XMIRoNp08yKZGAopmIs2LYgszHTmT5vhTOLgPdnwAAQgGQWCSGEGD0SBBJCCCGEGGm9iwXHghDYN+JPE46GianhZ40saexjSPR3yNqmtYmaPwCBaCCtO5hhGGnZO93hbl7Y9kJObS9tXEpnuDMxb2Hx48U/Jv+u/LTpX1v/lb5PB9biD/vTG+tdAyjmhxF4/YUQQoh3igSBhBBCCCFGWvGszGVtb+a2rbsq56dJHfEqld209znZeo9cBuzvGr0h7HPx0o6X0rprFTgLKPeWp60zv3Y+ZjzrxlIWz219Lqe2//7W3zOWWcoipmJpU8/w8ame2PRE+oKCqRnr5JbdI4QQQhwZpCaQEEIIIcRIq5wPe/8FVkox6L3PQc2F4CjoezuAjzRlLnsoe92Zho4GCl2FdIaSmS5XnnAlj3z0kT6bX7R7EZf+41I6Qh2JZb7I4S0O/eC6B9Nq/pR5y/j1m79OW6ct0IbDdCSCRY0djezp2MO4onH9tv3SjpeGvF9P1D/Bx2d9PLmgYBLYPBALJJf5GiCvbsjPIYQQQryTJAgkhBBCCDHSSuaAzZkeBNr3LzD/MKJPs7FlI4FIMiBhYDC9fHq/29QW1aYNxQ6wqWXTiO7XYHSFutjUmv7829u38/UXv56xbmq2UEzFuHfZvfziwl/02/6uQ7uGvG+LGxanL/DW6bpAqUGgtjeh/D1gZmZYCSGEEEca6Q4mhBBCCDHSSmZBNJC+LNQGHRtG9GlWN61OC+h4HV4mFk/sd5uxBWMJRtOHq9/fvZ+oFR3RfcvVX9b+JWNZTMUIxUIZU28DDRW/p3PPsP5frf7W9AV5dZmjvDUthGj3kJ9DCCGEeCdJEEgIIYQQoh93vHYHJ/3uJCKxyMAr93AUZBaHBtj5IET9mcuHaP2B9WnzdtNObVFt/7tmc1DkKkpb5rK52Hlw54jt12A8vOHhIW87UJbP39b/bchtAygUy/csTy7In6iLfKdqWay7iAkhhBBHAQkCCSGEEEL0YVv7Nn606Ee81fwWP1r0o8FtXHpq5rJdfwOy1/cZLKVURhAkpmLUFQ9cn2ZMwZi0eZtpy+iS9U5ZtW/VkLe1lMWyxmV9Pv781ueH3HaPh956KDlj92YWh452Q8fbuTU2iKLfQgghxGiQIJAQQgghRBYxK8ZHH/0oMRXDxORnS3/Gmv1rcm+g9qNgz09fFmqDhkcgpQjyULX4W4hZ6cOTByIBxhX2XygZYGJJepexQCRwWOoCNXU3Ze3mNRgPrH6gz8dW7189rLYhS2HpsRcDver/1P8CIp0M6CNNcI1KTkIIIcQ7TIJAQgghhBBZ/M/S/2FL+xYADMMgEA1w+aOXE4rmGLQYezFYWYI9638AKpa5fJA2tWzCZXelLctz5uG2uwfc9rjy49LmI1aEVfuHnpEzVH9c9cdht/HCtheyLo9ZsYzaRwYG08qm9TlNLpmM0StTq9nXnN5w9fvAkZe+rOGfjFSGlxBCCDGaZHQwIYQQQoheNjRv4If/+SGBaACXzUVMxUDBAd8BvvPKd7j3/fcO3IizBIpnQfuK9OX+Btj6a5h6I9jzsm+bg/rW+ow6RTX5NTltO6l4Eh67h0BK8eq3m3Ps0jSCnqp/KmOZw3Rg62ekrd6BnabuJpRSGEZ6EGZDywY8Dg/d4WTR5hMqTuDtG/v+fyqlyL87H38kWbepM9SJL+wjzxn/W1WcmVkXyArBlt/C9Jt1lzEhhBDiCCVBICGEEEKIFJFYhCsevSIRbLCbdi6ffjn/3PhP/BE/v1vxO644/grOGH/GwI1N/ISuFxPrNVLYuttg7CWQP3XIQ4uvbVqbFsQBmFA8Iadt64rrcNqcadvvOrQrazBlNPUefcthOvj+2d+n1Fva5zZ3LrqT/d37E/NOm5P61nqOrzg+bb0lDUsyusudXHNyv/tjGAZTSqekFdz2ODys2LeCcyecqxfY86BiPhx4OX3jDT+GqZ8FJAgkhBDiyCVBICGEEEKIFD/8zw9p6GxAofDYPXzzzG/y6dmf5sn6J4lYEQLRAB/950fZcvMWvI4BLvjHXQZrvpG53IrAosvgAyvAyAOjnx76vYckj1vTlFmfaHrZ9P73J662qBarV7sKRVN3EzUFuWUTDVebv40mX1PaMqfNyW1n39ZvIGrdgXXcv+r+xLxpmLyy85WMINBLO15KC3K5bC5OrclSrLuXU2pOSQsCBSIBXt/9ejIIBHD816FtefrQ8NEuWP5ZOOPBYWV4CSGEEKNJgkBCCCGEOGrFYtDUBI2N0NEBkQhEo6AUOBx6KiyE8eOhpgZsAyTdrN6/mnuX3ZsIHthNO189/asUuAr4xEmf4C/r/kI4FqY90M5XF3yVP3zoD/03mDceik+E9pWZj3VuhpfOgve+Ao4iMLOclllRiHRkbXpb+7a0eZfNxZTSKf3vT1xtUW1GFpHL5qK+tf4dCwK9tus1XDYX4ZQi2SdUnDBgJtIZ487g7+v/ji/iAyAQDfBU/VN88bQvpq23pHFJ2rzb7ubEqhMH3K9Tx5zKw28/nHh9IlaEF7e/yPfO+V5ypZr362HhU4NAAI1PQPl7YMp/g6NXUfChinTBofXQsRGCB8DfCL4GCDZBqBWigXigsCfryaaDinYvuMrBUwPe8XryVEPhCfo9OVL7J4QQ4qgiQSAhhBBCHPFiMVi3DhYtgldfhR07YP9+OHQInE49AbhcOtBjGDoYFA7rgFA4rKeiIh0Mev11KClJf45QNMTlj16euPj32r18e/63KXAVAHD7ubfz1/V/BXTg4a/r/srHZnyM8yae1//Oz/weLL02M2AA+uL+hdlw+v+D8jPAsIHNqUcPUzGdbbLskxmbdVvQEUoPDrnsLmqLanN4NaHQVYjDdBC1ooll4ViYTa2bBv7/jJDntj5HV7grMW9gcFbtWQNuN6dmDmavzKmle5YSs2KJWkJN3U10BNNfn2A0yMzKmQO2P7NyZkZXudVNq7GUlXxew4TpX4YNd2bWB1rzdT0U/LjLhh5oaVoIOx6EA6/qwI/dA45iXWOq6DiY9GkongmOQjCdYDrAcOhtVUQXJLciED4Eh96C9lXQugxO/xO4K4e2T0IIId4VJAgkxLtcRwds2wbNzdDerqe2Nn3xdPBg+l1z09QXT243VFXpqbQ0OY0bBxMnJi+2hBBitK1ZA/feC888o+cjET3NmweXXAKnnQYTJsCYMfo4BWDFezmZ8ev19nbYtw927YKVK+E//8kMAAFc88Q17O3cm5i3sMhz5PGHlclsn9PGnsaShiVEVZRANMClD1/K5ps2M6ZgTN//ibEf0pk+2YJAAP498Mp7IX8S1F6pL9KDzXrEqe7tWTfZEgavw0tnKGVYckXOQSCAqrwqdnXsSswHogHWHViX8/bDtWD7grT5fGc+88bOG3C748uPzygObTNsrG1ayyljTgFgaeNSXDZX2vDzDpuDyryBAyAzKmZkZEkZGNS31nNCxQnJhVM/Dxvvzt7Isutg2pdg9l3xIE2WU+5IH+8HgEX/lXy/VJ0Pc+6FwuN1bSmbVwcKc+Edp4NF4z+it3UW57adEEKIdy0JAo0WpfSXd/ignqI+fUdPWYDSd/oME2xuPXqIs0SfIPZXE0CIASilL5geeUTfLd+4EQIBmDIFZs3SAZwpU2D2bKio0MGcnu4SpqmDQT0XWMEg7NkDmzfDkiWwdSv8+c8SABJCvDN8Pvjyl+Ghh/TxSCkdoL7zTvjv/9aZQW63zvwZSGWlnmbPhosugm9kKdFz/6r7eWLTE2nLYlaMWxfemrZMoYiqZPZMd7ibM/90Jju/vLPvHTBMmH03rLix70AQQPcO2HjPwP8hYFOYjJo+wViQuuK6nLYHHTBKDQIBrNmfWWdoNOzt3Eu7vz1tmaUs5tTMGXBbh83BxJKJbGnbklgWjoVZuGNhIgj02q7X0rKMAKaWTs1p38q8Zbjt7rRuaqADS2lBIFcZnHg7rL8dYii6e6AAACAASURBVL5erSjYch/sfw6mfwXqPqaDN8R0xk7bm7Dt933vRM/7pOw0OPeFZNDHlsMbPhuba+jbCiGEeFeRINBwxMK6j/+hddC+Ro/+4dsdv9NSBvkTIW+ivutiOlPSdc14mm48VTfqA98u6NquU34/tFFSdcWgbd8OF1+sAzfBoL5AuvRSuOsumDQJQiHweHK7YOoxcya8//06kBSJQPHhvoEY6Y4HVCP6s2NFk79j6M9Xz2TEfzqL9U8hxFHlhhvgySf1sQt0N67166GsDPKGUXPX5co8Drb4WvjCc1/IWDdiRYhYkYzlve06tIvbX7ud28+9ve+V6q6Gtd/pPwg0CG+FwBfuHXiAEneWFKc+TC2byqKGRWnLetcZGi0v73wZu2lPlrEBolaUyaWTc9r+9HGnpwWBQrEQT9U/xbfO+laifYVK26YnQJSL6WXTWbFvRWLeF/GxcMdCbphzQ68Vvwxbf99nxhZd22DlTbDyZt1FzHTqOj4xf/b1ews06XWtCDgGeOM/Ua3PI/tlwjWxAdYRQgjxbiZBoKEIHIC134LGxwCbvgjNnwTTvqhTvt01un+4iuqMH9MBmPHf4xUplZXMDFJR/eVumLrIoFywiiG47z6drWOl3Bj+y1+SXR48nqG1a5rDu+AaNP8eaF0OHRugcxN074TAfjBduqBlXq3+jNk9YNj1CbXNpT9LqcHVSKduy7cLwu16BB53xTv4HxFCDMeCBckAEMCJJ+ruXqNxPLr80cszsmrcdjeuPjInlFJ0hjvTlv1o0Y/40rwvUerpY2hz0w5nPQyvXJA5XPwQrA6REeSozKsc1PDu08um4zAdaYGu7nA3XaGuRB2k0fLs5mfp7tUd6rjy4zJq/fTlzPFn8tiGx/BHk8GU1U2rCcfCWMpia9vWtPW9Dm9OI4P1mDtmbloQCGDR7kWZK5oOOOsReGn+AH9XpQs558peoAtb+ffAk2P1OebET0DhcfFzTEsXfh70OWP2keaEEEIcO969QaDbb4c77hiltoEpBhjxky93JVz8ts5K6OnzbQ5QCNAwU7p+vcPpudXVcGCgO0XDUFWlh2p5J4UP6mBBuD3ZBS98SN9ti3TGM0Z6Ct/EA3O2PHCXx7vileiMEWdpPMhQpU+++uCP+FnauJS3m9/mwikXMr1s+qBOvEfDt7+tu4KtWKF3PRiED39YfxTOOktn8xgGeL1gH8QnPxTSbZkmFAxwTXCg+wBP1T/FX9b9hTf2vMGcmjnccPINXHbcZQOPNrPjQdj0M+jaGj+pVTD5szDjNiicFs/86cn4iddX6OlW2UOp5Agpqevb3KOfBv9Ofa6UpS8KureDfy8E9uoswu4d+j3vyNevD/H3Y8/7Uik9GcRHG+oER4HOViyYrOtGeMfq+bwJyYC1EIfJF78IP/85+OPX+CtWwNKl8J73QP4IDmr0ys5XWLE3/WK/0FXIs1c/i7Ofuiu/WfEbHt3waKLLkM2wcf0z1/PkVU/2/WQVZ8K0m2HLr3PPBOnDpqhJ7wv68YXjB9VGbVEtbrubSDgZBPI4PNS31jN37Nxh7V9/lFK8svOVjOVnjj8z5zbm1MzRmUQp3HY3b+x5A5thw+PwEAkl/18O05FTUejU9r0OL/5I8u/UFmij1d9Kubc8feXSU2Du73R3v2H+XRM+0gTN/4GmV6D5Ndj6W9j8K32zMH8SqmAqKn8yprNIdzOze2DOLwFLB6Oifp05u+7bI7M/QggxkpTSx6hIh56saDxBInWy9HmsYcuc7PngLAJ7oZyzDsG7Owh0++39r9PXRbtS2Zf32P4nWPFFfREa7YZQG2z/M9Rdpd/MNpe+6OzL+tvh7X4CVLY8uGpk0sXflWJh2P9v2PM0tK1IpmCXztHDnuaNh4KpUHKyPkD0dMMz7YChDzJWBFRYD6vqb4DOLdC6BE68A1yZd3EPBQ+xpGEJL+98mac3P82OgzsSj311wVcBuGDSBXxo2oeYXzufk6pOSoxQ8k7pGe1m927dhWLRIli9Gi68UFFUqDhplsXkSVBbB8dNN6mqNnA4DFwuXefHZtNdvsJhHfgJhRS7dlps3QoNDYrNmw1WrMz8P+08uJPHNz3OX9f9lfXN6xPL3TY3q/ev5sb9N3Lj8zcyo2IGnzjpE1x+wuWZQxhHA/BGyug3VhAm3wCn/Dy5zMyhGFHPFwW23NY/WniAuQF9p7ntTZ0B5a6EMRdD5Tn6p6dajxyj4t3kUJnHMsMA4q+R6dSBoOAB3XW1r2OWsvSXc6gdrJD+Uu79RZ1o057+Be0o0IFVm6ffoKo4vJRSHPAdYNW+VThsDk6uPpmKvMOfNXfHHVBbC7fcouuVBQLwgQ/AlVfCN7+pu6sGAoPr5hoKpW/TGerkY499jGDK6E55jjx+8r6fcHbd2f22Nb1sOk9uejIRBOoZRvyxjY9xxQlX9L3hrDth77+gs56hZWWYRAum0hTbnrF9rjVvetQV12Vk3ljKGvUg0Nb2rWmvOeii0KePOz3nNmZWzkzLAgJ9g+bF7S9S6CrMKBztj/iZUTkj5/ZnVM7IGmRa1riMS6ZfkrnBpE/q4+lbdww/EOSu0lk+Yy6CMRcRiARYvW8VG/cuYvOeRWzc+BpFrKbSDmNsUGSC3YAih5uxheMozauizFtNWfEkTHsBRLvS2xZCiHeCUnDgFWh9A1qW6LIpkS6oOg+8Y3RPGs84cJXoc1h7XvIGr2GSuKGZqKtr6UzIcCcE42VUxl46cPLFcIzmTd7DkTgRZ6iBAh6AYRgXAvcBNuABpdQ9vR434o9/EPADn1JKre6vzVNPPVWtXLlyqPs9bEopDLOPlOMcXhPCHbDnST1yx8F1OsXXVQ5l86DoBP2mzp+is0oc+bo+Sc9FEka8C1j8QuqJLPV/rslhH0Zbtou2XF4b0B/UwH49ukm4TV9sRjohEq/nEgsl6yNhgRXPUEiktmf54NucepjTXX/X28UC8WKbP9EZIz37a/NmH4WjP1ZMtxcfyrWpu4kF2xbwqac/Nbh2epk7Zi6/vPCXnDrmVH1HeTQPJAZwSin8+RbYvwB8OyHUhlU0hz3WRbSEj6c9OJ52XxntXUW0d7hoazeJRE2iUQPLMrDbLOx2hculqCiLUVrkozT/EKXeFkqcO5n5oWsxTIMNLRu4+KGLaehoGPLu1uTX8MK1L3BS1Uk6i2rbA1D/c73fPcPcTvsCTPqM/jzFgvq9YJhguuMBh/hneKDAKhwZwdWhBp4XnA4H1+ogDIC3Fi7bre/02r3D369gi/5yblmsh6v279F/g6ITdHaQdzx4xujudM6S+Gc3JdiD0p+hnqBQzK+D48Fm8DfC9Jv1MMbisNvUsolXd73KtvZtbGzZyOsNr6dlOqQqchUxv3Y+x5Ufx5TSKbxv0vtyrtcyktra4B//gAcf1EPEu906kON266ygGTNg8mRd9L62VmcJ9WQ7RqO6wHRDg+4uu307bNqkM4oOHYJrH7+Wxzc9njaCVIW3gj1f29NvFlCP77/6fX629GdpI0kVugrZctMWqvL7udju2gYL5ukAqxpEfRbDBo4itsx9iDl/vxxfJFkTyGbYuOPcO7jt7Ntybm5f1z6m/GpK2v4bGHz9PV/npxf8NIf9Gdox7XcrfsctL96S9rz5znzeuP6NQQVqJt03iZ2H0gtyn1h5IuXecl7d9Wra8hJ3Ce3fSi9E3Z/OUCflPy1P6ypnYvLVM77Kz97/s743XHsrbP7fwQeCbB5wlWFdsIQtAT8r9q5gceNi7l91/+DayeKWM27hjHFnMHfsXMYXjj/smctCiKNDz02iLW1b2Ny6mcc3PU5jZyPnTjiX+bXzmVY2jamlU/vuPty1HZ7tdeN3yufgtD9kX7+3I6HO2VEcBDIMY5VSKms/6AGDQIZh2IAtwAXAHmAFcLVSamPKOh8EbkYHgeYB9yml+h3j850OAoWjYV7a8RLL9y7n1Z2vsrhxMfv/B6p71VRsyoNZP6jk7LqzE9Os6lmZDfZ+Q9iAcqASyAfy4lNhfPKg4xo9sY14jxUiwCzSe4TZCmD8ZfrkMHxQn0hMvVFnGBlOHSW1eeJdXNzxC7GeO/zxi+KeaKlSOtgUC+ogRyxAe1uUxr0ufG0H8De+iT9WhpE3HuUoQlWcg+WqwbLg8isyTxKefEK/X1LPH5TSdWgMAypZxBnB92MjRBQPCge22XdgnvCVlJVD8Uyc+EhpAzJ0mp/h0CfNh9Ynt/OOh8sa4umCOdQRGOBg8tN2+N/IOPZ07sl4rMhVRE1BDeXecpy9skwUiq5wF83dzTT5mjJGFHGYDubUzGHxd7Zjb2kdeD+H4oPAtejXScVPWi/dHg+ghIbdHWpLSz2/XfV7HtnwCE3dyQOWzbBhYDC+aDzjCsdlraERjoXZ27WX3R27UUoRS7noqfRWcuWMK/nC3C/oUVe6d8ZrAr0NHZt0TZ9gs87q8o7VgVVPTfy979TBQbOnJlAoWRdo40/TT8LdVTq9/nAaahDorTv0iEGGQ9/RtXnhPQ/BmA/oz7Zhi9cTyxL8zCVAltxB9BjTH4WzHtWLUru5DoGyLL77PZOuLn1B3t2tuxVecIGe7zl2mKbOzHA4ki9T7+NMz8+ejLVoNLme3a5HsWtq0kEAp1NPd96pgwXDchSfAHz44Q+zfM9yDvhGdv/HFIzh/Inn89f/+mu/6yml2Ne1j/rWehY3LOa48uOYUTmDqaVTcdlzOCYFW/Qxv3sHBJsJHGznzQ3jeHPjRDY3VLN9TzkNB0pobi8gELLjtMd0QmC8u7ZSBkpBOGrD7YxSWdrN+KqDTB3fwmU/aeWqx69KC4LlOfK476L7uP7k63N6HTqCHYz7xTi6w8kAs8N0cN6E8/j3x//d/8W2rxEWng2BffqYNRDTqY9971vE041ruO6p69KGh8935vP7i3/PtSddm9O+g876cf7ImXZMBjh/wvm8/MmXB25giMe0C/92Ycbw8A7Tgf82f0b2TX+ueuwqHt3waNoyu2HH7XCn/U0ATh97OstuWJZz2wAVP62gNZD+nX1S1Ums+/y6/jdsWghLrtaDGVjB/tcFffye+AmY83PG3DeN/d37MlbJj0ykKnI6Y4w5lJp1uN0mXg/YHTqT1zRBGVGaIlvYFVrNjtByOqz9Ge2c2P0VTmn9BeGwHiV07Nj0EUQlPiTEkaW7G954Q98Q6erSk92uyzv0nEMplTwXMs2+D8E966aefwH4rUM0hbeyvbOepyJfIEzmoAO5OrXmVL579neZVjaNSSWTcB1cpbPYW5fqc/xQO5Sfrs/LvWP1jU1Xqb7JaM/X2e49mUD/PhVCLX0+V4e/kJnfepuwfXyi6sHHPga33RbvHJB2PFMp80bGsS71PDPb8quvhrffTi6fMgUWLtTno8Ul2Q+cB5qS182pk2kmR2fuGaF5NAw3CHQGcLtS6gPx+W8DKKXuTlnnD8BrSql/xOc3A+cqpTK/feJGOwgUioZYsW8F/9n1H36y5CcZw4QO1vkTzufak65lfu18ppROwaipGb2Lgl/YoDLlhMxRDB89mNu2OVzwGdem/80//Wn405+yrNj7wieXi5XmxfDaRbqbXM9F+onfh+NviQd9iAeAIjpzoHcQaMM9sOkn/T8H8Ywq06Uv8svP0KNzVL9Xn0j1pJjbXHqd1E/5AEGghQtg4+b0ZdXdcOE2KAxl3yabjRXw2gSI9vpQX3PWFZR//b8JR8KsO9TIsw1vsqu7mfaQn13dB9h5aCf+iB91e2ab3js9TCiewMTiiZR6SqkrquPiaRczp2aOvpg6uA5WfQla34zX1DGg9nKYfD2UzNbLYqHkXWfDptfpCSC+/WPYeFef/6d/dsGP1+ukrR7FAbj5TbisHhw59GqImvDsNPjVPGhLSWAxFTz4nJOTGge4EPICbnTQtfek0IHV1CkK+NDB1hvOgAcGdwEwKLd8Er75GWhZBt3bSGSymXZdp8HmHHoQCHSXuf0L9HRwjf4ijQX137YnYydvAuTVxbtB2pMZiIaRrItlReHfJ2e2X/0+aFupg0ze8TDxU1B1rm7PVRof2ljpi1Wl9O8o2HB3v0NaKwXmx3M85gzVaNdjMs30iusjabTvAt2h33P5IZh4EEoDcEILnLEH5u6FygGSFfblw4qxsGQcbC3Tn9sdpRCIJ+up3+n9D8fCPLXpKZ7b+hzbD25nf/f+tG6zfSn3lDO+aDxjCsYwp2YON512E5V58ezYhefpWiiGqY/lVgyuTjkQ9xTHxQDTTiBoo7PLJBLRJ7hKJU+wCvItvJ5YoqtkVFlU/ryWjlBHWneoCm8FDV9tGFQg4s5Fd/LjRT9OGzY+akV5+qqnufS4S/vfOHwIXnm/LoLf36hh9nwonA7nvwTOEu5ZfA/fe/V7RK3kcxa5inj26meZXzc/530HqPpZFc2+5rRlYwvGsudrmTdDMgzhmGYpi8K7C9OymACOLz+ejV/c2MdW2f36zV/zjZe+kdb1K9+ZTyQWScvuArj5tJv51UW/GlT78/80n8WNi9OWOW1Omr7URTjgTNTMC4X0iJyxmD5UxGJgRDuY0P41yn0Po7BhU90YKec8McOLgUXQPoUdpffR5T0fmw0+eo2fhr1hbDb9MublQfM+N267jmb3FEu32Qau7+cL+4hYEaJRvU8KRUmeN7cArDiqWJbOcmxt1XXUekZ17ekqm3qBm3lxnF3PRTWkX6SGQvomi8ejAxE1NTB1cD1RD6uem9fZpr4CAalSXzvT1POuCdXYW0fnPOQ7rju5O5Se4Zlrx4xcuO50Zdy87uEwHXjsbhw2Bw7TkfJ9qYhZMcJWhEgsQiAazLiZ0OPNPRcy94F/Z39yA50o4UWfy5u9pvi9SaxekwKCsC9YwthweobnrbfC3XczIn73O7jxxvRlBw5AZe9OPNnOQw9jV68eww0CXQFcqJS6IT7/CWCeUuqmlHX+BdyjlFocn38Z+JZSqs8oz2gGgTbtXMfsB2eT+nY2MXDZ3Zw29jTOnXAuJ1adiKOPERUOBQ6xfO9yXt75MtsPbidmxdJG4Jh46FPs/OfnU7ZQ3POdWs45vTB1Eaefmj01bvmq9ICUSvwDGLDsprl8dVm9zg7yxicX4ARcJhTlQZ5bH33dHn0EMuNhRZupr9J7jmSWgvO2gDv5wbStHId1qA4iXojkYYsWMLlyHAXOfPKc+bhsbpymC6fdgdNux8DAMAxMw8TAQKFQSumfWESiMULRKOFYiIPBNmKPFHPa/hgFRV3kF3Yz4xw3088pwmb4sBt+7M4YdqeFzeHEsNkSd20NQyU+7PrurYGyFJW+n2KLR6Tv2jKV25ZfRIEjxFkV+5hd2solUwJM9LZSZLbjcnpR+ROw8iaivBPAUYBhc4Hp1j8NExULQiyIioVw1N+DEesn2m0vgCs7M5cP8cPec0E2kN5Zak15UPONHLcLAuOACnR2WjFQClQXQnUVlFRAXgW44oXUTHv8NqINYlE9WTFoegRU8sT6hbUX8p5fLqUokuX1GAETZ/ycXbuvItkN0GDXxgqcvXpk1NRkP+vdvz+aNq+SLentXum13fgrYP4/MxvKFvx88fP9Blef3zGD6+99ibL8NrxOP16Xn5/eHeS0ufG0Pyv+rTW+jwvCxmf0TyP+j4JEJp9h4323mJz16JvcTpZ9yEP/fUvRX6TZAmQGyaBYDPgE+rgS9+D/ubnulfjf2gmUAAUksxp7fhZ4obAEnA6w2/TksOnjTDQGkZj+eVIDOJPHTKNnkB4FRN0QzoOYC2JOiOqfNuXFaXPgtDkxMNMmhRWfFIpY/AIvTMwIUB5z8dZDKzKyOkfK3A/OZeVpKygwodYOZTYoNiHfhCKbjQpPCWWuAm7YWoDXka8jDjZ9LA46TF6dbBCxYsSURcyyiKoooUg3XcEuWkNdlHz7Y3y55H/1365nqq6GsnKdMpWfB143uNzgdMeP9/GzTjP+Do9ZybP1aATCQfAHwR8g9ssV2LpG58X5xwm1XHPl0LuEDuSmylLeZ2tnlgtq7GDDwJp1F2bJbAzvGAx3JYbdG685ZcZH24wH697+IcaGvoPaAH9eaNK6OT24d8EOmD3Icza/A/7vZAj2OsR8c2n6+dVVV8HDD2dpwIrBvudgw10668mwxbu+xn8WnwgzvgNjPpQofvn+X1/ES80LwUrWabM5FNu/vIW64rpB7f8p95/CWwfeSguGneGr5jX3bgA8hj6EuF0llHnLKXGXUOIpochdxCMffTRrmxc8+D4OBg5yMHCQtkAbUStK1IomAjMODOxG8vWJKfj8aV/ivovuG9S+r9m/hnkPzEsL2gWjQRyotOO/YZr89kMP8OmTPz2o9m9ZcAu/evNX2Izk6xxe8XHUMw+krdfvqXQsDAdehYZHdPDeCuuBKGo+AOM/oovyp3jsMXjkEVi1Cvbt023/4Acwe7bO2qmo0IEhj0cHgayUj3/PfvS+4xyJ6KCAzwfzfjCO5jF7mdIOk9uhzAdju+HUfXDyfqga4HDhd8D6KlhZA5vKwefUgeHtpXAwdRRSXzkEiygucPG+WScwqWQS1fnVVBdUU+IqyciSi6kYrf5WmrqbaOpuor61nm3t24ipGG3+NjpCHdTkjeUjj+bx8RUl+PHiI4+wtxj7mEpUXj7Km4fldIPTiem0Y9h1bRGVGvVIfbEsCyschUgEMxzkP3sm83LkbCgpBRQuR4Qf3RGiqiKMzYhgEsFQ4fjnU2EoMA0FRuobIH7+ipEIuCjsKMPB89d9km9tSe+mGN9EV2lN/c7uWd7XaWPPvRiAGDRFK6mJpJ+XPvMMXJKlfNVQ/PChBfxg64UAmBY4Y/oGXmEoORWEoSAE7qh+PGrq42K3E7pc0Bn/2eGCkB2UAZH4R+v728+npft07JY98dV21qduoqSwNO3zN5CIFSZk+em5vrWwCFsBPv/cLNrLksECQ4HdAmd8X10x/bNnAr1v4WyTCSolKGYEC9h3j5dqRicItP468M6aTLuvlK5AAV3BAgJzn8JmS96f6jkOJLICU48JnfUYnRsACxOFUhZWNIoVC2NTfs5Ydxv2lzrT3mr54cHd/Ab9dmzJS78BHjFh0udLsTwDd8UdyrWPE8gWvjIUuKL67+pK+Rvb42Usw6Z+D4ZsyZ+RLJcXE5tms/P1W9Hn5HawbHzluqmcOrMELBObacPAxDQMzESvnPiLYRiYBliJyKLesZgFlmVhGBYffn8FbtcopQEx/CDQR4EP9AoCnaaUujllneeAu3sFgb6plFrVq63PAZ8DqK2tPWX37t1D/1/1o7W5m/u++1mUMuLPq5h37gQuOu8CXazX6LnISr1MTHkddvwFdv4FgEMx2N8rsPnzhdfzwN/TTwA2boTjj++1I0MMFJx2y92s8D8SD9K4oWQnx03xUODKJ8+Rh9fhJc8Z/+nIw2baCEVD+CN+fBGfnsLJnx6HhxJ3Cf6In0A0wLTIHtpDXZTbDPJMA8tRzJTjr2ds/liq8iuo9JST78zTX9A9eYNxvs2/pWXbgxyIwr4YbA3rgGxQQWsMOg+OZeU96XcP//Y3uDb37PR+Xfm57fzzj+k1KdLewkrp7KDwoeQoYVF/PPsleVGNYepMIWdJcrIX8O1vdLHo+R14nAE8zgBue4AH/mTGAxFKHzyx4tfqyWg4gL3xIWx7/tHv/v+5LY9il48Kmw5wUzyT8nMfZ0LxhIHrT8SzvCIKdkegOf6+tIC2GOyJwpXfgopRKnuz6fppHH/+lvSF2WpXZXvfl+XBr/o/s5z+sxfYsubCxLxh9JF8McTPVdmXL8SnWjBiXhQxbIXN1NXk4bXn47Hn4bF78drz8TrycNv0mWwwFiAQ9eGP+vBHfMnfoz7K3BWYho1QLMAplp0/ly9Pf8Ir2vX7Kpd9/y39ZqjdtfY9/OTVT2E4iwDwR3x85doZTKstSrxWSsE1nzkL76H0rgv+4nIe+tPitM+JaRqJiybDgE9eOiltm5ISaM/2fT3UOx0P9TqLrbsaznxo4PZzCMDt7Spkh70TrwFeU58QGCf/lPwpn6TQVYjL5uq/S87624m+dQfdFnRa8TiZgoACnwWqu5L3VOgsCV/UhaVs5H+8DSO1kHYskNLFdQDPTodQMuviTx36szvZAW4D8I6h5Ky/Mrt6dt9DjfeIZzZGFWwKw7aIjscp9PF5Q2c+93+7C1B4XX4K3F38+AedXP+pgM4KtIJ6v2MROPkaaEnJOK0ohjV/T7nlmXo1osCws2ztWr791jc4zgFTnOAywDbls8yc/nHm1Mwh3xkv1NjX++bFz2O9dQdbIrAiCIcsve/7o1Af1u0tDjvpNjz4Ij6cKkqpDQpNXQi35+cfXoBi5YhXuDfBbqPLY3LnOQZRFUsE4e4q9lGUeuLeKyt2yhRdNyjDEN/3txd8ltu7H+h3nQxjgAnoYGAA2AVk9gziX1Mn8fFxn0l0ewO4+L11/OST19KT5q4UVJ9cg60lfd9jFVUcWLOPnqLSG9rWsbzp9bQAwtaVL/Nc9AU6VIz08Hq6vrrV93Xi7gRKbPCvV2sZvzw9gFjuB9sQ7m63e/SFRo9uB/ztm2XYbMlaPnlV0/ncZQ/htbszzmsyUiI23Yux+RcANEfh0V7fqXsDbt77vRNwBvII4SKIG6O6CntVGcrlBrcby+ECux3DYU8GbRP9XHsClvFAlbKwIjGIRjGjemSGC84MYP8ffSs7gJt2SumgKG0K4cKyOVAOJ8q06d9tdt2uFcOMRTCsGEYkjBmL4CZIER189558VgafGPwLnQOvWYirAw4W6JtFLgPK4p/VgpQpzwS3zYXb4cFu2LAZpp5Mk5hl6aC5sohYMYJRP6FYmGAUGp69hZ1rb6WyqJkiTwdF3g7+/WyXPsfrGR00Nds57W/d62+u4hdrPVnphsn9j93FDtcmqmxQadPBfvf5/2Zc4Thqd8q+6wAAE7JJREFUi2r7rnvS8wxK0RZoo7GjkX1d+4guvZaDwQ6ao3AgBvf2rrdfMA0u2Zy1rZykZLdbCjr9RbR1lxEIe/CHvQTGfA41+YZEdlpPtkuW0/tEwCrtJYoHEUwT6rf+kSvzP4eVcp1beOq9eOquIC1qZaR+VwxEJa7HXHdNJ+YcoZH1spjnqmNbpIWAiuBXkYE3yIELGx7DQbFh4DKCOJUDh7LTHbVzUBXgdFbgtnlw2704TQ9O043LdOGw28EyiBIlEosQC7QQDrYQURBGEQWqTAtLWYRVhEqXjw8tCXPTv+MnZgbgIJktk5pBY7elRIB7MtKNeIJA/A96R1SXKon7zctfY9X2k7BU8rrmV/9XR15eShqOpdNvDIO0N46x60GM3X/r93Ua/58LaLZ3YkaKMGJObIVtnHFSOeXuKsrcFRS6ihPn33ZDn5tayiIQ9eGLdtMV7qQ92EJroIXW4AG8dn2N2h3uxFRBlhf3KkM89Ysw99fpy/o5D+nvHPP1AHypRZ9rFJn6PNFZcQY1JdOoyqui1FNKgauAAmdBWoZlJBahK9xF967Had+3kOb4dXOXBeU23U6HBTeNn86nrq3v9/UbjmOyO5g4NqWmePbM9/7Zu95Iz7HSZiPjXFAMQk8XobQL4X7OMFJPEoyj/MW3oro7R6hdByGjfn1xbXOjg48kfxpm+v9VAcs/A5FDAzzJ6BW+i0SguVn3a+4ZHS41NbrnBLK3rIOP9Zo3TX0H25E98fLIt/nXUP8zXdsjfFBnzp3zLz0CoenUxeRNt+5uqVICQUrB23f228USoHQ7HBylnmYewN87RX/qjTD3N0NvtHeX2lxqbQ2nG+Ttt+thwkZB41fuZeslXyMQ0N0n/H7dtSG1vkIslnwfp+52tvd6z2elZ/6SS0agHlV/RvG1AXT6ST+jrEZiEQ4FD3EweJAD3QeoKaihxK0zhAbTne6oNNpdUEezG4FSug5V5yYI7Kf1YD0NrRtQsSBmvNC/2+7C+f/bu/8gu+ryjuPv5+5m84skhJAIMSEIYpDagAjUVg1CkAF0otSBscWpLe10ZEoLdKjFwXFwrB1/l+l0RkaEtoNKpYICzrSG2qKdaUF+BpImYmiChEB+UCAxCtlkn/7x/d7sZbnn3M2e5ySevZ/XzM7e3Q2f+3Duffb7Pd89P4ZmMTh4GK3WIC1r0bIBWjbAlIEpDGC0Wi2GWlOY0oJW+1TzPS+lo9qGd6bTG30fLPoAfvJfgQ2mI6AGZ6bTO9s3Sdl/J8tXL9JYe+H5ziWjCx0jXa6dcSA3UulxSYCVW+Dumo4qBXjgmAFOO/HD7J8rtabCcb+XT9dun+PS/v9pdTx22HgLbCrf2YYBWHhujtkHhy9L1/gjnzbbZrb/WLn9391wIzx544H9D521Co5+z/j+ba/LVcw/E95zLyM+wst7X2bd9nW88MsX2D28m5defokXXk5HFrY/YzDYGtx/ZOLcaXPTDvnQLGZNncVRhx3FksOX9P5DkMgkVnURaJB0YegVwDOkC0P/rruv7fg37wUuZ/TC0H/r7meU5WoRSEREGsVH8gX7X0w7OMO7Rj+P7GF00t5eEO04tALLPwcYSYtGg7PgqLOgNcTekb2s276O6++7nvXPr2fb7m1s2bWl8M5dnRYetpD5M+ezZM4SVp64kotOuojZU2enHYtHPpZqHt6ZFrGmzk+noPjetFPWvnbawLR88fhco7Vgw1d77xTcMQi3lx0rUlGPhQgROQB7d8Nt+Qg9G0gL2fN+A87pOEVpZHj/tbOgNXqaMgZ3HjOOO/Vkrfw75cSr4dc/Mfr9fS/na8uNWZiAdI25XteFtCFYdl26A+UrO9LvtGkL0u/U1lD+PDXdObN9Ew/Lh0n81yU9/uBicPGutFAFbP35VtbvWM+zu55lxy93sPGFjazdvpbHtz3Oll1bmDU0i117dnH83ONZ9rplnHTkSSyes5h5M+ZxzJxjWDpvKXOmzRnf9hIRCVZpESgHXABcTzrg7GZ3/4yZfRTA3W/It4j/O+A80i3i/6DsekCgRSAREZHxGN43zKYXN7F+x3qe3vk0py88nTce8UbmTp/b+z8WEWkb2ZeuPfX8ffDiWtjzfLro+Ml/DdMXwvSj8unx+Vpb+2+uYWkhZby3a754J+zakO7q88rzaRF6eHc6OqV9F8/W1HznydFTgkbZ6OLTyF7wPaMLPCdctn+RRkREilVeBKqDFoFERERERA4hH8lHNO5MRzUO70p3iRzZSzqNOV9np/25fetmyxciaX89MAOmzII5v5YXd0RE5FAqWwTSb2kRERERkX5kLZgyO32IiEhfqO+eZCIiIiIiIiIi8itDi0AiIiIiIiIiIn1Ai0AiIiIiIiIiIn1Ai0AiIiIiIiIiIn1Ai0AiIiIiIiIiIn1Ai0AiIiIiIiIiIn1Ai0AiIiIiIiIiIn1Ai0AiIiIiIiIiIn1Ai0AiIiIiIiIiIn1Ai0AiIiIiIiIiIn1Ai0AiIiIiIiIiIn1Ai0AiIiIiIiIiIn1Ai0AiIiIiIiIiIn3A3P3QPLHZduCpGp/iSGBHQ/ObXHvT85tce9Pzm1x70/ObXHvT85tce9Pzm1x70/ObXHvT85tce9Pzm1x73flNrr3p+U2uven5dde+xN3nd/vBIVsEqpuZPejupzUxv8m1Nz2/ybU3Pb/JtTc9v8m1Nz2/ybU3Pb/JtTc9v8m1Nz2/ybU3Pb/Jtded3+Tam57f5Nqbnl937WV0OpiIiIiIiIiISB/QIpCIiIiIiIiISB+YzItAX21wfpNrb3p+k2tven6Ta296fpNrb3p+k2tven6Ta296fpNrb3p+k2tven6Ta687v8m1Nz2/ybU3Pb/u2gtN2msCiYiIiIiIiIjIqMl8JJCIiIiIiIiIiGSTbhHIzM4zs5+Y2QYzu6aG/JvNbJuZrakhe7GZ/YeZrTOztWZ2RXD+NDP7sZmtzvmfiszPzzFgZo+Y2fdqyN5kZo+b2aNm9mAN+Yeb2bfNbH1+DX4zMHtprrv9sdPMrgzMvyq/pmvM7FYzmxaVnfOvyNlrI+ru1kdmdoSZ3WNmP82f5wbnX5TrHzGzSlfiL8j/Qn7vPGZm3zGzwwOzP51zHzWzVWa2MLL2jp9dbWZuZkdG5pvZdWb2TMf7/4Lo+s3sT/Pv/rVm9vnA2r/VUfcmM3s0snYzO8XM7mv/XjOzM4LzTzaz/86/O+82s9kTzO46PkX1bUl+SN+W5Ffu25LskL4tyu/4eaW+Lak/pG/L6q/atyW1h/RtSX5I35bkR/Vt13lfRN+WZEf1bFF+1FhblB/Vt6Vz7ip9W1J7VM8W1l61Z3vUH9W3RfmV+7YkO6RnO57nVftTET3bIz9yjjw2O6RnS/LD5sjd8ju+X3mOXFB/2Bz5gLj7pPkABoAngeOAIWA1cFLwcywHTgXW1FD/0cCp+fEs4InI+gEDDsuPpwD3A28P/n/4c+CbwPdq2D6bgCNrfP/8I/BH+fEQcHhNzzMAPAcsCcp7PbARmJ6/vg34/cB63wKsAWYAg8C/ASdUzHxNHwGfB67Jj68BPhec/2ZgKXAvcFoN9Z8LDObHn5to/QXZszse/xlwQ2Tt+fuLge8DT1Xps4L6rwOuDno/dss/K78vp+avF0Rum46ffwn4ZHDtq4Dz8+MLgHuD8x8AzsyPLwU+PcHsruNTVN+W5If0bUl+5b4tyQ7p26L8/HXlvi2pP6RvS/Ir923Ztun4NxPu25LaQ/q2JD+qb7vO+yL6tiQ7qmeL8qPG2qL8qL4tnHNX7duS2qN6tig/aqztuT9SsW+L6q/ctyXZIT3b8Tyv2p+K6Nke+ZFz5LHZIT1bkh82R+6Wn78XMkcuqD+kbw/0Y7IdCXQGsMHd/9fd9wD/BLw/8gnc/UfA/0VmdmQ/6+4P58e7gHWkHfyofHf3n+cvp+SPsItCmdki4L3A16IyD5a8Yr8cuAnA3fe4+4s1Pd0K4El3fyowcxCYbmaDpMWaLYHZbwbuc/dfuPte4IfAhVUCC/ro/aSFOPLnD0Tmu/s6d//JRDPHkb8qbx+A+4BFgdk7O76cSYW+Lfkd9jfAx6pk98gPUZB/GfBZd38l/5ttgdkAmJkBFwO3TiS7JN+B9l8M51ChdwvylwI/yo/vAT44weyi8Smkb4vyo/q2JL9y35Zkh/Rtj7lB5b49CHOPovzKfdur9qp9W5If0rcl+VF9WzTvq9y3RdmBPVuUHzXWFuVH9W3ZnLtS39Y9ny/JjxprS+sP6Nui/Mp9W5Id0rNQuD8VNkfulh/VtwXZIT1bkh82Ry7Zlw2ZI/8q7StPtkWg1wNPd3y9mcCJzMFkZscCbyWtMEfmDuTDK7cB97h7ZP71pAYZCczs5MAqM3vIzP44OPs4YDvw9/kQva+Z2czg52j7EBV2JMdy92eALwI/A54FXnL3VVH5pKOAlpvZPDObQfrryeLA/LbXufuzkCbGwIIanuNguRT4l8hAM/uMmT0NXAJ8Mjh7JfCMu6+OzB3j8ny47s1VD2Pu4k3Au8zsfjP7oZmdHpwP8C5gq7v/NDj3SuAL+bX9IvDx4Pw1wMr8+CICenfM+BTet3WNf+PIr9y3Y7Oj+7Yzv46+7bJtQvt2TH5o3xa8rmF9OyY/vG/H5If1bcG8L6Rva55Tjie/Us8W5Uf1bbf8qL4t2TYhPVuQH9azPV7byn1bkB/StwXZkWNtt/2pyLG2zv21XtlVx9mu+YFj7Wvyg8faou1T5xy5q8m2CGRdvhe2Mn6wmNlhwO3AlWNWNytz933ufgppFfYMM3tLRK6ZvQ/Y5u4PReQVeIe7nwqcD/yJmS0PzB4knUbxFXd/K7CbdLhlKDMbIg0S/xyYOZf0F4I3AAuBmWb24ah8d19HOnzzHuBfSadZ7i39j/qYmV1L2j7fiMx192vdfXHOvTwqNy/sXUvwwtIYXwGOB04hLVR+KTh/EJhLOiT7L4Db8l8SI/0OgYu3HS4Drsqv7VXkoxEDXUr6ffkQ6XSTPVXC6hyfDmV+RN92y47s2878XGto33apP7Rvu+SH9W3J+yakb7vkh/Ztl/ywvq1r3ld3dq/8iJ4tyo/q2y75ywjq24Law3q2ID+sZ3u8dyr3bUF+SN8WZIf0bN37U3Xm98qu2rNl+RE92y0/co5cUn/dc+SuJtsi0GZevfK6iNjTYmpnZlNIE4FvuPsddT2Pp1Od7gXOC4p8B7DSzDaRTsM728y+HpQNgLtvyZ+3Ad8hnf4XZTOwueMvEd8mLQpFOx942N23BmaeA2x09+3uPgzcAfxWYD7ufpO7n+ruy0mnm0QfDQGw1cyOBsifJ3SY8aFkZh8B3gdc4u51LUB/kwqHGXdxPGkBcXXu30XAw2Z2VNQTuPvWPGkaAW4ktnch9e8d+TDtH5P+wlLpwn2dLJ1m+dvAt6IyO3yE1LOQFodDt427r3f3c939baRJ9ZMTzSoYn8L6tu7xryg/om/HUXulvu2SH9q33eqP7NuC7RPStyWva0jfFuSH9W3Btg/r27Yx877Q8baGOWVpfvRYW1J/yHjbkd/+g13YeNtZex1j7ZhtEz7WdnltQ8fbMfmh4+2YbR/Vs0X7U1E9W+f+WmF2UM+Op/YqPfuafOAW4nq2a/0HYY7c1WRbBHoAOMHM3pCPuPgQcNchrmnc8mr6TcA6d/9yDfnzLV+R3cymkxYP1kdku/vH3X2Rux9L2u7/7u5hR6OY2Uwzm9V+TLrIWNgd2tz9OeBpM1uav7UC+J+o/A51HE3wM+DtZjYjv4dWkK4rEMbMFuTPx5AG5zqOiLiLNECTP99Zw3PUxszOA/4SWOnuvwjOPqHjy5UE9S2Auz/u7gvc/djcv5tJFyp9Luo52hOX7EICezf7LmmwxszeRLqw+47A/HOA9e6+OTCzbQtwZn58NsELrB292wI+AdwwwZyi8Smkbw/C+Nc1P6JvS7JD+rZbfmTfltQf0rclr23lvu3xvqnctyX5IX1bsu2j+rZo3le5b+ucU5blR421JflRfdst/5GIvi2pPapni17bkLG2x3snom+L8iv3bcm2D+nZkv2pkLG2zv21ouyoni3JD+nZgvwPRo21JfXXPUcuLGhSfZCuV/IEaQX22hrybyUdqjVMeiP8YWD2O0mnrz0GPJo/LgjMXwY8kvPXUOEuNz2e590E3x2MdM2e1fljbU2v7SnAg3n7fBeYG5w/A3gemFND7Z8i/dJbQ1q1nhqc/5+kRbHVwIqAvNf0ETAP+AFpUP4BcERw/oX58SvAVuD7wfkbSNcka/fuRO8o0i379vzaPgbcTbrobFjtY36+iWp3B+tW/y3A47n+u4Cjg/OHgK/nbfQwcHbktgH+AfhoTe/7dwIP5d66H3hbcP4VpDHxCeCzgE0wu+v4FNW3JfkhfVuSX7lvS7JD+rYof8y/mXDfltQf0rcl+ZX7tmzbRPRtSe0hfVuSH9W3Xed9EX1bkh3Vs0X5UWNtUX5U3/acc0+0b0tqj+rZovyosbZw2wT1bVH9lfu2JDukZ8c817sZvYNU2By5ID9sjtwlO6RnS/LD5sjd8sd8f0I926P+sDnygXxYfnIREREREREREZnEJtvpYCIiIiIiIiIi0oUWgURERERERERE+oAWgURERERERERE+oAWgURERERERERE+oAWgURERERERERE+oAWgURERERERERE+oAWgURERERERERE+oAWgURERERERERE+sD/A6ggrcq3GyuSAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "onehot, fwd and rev:\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABHcAAACMCAYAAAD2tUXSAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdeXxbV5338c/RYlt2HNuxkzj70uxtaULTQqAttKVAadkKhS4DZRnKWtaZeWA6QAeYAYZhm+F5YNhLGQbaTktXukDbNClZnaVJmqVLVtuJlySOF1mWdM/zx5Vly5Js2bpKovT77ku1dHXvTyeyj3T10zm/Y6y1iIiIiIiIiIhIcfKd6gaIiIiIiIiIiMjYKbkjIiIiIiIiIlLElNwRERERERERESliSu6IiIiIiIiIiBQxJXdERERERERERIqYkjsiIiIiIiIiIkUsUIigdXV1dvbs2YUILSIiIiIiIiLystTQ0NBmrZ04dHtBkjuzZ89m48aNhQgtIiIiIiIiIvKyZIzZn2m7pmWJiIiIiIiIiBQxJXdERERERERERIqYkjsiIiIiIiIiIkVMyR0RERERERERkSKm5I6IiIiIiIiISBFTckdEREREREREpIgpuSMiIiIiIiIiUsSU3BERERERERERKWJK7oiIiIiIiIiIFLERkzvGmBnGmCeNMTuNMTuMMZ85GQ0TEREREREREZGRBXLYJwZ8wVq7yRhTCTQYYx631j5X4LaJiIiIiIiIiMgIRhy5Y61tttZuSlzvBHYC0wrdMBERERERERERGdmoau4YY2YDy4B1hWiMiIiIiIiIiIiMTi7TsgAwxowD/hf4rLX2RIb7bwZuBpg5c6ZnDRQREREpWvEIvPhz2PMj6G0F44dxs+GcL8PUq8CYU91CEREROQMYa+3IOxkTBB4EHrXWfm+k/ZcvX243btzoQfNEREREipB14Pkfw7NfAScCse7U+wMVUD4Dzv8PmHLFqWmjiIiIFB1jTIO1dvnQ7bmslmWAXwA7c0nsiIiIiLysWQtrPwyb/wH6jqYndsDddmIXPP0OeOk3J7+NIiIickbJpebOa4H3AZcZY7YkLm8pcLtEREREio+1sPEWOHAnxHtG3j/eAxs+BgfuLnzbRERE5Iw1Ys0da+1qQBPCRUREREay9VZ46de5JXb6xcOw5iZ3qtbUKwvWNBERETlzjWq1LBERERHJonUN7P4BxDNMwxpJvAeeud77NomIiMjLgpI7IiIiIvly4rD2JncUzljFI961R0RERF5WlNwRERERydfzP4aepvxiOL2j2r2lu4VDHYfye0wRERE5Iyi5IyIiIpKP3lbY+qWxTcfKw7V3XstFv7ropD6miIiInJ6U3BERERHJx45/BSd60h/2QMcB2nvaR3dQfT0YU7hLfX1h/rEiIiIyLCV3RERERMYqFoYXfw7Oya+Xc6T7CF3RLnpjo5jOdeRI4Rp0MuKLiIhIRkruiIiIiIzV/t/ltl/ZZJh4MdStcJc8z9Ox8DHCMbd48662XXnHExERkeIWONUNEBERESlau74Psa7s94emwSu+BrOuA6fP3WZ8sONbsOc/IDa2Oj07Wnckr29v2c7S+qVjiiMiIiJnBo3cERERERmLE3ug66Xs91edA1ftgNk3QqAcSqrdS3A8nHMrvGkDBKvG9NDbjmxLXt98ePOYYpxKjnW4/DeX09rdeqqbIiIickZQckdERERkLF78Jdh45vsqF8AVT0OwEvyl6fcHKqBiDrxh5ZimaW1o2pC8vu7QulEff6q9ePRFntj7RMq/Q0RERMZOyR0RERGRsTh0z8BUq8F8JXDZ4xAY707ByiZQBpUL4VW/HPVDNzQ3AGAwRVlzZ1PzJgC2Ht5akPh3bL2Dyf8+uSCxRURETkdK7oiIiIiMVuQodO/PfN+iL0DJBPD5R44TKINpV0Hda3J+aGstLxx9AQBjDB2RDjp6O3I+/nSwrtEdbfTMwWcKEn/NoTW0dLdwLHysIPFFRERON0ruiIiIiIzWkSfBl2G6VWiaW08nOC73WIEKePWvhh/lM0hzVzOOdZK3y4PlKQWWi8HqA6sB2HJ4S0Hi948M6v8pIiJyplNyR0RERGS0Gh+EWGf69ld8HXzB0ccLTYGZ781p121HtlE6qI5PLB5LKbB8urPW8lzrc4CbqOruG9uKYcPpn6pW0Jo+0S7Y+1vY8El45gZY/1HY/Z8QPlK4xxQREclCS6GLiIiIjFbzI+nbglXukue+ktHHC1bC2f+Y067bWrYRjoWTt3tiPckaPMXgQMeB5MijskAZzx55lhUzVngWv72nnY6IO01t5b6VfPGiL3oWG4Bjz8KzX4bmx8AXgFjXwH3+ctj891CzDM79Cky90tvHFhERyUIjd0RERERGo3s/RI+nb599Q/bVs3Ixbk5Ou61vXE9fPLWQ88amjWN/3JOsobmBoN8d3RR34p4nphqaG/AlTnE9jW2tOzLnsVdD4/3g9KYmdgDiPeBEoH0trHq3O5onHvGuDSIiIlkouSMiIiIyGm3rwGSYerXgU6OrtTNUjtO5Nh/enLZtT/serLVjf+yTaH3jejoj7pS2SDzCqgOrPI2/oXEDFovBLTZ9NHw0/6CxbnjqLbDlSxAPj7w/uImevXfAw6/IXnxbRETEI0ruiIiIiIzG8e3uh/3BQlNh3Nz84uYwnSvuxNl/3E0U+IyPYCIhFHNiHOkujlovqw6swjKQiNrQ6G1dnKf2P+Umd4yhLFBGQ1Oeo3esA09f4xbRjo+yPlA8DF0vwOOX5NcGERGRESi5IyIiIjIaRzcATuq2+svBiRb8oV869hIlfjcJFPKH8CVW2CoLlOVWVHny5EI2b8T41tq0dh48cZDeWK9nTdjSPLACVzgazn/K2qYvQOtqd7rVWFgHeg/n1wYREZERKLkjIiIiMhodGZYdn/Z2tyhygW1v2Y7f5wfA5/MRc2IA9MZ62d6yfeQAhw+7tWOGu2Qz0nHWuvGH0dzVTHRIEqw8WJ5b23PQ1tPGib4TydtRJ8pT+58ae8AXfgkv/NSdYpUPp2/kfURERPKg5I6IiIhIrpwohJvTt9dfflIe/tkjzyaXDu+N9iZH7kTiEdY3rj8pbcjHpuZNyZFH/WLxGJuaN3kSv6GpgbJAWdpjjklPEzTckn9iR0RE5CRQckdEREQkV50vgj81eUDlAjCBk/Lwaw+tJZ5YkSvgDzC1cmryvk2HvUmQFNKGxg3J5FS/nlgPqw+s9iT++sb19ERTkzEnek/Q3tM++mAbPzXyVDt/OUy9CubcBDPeDaV1o38cERERD5ycMxERERGRM0HHDtK+G6s+N78l0EdhW8tAvZoplVOYUz2Hvcf3ArDv+D4c6yRH85yOVh1YlUxOhQIhwjF35am1h9Z6En/l/pXJqWr9yoJlNDQ38Maz3ph7oKObofkRsFmSO2WT4fwfwrS3uVOujM+dluYvgfb1sPHTcHxrHv8SERGR0Tl93/1FRERETjfd+8EZUvy36mwIVBT8oSOxSMqKWHOr57J44uLk7aAvyL7j+wrejnxsOTxQ7HhK5ZTk9X3H9xGN51+QevAy8f1Lw/dEe0a/Itemz0E8S5Hn+ivg6l0w450QCEFJlVtvqWS8O6pr4kXwxmdgwS1j/WeIiIiMmpI7IiIiIrnqPZxeHLf2QvAVfjD0rrZdhAKh5O3FExezsHZhssaM3+fPbcWsU6Slu4XuqDsly2BYUreE8mA54K729Vzrc3nFb+1uTU75KvWXMr50POAuEz+qosrd+6FtHZChuPSUN8Mlf4SS6uxL1xufm+xb+q9wzldG948QEREZIyV3RERERHLV05i+rersk/LQ21u2YxMJh7JAGYvqFjG3Zi6l/lK3aX09KdO2Tjebmzcnk1PjSsaxrH4ZQV8QAMc6eRdVbmhuoDTgPhdlgTJmVc9K3jd4efQRvfgrMiZ2qs6Gi+6CQHlucQLjYMk/wIx35f7YIiIiY6TkjoiIiEiuejOslFU+7aQ89ObDm5MjU0r8JcypnsOc6jk41gEgZmOsObTmpLRlLDY2bRwYuWMMK2asIBKPANAd7c677esb19PT5xZTjjkxzp9yfvK+E30naOtpGzmItfDCT8CJpG73lcDr/5R7YqdfoAJW3A4Vs0beV0REJA9K7oiIiIjkqrcl9XZwPCSSK4W2rnFdcuSOYx3m1MxhdvXsZFFi4LSelvX0gaeTxY7D0TArpq9IJqYAnjn4TF7xV+5bScy68SPxCCumr0iZ9tXQ1DBykNbVEOtO377476B0gjvlarRMCVzw49EfJyIiMgpK7oiIiIjkqu9Y6u3SuvQaPAWys3Vn8no4GmZ29WxCwRAVwYFizs1dzfTFT057RmtwMeVQMER1qJrp46cnt71w9AXizthXHRtcTHnKuCksqluUnPYVjoZZ37h+5CB774BY6lLqBKvh7C+NvWi2PwiTLhnbsSIiIjlSckdEREQkV9GO1NulE0/KMugnIic4ETmRvF1ZWpkspDxt/MC0sFAgxO623QVvz2gdCx/jWHggMTazaiYAC2sXJreV+EvY3T62th/pOkJPdCAps6B2AQvrFtIbc1e8ijpRVu5fmUOgvwBDRmKd9UHAjKldSb7QyPuIiIjkYcTkjjHml8aYFmPM9pPRIBEREZHTkrXpozpK607KQ+9o2UEoOJAgmFY5kNCZN2Feyr7bW06/U7bNhzentP/siW4R6qX1SzGDEidjLao8uJgywLIpy5hYPhHfoGlUg0f2ZBQ9Ad0H07cvuCX/pe59+j5VREQKK5d3ml8Dby5wO0REREROb5lG6JTWgfEX/KG3tWwjFo8lb8+fMD95/eyJZycTJN3R7pGTGKdAQ1NDchRNwAQ4b/J5ACyuW0xFiZs46errYu2htWOKv75xfbLYdEWwgiV1SzDGJEcI9cdv6W7JFgLa1kJgyAibmqVQNmlMbRIRETmZRkzuWGufBo6ehLaIiIiInL5sPL2grr90bEV2R6mhqYGexKghg+HsSQPLr8+fMD9ZONixTm61ZU6yVQdWJWsBlZeUs7DOnY41v3Z+yuiaZw6Mrajyyn0riSeSb36fPxl/ycQlyX1GLKp8ZGV6MeWZ17orZYmIiJzmNEZUREREJBc2RlrtFeNP31YAG5o2JK+XB8tTpmLNqZlDwBdI3n6u9bmCt2e0GpoHkirWWhbULgDc2jj9I3oAdrXvSllBK1dbj2xNXu+N9SZr+SyrX4Y/MbKqp68n5XlM07oyfXTWlDdDoiiziIjI6Sww8i65McbcDNwMMHPmzBH2FhERESky1iE9ueNL35bNPfXQe2SEnXxwQ2qCwVrL80efT94O+ALMqZ6TvD2neg5RJ5q8faz3GJ2RTipLK3NrV4F1Rjpp7W5N3g7HwpxVcxYAE0ITCPgCyVE9fuPnxaMvMr92fsZYmRzuOpxSTDngC1BbXgvAorpFVJRUcCJygpiN8dS+p/jK676SOdDQejsmAFVnZ95XRETkNOPZyB1r7U+ttcuttcsnTpzoVVgRERGR04PxAzZ1mxNP35bNiIkdSFupCWjpbiEaH0jeRONR5tQMJHemj59OJBZJ3i4Plp9Wo3e2HtmaUky5qrQq5fasqlnJ6z7jG3VR5Yam1GLKs6tnJ68vrFuItQO/n8HLsaeJtKberjkP4r2Z9xURETnNaFqWiIiISC6MPzF6ZxA7iuTOGG1v2Z6SvOhz+lJWy/L7/MmRKgBxJ35arZjV0NSQknwanHwBWDxxcfJ6V18X6xrXjSr+usZ1yWLKMLASF7griYVj4eTtnmgPR7oyJNminTBo9BMAlfPAFH7KnYiIiBdyWQr9f4A1wEJjzCFjzIcL3ywRERGR04wJkJbIiXdnXkXLQ88eeTYlOVIbqsXvS12ha/CqUN3R7pQaN6faqgOriMQH2n/upHNT7l86eWmyLo7FsvrA6lHFX7l/oJhywARYWr80eV95sJyq0qrk7dJAaebnpucQ+IeslBWaDr6yUbVFRETkVMlltazrrbVTrLVBa+10a+0vTkbDRERERE4rmerrRNrSR/N4bEPThpTkyOBETr/+AsLJYxqHKRx8kg0uYlziL+EVk1+Rcv/CuoXJ1b4AdrTuSJlKNZKthweKKZeXlLOoblHK/XNr5iav9/T1ZF5NLNyUvupZ5Tzwa6UsEREpDpqWJSIiIpILYyA4LnVbb1vBH3ZoDZrFdYvT9jln0jkEzMA6Gbvbdxe8XbnoifbQ1NmUvF0WKEuulNVvQe0CzJDpTwc6DuQUv6mzKWVU0+CVuPoNTibFbIyV+1emB4qH07dVaIEQEREpHp6tliUiIiJyxgtWQ/TEwO1IK/gKdzoVc2JpiZo7n7uT+/fcn7ItGo8Ss7Hk7c6+Tva070lLdJxs245sozxYzomI+5w51klr07wJ89JWu2pobmBW9SxG0tDUQEmghN5E4eOeaE/KMvEA500+j7JAWXLJ9YxFlZ0oDB0tpClZIiJSRJTcEREREclV6QToGTSqJNIGvtLs++fprwf+mratN9abTFQM58E9D/L5FZ8vRLNydt+u+1KKHXf3dfPlJ7+Mb8gUKDNoutuJyAnu3HEn1yy+ZsT46xvX09XXlbw9ITSBskBqUmZB7QJK/aXJ5ywcDdPc2cyUyikDO1knfUV74ydnY1zmXkRExCtK7oiIiIjkqmxy6u14GGwMCBbk4R576bExH/vMgWdOeXLnd9t/lyx2DG7B5D/s+MOIxz38/MM5xf/Vll/hDKp51BnpZMF/po4MijrR5Mih/tt3P3c3t7zqloGdMo2+stH0bdmMcZl7ERERryi5IyIiIpKrsinp27r2QVV6HRwvrD20dszHDq3Vcyo0djaO6bjOvk4cx8Hny14e0nGctPi98V6eP/r8sLEd63DXjrtSkzsmQNrQnWjnaJstIiJyyqigsoiIiEiuyqenbzu+NX2bR7Yd2TbmY5u6mkbeqYA6I53EnNjIO2ax5UiG2jiDbDo89uTV1pYhv7OS6vSdOp8v+EpoIiIiXlFyR0RERF6WovEon33ks7R0t+R+UNnk9EK77Rth0FLlXmoPt4/52L54H45z6pITD+x5IK/j/7jrj8Pef+/Oe8cce/A0LcBN2jlDpmF174P4yLWNRERETgdK7oiIiMjL0r+u+ld+uO6HfPSBj+Z+UOU88A8poNyxI/NS2kMNrdczgq6+rpR6NWOx5tCavI7Px6MvPJrX8U/te2rY+5/c92Re8VOmrYWmgjMkkdNzMD3hIyIicppSckdERERedna27uTbz3wbgIdfeDj3RETVkvQP/Me2gD+HZbOvOQw32NTLMP780p9za9MwHntx7AWZ8/XXg+krfY3Gtpbhp6Rtb9meV/yUkT++IATGp+5wfLu7XUREpAgouSMiIiIvK3EnznV3X5dcGrsv3sf77n0fnZEcCuiWz4Cho2l6D0PvKKZ25eiJvU/kHeNUjtw5cOLAyDsNo6O3I+t9juPQ2ZdfweO0kT9DR1Z17wOnMNPtREREvKbkjoiIiLys/HDdD3nx2ItYBkbOdPZ18rlHPzfywcZAxaz07U0Pg5PfFKqh1jeuzztGPgWZ89Eb66Uv3pdXDItlR8uOjPdtbN6YV2zIMDJo/IL0ndpOXXJMRERkNJTcERERkZeNvcf28uUnv0x3tBu/8XPOxHMIBUL0xnr53bbfsWr/qpGDVJ+Xvq3pIYh1edrWPe170raFAiEqghUZL+XB8rT928JtnrYpV4+88EjG7WaY/zK5b/d9GbfnU0y534nIidSC0/VXgD+UulPjgxDrHjnYKOspiYiIeC1wqhsgIiIicjJYa7nxnhuJxNypNkF/kN9c8xsu/uXFAIRjYa7/3+t5/pbnCQVD2QPVXgCH/gh2UO2dIytzq7szCsakJjwMhu++6buUDi3oPMgnH/okvYNWeLLWEo1HCfpPbu2Yoz1HKfGV0OcMjN557YzX8uZ5b856zNpDa3nkhUeSRaR9xpd19E+mEUkBXwCfyf69ZTQeTRmtBbD3+F7OmnCWe2PiRWCGnBofuAte+b2sMZOuOZy+7XeZE1YiIiKFoOSOiIiIvCz8YvMvePbIs8RtHJ/xceW8K1lWv4zPvfpzfHfNdwnHwhwNH+XWJ27le28a5gN91dkQCEF0UHIn1gmtq6H+ck/a2tXXlbZcd2VpJR9f/vFhj/vOX7/DrrZdyduhYIjnjz7PkolLPGlXrtY3rU9J7FQEK/jQsg/xoWUfynrMoy88yuoDq+mIuLV2HOtkrRl0tPdoyu3Kkkrufe+9nD/1/KzxP3jfB1OWV68sqWRH646B5E71ueAMSSZF2qBlFUy5ImtcERGR04GmZYmIiMgZr6mzic89+jm6o+4Um1J/Kf9y2b8A8PkVn0+OkgnHwvxk409oaGrIHmziCoj3pm/f8yOInkjfPgbPtT6XNs1qeuX0EY+bVzMv5bbB5L2q1FgMXSkr4AuwoDZDTZtB5tfOJ+bEUrZtbt6ctp+1Nq1eTm+sl+VTl1NdVp31cuHUCwn4Br7X7I52s+7QuoEgvgDUZJhyt+c/IZpf8WYREZFCU3JHREREzmjWWm76403J1bEMhktnX8riiYsBqAnV8IkLPkFZwJ1WFY6Fue7u64jGo5kDltRAxez07Y0PwpDkxFhtb9meluhIjjAZxtmTzk6pX9Pd183Ww1s9aVOuHOuk1QuKxCPMnzB/2ONmVc0iEk9dnep473GOhY+lbDt04hDxIcWrQ8EQVWVVw8ZfVLcoJWHmWIeV+1em7jTt7eAbMr2u8UF3RTQREZHTmJI7IiIicka79S+38sTeJ5LJEoPhWO8x3nTHm5KXjU0b6YsNTMl56fhLvOvOd2UPOu1tgD91m43Bru/lVoB3BA1NDfREe1K2nT3x7BGPmzdhXmoCA4e1jWvzbs9oPN/+fMoImX6TKiYNe5zf52dyRWph4vJgOZsPp47e2di0Ma2G0Oyq2SO2a2HdQqxNrbnz7JFnU7fN+ZsMR1pY/3FPfq8iIiKFouSOiIiInLF2t+3mm898E8cOrIrk4NZyeeylx5KXp/Y9hcOgfazDA3se4P7d92cOPPVKCFakb9/1PU9WzdrQtCHldkWwgnkT5mXZe8Cc6jlpiZVsy4kXyqbmTWmFjaePn55WIDqTof/GcCycNkVuXeM6OiOp06TOmXTOiLHPqjkrLWEWc2I0djYObKiYmXlq1pG/JFZE60m/T0RE5DSg5I6IiIicsS69/dK8jn/PXe9JGdGTNPE1mevuxMOw/qMQzS/Bs7t9d8rtgC/A3Jq5Ix43t2Zu2nSu9nA73X0nb9TJ2sa1dPalJl8W1S7K6dil9UtTbvfF+1h1IHV5+pX7V6asehX0BdOOy6Q0UEpteW3KtqA/yMamjak7LrgFApXpAdbcBF0vQpYVvERERE4lrZYlIiIiZ6S7d9xNc1dzyjaDocRfkvWYqBNNGeUTiUf4ypNf4VtXfCt1R38Z1CyD9nWkOXQftK+Fute6q2qNUmt3a7I+0OB2zamZM+KxM6pmpB1bHixnZ9tOlk9dPuq2jMXq/atTbhtMTskXgCUTl1AeLE8ZYdPQPDByx1qbViA6FAyxsG5hTvHPqjmLlu6W5O2uvi7WHVrHOxa9Y2CnGe+E9TenHxzvhSeugDdvhJLa4X+3udZesg70HISeRoi0Qm8rRFrc271HwImCjbsXE3CLPvvLIDQNQlOgdCKUTXR/jpsDpbUjP6aIiJyRlNwRERGRM86JyAk+9tDHUraFAiHufe+9XDjtwqzHNXU2cf5Pz08p7Puf6/+Tm5ffnD5yZvYNcHwbxDNM1Xn6HfCG1VC1yP0wnkmW0T07WndQFiijb9AIkUgswvTxI6+WFfAFqAnV0NbTltwWd+Jsb9l+UpI71lp2tu1M2TauZByL6nIbubOgdgFBX2o9ndbuVjojnVSWVnKg40BaMWXHOiyszS25s7R+acry6hmLKgfKYf4n4PkfpY/O6j0CDy6BFbdD/RXgLwffkIHw0U7o3pe5AfGIO73r8BNw5El3JJDxQ2kdjF8I486CyvlQ/wb378ZXmvgZcEcMOb1um2Ld0LETjm2Frpegcze8ZVvmxxQRkZcFJXdERETkjHPLn26hqy81eXLupHN507w3DXtcTaiG68+5nv/e9t9EHXe1rEg8wg3/ewNrPrwmtW7MrBtg8z9kDhTrhr+8Dt7wNIybC8FB03wcB5wwHLwr46HPHnmWSCx11aja8tqMRYozmVk1MyW50x3tpqG5gQ8s/UBOx+dj7/G9abV1jDEjLoPeb0HtgpSkFrgjj7Yc3sLFsy6mobmBoC9ImHDy/nA0nNOoJnD/BkKBEOHYwPHbWrZhrU1t9zm3wgs/yRwk1gmrrnETMPM+ClOvAn+pOwqn7a/w/E/gQObfLfdMdveLdblJpIW3wIJPQ9kkd0qfCbjbTQ6VE5zYQJFnfwiGGZEmIiJnPiV3RERE5LRhLbS1QUsL9PVBNJp6icchEIBgMPVSVgZTp8L48fDUvqe4e8fdKaNvKoIVfPuKb+fUhttefxu/3/H7ZHInbt2RLz/b9DNuPn/QdJ2yOph0CRx+PHOg6An40zKY8S5Y+k132oy1bgJg8z9kntKFuxrU0CXBZ4yfkVPbwU2QbGrelLJtQ+OGLHt7a1PzJvwmdRWxcDTM/Nrhl0HvN2XcFOI2dWROJB5hU/MmLp51MWsOrUmr5zOxYuKwU+0GW1C7gBJ/SUpyJ+7EOXjiIDOrZg7sWFINr/gabP0yxLPUKzr8Z/cCblLG5jAVK9oxcP1NG90CzoHE6mb+0pz+DUm+AJQMv/y7iIi8fCi5IyIiIidddzc88QRs3QoNDbBvHxw+DBUVMGcOzJoF06bBpElu4qakxL0EAm6Sp6/PvfT0QHMzNDbC3r2w91APsU/cQM+QVY3mT5jP62a9Lqe2zaqexTsXvZO7dtxFLPGBvTvazecf/TxXzb+KaeOnDey86PPQtmaYFbIsHLzbvWDc2yMYXGOmX67TjsBdMt1v/ClJkl1tu3I+Ph/rGteljZgqDZRSXVad0/HGGKZVTmPv8b3Jbb2xXlYdWMVnXv0ZVu1flVJMGdzfba4W1i1MGxkU9NrFLFgAACAASURBVAdpaGpITe6AW1h5z/9zp06N9HvLJbEzVO9hKB95qh0A99S7U8KG5YMb4iPsIyIiZyold0REROSkOXQIPvlJeOwxN1nT0wMrVsA3vgGXX+6OzIlG3TIm/UmdkUQi0NvrDor52pqv8sMNqR+Cy4PlfPuKb+e0FHe/r136Ne7ddS+x2MCH9p5oDx954CM8fOPDAztOeSMEx+e4/PnIiR1r4cWjL6Zs8xs/SyYuybXpzK2ZS3mwPGWESzgapr2nPW21KK+tPrA6Lfkyq2rWqGIsrF2YktwBd2l4ay3bWtLrypw3OcPS5VlMrZyatppYV6SLtYfW8s7F70zd2ReA1z8Ejyx3p2J5oXIh9BwCHPjLZTDtajdBOGF5oq5OL5hgYmpW7n+vLmfkXURE5Iyl5I6IiIicNL/7HTzwgJvE6E3Uqr39dpg9ewyfZRNKS90LwFsXvQX7s//nZo0Spp3o4Ypbh6+1M9Q84L9eAZunDN5qec2jz8CNgzYZHyz5Emz5YvbpO6NwMEbatKbyYDlnTTgr5xhza+biG1KzJRQMsaN1B5fMuiTvNmaTaSUrYFSJKXCLHj/64qMpSaKmzqaMo4/Kg+WcO/ncnGP7jI8Z42fw0vGXktscHJ4+8HTmA8YvgEv+CCuvdmvi5KNsMly90y3C3boaDv8Fjm12V+DyBaBsKoxfiFN5FrakDp+/DOMvc1flWvqtRCHlHven0wc7v51a8Llscn7tExGRoqbkjoiIiJw0f/u37vSrO+4YSO5cdRV8/ONwzTUwebK7PRZzR+8Eg+5Pnw/8fvdnPJ6oSewMjPSx1h3lc9H0S7n0r5VwJMMKVqP0/mfdS4rJGZa/nncz7Pw36Mk/ubOtDwL+AAwaXGKMYU51bgWDAeZUz0mr2dMX72PbkW0FTe4cOnEobSUrv/HnvAx6v8UTF1NRUpEyvas8WM69u+5NS3wFfcFRTVkDWDRxUUpyB2DbkQxFlfvVXwav/AFs+lzmldFG4i+Hme92V9gCqHmFe1nwCfe2E+f4iRf5y87f85edv6ft2J+Y6IcaH4QCAc6beA7nTT6b6VWzMb4g+Erc6Vyv/b27BHr/cuhB1d8REXk5U3JHRERETpoJE+B734N//3e33s62zWF2bOngiYccfvXjIG3HyyirCDF9OsyYYamrS9TbCVqCQTfBE41BLGqSdXeaD8PBA4bmZodYJMz+w4dHbki2YUJ25KlTafwl8Opfwcq3je3D/yDbIu70r8EisUjOq0EBTKqYlJZkCcfCbGgqbFHlTc2bCPqDKcWKK4IVOa+U1W/+hPlpI4+i8ShP7H0irZ5PJB4Zdfxl9ct45PlHcAZNY3Ksw4GOA8yqzjKFbP7NUFoLaz/gjuCxOda28YdgyRfd1beGaO5s5scbfswDex5gR+sO4k4cB4eAL8Blcy6jqbPJHQnVuoWS3c9R6i/lirlX8K7F7+K6udfhG7oEu4iIvKwpuSMiIiInj7XQuhrf3jtYduheloU64OIKuOYiqL8CJizFls+is6+Ovlgp0Ugf0T5LNOoQ7YO4A4GASaySZQiWGIJlpZT5u6gItLrFb+0VuS0l7aX6y2HypdD86NiK6yasi5YQc1IL/losE8sn5hzDGEP9uHoOnjiYsn3oClpe29C0ga5IavLFYkedfFlQu4DeWG/KtnAszObDm9Pq+VhrqR9XP6r4i+sWU15SnpIoCvqCbGzamD25AzDzXTDhfDeJ1713+DpLgXHgL3OndE187cC/Ixrmoecf4iP3f4TjkeMZD405MR578bGUbX3xPvrifdyz6x7u2XUPN957IzeddxOfX/F5zp107qjqSYmIyJlJyR0RERE5eV78OWz4OGDBJkZOXPqIW1AWwOfHAOOTB+R6qlLlXirnedjYUbrgx/DgIoiPJbnjg3Fz2doaB1KLCdePqx/1h/fZ1bPTkjsvHH0h+9QjDzy9/+mU0TDgJmXmTRjd76S2vJaAL5C2qtWx8LG0fWdUzcAYg7XQ1QXt7RAOu9P64vHUn8a4q63FOxcQj6cmiTr7OlnXuI53LXkXHR3u6m2NjdDW5sZsa3MvkchsQqWbWDr5MVZM+imLqx8l5pRgMRgg4OvlYPf5/LXlY2w8/E6OPzDOTUTWHKb5lR/n4RceTvl3lfhLqC6t4fKp72Rm4AJ6uv3utMO4m8jsv94VO8Zz0YfZ3bcSgDh93L71dm7fejuTyqbz8fP+jn+87DM5FSAXEZEzU05nTMaYNwM/BPzAz6213ypoq0REROTU+ev7oGMnkPhkWVoLr/we7mpPJjEqJvHTBAbdHpw0sInFoRxwYolpLBZ8QbcGiY0nCtRaaHwQqha7h8WNO5XFl+UU5dnbYPs/D99+fwX2PV20tsKBA+5S6f0f0lta3Muvsxx6yy2ptx3HTRbE41BVBVOmQG2te6mvh+nT3YvfD1TMgIvuhNXXjrL4roGSamKve5BDW9OLA8+umj2KWK7FExez6sCqtO2NnY1MH5/j8tuj9O4l7ya0ep07Vy7hnJYY5SUVo45160WwcvbAbQu8VOfHmb6A7m63LlNfHxxr+CBvuM/9HUyb5l6mTIGJE90i24GAO63P73cHjcXjcBZns6TqQtp6jxCPuTWb+rorWPn9jzDjQ3DkCIRCsHw5fOIT8PrXw6RJboy+PojFAlj7FuAtdMe68HfvxsQ6sf5y+kJzmFA6kauBqxl4/NYeH//nz1VcVHUdhxrh6FHoPhHE/9yNnDv59dQtNtTNhJkz3X9LVZV7bP/FrTX1WY6FT/A/u3/K7mPb6O2F7m738qdH4nxqOdTV5fUrFBGRImbsCHPLjTF+YA9wBXAI2ABcb619Ltsxy5cvtxs3bvSynSL5CR+BQ/e6H0CcmLu6RNlECFYnPnTEgMT8eeNPXa025bOKATPoA4u1iQ83fvcDi/FBxy7wl7oFD42Bijkw5YqT9k8VOVmOho9yoOMArd2ttPW08c3V36S1u5WuaBfhaJh4DjUpgr4goUCIytIqlk5axg3nvI9J4yYyeVwd8+vOoixQdhL+JZLmd0NGdkw4H96c4/t6LskXXzlc9ggc/F9o3wCdL0C0AzvhfGzVuVA+DcbNgYpZUFqLMYHEa2wikWTjGBtzX7+dKDx8TjL0kztez3ce+jv+uu8qenvd5dQ/8AG4+mo4+2y35o/fD75p9fhaUpdMdyZN5sTu9Ho9/R/Q+ws7j1jq5MDdsOb9uSd4gtXwxjXs7LMs/9nytJo7Hz3/o/zk6p/kFivh+2u+zxf/8sWUUSKVJZX84d1/4Mr5V2Y8JhqPsq1lG6+cen7G+w8eP8D08dOHH/lTX+9mRwqggm56KKe0FCIRuPhiePppN2HT0+P+roPBscXesgWWLXN/1/1JoK9/Hf7pn9zkTyzmJovGUubGWrjzTnjf+9ykUWenu+322+HGG93bwaB731jix2JuArKycvTHSmH0F3sfPHLMcQZKelmbXt6rv1uZRJ68v4h8IDDwsyBllvb9PvFa5UA84p7Tls9wE/B2UGIeA/gGzosznSvbxP+s4270+d14JgDhZnB6wVea2GZg9t9kT+QXCWstvbFeOvs6icQijC8dz7iScfh9/pEPLna33Qb/PML7/Vh99atufMnIGNNgrV2etj2H5M4K4DZr7ZsSt78EYK39ZrZjlNw5M11/PTyWmALuOJbqamhoyLDj4DenLLEG/uxMypubtfCzn8G3vz3w5gbwzDOwaNHY296156eM2/jR1I3XnoBgjmdCuX5Yec8J3KRP4tKfAEr+HG2hzv4nwecea/vfMAfHsUMey4zwOIPuN76BC/3X/UMuL/N5/OtuhqP9r2cWgrVwwY/I/Bzn8lwN/oN3oH2du61lFbSshrJJA9NK5n4QguMzRhm1WGdqHRB/KKUOxFj4v1KO489zaeBh3FL/e9447b0Dj+d3R0v06z9RHnyynM3gP+P+k+b+bd3d0NEZo9s5Tk/sBH1OL0sv6KHbOcqx8DGOho/SEenAZ3xMCE1gQtkEakI11JTVUBYsIxQIUV1WTWVJ5RlT4LTyG7V0xY8mb4eMeyk1UGagzOde9wElviA+Ywj4fBgMAeMjjsWxDo5jiWO5v76PusR5bo8DN7eV0VSzgoMnDrL32N5kIrDOD9P8MC0AkwJQAgTNoAvgNxCzELUQxf35zToYn3jq3/7de7l/0zvw+90PVZWVcOKEe180OvYP/6O29w5Y/1F3yepsiU5fqftlwBtWQc0r2NO+h1d9dxFRk/rH/Nt74B3pq4APa/00eOP7IDboT9JYuO+hGhY8dJRg0LKu9Qnu3P1rthzZTFNnE8d63WlPzd+B+iELfx2ugCl/DwbDlMopzK6azSWzLuEzr/oM9ZWjq3kz1mLWn/403HUXHDvmJnKmTLF885vwmtcYamsHVlmzdqCPD74Mfb3ofw0xxv27iERg7VpYvRqeew7273fvnzfPHblTV+eOqpk82TKhFoKJD91+v3Gne8VTP9B3dLh5rsZGWLkS/vxnqKhwp48B3H8/vPWt7n6hEHlNqfrlL+HDH07d9sQTcOmlY4+ZybFjboJ0sM98Bn7wgzwDO1H3izcbT1z6z6MYOO/pTxi4G4cJNmif/nMoY0ieUyXPb3wDfTAPH/uY5b/+K/Vveix12bN54LnH2XBgKz19vXREOnj8wH30Ob1E431EnShR20fUcS8Apb4QESeM3/gJmBKCvhICviBBXwmlvlJmVy7i7JoLKAuEKPOX8a2ez6U+4FkfgVf9NLfG5TiSkvcOU5/KI9Zajvcep62nje5oN73RXo71HqO9p532cDvtPe1EnShBf5DaUC215bXUhmqpKashFAxRUVJBbaiW6rLqZAJ72XfeypaeBwvW5t+/eh/1ZbPYvx82b3a39b9W3XILzJ079thxJ46ZMgVfS6s3jR3iD8vhS5f5aBlfQveQGmmDDfd+ksm4QBmTQjX86LWf5MpZrwKMm3z0lbj91VfifvFTPtW7f0wRyie5827gzdbav03cfh/wKmvtp7IdU8jkTvnfzyE8bl9BYgMsePLX9EVKicWhK+KwcMl4PnH9koz7Jk8UsrzBGAwl/kByxYfDTdtYeejvAIhHLYc4TqymhGCoHF/iDcdA8gWl1Bck4kQB9wUL3Mey1ibz56+tPy9538Hnt3NP3w6PnokMfr4aDg18GKytdYe5e2boN8Wv/C4s+rwnob981x1847n3A+5cxP4PJ0EGPjSUGT+lgSBBXxC/8WGMwSTm0PuMwbEWJ/Hbvr+ug1r/wO+9LeqnLjjk5P0GD9/Z32XgHu/CDbXktf+XeLAcgJ54nLnzarjhqkXJk5OB34xluBOr/i2hQAkG95NcdPd/8+H1XylY+39z3VnMvqjNPcN2osQDYRZf+itKK4Z50R/mdc8YH75BS+2ae66ismbQScm4ufC2F3Nr3AgnPdE4BId+sfOa38LsGz2J/6kdi/m/JTtzizUG//bA+2louBKDJY6fGH7+9kfLqKgJ4n5jZ7CJBKHxDcr6YobkIAc+cVnH/cRlrMOTN/yM2yjMN0LHKnz8cLnDbSsLEp4fLj+XL1zWDLiv205JJwSig/7ZqX+DfhMgnlaE1yR7mzE+akonuK9JxnDR8bex62gbBkN3l8Ox2ueYNK0Cv8+XSKybxHuJ+yoW9JUQdfrcVzBr6f+v/x2sOljLzNCC5PvZ3Y8ehcpm6JwKXZOYNXU8X/joRGZXz2ZOzRwmV0zOOnrDWsvR8FH2Hd/HvuP7aO5qpqO3g/Zwu5tACB9j0+HUwr7+ONR3wezj7klgTRhqeqFs0FNigc5SOFYGR0PQWAl7a+B4GSl51Wv8pXwqvIKVu17Hql0Xc/DoDHrMbM4+t4Rzz4U5c9ypO5MmuR9Sy8r6P6C7F2MGPqT3L7N+/Lg7levwYff+++5L/Td/9rPuh/OhQn07mNH+JcaH/4zPRjCJejRxSsH4aBn/UZpq/pGYf6BY8qxX11NPYUa+NFeW8dVP1bExFGaP00E3Q//mxmbGuHpeM/kVvDH8Kpa0u+d/sUgY6zic89abKJ/qTrkzifOhkqmvzhinr2ntsI8TXPMuTG8jTcemsKtpEfvbz6Jlzs9obnaTKP2jIyoq3GlN/b/P/tFWgxPC1rrJnOPH3alWgQBcb8/nHXdlLjptgTAhjlFDlGDiNS9AHH/yuj9xK0As5XoVHVTSydF9nfxp1Tj++Ec3eXTwoNvWyy6DBQtg9mw3eTRlykD7+y/utKyB5FEs5k4zbGpypx7+58qvsut//xGM444yxnD/HwO84XJf4rkn+dILmUeNDN429PYfvv8pFvrWJJ+LuBPnVR/6OcY/KFs6JObQd9q0VwwzcCXw2NLU+xZ+Fs7/fsbfxWjt3vMCb7ti4MOnYy3vuXEq7/9AdTK5N1SuXxYAvO+3b2XD1mnucw9gDW85/zym1NSA9WGsD6wfa93XY/d12CQfx30ttSnx+1+fjc/h5+3vh0Bq/SkvVX2zhY7IRIxxKA1EeMOlYR74Y9T9QsgZ9BMGnQYmvrBM3k78gVngzxdDXzsAD+45n7f+c+pnwvXr4YILvGn75d+Zy8UP7S3Ye3np2z9I31mPQaQSouWYyhYWzhlHdVk1VaVVVJVWMb5sPBXBCsoCZfiNn0g8QjgaprOvk47eDjoi7uV473HK/GWUBErojHTS1dfFpJ88Svvxgdf/C1eU8+Of1iRv55MkvGf1N7n2w7emJVa88oV/quJ7gQ7A/bKnBBhXMYVZ1bOYXjmdCaEJVIfc5ynoG3id6HP66DjwMMdb/kpbHBpjcCAG3Q5ELPT/pf8lcC6Xzdk28IC+UrguexJp1Ar82So58mjHv8LWIaslevAZMZ/kzrXAm4Ykdy601t4yZL+bgZsBZs6cef7+/fvzbnQmP3nl2Xxsc9YZYXm7ja8W7MPEjy6bwy2X7B15xzG6um0pVz63hU88UZj4O99uiK2xlMahJAYBx72URyGUuD0cx0BvAMIB96djoC8AET9EAnDb3yzE+OLg+LDBHibWl7F49vJEcsU38NMYfMaPY91Ui3Usr+rdwqv7tmd97Ia9r+SKbz2JKXFHQRjj9rkbE5+h+09iqhdnHqbfsWtgmH6mE6Kbvv5b2ttvY7F9kaCFPbVQNW4CpdZPEEMpPoLWEHQMAXz4Hffb1Lgf3jTpBG+ZeGLY527+ytcTrduG3wkQAIIVHZw1cRZ+4yPoD1Dicy9BXxC/L4Ax4DgODg5XcYC3+g4NG/+2Gwv3d//TcxazbfGV/acpANx4/StYuGRach9rYcLF1+JrSy2W6dTV0Hvn1ZQ335E1/p2H63nPM4cL9gIduOILxNsXuF95AzWVZXzrlguTH4JNYvTZ+z58MeUd7SnH9lTXcscvngYGvh3uH8DVP0Pwd//1Ud4QX03QcT+0HqmAUBTKY+7Psph7KY9CSRwwbh/q70fhoPuzJ+hum98OAQt9fiC4nOc6ariq73ECDhyqdPcJxQbilsWgNAZlcQjG3b/LSAB6E/2y/3q4BGIGFra7+8R88Mb3XcCMmYNf0yxc9gSEprg3TeJEb/YSODLkm6PacviP4ZeMvroJJg2aJRkqqWT5/GsBmxjE5nMvibPLwX3zvO6tLOvdkrxtBo2E8BmHvqiPW595j9unbICA9bHismm86nVLqQiWUeYvHX7Q2ku/xnnpdnqse0ISteAAvda9/HT7hfzf8euH/ffl418emsQ/bmgpWPy2C86mdsMOYgTopYwwIfooIUaAKEGiwXLiwRAEg9hAAIzBYrDGhzU+jHUwWIx1P02bRGETf7SXQDTM3OObCIwfoQ5Lpuk9kye7GZbhND4Eq64hOeIRYMVvsNPeRk8PtLcb2trcqTDxuElJ5MTiBrvvTgKN/4PfF8fvixPwx/D74pQFe6kd185vv76C247/dnRP6DTgdUAdEAOagCeADC/9v7r5AxzrrsFaQ2+0DFu9lHOvujZR68VtJwxM2YBB0zn62rF9x8A67hc/1rqjp2JxcKJ0dO3n0cA7U1I6/uqzufScD/GW+W9hYe3C4adcPXsbkWf/mVW9cF8XvBgduMsAV7VdzCfOG1Ln551NA68J/bL9bh/72PCjADZNhKZWkjWb/T649itQUur+un2AL/E79w0aeeozcOJx6HwsQ9BB/4bn07f5jZ9QMEQoEBr4GQhR4neH2USdKOFomHAscYmG6Yn2ZJyWau1X06YwRAlwhMk0M4XD1NNGHTECyUuUYDKJFCBGkOige2OUEmEyR5hyyXb805ope8R9TfdZ91IRdd9L/DatOWkc476XdAfd645JvAcEoOPjy1ixcHPqAbl+QMlhdMc3Pvte/qnrD4N+j0B5CAL9GS6f+3vMNC/ydd1wcfZPsKsOzeaS/5N6/v2DH7gjjrzgvPQb7N/fBPcObDMM/CmOKpbJ8NXZG4J0P16W8jfhBEqwJaXEA6XYQBDHBNznx58YkZRgjcGknLja5LxD48TxOTHmfmbz0EfMaOgIjOFGX/SbGa3knDtv5K3PD7ShbvlsJi2fSX9pAzto1LlbHD17lnHgfoMx8ERbO82lzxJwggSdIAbDRz5/LtOnTKYiUIbfF2DgGR0ysv2lX8Pe24kn3sc7LTjWLdIQthB2YMnGCZRtOTpwmN8Hl1470CbfoIzpkCQdtduhdvgv3Qt5/r0nNI/blv0zjjPw9/CxT1fx+jdUDeyUNhuAgX/bS7+Cvb/OGv/3a97L1+77V0rG1xPw9RH0R/jG1/qYd1YcQxy/iWNtPPGF08C3xf3XjbFY6547YGHytkvwxwbOo7f+aC7nrXkpn6dgWO//RjWlpd1g3XOF2pp6zpn95kTb3Db5DLzj2t8QOjYwSj1cE+KFXy3h3O5M01cGqX0VvGn4LyzyoWlZIiIiIiIiIiJFLFtyJ5fiABuA+caYOcaYEuA64H6vGygiIiIiIiIiIqM3Ynlya23MGPMp4FHcpdB/aa0tYGEXERERERERERHJVU5rz1lrHwYeLnBbRERERERERERklM6MNVtFRERERERERF6mlNwRERERERERESliSu6IiIiIiIiIiBQxJXdERERERERERIqYkjsiIiIiIiIiIkVMyR0RERERERERkSKm5I6IiIiIiIiISBFTckdEREREREREpIgpuSMiIiIiIiIiUsSU3BERERERERERKWJK7oiIiIiIiIiIFDFjrfU+qDGtwH7PA7vqgLYCxVb8Uxdb8U9dbMU/dbGLPX4xt73Y4xdz24s9fjG3vdjjF3Pbiz1+Mbe92OMXc9uLPX4xt73Y4xdz209G/FnW2olDNxYkuVNIxpiN1trlin/y4xdz24s9fjG3vdjjF3PbCx2/mNte7PGLue3FHr+Y217s8Yu57cUev5jbXuzxi7ntxR6/mNte7PGLue0nI342mpYlIiIiIiIiIlLElNwRERERERERESlixZjc+anin7L4xdz2Yo9fzG0v9vjF3PZCxy/mthd7/GJue7HHL+a2F3v8Ym57sccv5rYXe/xibnuxxy/mthd7/GJu+8mIn1HR1dwREREREREREZEBxThyR0REREREREREEooquWOMebMxZrcx5gVjzBc9jv1LY0yLMWa7l3ETsWcYY540xuw0xuwwxnzG4/hlxpj1xpitifj/7GX8QY/jN8ZsNsY8WIDY+4wx24wxW4wxGz2OXW2MudsYsyvxO1jhYeyFiTb3X04YYz7rVfzEY3wu8Xvdboz5H2NMmYexP5OIu8OrdmfqS8aYCcaYx40xzyd+1ngY+9pE+x1jTF5V6bPE/07ib+dZY8y9xphqj+N/PRF7izHmMWPMVK9iD7rv74wx1hhT53HbbzPGNA76+3+Ll/ET229JvO7vMMb8m8ft/8Ogtu8zxmzxMPZSY8za/tc0Y8yFHrf9PGPMmsTr5gPGmPF5xM/4HuVFvx0mtif9dpj4nvTbYeJ71W+HPT/Ip+8O03ZP+u1wbfei3w7Tfq/6bbb4effdYWJ70m9NlvM+L/rsCPG96rfZ4ufdb4eJ7VWfHfacO58+O0L78+63w7Xdoz6bre1e9dls8T15vx0mvpfvtymfpbzqs8PE9+wcOUt8L8+Rh8b2pM9miz9oe97nyFna79k58qhYa4viAviBF4G5QAmwFVjiYfxLgFcC2wvQ9inAKxPXK4E9HrfdAOMS14PAOuDVBfh3fB74HfBgAWLvA+oK9LdzO/C3ieslQHWBHscPHAZmeRhzGrAXCCVu3wl8wKPY5wDbgXIgAPwZmO9B3LS+BPwb8MXE9S8C3/Yw9mJgIfAUsLwAbX8jEEhc//ZY2z5M/PGDrn8a+IlXsRPbZwCPAvvz6WNZ2n4b8Hce/T1min9p4u+yNHF7kpfxh9z/XeArHrb9MeDKxPW3AE95/NxsAF6XuP4h4Ot5xM/4HuVFvx0mtif9dpj4nvTbYeJ71W+znh/k23eHabsn/XaY+J702+Gem0H75NNvs7U/7747TGxP+i1Zzvu86LMjxPeq32aLn3e/HSa2V3026zl3vn12hPbn3W+Hie1Vnx3x80iefTZb+z15vx0mvpfvtymfpbzqs8PE9+wcOUt8L8+Rh8b2pM9mi5/Y5sk5cpb2591nx3IpppE7FwIvWGtfstb2Ab8H3u5VcGvt08BRr+INid1srd2UuN4J7MT90O5VfGut7UrcDCYunhZTMsZMB64Cfu5l3EJLZNcvAX4BYK3ts9YeL9DDXQ68aK3d73HcABAyxgRwEzFNHsVdDKy11vZYa2PASuCd+QbN0pfejptkI/HzHV7FttbutNbuHku8HOM/lnh+ANYC0z2Of2LQzQrG2HeHeQ37PvAPY42bQ3xPZIn/ceBb1tpIYp8Wj+MDYIwxwHuA//EwtgX6v92rIo9+myX+QuDpxPXHgXflET/be1Te/TZbbK/67TDxPem3w8T3qt8Od36QV989Cece2eJ7ttTbPwAAB/hJREFU0m9Har8H/TZb/Lz77jCxPem3w5z3efVemzG+h/02W/y8++0wsb3qs8Odc+f9flvIc/phYnvVZ4dtuwd9Nlt8T95vh4nvSb/N8lnKkz6bLb6X58hZ4nvyXpsltid9Nlv8BE/OkU+nz8nFlNyZBhwcdPsQHp6knCzGmNnAMtxssJdx/Ylhji3A49ZaT+MDP8D943c8jtvPAo8ZYxqMMTd7GHcu0Ar8KjFU7ufGmAoP4w92HWN8w8rGWtsI/DtwAGgGOqy1j3kUfjtwiTGm1hhTjvttxwyPYg812VrbDO5JLzCpQI9TaB8C/uR1UGPMvxhjDgI3Al/xMO7bgEZr7VavYmbwqcSw2V/mO5w4gwXAxcaYdcaYlcaYCzyO3+9i4Ii19nkPY34W+E7i9/rvwJc8jA1u/31b4vq1eNR3h7xHedpvC/X+l0N8T/rt0Phe99vB8b3uuxmeG0/77ZD4nvfbLL9bz/rtkPie9t0hsT3rt1nO+zzrs4U+r8wh/pj7bbbYXvXZTPG97LPDPDd599sssT3rsyP8XvPus1nie9Zns8T3qt9m+izl5ftsoT+rjRQ/n/fajLE9fJ9Ni+/x+2y256aQ58gZFVNyx2TY5unolEIzxowD/hf47JBsZN6stXFr7VLcjOmFxphzvIptjLkaaLHWNngVM4PXWmtfCVwJfNIYc4lHcQO40xl+bK1dBnTjDnv0lDGmBPeF/y6P49bgZvXnAFOBCmPM33gR21q7E3cI5ePAI7hTHWPDHvQyZoy5Fff5+W+vY1trb7XWzkjE/pQXMRMJu1vxMFmUwY+Bs4CluMnH73ocPwDU4A6L/nvgzsQ3f167Ho8Ts7jfhH4u8Xv9HInRgx76EO5rZQPutI++fAMW8j2qkLGHi+9Vv80U38t+Ozh+or2e9d0Mbfe032aI72m/HeZvx5N+myG+Z303Q2zP+m0hz/tOdfx8+2222F712QzxX4GHfTZL+z3pt1lie9ZnR/i7ybvPZonvWZ/NEj/vflvoz1KnOn4+fXa42F702UzxvTxHHqb9hT5HzqiYkjuHSM2UTse76SkFZ4wJ4r7B/7e19p5CPY51pxw9BbzZw7CvBd5mjNmHOx3uMmPMbz2Mj7W2KfGzBbgXdxqeFw4BhwZ9c3A3brLHa1cCm6y1RzyO+wZgr7W21VobBe4BXuNVcGvtL6y1r7TWXoI77cPLkQuDHTHGTAFI/Bzz9JpTwRhzE3A1cKO1tpBJ5d+Rx/SaIc7CTQpuTfTd6cAmY0y9R/Gx1h5JnAg5wM/wrt/2OwTckxgqvR73G5G8Ct4NZdzpjtcAf/AyLnATbn8FN+nr6XNjrd1lrX2jtfZ83JPlF/OJl+U9ypN+W+j3v2zxveq3ObQ/r36bIb5nfTdT273st1meG8/67TC/W0/6bZb4nvTdLM+9p/02EXPweZ/n77UFOq/MGt/L99th2u7Je+2g+P1fwnn6fju4/V6/3w55bjx/r83we/X0vXZIfM/fb4c8917022yfpbzqs4X+rJY1vgd9Npe259Nn0+IDd+Bdn83Y/pNwjpxRMSV3NgDzjTFzEqMkrgPuP8Vtykki+/0LYKe19nsFiD/RJKqTG2NCuAmBXV7Ft9Z+yVo73Vo7G/d5f8Ja68noEQBjTIUxprL/Om5xLk9WLbPWHgYOGmMWJjZdDjznRewh/n97988aRRCHcfy7FgppRIWAjdhoKYKNRcCQWIhFIPgCUtjYWVpoY+dLsBQUrISolUUqK0GN+SNIsLAIoqCtIBZjMRM94u2c3v5WWPh+4PAS4bnJ7j2ZudHb6+Nf/iG/Het80zQz5Xm0SH7vfoimaWbLnyfIk24fPwPkrq6U+yvA454eJ1zTNJeAG8BSSulbD/mnRr5cIqi7KaWtlNJsSulk6e4u+QKfnyLy4ddCZM8yQb0dsUqehGma5jT5guhfgh/jIvAupbQbnPsRuFDuLxC8cTrS3QPALeBuh6y2Oapzb//D/Dc2P6q3lfyQ3o7Lj+puZewhva2c25DeTnjudO5tJb9zdyvHPqS3lXVfyFzb97qyLT+it5XsqM6Oy1+Pmm8r4+/c28p5jeps7XkT0dm2/JD5tnLsO/e28loqpLN9v1Zry4/obCU7pLMt+VeiOlsZf99r5NYBDeZGvibIDnnH9GZw9kPyf5n6QT7BVwOz58hvIdsE3pTb5cD8M8B6yd9myqvQ/+VjzRP8aVnk6+JslNvbHs7tWeBlOT6rwJHg/BngK3C4p2N+m/wLbZu803woMPs5ebNrA1gMyvyjS8AxYI084a4BRwOzl8v978Bn4Fnw2N+Tr/e1192pr9bfkv+onNtN4Cn5Yq0h2fv+/gPdPi1r3NjvA1tl7E+A48H5B4EH5fi8BhYi88v37wHXenjOzwGvSrdeAOeC86+T58Md4A7QdMgfO0dF9LaSHdLbSn5Ibyv5Ub2duD6YtruVsYf0tpIf0tvasQnqbdv4O3e3kh3SW1rWfRGdnZAf1du2/M69rWRHdXbimnvazk4Yf+feVrKjOtt6bII62zb+kPm2kh8235a8eX5/olJIZyv5YWvklvywNfKY7JDOtuXv+/7Una2MP2yN/C+3pjy4JEmSJEmSBmhIb8uSJEmSJEnSPm7uSJIkSZIkDZibO5IkSZIkSQPm5o4kSZIkSdKAubkjSZIkSZI0YG7uSJIkSZIkDZibO5IkSZIkSQPm5o4kSZIkSdKA/QT77A04x5d7ygAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABHcAAACMCAYAAAD2tUXSAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3dd3zb1b3/8dfRsiXbiZM4gyQOGZA0IUCBlBloGW2BDgqUUe6lk8uP3sJte/tr7225Xb8Ourgdl45Lgd5bWuhtGbdltEALhJVAQiAbQggJmbazPWTN8/vjyEPWsGN9ZVvJ+8lDSPpa+ugTSUffrz46w1hrERERERERERGRyuQb7gRERERERERERGTwVNwREREREREREalgKu6IiIiIiIiIiFQwFXdERERERERERCqYijsiIiIiIiIiIhVMxR0RERERERERkQoWKEfQhoYGO3369HKEFhERERERERE5LL344ou7rLXj+24vS3Fn+vTpLFu2rByhRUREREREREQOS8aYzfm2a1iWiIiIiIiIiEgFU3FHRERERERERKSCqbgjIiIiIiIiIlLBVNwREREREREREalgKu6IiIiIiIiIiFQwFXdERERERERERCqYijsiIiIiIiIiIhVMxR0RERERERERkQqm4o6IiIiIiIiISAXrt7hjjGk0xjxhjFlnjFljjPn0UCQmIiIiIiIiIiL9CwzgNkngc9ba5caYOuBFY8xj1tq1Zc5NRERERERERET60W/PHWvtDmvt8szlVmAdMKXciYmIiIiIiIiISP8Oas4dY8x04ATg+XIkIyIiIiIiIiIiB2fAxR1jTC1wL/AZa+2BPH+/1hizzBizrKWlxcscRURE5DC2Zg184AMwdSqMHQvTp8MNN0BT03BnJiIiIjIyGGtt/zcyJgg8CDxirf33/m6/YMECu2zZMg/SExERkcPVhg3wz/8Mf/0rxGKQTvf8raoKfD645hr4+tdhzJjhy1NERERkqBhjXrTWLui7vd8JlY0xBrgdWDeQwo6IiIhIqdauhdNPh7Y2SKVy/x6LufNbb4VHH4UlS6C+fmhzFBERERkpBjIs6wzgauAcY8zLmdOFZc5LREREDlMbNsDChXDgQP7CTm+xGLzxBrz97a4QJCIiInI46rfnjrX2GcAMQS4iIiJymNuyxfXY2bcPBjByHIB4HF59Fc45B556Cqqry5ujiIiIyEhzUKtliYiIiJSLtXD11bBnz8ALO11iMVi9Gm66qTy5iYiIiIxkKu6IiIjIiPDAA7BsWf9DsQqJRuH73/c2JxEREZFKoOKOiIiIDLtoFK69FtrbS4uTSHiTj4iIiEglUXFHREREsk2aBMaU7zRpUs5Dfutb0NpaeurJZOkxRERERCqNijsiIiKHsCVblnDyL08+uDs1NZUnmQLx9+6Fm2+Gjo7yPqyIiIjIoUrFHRERkUPYos2LWLp9KW3xkbtO+G23gU9HJCIiIiKDpkMpERGRQ9jalrUArGleM8yZ5JdOww9+0H+vHWPghBPgHe+Ao48ektREREREKoaKOyIiIoewFU0rAFjZtHKYM8nviSfcZMrFfPCDsHEjLFoE998PL70EzzwDp5wyNDmKiIiIjHQq7oiIiBzCXt/zOgBLty8d5kzy+/nPoa3IiLHbboNf/QqmT4e6Oqivh5oaOO00ePxx+NjHhixVERERkRFLxR0REZFyKOeKU3lWm8qnpb2FtoSrnLyw7YVy/msHpb0dHnoIrM3/95/8BK64Amprc//m80EkArfc4m4jIiIicjhTcUdERA5P5V7uu5wrTg0w9qrmVfiNH4D1u9djC1VRhsnTT0MolP9vV13leuXkK+z0FonAHXfA3Lne5yciIiJSKVTcERGRw1O5l/seAVbsdPPtGAwAWw9sHc50cjz8cP4hWXV18B//0X9hp0tVFdx+u7e5iYiIiFQSFXdEREQOUUu2LSFlUwAE/cERN6nygw+61bL6+ta3oLp64HH8fjj2WDfxsoiIiMjhKDDcCYiIiHghGoUHHnBDffbsccN15s6Fyy+HqVOHO7vhsXzH8u7L0USUFU0reM/s9wxjRj2am2H79tztRxwB11wD4fDBxauthR//GO6915v8RERERCqJijsiIlLRXn0Vvvxl1wskEIDW1p6/VVfDl74ExxwDN94Il1wyfHkOtWQ6yeZ9m7uvJ9IJntvy3DBmlO3xx918O7FY9vbrrx98zNpaOP/80vISERERqUQaliUiIhXrV7+CE0+Ee+5xPXd6F3YAOjtd8WD5crj6ajdJb3v78OQ61Dbs2UBVoCpr24qmFcOUTa4HHsh9vXw+uO66g++102XUKPjsZ0vPTURERKTSqLgjIiIVJxZzw62uvx46Ogovpd1bRwfcfz/Mm+d6+xzqVjWt6p5IucvOtp10JjuHKaNszzyTu+2881zvq1KceWZp9xcRERGpRCruiIhIRbEWPvxhNwyro+Pg7tvZCVu2wFlnlSe3kWT5juW0xbOXogoHwqxrWdf/nSdOLFNWTnLC5Lzz7Vx55cBXyCokkSjt/iIiIiKVSMUdERGpKN/8pivsRKODu7+1sHevtzmNREu2LsGS3aXJWjuwFbN27nRPVH+nfAZwv9ef2pZ3Nazzz3dDs0pRV1fa/UVEREQqkYo7IiJSMe6/H2666eB77PR1OPTuWN2yuvuy3+cHoC3RlrWC1nBZuza3iHPkkTB69PDkIyIiIlLpVNwREZGKsHcvfPSjg++xczjZ37mf/Z37AQj4AtRX13f/bcnWJcOVVrc1a3Intj73XEinhycfERERkUqnpdBFRKQifOELuctm91VVBWef7aaMiUbh6adhx46hyW9I9TMnzurm1YSDYRKxBOFAmGmjprGrYxcAr+x+ZSgyLOqFFyCVyt72vveVPt+OiIiIyOFKxR0RERnxNmyA3/ymcHFn7Fj44Q/h0kshmXRDfqyFUAhWrIDPfAaW9O2wMnEiNDWVL+mJE93cNcUYk3/7QJb/KmJl00oSqUTmIQzHTjyWl3a+hMUSS8ZoamtiYm15J00uZvXq3G3HHz/0eYiIiIgcKjQsS0RERrwvfMEVbfJZuNAtbX7FFVBT4+ZtqauDUaOguhpOOQX+9jf40pf61FIGMmlwIQOZbLi/wk4ZPb/teaJJN34tmoiyYPICIsEIANWBalY1rxq23CD3qfH7YcqU4clFRERE5FCg4o6IiIxou3bBww/nL+4sXAh/+Qs0NLghWYVEIq6486MflS/PkWTZ9mXdl4P+IPMnzCfgc511o8nowFbMKpNEIrcH1owZ/Q+5ExEREZHCVNwREZER7a67XM+OvmbOdEui19QMLE5NDXziE3DNNd7mN9KkbZoNezZ0X59SN4VZY2Z1D9OKp+Is3rJ4uNJj167cQty8eZpMWURERKQUKu6IiMiIdsstuUuf+3zw0EMHPwFvTQ38+MeumHCo2rxvc/fS5wBHjz2ayXWTiafj3duW7xy+5dB37YJgMHvbnDkQDg9PPiIiIiKHAhV3RERkxFq5ErZty91+7bUwdWr+Hj39qaqC228vPbeRamXTyu4hWADHTDgGv8/PhMiE7m1b9m8hmS4wiVGZ7dqVO4/0lClu8msRERERGRwVd0REZMS6+26Ix7O3hcPw7W8Pftlsvx/mzy89t5Hq5Z0v0x5vByASjDBn3BwApo+Z3n2bqkAV63evH4702LUrdwjW1KnDkoqIiIjIIUPFHRERGbEeeSR3IuUrroBAIP/tB2qwhaFKsHjrYlI2BUDQF2TmmJkAzG2Y230bgxm2SZVbWnJf04nDtyq7iIiIyCGh3+KOMeYOY0yzMWb1UCQkIiICblWlNWtyt99wg1vqXPLrvcx5Ip1g1thZABwz/hhCfjf2qS3exvIdwzPvzp490NmZva2hYVhSERERETlkDKTnzn8B55c5DxERkSwvvQTV1dnbZs6EuXPz316gI9FBc3tz9/V4Ks6UuikAzBwzk+qAe0ItlsVbh2fFrFgMrM3eNmbMsKQiIiIicsjot7hjrX0K2DMEuYiIiHR7+mlXCOjtoouGJ5dKsbZlLZFgpPv6+Mj47pWzZo2dhe1VVVnbsnbI8wPXI6uvvqtniYiIiMjB0Zw7IiIyIuUr7lxwgZbMLmZl00pS6VT39en107svz6ifQTQZ7b7eGmtlb3TvUKYH5C/uDGbVMxERERHp4VlxxxhzrTFmmTFmWUtLi1dhRUTkMLVxY+62U04Z+jwqydJtS2lPtHdf7z2Jck2oJqtXTyQYyZqfZ6ikUrnb+i6NLiIiIiIHx7PijrX2VmvtAmvtgvHjx3sVVkREDlM7dmRfnzULfOpvWtQL217ovhzyh5g3fl7W3xtHNXZfjqViw7JiVr4hWH2XRhcRERGRg6PDZBERGXHSadjbZ8TQrFm5S2hLD2str+5+tft6daC6e6WsLrPHze6+3JnszCoGDZV8y9iruCMiIiJSmoEshX43sBiYY4zZaoz5RPnTEhGRw1lTU24Pj8bG/IUBcXa07SBle8Y8WWuZNSa7uDN/wnx8vXb9y7YvG7L8uuTruRON5m4TERERkYHr9zDZWvuhoUhERESky/btEApBZ2fPtmnTIBIpfJ/D3cqmlVT5q+hMuictmowyY8yMrNscPfZoIsEIbYk2ADbu3UjapvGZoevIG4m4CZR7z72zZw9MmTJkKYiIiIgccjQsS0RERpxoNHeS3enTNedOMSt2rqAj0dF9PRKMUBuqzbrNzDEzu5dGBwj4Aryx940hyxGgoQGqqrK3aR0GERERkdKog7uIiIw4+ZbL1hLoxf1u9e9IpHueuFQ6xbvvfHfWbWKpGAdiB7qvdyY7efi1h7nhlBuGLM+GhtzhdTt3DtnDi4iIiBySVNwREZERJ98Eu35/7jbp0XdZ8/ZEO49ufLTofVI2xR/W/mHIizt9e2Vt3TpkDy8iIiJySFIHdxERGXHyTZycrzePOG3xtqzJlA/GmuY1HmdTXENDbvFu61ZNqiwiIiJSChV3RERkxMlX3Nm/f+jzqBSPbHhk0PfdF9vnYSb9Gz8e4vHsbevWQSw2pGmIiIiIHFJU3BERkRGnvj63d8frr6v3TiF/e+Nvg75v2qbZ2TZ0k97U1+e+jmvXutXRRERERGRwVNwREZERp7Exexl0gC1bNHSnkOe3Pl/S/R9a/5BHmfTP789d0n779iF7eBEREZFDkoo7IiIy4owalbvs+ZYt+SdaFli/Z31J91+0aZFHmQzMkUfmbnvDyxXZJ01yszaX4zRpkoeJioiIiHhDxR0RERmRxo/Pvr5mjZZDL6Qt3lbS/V/Y/oJHmQzM8cfnbluyxMPiXVOTR4GGOLaIiIjIIKm4IyIiI9LUqdnX9+7V9+p8Xt31askxNu/f7EEmA7dgAVRVZW976CFobR3SNEREREQOGSruiIjIiDR3bu62J58c8jRGvIdeK32+nM5kJ+khHPM2bx5UV2dve+KJ3G2DNnGiR4GGOLaIiIjIIKm4IyIiI9LZZ0Ntbfa2v/wFDhwYnnxGqqXbl+Zsqw5UM7pqdMGTz+Tu/te0rBmKdAE45pjc5dD37YNNm0qPnU4DO3eCtcVPhfR3v51Dt7KYiIiIyEAFhjsBERGRfBYuhFQqe9uf/gS33z48+YxUyVQy63okGOHGhTdyauOpBe/zjUXf4MnNT3ZfrwnW8Ob+Nzl24rHlSjPLlCn559f54x/hs5+FYHDwsVtbYfTowd9fREREpBKpuCMiIiPS9OkQCmUvf97e7goAl13mltQWWNG0Iuu63/i5eO7FzB2fZ1xbxnNbnuPpN58mZV31LJaKsaJpBe+Z/Z6y5trFGJgxA155JXv7b38Ln/pUacWdgI5sRERE5DCkYVkiIjIiGQOnnZa7/ac/zS74DEbfIUGVKpVOsWnfpqxtHYkOZoyZUfR+s8bMIhKMdF9PppMs3rq4HCkW9K535S53v3Il7Ngx+JiJBPz+96XlJSIiIlKJVNwREZER66KLIBLJ3vbMM67HRynz/yaT/d+mEmzYs4GqQPayU6OqRlEdKD4z8ayxszDGZG1bsXNFgVuXx4UX5s6pBPC97w1+1axEAn74w9LyEhEREalEKu6IiMiIddllufPuAHzyk9DZObiYHR3wn/9ZWl4jxcqmlRiyizSNoxv7vd/MMTOJJWNZ23a07cjZVk4LF+bvgfXb3xaf77iQdBrWrIFVq0rPTURERKTSqLgjIiIj1rhxcM45uduXLYM773Rz8ByMVAr27oUvf9mb/Ibbyztfpi3elrVtzrg5/d5vXHhcTs+dcCDMul3rPM2vmJoamD8/d3tHB3z+8wffe6ezE6691pvcRERERCqNijsiIjKifepTUFeXu/36690cLQfTg6ejwxWLDrYoNFIt3roYS083F5/xMX9CnopJH8YYjqg9ImubtZaVTSs9z7GYiy/OP3nybbfBli0DH3oXjcJdd8HLL3ubn4iIiEil0JoSIiLiqY4OeP11aG6GlhZ32rkTtm51vTGSyZ6hVn6/+3I/ejRMmwYTJsD48e40cSLMmgXvfnf+lbGSSTdvywsvuKW1+87N01sq5YpAH/gArF9fnn/3cFjdvDrreiQY4aixRw3ovkeNPYo39r3Rfb0t0caL21/kw8d/2NMci3nXu+D733dz5fSWTsNHPwpPPOF6+BSTTrv33Be+ULY0RUREREY8FXdERKQkb7wBDz4Ijz7qhkvt2uUKLTNnwlFHufN58+DUU6GqCqqr3bm1EIu5oktnJzQ1uYmSH3vMFWAef9wthQ7ui/s3v+m+xPe2bx8cfzz8/Odw6aUQDucWgtraXHHpve+FV18dmudkKByIHWBf576sbX7jZ+aYmQO6//wJ83ls42NZ25ZsXeJZfgOxYEHhJe2XLoUPf9gNvytUuEun4cABOPNMN9xORERE5HCl4o6IiAzKhg3wj/8ITz/trnd2ujlUfvpT19vGWte7Jhx2xZyB6Ohwy5SHQtlf6D/9adfDo29xB9yQnI9+1A3lue461zsnHHaPv3Qp/OIX8LvfuULSoWR182rCwTCJWE+3l85kJ7PGzBrQ/eeMm0M4ECaa7JnV+JXdr3ieZzF+P3zkI/Czn+X23gG47z5XDPzlL91te7+P2tvde+Wcc2Dd0E0VJCIiIjIiqbgjIiIHzVo4/XTXS6drZaPTT3e9bfx+CAxy7xKJ5O+lEYnAj37kikmF5st55hl3Avf4h8py54WsbFpJIpVbEWmINAzo/jPHzCTkD2UVd2LJGE1tTUysnehZnv35h39wxZt8xR1wc+ksWgRf/Sr8/d+7As++fXDzzfCTn7ieWSNKqhM6tkGyHWwC0n1OxoAvCCbozrtOoTFQPQl8OjQTERGRg6cjCBERGZQxY2D/ftd7Atx8Oum0Ow22uFPM1Ve7As/KlfmXR+/tUC/sADy/9fmswgzAEXVH5KyCVcissbNIprOfqOpANauaVw1pceeYY9zcSsWWMN+2za2Ede21rjYymKXSPbdvDex6Fva+DPvXQMdWSHZAZArUzIBIo7scqAVfCPwhMFVAGtJxd0rFIb4HotuhYwu0bYRz/wbVE4b7XyciIiIVRsUdERE5aMbAs8+6eXB++UtXzFm7Fhob4Z//GT74QZgxww3VSqfdMKmu+XMK6Zp7JxBwt+17e2Pgj390c+xofhVYtn1ZzraBDskCaBzVSGcye6mxaDLKyqaVnDfzvJLzOxhf+pLrwTOQXjjDXthZ/3NY913obHHXjYG5n4eZH4PwEa7Ag80UdKrB9LMwqU1BMgo26W4bHFX2f4KIiIgcelTcERGRQWlocD1pvvlNN+/OokXu/Ac/cENoamtdj4zZs2H6dLfqUddcOl1z4kSjPfPstLa6VbbWr3eTNLe25j5mYyM88gi84x35598ZqGIra1UCay0b9m7I2T6QZdC7BP1BxobH0tLR0r0tnoqzeMtiOM2TNAfs0kvdkvdDpaW9haoxEUbtzX4TpSY0UGB+Z8daWPaP2dumXQbHfrXnemh04fvfNwk6m/rJzgdX9dM1TURERKQPFXdERGRwJk2CpiZqgQsypy4dhGnZN56WF92pmQm0MJ4OIrThJ04IQ5ogSfykqKOVGTRzLi2Mz5xs83LMhNzhKW97G/zqV24S5Wg058/9ikTgvKHtmOK5zfs34+vTIyQcCDNn3JyDijO9fnpWcQdg+c7lJed3sIJBuOUW13un0JxKXtjeup1vP/1t7njpDpKfTQJBgv4gyXSSVDpF0N/GRfdcyf87+/8xe9zs3ADGwFl/gnXfg91LXc+cbQ/Bko/DrH+AMce73jepGK73ThCMH/D134OnW9q7f7CIiIgcNlTcERERz0WIciRvciRvDj7Icce5NczzuPxyGDUKrrzSFQMGOsdOOOwmZb7ppsGnNRKsbFpJoM/EuyF/aMDLoHd5S8NbWLp9ada2Lfu3kEwnc+KX25VXwr//O7z4YmlDr8Lh3G3PvfkcX3nyKzy1+SkslmQ6ScgX4oPzPsglcy/hyc1Pctvy24in4vxhzR+4b919vHXSW7nxzBu56C0XZQeb+j536txFetdS9m5eQ2zHOnyvf5Gq5BbC1WmCtWNIVx+ZmXMnAiaI9YVgxj8BFtIJjHXz7gQ2/gyT7lWlrB66+Y5ERETk0KHijoiIDE6BwkuOQhP8ljh5yvnnu3l+Lr7Ynbe3Fw5ZU+N6h/zhD5Xfawfg5Z0v0x7P7uKSTCeZNXbgc+6AG8YV9AVJpHuWqqoKVLF+93rmjZ/nSa4DZYzrkfW2t7m5lward3Fn/e71HP+L43PmFgKIp+Pctfou7lp9V87f0uk0S7cv5QP/8wEAnvnYM5wx7QwAWlrgnnvgttsaWLXqAoLBC2hshPe8x60YN2cOTJoQo762g0Q8QTqRwKYTkMqcY8AfxPiC+PxB7Nx/ARNk9/5atu0IcNJJMLApsUVERER6qLgjIiLesmmI7YLoTojuKHy71/7TLftsApnhKwF3PTjaLQkdPsItD51sg/ZNbjWi2C6I7XbnnS1MTsdY/KMqHl9+HL/839N44On5BAMpV0+y0JkIMH/WDj556bN88OyljA7vgSV+CNXDiTcXzi2ddKsYFdLyrBtuY/wub+N3uftCEBrr4g94GM7BW7xlMSmbPS9LZ7KTaaOnHVScmWNmEg6EScR7ijsGw8qmlUNe3AGYPx8+/nFX5BnMkLuaGvjZz2BV0yr+7fF/49GNj3YXdgwGv/FzWuNpHDvh2IKrim3cu5HH33jcDdXKPMfvvPOdnHjEiXz7nJu44Jgzu+eLAli4EB5/3M0B1TOXUxVQReAg5nY6ohaOmHLw/2YRERERGGBxxxhzPvBjwA/cZq39TlmzOgzFU3Ga2ppoam/izf1vsmz7Ml7b8xr11fWcOuVUZo+bzaTaSUysnUhdqG7AS92KiJRV2ybY9idoWgQH1rliTmgcjHsb1M2CyFQYXw8t+7LvN6EBJl/gVghKJ915ssPdf/9a2PYwxHdD85PQsd3NbVJ/LMz5J5h6MYQngAlCOoYvneS8kyzn/QNEox2se8XPgQOGcNhy5LQ4kyaNontWION3BRjjh2izW8q6+SmXe/sWV5Cpm+0KS+HJ0DAKdh3ok/s4CNbjlrROutWO0p3QsdflH90KHTvghJtccSqPaCLKnzf8mbNHhxizP571t45xo+iM7mFseGzBp31l88qcbWPCYwj5+1mSrI9ZY2bldBNpi7exfMdyrpx/5UHF8srNN8PLL8Py5QfXgycSgWuugfbZv+K4X3wcgNpgDaNDtSTTCU4eN4Nfv+1Spvri0Nns7uQPu+IcuOfBAuNnsW/GVP5pzVPcu/N1gj4f1iZ5dsuzvP2/zuKouU+zZdVpRMKWjmiATZtcrvPmwb59UF3tTgcrnXYFo5qag7+viIiISL/FHWOMH/gp8E5gK7DUGPMna+3acid3qFndvJr33f0+drbtzNtFvJDblt/W720m1kzk06d8mi+e+cV+bxtLxmiLt9GeaKcuVEdtqJagPzjgfGTo/fnPsCPTASIWc/OLHHWUO0+l3Lm1bliDz+fOi414sbbn7z6fW3ra53PLS3d9OQkEXOzLLoPRRRZ/GRSbznwhznwxtkm3DduTIH3/AZlvoMa4y8b09JjoPvcVHgIk3nvs7bD7+cwEslGoOxreu9b1vEkn3Bdnfwiarzv42K2vwQOz6Z6INtkK406GI69w75t0AnwGAtnfhMMhOPEU3KpELU30O+WPP+Jyx7qJcqe+DxJt7jH91dDypYPP3aZdzD657evcx92r7uaetffwzJZnSKaSpD/rJs89efLJrGhaQSwVAw4Q/MEk5k+Yz+XzLudDx36II+uP7AlvLdFElHAg3F3oT9s0x0087qBTnTV2FolUgkiwp4tJMp2kub25wL/NZtpuAmwi/206d7nz3m2VzKmrd5MJFGyr1dXw6KNw1lmwZo37zOtPTQ186EPwwx9C06ZR/GX+AjiwFtJx8AUZ1XgRpx5zDaZ+vutZZfyQjrn3Us5nDdQDv14An2taxc725l6fMz6OumEitUk/994Lf/0rrF7tcq2vh1NPhaOPhqlTYcYMmDIFqqrckMBAwJ2sdZ/ZXae2NnjzTdi4EbZtg+t2fo05v/t6///oQXrhgq+y+N1fY8cO19to3Dioq4OxY+GKK/LPWSQeyUxCXzYTJw58uKzIIWDdOnjqKbc7SSTcDwKNje5zLJFwn7HpzBz1/sxSiPmOkXtvS6V6bu/39xwPv/662z+FQu62J50ECxYMzb9TZKCM7WfOA2PMacDXrLXvzlz/IoC1tuB0lAsWLLDLli3zMs+C4sk4HckO4qk48VScaCJKW7yN1lgrbYk2kukkNcEa6kJ11FXVUROqIeQPEfKHqPZXUx2oxucrX9f53h5fv5hz7z4dgJq4O4UTcNQemL4PGjrcqb4T/L1eFgu0h2B3BHZFYHsdvDoOmmsgbWBP5pj8uB2w8ojy5X/PZfdw6bxLyxPcpmH8KNhdnmVSXh8DX74gSMe7TiYabWblvm00x6Kk8xzU98dnfAR8ARZOW0gkGCESjHDJWy7hivlXlCFzp+93oNmz4dVXPQpuLcT3ui+jvXtRQFJbXVoAABzxSURBVKYIY4F0pvjSlYjtdTkrWPZtjA/evB9WfyX7Zle6L1yVIJl0v6anUu4Aoesc3Lm17rzrNSr2kdr7Nr0LcV0nv99t8/vdwUNVVYm1qh2PwRPvyt52xu9cgcQLDx0LbRsz75s4jJ4HF7yUWSnIZCaSLfD5OqAloQ2c/Qi0PAP7VkPHZldUqD0KqidA9XgIT8FWT4Kqsd1Du4zxw+PvdD1/+uOrztzPYKddAUdfhxk9zz12OpZ535P5d/QqVqz+Nqz9dvHY/ho6L93FIxse4bI/XJY1r81g3P6+27lk3iXUV9ez92v/QvsPv5f194YOqB7gxNK97a12+5jepv68z43GLoDzl5Kj75dVD79cHjgAZ5wBb7xRfAWtmhq46CK4807Xflh0ketNZvyuEBWog8szva/Sif4/e/p7b94L3Je7OUo125nMNqawjSm0U0OCYM7JYPNsTVDPPqaylVN5Pivu+98Pf/xjnjzK+NyPVPetu4+/bfwb0WSU9kQ7j2x4hEQ60b3aWd+hij7jI217Vh8zGPw+P37jJ+gPMm3UNE6cfCLhQJhwIEys9XU2t+6gPRlje/tuXm8t7fmcVjuRaXUTqQmEmR+J8IPrnoD9JYUsrozvgXXrXPGxt/p6735P+dznXOrWuv3snDnw3e/anhoxABbb67jNPbZxf8sk0vX/QvviW2+FJ5/sydvng2efdftbr6Vtuvv7STwVpzXWyoHYAaJJV5wfVTWK2lAtVYEqQv4QQV8Qv8/vfSL9WLFzJfs7W4nGY2ze9yZLti6hLdFGNNFBNBGlI+nOO1NRkmm3kwn4AlT7XbupDkQI+915TaiWkyacytS6aVQFqhhVVcf88cdlvU98vsxndUbXsdTB8vng//wf+N3vsreXOJ3f0Hpofs/wdZuGhtPh9Dv73Mj0OuQu1uBsr7M+T8KLn4FtD/S88f0RuGiT+8FFKpIx5kVrbU55cSDFnQ8C51trr8lcvxo4xVp7faH7lLO4Y75eub/KH7vhY6z6zR1Z2/I+/fl+2RnADnv2Zd9ix5HfYXKsjdq4KwaFUlAfhdExGN3pzmviEE5CMAWxAHQGoDUEB6pgfzXsr4J91YCBuhi0haC1CuZFJvKSvxkLpKylrZ9/r8Fk7YT7qvKHqA5UYzD4gN3f2V+2g54bF5zKt9+7pDzBgafHRVg4tiN741Xe7V2eut1wVhjSaUM8GSLqm07i/Fe6f5VIJNwJen596O6ds+EO2Hg7xrjeMAbXa8bYBH7TiZ8YM5/ZnPfLihd+MPlDzJnTyvvSD/bsk44/E6bNAWNd7wss+KBnXAQ955GXIPxSwfi/eeMtvHViT/eMtK+T6ef9kWDNVLch58jT5vuhvofxdR0qAhAed2zWn08/3R0IemXxd07slVmayccsZOpp19BrY5aiqXf/z/nvXz3PRyZ8ikDvLzxn3AYzrsrcwfS5d5/oq78Ja75V8PF+y2yWMJGT09s5jt2MT++nwQ9m7AmkxpwANTPx1c7EX9OICU/C+KrAl+kB8dB8TKxA75CMR34N736kyA2CQC1uwLAvc+p9OV3g1AHN0fFMpBm/L8n8xtVMb9jE5z65lTPf1gId21xPIZtygYKjIFCbeW67lrTOPF82lTm3sOFWNzwLeHDrkdwcPcBz7Cfea2nroC/A6FAt5045mWPHHZWznDkA1vL6gW38bdsLbG1rImVT3WVTY3wsnHQ817Wdx4z4agASUVf5WPCRG/FV1wGmu0dPaPKpeZ+6+Pbin4f3/f6jjK/aBiYOJk5N3VRmL7wVSOMzfnzGhzHGtRXjw2SKuQYIbvwvgpv+u2h8GxqHmbCwZ8OYE+GId+fmGTfcftd4vnLTVKIxH+3tPV98amtSTJ0c5+avb+aC8/Z3v53/+FCEH31vF29/yyLOnPM0jeO2ML2xg1DDMW5oX+0MCE9xBcKqsa7A1z1/kh8ePhZiLTm5dPnFPvjvqlPZ1bGLprYmWuOteW+34/swqU9RamcNHPH53NtOqJnA+Mh4GiIN/NX/DM0HJtAaraO1s47WmncSnXMTqRRZp64vSL2PI2zLC7DnBfc5n/m8t6kEqWQCn43SGd/LfZEnu1+rpnQb+yNJQuHazPvLvaZdlwPGTyLtPj9s13+ZB+z6mn1Sw1uo8oWwWKZsruFD1Y9nsnE/n0x593cITj6r17/24PaNptelyV86kZ3jBlC0LQMf7j3f9d7varvWWtI2Tdom3eUC9x/VUc+tM/eR+VTBD0w98r00HnUV7rUy+HrFNV3tKtOeI2/+nsjW3xfM7182TuJ7qTIW976W+7p5+SW676763HNdzzgvvPLa65x2fk+bjqXTXP6BBq65qmdluoP9t/gz+wFj4Ct/PZO/xl72Jtk8Lk2eiS/k5oBLJ/azxuyndsIU11a7Poeh53PfFySeTvRqq+7/1ro2e0SkgVmjpnT//cdr/qdsuddvPot9v1qUta2tzbvhpzfc9XbG3foUX10ECYJ0Uk0n1dmlc381NhiCYBDr87sfc7rar/FhbBqT+THT2DQkEphEnGAyyjvGP8n2lp7J0AKBnuNtLyTvNAR61/MmXwDveHhgd175NVhduJfn3W82clVsS0n5FXPS7vNpXXU5YGhvg33EuP7vj2f65FG4H3i73pnufWaMD2vzf0JaXDE+HKjqbos7136OxvBLpC2kUkls5AALz70lEytfFFMwPkDAF8RveopZjXeV70d5APvVzD/kub+DTX0WbvDgO2IpxZ3LgHf3Ke6cbK29oc/trgWuBZg2bdpJmzdvLjnpfH57wUVsej6MP23wpwx+f5DZV5xMiCABG8KPz/0qnnlTZX1aG0PapkiQJGGSJH0p0jZN0ljSJEn4Unx38r/RSQqfgfa0ZTc+fL5QzwFPr3O/8Wd25Gn3gZmKYdNxugaUWGCSH6qM+z7xzgj8ZGKEWPAo4skA8WSA2JRPkJp4PqkkpKyPdMqQsgC+7tKItZmm8eb9mK33Yox74xprM93iU/hJsGtfNZuaj8x8iQdjLJPeewuhuobup6H3cJyu6wDsXgp7Xuh5qnpugTHudMObX+IlytOzBgusuRxszyM3NjRwxpzZpK3t/nWGdNdBT/avMgYfvQ+p3Euf2Z2ZFJPa91D/kq/7uQE4+p1XM+Ut2SvLnH7JJEJ7swtr8TETee7XS9yErjnxXTX9P5+6n8aJd1Bn2/BZ2B2GE+ZeSbhqtDtItl1fBF3Ry2ctaeP+2XOjy5gbfbHo0/PdZ2vZsKWNmgT406731phOGNcBY6MwKlO0iyQgmHkaUj6IBqAj6Ip3eyKwp9r1/qrL3LY9BG0B+H3jbMLGEkgHCYQ6qBm9jwn1EcKBKvdrjD9IKHMK+IIYA6l0imQ6yS2BF6k3hbsL/HpHAx9ZfB69D+jfdtQsZkwcn3nt3Gv+i69+mfrW7C9J++rquO7r38j+pa73ob6BcxO3cM2UDdkPOtAPzX52jABffS3CukQAf8pP3PpYTxWRhvlU+8IEfSFCviqCJkDQF+we3piyKVI2TbJjO4nOnaQsJIEEMMFY6nxpUiRJWMvdM9ZkP+Dcz8MJ38vJYzD5/3TTNK5//CrIfGZgDe85ZS7zZ0wAutqR5cbPXUXdgew5cVpH1fOtm+/Gdre/7I9UYwzPp2/hie0P5TxunQ+O8MOkgDuP+FwdJmDcKQgEM5+Lya7nxsJN42B0r4Oc4Gvub735jI9IIEI4GKY6UE046H45rPJXgYFEKkE0GaUz0Uk0GSWajNKR6Oj+tbFbogoWfTXrM+fkOUdy6dvfQjrlA+vHpn2Q9mOgu4dn1+e/zxjStutg2T0pqa4uXb4UzZt/zvpRt2R9jR099UL+8fR/ZeG0hf3Pm5Z5bdfF4Yd7YWuf9P+l81TePqtPgSbf+z7fjwXjauAnxT/LzWu528KBMPXV9YyuGs3o6tHUhmrda5AZHtaZ7KQz2UlbvI0DsQPs79zP3s69dCQ6strwKB/sf5mDKijHCHEnf89znM5exjKRnbyPB7mQh3N+x3yIC7kk9CA+X89+4te/hve/z0KqA5PY7YaOJVsxpCCdygwPTWHIjHH1BbC4Yk/whSsxib3d8S/cEeLPbdnzJIUDYcbXjKch3MDY8FjqquqIBN371GBIpVO0J9rpSHSwP7af3R27aeloYW90b8EeXQEg7IOwce0lgDuv8Qczn8khgr5Aphhg3fsUQyrzbKcz7817xu5hXKY78Oo99dxzzz6+tijvQ5bsZxefxT+ap8r2Y8F9V3+IZ3ed1L0vt9Zw4ec+lzPcIu++vH48z92e+byyvW5PT2F8863rSP7lyUxRBULj6jjyordmbpQ5gDLpnkJ6rwMR6zOYdPYx59vO+DyhKtdrbNP+ccz732sw6fH4krWkSXL6aX4+8oEpjK6uZ1RoNLXBOqoCmW50vert1lqiqQ4OxPbTGj9AS7SZXdEmagK1RJOdtCfa2PPCJk568pd8/PHCX25K8aez4f1PDO6+hfr69vbX780ltWkd1ZnfetL1kxh9xjXU+kKEfSEiviABn7/XoURP1GTrw0RbH6UjDW1p2J/ueS90Wli3cwaf/crGrMf72c/gk58c3L+nrzt/fhe1f/k0U5ftIpRyx17VSXesVZ2AqpT7sTVfP9Y0EPdDzA+dQfeDaqcfqlNue9wPH7zasDNUvu4oby6ZQvIvQVL43akqgn9iA2l8WH8A6wuQ8gUwPtfl2PZ+Nft81zK47sw2bfGlk2yb0sRjiTf4/GL3bSWND1tTCzU1pHEV6rTxuyKLMTlvlK7iS/ZG1yZ8NsWG07ew6OzdRHyGsM+wPZEm2HgR48bOp756NKOrRhEJhKkOVBHyV3U323g6TvT1X9Px5r3sz7xndqfcscgRAYhm3jsLfnkS719V/Bi9FIGr30UqdABSVRCIUt2wg6mTXU+uKn9V92iT//3M84w90LPf2T0qyIU3n0A8GSeejhNLxoilYkytm0ooECKeinPkvka2PbKFM9NLCKRh8yj3w38w7X7g73seSLsRIQk/JH3uvZfwZS4HIGFgwQ532JT0wR93/wdXvLSLr1H8OHqw2i6C2ny9Vj1yy1W1RNa1EUy570k7a11brU66kTVVSdcOq5MQyhyDxQKunXb6ezpIdJ0a97vbJ32uc8RlJzbCnf3NDTB4pRR3RvSwLBERERERERGRw0Gh4s5AJptZChxtjJlhjAkBVwJ/8jpBERERERERERE5eP3OomStTRpjrgcewQ0RvsNau6afu4mIiIiIiIiIyBAY0BTZ1tqHgQHO7iQiIiIiIiIiIkNlaNYAFxERERERERGRslBxR0RERERERESkgqm4IyIiIiIiIiJSwVTcERERERERERGpYCruiIiIiIiIiIhUMBV3REREREREREQqmIo7IiIiIiIiIiIVTMUdEREREREREZEKpuKOiIiIiIiIiEgFU3FHRERERERERKSCqbgjIiIiIiIiIlLBjLXW+6DGtACbPQ/sNAC7yhRb8YcvtuIPX2zFH77YlR6/knOv9PiVnHulx6/k3Cs9fiXnXunxKzn3So9fyblXevxKzr3S41dy7kMR/0hr7fi+G8tS3CknY8wya+0CxR/6+JWce6XHr+TcKz1+Jede7viVnHulx6/k3Cs9fiXnXunxKzn3So9fyblXevxKzr3S41dy7pUev5JzH4r4hWhYloiIiIiIiIhIBVNxR0RERERERESkglVicedWxR+2+JWce6XHr+TcKz1+Jede7viVnHulx6/k3Cs9fiXnXunxKzn3So9fyblXevxKzr3S41dy7pUev5JzH4r4eVXcnDsiIiIiIiIiItKjEnvuiIiIiIiIiIhIRkUVd4wx5xtjXjXGbDDG/KvHse8wxjQbY1Z7GTcTu9EY84QxZp0xZo0x5tMex682xrxgjFmRif91L+P3ehy/MeYlY8yDZYi9yRizyhjzsjFmmcex640x9xhjXsm8Bqd5GHtOJueu0wFjzGe8ip95jM9mXtfVxpi7jTHVHsb+dCbuGq/yzteWjDFjjTGPGWNey5yP8TD2ZZn808aYkmalLxD/+5n3zkpjzP3GmHqP438jE/tlY8yjxpjJXsXu9bf/a4yxxpgGj3P/mjFmW6/3/4Vexs9svyHzub/GGPM9j/P/n165bzLGvOxh7LcaY5Z0faYZY072OPfjjTGLM5+bDxhjRpUQP+8+yot2WyS2J+22SHxP2m2R+F6126LHB6W03SK5e9Jui+XuRbstkr9X7bZQ/JLbbpHYnrRbU+C4z4s22098r9ptofglt9sisb1qs0WPuUtps/3kX3K7LZa7R222UO5etdlC8T3Z3xaJ7+X+Nuu7lFdttkh8z46RC8T38hi5b2xP2myh+L22l3yMXCB/z46RD4q1tiJOgB94HZgJhIAVwDwP458FnAisLkPuRwAnZi7XAes9zt0AtZnLQeB54NQy/Dv+GbgLeLAMsTcBDWV67/w3cE3mcgioL9Pj+IGdwJEexpwCvAGEM9d/D3zUo9jzgdVABAgAfwWO9iBuTlsCvgf8a+byvwLf9TD2XGAO8CSwoAy5vwsIZC5/d7C5F4k/qtflfwJ+4VXszPZG4BFgcyltrEDuXwP+r0fvx3zxz868L6sy1yd4Gb/P328GvuJh7o8CF2QuXwg86fFzsxR4e+byx4FvlBA/7z7Ki3ZbJLYn7bZIfE/abZH4XrXbgscHpbbdIrl70m6LxPek3RZ7bnrdppR2Wyj/kttukdietFsKHPd50Wb7ie9Vuy0Uv+R2WyS2V2224DF3qW22n/xLbrdFYnvVZvv9PlJimy2Uvyf72yLxvdzfZn2X8qrNFonv2TFygfheHiP3je1Jmy0UP7PNk2PkAvmX3GYHc6qknjsnAxustRuttXHgd8BFXgW31j4F7PEqXp/YO6y1yzOXW4F1uC/tXsW31tq2zNVg5uTpZErGmKnAe4DbvIxbbpnq+lnA7QDW2ri1dl+ZHu5c4HVr7WaP4waAsDEmgCvEbPco7lxgibW2w1qbBBYBF5catEBbughXZCNz/gGvYltr11lrXx1MvAHGfzTz/AAsAaZ6HP9Ar6s1DLLtFvkM+yHwhcHGHUB8TxSI/0ngO9baWOY2zR7HB8AYY4DLgbs9jG2Brl/3RlNCuy0Qfw7wVObyY8ClJcQvtI8qud0Wiu1Vuy0S35N2WyS+V+222PFBSW13CI49CsX3pN32l78H7bZQ/JLbbpHYnrTbIsd9Xu1r88b3sN0Wil9yuy0S26s2W+yYu+T9bTmP6YvE9qrNFs3dgzZbKL4n+9si8T1ptwW+S3nSZgvF9/IYuUB8T/a1BWJ70mYLxc/w5Bh5JH1PrqTizhRgS6/rW/HwIGWoGGOmAyfgqsFexvVnujk2A49Zaz2ND/wI9+ZPexy3iwUeNca8aIy51sO4M4EW4FeZrnK3GWNqPIzf25UMcodViLV2G/AD4E1gB7DfWvuoR+FXA2cZY8YZYyK4XzsaPYrd10Rr7Q5wB73AhDI9Trl9HPiz10GNMd8yxmwB/g74iodx3w9ss9au8CpmHtdnus3eUWp34jxmA2caY543xiwyxrzN4/hdzgSarLWveRjzM8D3M6/rD4AvehgbXPt9f+byZXjUdvvsozxtt+Xa/w0gvifttm98r9tt7/het908z42n7bZPfM/bbYHX1rN22ye+p223T2zP2m2B4z7P2my5jysHEH/Q7bZQbK/abL74XrbZIs9Nye22QGzP2mw/r2vJbbZAfM/abIH4XrXbfN+lvNzPlvu7Wn/xS9nX5o3t4X42J77H+9lCz005j5HzqqTijsmzzdPeKeVmjKkF7gU+06caWTJrbcpa+1ZcxfRkY8x8r2IbY94LNFtrX/QqZh5nWGtPBC4APmWMOcujuAHccIafW2tPANpx3R49ZYwJ4T74/+Bx3DG4qv4MYDJQY4z5ey9iW2vX4bpQPgb8BTfUMVn0TocxY8yNuOfnt17HttbeaK1tzMS+3ouYmYLdjXhYLMrj58As4K244uPNHscPAGNw3aI/D/w+88uf1z6Ex4VZ3C+hn828rp8l03vQQx/HfVa+iBv2ES81YDn3UeWMXSy+V+02X3wv223v+Jl8PWu7eXL3tN3mie9puy3y3vGk3eaJ71nbzRPbs3ZbzuO+4Y5farstFNurNpsn/nF42GYL5O9Juy0Q27M228/7puQ2WyC+Z222QPyS2225v0sNd/xS2myx2F602XzxvTxGLpJ/uY+R86qk4s5WsiulU/FueErZGWOCuB38b62195XrcawbcvQkcL6HYc8A3m+M2YQbDneOMeY3HsbHWrs9c94M3I8bhueFrcDWXr8c3IMr9njtAmC5tbbJ47jnAW9Ya1ustQngPuB0r4Jba2+31p5orT0LN+zDy54LvTUZY44AyJwPenjNcDDGfAR4L/B31tpyFpXvooThNX3MwhUFV2Ta7lRguTFmkkfxsdY2ZQ6E0sAv8a7ddtkK3JfpKv0C7heRkia868u44Y6XAP/jZVzgI7j2Cq7o6+lzY619xVr7LmvtSbiD5ddLiVdgH+VJuy33/q9QfK/a7QDyL6nd5onvWdvNl7uX7bbAc+NZuy3y2nrSbgvE96TtFnjuPW23mZi9j/s839eW6biyYHwv97dFcvdkX9srftePcJ7ub3vn7/X+ts9z4/m+Ns/r6um+tk98z/e3fZ57L9ptoe9SXrXZcn9XKxjfgzY7kNxLabM58YE78a7N5s1/CI6R86qk4s5S4GhjzIxML4krgT8Nc04Dkql+3w6ss9b+exnijzeZ2cmNMWFcQeAVr+Jba79orZ1qrZ2Oe94ft9Z60nsEwBhTY4yp67qMm5zLk1XLrLU7gS3GmDmZTecCa72I3Uc5fvkHNxzrVGNMJPM+Ohc3dt8TxpgJmfNpuJ1uOf4N4NrqRzKXPwL8sUyP4zljzPnAvwDvt9Z2lCH+0b2uvh+P2q61dpW1doK1dnqm7W7FTfC504v40H0g0uViPGq3vfwvbieMMWY2bkL0XR4/xnnAK9barR7H3Q68PXP5HDwunPZquz7g34BflBCr0D6q5HY7BPu/vPG9ardF4nvSbvPF96rtFsndk3Zb5LX1pN32894pud0WiV9y2y3y3HvSbosc93myry33cWWh+F602yKxvWqz+eK/5NX+tkj+JbfbIq+rV2222PvGizZbKL4n+9siz33J7bbIdylP2my5v6sViu9Fmy0S25M2WyD+pV612SL5l/sYuWBCFXPCzQmyHlcxvdHj2HfjukwlcC/wJzyMvRA3hGwl8HLmdKGH8Y8DXsrEX80gZ6Ef4GO9A49Xy8LNi7Mic1pThtf2rcCyzPPzv8AYj+NHgN3A6DI951/HfaCtxlWaqzyM/TSu2LUCONejmDltCRgH/A23w/0bMNbD2BdnLseAJuARj3PfgJvvq6vtDnq2/gLx7828tiuBB3CTtXoSu8/fN1Haaln5cr8TWJXJ/U/AER7HDwG/yTw/y4FzvIyf2f5fwHVleM8vBF7MtK3ngZM8jv9p3P5wPfAdwJQQP+8+yot2WyS2J+22SHxP2m2R+F61236PDwbbdovk7km7LRLfk3Zb7LnxqN0Wyr/ktlsktiftlgLHfV602X7ie9VuC8Uvud0Wie1Vm+33mHuwbbaf/Etut0Vie9VmCz43HrXZQvl7sr8tEt+z/W0m3jvoWVHJkzZbJL5nx8gF4nt2jJwntidttlD8PtsH3WaL5O/ZMfLBnEzmwUVEREREREREpAJV0rAsERERERERERHpQ8UdEREREREREZEKpuKOiIiIiIiIiEgFU3FHRERERERERKSCqbgjIiIiIiIiIlLBVNwREREREREREalgKu6IiIiIiIiIiFQwFXdERERERERERCrY/wf63ve3TtlzcQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from collections import Counter\n", + "from modisco.visualization import viz_sequence\n", + "reload(viz_sequence)\n", + "from matplotlib import pyplot as plt\n", + "\n", + "import modisco.affinitymat.core\n", + "reload(modisco.affinitymat.core)\n", + "import modisco.cluster.phenograph.core\n", + "reload(modisco.cluster.phenograph.core)\n", + "import modisco.cluster.phenograph.cluster\n", + "reload(modisco.cluster.phenograph.cluster)\n", + "import modisco.cluster.core\n", + "reload(modisco.cluster.core)\n", + "import modisco.aggregator\n", + "reload(modisco.aggregator)\n", + "\n", + "hdf5_results = h5py.File(\"results.hdf5\",\"r\")\n", + "\n", + "print(\"Metaclusters heatmap\")\n", + "import seaborn as sns\n", + "activity_patterns = np.array(hdf5_results['metaclustering_results']['attribute_vectors'])[\n", + " np.array(\n", + " [x[0] for x in sorted(\n", + " enumerate(hdf5_results['metaclustering_results']['metacluster_indices']),\n", + " key=lambda x: x[1])])]\n", + "sns.heatmap(activity_patterns, center=0)\n", + "plt.show()\n", + "\n", + "metacluster_names = [\n", + " x.decode(\"utf-8\") for x in \n", + " list(hdf5_results[\"metaclustering_results\"]\n", + " [\"all_metacluster_names\"][:])]\n", + "\n", + "all_patterns = []\n", + "background = np.array([0.27, 0.23, 0.23, 0.27])\n", + "\n", + "for metacluster_name in metacluster_names:\n", + " print(metacluster_name)\n", + " metacluster_grp = (hdf5_results[\"metacluster_idx_to_submetacluster_results\"]\n", + " [metacluster_name])\n", + " print(\"activity pattern:\",metacluster_grp[\"activity_pattern\"][:])\n", + " all_pattern_names = [x.decode(\"utf-8\") for x in \n", + " list(metacluster_grp[\"seqlets_to_patterns_result\"]\n", + " [\"patterns\"][\"all_pattern_names\"][:])]\n", + " if (len(all_pattern_names)==0):\n", + " print(\"No motifs found for this activity pattern\")\n", + " for pattern_name in all_pattern_names:\n", + " print(metacluster_name, pattern_name)\n", + " all_patterns.append((metacluster_name, pattern_name))\n", + " pattern = metacluster_grp[\"seqlets_to_patterns_result\"][\"patterns\"][pattern_name]\n", + " print(\"total seqlets:\",len(pattern[\"seqlets_and_alnmts\"][\"seqlets\"]))\n", + " print(\"Task 0 hypothetical scores:\")\n", + " viz_sequence.plot_weights(pattern[\"task0_hypothetical_contribs\"][\"fwd\"])\n", + " print(\"Task 0 actual importance scores:\")\n", + " viz_sequence.plot_weights(pattern[\"task0_contrib_scores\"][\"fwd\"])\n", + " #print(\"Task 1 hypothetical scores:\")\n", + " #viz_sequence.plot_weights(pattern[\"task1_hypothetical_contribs\"][\"fwd\"])\n", + " #print(\"Task 1 actual importance scores:\")\n", + " #viz_sequence.plot_weights(pattern[\"task1_contrib_scores\"][\"fwd\"])\n", + " #print(\"Task 2 hypothetical scores:\")\n", + " #viz_sequence.plot_weights(pattern[\"task2_hypothetical_contribs\"][\"fwd\"])\n", + " #print(\"Task 2 actual importance scores:\")\n", + " #viz_sequence.plot_weights(pattern[\"task2_contrib_scores\"][\"fwd\"])\n", + " print(\"onehot, fwd and rev:\")\n", + " viz_sequence.plot_weights(viz_sequence.ic_scale(np.array(pattern[\"sequence\"][\"fwd\"]),\n", + " background=background)) \n", + " viz_sequence.plot_weights(viz_sequence.ic_scale(np.array(pattern[\"sequence\"][\"rev\"]),\n", + " background=background)) \n", + " \n", + "hdf5_results.close()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "UFQSYr9q_qI9" + }, + "source": [ + "## Load the saved hdf5 file\n", + "Load the results object from the saved file" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "WVtrMZ9o_mu0" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loaded sliding window sizes: [ 5 9 13 17]\n", + "For increasing = True , the minimum IR precision was 0.2954850349262155 occurring at 5.7220458984375e-06 implying a frac_neg of 0.41941626448668695\n", + "Adjusted frac neg is 0.99\n", + "For increasing = True , the minimum IR precision was 0.31974367348777494 occurring at 6.765127182006836e-06 implying a frac_neg of 0.47003410483096586\n", + "Adjusted frac neg is 0.99\n", + "For increasing = True , the minimum IR precision was 0.3469747405521833 occurring at 1.621246337890625e-05 implying a frac_neg of 0.5313343328335832\n", + "Adjusted frac neg is 0.99\n", + "For increasing = True , the minimum IR precision was 0.4006572406407763 occurring at 7.033348083496094e-06 implying a frac_neg of 0.6684943371454617\n", + "Adjusted frac neg is 0.99\n", + "For increasing = False , the minimum IR precision was 0.35928651361524633 occurring at -5.638343282043934e-06 implying a frac_neg of 0.5607600296390388\n", + "Adjusted frac neg is 0.99\n", + "For increasing = False , the minimum IR precision was 0.4258213778275138 occurring at -2.9428978450596333e-05 implying a frac_neg of 0.7416183072374903\n", + "Adjusted frac neg is 0.99\n", + "For increasing = False , the minimum IR precision was 0.11749949829420027 occurring at -1.7642974853515625e-05 implying a frac_neg of 0.13314383172256963\n", + "Adjusted frac neg is 0.99\n", + "For increasing = False , the minimum IR precision was 0.41327328308403144 occurring at -4.0531158447265625e-06 implying a frac_neg of 0.7043709978920574\n", + "Adjusted frac neg is 0.99\n", + "Loaded sliding window sizes: [ 5 9 13 17]\n", + "For increasing = True , the minimum IR precision was 0.2954850349262155 occurring at 5.7220458984375e-06 implying a frac_neg of 0.41941626448668695\n", + "Adjusted frac neg is 0.99\n", + "For increasing = True , the minimum IR precision was 0.31974367348777494 occurring at 6.765127182006836e-06 implying a frac_neg of 0.47003410483096586\n", + "Adjusted frac neg is 0.99\n", + "For increasing = True , the minimum IR precision was 0.3469747405521833 occurring at 1.621246337890625e-05 implying a frac_neg of 0.5313343328335832\n", + "Adjusted frac neg is 0.99\n", + "For increasing = True , the minimum IR precision was 0.4006572406407763 occurring at 7.033348083496094e-06 implying a frac_neg of 0.6684943371454617\n", + "Adjusted frac neg is 0.99\n", + "For increasing = False , the minimum IR precision was 0.35928651361524633 occurring at -5.638343282043934e-06 implying a frac_neg of 0.5607600296390388\n", + "Adjusted frac neg is 0.99\n", + "For increasing = False , the minimum IR precision was 0.4258213778275138 occurring at -2.9428978450596333e-05 implying a frac_neg of 0.7416183072374903\n", + "Adjusted frac neg is 0.99\n", + "For increasing = False , the minimum IR precision was 0.11749949829420027 occurring at -1.7642974853515625e-05 implying a frac_neg of 0.13314383172256963\n", + "Adjusted frac neg is 0.99\n", + "For increasing = False , the minimum IR precision was 0.41327328308403144 occurring at -4.0531158447265625e-06 implying a frac_neg of 0.7043709978920574\n", + "Adjusted frac neg is 0.99\n" + ] + } + ], + "source": [ + "import h5py\n", + "import numpy as np\n", + "import modisco\n", + "from modisco.tfmodisco_workflow import workflow\n", + "\n", + "track_set = modisco.tfmodisco_workflow.workflow.prep_track_set(\n", + " task_names=tasks,\n", + " contrib_scores=task_to_scores,\n", + " hypothetical_contribs=task_to_hyp_scores,\n", + " one_hot=onehot_data)\n", + "\n", + "grp = h5py.File(\"results.hdf5\",\"r\")\n", + "loaded_tfmodisco_results =\\\n", + " workflow.TfModiscoResults.from_hdf5(grp, track_set=track_set)\n", + "grp.close()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Getting the exemplar motifs\n", + "Numseqles: 83\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Parallel(n_jobs=10)]: Using backend LokyBackend with 10 concurrent workers.\n", + "[Parallel(n_jobs=10)]: Done 30 tasks | elapsed: 4.6s\n", + "[Parallel(n_jobs=10)]: Done 83 out of 83 | elapsed: 4.7s finished\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "After filtering: numseqlets 79\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIEAAACMCAYAAADr57kMAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOydd3gU1frHP1uTTaMTQu9VEKSogFTpHcGC14sVe8OfIvZruVe8louAKCAgSO9dpEjvnQgEQq8hFZJsyZb5/XESYNmWZDebBM7neeaBzO7OnJ2dOXPme973+6oURUEikUgkEolEIpFIJBKJRHJnoy7sBkgkEolEIpFIJBKJRCKRSAoeKQJJJBKJRCKRSCQSiUQikdwFSBFIIpFIJBKJRCKRSCQSieQuQIpAEolEIpFIJBKJRCKRSCR3AVIEkkgkEolEIpFIJBKJRCK5C5AikEQikUgkEolEIpFIJBLJXYC2sHZctmxZpXr16oW1e4lEIpFIJBKJRCKRSCSSO469e/cmKYpSzt1rhSYCVa9enT179hTW7iUSiUQikUgkEolEIpFI7jhUKtVZT6/JdDCJRCKRSCQSiUQikUgkkrsAKQJJJBKJRCKRSCQSiUQikdwFSBFIIpFIJBKJRCKRSCQSieQuQIpAEolEIpFIJBKJRCKRSCR3AVIEkkgkEolEIpFIJBKJRCK5C5AikEQikUgkEolEIpFIJBLJXYAUgSQSiUQikUgkEolEIpFI7gKkCCSRSCQSiUQikUgkEolEchcgRSCJRCKRSCQSiUQikUgkkrsAKQJJJBKJRCKRSCQSiUQikdwF+BSBVCrVZJVKdVWlUsV6eF2lUql+VKlU8SqV6pBKpbov8M2USCQSiUQikUgkEolEIpH4Q24igaYC3b283gOok70MA8b73yyJRCKRSCQSiUQikUgkEkkg8SkCKYqyCUjx8pZ+wDRFsAMoqVKpYgLVQIlEIpFIJBKJRCKRSCQSif9oA7CNSsD5W/6+kL3ucgC2fWdgSYbkPZB5BoznIf2k+L/5MtjN4LABDlBpQKUFbTiEVYLwGhBRC8IqQ2QtKN1cvHY3Y8uE1AOQcUYcw+tH4frx7GOZBYodUMRxVOsgtDxE1oGoBhBRA8KrQ6kmoC9V4E1dcmwJy+KWManfpALfV35Jt6TT4/cezHt0HjGRRVu7zcyE1ath0yY4dAhOnhTrAEJDoXp1aNIEWreGXr2gVMH/xE6sOrGK5SeWM67nuODuOD9knoeLyyB5J1w7AsYL4MgClRp0JSCyLpRqChUehvLtQB2IW0XueeuPt2hVqRVDGg8J6n7vWLJS4fIaOL8AUg+CPRNsJvG7asIgtBxU6guVekPJJqBSBa9tigMyTkFarGhb8g64Hpd9b8wS71HrQB0CkTWhzAPi3CzZWPTtQT43iyKKAidOwNGjcO6c6Bvj4sT/U1PBZgO7XfysWq3oLytVgpo1oV49qFZN9J/33QfhBTzEsNqt9JzRk1aVWvFV568Kdmd3OPEp8fSd1ZffB/7OfTHSiSHP2DIh7W+4FgumS2J8brwg/m9JumVM6QDUYoyuDYOQcmCIgfCqYnweVkX0R1H1RV91lzNo7iAerPwg77R+p7CbUqw5m3aWXjN6MXvwbO4pf09hN8ctiqLQb3Y/Hqz8ICMfGlnYzfHIT7t/YvGxxax6chUataawm1NkUCmK4vtNKlV1YLmiKC5noUqlWgH8R1GULdl/rwPeUxRlr5v3DkOkjFG1atXmZ8+e9avxRRJFgWt/w9VNcGUdJG2DrBTQGMBhBbsJ8H3Mb6IGrUHcfGwmCK8C5dpBdAeI7iT+rlABEhIK6AsFiOhouHIl75+zmyFph3iAubgM0o+JY6k4xPHAnssNqcXn1FqwGyGsOlTqBTHdoFxb0EXkvW0+aD6hOfsu7+Pq/12lXHi5gG8/EPx787/5cP2HvNHqDUb3GF3YzXHBaIQ5c2D6dNi2DfR6SE/3/pnISLBY4N574Z//hCFDoHTpgm9rzxk9WX1yNZaPLGiL4oNpxmk4PR3O/A6Z50SfYjd6+YA6W3R2QEwPqPEPqNRHCEUFiNlmJvzf4dQpXYdjrx0L7Mbv5L7ydtLj4cwsODcP0uOEiGLzcvGoQ8QDjEoLMd2h2mCo1A8KYsBkz4LLq+DEeEjYcHMCxJ6Z/dDljZzzUgG7Bcq0hDqvQJX+rpMkd+jv7XBAbKwQxFesEH2jzSYEHotFLLlFowGDQfxrNELt2tC9O3TuDG3aQMmSefw+XlAUhccXPM7cv+cCMLX/VIbeOzRwO7hDf293XE6/TLNfmpGQmUDJ0JLsG7aPGqVqBKCBFI/jCHk7looCaYfh0krR56QdAkuiEHUUe/Z40pH3Nqi0YmwJYrwaVhlKNxMTKBV7Qq37i/6xDNQ9B5gVO4shC4agVWs58foJqpesHpDtAsXjvAzQsUy3pHPvz/dyOu00FSIqEPtyLGXCygSggYHlhx0/MHz1cNQqNXte2EOzmGaF3SQXjicfp9FPjbA5bHz00Ed80emLwm5SUFGpVHsVRWnh9rUAiEC/ABsURZmV/Xcc0EFRFK+RQC1atFD27Nnju/XFhYwz4uEqfqKYQUDJFnwKCG2EEJWiGkCvAwW3n0CSi3PtBsl74Oh3cGERaELAZgTFFtj2qNTiONpNQlBr8B5U6BSQTaeaUin7TVkcOBjdfTRv3P9GQLYbSIxWIzHfxXDdcp1QbSgXh1+ktCEIakkuUBRYsgSGDRMPJjkRP3nFYBAPRt9+C88/D+oC1C/KfVOOJFMSW5/dSusqrQtuR3nFZoTDn8HxMUI8zYmuyCvaCAirBg9OhTJu7ycBYdHRRQycOxAVKpLeSwrsORnMCBd/yEtfeTvWdDj4EZycKB5u/Pm9DTHwwBQo1yb/7bmVpF0Q/wucmwuovItSeUEbISJqK/WGOi9BdEfRv99hv/eFCzBxIowfL/pFux3M5sA3R62GiAghJnXqBCtXBma7b656k0n7J2G2mXEoDgxaA/MGz6NX3V6B2cEd9nt7Is2cRosJLTh77Sw2hw21Sk2FiArsf3E/5cPL+9++4nIcwfuxtGfBlT/h3HwxieiwiHFzfvvEvKAJE/fbJwrgAi0I/DwnQQiT9cbWIyMrAwWFlhVbsuP5HagDNXFUXM5LP4+l3WGny/QubDu/DYvdgk6to0l0E7Y9tw29Rh+gRvrPnkt7aDelHRabBQcOKkZU5OhrR4kKiSrspt3AZDXRZHwT4lPjUavUhGhCWD5kOZ1qBOZZrzjgTQQKxJW5FPhndpWwB4BrvgSgOwbFAecXwsp7YXkDiP0SjOfE7HpBCkAAtgxxQ0srJgJQbrCb4dRUcSzXtofzc8V3tF4PvAAE4vezXheDgsurYVO/gG16zt9zULIjvsbtKprpQeP3jMfmEMdVURS+3fZtIbdIcOIEtG8P//gHJCbmXwACMJlE5NDw4dC4MRSU7nwp/RJJpiQA/oj/o2B2klcUBc4vgiXV4fhY5/Sa/GDLgOt/w9p2sP1pkeZaAEzaL9InFRQWHl1YIPu4I1EUODUdFlcVApDd5P/vnX4C1neBzYPB5MdtPT0e1naCdR3h9G9i24ESgHLa6jCLdLdN/WFVU0hxCUYuligKLF8O7dqJKJ1Ro272iwUhAIGINLp+XYhAq1YFZpv/3vxvJu2fhNFqRIV4mDPZTDw6/1G2nd8WmJ3cBZisJjpP68z56+dv3L8dioPEzETaTWnHdcv1Qm5hEcB0GfaPgIXlYeuTcHqaiMi3ZfruE7XhIrqwwsNQsRdUGQjVHoPKA0RkT3QnkfrlK+3LbhR90l2Coig8ufBJTDbTDdHnSOIRRu8oehHmRZ03/3iTnRd3YrGLkE6rw8qRxCM8vfhpchO4EQzSzGn0ntkbk82EKlucSzYl84+F/ygybQR4acVLXEy/CIAKFSabiUFzB3ElIzCRb8Udn5FAKpVqFtABKAskAJ8COgBFUX5WiV9/LKKCmBF4RlEUn49axT4S6NIfsOdVMF8VA9DcElZF+G2EVQJDJQivJm46Ki0oWUKUyDwLxotguihSy3w9bD3p31cJGp7ONUURg/fdr4gHl7wcz0AzJDCdV+PxjYm9GotGpSFEG8Ku53fRqHyjgGw7EJhtZmK+iyHNnHZjXbgunIvDL1IitEShtMlqhY8+gjFjxMOHIx+R2b4wGODRR8U+IiMDt91pB6cxdLFIa2hcvjGHXj4UuI3nh8yzsO0pSNknUmwCjToE1Hpo/gPUei5gm83IyqDsN2WxOqw4FActK7Zk1wu7Arb9O3Ym8XocbH1ciDa2Avi9VXqRStvkc6g/PPfH0ZoBhz8VaV+OHH+NIKExwOMFPBkTKDz83tu3w0svOfuf5QWVCsqXh6go0OlEn2qxwOXLeROQ/B3TT94/mddXvo7RJtJPNSoN9lvOhUh9JNue2+a/78Wden1nY3PY6DGjB1vObcFsc/0BQzQhNK3QlA1PbyBUG5r/9hWX4wjOx9KSAvv/D87OEusdPvIiw6sLD7RSTUW0Y8nGEFJWRM/esG1QZS/KzXWqbHsB40VI3QdJ24WfWdpB8UxwK8V9fJ5LJu+fzBur3iDTmul0fYfpwtj/4n7qlqnrfxuLy3npx7H8ec/PvPPnOxitrqn64bpwPmr3Ee+3fd+f1vmNoij0mNGDv878RZY9y+n3DteF8/XDX/Naq9cKtY0AMw7PYNiyYTeOZU47dWodzSs2Z8szW+4KfyBvkUA+jSsURXnCx+sK8Go+21b8MF+FLY9B8i4ffhrZhFeDKo9Axe5QuqV4cHJkCQ8ETaj72QS7RSw4xI0mK0V4C11aJSKPslID/rUKjczzsO1JcSPNy8NLeDVhWBtZV6TERdYSZn1qHaACxSoGBBmnhHl0+glI3ArXA+wx4oYTySeIT4m/8bfVbuXX/b/yfbfvC3zfuWXSvklY7VandQ7Fwf92/I9PO3wa9PZYLNCnD2zZIqJ3CgqTCWbPhr17YfPmwPldLD62GBA3mbjkOK5brhdeSOy1Y7CmDVivFdxDt8Milj1viGur6dcB2eyyuGXoNLobM9yHEg5xJeMKFSIqBGT7dyQp+0SEjTWdvPnN5QElS6RWHPpECE73T/D9mQtLYcfTIgKtoCNj3VEY+wwQqanwxhuwYEHu+8OSJaFtW+Hl066dMH4uXVqI63a7EIBUKpHqFRoqtpuQIMykV60S/kJHjgQkK8SJpceW8trK1zDZbn4RFSpCtaE3hIyMrAzaT23PvmH7qFayWv53Fh1dPDxD8oGiKDy16Cm2ndvmJABp1VrsDjsKCha7hUMJhxg4ZyDLnliW/wec4nAcwflYnl8MO57JjoD0Iv6E14Baz0OdYdlenTbhC3TrWFyfy4mwiOpiqdhL7FcTKoShuB+FPURWSvE4lvk8J3M4d+3cDQHodsw2M4PnDWbfsH3+P3Df4cfyr9N/MXz1cKe+8lYyrZl8vvFzGpZrSN96ffO9H3/5YccPbD63mSy7a1RdpjWT99a8R5sqbQrVHyguKc5JALoVq8PKoYRDfLrhU77s9GUhtK7okCtPoIKgWEYCJe+BDT0g65oQGTyhMUCNfwqzysg6Yp3W4P/+rRliNjZxG5wYBxcWi5Sm4cWkY7zdLO3iCtj6mBC8fKZ7qaBCZ6j5NFToIjwgFHt2FJWPrEaHQwh2KpVI/UrYAGemi4eU2/cbgEigkWtH8v2O750U8pKhJUl6N6lIqM5Z9iwqfleRZJNrhFmEPoJLwy8RGRLAMBkfmEzQrZtI1SpIAehW9HpRDScuzv9tKYpCqVGluGa5hkalIVwfzvQB0wvnJp12GNa0EwJQQQkCt6MJg8cCE33ScWpHNpzdcOO6CdOF8Z/O/wmcp9adNpOYuBX+6h7c6Elfv7eiCA+qo/8tfCGmGM7CHz8u0mFTU30bPEdEwOOPw1tviVQxs1ms0+TxNpOZeTPycvZsGDcODh5027w8seXcFrr93s1pIG7QGnj+vudZd3odRxOP3kib1qg0xETEsO/FfYVXSCE3/UMhjZnfXv02E/ZOcDmWv/b9leeWPuf04BimC2Nww8FM6TflRqpG0AnWsXRYYesQYfjsbWK2TEto+g2UuV+0TeNHpJQvbBkiuv/cfFFQwR9y+/sV0nmpKAptJrdh18VdN6JBbo/0C9eF88FDH/DBQx8UShtvUISv7+PJx2kxoQXpWTfTpA1aA60qtmLP5T1OAluYLoytz26laYWmQW/n7ou7aT+1vVN/o1Vp0Wq0TuJ0TEQMx147ViiToSaricbjG3Mq9dSN+4tOrcOhOJzOS4PWcFf4AxW0J9DdwanfhBeGJcmzAKTSQt03YMAlaPatKEWuNQRGAAJRwUoTKsyLH5gKfU9D5X5CXFGU/C+5xZ993C4AnZ4BWwaL6B9vApA2Auq/Df3Pw0MLodoTouy7Ngx0kbmrVKRWi2OnDQd9SVFF5oEpMDABGn8mIogChENxMGn/JBeF3O6ws+70uoDtxx+mHJjiNpQcRPvH7hobtLZkZECHDrB7d/AEIICsLDh9OjDbir0a63RjSbeks/z48sBsPC+k7IU/24I1jaAJQJC7iMhckGpKZfuF7U7rjFYjE/dNDMj27ziurIX1XYOfPuvt93bYRKTs0W/zLgAZYoTnRsMR8NBi6HkY+pwQS69Y6LAK7vkEKvcXaRx3INu2QcuWYk7HmwBUoQJMngxXr8L330OjRhASAiVK5F0AAlEWPjJSLE8/DVu3igihvn7o2IcSDtFjRg+XmdiYyBj+2+W/LHh0gVPKkl2xk5CZQPup7Um3BNAv6g5g1JZRLgJQmC6M11q9xhONn+CT9p8QrrtZGc9oNTL/yHxGriu6JZsDguIQ/Y03AUgTBi1+gs4bRGVdraFgBSAQ41ZNqPASusMZt3schxIOOY2BtGqt0/mYac3ky01fEns1tjCaWORJMaXQ6bdOZGQ538tLGUqx/MnlVIqq5LTeaDXSZXoXLqcH1343zZxGn1l9nAQgjUpD55qdMdz2nJtiSuHJhU8Wij/Qi8tf5FL6pRsCEECINoRBDQc5GWubbCYemfvIXe0PJEWg3HB5Dex+2fugNrw69Pob7v1KCA0FUHLcCV0khFeFB38v2P0UBHFjYdcLvh8SajwF/c9Bky+Eh1JuRZ/coIuCkNKiIli/01D//0SKnp9sPrsZi8119J6RlcHPe372e/v+YrVb+eSvT9yG7YK4uXy99Wu3IZSB5to1kb5w6FDBGZx6w+olmC8v/HnyT6fUOgWFFSdWBGbjuSVxO6ztALbiawq68OhCtGrXDOX4lHjOpp0thBYVYS4sg439AibABQS7BTb0hksrct8uXUmo9QL02A99T0LrGdD4c6jSD0reA5G1xVKikUipvucjMQHS628hDtUfDqF3RqrgqlXQpYswZPY0btZo4L33ID4ehgwRHmeB9DYD4R0UHg7168OMGbBjR963cTr1NB2mdnB5qDFoDSx4dAEh2hDql63Pl52+dHpYtDqsnEo9Rbffu7m9j96NTN0/lc83fe5yT64UWelGKsO7rd+lXtl6aG4Zw2RaMxmzawz/2/G/oLY3qOx6WRT18NTf6EtBz4NQc2h2yleQH3l8mUcXc06mnGTE2hFO48lQTSivt3rdpTS82WbmkbmPuNgQ3O1Y7VZ6zuhJojHRSbQI04Xx+4DfidBHMHPgTBeRJc2cRpfpXTBZgzN7qigKj81/jFSzsx2JTqNjfK/x/NDtB6e+3GK38Nfpvxi7O3iTygC/H/qdBUcXOAlV4bpwPu/wOaO7j3YZY2ZmZdJ/dn/sjiD6FRYhpAjki8xzsHmQd8EiuiP0PAARNQte/LmdYO/PX84vggMjvB9PXRR0Widmb/SlRARPQaE1iO03/hR6+F9p7ec9P7sMfEEIA6viVxX6DOeMwzPIzHIWgHIqteRgd9gLXLByOIQH0NGjhSMABZKFRxfeqOKQQ4ophfPXzgenARln4K9CiAgJMBP3TXQvTiowO3Z28BtUVEk9JEygi5IABGKiJHFT7tqlKyH694GX4b7vhTGrxiAmULyVwFXrhF+HNkyIQ02+ECJ+2/kikqiYcvEiPPaYKPvuiYgIWL8ePv5YiDQhIQXfrogIaN48b5+5mnmVtpPbcs1yzWl9mC6MEW1GOKUwvPXAWzQq18hJvLDYLRy4coBBcwfdtQPzHJbHLeeVla+4CEAGrYGFjy28MautUWuYN3geIVrnk8JoNfLBug+YeXhm0NocNK4fhzPTPPc36hB4eJMoxqINC27b7gLsDjuD5w12iSpXq9V88NAHfN/teydRQEHhwvUL/Gvjv4Ld1CKLoig8t/Q5DiUccsoe0Gv09K3bl441OgLQvGJznmn6jJMQZHPYOJV6isfnPx6UaJvvd3zPlnNbnNoZqg3lpRYvUaNUDZ669ymXiKVMayYj1oxg3+V9Bd4+ED5ALy5/0aW/LBlaktdavUZ0RDQj244kTHezP7A6rBy+ephPNwTfC7UoIEUgX2zq7726TomG0H6ZGNS6mcWW3IIlOdu4z8tIN6QcdNsF5VoHV+DSRUBUPb82YbQaWRK3xEnNvxWtWsv8I/P92oc/2B12Plz/odODtlal5f5K9zuF5WdaM/li0xceU8YCwahRsG+fSMsqzlhsFvZedi1FrVVpWXNqTcE3wGGFjX0L33vFTxIyEjhwxb0Ia7abmbRvUpBbVESxZsDGXkXv9z49A87OyUW7VMKUtd9Z4e+mCfWvn9eGiW1U6iMigxp9IIovFCMcqBg0yHs6bHS0MLNv2VIIM8FEm4dhzXXLddpNacfVzKs4lJvlHVWoqFWqFh+2+9Dp/WqVmrmD57pUsjLZTKw/s55hy4cVqXLDwWTrua08tuAxF5PYMF0YH7X7yKWSWs1SNfm+q/ODN4hj+fzS51kdv7rA2xxU/v5KpJ96ouZQEaGvCYJaehfy3fbvOJ583Ok6D9WG8vYDb1PKUIouNbtQu3Rtp88YrUa+3/590ESBos53279ziVoBcRzH9nSOoBnVZRThetdre93pdXy0/qMCbeeui7v4eP3HLuKKXqPns/afAaIvn9B7gpPAktPG3jN7c83sPCkQaExWEz1n9nSJjArXhTOu5zh0GhGV93+t/8+lj8w5L9edKhqWHcFEikDeSD0kKqF4qrCjMUCHP0AdIM+fO52dz/mIACoB3feI6g0FnbPtDj9DdxcdXeTV+DkjKyPooZG3Mjt2NtctzulCeq2ezzt+7jLQttqt/Lrv1wJpx86d8MUX+St5nINOBw0aQKtWcP/9whMjrBAm+7ad3+Yy+wqQYc1g0bFFBd+AA+9Dxkn/qoDpS4syuWUfhNItRIQFwTUTnXdkntdr52L6ReKSAuDiXdzZ8azwpcuv55NKLQxSqwyCGkOh+hDhwxNSJv9tunYMdg3zHQGkKwEP/wX3/ZAdzRPA+6ZGLyI6G30gIjoNlXx/pojwMy9x+DDYPDzPqlSweLEwsjcU4aGG2Wamy7QunE47je02n79QbSgLHl3gNt2zWslqjO4x2u3AfHbsbD7+6+MCbXdRJPZqrFs/JbVKTd0ydRnRZoTbzw1rPowWFVugu20sY7KZGDh3IDsv7CywNgedC0u8+0nWf6f4RcoXE44mHuWzDZ+5RO5qVBrebf0uACqVyiUaCG76sNzt6Z7L45bzyV+fuFzj4bpwxvYcS5kw53tyhD6Cqf2muogsmdZM/rfjfwUW7ZdqSnXxAcpp5386/4cSoTcr6bWv3p62Vds6RXZCcPyBhi0fxuX0yy6T8LdXUgvVhvJjjx/dnpeD5g666/yBZOiKN078LMq5e6LKIyJ8Pdh5xsWRpJ3CW8nb8Ww5XkQCeUsHKMKM2z3OKRVMhUpU5rilTzqSeIQzaWdc8qULGofi4IP1H7ikqlWMqEiXWl24p/w9ThEtmdZMPt3wKS80f8HJSM1fzGYYPDh/JtAxMdCrl0ibaNNGePrkVLRRq0V6xN69orrNihVw6lTAmu2RlfEr3ab/AWw8sxGH4kAdKB+r20naBSfG5y8qpNR9UKk3VHsUImqLMt45J6pKCzjg0io4v0B4LlgL1mto4r6JXn2o7IqdmYdn8q+Od3Eo+YVl2X47eYzQ04SKe1XVwRDdGXAI0xmVGsg27teECjHx3Hw4NweuHcndtm0mUTHT1zloqAhdtoKhQsEK/NpwcT73PAhr20N0UpGvnPk/zTteBfF334V77hEVDYsqWbYsWk5oybHkY9hui87Qq/V0rdWVJXFLPH5eURQqRlbkZOpJp8gCo9XIN1u/IdmYzPje4wus/UWJ7ee303laZ7dlojUqDd1rdeeHHT94/Hy7au3YccHVyMloNdJ+anuWPr6UrrW7BrTNhYKvfjCkbGD2s7ACmP3pQ9Qw5M5Ja7Q5bAyaO8glUtygNfBu63edRIGO1TtSv2x9l2jpqxlXGbluJN93+z4obS5qHE44zOMLHne5xtUqNU0rNOUfjd1XlOtVtxcdq3cUPpSOm95KRpuRF5a9QM1SNXmg8gMBa6eiKDw+/3HSzGkur5UNK8uw5sNc1o/rOY4m45s4fTeL3cKGMxsYu3ssr7d6PWDty2H6oeksPLrQ5XgatAYm9JngUiHxsUaP8dXmr1yMyjOsGfSb3Y9tz24rEpWcg4EsEe+NBeXBkuj59a7boWzgLrhCIxglKPe8Kcrae4pYqPAwtFtcsP4/BcjF6xep9WMtJ2+YKH0UWrWWFHPKjXUhmhBGth3Jpx2Cm3867+95PLv0WSfBwqA18GWnLxn+4HCmHpjK66ted3o9Qh/Bd12/c9vR55cRI2DsWO/eF7cTEQFffgnDhoHd7jsdImfbS5bAm29CopdL2N/ur+6YupxIOXHj71tLo0boI9j09CaaxTTzbyfusGfB8vqQmccSZ1ENRGW8Eo1E5JuvUHnrNUANB0cKwemWBzQnhuT/QJ6/dp46Y+o4XTs6tQ6NSoP5loF+5cjKnHv7nH8lj4trifisNFhaE7JS3b/fE5X7Q6tfRNSqLhcOwvYsMbt+dg7s/z/ISnH/vpzf+9j/4OCHPlJ8y0LPQ6AvC5ogGaU6HGBLFxFH/lDAJYXj46FJExgoWX4AACAASURBVM+iuE4HKSnBTwHLCw6Hg7pj63Iy9aTH97iLAHLH7QLSrbzR6g1G9xid5/bliUIuIX0k8QiNxzd2EsJuRa1S52pSQVEUp2pNt6JCxY7ndtCqciu/2uqTgj6Wvsbn3XZDGbdVkfPGzADcM/y4Pxa1EvGfbfiM/277r8ukTYQ+gkvDLxEZ4nyf2XR2k9uoNoPWwLp/ruPBKg8WeJtvUARKxB9LPEarSa2cSsHnoFPr+KrzV5QPK+/x82nmNN5b+55LBWKAMG0YG5/eSItKATjvgW+3fes24itMF8aCRxfQvXZ3t597beVr/Lr/V7dC4eZnNtO8Yh6N5rxwLOkYzSc0dzm/dGodgxoOYuYj7iOktp/fzsPTH3b5XJgujLfuf4uvOn8VsDYWNrJEfH7xNfsdWTc47SjuKAqcm+09ZaX+8GIrAAFMOzjN5eHUYrfQr34/J+Nli93CL3t/CarPgaIojFw30iVixaE4eLLxkwA80uARlwF4RlYGH//1ccCqORw5AmPG5E0AevRROHsWXnhBpELk5mEoLEwsAweKaKDXX89f2WRfJBuTOXvNc9Uqq93Knyf/DPyOAY6MytvspDYC7vufSLcs3UKEyefGK0FXQogH934NvY6KlLEAMzt2tsu1Y9AaXGZiUswpHL56OOD7LxbsfxdsebhwIutAly3w4HQILZ87AQiy06rCoPoTwnC5zsue32vPgtgvfaSBqeChhSLlMFgCEIjQQG0RVk6ymTfvZjSjOx5+WAjfRZnWk1t7FYBAiDu5Wbzx464fGbVlVCCbXqS4dP0SzX5p5lEAAnHPzs1x9CQAgTDobT25NSeST3h8T7Gg1nOg9hJV+PdXYC3cQhx3GgevHOSbrd+4fXAe2XakiwAEIjKtSfkmLutNNhOD5g0KSiXaokKaOY1mE5q5FYBy+NeGf/Hqylc9Lh+u/9ClmEsORpuRByc/yKXrl/xu666Lu9xWElaholmFZh4FIIAvOn7hVvg32Uz0nhU4fyCj1UjPGa4+QCAmHr7t+q3Hzz5Y5UE61+js0k6j1cgPO364a/yBZDqYN3yVDPfHh+NW7vRw0+vHwENJckDMUkd3CFpzAo2iKPy852cX1fv+yvczoP4AFhxd4OTFk56Vzo4LO4I2A7Ls+DISMl3Pr1aVWhEdEQ1AZEgk3Wt1Z3HcYqf3GK1GZh6eydCmQ/1uxyef5N4IWqWCyZNh0KD8z4KHhIjl3/+GAQOgRw+wBDANff3p9YRoQtzOyIAQ/BYeXciItu79G/KNLROOfpP76lCGGBG1GFIu/1VSdBGgqwud1sD+9+DET/nbjhsm7pvocu10rtGZ9WfWO62z2q1MOzjN6439jsSUAGd+B0cuT94yLaHTWtCE5b9YgSZULE2/gTKthJ/b7Q+nZ2f6blPjT6BUs8IxZy0G4dxxcd77pA4dAl8CPpD0n92fnReD5zPz/rr3qRBRISD3o6LEdfN16o2r5/FeEmjsip3G4xtz7q1zlI/wHHVQpKn3FsT9z/PrF5bAlXUQ06VYTzAWFbLsWTwy9xG3aYpatZY373/T42e/6/YdXaZ3cRF8Uk2pvL36bX7p/UvA21vUcDgcNBzX0GvBFavD6pTmlR9sDhuNxjci4Z0E9Nr85RCfTj1N28ltPbYlyZhE05+bun0th6iQKDKzMl08ehIyEmgyvgmn3zyN2k8rlRYTWnAm7YzLPlSoiAqJoueMnl4/n2XPcluB0mQz0e33bux5YQ9NY7x/z+KOFIG8YagAGV6MRa5ugsoD/PcE8ksAAvAylVgUMF0WDyOedKqo+mJWWVOEXS+9sP/KfpJNyU7rDFoDjzR4hA7VO7h0+karkQl7JwRFBFIUhRFrRrhEAUXqI3m15atO615q8RLrTq9zmqXIyMrgw/Uf8o8m//ArR/bcOeHTk5tZbY0GZs2Cnj1FKWR/iYgQ5tHr10OXLnmLRPLG0rilLjM6apXaaRb2QMIBTFYTBl0Az+34SbkPWQ6rCt22g75cYCIxtOHQ7BtxrR77zu/NnUg+wYXrF5zWhevC6Vu/L3bsLI1bemO91SFEoP92+W/+U8Kio4u8RwzR0c5/H/s29793+XbQfkXgDFF1EcJEWhsJWx+7OfGhOODQx2Bz74cFiGqLDd6T5Zm94KsviogoupaDMw7PcLo+b0etUufbT87bg9KwZcN4oPID1CvrXzXPooLdYaffnH4eveUgOz02H/dfh+LwOknRfUZ3djy/I6C+f0HDEC1E6gPve5gQUWDLYGi3RPSL+e0TQ6MDMEYv/gxfPZyL1y+6rA/VhvJKi1e4mnkVPMz1xkTE0LBcQ/ZccrYAMdlM/HbgN/rV7UfPut4f2Is7HX/ryOWMy0HZV5o5jRYTW3Do5UN5/qzD4aDFxBYeBSAFhbjk/BfpUFA4d/0cg+YNYuFjC/O9nWHLhnE06ajHfSRkJrid/M4tdsVO2yltSXkvJd9iWnFAikDeqDUMYv/l2fTyxE8Q0xXURXiqrijgy8BPE0q+q93cjl9RVfmLqPpl7y9uB63da3cnMiSShuUaOpW/digO5h6Zy/je411K4waaP+L/4Pz18y7rbQ6bk2M+QOeanV1c/QGuWa4x9++5PNH4iXy345tvvKc95KDVwsKF0KlTYASgHMLCoFkz2LxZzK6n+xklrigKq086l9w1aA0uA+5QbShbzm2hS60u/u0wB4dNhLnbc1FaLaIWdN0mUnHyGxHiDm04NPmX+Df2c782NePwDJfUBbtip2P1jtgddtadWucUjmyymdh1cRf3V74/fzu84mflh2B7Clivw/HxuYsCiukqUq8CPeuti4CK3aH9ctjUFxxWSNoOWT5Cuu/51O+Ki3c6pUp5f/3SJRE9WdRMof848QcvLH3BZQY2hxIhJTjx+gnKhZfL1/bXnFxDv9n93EYdWB1WHpryEPtf3E+lqOJTBc4diqLw/NLn2XVxl9vX9Ro9XWt2ZekTS/MtfA9dNJS5R+a6HaPEJcXx+PzHmf/o/IIrYFCQ1Htd+KUd+dq9EKTYYGMvqPE0tPhRFD3Ia1XCgbm4ZwTCN6gIM2X/FMbtHuf2NbPNzJhdY3xWvnUXcQFCjOw9qzfn3z5f7K9nT3y3/Ts2ndvk8XWdWpeviUKzzexR5D189TAj1o5g1MN5S6HtM6sPKSYPXoABZNGxRUw/OJ2n7n0qz59dcXwFE/dNLIBWOZNpzaT91PZsf357ge+rsCiGvX4QqTnUsxEqQMJ6MRjOa7WWuw1fMzBZKdkViQKAXzM2eY+ostqtzDo8y+VBNkIfQZ3SdQAY1GCQy0ybRqVh+fHl+W9qLlAUhRFrR7jN6R3QYIDLTUer1vLPpv90yZHNyMpg5LqRXr0KvJGaKlK7cpMK9ssvgReAcjAYoGFDWLrUf3/gk6knXWZutWotFSMrOq3LyMpg5YmV/u3sVs7Ny101MF0UdNkM+jKBFYBy0IZDw3eh5rN+bWbKgSkug5gSISWoVrIanWp0cjnnTFYTvx38za99FiuO/0SuBPLI2tB2QcGlPWjDofxD0Cw7+uvqFu/CVFhlYUotRSCvtG7tPd11yRJRBbEosfPCTh6Z5z4tBIQ/yNT+U/MtAAF0qdWFIY2HYHDzwK6gkGJKEbO0QXhYKUg+XP8hc4/M9eiLknMs/THDH9tzLCVC3BukG21GVp9czSsrXgmqT2FAafwxNP4sO5LcwyPN6amwtBbE/SiE9QKudnknkWJM4YVlL3h9T6Y1k4ysDK+Lp/4CxDX90JSHAt30IsHui7v5eN3HHl+P0Ecwtf9Ufuv/W56X6QOmUzq0tMdt/7jjR/46/Veu2/rrvl9ZGR/A8aoPnl78NGfTPPtquiPJmET/2f0LqEWu7Li44472opMikDcMFaDa497TlLYMBkuS99LnvgiN9v2e4kxUA+9C2fW4/JW5LgKsil/ldn2POj1uDNx61OnhIgKlZ6Uzdpf3mRN/WX96PadSXdMZw/XhvNT8Jbefeb7Z825Dw5NNySw6uihf7Riby685cKAo/14QAlAOoaHQooUou+wP7gyfzTYz7au1d1rnUBwsPe45ZSJPKAoc+sR7Ck4OD04HXcmC9UXRRojZ1agG+fr44YTDJBmTXNZ3qSmipmqUqkGE3vkJ2a7YhejqYVbxjsJuEQbgvryf1HqRAlbQ6bTacKj1LFTqA1dWe7/n1Xw2uwS9xBv9+3sXeWJj4erV4LXHF0cTj9L1964eRYsQTQh96vahf33/B+mju4+mlMF9qJRdsXMp/RIdf+tYbI1lR+8czeido70KQNP7T6dMWBm/9hMZEsm8wfPcCmog0tOnH5rO5xv9i+osVBq+C933Qcl7QONhAGFJhIPvw4KysP1pSNggzPZtmSKaKL9eLHf4JHD7qe29Go0HitNpp4v3OeiGC9cv0O33bpg8PN+E68KZPmA6QxoPoX/9/nleHm30KAseW0CYzn3Ktdlupt/sfrkygU8xpTBsufdKwGG6MMJ14XlaPPU7AA4ctJ3SNk8CdPsp7bEpnosIhGpD89zGcF24R7NtgJHrRrpNhbwTkOlgvmj1MyTvhPQT7o2grdfhjxbQYaXwQMjPTOydHm4aWg5KNITU/Z7fc3YO1Hmx2M0c/7T7JxdfmEh9JP3r3RwEN63Q1G0Hs+PCDq5mXqV8eMEYM7qLAgJRRrJN1TZuP9M4ujExETEu1V4ysjIYsXYEAxsMzNOspNkM333nuQRyDuXKwZQpBSsA5RARAZ9+Csv9CMRadHSRy8xWjVI1aF+9PQuPLXQa2F+8fjEwv/OVtWDORU55tccgulPew97zgzoUHlqQr49OPzTdpfJcpD6S3nV73/i7S80uzIx1LvFpV+xsPreZDtU75Gu/xYYzM0DJxYNJ439BWKXgGCFrw+GBqbCkuvf3VexROGbQxYwSJaBtW1jnpRDJ0KGwalVw+kZvnL92nnZT2zkVObidyJDIgJm8huvDWfDoAjr91sltFEGWPYvjycfpNaMXfz71J7pgVp/zk1mxsxi5dqTH6IhQTSgD6g+gd73ebl/PKw9Ve4gX7nuBSfsmYXRTZdBoNfLNtm+IjojmpRbuJ4iKPCXqCyHo5EQ4/JkQd9xNmDiscGGRWED45pW6Vyxl20DJJmLM6rABjuxsAAVQCWFbpRH/Zp4XY9qkbcH7jkFmzM4xxCbGBm1/n234jKeaPEWNUjWCts+CIiMrg06/dfLYX2pVWtpUbeO3YN6hegf61u3LomOLsNhdo3MzrZl0+q0Th14+5FFUVxSFx+Y9hlqldhvxr9foebbps7Sq1Cpfbfxl7y/subTHrZiYbEzmx50/8uYDno3Fc/jtwG+cSnPv06tCRaNyjRj+4PB8tTE2MZaxu8a6Ta9Tq9QMmDOAbc9tc1v1rDhzZ32bgkATCh3/gJVNsstNulEszQnw5wNw3w9Q8xlQhxSLyiRBpcZQUSXMU8TPka+h5tPFSgRKMaWw4cwGl/UWu4VONTrd+FutUtOpRieWxC1xep9apWbGoRm8/eDbAW/b5rOb3Zqm6TV6nrvvOa/5/6+0fIWP1n/kMkBNyExg2fFlLl5C3lizJncWKZMmiUpewSIkBGbPzt9nbQ4bW89vdVnfpkobWlRs4eKrpNfoWXdqnV+eSgCcGC8Gtt4IKQMtfw6cMbAv1BoIq5LnjymKwrSD01zMBy12i5O406tuL5YdX+YktGZaM5l6YOqdLwKd/NX3712yMdR7I7jmy8bL3itjqtRQ8t7gtaeY8/nnsG2bZ6F882b46Sd4+eX8V0r0l2RjMm2ntCXVlOrxPQatgTmD5lAi1H3qUX54oPIDvNrqVX7a/ZPbiBmzzcyuS7t4YsETzB08Nzi+Nlc3CYFArRNReDf+DRGVGH30vX/G/8lzS57zmh5TIrQE43uND2izR3UZxdLjSzmTdsbt60arkeGrh1M+vDwDGwwM6L6DhloDdV6CWs/DhcUikjItVvRJniIqjefEcnHZLdsJEb+jOlSI2WqdKF7iMIvIH2u68Bu6g0m3pPPW6re8vic/huKKong1He78W2dOveWlIE8xwKE4eGTuI5y/dt5jFFWINoTJfScHZH9je45lZfxKtyKQQ3Fw1XiVnjN6sumZTW7F8v9u+y/bLmzD5nB/TtcrU4+fev2U77TU7rW7U3tMbbd9uMlmYuS6kbSpKsbPnjiaeJRXVr7isWhAqDaUxY8vplbpWvlqI4jUva3nt7oIYXbFzt+Jf/PR+o/4+uGv8739oogUgXJDeDXouhP+6grmq+69EBxW2POaeFBr9q2oRqBSZ5seS6j2KBz80PPrpouw901oPtq/B9ggVnKYFTtLVOy4rY+vV6aey0B4YIOBrDu9zslHxmQz8dPunwpEBHpv7XtuO1y1Ss2zzbz7uAxpPIQP1n3gsj4nGqhP3T65vhksXOjbhLlFC+jcObgikEYD1avn77N7Lu1xmQ0I14XTpkobGpVr5HKTSs9KZ0ncEv9EIMUhIoF80eiD4Pc5+bhe91za47YaToWICkRH3EyP7Vi9o8vMjENxsODoAib2mVisZv/zhM0IKXt8v+/er8UDSzCxpmQ/FHl4PaL2Hf+AFEhat4bXXxdps56qhY0YIUzzhw0LfkSQyWqiw28duHD9gkdfuFBtKE/d+5TT5IdP7BawJIt0+qxUEfWWk+ap1gifQH1Jvrr/JRYfXcTJ1FNujaiNViNLji3hrT/e4sceP+btyykKZJ4WKekZp6F0GKR4SS8roYKNt0+CKNlzgw4hEGhCwVAZImuJ9KSI2hBRE0o0ZG/qRfrM7uO1FLxBa2Du4LlEhuSy4IjiEBHplmSx2DOFSKXYb0auqPWE6kuxsN8vtJnR36MAZbKZeHTeo6wfup521drlbv9FEbUWqg4SS+Y5uLQSzs6CpJ2iv7QbvfdRDgtYcmHGnxuKqd3Dm3+8iUalcR8ZotbTt35fWlduna9tT9w3kWNJx9xez5czL7Po6CIGNBiQr20XBd758x22nNuC2UOqYLgunH93/nfAjLDLhJVhXM9xvLT8JbfR/1n2LA4lHOKFZS8wpd8Up/H7jgs7+GzDZ1493ib0meCXL1lMZAzvtX6Pb7Z941EI6j2zN8deO0bJ0JIurxutRnrO7InJ6r6NIZoQnr/veb8EIICfe/9Miwkt3B4Lo9XIjzt/pHONzoEr9FIEkCJQbilRH3rFwuZBkLjNc3Wea3/Dhh6iMk+Np8SMhK6EcKLNr2lnPg15ixSGGGg6Cg6M8HzsTk2GMq2g+pP5F4J8pdYFMK3O3eykTq1zO4vWtVZXl9QXgEsZlziccJjG0Y0D1q7ZsbM9VhvRqXW88+c7PrcRrgt3O6twIvkE43aP47VWr/nchqKIlCtfkUCffiq8eoJNZD6L+v0R/4fLTUKtUtOiYgt0Gh01S9V0KaG55tQaFEXJ/400OReCgC4Kar9YLITnqQemuohlKlT0qN3DaV1MZAzlwsu5lJFXoWLtqbX0qOP8/juGhL/ELLQ3353I2hDdMfhRp27SSZzQl/QeKSRx4csvYcUKiIsDm5tnU0WB4cPh1CkYNUoI5pog/ewWk46YiBjCdZ7HLzERMfzQ7QfXF0yX4doRuHZUpM6kHhBRF9Z0MXGmCQGVzotTv4LeYWNxlJlXzGBBCBpowsR4SmMQaa/qkNxFJTjskLIXEjfD5dUi1T8nqsdhgTG+/F0UsPqoimfLgPRjYrm0UrRRrQO7mawsA80qNPP68QH1B7gKMDajiGhJj8s+lvuEcGVJEq+ptWIfKg148rZQHDRTbHxXysRv6aob4pA4jmHivqENQ6XWY7beQT434VVFdFCdl4RIl7ARUnaLcXzaQTGxqw0DVOJccJhz13+pdNnnr0a8326B8CpQ6j4o1xrKPCDGs8Hqny8uB7JFP41eVAUNKSuig/M4Jlhzcg1z/p7jMWKnpKEkMwfOzPckTNdaXWkxsYXbqA6zzcwzS56hbdW2fpnL55eVK0UlW41GLGFhULasWEqV8t3vTt4/mQl7J3j1KqtRqgavtnw1oO1+svGT/LznZ3Zc2OE2+shoMzLvyDwaRzfmnQfFM0CKKYW+s/p6FIC0ai1danbhgcoP+N2+99q8x5hdYzwelzRzGk/Mf4KVT650GSc/v/R5rmRc8ViNUq/R83lH//2kGpZryOP3PM7MwzPdPv+YbCYGzxvMkVePuBSBKa5IESgv6KJEatix/8HhT7JvGB5mCzJOirzkw59BiXvETSG6M5RrI2YGHNbsAX52rvENsv/OublknhEGdncCdV+GM9PEIMzTTXb3S2I2q/6bBVfpJgDEJcVxOvW0y/pQbSg96/R0WV8hogIVIytyOs35M1n2LCbtn8To7qMD1raXlr/kccY2PSudpXH5Nyq2K3be/fNdXmnxCmq199D7Y8c8z2znUKuWiAIK1gNNIFh0bJFL2KzZZqZhuYaASAu7XQQy28zEJcdRv2z9/O304nLfBpS1i4eXg0NxMDN2pstAJTIk0kUEAuheqzu/7v/VaQCQkZXB5P2T71wR6PxCsPkIobvn44Kp/OYLX1E+gar0CLCwgh+RnWoYUjzEKJ0OVq+G9u3hwgXPQQhjx4oU28mToUmTgk0PMxrBboePP9Ty5xhXI3z3H7okBMxLK0TkojVdjGXsFvFwfTt2E+C7KEQjPWysDCL8LPsz6nQhsDiyhJgRUsH9hxVF+Lac/BXOLxB/O7Kcx26eThN9KYisIyJ5tBHZaV96cd3ljOEcWcJYOD0eMuJvS+FURNRJ9vYf1FrY8c8dPr8v1nRI3ApX1sHlVZB+XHxXxZG9/dsehnLakQteLgkvl1QAW/ZiFNExmmzRWWOA2l1ztS2vREdDgpdrNzoAETIVKnjfR27QAxWvQykgKnspDZTJfk2DKKFjz17MQBKQaoXrVrgGpABXAPsp4BQw/+b2ExKgfB79AB1WYZ9w/RiUCYdkH2nBJVSw7R/O6xRFRNfZLUIg1EVBRA0o1Uz4H0U1EM8moWWdPnbNfI0nFjzh8WE9Qh/Bvzv/268o3EblG9GtVjeWH1/uXrCwGhm6eCgrhqzwKwIF4No1+PtvOHoUBodFE2X0fL4kqKIZMsR1vcMhqttmZYkqs2XKQP360Lw53HMPNGggKs/uS9zGsGXDvBppG7QGZg6cKbIIAohKpWLagGnc89M9HkUdo9XIu3++S6Ny4vgPnjeYaxbPorZOrQvYs4lBZ2B099G8uPxFt9FKFruFTec2MXrnaN564GYa4tT9U1kSt8RjGli4LpwvO33pNoIoP3z98NfM+XuOx3tCpjWTfrP7sf257XeEP1Dx/wbBRqWGBsOhxj8h9l9iYKE4vJfLvRYrlvgJN7cRUl6YeRpixA1YpRGDa5tRpEYZL4rS6XcSKjW0mQOrmmXPpnkIETn0IVw7DK1+yZ71K3qRDZP3T3abP+tQHDSPae72M/3r92f0ztFOAo3NYWPagWl81/W7gHQovx/83WunHgjMdjM/7PiBd1p7jyhasULcPL3xwQfFSwBKt6RzLOmYy/rapWvfGBS1rdqWOX/PcbrRKYrCmpNr8i8CnZ/v3SRYrYdGI4q0cJrDlnNb3Fb3MlvNtK/e3mV9jzo9mHtkrpPBooLCihMrMNvMhGqLXv/gF4oCF5fitTR8aAWoMrhwPNR8+Q/ZjXiMRsgrfqX2Fq8I2kqVYN8+6NED9u/37BEUFwdt2gjx/L33oF070c+GBcAWyuGAjAzIzBSC07hx4iFqzBgvHzIlwOnpEP8LGM+Lc/JWQ1534s8NVCJaQWMQ0QvqELHOYRGChN0sqjq5m9S4Vfiwm+Dikttet8PZ2XDgfbCmZacAeTgnNAao0BlKNc9+QK4vojpUumyhSp0d0aHOrnqnQqSB2cW/OWMBbZgQaTLPiKjw1EOQtF2IUL6iS+xmOL9YjBOTtopxjzWDG+ext+pV6hARGRhS7uZxVOvFPh0W4Wdjz4SMUyLyxeVYWm6OYQNVqfXKFRIzE2n6c1MuZVxChYpedXux5PElgfNu8lcAAsgCzmQvBUF0tO9waIddRMolrIcLSyBl382+/cfcRGX5iFBzWMR1ZEmE5F3Z0Wl68VuHRkP/czfe+uLyF92maucQqY9k6L1Dc9Em74x6eBSrT67GbnO9LqwOK5vObmJW7CyGNHajynghPR22bBGi+ooVcO6ciDS32+F5o49MAQUh6nnBaBTL+fOwdq0Q4lUqUQSlehsND9VWQ5bna/2RoyYaf9QkT98pt9QExt8LU5t6e5eC7rEn+Gb0++y4sMNjamqoNpRXWr5CtZLVAta+Jxo/wVebv3LrVwpCpPpg3Qe0qdKGlpVaciTxCK+uetVrVFVpQ2lebvFywNpYPrw8Hz70IV9t/srtfm0OG0cSj/Dhug8Z1aX4l46XIlB+CS0LLcZAo4/gxDghBlmviRu5r5u94gDzFbHcbURUh267YE0bIXJ5OlZnZ4uZxPu+g6qDReccjGpHucChOPh1/69uQ2U7VO/gUeHvVacXv+7/1aVagF2xs/bUWrrX7u53295c7dthPxB8suETnyLQnDnixuiJqCh44gnQ591bsNDYeHYjodpQlxtnmyo3q601r9jcZZBrsplYeHQhr9//et53ak4UkYXeqDoosBEYBcjUA1PdDjKrl6rudjanQ/UObmeBtGotq06sKtbeAW65ftR3ylVN/wfh+UYbiVeBKv1kwZerv0OJioING+CZZ2DRIu+RlOvWiSU6WlQQGzRIRAeZzaJPNeTiJ7DZhOATEgIpKWJ7kyfDxo25MPRPi4WDI+HyWvEUlCMeuJsQU+tERE1UA7GUaQElGonKTIo9exzguLlTlYobgotaB6ZLIq0sZa8QV64dFdExngSLiytgz6siqthdhSgQKVBVBkDNZ0Wktt0iRPTbJ2PyWuVOXxL0TaFUUyHU2k1iku/yKjjp/mZeOwAAIABJREFUxgg2Kw1ivxQiGqqbEYDuIns0YVD2fiFSlWgsBKvI2iL1x0XkyhaqgJsR5qHiPcZz2cdzv4g2Sd3v+x6TR0xWE52ndSbRmIhGpcGu2Fl/ej1vr347oJHPxRZFgeTdQvQ7N1esuzVCzat4iuhjfYl+7gQ/EOdkzrVjPH9j9dJjS1l2fJnbVBgQURejHh4VkAnLemXr0btubxYfW+x2QjXTmslLy1+iY/WOxETGeN2WxQKLF8P48bB9uxB9MjJuTkJm+QiSK11a9L0hIaLv1GrBahXbzcqC5GSxvdtRFGfPy+N/3U/cX7mo6FmADD0oFm9sr5zGvzb+y6s5fYgmhE/bfxrQtqlVaib0mUC337t5FHZMNhN9ZvVh77C99Jzh2QcIxPk4vtf4gHtDDn9wOKN3jvbYRqPVyJhdY+hcszNdawUgarIQKR5PDUUZQzQ0+VyU6U3dByeniNK+jiwxgPE0AAkkxc14LqoO9NgHf7YRngGeIhwsSbB9qJjJq/0y1HsV0IjZtkKsIrbxzEa36nm4LtxrVY22VdtisbneXNOz0hm/e7zfItD8I/NJMQUnesxoNTJu1zhebeU+rzkjAw4d8r6Nhx++GV5bXFh2fBnpFuc0nXBdOG2q3hSBGpZr6HYQtePiDqx2a95vWJf/FIM8b+H+1Z4Q4d5FHKvdyvwj811yu9Wo6V3HfTnk0obSVI2qSnxqvNP69Kx0Ju2bdOeJQJdW+Z5IqPZ44YniJRqBl8EjtnQwXRApNJI8o9PB77/DH3/A00+LhwxvYlBCAnzzjVh0OrjvPmG2X7Mm1K0LNWqI2Wqt9mZaw+XLEB8Px4+LZcuWPARVWJJh/3vCaNduxqMgqA2HSr2FyFK+vXg4VZT83b/Dq4mlQlfxcKso4vxP2Qvxk0S576xUIXAcGAnHx3quBqUJhbqviXRKVKCLvLk+0Gj0YgGo8gjEdLv5mj1LtPPwZ9lpOx4e+jVhUGUg1PwnlHtIvE+td43IU+eh/4+qL5ZKfbI9hXRivHVmJpz5PU9f0R12h50BcwZwIuUEVof1RsVMo9XIpH2TqFWqFm/c/4bf+ymWKA44PUNkEpivCDHGm+9nSJns36uBqLpY+j4hqOpLCuHyhniaU8ZeJf5Va8W/mWch7bAoNHDtqBD9Mk663GOSjckMXTzUa9RFKUOpPEfmeOM/nf/D8uPLPValMtlMDFk4hPX/XO82LSw1VfipTZwo/s4RZNyJPioVVKsmUrcaNBCpXI0bi/5RpxOijyP7UCqKeL9aLf7V64VYHh8vojQPHhTpZUePwpViNpd/PQT6PIFXAShMF8aoh0flypxeUcR4Pzn55nLtmphgsNvF6xqNuP9ERUGZMm1pVa4jmy//4TFtLsmYxP2T7vfqAwTQJLqJW/sNT+28fh2uXoXERLGYzaKdt3pARURAuXKhfNJiLO9tewajm9Q1EMdv0NxBxL8RT/nwPKZ7FiGkCBQoVCoo3VwsLcaITjZph/DzubpRhAerQ1BUWhRFAbsZNe4f6hTAoQpFpdajUoFKsYoOO6oBRHeC8g9BmfshLLjGVJMni05RoxGKeZkyUK7cTdO0PEV0hFWG7nth62PCnNFbKWTTZeHBFPs5lGsLFR6Gyn0hqp64CSp2MYjRhGYbIyJuqnbzTTFOYxC/QQAYv2e820gGm8PmVRUO0YbQslJLtpzb4vLan6f+5Jr5ml/ldV9dEVijOV+8v+59jyLQ/v1C3PE2A/PII/k3Zy4sVp5Y6XJTUqlUTqUttWottUvX5kjiEaf36TV6dl7cSduqbfO208RN3v1hVBphEFwMWH96vdv1ESERdKvdze1rAD3r9mTsrrEuXlfrTq8j3ZKe+0o6xYGknd7Ti3Ulxb2gsNAaROWj665pkTdI2CBFID/p3h3OnIEff4QvvhDr3M1G34rVCjt3iqVAuLwGNj/i6qlzK4YYaPKlECoV201xOq8RNe5Qa5zFjrIPCl+TluPg4krY8ihc+sOzABRVDzqtFdeQP1VI84NKffNYmBNhXSeRnuWprboouOcjqPPqbccxgGKVWgf67DGHtirUHw718hGtehuvrnyVzec2u43gNFqNvL/2faqVqEa/+v3825Ev36GiwK3eR4nbYedzomKZpwIpIPrOao9DzWcgrEp2NJkObjdnz42YGlVPLJX6Zm8n2zz60go4NRWurAHgmSXPYPQSgRqhj+Cbh78JqJdN7dK1GVB/APOOzHMrBNkcNnZf3M2v+3/l+fuev7neBr/8AiNHijGmJw81tRoeegieekpESuZE+BgMrtVofVWn1euhZUuxGI1ivyEhQoiaNg1mzoTDh/N6BIJPmBW6x0PGo56vvcpRlZ2ONwgRbO9e4fUZGwsHDsCJE0JMUavF8dFoxKNwjpDmFNiJeB+ANWw8jrbvgsaMXgfhEUIgKlFCiDAlSwJqq9eS8Tq1jq86f+UiDprNcOSI+C327xf3whMnIC1NtC+nnT7baBuEqe0uVKVPoNeLZ5XSpSCqhGhrRASEaPVE6ov32FOKQAWBSoVZV5tDibXZvfcfbNwIB/dnobZcomzYRWpEX6RKmQtULnWWiNB0dJosNGobNoeOLJueNFNpzidX40JyJU4nVCYtqxK6yGgeeFBD27Zilq9BReFXl1/MZnGRHDkCA3yYpQEkEM0bb9z4ejdUckW5GTYZEiKU9nvvFR1lw4YiPL2SpyqIoWXFgOz077D39ewwVi8hsIoNrm4Qy6GPRHREeNXsWcLqYKiQXWlELQap5kQwnoWMM2I2xNNgKw9kZmWy7Pgyt+p0dHg0laMqe/38oAaD2Htpr4sKr1VrmX9kPs/d91y+2rU8bjlXjR5CfwuIjKwMft33q9s2x8e7r3JzKz163OxwiwMXrl8gKTPJZX2WPcvF66dt1bYuIpDRauSP+D/yLgKlxXp/vcz9xaYa0+T9k0nPchW0TFaTU0rd7XSv1Z2pB6a6pFLqNXqWHV8W0NnJQsebuAIQ01WI34F4qM4v0Z1FdSJPs3Tn5og0Xl3xHiAVNqGhwvfnlVdg7lz4/ntRIcxq9d2/Boob5tNn58GOpz3fR1VqaPg+NPpApKYG6/zMOcdUmmwByMPDdXgNkYquCQ9+Rb1byTgFax4S4xNPUdBVBsIDU8Rx9OXBFUg0eoQbcv75dtu3TD803SmiRK1So9fob4x7ciI8/hr6F60qtcr/zvwNw8iN6bDPvMhcoDhgz2tCdPHmuRTdUVTRLXGP+Dsn2jMQ19KtUWkgItMqdAWVijmxc1h3ep1HfxiAMoYyPHbPY/634za+6vSV22IbOWRaM3nrj7foUrML1UpW4/Jl6NRJePJkerjUdTp4/XUYMUL0oeHhgfWeDAu76cFmMIjKja+/Lkz9yaftY7DQOuD3RcDCxV7fl5EBmzbB+vWiYlp8vPjOVqtrZKrdLtbnmmtVYN5sQFhyZQGpiGOp14vtV6kCJ3ORoaooIiJr1SqYN08IP6GhIronM9P58rXbfacG3kQFq/8LgCV7SVGL+6HDIbbVrh0YBuf6WxdJpAgUQE6dEgO1adOE8phzwQiDRz1QHajOljivm/HI30dg9mxx37JaoVkzePZZ+H/2zjs8inr94p/Zlk0PobfQe5MqzQaiIhZUFEHFgg1sV8Vr91qv/eq1gChVFLGCgCAC0kGkQ+i9l5AAaZtsmfn98WbZlJndlM1uuL+c55knsG1mZ3a+5XzPe84DDwR+r6pKec4ff4jXwPr1vhvlXscJfw4PPgQIKHA4hCXesUP2ERkp5FCVKnDsmMGbFAUa3yXKns0vwd5xgKl4hI2aCxm7ZQsRftz643lpc34oKFzV5KqA5VhGUYuZzkw+/uvjUpNAn635zPA5k2KifY32pVJLOFwO1h1fZyjJHLturO4x79rlv4ShQwdZlbmQsGDfAlkFK8S3NE9sXqRGvme9nkzdPJVMl2/p3q26mbFjBm/2ebNkO84smkJXAHVvuCA8WHLduczeNVv3udbVWxNtMza17p3UW7c2PMOZwVfrvvrfIoGyD/p/PmkQ2MJc+lfzctj/tbFC7fgfUupQSQIFBTEx0tffd58s3IweDT//LKvQNltBX4qywuuL4XTKgtOjjyIKBn8EkMkKvX8Sc+VwmdNveNq/uqLLJ3mGuGEkgDQNlg0CxwkMjcubPypEQCjJnyDhx20/8sqiVwosckVbo3njijeYvXs2Sw8uPT/Zz3Zlc9WUq1j34DqaJDYJ1yGXP1QXrBgiZb5GBFBkXeg+XpTuobp/FBPY4klzpDF85nC/ZWBR1ig+uOqD4Bl650OjKo0Y3GYw32751pAIynZlc8cvdzDliuX06iXqEyMSvF8/mDTJp9YIBWw22Vq04MJTp+WD2y1kyhdfiD9cRERBb6VzfkyzY2Pl+yclydzSe04UxZeslpsLR49KuEGazlTJ4fAFIuzb5/8r7N0rHlCTJsl7VNXnQVp8oqdkUFUpKfNi3rzy2U8ocYFNwyoeTp6E8eNh4sQ8FhjfDzE93fh9pUV+5vuvv0TN448E2rFDbujJk+UG96p2IPCNoih5krcI38DQ45H35+b6JJF68N70IP4DAWGLlzK69m/Avsmw/X0x2g6Fp9J5BF4Vevz3x3XjDTU0Jm+azJTNUwJ+hpHpXnJKMksOLNFNSPKH3am7WXJwieHzdWLrsP6h9aWO2mw7ui1bU7bqPpd8Kpn1x9fTqXanAo9v3ux/Aa1PH1mtuZAwfcd03Wuf3w/Iiy51uuj+nHan7S5Z2Z/qkUQPf6h3Q1g9soqLuXvm6krJLYqFG1rc4Pe9sRGxNK/aXPd3uOrIKtIcaSRGJgbtWMMGd1ZgU+hqxoqpkKFmn8BR8ZtegovHlY0IstcsY0LY/x5at5bkrs8+k8WVZctkcWfBAhlgewff3kGx3gqtosgijdUqr3M45P8dO8J110lUfceOeW20psG8x/wvzHT8UMq0w0lcZB/x/3y1nuFvJ4/OFkNrIwIoutEFSwCtPLySe2bcU4AAUlBoltiMJ7o/wW1tbqPlZy3JVH1jugxnBpdNuoyND2+kWlQ1vY+98LHuH3kEkMH9E9sc+i0Xj58w/D7jIuK4e4NKth8lR52MbG5+6Va/eQBlwTsxYL8ccg35WY22v62h5wMnOUVNw9TZ4cOlfDYYSYmlRijUaRAchVoecnMlCfLNN2We6F1U0Cuzi4iQ/qFtW7joIvnbqJGccy+B4/VS8n4VTSvotxQZKf3SwYNSWrZhg6h5Fi0KvKCxbBm88orMf70ed/5gMkHTpuL/1L49dO8ufWh0tPRvFouoxLxqJpdLSsc2bxaT8S1b5BgPH/a/nwsVlSRQKXHokPwQv/9eftRGNal6qFJFbpwqVYQx9bKmublyE+XkiHlVcrJ/NQUYyyH//BNefFEMzLzkjxG8hmlt2sjN0a2b3CwNGuSFfnjkZlNVXxmY10TrzBkhmtaskZtm61a5mY2OKyBsCdDyCWjxOJxcBLvHwMmFeQZ4BKWkCwCT3ZcCUr03NH1ITCz9YM3RNbqlLF7opYWVFC8vepml9y4t8XtcHv192y12Hu78cKkJIIBHuj7CM/Of0SVActw5PL/geebdVZAS3x1AnHXRRfK7v1CgaiqL9i8q8niMLUa3jKlltZa618RusbPowCIGthxYvB1nH86LcvUz4Y4OXoRneWL8+vG690+ULYp+jfsFfP8NLW5g5+mduAuRDxaThenbp5daRVehkLFXjGDdBisIihns1UN7THqISIRGwyTtyKik5fBPUhoU37r0k5ubAwyopwYpij6cqFWr1CvHdYDBeRuAisJJR00OOZI4hGynqE4uEeQSgQU3dnKJ1rKon30Y76vqc5ioDAcsRbb8SALe9TOriqgOTe4Pf3pnRKL4BxohfQdU7V72GuRfapUfMdn0/vATVaXArtRd9P+2fxE1id1i5/tbv8ekmKgbV5ePrvmIf/z+j/NjCVVTSclK4cqvr2TV8FVEWiu+orVEyDoI+yYaK4BMNrhyiaS7hUmhZjFZ+PwnPyVqIUCtTPhCXyR8Hp/wIBlEG9Gn9OwJ//1vmAmgCwyaJtUrTzwhih+jeZvNBtdfL0EFffsK8WK3F/VRKokvbESEzDnbtIGbbpK5b0SEePhMnAg//VTw9adOwUMPyYJHoHlxly5w//1yrElJMrdWVSF+jCoQrFbfnCQxUYIV+veX4/J+r717JYVu0qTASqULBZUkUAnhcEiN/vjxgckVkB/dlVcKsdKrl5A/MTE+xjS/A31+ttT73pQUMeBasUKYz6VL/XsBHDkCDz8sjKq/G8VuhwED4MEHhdX1egzoGab5Q/XqsvXqJQ2IqkojfPy43MhTphSvrrMIFAVq9ZFN06Tk6+QiOPIrWuoacJ5BVeyoWED1YMaBSSlYp6NqJjxEgsmCCQ8mzQHWOJSEdlBvoEjXE9qKLLYYeGHhC6X4IiXDikMrUFUVUzEHqgfOHuDXnb8auuyjwbAOw8p0TIPbDubJeU8afLzGskPL2HxyM+1rtj//+NGj/j+zVRh9bUuDzSc365fEaeia15lNZppXbc6WUwWdAjNyM5i1a1bxSaDMvTIpMLL8sVXxmaFXYJzKPMXs3fqjvPTcdAZMHRDwMzyqpwgBBOIZ8Mz8Z/43SKDMPf6fj6ovhHhFmCi2eQH2TwYDAhpNhSXXwbXJPvPZShRFEEsHTGjU5gS1OcHF/B2cD00AMrLBqEoltkmeSXSYJ/Dt3oD1TxiHTKx9DPotBVMZy23KU5nm9TQMBspEVplgaPF85k5lneLySZcXSc2Mskbx0iUv0bxq8/OPDe84nIkbJ7L6yOrzYxan6mRX6i4G/TiIWUNmlUvJUdiwa7SUgxmh0V1giQlvieIFgnd4niyM67vef//CSpoNN1wuIXV+/dW/t9LIkfDaazIli8urQg/2efaqV0Hmo506ScmzF5MnS1ly/gqTwoiJEeLnySeFxImI8FUblCi0KB+8VTBetGsHzZrBqFFiefHOO6X73IqEShKoBNi+XaTSx4/7SBw92Gxw881w771iHJWbKz/Q/MZkxSVa6tSR7corZZ9mM8ycKQTLggUFXzt+PDz+uNwkRkRR3bqiEBo2TBQ+3pu6JMSPHkymgklPSUliyvbPf8rNUhqoqiiLNm9W2LChOatXN2f79oc4cwaio9wkVTtKg2oHqJdwgJpxR7GanURYHCiKRq4rEpdqIyWjFkfONuTQ6YYcPF2fjCwbMTFSu9qtmzQ27dqJR42/8iRVVVl0oKgSJNhQURm7biwjuo4o1uv/tfhfhnXUAO1qtqN+fP0yHVNiZCKXN7yceXv1C2BzPbm8sPAFZg+VSX5aWmDT0oYNy3RIIce8PfN0lT0u1VVgkJsfvZN6FyGBNDTm7p5b/B1n7PE/iIxtKmbq4TQJLgbeXObfB8mfwq44OJNzhuSTybSt2bZMnxN2ZOzxbxwa2zRwGVaoEJ0EdW+Ewz8bH1P2EVhxO1zy8wVZ4lIJIAP/KRRZByWkIRgoE3GhSHz2ua36ARNn1sOS6+HSGXK8pW0zy7NEcf/X0PyR4NwrZTpGP5Hl+ZDtyqbP5D6kZKcUWCRRUGiY0JB/9vpngdcrisLUm6fSZnSbAspih9vB4gOLeXzu43x2rbG/4QWHrAP+2+uEi0KfUneBIg3/5d4tW15YQSPhRE4OXH01rF1rLBZo2xZ+/92X2BVK5J9LfvihVN34EzXcdpvYnlit5X+sXrVQhw7w5Zflu69QoJIEKia+/hpGjBAixqgU02YTFc6//iWSMy/BEoyyl/xM6e23izQvJQWeeUYe++QTeO45Y3LKYoGnn4aXX5YbpbTMaEmQ/2YpLk6dErnfzz+LMZn3XBd2ec/ItLA1swFbDzQASuahc+4c/P23bNHR0nG4XBIl+ccf+u+ZsnmKsdomyHh/5fvFIoEOnzvMD1t/MCSBYmwxjOw6MijHNKLLCFYeXqk7WVc1lYX7F7I9ZTutqrfiwAG59kaMvc0mpZAXEqbvmK7r5dSiagvDyNSe9XsyZfMUMp0Ffa3O5Jzh4NmDNEgoRhlX5l7/JZAxTSiOl1W4URyvrLLi1SWv8tNtPwV+YUVG1iHj8iqAmKZSQlBR0P41ODrTf7ni8d9h3ePQ+ZNKIuhCxH4gFTBK+XQch0M/QIPBZY8vLxNxocGVy4R0PLFQ3yT65CKY3Qo6vAVJg0V1U1IyKFCJIpS+TPFcMuz8GFo8ET6D7WLCo3oYOG0ge8/sLTIGsVvs/DDoB92+sUFCA9698l2eXfBsASIo25XNxI0TaVKlCU/20FceX3CIqicJb0ZE0LlkcGUGhwgqC4EaD/gx/a0ISOAsJ6ll+PzevaIAqURgfPihWHgYzRe7dRORgXd+FC589pl/AshqhV9+gcsvDz1RBQXJqgsVxbq8iqJcoyjKTkVR9iiK8pzO85crinJOUZSNedsrwT/U8GH6dCF3srONCaD27cUH5a23pCGKK8fwFq/qpnFjqU2cMAGef974hrbb5YZ++WW5qUNBAJUEDoeQbB07ioJoxAipu8zIkDrVzMzAHmiKIt8zPh4SEkSuWJzGKytL9pOTA/PnG7/u7eVvl+xLlQH7z+4nLdt/yhjA60tfx6MaE1Nu1c0trW4JyjH1b9bfMCEMwOVx8dKfLwFyn/izIGrQwL+SrqIhx53DhhMbdJ+7pMElhu/TKxMDMCtm5u/z82PLD1eAkVlM4wo/sT5w5gBnc86W+35+2/Vbue+j3OFPBQRSDlaRrndcCzGyNQeYsO4dDyuHSqmOVjyVwf8bGCS1VCjMTBCvKiOsfQTS1gY2NS9vWCJF6dPuVSmz0UtNdByDv+6F31rDjv+IWs2dDe4QdkrWBOOyr00vwsbn5Zj8RHYHhL38fleqqnL9d9ez5OASctwFVVc2s43rml/HztSd/LL9F92tZkxNakXXQim0gJHtyua5Bc/x37/+W27HHlI0G+nzntSDNzI+GG1iWQjU0fhce0u7FQdl+Pyn3q3l1+/nn/8sgxfp/yOkpcHbbxuPwU0m+PZbmWOGkwA6dkxEDkYEkMkkVTF9+oSHAPpfQUAlkKIoZuBzoB9wBFijKMpMTdO2FXrpMk3T/DvrXoDYsAHuvNP/pPXee4WxtNtDf9N4FT7+pHIzZ0LXrhXPMO3cOanj/eQTaecz8wQTRibbiiIu9O3aydajh/ytXVvOg9stJW4g18FikZKylBQpK1u1Ssyrt2wRws5TTGFPpjOTnak7y/6FS4DXlrzGf/sbD4SOZxznm83f+DWj7t+0f6li4fVgM9sY0nYIEzZM0FVEeTQPc/bMYU/aHpzOpn4/Kza2+Oe+ImD5oeXYLXachQbksbZYetbvafi+5lWb65aQZbmymL59Ovd3uj/wzvXKGvLDmuB/kFkB8NqS10KynxxPDqsOr6JH/R4h2V+5wCA58DwqEgHkRfNHRXlxfB6ofn6vR36Fed2h9zSIalBZBuHFhZIms2s0bBilT1S6s2BhX+j0ITS+T9RqpWmXglFqpSjQehQ0fQC2vSfKGsVUNGk06wBsekG22GZQ9waofgnEtxCyVbFI+6soosrx572munwEWHHu0f7rYf6l4Dyt38bv+hSOTIeOH0j6o0bJjbfL0VT92qnXGpaHuzwu5u2dZ/i8F6qm6i4sOVUn/5j3D6Jt0cXrIysyYptA0hA4NE3/vlFz4c8roe8isMZXegP5wWOPyXzBqBpj8WJ46SVZiK9oc52KhA0bjM2RQSo3KsK6xDvvYJgCBzB4MPTuXXmty4ri9NLdgD2apu0DUBRlGnAjUJgE+p+DqooHkD+CZcAAIYDC9UOcMMG/OXXv3uKaX5FuFE0T5/eHHvKloRmhWjUYOlQMv5o3l+/q8cj3KezhY7EUbdzMZglfqVVLJIOZmUIQRURIPOHkyaJC8hf/99ayt0r9XUuLSZsm+SWB3lr2Fqqf1aNYWywjuhTPV6i4eKDTA0zdMlU3JQzA7XHzyqJXGBY91e/nVDQlWiDM2T2HzNzMIo+rmmqo9gEwKSZaVmvJppObijy35OASVE0NbIIZiBTQW+muYPhpe+hKtN5Y+gZz7pgTsv0FHf5IFCh7uU15QFGg5xSY3RocR/GbI3wuGX5rB43vhk4fCVlQEYmtShRF85EQUVVUNKqraImL6hTz5V2f5UXG95FBlLUEZU3BJC5s8XDRW9DmOTj0E+weDWc3y2+uMCGUsRt2fCjb+fcnCjkU20y8uKzxcv+Z7XmJjblC4HgckHtaTN0zdouvVyDENIIBybDlVdgzVv98ev20IutAozuh0d3yPo9LzmmYAgGe+P0JvwSPhkZ6rkG6YQnwwKwHaJTQiL6N+5b5s8KKbmMg5xicWqZf2n12M/zeBXp9C/HtSk+Ol6dXVQVAZKTEg19yiaQS6y0kfvwxHDgAX30lr4+u2BWVYYHJ5H89oKIs0H77rf/49xdfrFQABQPFIYHqAvmnyEeAi3Ve10NRlE3AMWCUpmlbC79AUZQHgQcBkpKSSn60IcYff0C6n76sdm2YNi28BMuqVf4lkDfdVLEc89PSYNAg8ePxd9y9ekkt6KWXSqPkbczLYmBtNku5mBfNmklD8tJLsGkTvPGG/vsmbpjo93NjbDFFZM3FQbYr29BnKD03nX1n9tG4SuMiz53KOsWEDROKKFPyw2wy06dRnxIfkz90qdOFKvYqxiSQ5mb6jun0bXISMF5KMF9gi10zd85E1THK9Ggemib6Vz1d0uAS3WQxRVHYcHwDnet09r9zf6bQENyUqHJIk9l6amsRT6TyxIJ9CwK/qEIjQDtSVjVHfgTzeltj4Yq58EdPcAcy+dakDOLwL6IaaTYCoupKMpK5mAyx6g5cOleJ4KPBYKh6Max9VPx19Ca16TslFc5eE5IGSXx8XEshTEzW0HvdWGOhyb2y5aSIR9WJBXDabBIAAAAgAElEQVRyMeQcFyLdk5uXcJYPzjRIXS1bMOEt07LFQ+ePoOWTsH6UeGsppqK/a8cxUTRtew8i60LNyyGulZhgx7WAyHriI6a68krM8uJmMQFaXqmR9y9CurpKR9KMXjOaT1Z/UrrvXQpc9c1VbB25lZbVWoZsn0GHOQIumy3k6eFf9O+ZrP3Sdta9AS56R0z3S9IeQrkqvyoKWraEdetkXpCSor9AP2MGzJsnwTT/+Ic8Vt6lTW63LGifOwf16pXffoKBzp39DyM2b5YF8rZhztgIVNpXu3ZojuN/HcUhgfRajsI/ofVAA03TMhVFuRaYATQr8iZN+xL4EqBLly5BHM2WDz74wFeipIeHHw7/hNafrA+ESQ3mvKEsOHNGVEn79xszvDVqwNixkoYWFVX+5XVeguzii+G774o+n5qdyhnHGcP314mpw8fXfFyqff+5/08mbpyoazhsM9n4ZfsvjOo5qshz7yx/x68KyGKycE+HewwNi0sLRVF4qMtDvLXsrSI+AF54VA/Ttk8Bih63F4GSwyoSUrJSOJyuLxNrVa1VQCVPz3o9mbxxchFDbafHyby98wKTQIEGgWoZPCMKoxzSZEJVCuaFS3Uxf+98+jXpF9L9Bg2BlD7BJD6Cfb0T2sJVK2D+ZXleVgF8LlzpUqqz82OIbw0NhkD13vJvW0KeR4u381Lk3Hiy4dwOOL1SzIgrEXrENITLZ8OppUJenEsWUq6woXnOSdj1uWwRVSG+jZAXCe2FwIhtBta4PE8UDX0FmZJH0mSLSX5ZYa8usdyN7pL/O8/A6b8gfRek74D0bWiZB8BxHFUz49EiUFXvcckxKuSRKihomOQY8zaTScOiOMBkRYmqjRLTJO97N5ffdWLXomVd0UlwyQ9CUO3/GvZ8BdmHAFNRc2vHUTjwbdFzFFVPCKGI6nmleDbpO1SP9BGqU85hxl5RK/kLGzDAztM7eXTOo4bPKyjERZTcDFPVVMN0SFVT6TWhF0eePEKktQKtZpYUJouoJU/cA6sfgNxTUkJZGEdnypbQHhoOhUbD5B5RXT4V2v9zJCVJ4vB//iMLt2530fmEwwGvviqlYVddBXffDdde6xt7RkcHnjv5g9MpBJTFIv+eNk2UKytXVpz5lhHi4iTy/aWXjKtchg6FJUvkteGa48bHS1CQESqNwIOD4twGR4D8GdP1ELXPeWialp7v33MURRmtKEo1TdNOB+cww4PVARaA7r47/Cqbq66SJC0jsurbbyU2PtzlYFlZUprmjwDq2lUMrCMiyh5ZXxroOb1/l/wdFrMFp85k26JYuPuiu7m1za2l2l/3et2ZtHGS7nNO1cmYtWOKkECp2amMXTdWlzjywma2MbzT8FIdUyAM6zCMN5cax327VBdLjszHrj2Fke+8P4lnRcPC/QuJMEcUUV0pKH5Nob3oUqeLLmHn9Dj5ZfsvvHDJC/4/wBRCUqAcMGvXrJDv861lb/0Pk0B56QTF9YEJNRLawTVrxB8m50RRdYURzm2DzS/7/m+Jlcmx2Q4o8jnZR0WdUYmKgRqXwjV/Cym3d5you9RcIYQKlzXmpgppdGppwcct0RDd0BfZbrLlqWHylDmqE7IOgyv4xvK5ubB2bRVWruzPhg392bVLVsDPnAG7XaN2lVPUS9hPvP0UZsWFzeLEZnFiNbuwml043TacHhsutxWn24ZHs3E6uy5HzjQi5VwCLpcsajVsKAqGzp1F4dy+vcHta68OrZ6WLfOAKK2OzYFTS0Rdp9jyCLPC6lANsg/LFiwUMpU+mXmSyyddbhgOEWGO4PNrP6dNjTal2t3EDROZvGmy7rgmy5nFzT/czOwhs4O+sBVy1OoL1++CPV/C1jfBlZFHBhU6r2c3w8bNsPE5iG4gSjqv+iuhg5QFmqx55eIG5Klilnsq5wSc2x6CLxc62GyShnzvvUJmfPutLBgXVo+4XPDbb7JZrdCiBbRqBa1bQ5cu8rdePRmTejxFCRzvfeq1MDhwQDxF162D7dthxw7Ys6fiEz+F8eijQvLMn69PBG3ZIu3VnDlQt254UrAeftjnAaWH114T8q2yJKxsULQAv15FUSzALqAvcBRYAwzNX+6lKEot4KSmaZqiKN2AnxBlkOGHd+nSRVu7dm0QvkL5ISLC/4Q1LS38Uddut6QtHTtm/Jrx48VEK5z1se+9J8y80Q3dvj0sX17xIvdaftbS0BQ61hbL3Dvm0iupV6k/v/5H9TmSfkT3uShrFCvvW0mHWh3OP/bByg94fuHzRBjE2qqaSr24eux6bJff/Xo8MuA9ehROn5YtNRWOH4ezZ32dotdg224X+WX16vDf7G4ccW7BbDKjKEUHtDn7OmOZ9ju5WfoMaaNGIjm9EBrvzmM7s/7E+iKPmxQTjRMaUzWqasDP+Pvo37qDZwWFlGdS/H/G3yNgzxfGz7d+Ftq/EZyysLLKxYcW/I4Hzh6g0X8bGb7cpJiwlUTung9GSjSQeOLsF7JRyoMoKc5nlmVEuPZxMYU1QpP7xUsnGKbKQb7eBeA8B8tullIavRXvUMHfMRYH5X29g4FQGUMH/HwVzibDyT/FBDz1LzFXRsn7DZRzKpxihSHGAzZVlZX66dOl1H/XLunXcnJCszARGSl9qT+LAUNkHYIzG6TU7sxGtLPJaBn7UdQsPFoEHtWKiimfosqb2KTkafmlPExRNEyKB4spFwXQ7LUwxTeHKh1FsRTfCqp0KqBAzXJm0W1cN3ad3oVbJ+o80hLJ/Z3u55P+pS8Tc6tu2o1ux87Unbp9ZZQ1irs73M3oAaNLvQ9dhPP+1lQh+naPhWOz8ryqso3j5AsjohrYa+Qpv/IIVM3jI0/dWfK7Ke7nXcBtZUYG/PADjB4tITA2mzxWHJhMUL++zD0iIuS9Vqu0Cbm58jctTcbGxUGZv2KI2nNVhSefhHHjjBVBigJDhkhVTHS0bOWtDFJVuXZnzkCbNv49eb/6Cm6//cKYS4QTiqKs0zRN18A0oBJI0zS3oiiPAvMAMzBB07StiqI8nPf8F8AgYISiKG7AAdzujwC6UBAd7X9wcOxY+Ekgi0Vu4ltuMSZY7r9fGrpBg8Jzs+Tk+I8kBCkBq2gE0PaU7Rw6d8jwebfq5uJ6evZYxccNzW/gi3Vf6KtF3E7GrR/Hp9f6JoV3tLuDqpH+iYfCiVXp6WKo9/ffsHYtbNsm5I/NJr8fTRMyMTc3sClcRARYqn2POWkxGnJ/RNhlxbNBEjRoCHEXVWHSDxEYaQAOHZLBd0WHqqqG0fCqprLnzB72nCmGCagBNDS+WPsFL176ovGLbAnIAN6gOc3YKwNHW7z+82HEj9t+JMIcobu6G2mJ5PUrXmdYh2Gl+uzBPw5m8cHFus8pKCSfSqZdzXal+uywIrqhDOaNyvwy9hR/UB9O2OKhzwI4OE38YzyOCq9aq0QZoZigSnvZWv5DFEHntooK4dxWiZA/t118eDRP3sQ1jyQ6T1rkK//Du8Kg5ZU15bUj9ppS+pTYWZRncS2lfMZgYWTLFhlffPONTDCysnypM0bju9q1xTOwWTNRDrRtK6UR3kmi2ewrQ8nNlUWUzZth505JHt29WyaO+eFv/GMEj0eOf8WKJFavTmLnTlm8OX1ajiUywkVsxBkizakkRqdSNTaV6IgszCYPZpMHTVPwqGZcHitpmYmkZlYlI7cqWe6qZOVGk52tYLdDnTrQtKkkA/XqJaUziiLl3TdOu5F9Z/bpEkAAVSKr8O6V75b8y+WDxWTh+1u/p/u47jjcRU9UtiubyZsm07hKY90S+QsSikmUQbX6il/W6dVwYr6Ug6XvkDJI1VO0JNCL3NOyBQOFlF8XGmJjYfhw2U6dEpXLnDniDZSW5iN79ZKHVVXuqdLCG1LjcMiC/IUCkwn++1+4/noYMUJIrsJKKk2DqVPFKuPyy+Guu8Rn1pRnOxYdXXbLDlUVosfjkfnI3LkS1jN3rhB7d9xh3HY++KA8N3x4+KtdLlQEVAKVFy4EJdCwYXIDGE2MH3pIGNKKwELOmiVqH38DjZtuksFQVFRoVUGLF8ONNxqvgDVpIsbMFc3Jf9Qfo/hk9SeGMez9Gvfjj7v+KNM+ft/zO4N/GmyYphEXEUfqP1OxlCBu1+OBpUulE5w9W2pnIyOlZNBf5GIw4G2InU7/3j/Hj0tiW0XG3N1zuXbqteW6j/Y127Pp4aLpYeexdwKse9xYTVHlIui7ODgkUJCVIS0+a8GuVH1FWqQlki0jttAksUmpdvXF2i94+o+nyXYVXSaymqw80f0J3u/3fqk+2y/Ke7XzyExYdZexcWtUPbhuR3DMdctTCZQfrkxIfl1So1SnEAChgMkOt5eReKpUAglq1YKTQUwesgIxQGzeFo1UD3stdjyIcCgbyAAy8/4GUuycPCkrEogi4OmnpS90uYz7o+hoKasfPBi6dRNCxOORPsxqlb6zOBMdj0cmM6oqk063W1JH//xT0lCXLZPHAl2Gbdvgl1+k7960SSZGHk/pSKSSwmSS8ey5c6BpGvfPvJ9pW6fptrMg7fgfd/1B76TeQdn/iwtf5OPVH/vd35SbpnBL61uCsr8Ke3+7s+DMZiGDzm6BtHWQsRMtNxVV86CY7ZhMVnwEKpwnUBWvRxV5yqA803BLFEQl+Ty54ltBfFspNwuGaraCnsvjx4VI3b4d1q8Xsnb/fkjP0DCZPETazZjNyvnD0/Kfxnx/vQulmiaL/02bQseOQpy2aiXVDAkJQTjgMCg7VVVK6l54QSoBvO2Y0eF17iwqndat5Ry0aCHEeW5uwXY2/1fxHq7ZLO1jSoqoMTdtguRkuT6rVxd8v6bBjz+K9Yq/9q9HDyH5q1UTsj4U8LbJFWH+Hwj+lECVJJAfbNggPjZGcrToaFnxqVmz/A2Mi4OFC2Ugk51tfMNERcF998Ezz4ipls1WfpHd6ekyiHr9dRgzRgYWeujeXVjfoDSgQYJH9VDjgxqkOfQ9KKKsUXx41Yc83OXhMu0n25VNlXerGCZ9xdpimTZoGtc2C0xG7NkDn30msffeAWlx4h6jony10jVq+DyZ7HYZPOfmypaVJfvYsQOO6FewnUdMjH9T9ZUrpeGuyBj0/SB+3vFzue7DYrLgetlPAtjJJbD0xjyjXb0PiIVBqRWuHGxP2h7ajWlnWLZVNbIqKc+klLpka1fqLjqO7Wg4WagRXYMTT58IfklYeQ90z22Ded39JGwpcHtuhbvexULGXtj0Yl4KkqUYKWIlhDlaVFI1r4AO/4bEjmX/zAo6sSmAUEwaKqoHlQ6yszQeeEDKvnJzjSczV18tJNEll8jryitByO2WvtNikeSiO+4o+pqTJ2HiRBknnT6tb3ZbGDVq+NRKLVvKJNTbf1utsqmqfI7LJeOBHTtkQuxVK+3bJ88VhqbBv5f9m7eWvWXYxtotdu5qfxdfXv9lKc6KPpweJy0/a8n+s/sNXxNpiWTBsAVFFM+lQiBys2ZNOBEgdStEOJJ+hN4TenMq/SCtYqsx/aZxJEVESTuqeUQ1pJjEC8hkg4hEKRmLqAbWBChvP6ULoa3Mw6rDq7hkwmV4HFEMafw4j7V7jdRU5fzipaoKWWE2y/i4WjXfFh1dzs1hGMt7NQ1WrJDqkp9/lkPxlsQFgskkSqgGDXxzCJtNHvfOIZxOmTvs21e8gBjvV/zzT7jzTplDGs3HTSZRNY0aJX5Pqlo+6qCMDJ9i6f33JaG7oqOSBCoDuncX9livowSZOK9eXXFKmbKyJFp9zBifr4sROnQQhvWmm8T8KyfHd+NYSzjHyMqScxQZKQTUhg1SrzlzpjwXHW0c+ZeYKCtmFUnOt3DfQm76/ibD1Aq7xc72R7bTMKFhmfd18biL+fvo34bPX9fsOmYNNTbY3bMHRo6UlUaPx/i3CuLHc+WVMmDs3FkGkPHx0rAqijTcZrM0qN4Bsccjm3dg6m3YDx3ymeStWweLFvn23aqVMPtGGDdOJJwVGVXercLZnOAbkhbGloe30LamQR5n9hGY1dx/Kc2t6RKDXFYEkRR4fcnr/HvZvw0NzAe3Gcy0QdNKvStN06j6XlXO5Ogn98XYYlg4bCHd6nYr9T50Ud4DXbcDfoz1r5a58aCYJpcVoSaBvHBni2fM7tGQukYILT1z1OLAHCXeGnEtoPkjkHRrXgllkHAhTGwqSaDzOEodrmx5lAMHZDyjhx49ZHzUuHHox20eT0FPjdRUSTj68ku5PEbHbLHIguSgQaJaql9fXp+b65uoFterIydHNrNZxmtpabIS/913oj46cQKmbvmO4b8O1y3N8qJGdA32Pr6XGFtwl8LXHlvLpRMv9bvvuIg41j6wlmZVi4QQlxgzd8zk9p9vx+F2YFbMRFgiuLrJ1Xw/6Hus5iCQ7UHA9pTtXDrpUs44zuDRPJgUE3G2OBbevZBOtTuF+/AEF0JbiRBA/ab0I8uVhUkxYbfYGdZ+GKMHjC4fH8GSooJ4vLndMq5fskTahbVrfXOD7Ozgp/yaTL5qkNxcmaOsWeN73uGAl18W3ye32/88p1YtSTi75hop5a1WTY7Zu4/iKju9c9bISCGvNm2CX38VZad3kbsC/KQDopIEKgNOnYJ27fxH1XXuLDdJQkLF8TrZvVt8eKZN03fNLwyzWeSNrVvLTdOtm3zvxEQZgFgs8hqvf4zbLQOJffukcdiwQWTM27aJoVdhtGsnhIERvvxS6k0ryvkb9MMgft5urAKpHVObY0/7ceMuAd5f8T6vLH7FUDVhN9s5Puo4CfaCk5v0dCH8vvzSP+FXs6aUNg4fLoNHVQ2uhNHplAbaYpEGctw4IZZmzDB+zyOPiFl4RSL+8iPbmU3026GpTxzRZYSx4aWmwjS7TiJMPvTfIGVhZUUQSYGGHzfk4Dn9QvsYWwxjBozhzvZ3lml3t/xwC79s/0X3ObNi5uEuD/PZtZ+VaR9FEIqB7k+JEl1thB6ToeGdsupbFoSLBMoPx0k4Pg/OrIfUvKQpT5YvFawwPDmyyh3XXOK2EzuLp0aMsQF5mXAhTGwqSSAAHNhpwh5SLHUNJygjR8rqbbj7HU2Dzz+HZ5+V/tiI/GnVCv75TyF/PJ6yR1v7Q2amfPa65HSumFsNs8lsGEDh9DiZNWQWfRv31X1eVYVMOnTIt+3Z4wud8KoCnE45FzabTzlgs8HWek+zK+4LLCYrJiXPg8TkaxGyXFlcVOsi1jywRnf/xcV3yQXJLrNixqN5iLJE0SupFzOHzMRuCe+gdOXhlVzzzTW6C5LR1mhm3D6DKxtfGYYjK4QLoK1ceXglV025iiyXTIjOX29rVMUhgoq5/0sv0TCZfPeM1Sp/a9aUuZxXldOggcxNy/q1PB5REsqmsWFtDtu2ahw9biUr24yiaERYXZjNHhSDBR0NBVU14XRZcasmoiI91KrhplUr6Ng5glatTbRoIaVmRhUqe/fCO+9I+ZfZHHhuC0LitGol89BOnUQpFB9f0OPN5fK1TSkpIu7YuNGnnDTqU8Ld/RcHlSRQGZGcLKtH/spb4uJg0iRZpSluDXlZ4a1z9xdTf/asmGt99pmYFtrtImcL9WWfPVtK1Yxu2JgYqd1v1Sr8RFCmM5Pq71c3JGUUFB7o9ABjrx8blP1tObmFHuN7nO+YCiPaGs1HV3/EA50fOP/YsWOyMnj8uPEAMjFRiJahQ+V6h2Lg6zXefP99eOstYyl+8+aisKtoPlBejFkzhpFzRoZkX/Vi63H4KT/xvjPqiyLICG1fhjYvGhqjFhtBIgWSTyVz8biLDcsIIswR7H18L3Xj6pZpd5M2TuKxuY+R6dRvmBPsCZx+5nRwY4VDMdCd20mSgIxQ9wbo8XXZfaDKcr1HAgYVimVGNFALsCHeMQrgQvxgTgElSVfK5xFTKlwAE5sL0hOoHPAar/Aez5KNfkfXv7/4S4S7z3G5xE/y+++NSxtq1xbT1gEDfAEOocTCfQv9KnGqRVWje73uaJqQO3//LWUkf/0lK+Zpab7JqZfk8rdyXwQmF6amC4mIdItBdZ5HU3Q0JFaFZk3hkvZJvDC8fYlV6158tf4rnpj7RIHv6SUFQMrOOtXuxLw75xFtC8+PZuaOmQz5eQjZbuOIpEhLJONvGM+QdkNCeGSF4HaAtRgDzN97AJqoP89vNrDEQEwT8SeKqi9K16j6wUnBzENhAggKXu9QE0H794vKZvt2WTzfv1/G9dvO1KIW/tvaE9SkNsZlit5yLJB7T1GEHEpKkrH3J58Usx10noOUZZC2QfypMnbLWDQ3RUz9TTbQNDR3DpmOCFIzq5KaWZWzWQm4VQse1YymKVjMbswmD/GR56gam0pidBrx0Vkolkhhd1WnbLaqEFUXYpqK4X/71wz7t/R08ez94gs5h3Z7KZMXywCTqXiWG+FGJQkUBGzaJB1yaqrxpBuga1f4978lYQH8EzSlRWamMJc//AD/+hccOFC89509KyU7s2dLPWNqqs/A0F8MX0lhsQjh4C0h6tJFSpVGjRJjaiMiKDZW6lB79Aiv2dakjZN4bM5jZLr0J5extli+u+U7BjQfEJT9aZpG4nuJfkuP2tVox+YRmwFRX/Xq5fMO0MNNN4k3kNUaHlJtyhRZdfVHnJ44IR1TRUTvCb1ZcXhFyPbnedmDyYg5XnA5nFpi/OYqHeHKJWUvCQsSCfTs/Gf56K+PDA3V68TW4ehTR8u2L+DQuUO0+KyFIVkba4tl1pBZXNbwsjLv6zxCQQqsuAMOTjV+3hINt6SGl/TT8TWpsChvBcz/BxIoGCjnc5mYqK9C9mLbNllkCjfuu88/AdS5s6QaxcaWn19jWXD0qASRTJsm5I+3dLw4kdw2m/CJXt8im01+Fl7fIqdTuMbimGBHR/sfX/jDf1b9h5f/fLkAuWI324m3x5OSnXI+rdVusdOqWisW3b2IeHtoEzjHrR/H43MfL0BSRVmjGNhiIDN2ziiwyBJpieSNPm/wdI+ny++ANE2IgFNLpYw3cw9kH4acU1KuPsLjf2EgHjAQPAsUSUQzWUUB7XHIvyNqSCBCbBPoOrpUoQh6BFCkJRJVUwuUrEdbo7mz/Z2MGTAm6ETQ2bMS1jJzpnjceOdxgX7DXgKnQQMxpPb6fVksQrB6xQAOhxCwhw75n6OCn2ZWdUPKcjg6C47+Bln7RZXrykLc+v3AEiskXmRtGZsoljzvQkWMybU8g/Kck5B10L/aWb45DC1eks25c+KJO326zG0zMmTunZsb+FyUBNHRcs2ysyVAYOBAIesrOsoUEV8JQYcOIoO75x74/XdjImPNGujXDxo2FAnvvfdK7XlOjhAjpenUHQ75MdvtUno1caKU3aSmluxzEhKEHLjpJvl/Whps36axdVMWG9Y5WLfewtHjVs5lWMnOsRJhdWG1uDEp3htRwyvI9UaP5rpsKIpGXLSTKglu2rRy0rWribYdY2nd1krjxr5a9Q8+kMZq/Hj985eRIUqqm28WsigiInQ1+5mZ0jDGxsLnaz43JIAActw5QZ1YKorCVU2u4oetPxi+Znfabvam7aVJYhOGDJHyRCOVzX33waefhlfy3rRpYDXczJlyrMX1Mggl1h4LLUE9e/dsbmhxg/6T8W39k0BnNsqgqQJA0zQmb5psSAABXN3k6qDsKyk+iYSIBE649VfEslxZTNo4KbgkUChQrQccmW7sA+XOEqVQte5l24+9pgzIKnHhwig1UA9zLsqrqbH4VuEVC9gSIbYpRNeHyHqyEhtZF+zVy15yGEIEIg7KIggLFjZvFvLE6Fjj42HBgooVkgEy0fz+e1EW79rlmwjpwWqVxdBmzWTs26aN/LtePVHMe70nC09ElbyyL7tdxodHj4rKaOtWKQHZu1dIJ+9+i1MGoofXFr/GeyvfK0AARVmjeKbnM9zR7g46je10fvyX485hW8o2uo/vzvJ7l1M1qmrpdloCaJrG60te572V7xUggCItkdzW+jYm3DiBUfNHMXbt2POkhsPt4JVFr3A0/SgfXvVh8AiMzP1CBhz5FVL/QpLINPDoXHwvwaNYpA2Jqi+bvaYoRkxWUY+cJwXc8jc3BbIOC6GUfQTyK4g9bsg+KNvpFVIKXULoEUA2s41LG1zKY90e49Yfbz1/nrNcWUzZPAUgKESQpsnC+1tvwfLlMqcxIkujo0Xd36WL2HI0bSr2DdWq+ZLJvCh8WPmTtyIj5R45flzURdu3yz20ZIncT7rI3A87/gP7JgFKXr+SN6ZU87lCKyZI6AA1LoG41lKWHd0A7LXk+noc+caihc+d5nvcbJf/55yCrEOQsQvSt0PKSikL19z5Xh8Y8fEyb7z5Zvl/aqpU8CQnS5uxcaPMmc6dk/PoJaH1Lq+XWMvNlWuSkCDKzK5dhaBv21batHArSoOFSiVQCaFpEt/5xBPC7BanI6pZU2L0OnaEnj3lb40acmN7PL4O0buiYjLJzXzokBhzrVwpSqQNG/TlbsW+hM6zkLYWTv8NJxfJTZd7CjD5VpU9uaDm4vaYOZNVhZT06mTkxOJRzbg9FkwmFYvJjc3ipGpMKtXjUoiKcABmsERKMoHqBtUBljhh8Kv3hK5fgKKgaVI298QT/l3nrVa49VZ4/HExCIPgq6pyc+X8798v5XJffw3bjx2ixactyPEY08edandi3YPrgnos3235jodmP2RoRG0z2xjVYxR9lbe44Qbj313t2tLQh9vzICdHGs9cfV9gQOT5330nDXhFwqFzh2jwcYOQ7vPGFjcy43YDE6XDv8Bf9xrHhgP0mgYNBpftIH6pVTZSYKjG2mNruXzS5YaljXERcUy4YULQIn6HTR92ftCmhxhbDGn/TAuewWcolCGZ++C3tv7NwFs8LglYwYiKN4I/pVClEig4n18caJoMkk+vkrTA9O3gOAa5p2USNcIduDSvWKvwdpmsoeXJ812SKmSvCf2WSdpQWVDO57JrV07FFeAAACAASURBVFkkM8LYseKNF85y85EjpXzB6Gs++6you8tDQV4auFxiov3mm0JcGakWqleX8drgweInmZsr49iSGFYbQVV9RrSRkeLR8eOPQqYd1Led04WmaTwz/xnGrB1TQEUTYY7g0gaX8vudv2NSTMzaOYvBPw0uQMDYTDbqxtVl5fCV1IqpVbYv5AeqpvLw7If5dsu3BY7RarLSsVZHlt+3HKvZiqqpXP3N1Sw/uLzAWDXaGs2A5gP45qZvSt/neXLh0E+w/T1pdzDpkz6KSeLmq18Cta8SItleSxQhqkPmAd65heI1dcr7MWiqhB9oqrQ1mkeeM0fKvnJOCTFxYgGkLIW0ddIeldCHTo8AAqgZXZMdj+4gwZ7AU/OeYuy6sQXOd5Q1irva31UmImjmTPjHP8Rfxui+SUqS+2bYMEn4czjKx/crM9OX9PXbb+K/Kk/sgzUjpV/RPPrek5ZoqDMAGt8DNS7Nu1ZWme8FE55c8fwzRwgRtG8SDJwT9DJkJ1ZSqE4K1cnBjgczHsyY8WDBTRTZ1OQkiaRhCaR+grKXnIcAleVg5QC3W+oRX3lFWMfsbGNlhh68KpfISBmU2Gy+1AaHQ8ie4rqv+5f2LYNDPwuTn3tS0lTc2f6NZkEa7Mg6skp4nsW3+hpt1SWTlKxD+h1EYRRqvFNSYMQIkUcGSjGrV09UVb17w0UXCTvujX6NiQk8yCjs8n78uAwkVqyQ8rNdu3yvfX3xG7y17C3DVCOb2carl73K85c8H/g7lwCns09T9z91DaPiAapHVefGXScZN864U3rlFXjhBV89cDhx6aVSBmiEyEj5HVQ0Rv2FhS/w9vK3Q7rPuIg4zj1nMJNzpcPP1QuuyBRG3Rug5xSwxpXPAULg8qGhGo/NeYwxa8ecr7MvDJvZxrGnjgVtRfX75O95YNYDhuRprC2WH279gWuaXhOU/YWMFJheVyb6RrBVgYFHwFKObG8lCRQ+EijzABydDYd/hrQ1eSJcBdwGswlLjE/B4/0b0wTs1WTA7lX9oOYt0rik3846IH149hFwHIXso7IwVFhZGAwT8HI+l2vXSp9jpLJJTJQV4erVw0cEDR0qCx9G+M9/4MknQ3c8/nDwoEQu791rrPrp0EH8Rbp18xlXhwLea1xcskzVVEbMHsE3W74p4lVXL7YeySOTC5R7vbDwBT5Z/UkB8sBislAzuiYrh68kKT4I6YyFkOvOZdCPg/hz/59FjrF2TG22jNhSoN/MyM3gorEXcfDswQL9bZQ1im51ujF76OySeRlpGuwdD+ufBjSJni8MxQx1r4OGd0Cd/tJOKJby64fOEwM2ISrqFL8fNyKAIi2RLL13KV3qyJzY5XHRbVw3kk8l41Z9k67SloZlZorn14wZxvdN3bpS0dG7d+j8Or3weMBs0mDfRFj7uBB2ekpyxSJek62flflieY4t9eDKAFuI91lahLvUOgAqy8HKARaLsLd33imGxt98I7Fx3lWLQGZRubn+VRLFgaFhYNZB2PouHPhG/u/J8t3kaqGJZlQSVLsYYhpDfGuIbSGmbBHV8sgeP7I8xZTH3DtkwpKxF85thYw9slqZuloGmzqoXl3O1+bNIpX89VdjifGRI/Dxx7KBL8msXTsZhLRvL42o3S7kh5fx9pJq27b5XN537jRWH4HG2HVjDQkgkEls/2b9DZ8vLapFVaNhfEN2pe0yfI3D7WD/qRTAmHVOTKwYBBDA7beLks2oI3Q4ZFX0kUfCbwaeHz9vM06FKy+k56aT6czUj9u1xkF8G/9mwcdmi4Q31B11PqiayrdbvjUkgEAG3MGU1F/e8HK/92umM5MJGyYEjwQKFerdBHvGGJf5Oc/IgL3pg2X3BioN4ik/Y+hgoqKajunBkyOqvx0fwdlk6cj01GCWWKh5hazK1rpSJPmKRd5/fkXdnufHEACaKu/z9tNeo9bcFDj9l6zEn1oc1K9ZXujSRZQ0772n3+ekpclY4ddfJSEmHL6Dl10mCgEjJe9PP8GDD4Z/YWTbNuje3XgsazbLYtNzz0nfHYoglPwoiVLKo3q4c/qdzNw5swi5EmWNYt5d84r4/bzZ501WHl7JX0f+Ot+/uFU3JzJP0OXLLqy4b0VQ4um9SM9N56opV7H55OYihtzR1mgWDltYpN+MjYhl4bCFXPTFRZzL9TXG2a5s/jr6F93Hd2fR3YuoFlUt8AE4z8KS68UA2GPw46zWHbpPFs8XS3RoSkXNEb7+LQgEUJQ1ijf7vHmeAAKwmq3MGjKLNqPbkJ7rU1tnubL4ZvM3aGh8MeCLYhFBmgbXXScG6Ubzu7vvlsoDr3F6qGE2A3snCAFktIAf1xIumwX22nmKnzBIE8vqcVmJYqFSCRREeDywapWs9Pz5p6yg2O3yeDCMl2NjhWTyeKRm9NprZaLdpk3eCzL2wMbnpIbXSNqHAtV7ScRw3etE6aM65UY3BaFF8hq6qW5h71P/hgNToZv/JK20NCnHmjxZBiDhcHqParYa5Z6+hqUsIIqNM8+ewVQOHeBzC57jw5Uf4tb0JWAmxUSHvZPY+dNdhr+nK68Uc7RwGmt7sX+//E79GbPVri33SUWRvwPEvR1nqCxRUEo9+EvJSuFMjr4ZnlkxM/eOufRr0k//zVvfhS3/AtUPc9z0Iej4QVATNQoggBJoWa+lDJg6wO+5e6TrI3x67adBPSx/cfQgK39pz6YFJ+o3VMqQEwtg2S3+SwAj68L1u4Mvy/aiGMqvMqEilFoFQqiO8egcWH2fELm6ah8FGg6FFk9ICYYnR9Q/wUy+04PXcygYZYchOpfffQf33+8r99ZDv37w0UdithqqyZjDIeru9u39h3mMHi3lGuHqwz0esSxITja+HOPGydgz3GRVILg8Lm754RYW7l9YhACKtEQyaeAkbmtzm+570xxptBndhhOZBT3nFBQS7AksvXcpbWu0LfMxJp9Kpu/XfUnLTisy9rOarIzsMpL2tdobvn936m4+XPVhER8+s2ImLiKOOUPn0L2+H/84TRMC6MR8Y7Vxy1HQ/tXyLT8OElYcWsHV31xdZBxvM9vo07APc+6Yo0vozN09l1t+uKUICRdljeLO9ncWiwj6+msp+TQiebt2hcWLw2zX4DgJs5oY+8mZbHD9LvFzCrcn3AWQSknNmpJyU4FRWQ4WJjidYsi1Zg2sXKmxcN1+Uk5ZicitS2aGCZtNWFlFkU3L81xzu2VLSJBSwzp1oEUL8RPq0kVM9oqsvOyfCn8/CGreamARKNDiH9Dm+Tx2Pbr8B5BeuDJLNDFNTxcSbfp0mD9fSoa8aWOlNQMsjKgoUVE5HOJJc9llcLrXcJZlTDqfDKGHm1vdzM+3lY9SZNnBZVz33XUFViMKw65WxfZxCunpxp3R4sXS2YTbFwiklO9ogCCob76B226j1FGvwUSgxKme9Xuy4r7SpYZN3z6de369R/f6WhQLo3qO4u0rDcrQzm6BeT2MV+lAVv9vOlH26HAjBCAF7ou+l8mbJhveP3ERcUy9eWrQUvW8eHj2w3y57ks0A8VirC2Wr2/6moEtB5Z9Z6EiBTy58GOCtOf+0HMqJA0qnuqjpKgkgUJzjOuehD1fGq/KVusOF08IemRyyBHC671zJzz9tIwjcnKMP7ZDBxgyRLxsatQQD5zIyOCQQt5Aj8hICRWZOlUIqhkzoG9fMYg1IqmeegreeEPGh6FW9q5cCVdfbexj0rixqKorwvjCH87mnKXZp804nX1a9/loa3TAxC+Xx0VKdorucwoKkwZOYliHYaU+xoX7FnLVlKtQ0e8zbSZbsbx9XKrL0EpAQeHHW3809uFLXQMLrjAeW0QlwXXby7f0OEiYtmUa9/x6j646OCEigdHXjSbGTxs6fsN45u6ZW+Rc2sw2+jXux8zbZxqnuAJ33CH3uRE++kh8gsKK43/A8tvAZSDlrdoN+swPq6o8aLgQxhghQGU5WJhgs+WZQDc5ygTTLRxrvAZN07DZYvj++sn0rnbT+dUhj0dICYtFFD+JicVPfmXL67DtXeNBZHQD6P0jxLUKzyCyhPuMi5PovYF5c7bsbFEHJSdLedHmzUIMpaaK27vbLefaZPKdMy+h5nTKY/Hxck6rVxd1SpcuUk7Wpo3sD6DlZyuIMEdgNiDHnB4nt7e5vegTnhxwHM/bjsnf7CNibJd9WKS2mjtv8+T9VUW2r5jz0losdMcM7ixizBbA+2WUPDZemMJs1xmeffUA77/UyFAN1L8/zJ4tdfrhVgQNHCjGkv78st54QxLrQk0CZWYWPT/z987HrOhffxMmLk26tNT761KnCy6PfnmkW3MzY+cMYxIovq0o6/yRQJ4c2PEhtH4u5AM2twY/bfvJL4HqcDm4pMElQd/3tc2u5bvk7wzJ0wxnBuPWjwsOCRQqmCNEsXlyof/XbXoR6t1QPiRQJcofh2f4J4AS2kGfBRfECnxFQosW0gdu3CglS4sX65ebb9ok23PPSaJrx45Sat6hg4wTGjaUPsLh8N+HeVN50tJg3z4hSZKTYfduWQQ8nY+H6NRJjqtPH1lA1uvH//MfMT5+801R3LjdoUlKdblkXOWvvCshIbDdQbhxIvMEzT5p5jflNcuV5Vf1HQgaGnfPuJtMZyYju44s8funbJrCsBn+CSSn6sTpzwuwGNDQGPTjID655hMeu/ixoi9wpftXfEQkUpKkJr8oU/iECYYa//DGrBnDyDnG18Glunh49sMB95LfF8gLp8fJb7t/o/Xo1mwbuc2QCGrUSEhbo1KwjRv1x50hRWRd//6SWQeAICmAyvF6VyI4qFQClTN+2f4L98y4B4fbgVt1Y1bMeDQPUdYobml1C2MGjCmZeVthnE2Ged2Mk2SscXDDXrDGh3eiUI6yPgd20kjEjQUPZjQULLgx46EKZ4imeLV4qZFwZtNfUFXfs8SsOmmknZGVk5OLxKMl97Q0qCZ7Xvyldj5hrTRI88gmO4zwXTPVDZ5czJZIGg06wISp1Xn0UWMTTLNZvAXeeUeIxVCu2qmqbxC5YIHENhrFYnrx5ZfirxWqsjCXS4zBL7+84OPXTb2O33b/pvueuIg4vh74NTe2vLFU+9Q0jfh34o0T4Ew2Tow6QZXIKvofsPIuOPAtfgdk5ii53yPLIcHEjzLkjywYdDrW8LsBtK7emq0jtwb9sM7mnKXm+zX9DpYjzBGc/udpfc+lkiCUK0sHf4DVw43NgL1oOQra/Sv4BH+lEqj8j3HFHXDQz9Jxp/+IgjdYkc/hRBiv9+nT8MMPYsa6aZMvRrk44RtRUaJ+iY72lY5ZrbLA5N3OnpXyZ1eAvA3wfUWHAz79VIget9t/bPzNN4vKoFcvmWCazXJcZfXi8XonWq2ysPb996JkOHBAFtj0oCiSVNu2bdmTv8oDB88epOXnLQ3VvOWBf/f5d4nCQr7Z9A13zbjL8HkFBZu55HI0p8dpqIgF9IkgdzbMbikLlka44ndJASvr4lKgPiUQDPqc0WtG88icR8r22cVEi6otDImg9HQhkVP0xWMoipDTl14aZiJo5d1w6HvjeUqjYdB1TN68pgyNTDld72LjQhhjhACV5WBhQJYzi4dmP8T0HdPP1yIrKJgU03njVLvFTrXIasy4fQad63Qu3Y7+fgj2fIXhxLDNS+LwHgw/jLLgQhrE5r8nzibLxPvIr+K5ZIkEj1O/TCOmCcQ2ETO1yDoQ0xCiG8q/7dXBFJGn/MmLyzwfk+kREi/npKSzZB6A7IM+VVH6DvnrRV7DOHu2mJN7E+X0kJAADz8Mjz8uK4nl6X+Qni6fvWCBmOOBDG7r1DHuFL2IiZEV1OrVy+fYCiMzU1Z6Dx3yPaZqKvHvxJPp1J902y129jy2h7pxdUu9314TerHy8Erd5+Ii4ph440RubnWz/ptPr4aFfQKn8dXsC5f9Gnz1gJ8O/fbj8L0frsKsmHm6x9O82+/d4B5THlp81oJdqcam6rG2WMZeN5Yh7YaUbUehHFSobphRL/BKmmKCq1ZBwkWiFgsWKkmg8j/G7R/A5n8Z39N1r4de3wXnXg73qmwFud7p6bB6tQR6/P67qHZMJum7vCXnwTgML1HjDaqwWkWdu7CQuC89HT78UMxiXS7pm4z2b7dD585iCdCypSiWmjeXtCFVFULK6L3eyHYvYZWcLN999275mz9u/ccfxcDWSG1cv74YbDdrFn61cX6kZKXQ6vNWpDpSDV9jt9hL5emY48oxLNsCmH7bdAa2Cqw2/XbLt9z/6/0Fot3zI9YWywu9XyAmouQn1uFy8Pbytzmbc1aXDLKb7Xx49YdFlUtnNsH8S/LM5XWYTLMd2r4KLR7LSwsuZRFJmdogdPucUBJAXvgjgtatE7/W9HRjP8y77oLPP/e1ESGHKxOW3QQpq4zV5QntpO+JSiq9SXM5XO8SoYL0OeFGJQkUYqw9tpaB0waS6kg9vxphVsxUj6rOJQ0uYc7uOQVkqJGWSF669CWe6/1cyTunVXfD/q+Nn7/oXWj5VOkb7fwoyw09kgsnTeboAdg1GnZ9Jt9XdRXtGBUTJHaB2tdIVGZCe87H7ypmSU0ryzn3Ek2aKoogTw6krYOjs6Dzf8+/LDMTXn9dBpBut/+VyI4dZTXxhhsgKcn3eru9ZOlc+QfK3kHlhg0waRLMmlV0EPvpp/D884H9nC69FObOLf9OMTNTzPumTCl4nOuPr+eySZcZkkBxEXGcffZsieJCC+PFhS/y7op3DRO07ulwDxMHTjT+gLmd/KeEedH1C2h0Z3CJIANSIFeFxH2Q7acriYuIY/rg6fRp1Cd4x5MPT//xNB//9bHfcrQrGl7Bn3f/WbYdhXpQsWs0bPynsYmjF5G1YcA2sCUEb9//T0kgTYMzZ+DwYehwUeBjTIjXUFUZ0JvNorw0m4VUqF5dVCTNm4sJcf36vi0mBukv5l8CZzYa+z+1fAravy5lw2VJgqtcldWFqsKxY0KM7NsnQQXJyRrLNpzgzMlotNxYVFXBZBIixevjqKq+oA5Nk8cTE6VvbdFCFhmaNJESkcaNoVo1/6fA44FFi6Rfmj7dV35WXB/E2rVlH1arb7HH4/GplRwOIXqKk0qraaIIevBB41I4k0nS2F5+OXTlavlRuKzmWMYxeozvwbH0Y7rhGnaLndcuf42h7YaWan+nsk7Rd3Jfzuae1X0+0hLJuBvG+f38D1Z+wCuLXiliPuxFlDWKv4b/Rbua7Up1jAB70/bS6ctOhuXRUdYonur+FK9f8XrBsYzjBKy6B04vF3WQ3sJybDNRnda9Xv5vsod14WH5oeX0ndzXUAVsVsw0iG/g18fHCKezT3Mu55wumWZSTAzvOJyx143VHQ+eOyf3zsyZPo/XwqhWDYYOheHDpX9wOuX3XF5Jezk5vmTkuDjkJt/zJax/ClD0ySDFBHVvhMb3Qu0rZV5iiQpeVcn/0zFGqFFJAoUIHtXD28vf5t/L/l2gkbearNSOrc2q4auoHVObJ+c9yVfrvyqQVhBtjaZNjTb8fNvP1IurV/ydHp8PSwf68QNqCAOSgzMZ/P8wiDw6G1bfD64M/XNqskkKU/vXAVPBCMtQwJ2tK8k9dAg+/lhSOyBw+ZWiiGlzq1aydewoq4rVq8sg0mqVyYyqClHkdsuq4K5dstKxdSts3y4GnHoqpPyXIStLqgGNjCbz47XXxNCzvFJHsrOlYx4ypOhxvr3sbV5d8qqhwWLvpN4su3dZmfY/c+dM7pp+l+EArWZ0TU6M8pM0cPQ3WHF74BIhkw36b4SYxsH7fRrc/3ud0PwgWP3sJ8ISwYmnTxBpzVfv53ZAzvF8flrHRZLu9dJynPAZ3Z/fVGRwmuenZZK/y7I1+uw7hTm/lxaK/EFB06B6dHUOP3m4TCReyAcVbgdMr+U/JcyLxC7iH2ONDU6qx/+DAVpmpiR6LlokJsKHD/v8W+x22JVRi5qa8cLHCWpSm8DJIIoiJUhWq7SpDof8u0YNWP93FomHX4I9Y0Wer0dkRtaGju9D/ZvzBuKlSAarXJUtFlRN5bE5jzFm7Rg0NJLik1h6zzJqRyXhdEp/6HIVLA2zWIIrdtY06VuXL5dwjKVLRU0bGSlkk7eMq6zIX1aWmyv77dBBlFIg/f2994qXSU6OPhkUEyOefg89JF6LOTnyWLBLxVRVxjV2u4w9vvxSktQADpw9QM/xPTmVdUp3gSXSEsmtbW5l8sDJZTqGVYdX0ffrvoYkTqQlko+v+ZgHOz9Y4HFN03TH/YXf+90t35W63Dw/Fu1fxICpA/ySTbe1vo1xN4wr6IGpaZCyHLa/L3MLRdG3mlBMUK2HqI7rXAtVLgJUaZvQZPxR0tIxdw78EMAPIF8btPzQcq755hpDX6dISyTL7l1W6ioLt+qm21fd2HJqi65PUJQ1ijva3WFIBIGo7N57D779Vu4HozFwjRpiTdC/P/TuLeNlm813z9lsxVscdbl8pK23fTp9GvbskXHvn3/Kgm0BTy9XBuwdD9vekfmFJ0u/DzJFyDWv3Q9q9xevWWu8/D407+J3VOB+SVNlP5obfjKwPvDi/0mfU96oJIFCgCPpR7j5+5vZmrK1QCNvM9tomNCQ5fcup3q01Lpomsa/Fv+LD1d9WOC1FpPlfGylYUmIHpYPFoWIkS9QzSvEGNoSLbLO0uJ/nQQ6+pu45hsRarHNod9SSVaroCktTqeoacaNEzNMEAInGAPG4sK7SpofL78MH3xQvOP45BMZeAZbZp6VJZ3gLbf4FFP5fy5dv+rK2mP6bZJZMfN87+d5o88bZTqGo+lHafppU0O/gkhLJFtHbqVRlUb6H6BpMLNxnnlfAERUg34rIDqpbPe9F37u/7Me8Nyin8KCphLpOEJURjKcWgYpyyDrYEEvLU2TCXApvbQAznng/FDNZAUlIi92UQU1B7vJTPTNR6Q0s7QIx6Biy5uw7d/G7Xt+JLSDK5eAJa7s6Y//gySQpsHatfDLL6K22LdPJtZZWcZmt9HRBRU8SUlSBhMbW5Aw95IDTqcoiXbtElLJux054luJ1f2KZ7dKwMPhn2RArUf0miKg5mVQ53qo1VfKj90OZOJlFQVqaQnA/8HrXVI4PU5u/+l25u2dR7Yr+3xIQII9gcX3LA5KJHhp4XCIV8++faJa2rFDAjP274dTp+S35/Hwf+2dd3hb1fnHP0fLlpw4cfaekIS9N0kIIRD2KCukUKC/QikUOpilQKGFMtpSRpktFFpWwiZAAgkkBCghAQJZEBJnONtxHO8l3fP7473Xkm1dybZsSybn8zz3kWTJuq/uOON73lHvlebxyOF0rmvHU61LF7mGR42Swhix3kp9+sQ/TV99BbfeCu+9J9e7m3dSMAhjx8KkSSImDR8uHkp+f3SxyO+P2ucIRY7dTkgbiNijtSTPXrNGFp5mzxbBttTWxLWG77Z/x1FPHUVxdXFcT1Cv8rJH7z1Y9LNFZPlSXxB5+POHuWH2Da5iTsgf4vZjbufaI68FpMLY1Fen8vb3byf8n5uOvonfj/t9yvY5PLLwEa57/7qE+xw3dByvnfca2fHSRVRtlbwx614UL3RPtizKuOXey+olFQxDgyFnsCxAdx0NoQEiCimf7UGixLPesrfqbVC2Esrz4bsH4n+3g90GJROAQv4Qf574Z64+7OrE35eEDaUb2OuRvVwX7XL8OVywzwUJhSAQz6C33hIxaP58uceSjcud+3TYMPEiHTEiKg7F8/SrqBCxZ9266LZ5c/wmNW4za0Wg8CM53xtnQE2RnK9EC47KB6FBIgjlDJVz3mW4jDc9AdlQcs1YtTK+q1gvC30V65IXvtgF+pyOwIhA7czLy1/m0jcupbKussEqRJY3i9G9RjPv4nl0z27qpn/vJ/fyh7l/aKLWh/whzhxzJo+d8ljzEpladfDlb2H1PxMkiO4Ohz0hbpw60jrPoB/6SuLLvaDWPZack5dC1zGpT646CMuSuP85c2QV4KuvxBMmGJTOo7Iy9fYvEJDBmtMZDR0q5WUffrjh57Zvlw7NLXdRY+65B668su08gioq4J13xAModrJXn6Szroru93R39QLKzcrlubOe45RRp6Rkh9aavHvyKKmJHxsZ8oe4/4T7m6wkNiD/WVh0ZXJvIJD7ftJ86Lpb6kJQSyaJdeWw4XVY8x/Y/on9RxXf5kAPyDtAxKpgfxlI1OfS6mN7tji5tOx7T1vRLVwONYWSQ6tirQwwnAp9xYuhOsZTI9PboHjU7oTXBibPBeXQdXcR//y57Rs+1ImOZVkZ/Pe/IkRv3Uq9R0djunaVsNRjj5V2bPjw6ATWskTscbwxkuEk+3Uqfzpi04oVItTPnSvluJsIQ+EKWP+KJIzeNj+aPy7e+fdmQ+4YqfgSGigTsC67QZehcv/4Gt87OupV50zAKgugfDUsilM5KJZWnG/LkonIunVw5FHJz3dWQNeHVjlhdT6f9DEDB0rS1TFjohOjoUPl7742iHYvqynjxOdO5MvNX9aPyZxCHgpFl0AX3pn6DkcPOTq1HbVjkQwAC0UdfmoJ4CVCgFq8RGjREt7WraIINaKwUMTT//4XPv88WgkpWYhZbq7cS8OHy/lyPKgCAWkGnPuxtlZEn7VrRfgpSjAcA/h6yzeMf3o8JTXxw3YAumV1Y+kvlrbMwz4BWmumvDKFN797M6GnzXVHXse1R1zLKS+cwucbP0/oPXTyqJOZdva01LxU43D5jMv57zf/Teh9tGfvPZl90ey4c5R6IrUiBG37CDa9DSXLoW5ndKKvdWKBqE1QcIGVVADK8mYxccREZkyZ0SbHc+aqmZz10lmu5y/Hn8P5e5/Pk6c+2az9WZZUOJ4zR/J6rlwp95XHI/cTNAzdSgWlxIPI54uKTl26SAqHpFRuhK1zxcFgxyIZR0VqogsNVm3zFqZazQ8nD126MSJQO7GlfAtHP3U0+cX5TTogMDCsGAAAIABJREFUhSLkDzGq5yjXkuMgccYFJQVx/9/v8fPkaU9y0X6Jy0jWs/FtWHSVVKxymyBm94Wh58PIn4pnS6RaBoptEYja2ScN0/OkY3Pj1JWS/DnVUItUxbQUGsedO8XNfMUKSQa5erWsIm7fLu+VlkYHdM7hdgblOTlSqaRHDxkf9u8P++4r4WRjxsiAPNHk6LLLJG9QcyqogHgP3XBD6kJQeTm88op4FzW+PJzX761+j3Omn+O64pPlzWLNNWvo37V/asYA458ez0frP3J9/4SRJzDzxzPdvyBSC6/1h9odzduhrytM/EAmi6l4sDXn/t65FL65BTbNFA+feO1QcAD0mwSDTodeR0oem0iVnfPEqbKXAlYk6qLszRbX4x2LoOA1OPTR1L47XYOKr66XHGXNHXRl9ZbcYYNOa513SF05TE+S5CPT23P73194QZLjW1Z8DwaPR3KlXXaZhLPU1Eib0xbCghtOjha/P4mbvxWB0uWw/X+wZQ4UfiJ9h/LaAp8SMSdiewO1F9l94azEYW8lJbLKPWuWiFsbNsgk3lm1/q60bULrnHLsXq/0JTU1UgBh4EAJm+rWrcW/jm0V2zjm38eQX5xPTUQ6QL/Hj6WtBgt7bRKy01mKZCS596qqJDR84ULxsF24EHbsEMFOqWhoSluQnS3XkNbRiexu4z/n20OPS1iRMugL8u7Udxk/bHzbGGJTVVfFAY8fwKodq1zz+4X8ISYMm8Db37+NQrkKBPv13Y9Pf/ppA28cyxIdLtaTcPVqCS9at05EA8fzy9ksS4674/Hl9YLHF6bq3InU9vsYiF569ZYoCX98/JTHEy88xcOKUFq4lcJ1BZRuXk9VUQGqYjXB8Pd0968nL7iFgLcGryeCx2Ph80TQGjQKj9KELS+W5cHSXmrDAXZW92Zn7RAqvbth5exOVt5gcvsNpteQwXTv3x/l9ScVgAD6denHt1d+S7fsVjQELlz73rU8uujRhF5VU/ae0mwhqDHasigsKGTdyu2sW1XGurW1rPzew8r8rqzb0oPCkjzCES8RSzZLe1HKQmsPCguvJ4LXI4+h7CoG9Spi5JBi9hhVzfDhXoaODDJ0tx4MHtWXrJwUkm7WlUPlevHiqVgLZflQuiK68NYgfN8J3VfyWL8YYXuEZfeTxb7cMbJI6XgS5QyFQBudOyMCAUYEaheeWfwMl755acJEpG3FxOETeeeCdwj4mpGATWvY9A5883so+Vb+5pZw0t9NQsV6j4Vue0r+kOAASfTmuJgrJ9jdqWilAXsF3nl0VgNeTJIsLNMnDWtflJLMbivu3feD4+a2Lt45llTD6jogybaFIoIXDxYerJatIkLclcT160Uwcqs4Eo8jjhDhaMCAloeHVVSIB8DPfiYrLvFwLpdrZl7Dwwsedq3+kZedx44bmim6JOG2D2/jzvl3Jhw8lt5YmlA8ZuWj8NV17pUdGqO8sPsvYL+7RGRpqVdQc0SBEZeK90KkFuIdx9wxcOBfoe+xMnFtbcWJ1lJXAf4UFcV0DSrCVfDWbuLt1BJ6HgqHPy0u295QcoGtrkza+eX3wtI7En82w9tzy5LS2rNnu4evHHIIPPNMTKLmzoDW4qpftVFWa6s2QEUBumwVW7Z+Rl3FOvr6/QQ8XlR9BUq7v4boYNzJq+ULyoA8NNgejA8TryLHuyg4IK5HmdaSK+bllyW8Lj9fJuvl5fFzxzjk5cmCwZAh8jhokAhhgYCshDueITU1IiI4nkTOlqjSZGsul/zifMY+NZZtldvqc394lIeh3YZy/t7n8+CCB5sU8rj/hPu5/ODLW74z+MGIQE0IV1G2bTMFq3ewPr+M9WtqWbNG8+3qruRv7MnmHb2ors0iYnkJW86EVtojryeMR1n4vGG8nghZvjr65hUxYuB2Ro8oZcQIGDLUz5AROQwe2YO8Af05/eWpvLnyTVdzFIq/HP8XfnPEb+r/FonI0GTjRhEpN26Ua2r1anncskXGDLHCipP4OzYxuMcDnrx1VFx0ADpQHLvTBnjwUPCbAnqFernaWVvlZ8ECxdy5IqCuWSPhpI63FKTqGaLBKytvTm4yn09+V1WV3LP5q3z07eO+UOB4lc+fLx7V33wj96Flyf97PFHRz/2y0XiUhVKaiOWlycGKwRH9QNoBy4LcvT+m6uwTXIUYkHvz40s/5sD+ByY5JgnQWtpL5am/V8NWmMP+eRjfbP0mbn4gaIEQFK6A7Z+Jl83mWVCxBmqL7XmUfcIjib2qtIZwxGcLbInuU4+078oXrULszYaru7SrN2I9TnrG1k6TXTwSm79/IwKBEYHalIgVYcrLU5i+YnrCz6mWT5td3VlBykYu+8UyBncb3PwvLF8D66dLjGfJMrn5kzQugHgOdBkGOcMhq6c0TB6/7fYZkUmetlcfK9aLIly1KX4ysVgyfNIAwJr/ijdVpCa+eObrAntcK5sVlrC6lnoupOoJ1BkqrfXtKyOqRvztb5JboLkVT0AGGFdcAX/+swwGEq3SO8kjAwEJ/bjrrsRx187lMuKBEazZucb1c8cMO4YPf/Jh841OwIyVM5j66lRXr6Ouga7MuWgOhww8xP1LtAUzD5bSri3pYR0PkcFnJhdinAp14XJYcJm4gSfCyRkQjz1vhL1vSa28bCaQzkHFtvnw4QmtcMFW0Gc8DDxNznuwr7Rv9W/bq3PbPpL+YtMMCRNKRoa353feKfe/m+h8/PEiXgSD7VeRpaNYU7yGKa9MYem2pVTUVRDyhRjZYyTTzpnGmF5j5ENat4kAUVMDL70Ef/yjCDRuoXUej+SFOfZYOPlkyT3j5Jxx2uSsrOSVKWOTIGdlyfcWFkrI0KxZIvItXCjhDi29XBZvWcyEZyZQWlPaYEEvNyuXxZcvZlj3Yfxo2o+YuWpmg3CQkD/Eb4/4Lbcfc3vLV/7bORysTXDpv+up2ireadvmiYda+WrJ9+ENirCoLfdy4zE45yvpIXS8RJXXHoNWo/Gizyt39XKsqoIvv/DwySeSy+jrr8VbzfFM01qu3dTyJWpQ0YvOSf6utVy3kQhs2uhpMo/99luYPh2mTRPP7GBQ2ql4VaQgWnXOyUs2bJjkdOrZs2khD6fqq5ND6vvvZQHO8SjauLHp/Rrvvtm5U0L/XngBPvlE7jtHOIpHMNg0d9qoUSLyZmWJfX5/1EvM2bZskeMRa2NBQZziJuefjhrzluuZUErx0OSH+MWhv7B/lCVREfWFJzbJY/ma6JylujCaCLmxWA7UL34rLxvDigPW1rA9Eq+RkQvY5/Gx6Tcb6ZXTKO9gybfSt66fBqXfiTDjJEeOR6CHhMfX51gaBrmjIBA7H/PZ+Q7Dcp+Fq2zvnO9tb50Cu8DGRhnrxTLV9TBmHqmMp4wIBBgRqM0oKCngrJfOYmnh0riJXf0eP2N6jeGcPc9peal34Psd3/P8kuepa3zDIitTIX+Ip09/mrP3PLvlxteVSkzv9s9h64cSHlG3M9ppt7dLeTPcyZPSUTd0XSksuwdWPynHJFLZVODyBqHPWBhwMvQ/XryonEGiN6tj86+0lOYOWtuhbYhEpBLZ0qUt//pAQPJ1nHGGbH36yCBCaxlclJVJ8r1XXxX39OYITVrD1vKtDPn7ENd8QF7l5ZZxt3DbMbe1zGAXNpdtZvgDw+vDDhoT8Aa4ZdwtyZNEln4H7x7QurjsrN7Q/wQYci70O9ZeKQoDHhlglK2Cgumw4U1pN1JpF7ruDid+LQOfzk66BxULr4T8p1OLxQ8OlAGmr4ssCNTulEUCtwGpGxkuAuXmJq6SuHateKJ0Zixt8cjCR7hh9g3UhGsaeBd6lIcsbxa3jr+V6468LrFnYTOZNk2qQIXD7pVuJkyAiy4SLyyQtjnYTrd+bFjdu+9K0v/m8uGaDzn1hVObhJYEfUFm/XgWY4eOBST055AnD+G7ou8aeAGE/CHO3/t8njjliTY5ts0mHf231rD9U1jzbEzS2Cw73DfOIoST183xKOsyQrbQIFlYVD7bI81rJ++PSPtjRWRcWrlBJuvlq+V55UY7d9WqhmOxRm1QQQH85z8isCxbJtedmxdNjx6S4H3gQNmGDJGcU0OGiE7nCBeOB5DjFeTk+tq0SbyHVq0SAWPjRtm++66h8Oychro6eP11qRa1bFk0j2JjsrNh/HiYOBEmT4bRo2XfTvU2Jw9jc4Xr2IpRTm6yoiKpPDdzpoio+fnRz3/5pSzWvfKKeD25jaP231/u9ZNPFo/KUCiaA82pOtfcCnGWFRXBPB6xsa5OPA3ffluSgS9Y4J68H21JnqKiz+3iEx+LIKJ8dlJqJddXuBqI8yX1IqNPxBXlta/HsDxGquIvcjcQJy0RQs+3x3VWneRFXH6v3b9G4i/Ae7NlkabvRBgwWZJpY9kLNVrs92Y3P6Tbmctpy7YvKLlOCz+WMP0ts+HyyswXoiG5GJ2MdI/XMgQjArUB05ZN46dv/pSquqq4YRxOucDHTnmsVQKQw/x18znxuRMTZr0/ffTpPHHqE81LGp2IcKV0rBXroXI95cVL+Tb/DTzlaxmWnU23QBAv2m4IIzGTRKcDtxtMX9eoUt11NwgNsVXsIVKJpy3KFUPyFbRUG4zGOAOf/Gdg07tQs028HSIVcjxi8QSkMk+XkZLcNjQ4OujJ7gdZPUD57VUFJ7QuEk1ua9XYqxZbRMX/ZEpi2zqpCAQySDrwwJaFhcUjJ0dCODwemZAkmvC5oTU8v+R5Lp9xOeW18Wc1uVm5vPijFzlx9xNTMziGHvf0oLi62PX9A/odwJeXf5n8i5bfB0tub35YWDyUR+5hRxSoK02pSlcTcobDycvaRgRKyYvuB5BoMFIrwl/Zt8k9L9ubDBeB8vISJ8BcuVImgZ2VNcVrOP/l81lauLQ+RMJne9l5lKde1M7x5zAib0RDr6AWUl0tws7bb7u328OHS/Wbvfdu2QSwrbCs5k+MX1r2Epe8fkncohzxEvNvLtvMPo/uQ1FVUZPPjx86nlfPezV+haX2oCP777oyWPkPyUdWt9Ne6IrT7nTbSxbEBpwEPQ60E8fWyaNTKag1WHW2R1FExpwen3i/bp4lnqknfI7W8MYbcN99ImA4XjiN6dVLSnCfcoqU4e7ZU0QLpURYaa1QaVnyPXV10XCr9etFuJgxQ2xbuBDOPVdyL7qJp8cdB7/9rQhAtbXtn5cMxBaPR+7XHTskL9q770ZLkzdm8GD43e/g7LNFiHLyc7UnsYnHc3Nj3ohUiyC5+impaoWSkx9vLJTdB3ocLOPz0KDoY7CfeNf4giJAYtn3jeM1aYeEKa+ExDueRZXrbYFyE5R+KwtlYXsAeoGGooVSaThRftZ+x8GY30q1x0ht66IKWkq4XH5TKuksHNI9FmoOzbGxtsQWzLxxtk4SupsEIwKlQFlNGZe9dRlvrnwzYVKwKw6+gvsm3dcm2egXblzIcc8eR2lt/HCRbF82PbJ78Pr5rycOGWkmxVXF/Gn+n3h04aNEdITaSC1+jx+fx8fF+1/MH475A31yUojLbAMsbfHCkhe49v1rKaspo6quCguLHH8O+/TdhwcmP8ChAw9tXyOqC6VxL/pMvKlKlsmE2QmVQ4lgFnEZKLUVqXpVpVkEAsnzc+WVqQtBqaI1nDf9PKYtn+b6mSxvFut/vb5N74FjnzmWD9e6h5cFvAF2XL+DnECSHDZawwfHySpPu1bmaAbeoLuHysjL4KD7YxLatpJU82lluHDRLMrXwDv7RQed6SLDj+XDD0tiebc25qijJJzIWfHvLFja4h8L/8GNs29s4P2T5c1ieN5wXjvvNaa+OpUVhSvqRQ7HK+iW8bdw/ZHXt9hz5aqr4F//cg+dOeMMqRjVGY7lAwse4KbZN8UVgC7e72L+cfI/4v7fF5u+YNy/xzUZBwZ9QfbqsxezL5zdpsloXemo/rvgVVjwM9sbOk67rryw2+Wwz20yqXS8IjoCO1T5+7W5/OQnkqPGzWPlyCPhwQdFnKytlQqAHYETmv7ss9IOuYVRDRoEjz8u4k9bVUNtKStWSHtYWRlfQPP74frr4aabGuYqSgtVm2Hx7yS0Snnj94PZfcXTedAZ4rHv6yKikTe77a5RJ+TRqpXrv3orbH5fcv4svsF9LBQaBIc+Lt4/ranSnClkwlgI5DxUrBPv9ZpC8VKsKRSB7qT/QHGCcXE34DE/9cmrnXxQ2EKgJ1tSJgTyRCzM7iOL/MEBkN1L/jboDMmjm8EYEaiVfL7xc8548QyKKouodZlghfwhrj/y+jYLFXFYsnUJ4/49jpJq99KXfo+fW8bdwu/G/q5V7sjlteX89dO/ct+n9xGxIlRHmo7wsrxZeJSHqw+7mhuPvjFxGcl2QGvNWyvf4lczf8W2im31HlJeu1S0U74125fNUYOP4m8n/I19+u7T+h22NF5fAV2BPKC7veUBve2tOxCyP+fkwvPYm9VoiwAVQDGwDdgO7LS3Yvuxgo5Jlgbt3oCfd56Eb7VVBZHWYFmanvf2TOiV0yPYg6Lrk9SqbSG3z72dP83/k2uSwRZ5H9UUwYwx8tieFYKSsedN8N3fZfU2XmhRcCDsd6dUJ4xUy8Cspe1Wqvm0Mly4aDaF/4MPj3dfZewIMvxYai1J4V94wV0IGj0ann5aJogdNTlMBcf7Z1nhsgbewiF/iIP6H8Q7U9+hS6AL1eFqzp52Nh+u/bCBaNEar6DvvpMQXrd2ukcPCa3L9ONnWRYTnpnAxwUfNynooVDkBfM4evDRCRfyNpZt5MvNXzb5fw8eQoEQ8y+ez/79928X+6PGdkD/vfIfUpHQrUhGj4Ng7CsyCUql4mQKrFolHsUVFfG9VnJy4PnnJawqXeLKokUSwu527/TuLflwunZNn7BSXQ177SUJqd0umddekxxqCSsZdgTL/wJLbrOjE+LF0vWDff8Iw6bKGKSji09s/xzmHOMuAGX1hlO+Fbs86VTS2oB0jIXCFbDjS1mM3zYPSpZKNIuy8yRpS0Q5qwZQEoER6AlZvSQMNct53jtaKEP57MgMKxoCWFdqC0rbJZSuxtm2Q10J4JHFTOWDc+M7a2QSRgRqJVfMuILn//c4WPGPkQJumwu//qx99r+yJ5w0FQoTNLzBMOS/0IfQhuZPjKrD1Tyy8BFun3c74UiYyrB09FneLLoEuvCHY/7AXfPvori6uD73UdAXxKu83DT2Jq457JrkHgptwAdrPuDqd69m7c61TapzXHXoVSzdtpR56+bVD3Kd1c7Ju03mvkn3MbLHyJbvtLO4/7V3srRU99EMamvh9NOlrG+6PIKWb1vBwU8enLDixMThE5l90ew23e+737/LlFemUFITP8O3R3m44uArePikh5v3haXfw/tHStn4dIUJXaAltHTZnbD2BflbvFU6Xxc7UfGp4gqdMyKaj8zjb11Jc4f2zKUFmSMCAez4CuZMkAFLOsS/TnIsZ82CCy+UyY5byOhJJ8Ell0i4SDgsoQ5ZKTisJcOZuNbUSJhKMixt8fDnD3PTnJuoDlc3ECFC/hCnjTqNZ898Fr/X3+B/rnz7Sp795tkG7VtLvYJmzRLBvsSlGMFhh8lnWlOavaOoDlezxz/2YO3Ote26H4Xi3anvcsJuJ7TjTtq5/y5fA2/v5T6R9XeD0/JlgpVG9ttPcgu6VaKbNg1OPTV54vH25JJLxOvZjbvukhCwQBodCT78UMZhbm3jvvvCp5+mT0irJ5kw2ftomDDT9khrx8Y7Ef+7BNb82/39/e6SELAM9xxpFh01FgpXSVLtb/8KJSskdC9S0zBlga8r9DwYeh4GvY+S8NTQQDsPU110TOzkiGrO8Y/UiKDkpP5QXrs4kiX5pnZ+Ix74Bz+U+m9sZ4wIlAo/IFEgbIV5evHT3DRbBpKNVxKPH3k8T532FHnBPMpry/nF27/glRWvNBhAhvwhAp4Ad0y4g8sPvpxAOzRmCzYs4JqZ19RXOnEI+oL0DPXktfNe4+ABB6O15pmvn+Gqd66iOlxd7xbv8/jweXyct9d53HnsnQzMHdj8nf8QKncko7nXdFk+oKI5jJz4aE/A9uIIpHx/hMMSKz9rVscLQdnZcPeHD3DjnBvjJnoHuZZuG39b8iTNLWRbxTaG3D/ENTk0wNBuQ1n7q7XN/9LyNfDeEbJa4VJ+vl2JFQWsOklAuPYFeazdIQOzsEs+rW572TH6tqttl+EQGgqhAeKKGxunjZNI1N5qS6B6s1TD+LQdc2lBZolAIMkw3x8ryZ3bMwS1MZ0p0T+Sr+ONNyQpq5OUPl5ok88HBx0koRknnxytwBOJRMMkmpM/JDZPiMcjbY1lSVWrr7+WMsvz5zcvQf68tfO46PWL2FK2pYlHst/jZ/zQ8Zw6+tS4FUk1mtn5s5m5amaTghMBT4CeoZ7889R/ctKok1z3v3GjHAe39jkYlBLb/fsn/h3pYnvldkY/NJod1Ts6bJ9Pn/40F+9/cft8eXuLQJvfk3wmdS6qX89D4NgP2sYDKAXPztDFFVTVua+QFhY2T2BtT375S3jsMfeqX9deC7ffnl4Pm88+k3xEbuF0w4dHk2ynlWm5iUOgT18LOWnO9L/ol/D9Y+5FFva4Fva5vW1y8vzQ8yNaYVh8oxxPpeJ7Pfc+Gsb8BgacaIf7BTtWAAxXts25bGeMCJQKPwBRIGyFefKLJ7lj3h2U1JQ0iIX3Ki9ZvizuPe5eztrjrCb/O2v1LK5+92qq6qoIxzRsQV+QoD/I78f+nl8c8guyfKnfeJ+s/4SbZt/Eos2LmsTrZ3uzOWvPs7hjwh2EGt10BaUF/N+b/8eqHasa/J9f+fF6vEzZZwq3jb+Nod07oINI1yTRikgpyIq1EgtbvVmqalSshZod0oCGy6XRurgASpLYkBeAVyY0LEFpORU8aqXBDVdAuATwiTrvDUqMs68rjH+z2SuFkYgkHX399Y4TgoJBOPhgUJeO56N1H7l+Ljcrl+nnTOf4kce3uQ297u3VJNFoLFneLNZcs4b+XVswu6rcALOOgOotLa/2lArJRIHqbeLCu/0z2PaheC7VFYsDi1P5opllhVuPggtSFEoyTQQCKFsN7zleYO18zr0h2PNG2OeW1L8rTcdy9WoJQ50+XRLJ+v0i1iQqFd2rV8MSzUOHSpJSp9y0zyffUVsrW1GRVA6KLXns5knj9hPDVpjzpp/Hq9++6mqXz+OrD41OhKWtuFVHHSaNmMSMKTMI+OIv6jzwgCSEdWufDzhAkkZ365YBISMx7KjawV6P7MWWcve2KeQPNesYNqaitgIrgfA6c+rM9vEIam8RqHo7vLW7JIKOh8cPk7+Sqo+pLgKmkOPt9L++zqxlp8fNYQNw661w3XVSPCJdbNgAe+7p7mUTCEjI2PDh6bNTa5g0STyyG5eOd7jtNjmWafUGem2A5ANy44TPIW//1MOsUg05T4QnAJMXSbGMVEXUH3p+xI/OkBxLbp5f+/4JxvxK8vZ0ZHXGTogRgdJJGicNlmVxx7w7uPPjO11zj3iUh4A3EHcVMZaaSE2TOHgHr/JyzWHXcO+ke1uVm2jOmjlc+OqFbC53b+Cd3ESJCFvhhAPdIwcdyUvnvMSg3EEttrHZdMT51hbsXArbPpIKGTu+kAmgJysaF6vDkLcfdN8XuuwmlduCAyQeNpAnnjz1JSt1jE3JbFPR36i80gBbtbJqWFsEVdugYg2MvLRFP8myJH/Hiy+2vxAUCkmyyNfeqKP3/bmuXkAgCZo3/WYTPUM929yOSc9OYvYa9zCzLoEuPHLSI1y434Ut++KqLeIRVLWp/ZNFe0Nw4P0w9tbWieVBonm0nJxaPZF8Wj2AAJJLyxOzKSR/Vmw+rTokb1Yh0VxaTh4tJ5cWdEw+rXT0qVWbYcFlsPUD90FTKniDItYd8hgMPbfVX+OUAq6qgt59kh/LFcs1WkfLNMfblIo+DwZlotLcylThsCSVnT8f5syRvBibN2t27rQFHr/sv7pGUVvb+kF3drZVH/JRU6OIRMTDaMAAxZdxigAu3rKYo546KmGYaluT5c3ivQvfY9zQcU3e01rKRt9yi4hl8S7xYBDuvlsqDIXDHT+praxsKEBtKN3A0U8dzaayTXHHBdm+bK49/Fqm7JvEe9CFLeVbOPPFM10LeAR9QR475TEu2u+iVn2/Kx0Rzr11Hsw9SUIu4nmVZvWWMIiBp9qTsFaG76Yw4S6t7MqBd5eyeXP8MYNScM01cMcd0dLo6eCDD+Css6TNi1cS3u8Xj6Cbb462YR1NUZHk/PnuO3ePoIkTJX9a9+5pyv+17WP48AT3/i04ECbOkXFuKrmAUhVXQEImI1Xxx18eP4y5Fva+GanU1coT/kPPj/hSl8RVb8/cJJ7jqZKy6NcGXlXtTMoikFJqMvAAMhz/p9b67kbvK/v9k4BK4GKtdcL6xkYEiqEdJg1vr3ybs6edHTfZc3vh9/h55oxnOH/v85tVJW1j6UYm/WcSK7av6ADrovx4nx/zxKlPEPS3TW8bicggpLIS+vZL/ruXfBOd2MROYNy2QEAmNtnZ4CleCPPPEcFFR5rG7XcdBYc8Cr2OkA7I40stx0oHojU88YSsONXWxq9SkQo+nxzLG2+U7bNN8zn5+ZMpq3V3Me4V6kXhdYVta4jNnR/dye3zbk8oXJ61x1m8cu4rLf/y2mJY9CsomO6e2yEVvCEIdIfD/w39J3UOj0nomFDKdJZF3fIBLPipVDJMNIBqLk4c/O5XiBu7vXoZicCmTZCfL5uIJ1ICuahIvF4iEUl82ru3TM5zcmSC07WrlG//2S39CJa6XzO1Pfqy+N0tKCXiUewWichhrquTdre0VPa5c6c8r66G8nLN3+8ppps3X4Tp8nwJGXQqiNTthLoqCHQTTzZfF3Ht9oWIqK5s3tmfgqKBFGzrxYZteaxe34Xv83Mo3BGgrk4RiSjqwh7CYUXEAp8XfD63kqC4AAAemElEQVQLn0/j82oCAYv+fWoYNaKS4YNKGdx3B4N7b2Nwz0307roFFakQb8rDnqhvny1t8dCCh7hpTtPqVQ4+j48jBh1BXjCvxaeztLqUTwo+cW1zsr3Z/H7c77nh6Bvqy83HsmSJiPXffCNtdCTO2LdXLzjzTPjpT2H//eVchEJtn/g2EpES18GgTF6fflqEKoDlhcsZ/+/xFFcV14eJxxL0BZm671SePPXJlGxYsGEBxz57rKtYF/QFuW38bdxw9A0p7acBHZXTrzxfcpwUfyEexPEWiPIOhL1vhf4TZTziyW7bcIwkE/LqszR33AF//3s0x1ZjevSQ/n7KFHluWe0vUFqWXJuBgIzbtm+Hyy+XMFDLii8GDRwIU6eKV/Ruu8l906VL8wXtllJZGQ1Ty80Vux58UMQopeKLQX6/hO//+MfRUvbtmT/Nad+zs2HhQjh69Kfw2aVQtUHaziYoGPwjOOBeadO11XKPm7bwBDqrED6/HDa/E01W3JjgQBg+FYZdBF13a32xDDc6e37ElY/CV9e6i359J8DY16TvTLfol+qxbGdSEoGUUl5gJTAJ2AAsBKZorZfHfOYk4JeICHQY8IDW+rBE32tEoBjacNKwaNMirpl5DV9t/iruINKnfHTN6sqZY86kV6jlAdPF1cW8tuI1dlbvbBAe5hDyhRjdazQPTH6AsUPHxv2OwopCbp93O0999RQ14Zq4LtU+5WPSyEns3WfvpF5KjQnrMB/kf8CSbUviDgCzvFkE/UH+dOyf+NmBP6vPa6S1xJE7k5rVq8WNv7BQJjY7d8ogo0cPmfN26SITm5wc6US7d08+sanr0Zels7fU76/x5MaZ4MgkRiY0O3fKVlYGp/T7JRMGPYrCRXke81s48C/y5anms0pTzHFRkSRLnDat7SqHhUJSpePxxyWsA+B3c37HfZ/cF/c6djh+5PHM+vGstjGiEe+tfo9zp5/rmhwaoFtWN4pvKG6WqBqXooXwv4uhcp3LoKmFOIn19rwR9ry+VQN+J79K7FZbC7uPSv4bv1gkbaVSUQHV7bnHI4PWrCzZnMFqSoPqTBeBQPIxffegVFHRtE4McpJr5h0Ehz0pnoQ2RUXRXBt+v0x0KiujPzs7u+F9W1kp59w5Hz5f6x0HkuEIQ+EwBOYejm/nAnnDm2N7NcTc60dPgyHnyPNIjRw3sCuG+NvXxdwKRyuR2JOU1TtWc/7L57Ni+4oGufAcfB4fvUO9mXfxPHbvuXurd11QUsC4f49jU9kmaiNNJyc5/hyGdR/GtHOmsWfvPeN+xzffiNfPq6/KPVXqUiAlOxuOOEImjHvvDSNHymQ3L0/u+7q6pvcv2JV67f5R66gnR0lJVHxcvlxCWObPl77S+b9PCz5l8n8nu4r7AW+Ag/ofxEeXfBRX6Gopz33zHJfNuMxVCAr5Q1x6wKU8MPmBpN7MzaIjCztoDYWfwMqHYcMb4sUQLy+L8kpS1j7jpDR33v4SFh6pkutcecRTubn9hV0CnulJso3bk6+CAnjyScm/U10dbXMaM3IkTJggXi1jx8qagBPGqXVUtGlO+xSJSDsXDsspcf5v7VpJtjx3LsyeDdu2Rf8nPx8eegj+9S/5n/Ly+Imte/aEo4+WXD1HHQUDBsi4MxyOCkhOn+ZGOCz2RSLS5wWD8nrrVli5Et59V+6dJUsaHqvycnjuObjvPhH2Y/OhxRIIwCGHyLjqhBMkpK13b9lXdbX8Lp9Pxl5ux9Oy5LO1tdFjCCKaFRTI8Zs7V/IWVVTYl7S2YN00WPmgVIpSnvgLXTlDod/xMGCyXJvZvSXJMNru37KlrW8pVh28mCQM0hEFyvPhu4dg9b+ieW3iRVRk9ZT8Nn2Pk8TGoQEQ6CH9gyMgebMSl7e3wvb9FpH7cXpu82xsLR0xFtr2MSz/M2yZI/tr7NTgCcDgs2D0NdLmWHWyT3+OnT+yGbSF6PcDF4GOAP6gtT7Bfn0TgNb6zzGfeRyYq7V+wX79HXCM1to1vseIQDG0QWe9vHA5v5n1Gz5a95HrCmLQF+TnB/+cu4+7O6WEzmErzB/n/ZH7Pr3PdV9Oydq/T/47B/Y/EICS6hLu+eQeHljwABErEjcpbo4/h9G9RvPKua8wrPuwVtsIMCd/Due9fB7lteWu+8oJ5PCXSX/hgn0u4PDDvDiXZCgkHV9s5/jqq7LCCdJpOQNYn08mN+2ZQ9yy7MlNdSU56/8C+U9LDiBvEOrKqU8K6/HDwNNh4MnQf7J0LpEq6XiU1x6INfPcp9nddNEiuPhiya1RWeleBcQNpUSoy82VVeJJkxq+v+c/9kzohebz+LjjqOu56fArZSCrI/bkLRJ9HTdE0v7dMmJpbFW9cUVVJQx46gRqE3gCZXkDLPrxG+zdey97cuqNCjGegJzvZBeetmD1P+HLa8We1pQVd0pw9j1GPM1yhtS/ZVnw1FOS/2DdOnnctk0Gk1VVMsg77TQZgHfrJltenpyXUEgGp4EAjDy6H77t7teb1acvZSujXjzORNHZHFtic7PU1ooNVVUyUZ04MUV3+84gAjlUb4dNM6Syxta5cu04k7J4+LrIICpniKymDjpdBs+NfnN1tSQ8/fprOd9FRTJ493qjk/mbb5ZcGMOHi2AeCsn7dXXSpkYi7vdz40OsVMND6nZ4HeHP67Xb49WP4y14URKmV28GlLR/SgEaBpwiIlDOEElK7u8q71t19v1t2fd3vB3GGLnsz7DinvhGNQPLE+LBYXdy85ybqY5Uxw27zvJmMSJvBHMvnkufnBTCGW12Vu9k0n8msWzbsrh9uEKR7cvm5rE3u3oFgbTL770nSbdnzYLiYukPy5M0MV6vJJIeOlQmuIGAnDOnH62ri25bt0bbFbecJQ5vrHiTKa9Mqa94Gu93Deg6gCVXLGmVJ5Ub171/HY8ufDSueAcyHjpxtxN54UcvNKjg1irSVd2zrgw2vg0bXoetH0oIuDer4fgjFk9AQnNCA8XrITQQcoZBaLBdXtkf7b+sOnurldDW8nwZ36x9PrFNjcYYlgUffyw5v956S0SXYDAqNDRGKYkOHjgwug0eLH1VTk4035fPJ6KK07eUlEiJ+g0bZNu4Ubbi4qb7iHcaampEwHz9dblvCgqkDXUThRxbe/dumJuse3ex0RGEHPtqauQ3b9wYzUm2YYN73rN4NmotCaHfekvu78WLZV/JvLS7do3aN3iwtP9ZWVE7lWq4+FNY2DB3Wrxj6Gpn1RZY/7Jck9s/QwQerz3GafRhf65cf07xiWB/yc2TYxeg8GTbY2S7ZLgVM84Ll0OlnXOzYh2suM/dSGg69o3USPqGDa/D5llS1tyb7X7vAKBEuAoNkXsmZzD4u9vVrbLEXm3fM5EaEUiqNsp3VxZA2aqW2dhSOnIsVLVFhLQNb0hZeOxiNbHnWXkgdw8Rg7rtDT0PguAgSX/hz5XjbdU0rBaWCMcL2uODF5KIhT9wEehsYLLW+v/s1xcCh2mtr4r5zAzgbq31x/brOcANWmtXlceIQDGkcKNsLtvM1e9ezSsrJGRExxmwZnmz6JbdjZfPednVO6c1LNq0iDNfOpOiyiLXgSTAibudyF599uKRhY80qOLVmKAvyM3jbubGo25sVW6heBRXFXPJG5fwfv77rit1XuVlYO5Azqx6i+Uf7kt+vqw2RiLSaTmrGJMniwg0fLh0bl27ygDDsmSA4ExuEp3OxpdDss86kypnIALRR2p2yCpd0edQulwa/cqNEubgCAW+LjLBCdmNYVZPyO4jHUuwvyRvVj57s6sveWIqMWkdU4kpHH1uheHt+KvE9eyfYGKUO0Ya5iRYFsz7tDsvvdGHl2f0oqbGQziiqK6Jf30EAhGyAho0nHpCERecuZVJ44sJBJoe6LOfP5clVe6hXoHQAKZNnc0evfdIamdrOXf6uXy99WvX9z3VPTitYgY9g/FzEvl8cOCBzduX1yqhZ/UM+lX9h241c9EqC4+uxENTUUADlgqB1tR6+7I1eAHbg+dQ7t+/yWdra2UlsMG+vNH7xrk/4qF19J6JvRfiCQGxz53PNr5/Gr+ODatcOm8B25fNi28I0HtwH/qNHOb6PkDPvSYkfB+gaNmHST/jRkmpj3W/nsaEz9q47KgH2A04ABgJZANZQBioBkqAL4FvABevjlgen/8ga6s3UV5bTml1JYVbAuzc4WFZwUZKSxTU5EJtDtSFoC4HqrsRiOSR48sjx9uNHH9XQlk+coI+coJ+vB4PHuXBo5Q8euS5UgqPUkQsC0trLMvC0vZzLc/DdV7CtV5qajR1OoxWtShvHaGBazjsjK+oo5zymjI8dUX4andQWrqe4vK1dPNAjoIcD4QU5Hqgu9dDj6wudPeHyM3KIeDPwefLwefPwesJiE049nnw4EF5PCjlwbIiaK3R2DZalv1cM6JoNj7ddBa6vg5+tMXHVzXatV8M+UIcMvAQ3r7gbXICbZeZtSZcwznTz2HOmjmufaPP42NUz1G8ft7rzfI+2rhRcqAsWgTffiteEU7OlmAwKgRWVbVu2OMIxk71tUBAJpnDhoG131N81P1nrrkLQfKsLfrZIkb3Gt3ynSfA0hYnPnci89bOc6346ITxzfzxTEL+FLJnp0sEakzVVij6DLZ+BDsWygTUCUP1ZNv5CbV49LRHbjrlhymJv7eqCr74Qkqcz50L69eLqFhcHPViVEr6MLdcV8lw8vj4fNGQNK3Fc6d/f/jqq+TfUVIStXHJEhE9N2+Wv2dni62O10wyITQeSomNsd/j9YoANmgQfPJJ8u8Ih0UImjcPFiygfpy8fbscAyckzDmWrcHx2nW+JxyOHsfhw+G11xL8s9YiHhYthO2fiChUtUnyZVp1dgEKXzQ8y0qgZKVCcypn1pbA9k9lcWbnEhGWqjeLsFp/76RSKMNe6EjFxqS7SNOCmLag7HvJhbpzqTyWLreThntkkVvZkySnRLxVI/OZQJ7kRc3qaVc3jp3rxFScDVdKyo3q7XaVxHY+lu1MqiLQOcAJjUSgQ7XWv4z5zNvAnxuJQNdrrb9o9F2XAZcBDBky5KB169a1/ld1FpLlykgxR8XiLYu58LULEw58DhlwCA+e+CC5Wckn3S2lsq6Sa9+7lnnr3CdXTvLpRAl487Lz+MdJ/2C/fvu1uY0Azy95nrs/vtt1oA1w+ujTuWviXfWvd+wQjwYnHKukRFxSKypkUFteLn93VpnCYelYnY7M54u2gclWt6Hh69gVHccd3u+X1ak//jFJYj5tSU6Yqs1SJaq2xK7kVR7daoulrHRdqWz1bqo6ZgU8Qr3i7jwqezXd31U6MLeO9BXAvahNq9DAVxzA/ziCpezFUvahlFwsFF2oYA+Wsy9LOJhFHMH/8CYpmX3TXndx+gFvcLhlh4x4kKxnfnsbfSTsfzYQAY+K+Yzj8mCvGnl94PXbnYmC+uTZ9uPm6bClFXl9gIWrD+btW0/mD9zeqv93xQ/sCQyxt36ADznIZcA6YBOwHNjm8h0x6NIySiJd2LpVmrvCQrk/nPvFmfQ54R3Q8B5QKhoq1NirLqmjk45GP2oddZkPhxt+/0TPZMbtniC07/B/w4ifJN5Zc9rz934OS1t3vhauPphDb13o+v7gwTKRSclGSLnfUbc3byLqVV78Xj9Z3iz8Xj8Bb4CAN4DfI5UbfcqH1+PFq7xoRAiJWBHCVpiIFaHWqqUuUkdtpLZ+q4vUJazK5NA10DVhvq/634KqtyvgDdTb6ff4pfpWjJ0KJTbqqI11Vl0TG2sjtQn7mlj27r13wt8zfuh4HjzxwTYJXWqMpS1ueP8G3ln1jutnFIqHTnyICcOTC6BuVFXJdbtunWz5+ZLHp7Q06lXrPGodnaA74Zw5ObD77uKhMXSobEOGNOwHb/7gZl7/9nVXG7zKy/0n3M/EERNb/TsSUV5bzjnTz2F9ifsNGvQFmX/J/NTyEXbA/Z0SkRoZe1RtlEWpqo1QvhbKV8s4wwlxccIh0bZHkE8ePX7xcO4yXDw1QoOi3kTBAa1PpBuDZUkf5XjwOB4zq1bJmM/x+nEeI5HoQpzjsRYIiDix224ipAwaFPUm6t69bTzDw2ERg2I9Zb7/XsRVJ5wydvN6o7kPHTt79oRRo+SeifXQyW2j6YDW4g0aa+PatRJyVlYWtS22T3Zsc7acHLm3R4wQ2xxvp9692yh0OFxpX5Ob7cq5m+zqufmSH65eLHC8QCP29ehreF1m97O9hwZBdn/bq6i//D3VSnkg90PV5qg3T2WBCB7la6NeLFad7QFU18gz3LYx0FPCt3OGigdRvRdRG8//2nlu22K0llDVmiKo2W4/Os8Lo1WT68rscxyzqO2c73pRyCfj+0CPqOdYVi85ttn2oyMm/dBLxJtwMIPBYDAYDAaDwWAwGAyGzkEiEag5GutCYHel1HClVAA4H3iz0WfeBC5SwuFASSIByGAwGAwGg8FgMBgMBoPB0LEk9S/WWoeVUlcBs5Bgiae01suUUj+3338MeAepDLYKKRF/SfuZbDAYDAaDwWAwGAwGg8FgaCnNCjLXWr+DCD2xf3ss5rkGrmxb0wwGg8FgMBgMBoPBYDAYDG1FW6TcMhgMBoPBYDAYDAaDwWAwZDhGBDIYDAaDwWAwGAwGg8Fg2AUwIpDBYDAYDAaDwWAwGAwGwy6AEYEMBoPBYDAYDAaDwWAwGHYBjAhkMBgMBoPBYDAYDAaDwbALYEQgg8FgMBgMBoPBYDAYDIZdACMCGQwGg8FgMBgMBoPBYDDsAhgRyGAwGAwGg8FgMBgMBoNhF8CIQAaDwWAwGAwGg8FgMBgMuwBGBDIYDAaDwWAwGAwGg8Fg2AUwIpDBYDAYDAaDwWAwGAwGwy6A0lqnZ8dKFQLr0rLzltEL2J5uI5JgbGw7OoOdxsa2ozPYaWxsOzqDncbGtqMz2GlsbDs6g53GxrajM9hpbGw7OoOdxsa2ozPY2RlsHKq17h3vjbSJQJ0FpdQirfXB6bYjEcbGtqMz2GlsbDs6g53GxrajM9hpbGw7OoOdxsa2ozPYaWxsOzqDncbGtqMz2GlsbDs6g52dwcZEmHAwg8FgMBgMBoPBYDAYDIZdACMCGQwGg8FgMBgMBoPBYDDsAhgRKDlPpNuAZmBsbDs6g53GxrajM9hpbGw7OoOdxsa2ozPYaWxsOzqDncbGtqMz2GlsbDs6g53GxrajM9jZGWx0xeQEMhgMBoPBYDAYDAaDwWDYBTCeQAaDwWAwGAwGg8FgMBgMuwBGBHJBKTVZKfWdUmqVUurGdNsTD6XUU0qpbUqppem2xQ2l1GCl1IdKqRVKqWVKqWvSbVNjlFLZSqnPlVJf2zbenm6b3FBKeZVSXymlZqTbFjeUUmuVUkuUUouVUovSbU88lFLdlVIvK6W+ta/NI9JtUyxKqdH28XO2UqXUr9JtVzyUUr+275ulSqkXlFLZ6bapMUqpa2z7lmXScYzXhiuleiil3ldKfW8/5mWgjefYx9JSSqW9MoaLjffZ9/c3SqnXlFLd02mjbVM8O/9o27hYKfWeUmpAptkY8961SimtlOqVDtti7Ih3HP+glNoY02aelE4bbZviHkul1C/t8eUypdS96bLPtiXesXwp5jiuVUotzkAb91dKfeaMM5RSh6bTRtumeHbup5T6nz0meksplZtmG+OOyTOp30lgY8b0OwlszKh+J4GdGdPvuNkY837a+50ExzHj+p0WobU2W6MN8AKrgRFAAPga2DPddsWxcxxwILA03bYksLE/cKD9vCuwMtOOJaCALvZzP7AAODzddrnY+hvgeWBGum1JYONaoFe67Uhi4zPA/9nPA0D3dNuUwFYvsAUYmm5b4tg2EFgDBO3X04CL021XIxv3BpYCIcAHzAZ2T7ddtm1N2nDgXuBG+/mNwD0ZaOMewGhgLnBwhh7H4wGf/fyedB/HBHbmxjy/Gngs02y0/z4YmAWsS3f77nIc/wBcm+5z3Aw7J9htUJb9uk+m2djo/b8Ct2aajcB7wIn285OAuRl6vhcC4+3nlwJ/TLONccfkmdTvJLAxY/qdBDZmVL+TwM6M6XfcbLRfZ0S/k+A4Zly/05LNeALF51BgldY6X2tdC7wInJ5mm5qgtf4I2JFuOxKhtd6stf7Sfl4GrEAmjhmDFsrtl357y7hkWUqpQcDJwD/TbUtnxl6JGwf8C0BrXau13pleqxIyEVittV6XbkNc8AFBpZQPEVo2pdmexuwBfKa1rtRah4F5wJlptglwbcNPR0RK7MczOtSoRsSzUWu9Qmv9XZpMaoKLje/Z5xvgM2BQhxvWCBc7S2Ne5pDmvifBuOJ+4HoyoG/sDGMfcLXzCuBurXWN/ZltHW5YDImOpVJKAecCL3SoUY1wsVEDjldNNzKg33GxczTwkf38feBHHWpUIxKMyTOm33GzMZP6nQQ2ZlS/k8DOjOl3kswTM6Lf6Qxz2dZgRKD4DAQKYl5v4AdwstONUmoYcADiaZNRKAmzWgxsA97XWmecjcDfkcbQSrchSdDAe0qpL5RSl6XbmDiMAAqBp5WE1v1TKZWTbqMScD5pHoS7obXeCPwFWA9sBkq01u+l16omLAXGKaV6KqVCyKrx4DTblIi+WuvNIAMPoE+a7fkhcCnwbrqNcEMpdadSqgCYCtyabnsao5Q6Ddiotf463bYk4So7xOGpdIazJGEUMFYptUApNU8pdUi6DUrAWGCr1vr7dBsSh18B99n3zV+Am9JsjxtLgdPs5+eQQX1PozF5RvY7mTxvcEhgY0b1O43tzMR+J9bGTO134pzvztDvxMWIQPFRcf6W9tWvzoxSqgvwCvCrRgp0RqC1jmit90dU+0OVUnun26ZYlFKnANu01l+k25ZmcJTW+kDgROBKpdS4dBvUCB/isv2o1voAoAJxf844lFIBZAA5Pd22xMPu8E4HhgMDgByl1I/Ta1VDtNYrELfs94GZSHhvOOE/GX4wKKVuRs73c+m2xQ2t9c1a68GIjVel255YbOH0ZjJkkpCAR4GRwP6IIP3X9Jrjig/IAw4HrgOm2R43mcgUMnQBAvGo+rV93/wa27M3A7kUGQd9gYSR1KbZHiDzx+TQuW3MtH4nnp2Z1u/E2ogcu4zrd+Icx87S78TFiEDx2UBDtX4QGeBq2llRSvmRm+Y5rfWr6bYnEXZY0FxgcppNacxRwGlKqbVIeOKxSqn/ptek+GitN9mP24DXkPDKTGIDsCHG2+tlRBTKRE4EvtRab023IS4cB6zRWhdqreuAV4Ej02xTE7TW/9JaH6i1Hoe462fiyrbDVqVUfwD7Ma3hIp0ZpdRPgFOAqVrrzrCQ8zxpDheJw0hE5P3a7n8GAV8qpfql1apGaK232os5FvAkmdfvOGwAXrXD0D9HPHvTmmg7HnZ471nAS+m2xYWfIP0NyCJJRp5vrfW3WuvjtdYHIYLa6nTb5DImz6h+pzPMG9xszLR+pxnHMu39ThwbM67fiXccO1G/ExcjAsVnIbC7Umq4vRJ/PvBmmm3qlNgrXP8CVmit/5Zue+KhlOrtZPBXSgWRie236bWqIVrrm7TWg7TWw5Dr8QOtdUZ5XAAopXKUUl2d50iSvIyqXqe13gIUKKVG23+aCCxPo0mJyOSVWJAwsMOVUiH7Xp+IxEpnFEqpPvbjEGRik8nH9E1kgoP9+EYabem0KKUmAzcAp2mtK9NtjxtKqd1jXp5G5vU9S7TWfbTWw+z+ZwOSIHNLmk1rgDOBtTmTDOt3YngdOBZAKTUKKUywPa0Wxec44Fut9YZ0G+LCJmC8/fxYMlTYj+l7PMDvgcfSbI/bmDxj+p1OMm+Ia2Om9TsJ7MyYfieejZnW7yQ4jp2l34mPzoDs1Jm4IXkjViKq/c3ptsfFxhcQ97M65Ab5abptimPj0Ugo3TfAYns7Kd12NbJxX+Ar28alpLkSRjPsPYYMrQ6G5Nv52t6WZfC9sz+wyD7nrwN56bYpjo0hoAjolm5bkth5OzKAWAr8B7vqTSZtwHxE6PsamJhue2LsatKGAz2BOcikZg7QIwNtPNN+XgNsBWZloI2rkNx+Tr+T1qpbCex8xb53vgHeQpJ2ZpSNjd5fS/qrg8U7jv8BltjH8U2gf4ae7wDwX/ucfwkcm2k22n//N/DzdB/DBMfxaOALu01fAByUoXZeg8wlVgJ3AyrNNsYdk2dSv5PAxozpdxLYmFH9TgI7M6bfcbOx0WfS2u8kOI4Z1++0ZFP2jzMYDAaDwWAwGAwGg8FgMPyAMeFgBoPBYDAYDAaDwWAwGAy7AEYEMhgMBoPBYDAYDAaDwWDYBTAikMFgMBgMBoPBYDAYDAbDLoARgQwGg8FgMBgMBoPBYDAYdgGMCGQwGAwGg8FgMBgMBoPBsAtgRCCDwWAwGAwGg8FgMBgMhl0AIwIZDAaDwWAwGAwGg8FgMOwCGBHIYDAYDAaDwWAwGAwGg2EX4P8BrbcBeRl7ziUAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Numseqles: 81\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Parallel(n_jobs=10)]: Using backend LokyBackend with 10 concurrent workers.\n", + "[Parallel(n_jobs=10)]: Done 40 tasks | elapsed: 0.2s\n", + "[Parallel(n_jobs=10)]: Done 81 out of 81 | elapsed: 0.2s finished\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "After filtering: numseqlets 79\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIEAAACMCAYAAADr57kMAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOydd3xUVfqHnzslmXR66EU6ghQpKl1gkWJD7IVVd9XV1R8qurq2XV1d1y6La1l1raCC9I6AgErvCKETaoBA+sxk2v398SYkw2RuJslMipzn8xkxM3fuPXPrOd/zvt9X03UdhUKhUCgUCoVCoVAoFArFbxtTVTdAoVAoFAqFQqFQKBQKhUIReZQIpFAoFAqFQqFQKBQKhUJxAaBEIIVCoVAoFAqFQqFQKBSKCwAlAikUCoVCoVAoFAqFQqFQXAAoEUihUCgUCoVCoVAoFAqF4gJAiUAKhUKhUCgUCoVCoVAoFBcAlqracL169fSWLVtW1eYVCoVCoVAoFAqFQqFQKH5zbNy4MV3X9folfVZlIlDLli3ZsGFDVW1eoVAoFAqFQqFQKBQKheI3h6ZpqcE+U+lgCoVCoVAoFAqFQqFQKBQXAEoEUigUCoVCoVAoFAqFQqG4AFAikEKhUCgUCoVCoVAoFArFBYASgRQKhUKhUCgUCoVCoVAoLgCUCKRQKBQKhUKhUCgUCoVCcQGgRCCFQqFQKBQKhUKhUCgUigsAJQIpFAqFQqFQKBQKhUKhUFwAKBFIoVAoFAqFQqFQKBQKheICQIlACoVCoVAoFAqFQqFQKBQXAEoEUigUCoVCoVAoFAqFQqG4AChVBNI07VNN005pmrYjyOeapmkTNU3bp2naNk3TeoS/mQqFQqFQKBQKhUKhUCgUiooQSiTQZ8BVBp+PANoWvO4D3q94sxQKhUKhUCgUCoVCoVAoFOGkVBFI1/WVwFmDRa4FvtCFNUAtTdMahauBCoVCoVAoFAqFQqFQKBSKimMJwzqaAEeK/X204L0TYVh3zcfnhZy9kLkV7MfAfhhyD4HjKDhPgTcfdC/gA0ygmcESB7aGENcU4lpBbBOIawG1u0NsM9C0iDT10CHYuRNSU+HAAdi1Cw4ehIwM8HjA65VNWyxgs0GTJtC2LXToAC1aQKtW0L07REdHpHl+PDjvQS5rehl3db0r8hurCLoPzqyH4wshYzNkp4DrrBxzzQIxjSCxI9TtBU1GQWL7Sm2e2+vm2m+uZfINk6llq1Wp2/6tMX/vfObtncd7I9+r6qYExe11c82Ua5gydkr1P94eB5xeBcfmwcll4M4Brx3QwRwDlniodzk0vQaSB4M1sXLapfsgayfk7IO8Q5CzR67rvFTw2EH3yDKaWa5xayLEt4KkTpDQBmJbQFIHubdH6F6ekQGbNsH+/XDsmNzHU1Ph+HHIzZV7eeH93GyGqCho0ACaNpX7ePPmcn/v2hXatQNTuN0DPXbI3g3ZuyD3IDiOy8t5EvLPgDu7aD+ic+7ZaE2E6LoQ3QBiG0FMY4hrKffQpA7hPwe8Lmlj5raC5/cRyDssbc0/HeT5HQu25KK2xTaBuOZQq6scfy28OzM/H1JSYMcOOHIEjh6VV1oanD5ddLx9PjmOJhNYrVCnDiQny3Fu1gwaNYL27aFLF3k/3GRmwtat0tYTJ6S/cfSo/H/xPgbIOWk2Q1ISNGwo52XLltLGtm2ln1G/fvjbmJcHv/4q+/L48aL9efw4pKeDy+W/L81miI2VtjRqJNdN06ayP7t0kb6R1Rr+duJIg7Ob5P5jPwZ5B+XcdKSBJ0fOSd3LuXPSZAVbfYhpIudkXHM5P2t1kfuSKRKNVISbI1lHGDl5JN/c8A0XN7i4qpujUChqOJqu66UvpGktgbm6rncu4bN5wD91Xf+p4O+lwJO6rm8sYdn7kJQxmjdvfmlqamqFGl8tcWXC8QVwagWc/kUGCCYroIHXCbq77Os0RYM5GnxueaAnXQwN+kODwdDwSjDbytXUQ4fgxx9h3jz5Ny9PBgMuFzgcoa/HYoGYGBlQOJ3QuTOMHg1DhkCfPuEXhc46zlLvtXo0TWzK4UcPh3fl4UDX4dSPcPBLODJDBjNep/wbDFO0DA6i6kKLW+Ciu6SDFmF+Pvwz/f7Xj+9v+p4xHceEb8UNG8LJk+FbX6RITpbRUhj43Ze/Y+nBpTiecRBljgrLOsPNqtRVDPhsAFNvnMrYTmOrujmBOE7CgU/hyHQZeJtt4MktEANKQgNLAvickNAWml4Pre+G+IvC1yZdFyEgbRkcmw2nf5ZrVTPJde1zhb4ucwyYouQ75hhIHgJNRouIFdes3M3buhWWLZPXxo1w5owMTt1uuZeH8Jj3IypK7ts+nwx6O3aEgQOhXz8YPhzi48uwMp8bzmyAtKWQtlDEH1cmmGMBHTx5iIhSHjSZNNFMIixZ4uU8aDgEGv0OGgwqm9CWdwSOz4OTP8LZDSL4mG3SztLu4cEwRYHJVjAw90j76l0mx7zxCIiqHfKqdB1274YFC2DJEti+XW5fMTHymcNRJKSUFZtNjrnTKcJFu3Zw+eUwahRcdVXZdqPPBxs2wMKFsHIlbNsmIlBFzsnz2xgTI32NwnOyXz/pi4SKrsv+mz9f+j/btoloFhsr+9DhkN9RVgr7QyDtbNpURKuhQ2HkSJkwKxM+j4jhacvg1Eq5L3odcl5688GXjwilZUCzFJzXmtw741pBvSukX9l4FLTqWjOe3yZT+Q5SZRKmPobD7aD7h93ZfWY3TROb8uuDv5IYHSbRu6b012rC8VZtDB81oZ1hHENECk3TNuq63rPEz8IgAn0I/Kjr+pSCv3cDg3RdN4wE6tmzp75hw4bSW18TcJyAo7PgwOeQsUkG9J6cCG/UBNZ4GUzcHLpik5UFX30Fb74p563ZLDOF4cZqlY6QywU33ghffBG+db+5+k0mLJ4AwPY/badzg4DTsurI3gtr75VZusKohbKiWUQ4bH4T9HhTZr4jxDNLn+GVn17h3u738vE1H4dvxRGKcIgI5RmNlEDtV2uTmZ/JsruWMbjV4LCsM9w8ueRJXv/ldcZ1Hcdn131W1c0pwuOAXW/AzldlsOzLL996NCuYLND6D3DJixBVgWgnx0nY9xHsmSjtwyeDr3BjiZeBXmxT6PgEtL2v1K/oukT6TJ4MX38t93CPR6JCIoWmifjjcsng1hBnOhz+FlKnwJmNBcJXGQWziqBZJCLnxizj5XQdMraI6Jg6RaIqNFPBvTvCWBLkPL/F+KC53SKmTJsmgoXdLv3iUo9BGDCZ5JhnlbIbQdrzww/w7bcwZ44IKU6nnJeRbmNcnGwvL894WZcLFi+WfTlnjlwvbre8H2liY+W4hTTB5nXCiSVw6GsRJdFE5KScCl+oWOJFtL01gjeSC5EK9jF0XWfsd2OZv28+To+TKHMU/Zv3Z/GdizGFI7KwJvXXFIrqRpjGEJHCSAQKRzrYbODPmqZ9A/QBskoTgH4T6Dqc/gl2vCSzM5q5qONY1o6uKaqgk5wvD+CQ8EnIfIhs3gxvvAHTp0unyR7hPq7bLS+QgUq4RCBd13l79dtoaOjoTFw7kY+u/ig8K68IHjts/xvsmSTHX69AZ033gNcDqd/I4KT769Dmj2FPIwCYmTITgAX7FoR93RcSe8/sJTM/E4DZu2dXWxFoRsoMQFLXqgW6Luf5xv+TiJCKDr51N3jdsO+/cOAzuOQf0O5Poac76LpE+ux6HU4sBg0ZkEUST4EKn7sPNj9uKAI5HPDpp/Dyy5CdLYPYSA+yC9F1yDGa29B1OLkUdr4hkZB+z0SDfWhLLkjn6gi1LpH/t8TIZIopSgYo3ny5r3qdkLtfUmuzdkkanv1I4Dp1j/Hz0euC1Mmw42WZxPG5yhala00Ea5JEU5htIj768gsiw/Ilpa00wbCUiaLjx+Gdd+Cjj0Q8MNz3xdA0uOgiiZJp1EgiZwpfXq+cM/n5IhwWppEFmwjy+eQ8K62db78NH34o287JCb1PrGmSShUbK+2z2eS9/HwRkJxOCVAwmgwOZd+cOCH78sMPi87jUNsYFwedOklqWuF+tFpFOCps5+nTsi/dBqdQSH0u+1HY9aaIz5q5/JOJmqUgetxTNkHdE4EZQUWFee3n11i4fyFOj9xHXV4Xa46u4ekfnuZfw/5Vxa1TKBQ1lVJFIE3TpgCDgHqaph0FXgCsALqufwDMB0YC+wA7cHekGlttOLUKNj0qHVBPCNEeZhskdoLal0CdS6FuH0hoJzOVmrkg1aHAQwKtqAOb9SucXg2ZWyBjm6SWlVFcOHwYHnlEZr/y8ysWWWexyPfLuo7yhqeXxMrUlWTlZ2HSTHh1L19v/5q3h79NXFRc+DZSVo7NgzV3SwcqnJECvoJQ782Pw+6J0Hcy1O4attVnODLYd3YfAKfzTnMk6wjNksqXknKhM3/vfDRkNm1GygzevurtKm5RIKfyTnE4S9Ins/Oz2Xd2H23qtKm6BuUeghWjxdfCU8oUflnxOeW17a8i6AycBXV6GH8nKwXW3SfRnKHc1yNBkEGYyyUD2Oefl4FmaREPUCQGdOsGl14KV1whqSnFB7Jeb9FgNicHtmyB1avl3+3byxAlenYjrLlXBBqjgaTJCg2HQvNboG5P8ScpFHlMUfJMLI0G/cFzs9wbTVHy3MxLFd+9w1PlfhxMTPR5Yd+HsO15+X6pg14NaneT+27t7lC3t/i2WeJESEIv5lukFaUJmqJECMraCWfWStvObhQfqVLIzITHH5fJE103ju6y2aBvX/Gf6dMHevQQ75xC7xqrtci7xmyW9RX6QRW+YmIk0mfnTlizRo79unXiC2jEqVPw9NOhtRNETLnsMhGneveWFKlWrYra5PMVCTOaVuRXZbFIP2brVmnfjh2wdq34CJXG2bMwYQJMmRJaG1u2hEsukWumcL/WqycCzvlt0/Wi90wm2Y/HjkmE3urV0t6tW2U/lYr9OGx7ToRJ3RfCRKImKa+1LpFzs94VUKszRNUpErx1D2CSyEifW66x3P3iUXh2vaSVZe5Qwk81Z9G+Rfx9xd9xePz7lnnuPCatn0SvJr2qZ2q3QqGo9oSUDhYJamQ6mNcJG8eL10tpM9a2BtDkWmh1l5j+ep1FppFliejweWWApGkyu5O2RLZ/YkHRwOm2wGPo9crs3AsvSIcw1Nnili1h0CDo3188AZo3F8NQm006aZom/2ZmFhmObt4My5dLxyxYJytcp9k1U65hzp45mDUzXt1LnDWOiSMmck/3e8KzgbKy9yPYND4yaSLnY4mDQQuhQb+wrG76runcPetusvOzibXG8u8R/w7ffqxJ4cVhODn7fdqPn4/8jFkzYzVb2fvwXpomNg1D48LHV9u+4k/z/kSuKxebxcbrw17nz73/XDWNydgKSweDO8vA7yeMWOJgwEwRIM7H64IdL0LKWyIMhNoeSwI0GCAebUkdRdiPbVLg72UWwd6TJwJFdooUCMjYBOlrjAd5593Pd+4Uj7VTp0oXfxo0gOuvh7vvFlPnQrPd+HgZUIeC3S5CU0yMmOHOmCED/dWriy6Vc5eMOxvWPQBHZxZETAW5lmp3hw7jodkNEp1gTYhIZCPubBFgTiyClHdg6PKiz3IPwKobxZPIa7AjNTM0ukq82ZpcXXAvM5X92V1I4XmgmcUL6fBUOPwdpK+WzwuOt65LmtJ99xVFwQSjXz9ZbswYOcaFUTQVpTClymKRZ/ukSfDNN4GCy8yZ8PvfS2SaUSpV3bpwww1wxx3Qq5f8Jput/G3Nz5dtxsSIgfNXX8HUqWLeDP638pkz5TpwOIzFn1at4A9/kP0ZEyP7Mza2YobOhe202aSfNHGitPXs2RIeN4enwpp7CkzGDUKJTFHiddXy9oLz0iT9Q0ucCD1lwZMn16E5BrJ3StTkkRlSuATgseSa4RFTUyhnH2P/2f10/7A7Oa7gEWFx1jhW37uaLskV8JCsKZ5ACkV140LwBIoENU4EytwBK6+V0HGjAX/t7uJF0XBoQWe3LA6aIeLKktmeg1/Cry/Ddf7myFlZYpS4Y0doM8bdu8PDD8PVVxeZIiYklKE5rqIOz/bt8J//iC9A8fDncJxmp/JO0eKdFjg9znMiEEDHeh3Z+dDOim+grKS8C1v/Wjn+EYWY4+Dm8MzcjZs5ji+2FuXpjWo7irm3zQ3Lui8kEcjhdlD7X7XJ9+Zj1szYLDbeueod/tDjD2FqYHi4/pvrmbl75rm/+zfvz8q7V1Z+Q07+CCuurvwZaHMM3Hzeteo4AT8MlpSiUK7j+IvEb6jpdfL/XqeIA6Gkm3mdMtAz2wp8aKbK4Cv/jP9yxUSBTz+VSM7SjHSHDoW//U0ifjyeMho3l4LHI/dyjwfefRf+/W8ZzOI8DUv6SyRXsJST2ObQc5IUMDBFl32wWl58PhF6rAUPsn2fwsaHC0S+IKGp5lho9yB0eqrAUyghAmXRkH6B1yGV0LY9D30n4/PBnXeKcGGUNnTVVSIoNGwoz+pQhb3ykpsruyC2IEDL4RDxZ+5c43ZedJGcj2PHFomQkcBul0fN8uXwzDMyIeV2w223FfknBaNXL3jtNYmg0rTwiGjByM0VYW3aNBHEAHDnwto/itm80b0nui50mCDnpq5H5rz02AFNotW2Pw9DllV8naH0ASraMawJ4kU5B4k5+Tlc8sElpGamoheI61aTlUYJjTiVd+pcahhAw7iG7HhwB3VjI+cfWSrqeAs1wcy4JrQRKi6wVMY5WQNQIlBFydgGS/oWRN4E2V9RteGy/0HDYQWd3Qj3zqCoPG2xEPq0NBgwQMKnjWa/NA1uv106Ts2ayUxiWSprGJGTI/eYr7+Gl16SWbpwnGb/XPVPXlr5Eg6Pw08EirXG8tPdP9G9UfeKbyRUfv0n7PhH5QpAhZQQ+VVWdF0n+Y1kTttPn3svzhpH1lNZmMNx7l5AItDCfQu5edrNZOdnnzsvh100jMV3Lg5TAyuOT/dR69VafjOK0eZosp7KItoS5vJ9RqROhTXjKidyriSKXzu5B2BxX8hPL73qU+NR0OkvUKenRHSEo/qbp2AEe2yeGGKf3ejXxkceERHISMjv0gU+/1zKZkdqoF2cQlPieOsZWNBdSlIHi15oMhr6fiN+OVVZLW/fJ7DxEeN7dfIQ6DtFvIgslbAjC3Hn4DMnMG6c+PUFEy3q1oWPP4ZhwyStqirweESE+vnn4FFKZjM89xw88YRE0kSkPHoJFJpQx8SI8LRoUfB9GRsr/ojjxonwEwmdLxhud8E+8Tph8RWSLhjUs0eD9uOh60tIJFpMJTUyNzyTlzVhAFZN2+jTfYz8eiQ/HvqRfG/R+RFnjWP9H9dz+SeXk5Vf5NYeZY6iR6MerLp7FZbKEtrPp5ruSz9+K22EmtFO1cZqgZEIVImPvxqK/SgsvbJg1jrIyVK/P4zeA42GF8wKV4IABGL8V0wAOnBAonoOHTIWgHr2hF274P33oUMH6VSGSwACiSKKi5MZw927ZUawovh0HxPXTgzIiwbI9+Tzztp3Kr6RUNB12Ppc1QlAYWJ/xn5yXf6RGCbNxOa0zVXUoprLrJRZ5OT7h2v/dPgn3N4yGM1GmM0nNp+bTSwk2hLNT4d/qrxG7P+sagWg4mTugIU9wXnKWABK6gxXbRSBoEF/GYiFS9CwxEp0UtPrYegK6P+9mCQj9+ZPPjEWgB56SDxSunatHAEIZAAdHw9s/3vBvgtyjjceCX2/lVSVqhSAjs2VCCCje3WPt8Qzyla/cgUgAGsCL75YugC0di2MGFF1ApCui2iyenVwAahuXYnEefzxiqdTlRWzWfbNn/5kLADVri0+PePGSRsrUwCCgn2i++CnmyRFNJgAFF0Phv4oUeWWuMoTgCAy0euKMvHC8hdYdXiVnwAUa43lxcEv0rF+R9656h3irEU3A5fXxbaT2/i/Bf9XFc1VKBQ1FCUCGaHrsPwqcGcGX6ZuLxi8AGz1JMy/inC5JAXs1CnjChV/+QusWFE5M8dRUdLRmjCh4utaemApue6S00e8upepv04NGIhHhH0fi3dIDRaAQMwGzyffm8/CfQuroDU1m1m7ZwUILFazldVHV1dRiwKZt3ceLq+/eUeeK4/Ze2ZXTgPS18GGB6uHAJR/Bn4YIP4sGIREd/wLDF8LtboVpRVFApNZBnqNR8HVe1i5UgbSRqksb70Fr75aNQNZHCdh/8fBB7CaBXr/NzST50jiyYOfbzU+57r8HVr/UfZ/FZCdLVEpRsd6yZIiQ++qYs4cmDXLOLpm+XLxEawsQfJ89uyRKqTB2hgdDStXSuRzbFWemjtfh7Slwc9Lc6yIwnUvU4LMBcjMlJm8ufpN7G7/E7lRfCMe6fMIAOO6jqNd3XbnilEA2N12Ptv6GZ9t+awym6tQKGowSgQy4vQqMfUM5iEQXRcGL6qyDmRxnnlGSrUGS/PUNPESeO65yh84hGP28s3VbwZErhTHpJn4evvXFd+QEZm/FphA12wBCMQU+vyoKpfXxfe7vq+iFtVMDmQcINMZKBLnufKYs3tOFbSoZL7f+X2ACOTVvcxKmRX5jTtPwYqR1UMAAlh7r3FqL8ClE6HLswWRnZV0szRHgzWRRx8V75Vg3H23mNhW1WCbrO1iUhuM2l2rx+D1wGfGod51+0DHx6u0rR9/XLrXU5s2VSsAgaR1G0Wl/fOfVd/Ol182LoAxbpwUvqjSfelzw65/Gfch+k6GuFZVG0GnqBJ2nt7JHdPvCOibxVhi+OL6L86lemmaxufXfY7N4j/xbHfbeXDeg6w/tr7S2qxQKGouVZQ8WkPY+S/j0sWt7xP/nypmzRp47z3jgcM//gH33FN14eQV4UTOCX489KPfeybNhNlkPjewzXPn8cYvb3D/pfejRcKPxuOQctYVHcjGtZQyrmabnFvONDEIrUTcXje/HP2lxM92nt5JTn4OCdERjHz4DTF/7/wS3/fqXr7f9T2v/+71Sm5RIFnOLFLOpJT42cm8kxzNPhq5Sma6Dj/dDK7scnxZg1pdoOHvoPkYqcJlsoFGQbnjA3BkulSCOrshuFhfnCMz4MQS4+pcvT+ElrdVfmoQkqa7a1fwz202EfOr9D6ulZLu7HMDYboHT28YufvjxU/L+VSFbNxoHAU0cmTZijREgr17pRJXMOLi4N57xY+nKpk1y1gEevzxKhROCzk6S4zBg5HQRu53lZn+pagWZDgyGPbFMPLc/mOOKHMU13W4jiuaXeH3fpfkLtzb/V4+3vyxn0m0w+NgxNcj2PHgDhrGN6yUtisUipqJigQy4tQqDGeL2/yx6kPeEc8dIwGoVy8YP75mCkAAH238KEDYibPGBRjgpeWmsf54hGZAtj1bMBgpo4mY2SZpHn0+gTGnYNQOqbwxaJ6EfF97CK45AN1eg/r9IlM2+TzWHltLVJBZRpvFxorUFRFvw2+FqTunluhTBXA85zjHc45XcosCWXpwacCMYSFmzczi/RE0sN77IZxZb1z6+Hw0E1x0t1wvw34SX4x6l4M1UWbHTVGSnlW7K1z8DFy5GMZmQMcnjCNUANbdbzwL33iElGCuAgEI4MsvjdN5x46tBj6GtXsY+yhlbgPHsfBsK5ICef2+leffF4TSvPjcbjE9rkoOHpTU7mB06mR8zlYWwbyKCqlXr3LaYciJxeAxSFtvcWvpIqviN4fX5+Xab64l3ZEe8FmUOYp3r3q3xO+9MuQVYkoQDLPysxjx9YiA6F+FQqEojooEMiJo1YYComqFZzsVmO3Mc8by47IzQPAZzc8/r+Ic+Arg9XmZtG6S30yHhsaYjmNYsG+BX960w+Pg7dVvM2XslPA24uwm2Pt+2aOAWtwMPd8rvdxwfCvoMB7a3i/Vdtb8HtIj5yczf+987K6SB8I5+TnM2TOH0e1GR2z7vxWcHidrj64N+rnVbGXRvkXc3f3uSmxVIDNSZpCdX3IkTp47j2k7p3FP93vCv+HcQ7D58bKlTyZfCb0/AFvD0Hx4zFFFaROdn4cOj8GGh+HItJKXN7qGzbFw+ZdVmt574IBxNEOvXlUfGUJUkvgl7fxn8P25ehxcubR6pIUFwxcmdaUCz+8rY+5ium0Suc6SD+qUKfDnP1ft87s0ocrjqQJfqhJITITTp4N/fuAA1KlTee0pEZeBvySIMXy40sAqFEVngtuqWH28gHh88eNsPLExQLSJs8bx2tDXqB9Xv8TvJUQn8P6o97l39r1+EUQen4fd6bv54+w/8vn1n0e07QqFouZSDR7d1ZjSZoPtR8OznQrMds7bMoooc3CxqnVraNGi3KuvchbtX+RXIQHkwXdz55sZ22ks5mKzZj7dx8zdM0v0aCk3ug9+vq1sAlBiR/jdGuj9sfhGRSWV3ks2WSXSIbEdXPmDVCOKLvnBX1FmpszEE2QmX0dn7p65Ednub41VqasMy6vnunKZunNqJbYoEF3XWbB3geEyK1JX4DFKUSgv2541TrvyQxPBdOBsSGhbPiNmazzENITL/gcD55Scqus1CBdoMkquwyrEKOICpABAMN+3SqXj45DUKXgxhDPr4IeBYsLtqYCHWkG1tIhwdAaEY6a8As/vW6+YQrQl+PN7yxYxhjZKGYs0HTsaVxvdtk3Oy6rm3nslXTIYL78MOZVQO8KQmIYYpkrm7K3Y9VKcCkXRVYebzIXBwwseZuLaiQFG0CDFOl5Z9QrN3m4W9DVhyQTcvsBQPIfHwZfbvuT272+vjJ+hUChqIEoEMqL5WIniCMauNyFIxarKYsWuAeQ4k4J+fu211WOWrry88csb5Lj8e24ur4uBLQZyQ8cb/MpkgngFfbH1i/A14Pj8sqU2NBkNV62HOj3LPwtuiZWy0aNTZKAVRjIcGezP2G+4zFnHWQ5nHQ7rdn+LzNo9K8Cs/Py0xYgJLCGyK31X0HS1QsyamXXH1oV3w3mpcOR747ShQkxR0H86XDQuPFE41niJKBq2UoTV4hi1p9VdgctXMl26GHurLF5sbNBbaVhiYegqqHeFRFCVRMYmmNUS9r4nnmrlGdyOSYPb9OCvUttpcA/e9XrZ0hQjQJTFzRu3TzCM9LnpJikRX1XHvVEjGDZMikuUhNcrxgKNiOMAACAASURBVNBVfV6OH2/8+axZsHRpFbez+U3GFgKHviJsflqKas+U7VOYtG5SQHXRQjw+D0dzjnI02/gVLO1LR2fyjslMWjcpkj9DoVDUUGqwPFAJtH8UTAYiUOo3IhBUYd5teo5xtMhFFxnPjlVnjmQdKbHM9sAWA4m2RNO3ed+AiBa7285bq99CD5dxxrbnwBOi0NdsLPT9VgayFfWaMEeDtRYM+xlqd6vYuoqx7OAyos3+ERLaeZ1Os2Zmyf4lFdtQcgRn8MNJBdo5a/csfHrRjGm0Kdrvb5B9aZQyFmkW7lsY0Kbz/aAcHgfz9swL74a3vRBauo0lHoYsh0a/C28aliUWal0CV22EmEahfadur/Btv5yMG2cc6fPDD1JWvFpgiYHBC6HTkyIEaSVEUXlyYfOTMLsl7PgH5OwXMcgoIiucWBMJOqjOPQC/3Bm+yIty8vsBn/PCC8FTvlwuGD4cXntNIoKM0gUjxbPPGouTb78N8+dXbcRScrLso2D7UdfhxhthxQrIraq5u/p9IdrgmZN/BlLeCr3Poaix/HrqV26fXjlROg8veLhK+yEKhaJ6okQgI5I6QKMRYA7S+/Hlw9LB4M4oqIhSTioQ8h5lMRagjMK4qzvvb3g/YAAbHxXPbV1uA8BisjC89fCA751xnOHnIz9XvAGnV0P2ntCWbXknXP55eI3CTSYZxAxdAXV7h2WVs3bPCoisqhfr75iZ586reKn4tDTpdVfkFQoV3UZaWrl+XmpmKul2fxPHaGs0yXH+17LD7WDOnqorFT/116l+floAbeq0wVTMgNzj8zB91/TwbTTvCKR+G0KUhQYDZorRcCQM9s02iGsBVy4LnrZUnNJMpUNlekOYrJXr1eAHjWGd5mAOoiHrOowZU7WDbT9MVujyAly9F5peJ/u5JDHIeUo8hOa0gQXdRSQ8MkPSX7z5IsS4MkMTh7z5smwoA+XBi42jgY7OgDX3gDun/M/wMKSsPfkkvPCCCC0lRdy43fDii9C1q0S0OJ2Rj2jxekVwPHoUeveWMvFGAsttt8F331VtpM3DD8NTTwVvp8cDo0bJcjk5xgU1IkFungY93gjepwRJoz2+yLgybShEMpVSUSHsLju9/9s7aARQJOj/v/6csZ+ptO0pFIrqjxKBSuOKr8WjoqSOLYDjhHRqz6wvf2pYaSHvBmHvTescwWwKPjW4aVM1mjkuAx6fhw82fBAQ5uryuhjZduS5v2/pfAsJUf7+IXmuPN5e/XbFG7H9b6F5ARWa2UZiIKsVCEFXLoHY5hVala7rLNjn7w9j0Sz0btI7oMLEitQVeMNlnPobZP7e+X5CCojgM6jlIL/3PLqn4oJaObG77WxK2+T3Xpw1jkEtBhEf5T8wPpB5IEDUKjfb/x5aufYuL0DdPhCkcllYMFkhrjlc9mnpy7qywrPNCla0+ve4hw1LWa9bJxFDdns18QcCiG0M/b+DkTug3YNyz7IkUGIUTs4e2PUarBoDc9rBtzaY2x5+ukmihvb8Bw58JkLi0VlwdDakfgcHPpdqc1ufgV9uh3mXlN6uWhfD4AXBU9YADn8L8y6G9LXyDNfLuFMr8PwuzpNPwpo1Um0rWCXPffukQlzz5vDMM1K+3emEzMzSq2OVRqHok50tQs6UKSKYNGsmnz/2GDzwQPC2eTxw993SvvT0yo22ycsr8vt57jmpmBoTEzwV/rPPxC9x4sSi3xwpvF5p24kT8PTTQLProdPTxufkzzdDytsVi1KraCqlImLcNfMu7JUcgej2uRn73djwRckrFIoaj1ZVN4SePXvqGzZsqJJtlxlnOizsIbOZQSuGadB+PFzyN8AM1jBXmJlcckj76r2XMfzVReQ4S/aySEyEU6cgOrh/bbVkZspM7ppxV0DUyiXJl7D1ga3n/s5yZtHgjQYBYlG0OZpjjx2jbmzd8jUgezcs6Fb6zLStAYzaBdERLjvic0PWTljYE24t34z13jN76fpBVz+PmMToRF4a/BLPLX/Or4JUQlQCS+9aSq8mVZgiE8yEojhVdP+68vMrWX5oud977eu2Z8IVExi/cLxfpY5oczSHxh+iYXzDSm3jgr0LuOX7WwKO6/Sbp3P1lKv9IoQSohL4cPSH3Nrl1opt1HFSUn9Ku27q9oEhyyIjnJaEJxdmNAO3gWn8pe9A24eMU4BDIci9uiz83EJn2DDjSIUePWDOHKhd2zhVJ9z4fCH4zPk8kLYUjk6H4wtFGDNFGZfHjgSFg90z60V0yj9jLOw3GACdX4D6V8hvCFd1s9LOiWKDcq8X/vMfETJcrtLFlORk8ZLq0kUidnr0gJYt5bvFU8c0zf92qWly3mRlwc6dIi5u3gzbt8Pu3f5l3wu/p+sinPz1ryI6BRMho6Lg978Xoap2bel/lGZ6XlY8HhFCXS5480147z1/MSclBW6+GfbvN45Oslph9Gh45BHZf7ouvz0uTj4rK06nvGw2icRetAgmTYJVq+RzXS/4z5p74fB34DVoXL3Lxeg+pnH5zPKNKMM5WS6q8fP7HFXQxo82fsSjix4t0QgaoFtyNzbetzHAXzAUdF1nyBdDWJm6El8J5t6x1lieH/A8f+n3lzKvu1TU8Q4PoR73mtBO1cZqgaZpG3Vd71nSZyoSKBRs9WDUDmhytcHsjQ6734YZTWD7s2A/LrOKEfY+6NN6LRZz8Eig7GyYObPis4SVTUmG0NHmaG7rfJvfe0m2JLo1DPTMMWkm/rflf+VvwI5/hJYecNlnlVNS2mSF+DbQqfwP70X7FwW85/Q4uaHjDTjc/gOjfG8+C/ctLPe2fsu4vK6gXlV9mvQJ6LxZzVYW719cWc07x+zds8nJDzRVH9RiUIAvVI4rh+kpYUgJOzqTUh8rJiv0n1Z5AhBIStDFzxjPvqd+U3leNaXQty98+qmktQTrx2zaBB06yADTbo98ipjPJ4LE9u0hLGyyQOPh0PtDuC4Vrk2FPv+F1n8sMM2vJdG1hRFDJluZEiN0kOpvlniwJonAZIkXH6iWd8p9+drUoi/U7QWj90CrcQXnQJCdemolLBsCs1vD5sflb28+uLPlFUqEW3F87jJHmJnNkq6UlgYffSSijs0WXOg7eVK8ot5+G269Fdq3l2W7d4err5bInNtvlyidcePgllvg+uth6FCoVw8aNIBBgyQSacoU2LHDXwAqjqbB//2fiEUXXxw8Ksjlkra3aCHrfu01EWNcLolaKk/KmMNRFPF0/Lic96NGQcOG8OqrgZW/OnSQa+SNN0QoCxZd53bDjBkweLD8nk6d4K67JP1u4ULZltst2y+MOMrOln/z8qQ9Lpf8vmnTRCArjNaqVUuEqEIByG9HXvYJ9Hiz4HwMcs9MXw1zO8DPt0h6utcpqYuKGsnqI6sZv3B8UAEoxhLDF9d/gclkQtO0Mr9MJhOfXvtp0Kqldredv6/4e5X0RxQKRfVDRQKVlYOTYf39MkvoK2XAkNRZKow1vwniW0sUke6TzmooxsE+l4QDm6zwXfAZyYc/m8hHKx4OWqa1dm0JI68T4WCVcHEw4yCd/tMpwMsk1hrLpvs20b5ee7/3J66dyFM/PBVQBalxQmOOPnq07DMqXhdMSyp9QNhsTIEPUJhmi0PBYy/34Hnw54P58dCPfu/Vj63PqSdO0WZim4CqYV2Tu7LlgS3lbWnFqaYq/rKDy7j+2+v9Imzio+J5f9T73Nr5VuJeiSPf6x8xOLrdaObcWrneQE3easLxnON+73VL7sbmBzaXGMmUGJ1Ixl8yAtLcysSSfnC6FD+u1veJL0a4Z7ZLI2e/pP0EjeZETKrrXQHmCoQthCESqHAWfvt2GeiePm0s5NetCw89BH/4g9znLZbwRX9mZUkUx9Kl8PrrsHJl+S+7s2dh1y557dmZTcahFKJc+7FpZ0iynaZJneM0qX2COvFnsJrdmExeNHS8Pgsen4WMvNqcyGzIkdNNyMqvj8NXl3xLKxKadKBt57p07CglzQ393tPXwZYnpYy9z1W6sGOyQkI7qNUZanWVKLakjgUFAKwiZmkmWY/PLS93JmRuh/Q18u+x2cbbKCXq4sABmDcPpk6ViJ3oaBEgvBHO2I2Lk22UFJHm8cAXX4hpdE5OaOlfSUkiHnXuDJdeCj17StRSVJScs1ar3PY9HhFeXC44dkzEnPXr5Xr49VdJNyuJYOelxyOTYf/6l4hcJlPZRNPoaBGRbDb5f6tV2lYY9ZOTE7phd0Abs3fDyuvAfrR0n6voetDkGmh1J9S5VMRWb754DJlDuOB9PvAWbGNq8KqyQKVEAi1bKtswm+X4JyXJvaxu3fBHjpVIJfYxjmUfo8v7XchwZpT4uc1i497u9zJpZMUreb2w/AXeWP1GULEpISqBzfdvpnWd1hXe1jmqaX/Nj99KG6FmtFO1sVpgFAmkRKDykH8Gfn0F9r4vf4fiG6OZJJKj1iVQp7t0JKNqy4PbZJPOpM8lD3SvA5xpMvOTuRUyt4H9SNBVn8mpQ9unz5BR8rMFgCuvhNmzg8/cVScmLJ7AxLUTcZ8XidMovhHHHz8esPyhzEN0fK9jgGgUHxXP7FtmM7jV4LI1IG0ZrLwePAZGAZoJrjsaeuWhcOHzlqvymNvrJvHVxIB9NKLNCObfPp+7ZtzFl9u+9PssyhxF+hPpJERX8mC9kGp6A/+/Bf/HpHWT/MKt46xxbL5/M23rtqX7B93ZctJfPIuzxpH1VBbmilaNC5GDGQe5+D8X+wmjGhoP93mYd696l3+s/AcvrnjR7xqLj4pn1d2rSoysCwl3LnxfV+5jwdAscP0xSaOsCpb0l9n1YAP/mCYwOqViaUDTG1bYF6j4ACwvD+67T6IVnM7ST/lOnaSs+LBh8v82m3wvJsZYGCqM9AH5zuHDIjhMmyYREcWFgFAvuzNnpBrTggWSFnPypLTD4wm/gXBMjAwcnU5Jgx42DL7+2uALmdth5+tweGqxVLUq6hCWYcDtdEpkyS+/iIfQ9u1F+9VkEvEkPz80gUjTikQNk0nWbbVCu3Yi0PTpIxFDzQ3s6DweSUt85RVpi8VSdebQoZyXhw9LJbMpU2DtWvn9ka66VpgOV/wa88PnlUjELU9KxFmo1cFsydKnrHWJpDDGNhNzdrNNIuUKJyu9+dKfObMBMjZBxjbI2mG87nKIQKdPS2rhrl1w62MNSXIEvw+e1JJpn+hfmKEwFS8/X87DxERo2hS6dZPItkKRt3Hj0MfKhlRSH8PpcdLzo56kpKfgDfLsqW2rTer41LD0t5weJxe9exEnck+U+LlJM9E8qTnbHtgWvv5dCPty0UJ/0S8xsUj0i4sL0zGtYBurXBRQIlD4qAltrASUCBQpXBmw9wNIeUcqOfhcIVTEiQzza+nceKPx7Fb//jKbGBcXgqdDFeHyuqj/en2/KAuQUtsP9nqQiSMmlvi9Vu+04lDWIb/3NDRGth3J3Nvmlq0RG/4P9kyCEnKqz9HsBsnVr+xohnKyKnUVo6eM9tuvUeYoXhr8Ek/2fZL/bvwv4xf5hyknRify1fVfcXX7q6uiydX2Bt7inRYczjrs916sNZbcp3PRNI1HFz3KxLUT/SrbJUQlsOiORVze7PJKaeP7699nwpIJfsczISqBT675hBsvvpEl+5cwdurYgPPhhYEv8Nf+fy3fRo9Mh9W/N/Z9uehuuPTdqrtucg/CvM7gNbhRNvod9J8e2TTPcvhxbN0K48fLwNXlCj0KpEEDqSrVrRu0aiURDbGx8nK75ZmRmwsZGbKNLVvEE8ZoUGx02WVkyAD7/fdhzx4RlHJyQr9UExKKIi6iouQ24HLJwDA/XyKTQiWkbXoccHKZGFEfmy0Coe4NbXInHDxkgsyKOXw7iSaFDhylKadowGnqc5SmHKUJGdTGiwUvZkz4MOPFhpNGnKAZh0nmFA0KXh1IIZmTgclyJ0/KiVQKJ07A3Lnw1VeVI7CYzdKfcTrFE6msXUqnU0TK9etFVNu6VTwUpbqYjscL+U4tpGvNapXfazbLtZmfL6baPXrAFVfAZZeJ51Cwyn+AiEHH5kg6etYOEc2NPIMiSQgi0KlTsHy5iGpLlkikn80m12u4K6/ZbHI/cLnk+Fx5pUTGVYhK6GPous6t39/K7N2zA6LVC4mzxvHxNR9zS+dbKrSt4izat4gx340JGg0UbY5mUMtBzL89sMhFKPh8cn9PSZHnxf1/a0gtg8mPYKJf4bWi63ItN2okkxfdu0tKZ/v28relglZ9QLXtU/qhRKDwEUobj82X571mlvutJQ6i68tEpTWxEpTJyKNEoEij6xKtc3gqHPpaZoE1S8FsTiXsX1syjElj3DiZtTUSgjp3llm7+vUrJyqo8AYfrGTr+Uz9dSr3zr43wA8oISqBubfNZUCLASV+76kfnuLN1W/i8fn3Nm1mG4fGHyI5vgzlUme2APth42VG7ZSUgBrC0z88zRu/vIFHL9o/idGJzLplFoNaDmJL2hYG/G+A337X0PhDjz/w0dUfVUWTq+VD5kjWEdr9ux3O81IFL2t6GavvFZ+g73d+zz2z7iHbVSSwWE1WnrjiCV4e8nKltHPoF0NZenCp33sxlhh2PbSLFrVakOHIIPmN5IBou+4Nu7Ppfv+KYiGz6iY4YtAr10xw3TGIqVyD7AB2vwdb/mI8uKrfFwYVVJWKRPRWBUxZt2+Hl1+W+7jFUjXVH0u67PbskcpMs2eXnm5jMolfTMeO0tG/9FK45BIRqaxWeW74fEXGw5omg2eTSbadmir7YePGovSy/fsDhbEy3x50H2RsllSx06vhzFrIOyhRFZpZPvflG0e7nfuRNokw0rQCfzkdEtpLxEbd3mL6m9iu5nQyy7gz8/IkYmnTJvjpJ/EROnOmwNtI0/F4QhNYTCYRAApNmh0OiSDo0gX69ZNzZ8AASXsPB3Y77Njp4aZPx3P4uJOHO7+EJ6MRR48WCVper5yPVquIli1aSHRKcrJoZU2bSjRVeYylz+E4KaLkwc/F2Nxsk3RwPYIhS4UU9ClLIj1dIuzefx8OHhTh63w/JiNq1zYWec+eDf1Uq/DjvxL6GG+tfovnlj8XVIwxaSb6NOnDz/f8XC4zaCNGTR7F4v2LA/rFhcRaY3nsssd46cqXSl2X1yvX8IoVIvSuW1d0X46E0Gs2F40bXC6ZxFizpoIrrYZ9ygB+SyLQkdmALs9BU5RkvJiiRGiJay4iS7jRdchLlUjfbrfBGYOoyiQN/ltCG3SvRE/iA0uiCEK1u0O9PpIWntQFYsowpqxilAhU2eQelE5k+ho4/ZNUdQJ0kwV0Hc3nLt1PCE3yvE1WQC/I+46F2l2g/oCCTuRlYKt/7hseD9x5p3TCjTrgUVEwYYIYGGpa6AJNWSj0Edi+Hf74R8nDD4Xe/+3N+uPrA96PtcaS9VQWliCVe9YdW8eQL4aQ6/K/4G0WG8/2f5ZnBjwTWgPyDsOc9sbHp8EgGDgnfJVjKoGO73UkJT3F7z2ryUr6k+kkRifi9rqJeyUuQBRonNCYY48dq8ymFlENH9glVfYwaSb+0vcvvDLkFaBAKJrULiD1rn3d9qT82f8YRAKX10XSq0kB20+ISiDrqaxzHc3GbzYOCBcvdwqgzwPTahunMdTvC4PmR+bBXxZ0Hyz7HaT/Yhztkdge+k2DuJbhv9bDUJknP198er74okgQKjSwDTcmk0QQ5edD27b+5tCZmSL+fPyxbD/YoD46GoYPl6pRV10ly3k8paepGVEYcWAyyTpWrRJD7TlzCqKPkhtKFEtFMAHJQB0gCUgs+P96QBRgKVjGW/CyA+lAZsEru+DvID42NYYw3GtzcmDZ+iOM+d+D1PF04pHOL3PsiIUTJ+RYut0i/EVFiYCSnCwCS8OG8kpOhjZtIutvqOs6d824i8nbJ6OjUyemDlse2ELTxKaR22hpuLKkP3l2I5xaIUKlOwvMNnQ0dJ8bzetEM4peBnxaNJo5Ck0ziZjk84jfVf2+IkrW7QWJHUp89u7aJf5P8+YVDfyDYTbDRRcVpW/17CmiXYsWsuqSRF6TqUjoPXJEvJ82bChKL9u3jwDfy+ouAq1MXcmgzwahG0wGx1hi2Hz/5gCvy2B4vSKUnTol6XeFflQej+w7i0Wun3r1wBt3lCEz2huWo9fQmH3rbEa3Gx3wma5LRN/HH8N338l7hYJdaWiaRMI1b24s+h07BocOhRbZWt2Pd1ioriKQO0fuOzn7IXc/DH4DMgxOhCQN/lvYjzzvN+k+6XuZoyUFP6ENJHWSe1H8RVC7G0SXobKz/TicWARHvoeTPyLCk0WifMOZnWOKFjHe6xQv2MYj4IovS/9eFWMkAoUjwE5xPvGt5NXiZvlb1/HmHuL33wzDkX2Qfw/+K41MPsg7JIMm3VMQjmYR0ceaJN+PaQy2hjJzHteiVB8NiwUmT4YnnpBZmmAPaZdL8vc//BDuuUeqfSQmSme8oiGXubnyIJ8/H955R2YAQ2XPmT3sOFWyWjS89fCgAhBAz8Y9MWuBM/ZOj5OJ6ybydP+nQwt5Pb5AIhaM6PxM5VY2qiBnHWc5kHEg4P36cfVJjJYBudVspU2dNuxK3xXw3dTMVFrUalEpba3uTN05NWBGLz4qnr7N+p77u2liU6LN0QEizKHMQ5zOO039uPpEktVHVhNljgrYfreG3fxmGvs07cPMlJl+y9jMNpYdXMa1Ha4t20YztxK04lIhzcYaV+eqLDSTiFGrbpA0oGCpYdm7YUFXaHM/dP2ndM6qWsAqRnQ0jBwpL7db0rg2bJCZ2jVrpKqRzaaD5kP3mcjP14JWfQL5eYUpFyAddItFInQGDSpKZyluurxiBVxzTZFJbknUqwfPPy/VqbxeiZwIVzpyVJS/geyQIdCrlwxapk8H7qigAASSFXyi4KWoED5rFo9s64evzWHOMI8d7Q/xzV+/CXsEREV4ccWLTE+Zjg8fZs1MpjOTgZ8NZNN9m0iylWKmHCmiksiOH872g8PZmvJX1q6FPTsysLoOkWQ9QeM6aTSpe4LmdQ9RLz4ds8mDxexG1024vVac7hgOn2nBsbNNOJLeiDN5DbHTmPjkllx+hZlu3aBrPWiZAKbzDkVGBjz9tIjN+flFws35xMTAiBFynQ8dWiToFXp1lYXWreU1cqRElBXem9asgU8+gVmzypYWGpTkZGOR2NBhvnRsFhvDLhpmuMyYjmMCBCBdl9TK7dtlAnXNGrm/nzwp+6NQJC28j56vBxReTh5PUxytP0Lr9gUWC8TFQlItSEyAuHiIL7CGiD2vP+vzwbffykTx6dMitAc77pom6cadO4vgV5jG1aSJnAPFnzmF7Sre3sIiBmlpsHevRA4WCn/r10fe/F4RBOcpOLkc0pZKP8l+WPpvukciEieVJkLp4m9mhMcDOXvkdXx+QeS1VQSi6AZwfXAvXJynYP//YN+H4Dgu3ys+CRmJ88aXX1RYxJUPh76qESKQEUoEqgw0jadW/4evjx9AR2f18k/Z8eAOaseEKX7Zf1O88YaE1T/xhPFD+8wZqfby+uswcKCUkx05UmZwHA4Rc4yEIbtdOv8Wi1zLq1ZJmOi0aTJTUVb+ve7fJYatJkQlcGvnWw2/a9JMjG43+tzsXXEcbgdL9i9heJvhpTci9VtjvxCzDer3K10oqkYsO7iMaHM0Lq//NFrvxr39/u7XvF+ACGTWzCw5sIQ/9PhDxNtZ3XF73fx0OFDVdHqc9G5StC81TePSxpey7OAyv+UKS8XffsntEW3nnD1zyHP5pzqZNTNXtrrS770rW17Jwn0L/cSiHFcOM1Nmll0Eyt5d+jLNb5TZmeqAOQoGzIQ1d8vsUbBrXvdJAYD9n0ilx05PyUwVWrUSgq1WET969YI//Uney83V+fOU1/j8p0X0q3MTVze6j8OHTZw+XdQ5L0xpiY2VKk2NG4snQ6NG0olv1Cj4xOScOVJuPNhkg6bBo4/C3/8uzwibLSI/PYDEAp3uppuAOypnm795KjgYBvD4PIyaPIq03DTMmhmv7mXennm8vOplnh3wbBgaWXG+2PIF//r5X37eLV7dy7HsY4z4egQ//v5HoipSObAMeDwy+J81S/pUx45Jf6wo2q92wat7+TeyHZYtF2sAj0cG54MHS7QPwLJlcN11ss1gIm+DBnKN33mnDNgLr79wXO+FFcMKGTBARIYPPpCI9wqTloau69w09Sam75qOjk6SLYnN92+mZa2WFV597ya9WXTnopCWzc6WyM4ZM2QSNS9PxBGHIzACqrAqXUhsux223Y4bCUzM0opMmPPzJc3qyjuLFl++XJ4hR48aG7wPGAB33AFjxxb5XMXF+XtelUX8a9ZMXoMGyXZ9PlnX3Lnw5ZdSWKDCRFj0CwultbFwmUjgyoDU70RYydpZrGBCAb4gyqspGhJaQ0JbMac3Rct3zVGAJunThS/7ccjZC7n7xEu3OF57kXjjOFrytjK3w/YX4djcgrDCgnu1UdXX6HpQq4tU7K7bWyKNrIlFKWqaRSKGfG7JunGdkRTcsxvFmy1zR+hm/TWMatIj/23z7a/f8p8N/0FHx6yZSXekc+0317J83PKIVQt66CEJub/jDplNKK1ax4oV8powQWZqu3WT0N1C34bateWG7vXKw+fAAfFgSE0VU7i9eyvW3kxnJu+vf7/Eygk5rhyeW/4cL/z4guE6cl1izHt+imOOK4f75t5H6vjU0huSsdH48wYDC1LzKmlEEwZmpcwK8FiKNkczsOVAv/f6Ne/HlB1T/FLq8tx5fL/reyUCAb8c+QWryYoT/95XUnRSQHTPkFZDWJW6yi+9LteVy7Sd0yIuAs1MmRlwHcVFxXFZ08v83uvVpFdAxJCOzry989B1vWyz81kpgQ/04iS2h6haoa+vMjCZ4fLPxZfl11ckxDdY2L7PBYcmyyuxAzQcKqWa61/BuU6OZiqWwouM0zKxpAAAIABJREFUqHyugvUioc+ePJlVizC6rvPCzxOYevoDuMjORssa2rZfx8dPfFwuE9DzWb/eWAAqjEodMULSyKqCCvmxVDYVCe2vrukD5/HA3AfYnLYZl9d1Lmo3z53HK6te4eL6F3N9x+urtH1LDyzlgXkPlGjem+/NZ2vaVu6ccSff3BC5yCVdh59/hnfflYp6JpOIAIV+K0aRfOXF6/X3FZs/X/6dMQNuvz14eqmmyUTj888XRXNUBgkFGSZjxoRnfU8vfZr5++afi/zKzs9m4P8GsuWBLRGZqC2OwyEC37vvSj/dZvM/FiELPWVA1/0r1K1bJ//6fHI8P/jAWNi/6SaZaE5KkskDQ6PzcmAyFR1jkO2NHBkmz6G0NDIcGVzx6RXsTpeJK5vFxrSbpjGy7cgwbCAMpIkX1+J9i7nu2+tweBzYzDa+HPMlYzuNjcw2HSdg63PiaWsyF/XlShJWEtpCo6ugTg8RVeJbSfaK1y4nlymqwGTZXOSnWFhsQffJ+ElDon48eZIRk7VLUs3SlkDGlsBtgkQVbXwMUidLu3SD1NeENtBqHDQaLn1PU7SIRaZosMSEsENaQp1LpeKt7pXvuLJEGDs6Q/qB+adDWE/1R4lAEWZr2lbumXWPXwqJy+ti44mNTFg8gbevejti227dWipezJ4Nf/6zeDeUWJ70PHJyJKpn1aqINS2Ap394OmjpTIDdZ0KINDDgcNZhNp3YRI9GPYIv5M6VMEcjml4ruaA1BF3XWbh/YcD70ZZov+gVkJS6kliZuhKvz1tp5c2rK7N3zybPHSh0nL8fQYyiY6wxuPP9e+0/HPwBn+4Ly0C8JNJy0ziaHTiD4nQ76dW4l9973Rp2w+EO7OHnufPYe3Yv7eq2C33DmZsxrKbX6CrEOKWaoWnQ+Vloej38cpvkuhuJWQDZKfLaMwnQIKaR+AbFtywq0axZRQAq7OTkHRKzwvzIG8Pous6ExRP4YOMH5547Do+Db3/9FoCPr6m4EPTII8beQ6++Kh33yig+YEgos6pVTXWYfY4w7659lyk7ppRojuvwOLhjxh38VOsnujeqQFRLBdhxagfXfXOdnwAUa4nFq3vxFuSj2D125u6Zy7PLng27wb/HI54rzz8vY0C7PTTNLjFR0jUvuUTSNVu0ECGh0IPF45FoD6dTxIX168Xcd9s2mcgLto21a2UCMdg1brVKutCwYVV3jYdD5P1o40f8e92//c5Ln+4jLS+NYV8O4+d7fibaEn5169QpePNN+M9/5O/Cfvn5ET/FSUqCiy8Wb6WePeWVnCz7ofDl8xVFedrtklK1erUc7x07gh9zt1tE/YULgwtALVpIhFiLFpUr7JtMRdFlFaVQADqQceDcpLzD42Dsd2OrlRC06/QubvjuhnP3I6fXybiZ42hVqxWXNr40fBvy5MHWZyXyR/cWROuUsFxiB7joXmh5C0TVpsRIaJPBQSoUhcB/Aj2qFkR1k8icZmOg83Mi8ByeDgc+Llru6BxYM048foL5tZqs0OIW6PgExLeW7ZmLXbvmclzHxb0gbfXBNhDq9oRur0L6atj5atnXWc1QIlAESbenM/yr4SV2fOxuOx9t+oheTXpxW5fbItYGTYNrr5VUr6VL5cHz44/yfiRmGUoilAfGZ1s/i3g7Hl34KCvuXhF8gdwDBeq0QR5rk2sjUy0oQuw9u7fkjrfbQbeG3fzea1+3PW5v4FSjWTOz8cTGEsWOC4npKdP9yr6DRFSdn2YFIqiVJLBoaGw4viFi+3Lx/sVYzVbyvf4zOLVjalM31t9oz2ax0bJWS/ae9Q/j03WdBXsXlE0EyirF8LpOzxBnYKqIWhfDiC0yw7P5MelsGJW6P4cu+eiO42I0XcXous5jix/jo40fBVz3dredb3/9Fh2dT675pNxC0PbtMqgINoCsW1fSCSJRcKDMpJVc4ShkaoKRaDVn4d6FPP3D034Ci4aGzWI7F4Vod9sZ9uUwtv1pG40TGldq+47nHGfw54PJdRfNkJk0Ex3rd+Th3g/z0PyHzon/dredd9a+Q6varcIWHbt+Pdx8s3ivlDZJ17On9Of69hUPlqQkGbRHRYV2vQ0dKlHhZrNE7xw4IJEgy5eLh1bh9h95xNj4+bXXxOS9Wlzj5WTB3gWMXzi+xMgvl9fFztM7uXnazUy/eXrYJm18Pom0efLJIoEuGHXqyHlx661SIj0hQY6J1Rq68NaypRxzu70o9ffQIYn6//RTEftAPESNBKCLL4aVK0WMCUup9iqguAB0vjVCoRA09capjGo3qopaKKTb06XIjdv/ZmB32/ndV79j2wPbaJLYpOIbsh+DpUPAnloUrXw+iR2hx5uSAaFZCtK7IoQ5ukCoSYDW90DLgnHxvk9h48PGNh0Nh0lUtyUerGUsalJWLAUXX/Jg6dfWcKrh1OxvA7fXzaivR3HWUWSOY9H87552t50/zvkjm09sjnh7TCaZtVm4UB4CzzwD7dtL5yExMXxGnSAdg7g46aBcd53ktBsxK2VWgIltJFh1eBUuj8FUS+4+4xXENq1+KS2lsGjfooD0OIAmCU2Itfr34MwmMx3qdQhY1ulxsnBfYDTRhcTxnOOcyAl0ho22RAekWQEkRieSHB84w+/0OJm3Z15E2ggwbee0gAp5IKlfJdGveb+A9xweB1N3GpR6Px9dB3uQ/O1CkjqFvr6qQtOg1e1w3XHo+41UYSws812Z2MoXGRJMANKKGXbb3Xa++/U77p11b4CgGSrHjhnPwrdtazyjrbhw2Hl6JzdOvdFvoG0z27ir2100im/kt2xWfhZDvxgatJR2JMjJz2HgZwPJcGT4vR9tjuabsd9wV9e76Nm4p19RCrvbziMLHmHRvoqZlDid8Nhj4sd48GBwASghQYp3HDggYs1TT4lvT/360n+rVSt0MabQYyc+XqKFOnWSan2TJknA3OTJkv5vVM21Xj24776aLQBtPrE54LyMtcRiNRfd2BweB0sOLGHC4glh2ebevdCjhwhAeXnBBaCBA8X/5tgxEdv69xdhvfBYlzXyymotOubR0dLvv+ceWLJEtjF+vFR3NBL9Jk+WbddkAejyTy73E4CsJv+HmMPj4MapN0a0f1YaLq+Lq766inR7yRHD2fnZDPliSIDnY5nJOwzzu0rkczABqN3DcNUGEVgssZEVgM7HZJEonINfwsY/BxeANBNc9jkMmCER2ZEWgM6nsrcXAZQIFCH+vODP7Di1w88TJMoSxdCLhvrdfOxuO8O/Gs6pvFOV1raGDaXUZ0qKzD598410Mtq3LyzjqJOY4CMxwUN0VMkpWiaTj/g4D0mJXuLidEwmeVCNHg1vvQUbN0pViRkz4MrAQAk/nl76dAR+ZSA6Ov9Y9Y/gC+TsNy4ZndBewiVrEN/v+r7Ema6ShAuA/i36+w0aAdw+N9/v+j4i7aspLNi7oMTqdHa3ne4NS05huKLpFQHvuX1upu2cFvb2AXh9XpYfWh7wfrQ5mitblnwRDmgxgDhrYK9yw/ENoQuzzhDuXfGtQltXdcBkhiYjYdgKGL0T2j0i4cWmKLAkUmoVtJAxF5kT1uoG3V6DG9JhTNmjV4IJQDGWGN4b+R4xxaKw7G47U3dOLbcQVLeuccWWI0cqzx9EUX1Jt6cz5PPAGe3YqFjeHv42X4/52u+89Pg8HMw8yI1Tbyy3QFkW3F43IyeP5EjWEb9U9DhrHH8b9Dfa1GmDpml8NeYros9LJXB4HNzw3Q1sSQviX1EKdjv06ydRIcFSrkwmePxxqfL38stS7CM+PjID8YQEEXVuukkqxxqJvG3a1GyR93DWYRlIF0vtNmtmLkm+hE+v+dTveWh32/lw44dMWjepQtvctUsqK27bFtyf86KLpJru3LkSvWOzRS7tymKRY964sUwOG9Gli7QtnBPFlUmhAHQw86BfBFD92Po83Pthv8nQqhSCdF1n3Ixx7Dy902/caDVZz/XJPT4PqVmpjJ06tmL3yPUPgTtLKn2VRIfHoNs/RfypqmIeztOw7n6DMZkGV3wNzW8ois5RlJkaqutWbz7e9DFfbfsKezF/mcKOxe1dbqfNv9v4XeSZzkxGfj2S1feu9puJqAwS41yM6LmBEc1X8NZV89Cz95CRoZN6pg2Hz7Yi9XRT0rNrke+OwumKxmL2EG11EWdz0qzeCVrUS6VFnb00qZeONb4+NOgvZlz1+4NWelh3uj09oCJVJJm4diIvDn6x5A8zt4tDfDASWheZvtYAXF4Xa4+tDXg/xhLDgBYDSvxO32Z9+XzL5wFG0inpKWTnZ58rKX+hMW3ntBL9gFoktSDGWnKa0+BWg5mzZ06ACLcvYx9n7GcC0rMqyqYTmwIEPJBopT5N+5T4nd5NepdochptiWZV6iqGtS6lhwjidWOOCp6rbYn7f/bOOzyKev3in9maTUISeofQi/ReRJoixYKI4kW8WBG8iGK7Xq+996sgioiCShGVIlWwANJ7J/RA6CUhjZRt8/vjzZI2M9lkNwn44zzPPMrO7sxkd+Zbzve851y9nXR4HWjzgWyZCXBuJZxaAmd+Q007iQqYfBNZT4YGSayIGaHZJp7TnnRpQ8JqQ7UBUO1mqNAloKQxVVUZu3QsX239KhcBFGoN5alOTzGq/Sgy3Bm8tPyly/fwJdclftr7Eyoq39z+TaHKHdq2ldQwvTCAkyeF/B80qOQSwa7hykKmO5Obp91MfHp8rtdDraFMvnUyEfYIOtfszD+a/YMZu2aQkbUaneHOYOXRlfzn9//w3k3vFdv1qarK/b/cz5ZTW3KVzioo1Imqw9Odn778Wo2IGnzU5yOeXvZ0rj7gkusSvb/rzfZHt1Mzsqbf53Y6xS9rzx79kvzoaJg3T3wdS9J/xWyWVEAjkjcu7uoleRMzEuk+tTtJmblTjuwWOzPunEF0VDRTtk9hxdEVl8foaa40nvvtOaKjorml4S2FPufBg1K+l5SkXzl6773w5ZfyvZa02sZuN656tVqv3orXhPQEunzdJR8B5LA4WDh0Ic0rN2f18dVsP7P9cjKxjwgq6dKwt1e/zfwD83ONFx0WB18M+IJRi0Zl+wO5M/jr2F8899tzfNjnw8KfKCkGzv6hTwDZykGL10t/zBbzkfGNV2MgVLul9K/zKsc1EijI2HBiA2OWjMk38ascXpknOz2JxWThjZ5v8PLyly8PKFxeFzEXYhi1aBSTb5usddjgIuOCyOyOTpP4O1OITOC8ThSgXBiUC7tA61rrC3fc1CQpqYr7WSZDtrIiJWzwKFTsqvmR5357LvC/pxBIykxiTdwautbSuJ7kvcYfjmgs6T9XCdafWJ8v/QlkZUGvPKhdtXaaKwwhlhBWHF3BbY1uK5ZrvZLh9rpZeUzbS0qrnMqHDtU7aKqH7GY7yw4v4x/N/xG0awRYdHCRpnonzZWWz//JBz0fqFRnKvP3z/ePBPJmYKiOCYsWgqSky6qCDXs5qHkH1LyD+LR4Gk9ohJoRz4/936RXxbpChrkvZZFBLqlvN9nBFinfQVi0kD+2yILO5Df0CCCLyULLyi15tcerADzZ6UmWHVnG8tjllye9l1yXLqvSCkMEmUwwbhzcead+CcGoUVIW1qyZxFpfw/8fqKrKP+f9k5jzMbkWuyyKha41u+ZKAfv45o+Zu2/uZRII5L78bNNnNKvcjPta3Edx4JUVrzBv37x847QQSwiz7pqVLwRhRNsRTN0xlU0nN+VSDSVlJNF9ane2PrqVqBD/SsWfe058ePQIoOrVJRq+QoXgJy/5g3bt5Br262RxnDoliVZ33XV1kbyZ7kxu/v5mTqWcyjXGCbOG8WavN6lTVtSq3w78loafNcTlzL53093pDPl5CCuGr9AdO+nh/vsllEVvPnvPPTBpUumV17VqZZw6t327VAyUucoqX/QIoDBrGO/e+O5lE/pf7vmFphOa5iIGS5oImhszl7f+eitXe2Q32xly3RCGtxrOznM7+WLTF5f3p7nS+GLzFzSr1Iz7W91fuJNdOiZjMT2FTURDGb+UNo58rb+wCND85dzGzddQJFylAr8rE6dTTtN/Rv98AwuHxcF3A7+7PCEc03EMVcKr5HpPmiuNmbtn8tWWr4rn4lQvnP4NVtwC82rAzhfh4tasBJvk4JY5uVPE4T3jjEQOLu+r+9bpu6YH77x+4ullT2vvuHTc+INRzaUG9SrBkoNLNGuH093pNK/UXPMz9crW0ySBUjJTWHhgYdCv8WrA+hPrNcmcMGsYPaJ76H6ueaXmmqRMijOFOTFzgnmJAMzeOzvXpMuHWhG18vk/+WA2mWlaMb9fj1f18sv+Asy8Lr+5gLbD7DCO87zKcMl5iR7f9iA+LYEEr8Ktv77Gck95aPK0DExavS3KoZZvQvOXoNEYqHEblG1RIgQQQLgtnLlD5l6ezCqKwsw7Z1I2JHfksU8R9OAvDxZKXt63L7z+uj7Bk5wMN9wAM2cKUWSkLLiGvxfeWvUWCw8szDcOslvsfHP7N7leiwyJZPJtk/OVpKa50hi5YCTrjq8L+vVN2TaFj9Z9lO+ZCbWG8vz1z2u2h4qiMGPQjHxJUR7Vw6mUU/Sd1jef2awWEhNlwm+UrLd0qZgClwYBBKIKGTfOmJR47DEhB4x8ZK4kqKrK0NlD2XVuV67fyaSYaFi+IWM6jrn8WtUyVRnfb7zmPdnn+z7EXoz1+7xbtsj3pEcARUbC5Mml669Uvjz8+9/6bbnXK0ql1FT5/6sBPgIorwm0L8jjX+3/dfm1amWq8dNdP+UqTYVsIqi4x73bz2xn2Nxh+eeNVsfl9Og3e75JZEjusUOaK43HFj3G6rjVhTthaA1jkiflUPAW7OZUgRlK0baCklRDawXnGv+fw68ZraIofRVF2a8oyiFFUZ7X2N9DUZQkRVG2Z20vB/9Sr2z45M/JmbmTpWxmG7c1ui2X8sRisvDdHd/lm5iludJ44tcngjvwUVU49iPMrQGrBsGpRULQGDmtBxVecGs7Hm49vVVTheCD1WQlyh5VpE2rLMaHbae3aZ/XiHUGCK9rvP8Kw7x983KtWvoQHRWtG3uqKArNKjXL97qK+v+WBJq/f76uWalRypfVbNVN2Fp6eGlQfS8upl/kQMIBzX2aqrcc6BHdQ1MFcj7tPMeTCiBGATwGESdw9SuAcsDpcdJvej8OxR9CRcWkmEhzp3HrzFtLxODfByMCyGFxMOfuOfmMyaNColgwdEG+wa7PI6iwRNDTT0uqjMOhPWHNyICHHpLo6r/+komv0eQ3WMjMlMnp1q3Ff65ryI25MXN5e9Xb+e7JMGsYb/V6ixoRNfJ95o7Gd9C5Rud8RHuaO41+0/txNPFo0K5vytYpjFw4UrM9j7RH0rhCY+bEzNHctp3ZxpDrhuTzB8r0ZLLt9DZ6f9cbbwGz5K+/Ni696d0batUKTvx5IOjTB955R5+cSE2FHj3g+++vDpL3ud+f49fDv+YnJrMMwPP2f8NbDqdN1Tb57slkZzI3TL0hV+CLEaZONU7hfeAB/wIIixvPPitlvnpE0Pr1UtJ27lzBCXaljZwEUN5FsfKO8kwbNC1fCfxN9W5iTMcx+eZk6e507v7p7mIb+55OOa1phh9mDWPSLZMuqwsdVhESaF3fLTNu4cjFI/6fNKqZlKArOixz5gWJPteZtxUKGWcDP4Ye0vwYm/qDQIiqGQrMuHrSorVQYDmYoihmYAJwE3AC2KQoynxVVfPWzqxSVbXwBbN/A6iqyoPzH+RQwqHLdaU+2Mw2xvcbn+8zXWp24baGtzFn35xcTHW6O50BMwawa9SuwGMAL+6AdfdJ9Lm7EG7yjmoSfRdWC8LqQEQjScVSLIBXyh0uxUHyfnkQUw5Awlb9GlMdjNswDpNi0iQqIuwRTLtjGrc2urVQx/RhxIIRfL3ta81Jjd1iZ8GBBQxqMij3Dm8B138V1Z4mpCdwJFG7Y+hSM79hcU50j+7OltNb8n13FzMucjTxKNFR0cG6zKsCc2LmaN6jHtWjmaaWEz2ie7D3/F5Uci8FqqhsO72NttXaBuUa/4j9A7vZnm81OtQaSvfa3Q0/27VmV77e+jXJztwEtlkxs/TwUj+ikEtwFDunSgADCxMMLfpsxat6uefne8Q0O0+ixiXXJXp914tNj2yifrn6RT6HP1BVlSeXPsnkrZM11QxPd36annV6an62XbV2vN37bV7888Vc/iY+IkhVVaYMnOJ3adjw4dClC4wcKRMFLWXArl0SDlCrlkQeP/SQ/H9mppSTBFpSkpkp5JLVCgkJ8O23kmYTE3P1ellcjdh2epvmijbIwsPoDqM1P6coCt/c/g2NJzTON35KcabQ69tebB+5PWA/utl7Z/Pgggd19ydnJvPIgkcKPI6W2tLpdbI6bjVdvunC+of1y+i3bTNWz/Tvf+WU3YwZI4qkESPExygv0ZOZKc/9uHESBnLDDfK8FbeqJSNDFCm7d4vZckGYuHkin2/6XHOi/eINL2ou1CiKwvRB02kyoUmue9Krejl36Rw3fncjax9aS4jFuPE6d85YPVO//pWRsuZwwJ9/wrBhsGiRtnn1zp1QuzaMHg2vvCKvRZSQRWRqqpQhF/RdJaQniAn0xdh8z6nPB0ivHXmr11v8Gfsn289sz/VZHxH0410/FskTSg/prnRu/P7GfP5UFpOFDtU7MLjp4Fyv31TvJvrV78eCAwtyjfN8beSOkTvyqYV00WEi/NpGiB6thZ/db4DXA81eAJOj6K7gIZUDI4JMdhEtaGH3G9BpauAlYQETVVeJPE4H/ngCdQAOqap6BEBRlB+A24ECDFT+/2D8xvGa9eW+2tOKYRU1Pzeu3zgWHlyYb+KW4kzh5mk3s3nE5gI7GU2oKux8GfZ9lBX/V8BI2GSHGrdDzUFQqQfYIsDjzErDMTB08Lqz6kq94iuUuBNOLpQSsNTDhqdMyUzhxz0/ak6uQZRVvev2Nr5uA9zV9C5m7ZmVT5kF8v1+uPbD/CSQzrVchnL1mEL/cUSbFAizhtGtVjfDz3au0ZlwW3i+786smPnt8G880rbggfLfBWdSz3AiWTv+vFnFZgVOlrvV6sZ3O77LZ7Tt9DhZeGBh0EiguTFz850D5DczUiuBqJm0Jja+UqECSaCCokODWWoaUIdd9M5aVVVGLRrF0sNLNSe5IJPI67+5nm2PbqNqmaqa7wkUXq+Xtl+11U0lSnOl8cZfb/DmX/opiHkJyZyf/W7nd6w5voZ9o/dplkBqoUED+OMPWLYMnnkGDh+WCWLeSWNcHHzwgWzVq4tfUJMm0Lo1tGwpCTQ2m0zyjMgbu132Hz0qBNOWLUL47N0rMdrXUPLYdnob7b9qr9mfKygkZybTeIIxYR5qCSXdlZ7r/vSqXmITY2kwrgHHxx7HZimaqnDTyU3c9dNdhu/RMv4vLDac3MCwOcOYNmia5v6CVB9er2xXShLTsGFC8o4aJclVWgTW3r1SHlqtmqSLPfSQkBsZGfKsBuoJlpEhm80GZ85kk7yHDhVM8k7YMIGxy8Zq9m9RIVFUL1Od6Tv1LQnuvu5uZuyakcs83OlxsvvcbrpN6ca6h9YZtpPVqslvqUcExcQI4VLY2PfigNUqScEzZ0ps/KVL+X9vp1MIvwkTYOBA8Tvq0UPae4dDfqNgwOWSc4eEwObNMGUK/PijlBnr4XDCYZp+3lS3LDPdnU7bScbjLb2+Md2dzq0zb+Wlbi/xei+dYJlCwKt6ufunuzly8YimcGDqwKmagR1fDPiCZYeX5fobvaqXM6lnuHXmrfw5/E//+u0y9aDfNvi9l9h2aBEte9+GM0uhzSdQrrXMEwubFFZQ0umMAhpEo/H18TlQ+x6o2g80Em6vwT8oagGtqKIog4G+qqo+nPXv+4COqqqOzvGeHsBsRCl0CnhGVdU9GscaAYwAqFWrVttjx44F6c8oPczaPYt/zv0nTo2JTs2Imnx5y5f5TAZzYsH+BXy19atcnQyAzWTj+trX89uw3zAVZkTgccLaYVL2VVDJV0RjaPQERA8DvBJXHCg8mUKmJO+Fff+TUjTVDUNz32cTN0/kmWXP6A68etTuwfL788dd+wunx0nUu1G6E7YQSwi7R+2mXrl62S/OtBmngw1ODI6nR0BqBvBH0XDvnHuZsWtGvtfL2Mqw+sHVtKjcQvezcUlxNP6sseZ3d3O9m/l12K+Fv+SiwB+ddDEv9X+7/VtGLx6dL+ZYQeHpLk/zwU0fGH4+9mIszb5opll+0KxSM3aN2hXwNaqqSvn3y3Mx42K+fTazjbQX0gzbIFVVKfte2XwrUiCrZ8n/STYeWJz7C1beJpGjWohsCn3WBad9KWjQUBCGFu1+eW3Fa7y/9v1cv2OIOYQ6ZetwIP7A5cmvxWShdmRtNo/Y7LdRrL/wer20mdSGHWd3BPW4WqgbVZf9j+/3mwjKiR07JOlm+nR5PDMz/Y+ULl9eorDtdtlsNplEZWZmHycuTiaD/iDg5uEKaIMKhL/1JMV0nRfSLlD94+p+eeIEgusqXsfux3YX+nMnkk9Q59M6+SZbxYnXerzGy93zuyJ89hk8/7x+TPj118OSJSWbCOYv/vxTSN59+2SS7jb4OitXziZ5W7WSrV49UXKkp2ffiqoqt6/vvyATf7dbCN2dO6Ws00fyxsXlPo/RLT1913SGzRmmuz/UGuqX4jHNlaZbJtuycku2j9Qm5EFI6o4d9ctgw8PFaPtKUX/5kJEB48fDm2/Kd5ySf33pMhwO6NkTrrtOCP3rrpN0u5CQ7L/bZJJNUWTzkZ2qKv8NCZH/Hjsmv7PvN//zT0lV80Hv9z6ccJgmE5pokn3BRjCIoP/8/h/GbRynqU57tcerPNPlGd3PTtk2hceXPJ5v7hRqDWVYi2F8ecuX/l+IMwm2PgXHZopPkF41R7l2UH8E1LxT0k19iaeBoqDxXKcpsOkxfRNFS5nMAAAgAElEQVRrxQydvxMRQ1ErNQKej1HkcWVJQVGULaqqttPc5wcJdBdwcx4SqIOqqo/neE8E4FVVNVVRlP7Ap6qqNjA6brt27dTNmzcX8k+5srAmbg3XT9FPBwq3hhtOvnxIcabodjK3NbyNX/7hp0GrMwlW9IOL2/UfGgB7RWj7iUTsmazFF3vuSgFXMmwaCd0XXH5ZVVUaftaQQwmHND8WZg3jfzf/L2DFSf/p/VlyaInmPqvJyugOo/n45o+zX/whRF96CHDnBbAHIdY70IksGDY6qqpS8YOK+eJ5QUiBSy9cMpzcqapK5LuRmsqSUGsoyc8n+3VfB4wrYAJW55M6HE06qrmvjK0MtgI6QhXV0D8gdkws0WWjA7hC2HpqK12+6ZKPSAYxhX7/pvcLPMZrK18j5kJMvtcdFge/3POLcUpY/Cb480Z51rVgCYPBF4PTzpQCCTRx00Se/u3pfPHrz3d9nmEthtH8i+a5BmQ2s41mlZqx+oHVOKzBicYqSQLIh0CIIJCJ3JYtohKaP19KYUJCRCGkNwkOFKGhsqKdliYT0B2Bfl1XQBtUIEqRBHJ73VT7qBrn084H/dhauOe6e5g5eKbf73d5XNT5tA4nU07qvifcFo5Zzx/DAEbjNoAtj2yhTbU2uV5LTYUqVYzv/40boUWLKzeGfc8eMbf+7jt5xl0uIWj9QWRkNkFgs2XHk/sI3sxMOH4cLhTgCeuD3i29Jm4N3aZ001V2BBN3NL6DOUP0gx569RJPND3fpFtugVmzroyysLxwuWDhQpg4EVaulN/LX4PoqCho1EhKyHyEfk5S3/d7nzwpSXTn/WhCtH7vkiSAfAiECBq9eDSfb/pc8960mCxUCatSYIX9udRzmsIDBYUh1w0pVBsJQGosbH8eTvwi6huj+WPZ1lCtH5RrL0KCsJpiFeJJl8+aQ/UVQ16PvE91S3rqrAJu+qEqHPwKtj5pLGqo2hc6T5VzW4uBUS1o3Pk3J4E6A6+qqnpz1r//A6Cq6jsGnzkKtFNVVbcpv9pJoAtpF6j2UbUSaXg+uOkDQ2YYkLrO37tD/Ebj8ovqt0KX6VLqZS6hUYY7FSzZS1ubTm6i57c9dVVAdrOd2CdiAy6pmLZzGqMWjSLVqW1wVsZWhgvPXcieyM8KB4/B6OyOM+CorL/fXxQzCbT33F7aTGqjSQrUjqydL6FFC2OWjGHP+XxiPhwWB8uGLeP62vrkZ9BQyhOwDHcGjreKN9/6yY5PXk6AKCoGTB/A4kOLNfdZTVa/SkozPZm6K/kdq3Vk/SP6PhdknIN5tQogUOMlYj1QlDAJNHvvbO6be18uVZxJMXFdxevY+uhWLCYLk7ZM4qmlT+VqzxwWB11rdWXJvUuKTKL4oKoqw+cN5/ud3+u+x2qyYjUXnmRzeVyGfVj/+v1ZMHSB3x5BRsjMlKScvXuzy7h8g3+LRSYIZnP26rCqZj/evhVk32qyxyMTFKdT1EP160ObNlJW1rixmJwGpcTiGglkiE6TO7Hh5IagH9cIH970IU930Un4zAFVVfnH7H/wy75f8nl4gYwzBjYeyJOdnizSdRxJOMKD8x/U7GcByoaUZfvI7dSKzJ1i8+KL8L//6XsDVagAmzZJyWRpG0QbweOR5/nPP+GXX6Rsx2aT2+zSpeJ5LMLCpI3IyBCl0ZYt+d8TezGWBuMb6FoNFAdeuP4F3ur9lua+uDho316ILT3y5PbbYdq0bKLkSkRyshBBv/8Ov/4KsbGiAnK5is/w36cIzciAqlWlBDgnEtITaDC+geFCW4glpPD9lwoZngxDknf+PfML7Vk6acskHl34aOGupQh4u9fb/Kfbfwr/wfTTEPs9HJ4sacmK2XhO5IOtLJRpIFtoLVEJmR1gDgHMQuB40mVumn4KUg7KlnHO+Li+8drxebD+AbE30QvwMdkheqiktIbVkWsP1hz3/zkJZAEOAL2Bk8AmYGjOci9FUaoAZ1VVVRVF6QD8DNRWDQ5+NZNAXq+X6h9X58wlPzXpQcDK4Su5IfoG/Tfs+x/seMn4gW04Blq9A5bSXXK4d/a9/LDnB90GtnH5xsSMzq9KKCwS0hOo+lFV3cltGVsZvrr1K4Y0GyIv/BSlX9ICcOtBKBME09diJoEGzxrM7H2zNffZzLZ86UBayHBn6A5uu9fuzor7V/h1mQGhlCdgJdFh14yoSdzYuILfaIDwt8OD4mehB6vJivMlA2JZVeHHMOPVo76boVwQ/I9KkARaHrucW2bcQpo7j/myJZTtI7fToLyIXVVVpdd3vVgTtyYXoRJqDeX2RrczfdB0zfp+f6CqKk/8+gRfb/tas6TQolhoVbUVc+6eUyR1nqqq/HPeP1l9bLXmyqLD4mBw08FMHTg190C6ShU4G5zkDy8KyURwgQqXt4uUxY0FD2ZUFCy4MeMhikQqcIHyxFOBC0SRiNnI6+nsWahUqegX93cigVbdnTUwDhEPP7NDPP/s5WXQHF4Xwuv4vZL6/Y7vuf+X+3X7cavJSpitaExcUkaSrorDZrKx67FdusmLPvz3j//yyYZPdJMda0TU4MDoAwGp9bTKRH0wK2ZqRNRg+8jtuUpDPR4YNAh++01/8lyliviztG17ZZaGacHlkvKtmBgxbd68WUrHzpwBFQ82u4rNYrlcDpS3JMxH8kK2wsjthooVxXesbVtRSPl8xLQM5TPdmUR/Gs2ZVP2xeZg1rEhtZaoz1ZAUWP/QejrW6Ki5LzZWTKwvXtRXBFWtKnHx3bvL36aVuFgcSEkpWjlaSkr2b7xrF+zYoXLooJcL8SYsZi9WiweL2QOoeL1K9u+NCF0UBUyK/MPjNeFyW3C5TERFealXT6F5CxMtW4qaqH17MSnPCZ8J9JGEI7g1yphCLCG8dMNL3N/q/sL/ccDZ1LN0n9pdUxEP0jcWxiy6oMqRYGPR0EX0b9C/6AdIPQpn/4DTy+DcKnAmCKnicRacpBwUKDA0x/PmTIQtYyFuVlYirUG/H9EI6jwAVW+CMg1FmeTJkL7PXAifXfclKZP7uazx+/7OJFDWAfoDnwBm4BtVVd9SFGUkgKqqExVFGQ2MAtxAOvCUqqprjY55NZNARmVGxQWLyULCcwmUsWu01ol7YGl740lYwyeg1VulnnCVlJFElY+qkOHWbkRsZhv/7fZfzXr6oqD1xNZsP6tfs922als2j8i6D+dUFZM0PfRYLDLIQFHMJFDku5GahtjBQog5hPQXSyDruZQnYF2+7sK6E+uK7fg+eF7yFM73KwfOpZ6j8kdBUKcVgD2j9tC0UlP9NyxoJCmBeug0FeoOD/xCSogE2nZ6G92mdNOsu3+n9zuM6Tgm1+unU07T6LNG+QaMYdYwRrQdkbvs1E8URACBqA32jd5HpbCiEx1JGUk0ntBYd+IUag3lziZ35iaCroRcY38RSBtxpZFAXg8k7YLza+DCBkjZD/dshsQC6jMigc919plsMjBWkRVbc4gkhJapD1EtoWJX6fdykIDrjq+TaGO39n1ZxlaGw2MO64ZiFISlh5Yy6MdBmve9gkK1MtXYOWon5Rza6sJvtn3D6MWjdT0BHRYHv933G11rdS3S9fng8rho9kUzDsYf1CStbGYbLSu3ZNUDq7BbslelnU7o108/Uc+H4cPFiNdqLRnfGF8KWKBmzjnx+oo3eGXZe5jSKzOx90/Usrbh4kUheDweeXzMZlEDRkWJsq9CBflvRIT/TY1X9XLnrDv59dCvmsqvEHMI9zS7p8jKr2NJx7j7p7t1F8ci7ZFsfXQrdcvW1dwfFydG21u3GpcDtmkDzz0Ht94q31FxJHA5nXLs48dFlTZxYiE+7HVD0m64sF7IgZT9kHYCMuPBZMWLneS0MOITQ4lPjSI+pTyJaVF4vGY8XjOqqmA2eTCbPESGJlE+PJ7yZS5SLiKdqDKpmMkUVbE1CkJriLqkYleo0AnKdwRFMUwBA1H59a3fl7lD5hZ5AQbg9yO/c9vM2wzbkVmDZxWoCDqZfJLoT6NL1JfMpJiIeSyGhhWMyXK/kX4WEjZL2nTyfryJe/Ekx2LOPI2qgstrR1UVaQUv94lq1pY9bvARgBZTJibFg8dWGXOZaExRTSCyiSxIlGsj6dRaSNgGu1+HU0uyZMF+EFIhlSGqOUQ2gwodpV+zlpG+z2SVcjavSzxhPU5wxkP8FkjYJPf6+TXGx/+7k0DFgauVBFpycAkDfxiouWoKUN5Rnrua3lWkhmffhX2sOrZKk9U2K2b61e/H/H/Mz3/svwbCifnopoBFNYc+60tdAQQwfsN4nv/jed1JTZg1jLUPrTU0Li4MPlz7IS8tf0mXdHJYHGx9dKtEfS/tDPEGZS+t3oXGzwYe3VGMJFCqM5Uy7xT/aPH42OPUiKhRvCcp5QmY7Q1biZR7/nDnD9lqtELi1RWv8trK14J8RfnxWLvHmDBggv4bVt4OJ+fr72/4uDw/gbZBJUACHUo4RPtJ7UnMTMz1usVkoUO1Dqx6cJWmvPynPT9x/y/3a8a2v3zDy/z7+n/7fZmqqjJmyRi+2f6NblvpsDhYcu8Sukd39/u4ethyagvdpnTTHeyGWkMZ1GQQ3w78Vv72ayRQcI7vD5L2QtwcOLUQLu6QVU3VY7zoEzSYJIL3rmyF7LHEY7Sc2FLTSB6kDx/XbxwPttaPY/cHd8y6g0UHFmm2wTazjVZVWrH6gdX5yiCXHlrKHbPuMAyFGN5yOBNvKczMVx/bz2yny9ddDCeK/er34+e7f841dnO74f33xXw3M1O/VMhmk9StJ54Q010ILknj8YjPC8DUqWJeffBgcI79xso3eHfNu2S4pbQmzBrG4nsXc0NtA1V7EfHMsmf4YvMXuu1ldGQ0+0bvy0XGFRbvrH6Ht/56S1N5a1JMVAuvxvaR2ykfqu0dqaqSvvXYY9kJWHoIDYU77oAhQ6TMtWrVbOWYryzOH6Sny/0VEiLkz/79sGKF/NZ792Zfly5UFRJ3SBt0coGEvpjsWW1QAeEzwYIpRCbsdycRnxZP5687czTxqO74rHqZ6sT8K0Z70byQeOGPF/h0w6e691WoJZQfBv+gSwR5vB5JkjNYUIwKicJehNIll9dlWArXtEJTto3cVqB3pRGcTlH4rV8v3lYHDoiP08WLUqpntapEhcRTOTyWMHsKNovz8mY1uzApXjLddpxuGy6PFafbRlpmGGdTo0lIr4zbrZCRIWRntWpS2t21K3TuLP/V7YLTT8Phr+HQV1JW5m/pWnHgGglUeFyNJNDB+IO0mdRG12PGYXGw/uH1RSYwVFWl7SSJ/9VaVfKZkb7U/aXsF91p8HN5Y3levx3CgJZy7qiqqtT5tA7HkvRT4SqEVuDcM+cCYu9z4mD8QVpObKk7QLOarDzS5hGZ4K5/CI4Y+OXUfRDafiqD4kBQjCTQuPXjeGLpE4EfvwAY1cAHDaU4Adtzbg/NvmhWLMfOi951evP7P38v0mebfNaEffH7gnxF+VGtTDVOPqVvrsrOV2D3m+hKdMvUl3boCieBTiafpM2XbTiXlr9WPcwaxvaR2w3Jz7t+vEsiXPMsEjgsDsb1G8fDbR4u8BL9IYBCraE82+VZXu3xaoHH8xfjNozjhT9e0C0tzEUElYQxfLBQzCTQgP4qbreoNXwGqCEhstWqlXurVs1Pn5f0s3BkChz8AjIviJGmkdcfQEilbF+GiMYQ1UJeM9mzAyBUrxzH65IJXPI+SNyV7dGQekT25UXWc5OcmUyria04lnRMszTGpJhoV7Ud6x9eH3Affu7SOeqNq2c43hrcdDDfDvz28rl2nNlB12+6GpbHVg6rzOExh4tcqqYFvbQfH0KtoTzW/jHNNMl9++Cee+Dw4WwyRg/16sGAATJBattWTHczMuQWDw8vmBjwEQIOh5xrzx5YuxbWrBGfF1/iVzC61ddXvs57a94jzZWGWTFf9ugpDiLo842f8+zvzxoS5ivuX0GH6h0COo/b66blxJbEnI/RVn6ZbDSt1JS1D641LDNMSoLPP4cPPxQyyCh96/KxbVIa1ayZpK116iTEkM9HyGrN7ZV26ZJM3jdulHKt3bv1zZc1f++0E3DgcxkTu1OlXTBqg0IqQ3g9iR8Pry/tT0RDed2ntlCy/PFUt5BIXpe0bykHs9qhA5B6GFIOi3dMnu84fuCFAgkgh8XBuofW0bJKy4K/VD/g8Xro/HVntp3ZpqvkMVIEjV48minbp2jem1aTlX71+/kf/qOBB+Y9wA97ftBc6HZYHAxsPLBQJemqKl5bs2eLKfiBA9Kvud3F5/2UF74+NMnAnSMXLh2H00vh+M+SVospmxQqbm+wkMowqOSsYYqCayRQEJCcmUzzL5pzPOm4ZuMfYgnhwVYPGq+W+4FdZ3fRcXJHw1Wln+76iQENB8gLcT8JeeHW6UXC60H/nVeECmjt8bX0+b6P7gBNQeHhNg8z6dZJQT1v9Y+rcyrllO7+cGs45549h+PwRHHI1+voKnWHG+aBLcDo52IkgTp+1ZGNpzYGfvwC0LBcQ/Y/vr94T1KKJNCohaOYuCU4K8UFIcQSQvp/i9a7ml83G/oUBBOul1z6JsdHZ8LGR/XbIYCBcRBaM7CLKEYS6FjiMRqMb6A7uDQpJpSCYjvA0JD05Rte5rWe+sotfwggq8lK++rtWfWAtiKpqFBVlVtm3sIfR/7QLXnwEUHfjfoNJUieQMWKypX9ypNPSZGB78aNYn568KB87EBKFaqg/3eeoTJV0T++xZLt7+FyyYQ9MlImb9ddBz16wCOP5CCGMuNh9xtwaBKg6kvdFQtUvB5qDYaqfbKeK1W8EhRzVkKLn0SdJ0M2xSw+Qc4ESNwtscEnF0qJ9FAVj9fDjd/fyLrj63TvD4fFwfaR2wv06/EXk7dO5slfnzQkJl/t8SrPdnmWE8knaDmxpeHKuMPiYNHQRfSs0zMo1+dDpjuTxhMaczTxqO57Qq2hfNjnQ0a1G5Vvn6rCsmViGr1nT8ER7D6YzdCwoXjltG0LdevK/eZwZEetZ2SI4iQpSe7xHTuEFLh4Uf+4gXarOQkgIBcJBMElghbsX8CQn4cYjpkfafMIn/b7NOBzgSwQtf+qveH5etbpyYJ/FGyo73bDokUSx756deHSt4KJXL/3pTjY9ao8/z7SWAshVaBaf6h1F1S6AVCkjEsxgTnM//bHB69XiGnVnU0axW8SD5iTi4hPjqVzYgNDAsjoGQsEp1NO03RC03zq4JzQIoImbp7I08ue1u3Lw23hHHr8EJXDi17Sn5iRSN1P63IxQ/uBDrOG8eINL/L89c8bHicuTu7DqVOlzcjMlHZIC4oixvV16wox3bAhNG8u3l2VK0u/5yvxBCEnPR653y9cgEOHhJTcv1/I78OHpTQxr19Wkdoh1StpZ4m7cJ7fifPUesype7B44jGTjttrw+21ZZeu+U6UNd9QAJPixWJ2YlZcuAnHbamEN7IVITU6YSnXTKprHFWvGkX0NRIoQHhVLzd/fzOr4lYZJkEcffIoEfbAC3hHLx7NN9u+0e1kwq3hbB6xmUYVGsGmf8FBvWJ/oPHT0PLNwplhFRMG/ziYOTFzdA0fI+wR/HzXz8Zx1EXA2F/HMn7jeN3JWbgtnM/7f8595SNh3X36UdchleD2Y4F/l8VIApVUCZNJMeF5uZgZ9lIkgap+VNXQXDLYOPbksXwpMgVheexyen3Xq5iuKD+mDZrGvc3v1d6ZsE3SCY1IoNYfQKMnAouKLyYSKCEtgRr/q6Hb5gYTEwdM5NF22objP+7+kSGzhxBmDdMk3FRULIqFmNEx+j5AHiekn4BLx2RLPSqrq750jsubWwbsJtvl2vgkLzRZv4xUjweTYpb9iglfZq1H9ZDqTOWL/l8wsv3IwL6IUny+nU4piZgzBxYvFsLH4ZDBr7MAwQ0IkRMWlr0CbzZnm9k6nTLhNir18MHhyHqfqsKBCbD931kTLx3yJ6IJNH1OyB+vRzz+Akyf04UrVY6dvB/KtuRfi/7F1B1TDdUuz3R+xpDkLCxUVaXDVx3YemarLtntWxj7dMOn/Bn7J+E2baWuy+virqZ3MXXg1KBdX05sOrmJ7lO765ZeOD1OMj2ZHB97nGplqukeZ+9eKcmaPTubEMgoCR/WLPiMm4uKvAQQCHFtMVlyta/BIII2n9pM96ndde9JEBXroccPBWQAnhevrniVD9Z+YPgsPNjqQcb3H+/3MTMzhQiaPx/mzYNTp6QkzO32ry3xFxZL9nFVFbp1g6VLkX/s/wR2vCBti6ozjqxyE7R4Hcq2EiVPcURy54T7EqBw64wBLI79i3B7uOZijNvr5sa6Nxr7AHkyhOS6dFQ2n+LIk5HVJ2YKka56pO0z2WUz2/gjMZFbty3HZrZm9Ym+smg5V4Y7A7fXzemnT1MxrCLLY5czYMYA3TFFmDWMj2/+mBFtRwT8Ff2892fun3e/LlnusDj4YfAP3Nbotnz7YmPhlVfgp5+ylWRaqF5dVIhDhkCXLtJGOJ3Z91NhC028XlEWuVxyDLtd/LJ++EEUSIcO+df9ezxCbK9dK6qlffskRe70aTm+w5G9COPMdFMuLJ6KEeepGHGeEGvGZX8qj9eM22MhzRnKuaRKnEuuRHJGFA6H6XL/np4ufX+1alCnjpjUv/felc8FXSOBAkRBUt8waxiTb5vMPc3uCcr5kjOTif4kWpfZVVCoHlGd3aN2E7l5BMT9qH+wdp9Bw38F5boCQUJ6AtU+qqZLooE0VInPJwZUv6qF1XGr6T+9v67LP0CLSi3YMXQmLO1kPJG97YgkqASCYiKBDsYfpOFnQTKB8wMFJtYFilKaJDrdTuxvBSla0k880/kZPuiTv1TACEN+GsKPew2e/SCjd3Rvfh+uU7bm9UiCgtGzU6Ez9PwVrAEQ5XOqQEYAChSN5ybDnUH1j6qTkKGvIAg25tw9hzua3JHv9aSMJFbFrTL8bLNKzYiOipbVrnMrISlGfBpSYyHtFLiTwOSQQazXneUd4/+s7qQbtjktWeVDZE8GbGXBXhEc1ejUYzIVImr7/wdroRSe79274Z13ZJJlsRivuteqJQqLOnVkhbNpU/n/qlWzB5W+OHvInXBktcrE/dQpWeXcs0cGtbGxMtCNj8/xJ3pcoqI7NkvfY8NRFdp8CtUHZBF2xUT86KCgFW2A2pG1OfD4gaD33/sv7Kf1l60NCdowaxjTB03HPPx+SNRerTep0CsWQorRm3VLVThtMCe2euDmVP/UaaoqE5qFC2VitGuXTJQURUp9gqUWCQmR46alQdmyMtH7xqAq3ghaBFCoNZTxfcez6OAiFh9anKtsJcwaxqKhi4rka3Y08Sitv2xNYoaxOmPZfcu4vlZwU5lcHhfXfX4dBxP0zZNCraG81eutIhtRJydLu7F7RyabN6SxabOZU2csJCVbcbrNhFidWMweFMVnvutDFmHvNeF0WfF4zZQJc1I2yk3Txi46d7HQok0YzZqbqF07a/LuccLaoXDqV31flTL14fqfpbogUEuEIiDmfAyHLx7W3W9STPSM7ilkn9cFiTvFvPrMn5AcA+knhVAyO0T16HVl9Y3+9zGbMxTOqDb5vOoR4sgSLgmL4XWxlmvFzV3e48DFI7Sb1E53zqGg0KZqGzY+sjEoal5VVbnx+xv569hfuiVrodZQ1jy4hlZVWmV9Bj74QAggt1tfedivH7zxhvR/Hk/xpxX6CM8TJ0RhpIUjR0RBN2+eeBXlVNoawWwWMqtmTSGurNb8izgulzx7cXESLlrQEKS0w0H9wTUSKADM3jub++bepzsAUVDoWKMjax9cGzQfG4BZu2fx0PyHdJldu9lO15pd+b1BNZSj0/QP1PpDaPJ0cC4qgAnYhxfh5USH4UCuX/1+LL53cVGvThcer4eo96J0vQVAGsiND6zkuhWdjGtIW38AjZ4MbBBeTCTQ2F/H8smGTwI/tp+4t/m9TBtkcO8FilIigb7Z9g0PzX8o6Mc1Qu3I2hx98mihPlP2vbKGA+Bgo8CytdX3iHRbF0pWSVgxGooX9GzleW5UVaXFxBbsPrdb9yMhlhD9Mjg9qHDJdUlX9aigcGTMEaLLRvt/TGcinFosIQBn/xSfBsUs/zWEInXrYbWFyPH5wygWUZ2ormyyKO0EpMUVnLgRDCPEEny+16+H//wHNmzITkDKC7MZevaUlc7+/SWpyOmUCXKgRrw5Vz0dDjh2TAaws2bBlgkPGhNA5dpCz6XZaSYljKSMJMq/Xx6b2WaocjFM23KlQNpx8W5IOy4KtZSDorr1eY340llQQbFl36cmKy8dO8bHJw5iNVmz7pvcCrU0VxrNKzVny8itxfIdBB1FuK89HilT3LFDiMS1a2WicvGikEI+bxi9x8rtFrWJyST3dsWKYjjcubOQnS1ayOtFxWsrXuP9te/nIoBCLCEMbDSQmYNnkupMpcmEJpxMPpmrXQy1hrJ46OJCE0E3fX8TK2JX6Ho7ubwu7m1+r669gMslBrfHj2dvvjJQpzN7QuhrL3wTRt+WEbWNNU26YlVsmExc3nzfv8vrIt2VzomnThgqvy7DnQYXt0kJ1NnlkkqUflbUKeaQXMRFpsvK+eSKnE+pSFJa5OXkLZPJi1nxYLdmUqHMBSpFnCMyNAnFbBNFi6Jkq0Bt5aRPqNhN2paY9/XN5iteL+m4hSkzLUmoqhjoH58jvjDJ+7LMq936f5MWfMpYxSzfkddJYUgiLGEk3BpHiy9acCrllG7/nyuQJkiIS4qjyYQmhkR9hdAK7By5k3K2qgwZAr//rp9U16iRqBFr1SqZZMKCkJ4O06eL8ubkyezXtFC5svTlzZqJWqdePSF/oqKyy9xyVIChKNlNsu91n8r3wgVpGw4dgpgY2LZNDLJ9Pl7XSKAi4moggXaf203HyR0NHyqHxcG2R7dJaVYQoaoqXb/pyoaTG3Rl0CQ94zwAACAASURBVKHWUOY1bclN6Zv1pZs174SO34AtCDmTRSQvVBVqxsJJA24l3BbOFwO+YFiLYUW8OGPc9eNd/Bzzs+5+s2LmgdYP8FXmbHAaFMtXugFumA+2yKJfTDGRQNGfRBuabgcb5R3lufDcheI7QSmRQN2+6cbq46uDflwjKCi4X3L7HRVfUilweWFYtnZ8Hqwfrl9OCVDnPmg3ofgk5IUkgcYuHcvEzRM1TRUtioV21drxrw5FU1IeiD/Au6vf1SzPVFCoXqY6Wx/dahyjraoyIdjzFpxfLQNbPbWVJUwG6+XaQWRTWbkNrQn2ClkD2pwqzLzfU9b34vOF8aRJ+kZqrKyiJu0R1VHKIXnfVUICud3wwgswYYIMGLUOFxoqK50PPiiXVKZMyWQouFzgOreT0NWd9Ccq1ki4/WjgPnQBYu3xtaS79CdTFUIr0LJyc/ESOvcXxG+UEsS0E5B5XiavZodMsoqwAu9RYU0GuBQbKFbAm21gbY2EkApUj6xH477BX0S6GuDBRDzlOUtlkonAgxk3Fkx4seDGhpOKnKcS5wjDj9qis2ehkk65qQa0CCAFhdpRtdnz2B5CreJJuevsLjpN7kSaO3+CYmGJoEMJhziWqD/eMSkmutbqyoWzNlatklKr/fuFODtzRiZxDocoAn0krT8+TLlQcQ+WsmewZXGTLje4XRBeBsqVgyqVLCyb1F17Eq164cIGODEXjs8VYtTikHIkr75i/jLs5YXIMeUgTHMZv6dD2kkhQgqCOVSfhDbZ4fZYUSNeaXAmShntoUkFG+grJgitnWVcXQ8iGom3S3g9+dtMNkDJWgT2AqbsJEZ3uiiJUg7CxZ2QelBKyVJ9BtYClwrd0juy7cw2nB7t6wi1hjK201je7PVm0L+Oj9d9zMvLX9YVD1hMFhqVb8Rtp7bxycdWXRLlhhtEaeMrpSpNOJ2SoPjJJ9J/65nnt28P994LgwYJwe10imopmH252y2kWUiIqJGmT5dru9JxjQQqInpO7cma42sud2B54fK6GNVuFB/2+VBzv9MpjGVcnGzHjkkn5Ftp8G0ul6w0WCzCPPpWdNyR+1nfqjVWk6w0KCYw51hpcHvd1FUusb2uA5PeINLsgDvjpXMJFEUkLw47of4xiLTrEycZ7gxOPnVSN1ozUMyNmcvQOUN1YxjdXjdl7GU43bYtnFqkfyDFInG5gRhtB1rSAvkmYV6vF8sbFt2Vh+JCxn8zAopcNUQpkUCR70SS7NQnMsxK0XpFr+o1/H3WPbiOTjU7+XWsj9d9zNPLgqTwKwSe6/Ic7930nvZO96WspEKDAaxihoHHi29AWQgS6N3V7/LGX2/okvwVQytyaMyhgHzexv46lklbJ+kmg9QvV58ND2/QjrI9MR+2PCmTaD21T2gtqH0XRP9TEqE86cXjE+NKlefRkyntY537Aj9mMT/fHo+sBm7Zou+p0bmzeCGULStkUIlj02NwcCK6hEjTf0OzV4LTfxcHUg7BiQVwYh4kbMoukzBafTfZRQ0YWhPCamWlB9myPTh8BrNeV3Z6UFpctpLIKJb6qcpCYFxD4PDz2dMigEAmu5se2UTTik1zvf7Vlq8Yu3RsvolqqDWURUMX0SO6R0CXnZgoHjdz54rvV2KijKeNErhMJqhSRcpEatYU1YCvXMSnCMg5Xk9Jya0gumCwFpbva0w/AzEfwZGvsxWYekRNSCUo3xHC60KZRhDZGMLqgKOK7Pc6s06QpxzMp5Yzh4ArUcjYlIOQuAcuHRHVzMVtQhqBEKkunSim8h2g57LAFj6DjcwEiPkA9o8HvPrtjb08VLsFat0NlbvLd+UznrYUMR3Q68kysPZIu+XJkD7x+BymxizigTMuIuwRmr5FKiqR9kgOPn5Qe9zsdQmp5FNMph2H5APZ6lyfWtLryrpnsogqxQomGx7FQvPtWznhzMz29EPJpZpMOh+KdcIxXJna3ox2u3jqVKlStK8nmIiJgYEDpTRMrw/v2RO+/VZUPiEhfqZvBgkZGXLOKx1GJFDJFpZfZZg6cConU/RjkU2KifbV2qOqIhXbtEmiNlevFtInOTl7pcHjkZu4cHXcjWD1Tog4h90uzXyGR1YaypSB2tWhVWszim2wGIFqwZMuxtENRha90QsQ9WyweTpkZujn/VW6BOVfqlBs1zAQWFUNnGb9ModKly5B51Xwz3D9SZfqlijC6rcVXRbrT5xgIQm3pYeXljgBBDBt5zQealOypVPFiQtpFwxLFptXas7GR4qWvjZj1wyeWPIEqa7895bNZGPFsRV+k0C7z+qXL5kUE40rNKaMrfBqmzRXGnvO79FVH+45v0f/w5YwqNAxK6JTB6oHdvwX2n5a/IaSBpi6bSqvr3zdMOFl1uBZARv9v3vju/yy/xdiE2Pz7XN5XcQmxtJnWh9WDF+RPSh0pYpHzIl5Bh4x1aHTFKh0vQxsfaR0kP1YLsPnAWEJg9pDi+ccQcZnn0nZjN7g8frrJRY7rHS6RYEzEUNFTEjl4BFAAS0+mGBolpTXnS4+hHvfh0tZ97XWJEwxQ9nWop6t2kdW3EMqZakO0qUtUMxZ5qtm+f+cUD1ZhJJT+l3FJItaXidknBPlxJnfRaEWv0mIIz+8dgxREgsPV7qLaCGgZ5Acag1lQr8J+QgggIfbPMzSw0tZdHBRLgVmmiuNATMGFIkIUlUZe3/0ESxZkp/0ycyxLlG7tigd+vSREriqVYUE9pE8iiITYV/CUc6fy+vNNsTN+V6TSXy+Tp6UhMHff4dVq/KQQ5fiYMdLcPzHLDMxncWScm2lja05UNp5T7qQOVqBJP6ElNgryFa2FdQYlNWnqPK8nfsLDoyHcwY+dOmng1eGGow26MzvsOpOaQf0ypbLtoFWb0uib7DNq01mMOU4niUUou+F6rdxVzsnDeP1faIAGpZviN2bDiez2q6LO4TkST8D7mQwhWSruowIQg2YgbVVYK+TrHbVlKUOS5f20xbFhtRbeNVuwqVz+7VsGXj5czBw8iR06iTPsVaTa7XC11/DnXeW0gIOVwcBVBCukUAGqB1Vm9pR2uaX8fGwYAG8NkvqA32GkHlXG7TqLUNDpSMqKF0kLg6cCfXxJNTPJ+BNQkqG9/0G3+0YJeUCehOGHS9A9VtlEBZIPW9I5SI34G2N28VihwK000+Jz8aqZBhWQIe35y0Z1JpKc/aQG7/s/8Vwv81sK5KCxat6Dc28Fx9c/LcigZYdXkaIJQSXU7uEp1edXoRYitbyd6vVTZeoc3qd/LTnpwJjPH1YcWyF7j6TYmLjwxt1vRKM4PF6CHs7TPc333ByA6qq6vufRQ+D+C365pIAsd9D81eEUAhixLm/WLh/IY8tfsyQALq/1f1BiZG2W+zMGTKHLl930TxfhjuDHWd2MPjHwcy7Zx5mxQQrbxFDS71JQp3hYvhvshUf6WOEK9ETQgOvv67vdwDw5ZelTACBTFJOzNd/XuJ+hvojgrOAE5D61Csj8YNfwvZn5SWthRLFDDUGSjtQtU/Wqrst/2TV5MekTMkihvJOQE1WCWcIryNm855nwWyXcsmrAZWvArVS5YIjqx+Z/wjf7/w+X19hNVnpUK0DNSJr8PsR7SCB4S2Hs/LYynxluGmuNPpO68vXt33NvS10kijzYOtWGDo0Wy2gqrlJH4A2bWDYMPH7ioqSRdm8JVq+lCMj+Hx/tN5btapsrVtLWYpPUQFIude6fwppoTepr/8oNHtJVDlme3aKpo56vUjIS2BU6wcVusAfveHiVjQJ6bTjcOQbqHt/4O1QoG1QzMew80WD8tkI6DwNqvTOJpdLIhlZMYEtkjAbdAnVKO/2ZMLZFbKws3WpLNqbHbLgkze0wZMGHsj28qslqsnQmlIWbLJn3R+2LJI8M4sQS4P0U0RdOk4Xn4ooV7/iAc5jsW/H49Hvw0+dKlk1jR6GD89+nrXw1lulSwD9XXCNBCoEVFUY/tdfF9WP1apfn2g2S41iixZQv744q9erJ9FyDofUHxupgsxmeV9ysnRuBw9KUsCRI7B5s/w/ZB2jyTMQ+x2kHECzEfc6YeUAuGkNWKOKPnEoSMESDK+b0kYyYpaXYsBaJWwR74MKHUvssgrCnnP6Cg272c7ah9b6Z06YBymZKTSd0BS3zsBlf/z+Qh/zSsbsmNm6iQ7htvCAUkbql6tvqNbafX43KZkp2qVBOXAq5RSnUvQZzZoRNYtEAAGYTWaaVGjC9rPbNfenudLYH79f39CwxkDY8oTxSVQ3/DUIbloVWFllEbAmbg1DZg8xVHtVCK3AR30+Cto5W1VpxfPXP8/7a97XrNVPd6fz59E/GbFwBJOvuwElfrM+AVS+PbT/vMS/t6sRen4HPlQoPuGp/6j3EOx9V5+turBW+vY690kKTWnit67ih6FHWFW8HjpNhZCKgSUAFgZme/YkucqNJXPOQFESaiUoVsfSHlN7sPLYSs19bq+bbWe2MfjHwYbH8OgEcGR6Mhk2dxjn084XmKz1yiuScGRkEPvZZ5Jw5FtwLW6YzRIjDdC4MbD3A9j1qoGqsxp0nSnqlVJI3cIWCV2+g6Uds+LYNe6bLWOEbGjwaLa3V1EQwEIyYEwA2ctD361ZasMrRKKRchj2jxMSDVMWcZ418cvpFWivKO1nlRuhYhdRgNnKZvk7OQElq60z+Ltylqn5vP28GaKaTD4Ap5fAuVW0r7eFpk2lTFprDnriBEyeDA89VLqLJGvWGHt0PfDANQIoGLhGAvmJuXPh3/+G06eziZ+8qw1lysAdd8iKQ9euouqxWITMyWtO5W9nVK6cbC1aSG1kWlqWAZ0LfvsNvv8eIXVumAe/ttXvaFIOwZJW0Hu5+EiUtMdAJCJfutJRuTLUHAwxH+qbbQPsfAm6zS7VkhYfnB4nm05t0t0fYgmhdZXWRUqvqxJehcrhlXXLIg8mHCQpI4nIkCuoXryI8Kpefjv8m+5+l9dFx+pFJ/4URaFF5RasP7Fec3+IOYQ/Yv9gYOOBhsdZdngZVrNVV63TpWaXIl8jQI86PdhxdocmYeVVvSw5uESfBAqpCHXuz/I70DFoBFl13P0mXPdCiQ18d2dC3+l9CzT6n333bImZDSJe6PYCP+/9WbfULs2Vxg+7f+Bx13paGamoag+9RgD5iT59YPFi6Su18OmnYhpdqmogk0X6kT96i+G31sR402PSf7d4I2twX0RlQKATsPgtoOo8002fh2YvllrJ+TWUHIwIIBDfk6TMwAd7Y5eOBdAlgmbOhA8/1CeAmjeXiaTNJqqcUkHSPtj1ij5xYQmHfluzDJ5LUX4R2RT6boE/+0gb4c1TZqV6YdvTcHw2tH5fSstM1sKXiQW6kGzkNdbmf1cOAZRxATY+Aqd/FXJGay7hqA51/ikEf3gdIdkseVIJTBbAz/4+r8oLwBQu7sjhdUV1qrpQUPiuDXToIGsPWkTQ2LHid/Ovf2nPX0sCFSoIIaWHmBjx9LNcYzECwrWvrwCkpcHDD8Mvv+h7C1SsCJ9/DrfcIgPO4orTM5tzH3vwYLj55qx/RDaW1J3Nj+k3lOmnhShq/ZE0PD65ZEngcwJPlCkpo+Dz6+DAZ2K+pIczv0HGmSuCBFp3fB12i12XFGhZuWWRCCAfOlbvyJx9czT3hVhCWHF0Bbc3vr3Ix79SsPX0VkOljt1sp0ZEYPHmvaJ7senkJs1V0GRnMnNi5hRIAs3eO5tUp7YEMdQaGrCxZteaXfl669eaiqgMdwY/7/2ZsZ3H6h+g2YsQO6XgE+19R1a/KvcsEVL6qfOQ7kon3KZNOrk8Lp7s9CTtq7fX3K+qIpWOiYEDB2RB/9QpWRg4dw4SEmRhwOORgZXZLIOn0FAoX95CxZo/Y2rSGovJdLl8OGeksNvrZuHpvbSoYMekpwS6uF0k5MEgzoLlEXOF4ssvoWFDWU3U6hbefx+io6WUpFSJoHJtoP92+KOX+EJoLeTs+xiO/QAt3oToe8RQtrB9T6ATMD0CKKy2lLFcIyf/9ugxpQcr4/QJoGBj7NKxqKqq2d+MGaM/JgeYNk2e69KYwF7GgXH6vjUADR8HS0TpEkA+RDSEAbtgx4tw+KssL5k8/dCFtfDb9RDVQsrDag4WBY7qLR0VU05U639lEEBn/oRVg2QeprUQZrJCk+dkAUwxZV9zcV+7xQHIOKtxYymj7NNHxi8ZeW5Rr1dED7NnSyR7+/bZJuklAbcbxo+Xskq9Z3z4cKnICQ29MjyMrlZcI4EM4HRCu3YQG5v/IfHh9tth6lS5Ce32kjWKMpmyZacA1LtfpJ1rh+krgtyXYNNIODgB2o6T5AFFuTIazysF5TuQr05XCxtGQI+Fpb76uejgIi45tdUDZsVcqNhVLXSP7s7iQ4s1Y7RTMlOYf2D+34IEWnhgIZluff+jNlXbBESmgah0wm3huiuliw8uNvTc8Xg9LD+6XPf4ZsVMh+odArrGDtU74Pbq63A3n95MuitdXy0TWg2i74MjU43VdACrB0P3hVJaWczP0Q9VIWHAPt39JsVEnag6l/994gQsXy7mwZs3S7qjySQDIaez4HKjnDh4EFjfEEKPoTgSCQkRkigzUwZXtWqJl0T1+mkolhslEUwLsd9B7buh4g2BD7oD9We4wlG5sigBBgwQki5vH+52w4gRkg42fbr8riUVD5/zGiwWhEjpv1tMWne/KSWTeRdz0k/Bhgdh61ioOUjMSCt2lRVkxSyGy6Ux47VGUZi4d0P8zYnJqxmvLH+FVcf1DYQdFkeR0l1VVeVM6hnd8rB///5vWlVplc+jzZ9yz1IlgCDL88Xg2bCVvbJMl61loN2nspCz911JLlTMolLMicSdsPUp2cKipYwp8rrcket4pW3KmU7lKyNTvYCaxc57s2PuA0HKIbCWDfxHD0Z6rx5Mdui7Wb6zUibN69eHXbvg5Zdh4kQhfvL2kRs3SvrWddcJ6TJ4sKSGud3BJ1h9FdEpKVJ58+23Uu756qvaz3psrFisjBsn3kA+M/drKByuRcQb4OWXJW1Aj4kcMABmzboCzCXz4vw6WNFXCB+djvUywqKh/iNQf6Q0woqpaJMxrwd+KOAJvFqUQACbH4dDk4xLWkA8EGrdHXwlQyGirhuNb8SBhAOab4uwRzDzzpn0b9C/yJey7vg6+k7vS3Kmdmx6lfAqnH76dJGPr4sSjohv9nkz3fQri8nCK91f4cUbXgzoHOcvnafG/2rg9GjfV3qxuj5sOLGBm76/Sde3yGa2cemFS1gCiAhXVZXIdyN1zxFhj+DHwT9yc/2bNfcDEkk7v0F+WbkWFAt0/k7M6wMlNgrx3OSFxyORwtOmScRwQoKx71uwoShCQiTFboHl/cGVrP/91blPlJ+KueiDyUAHu1dJe56aKqqBmTO1TWNBBo833giPPAJ9+4qi1+EonpVPX0qo0wk//ggjR+Z5gytZIqQPfCa+EW6DiaQ5RNKEyjSAiMYQ1VJW9B3Vs1bynfqfVUxCHLkSITUWlhZEHiv6x+qxWMoNAp3YBOoreJXckwGhFDyBXln+Ch+u+1CzlFZBoXZUbfY8todQa9F+/93ndtNxckfdUt1QaygL/7EwFxH01FOi9tMbn99zj3iblOr4/ORiWH2X/qJseD3ovyM4CyDF8ex4MuHUEoj9Fk4vk/5Gi6DWQkhl+ftCa2SRPFmbomR73XidUqGQclhI7oLIZHOYvidZ2VZw0+rAv8vi9DZt8gw0f63UCaC8iI8Xb63PPpPFqWTtoT4ANWpA797ic9u8OTRoIF63ZnM2WeNTOPs2b1augG/zJeqdOgWHD8Pu3aKw/vNPSdr2QVXFu+jOO+Ua9cZibduKR9A//iFjNp8NS3EhNVWu/9w5URNf6TCKiL9GAhkgMtL4YTh0SJjIKxKpR2HdfZCwzTip5zIUYfIr3SCyynJtRebpdWkTIT7jMU+6RLWe/hW2PWt8iqtpgObvJNYSDrfEiLlfMJOO/JzMXki7QPWPq+uSCnaznbixcVQKq1TkS0lzpRH5bqSuOsRhcbD7sd3ULVu3yOfQRAn+3gnpCVT9qKru9xhhj2DO3XPoXbd3wOeq9EElzqdpKz1CLCG80fMNnunyjOb+l/58iffWvIfLq62waV6pOTtH7Qz4GrtP6c5fcdpR7ybFxMi2I5kwYILxQdY9AEenF6wG8qH1+9DgscCMJ4tAAh0/LuW8X34pK1ypqQXfVjabrKQ1aSKDodatJXXGbs9ekXK5hHDIyJDBwtatMtCJiZHUGL1gAFUFnEmwcQScnC+lP1rG7PYKED0U6j4kE3+PU0i0YLVDARBqfqGEJ9ynT0sJ2KRJMmDNm+Tpg9ksCuC+faFjx+xAB5tNBrmqKopffyKkfQEPKSmiLDt0CFauhGXL5D4w/BO9Hji3XNL0js/NWj3Hz/4cWY23VwDFKr6BvjQZr1PuFV/frVd6mBfWCClt0SxxsIt6oPFTWZO9IpLQ/0+IyYBQwiTQy8tf5qN1HxkSNJsf2UyTik0COs/krZN54tcn/CaCnE6Jet+9W99XfcAAIYLKlClFMmjl7WIfoEecVO0LXWcIIRtIElhxE6helyiALqyXmPYL68EZDyaH8MOeTP/bkqJAscr85MI6fVKtfAfovkgWZYtKBhWnEqjlW9D4meCkehaDatLplL7p++/FTw+kPzMqu/ShXDnpK2vUkL7StylKdn/odEo/fPiwjIkKgq8J83rlel5/XZ53j0eOlReKIv65PXtKlU7jxqII9J3bZJL+2B9PXt/YDWRMpyjZ47gFC0QlfuRI6XcH/uAaCVREhIUZ3/ynTkkk5BULVYW4n8TZ352a5fxfGChitBZWK8uwLMcgMv1UVgShHyv9PlxtA7TVQ8QIryA1VbBWIHLCzwnYrN2zeGTBI7qqjfKO8lx47kLAl1Pn0zocTTyquS/UGsrHfT7m0XaPBnyeXCjB37ug79FqsnL+2fNBMcC+ZcYtLDq4SHd/+2rt2fjIRs19131+HXvP79X97Oj2oxnff3zA1/jaitd4c9WbusRfjYgaHB973PggaSdgYePCtTsVOkOHLyGsTuFVQa5U+KkAn5QcbVBSErz0Enz1lb5CxIcGDeDuu2UFrFEjqFQpO740NNT/QUV6upAHdjucPAl798LChVJ77xsU5bqlkw9CzPtCpilm7VhukHa6Ug+J/K14PTiqSHvtyRDywGTzb/XR6wJ3OuCFn8sav/dqa8+zkJ4uJX7ffitpnyaTkH8FlZeEh0OdOrLVri3jg5yD3czM7MFmUpLI1WNjpYzQ6N7y609UVUjeLzHoZ36Dc39JyaD5/9o77zCnqvz/v07aJJnCMMDM0JuABQURUREsiIiIvYKdVdRV11VZ635dXXd1F3fX9mPVtSsiIKgrKoKCiogCUqSIdIahDTAwvSW55/fHuZmamynJTDLLeT3PfSaZJPd+cm/uKe/zKR71uwiUN8zrrqm4M2DMGvhxgip1HCgh5Kp9Ui/o/5iqEihEVTnjaPE/Jkw2iRYUgRoiAL005iVuGHhDxMeSUnL1rKuZs2lOyNDz4PHmjJvDiJ4jADUZfPZZFTYSCIS+z9xuleh2wgTo3Fm9L6mZ09cYhlpMcLnA7SyD5XdB1vvW4kVCezj1TVXaXNI0z/JYCKgVeVC8Q4nJRTugcDO+vLXsy/mRDrYACQKEDKBCwew1w8FkAJDq/zYnJGSosNiUfmpL7KGeJ/YAt1nK0QioxeYtr1ifS0cy9PsdHPuAet4clQqbKrgldFCLxs7kyMMAm1n0CwSU4PLjj7BgASxZAjk5VYmiq4skkRJcPAPVD7dpA6eeqsSW2mzYALNmKc/eLVuUPUVF1otqQqh5evfuVVvfvkoYDvbdwUW7YP+dm6tC+LOy1IJdVpb6Xyhi3R00BC0CNZGbb4bp061/6HfcoVYWm7tDiZhAOWx9TVW8Kj+gViRCVKhpdlrbAC1vPcw7uWGurxnnwJkfR6+MbwMHu+NmjWP6+umWbxvZayRfXm9d8aqhjJ89nvfXvW/5+rm9zmX+9fMjPk4NWvB6X/3B1cz8Zabl612Su5B9Xz2iRwN59odneXjBw5aJvF12F7kP5NZJYFyft1KyK5lXL3yVq/tfHbGN87bM46pZV1mGALodbn6981e6p3YPv6Otb8BPv2u490KQ7lerBPauVPXcSmD1lyovGelXCS03/zv8fs375q234Pe/Dz+QSU1VfcBvf6s8QWy25sn5VlSkBiFr16qKVVOnhnhTRT7snqPEoP3fmT7W/vATf0eSEvCDg+mkXuA2xaGgZ4gRqHLL9xdD0RY1oC/OUiuu4Yi0Pc/MVKNKKzIyIi+nXQ+BAKxerXIffPst/PCDWtwJDnR9virvn0gJrkI6HEp0qqhQK6dBj6BG4y9VE7CibSqcq+BXcvctpvjwWjo5HTiEVNcXQ020sKHycJiLGsJuhhOav5PkvsobOLm3EmGTeilxsXY7fOAHNZbY85kpQIWajAm1Kp85AjqOUcmvhd1cNJJq0tdYjz9/CcysZ6GltY0xmkILiUD1CUBuh5vLjrmM9y57L6LjVKe4ophj/30s2fnZlkUaagtBoAT1l15SHp1+v7WXX/fuKuzz/PNh+HDlvVBaqtqBoNdeY/KKVFSo/sMw1EJAQoLy+Fu4UFXvnT+/2uRx52yVZsBfaC3me7upXF+9bwZvV9UuR0vEaG4BFdhyaAtnvXUWuwt3IxCM6j2KD6+ajdeRUK3cuawWGuZo+O+5Onvnw4rfQ8lO60Umu0eFmPe8XhWfMPyq3YlGKFZ95zIYJREKT2cY8rJZECOCheMYiH5FRUoQCYojmzfD6nVlLFmzD6MwHeH3EAgIDKNm4YtgsQybTd1nLpfq3nv2VN46ffuqe7NHD/U3NbVh9hQUwOLFalFn4UJ17xUVVXnq+v1Vi3WREmwf7PYqL++2beGARfrGekevHQAAIABJREFUeEKLQE0kP1+5/OflqR9TbYSAP/4RHnpI/ehinoSuPqSEQz/BxheUh4twmp1RCwhC7oz6q5PURywGaF+dDfu/adh7OwyDs+ZGp0pCAzpsKSXtn2nPodJDId/itDl5/KzHeWT4IxGb8/JPL3PfvPso9Yfu2DwODwUPF0SUi6YOLXS9DWmQ9ve0sGVtrzz2SmZeaS0SNYYl2Us4/73zLQWWFFcKUy+byoX9Lqzx/5nrZ3LLJ7dYeit5nV7W3bGOnm17hny9MdQnOCU6E/nXef9i4kkTw+9ISvjmfMj5uv78WqFIPgoyz1WJcFMHmAnshRI/CjergfW++ZC3tkG7k+MkDz4IU6ZYe3k6HHD33cr1WIiWDSMoLGxAdUlpKLf8fQtg96dQuAnKDpg5XszlNKuwnWgRhfZ88c7FXDDtAgrLC7EJGwEZwO1w06ttLxbcsIDMpMwoGds4SkrUIHfnTrXt2AG/bAjwzaqdFBxMxulPwwjYKge2wUpvwbwHdrvaHA41mO3aVYk9/fqpAW63bmrr2jV6OYeklEz+fjJPfPsEpf5S3A439516H0+OeBIbVIV1C7s5+bI3bfJVnbKDkP0B7JgOucvUBMuosA4JcaZCYlc1ufV2NVf9+4Kni1lu2lk1KTT8KozU8KmKaYWblOC1qZ4QVC0CVRGBnfUJQAJBj9QerPvtuibnAbKivvxAEFoIAjU5++ILlatz7lwl8Njt1rlEEhJU+ErXrlVb377Qq1eVh2cw7NPvV5vPp+YGW7aoLTu7atu7t+5cocZlMAKw6yNY80cozlaLF1btdEIHlXA5/UxV/Texp2p3kap9FzbzfrGZYqodMEwvG9PTRvqrUjdMr8ddNcJ7p8Xbcylh7zz4+VHIX2+qDRaLIsKuiuC0HaByp7Xpr8Rud0czuqF6mxW8v2TN/9nd6r2lu2FO3/C2nbccFl+lFt2tBL+Mc1T4bMbZ6jfgSGx6GG0oWkD0W7Z7Gee/dz6HSg9hEzYGdRzE5+M/p723Q6VnjZSqn3M6W2aOXF6u7sWgWLV9O6zfEODrFTspOJiCw9cWI2CrDN0OClXB/jsoVNntSiTu2lXpAEcfXSVSde+uFgZbSyJqLQJFwK5dcOGFqiSw1aRhwADlMdS1a8uW0QPVyTUpAZavCPZ/qyYSe79QK8B2j8oV0CS3crtyYQ2GHqQPV7mFMs5Wrp3RIBYDtP3fwdfnN9yTod0QOHu+6jCaM757vGTDgQ0MfnWw5WApJSGF2VfNZmSvkU23w2TFnhWMeHsEBRXWwsUX133BaV1Pi/hYlbTQ9V61dxVnvHWGZdl1j8PDP0b9g9+e/NuIjwWqTHmbv7WxzOsjENw08CbeuPiNGv+/ZtY1zFg/w3K/Sa4kCh4qiLiCWZDMf2SSU2y90jSy50i+vKEBXmblufDZcc0XZ98IfrtY8vbb1m15erryCOnSpRV4eFZHSjXgDHrxFGepiXPBJvW4/IA54QiYniAGVYl+g676Qc8Qr5qYJ/eGlGMgqafplt9dTd6jEN4z9eepTPx0YqWobBf2yupADpuDtu62LLxxIf3T+0d8rEjJzs9m7LSxrDuwDiklXqeX1y56jWv6X4OUVZNDp7NujqCWoNRXyvUfXc/cLXNr9AWJzkRO73Y6s66cRXJCI8vJNxbDD4dXqzC1PZ9B3jqoOKQmqcH8F82dMwQB4yNc0NIiEMUVxbSb3I6KQIVlX+JxePhp4k8c3f7omi9U5Ks0ASXZULzTbIc2qlCh0j1meKrfFCgCVVWiqrc/ws6b+Qa37i40p+GmDaLqsSENhnYdyvcTvg/7XbKyYNEi5ZGzeLFyPAwmfQ+GgTaHp0AgUDU2t/JKIv9XyJoOO2cobz67u2HFXBI6qDY5qSe42lUJqNXTNRg+M+fXTijerv7WtygQgSgQ8/a8eCdkzYAdU6Fgg8qv5C9pWD5Cd6Y6l47Emh5K0leVP82XD0VboeJww+wZL9U12PUJ/PJ3yF9XdW1qY0uAjDMhfQR0Gq1EKqjmNelSv42Gek0GKtRnZ9WTuiBCEejNVW9y5+d3UuovrbzeTpuTVHcq86+fz8DMgRHtP1rU13/7fOp+dTjU1tL9d0ugRaAI8fvhqadU9vRwSbJOOAFuuknljkhLa57YY8NQnYrbrVYo33oLnn46CvutKODn9a/w069TKTm8jtPapHGsx0tioABR2TGZEwdhUw1TQns1KUg6Sq3oJfaA9qcqN/LmuJNiMUCTEuafBoeWNzyEzp0OJz2vXFEb6+5pmKufDXB7f+7H53h4wcOW8fNOm5OcSTm09dST26MBVAQqSHoqyVK4cNqcPDTsIf589p8jPlYlLXS9/7LoLzy56MmwYVbf3PQNgzoOivhYQfq80Icth7dYvt7B24GcSTmVg3ApJWmT08gry7P8TEMGxY3hovcvYs6mEEHZJh6Hh/yH8nHaG5AQ59Aq+HKYdRx/C7Bi+yCG/3WFZe6X1FQVkpWe3rJCfh3qC5OKFubCcZOqe+fkqBPVSKSU/N/X/8e/fvhXDa9Cp82J3Wav0ZYlOhOZfdXs8FXompm5m+dyzaxrKPYVE5CBysGu1+llXP9xTBkzhQRHFHPeNJLs/GxGTR1FVl5WSC/NBHsCmUmZfHXDVxyVdlTLGhcUJoOCQEm2muwWblbiQOleJQxVCgLBMQaArSqHiLCriVIwP2FyH+UhGPQo8nZVHhI2e+Q2N6TPMUxPC2GLzYyhBTyBfAGfZTgWgB2BvWADHPgO9nyuPBPLDqjzEpywBoWIJjUw4JPVPmlPqMqhEigHDGyu9jjGroeEtIbv1AhQeGA/2VsPkr2tgOwd5WRlBdi01cO2XW3Zc7AdBaVJ+AN2DGkjYNgxDBsSGwIDuy2A3WZgswVw2AK0TSqga/pBenfNo89RPrp1t9O1u4euvVPo0rsD7jbtG3a9yg4qb7rcpcpr9vBqJZjazfjjJi/ONpAmenbGZXvuK4Dc5XBgiUpgfXil+s3YWyiBdahzWbARds6CnTMhf4NaMPeXWotUzlTV1gXbt6QekNxP/dZtThXFYXOawpLpNRkoVWHBhVtUmFyWdZoIoMkikN/wc/fnd/POmncqFx1swoZRbX7kdXp57cLXGHf8uCYdI1rEe//dUmgRKEoUF6vKIk8/rVT+YCxxKLp1g3PPhUGDVAWZnj3V2B6qktdVj5kUQvXZQZe0QED9z+NRLnXBUnrr16v8BQsWqBLGENk8eEfeDl5f+TqvrHiFUn9pDW+IZFcyDpuD3wz6DRMHTaRP2lGxlUljtUpXuAU+P6FhuYGq0/40lezP01m5edrDJBTxFwF2OLgElt6qVm/CMV4y/M3hLN652PItmYmZ7J0UvdLt/f5fPzblhi5FD3Bch+NY99t1UTteS13vAS8PYE2OdUUtp81J8SPFDRM7GsjNH9/MWz+/Zfm61+ll5cSV9GuvvOjW5qzltNdPo9gX2iPNLuw8POxhnhzxZNRsfO7H53joq4cscxeluFL4dPynDO8+vGE73PE+LP1N4++jKHHWk1+zaONZlj+ZyZPhrruat7Rog2gtS1GNvPfK/eVc9+F1fL7l8xoeKx6Hh7cueYt5W+cxfd30Oq89M+oZ7jz5zqiZ3RACRoBHFjzCi8terDG5qT7Y9Tg89Gzbk8/Gf0aP1B4tah+o8IsLp11IYUVh5aq7x+EhPVFVH6w+QE90JvLBlR80fQLWUsJkpDRGnJQGlB9UYlTpXuWpcso9kGsRvgHQBqiRdsxWJVQJu0r46s5QfX7Qg87TUVUP9XRUmzM1sns8BiXiAZUEOPsjleD4wPfqe8uAdXtu91QL/euq8t2k9DVLhicobwub04zF8FVtZfug4Ncq4bAkW4VO+UO41ISbyPpLVfqDA9+rkOHDPyuPjqC3B7LB4oqUDTntQn1nm9Pctylw3tuuafdOItDO3NoDHYBO5t82KBHfVmuTKB01uAWAMiAXyAH2AgfN57nAYfM9TRD14709Nww4eFCF6B3YnUdRTha+vB3487Pw+DeR4fmVzOTttHHnYbf5sdsCOOzqr00YGIYNv+EgYDjwG3b8ASeHijuwr7gn+8uOxefujSOlB660HqR07EZGJy8dO6rFpLC/FX+JKfZ9a0ZhbFdekzaH6c2FEqlaWqhqALkluVww7QLW5qylxK+uq0CQkpBCeaC8hujndXq57aTbeObcZ7BHQ6BvBK2h/25JtAgUZaRUQsy0afDRR6qqS0JC+AzlQdq1q1tdJBh37PNVZSgPVhfZsSOMO2k1expDia+EDzd8yAtLX2Dt/rUY0qAiUIFN2EiwJ5CRlMG+on34Aj4CMoDL7sIu7PRt15d7TrmHK4+7sk7S2hYhlq7a6/8O655sfIJbUMk2O18A3a6G1ONNd+hgsk7UisXOGbBnrhrwNIDyq8po87c2lhN0gAv6XMCn4z9tvL0WTPjvBN5c/abl6y67i/2T9kelghbQItc7ryyPjH9kWHoBQTOIW8Bbq9/i7s/vpsgXesLhdrh5asRT3HvavQD8ffHf+dM3f7IWZBJSeP/y9xnTZ0zUbKwvd5Fd2LnvtPuYfO7khu9096eq6l4MPIISby6ipMLaw66Jzi3RpzVMuBuZtDm3JJfzpp7HLwd+qTEo8zq9PHHWE0waOgm/4Wf01NF8n/19ncHkhIETeG70cy0ymNxXtI+L37+YdQfW1ZjAJLuS6Z/en9X7VtcIe/A6vUy7fBpj+45tdtuC/HvZv5n05aQa59LtcHNK51P44tovuHrW1Xy57csar3scHh478zEePP3BxoeMthZhEkL3CdKA/F+Ut8X+71SVteIdphBh1jGWfvCXoWbFtRDmIo5wqMmasJvhlWZSeqtiG5Wfs6vXjXK4JsLJXUPah2gmVT+0Ejb8C3bNVt/DKhFv24Eq/L/TBdDuZBWSEyhVQoiwq+cNvX+lYYbz+M1cZx4lEB1ercINc75WE+lxta5VcTZsf1dVxc1frzwurPKjudKUV5m3sxLtEruZHmbdzOqKCTVz7lTPs+MvVaJhcVaV50XpbijZrbw+qvdv1zbsK8ecRoyl4q09NwxVaXPZMvjuOxX6t2OHmlcFy5T7/SqJd6iFe4ejKplw7RxQwcqRoeZ2wc/Z7er18vLwlSBrU1Kikprn7DPIyzlAycFsfPnZGIXZeALb6ODZREZiFu2S9uOw+XHY/NhsQY+0AFIKAoa9cvMbDkrKk8gp6kJOcW8OB/qApxuONl1JaNuVpPQudMj0MGBA45v0NTlrGPXuKA6VHqoREdAmoQ1Lb1nKyr0r+c0nv6nzezi508l8fM3HpLobmO05QlpD/93SaBGomdmzB5YvV5VFvvlGldWrqKhKFl1RUX/52foIegU5naoRKyuDlBTlafRlA9JySClZtnsZU5ZPYfYvs7HZbJVePwKB2+HmrB5nMfncyfRP78/m3M089NVDzN0yl4pAReVKY5IriYAR4KJ+F3HnyXcyrNuwqOUgqZcGHCc/T9ZIzll9i8hMww/zhqgEtDJ02ewGYXOZ5SHN+G9/Yf0x4CH4ZujXXDz9YssJusvu4qkRT3H/0Pubbmst3lj1Br+b+ztLb5SUhBTevuRtLjn6kugcsAVEoFm/zGLCfydYJlsGuGPwHfz7gnqqTjWSXw78wimvnmIpAgGc2vlUfrhFVWga/J/BrNi7wvK9LruLXffuokNih6jZWOorJeVvKZZl4gGOSjuKzXdvbtyOD/wAX482V3Zbrv9JnFBISbm1eL1njyol2uqJlaeABZtzN3P222ezv3h/jcGj1+nl+hOu5+WxL1f+r7iimJNfPZkth7bUee+wbsP48KoPSXQ1X6bub3d8yyUzLqGovAh/tXY+2ZXMopsXcWyHYxnz3hiWZC+pM9idOGgiz4x6JrrJ8WtREajg1k9uZdaGWTUGuC67i+M6HMfiCYvxOr1UBCoY+c5Ilu9ZXickY1TvUUy9bGrjEvq2BmESaoofgTIlOm99Aw4sAkx361ALOe50SBsMSb2Vp0rwrydT5V1xeKoqrUmJymMjUJ5AZk4tX1GVZ1HJTpVDpGSP8mo5tKLKkyXCXByGNHhr9VvcP/9+yv3llPpLSbAnkOBI4KkRT3Hb4Nui8xssPwTLJqrFKaMstMjl7QrHPQLdrlBjGmFvWnnzxlA9nMeZoq7Hrv/ChmeUYIUM7UWR0B46nQ+dxqoiHgntTC8mocZlTbXbMMAoVSIVQu2neKcSqnZ/Cmd90sQv2sI0sD+Il/a8rAw+/RTeeEPlfQpGUxSHuL3T02HwYJWgv0uXqr+ZmWph3uOpqmAlZZXnVzBSI5hcPOhZtHOniszYswd+/RVWrKharLc6jcXFsHQp/PSTEqpWrlQOBEERScqqanO1SUtTTVtSUpVQ5XAoe4NCVUWFqlS1f796XJ3qYpWUysmgMcxYP4MJ/51QJ/9oojORRTcvqkyVMGX5FB748oE6fVMHbwfmXz+fYzsc27gDN5J4779jhRaBIqGJg598UsimKzvpxk66sY2ebORottOTQ6Thx1G5BbATwI6dAA782PHjxI8TH+nspxdbOZpf6UGWubeddGEXXswfcZgl7DU5a3joq4dYuH0hPsNXI24TwIaNVE8qfdv1JcVVtxRlka+IzbmbyS3JxahVRcwmbDiEg6HdhjJ55GRO7nxyo89TdQIBldV9yxaVkPvwYdXo7tunGra35mXSzmd9LfaRQXeXGgAGG/Jgow6qoU9KgjZtlMtm+/bqtGVmqsdpaXDttcqrKyTF2SrBbSi35BbmDx0m8ewPz1aKc7VJSUhhzrg5nNH9jKgdc23OWk5/43RLwcQqoXGTaQERaPzs8by/7n3L15Ndyfznwv9wTf9rIjpObQxpkPhUomU+J1Cd5+EHD2NIozJRpxUdvB3Y/4f9UbUR4KgXjmLr4a2WryfYE9h5707SExvpQpO/Ab46QyVabIII2mgcSZz/chbzv02z9Nb805/ggQdUVZhWTRyJQN9lfcfYaWMprCiskWPE7XBzZvcz+Wz8Z3VWg3OKchj48kByinPqfKZHag8W3rCQjsnRVesMafDXRX/l6cVP18mtk+RK4tubvq0c6Jb7yxk9dTRLdy+tM5A8uv3RzBk3h07JnaJqH6jzMvq90Ww8uLHGcR02Bz1Se7D81uU1VluLK4o5/Y3T2XBwQ422w+1w061NN768/ku6tekWdTstaSlP3tK9sPoRlX9D2EP31+4M6HgedLlEFbFwJCnRyO4OH7bdGKRR5YXi8KrE+Hu/hN4TmrzL77K+49Y5t7KrYFfIxZhEZyIdvB34z4X/4dze5zbd9vwN8OXpyhsnlKBic8IxD8BxD5vhVdELlW4UBZvhxxtVTiIrD6X2Q2HwC6oilFGhFuFaAmmArxC69Yt/AbWBnmPx0J7v3QuPPAIzZypRI1SkREYGnHceXHIJDB+uxv1lZUoIcUfp9jYMtc+KCjVmyMlRC/ITqt3e2dkwa5bK3bphg5qDBD9TnbQ0OPFEtQ0apIoMZWaq/6ekqLlReXn4SBMhqsSe8nKVLuTAAXW+Nm5U4tOqVeqxVRqTOt9RGjz45YNMWT6lTr/odXr5fPznnNnjzBr/f/ybx3lmyTM1hCCBqPS4uajfRQ07eCNoDf13LNEiUCS0FjfoatfRF/Dx4YYPuf2z28Mmko02ya5knhv9HNcef229ybb27VPq+apVShVfv141osHwuGApzooK6NBBKfft20Pbtmpr10419BkZ6nnQhdNu9j+BQNWWn69EpL17VcN46JASmHJzVcjdnj3qmE5n6FWEGuyaA99fE9MEtwB9c/uw+ZC1B4bT5iT3gdyoVoXxG34Sn0oMK0ZkJGawb1KU3NCbedLQkGTLXqeXtXespVfbXk0+jhX1efcEQ7wMaXDt7GstK7MBjOkzhs/GfxZ1G2/8+Ebe+fkdy9eTXEm8dMFLXHfCdY3fecluWHSJquZhNYCPFEeiqv5xxses392fwYNDr7SBCs9duVLlc4vWQDEmxIkINHnxZB775rE6IYwOoUSLty99G7cj9InekbeD6z+8vjLvQBC7sJOckMzsq2bXKQ/dVA6VHuLymZezfPfyOhPrJGcSC29cWGeBo8xfxqh3R/HTnp/qCDLBBKjn9DonKvYB/LTnJ0ZPHU1+eX4NzzybsJGZmMnK21aSkZRR53OHSw8z+NXB7MzfWeNzdmEnyZXEJ+M+iepCQVhaQgT65R+w9k9mmFaIfsqdCSc8CT2uVR69LSUIBAnWJG4kO/J2cNfnd/H1jq/r5Fg5s8eZfLvj2zoTmlM6n8JLF7xUmVeuwQTK1GJX0XYsPTWHfwQdRylxK1YUboG5g5RnVygvJUciDJ0Gmec0vkBHPKHb80r+8Q+1WBP0fKlNZiY8+aRazPX7ITlGt/fKlXDPPSpCxGYLHQly1lnKzlGj1DwmWE3OchE6QruKiqq8mhqy0JVfls+lMy5l6e6ldTyAPA4P0y+fzkVH1xV0pJTcPfdu3lz9Zp3PeR1e7h96P4+f9Ti2hlY7q4fW0H/HGi0CRUJrcIM2Vfx1+9fxyk+v8PbPbyOlDBlq4hAOOiZ35Jye5zRJ7dxfvJ8F2xewM39nSC+UJGcSEsn448dz++DbOTHzxMpwsbw8+OAD+Pe/lSqekKBiYv3Vok26dIGxY2HoUBgyRE3IhKiauNntSqxJSGi8PmcYVcJSUAl3uZSAtGuXEqWuvLIBO9ryOqy4O2YJbg/4octOV1gxpktKF7LvbVh+ocZw/L+PZ90B6/w4HoeHtXespXda78gP1syThjU5axj6+lDL8DaIftn16jzw5QP8c8k/63jYBREIbhl0C4Y0eGPVG5bVWlx2F38d8VcmDZ0UdRtfX/k693xxT9hzdEm/S/jomo+adgApYfcnsPy3qrxwU3JuhcLuUTkdTnwGet1cmYvij3+EZ5+1rvCYkqLKCR93XCsrEV+dGE8aDMNg2JvD+GHXDyFfFwiSXEn13lMBIxD2d/fEWU/w2JmPRWTrjHUzmDhnYmX1kOok2BN48uwn6duub8jPlgfK+dPXf2Lr4a11qia6bC6uOPYK3r707YjdyyfOmchrK18Lef8Hc/W57Nbl7HyGj00HN9Vwjw8iEFxx7BVMv3w6tiaIE42iuUWgTVNg1QPWCzQdhsHZX5h5elpHRZjC8kL+vOjPTFk2pUZYfnCy8uHVHzKi5wh+yP6Bi6ZfREF5QeW4wC7suOwubh54M38Z8ZeGVwnN+Rq+vdja4zn1BBi1JPbCyucDIG8dWPSfDJupKrRGy7MrVuj2HIApU5SnrlXfPWwYfPGFGs83h5DSEKSE+++Hl19Wc5ZQl+Sss+D556FXLyXGNHez2xTmbp7LJTMuCVklUCDoktKFNE/4qnxZeVnkl+eH/HxmUiYrJq6I2KO3NfTf8YAWgWJJMw98CssLeWfNO7y49EU2H9qMQIQUZ7xOLwMyBvDPUf/ktK6nNfl4QVbuXcmk+ZOUS52vtM6NbhM2BIJubbrxu1N+h3/prfzfQ4nY7aG9bc48E555Bvr3V2JNYrwv3GyfBstuiYkQNL0QJh5KDpvH5vJjLmfWVbOifuzffvZbXvrpJcvXvU4v/xz1T24ffHvkB2vme+fp757miW+fCJtc+/Sup7N4gnUFtkj4+NePufHjGy3zOoHyrALIKbYWolMSUvh0XCOqdDWCtTlrGfrG0BpVA2uT7Eom76G8yFZ2AhWw6f+pVfxwFWfqw5agknj2+73KVeGsq+QEVxOtBpNCqBW6559XgnNLriYWFCghKiJiOGkoKCvgmCnHsKdoT9T3HYorjrmCD676oNGfMwyDy2Zexn83/tfyPYnOxAYlLi2uqDsADZLsSmbpLUs5psMxjbaxzF/Gyf85OazoHi16pvbk59t/jqrnaB2aWwSamRI+VPviHapaVyvAkAZvrn6TSfMmUR4or+nl4/ByTIdj+GTcJzUW8g6WHOSyGZexcu/KGpNtt8ON0+bkqXOe4vbBt9c/qTn4Iywcae2dmdgTLlgfndw/H2aqMLnm4PIDKg9QpERsow3GRxDyrNtzQPWL4Yrk7NihCu7EktdeUx5AVmOLs8+GOXPie37z+NeP88SiJ5r9OA6bg3nXzWuSR29r6L/jCS0CxZJmHvis2ruKMc8Oxm+1GgIcdQgmfwnDdzb5MJYs7wQPnAvrwqQEMXafTNH731IhQw8aevdWmf1d1ouZ8Un2R7Dk2hYXgq7Zn8CMfGvhwu1wM3nkZO4+5e6oH/u9Ne9x+2e3hxUFRvYcyZc3NCBbeX00870z6JVBrNq3yvJ1u7Dz6PBHeeLs5ukQ9xbupefzPcOKUE6bE7vNHjZ3kNPm5PCDh5slYW7ACJD4VGJYG5NdyXx949ec1OmkRu8/mAyxpER558nyQyTseY+E/bNxFSxF2lyIQAmC0MmpJTakPQlhlOFLGkh5h8so73Qt0tMFu125V7vddX9Kc+bArbeqQaXVgM3tVp6Bd90FJ5ygPBabwzuooEC1fQsXwosvwty5Ee4wRpOG3JJcejzXI2yyc7uwI2icV50hDUtvOVAJ1BdPWNzgSjO7CnZx0isnsb8k+jm0QiEQvHTBS9w2+LYGf2b74e2c8PIJYdvZaON2uFl+63L6p/dvngM0twj0USeVD8iK85apClaR5q9pZlHgxWUv8tjXj9VJbgrq/jkh4wSGdx8eUnSXUrJ011KW71leZ2LjEA48Tg8PD3+Yh4c9bG2elLDwXJVMu9YKeSX9/wTH/iFyb6BpEXrY2hKsS2n3fwyO+UPIhYBGEamNEFkycN2eA9Cpk0rpYMWyZTBwoFq4iRXXXw9Tp1q//swzcO+9VWkr4gkpJSPfGcnCHQtb9Lh/P+fvPDDsgQa/vzX03/GGFoFiSUvEwcd53qJt9OR41lJC6AFDu3ZKBEpOVpO2VsXuz2Hxlc2fI0gMjDhLAAAgAElEQVQ4wJmCHLmYdq+czuGyw5ZvTUlIYd518zi1y6lRN2PjwY0M/s/gsAMDj8NDwcMFkbtRNvO9M3baWH76ea5ltj1nAOa8DwOjlOIoFCNvCC+gltmh1AUVYQYNPdr0YPvvt9f5v8+nvO6CCQVDbcHk6cEtWBEjuAkBYz8dyIbDP1se32Fz8H/DH2Pi0f/Htm2wbZvKtZWTo3JxHTyo8nL5fCrRYfv26j5PTKz6m5KikrUnJyuhxeUCu/CRGlhK+4rPSatYgEPmY5clgCQgvAREEnnOYRx0jeWQYxh+6an8zgUFasvPV7Hw5eXq75tvVrlfl5Upr6Cnn1bPrcQgUHnJLr1UuXKfcAL07KnOTXm5srW+GHvDqBK6PB71eOtW+PlnmDdPVTkJHj/iLjkGk4ZNuZs4+62zySnOCbmq5rA5GNd/XJMEBiklszfMZvW+1XXctkGJF8O6DePjqz+uVwhdk7OG4W8MD5tfy2FzNHpiAypnmlXIpkDwt5F/4w9D/1Bv2MTanLWMfHck+4tDD3IFgh6pPZrktVNSUcLWw1st7Ux1pzLvunkM6Tyk0fuul+YeC+1fDF+fZ90XezrDOQvA0ymyXEDNJAos2rGIKz64ggMlByLffz2kJqQy7fJpnN/n/NBvKM+FhaPMcucWHkEZ58Cpb4IrtennM1JBLam3Ev5CXnMB/e6BE/6sxk9N9VyKhrdSKxOB4rE9X7xYJXu26qc7d4YFC5RY1NK5gIJ8952y0aoadI8eKkGz1xtfc53iimKunnU1X2z5IuT1FgjaetrSJbkLje0aDcNg86HNlguJTuHkL+f8pUF9Y2vov+ORiEUgIcRo4HnADrwmpfxbrdeF+foYoAS4SUq5Mtw+tQhUjUgb71aQt2ht2pnc3PMb1q9XX7e8VnuQlqZW5m+/XVXs8vnUZLClFPNAQE0emxSKcWgFLLkBSrKaJ8Gt3QvpZ8CQ//BLSSFDXh0SNrbaYXNQ8FABHmf0e5mGVLVKSUhh7rVzGdp1aGQH0/cObw6EP460E+iQWVkKNBCAgKEqFksJqZvvoPO2R0lPV0nSvV4lrCQmqsFQaqqqiJecrP5ns6n7KijyVBd9aotCUsKH2S8xNeuvdSruVf4tTqXknypkxeVSW0lJlbbmdtccFBUXq+9gs6n4faez+e7zQIAa5y3U/X34MLz9tsoVlJur2iZ/aMejGmRkwNFHwzHHwPHHqzbM7Vb5CFwutZ+yMrXt2wdr16pcaL/+Gr5Ea2sTgRZlLWLstLEUVRSFHER5nV6ePPtJ7jvtviYfI2AEGD11NIuzF4dse9wON93bdGfhjQstc929tvI17pl7T53kpEE8dg8zr5xZp9pJQyksL2TU1FFszt1MhVE3X1uiM5Fh3YYx/YrpNap4VWfWL7O48eMb6yTUrLTR4eGdS9/himOvaJKNAPO3zueS6ZfUqaJS/RhTLpjCzQNvbvIxQtIS7fmBJfDjBCjdZdEXC+h6OZw4WVUIk0bjPUWiLAoUlhfy4JcP8tIK6zBrm7CR6ExsVMhtMC9k7YqwNczoP54Xx7wYOr+HNGDjC/Dzo+rahTqfNid0uwp6XAcZZ6qwXrs7ejmX6hPcri6FtX+Gjc8pe0N5BbnS4LiHoPs49bgp1zxSO1uRCBTP7fmSJar61q5dodNKCAGXXw6TJ6v+2TBaNrdfQQF8+y3ceKPq/0MJVu3awaRJysM4EFDjsljmBdp+eDvnvnsuuwt3h7wWXqeX8486n5lXzmxyyP/BkoOc9J+T2F2wO6TIlOhMZPRRo3n30nct5y2tof+OVyISgYQQdmATcC6wC1gOjJNS/lLtPWOAu1Ei0CnA81LKU8LtV4tA1YiRN1YlLdjJZGXBO++oFfnsbDVhDQowQXr2VG6dgwaprW9fpfK7XCp0xOermmAGJ5LByWzwqwQnrFJWTQCrvz8hQf1/3z7YvFlVKVuxAqZPb+IXkwZseRVW/UGVIbVyUW4Mdi+42sKpb6hKHMCzPzzLQ189FLKRCtIrtRdb77Eu6x0pJ71yEiv3WWu8dmHn4WEP8+SIJxu8T7/hJysvi82HNrPl0BbW7V/HX699g3YFFu7oQEFbLx989QJ92vWhT1ofMpMyW16lb+b7e9o0lZ8G1MqRlDWrW40eXRU+JKUadEipRJWgwNJcBAWWwkK47z4lcmRnqwTwbrc6PqhT9Je/KMGkWzelu3m9VYnaDcMMBat1mqqfWqvTXP0zoT4fFLyczqrHVkipPHOmT1fhYps3q3NeVBS+NGu0cDjUeQknEDWIFmzP3179Nnd8doeloOB1erlpwE1MuWBKxMcq8ZUw5NUhbMrdFHIF2WFz0CahDQtuWMCAzAE1PjfhvxOYs2mOpbjidXr5+OqPIyurDRSUF3D6G6ezOTf0ymeCPYE0Txqfjf+MEzueWPl/Qxo8/NXDvLjsxbDizHOjn2PiSRMjshFg5vqZ3PTxTWGv2w0n3MCLY16MXmLMlhoLSQOyZsKmF+DQSpUjLFTIdmJ3yBwFnUZDu1PA3QH8pYA0k0e7oSnf3fDB9Hpi28dLAkZA5f2Zr/L+hJqAJdgTOLf3udx36n1hk39b4Zd+Xlr+Eh/9+lHIQhIJ9oTKwgJ3nHxH6GvtK4Id78GGZ5TXjQxYlI13QbuT1YJV5nmQ1FOdU2FXFcekYXrkeNU1CYU01HuNCkDArHomW0FxpTgbtr4Km19Wnw+UKDtrk9QbMs5WFcM6DFdCoOEzjyfVd7C7re2rYWtA/V6kH2bVk3S7lYhAraE9NwxVHv6FF1QVLqvqW927q8pbo0fDKacob97SUnWagqXUHU24vX0+tZ9gJTC3W81rvv9ejcVmzFCvv/CC2vLy1Gd8tb5icjKcc47yHDr3XDU2Cn6PhIToJLcOBNR40edTdpaVqXnOOWbhq4XbF3LpjEspqggtFrsdboZ2GcoX132B0x7ZYHJXwS4GvTKIgyUHQ4qLHoeH7qndmX/dfLq26Vr5/9bQf8c7kYpApwGPSynPM58/DCClfLrae14BvpFSvm8+3wicJaW0jODUIlA1jiARqDplJQHWr/WxapXBqtWCNWvtbN1m58ABG06XxGGXlQq5PwAg8HoFaWmCtm3VynvbtsrLIVgePigEBcvDG4aapAbLwgdLxBcXGUgpsdvV+5VYJCguiVCSL8+FlZNg5wzrlan6sCcCEo57WMW0V1tVe3fNuzzx4T3qy1hw+3KYFLqQQ1R4/UR4up4cxLcmnM+4uz6vFCMcDhB2P9/s+oKvd87nlwPr2Za3jfyyfEp8JWFzzqR50khxKReOgyUHLUPRBAKPw4PX5aW9tz190vpwQsYJXHHsFQzIGNA8AlEz39/r1sGDD6qkh7t2KZHH7ZaVYkb37pIHHxR06aJcjdu2FZUCS9ADJuixU5/5wfugIaYHBRW7XYmztj8/Dk+o3EnluMimK4dpy2HakkcqBaRQgpdiEikkiQLaUOZthy+pDX5vCjIxCVeiiwSvnYREB8JuA5tA2GwIm6h8jLAhbCADBtIwwJBIcwu6L5WXBCgr9lNR4kcUF2MvLsBVfBhn0SEmH7yF5HYNm0wVFioX9PnzVb6BTZvUgM7rrcplVNujsT6EUIMxp1OZW1ZW5VF0+ulqMDhsWOP2GfIgDSGC36WUkkcWPMLzS5+3nDC4HW7O7nE2n47/NGrlYPcX72fAywPIKcqxdN32Or18cOUHjOkzho0HNzJm2hj2FO6x9F70ODx8eNWHjO4zOio25pXlMfT1oWw9vNWygqPH4eFf5/2L2066jcKKQi6bcRk/7Poh7CD30eGP8sjwR6JiI8DLP73M/fPvD3vM49OP57Pxn9HO2y7yA8ZiLFS6D3bOgl0fq4THSCVK+IuoU/7cmQKJPcDTUYWMeTqqJMiJ3cHbCWxu9VmbQ4kERkAJADKg9leyG4p3QHGWEkzC8O3Qb7h1zq3sKdwT0qtXIPA6vbx60auM6z8u4tPw2abPGDd7HCW+EsuV+Pbe9rwy9hXOO+q80DuREvLXw+45sOu/cHi1Ek3qW/RyJENiV/CamydT5fKxucxE/gIC5WofRgWUHYCSbLXlrQn/xWqLK9KAA4th1xxlZ9E2FQZWKSzVRoA7XYUKejubf7tCcm+V78jmUsKVzQGGv0ow8uWrEvWlu6BkF+yd1zg7G4Nuzyvb89rs2wezZsHHH8OPP1YtgBUV1T0dKSlqjNSxowoZ69hRLTh3766eu91Vi2c2W9UiVyCg9rd7txqHZWWp3ER79qi/27bVHAfUXphat65qYenXX9VxAoG6XkIul6pKevTRakzQubOyrXNntXCWlqYWpYJe23Z7Ta9tv1+NTw4cUOdl505la06OWpxbvbrK6d0wJM/++Cx/XPhHy+vtsrs4Pv14vrv5u6hFFWzK3cSQV4eQXx56pcsu7CS7kpkzfg7Dug1rFf13awgPi1QEugIYLaW8xXx+PXCKlPKuau/5FPiblHKx+XwB8KCU0lLl0SJQNY4EEagR7rJ+v2rIgqJN7b9791blGikvryn4BCe81SepwYlqWpoKNcvMVHlJqgtJbduqBv6XX6xPR3q66kQagse/hfals8gsfRePfyuGcGKXxYgQHZ3ETkB4sclyCl0ns89zAwfdl+Cz100Ws/XXQm65wzrguVMn1VmFpSEhUBkZqidpIi+88hBbijaww5/DNv8+9gRyyZPFlh19c+MUDjI97eid3JXj2vSiT0o3uudk4j1YlXdDGgZFeVWxxp379aL7CcfX2I/LUzP5S7vjzq732Lnrv26y3faSTaRuqkpIV1zmZdehLuSXtiGvOJXDvt4UH/cSxcXKm66wULkkl5aq+8jnU7/n4MqS0xn69y1ETREolBhkGOp+Ky9X+w2Key4XHHv9q+wt3UZRRRFFviKKKoooLC/kpz0/kVua26DvuvcZyAwTTbkvETr+of799GvXj6PSjiLJlVS5JbuSOavHWZzzzneVYlVTKMHDJvqykX7kkMFB2rOLzuSQyX7SKSeBAHYMbNgIYCdAIiWkk0NH9tGZ3bQjl47s5Rg20JutOGsnvS4sjMyHvZnbc1/Ax1WzruLTjZ+GLDsOKln5MR2O4cff/Bj1sNSNBzcy5NUhYfMC2ISNGwfcyHtr37McyIEazH1w5Qdc0PeCqNp4uPQwp71+Gtvztlse3y7sjOw1kl8O/MKewj2WFUq8Ti+3nXQb/zrvX1G1EeAvi/7C04ufthSC7MJOO287Ft6wkOPSj4vsYLEeC0mpRIHc5XDweyUKle6BikNqcm93qwm/NKLnzVuL3X645YCLeUV1Sy8HcTvcdEruxNxr51qWN24KWXlZXDDtArYd3mY58bMJG8O7DefNi9+kZ9ue4Xdo+JUQtP9bOLgUirdByR4oP6hEsuDilVGhRJhoY0uAa+rZr79UhesfXAI530DJTijNAd9hEE6wuwBRzcam/P5sWJapB+VtdFkEiQV1e45N2Hh+9PPcNeQuy/dIqQSZ5cuVV86PPyqh5tChKk8Yh0ONY5qygFMdj6dqLOXzqcUcr1eFeu3YYf258nJYv15FHixZAkuXqvlMfn7VPCUo7kRqYzDiweFQ58bnU/tzJ/q48I3rmfXLLMs+x2Fz0KttL5bdsow27jZNNyIEK/eu5Mw3zwybV9QmbPzmxN/w9s9vx3X/fcnRlzD1sqm4He6oHj/aRCoCXQmcV0sEGiKlvLvaez4Dnq4lAj0gpVxRa18TgYkA3bp1OykrK6vp36q1UN+EO8LJdlRoAVGADf9QK2XCrgZZMlDV8RplkH42eNLV6hpSvQfMjk2as1RzRQbTfacy+ZcwHwrYPhWy3muSiaP/uYhTVy7gcaJcDSoV6A90Arqbz+2AHzgA7EQFWq4D6ik0drB7O/56zKMIIbEJA8Ow4Qs4Kfe7KPO5ka50rvr9+ZUrGMHJe/UJflAgczio9IQKEnwsBOq6BMpBymrigLoeKtRO4vdJ/H5JwG+Y10wiMJid25WNFeCzaF5c7QZyUseTOK3LaQzMHMhx6cc1rSFd8zisU9crLwCry2FVOSwuhY2+0OMiIcAl4Hn/EIb3Wma971Pfgl43hj9+Q+7v+bdX2tgktifDhkI1PhWo344DcAGJXrjwr2pF2oZ5n2BeWMAWdJFzgt1p3kPV7xtb1b2zdxbsm9UkE8Xmhr3PLuw47U4S7Ak47U5cdhcuu6uyCppDOLDb7NiFHYkkIAMEjAB+w0/ACFBhVOAL+KgIVFRuvoAvbLWRIAMyBrD69tVN+n6V6PacgBHgjLfOIK8sz/I96d50PrjqA9p7o1CiOQRLspdw5+d3hh0gJjoTw+ZOsws7T414irH9xjaHiRwqPcQ1s65hd6G1Km8YBrZ6EkKc2+tcnj3v2WZbcXzs68eYvWG25esCwbPnPRuxq31c3zv+EhXqVLoXyvYqMaNklxI2ynPN8YpPbUHvn+B4RDhU+2pzgjvT9B7qAu6OpldRR/V/u4tVe1dxw8c3hM3Tc2rnU3lxzIt4nfVkm28CFYEK7p9/Pwu3W1cAsmFjygVTOKP7GU07iJTqnAW9eUqyoWgHFG4Cf2HVeTQqzHMpq86fMP86ElXoVlIv04uom/LQcXdoWKhWvTYayuOodLcal5buViFlRVugbL+yK3itDV+t623aaHOpa5t8FHi7gKeL8ibydgZnasPFm/rQ7TkAI3qO4MXzX2zS/ktKlNgS3PbsUZ7V27apPICBQFXIVnDsHFzkCobVO53qUvTsCV26KE+i4JaZGVl1YymVEJSToy5jTo7a9uyp8jwK2lZ9C6a3qL6lpCgPoq5d1c8iM1P9zchQC9l2h8EZb54RtrhMujedGVfOID0xTNWSCPgu6zvunnt3yDDAIEnOpHor08W6//Y6vXw/4fsmheq2JDocTKPRaDQajUaj0Wg0Go3mCCCcCNQQSX050EcI0VMI4QKuAT6p9Z5PgBuE4lQgP5wApNFoNBqNRqPRaDQajUajaVnqzY0upfQLIe4C5qECEd6QUq4XQtxuvv4y8DmqMtgWVIn4KNcW1Wg0Go1Go9FoNBqNRqPRREKDCuRJKT9HCT3V//dytccSuDO6pmk0Go1Go9FoNBqNRqPRaKJFdOr8aTQajUaj0Wg0Go1Go9Fo4hotAmk0Go1Go9FoNBqNRqPRHAFoEUij0Wg0Go1Go9FoNBqN5ghAi0AajUaj0Wg0Go1Go9FoNEcAWgTSaDQajUaj0Wg0Go1GozkC0CKQRqPRaDQajUaj0Wg0Gs0RgBaBNBqNRqPRaDQajUaj0WiOALQIpNFoNBqNRqPRaDQajUZzBKBFII1Go9FoNBqNRqPRaDSaIwAtAmk0Go1Go9FoNBqNRqPRHAFoEUij0Wg0Go1Go9FoNBqN5ghASCljc2AhDgBZMTl442gPHIy1EfWgbYwercFObWP0aA12ahujR2uwU9sYPVqDndrG6NEa7NQ2Ro/WYKe2MXq0Bju1jdGjNdjZGmzsLqXsEOqFmIlArQUhxE9SysGxtiMc2sbo0Rrs1DZGj9Zgp7YxerQGO7WN0aM12KltjB6twU5tY/RoDXZqG6NHa7BT2xg9WoOdrcHGcOhwMI1Go9FoNBqNRqPRaDSaIwAtAmk0Go1Go9FoNBqNRqPRHAFoEah+/hNrAxqAtjF6tAY7tY3RozXYqW2MHq3BTm1j9GgNdmobo0drsFPbGD1ag53axujRGuzUNkaP1mBna7DREp0TSKPRaDQajUaj0Wg0Go3mCEB7Amk0Go1Go9FoNBqNRqPRHAFoEcgCIcRoIcRGIcQWIcRDsbYnFEKIN4QQ+4UQ62JtixVCiK5CiK+FEBuEEOuFEPfE2qbaCCHcQohlQoifTRufiLVNVggh7EKIVUKIT2NtixVCiB1CiLVCiNVCiJ9ibU8ohBCpQohZQohfzd/mabG2qTpCiH7m+QtuBUKI38farlAIIe4175t1Qoj3hRDuWNtUGyHEPaZ96+PpPIZqw4UQaUKIL4UQm82/bePQxivNc2kIIWJeGcPCxmfM+3uNEOIjIURqLG00bQpl55OmjauFEPOFEJ3izcZqr00SQkghRPtY2FbNjlDn8XEhxO5qbeaYWNpo2hTyXAoh7jbHl+uFEJNjZZ9pS6hzOaPaedwhhFgdhzYOFEL8GBxnCCGGxNJG06ZQdg4QQvxgjonmCCFSYmxjyDF5PPU7YWyMm34njI1x1e+EsTNu+h0rG6u9HvN+J8x5jLt+p1FIKfVWawPswFagF+ACfgaOjbVdIew8AxgErIu1LWFs7AgMMh8nA5vi7VwCAkgyHzuBpcCpsbbLwtb7gGnAp7G2JYyNO4D2sbajHhvfBm4xH7uA1FjbFMZWO7AP6B5rW0LY1hnYDnjM5zOBm2JtVy0b+wPrAC/gAL4C+sTaLtO2Om04MBl4yHz8EPD3OLTxGKAf8A0wOE7P4yjAYT7+e6zPYxg7U6o9/h3wcrzZaP6/KzAPyIp1+25xHh8HJsX6GjfAzrPNNijBfJ4ebzbWev2fwGPxZiMwHzjffDwG+CZOr/dy4Ezz8QTgyRjbGHJMHk/9Thgb46bfCWNjXPU7YeyMm37HykbzeVz0O2HOY9z1O43ZtCdQaIYAW6SU26SUFcB04OIY21QHKeUi4FCs7QiHlHKvlHKl+bgQ2ICaOMYNUlFkPnWaW9wlyxJCdAEuAF6LtS2tGXMl7gzgdQApZYWUMi+2VoXlHGCrlDIr1oZY4AA8QggHSmjZE2N7anMM8KOUskRK6Qe+BS6NsU2AZRt+MUqkxPx7SYsaVYtQNkopN0gpN8bIpDpY2DjfvN4APwJdWtywWljYWVDtaSIx7nvCjCueBR4gDvrG1jD2AUs77wD+JqUsN9+zv8UNq0a4cymEEMBVwPstalQtLGyUQNCrpg1x0O9Y2NkPWGQ+/hK4vEWNqkWYMXnc9DtWNsZTvxPGxrjqd8LYGTf9Tj3zxLjod1rDXLYpaBEoNJ2B7GrPd/E/cLFjjRCiB3AiytMmrhAqzGo1sB/4UkoZdzYCz6EaQyPWhtSDBOYLIVYIISbG2pgQ9AIOAG8KFVr3mhAiMdZGheEaYjwIt0JKuRv4B7AT2AvkSynnx9aqOqwDzhBCtBNCeFGrxl1jbFM4MqSUe0ENPID0GNvzv8AEYG6sjbBCCPFXIUQ2cC3wWKztqY0Q4iJgt5Ty51jbUg93mSEOb8QynKUe+gLDhRBLhRDfCiFOjrVBYRgO5EgpN8fakBD8HnjGvG/+ATwcY3usWAdcZD6+kjjqe2qNyeOy34nneUOQMDbGVb9T28547Heq2xiv/U6I690a+p2QaBEoNCLE/2K++tWaEUIkAbOB39dSoOMCKWVASjkQpdoPEUL0j7VN1RFCjAX2SylXxNqWBnC6lHIQcD5wpxDijFgbVAsHymX7JSnliUAxyv057hBCuFADyA9ibUsozA7vYqAn0AlIFEJcF1uraiKl3IByy/4S+AIV3usP+yHN/wxCiEdR1/u9WNtihZTyUSllV5SNd8XanuqYwumjxMkkIQwvAb2BgShB+p+xNccSB9AWOBX4AzDT9LiJR8YRpwsQKI+qe8375l5Mz944ZAJqHLQCFUZSEWN7gPgfk0PrtjHe+p1QdsZbv1PdRtS5i7t+J8R5bC39Tki0CBSaXdRU67sQB66mrRUhhBN107wnpfww1vaEwwwL+gYYHWNTanM6cJEQYgcqPHGEEGJqbE0KjZRyj/l3P/ARKrwyntgF7Krm7TULJQrFI+cDK6WUObE2xIKRwHYp5QEppQ/4EBgaY5vqIKV8XUo5SEp5BspdPx5XtoPkCCE6Aph/Yxou0poRQtwIjAWulVK2hoWcacQ4XCQEvVEi789m/9MFWCmEyIypVbWQUuaYizkG8Crx1+8E2QV8aIahL0N59sY00XYozPDey4AZsbbFghtR/Q2oRZK4vN5Syl+llKOklCehBLWtsbbJYkweV/1Oa5g3WNkYb/1OA85lzPudEDbGXb8T6jy2on4nJFoECs1yoI8Qoqe5En8N8EmMbWqVmCtcrwMbpJT/irU9oRBCdAhm8BdCeFAT219ja1VNpJQPSym7SCl7oH6PC6WUceVxASCESBRCJAcfo5LkxVX1OinlPiBbCNHP/Nc5wC8xNCkc8bwSCyoM7FQhhNe8189BxUrHFUKIdPNvN9TEJp7P6SeoCQ7m3//G0JZWixBiNPAgcJGUsiTW9lghhOhT7elFxF/fs1ZKmS6l7GH2P7tQCTL3xdi0GgQnsCaXEmf9TjU+BkYACCH6ogoTHIypRaEZCfwqpdwVa0Ms2AOcaT4eQZwK+9X6HhvwR+DlGNtjNSaPm36nlcwbQtoYb/1OGDvjpt8JZWO89TthzmNr6XdCI+MgO3U8bqi8EZtQqv2jsbbHwsb3Ue5nPtQN8ptY2xTCxmGoULo1wGpzGxNru2rZeAKwyrRxHTGuhNEAe88iTquDofLt/Gxu6+P43hkI/GRe84+BtrG2KYSNXiAXaBNrW+qx8wnUAGId8C5m1Zt42oDvUELfz8A5sbanml112nCgHbAANalZAKTFoY2Xmo/LgRxgXhzauAWV2y/Y78S06lYYO2eb984aYA4qaWdc2Vjr9R3EvjpYqPP4LrDWPI+fAB3j9Hq7gKnmNV8JjIg3G83/vwXcHutzGOY8DgNWmG36UuCkOLXzHtRcYhPwN0DE2MaQY/J46nfC2Bg3/U4YG+Oq3wljZ9z0O1Y21npPTPudMOcx7vqdxmzC/HIajUaj0Wg0Go1Go9FoNJr/YXQ4mEaj0Wg0Go1Go9FoNBrNEYAWgTQajUaj0Wg0Go1Go9FojgC0CKTRaDQajUaj0Wg0Go1GcwSgRSCNRqPRaDQajUaj0Wg0miMALQJpNBqNRqPRaDQajUaj0RwBaBFIo9FoNBqNRqPRaDQajeYIQItAGo1Go9FoNBqNRqPRaDRHAPTFgBkAAAAYSURBVFoE0mg0Go1Go9FoNBqNRqM5Avj/MCY53phHtx0AAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Getting labels\n", + "Getting impscores data\n", + "Computing fwd sims\n", + "Took 0.18344807624816895 s\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Parallel(n_jobs=10)]: Using backend LokyBackend with 10 concurrent workers.\n", + "[Parallel(n_jobs=10)]: Done 40 tasks | elapsed: 0.0s\n", + "[Parallel(n_jobs=10)]: Done 2100 tasks | elapsed: 0.2s\n", + "[Parallel(n_jobs=10)]: Done 2362 out of 2362 | elapsed: 0.2s finished\n", + "[Parallel(n_jobs=10)]: Using backend LokyBackend with 10 concurrent workers.\n", + "[Parallel(n_jobs=10)]: Done 1 out of 1 | elapsed: 0.1s finished\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Getting impscores data\n", + "Computing fwd sims\n", + "Took 0.18466782569885254 s\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Parallel(n_jobs=10)]: Using backend LokyBackend with 10 concurrent workers.\n", + "[Parallel(n_jobs=10)]: Done 40 tasks | elapsed: 0.0s\n", + "[Parallel(n_jobs=10)]: Done 2100 tasks | elapsed: 0.2s\n", + "[Parallel(n_jobs=10)]: Done 2362 out of 2362 | elapsed: 0.2s finished\n" + ] + } + ], + "source": [ + "from modisco.hit_scoring import exemplar_based_hitscoring\n", + "reload(exemplar_based_hitscoring)\n", + "\n", + "SCANNING_WINDOW_WIDTH=25\n", + "\n", + "instance_scorer = exemplar_based_hitscoring.prepare_instance_scorer(\n", + " patterns=(loaded_tfmodisco_results\n", + " .metacluster_idx_to_submetacluster_results[\"metacluster_0\"]\n", + " .seqlets_to_patterns_result.patterns),\n", + " trim_window_size=SCANNING_WINDOW_WIDTH,\n", + " task_names=tasks, bg_freq=background, track_set=track_set)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fraction of values above cutoff: 0.1572\n", + "Getting impscores data\n", + "Computing fwd sims\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Parallel(n_jobs=10)]: Using backend LokyBackend with 10 concurrent workers.\n", + "[Parallel(n_jobs=10)]: Done 40 tasks | elapsed: 0.0s\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Took 0.5228831768035889 s\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Parallel(n_jobs=10)]: Done 9764 tasks | elapsed: 0.4s\n", + "[Parallel(n_jobs=10)]: Done 13072 out of 13072 | elapsed: 0.5s finished\n" + ] + } + ], + "source": [ + "from collections import defaultdict\n", + "from modisco.hit_scoring import exemplar_based_hitscoring\n", + "reload(exemplar_based_hitscoring)\n", + "\n", + "CUTOFF_VALUE = 0.9\n", + "coordinates_to_be_scanned, task0_transformed_scoretrack =\\\n", + " exemplar_based_hitscoring.get_windows_to_be_scanned(\n", + " scanning_window_width=SCANNING_WINDOW_WIDTH,\n", + " contrib_scores=task_to_scores[\"task0\"],\n", + " val_transformer=(loaded_tfmodisco_results.\n", + " multitask_seqlet_creation_results.\n", + " task_name_to_tnt_results[\"task0\"].val_transformer),\n", + " cutoff_value=CUTOFF_VALUE)\n", + " \n", + "(motifmatch_to_coordinates,\n", + " motifmatch_to_coordinatesbyregionidx) = (\n", + " exemplar_based_hitscoring.scan_and_process_results(\n", + " instance_scorer=instance_scorer, track_set=track_set,\n", + " coordinates=coordinates_to_be_scanned))" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index 0\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index 1\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index 2\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index 3\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index 4\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIkAAACMCAYAAAD4MPn4AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXxc1Xn/8e8zo321ZcmSLVuWZMsy2IABxwbbcgyEPcSQNCmQpkAgNClkadpsv7x+TdI0/aVpkzZt06RsAZIQtkJCErNDwMYYvIDxgrxIli150eJF1mItM3N+f2isyLZWz0h3JH3er5de0ty5uuexfXzmzjPnPMeccwIAAAAAAMD45vM6AAAAAAAAAHiPJBEAAAAAAABIEgEAAAAAAIAkEQAAAAAAAESSCAAAAAAAACJJBAAAAAAAAElxXgfQn+zsbFdYWOh1GAAAAAAAAGPGhg0bGpxzOacej+kkUWFhodavX+91GAAAAAAAAGOGme3p7TjLzQAAAAAAAECSCAAAAAAAADG+3EwNO6WfX+t1FAAAAAAAAGMeM4kAAAAAAAAQ4zOJskuk2/7gdRQAAAAAAABjx6et18PMJAIAAAAAAABJIgAAAAAAAJAkAgAAAAAAgEgSAQAAAAAAQCSJAAAAAAAAIJJEAAAAAAAAEEkiAAAAAAAAiCQRAAAAAAAARJIIAAAAAAAAIkkEAAAAAAAAkSQCAAAAAACASBIBAAAAAABAJIkAAAAAAAAgkkQAAAAAAAAQSSIAAAAAAAAoSkkiM7vKzLab2S4z+3ovzy83s0Yzezf89ffRaBcAAAAAAADRERfpBczML+knki6XVCNpnZk945zbdsqpq5xzH460PQAAAAAAAERfNGYSLZS0yzlX6ZzrkPSopBVRuC4AAAAAAABGSDSSRPmSqns8rgkfO9XFZrbJzJ41s7lRaBcAAAAAAABREvFyM0nWyzF3yuONkmY455rN7BpJv5FU0uvFzO6UdKckFRQURCE8AAAAAAAADCQaM4lqJE3v8XiapP09T3DOHXPONYd/Xikp3syye7uYc+4e59wC59yCnJycKIQHAAAAAACAgUQjSbROUomZFZlZgqQbJT3T8wQzyzMzC/+8MNzuoSi0DQAAAAAAgCiIeLmZcy5gZndLel6SX9IDzrmtZvbZ8PM/k/Rnkj5nZgFJxyXd6Jw7dUkaAAAAAAAAPGKxnKtZsGCBW79+vddhAAAAAAAAjBlmtsE5t+DU49FYbgYAAAAAAIBRjiQRAAAAAAAASBIBAAAAAACAJBEAAAAAAABEkggAAAAAAAAiSQQAAAAAAACRJAIAAAAAAIBIEgEAAAAAAEAkiQAAAAAAACCSRAAAAAAAABBJIgAAAAAAAIgkEQAAAAAAAESSCAAAAAAAACJJBAAAAAAAAJEkAgAAAAAAgEgSAQAAAAAAQCSJAAAAAAAAoCgliczsKjPbbma7zOzrvTxvZvYf4effM7MLotEuAAAAAAAAoiPiJJGZ+SX9RNLVks6WdJOZnX3KaVdLKgl/3Snpp5G2CwAAAAAAgOiJxkyihZJ2OecqnXMdkh6VtOKUc1ZIeth1WStpgplNiULbAAAAAAAAiIK4KFwjX1J1j8c1khYN4px8SQf6u/D7B45pwT++GIUQTxbn8yk10a+0xDilhr/Sk+JUOClVpXnpmpOXrukTU+TzWdTbBoDRrq0zqPKDTdq8r1Fbahq1eV+j6praej03Me7EWOvvGm8T4pSS4Jd6GV4npiSoOCdVRdmpKs5OU25GoswYh8eTUMhp7+HWrr61v1Fb9x3TzromBUPutHMzkuI1Nz9T5+RnaF5+publZyojKd6DqAEAAIbGOacDjW3afrBJ22ubtLu+RZ2h0GnndQadWtoDXV8dAbW0B9XSHlDInX5vFC3RSBL1dgd/asSDOafrRLM71bUkTROmFuvKuXmRRdeLzmBILe1BNYf/sg+3tOrY8U49tXFf9znJ8X7Nzk3T9KwU+XiTgnHGSQqGQuoIOHUGQ+oIhNQZ7PqKmJkS/KZ4v08Jcb6u736f/DGQlI33+/R3V87WlMzkqF535eYD6gyGtGJ+/oDnvlt9VD9/Y7eGY9x3kjoDIbUHguoIhtTeGVJHMKTO4J8aO/GvcGLY6zn8mUztgaAq61sUCL9pn5gSr3n5mZpfMOG0gd6pK6HU9cIWVFNbQAcb23S8M3h6bE461NKuts4/9bGUBL8KslKUGDf4Sa9+35/6VkL4e5zf1+uLUG8S4nz66lWlmpyeNOg2x6r7VlXqvZrGiK5xos91BMP9LhBSe+DkPtd9rnPad+S4mtoDkqR4v6k0L11LZ+UoKf70PtDQ3K6Ne47od5v2dx8rnJSirNSEiPrASPOZVDApVXPy0lWal67CSaknjYeHmtu1/WCTyg82aVd9s66fn6+FRVkDXvfZzQcUCDldd97UAc/dur9R975eqV5ycTEh5Lpei9oDoe4+1BEIKeScEuO6/o0T4/xd/+ZxPvl7uW8LOdf9WtYRDKkz4NQeDMmkk/pKfPj1abTd+01Iidc3rz1LiXF+r0MZNZxzenBNld7ZezSy60gKBE/0LaeOQFCdQadANO6Z+hDpa100pCfF6ZvXnqWUhGi8nYwtx9o69U9/eF+tHaffr4x1Qee6X7c7e4yVfd2Y9ryfj/f7lBjnk89nMfuaGwucpIONx1V+sElNbYHu4znpib3e88b5rHtiy+T0JKVmxyk1wR+V904b+jgejf/VNZKm93g8TdL+MzhHkuScu0fSPZK0YMEC970bzolCiIPT0h7QzrpmbT94TOUHm7Sjtklb9x8bsfaBWOL3mRL8PsXH+ZTgNyXG+5SaGKdI75tDrutmqiMQUkt7oOtmPxgalqTIUO093KqUBL++e/28qF2zuT2gr/3vewqGnJbPnqzMlP5nOnz399u0bf8x5WUOT5Ii3m/db6YS43xKS4pTnM8ns56v/6775xOHXPiA3+fTh87K1Tn5mTpnWqbyJyRHbbZPKOR08Fibdje0qLKhRZX1zao+3NqdkBqIc1Iw5NQRDKm5PdAjuTnY33eqOtSqkslp+qsPzozkjzLqVdY363sr31d2WqLSEiO7VTi1z6Um/qnPnWpB4USdk5+puVMzNTs3XQmDSBAeam7vmnm0r1HbDhxTU1vXuHImfcALncGQntm0vztBkxjnU0lumjKS4rWjtlkNze3d5/pMerPikF74m2WK9/f9d9PQ3K6/fWKT8jKSBpUkemxdtX733gEVZKVE/OcZLn9KBvmUFO9TZnK8TOpOeB893qn2zmCfrycnkkHxPZJBGfFdfbsjEFJrR0BHj3e9IeoMhnr/JDNGdQRC2nf0uJaX5ujSOblehzNq/PtLO/Xjl3cqf0LyoMaa/sT57KQPvpLj/fJH4Z6pN851JT29HOdCzmlP+PXy1iVFI9buSHlu80E9uq5aBVkpMfEh5kgyU4+keVd/zoiP6/XvwTl1f4jc0h5QR7Br/Oxt9i9Olp2WoBXzp6o0N12leRkqzU0f8D3CcPinPo5HI0m0TlKJmRVJ2ifpRkk3n3LOM5LuNrNH1bUUrdE51+9SMy+kJsZp/vQJmj99gtehAPDAV57YpCc2VOvLl8/WxNSEqFzz8XXV3Z8SPPL2Xn1ued/Jh417j2jDniP61nVn67YxeNM1EJ/PNHVCsqZOSNaSWdmexHDFv72mVTsbxn2S6P7VuxXv92nlF8qUk57odTj9mpSWqOWlk7W8dLLXoZyxts6gdtU1q/xgU/cHVcfaArqkNEel4RlGpXnpeq+6UXc8vF5PrK/RzYsK+rzef72yS60dQe053KqOQGjAN8AV9c2al5+p3961JNp/NIyAts6gzvvOC3p9RwNJokH6n9cq9OOXd+rjF07TP3/sXEpMnIGP/vcbeuCNKn3q4sIxl0h5fWe9ctIT9dpXlrPsHeNSxEki51zAzO6W9Lwkv6QHnHNbzeyz4ed/JmmlpGsk7ZLUKum2SNsFgGi7o6xYT2yo0SNv79Vdl8yK+HrBkNMDb+zWghkTlRDn04Nrduv2pUV9vmG7f9VupSfF6RMLpvf6PIZfWUmOfrF2j453BJWcMD6XbRxu6dCTG2p0w/z8mE8QjRVJ8f7uukr9ueysRF04Y6J+/PIOffSCfCXFn95Hqw+36pG39io3I1G1x9q193CLZk1O7/e6FXUtWjxrUkR/BngnKd6vRcWTtGpnvdehjAq/eLNK/+/Zcn343Cn6PgmiM/aZsmJ97lcb9eK2g7pq3tjZjygYclq9q0GXzplMggjjVjR2N5NzbqVzbrZzbqZz7nvhYz8LJ4gU3tXsrvDz5zjn1kejXQCIptK8dJWVZOvBNVVqD0S+Dv2FrQdVc+S47igr0h1lRao91q6Vm3ufRFl9uFXPbjmgmxcVKDXC5T04c2Ul2eoIhPR21WGvQ/HML9fuUXsgpDvKxt9stlhnZvrqlaWqPdauh9ZU9XrOv7+0UzLpH1Z0LZvdVdfS7zWb2wM6eKxNM3PSoh0uRtCykmxV1Ldo39HjXocS057cUKP/+9ut+tBZk/Vvfz5/zM2AGUlXzM3T9Kxk3bdqt9ehRNXW/Y062tqpZSU5XocCeCYqSSIAGCvuKCtWfVO7fr8p8hWx963erYKsFF1+dp6Wz56smTmpum91ZXd9n54eXFMln5luXVwYcbs4c4uKJikhzqdVO8bnJ/JtnUE9/GaVlpfmqCS3/9kn8Mai4klaXpqj//5jhRqPd5703I7aJj31To1uXVyoxTO7ZgZV1Df3e73K8PMkiUa3ZbO73tCuZjZRn1ZuPqCvPrlJS2ZN0n/dfEG/db0wML/PdNviIq3fc0Tv7D3idThRs2pngyRpaYk3y96BWMDoCAA9LCvJ1uzcNN27qvdkzmCdqC/06SVda/V9PtPtS4u1Zd8xvbX75Fkqx9o69di6al177pSo76yGoUlO8GthYZZeH6dvtH7zzj41NHfozrJir0NBP75yZakaj3fq3tcrTzr+r89vV1pCnD73wZlKT4pXbkaiKuv7n0l04vlZk1OHLV4Mv5LJacrNSNTrOxq8DiUmvbajXl/49Tu6oGCi7v3LBb0u1cTQfeID05WeFKf7Vo+d2USv7ajX3KkZyk5juTXGL5JEANCDmemOpcUqP9ikNRWHzvg6J+oLfbxHfaGPXpCvrNSE06ZmP76uWs3tAd2xlDfmsaCsJFs7apt1sLHN61BGVCjkdN/q3Tp7SoYunkl9mlg2d2qmrjtvqu5fvVt1TV39dOPeI3phW63uXFbcXXh/Zk7agDOJKuqb5feZCrJIEo1mZqaykhyt3tXAzkKnKD94THf9aqNKctP1wG0fGJNbtnslLTFONy8s0LObD6j6cKvX4USsuT2gjXuOqIylZhjnSBIBwCk+Mn+qstMSdN+qyoFP7kVf9YWS4v36i4tm6OXy2u4lHoFgSD9/o0qLirJ0zrT+i9ZiZJy4ORxvRWBf21GvXXXN+syyIop1jgJ/e/lsdQZD+skru+Sc0w+eK1d2WoI+vfRPtaROJIn6mxVZUd+sGVkpEW8BDu+VlWSr8XinNu9r9DqUmFHX1KbbH1yvlAS/Hrh1gTKSRn6L6bHulsWFMrM+66SNJmsrDikQclrGUjOMc9wRAMApkuL9+tRFhXp1e7121TUN+ff7qy/0qYtmKN7n0wNvdM0menbLQe07elx3sLwnZszJS1d2WmJ3XYLx4t5VlcrLSNKHz53qdSgYhMLsVH3iA9P1yNt79cjbe7W28rDuvmTWSYnpmTmpamoLqL65vc/rVNS1qDiHWURjwdJZ2TLTuK2pdqrjHUF95qH1OtzSoftv+QDLuYfJ1AnJuvacKXp0XbWa2joH/oUYtmpnvZLj/bqwcKLXoQCeIkkEAL34i4sKlBDn0/2rq4b0ewPVF8pJT9T150/VkxtqdKSlQ/etqlThpBRdNmdylCJHpHw+07KSbK3e1aDQOFm2sWVfo9ZUHNJtSwop5jqKfPGyEvnM9M2ntyh/QrJuWlRw0vMzJ3cVo67oY4ezYMhpd0MLRavHiElpiZo3NXPc1lTrKRRy+vLj7+q9fY368Y3zmak7zO4oK1Jze0CPrav2OpSIvL6zQRcVZykxjppVGN+4EwSAXkxKS9THLsjXUxtrdKifT+FP9djbA9cXun1psdo6Q/rKk5u0qaZRty8tko9teGNK2exsHW7p0Nb9x7wOZUTct6pSqQl+3biwYOCTETNyM5J025Ku5WVfvnz2aW9sTiR/+qpLVHOkVR3BEEmiMaSsJFsb9x4d9TM6IvWD57fr2S0H9c1rztIVc/O8DmfMO3faBC0szNLP36hSIBjyOpwzUn24VbsbWqhHBIgkEQD06falRWoPhPTLtXsHdX5XfaHdA9YXKs1L17LZOXrp/TpNSInXxy6cFq2QESVLZnXVIxgPn8gfaDyu3793QH/+gQJlJlOvY7T54mUl+s+bztcN5+ef9lxeRpKS4/19JolOHJ/JzmZjRllJjoIhpzcj2HhhtHts3V797LUKfXJRgW7vUaMLw+uOsiLtO3pcT7+zT4ea2wf11R4Ieh12txNLzJfNph4RQHl/AOjDrMnpuqQ0R/euqlRxTqquO6/vWi1NbZ361m+3an9jm779kbkDXvuOpUV6fUe9bl5YwE4rMWhyepLOmpKhVTvrddcls7wOZ1g9+na1Qs7ptiWFXoeCM5Cc4O9zbPL5TMU5qd3b3J/qxPHibGYSjRUXzpiolAS/Vu1sGJczaDbXNOqbT29RWUm2vvORuRThH0GXnZWrwkkp+sqT7w36d3LSE/Wbu5Yof4L39aJW7azXlMwkZlYCIkkEAP367vXzdPcj7+jzv35HL26r1XdXzFNmysmzLd6qPKQvP75JBxqP6/OXztLlZ+cOeN2ykmzd+5cLtHQWn1jFqmWzs/XA6t1qaQ+cVAx4rHm5vFYXFEzU9KwUr0PBMJiZk6aNe4/0+lxFfbMmpSZoYmrCCEeF4ZIQ59PFxZPG3e6MUleh6i8+9o6y0xL1nzedrzjqq40ov8/0P59aoLd2D24WWyDo9KMXd+hvHntXv/7MRfJ7uOw+EAzpjV0NunreFBKLgEgSAUC/pk1M0ZOfvVg//WOFfvzyTr29+7D+9ePnaWlJttoDQf3whR26d1WlZmSl6InPLtaFMwa3I4aZDSqZBO8sK8nR/7xWqbWVh3TZWWPz36ruWJu27Dumr1xZ6nUoGCYzc9L0u/f263hHUMkJJ9csqqijaPVYVFaSrZfL67T3UKsKJo2f5O8/rXxflfUt+tUdizQhhcSnF0rz0lWalz7o8yekxOvLj2/Sz16r8HTW7qaaRh1rC6iMpWaAJGoSAcCA4vw+ff6yEj3910uUmujXX9z/lr7x1Gat+K83dM/rlbp5YYH+8IWyQSeIMDpcOGOikuJ93XUKxqJXt9dJki5ld70xa+bkVDkn7W44fclZRX0z9YjGoLLZXYV3x0NNtRNeLa/TL9bu0R1Li7pryiH23XB+vq47b6r+7cUderf6qGdxrNpZLzNpyUz6DiCRJAKAQTtnWqb+8IUy3bakUL9+e68OtXTo57d+QN+74ZwxvRxpvEqK92tR0aQx/UbrlfI6TclM0pwhfPKL0aWvHc6OtHToUEsH9YjGoOLsVOVPSB43S84ONbfrK0++pzl56fo7ZkWOKmamf7x+nnIzkvSlR99RS3vAkzhW7WzQufmZLL0FwkgSAcAQJMX79a3r5uq5L5Xppb/5oC5hBsaYVlaSrcr6FtUcafU6lKhrDwS1emeDLpkzmRoMY1hRdqrMTk8SVTaws9lYZWYqK8nWml2HRu125IPlnNPXn9qsY8c79e83zldSvH/gX0JMyUyO148+cZ72HG7Vd363dcTbbzzeqXerj6qsJGfE2wZiFUkiADgDc/IyTitgjbHng+FlG2Nxydm63UfU0hHUpaUkOseypHi/8ickq+KUHc4q6roeU5NobFo2O0dN7QFPl/CMhMfXV+vFbbX66lWlmpOX4XU4OEOLiifpr5fP1OPra7Ry84ERbfvNigYFQ07LZpMkAk5gfQQAAH2YNTlNeRlJem7LQc2dGtkbkBmTUpWZHDuJxVfK65QQ59PiWZO8DgXDbGZOmirqTp5JVFHfrAS/T9Mmjp/CxuPJ4pmT5DPpN+/uU0LcyZ8Jx/l8mpOXLp+Hu0lFQ1VDi77zu21aPHOSPr2kyOtwEKEvfWi2Vu1s0Dee2qyJKQlKTRyZWWG/f++AUhP8Or9gwoi0B4wGJIkAAOiDmWl5aY4eXVet13ZEVt9jYWGWHv/sxVGKLHKvbq/TxcWTlJLArcBYNzMnTW/vPqxQyHUnBirqW1SUnerpttMYPhNSEnR+wUT9cu1e/XLt3tOe/94N8/TJRTM8iCx6vvv7bYrzmX74ifNGfcILUrzfpx/feL6u/Y9VuunetSPa9pVzcxXvZ4ENcEJEd4ZmliXpMUmFkqokfcI5d6SX86okNUkKSgo45xZE0i4AACPlG9ecpSvm5sq5M7/Gi9tq9ei6atUea1NuRlL0gjtDuxtatLuhRbcuLvQ6FIyAmZNTdbwzqAPH2pQ/IVmSVFnfrDlTKFg+lv3k5gu0dX/jacd/+MIOPbB6t25eWDBq65HtbmjRy+V1+uJlJZqSmex1OIiSouxUPf+lZdpR2zSi7c6fziwioKdIPz78uqSXnXPfN7Ovhx9/rY9zL3HOjb2iDgCAMS0zOV6XzsmN6BrTs1L06LpqvbCtVp+6yPtP718pr5MkXUrh9XGhe4ezumblT0hWRyCkPYdbde25UzyODMMpLzNJeZmnJ6Ubj3fqy49v0updDaO2WO/Db1Yp3m/65KICr0NBlE3PStH0LJbBAl6KdF7dCkkPhX9+SNL1EV4PAIAxp2RymoqzU/X8loNehyJJerW8TrMmp3EjPk50J4nCO5ztPdyiYMhRtHqcuvbcKcpOS9BDa6q8DuWMtLQH9OT6Gl1zzhRNjoGZmQAw1kSaJMp1zh2QpPD3vj6SdJJeMLMNZnZnhG0CADCqmJmumJuntZWH1Nja6Wksze0BvbX7ELOIxpHstARlJMV1J4l2hXc2K85J9TIseCQxzq+bFxbo5fI67T3U6nU4Q/bUxho1tQd0C8tlAWBYDJgkMrOXzGxLL18rhtDOEufcBZKulnSXmS3rp707zWy9ma2vr4+sSCgAALHiyrm5CoScXi6v9TSO1Tsb1Bl0uqSUJNF4YWaaOTmte9v7E8miYmYSjVufvGiG/GZ6+M0qr0MZEuecHlxTpfOmZep86sgAwLAYMEnknPuQc25eL1+/lVRrZlMkKfy9ro9r7A9/r5P0tKSF/bR3j3NugXNuQU7O6FwnDQDAqc6bNkF5GUl6zuMlZ6+W1yk9KU4LCid6GgdGVnF2WndyqKK+WXkZSUpLZGe78So3I0lXnzNFj62vVkt7wOtwBm31rgZV1LfolsWFo7boNgDEukiXmz0j6Zbwz7dI+u2pJ5hZqpmln/hZ0hWStkTYLgAAo4rPZ7pibq5e31mv1g5v3pQ55/Tq9jotK8lhu99xZubkVNU1tauprVOV9S2aOZmlZuPdrYtnqKktoKff2ed1KIP24BtVyk5LoOg6AAyjSO8Qvy/pcjPbKeny8GOZ2VQzWxk+J1fSajPbJOltSX9wzj0XYbsAAIw6V83NU1tnSK/v8GY59db9x1TX1K5LqEc07vypeHWLKuqbKVoNXVAwUefkZ+qhNVVyznkdzoD2HGrRK9vrdPPCAiXG+b0OBwDGrIiSRM65Q865y5xzJeHvh8PH9zvnrgn/XOmcOy/8Ndc5971oBA4AwGizsChLE1Li9fxWb+oSvVJeJzNpeSnLucebE0mhtyoPqaktQJIIMjPdsrhQO+uatabikNfhDOjhN/fIb6ZPXjTD61AAYExjrjkAACMkzu/Th87K1Uvv16ojEBrx9l8pr9O50yYoOy1xxNuGt2ZMSlGcz/TCtq4EJUkiSNKHz52irNQEPbimakTbdc4pEBz8GNjSHtDj66t19TlTlMu29wAwrEgSAQAwgq6cm6emtoDWVo7sJ/eHmtu1qeaoLmVXs3Ep3u9TwaQUbdx7RJKoSQRJUlK8XzcvLNBL79eq+nDrsLdX1dCiH7+0U5f96DWd/ffP686H12vl5gNq6wz2+3tPvbNPTW0B3bqYWUQAMNzY1gIAgBFUVpKtlAS/nt96UMtmj9yyrz9ur5dz0qXUIxq3ZuakqbK+RSkJfuUxGwNhn7yoQD99rUL3r96tz186K+rXb+0I6qX3a/Wbd/drU/VRmUmLirK0eOYkPb+1Vi9sq1V6YpyumpenFfPzNWdKunruW+YkPbymSvPyM3RBAbsyAsBwI0kEAMAISor3a3lpjl7YVqvvrpgnn29ktnF+ZXudctITNXdqxoi0h9hTnJPa/Z3tw3HClMxkXTUvTw+uqRrWZWdnTcnQN66eo+vOm6qpE5IlSd/5yDy9WXFIv3l3n57dclBPbKjp8/f/5c/Opd8CwAggSQQAwAi7cm6eVm4+qHeqj+jCGVnD3l5nsGtHtavn5Y1YUgqx50QdIuoR4VTf+vDZuqh40rDscmZmWlSUpdm56ac95/eZlpZka2lJtv7x+nn64/Z61TW1nXZecrxfN5yfH/XYAACnI0kEAMAIu2TOZMX7Tc9tOTgiSaINe46oqS3AUrNxjiQR+jI5I0mf8njXsKR4v66al+dpDAAAClcDADDiMpLitXhmtp7fWjssn9yf6tXyOsX7TUtLRq4GEmLP2VMyVFaSTbIQAAD0iSQRAAAeuHJunvYebtX7B5qGva1Xyuu0sChLaYlMIB7PkhP8+sXtizQvP9PrUAAAQIwiSQQAgAeumJureL/psXV7h7Wd6sOt2lnXrEtKmT0CAACA/pEkAgDAA9lpibruvKl6YkONGo93Dls7r26vk9RVBwkAAADoD0kiAAA8cvvSIrV2BPXo28M3m+jV8jrNmJSi4uzUYWsDAAAAYwNJIgAAPDJ3aqYuLp6kh9ZUKRAMRf36xzuCWlNxSJeUTpaZRf36AAAAGFtIEgEA4KHblxZpf2Obnt1yMOrXfrOyQe2BELtZAQAAYFBIEgEA4NvxT8MAAAgMSURBVKFL50xWUXaq7lu9W865qF77lfI6pST4tag4K6rXBQAAwNhEkggAAA/5fKbblhRqU/VRbdx7JGrXdc7p1fJ6LZmVrcQ4f9SuCwAAgLGLJBEAAB77swunKTM5Xvev3h21a+6obda+o8dZagYAAIBBI0kEAIDHUhLidNPCAj235aCqD7dG5ZqvlNdJki4pJUkEAACAwYkoSWRmHzezrWYWMrMF/Zx3lZltN7NdZvb1SNoEAGAsumXxDPnM9OCaqqhc79XyOp09JUN5mUlRuR4AAADGvkhnEm2R9FFJr/d1gpn5Jf1E0tWSzpZ0k5mdHWG7AACMKVMyk3XNOVP02LpqNbV1RnStxtZObdh7hKVmAAAAGJKIkkTOufedc9sHOG2hpF3OuUrnXIekRyWtiKRdAADGotuXFqm5PaDH19dEdJ3XdtYrGHK6hCQRAAAAhiBuBNrIl1Td43GNpEUj0C4AAKPKedMnaMGMifrn58p17+uVZ3ydprZOZaUmaP70CVGMDgAAAGPdgEkiM3tJUl4vT33TOffbQbRhvRxz/bR3p6Q7JamgoGAQlwcAYOz49kfm6pdr98j1+Uo5OEtLsuX39fYSDAAAAPRuwCSRc+5DEbZRI2l6j8fTJO3vp717JN0jSQsWLIjwFhkAgNFlXn6mvv+xc70OAwAAAONQpIWrB2OdpBIzKzKzBEk3SnpmBNoFAAAAAADAIEWUJDKzG8ysRtLFkv5gZs+Hj081s5WS5JwLSLpb0vOS3pf0uHNua2RhAwAAAAAAIJoiKlztnHta0tO9HN8v6Zoej1dKWhlJWwAAAAAAABg+5iKtjDmMzKxJ0nav48CokS2pwesgMGrQXzAU9BcMBf0FQ0WfwVDQXzAU9Bf0ZYZzLufUgxHNJBoB251zC7wOAqODma2nv2Cw6C8YCvoLhoL+gqGiz2Ao6C8YCvoLhmokClcDAAAAAAAgxpEkAgAAAAAAQMwnie7xOgCMKvQXDAX9BUNBf8FQ0F8wVPQZDAX9BUNBf8GQxHThagAAAAAAAIyMWJ9JBAAAAAAAgBEQk0kiM7vKzLab2S4z+7rX8SC2mNl0M3vVzN43s61m9sXw8W+b2T4zezf8dY3XsSI2mFmVmW0O94v14WNZZvaime0Mf5/odZyIDWZW2mMcedfMjpnZlxhjcIKZPWBmdWa2pcexPscUM/tG+J5mu5ld6U3U8Eof/eVfzKzczN4zs6fNbEL4eKGZHe8xzvzMu8jhhT76S5+vP4wv6KPPPNajv1SZ2bvh44wxGFDMLTczM7+kHZIul1QjaZ2km5xz2zwNDDHDzKZImuKc22hm6ZI2SLpe0ickNTvn/tXTABFzzKxK0gLnXEOPYz+QdNg59/1wMnqic+5rXsWI2BR+TdonaZGk28QYA0lmtkxSs6SHnXPzwsd6HVPM7GxJv5a0UNJUSS9Jmu2cC3oUPkZYH/3lCkmvOOcCZvbPkhTuL4WSfn/iPIw/ffSXb6uX1x/GF0i995lTnv+hpEbn3D8wxmAwYnEm0UJJu5xzlc65DkmPSlrhcUyIIc65A865jeGfmyS9Lynf26gwCq2Q9FD454fUlWgETnWZpArn3B6vA0HscM69LunwKYf7GlNWSHrUOdfunNstaZe67nUwTvTWX5xzLzjnAuGHayVNG/HAEJP6GF/6wviCfvuMmZm6Pkj/9YgGhVEtFpNE+ZKqezyuEQkA9CGcDT9f0lvhQ3eHp24/wPIh9OAkvWBmG8zszvCxXOfcAakr8ShpsmfRIZbdqJNvrBhj0Je+xhTuazCQT0t6tsfjIjN7x8xeM7Myr4JCzOnt9YfxBQMpk1TrnNvZ4xhjDPoVi0ki6+VYbK2JQ0wwszRJ/yvpS865Y5J+KmmmpPmSDkj6oYfhIbYscc5dIOlqSXeFp+UC/TKzBEkfkfRE+BBjDM4E9zXok5l9U1JA0q/Chw5IKnDOnS/py5IeMbMMr+JDzOjr9YfxBQO5SSd/2MUYgwHFYpKoRtL0Ho+nSdrvUSyIUWYWr64E0a+cc09JknOu1jkXdM6FJN0rptsizDm3P/y9TtLT6uobteH6VifqXNV5FyFi1NWSNjrnaiXGGAyorzGF+xr0ysxukfRhSZ904SKh4WVDh8I/b5BUIWm2d1EiFvTz+sP4gj6ZWZykj0p67MQxxhgMRiwmidZJKjGzovCnuDdKesbjmBBDwmtr75f0vnPuRz2OT+lx2g2Stpz6uxh/zCw1XOBcZpYq6Qp19Y1nJN0SPu0WSb/1JkLEsJM+fWOMwQD6GlOekXSjmSWaWZGkEklvexAfYoiZXSXpa5I+4pxr7XE8J1wwX2ZWrK7+UulNlIgV/bz+ML6gPx+SVO6cqzlxgDEGgxHndQCnCu/ycLek5yX5JT3gnNvqcViILUskfUrS5hPbOUr6P5JuMrP56ppmWyXpr7wJDzEmV9LTXblFxUl6xDn3nJmtk/S4md0uaa+kj3sYI2KMmaWoa5fNnuPIDxhjIElm9mtJyyVlm1mNpG9J+r56GVOcc1vN7HFJ29S1rOgudh4aX/roL9+QlCjpxfDr01rn3GclLZP0D2YWkBSU9Fnn3GCLGGMM6KO/LO/t9YfxBVLvfcY5d79Or6soMcZgECw8uxUAAAAAAADjWCwuNwMAAAAAAMAII0kEAAAAAAAAkkQAAAAAAAAgSQQAAAAAAACRJAIAAAAAAIBIEgEAAAAAAEAkiQAAAAAAACCSRAAAAAAAAJD0/wEn3p3cTVsuyAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index 5\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index 6\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index 7\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index 8\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABI0AAACMCAYAAADx21mCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3gU1frA8e/sbnpPgISa0DvSm4AiFgQVC2L/YUH0em3Xq9euYAe7onLFcm2gNJUqSJHeey+BJCQhJCF9U7bN74+zJZtsMIHQ38/z5Mnu2dmZs7uzs2feOec9mq7rCCGEEEIIIYQQQghRnuFsV0AIIYQQQgghhBBCnHskaCSEEEIIIYQQQgghKpGgkRBCCCGEEEIIIYSoRIJGQgghhBBCCCGEEKISCRoJIYQQQgghhBBCiEokaCSEEEIIIYQQQgghKjGd7QqcSJ06dfSEhISzXQ0hhBBCCCGEEEKIC8amTZuydV2v+3fLndNBo4SEBDZu3Hi2qyGEEEIIIYQQQghxwdA0Lbk6y8nwNCGEEEIIIYQQQghRiQSNhBBCCCGEEEIIIUQlEjQSQgghhBBCCCGEEJVI0EgIIYQQQgghhBBCVCJBIyGEEEIIIYQQQghRiQSNhBBCCCGEEEIIIUQlEjQSQgghhBBCCCGEEJVI0EgIIYQQQgghhBBCVFIrQSNN0wZrmrZP07SDmqY9d4LlemiaZtc0bXhtbFcIIYQQQgghhBBCnB6nHDTSNM0IfAZcC7QD7tA0rV0Vy40DFpzqNoUQQgghhBBCCCHE6VUbPY16Agd1XT+k67oF+BkY5mO5x4AZQGYtbFMIIYQQ4uwyH4HFV0La3LNdEyGEEEKI08JUC+toCBwpdz8V6FV+AU3TGgI3AVcAPU60Mk3TRgOjAZo0aVIL1RNCCCGEUBISIDm5ttbWGFhUWysT55j4eEhKOtu1EEIIIc6u2ggaaT7K9Ar3PwKe1XXdrmm+Fi/3RF3/EvgSoHv37hXXI4QQQghx0pKTQa+N1oW1EGbEgMMKpjDo+wM08tXRWpyv/qbJKoQQQlwUaiNolIq61ObSCEivsEx34GdnwKgOMETTNJuu67/VwvaFEEIIIc6srFVgDFJBI1sRHF0oQSMhhBBCXHBqI2i0AWipaVpTIA24Hbiz/AK6rjd13dY07X/AHAkYCSGEEOK8lfEnWIucd3Q4+sdZrY4QQgghxOlwykEjXddtmqY9ipoVzQh8o+v6Lk3THnY+PvFUtyGEEEIIcU5Jnwc4PPeLU89aVYQQQgghTpfa6GmEruvzgHkVynwGi3Rdv7c2timEEEIIcVboOhQd9i4zBp2dugghhBBCnEaGs10BIYQQQojzSll25TLdUblMCCGEEOI8J0EjIYQQQoiaKDoMxgDvMlvx2amLEEIIIcRpJEEjIYQQQoiaMB9WQ9QAIjuCwQ+wn9UqCSGEEEKcDhI0EkIIIYSoieJUsJdCg2thyHbo9snZrpEQQgghxGkhQSMhhBBCiJowJ4FuhTZPq/vN7gWtVuYWEUIIIYQ4p0jQSAghhBCiJoqSQDNAnd7qvr0MYroDMG3XNAxjpXklhBBCiAuDtGqEEEIIIWqi+AhEdATdpu4bAyF2IABrUtego5/FygkhhBBC1B4JGgkhhBBC1ERpJkS299w3BkB0NwAcuuMsVUoIIYQQovZJ0EgIIYQQoiZsZghpCsZgT1loSwCsdisgwSMhhBBCXBgkaCSEEEIIUROOUohoD4Zyya+DGwFQbC0GoMhSdDZqJoQQQghRqyRoJIQQQghRXboDHBYITfAu948AwGwxA1BYVniGKyaEEEIIUfskaCSEEEIIUV22YtBMEBjnXW63AJ4eRgVlBWe6ZkIIIYQQtU6CRkIIIYQQ1WUrAoMfBNTxLneooFGBRQWLJGgkhBBCiAuBBI2EEEIIIarLVgSaEUwhFR7QAU+wqNAiw9OEEEIIcf6ToJEQQgghRHXZitSsabq9wgMaAEVlMjxNCCGEEBcOCRoJIYQQQlSXtQhMoeCweZdrqklVZJWgkRBCCCEuHBI0EkIIIYSoLpszaKRXDBoZAcgvywdk9jQhhBBCXBgkaCSEEEIIUV22IjAFge7wLtdMAFics6hJTyMhhBBCXAgkaCSEEEIIUV22IjAF40p87Wbw87qbU5pz5uokhBBCCHGaSNBICCGEEKK67KUqEXZFmuZ193jx8TNUISGEEEKI08d0tisghBBCCHHe0B1gDME1W1pVMs2ZZ6Y+QghxDkhIgOTks10Lca6Lj4ekpLNdC1FTEjQSQgghhKgu3QFGf3wFjcpsZe7bR4uOnsFKCSHE2ZWcDLr+98vVGq2KwP0ZrYSoqao+NnFuq5XhaZqmDdY0bZ+maQc1TXvOx+N3aZq23fm3WtO0S2pju0IIIYQQZ5YDNIPPjkaFFs+MaVnmrDNYJyGEEEKI0+OUg0aaphmBz4BrgXbAHZqmtauw2GHgMl3XOwGvA1+e6naFEEIIIc443YGKGFWOGpWfMS2nRBJhCyHESbHkQVHS2a6FEMKpNnoa9QQO6rp+SNd1C/AzMKz8Arqur9Z1Pdd5dy3QqBa2K4QQQghxZukOqmo+FZapnkZGzUiJreQMVkoIIS4QBfthVjOY0wb2feYuNr1m4tKvLz2LFRPi4lUbQaOGwJFy91OdZVV5AJhfC9sVQgghhDjD9MpJGWbGwWSNgrldAAj2Kze7WlycWr7iX1zcGayzEEKcJzY9rnoaOcpg6zPuYrtuZ2fWzrNYMSEuXrURNPKVzspnBjJN0waigkbPVrkyTRutadpGTdM2ZmVJPgAhhBBCnEM0A5WaOaXHAChwqPJQ/1DPY8eO+V5PVeVA2Fth9JzU81RqKYQQ55/8PZC5HPcxtkJS6/KTDQghzpzaCBqlAo3L3W8EpFdcSNO0TsBXwDBd149XtTJd17/Udb27ruvd69atWwvVE0IIIYSoLZpziFplhc7isIAwAKx260ltochaxJaMLSf1XCGEOG+lTAeHzXPfUer1cJm9XNAoNrby832VCSFOWW0EjTYALTVNa6ppmj9wOzCr/AKapjUBZgL36Lq+vxa2KYQQ55bM5bDyNji27PRvy1YC6/8Bf10H5pTTvz0hhIe7p1HlTtUFzqBRiF8I4D2bWk3Zyp84CSHExSBtNuhWCIyFyE7uYoevQH1GhndPJF1XZUKIWmc61RXoum7TNO1RYAFgBL7RdX2XpmkPOx+fCLwCxACfayoPgE3X9e6num0hhDgVCQmQnFxbaxvg/DsTgoAvztC2RHw8JCWd7VqIc4dB9TTyMRDfFTRyDU8rLCsk+gzWTAghzlu6A/K2gykErtsDxmBYORyAvNK8s1w5IS5upxw0AtB1fR4wr0LZxHK3RwGjamNbQghRW5KTKw2XPzl/DoCsVYBzVqU77bWw0irk74U/uoLdOTOTKRRGnHxvBvH3KuY8Fhc5zQD2UtT33Vue86sf7h8OQEFZQY1Xr9fKQUkIIc4zhYmgmaDN02DwB2MAdPsEgCyz5LkV4myqjeFpQghx8So6DDkb8ZxA+s51UmsSJ4HD4rlvKzq92xPiIqPrkJgI1qrSEWkGsJl9PpTjDBpFBEYAJxc0OpnnCCHEeS9/B2hGaPGg6m0EEFAHgExzpnsxCawLceZJ0EgIIU5F+jxAg4C60PQe9f90OjITdDvUHwzNR6kGlhCiVlitMHAgtGsHrVuDz0lcjcGenn4V5DhjxlFBUYAzAFRVYtYqyo+ZPbOqycmREOKiUZwO/lEQEOMp09SgmKxiz8E4vyz/TNdMiIterQxPE0KIi1babLAXw1XLIaID5O88fdsqy4GSdIjqCv1nqjJT6ImfI4SotvHjYcMGsFggLQ1Gj4Zff62wkF+o+s5TedziLufEPvMPzAcgMTfRk5jVNc7xbwJBx4o8QaOCsgJ3ryUhhLiglaRDZHs1/NcYqMpMQYB3T6NMcyaRgZE1Xn12cTZ9v+7L/sdkTiYhakp6GgkhxKk4vh4aD4ewVmr8fVjr07stYyD0/EJtyxQEl7xx+rYnxEWkuBjeeEP9BxU4WrjQx4KmULAV++zld9g54dmhvEMAbEjbUON6lO9pVP429lJYcSvM7QBHKkayhBDiPGdOhvA2YAyq9FD5YHr5AFJNbD+2nQM5ByiyyLB+IWpKgkZCCHGyrAVgLYJmI8EvTJX5ncaePwV7VWMq8hLntN+ATMstRK2YPx/8/KBOHXjoIWjRooq8RqZQlUvMUK6zdqAaamat0InoZGb8KX9yVP4260ZD+hzI3wWr7wZHVUmXhBDiPFScCsGN1EWxClILUt23TzYptmsdKfkpJ1c/IS5iEjQSQoiTVZymev7U7X9mtmdOgpgezpmbnGR4mhC14tdfwWyGefPg449h1SoIqnzB2xM00vw8ZTerIWgV5038u9wbSXlJDP1pqFfZ0aKj7tvunkYZiyF1pue7by8Bgx9CCHHBKM2AkHifDx0pOOK+fbI9jY7kq3VI0EiImpOgkRBCnKySNAhqWP2Tt7g4ldek/F9cXPW3V5io8hm5ZhUBMEgibCFqw5IlMGIEtG0LAQEQHg4vv+xjQb9QFbypnNKoUtAopyTnhNuctW8W8w7Ow1aux2ByXrL7trun0f7P1IxtMT2hxUNgCq7mqxJCiPOEJVe1qXxIykty3y6fFLsmXMEiCRoJUXOSCFsIIU5WcRoE1QeHBajGSdyxY9Urq3J7KRB/m/ewGCHEKbNa1Vfx3nsh1Nl5LzAQ7r7bx8KmUNBtYC0E/xMnYy0oKzjh42kFaYC6At40qikAKQWeE5qjRUfVENSjCyCyEwxaooamNryh2q9NCCHOC7rNe+a0csoHelw9hmpqb/ZeAA7lHjqp5wtxMZOeRkIIcbJK0iCgDj67HKB6DCw5vKQWt5cBIQm1tz4hBKBmSgsOhksv9S4PD/exsClUBXLKvK92OxyVFzVbzSfc7uG8w4BzljVXWe5h9+2U/BTI2aySbvf8UuU0MwZBvTM0JFYIIc4U3VFlz+0SWwmh/iqin1aYdlKr35G5A4AtR7ecXP2EuIhJ0EgIIU5WSQYE1weDv8+HB30/iEHfD6q97dmKILhB7a1PCAFAcjI0aADGCqM9LRYfCxuDQLdDyVGv4uM+gkalttLKheUcOH4AgMQcT9CofO6O1IJUKNynrr5HlUuAbwxBCCEuKLrd56yUdoca+NswTA1dO1p4tNIy1ZFbmgvA5ozNJ1lBIS5eEjQSQoiT5SgDv3CfM32AZ+Ykh+48m4yNrbyQr7Kq6HZJfC3EaZCcDA0bQlmZd7mfr4vemqYCxUWJXsV5zq+5hkaA85ig63rFZ3vZk7UHgH3H93mV1w+tD7iCRgchphfYy0WwDNJ8E0JcaAyqt5HLzDiYrJHzozoQh/ipYHn5wHp1uQJPRs1IdnH2qVdViIuMtDqEEOJk2S1qBiXN96H0eMlxoNz4+4wMKH8SqeuqDJXbZP6B+Sfenu7weRVOCHFqjh3z5Kkvz+fsaaBmTczf4xXIcX2zW9dpzcbRGwGIDoo+4XbLHCpKtTZ1LQBFliIA9zCM5PxkyNsJYc3BVFVl8D6uCCHE+UgzqLxGLqUq5+OmUnV82565HTi5RNiumShdx2RXEEkIUT0SNBJCiJOlaXhOFXFfFWOyd2BnT/aev13V8GnDGTJ5SKXyph815ZN1nzi3R7W2J4SoGYsFIiIq9yyqskOPXzgUHQZ7ibuowHmBPDwgnPgINW10ia3E17MBMFs8+Y42pqsg0+Z0NWzClevIYrdA0UGI6OA714etBFbfDT/7wbQoSJt3opcphBDnLs2oJhioYK9V/S8/y2T5274YxhqI/zDefd+VSDsuVM1Ye7So3BC3nC2w6SnY9Y6apVIIUYkEjYQQ4mQZ/NRVMVd36lLXTGgOr1mTXENQTiS9IB3wnqJb13WS8pP4YuMXzhKjGqLmUm57QoiTZ7PVcMRXYCzkbfXMZGgrdgeNQvxCCPJTvYKKrcVVrsI1g09UYBRWhxVd190BZq+TI0sBhCZUXoGuw5Ir4chMdVyw5sHKW2vwIoQQ4hxiClW5IitI8REfKj9hgC86utdMlK6gkSsvkns2tsRv4M9LYd+HsHMszO0A0gtJiEokaCSEEA4bZK+H3K01G+ZhCARLLtgrJ7t1Te0KsCF9w9+uytW4KT+rh+uk0t04MhjBkl/9+gkhqsVgqOEIr+AmKteQwzk8TbdT6AwahfqHYnIGk4qtxVXmNXLNmNY4vDEA2cXZPqeCttpKfCfbT/0d8rZBi4dhhBmu2wshjWvwIoQQ4hwSWA+KK+crSvURNNqXva9yoVNhWeXeSkl5SQA0DC8XNCo6BBsfVRcBuk+Alv+A4nTV1hJCeDGd7QoIIcRZlbsNVgyHUme+ociOcNXK6jUagupDzkbniWOw10PlexetSFlxwtWUH1u/6egmBjVTM665hqyU2Z3Zef0ioCQNwltV44UJIarLzw9KS8Fe3QvMoc3U/2NLodGNgPfwNIAgUxAlthLK7GUEmgIrreJgzkEAEiIT2J65ncTcRJ8JXq0OG0Hl404z4zy9DBvdBJe8BqZgCG0Bg5ZV8wUIIcQ5JqgBFCernj4GowrmlB7jqLXyoq6guy9bMjwX37LMWdQNqcvUXVMB+HbrtwD8tuc3bi+cry4ADF6vZqR0lEJsLc54K8QFRHoaCSEubosHqiFmXd6DTmPVjEjVvcoU3BDKjnvuB3pmQtuRuQOAiIAIUgtSTziL0v7j+z3VObTYfXvVkVXu25nmTBWkKirXJTuwBjOvCSGqFB6ukmFXDBpVnE3NLaQxGAJg5+sqeeuOse6gUZh/GAABJjWDWvmhquX9mfgn4OlRuDZ1LRmFamhGgDHA3VvJojvAXi7PhntYKtDpNc+MigajCh4JIcT5KCQeipI8x7ubncdD5wQFzSKbERMUA+AzEO/iuuAG6kIceIL0rtlsN2dshvR50PkdMAY7j58hUO+y2nxFQlwwJGgkap9rCpqKf3FxZ7tmQlQW1BCGbIfmD0CrR2Hozpo9tzhNzaQE7gYOwOojqwFoFqV6JJxoto/NRze7by88tNB9e87+Oe7bG9M3QnA8FOzzzNh0c+Wx/0KImmvSRE1kaKwQLy51jjx9fdnraGM1T/A3uDEYA9SQ1p/9Ye/7lXoauU5qqgoauY4RO7PUMef3fb+7k7Q+1O0hhrYYCoDdFAYF+yuvwBgM4a29y/zCqv2ahRDijDEfgT3vwc434HgVQ/aDG0HeDpyzfrgZnHcn3TCJ0d1GA2DXq+4W+lfSX+7bG9LUtsxW7wTXWulRsBVD/Ws8uekAjCeYpVKIi5gEjUTtO3asZuVCnE2dxzmvMpnUSaBfuO/lfAVDuw6C7IM+Z9tYl7oOgJ2Z6oRw+u7pVVbBNd12h7odAHWSaXfYOZx3mDpBdTzrC2uuhsPZq56RSQhRc/HxkJICgVVcvP5u23cA7M7arQpcw9MAHGrsRK7zHCYsQAVuXEEjX/k1oPJJzIHjB8gszgTg+tbXMyBhAAAZhkgo2A2uYaquHobhrdRJjxBCnMt2vwdzWsGRX+HYMlhylcoHWVFQHJgPq1nUyjnmPLZGBkYSHRQNOHtfV2Fhoufi27JkNWS34mxrjSmGiHaqp3l5ks9ICJ8kaCRqX2wVQ2aqKhfibCh1NjhiB3o3EoxVd3muJAfw01Vek3LybOBwzmhmdZ5QrkiuOq/RlJ1TAEjKTwJgzr457oTYEYERAEzbPU113c7ZUrM6ijPPWgD7JsCfA2BBL9g+RvVIE+cehxXsZcTHQ14eHDzo/XBAgMo55sqfMW33NPVAaFM13X05x8vNngYQ7KeGivnqaVRmK0NH9VoyaKopll2cTUaR6j0YFRhFVGAUAPttfs4ehs5uT64ehgZ/oNyw15lxMFmDyXLSI4Q4R2Qsgj3jYdBfMHAB9J8O1+8Df3V8e2HRC/xx8A+1bFhL53P+VBOUOGU7g0ZRgVFEBkYC5WY/qyCzKJMyexmh/mrY7uLDi92B+0BTIP/s8U8AAtDBFOY9I60cQ4WokgSNRO3LyPCehkbX1V+GDKUR55Ay59T22okXc3Pt1+X37VIdguvCoW/BWuQu/qvUtWoNP4MfANszt/tcrcPh4HiJyotUZFHrmL5nOl9t/grwJHvck70HR3h7wK4aVHYfmSHF2VecBnPaqy72Xd+Hnl+Cwc+7+7s4+1JnwbwuMO8S+KMb4cvbE+CvM3WqZ0gawF9/eXoCAry3+j11wy9cfa7luHoauYJFwX7BaGg+g0bphekAxATFMObyMQCYDCayi7MBiAqKIipInVTtLbXA8Y2qJ2R5ZdnedXDnOnJU800Q4hzlq2fvmU5xcC7U4UKwaxy0fQYiO4FfKPhHgH9dQAXK3171Ntf+dK1aNrKT6j257QXQre7elfnOQ1pkYKQ7mO46hlb0y65fAE97CmBZkuptFB8Rz4QhE4gMjKRY19Gt+d69muQYKkSVJGgkfMoryWPHsR1nuxrnN8ntdG5z9dbRyp3Mn8xVpjq9VTLFnI3uBk6Js73RvUF3nuz9pNqc5nud69PXA6q3getkc9PRTSxPWV5p2S1Wg+rdsOGfzgZVaaVlzhvWAkiaAns/gv2fwdGFasaU892mJ6DZSBUwiukBUZdAmyclafm5ZtvLMGAGXLMerl4NV/5Fl64a//0vWJwpw4qL4bXX4PMNnwMqP5nZamZv1l61QEQ7r1XmOVQM2vU9dvU4KrRUHp7mSn7dvm57Xh7wMkGmIMxWM3mleQBEB0W7h2GsM5eArUgFusp/54sOeQexZR8TFwpf6QxOIsXB+JXjmX9g/lmtw0UvexXE3w6mcrmCDOr0c8L6Ce6iQ7mHVCL/4IaQvxs2PAqJk7DpUOw8zIUHhLt7Grl6ZVa05PASQAXhXb04Z+yZAUBsiDpGRgdFs88Cev4u76CRHEOFqFKtBI00TRusado+TdMOapr2nI/HNU3TPnE+vl3TtK61sd1zjq8ggdF4zgQOzBYzx4r+/gdP13XiP4qn08ROXjMQ+FgQMpbAmvth7QOwdhSsuhsOfe/JvSDE6XQqVwJDmqj/Bft8PFiDq0wNr1dTtS67Hparqbf3OE86h7UexjN9nwEgtSDV59Nd5b0b9uaDqz8A1HCYEufQlwc6P0DrGJXsNqkwSyW+LU6BeZ1g0eXVr2ctWrMGHnwQ7rsPHngA7rwTPvgAcn2kKPDp4FeweJDqnt74FmhwLRQeBEvOaa33GZE6SyVU9wv1lJlCaraOMWN8/26MGeN7eV1XSUbzdkHBAZ85toSTK8jS72eVWN4vVPUaCqzLjTeqffiuuyAxUb3da9Y43MNHXd/V/yz6j1pHw+tB8/T0ydcC0TQDIf7q83YNj/DV08jVgzA+Mh6AuiHqyrvFbkFDIzwgnKjAKDQ0NhYVqJOpDf8AS57372vqzNpPjC8XPGrPmX4vz2TvmNP52nylM6hhioON6Rt5dvGzDJk8hBLrSeQBrIU6XJSK09XvYNJklcNId3gHZpwX58p+1Bi7bKy7+KXFL6kb9a8BNDj0DWx8jGy7CsYHmgIxGoxEBkaiobl7ZVZUalOB9fs738/QlmoygSyzmoikYXhDAOqF1OOoHayGADi6wDMUTiYXuWjk5sIbb8BNN8FDD6k27Q03wPffg83298+/GJ1yf3lN04zAZ8BVQCqwQdO0Wbqu7y632LVAS+dfL+AL5//zU2k2pP4OJameXgq6HRznbqDEbDET+rZqwC66ZxGDmg2qctmP131MgUU1cntM6kHBcwXuxJ5eNj6mcir0+Mzz2l29Nyp2oz/TxoyBsWMrl7/6atUnXqdoyeElDPp+EM/0eYbxV4/3Ho6nOcdAnWDa9RPSdbWPaUbPumogrSCN9WnrubHNjWgn8fwLkvMKFNtfhb7fqxP7mzNUT6OaaHAtbHxc9QA4qsblb3R+HRIiE6gTXAeTwURuaS4FZQXumZVc1qWphNlDWw1lVNdR/GPuP0grTHP3TPps6Ge8v+Z9XlzyIhvSN3BLkxGwaz8UJaq/M+zDD2HdOvjqKzU9ua6Dnx/4+6v/f6voMGx/CW5IBEOQ+4ojze8HYyAlJZCVBVaryicTFwem82lkl8EPHBbP/Zlxzi7vBrizmj2pxozxBI6g6uOG7oAdr6n9IOFONfOMNQ/2ToVWj7hzRohydAdghKAGnlxmzs/oZmMzXiKROXNgjnPiwqCWGyhx5g1yTdXsHq4WewXsfV/trJqRQi0IDau7p1FYQBg6us+g0b5sFaxuHtUcgPqh9UnJT0HTNAJNgRg0A1FBURgNRvJK8yF+NBz4Ama3VHV32fYKNBgCWrj3fidqTNehoEANT/Tzg/Aq5kQQZ4Cr/XSSbSezxcylX1/qvj/y15FMHTH1jNbhomPJByLg8A/q98g/Uk3aEZIAR2ZAi9Fe5waPV5hQdsquKYy7ahyNG1yneiHbVA/NLLvq4eDquRkZGInRYCS/LN9nNVypAJ7q8xR7svcwe/9s9wyV8REqSN8gTB1DDwe1o83W59Sx3BRy0he8HQ4oKvK0W0JCTqqpLk5gT9YeAkwB7hmJs7PVBcy8PPXVNBigZUvo1g2MRvVdrep8x2yGrl1VgOjJJ9Xnp+uqHWu3n2dtzjOoNnoa9QQO6rp+SNd1C/AzMKzCMsOA73VlLRCpaVr9Wtj2mVecBnPaQJPh0OZf0Oqf6q/983A0vXIuH9dZVcXyM5jfp8hSRPT4aPf9K3+4krd+n8J998HEibBqFWzdCmvXwvgvk/jXgn95PX/Q91UEmA5/B60fU11O/SPV+/JLEPxSg6vqNb2iXpP1VvyBd92vuK3Q0FO+WvbCohfc79O7a95l4P8Gnlr9QfWAWXUXJH4DOZugcD/kbqmUfPXvjF85nkYfNuLmqTcT934cB44fqNn7fro+o9ytkDIDkqdBynT1lzwN0uZB2fHqrcNX/qwqvltWu5WP1nxE9LhoHpv3mGe8+9H5sOlfKj9I8ZGav47gRhB3hdcwt91WAwbNQHxkPJqmERsSi0EzsCdrT6Wnr0xZCUDrmNYYDUb3lTC7bqdeSD0CTAG0qdMGcE4j2+JB7yF1gMO/LpN3TNUwhDYAACAASURBVMY01kSjDxqxO3M3p8ukSXD//apRFBEBkZHqtq+A0e7d8Prr8OmnMGUKTJ8Ov84ow2o3qQCoK2A0M47Zzw7npsFprF2rfrijopwfbVX73+WX1/4+WRuaPwBbnq08q9UMR+2/jrTZKslo3x9U8DKyoxoS1+4/EjCqiitQlPiVVx4ygKb1DtGjh+og7KK1mQXAf/r+h9IXS/Ez+JFVnKV67cb08AwXMwZTpGtew0zD/VXUwTXkrLwdmTvQ0Nzf9yYRTdyPuXoouXJ32Bw2Spvery7S2IrUbwFAQB0oy4K57VXwcN3oU3hjyvGVv62m7Zaa9Hjx9R0/g9/ltDS48Ub47jv1Em02FTxatKgWVn6mczzW4DexJswWM/f/fj/aWI1679ZTv2W1sZ+cJnfNvAtLuSDqtD3TWJRYGx+o4tAd7iCycEr8Wv1v+xSENAa/MAisB13Gw663VW9iawFctx9dh7nODrHd6nejQagK4vy0/ScVBC83i22mHgAGk/vidWRgJAbNgNlixl5hSHthWSEZRRloaDSNakqrmFZoaO78R65gkSt49JtfR9Xum38JHPhc5VKqgUWL4LbbYPZsyMxUQ5pTUqDkTE9w6+N4m1evFStWwPz5MG+e+ps/H5YtUxfmKjnLx+GqWGwWbvr5Jtp93o7mnzTnkbmP8OKLDl56CQYNguHD4ZZb1OfQrRt8uflzDK8ZMLxmYNKmSWolFV7bwdBLsJbY6NdPnQKGh6v2bFCQui98q41YWkOg/JlWKpV7EflapiFwtKYb2/lBb9re8Q6GcM90t2t+XUSbqD+Junycu0zXYes3T5EW9TJ6cFN3tNGa+DM3d5sGVyz0Wu/1bzQiJzqU3k36Y3XY2HxsJ83z6jOn7A8KdR1/oz8Wu4UWQaFsiPMnuDQLghug6RbY9Q57Fv1OdP1o6t00xZ1XVzensHLC8/S8bgD+Cde6y5ct+YUF2//Nw7dNp3F4AwrKCpm0fQrtVqdwxdCuBLS42V2v9EPH0FePpOHdf3jV99kJo2jaMowHr3oPo8HIXylrWHH4T14qmoHjmi0sWRbMgYMmmjezMXJbSyxYMGpG/AwmSu1lvPLNIgbb7+Dhh9X67HbVUP7HkisBuLX1UK5JuIzRC55lQ/oGDn3cnIS7Z6AFeoJPy/Neo+/qhzH1+QwtpKm7fG96S1oeW42r3a2bU1g1bR7d/5xI4ORtXq9j2xtd6ZC6CGMjtV29KJlvp35DtmMWD+eOIMw/lCMF6cw88Af7l3/HkIEjGdr5fnRd55d9s8lem8oDy2YSPO2A13rXvng53e59mPLnsdvnzyauzQrqFiWjhca7t2eNa4U/3vY3bkH4a9HEmr1nZ5j02kL6Xx5MfFvPld6fNizk7d1vey33V/JffP/Kzdx6U18CW43w7BPHN6AvvQ5zv/X8uSSYtHQjjRvZGRr/JiZ/E1vL/s26DepKzKCEmbSMLlU9MMB9NfyRvc34PTgLg18I/kZ/Ci1FxATUofTd9Sz4PYtofQ0GWz66MZRhC95lld0TQMg0Z9JqQiv2R7aieeYGDPV6uN8HW+I0Nq/JIuWnHMDobAc6aBs8i3bpyzA2uMy9bOqmpWxfn4X+az6aZgA0dF3nhRc13h2v06XxWkwl+9CNYWzd7kfvhW8QMrVcwKQ+8GkduMX7l8ue/hc75k7nUFgv7I58QANdp582grKG97Iq8Sry8gyYTBBm38ygeq9T78YfvL5zKcOGEL94l9d6J3eL467rPQ3ZCRsmMGHDBEDnr+NjGKCPQUv8CjCyNSuWp4qLuGnFWHrGdSa5II3p++dx16G6XD24NUFt7nRvLys5ld79Qlj+54fUz+iKptuwaUEcsZaiAU38TOjmFBqF1uN47nFifx2BPnKR+/mOomS2pW7GgEaL4FB0cwotIxq7h8G0CG+Abk6hdXA4Bs3A5tk9eWStP2/e+xwRqe+g6XYyg7sQt3Ut7LoLgLTCNNp/0Z7bM/5NqPl5Xhgb7ZlgSYPQ1X3RO73F8m0dyMo2Ehysszd/DBNKJ2J22DEZTNgcNqKDImlcYmMrhWho6OgYNQMP3PIkL7/wJjExAXTurOFwQFmZzoSnfqDppdcS1yTC/T6//koew0bU47HHyn8abZj+6oPcFDUMQ7d30cJagK4zd8tQ2vRsyMCBUFamjknh4bA6Mp1eOyeqY6jze3to7XICdz5O/bne3+XkG28mQfPuYZjZLIZ6H9eB6/Z6lf/18Uv07BtIULv/c5fZSvLZ+N+nyGr9M7ruh+585RBe+bKhERwTg9jachvb9kRTVKQRFKSzb8/zPNz+FpoWX4sWfytap9dg/UMc6t+UhP9Ow1C3u7u+K6b8yiUJuwmf+73X69g78XpaZVzpdQwldRZlKYtZUTqRpGQTFotGw+jm9LVnUefYCrQ6PdEc6vdo3aw/aXlJY6Ku/NCryhs/vY8utz+GsW65EeJZq3Ds/RRrzynMmRdMZpaRPr1L+HnJtQwccD3XdH0IgIVJy/lrxQpCHUv45+2/EhEQTqGliO92TueP9+7kpmtjGXyVlaDjv+EwhXHgaEsSsv5B/Vt/8X7fNj+NLbwzm3PvZ9MWf0wmnYHdD9Di2G1oVy5j3cZAtmzzp1+fMrKXv02vKxoR2Pp2T3XTcihbNJxGI5d4r3fvh9hsBrZZn2bjpgB0HRo1O8SmfVcz4tYptK3bFqvdyne7pgPPkrn6C+rk7VGfUd+fwPnb992ne+l0aSvMxRpBgToh3SZSDFxevz2GkjR6xl3CqvSNdO1gYcZkjfb1RhGa8V9sxjoUlGTg0G0E2QrQzSmEGdQX7+aNc7G3vdrr89yVshXQqe88RjQLraMe0x2EG1VZkK6j6zr6wWsYcU8jvn3lXaKSnkFzlODwi+Wm747y4l2T6WEZhbbrTXQtkF8Pt2FLlI3Hs7ZQNziGDHMm3+yYysKnRvDoS924UY2gVbtzziZS577I7ojvOZbpj90BJqODBhlPctnw/vgnDPZqt/yx/Skevm06TcIbkl9WwKTtU/h+1H2M+6QFQ4Z4Por0g0eILcmmXOwNgDkd+lL46Vrqt+vkLivJz6Fd9Hc0qfC7fPendzC5Qm/hesYY9q+yEfGHdw8D/b0B2Hu3YLfpDdau98dm0+jQsZgJ69ty99VvckXzqym0FvH1jqlkrd9HbMNsHrv+K0L9Q9iauYu3fjzAkSOPc++9qu1YVqbaQ6tWqfVnb56OyaCCgw67nffGlfCPp5sSXTcATdfRNcg9tIXNG0rRW/wTgysYjk6d3TfR454n3Y1t3ZzC15+mM2NZb+ZXSLUz5PUmHAix0iiiKaCTbj7GzQF96XK0PdG9H8Vm0wANTdPpUHgvaX63sz9/IHa7EYMB7Md3MjjuGWJv+cXrN5FNT5FtHMBfh+4gK1st6zCs5aeiEVze5T66xXbkUH4KS1NW82k9E/kFw9htvh2HQ32CyQVLebnA0y7NKs6i3eft+Ea/nduGtCOo/Uj39o4e3sTwyZfSs9OdXNqoJ0eLMlmYtIK3/pdLxyWbvF6vQ4PUD5vQaOR8tHLDeZd/P4WubdMJ7fFv93qthYeI+KA5Fc/F79IuY0fQThrEdiQuuC57cxLJLytgT46aBvHHIR+zI3sv49Z/we8Lb6d55PVstI+ntMxP9U7QHLQvHElazFisAS0A9d0oPLCQIe0mE33VR17vZbP32pKE9wWBj0L68kSfeLh0slf57W+2IjyhMcM63Q3A7IOL0ZOsNPHfxKhbp1IvpA45JXn8tOdXNi79hZbtW3NH76cwaUZm7J/PsT2Z/CtoM3G3zvBa76NPhNCqjZERQw4TULgWXTOxLTuOj7ffw0NDP6ZrbAfSCo/x7c6pZG/fxrrAFCJD4vAz+nHMnE0jQwcy3p/CkuXBBOUvxlR6CFtgU8b9MBibzcjTTxQSfHwm6HaOBw5h+4+vENTnHTSDn/PAoTNv8wOENU1l9JXvEhEYzrIja1m5fyHwFHr2OojpibZjDOx+m4mLHqJJ8zsYbOmJVvdS8AthVSmk2SEmIJz1d85gZdoGLvv5Vt76LJl9X+Qx/qnxxBx8EE23k+bXArtjF+EGI7o5hXCHDavdys15vcifezdRV4xzf0abD/+BrjuIDYrCrzSDZv5+GDSNAKsJm9FKXZMB3ZxC/QCVX+mj5+9m4DPd6VHyJNqmJ9C1QGYmteRAlMbo7O1EB0VyvCSXH3f/Sury37i831UM7aEaNEtSVvHOR43p3bkfw4apXkYOBzRqpIY79epWzA09F2K0ZKBrRn5f0oLv/xjIX39578P/fmcQbdrGcv+gtzBoBv5MWsHKrRt4evIPhM/zHrL/Yt8FhF3Zjgdu3IjRotq0eSVRxBdnVTreRmftJTkBGjf2lOUV5lHngyjsFeow0Xg/dw4MJ/QZz3HYUZhE74/aEDxpNj0adienNJ/d2fsZmduXO7pZCe/zomcFDgtP3LOJZ54PIzJKU5+HBlsXr6Fvu10Y+k+rUDsD2ljvNtUVJe/QKvlqXnvmIH4GZ35Qq40G8+7zWu6LjV/QcEFfHh52O8HBJndPI7vdQcSH3u/C6Dmj+W7KZ8zoGkW9cr8xHQtnc+XwpTz26EBeedVITIyGpsGsWTrvvWtjxsQ1mEr2ozlK0Y0hhF7xCAFF3jlED0cncHPUUn5dFO9V/vAdu7nl/vY8+KCnLCs1k+Lf+9HkXu/A9TfjVpHv15veV3g+JIu5CMfKOxnwyItoxkBUA15j+U8z6dHNSkjXR73WceSbATS6ezaav6ftvfzHqXRplUJYz6e9lrUkL2D9vLX0f/prTkZtBI189f2q2IezOsuoBTVtNDAaoEmTJpUe77BqHfzbuxeH9er+RDc8Dtd5PrhdtGdI7M5KFzyWfF8PS7Ed/1LnF3HPONgznjl2IAtWZ3nymxjzWpATqWYosjrHu+4x5/HhPx7mpQ9aQs8m0LA+WO2UGgOJjcpXeVJiY8FWhPZ7PEG0JSDqLq/yeWsfZ7w1k6lv9+HdP+GL7vBnC1hs6ExgxLVq2bg4sBVheakOTRvmepXxiZmPzWDZAY/smOmubz0jjFzVhEG32SiNCKJ5Gz8O7bNyx02BGNIKeGuJnUCbnZlt4Puu3/BC+g6+aXQNto5dICQYrbSUEZE2rsyEsW/OJdg6lybNYEY7aHbHIYjprDa0fQzsHMuf817Hlt+RQcaW0CAAAkzQG9o02AcxXdxjv7XEb7AdXErgo53hp61er+MSNkNMR69lf076gj8Nmey8vz3/Wgv33QDbnDGaLxaNhUWehuTtuX147KHGMHW/13ob5uzDL6q5Wu+xYxATQtnG16jXg0qf0f4xLehw95dwyR3uZUv+EUSrBQfhPu+DweifgCsLPflKto+hweEfuabIwGtTHPRMgyPh8PTVUK9DCkERw7y3t6AnP310D/++rw73PWCkYYKRVatsBH75O/9eNo8BIyMZOkyFut6Z/iS91zzGg70awSUdoUEeGCAjM4P0+sVQ5kmummvOZfuIPrQqvRTaPQlB9cBSQIfZr9OsrC7vT8iibjH83hrGXwotB+2Hut293ocez29h7CedubViP8HJW6BOZ6/P6K7RVzDymZE8cJP3ormv3sk12XMg7glo0B3K8vA/Op2QfzSFX3Z7PqP3zHz/2kD+b1k3aNsWgkNBW8/dE5+h600TeKbcwdZigRviH+PKJ67h/geNREVr6A5Y+L2V2Ki8Sp9nzjWtif/hD+gy0v15Bt0cTFOzxgvzdfqnwM668GZ/2AJc/s9nVQi7H2CzkZxq4K9rzfy1ZIzXa7vH0YPgiEu9tmeZ3YuRaQ/SsO1YaKLWYVpZwr+vqEfI4Uwaje2DpsMbTWFm+2AS7kiB8Jbu5xtmJfBUYj30tEzavTYYzQGvNYbPe0BYQ7jtf1vRHoqntQFeHAArD9TnhkafENV/LFwGREPM/LW0ewKGr4WR2yA3EN7qD8b0QPQ2MTRt6vUymHhzJ74o6snzr/jRe4CJwgIHv87MoCjG5jzWqWPe8ZJcLDbAhHtqcLvuoJH9A8a3XMRv3Tsz09SOsoBwIs1pvMwb6F96b6vrpA0sfeRXvv2xK1pCAvj54ygsJOXPLIZ/vhB6LoRowAqf3fEoa3+ZzZeNe+No2x49IBAKC+k6eBUBEdd5v+8rRtGseVGlz/5A/y4kTPoREu5y72ulTwRxaHM0zeKng38IpP8IRydTb0ZDgp9MA1521/ergIdYNPRPZrxIZTvfUj1Knes98moUN49dynPvxTPiHhMhIRplZTp33qGTtO0qmme+Bl2Wgx8wAJrVOwx1unnV15F0GRGXtK/0OtrWB+p4H0MXTVnBi/N+581xAdz2fyZMJjiaFsHEtsN5pf0AuCQc4uqBuZSyiASiI22Vfjeax0RiimoDzXuq17TwYdg5lq0/DWXIvED0wABCo/xIL8mg7MkdfLJgB4WXv4VDg+tfgAh7ONl+BYRf25HH1sPP3eDx6+DVRUcZtW4i2ADVyYaMLR1ocFVJpTosntSGh1aMY8gDkVx+lQm7Df77hR/vlWbx0U0f8iJvOZtIAUx9dQ1BEY94rcM2NozGSzPhn97H5rmXN+fpFXMZPDqKIcP80DT49I8tzIrIZfq7g9n5OUzrCKNvAXiWeg8lQrtE6Pi16nM9APgDmt7VlnW05Sse4PqSOczOiMEUEsjALiPRbPBuI/hfZ6if/DW9Lx0LQcAQ8Ft/mFFXt8AvooCOba5Hs8F9daGwF3S/Y3ulY+g9ZZGUme0M6H4fmgXuj4GMfhDUCAb9ko72VDwa8EFPWFBUhxFlE4jpMxb6A/XBuDyDrsefptfs99Wx51LQ8kuZWjeXqU2P8d3bXRm1WR1LMkOh+5EbCQzUvHoEfvldCHOWzua/k0zE1NXc3fK3fbCJgKg7vPbLRWuf4B3rMb78qC8vrIDvL4HtcTCaCBJX3s3eBlFoqMb7scN5NPgqBG7N9/rsR/zfD2z6NIS2bT11yEoppG5pUqXvgONwKDSAABsYHVBqgnxbIRH3WGC+7rXeOV8f5NVnPqTrXVHccpsJk5/GrwvMTAstYtrcJ7z2k+aWCBIP5/PiJ95JzPfEfM7/ogZT1rm3ilZbSunS6X1gFXW6DgdroXpxs1vw1k3HoWe5Hg7bx3DLv3oz/PHBjBrufdgoyN2AKbqN12efULCSsOKv2L8jzhOQAJZZj1BcCAcLPQ3X+StHkN7geb4b41lnbi5ckvAJvy+J5bZOBsrK1Ln8/pUO4izHvd5LfovnkVffwdzjYV4eY6RxvAHdARMnZ7E6x8zqdZ5ExNj82PLQQWYuasjtvQ2UFAMa7NkXx+Tp8OIcuPoQHI6ElwdCcEISwZHev4l5Cy5nta2M1Zu/5aPN37pXPaxHPzp+/AZ0eNH92ekfFdPEkAKR7bw+Tz1tAGG9e3mt1zSrOSU6hFigfpHaH7KCIbP0ENv142w//JfX+/5wNgxcAiPGPIFDg8DLYEXqx/x87208/6IJc5GOQ4ddu+Cm22eTlOT9ua34roCYyLJK+6V/CUTr0CYbbAY4EA0rdwRwXUkpzUsnqA+iaC4UzecXG3DwAJMOegLcTUtiORx0jDVPduOzefCfK2FqRzDo4Ni5h1d2/uZetmdBO8anpVVqhzZrMpwnWkyH1CHQaDA4SshN/IZZZfnMmnmv17J9cvxJirZAsSf4kFKg81/Tc8T/8SXUawd1LoG0Lwj78WvGhP0KbcF1JXXD1qsZt2YBG8Z7vz9vLf2DVUmFvPNVPyrSBveHdiFQLwryokjOiCdhdxmGlGK49E8IgDa74KF+MHRBAYbnE+inwSuXwfpDkdwY/Sl1e4xV41gawdVLd/HQXTBkciLa4/H4AeP7QFAzP6IjrV6fUecNI3goU+OyZbloz8YTCLzfCzZ0aERU+DGu7v8oWsmj3BYBh/pB7K7f6XXXBxAP9FXH0J/r5TEjIYv0/7uET+fDy0Nhorq+yqeLt2Ee9B4GHW54HrpfauSqxUOY1LQ3jjZtwNluudb4OTddmwMxb0HMdeCwcdma6zlk+w+LP+iIwd+kLkpp8EHZEtgKo7dO8ewn5ka8NrIM5nof63pOfoFhPQOgwXiIUufCjh+6YJzogDu9l/3h8x4sGzQMY/fOGCLVha/i/EzsLdX3qI4ZSv0gJwjCMg8SVqF9a/s9gQ12IH0zy9I3u+t217FwIq5oX+m3/ZN76kCvcheCt4+hJHk1hvYR5dJBjIGdYwEdo0PVw6FBsR886fcVQ58vw9DpFdULWHcQMbslg/I1rl2r89Qa9Z0bcznE9rmHPmum8kVMR2xtO6IHBKEfz+aqy4103mXn6dWga/BuX7DXM1Y6VzDMimdcAOR+3pr/fX4DGf6N8beX0qjZYRa/uZqAuhOg3kjVq39mHBYqJzkym4JJzU8gIcG7POboUvKPJnA8O8hzgfloCe2WJsKj3t/ljyLWMvabpvT1jKSlMMtKWM4SiJvn9Z6FTWtC6L9SgHe91tHkZuDxTl5l+h2XEb7ZAld4by/grgb0/zGt0mupLk0/xTG6mqb1Acboun6N8/7zALquv11umf8Cf+m6PsV5fx9wua7rJ+xp1L17d33jxhMkYj4BXYeNG1UvWYfDVQ9VPniwGnPqS4m1xJ1T4HSxO+xEjYuqNKNK/nP5nnwnvsZQlyuz2q30+7Yf69PUzEtBpiBW3buWW/p34oor4JNPVNTbzw+Cg0/bSzktMs2ZxL7nnWww0BTI+lHr6fLfLth11ViLCIjgwGMH3AlEzwfbt8OwYbByJURHq66QZjP07q16T15zjadrZFFRDbpJ7pugZqjo9ZUal+3Oo+J0599/z7/6CnbsgKuvhgYN1MihvDzo3l0NPyqvrAwOHVKPu8cCO47RI6sT2jXr1AwUrpkyZsSqfbcaCQaXLoXfflPbbNRI7b8bNqj9+fDhar4XNeA6JviSkp/Cj9t/5IqEK+jVqNcFkQtq61a49VbYvFnte65x2zXa1y5gRUWwYIE6doJn/7jjjsr7yZtvqu/Al196D2dyODyj7mpTw4YwaxZ06VLD9f/Nb0luLrRoobp2jx+v9onERLh+UTMO5x1m3ah1WOwW+n/bn5igGI6XHGdU11FMun4Sj89/nE/Xf8pL/Z7ndfNUNZtXcCPViLTkquPAzRnu7dmsOi1bqvesTx/vY92WLeq32WJR3/2UFLDXjfM9W1FsrNcQGF2Hdu3g3Xdh4EDP8aqg0E7jz6Ir5xQao1+w6UnsDjvR46LdeQlBzRSU9UyWeyYhl//7P/W+PfecGk5hNKp9v+LxHtQEGY0/bExaoafBadAMFL9QTIDp7OYw7NcPRo1SwxRc+5TZDAFBNj5d9ykvLHmBBqEN+Hn4z3Rv0J27f72byTs8vUJm3T6L61tfX3nFa0ai9f0O3WFXiXJ3vga73lITH9xWpGZ71O2gGcjNM7Jtu0ZxsfdX7corq25vVpcrX4rFom7n5Kjvz4ED6rMqc6ZhiYys/NyDB9WQjXzf6V8oKCtgadJSejboSbR/fZo1g99/V8eZYmeHmjAfKS3/TrG1mKWHl9K+XnsSIhOqXrAW8086HI5yvbwqu/VW6NULnn4aCgs9eVB++03t/35+nmO5xaKO+6fafrbYLczap4a43tD6Bix2C+Fvh7svxLjk/CeHnJIcnl74NCXWEt69+l06xnasvEJdhwU9oOl9apZO1wXMGbHYdJ0fmo/j/TXvc2WzK3llwCtEB0dXXoe1EH5rAl3fg/g71D48qwXgzJ0ZWBc6v6vy8y27niJHYzL7HKKkxPP71ro1HMrfzwOzHuDg8YO8fsXr3Nf5PkxG43l/bE0tSKXxh6rnh0kzYdNVwKB+aH2OFh1l0+hNBJmCaPd5O+oE1yHz6Uzv9mFxOszrADceAWOQCpiUb5NXaI+XWEvoMakHu7JUD/kQvxA2PriRNnXbeFfMWgjTo2BEkSd/7AnWW5vMFrM7ETmggkUVf5vj6sHhHWoiDodzOL4xQOXgq9B+9tn23vQvwACd31IL7HgNdr3pOd6eCcuGQdwgNZmJZvAEuc5kHc4CTdM26bre/W+Xq4WgkQnYDwwC0oANwJ26ru8qt8xQ4FFgCGro2ie6rvf8u3WfStDoXJeYk0iLT1u47y+4awFXt7jas0D5hr6vL6ez0Tx3/1x2Zu7kmUufYeECA//5j8pNdL4Fiioat3Iczy1+jkBTIKW2UhbevZCrml+FxW7hhik3EBsay/+G/e+8O5F/5BHVAHv9dZW3BdRVw3r1VAOtWomEfUmZBge+hMt+B0MA/NawXNCoBgl4T0XyL5D4LfT7BVzdJGvhB83hgCeeUMOV/vlPFdCy29VJ5lVXnVqVTxQ0uhD9+CP8/LPKL3QyJwIXK1/7SWamOgm58041+0ZYmDrxWLxYlde2J55QJzRvvuk5SfT3P8Gx/gS/G+V/XyZMULmm5s71BAvsdnhwzv18u/Vbr6cPbTGUuQfn0qthL9aOWstl317G8pTlrBv8PD2TP4UOL0HrJ1Sy6anOld2pu7e3b6/OZZfBkSOVj3V9+kByssq30LixCnD2vrF6QaOCAhWEN5srn6C/ueJNXlryknvYZVRgFLnP5VzQ3/tiazFhb4XhwEF4QDjHnj7m80JYSQn88gvs3KlyiJlM6nfo6ad9Hx9KraXUfbcuRc5cUOlPpVM/7OynpzQaVY6OaB/nx1XZcWwHs/bN4plLn8HfWHGAuoemgZ6+0H3lG4MfNBwKhrObKbW4GJYsUd8ZUCfymqbyzfmXezlWqwqqPfoojBihknxrmvr+BQVVXq/DAdu2qXx0dmezwc9PBeROun1yDjl4UF2IcgXgNE0dw/2r3gVq3QdrPuDfC/+tjkWlubwy4BXGDvQROPOlKAn+6AI3Z6p9EWrezjrwhZrdrN80T9DJNQFIaCu4doM6SdY0mGKs/nq5zEs9UgAAEtJJREFUcNpU3f7bjc0Znt413et355LYS/h669e0qdMGo2ZkV9YuRrQfwS/DKwzBLsmAOW3hxhQVNDKYqjUhxs87fyYxJ5Hn+z9fKcAPqCD1vI7Q5X2I7a+6J85qDmWZJ1zvaXGi9kU1VLmfWAtUvtOyXMABmh80GHzmjrcFB2D9aEi4G+pfrYJzljw1QuACdsaCRs6NDQE+AozAN7quv6lp2sMAuq5P1NSZ/QRgMFAM3Kfr+v+3d+9xUtf1HsdfH5ZVhHWVi3JxYVmVQDR1dQXRREULFVEOauLj6OFhlmlGonZMpI5W6sPUDpbROZkoppQaUtKpVKKr+RACb4BoriByWVwVJWCR237OH9/fugM7AzN7m99veD8fjx7OfGd25kvvufx+n/le9lgNKuSiEcCzbz3LyEdHMvHEiUwZOSX9mxDC0UDDcKkGad6cEyeGu95xB3Rqu4FS7WbAfQOoXlfNzZ+5mdvPuD3f3WkVEyc2nvg1ZFRfD4ceCo88EkbYNBzIbd6c/qAuo6VTwvbLFePDMMyP3wtbnp7+21b/d6S1/jX48yg459Uw2mmnX1da/oW2eTMsXBiKbMXFYeTFUUc1XWomF4VygJOt9evD/2cPPRRGtzWMEtuxI7cTrr3N7l4nK1aEAuamTeH9OmhQmHHZ2vVs97Do5s9/3lgY2bQpbGaQbmRItkWjYcPgqqvgsst2HsE0d9lcznzkTIqsCMep93p+c8lvGP2L0ZTuU8rsS2Yz9omxrNu8js0nnUanomIY/qvw3ofGk5CUotHGDU7v3rB06c674q1YEX65nj0bRowI7Vu2ZD9Cwx2OOSYMTth1tGaXLs7h9x3Osg+XAfDqVa9ydK9PF/z7fu2GtVwy6xJmXjST7p27t9rj1m6q5cgfH8mTn3+S4eXDW+1xWyLdSKO6utb58awQviN27AgjKJ9+OvxbzMJ76/bb27dYIo2GPjCU+avn0/+A/iy7dln2P4B+XAtPVcCFH6QZbZLlcda8L4XRH5++NbwYUotOQ6dBxWWNBanUz/EsFML7BWDd5nV0v6v7J+s5rrtxHTMWzWDC73daoJHbTr+NycPTzGd/ZxYsvi1sStGtMozgWvsHGPi1lnVs63p4476wKU7nsIkCdath2MONBcAEiP3rpG4NbKwOG1107AI9hjVOsStA7Vo0aiuFXjSCMOSvc3Hn8IWRqWiUZfX2q18NJw+po1iSbMVHK/jmH7/JQ2MeomOef9VrLdXVcMopYTRC377hwG3LltB+/vkhw5EjwwfqnDlwww05PkH9jjBFZNt66FgCJf0bDyzaw6LvhB2djpsCBwwKw1SrH4Bjvtt+fchB7L+42sCaNTBpUnjN9esXCg81NeHXV0mv4F4nKUWjgQNh2rRw4r2rg+4+iPfr3gegT0kfVt+wmg7f7oDjlO5b+sm0r/qjemAnPx52EWyQpmiEO7/8ZXj93XsvnHRSOKG9445wUrtwYY6F8hRvvx12wBoyBEaNCk/5zDMwdSosXLOQqp9WUVZaxsrrVhZennu51avh3HPhhBNg7NhQdPzLX8KxUEvptSJtoWZDDf3u7cfiqxczsMfA3P74+fHg22DoT8O0SQDqs98xc9F3YeObUDU17HCWWjT6txrYL9rlsBkjxQvp/TJ57mTueO4Objn1Fm497VY+3v4x+90evqA6WAfqvZ7131hPaafS9A9Qvw1q/wYfrw1r43TpH3bcTNgMibZQSK+TQqCi0V5o5ky4555QkEj7y7PEwjPPwPjxcPbZYarVqlVhq9+6ujCS4PnnwwiQk0+G885L4PfLR4tgxWOw7qVwEHPIaCi/OJb/kP79G4f3i2RSXk6ThVITLaWIM2JEONG+6qrGkT8N7nzuTibNnQTA9z/3fa4fdj1dv9d1py3k+3UqYUX5Vrjg/XACAk1PNnZZV2n5cpgxI5zYN0x5KS2Fn/wkbHvbXO7w+uswf364XFUFRx4Znv5nL/+MU8pPoaJrhd73krWCe+9L8tVvg5cnwcpZ0LUSfDt8+AqMeTu7v69bBb89Cj77HJRUhJEUm2vg1+VwcV3jVKCfpxyz7YVFo41bNnLWo2fx7H88S+fiMGxxzGNjeOqNpwA4vf/p/HHXXTwlK4X0OikEKhrthbZsCQuITpgQ1iTYvj2cBCR9faNCtGMHzJsXRn2UlYXFGWNYUxGRQpRSxJk+PYzG+fOfG39s2Lo1jFZd/uFyDv3hoQCsvG4lZaVlXPD4Bcx6fRYlxSVs3LaRaw4/iR/tXwujXg3rN0DTk410i3GnGDcOjj46LMjcFouIi4gUnPrtsPGtMIql5NDcDiLfeghe+npYCLvHUKh9Ht66Hz6/ATpGJw3NWF6g0IsBjy9+nHFPjgNg2nnT+ELlF/Lco2Qq9NdJ0mRbNNLhWQHZd98wpWnKlLBeyZVXhuH/Ej9FRSGbCy8MWalgJCL5cPHFYRHhiy4KIyq2boXfRTu9VnSt+OR+ZaVlAFxx3BUAnNr/VAAuHDg6TIWtb7olbbbq6sKaWioYiYhkqUNHKB0I+x+W+0HkYZfD514IaxctfxQ6doJOB8O6lB/qx64NRf/2XGA55kYePvKTy6MGjMpjT0TaX2EsFCOfOPbYML//kUfCYqOnntp2W0CLiEiy7bdfmCY2dmxYJL1h2/WG7bannjOV4g6N2yYd3/t4ABbXLgZg4MGfhrUPgxU1Pminno2/UGdhn33Crk4iItJOSgfA8VMar2/9CJZ+H7od37ihwbaNiVpgua0d2OnATy73LOmZx56ItD8VjQpQ587w5S/nuxciIpIE5eWwYEHYaru2Nvz40OArJ3xlp/s2HCivXL8SgF49KmHjip13Fhmb3ba7Dfr2hSVLwm5nJTo/ERFpfwO/BnNOhqX3wOCbQlv1/XDE9Vk/RHn53jByPsyrslvz24skKy/Pdw+kOVQ0EhER2cuZ7Vws2p3BBw3mtfdeo29pX6xzHygqho8WQ/eUKfE7tkDRvlk93pAhYV0lrXEgIpIn3SrhUxPgtbvg9XvDl8KOrTkVjbRovEjh0qQlERERydoFR1wAwJhBY0LDgUfDG/eGqQwNPPt1MI47Dl56CT74oLGtvr41eioiIlmr/B4MewS69IP9esOQ/1U1X0QAFY1EREQkByf0OQGAoYcMDQ0V42HVbKj9aygcba+DV27O+vEGDIADDoDLL4dNm8JOoBs2tEXPRURkt/qNhXNegVFLoOLSvWG+mYhkQUUjERERydrxfcJi2JW9K0NDxaXQYR/462h47iL4w3D454+yfrwOHeBb34L582HYMLjxRqisbIuei4iIiEiuVDQSERHZG/TqtfOvxmbhf7165fQwffbvQ/WEagZ1HxQaijrB8F9BUWeoeRo+WgRdKnJ6zC9+EaqqoLoafvhDePfdnP5cRERERNqIFsIWERHZG2SqxDSjQnNYt8N2bjj4FBj5D3hzKhQfCINvzOnxioth7lyYPBn+/ncYPTospaGZESIiIiL5ZR7jBc6qqqp8wYIF+e6GiIhI8u2uAtMWxwK9ejUtSPXsCWvXtv5ziYiIiEhOzGyhu1ft6X6aniYiIrI36Nkzt/aWSjeCSfPORERERBJF09NERET2BhrhIyIiIiI50kgjERERERERERFpQkUjERERaX3ppr211VQ4EREREWkTmp4mIiIirU/T4UREREQSTyONRERERERERESkCRWNRERERERERESkCRWNRERERERERESkCRWNRERERERERESkCRWNRERERERERESkiRYVjcysm5nNMbM3o/92TXOfvmb2JzNbamZLzOzaljyniIiIiIiIiIi0vZaONLoJmOvuA4C50fVdbQducPcjgBOBa8xscAufV0RERERERERE2lBLi0bnAw9Hlx8Gxux6B3evcfcXo8sbgKXAIS18XhERERERERERaUMtLRr1dPcaCMUh4ODd3dnM+gOVwLwWPq+IiIiIiIiIiLShjnu6g5n9AeiV5qbJuTyRmZUATwIT3f1fu7nflcCVAP369cvlKUREREREREREpJXssWjk7mdmus3M3jWz3u5eY2a9gdoM9ysmFIxmuPusPTzf/cD9AFVVVb6n/omIiIiIiIiISOsz9+bXZczsbuADd7/TzG4Curn7jbvcxwjrHa1z94k5Pv57wIpdmnsA7ze705JPyi6ZlFtyKbtkUm7JpeySSbkll7JLJuWWXMoumTLlVu7uB+3pj1taNOoOPAH0A94BLnL3dWbWB3jA3c8xs88AfwMWAfXRn97s7r9r5nMucPeqZnda8kbZJZNySy5ll0zKLbmUXTIpt+RSdsmk3JJL2SVTS3Pb4/S03XH3D4Az0rSvAc6JLj8HWEueR0RERERERERE2ldLd08TEREREREREZEClMSi0f357oA0m7JLJuWWXMoumZRbcim7ZFJuyaXskkm5JZeyS6YW5daiNY1ERERERERERKQwJXGkkYiIiIiIiIiItLFEFY3M7Cwze8PMqs3spnz3R9Izs75m9iczW2pmS8zs2qi9m5nNMbM3o/92zXdfpSkzKzKzl8zs/6Lryi0BzOxAM5tpZq9H771hyi7+zOy66HNysZn9wsw6Kbd4MrMHzazWzBantGXMyswmRccrb5jZyPz0WiBjdndHn5evmtmvzOzAlNuUXQykyy3ltq+bmZtZj5Q25RYTmbIzswlRPkvM7K6UdmUXAxk+K481sxfM7GUzW2BmQ1JuU24x0Jxz71yzS0zRyMyKgKnA2cBg4BIzG5zfXkkG24Eb3P0I4ETgmiirm4C57j4AmBtdl/i5Fliacl25JcMPgKfdfRBwDCFDZRdjZnYI8DWgyt2PAoqAcSi3uJoOnLVLW9qsou+8ccCR0d/8ODqOkfyYTtPs5gBHufvRwD+BSaDsYmY6TXPDzPoCnwXeSWlTbvEynV2yM7PTgfOBo939SOCeqF3Zxcd0mr7n7gK+7e7HAv8VXVdu8ZLTuXdzsktM0QgYAlS7+zJ33wo8RvjgkZhx9xp3fzG6vIFw8noIIa+Ho7s9DIzJTw8lEzMrA0YBD6Q0K7eYM7NSYDgwDcDdt7r7Ryi7JOgI7GdmHYHOwBqUWyy5+1+Bdbs0Z8rqfOAxd9/i7suBasJxjORBuuzc/Vl33x5dfQEoiy4ru5jI8J4DmALcCKQuzKrcYiRDdlcDd7r7lug+tVG7souJDLk5UBpdPoBwnALKLTaace6dc3ZJKhodAqxMub4qapMYM7P+QCUwD+jp7jUQXtzAwfnrmWRwL+FArD6lTbnF36HAe8BD0dTCB8ysC8ou1tx9NeGX1neAGmC9uz+LckuSTFnpmCVZvgD8Prqs7GLMzM4DVrv7K7vcpNzi71PAKWY2z8z+YmYnRO3KLt4mAneb2UrCMcukqF25xVCW5945Z5ekopGladPWbzFmZiXAk8BEd/9Xvvsju2dm5wK17r4w332RnHUEjgP+x90rgU1oSlPsRXPLzwcqgD5AFzO7NL+9klaiY5aEMLPJhKH9Mxqa0txN2cWAmXUGJhOmyDS5OU2bcouXjkBXwvSZ/wSeMDND2cXd1cB17t4XuI5oVDvKLXZyOPfOObskFY1WAX1TrpfRODxOYsbMigkv2hnuPitqftfMeke39wZqM/295MXJwHlm9jZh+ucIM3sU5ZYEq4BV7j4vuj6TUERSdvF2JrDc3d9z923ALOAklFuSZMpKxywJYGbjgXOBf3f3hgNmZRdfhxGK7K9ExyplwItm1gvllgSrgFkezCeMau+Bsou78YTjE4Bf0jiNSbnFSI7n3jlnl6Si0T+AAWZWYWb7EBZvmp3nPkka0a8G04Cl7v7fKTfNJnzwEP33qfbum2Tm7pPcvczd+xPeX39090tRbrHn7muBlWY2MGo6A3gNZRd37wAnmlnn6HPzDMI8dOWWHJmymg2MM7N9zawCGADMz0P/JAMzOwv4BnCeu9el3KTsYsrdF7n7we7ePzpWWQUcF30HKrf4+zUwAsDMPgXsA7yPsou7NcCp0eURwJvRZeUWE8049845u46t2+W24+7bzeyrwDOEHWYedPclee6WpHcycBmwyMxejtpuBu4kDEW9gnCydFGe+ie5UW7JMAGYERXVlwGXE34YUHYx5e7zzGwm8CJhesxLwP1ACcotdszsF8BpQA8zWwXcQobPR3dfYmZPEIq324Fr3H1HXjoumbKbBOwLzAnH27zg7lcpu/hIl5u7T0t3X+UWLxnecw8CD1rYzn0rMD4a4afsYiJDbl8CfhBt2PExcCXoPRczOZ17Nyc7axyNKyIiIiIiIiIiEiRpepqIiIiIiIiIiLQTFY1ERERERERERKQJFY1ERERERERERKQJFY1ERERERERERKQJFY1ERERERERERKQJFY1ERERERERERKQJFY1ERERERERERKQJFY1ERERERERERKSJ/wfAhhkxCFVu6QAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index 9\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIEAAACMCAYAAADr57kMAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3de3xc9Xnn8e9v7tLM6DqS8d3GNgbbGAgOhCah3EsCgTSbZgl5pSlJy6ZNXm3avnrdtEmT3W2bbbpbNimUFtKkTSFtGlqakARIKCSlgM3dF2xswPiGLWl0nZHm+ts/ZkYWjmRL1mjOmXM+79fLwZoZSU+so9+c85zneX7GWisAAAAAAAB4W8DpAAAAAAAAALDwSAIBAAAAAAD4AEkgAAAAAAAAHyAJBAAAAAAA4AMkgQAAAAAAAHyAJBAAAAAAAIAPhJz6xqlUyq5atcqpbw8AAAAAAOA5Tz/9dL+1tme6506ZBDLG3C3peknHrLWbpnneSPoLSe+WlJX0C9baZ071dVetWqVt27ad6mUAAAAAAACYJWPM/pmem0072N9KuvYkz79L0rrqn1sl3T6X4AAAAAAAALDwTpkEstY+Jil9kpfcKOlrtuIJSR3GmMX1ChAAAAAAAADzV4+ZQEslHZjy8cHqY0fq8LXRAP1jOX3t8df07IEhp0NpSgFjdOU5vfq5C5erJRJ0OhwAwCxZa/X0/kF9/cnX1T+WczoczMP7L1ymG89f6nQYQNPIF8u6//nD+s4Lh1UsW6fD8YxQwOhd5y7We89fqkiIPZjgTvVIAplpHpt2JTHG3KpKy5hWrFhRh2+N+dg/kNFf/+gV/dO2g8qXytq0pF3h4HQ/TpzMyERRf/ivO/R/H35ZH7lklX7+kpXqjEecDgsAMINiqazvbn9Df/PjV/X8gSG1t4S1pifudFg4TXuOjkkSSSBgFsZyRd371Ou668ev6sjwhFZ2t6qb89a6SWfy+u1vvqA/f3CPPvaO1brpouVKxsJOhwW8ST2SQAclLZ/y8TJJh6d7obX2Tkl3StKWLVtIOTtk+6Fh3f7oPn33xSMKBQL62QuW6pcuPVNrexNOh9aUrLXa+tqg7nh0n/7Pw3t0x6P79F/fuly/dOmZWtrR4nR4AICq8XxJf/fEa/rq4/t1aGhcq1Nxff7GjfovFy5Ta8SxDVMxTx++60mNTBSdDgNwtf6xnL7yH6/q7/5zv0Ymirp4dZf+1/vO1WVn9aiyzw/qwVqrR/f06a8efUX/84Fduu2HL+vDb1upW96+Wj3JqNPhAZLqkwS6X9InjTH3SrpY0rC1llYwl9p+aFg3fOnHikdC+qVLz9RH375ai9piTofV1Iwxumh1ly5a3aXdb4zqrx7bp79/Yr+++fRBfe9T79SyzlanQwQASLr90X267Qcv621ndumPbtioK87uVSDAxU+zS8ZCOjw07nQYgGsNZwu67rYf6dhoTtduPEO3XnqmLljR6XRYnmSM0WXre3XZ+l49d2BIdz62T7c/uk8/2HVM3//1S50OD5A0uy3i75F0maSUMeagpM9ICkuStfYOSQ+osj38XlW2iL9loYLF/N337CGFAgE98luXKZUgG11v689I6s8/cL4+cflaXXfbj/S5f9upO39+i9NhAQBUaYNe2d2qe2+9xOlQUEfJaFijVAIBM/qzB3erbzSnb378El24ssvpcHzj/OUd+ssPXagvPrhbX3pkr4qlskJB5gTBeadMAllrP3iK562kT9QtIiyYctnqgReP6NKzUiSAFtianoR+9cp1+sL3dusHu47qynMWOR0SAPjeULagjlZmX3hNIhbSWI4kEDCd5w8M6e+f3K+PXLKKBJBDettisrYyL6iXDgy4AKlIH3n2wKCODE/ous2LnQ7FF37xHWdqXW9Cn7l/h8bzJafDAQDfG8rm1dHCgE6vScZCyuZLKpbKTocCuEqpbPXpf9munkRUv3nNWU6H41s9icrNhz52oYRLkATykW+/cESRUEBXUZXSEJFQQJ9/7yYdHBzXlx/Z63Q4AOB7Q+MFdbSSBPKaRLRS2J7JccMFmOrrT+7Xi4eG9enrN7BDlYNqA6H7RkkCwR1MpZur8basarfbPvMOR763H1lZPfv6kOLRkNYvSjodjq/s7RvTwFhOm5d1qCUcdDocAPCtrfvT6klEtaqb7eC95NjohF7pz+j85R2KhXifBSQpXyrr+YNDSkRCOntxUkYMwXfKRLGk5w4MaU1PQj2M5ECDmI8+8LS1dtrhtFQC+cTYRFH5UlndcWYhNNqKrlYFAkav9mdk5UzSFQD8zsqqVLYKshuY59R+pqUy77FAzesDGZXLVqtScRJADgtXh0EXaFmFS9Rji/jTk1on3fIdx76933zx/h36h0Ov65lbr5aizv3Y/Sgi6aUn9usP/mW7/uLd5+vG85c6HRIA+M5QJq+bPv+QPnvxBv3C21c7HQ7qaOfLffrwXU/pH6+5RBetZvAt8Pjeft38N0/qV69Yq4uvWe90OL4XlHTLH3xPH1q7Qp++foPT4cAvPjpz8pdKIB+o7Qp2+fqeyb55NNbNF63Qecva9flv79LIRMHpcADAdwazeUlidzAPqs06GeX9FVC+WNan/3W7VnS16lcuX+t0OKjqSUYZDA3XIAnkA9v2D+rYaE7XbV7idCi+FQwY/Y/3nqt0Jqc7H33F6XAAwHeGxisJgnYGQ3tO7QYX28QD0je2vq5X+jL6oxs3KsYsStdIJSLqJwkElyAJ5APfeeGwoqGArjy71+lQfO3cZe06a1FSu4+OOh0KAPjOULUSqJNKIM9pi1WSQCMTJIGAPUfH1NEa1uXrOe93k1Qiqv7RvNNhAJJIAnleqWz1wPY3dMXZvYrTCua4bu4CAIAjhrKVSqCOFiqBvCZRTQKNkQQClM7k1cVGMK6Toh0MLkISyOO2vpZW32hO121e7HQoUOUuwMAYdwEAoNFqSSAqgbynJRxUMGCYCQRIGsjk2A3YhXoSUQ1m8yqyQxhcgCSQx33nhSOKhQO6glYwV0glolQCAYADhrJ5GSMlY1TFeo0xRoloiJlAgKgEcqtUMiprKz8fwGkkgTysVLb6brUVrDXCSa8bdCciyuZLyuY5UQWARhoaL6i9JaxAYOYtU9G8krGQRmkHA0gCuVRPovIzoSUMbkASyMOeejWt/rGcrjuXXcHcIpWIShItYQDQYIPZAq1gHpaIkgQCymWrwWyBJJAL1a4B+kZJAsF5JIE87DsvHlZLOKjLz+5xOhRUpbgLAACOGMrm1c5QaM9qi4WZCQTfGx4vqFS26opHnQ4FJ+hJVn4m/dwIhguQBPKwJ15J6+1ru2kFcxEqgQDAGcPjBXW2kgTyqkSMmUBAOls5v2QwtPvUrgGYDQo3IAnkYcdGJrS0o8XpMDBFN28AAOCIwWxeHbSDeRYzgYDjQ4dpB3OfeDSklnBQ/bSDwQVIAnlUrljSyERxsvQQ7lC7MzNAEggAGmooW6AdzMPYHQw4XmlOEsidUskIIyHgCiSBPKrWb1orPYQ7xMJBJaMh+oEBoIGKpbJGJ4oMhvawZHUmkLXW6VAAx9QqgboTrHVu1JOI0g0AVyAJ5FG1UkMqgdwnleQNAAAaaXi8MjC4g5lAnpWMhVQoWeWKZadDARyTzlTOL6kEcqdUIqr+UW4Ew3kkgTyqtv0glUDuk0pESAIBQAMNkQTyvGSssgkGc4HgZwOZvBLRkKKhoNOhYBrcCIZbkATyqNoCQyWQ+3THo7SDAUADDVV3zGEwtHfVkkDMBYKfpTN5dcZJdrtVKhFVOptXsUTFIpxFEsijapVA9AS7TyoZYTA0ADTQULZaCcRgaM9KRCs/29GJgsORAM5JZ/LqinMD2K16klFZe3x2E+AUkkAe1T+WU1uMclA36o5HNZgtqMBdAABoiMFqEojB0N41WQlEOxh8bGAsP7kTLdynp3pznh3C4DSSQB7VN5ajFcylUtWfyyB3AQCgIWrtYO3MBPKsRLSSBBohCQQfq1QCkQRyq9qsVsZCwGkkgTyqfzTPUGiXSsW5CwAAjTQ8XlAwYNRWrRaB97TFaAeDv1lrlc5SCeRmtWuz2tgOwCkkgTyKSiD3qlUCDXAXAAAaYjCbV3tLWMYYp0PBAkkwGBo+l8mXlC+WqQRysdo1ADuEwWkkgTyqfzRHJZBL1e7Q8AYAAI0xlC0wFNrjau1gbBEPv0pXby6SBHKveCSolnBQ/VQCwWEkgTxoolDSaK5IJZBLUQkEAI01lC2og3lAnhYJBRQNBagEgm8NZNgZ2O2MMUolI9wIhuNIAnlQrc+0h0ogV0pGQ4qEArwBAECDDI3n1cHOYJ6XjIWZCQTfqm07zhbx7pZKRJkLCseRBPKgWnKBSiB3MsYoFY+wMwAANMhghkogP0jGQrSDwbcGqkkgBkO7WyoRVf8o1wBwFkkgD6pVAjETyL1SySiVQADQIMPjBXW0cGHkdSSB4Ge1SqBOkkCu1sM1AFxgVkkgY8y1xpjdxpi9xpjfneb5y4wxw8aY56p//rD+oWK2ahUmVAK5V3ecfmAAaIRCqayxXJFKIB9IREPMBIJvpTN5RUIBxSNBp0PBSaQSUaWzeRVLZadDgY+FTvUCY0xQ0pclXS3poKStxpj7rbU7T3jpj6y11y9AjJijWiUQg+HcK5WIateRUafDAADPG8pWZsR0kgTyvGQspP7+jNNhAI4YGMurOx6RMcbpUHASPYmIrK0k7XrbYk6HA5+aTSXQRZL2WmtfsdbmJd0r6caFDQvz0T+WU2drWOEg3X5u1Z2IaiCTk7XW6VAAwNOGxyvVse0Mhva8RDSsMdrB4FPpTI7t4ZtAbVwHw6HhpNlkCZZKOjDl44PVx050iTHmeWPMd40xG+sSHU5L32iOeUAul0pEVChZjYxzsgoAC2mQSiDfYCYQ/CydLZAEagK1cR1sEAMnzSYJNF1N4YnlC89IWmmtPU/S/5P0L9N+IWNuNcZsM8Zs6+vrm1ukmLX+sRzzgFyu9vPhLgAALKxaOxiDob2vLRbSWL6ocpkqW/hPOpNjZ7AmULtR3z/KNQCcM5sk0EFJy6d8vEzS4akvsNaOWGvHqn9/QFLYGJM68QtZa++01m6x1m7p6emZR9g4mb4xKoHcrjte+fkMkAQCgAU1lK3cbWUwtPclYiFZK2XyVAPBf9JjeXXFOf93uxQ3guECs0kCbZW0zhiz2hgTkXSTpPunvsAYc4apTiEzxlxU/boD9Q4Ws9NPO5jrpZKVOzWUggLAwpqsBCIJ5HnJWOVnzA5h8JuJQkmZfIlNYZpAPBJULBygEgiOOuXuYNbaojHmk5K+Lyko6W5r7Q5jzMerz98h6f2SftkYU5Q0Lukmy8RbR2TzRWXyJdrBXG6yEijDGwAALKSh8bxCAaNE9JSnPGhytZ/x6ERRi9sdDgZooHSmclORmUDuZ4xRTzKqfiqB4KBZnRFVW7weOOGxO6b8/UuSvlTf0HA6+kcrbwIp7gS4Wlc8ImPoBwaAhTaYLaijNcy2yT6QjB1PAgF+UksCdbILYlNIJaK0g82CtVbfeuaQfnp9D10udcYe4h7TNzYhSVQCuVwwYNTVGlEf7WAAsKCGswW1t9AK5gfHk0AFhyMBGmugmgSiHaw5pBLRyRv3mNkXH9yj3/yn53XPk687HYrnkATymL7JSiCSQG6XSkQZDA0AC2xoPK8O7o77AjOB4Ffp6ngB2sGaQypBO9ipfGPr6/rSI3slSXv7xhyOxntokPeYWmlhL5VArtediPAGAAALbDBT0JKOmNNhoAGmzgQC/GSgWlnOFvHNoScZVTqbV7FUVihITcaJHtvTp9+/b7suPatHpXJZe4+RBKo3jjqP6R/NyRjuBDSDVCI6Wb4LAFgYw+MFtbfwnugHtIPBr9KZvIIBo7YYra/NoCcRkbXHZznhuJfeGNGvfP0ZretN6Ms3X6D1i9q0r29M5TJ7TtUTSSCP6R/Lqas1Qla5CVT6gakEAoCFNJjNq5Pt4X0hHgnJGGmMSiD4TGWdiygQYAB+M6iN7WA49JsdHZnQLV/ZqkQ0pK/c8lYlY2Gt6Y1rolDW4eFxp8PzFDIFHtM3mmMeUJPoTkSUyZc0ni85HQoAeFKuWFI2X1IHSSBfCASMEpGQRkgCwWcGxvK0gjWRVHVsR79PN4gplsrKFUtv+jOUzeuWr2zVyHhBd//CW7W4vUWStLYnIUm0hNUZM4E8pn8sx85gTaInUXsDyGl5V6vD0QCA9wyPV9qC2hkM7RuJWIjB0PCddCbPKIgmMnkN4MOOgO2HhvW+v3xc+VL5J54LBozu+sgWbVjSNvnY2t7jSaDL1vc2LE6vIwnkMX1jOV24goRCM6ht4zmQyZMEAoAFMJStJIFoB/OPZCzETCD4TjqT1zlTLpzhbrVKID+2g/3nvgHlS2V96qp1Cp8wvuSCFR36qTWpNz3WnYiqszWsfewQVlckgTzEWqv+0TyVQE0i5eO7AADQCLUkUAeDoX0jEaUSCP4zkMmri4rHphGPBBULB3x5DbDj8LAWt8f0qavOmvXnrOlJaN+xzAJG5T/MBPKQTL6k8UKJmUBNolYJxDbxALAwBrOVeQvMBPKPZCzMFvHwlUKprOHxAu1gTcQYU9kgxofXANsPj2jjkvY5fc7a3oT2UglUVySBPKSWTaYSqDnUknVsEw8AC2O4VglEEsg3krEQu4PBV2rJ7trNRTSHnmTUd4Ohs/mi9vWNaeMcWxfX9iaUzuSV5pqpbkgCeUitr5RKoOYQCweViIbU58NSUABohKHxWiUQF0d+kYyxOxj8pXZhTCVQc0klor67Bth1ZETWSpuWzq0SaE11hzDmAtUPSSAPoRKo+aQSESqBAGCBDGYLCgeN4pGg06GgQZKxsMZyDIaGf6THSAI1Iz+2g20/NCJJ2rR07pVAEtvE1xNJIA+hEqj5pBJRXw6FA4BGGMoW1N4SkTHG6VDQIIloSBOFsgrTbD8MeFHtZmJ3nPP/ZtKTiCidzavoo7Vq+6FhdccjOqMtNqfPW9rRolg4QBKojkgCeUj/aE4Bw52AZtKdiGggQxIIABbCUDbP9vA+k4xVNr5lLhD8ojYTiPP/5pJKRmWtlM76pyNgx+ERbVzaPucbM4GA0ZmpBEmgOiIJ5CF9Yzl1xaMKBrjj2SwqpaD+WfwBoJGGsgWGQvtMIlpJArFDGPxioHoeScK7ufRUOzf8MhcoVyxpz9FRbZrjUOiaNb0JZgLVEUkgD+kbzSvFzgBNpTsR1aDPSkEBoFGGxivtYPCPZKxyITzKXCD4RDqTV0drWKEgl3XNJFWd4eqXm8F73hhTsWznPBS6Zm1PQoeGxjWeL9U5Mn9itfCQvrEcQ6GbTE8i4rtSUABoFNrB/KfWDkYlEPwincmrix0Qm05thqtfZoNuPzwsSdq05DSTQL0JWcsOYfVCEshD+kdzk6WFaA7dk28AJIEAoN5oB/MfZgLBbwYyOeYBNaFa94ZfdgjbfmhYyVhIy7taTuvz1/TGJZEEqheSQB5hraUSqAnV7gIwHBoA6muiUNJ4oaQO7pD7yuRMINrB4BPpTJ4kUBNKRENqbwlr9xujTofSENsPj2jjkrbT3q1zdSqugJH2MRy6LkgCecRorqh8scz28E2m22d3AQCgUYbHK0kAKoH8pTYTiEog+EU6k588n0TzMMbo6g2L9NDOo5ooeHvOTbFU1ktHRk67FUySoqGgVnS1ai+VQHVBEsgjav2kVAI1l8lKIJ8MhQOARqltm9zBYGhfqbWDjZAEgg+Uy1aD2QKVQE3qhvOWaDRX1L/vPuZ0KAtqX19GuWL5tIdC16ztZZv4eiEJ5BG17QWpBGoubbGQIsGA+qgEAoC6GspWKoEYDO0v0VBA4aDRWI4kELxveLygUtmqK875fzP6qTXdSiUiuv/5w06HsqC2H6oOhV56etvD16zpSei1/iy7KtcBSSCPqG0vSCVQczHGqDsRoRIIAOqslgRqJwnkK8YYJaIhjU4wEwjeN5CpnD92UwnUlELBgN597mL9YNcxT69Z2w8PqyUc1OpUYl5fZ01vQvlSWQcGx+sUmX+RBPKIvtEJSccnzaN5pBJRZgIBQJ0NVdvBOhkM7TvJWJgt4uELtbZX2sGa1w3nLVGuWNbDu446HcqC2XFoRBuWtCkYOL2h0DVreytJJFrC5o8kkEf0j+UVDBhOdpsQlUAAUH9DDIb2rUQ0xGBo+ELt/JEkUPN6y4pOLe1o0f3PebMlrFy22nF4WJuWzK8VTKq0g0kkgeqBJJBH9I3m1B2PKDDPDCsaj0ogAKi/wWxekWBALeGg06GgwZKxEJVA8IV0hiRQswsEjK7fvFg/erlfgxnv3RR+bSCjTL6kjfMcCi1J7S1h9SSj2scOYfNGEsgj+sdyzANqUrVKIGut06EAgGcMZwvqaA3LGG6O+E0yFtYog6HhA+lM5SYiSaDm9p7zlqhYtnpg+xGnQ6m7HYdHJEkb61AJJElre9ghrB5IAnlE31iOncGaVE8iqnypzHa2AFBHQ9UkEPynUgnk3SGrQM1AJq94JKgYFY9NbeOSNp3ZE/dkS9j2w8OKBANa15usy9db25vQvmNj3DyfJ5JAHtE/ShKoWXVXh3nTEgYA9TOYzauDOXm+lIyF2CIevpDO5NXFpjBNzxijG85boqdeS+uN4Qmnw6mrHYdGtP6MpCKh+qQd1vTENZorqm+U66b5IAnkAdZa9Y/laQdrUiu745Kkv3j4ZeWLZYejAQBvGB4vqKOFSiA/qmwRX+ROMTwvncmrK875vxfccN4SWSt9+wXvVANZa7X98LA2La1PK5gkra1WFNESNj8kgTxgZLyofKnM9vBN6oLlHfrta9fr/ucP62Nf3crdSwCog0olEEkgP0rGwiqVrSYK3FiBtw2M5dXNPCBPOLMnoU1L23T/895JAh0aGtdQtqCNS+Y/FLpmcpt4hkPPy6ySQMaYa40xu40xe40xvzvN88YYc1v1+ReMMW+pf6iYSd9YpWyQSqDmZIzRr1y2Vl94/2Y9vm9AN//1E7SGAcA8DWUL6qQdzJcSsZAkMRcInlepBGKd84obzluiFw4O69X+jNOh1MX2Q5Wh0JvqsDNYzaK2qBLREJVA83TKJJAxJijpy5LeJWmDpA8aYzac8LJ3SVpX/XOrpNvrHCdOom+0sp1gDzOBmtoHtizXnR++UHuOjur9tz+uA+ms0yEBQFOaKJSUK5bVTiWQL7XVkkBU1sLDrLVKZ6kE8pLrNy+RJH3bI9VAOw8PKxgwOvuM+gyFlio3z9f0xNkmfp5Cs3jNRZL2WmtfkSRjzL2SbpS0c8prbpT0NVtpvn7CGNNhjFlsrZ1xn7tMvqitr6XnEfr0jCplwJ3xsDpbIwoH59fxNp4vKZ3NazCT13ihVJ8g66z270glUPO78pxF+vovvk0f/dutet/tj+uPf/bcBbmIMZLaW8LqjEfU0RJWaB6/J9ZaZfMlpTN5DWbzyk0z1ygYMNqwuK0hu1eUylY7D49oojj739d4JKSueEQdreFpY5y6DnS0hrWss7WeIc/o2MiE9pMMdEwsFNQ5i5Pz+v3wo9cHsjo66uxgy3SmcnOESiB/SkRrlUAkgeC8wUx+QVpXcoWy8sUylUAesqSjRRet6tJ9zx3S29Z0Ox3OvD3xSlrrehN1P/9f05vQY3v6FySX4BezSQItlXRgyscHJV08i9cslTRjEuiVvox+7o7/nGWYpy8Zq1zcJWMhGZlZfU6xbDWczSudzTdNP3koYLSoPeZ0GKiDC1d26psfv0Q/f/dT+sWvbWvI92xvCasrHlE8Gpz170mhVNZQtqB0Nj+rgdYt4aDeuS6lqzYs0hVn99Z1N7vxfEmPvdynh3Ye1Q9fOjZ5AXg64pGgOuMRJaIhjYwXpl0Hzj4jqWs2LNLVG87QpqVtMqbyb1YqW+1+Y1RP709r62uD6h/LafOyDm1Z2akLV3aq8xQnatZavXxsTA/tPKoHdx7V8weGTvv/B+qjszWsK85epKs3LNKlZ6XUGpnN26a/lMtWzx8c0kM7j+qhnUf1sotKtM9o433Rj5Kxys2TMZJAcMjrA1k9uPMNPbTzqLbtH1SpvHBDyhd3tCzY10bjvfeCpfr9+15syHVyI9z01uV1/5obFrfpW88c8sy/kRNmczY73RXhiSvZbF4jY8ytqrSL6Yxlq/T3HzsxlzR/ZWs1OlGcvGtfq06Yy92ggJE2LmlTVzyiztaIuqpVRS2R2V8gN1pPMqq2GGXvXrFuUVLf+7VL9eKh4QX5+iVrNTxeeNPvSDqTVzY/++qZYMBo87JKNVFXa0Sd1d+Xlmmy/Zl8UT9+uV8P76okN4ypDMR+y4pOBYOV3ykjo2ouZfK37PjH5oSPj9t5ZEQ/erlfuWJZbbGQrji7V5ef3avuWe6WYWWVyRWVzhQm/x0GM3mN5oqTybHaOtDRGtGBdFYP7jyqLz2yV7f9cK8Wt8f0znUpHRme0HOvD022Hyxqi6o3GdNdP35FdzxaWQ7X9ia0ZWWnFk1zYTo8XtAju49p/0Cl8ue85R36rZ9Zr3OXtitg3LnueF06m9cjLx3Tw7uO6p+fOahoKKB3rE1p49L2Wb8TBIxRSySglnBQsXBQLZGgWsJBBQPu/ZkWS1bjhZLGCyVNFEoaz5c0USirPM1OS8dGJ/SDXcd0bDSnYMDo4tVduvniFVrbm3D8/TIWDugtKzodjQHOOF4J9JMzgUYmCnr29SF2DnOZE9edytoz/bpjTOXGUkukuq5W/1ip8vn50pu+1nQ/6mDAVNblyPHPj4UDKpbt5LpX+xq5OdwQzuaLemxPv3YfHZUkrV+U1C//9BptWdWpUKD+VaWRUEBvWdFR968L53xgyzKt6YmrUPLGGrV5ef3mAdV8+JKV2rikfUGTq17wzj+d+TlzqjdBY8wlkj5rrf2Z6se/J0nW2j+e8pq/kvTv1tp7qh/vlnTZydrBtmzZYrdta0yVAwB3sNZq55ERPbyzcmG9p3qSZCf/p5KUqbxWmvLw5An78Y8r/13a0aKrNyzSNRsW6a2ru+bdAjpb6UxeP3zpmB7a+YYe3zugpZ0tunBlpx07LVEAAAk0SURBVLas6tSWlV1a1tkiY4wmCiU9f2BI2/YP6unqn+Hxn7wwiQQDumRNt67ZuEhXnbNo2kQRnFEolbX1tfRkpcvBwXGnQ3KNeCSon17fo2s2nKHL1/cygweucCCd1Tu/8Ii+8P7N+sCWN9+F/o1vPKdvPXvIocjgdcGA0ZaVndXzkjO0orsx7eMAcCJjzNPW2i3TPjeLJFBI0h5JV0o6JGmrpJuttTumvOY6SZ+U9G5VWsVus9ZedLKvSxIIAOB1pdpd5cmKmpKy+ZJKLq5CCBqj1sibK5diLq9eAqYayuZ1/uce0h9cv0Efe8fqyccnCiVd+PmHdNnZvW96HM6by7pTKlvliserdWrrasCYN31+SzioaCigwDRfo1gqa6JYnlyXa2t0KGgmq4xqMURDgcm2bwBoFidLAp2yHcxaWzTGfFLS9yUFJd1trd1hjPl49fk7JD2gSgJor6SspFvqFTwAAM0qGDCKR0OKR5klBDRKrR3sxJlAj7x0TJl8STdftIJWwSYWDBi1RkLzmtEWCgaUCAYmjxUA8JNZrXzW2gdUSfRMfeyOKX+3kj5R39AAAACAuQkFK3O4TpwJ9G8vHFYqEdXbzmz+XXcAADhd7HsLAAAAT0nGQhrLHa8EGssV9cOXjum6c8+gtREA4GskgQAAAOApyVjoTTvD/mDXUU0Uyrr+vCUORgUAgPNIAgEAAMBTErGwRqa0g/3b80e0uD2mC5kFBADwOZJAAAAA8JS2Ke1gw9mCHt1zTNedu3janaIAAPATkkAAAADwlET0eDvY93e+oULJ6j20ggEAQBIIAAAA3pKMhSa3iP/2C0e0oqtVm5e1OxwVAADOIwkEAAAAT0lEwxqdKGhgLKf/2Nuv6zcvljG0ggEAQBIIAAAAnpKMhZTJl/TAi0dUKtMKBgBADUkgAAAAeEoyFpIk3fPUAa3pievsM5IORwQAgDuQBAIAAICn1JJAO4+M6D3nLaEVDACAKpJAAAAA8JRENDz59+s30woGAEANSSAAAAB4Sq0S6JzFbVrbm3A4GgAA3IMkEAAAADyllgR6z3mLHY4EAAB3IQkEAAAAT9m0tF2/ftVZ+tBFK50OBQAAVwk5HQAAAABQT+FgQL921TqnwwAAwHWoBAIAAAAAAPABkkAAAAAAAAA+QBIIAAAAAADAB4y11plvbMyopN2OfHM0o5SkfqeDQFPhmMFccLxgLjheMBccL5gLjhfMFccMprPSWtsz3RNODobeba3d4uD3RxMxxmzjeMFccMxgLjheMBccL5gLjhfMBccL5opjBnNFOxgAAAAAAIAPkAQCAAAAAADwASeTQHc6+L3RfDheMFccM5gLjhfMBccL5oLjBXPB8YK54pjBnDg2GBoAAAAAAACNQzsYAAAAAACADziSBDLGXGuM2W2M2WuM+V0nYoB7GWOWG2MeMcbsMsbsMMb8WvXxzxpjDhljnqv+ebfTscIdjDGvGWNerB4X26qPdRljHjLGvFz9b6fTccJ5xpj1U9aQ54wxI8aYT7G+YCpjzN3GmGPGmO1THptxTTHG/F71nGa3MeZnnIkaTpnhePnfxpiXjDEvGGPuM8Z0VB9fZYwZn7LW3OFc5HDCDMfLjO9BrC/+NsPx8o0px8prxpjnqo+zvmBWGt4OZowJStoj6WpJByVtlfRBa+3OhgYC1zLGLJa02Fr7jDEmKelpSe+V9AFJY9baP3M0QLiOMeY1SVustf1THvuCpLS19k+qyeZOa+3vOBUj3Kf6fnRI0sWSbhHrC6qMMZdKGpP0NWvtpupj064pxpgNku6RdJGkJZIelnSWtbbkUPhosBmOl2sk/dBaWzTG/KkkVY+XVZK+XXsd/GeG4+WzmuY9iPUF0x0vJzz/RUnD1trPsb5gtpyoBLpI0l5r7SvW2rykeyXd6EAccClr7RFr7TPVv49K2iVpqbNRoQndKOmr1b9/VZVEIjDVlZL2WWv3Ox0I3MVa+5ik9AkPz7Sm3CjpXmttzlr7qqS9qpzrwCemO16stQ9aa4vVD5+QtKzhgcGVZlhfZsL64nMnO16MMUaVm+T3NDQoND0nkkBLJR2Y8vFBcYGPGVQz2hdIerL60CerpdV3096DKaykB40xTxtjbq0+tshae0SqJBYl9ToWHdzqJr35xIn1BScz05rCeQ1O5aOSvjvl49XGmGeNMY8aY97pVFBwneneg1hfcDLvlHTUWvvylMdYX3BKTiSBzDSPsUUZfoIxJiHpnyV9ylo7Iul2SWsknS/piKQvOhge3OXt1tq3SHqXpE9US2eBGRljIpJukPRP1YdYX3C6OK/BjIwx/11SUdLXqw8dkbTCWnuBpN+Q9A/GmDan4oNrzPQexPqCk/mg3nwzi/UFs+JEEuigpOVTPl4m6bADccDFjDFhVRJAX7fWfkuSrLVHrbUla21Z0l+LclhUWWsPV/97TNJ9qhwbR6vzpWpzpo45FyFc6F2SnrHWHpVYXzArM60pnNdgWsaYj0i6XtKHbHUIZ7WtZ6D696cl7ZN0lnNRwg1O8h7E+oJpGWNCkt4n6Ru1x1hfMFtOJIG2SlpnjFldvRN7k6T7HYgDLlXtb71L0i5r7Z9PeXzxlJf9rKTtJ34u/McYE68OEJcxJi7pGlWOjfslfaT6so9I+ldnIoRLvenuGesLZmGmNeV+STcZY6LGmNWS1kl6yoH44CLGmGsl/Y6kG6y12SmP91SH0ssYc6Yqx8srzkQJtzjJexDrC2ZylaSXrLUHaw+wvmC2Qo3+htVdEj4p6fuSgpLuttbuaHQccLW3S/qwpBdrWx5K+n1JHzTGnK9KGexrkv6bM+HBZRZJuq+SO1RI0j9Ya79njNkq6R+NMR+T9Lqkn3MwRriIMaZVlR0qp64hX2B9QY0x5h5Jl0lKGWMOSvqMpD/RNGuKtXaHMeYfJe1Upe3nE+zc4y8zHC+/Jykq6aHq+9MT1tqPS7pU0ueMMUVJJUkft9bOdkgwPGCG4+Wy6d6DWF8w3fFirb1LPznXUGJ9wSw1fIt4AAAAAAAANJ4T7WAAAAAAAABoMJJAAAAAAAAAPkASCAAAAAAAwAdIAgEAAAAAAPgASSAAAAAAAAAfIAkEAAAAAADgAySBAAAAAAAAfIAkEAAAAAAAgA/8f2js5+W9Z3opAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index 10\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index 11\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index 12\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIUAAACMCAYAAADiDBl2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3xUVfr48c+Zkp6QhJLQQxUQBRRBFARFxMKKImCX9beuuxZ013Vdv67r4trrWtey9oYFG2sBBEFE6UiVFiCd9F4nM/f8/jiTKSmQQKh53q9XXpm5c+bOmXrvfe5znqO01gghhBBCCCGEEEKItsV2pDsghBBCCCGEEEIIIQ4/CQoJIYQQQgghhBBCtEESFBJCCCGEEEIIIYRogyQoJIQQQgghhBBCCNEGSVBICCGEEEIIIYQQog2SoJAQQgghhBBCCCFEG+TYXwOl1BvAJCBXaz24kdvHAV8Ce7yLPtNa/2t/6+3QoYNOSkpqUWeFEEIIIYQQQgghRNPWrl2br7Xu2Jy2+w0KAW8BLwDv7KPNj1rrSc15wDpJSUmsWbOmJXcRQgghhBBCCCGEEPuglEptbtv9Dh/TWi8FCg+qR0IIIYQQQgghhBDiqNJaNYVGKaU2KKW+VUqd2ErrFEIIIYQQQgghhBCHSHOGj+3POqCn1rpcKXUh8AXQr7GGSqkbgRsBevTo0QoPLYQQQgghhBBCCCEOxEFnCmmtS7XW5d7L3wBOpVSHJtq+qrUerrUe3rFjs2oeCSGEEEIIIYQQQohD4KCDQkqpRKWU8l4e4V1nwcGuVwghhBBCCCGEEEIcOs2Zkn42MA7ooJTKAP4JOAG01i8DU4GblFJuoAq4QmutD1mPhRBCCCGEEEIIIcRB229QSGt95X5ufwEzZb0QQgghhBBCCCGEOEa01uxjQgghhBBCCCGEEOIYIkEhIYQQQgghhBBCiDZIgkJCCCGEEEIIIYQQbZAEhYQQQgghhBBCCCHaIAkKCSGEEEIIIYQQQrRBEhQSQgghhBBCCCGEaIP2OyW9EEIIIfYjKQlSU490L4Q49Hr2hJSUI90LIYQQQrQSCQoJIYQQBys1FbQ+0r04OEod+88BzPNoypF+fsfDa7yv11cIIYQQxxwZPiaEEEIIIYQQQgjRBklQSAghhBBCCCGEEKINkqCQEEIIIYQQQgghRBskQSEhhBBCHFG7doHHc6R7IYQQQgjR9khQSAghhBBHzJtvQt++MHPmke6JEEIIIUTbI0EhIYQQQhwRWsNf/2ouv/UWZGcf0e4IIYQQQrQ5EhQSQgghxBGxdStUV5vLDgcsWdKMO1VmgOU+lN0SQgghhGgzJCgkhBBCiCNi2TKTLQRQVgYLF+7nDumfwRfdYcX1h7xvQgghhBBtgQSFhBBCCHFEzJsHlZX+64sW7aOx1rDmNnM5/VMoSz6kfRNCCCGEaAskKCSEEEKII+Knn4KvZ2buo3HFHnAVeq8o2LvgUHVLCCGEEKLNkKCQEEIIIQ47lwvy84OXhYfv4w45P4Dy7rZ4KiHzq0PWNyGEEEKItmK/QSGl1BtKqVyl1OYmbldKqeeUUslKqY1KqVNav5tCCCGEOJ5kZOwnCFRf1tfgrvBfz1vW6n0SQgghhGhrmpMp9BZw/j5uvwDo5/27EXjp4LslhBBCiONZSoqZcSxQ3UxkjaofBNKextslJLRsuRBCCCFEG7bfoJDWeilQuI8mk4F3tLECiFVKdW6tDgohhBDi+JOaCm7vzPKdvXsNLlcTjS031NQba2ZzNt42O9s/pRmYy1qb5UIIIYQQIkhr1BTqCqQHXM/wLhNCCCGEaFR6OlRVwbnnQlYW3HnnPhpXZoAtNHiZ1VQEaT8q0iB7UXDgSAghhBCijWqNoJBqZFmje1pKqRuVUmuUUmvy8vJa4aGFEEIIcSxKSQHLgnvuMdf/9rd9NK7Y0zAzyFPV8gd1V8L8kbD4Akif0/L7CyGEEEIcZ1ojKJQBdA+43g3Iaqyh1vpVrfVwrfXwjh07tsJDCyGEEOJYlJYGSsGIEeZ6RAT06NFE4/IU0G6wh8GQhyG6/4E9aMp7UFsKuhbW7Ss1SQghhBCibWiNoNBc4DrvLGSnAyVa672tsF4hhBBCHKf27oUTTzTZQmDqC40Z00TjygxwV8EJt8Ogu2DUuwf2oKkfmensAapzD2wdQgghhBDHEcf+GiilZgPjgA5KqQzgn4ATQGv9MvANcCGQDFQC1x+qzgohhBDi+JCXB+ed5y/tExMDw4c30bhiD2BB0rWg7BA3FJyxLXtAjwvyfvZfV61xXkwIIYQQ4ti236CQ1vrK/dyugVtarUdCCCGEOO6VlUFSkhk2VmfAgCYaV6SBPQKi+5nrniroNLplD1iwAmwhYHnnva/LGBJCCCGEaMPkNJkQQgghDiutzfTzAweCI+D0VK9eTdyhKhPaj/AHchxR0Glcyx60eLOpJSSEEEIIIXwkKCSEEEKIw8rlnU2+d+/g5YmJTdyhpgCi+4DyRpBsdog9qWUPWrLlwGYsE0IIIYQ4jklQSAghhBCHVUUFOJ2QkBC8PDKyiTt4qiCqrxlCVieqdxONm1C8oWXthRBCCCHaAAkKCSGEEOKwqqgAux3atw9eXtvU6C5PNbQbCLaA3Zbwzi170PI95v/QR2FyCoTEt+z+QgghhBDHof0WmhZCCCGEaE3l5aaWUFRU8HKXC8LD6zW23KA9ENE9eLktrPkPqDXU5EFoBzOtPTYY8KcD6boQQgghxHFFMoWEEEIIcVhVVEB0NHg8wcvrpqcP4q4AmxPC6o01a0l9IFcRoKDzRLBcYA+B7tNa2m0hhBBCiOOOBIWEEEIIcVhVVJj6QW53Mxq7y02B6ZC44OW6OXf2qkwHexh0uwScMWZZVFNTnQkhhBBCtB0SFBJCCCHEYVVeDhERDTOFlDL/X1r9EiEPhJgrdUEhewuGi9VXlQUoiBvmXyYzkQkhhBBCSFBICCGEEIdXRYUJCllW8PK6OtILdy+k1vJWnXZXgCOikcwg1fwHdJWAtiCia8Dd91FWMTHRRKgC/xITm/94QgghhBDHCAkKCSGEEOKwqqgwBaXr1xCy281/jw5IIXKXgyPKFJwOpFqwC+MuhZD2QMADBk5vX19OTvOWCSGEEEIc4yQoJIQQQojDqrwcwhoZDebwJu+4PC4AtNZQWw6OSDMDWaB9ZfrUV1sK4QngXS8QPL29EEIIIUQbJXtEQgghhDisamrM8DFVbwSY02n+V9ZW+v+7y01Wj64/1qylQaHOB9FjIYQQQojjkwSFhBBCCHFYWZYJCtVP1qkLEpXUlABQVF3kHT4WQdDQLzDT1DdXTYGZ0r4l2UVCCCGEEG2ABIWEEEIIcVhZFoSENMwUqlNaXQpAcXUxWDXgCD+4B6wpAGc02FsQSBJCCCGEaAMkKCSEEEKIw8qyTJZQU0GhMlcZ4A0KaQvsUbRotrH6aovB2Q5sIQe+DiGEEEKI45DkUQshRAslJUFq6pHuhTi66AYxi549ISXliHTmqGdZ/pneG1PhqgDqgkLaDBVrqnFzuEogtMOB318IIYQQ4jglQSEhhGih1NSGU2kfUk0dDB/WToh9UqrB+3EwMYzjndb7fn0q3abQdHF1MYRaLZt+vjG1pRASd3DrEEIIIYQ4DsnwMSGEEEIcVvsbPlbHN3wMOKjhY+6KlgWFEhKat0wIIYQQ4hgnmUJCCCGEOKwaSaxqVFFVEURHctDnsLTb1BRqruxs878uaiVZeUIIIYQ4TklQSAghhBCHlc1m4iyNxVp0wMLcylwgqWFK0WeJUJ0D2OAqz/4fUFvgiDyYLgshhBBCHJeadepNKXW+Umq7UipZKXV3I7ePU0qVKKXWe//ua/2uCiGEEOJ4UJcp1FhQqMpd5bucW5HrrSdkBTeqzvFeqLe8Sa1Ql0gIIYQQ4ji030whpZQdeBGYAGQAq5VSc7XWv9Zr+qPWetIh6KMQQgghjiM2m6kr1Jji6mLf5czSTMCbVsRBDOHSWoJCQgghhBCNaM4e0gggWWu9W2vtAj4EJh/abgkhhPCRorfiOGOzgcfTeKZQYFAoqyzLG8w52Jo+FjK3hhBCCCFEQ83ZQ+oKpAdcz/Auq2+UUmqDUupbpdSJja1IKXWjUmqNUmpNXl7eAXRXCCHaoOzs4KNnrf2FcIU4BtlsUFlpAkP1BQaFfMPHLOvg4kJaB9cl+iwRPlDwgf0gViqEEEIIcexrTlCosTlg6++arQN6aq2HAM8DXzS2Iq31q1rr4Vrr4R07dmxZT4UQQghxXHA4oKqqYaaQx+OdcQxw2BxU1FYACqwqml8/qBHKFjC1PQdQk0gIIYQQ4vjUnKBQBtA94Ho3ICuwgda6VGtd7r38DeBUSnVotV4KIYQQ4rgREWEyheqrrfVnCsWExJiFyg7u8oN8RBUcFBJCCCGEEEDzgkKrgX5KqV5KqRDgCmBuYAOlVKJSJi9bKTXCu96C1u6sEEIIIY59kZFQXd1wudvtDwrFhccBYNnDIGBGsgOi7EhWkBBCCCFEQ/udfUxr7VZK3QrMB+zAG1rrLUqpP3pvfxmYCtyklHIDVcAVWjdWPlIIIYQQbV1UlBk+Zqt3asqyoKjaDB+LCTWZQtU4iHBX0vho9mZSCjyNRKGEEEIIIdq4/QaFwDck7Jt6y14OuPwC8ELrdu3YlZQEqalHuhfiWNCzJ6SkHOleiCPGXQUrfwdlO2Hoo5A4vsWrUPcrbMqG575GKvYKcZSKjDTDxxoLCuVX5gPQLrQdAOUWRHgqvdk+B0jZwFV64PcXQgghhDhOyfysh0Bqqimeedj+UE3/Hc5+yF+L/yR42MatvAHSP4fCNbD0ErDcgAn0dHi8+WXZrObWSindDj9fC+vulKwJcdiNe2sc6n6T7RMZCRUVpuB0fbkVuQDEhscCUGpZpqaQLaBxWELLHtweAbXF+28nhBBCCNHGNCtTSBx/3B43SinsNpmOV4gjImseZHwJljc446kMOugtqGrlsmw1BbBwHFRngy0MKlJh9MfB03QLcQgFTjUfFQXl5eB0NmxXlynUIdwERotr3eCuABXQeEq2mVK+uZzR4Co6oH4LIYQQQhzPJFOojXI+6KT94+2PdDeEaLt2PA+eCog7BZKuAtV6MXqtNZWuelM7rbwBXIXmslUNWd9KQEgcVgWVJtBZ7ir3FZp2u4Pb2O2wOms1AK/98hoAa/O2e4On+sAf3BljAqNCCCGEECKIBIWOZlrDmttgTgdYNMGcKQXeWPcGjn8FHEAmNJFG39RyrzJXWWv1VAjREh4XZH8PsSfDhKUw4r8w4lUAaj21zV5NYOZF4P3yKvKIfCSSwipvEKimwASB0ND7/0HiuSYgJcRhlFORA0BqcSpRUSYgVFQveScszASNAm0ryQDtAfdBbLOccSZTyDtEs8XDzwLMmwcjRsC0aVBScuBdEkIIIYQ4GkhQ6Gi2/m+w63VwFUD+Mvh+ImjNgt0L8GiPv45IdrYJINWpK1iTnd3oausmhmt2HRIhROsqWAG2EDj9TbCHgyMCekwFIKM0w9dsf5M4ppWk+S5nlWX5Lu8s3Gn+F5j/ZH4FNiec9goMfx7O+hK6XNRaz0aIZqm1TOAypTiFyEgTFMrLC27j8YDHCi6avreqzARzqus1bonQeHCXgrcPTGl8+7g/ixfDZZfB6tUwdy6cfXbw5lcIIYQQ4lgjQaGjVflu2P68qTMS1gksFxSvB6XYW7YXgMzSzP2u5p0N7/gKe9bZW773kHRZCNFMpdsgrCO0G2hmRQKwhQLmgLlOXWZFU1KL/ZXKU0v8l+uCQXXBIdI/h6g+0HO6CUA5IkxASojDJDDAmVKcQkSECQplZAS3KywEXW+YWHZ1sckUqjqIbVdIPNQU+oNCB8DthssvN7OmAbhcsHWrjMIUQgghxLFNgkJHq50vm53gUW/DJZlwwXrA7HnuKtoFwI6CHftdzdqstUDwMJNdhbt8l1syVEUI0UpKd0KHUf6hLOArMh0YFAq83JjAQFBggGhb/jYAtudvNwtKtkCva0x2Uh176IH1XYgDUFTtHye2s3AnNpspMr1tW3C71NSGGax5FfkmaFqefOAdCInzBpUOPEP2229NHaSpU83/LVsgIuLAuySEEEIIcTSQoNDRKuV96Hk5dJtiDhaj+sHw5wDILDMZQs0JCtVlCmzN2+pbVhdUguDhJ0KIw6RkM8QMAEdkg5t2F+32Xd5fUCjwuxwYIFqattT8T11qxrZUZZrhYraA2Zvs4QfYeSFaLvCzvCFnAwDh4ZCc7M+8AVizveGwruKaYrCHmQw7j+vAOuCMMUGhgyjo/uabkJgIb70FoaHQpw98+ukBr04IIYQQ4qggQaGjkbsCqnNh0F/BGWWWOcKgxxVBKfibczfvd1V1waCt+f6gUGAwKfCgUghxmJTvhtjB/qFjAX7N/9V3eX9BobqMoPqXV2auBGB5xnIz45i2ILJ78J1tjcwFLsQhEvhZXp+9HoD4eBMUcnnjPDU1sGp7eoP7VtZWminly/eAp+rAOuCMhuqcg8qQW7UKbrsNQrwJd6GhpuC0EEIIIcSxTIJCR6PS7RDaEWIGBi+3asityPVd/Sn9p/2uKqUkBYBfsn/xLduYs9F3OXAoGQBlyZC/AtwHuOMthNg/dwVE9mz0pk05m3yXAzP8GvNrnj+AVBfs1VpjaYsQewi1Vi26PNXUJVMSBBJHzp6iPQDEhMb4hjMnJMDKlf4hWNXVsHm9+Zx2CO/A9EHTAYgLjYOwRCje6BtmibuSFnHGABpq8g+o/7W1kJMDl15qhr0JIYQQQhwvJCh0NCrZCtH9Gu702kKDsnzqUvCb4gpIs1+4e6Hv8tq9a32XfdkFnmpYeSN8c7KZ5ex/fUxxayFE69NuX2Hp+nzFoQnO/mlMWkkaTm/GT13busBxYlQiAMWVORDSHqyag+62EAeqbtvVJ64PYKad79rVTOme6Z0zISwMtuysAOCkhJN4auJTAGilIaIblO30F4rWwTOU7VfdFPSl+x923ZjkZIiJMYGsQFJTSAghhBDHOgkKHY2qcyCyB3WFpX0c4b4d66TYJGDfhaKTC01RTofNEXRwmV2eTXRINBAwBG3t7ZDyHiSMg97XmYBQYFFaIcRB2Vu2l9Lq0oAlATMsfZYIHyhc75uf5O4xZqjX5rymh4iW15QDYLfZsSs7Za4yLMvyBZV6xPQAILMkxTtUTObNFofG3r2QlRU8NfuW3C2U1ZT5rtcNGYtwmihKSlEKSUnmtk8+AcuCn3+GWrvJIooJjSEqxAyfLqspg6jepnHOD2Y4ZP3t4/5EdDPbtcyvDigTNjPT1BCqbGGCkhBCCCHE0U6CQkcjy2WmjLbZG9xUN1ykb1xfAPYU72lyNXVtA8/MFlWZGWA6RHQAYF32OjNkbM+7cOpzMPpjGPo4TDqws6lCiMZ1eboLnZ/ubK7YnCY7r061mXp+ZbU5qt5btheForK2EnfgDGUBVmWtMnd1V+PxZk3sLNzpm46+V1wvANLK9prMpMCDaG8Qig8a/sYI0VwpKXD22dCrF/TuDaNHm2nb3ZabwS8NZvqc6b62dRmqa7LWAPDZ1s/o3t3U5Xn4YXjtNfjDH4Bws41qF9aOSKcpxF5RWwER3U123ZYHTS2uXx9pWWfDOptt695vAMsbWGq+mhqIjjbBKyGEEEKI44kEhY5GSpmT+nWnXX0HcIov1zwN+IeOLdqzqMnV1GUB9W/fHzDDS77Z+Q3gn3WsuLoYK/1LiB8BSVeCIwoc4d76C0ZJdQkVropWfYpCtCWFVYWAt2AugMNbNLeeVd44kVu70d7Mns05jWcL/bL3lwbLVmeu5v1N7wMwe/NsAL7etRBqCoKHq3mDUAczPbdo28rK4MwzTYbQK6+YoE5JCTgc5nMI/s+oZVm+wGWNxwxj3Jy3mZ49TVCopMQEhHbuBMJMplBcWBxOuxO7spvAZ3hX8xkuXAMfR8OWh1vWYZsdnO2g5Fczi1kjRd73RangTCghhBBCiOOFBIWORrYwqC3210zwHcDBHm/SQF5lHgDzds5rcjVvb3gbgPm75gPwya+f+M7SegLqMVSkfAjdJgcfNNr80/bGPhZL1CNRB/58hGgjKirg0UdN5kRiIlx1FWzbBt/v+d7XJr8yH6L7QMkmsLzfQ2+9k82NlP2pywiqL7DIdJ1NuZt8w3TqMowW5ewwvyG66aGmQrTUk09Cx46wdi1cfTVceSWsWGFum5dstks5FTlY2mo0o3VHwQ7f8LFAzmiTKRQbFgtAmCMMgIqQjv5kN3f5gXU6opv5v2g8fD24RXetC17ZJblOCCGEEMcZCQodjSJ7mCwCFVwzwWU1PK+/JW9Lk6tJLzFT+9YVnF60e1HjNUrKk6HTmKBAUJ2ssiz/43uk8LQQTamqgjPOgK+/hn//Gz791Aw3iYuDL7d/6Wu3aPciaDcYSraBx5uBNyUbgBxv0Ndhc2BX5ugzszSz0cezeTMdukZ39RWVRkFJTUlQu12VxSYroiJgqu+wetVyhaiT9zMsHAeznebv+/P8xZ0DvPcePPAAhIeb7CC73V90+bVfXvO125iz0VffTqFweLczBVUF9OxpZhwLpKLMCY+6und1QaEie+zBz4rZzhsIqi2BEu+282bMtrb+X2Ji0F179IBdu0wxbCGEEEKI44kEhY5GMQNNoMbm3fv0HsDt8O6XKxQh3iLQdcNS6gusM1InuTDZV2t2RNcR9I41hTtt2gJ7QJZQQL2RjzZ/5Fv83a7vDvaZCXFUsCxYvhyeeAIeeQS++w5cBxnzfP55EwCaNw8uvtgMrXnqKejUSfPexvd87eZun2tmF8xf0aCYe6g3DvzW5Le4d8y9Zpmj8VnKSmtM0epnz3+WB89+EICy6jJfhlC4IxwAt+VBh3eBrG/9B/feIJQQDSy9BPrfAtPLYFoJJF3lLVTuV1UFqalwzjnBmTM2m/lcZpVl+bYv85Pnm5pAwKUDLmX1783QslB7KHFxDc594Akzs+fVFZmOcEagUBR6rEZPXLRI3BBQB7aOXr1MJmBmvRhthYysFkIIIcQxToJCR6PoPlBbBrneWVamZMNVmixvFsHYnmPZMdMUgtZNFDlIKU4xqwqJ5uL+FwNgaYv8qnwAXrjgBW4ZcQsAFTihfLf/zgH1Rp5d+axv8Ru/vNFKT1CIIyczE4YMgTffNP9HjIAlS6C4+ODW+8or8Pe/Q2SkOTgGiIqCH9N+BPBl/szePBsrZiC4CqFgFQQUkt7lvdi/fX/6xJsC8Vvztzb6eLuKdgGQEJVAQpR3+Jm3jljnqM5U/r2ShEizvCayr5ld0JJsP9GEum3JyP9C19+APcxMeNDj8gZNXS4TDGosa+al1S8BkF5qMtMe++kx9hSZ4WN94/vSN95MkrC3fC9KwcCB9boRXoBC+YJCdcWmi6uLIbp/wwdsSdZbzAnmOQV6IyG4WJDW5i87OHDqcECXLvDxx6bodB3bkdiL0trURspeCNnfQ9muI9AJIYQQQhwvJCh0GG3bBjfeCFdcATfcYOowFIcnNkxbt4fAXg2b/wUeb7q8u5yd3pP8AzsOpGdsT0JsIRTXFPuL1wY+lncK+jE9xvDFFV/gtDkpc5WRWpwKQJfoLnSJ7gLAKk8MZH5tAlHg28leWQWpJam+dX627TOzYy7EMezqq+HWW+Hpp+G882D8eLjnHujU6eDWm58P/Rs5Zv3Pqv8A/jpeGs2CogJTM2z5b8133G2+w5neoFBiVKJvSFjdbGL1ZZRmAJAQmeAL/uwuNsHdztFmlrPOUeZ/WswwKNsJ6Z+Zx3LLvNptXmK9bU+8d3egy0UmIFTHm3EWKCrKBEPS0hqu9s31bwJQ681KK6ouYmPORgC6xXQjKiQKp81JZW0lZTVlTJwYnG0UHl+IUoroUDN8LCo0CqUURdVFpm+BmT7RJ7Qs663j6OBZ/5SzRfcfPRpefBFqvdviqipYsKD5D98qClbDvNMgbQ5gM78jO/9jisnXV/89bmJonBBCCCHatmblUSulzgeeBezAa1rrR+vdrry3XwhUAr/VWq9r5b4e09auhd/+FubPN5kEdWIWAdWN3GFFOHRdB2tugyEPQsYXbPKenewdZ9LyO0Z2JLMsk+TCZE5OODno7nVFaAd2HIhSii7RXUgtSfUFdRKiEnxBoa/KapmU8SWc/ADYw81O8geKZ7zxn1B7KB7twW25eXnNy9w9+u7WelmOX9W5UFMIaDOjW0S3huMkxGGnNSxdCp9/bg5s6wR+Jw9Ur17w88/QtavJKqizu8gEas7sfia5FbnsLNzJxrxfOb/LRZA+xxS8jeqFS0Oxt2hYQlSC77taN1NgIEtbFFSZjIpOkZ0IdYSiUKaINZDULgmAHrE9WJ+znjV0pr9VCytvgLyfoCK1wTr3JzsbFi0yGVWWZT7OXbqYIUSxsc1bR0YGrF4Nld6YVGQkDB8O3bq1uDuimdxu+OEH2LzZ/77Z7fCHWggavFiXRGZVg8375fgs0Zs5aoOr/MOR7XYYO9Zkx917r/+7VFEBuRVm+NekfpNYlbmK3Mpc1u01uwN1gc648DjyKvJILUnl7LMH89JLUFoKISEQGlNCdUCmUHRINFpr833oPB52vgC1paZOVpcLWvZihLaHqD5Q6s2+s7esQND118PcuTB5Mrz7rjnRc9VVTQwhs2oh90fzWFqbF77eMLwWqy2H7yfABeshrJM/66njGeBohR8xIYQQQrRJ+w0KKaXswIvABCADWK2Umqu1Dpz65gKgn/dvJPCS9/8xzW25fUUxD9b//mdqjLRvb2Yx8QlMUa8LGmgNrmL4vAvsfsP8ARtdZvKV7jHdAZPtk1WWxY6CHQ2CQnVTAveJM0NQerTr4cv6aRfaDofNQdfortiVndmFRbzcOQG+OwNGvQNRJui01husenri02SVZfHQjw/xU9pPjT6/7dvNQUdtrT+dXmuIiYHTTze1VtqETQ9AZQb0+6MpGI6CmnyozgNXPrhKMeXClfeAZNgh6YbHA4WF5ky2ZZkgRXy8vxBsa6uoMJkydWfQw8PNzEQhIfu+3+GmFPTrZwITY8aYfoIZDgT9TrgAACAASURBVHOwff3LX+Chh2DiRDOsJjQUyivdbMrbBMDcK+eyeM9ipn4ylW92fsNdFz0EWV9DZRpUppFea77fkc5IQuwhJEYl4rA5yKvMw9KWr7A0+A+87TY7MaExJiiklG+677qhZ/3i+wGwsSSLqzqfB1nzIPkVf6ebOfTm1VdNAe33zWz3eDzgdJrn2ZzhM5ZlgkfXXmsOouvu4/Hs+35HI5fL1NMJDI6FhMDQQ/BY27aZ4EN8vCl0HBJigifp6eY1vPXW4OBmfZWV5vP+xRdmyvfqatPf8HDw3JAN4fi3OxXewMXGB+Dk++oFGepPcQB33glTppig3kUXmd/7j+alUVRdRHRINHOvnMuDSx/kviX3kVqSil3ZfUGhjhEdya/MJ6U4hbNGDabKmxAbGgqWowybx+YLCsWExgDe4WMdTvdn+tgjIfHclr+o3afCr496Z+Nr2Rzz55xjtmXff2+Cv9DEb2pNAXw7DMb+D/rcYPqs6n7z/9DyPtepLTVDysO7mIxiaDJwBzS9f9GE9JJ0Rr0+isyyTOZMm8Nlgy478L4eq6pyzO+yVWMyyVCg3YAFYYlmaGUr7RcebcpqysgozWBAhwGouoyynJwG7TyJnXh6zp18uf1LXrzwRYYkDkFryMsz+x0ej/l9iow0qziYbevateZ3sO63FsxHODISzjoLOnQIaKwtqMw0+1zag9nPCoHwrhAaf+CdwGxzJ743kYLKAuZfM5+BHQaY7NuKVG+tPu/3yhYG0b0hMumgTgRqrdmSu4UesT18v4Et9UPKDyxJWcKtI26lfUR788K5y8FV5P1M28xJy9B4E2QP6oAFVXu9bT3etuHmt6f+EFzReqr2QulO8ARkc6sQiOxuSovUf5+aYGmLkuoS4sLbxsGX1mbfqK42aGiomeilJV/B2looLzcn0ux2s291tB3DHGrN2bKNAJK11rsBlFIfApOBwKDQZOAdbQrcrFBKxSqlOmut97akMztWb6Jqy5v0P2dK0PKb3v0rCx078CiFQmFXNv7Ubjx/6boBfcEGlHcDrbXFDy8+xMAhscT09B9sZ6cVsXfFBwyddrPZ0Hn9efb9fOT+iTKPC5tS2JSNyXFjWZS/lAL8RQMcys6djosZ3DueS0fNQCnF1uI9bMnbzNiMteyJepBaFY/Gjk15gP5U/3gzW12/Y29OGFrDaX1q+fObPVlyaTvGjbP5DkJ/mfsZCZE7SRx8JnVJ+lVpy7j+pk7ccd1LnKpuwq6r8KgItlW7UHjoWFVAVdoyeoREsRqNnv0WJVc4aRdw/zW7f0IBnV3lVKUto09YO340LxLxjnCq0pYR664GNGXJQ3go43b+Nvr32L47Gxu17KqFnW5wKgfXdBxEblRnHgLSftnGE3kTuH7SXUQ6wylxlfPBqmQevPVWCuvVvE5e9yvl6/9LWNllVJX5l8989//4ISQZbXdgUwpLW1wZdSGTKis56dI/BL1H/5z9KNUdXZzVfzwhNgcrczeTtWIYu5ffxg8/BD/e0jdeITHBotvgk3w/BEX5Fez69lVOveZ2VMCP6X2f/JvZru8ptqpxKAcazYT2o3jywzSSluwIWu+9fzqLVzuso8BdgcNmxjkMsyaT+doc0tODmlK96UVCz5+Hih9qDgS+TDI77O0Gw0Wbgtq+9eGzwDDyd31HpDOc3aWZzM9YwXVVW9jpvplydQKWtqMUlKWtYVDCapLGTME/LzPc+dZfGHXaGM7qPRa35WbJ3nV8/uzZDB50Do88Ety3e56YzNhTT+OsvuPQWrM0+xdWrv+V5cULiemcREJ4PNlVBdiwEfvlLYyaeBaDh5ohHEpBVkoeaxes4trfdSIkRJl4l0vR7/TTcbmgZ0//Y61at5wZ71yD1T6euNBoymorCLOFclHmJIYPaE+PQX19TyMvT/PmKxXM+H0EkRF2lNJorXh10StEd7W4dPgUQu1OVuf9yta0bOY9dAuvfNCHkFBl9sMUROa+T8r2fHSncygrd6K1whFSwqLtNzFj8l/oG9cLl6eWeRnL+defPfz2mjv457/CuXiyDbsdfvzRImH39Qybcg02p3+4zDeL4li1SjFlio1I0lDU4rJ3Bk5h3nur6N2zHJvNAq04s8MmesWOY9jQk5g6zUaHDorZP66gemQ1HUPbEZ73K4PRKOCnZZqZi9vx10t+R9eq17BTRbInGk05sY4wqtKWEaEtLMvD8NKBrH/tZgacdzV1u2Lbt3+JZXlo54ygOt0EakNsDhw1DsodlXSx3FSlLaOLt17RnBe70e/M6VzbbRVOnYNFGPOKzuXR0k2UPt+PSEc4le5qOobFcXPl2UTGnElM9yFY3jdp9Q+KxIREoqIcFBebHX6XC0JSX2HbnlhyXCfjsRxooKQ0nflpM5lx0Z/oE9ONIlcZ81PWsPznh/jgA4cJXnl/Xj3lmdgWn4OevABC/OlGH872kL11A2efbcNpK0NpTYnbyVcrHuaaqTeTFNsNS1t8n7WGLSu30T62jCvH/QG7zUFq2V6W527ih2d/w/VXlpDYWWG3WWit+G5ZIsm77cyYnktEmNmRd3vsPPb93zj3zPM4s+cIqj0uvs9cTfguJ9f+3zM4S/w7Z1sZwDmJW9lbb8u2e/6LNOXTjyoYdLI/IyVz8y+c9buxhJQFD+FbPG08J95xNdFd+vmW/f1P3Rl7YU9uu81cr0s4KVr+LMk5/VizuB+WZUMpKM/LoEPJ6wyd+nvqvlxlZXZKioeTlOSgtlb5fhdzUvaSNf8+Tp48I2i7Ew6UbnybyPJU7EmXwanPUrzgD/zp/ee5obuHKNdaQjx7cdm70MO9hcvOOYkZ1w0lIdGOzQZZHb+C8+Gk2CSq039iSIj5xFbUVKAUxJamU5W2jARnBL9qi55rZuI4tZpJE8bxxbft6RhfTaa7BK09OAq2U+VxEeWpQaN5855B9LyxkjHhl9Gx8iNqrXD+89G5UJ3GuafvIdThAmXez+SFH3Hm9EnEBzy3n1bF8L+v7Fxx5RWM4EkUir1hv2Pnv+9i6LkjiQ1ou21dKrb8ZfSbcJXvO1eVtgy141nef/BiLrz5Ksor7ISFephwzlye/s8bzDj/diIcYZTXVvJT6kJ+4yrHFt0fZXk/7JsfZvWS9zgNyNr5LXGh0ZTXVjIvfTmb/nchXePiOX1MFFGu1WhCyChOwpH8NGdcdU3Qju3m3OkM+/Fq7COfQ4W0B2BbSSw35NrJ/nd3IuyhVHlqSAiP55ayczljcCc6nRiwf7F7AVWr72dH5GMUV7TH0jZsyuLFnTfxlce/UZ36yVScxT2I/2A323fYadeOYJsfhMH3+q7W1sKG126lKmE6hHdHY0NpzdJNb2CL+4Vrxt1IlCOCnaXpLMpczeVP/kDvJcGzp/4yaCjhd46h5znTgvbm73vrb0waewkjeo1Ca833WWvI21zCMHsx/c6ZErTP8PN77zDsgnOI6NDdt2zH+jQGXXsDztLg2etePG0mcTfMpEsvf3C8596b6DVyHJxwW1DbmU9eTHJkBj3i38WGIr0ih1NrR5D8xRXMvHcIyubfHqUtfJ7TRkWR0P9E3/2zckJ45GGLG39XRbtoNzZl4bFshJUsZm9ZH6oiRlBV7UABsRH5nGq/m8JuD7IluQMVlXYiIzwMKrueLuP/Cj39db4qSyv49ZXLGHzFPSi7/wgm+4+z6Pm/+UHPwYqCgqd60uHyBRDuf873vPkXHs1+PahtQng8qeUV1J/m4P8u7s6jp6TDwrsAGPrKUMgZTPevNpGWFjwMe84Xb5KR9zXXjb+JcEcoeyvzWZi5ikklm9lVdQ2uiCFYlh2bTVObvxl3cSodT7kYS5uMut0pDu78R+cGv7fbV26gZus7RFZeSlVdIm1tKeGrLoYr3eYA2mvHds37r+5m2qRfCXPWgALLUmz5fhHDx/WhQy//mO/MlBL+86Kb39xwNjabzfd+3r1sNCvY4Gs36D+DeKBdJ+4deT6Mejuob57tr7NzfTZZ1VV4tBM0lFfuZe3uv/Db6XfTNTKBWsvNgoyVpC3rQ6JNM2J0J+wOhQKyy4q48MfLKVI1Qev9nedtEoqGc+GlHWnnWYvCTYXzFGJT/4+YodeyO6MjBYVOYqLdfJnyMP8u8U8SM+uHWYwMd7LihK4weQ84o323PXnfDtbv7sB77wU8WPEWWHweXJoJEV19izcu+omQvDfoecaFvmXV1Yrep57Muo3R9OrlX8Wn377Ps7/MwtkhlpiQSIpdZcSGRDMg3cm4kWdw1oAJAKzI2UR5QTIddlZS1e1mbI5INAqFRfHaVzljYj+iuw7wrTd9Vz7FGz9j8CW/D/7ef/IVA4d3J67XEN+yjCwbb7yYy9UzoomIdKBsGm0pzp8+gJfeSmD8eH9/C/I1f5yRzszfpdClkxubTWNZNpYuzCehcwinjGrva5tdlM+li68jVfkPbMLtoTwTfTux7tPpfNJIf9+0m/apfyIv7k+4bJ3Q2oZSmpKdi5n86F9wFAekmQ4BHh0O568Oeu9f/eAJ9pQ/xpQRVxEfGsOWot38lLMB+6ZkLplwFSd1HYrWmh/2rmPhqhX8u+jDoNMd7UPb8a5rEiMvnkx4fGff8lXrolnwVSHTplpERmhQFh6PnW2L/seoi88gJqGLr+22DXkU7FjNqReNx2bzj/e+7+N/0XtgbyYOmAjAkr3rcKV7mPrJd3T5dn3Q8/j+5isZdMVY2vX0/y6mpcEHr+dw+XVxhIXbsSmwNDz93ZOkxWfTv/MJhNgcbC9J40SrLxNzSxh2xa1B733CwOEsXxXGif7VUlxYyz9u3cp1V5bicHh86/3gnTKsuJFMmmK2+FrDmlW1vPJaBOvWBScwLPloCe2cqSQNCji40RYrPniDM66+FkeY/1jh6a/f5rmij8j3VGBXNrSGkZ0Gcsue8zln+lmER/sDu8sX57Bqa2/GXWxG8nh/ZnhwyXC2RObhsDtxazfRzghutl3GObEWfcZeFrRN/OndNznlwvMIb+//fgLsWfYVutsUTjxrBAdCNVWo2NdAqanA+VrrG7zXrwVGaq1vDWjzFfCo1nqZ9/oi4G9a6zX11nUjcCNAjx49Tk1NDR7CsOydtxi96AF4Z3fQcjWrYb/G5JzJ0ouK4SLvFOsbZ8Hm+3F95CBkrjuo7YYBJzNkaBp8GFwPJ+luRWpY8PPvU96NXVEZhNdClzIoCoPCJoLisRuvY1TV23zzTfBypeCsk4u4c1YUQ08xB/XbNpUx6tUufDx3OktjLsJq3wlbSRGX3Powk6+eAf1vNqdU3OXwXAWzrv4ns7gfTgPGADvgigFdcDlcvP10PtEuWNgLHh4D308ErtL+OgEL/si1c96k1FXGm88VEV8FP3eHv0yA6DiYvBRu8f7m3HwR/LjnXh4MsTN59/1wGRAPBcvhmtPhrFXwf8tM29sugGUnduKXqFz65sNVm+GV4ZATofhw3jQKoqcTcvIAQmLCwNJUZ33Fja5/w7vBw18aez/PLz6Vb3PT4YPc/bYdXHQiZ658lukzBxER6zRfKktzwgt9iJtXGtQ2JaEHSaOz4NPgz8Qpdzj4JSZ4WYfqePJOKvS/lt734pyVYSyODx7jp0q68puvZnPHU0Po1N3fh/vuKeLRE26hT88S6NYLamcDVSya8xvGX9YZErtB1TIoXcAZ2+NY/q9CmBWwx585nL6LV7OzXhmZJc/ew7gtC+G/wRuLxl6fKwrGMDj975x8Vm8sZygohVXrZkpJ7wZtz6jow8+RDYuUOu53kbzHGRToWf/R8wxNmAfjvjYLNs7C2vgvnnrsT3QceSntBnZFhTrBsvg5+1WeCH24wXp1P+CyfDOMw7uOtCWv02PIKTD2S98yNt9P7FZFiSP4+9mlsgvlL2dSEjDrutYwqesnjLnlUm640Ub7DgqlFEt/WcfYuac26MP2NdD+q3g+ZjrfcgG1ODmbxdw15Qn4LLjtbfHP8MC9z9JuxHjofok565gyGzX6jYYn3D+KQC8axuL/hvIqv6eUdpwR8yFLf/8uFy+FW1ebfcwbfwMrd/6TB8Ph4g33w1QgETIXwv+7ACb+BHesMKv880RI7HoWf/ttRxgzx/e5zHu6ghkb4MzV8HdTx5q/nwO/DOqNOyKLl/5bTZ8iSI433/Ez3vX+nnTBfMeL4amCvtw5IrnB68Ms3eC56dyfWHblg/zw64Vw2ghURDiuonL+teAMSkpMRmCdL77/hEt/nN5gtZuXt2f5wsvIOv1SQnqanQ0rewv33HQrXJZnzoB53/tffu7DsOunwoDbzMGLggVvJDAxo4CoGnj7c1icBC+cDnHaSZEKnjL93Aj4bvAwuCB4FHPa8z3pMflJ6DHNt8zzaQKOzcG/OwBPl5zFn99eA4X+4E0FEbx+yh+JGXYJzh6JhEaFYLk9ZG5dwJ/fugmq8gEFvz4G2x5HXa3JzDTD7Oosff1lzvrr7VBUr+j3FBp8/gqHxzE34kaKwscS1q8HyumgvNDFX98+qcF7tPbr7zj1/atgdn7Q8vQL45k/fyppwy8lpHsiSltYuav4x5/uhyl7g37ruBoIBU4HhgMW7OrQm/VfDeOyG7+DE2aYA66KNDIefYFuc+FHRvMMt6OxMbr343w1ZSV3zIVJO6A8BGZcAqHtIqCwkre+gBAPfD4Anh8B35eb55xJF+7kSe7gaR69Kx27TfPWU7lE1MJ3veGR0XDWO97PcAxwLbAIkqf3pu9vZ0Gva/1PuC5zpt428d77HJye4WbS2vvhDGAw8BbwJg3aLvlkMeMmJsLoj4Jfn09Nf1cygse5ix6ksf3Gx/i2Sw6TtsG9P8J942BBP3jimTu484wXYMJI6NQZ3G5u372GZ+9Pa/C7/dDjd3DPH5+G0SdA+zPBcrFhxW6GbPi1wX7LrJA/M6vzv2Es0C0aLIuvouP4TW0G9W2M7MtJVz0PXc73PY85V5/Pc7/MYelS08bl0oSEKC6cGcFOVcVT882+z7MjYU7vrvT5cDWfL06gc2f/dioqxgbf3wAjZgEKtj3Fpu8WMPG5TWRlBfdh5ANdWWXVW4h3W1D/df94MePyXPDqCl87lx1C/9Hg7txXOob7p/WD073BDO9vR917FOiHCWMYu2YVFAUfaCsa/tZ98UEmXRfezmmnK+iaBK4VULUM1Uhpt+EZE6havoDNm4OXW+1s2EqDV5x6QXd6/v1MOHO2b1ntx9045ff/47H3T+bc80xwVwF7k3fz2wsKmXTrMKZcpoiKVpSValL+fhrj/t+ZcPL1gA12v0z+xk/oEO3dbwl4HRYkn8J518yE3r/1vfeeZyqxO8PN760jwtd20s6OfE0ew/ZCQjms7QJ5kfXeI+934IrtXZlLFnf9oBmQDx+fCJ/3juGR+X+ix7hJOBLa4wx3YLktHis8l9XOevsXOSfSde5mMup9XP8wfT0xPYfyxBMBr6MFc0ZNJy9yOqFDBuKMDkN7LNy5c7jh01nBv6E2+Hr8BVx0eUfo0QcioqHoW3bu2E2/s6fAsMf9bT9LxP1OHo4vgzMgF3Q/l9sjv2NrvbkdTrnLRk2F5uFFEFVj9rt3tRvIeyUDGD0hzr9fV/496mpNRoY/kxDgkx8/Yvr3VwCgNOi6eEE/zHsR2sH33qUuf4Kk7Eo6lsNpWZATZd6Ph16eyj1T58B5p0AXb7Za3g98cG8H/pX2H66/OZy+/W3kZlt8nnMSi0KTuW499CyGr/vDru4wd8e5jJ42AuI7mfTxgq945sMTWO15mnfeNZ3SGpS7jMVXXs65l/eFhC4QEgGFX7NkpYtx2aXw+i++51ZDCOPbL2TW2yMYMtzh+z7d+85l/LfqS5qj/3fPMW3cTB58sN4Nl6kG3+VVw4YzYmA6fBCcwVb6WjQxU1dCu4G+z+ueezvQa8RZcMY7ppF323DrfU/Qb9rVTJgWi837XtRuf4mTuq2A0R/7V/pZIp6KXOyXbDczxnrfo1+XPseJBUWgzfbMYzN/HR/J4ovvO3PGGf5VfPFZLU8+7WTZsuDnseKJyzj98e8gP+CMeTjMP/diJl4SY44fan6GskWctSOeH1XjM03XN76mB4tC0+hWYr7Lu+KhOBz0Rhq8lltnDmDgTb+HgXcEPWfez2nQ9ucLR3LG3d1hzCe+14HN9zf6uzi96HQ+utAG5/0U9NthzQHb58Ftd17ch373jIORrwWtN2I7VNVLijq1dABrMtLh4+Dx2o8Mnkn8sGkkjekJTgfa0oSXzmHskG/h7HlB6x1z+wJueHICM2b475+WXMwLV3zKmCvOJKR9tDnraVmcnHsSna9+E7pNDloH0OD39vwdHZivgve9nICrX0Bbb/vf396VrmN/z6xZwc9P3d8wremJwrHcWVkOr60NvqGR/UUAruwAH+QFr1eptVrr4Y20bqA5QaFpwMR6QaERWuuZAW2+Bh6pFxS6S2u9trF1AgwfPlyvWbOmqZuPOhWuCgb9Z1BQfY8Pzl7B5vkj6dXLpLCGhpphNNOmmRTa2Njjr4yMy+Mi7tE4KgMK1SZGJZJ5R2bQ8JbWpLUmrSSNKncV/dv3P2SPcyQoBcNePoU9RXuYMXQGN/T9J7PujuPyy6FvX5Mi7XZDbi4MG0bDs7VAcmEyr6x5hdiwWG445QbfTFT1uS03jy57lH8u/ic2m42nznuKW0+71ZwRawmtvenE3vi2sh/cB93yQGUquEoC0rAVxA+jrLaaj7d8THZ5NtcNuY7u7bo3vLtlXqdt20xtmrp6NWFhsKdkB9d9cR0rM1cC8MzEZ7j99Nub37dvT4XB/zDDVJzecTpzOqGm5aJ3vmqGsNhDIfVDSP8U7BFw+fExR7Xb7R8GYLMFFwMG8zF47jl8WWLt2pllRUVw4UUelud+x3sb3mNkt5HMGDqjZSnwH4bBb3aYVHVtweYHYMuDnJqmWFcTvM3a8IcNTHh3ArmV/sDOi+f8k5ujPRDZzQyRS5sDqd6xbwnjoc/vTGByz7tmVjZ7BGkTt/L2xrfpGt2VaYOm+QodN5tSDYbmNLLooGlthi/l55v3pa52sGXBpEn+IZEHpLEO56+CFTPg3KVmqIEjHD5NMG1bUuT5UNj9NpRsgY5jzIHVrtdh9+uH9XtYUl1C3GNx6IBzszZlo+TuEt8QuCBKBQWFJvSewPxuNlRUHxj2hPm8o2Fu30PyGi9cCA88AG+/bbI6QkJMlk+LPjdNfLCrq833v7ra3GyzmWPP2ogUHvvpUTblbuLGU2/kysFXEuJofl5+aXUpM7+dyTsbzcHdA2c/wD2j72n5tutwaWzYVT/gjiEw6QGI6ALJr1Oz9XW6zcxk4Y8dGDIEysrMS3vXXWbow0MPBdenO9Zorbl93u08v+p537JXz5tN1oIr6NjRvEwREWY7k59vhqNGRprrgZ+fRjX2GickNJg1kJKtZth0SDtTMzP900O6rX7qKfN96t/fX2uvqAhWRPydJ1f5T5T1iOlB8i2bcdYWgrvC+70HUBAzAGz1Nrg/XWVqU540y+xzYGP14+fz27e+5OcVYb4h6x6P+f61Rp3EQyGnPIfRb44mudCckDqp00l8OXkpu7fG4nIF/6yMH1+v3Ma+zJoF998fvMwJPHgjXHe52WdddjnUFtHoUNvqXDNsVIWYE1Rpn0LGwX9O0tLgmWfgxBPNyaHwcDN7ZU4OXHJJ8Am1fXF73CxJWcL6nPVMHTSVpNgk5m6fy+QPJ/vaRDojSf9zevOHjKV/YWa57nSWqVG3680D2n6W1ZTx6a+fYlM2Lh14acv2nTw1ULrdBI58xxWYoeI2s42wLKvlv/WW2wzvdJV412sBNuhwmm+9bUVrB4VGAbO01hO91/8PQGv9SECbV4AlWuvZ3uvbgXH7Gj52rAWF6nz666dszNnIP8b+o9F6Q3UbsjfegCuvND/OYH7YDmpn/ShS7a6my1NdKKou4tTOp7LihhWtVnuprTkUB41tUX4+fPkl7N3r34lwueDPfz7IOkofR8OFGyHKmxddd3bk6oZnmEUrqkiF1I9MDRWnNxLqLqOq70x6vngieZXmTMj7U97nqpOuAuDu7+7m/U3vs/yG5XSLOQKVqw9TUOiQaqzDq/4IIXFw8r9MoWRfDRuCz4C1Yd/s/IaLPrgIZXJPWHjtQsb3Ht94Y6XYmL2BybMn89YlbzG2Yy/4dihcmt1InSAO2WtcUABZWf56aiee2Lz6YHXP4dj6YB+9LMvUY9y+3V9jLSUFPvrIBO4GDDBBBqfz2K1vUe4qZ1XmKsYljTuuTuq11M6CnYx6fRS3j7ydf4xtJP2tKVrDbAdcluvPsv4skcc+mcHW0Id44QXHPmvLHY12FOzAYXP4Js4RB6a0ppQJ70zg1C6n8uKFLwYNqxICWj8o5AB2AOOBTGA1cJXWektAm4uAWzGzj40EntNa73NA27EaFGqOpCRTiFSI/enZ0+wAiqPUjpcg4zNTgN0ZY87mKYVyRskx0RGSV5FHpyc7cfVJV/PelPf2f4fD5XgNCm19Cop+gRGvmOLT+yps3IY9/tPj/G3h33j5opf5w/B9FJOu/xoXb4El58Nvkr0ZABz9r/Ex98E+9pSXw7x5sGOHP3B3xx0mA1a0QZ8lwrhvIfYkM3Tss0Q27ejIlP+u4ucV4URGmhNgLpf5O9aCREKIQ6NVg0LeFV4IPIOZkv4NrfVDSqk/AmitX/ZOSf8CcD5mSvrr69cTqu94DgoJIY4jhetg69NmRkClQdlJmvElqalyRkbs2zEX9G3sYN9TDfNOg84TTWFhZzuoLTbZQ8JHa01ORQ4JkQn7Pltb/zXWFsztA6c+B4nn+Gd9c1ccvdPMS1BIiMMr8xtYMxNOfwM6jTajbMq28e3PJ3LnnXD++dC7tyk18OmnNKhzJYRom1o9KHQoSFBICCHEcUNSREVzNBYpLPwFFk+EPv8PEs8Dqxp2vwujcMGjlgAAB4RJREFUZze6iiNOgkJCHH4lv8L2FyB3sRl32P40GPUGFiEkJ5shoTEx0KePZJQJIQwJCgkhhBCiZSSwJf5/e/cbcmddx3H8/cGlNcU0lmXbSAutVEzFxJL+aZGRzJ4EiwypKBIzlf65hKJnolH5oALRNaGhmFpJUDks6tFmNjVdZoqW3mptEv2hSFt9e3BdssN2H/Hc053fxfV+PbnP+Z37Zj9475xd13fnus9zMbi3wEmSND6zDIX87cCSJMkTfUmSpBEa78cASJIkSZIkjZhDIUmSJEmSpBFyKCRJkiRJkjRCDoUkSZIkSZJGyKGQJEmSJEnSCDkUkiRJkiRJGiGHQpIkSZIkSSPkUEiSJEmSJGmEHApJkiRJkiSNkEMhSZIkSZKkEXIoJEmSJEmSNEIOhSRJkiRJkkbIoZAkSZIkSdIIparm8wcnO4A/LvLQCuDJfbwd7T27DZfthsluw2W7YbLbcNlumOw2XLYbJrsN12LtXl1VL38uPzy3odA0Se6oqpPnvQ/Nxm7DZbthsttw2W6Y7DZcthsmuw2X7YbJbsO1t+28fEySJEmSJGmEHApJkiRJkiSNUItDoavmvQEtid2Gy3bDZLfhst0w2W24bDdMdhsu2w2T3YZrr9o19zuFJEmSJEmS9MJr8Z1CkiRJkiRJeoE1MxRKcmaS+5M8mOSSee9H0yVZneTnSe5Lsi3Jhf36y5JsSvJA//XQee9Ve0qyX5I7k/yov2+3AUhySJIbk/yuf+692XbtS3Jx/zp5b5LrkrzYbm1Ksj7J9iT3TqxNbZVkXX/Mcn+S98xn15rS7Yr+tfI3Sb6f5JCJx+zWiMXaTTz22SSVZMXEmu0aMK1bkgv6NtuSXD6xbrdGTHm9PCHJ5iR3JbkjySkTj9muAUs59561XRNDoST7Ad8E3gscA3wwyTHz3ZWexU7gM1X1BuBU4Py+1yXAbVV1FHBbf1/tuRC4b+K+3YbhSuAnVfV64I10DW3XsCQrgU8DJ1fVccB+wFrs1qoNwJm7rS3aqv83by1wbP8z3+qPZbTvbWDPbpuA46rqeOD3wDqwW4M2sGc7kqwG3g08MrFmu3ZsYLduSd4JnA0cX1XHAl/t1+3Wlg3s+Zy7HPhKVZ0AfKm/b7u2zHTuvZR2TQyFgFOAB6vqoap6Grie7oVFDaqqJ6pqa3/7H3Qnpyvpml3bf9u1wPvns0NNk2QV8D7g6olluzUuycHA24BrAKrq6ar6K7YbgmXAS5IsA5YDj2O3JlXVL4G/7LY8rdXZwPVV9VRVPQw8SHcso31ssW5VdWtV7ezvbgZW9bft1pApzzmArwOfByZ/8antGjGl23nAZVX1VP892/t1uzVkSrsCDu5vv5TuOAVs14wlnHvP3K6VodBK4NGJ+wv9mhqX5AjgRGAL8IqqegK6v7zAYfPbmab4Bt2B1v8m1uzWvtcAO4Dv9Jf+XZ3kQGzXtKp6jO5/Sx8BngD+VlW3YrchmdbK45bh+Cjw4/623RqXZA3wWFXdvdtDtmvb0cBbk2xJ8oskb+rX7da+i4ArkjxKd8yyrl+3XYOe47n3zO1aGQplkTU/Fq1xSQ4CbgIuqqq/z3s/enZJzgK2V9Wv570XzWwZcBLw7ao6EfgnXnLUvP7a7rOBI4FXAQcmOWe+u9LzxOOWAUhyKd3b7jc+s7TIt9mtEUmWA5fSXcKyx8OLrNmuHcuAQ+kubfkccEOSYLchOA+4uKpWAxfTvysd2zVnhnPvmdu1MhRaAFZP3F/FrreuqUFJXkT3l3JjVd3cL/85yeH944cD26f9vObiNGBNkj/QXaJ5epLvYrchWAAWqmpLf/9GuiGR7dr2LuDhqtpRVf8Bbgbegt2GZForj1sal+Rc4CzgQ1X1zMGw3dr2Wroh+t39scoqYGuSV2K71i0AN1fndrp3pK/AbkNwLt3xCcD32HWZke0aMuO598ztWhkK/Qo4KsmRSfan+8VIt8x5T5qin/xfA9xXVV+beOgWuhcW+q8/3Nd703RVta6qVlXVEXTPsZ9V1TnYrXlV9Sfg0SSv65fOAH6L7Vr3CHBqkuX96+YZdNeB2204prW6BVib5IAkRwJHAbfPYX9aRJIzgS8Aa6rqXxMP2a1hVXVPVR1WVUf0xyoLwEn9v4G2a9sPgNMBkhwN7A88id2G4HHg7f3t04EH+tu2a8QSzr1nbrfs+d3y0lTVziSfAn5K9+ks66tq25y3pelOAz4M3JPkrn7ti8BldG8X/RjdydAH5rQ/zcZuw3ABsLEfnD8EfIRusG+7RlXVliQ3AlvpLmG5E7gKOAi7NSfJdcA7gBVJFoAvM+X1saq2JbmBbji7Ezi/qv47l42P3JRu64ADgE3dsTSbq+qTdmvLYu2q6prFvtd27ZjynFsPrE/3UedPA+f279CzW0OmtPs4cGX/gRj/Bj4BPucaM9O591LaZdc7aiVJkiRJkjQWrVw+JkmSJEmSpH3IoZAkSZIkSdIIORSSJEmSJEkaIYdCkiRJkiRJI+RQSJIkSZIkaYQcCkmSJEmSJI2QQyFJkiRJkqQRcigkSZIkSZI0Qv8HocfSaFfRNx4AAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index 13\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIcAAACMCAYAAADm+clLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3de3Tc9Xnn8c8zd11GtixphC8YGSQTnAQIcU0AY8iSCyRtSdJuF9LmdNO0lG04Z3t2t2myOdvtyV6attvsbpq0lLZpm2wDTRpIaEsSkpOLYxMSbK4GgyXbMviCRpKNNZI8I83Md/+Y38hCluyRLc3vNzPv1zk+9vzmN5pH9s/f0TzzPM/XnHMCAAAAAABAYwr5HQAAAAAAAAD8Q3IIAAAAAACggZEcAgAAAAAAaGAkhwAAAAAAABoYySEAAAAAAIAGRnIIAAAAAACggUX8DmA+nZ2drqenx+8wAAAAAAAA6sbu3btHnHNdc4+fMzlkZl+Q9LOS0s65N81zv0n6v5LeI2lS0r91zj3p3Xerd19Y0l855z5dSbA9PT3atWtXJacCAAAAAACgAmZ2aL7jlbSV/a2kW89y/22S+rxfd0n6c+8Jw5I+792/SdKdZrap8pABAAAAAACw3M6ZHHLObZd0/Cyn3C7pi67kcUkrzWy1pC2SBpxzB5xzU5Ie8M4FAAAAAABAQCzFzKG1kl6Zdfuwd2y+49cuwfMtu58ePK7PfX9Azjm/Q6k5ZqZ3XpHSHVvWKxpm3jkAAAAALLVi0emfnj2qh546okKR961B0hQN69pLO7Str1O9qVaVJvEE31Ikh+b7Tt1Zjs//RczuUqktTevXr1+CsM7fN/cc086BEV21boWvcdSiTDav//KN5/U3jw3qE7ddoXdckaqZ/wwAAAAAEHSPHxjV/3xkr549fFI9Hc1a1RLzOyTM8vLxST36wpAk6aK2hG7s69SNG7t0yxtSaokHck8wSUuTHDos6eJZt9dJOioptsDxeTnn7pN0nyRt3rzZ19RnJptXKhnXg791g59h1CTnnL67N60/+OZe/cYXd+naDav0yfdeoSvXrfQ7NAAAAACoWfuHx/UHj7yo7+4d0uoVCX3ml67S+65eq1CID+OD5pXjk9oxMKId/SN69IUhfXX3YX3gmrX6zC9d7XdoC1qK5NDDku4xswdUahs76Zw7ZmbDkvrMbIOkI5LukPTBJXi+ZTeezSuZCG5GL8jMTO/c1K2bL+/SAz99Wf/7u/36+c/t1C1vSM2b0X7vlat18+UpHyIFAAAAgNrwmUdf0ud/sF9N0bB+592X6yNbNygRDfsdFhZw8apm3bllve7csl6FotMH/mynhsayfod1VpVsZX+/pJsldZrZYUn/VVJUkpxz90p6RKVt7AdU2sr+w959eTO7R9K3VdrK/gvOueeX4XtYcpnctJKJqN9h1LRoOKQPXdej29+yVvf+YL8efuaoinN6YUcnpjQ4OkFyCAAAAAAWMJ7L67PfG9A7rkjp079wpTpb436HhEUIh0ztLTEdn5jyO5SzOmdyyDl35znud5I+usB9j6iUPKopmWxe7c30bS6FtkRUH7v1DfrYrW84476P/eMz+t6Lwz5EBQAAAAC1YXBkQpL0gWvWkRiqUclEVIdGJ/0O46zYTmoeGdrKqqKns0Uj4zllstN+hwIAAAAAgTQ4WkoO9XS0+BwJzlcyEQn8+16SQ/PIZGkrq4YN3uIW9AwqAAAAAPilXDnU09nscyQ4X8lERGPZvN9hnBXJoXmMZfNqo3Jo2fV0lpJDB73FDgAAAADwegdHJtXdFldzjPeotaotEdVUvqjsdMHvUBZEcmiOXL6gqXyRtrIqKJdFDpIcAgAAAIB5DY5O0FJW48r5hUyAq4eCmQEZ6Zf+5r2+PHWoUNQDsRPqea5FOpTwJYZG0STpwaYTatsdlV5u9TscAAAAAAicTwwd16qWmPQ3vGeqVbeN57QxNq7W+/9Uiob9DmdeVA7NUfC2Ww+HzOdIGkMiGgp0aR0AAAAA+CVfLCpfdEoENKGAykS8/EI53xBEwawc6uyTPvwvvjx1/+GTuuNzO/SXt2zWOzd1+xJDI/nSg8/q288P6ckPv9PvUAAAAAAgUF44/Jru+NxO3fuOt2rNmy7yOxycp/6Dx3XHX/xY/++Wa7W1r9PfYH5t/kIYKofmKG8vx8yh6ujpaNHxiSmdPBXsbf0AAAAAoNrKm/ds6GTmUC07PXMouO97SQ7NUd5erjVOcqgayjuWMZQaAAAAAF5vcGRSknRJB9vY17JaGEhNcmiOciavLRH1OZLGUM6AD46SHAIAAACA2QZHJ7RmRYKZQzUu6eUXxqgcqh3lTB5tZdWxflWzzE6XSwIAAAAASg6OTMx0W6B2lTuTqByqIeV/rFaSQ1WRiIa1ZkUTbWUAAAAAMMfgKMmhehAOmVrjESqHakkmO62maFjRMH811dLT2ayDo5N+hwEAAAAAgfHa5JRem5zWhg6SQ/UgmYhQOVRLMtk8LWVV1tPRQuUQAAAAgHMqFp0KRed3GFVRHr1B5VB9KCWHqByqGeM5kkPVtqGzRSdPTevExJTfoQAAAAAIsE9+fY8++JeP+x1GVZQ37dnQyU5l9aAtEa39yiEzu9XMXjKzATP7+Dz3/46ZPe392mNmBTNb5d03aGbPefftWupvYKmNZadnJomjOnq8MsmD7FgGAAAAYAHFotO39hzTTw4e18h4zu9wlt3BkUmFTLp4FcmhelDzbWVmFpb0eUm3Sdok6U4z2zT7HOfcHzvnrnbOXS3pE5J+6Jw7PuuUt3v3b17C2JcFbWXVVy6TpLUMAAAAwEJeODamE5OltpydAyM+R7P8BkcmtGZlk+IRtrGvB8lEtObbyrZIGnDOHXDOTUl6QNLtZzn/Tkn3L0Vwfshkp0kOVdn6Vc0KGckhAAAAAAv7UX8pIdQcCzdGcmh0QhuYN1Q3ar5ySNJaSa/Mun3YO3YGM2uWdKukr8067CQ9ama7zeyu8w20WjLZvJJx2sqqKRYJaW17EzuWAQAAAFjQjoFhXd6d1E0bu7Sjf0TO1e9gauecDo5MzIzgQO1LejOHgnrdVpIcsnmOLfTd/JyknXNaym5wzl2jUlvaR81s27xPYnaXme0ys13Dw8MVhLU8aCvzBzuWAQAAAFhIdrqgJwZPaGtfp7b2deroyezMbl716PjElDLZPDuV1ZFkIqKpQlG5fNHvUOZVSXLosKSLZ91eJ+noAufeoTktZc65o97vaUkPqdSmdgbn3H3Ouc3Ouc1dXV0VhLX0pgtFnZouMJDaB+XkUFCzqAAAAAD888TgcU3li9ra26mtvZ2SpB113FrGTmX1p80rQhkL6NyhSpJDT0jqM7MNZhZTKQH08NyTzGyFpJskfWPWsRYzS5b/LOldkvYsReDLYdzr/6NyqPp6OluUyeV1nO3sAQAAAMyxY2BE0bDp2ktX6ZKOFl28qmlmBlE9Ghwpjdygrax+lItQgjp36JzJIedcXtI9kr4taa+krzjnnjezu83s7lmnvl/So8652bV93ZJ2mNkzkn4q6V+cc99auvCX1niO5JBfyhnxQbazBwAAADDHjv4RXbO+Xc2x0nu1rb1denz/qPKFYLboXKjB0QmFTFrXTuVQvSjnGYKaHKooC+Kce0TSI3OO3Tvn9t9K+ts5xw5IuuqCIqyicnkXbWXVV86IHxyZ1FsvWeVzNAAAAACCYnQ8p+ePjuk/vnPjzLGtvZ26/6cv65nDJ/XWS9p9jG55HByZ0Lr2ZsUilTT7oBa0NZUrh2q3raxhZGgr883Fq5oVDhlDqQEAAAC8zmP7RyVJW/s6Z45df1mHzEoVRfVocHSCYdR1JuiVQySHZiE55J9oOKR17U06SFsZAAAAgFl29I8omYjozWtXzBxrb4npTWtWaGcdDqV2zmlwZFIbOmgpqyenZw5RORR4GdrKfMV29gAAAABmc85px8CIrr+sQ5Hw69++bu3r1JMvn5iZHVsvRsanNJ5jG/t6Q+VQDaFyyF8bOtnOHgAAAMBpg6OTOvLaKW3t6zrjvht7O5UvOv3kwKgPkS2f8iY9JIfqS2ssIjNpjORQ8J2uHCI55IeejmZNTBU0PJ7zOxQAAAAAAbCjf1hSaQD1XNdc0q54JKQdddZadtDrptjANvZ1JRQytcYiGjtFW1ngZbJ5xSIhxSNhv0NpSOXM+ODIpM+RAAAAAAiCHQMjWruyST3zzN9JRMPasmFV3Q2lHhyZUCRkWtfe5HcoWGLJRIS2slqQyeXVRtWQbzbMJIeYOwQAAAA0unyhqMf2j+rGvk6Z2bzn3NjXqf70uIbGslWObvkMjk7o4lXNZ8xYQu1LJqIMpK4FmWyeYdQ+WruySZGQsWMZAAAAAD135KQy2bxumKelrKx8Xz1VDx0cmZy3Ugq1j8qhGpHJTqs1TuWQXyLhkNavaqZyCAAAAIB29I/ITGdNDl1xUZs6WmJ1M3fIOadDoxMMo65TbU1RZXJUDgVeqXKI5JCfejpbZgawAQAAAGhcPxoY0RvXtGlVS2zBc0Ih0/W9ndoxMFIXux6nMzlNThVmRm6gvlA5VCMy2WmSQz7r6WjRodHJuljYAQAAAJyfiVxeT7184qxVQ2U39nZqOJPTvqHxKkS2vMoflPewU1ldIjlUI5g55L8Nnc06NV3Q0Bjb2QMAAACN6smXT2i64Obdwn6urX2lc37kbXtfy8ojNqgcqk/lgdRBLIYgOTQLbWX+K/fW0loGAAAANK6XXs1Ikt60ZsU5z12zskkbOlv02P7R5Q5r2R0cnVAsHNKalWxjX4+SiYimC07Z6aLfoZyB5JCnUHQaz1E55Ld17aWp/MdOnvI5EgAAAAB+6R8aV2drTO1nmTc02/WXdegnB0Y1XQjem+7FOPpaVqtXJhQOmd+hYBmU8w1B3M6e5JBnYqrU99dG5ZCvUsm4JNFWBgAAADSw/nRGvanWis+/obdTE1MFPXv4tWWMavkNjWXV3ZbwOwwsk3K+YSyAc4cqSg6Z2a1m9pKZDZjZx+e5/2YzO2lmT3u/fq/SxwZFeSgUbWX+aolH1BqPKJ3J+h0KAAAAAB8459Q/NK6+VLLix1x3aYfMpJ0Dtd1aliY5VNfK+YaarBwys7Ckz0u6TdImSXea2aZ5Tv2Rc+5q79enFvlY35X/cVrjtJX5LZWMK52hcggAAABoRENjOWVyeW3srrxyqL0lpk2r27RzYGQZI1tezjkNjeXU7XVToP6cbiurzcqhLZIGnHMHnHNTkh6QdHuFX/9CHltVVA4FR1cyrmHaygAAAICG1J8uDaPuXUTlkFRqLXvq5dd0aqqwHGEtu0wur1PTBSqH6lhbjSeH1kp6Zdbtw96xua4zs2fM7Jtm9sZFPtZ35cohkkP+S7UlNERbGQAAANCQ+ofGJUl9i6gckkpDqacKRT0xeHw5wlp26bHSe6BUG5VD9aqm28okzTcm3c25/aSkS5xzV0n6U0lfX8RjSyea3WVmu8xs1/DwcAVhLa3TlUO0lfmtOxlXeiwn5+a9VAAAAADUsf50Ru3NUXVUuFNZ2ZYNqxQNm3bur83WsvKmPFQO1a/TyaHarBw6LOniWbfXSTo6+wTn3Jhzbtz78yOSombWWcljZ32N+5xzm51zm7u6uhbxLSyN8rRwdivzX6otrlPTBY3ngvcfBgAAAMDy6h8aV193UmaL2869ORbRWy5u12M1OpR6yKscIjlUv1piEZnVbuXQE5L6zGyDmcUk3SHp4dknmNlF5v3PNbMt3tcdreSxQXG6rYzKIb+lkqXFkKHUAAAAQGNxzqk/Pa6+RWxjP9v1vR3ac/SkXpucWuLIll+5cijFQOq6FQqZWuOR2tzK3jmXl3SPpG9L2ivpK865583sbjO72zvtFyXtMbNnJH1W0h2uZN7HLsc3cqHGs3lFQqZEtJJ8GZZTeTEsZ84BAAAANIbh8ZxOnpo+7+TQDb2dck56/EDtVQ8NjWWVjEfUEqebpZ61JaIaC2DlUEVXndcq9sicY/fO+vPnJH2u0scGUSabVzIRWXTpIpZeeQDbMJVDAAAAQEM5PYx6cTuVlV21bqWaY2HtHBjVrW9avZShLbt0JqvuFbSU1btkIlKzM4caQiY7rVbmDQVCyuuxTbOdPQAAANBQ+odK29gvdqeyslgkpC0bVtXkUOqhsZy62ams7pWSQ8GrHCI55Mlk80rGmTcUBMl4RIloSGm2swcAAAAaSn96XCuaoupqPf8kyQ2XderA8IRePVlb7ydePZlVd5LKoXqXTESpHAqyclsZ/GdmSiUTMwPZAAAAADSG8jDqCxn3cX1vhyRp50DtVA8555TOZGe6KFC/2mgrC7ax7DQ7lQVIKhmncggAAABoIM459Q9lznveUNkVF7VpVUusplrLTkxOa7rgaCtrAKXKIdrKAiuTzauNyqHA6G5LsJU9AAAA0EBGJ6Z0YvL8dyorC4VM113aoccGRuWcW6Lolld5p+ZuKofqXnkgddCuTZJDnkx2mrayAOlKxjVMWxkAAADQME7vVHZhySGp1Fr26lhWB0YmLvhrVcPp5BCVQ/UumYgqX3Q6NV3wO5TXITmkUvnieC5PW1mApNriyuTympwKXi8mAAAAgKXXn/Z2KktdWFuZVBpKLUmP1cjcofJOzSkGUte9clFK0OYOkRySNDlVUNGJyqEAKS+KbGcPAAAANIb+oXElE5ElqZ65pKNZa1c2aefA6BJEtvzKlUMpKofq3unkULDmDpEN0emMXSvJocAovyCkMzn1dLb4HA0AAACA5dafzlzwTmVlZqbrL+vQPz17VP/mL358xv2/8rZL9HNXrbng51kqQ5ms2pujikfCfoeCZdbmdSyNUTkUPOWMHW1lwTFTOcSOZQAAAEBDGEiPL0lLWdkHr12va9a3n3H8xVcz+vJPXl6y51kKQ2M5hlE3iKC2lVEqo9MZO9rKgiOVLFUODdFWBgAAANS94xNTGhmfWpJh1GVvWd+uL//G2844/jtffUY/2De8ZM+zFNJjWaVIDjWEclFK0NrKqBzS6X8UtrIPjpXNUcXCISqHAAAAgAbQP+QNo+5eusqhhfSmWjWcyenkZHDenA+N5dSdZN5QI2hrCmblEMkhnf5Hoa0sOMyM7ewBAACABtGf9raxTy1d5dBCytVJA8OZZX+uShSKTsPjtJU1CiqHAixDW1kgpdriSmdIDgEAAAD1biA9rpZYWKtXLH+CpLerVJ3UPzS+7M9VidGJnApFtyS7tCH4WmJhhYzKoUAazzGQOohSyfjMlo4AAAAA6te+oYx6u5NLslPZuaxtb1IiGpqpVvJb2uuWYOZQYzAztcYjGjtF5VDgZLJ5mZUyeAiOVDJB5RAAAADQAPrT49pYhZYySQqHTJd1tWogIMmhV0+WPhC/iORQw0gmorVZOWRmt5rZS2Y2YGYfn+f+XzazZ71fj5nZVbPuGzSz58zsaTPbtZTBL5VMNq/WeKQqWWpULpWM6+SpaWWnC36HAgAAAGCZvDY5peFMbkl3KjuX3lRwkkND3iY8zBxqHMlEZGbX9KA4Z3LIzMKSPi/pNkmbJN1pZpvmnHZQ0k3OuSsl/TdJ9825/+3Ouaudc5uXIOYlN5adVhstZYFTXhyHqR4CAAAA6tbpYdTLv1NZWV+qVUdeO6WJnP9v0IfGcjKTOltjfoeCKmlLRGtyIPUWSQPOuQPOuSlJD0i6ffYJzrnHnHMnvJuPS1q3tGEur0w2zzDqAOryBrLRWgYAAADUr/Jg6N4qtZXNfq79w/5XD6XHsupsjSsSZupLo0gmIjXZVrZW0iuzbh/2ji3kI5K+Oeu2k/Some02s7sWepCZ3WVmu8xs1/DwcAVhLZ1MdprkUAClkl5yiKHUAAAAQN3qT2fUHAtr7cqmqj1nbyo4O5YNjWXZqazBJBMRZXLBqhyqJCMy3yAeN++JZm9XKTm0ddbhG5xzR80sJek7Zvaic277GV/QufvktaNt3rx53q+/XDLZPP2dAZRKlv5NqBwCAAAA6tdAely9qVaFQtWbAXtJR7OiYdNAACqHhsZyWr2C96ONpK2pNgdSH5Z08azb6yQdnXuSmV0p6a8k3e6cGy0fd84d9X5PS3pIpTa1QKGtLJg6WmIKh0zpDJVDAAAAQD0qFp32Hhur6rwhSYqGQ+rpaAlE5VA6k2Ub+wZTbitzrqp1MWdVSXLoCUl9ZrbBzGKS7pD08OwTzGy9pAclfcg5t2/W8RYzS5b/LOldkvYsVfBLZTxHciiIQiFTV2tc6TEqhwAAAIB6tPfVMY2MT+m6yzqq/tx93a2+zxyaLhQ1Mj5FW1mDSSaiKhSdJqeCszP3OTMizrm8md0j6duSwpK+4Jx73szu9u6/V9LvSeqQ9GfedvB5b2eybkkPeccikr7snPvWsnwn58k5580cYreyIEq1xTVEWxkAAABQl7bvG5EkbevrrPpz93a16lt7XlV2uqBENFz155dO78zMmJPGUi5OyWTzaokHo1Cloiicc49IemTOsXtn/fnXJf36PI87IOmqC4xxWeXyRU0XnFoD8g+C10sl4zp84pTfYQAAAABYBtv3DeuK1W2+tFX1didVdNLBkQldsbqt6s8vlYZRS6JyqMGUi1My2WldFJB5Uw2/V95YtjQhvI22skBKtSVmsukAAAAA6sdELq9dh45r28bqVw1JUp+3nf1A2r/WsiFvhEZ5Mx40hnLl0FiAhlI3fHKoPCGctrJgSiXjGp2Y0nSh6HcoAAAAAJbQj/eParrgdFNfly/Pv6GzRSGT+n1MDpU336GtrLG0zbSVBWc7e5JDM8khKoeCqJxBp3oIAAAAqC8/3Des5lhYb+1p9+X5E9Gw1q9q1n5fK4eyCodMHS0x32JA9Z1uK6NyKDDKmToqh4IplSz13qZJDgEAAAB1ZXv/sK67tEPxiD/DoCWpN9Wq/nTGt+d/9WROqWRcoZD5FgOqb/ZA6qAgOUTlUKClvMFsaW9QGwAAAIDaNzgyoUOjk7rpcn9aysp6U0kdHJlQ3qcxFulM1pdh3PBX26yB1EHR8MmhcZJDgVbuvaVyCAAAAKgf2/uHJUnbfJo3VNaXatV0wenQ8Ulfnn9oLKvuJDuVNZrmWFjhkFE5FCRjtJUFWkdLTGZUDgEAAAD1ZPu+Ya1f1ayezhZf4+j1dizrH/Jn7tDQWC4wW5mjesxMrfHITD4iCBo+OVTO1LXGqRwKokg4pI6WOJVDAAAAQJ2Yyhf12P5R3bTR36ohSbrMSw7tH65+cig7XdDJU9PsVNagkokIlUNBksnm1eKVdCGYUkmSQwAAAEC92HXouCanCtoWgORQazyitSub1D9U/aHU6bHSe5wUbWUNKZmIMnMoSDLZaVrKAq67La50hrYyAAAAoB78cN+wIiHTdZd1+B2KpFL1UL8P29kPee9xqBxqTMlERGNUDgVHJptnGHXApZIJDY1ROQQAAADUg+37RrS5pz0woz36Uq3aPzyuYtFV9XmHxkgONbI22sqCJZObJjkUcKm2uEbHcypUebEGAAAAsLTSY1ntPTYWiJayst5Uq7LTRR157VRVn7f8AXh3G21ljYi2soApVQ7RVhZkqWRcRSeNjlM9BAAAANSy7f0jkhSIYdRlfd5Q6oEqt5alx7KKRUJa0cT70UbEQOqAGaetLPBSXpklQ6kBAACA2rZ937A6W+O64qI2v0OZMbOdfbq6Q6mHxrLqbovLjM2RGlGbVznkXDA6ZBo+OTRG5VDglaf3l3tyAQAAANSeQtHpR/3D2tbXqVCAdote2RxTZ2tc/UPVrRwaGsupO8m8oUaVTERUdNLEVMHvUCRVmBwys1vN7CUzGzCzj89zv5nZZ737nzWzayp9rN8y2Wm1UTkUaFQOAQAAALVvz5GTOjE5rZsuD05LWVlfqlUDw1VODmWyDKNuYOUilaDMHTpncsjMwpI+L+k2SZsk3Wlmm+acdpukPu/XXZL+fBGP9c1UvqhcvhiYKfmYX1drqXIozY5lAAAAQE0pFp12HzquT/3TC/rNL+1WyKStvZ1+h3WG3lSrBobGq9riM3QyqxTDqBtWebxNUOYOVZIV2SJpwDl3QJLM7AFJt0t6YdY5t0v6oiv9T3rczFaa2WpJPRU89gyTU3ntGjy+2O9lRihk6miJqSsZV3Ns/m/x1FRB+73MMDOHgi0WCam9Oap0pvbbypxz2nsso8mpYCwAaGzhkKmzNa6uZFyJaPiCv152uqDhTE4j7C5Y8y7ralV7S8zvMFCjnHN68dWMJnK81qFyl3a1ahXrzpJIj2X18vFJv8PQqemCvv/isL6555iOncwqFg5p28Yu/crb3qyO1uAlRPq6W5XJ5fW9F9PLMiC6KRZWVzKujpa4wiHTeC6viakClUMNrJyHeGLwuMZO+V89VElWZK2kV2bdPizp2grOWVvhY8+wf3hCv3jvjysI7dxavP+EXcm4TKbh8ZyGMzmNz/qBpYs+z8DrbkvMbPUoSRO5vL7/UlrfezGtzta4tvZ2asuGVUvyBrdSxaLTc0dOavu+Yb00lNHVF6/UTRu71JtqPWOo3CvHJ/Xgk0f04FOHdWjU/xdrYK5kIlJaK1vjao5V/v9ocqows64G5VMPXLhIyHTz5Sl94Jq1+ldvSFV1bUXtOjQ6oYeeOqKvP3VEg7zWYZFK606X3v+WdbrlCtadxXLO6cf7R/XFHx/Sd/YOBeZDmnJC6GO3Xq5bruhWW4BnvW5aXRqQ/ZG/27WszxMyaVVLXCuaSm/F2ca+caW8PMQnH9rjcyQllSSH5psUNne1WeicSh5b+gJmd6nUkqaL1vXoSx/ZUkFo88sXnEbGcxoez2kkM6Xh8ZzS3jDjN65pm0kWdbXGtXpFk9526arzfi5UR1cyrsMnJvXgk4f1zT2vavu+YeXyRbU3RzWey+u+7QcUi4T0Mz3t2trbpS0b2pWIhhUyk5kUMlPIpFg4rOZ4WC2xiBLRUEU7AxSLTqemC5qYyiuTzevJQye0vX9EO/qHdWKylOG9qC2hf372mP77v+zV6hUJbevr0raNXZqYyutruw/rJwdLlXDXXdqhj97cq9UrSUjCf1P5YmmtzIWmM0sAAAl9SURBVOQ0Mj6l4UxO6UxWoxNTFX+NRCSsKy5q07a+0+tqR2tMsUjD73dQs/JFp8cGRvSNp4/qu3uH1JaI6L1XrtZ737xGK5ujpfU0dHpdjYZDao5F1BIPqykaZseVgHPOaapQ1GSu9LqWLzg1x8JqjkfUHA2fMSB2eta5p6YLKhadik4qOqeic3JOevqV1/TQU0e0+9AJmUlv29Chu2+6TGvbm3z6LlFrCkWnx/aP6utPHdF396aVTET03jev1s9eWVp35oqETa3xiJLxqFriYUXCjfuak8lO68Enj+hLjx/SQHpcK5uj+vWtG3R9b6f8nvccMtOb160IdEJotrde0q6v/bvrl6XC37nSh9ul96e5mQ/WutsS+pke3os2qitWJ/XQb13/usKVatj2h/Mft3P1VJrZdZJ+3zn3bu/2JyTJOfcHs875C0k/cM7d791+SdLNKrWVnfWx89m8ebPbtWt5M7aoLf/pq8/oH3cfliStXpHQu994kW5700Xa3LNKuXxBPzl4XDv6R7Sjf0QvDVW2BaWZ1BKLqCkWVnieNzP5YlGTUwVNzjM9vrM1rm0bO7Wtr0tb+zrV2VpKXm3fN6Lt+4a1c//ITBXFhs4W/cI1a/W+t6zVuvbmC/hbAIDqKRSddg6M6KGnjuhbe17Vqelz76RhJjVHw2qKRRTx+10JXsfJ6ZT3mpY/S0VBIhpSSyyignOazBU0VShW9PX7Uq16/zVr9b6r12rNSpJCOD+lJNGIHnryiL71/Kvz/gw2n0Q0pNZ4tCHXnddOTSk7XdSV61boQ2+7RD931RqqrgCclZntds5tPuN4BcmhiKR9km6RdETSE5I+6Jx7ftY575V0j6T3qNQ29lnn3JZKHjsfkkOYa8+Rk3r0hSG9/fIuXbVu5Vm3vkyPZfXckZPKF0ufaDpX+pSz4Jym80VNTpX6eye9Pt/JqbyK8/zsGwqZWuPhmU/Ey79v7E5q0+q2s346ni8U9czhkwqHTFetW8En6QBq2kQurycGj2sqX1Rx1rpadE5T+aImp2etqd7vxYC0NOC0plj49OuZVy0UCZlOTRdmqoMmpwqayOUVCZma49553utfIhpWOGQzVWNmJpO0tr3pnK+LwGJNTuX104PHNV04cy2ZLhQ1nstrPJsv/Z4rVXc34rrTHA/rfVev1VUXr/Q7FAA14ryTQ96D3yPp/0gKS/qCc+5/mNndkuScu9dKPw18TtKtkiYlfdg5t2uhx57r+UgOAQAAAAAALK0LSg5VG8khAAAAAACApbVQcqhxp7cBAAAAAACA5BAAAAAAAEAjC2RbmZllJL3kdxyoGZ2SRvwOAjWD6wWLwfWCxeB6wWJxzWAxuF6wGFwvWMglzrmuuQcjfkRSgZfm64ED5mNmu7heUCmuFywG1wsWg+sFi8U1g8XgesFicL1gsWgrAwAAAAAAaGAkhwAAAAAAABpYUJND9/kdAGoK1wsWg+sFi8H1gsXgesFicc1gMbhesBhcL1iUQA6kBgAAAAAAQHUEtXIIAAAAAAAAVRCo5JCZ3WpmL5nZgJl93O94ECxmdrGZfd/M9prZ82b2773jv29mR8zsae/Xe/yOFcFgZoNm9px3Xezyjq0ys++YWb/3e7vfcSIYzOzyWevI02Y2Zma/zRqDMjP7gpmlzWzPrGMLrilm9gnvZ5qXzOzd/kQNvyxwvfyxmb1oZs+a2UNmttI73mNmp2atM/f6Fzn8sMD1suDrD+sLFrhm/mHW9TJoZk97x1ljcE6BaSszs7CkfZLeKemwpCck3emce8HXwBAYZrZa0mrn3JNmlpS0W9L7JP2SpHHn3P/yNUAEjpkNStrsnBuZdeyPJB13zn3aS0K3O+d+168YEUzea9IRSddK+rBYYyDJzLZJGpf0Refcm7xj864pZrZJ0v2StkhaI+m7kjY65wo+hY8qW+B6eZek7znn8mb2h5LkXS89kv65fB4azwLXy+9rntcf1hdI818zc+7/E0knnXOfYo1BJYJUObRF0oBz7oBzbkrSA5Ju9zkmBIhz7phz7knvzxlJeyWt9Tcq1KDbJf2d9+e/UynBCMx1i6T9zrlDfgeC4HDObZd0fM7hhdaU2yU94JzLOecOShpQ6WcdNIj5rhfn3KPOubx383FJ66oeGAJpgfVlIawvOOs1Y2am0gfo91c1KNS0ICWH1kp6Zdbtw+KNPxbgZb/fIukn3qF7vBLtL9AmhFmcpEfNbLeZ3eUd63bOHZNKCUdJKd+iQ5Ddodf/QMUag4UstKbwcw3O5dckfXPW7Q1m9pSZ/dDMbvQrKATOfK8/rC84lxslDTnn+mcdY43BWQUpOWTzHAtGzxsCxcxaJX1N0m8758Yk/bmkyyRdLemYpD/xMTwEyw3OuWsk3Sbpo175LXBWZhaT9POSvuodYo3B+eDnGizIzD4pKS/p771DxyStd869RdJ/kPRlM2vzKz4ExkKvP6wvOJc79foPuVhjcE5BSg4dlnTxrNvrJB31KRYElJlFVUoM/b1z7kFJcs4NOecKzrmipL8UZbXwOOeOer+nJT2k0rUx5M2vKs+xSvsXIQLqNklPOueGJNYYnNNCawo/12BeZvarkn5W0i87b/in1x406v15t6T9kjb6FyWC4CyvP6wvWJCZRSR9QNI/lI+xxqASQUoOPSGpz8w2eJ/a3iHpYZ9jQoB4vbN/LWmvc+4zs46vnnXa+yXtmftYNB4za/EGl8vMWiS9S6Vr42FJv+qd9quSvuFPhAiw133axhqDc1hoTXlY0h1mFjezDZL6JP3Uh/gQIGZ2q6TflfTzzrnJWce7vEH4MrNLVbpeDvgTJYLiLK8/rC84m3dIetE5d7h8gDUGlYj4HUCZt2vDPZK+LSks6QvOued9DgvBcoOkD0l6rrwto6T/LOlOM7tapXLaQUm/6U94CJhuSQ+VcoqKSPqyc+5bZvaEpK+Y2UckvSzpX/sYIwLGzJpV2jVz9jryR6wxkCQzu1/SzZI6zeywpP8q6dOaZ01xzj1vZl+R9IJK7UMfZSehxrLA9fIJSXFJ3/Fenx53zt0taZukT5lZXlJB0t3OuUqHE6MOLHC93Dzf6w/rC6T5rxnn3F/rzLmJEmsMKhCYrewBAAAAAABQfUFqKwMAAAAAAECVkRwCAAAAAABoYCSHAAAAAAAAGhjJIQAAAAAAgAZGcggAAAAAAKCBkRwCAAAAAABoYCSHAAAAAAAAGhjJIQAAAAAAgAb2/wGmGGIVaDHJtAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABI0AAACOCAYAAAC8E/iJAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3wcxf3/8dfcnXpvtlwkyw1caAFjigkYCJ1AAiSQkECICYEvEPIDQkJIMCaNkNAJEHoLHUIxJVRjqsEG995t2VaX1aUr8/tjTjqddMKyLCwZv5+Phx66m93bndu93dv93MxnjLUWERERERERERGR9jx9XQEREREREREREel/FDQSEREREREREZFOFDQSEREREREREZFOFDQSEREREREREZFOFDQSEREREREREZFOFDQSEREREREREZFOeiVoZIx50BhTaoxZ2MX0ycaYrcaYueG/a3tjvSIiIiIiIiIi8vXw9dJyHgbuBB79ink+sNae3EvrExERERERERGRr1GvBI2stTONMUW9saz2cnNzbVFRry9WRERERERERGS3NWfOnHJrbd625uutlkbdcYgxZh6wCbjSWrtoWy8oKipi9uzZX3/NRERERERERER2E8aYdd2Zb2cFjb4Ahllr64wxJwIvAqNjzWiMuQC4AKCwsHAnVU9ERERERERERNrbKaOnWWtrrLV14cevAXHGmNwu5r3XWjvBWjshL2+bLaVERERERERERORrsFOCRsaYfGOMCT+eGF5vxc5Yt4iIiIiIiIiIbL9e6Z5mjHkSmAzkGmM2AlOBOABr7T3AGcBFxpgA0AicZa21vbFuERERERERERHpfb01etqPtjH9TuDO3liXiIiIiIiIiIh8/XZK9zQREREREREREdm1KGgkIiIiIiIiIiKdKGgkIiIiIiIiIiKdKGgkIiIiIiIiIiKdKGgkIiIiIiIiIiKdKGgkIiIiIiIiIiKdKGgkIiIiIiIiIiKdKGgkIiIiIiIiIn0jPx+Mif7Lz+/rWkmYgkYiIiIiIiIi0jdKSrouCzbBZxfCxpd2bp2kjYJGIiIiIiIiItL/LLkZVj8EH/8Emiv7uja7JQWNRERERERERKT/WX4bhFrAhmD9s31dm92SgkYiIiIiIiIi0r80bISWGvc42ACbXu/b+uymFDQSERERERERkf6l9APwxEWel33Qd3XZjSloJCIiIiIiIiL9y+Y3IVAbeR5s7Lu67MYUNBIRERERERGR/qXi0+jn7VsdyU6joJGIiIiIiIiI9C8Nm6KfB5v6ph67OQWNRERERERERKT/iAOC9dFloZY+qcruTkEjEREREREREek/cgFvcl/XQuiloJEx5kFjTKkxZmEX040x5nZjzEpjzHxjzP69sV4RERERERER+YbJBYwHvIlw9Hsw/Gd9XaPdVm+1NHoYOP4rpp8AjA7/XQDc3UvrFREREREREZH+aPZl8Ope0Fiyfa/LAmwARpwHuYfChDuUCLuP9ErQyFo7E6j8illOBR61zqdApjFmUG+sW0RERERERET6mdKZsOp+qFkOsy/per6BAzuXDUl1ia8LTgdvPNggZE/4+uoqXdpZOY2GABvaPd8YLuvEGHOBMWa2MWZ2WVnZTqmciIiIiIiIiPSi1Q9DsBGsH4qndz3fli1gbeS5tfDrs8GGIPcgV+ZNhAFHfK3Vldh2VtDIxCizMcqw1t5rrZ1grZ2Ql5f3NVdLRERERERERHqVtVD8Cm23/d747Xt9/VpIGxmJGngTIP87vVhB6a6dFTTaCBS0ez4U2LST1i0iIiIiIiIiO0vNEgg0Rp4H6rbv9U0lkDrC5TVqlTq8d+om22VnBY1eBs4Jj6J2MLDVWrt5J61bRERERERERHaW8k+jn9vQ9r3eXwcpRdHJrxPzd7hasv18vbEQY8yTwGQg1xizEZgKxAFYa+8BXgNOBFYCDcB5vbFeEREREREREelnti6GYEPPXx9scEEjb1KkzPRK+EK2U69sdWvtj7Yx3QIX98a6RERERERERKQfq/qSLtIYd0+w0XVPM+06R4Watj83kuywndU9TURERERERER2B7Ur3P/BJ8H+t0QHf7oj2AzJBdFl29vFTXqF2neJiIiIiIiISO+wFppKwZcCk550eYmq5m7fMkLNMXIYqc1LX9BWFxEREREREZHe4d8KWBh4tGsd5E2EEed2//XBFhd4ikuLLvd4e7Wa0j0KGomIiIiIiIhI72jYAJ4EKDgNfOHAT+4h3X99sB48Phdsas/ExZ5fvlYKGomIiIiIiIhI76jf4HIY5R0KnnDIIdjc/df769xIad6E6HKPsuv0BQWNRERERERERKR3tFSCDXZOZN1dgXqXB6ljy6LtTaYtvUJbXURERERERER6h78G4nMAGynzJXf/9YE68KWC9fd61WT7KWgkIiIiIiIiIj1mrcXacJAoUAtJ+dFd0jzbkY8oUO9GXgsFereS0iMKGvVXm96Aso/6uhYiIiIiIiIiX8lzvYeCW8Ld0VqqIHkIYHq2sGCTCxrZYK/VT3pOmaR6UVERrFvXW0s7vrcWJP3MsGGwdm1f10JERERERKT3+IPh7mTNFZA0CDzxPVxSCLwpYEO9VjfpOQWNetG6dWDttuf7SqEAvDDARWcBMsbDSQt3uG7Sf5geBtxFRERERET6UkMDnHwyrFgBb7wB48dHpvlDrUGjSkjfc/u6pLVnQ+CNJyonkvQZdU/rb4pfie67Wbem7+oiIiIiIiIiEjZtGnzyCRQXw/e/H91ooinQ5B74qyA+Czw9bKNiQ/S4a5v0OrU06m9WP+ISh7VqnzxMREREREREpA80NcHdd7v/AJs2uV4UrQmwGwONbkLLVkjI3YE1hcCofUt/oT3R31R82qEgkvzLTDM8u+jZnVsfERERERER2e29+GJ0y6KGhvB/f0P0jIFaSMju+YqsRaGK/kN7oj9prnS5jIwH9vkLjLm8bVJr9HZl5cq+qp2IiIiIiIjspt58E+rqIs9bA0iVjZXRMwbqIS5zB9YUUiLYfkTd0/qTrYvAmwT534ExvwYMlL4PQL2/HoC6lrqvWICIiIiIiIhI73vf3Zqy995QUACvveaedwoahQIQn74DazJ0SoL9Qj40lQAe+HEw1ouw1tWxoABGjtyB1UsUBY36k62LIdQCe08DXzKEgrDXHwEobygHoKqpqi9rKCIiIiIiIruZlhZYvx4yM10ibI8HzjzTTesUNMKCN7nnKzOecDLsdppKwg9CnWZv9etfw/33u0ZKb78NBx/c8ypIRK90TzPGHG+MWWaMWWmM+V2M6ZONMVuNMXPDf9f2xnq/carngy8F0sJhUY8XBh0HQFl9GQAVjRV9VTsRERERERHZDa1YAYmJLjBjDCQlwV/+4qa1DxoFQ0EX8NmhRNYeOrU06kb97r3X5Vmqr4cLL9yB1UuUHW5pZIzxAv8CjgE2Ap8bY1621i7uMOsH1tqTd3R932j1GyBnIgSbwJvoykJ+8CZS1uCCRq3BI/LzoaSk8zIGDoQtW3ZShUVEREREROSbbvFi17ro/PMhOdyIqLULWPugUXVTNTnsYCJr44nOuN0N110Hfn/k+UqlAu41vdHSaCKw0lq72lrbAjwFnNoLy939NJdA5t7RTfnCB0trsKgtaBQrYPRV5SIiIiIiIiI9sHmzCxbl5UXKAgH3v33QqLKxshdaGhnXeKKbrIXp0yHYLtVRY+MOrF6i9EbQaAiwod3zjeGyjg4xxswzxrxujBnfC+v95mmugOwJ4I2PlPlSgEhOo9KG0h4v3lrbNgqbiIiIiIiISHeUlMCee7ruX61SU93/0vrIPWrn/Ea4JNZPGHjC272VGY8bga2bgafFiyEUcvW59VY491z3XHpHbyTCjjUWXsfIxBfAMGttnTHmROBFYHTMhRlzAXABQGFhYS9UbxfSUg3JHd6zxx1Ym+s2A9EH5Pba79/7Mb9kPnaqAkciIiIiIiLSPcXFMH48xLdr3+AJx3Ra71UhHDTqmMi6G0mso3jiIdgApntBplmzXGujqVNdLqNQCObM6d6qZNt6o6XRRqCg3fOhwKb2M1hra6y1deHHrwFxxpjcWAuz1t5rrZ1grZ2Q177t2+4gUAMJOTEnra1eu8OLr2+pjz3BhqButRsasVXdGnjjQHh5NJR9ssPrFhERERERkV3Tpk0wdGgkn1F7W+oiOXVdSyNDtwNEsfhSwi2NutfG5cMPXTDr4oshIcE9/sc/er56idYbQaPPgdHGmOHGmHjgLODl9jMYY/KNMSb8eGJ4vRoGrL1AgwvexGfGnLyycsczedW11AFEd1ELNsGbk2D6WPdnQxAKwoyTofILqFsJM07sPOShiIiIiIiI7BZKSqCgIPa0jTUb2x7HbGm0vXyp4K8FT1y3Zl+wAI46KpII2+uFI47o+eol2g4Hjay1AeAS4H/AEuAZa+0iY8yFxpjWge7OABYaY+YBtwNnWSXXidZS7Zrh+dJiTl63dV3b4wZ/gxslLZauyoGqxiqgQz/T+X+E6nkQaoGG9e4AX/MI1K+jLTocbNzBRGYiIiIiIiKyq6qshEGDYk9r3z2torECMO4esqd8KWBbogNPiV3f55aUwOTJkNbuVtrf/Tzasg29kdOotcvZax3K7mn3+E7gzt5Y1zeW9YMnqcvgTHVTNV7jJWiDlNWXMWxLpAkgJpxWahtxuJZQCwDFtcXkJOdASxUsuwNCzW6G8HRW3A3BeojLAG8CNPU8j5KIiIiIiIjs2mpro0dOa6+upY44Txz+kN8FkDw+aNna85X5Ul3qlFCzWxbAaVtcMu0YKirgsMMiOZYg+rHsGG3K/sIGwZfo/nchIyEDgLKGsh1aVXFNsXuw4UV3EKaOgL2nQdZ+4K+B6vmQMgy+twFOXQ8DDt+h9YmIiIiIiMiuKxiErKyup+eluIhSSV2Jaynkr+75yuJSwQZcKpVtaG6GpiYY0mH89li5l6RnFDTqL0KBcHb4zq2FWoKuBVB2UjYAZfXbHzRq3xuwuDYcNFr/rGvyd9Q7MP4aOPpdKP0AvIlwyOPgTXItjSY9s/3vR0RERERERL4RQiHwxein1BRwgZ0ByQMAKG8odylXWqp6vjJPgrtPDXQxkFM7paWQmAiZHVIDq6VR7+mV7mnSGyydYngv5ENTCRUB1wwvKykLqsIH4nZyfUudtpZGZR/CyF9AYh54vOBNgaq5EJcOOQdEmgJ6E3vyhkREREREROQbIBSKHYhpzZubleSaIZU1lEH8EGhud8+aOBCaSrq/MmNc4KipFFIKY89TNRfqVrNl/dHk5GRsK1OL7ADF3/oL43VN8GjXTzN8YJUF3RHQ1tKoB93T2gJFwKqqVa6PabAJRvzMNR8E8MZDzVIYeJRr+dSqdbqIiIiIiIhIWOso37OKZwGwpmoNxGW5lkat95Snbenq5V3zJkDjxtjT1j7pRgD/5Gc0vT+FvDxLc3NPai/doaBRf9EaNDKdk3uVhdMcDUxxGeO31G3/QdfWJQ1YWr7UjY4WlwGZ46NnrF0JuQdDXLvU8x41SBMREREREdldeTyutVFH80rmAeERvgF/yA/xWS5XbmgHhjDzJkHd2tjTZp0PwQYI1BJo2EpCgolZN+kdChr1F8YLgYZwXqNo68LH2oaaDQAsLF243Ytv39KoLWiUUgjBDiHZhg2Qtud2L19ERERERES+mTweCAQ6l2+q3dSpLBSfDY2bIqNz94QvGerXxE6GHWyEop/Agf8mGJ8fM9eS9B4FjfoLX4o7qAKNnSa97oK2fLD+AwA+2fjJdi++NeCUGp9KbUst1K+FpEGdR2trLncjp4mIiIiIiIgAXi9UxchtXVLXOVdRjfVAwyZiDfLU/RUmu5ZGHRs5AIw4FybeA6OmYA68XfmMvmYKGvUXcZmu+Z5/a6dJW8ItjQLhPqGtTf+2x+qq1QAUZrhEYoGmMhc0Mh3CsiE/JORs9/JFRERERETkmyktzY1U1lGsfLvl/hZo2uKSWfdUQq5r6ECH9C3GC/vf5BpdGC++hOSYLaCk9yho1F94vK4JXvuhCRNdDqPNHRoDBULbf1SsrV4LwNC0oQDUN1W4A619viJrgVDnQJKIiIiIiIjstnJyYFPnnmiU1XcOGpW0NLoeLGYHwg0pw9wgTd5w4Kn1HnjA4UAkpYsvIYGaGra/i1pLFax9Aja+DKHgtuffjSk60J/EpbthBVudtgWeMFR3SOoVstuf5Wv2ptkAvL3mbQCKazaQkTOatsjtC/mxh0FsK/fAj3UwiYiIiIiI7G4GDoTiYpcM29MuFtTaCybeG08wFCRog9SEvK5FUMMGSBvVsxWmFLleMFsXQ/a3IFDvyrO+Bd7EttkyMqCkBBITYy8mptIPYeapkZxLaaPh+M9j5hcWtTTqX+KzYetC6BAUqo8RI2po2b4uas3hvqCtAaeNtaVutLbWDqDtA0a2XUumtnKloxcREREREdkdDRoEGzZAU4e81IPSBgHwn9P+ww/H/xAAT+owd59Z/mmne9tuSx7sRlDbNB2CLZFAUfaESOujcL3q6qCxc2rg2JrK4f2TXIBo7BUw/BwXmIoVMMrPd6Obd/zLz+/Ze9pFKWjUnyTmQdU8N4paOwnhxkCHFRxGos8dLFVNMbKQdaGmqaZTWVlzDbRUg40xDGJzRffrLCIiIiIiIrusJn8Tm2s3f+U8Q4fCokXQ0m5AtFAIKhsrASjKLKIgvQCA4qAHQk2w4Xnw1/asUon54ImD5Xe5QM3qh1158tCo2bKy3KhulZXRL2/pauC2JX+HuGw4eQmM+z1860Y4+t3Y85bE6InzVeXfUAoa9SeJg6DqCzq26ml99u6577JHzh5A5ODsjnkl8zqVrW6sg8bNnUdPA6hf1+1li4iIiIiIyK7rxCdOZPDNgwl+RW6fgQNh2TJITo6U1dVFGjOkxaeRmZgJwJbmJsDAlrddDt1gU4wlbkNKIWBdQu1nUuDzC115+xZBL+TjecqQnljJsmXRL++y5dH6Z2HfP0FcGnjjXZ7fzH22v367EQWN+pP0PcNN4yKppkIWai14jZc4bxxZiVlA7Cz1XSmt75zmflVz0AWNPHGuIJx0G4Dadkdc+3IREREREZH+LBS+z+lpC5dvuGAQKirA367DyWfFnwEwq3hWl68bNMgFYto3svH5YGuTG/07LSGNtIQ0ALbUl7heNIE6+OQcWP3I9lc0pSgSbAq1q2ywXa+ccCqVvLQy3nsPmpsjk+LjYyyzpcp9NoaeAp52M8Slxq7DwC7uhbsq/4ZS0KgP+YN+cv6ew+Kyxa4gcy/wJMLqhyDYDP66tiTYqfHug5ydlA1AeUN5t9cTDLcmOmefc5h3oWt1VOlNh4b1tCXCPm0L/Dic36h8VuQke9qWnr9BERERERGRGBZsWUBpXYwx3HvKWlhyE7wwEF4d7/6/853IqFu7uZYW+O1vXXeuwkJIT4ef/xwaWpqo97sk0y8ufbHL148f77qj3XsvNITjNsuXQ22Lu29MT0gnPSEdgC11WyB1tJtpwwuRVkLbIz4z9uhrVfNdRdoZkl3Mu+9GB42qq2Mss24NpAzv/mjhW7a4z1VrHmBwj7fsXvfIChr1oenLp1PZVMk/P/6nK0gfB4Rg8Y2ABeunLNxCsDVolJecB8Qe2rArxTXFAAxOG0xuci4A82oqXQb6sg87v2DLu64ZoYiIiIiISC9r9Deyz7/3YcTtI3pvoXN/B2seh6PegtNK4fRSNzy77msA+N73YPZsWLIEamth0yYX/Jm5fkbbPHd+dmeXrx81yiXBvuMOFzdpaoKrrwnQFHCtgVLiUkiLdy2NyhrK3ChnXTDTDHvftfe2K50YI+F09XwIhkdSC/eKOXT0R3zxBVSF0/7W17vgVichv0uo3T5Fywv58ISBJzRyWlcUNOpDv3nrNwA8NPch1380bbT7IDesd5Hx/w5pCxq1Rm1bgz6xupx1ZW31WgAGpg4kJykHgM2NVdiEPFj5b/DXuRlbhzH0b4XKLxSVFxERERGRngu2wNonYf5UF9RZfhc0V/DkwicBqPfXU9XY/QF+utRUDsv/BUe+Bpn7ukCRLxXGXL7jy/4GmDXLBYteegmGDAGPx7U4euABeODLBwAYmTWSxkAjqytXx1xGXBwUFcHWrTBhApx0ErwxoxqDIdGXiDGG9IR0DIaKhgrIHOfyBXXw5eYvAVhYtpD6lvqvrnhmjMBSyYxIIDDcK+agUZ+RlAQXXeRaVDU2wo03xnoTGS5HUrvR1zRa+LYpaNRHlpcvZ1XVKoZlDAPgpaUvgccL6WPdDP4aCDZSFnQdyDISM4BI97QNNRu6va5VVasAF3BK8CWQ4E3AH/LTkneEay5Y/rHrL1q31r0g1AQf/8T9DzZ3veAeeG3Fawy9eei2TxDSN2INK/kVQ0qW15fzwBcPYNs32RQRERERqZoH0/eElq0w8nzY8zJIHY4Nhbjif1e0zXb/l/f3aPGfbPiEwlsKqW2udb0ncg92QQpPu1vcrnLV7GbeeAOOO65zeXx8iOcXPw/AxpqNAPzxvT92uZzJk93/pUvh3XeBpEqMMW0jfKclpGGMobqpGnImQsdbhMSB/OG9P7Q9ffDLB7+64oNPBG+7zNueBGgph4rPo/IcHTr6Y5qa4PXXYcwYGDky0oXOWsu66nXufiVttLvPrm0XGGuXwzcQCjBtxjQqG7o/6NTuoFeCRsaY440xy4wxK40xv4sx3Rhjbg9Pn2+M2b831rsrO+v5swBYt9WNVDbllSluwpATo5JylYdbGrUGizITMzGYbQ6J2N6Gmg0YTFsrpdYI8Jbsb4MvHWaeCu8dD28d6l6QsTfUr4UXC+GlIlfPskJuuQWuugp+/3u4+mq4/nr44ovuv+fa5lpOeuIkimuLOeu5s7r/wl1VrACMMX1dq14TsiHG/GsM579yPtPen9bX1RERERGR/uTDH8DBD8LIn0FKASQNgvxjuXfRC1Q3RxLO/Pat39IS6Gp89Nga/Y0c+uChbKjZwClPnoL1xEGggajbW3U7apOQ4LqTdfyd9/PiOVgshsg9yvtr3+9yOcccA2lp7QqSKjEYUuJci6L0hHQ8xkNNcw1k7BXdoicunVkTX+K1Fa/hC+cUuuyNy9q6t8U04PDo+6fsA8GXBh/9CJrL2xo45KRVUljoZlmzBmpqINHFsZj2/jSKbiviyjevdI00cibCoj+5JN0QlcN3yktTuO796zjo/oN6/qN4oBGaSqGprGejxvVDO9zB0xjjBf4FHANsBD43xrxsrV3cbrYTgNHhv4OAu8P/d1nWuuhlc7P7HCezASiABX+G5KHuAPHXQEMxJObCqAtc/0mgOdDM3C1zAchJyqGysZLqpmrWVa9j2KgLYMnNbespDfmwBMhNcgGfjMQMjDGU1Jd0qlNXttRtwWM8bUGjrMQsKhorWB5fxDADBJqgNHxy2GuqO6nPvsxllwc+XDaJy158i7dnuMB96/GTkBCdbGxbxtw5pu3x9BXTuWj6Rdx98t3dX0BXWrZC3crwF0UI8LqIcerw3a4P8/Rl0/nuU99laPpQFl60kAxfnIvEN4WTuBnc//gsyDkQEnKiF9Ca1K315PwVJ8vJD0+morECr/Ey7f1pxHvi+f3hv3fdHJtKIdTihsT0pbnRE2IlsutrjSWupV2gFmw4qGdDEJ8NAw5zCfi6qSnQRII3AdNVYNBaqJ7nRki0ofC2Da8zbRRkT3BfZNL/NJZA6Ux3TjcGl3POul8zB3zbnfP7UHMzlJa6UVA8HpfYMitrJ8ao8/Ojh1IBSAaOz4Y//Q68Se5cEPK7v9RhMPR7u875Odb7Gzhwt0uC+bXR9u09NuS6WbRUu3wdnjhIyHPf+bvKj1b+Gij9CJrL2l03hM+3uYe4oIP0KWuhuBjWro2MvuX1ui5PC/2v8L2nTyEjIYPVl60mu3GLGwErfA/EC/nQVMKdazssE8vTi57mp/v+tNv12OfuyBDpM9bN4PxZg3ggsBBqlrjh09sFKzZVDWTF++770lp3OOTmQk4OVFZGvj9TUmBoQZDfzriUu+fczaUTL+WW427BuzOvz2wIqhdAzdJI3h2L+87MGAcZ47d9PMc4r57OKA5Nmc8//pFEYqLrahYKwTur3wVgyv5TuOawaxh++3A21W2i0d9IUlxSp0Wfeir84heR5wmZlQSAlHgXNEqLT8NrvNT767GAGXwSrH3cvYlgc1srpoANhN+a5b4593HpQZfGfi/pY2kbuMkTD0NOdueGBVPh5RFRrYQuuQSuucblM2o19b2pXD/zerzGy82f3ozP4+Pv466CD3/olj3utxBsdK8vgUdrHsXn8bGyaiXHP348//vp/756W7e36G9Qvw4KToOUYe49V3wOeZMgPqP7y+mHeuOKbSKw0lq7GsAY8xRwKtA+aHQq8Kh14bpPjTGZxphB1truN5cJW/nFYhISPHi8kRvQDVs2smTjIoYUDiE1KZ0af607lkrGkRgfx5CiDIwNAIbamha2llZRMCyBhMTIclet9hK08QwdmYsnWIc1Pmoa01i/wUfhkGbSk2sxhKipj+Po49L5fLaXkSPdyQXAP+MK4BnYO9LcDmt5+tEyPL548jYEABfNfKP4cSyW8al78b+Tnuf3c6bx6Mon+MNjd/HTIb9kUvKhJNfNxBovK81IYDGJzT6Kly4nUFqHB4Pd5OezV95m8MghtN6urFuwmA1L1jBgWD4pGWnhKlgqGirwYGjZWEVxzXLSTAqhILz++iaKRt3AyJor8YQaCJkkSgdcR0V5gFFxNxEfXIrBsqF6D7IHJJCe7vqIJiW5k2tJievTWloSwhOqAxsg5E2nePEy8gb6yMqOnNDunfsgm+o2AWAwWCz3vPcyr19yE2++mcwee0Q22+ZNm/jztJWccEQ239o/npANUdFcSY6/HI83meScIvwBg8djSV55LckDRsK+f4r6nMyd8zmJ3nmkJbrtUO+vp7y6gspNJYwZOY6k1BS3bZor8dXUYgM+BhQNb3t9VU01q1YvYHTRGJKTMwmEApQ1VbC1JJNgUyrDx+ThCTViMbz9XgKPP5XG+++7L81WS1/9jDturW3AXeoAACAASURBVGXKFC/7H+m6Ha6Y8yUcAPM//oic7DyCoSDlzRVUl6cS2JrIsD2y8XkBLM0Bywfz3iFzUBwD09NoDjXjD/lJahiBf2smhXsOIt7bBFjqg17OePUQVjYvBVzz0sy/Z1I3OpOUY6bDsDOjD6TqBdjGcurKK2lq9hDns/gbKqmtqCIhezBDwrNtXLKM+z95gNu33EeV3/0iNC5jDCfkHMsH6z8AIqPzPfDhNfy+7Fb4/kYXsAurXT0Tu+FGkkafRvs2qmvmLce2VJO6x/FtIxiYYB2hmvWkDCjAejMIBA0J8ZZ5Kz5hbdMW4pPyAEOQAFmhTJasX0R1Sh3EG3zGR1FqIW/86ziOOi6fQyfFt32n1tc28uSDG5l4cDLjxsdjsXhD9ey1ZlRk1MCw5oZm1s1fREpdKRDJHeb96w3kP/ZQ1LxbEzxMuWQsz6ctaisbnjqM0zY9R3bGaI46JsU1MAOyqx9kVNIrcMQr0fuicQvNNZXUr19DIGiwFjwei6lZiknKJRgX+TKsLq0g667byHvs8ahFzJ1yCXHnnE3mgOy2Mk+gkpatpSTkjsDjS3IxDp+leJMhPtGLLyEVQxAwbC6voLy8hH1GDSIhweAP+SlvqqRmQwpJ8XHkFw1s+76uq6qjanMpQ4enk5Dk9lswCH+cmsixp+axx56R7W6Ctcx4eTn7HpDEPvslh98bVG7YQGKyxZc2pK2+DfWWdasaGDA0g7SsSFPypfMrCNgkhhRGmia3NDWx3/f3I7EmOgfC+uFjKb39DgaNHNp2QWWDLTSVr8SbMpSUrMj2mb/qS94rf5viUA3WWDLjMjgi9zAGlGcyoDCflMzIz2iDvxiPOXUVpBRGVmYtVC8g2FTP1tKV+AMGn8/SXFPBgCNPwFcZqZsF7j5qOM98fzCVwWqMMRyYtz9DFl9KdeUYzv9lEh6Pq6+vaRVFa48j4cSZUcGoys0VVL3/R3xDj8SXuy8Aa9bFcfo5w1m/HgoK2m2IlmpqNm7Ekkhzi/tMeb2WivXrSE5NwJMyoG3W2lrLxjUNDByWRWp6ZBtvWrWBxCQf+UMiF4xV1VWsXrOCsaPHkZya2nZuHtfcQsdRbf0/9hJ32eUw7jfhAKkF42HdOmios8Qt3YqxLYChucWwZXUxQ4uS2r5TAbwtm2lpqCV98B60+L3uWLINLFsxj6GDRuNLyHLbprmSlFANvuZmsgtG09TiPpcpSQGSWpZgEwZSF8ijqdlDQrylrt5QVQVx6UPx0ASECHnT2bBwEYOGJpCREfnuqi6tZnSM9/dRfi4p739AXnjI3ZqWWqqrfWwtSWXIyFySEgMYGyLkScbTuI6ERA/JyT78AYPXa2lpMVRWWBLS0sP7PoQ1cRSv3ExGppe8AZFrnIqKSjYUr2XMyLEkpiRhraW8uYKVy1fgj29hZMHo8Haowtfko7msljEjx5GYmtw27+qVqwn5Aowucl+25c2V+Jq9+Eot+UWDSUyN7PvKVfOITzDkFbYLhoaaaChdQTB5DEnZQ8K/QVgqizcTH9dMQmbkmKutr+XROY8xs2UWdbaeOOPj8PzDGM+e3Lj6VpY1rsRgyE7I4prxv+HipuZO2zeY0kLxp6+QXTiK5pY4rIXU5CBxDYupCw6m2eS638UNbC0ph0AVybkFUaPhfDznI0YMHU7+wMFt3/fLNiznz0v/zoKGJQD4jI+Lx17A9zme3IF5UefQ5RuXc8Oim5lZ8zHGGFJ8KZy/x7mMbRyBPznEoAGDsViagk2s+XQM8+eO4eo/JLs4Rziu/MWMJWzZ5OeMM5Pxxbnl1tfUs3F1NQOKCklKiVyIbl65lpQUy4DCyPHZUNtA2fpNDCwaTGJKZB9tWNNIMBRi8MjIOTRp493kJy2FSU9GBVZef6GEZn8VWTk+wiFvbLCJqrXLGDoig2EjI+e6Ocs+4+UtL7M6sBmLYWBiHkennsbcV/fn+O/lk5Qc2b6VxRvZvK6CY09IJynFXfwEA0HWL17d6Rz66qtBqhuyOWhSRtsPKzZkWfzJPAqL4tlvQuTAHzB3EnHHvApDToj6TCz/fAEptTXgiQyhvrW8mvQ7bmfoM/+JmveZX57J6qPGkJiWhMGQ7EuiwA7FbvUzdvQY4hITCYaCVDRXsmnlBgZkDWDwUPd5r/PXUVpeQU1ZBWNGjSUxOantXFe8cj3Z6dkUFhYBUOuvo7yinK0lFYwdNY6E8PFZ0VzJxlXryUhOZ/jwkW3L3VpTi39zfadjbv16H/UNULRnLibUhMVDU7OHlL9fw/Bn7ol6b+9eeA6zDy0iPicZYwxe4yFt6368/uQ+XHRZFqmpnrYrracerSI+KYHjTkho663lwc/KLxaRmZXAIYentQVQFqyZy7Prn2Fh0zoslgGJeXy/8FRyKyaTNSCNvAHxGOvHGh9HHpvOQw/7+M53IvVqCjRx4B0TWFjjroe2Nm8l58YcZow5m0mf/hLfYf9xQRxr2eCHhX53P7DijHm8WfwO//fJ/+PBD25gckMG6YOHE7RJBEOG5KQQzddMI/uh6H1874REVp4c3YLjwQVPcs7oqzns3e/i2fcPmCGnwBGv8NNTlzDmhHO45ojIvJs2wZ57umHnhw2LlM9bM4+smw4giLu2veOzO7j787t4cfwTDE7JY0BRu+uWBsOqlTBgSBIZmQlACIuXL1fOZX7dZ8SlushFgjeBvVPG499czx4jxpCemdl2bk5uriJQ7yW3aLT78RJI2HgPGfElcEj0EPXLlyyhqayGnNQVADQHW6htqSK3pZyk7HzSsnOoqfWQnhbCE/DTMcw1mpX8NPF+Dpv0f9x2u5fx42H9erjx1ccgHSYm7UtcSQsj0opYXbuWfz40naNHHk7u0AF4glsJedPwBiqhqZRfnpfPHf/OornZkD24hBJrSQzFU7x0OXX+OoKhIKGGLF5+ZjF7DT6L4Z7nMaEWNiYdzbvLXBDmneOms6h6Cb+a9Rvuf/deDtg4kvwRQ2lNi168dDkrV3qxngS+lXEGaZWPg/WycOsZeJMHMiruQeKbVmHq17ngVHwOvzxrKddPG019vZeE+BAnn/sa18+8Hojcr9z48Y0MLz+U0z0Hk7Pwb3gW/glsgE9r4/lXjWvtFgjn9X1z9Zvc98RtfCtjbwaNHNp2f7T8i3ksXbaAMcPHtp3rtjYUM27p7919hQ25wNYL+fjryql5PIOct6K7uy099xrWffc8hu2Zj8/jmoAFbBLFy1YxpDAxqjVXxeYKGmrqGDxiCN64yHl4zfwV5A7JJS0nq62surSa2soqBo0cii8urq084A/i8SVSMDZyj7Y9zI7mIjHGnAEcb609P/z8p8BB1tpL2s0zHbjBWvth+Pk7wG+ttbNjLO8C4AKAwsLCA9atWxc9w+kGXoguOvyaTD6Iix5TL98Lm0cnw5nRuXNmTj2Sw7c0w72fRAq98NGZhzDp/HEw5kxIHATWz//ueYjjjtwaddA2PlnEGVfcxZQbj+CASYnhLz/LK0+u4JLfj8G+ezkMnQCbX4KNz2DOtjQ0uEBLq1/f83Me3PQw975gOWsRzBkEx/4ULr1xKtcxDTKB3wEN8P8WDOSBvUp46Dk4fQmsz4CJv4At3wJ+WA++ZBdNDtSx9o85FOWtdx/WcFngtnr2Wuga4Sy4C5ICMHUy3PytVK645Qq3vtOAY4HP4bpHruS6wD8hD7gMSAHugpdyTuGVisvJP2E/MnLjaaoL8PgjFXx2+WlkTNwDBk120d/q+XDMbbA1eh8ddG0qn3nqmHUfTCyGGybB1Qfns/+T73PPf0ex9z6Ri/TJ/xjCrNBmPCFIDEBDHFA7mEEPLePzBakMiZyveWDaS/xg9GOkH3Q2pAyANQ9hVz+AZ6WbntrsLpDqE+DgpgI+TXS5oDwhCLVek19nOzWo+e2d53FjxcNRZfEGFjcOZ+SU62HQEe7Xc+Cd577gb/+ayINPpZOVZdq+rNOneyIBifD+eObKXM68ei1cF/0LQXCkwXPqCkgb2VY2+549OLBkBR09/t8zOfuihXDEhZC1HxjDkrUzGPf6HxhVAX+YCcty4G+Hwzkf3sy9l8wlYY/JkFEEax+hdN5rXH7zPex77olMPjaezEz3y0vw9YPY98wrYNhZbfW1t9W3bcv2DrQZfG62MvNB+PZ6uPFQuPF4+KRpH0b/5CrIHeuiAyvu4aVnNnHqD3Nd82SA+dfBwmnwPJ2O5UcP/ClvD76FS67OYuhQg88HdfUw8rHOrZQObxjBzOTOifpy/1rKu7Pz2Ltd3rxn//URNzw4iTlz2s1oLW+efBzH/jwX9j4JUvJh7SPMfX8++40td8Gv8Hbg9vB55Mxm8Ma3lb96VSYnNxZ3qsPE2z7lqvsO4vTTI2VVG9ez/qZz2PeMye4csfFZWPcoOT8r4/UPc5k4MTJvWZn7ob3DaKKsuX1Php9+Mww5KbpuMbblCSNf46Rfn8All7QrrFsNbxwIZ1REzXvYtGw+onMSSjua6KDa/Ot4/9l3OaKkBe6b1VbcQhwJtLB1q2vl0ur6i2ewun4yDz/cYcExzuMfH38Qh16VCUe+0bYuFk7DnN35+Jz1/EscdP7pUB2MnnBa5+3w3qAjuDR7BgsXRpebaZ1/pSuqH8KaVcWdlvHfw07h+1Oa4MAzIGMYrH2Mj95axQXPfczs2dHn99J78hlwrR/KIhcHIQPeqZ1WxylvP8D+3/k5U9tPq19PxUNHk3PmfyAznONu0V+ZPf0tJpQMgDtfj6yLPC4Y/gTn//UgRoxLwhoXkv/z//uI4QcdwV/+0mGFsbb7zw7m0EsPhv1vcQXhX4FjfaamTBnGgwUdvpNp9zlp/WUzJ4WXzjmK8WmNjPrOgTDkACh+HjY8SXNjPAk/mA/pe7a9fs4NR3DA2PVw6pqoz/WYXy7hzv+OiboxeeKNhzl71nmd6nDNk3+iYdLFnPHzDAYPdjdByxaU88zlbzLwlNM55uQEMjOhtgZmff/XXPmju+CMU2HAJNcKqvILWP9o1Pcnt9ezrryAYT+4HwYd21Y+/x/17LsehlfC24/Ckjw4+Wz4v0WXc+uUzcTtewGkFoHxsmxhHZO/N5YNG8DX7me6d/5yHkd/twD2uT5S2LrtW+sA8OaFHPn8v5jhKSevDvYqhVlDoaFjlCXsoOYhzEpw56So77kYLqr6Nnc9OguqOnQJ+Q+djvun7lvKvxc+xXvvdVhIjM/Uw5OGc94xa7pecTuj6gtZsd/6Ttv9hr9exfpxV/KDC3MoLHT7c+Z79fxxWhobOqR0DGV48NREnyQCHoi7tvP6xnriWRLq3AXGzqfT+zjk2jQ+bReg+Cqnzb6W9NxpPPRQhwlPmE7781e/ySI0+jLu7DhAUYxtOeOUI5icXQoPL4meEGMfvfGfTzhorJeso6+AxHRYdR+svg9ztqWxMdJNA+CF++dw7a0HdOu8uEfJRMy7s1i6dNv13Zydz6DJWzqVT8j8jKvvPzDqOzHQEsD3o7hO81588O3c/NvPSBh9OGQOh7WPwrrHYp6TFl8/lnHnXBt13cLt9ZjOl06MsSksNfVgwWsh2OHYOHgDNPpg3iDYP5jDF94K4oKQ2QTlyW33853s3zKQL+JL+NUncPFs+Puh8OABsee9rPpwbq3aBI+0u7CKh9I/5THg3GdhYCSq8fGTT3Fo5j/ghDnbfG97bzyKuC/eib7GAYqS1/Kft4qYNClSNvO1tfzyiiKWdPhIxdr3h5DGe+NHkHDiq1GtOf6+71U07HMRh55ZQFauDwys2LKKn8wfw6gKuP49WJ4D1x0J3tuWsubsv1KQ+ySMHQ++OOZUfs5R6+FHX8I906E2Hva9CH5UNoXNjTfyowszGTXK/RBbXg77L/N2Pi/+93ZmUMX7D8Hh6+D2iXDZiTD1uqlct+c0+B4wAmiCV9acxFur/8FRZxYysCAej9dQXhLi6Sue49jLjmPEfmkkJHnAws1vHMcTvMsPF8APlsDT4+G58bG/5z66ZB8mfacADns6stFeyMcs6NwbZELdSGanruq882Lcg8z7YAlJb13CHicfA/n7wsanYe0jbfs+q8Hdz21KhyIfPPy/w7l69q0UnbIvQwYF2VLq5ZETfHhOWeK+a9t9fuxz8Nx/z+AGfstqRjKQEtL+vDebW+L54qYGBtTDXw+DG74Nl/9tKtdlT4PfAIPdtqQO2PADGm99hdN4geWMZmrRkVz6042cPwtuetNd8+x1Eax99XVmjPuUia9PgynAOFh5O0z8KRy9DJ59Flq8sO+FcG3qofzox0e778R29b3u7PC9cQZwLfAZ/ObpGzl8/3q+u3waXAEMBN7ANYV5AWYxkR/yDGNZwuApF/NQwWoeeQHOmQ/PjIMzfxj+nJhprlnLsUAz/L8Fw7m1cA3/fhku+ALeGAUn/KTDtXC4blf/Kpsb7AYu/BzuftV9Ts76ATzy3E8458dzYPJpkD0K5l3G8g0D2GNoMZzZEPXe3n12MkddOAT2+wUkuR9eylYtIW/xyZ2+E1uejiP+ZT+dxLjuXXdzAcM2HgE3R//AzE+GwWNrOy3CGDPHWjuh88I7zNcLQaMfAMd1CBpNtNZe2m6eV4G/dQgaXWWtnRNrma0mTJhgZ8/uFFf6SqFQCI/H4/oPrvi3axJpPK5537qnYP3TLplW+2BS+acu8fMp7U7irTe2g0+CCXe6ZpVL/glLbwJvCpxZF2NbfGVvnp3juutgWof8MlOnuvLeNn08HHAL5B4aSTL3/EA4vxyqY2Sf72Zz80Z/IxPvm8jCssjVzGmFF1D+8D1ce61h/HhXZgwEApCaChkdWvzNXDuTIx45Iqrso59/xJ9n/pnXV0Zuuo4dcSyv/Gg6xsYRDEaarBoDIU8TS8oXs7R8KSOyRrB39ghSXt0DjvsM0sNNo1o/J3lHwDEztvneWuu9smIVi8sWMzR9KHvm7Ely1edu1DqP+6WCNY/Duidif9ae8Lq+twk5bVFsl/XfAz8OxlpllMcegyeecIniQqHoXIF97fzzXfPm1o9wn9VvJx5Hy5a5w6L1/NF6DtlnH/f+Q6Hoz2VOTve2yaxZbtkDBrjjJBSCBF8DRxX8m7isEUC4K174vPhlSwJPDv4V67auY/9B+3PW3mcxLG2o62Zog7jwa7gS3uRudXUoLoYvv3QtMtsfX9/+tuveGsVaCDa47ks22LY6162i5x+CQMD9otjS4h63GjUq+iZ+e82dC7/6Fdx1Fwxq11uipsadj7Kzu37t123pUpg/39WhteuAMXDkkTG2eyjgumcGw9v99X1dt5AuzicvL3uZ69+/njVVayjMKOQPh/+B08ae1nW3zPashdmXum4D2fsDxo3gueo+eMEHz0eP2HnmuAUcfdlenHxy5OXWWh5ZeRN/eP83bfMdXjCZD85/l5ISQ15epNv0TTe5vAb33dehDq/sAQfd6/IitP/ueqbe/XXU4dgP2RD73rMvC0uj77ir9iog89BwgCnYAguvp+Tj+7jo6Vc5/6oJFBREungnVr1JYepnxA88kKhzfoztUBcPo65OocRE6nbAoAP4ZMonxHnj8Af9eIwHr8eLP+jnhP+cwDtr3mmb96TRJ/HiWS/iNV4a/C4raHKca6XQ3a5h9fWwfHnnc9J++7kuDr3N44HNm11VWo9ba2HRIrf+9sfygafkYzq+ByA0MI/Viz5mXsk8spOy2S9/P7KSsjrN97WK9V0CvfN9YsO/ZredLHHnym4ci9a64bb9/uhzc25u/7om6E0N/gYm3DuBJeWRaMkvD/glEwdPjOQVDfvovI+Y8vIUllZEImXfHf1dHjz1QX73zu+Yvmw6xhjO3OtMLj7wYva4c4+o1xsMqy9bzb8++xfPL3EJhk8fdzrTJk8jOS45al4CDfDGRDjwThg42ZX14Nqyu1paYMUKt9/bH0d77x3jWC6ZCV/8PzjqTXfN2VqvvabCPtf1ar0Axo93Q7kfdZSrJ0B8FwHynS7WsZwH/PVMOPFnYP2w5glY/1SX94lrqtbwyLxHmLt5LsMyh/GTfX/C8PgDqa52+yMUilzrjRzZ+RplXfU6Rtw+gpCN3GNdVfg8r918Gu++6wLD8fFu20XlHOopfy28PBJaKiPd5DreQ++myurLGPjPgdgOWb4//vnHHFJwyLYXEArCUz44o9Jd54b8sOB6WPRneH0YPN7hB7qv616enRs0OgS4zlp7XPj51QDW2r+1m+ffwAxr7ZPh58uAydvqntaToFGPhIKw7Db3K3zuQZA02O28qvkw/qpuL6ZfBI12ppdGwKGPQda3XIun1i+TLk6W22tl5Uoe+vIhrjz0yh5d6IVsiNs+uY14Xzz/d+D/td3UVDZW8vDchzl333PJSc7ZxlJiaNwCdWsg1Owu0LxJkH1At29sd/hzMvcaaNwE438HyQXw0nBoLqW7QSO/Hx5+GFavdhfkGRkuMV5xMfzudy4I15fWrYOFC92NX2vQ6OST+9GFg4j0CysrV1KQXkCCL4EtW+DNN11uitZuwmVlsGABTJoExx/vLqLr60KMW5gKJy9z3/Ueb4++uyoaKhh681Cawgkuz9//fO47/hYoecflMiTcRwkLI84DX+e8ENvrkbmPcPmbl/PimS/y7WHf/sp5S+tKeXjew5y///ltA2nsSlatgpdfdt9NyeF77MZGuPRSorowimyvNVVreG7xc1x04EWkxrsLnvKGcg578DAK0guY/uPpJPhcdH3elnnc8skt/PU7f2Vw2uAul/nWqrc49vFj255/eN6HTCqc1OX8MVnrWhUEm8LXlsm9ct7oFcEWFzgItbg8WYn5X0uOrKoqePVVF8eOjw9vkgBceGHkPLC7s9Zy52d38uWWL7njhDv4/W9S8Pngb3/7Gq6T5/0Blt0OE26D4edC5Rz438EuT+lpyjl308c3ceVbV5LoS6Qp0MQJo07gtbNf6/4C6tZA8XSXCzbce4VgE+x5icvhtpPszKCRD1gOHA0UA58DP7bWLmo3z0nAJcCJuATYt1trJ8ZYXJSdFjTqqPUnl+202wWN6lbD7F+7LlX533FfJFXzXA4L6VKvfE6CLVD1pRs1gHBi69xDd51ElyIiO0kg4ILirV10hsW/hZl/NYz9rRue2XigeiEMjjEW8VfYXLuZwTcPZnT2aJZdsqx7ra1E5BvpjRVvcMITJ/DJlE84eOjBfV0d2U3MmAFXXglvv+2CRsnJbqCmHQ6yWQvPZcOYy2HsFa5xQMgPT4UjUz/enW54u/aLV37B/V/cT7w3nobfN+zchOm9ZKcFjcIrOxG4FfACD1pr/2KMuRDAWnuPcVdSdwLHAw3AebHyGXXUZ0GjHioqcq0kRL7KsGFuxAkREekjoSCUfwING12z+6R8GHiUAu8iIrJLeekl13PpsMNcioctW+DWW3dwoXVr4bW94fubI924weVpAwWNwlqCLZz65Kn889h/Mn7A+L6uTo/s1KDR12VXCxqJiIiIiIiI7CzWuqTh1dUu7URe3g7+BrLuGZe65cjXIS69Xf7UMAWNvjG6GzTagTSgIiIiIiIiItJXjHGBory8Xlpgw0ZIG01bkv2mzoMNyO7lGzpGgoiIiIiIiIhsF+sHTzxtQaPEge0mKnywO1JLIxERERERERFxo/e1VLucf6DR0kShQhEREREREREBMsbB1oXh1kbt+Gv6pj7S5xQ0EhERERERERHIngC1K6FxU3S5J65v6iN9TkEjEREREREREYH4DJcIe/bFEKh3Zf46WHp739ZL+oyCRiIiIiIiIiLi7HM9lH0I738XNrwIc6+CBVP7ulbSR5QIW0REREREREScgtNg7X9g8/+g5PvgSYTkIX1dK+kjChqJiIiIiIiIiGMMfPt5WHoTrH8BsvaB/W/q61pJH1HQSEREREREREQijIGxV7o/2a0pp5GIiIiIiIiIiHSioJGIiIiIiIiIiHSioJGIiIiIiIiIiHSioJGIiIiIiIiIiHSioJGIiIiIiIiIiHSioJGIiIiIiIiIiHSioJGIiIiIiIiIiHTi25EXG2OygaeBImAt8ENrbVWM+dYCtUAQCFhrJ+zIekVERERERERE5Ou1oy2Nfge8Y60dDbwTft6VI621+ylgJCIiIiIiIiLS/+1o0OhU4JHw40eA7+3g8kREREREREREpB/Y0aDRQGvtZoDw/wFdzGeBN40xc4wxF+zgOkVERERERERE5Gu2zZxGxpi3gfwYk67ZjvVMstZuMsYMAN4yxiy11s7sYn0XABcAFBYWbscqRERERERERESktxhrbc9fbMwyYLK1drMxZhAww1q75zZecx1QZ639ZzeWXwas61CcC5T3sMrSt7Tvdk3ab7su7btdk/bbrkv7btek/bbr0r7bNWm/7bq073ZNXe23YdbavG29eIdGTwNeBs4Fbgj/f6njDMaYFMBjra0NPz4WuL47C4/1Bowxs5VMe9ekfbdr0n7bdWnf7Zq033Zd2ne7Ju23XZf23a5J+23XpX23a9rR/bajOY1uAI4xxqwAjgk/xxgz2BjzWniegcCHxpj/3979xthR1WEc/z7pCloIAmlQ7DZpNUX5EwSiBCWKtiZWJa1vTGqANGo0EkRoFGUl0fiOgFF4oSaE1iWxgWAt2kBEGjTyqq1YqFAr0hTTLq0WNYrRSK0+vphDetN7x3h3aeeMeT5vduY392ZP8uzMnnPunDs7ge3AQ7YfnuPvjYiIiIiIiIiI42hOdxrZ/iOwfET9APDBsr0XeOtcfk9ERERERERERJxYc73TqAt3dd2AmLVk10/Jrb+SXT8lt/5Kdv2U3Por2fVTcuuvZNdPc8ptTl+EHRERERERERER/5/6eKdRREREREREREQcZ72aNJK0QtIzkvZIurnr9sRokhZJ+qmk3ZJ2Sbqh1M+UtEXSs+XnGV23NYZJmifpCUkPlv3k1gOSTpe0UdKvQvrktQAABUdJREFUy7n3jmRXP0lry3XyaUn3Snp1cquTpPWSDkl6eqDWmpWkqdJfeUbS+7tpdUBrdreX6+UvJT0g6fSBY8muAqNyGzj2eUmWtGCgltwq0ZadpOtLPrsk3TZQT3YVaLlWXiRpq6QnJT0u6dKBY8mtArMZe4+bXW8mjSTNA74JfAA4D/iopPO6bVW0OAJ8zva5wGXAdSWrm4FHbS8FHi37UZ8bgN0D+8mtH+4EHrb9FpqHD+wm2VVN0kLgs8DbbF8AzANWk9xqNQ2sOKY2MqvyP281cH55z7dKPya6Mc1wdluAC2xfCPwGmIJkV5lphnND0iKapzbvG6glt7pMc0x2kt4LrAIutH0+8LVST3b1mGb4nLsN+Krti4Avl/3kVpexxt6zya43k0bApcAe23ttHwbuo7nwRGVsH7S9o2z/lWbwupAmr3vKy+4BPtxNC6ONpEngQ8DdA+XkVjlJpwHvBtYB2D5s+88kuz6YAF4jaQKYDxwguVXJ9mPAn44pt2W1CrjP9ku2nwP20PRjogOjsrP9iO0jZXcrMFm2k10lWs45gG8AXwAGv5g1uVWkJbtrgVttv1Rec6jUk10lWnIzcFrZfi1NPwWSWzVmMfYeO7s+TRotBPYP7M+UWlRM0mLgYmAb8DrbB6H54wbO6q5l0eIOmo7Yvwdqya1+bwReAL5TlhbeLekUkl3VbD9P80nrPuAg8Bfbj5Dc+qQtq/RZ+uXjwI/KdrKrmKSVwPO2dx5zKLnV7xzgXZK2SfqZpLeXerKr243A7ZL20/RZpko9uVXofxx7j51dnyaNNKKWR79VTNKpwPeBG22/2HV74r+TdCVwyPYvum5LjG0CuAT4tu2Lgb+RJU3VK2vLVwFLgDcAp0i6uttWxSskfZaekHQLza39G14ujXhZsquApPnALTRLZIYOj6glt7pMAGfQLJ+5Cbhfkkh2tbsWWGt7EbCWclc7ya06Y4y9x86uT5NGM8Cigf1Jjt4eF5WR9CqaP9oNtjeV8u8lnV2Onw0cant/dOJyYKWk39Is/1wm6bsktz6YAWZsbyv7G2kmkZJd3d4HPGf7Bdv/BDYB7yS59UlbVumz9ICkNcCVwFW2X+4wJ7t6vYlmkn1n6atMAjskvZ7k1gczwCY3ttPc1b6AZFe7NTT9E4DvcXQZU3KryJhj77Gz69Ok0c+BpZKWSDqJ5subNnfcphihfGqwDtht++sDhzbTXHgoP394otsW7WxP2Z60vZjm/PqJ7atJbtWz/Ttgv6Q3l9Jy4Fcku9rtAy6TNL9cN5fTrENPbv3RltVmYLWkkyUtAZYC2ztoX7SQtAL4IrDS9t8HDiW7Stl+yvZZtheXvsoMcEn5H5jc6vcDYBmApHOAk4A/kOxqdwC4omwvA54t28mtErMYe4+d3cQr2+Tjx/YRSZ8BfkzzhJn1tnd13KwY7XLgGuApSU+W2peAW2luRf0EzWDpIx21L8aT3PrhemBDmVTfC3yM5oOBZFcp29skbQR20CyPeQK4CziV5FYdSfcC7wEWSJoBvkLL9dH2Lkn300zeHgGus/2vThoebdlNAScDW5r+NlttfzrZ1WNUbrbXjXptcqtLyzm3Hliv5nHuh4E15Q6/ZFeJltw+CdxZHtjxD+BTkHOuMmONvWeTnY7ejRsREREREREREdHo0/K0iIiIiIiIiIg4QTJpFBERERERERERQzJpFBERERERERERQzJpFBERERERERERQzJpFBERERERERERQzJpFBERERERERERQzJpFBERERERERERQzJpFBERERERERERQ/4Dd8ql8SPM59YAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index 14\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index 15\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIEAAACMCAYAAADr57kMAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXCc933f8c93LxwLECcBkuB9grKsg6blU5FEKolkK1GOJrXTdlLbreLUTp1JO5O4ncnVaXM1mTaJY8cZa5K0jpx4EttqLDmxqcOXJIuHDssEb5EEL3CBxbmLPX/9YxcQSC5IQMTus3ie92uGQ+yzD7FfQQ9+z/N8nt9hzjkBAAAAAADA30JeFwAAAAAAAIDqIwQCAAAAAAAIAEIgAAAAAACAACAEAgAAAAAACABCIAAAAAAAgAAgBAIAAAAAAAiAiFcf3N3d7TZu3OjVxwMAAAAAAPjOgQMHEs65lZXeu2EIZGaPSnpI0pBz7tYK75uk/y3pfZJSkv6tc+7gjb7vxo0btX///hvtBgAAAAAAgAUys9PzvbeQ4WB/KemB67z/oKRt5T+PSPr0YooDAAAAAABA9d0wBHLOfVPSyHV2eVjSX7uS5yW1m9nqpSoQAAAAAAAAN28p5gTqk3R2zuvB8rYLS/C9feVTTx/X8yeHvS4DN+G+HT368Hs3eV0GsGzkC0V97bWL+vKh88rkC16XE1j/8u3r9NBta7wuAwAAAB5bihDIKmxzFXc0e0SlIWNav379Enz08vLot08pFDKt62jyuhS8CWeTaR0fmiQEAhZgMpPX3754Vo9++5TOjabV196k3hUNXpcVSOdG0/qNr7ymvf29aoqFvS4HAAAAHlqKEGhQ0ro5r9dKOl9pR+fcZyV9VpJ2795dMSjyq3yhqJFUVr9031b9yo/s8LocvAl/9sxx/f7XjmhiOqfWxqjX5QB1aWhiWp/71in9zffOaGI6r7dv7NCv/9gtun9nr8KhSs8MUG0HTo/opz/9nD7/wmn9u7s3e10OAAAAPLQUIdDjkj5uZl+Q9A5JY845hoJdZSSVlXNSdytPwperbT2tkqRjQ5Patb7D42qA+vSL//egDp1J6sG3rta/v3uz7ljX7nVJgfe2DZ1695Yu/fk3T+pfv3ODGqP0BgIAAAiqG04MbWaPSXpO0g4zGzSzj5jZR83so+VdnpB0UtJxSX8h6T9UrdplLDGRlSR1txACLVfbe1skSccvTXpcCVCfsvmiXj47qkd+aIs+9XO7CIDqyH/cu02XJzL6wvfOeF0KAAAAPHTDnkDOuQ/e4H0n6WNLVpFPJSYzkgiBlrO1Hc1qiIR0bGjC61KAunQyMal80Wnn6lavS8FV3rm5S3dt6tRnnj2pD75jvRoi9AYCAAAIohv2BMLSeCMEinlcCd6scMi0ZWWLjg3REwioZOBCKSDduXqFx5Wgkk/s3aaL49P64v5Br0sBAACARwiBamQ2BGJOoGVte2+LjjEcDKjo8MVxRcOmTd1xr0tBBe/e0qVd69v16WdOKJsvel0OAAAAPGCl0Vy1t3tjm9v/G+/15LO9cHpkShfHp3XXxk6ZWCFnuTo3mtbZZEpv39ipsPH/EZhr4OK4soWibutjLqB6NZrOauDihDZ3x9XT2uh1OQAAAKgC+/ATB5xzuyu9R0+gGskVnKKhEAHQMtcUK82jkc4WPK4EqD+pbEHNsaVYdBLV0tYUVTwW0bnRtIry5iEQAAAAvOPd1Xr3NulDX/Xs42vttz73gsbTOX3lQ8Hp/eRHo5cn9YE/fFZ/sPs2/czudV6XA9SN0VRWP/XbX9cn7+3X1nu2eF0O5mGShg5f0kf+ar/+4K20YwAAAL704fk7n9ATqEYSk1lWBvOB9Z3NikVCOs7k0MAVBi6WJoXuZ1Lourenv0dvWbNCf/bMCeULzA0EAAAQJIRANZKYzBAC+UAkHNLm7jgrhAFXGbgwLknauYrl4eudmekX7tmiU4kpHTo76nU5AAAAqCFCoBooFp1GprLqbmV5eD/Y1tuqY0MTXpcB1JWBixPqaI5qJSsgLgvbelokSUPjGY8rAQAAQC0RAtXAaDqnQtHRE8gntve06OxIWqls3utSgLoxcHFC/atWyFg1b1noipceSoyksh5XAgAAgFoiBKqBxGTpSSshkD9s6y09QT8xNOVxJUB9KBadjlyc0A6Ggi0bHTMh0CQhEAAAQJAQAtVAYoIQyE+29pRudBkSBpScGUkpnSto52pCoOUiGg5pRWNEI1MMBwMAAAgSQqAauFzuCbSSOYF8YUNXs6Jh09FLTA4NSHNWBlvFymDLSVdLg4an6AkEAAAQJIRANZAod7enJ5A/RMMhbe5u0XF6AgGSpIGL4zKTtvfSE2g56YzHNEIIBAAAECiEQDWQmMwoGja1NUW9LgVLZGtvC8vEA2UDFya0sSuupljY61KwCIRAAAAAwUMIVAOJiYy64g2smuMj23padGYkpelcwetSAM8duTShfiaFXna64jGGgwEAAAQMIVANJCYz6mY+IF/Z3tsq56Tj9AZCwKWyeb0+PMXKYMtQZzym5FRWzjmvSwEAAECNEALVQGIyy3xAPrOtp7RMPCEQgu7opUk5x6TQy1FnPKZ80Wk8nfe6FAAAANQIIVANJCYzhEA+s6ErrkjIWCYegXfk4rgksTz8MtTVUuqhOswy8QAAAIFBCFRlzjkN0xPId2KRkDZ2x1kmHoF3+MKEmmNhreto9roULFJnvHReYnJoAACA4CAEqrLxdF7ZQlHdLcwJ5Dfbe1sYDobAG7g4ru29rQqFmPh+uelsnukJRAgEAAAQFIRAVXZ5stTNfmUrPYH8ZmtPq04PT7FCGALLOacjFycYCrZMdZYfTtATCAAAIDgIgaosUQ6BGA7mP9t6WlR00qnElNelAJ4YmsgomcppRy8h0HLUFScEAgAACBpCoCojBPKv7eUb36OXmBwawXT4QmlS6P7VrAy2HDVGw2qOhTU8SQgEAAAQFIRAVZaYmAmBmBPIbzZ2NyscMuYFQmAduVgKQPtX0RNoueqMxzTC6mAAAACBQQhUZYnJrMIhU0czIZDfNETC2tDVrGOsEIaAGrg4oVUrGtVO+7ZsdcVjGknlvC4DAAAANUIIVGWJyYw64zFWzvGpbT0tOjrEcDAE0+EL4+pnUuhljZ5AAAAAwUIIVGWJyQzzAfnY9t5WnR5OKZNnhTAES65Q1InLk+pfxXxAy1lnvEEjzAkEAAAQGIRAVXZ5Mst8QD62tadFhaLT64mU16UANXXy8pRyBcd8QMtcV0tMw1NZOee8LgUAAAA1QAhUZYmJjFbSE8i3tvWwQhiCaeDizMpghEDLWWc8pky+qFSW3owAAABBQAhURc650nCwVkIgv9rUHZcknRmhJxCC5VRiSpK0sSvucSW4GZ3xUk/VkSmGhAEAAATBgkIgM3vAzI6Y2XEz+7UK799rZmNm9lL5z68vfanLz2Qmr0y+yHAwH2uKhdUVj2kwmfa6FKCmBpNp9a5oUGM07HUpuAld5RBomBAIAAAgECI32sHMwpI+JemHJQ1KetHMHnfO/eCqXb/lnHuoCjUuW4nyZJtMDO1vfR1NOjdKCIRgGUymtLaj2esycJPe6AnECmEAAABBsJCeQHdJOu6cO+mcy0r6gqSHq1uWPyQmSxfVhED+1tfepMEkw8EQLIPJtNZ1NHldBm5SV7x0fhpmhTAAAIBAWEgI1Cfp7JzXg+VtV3uXmb1sZk+a2VuWpLplLjFBCBQEfe1NOj+aZnUdBEa+UNSFsWl6AvlAZwtzAgEAAATJQkIgq7Dt6rvdg5I2OOdul/Qnkr5c8RuZPWJm+81s/+XLlxdX6TI02xOolTmB/Kyvo0nTuSJzaiAwLoxNq1B0WktPoGUvHgsrFgkRAgEAAATEQkKgQUnr5rxeK+n83B2cc+POucny109IippZ99XfyDn3Wefcbufc7pUrV95E2cvD5cmszKTOZkIgP5vpDXGOyaEREDMTodMTaPkzM3XFY4TYAAAAAbGQEOhFSdvMbJOZxSR9QNLjc3cws1VmZuWv7yp/3+GlLna5SUxm1NkcUyS8oEXYsEz1tZd6QzA5NIJiZg6sdZ30BPKDzniMnkAAAAABccPVwZxzeTP7uKR/khSW9Khz7jUz+2j5/c9I+heSftHM8pLSkj7gmCBFiYkM8wEFQF95SAyTQyMoBpNpmUmr2wiB/KCTnkAAAACBccMQSJod4vXEVds+M+frP5X0p0tb2vKXmMwwH1AAtDVF1doQYTgYAmMwmdaqFY2KRejl6Aed8ZheH57yugwAAADUAFfwVZSYzNITKCD6OpoYDobAOJtMMSm0j3TGYxphiXgAAIBAIASqosQkw8GCYm1H0+xkuYDfnUumtY5JoX2jKx7TVLag6VzB61IAAABQZYRAVZLK5pXKFgiBAqKvnZ5ACIZcoagLY2l6AvlIZ7x0nkqm6A0EAADgd4RAVZKYKF1Md7cwJ1AQ9HU0aWI6r7F0zutSgKq6ODatomN5eD/pjJfOU8MMCQMAAPA9QqAquTyZkSR1t9ITKAj62ks3xEwODb87O1JaBY+eQP7RVX5YwTLxAAAA/kcIVCWJcgi0kuFggTCzTDxDwuB3M3NfreukJ5BfzPQEIgQCAADwP0KgKpkJgZgTKBj62sshUDLlcSVAdQ0mUwqZtKqt0etSsES6ZoaDEQIBAAD4HiFQlczMCdTFnECB0N0SU0MkRE8g+N5gMq3VbU2Khjl9+MWKxqjCIdPIVMbrUgAAAFBlXMVXSWIyo/bmKDdKAWFm6mOZeATAYDI9O/wR/hAKmTqaYwwHAwAACAASiipJTGYYChYwLBOPIDibTGkdK4P5Tlc8xupgAAAAAUAIVCWlEIihYEGytqOJ1cHga9l8URfHp1kZzIc64/QEAgAACAJCoCpJTGbpCRQwfe1NGp7KKp0teF0KUBUXxtJyjuXh/aizhRAIAAAgCAiBqiQxwXCwoFlbHiLDkDD41cycV2sZDuY7XfEYq4MBAAAEACFQFUznCprI5LWylRAoSGYmyx1kmXj41NmR0rG9rpOeQH7TGY9pLJ1TrlD0uhQAAABUESFQFSQmS8vsMidQsPS1l26M6QkEvxpMphUOmVataPS6FCyxrnjpfJVM0RsIAADAzwiBqiBRXmGF4WDB0ruiUZGQMTk0fGswmdLqtkZFwpw6/KYzXjpfMS8QAACAv3ElXwWJiZmeQIRAQRIOmVa1NdITCL41mEwzKbRPdcSjkqQRlokHAADwNUKgKpgdDsacQIGztqNpdvJcwG9KIRCTQvtR10xPIIaDAQAA+BohUBUcH5pUJGTMCRRAfe3NDAeDL2XyBV2amNY6QiBf6izPCcRwMAAAAH8jBFpihaLTP75yQffuWKmGSNjrclBjfR1NujQxrWyeFXbgL+dHp+WcGA7mUx3NpeFgwwwHAwAA8DVCoCX2wslhXRyf1sN39HldCjywtr1JzkkXx6a9LgVYUoPJ0vLwhED+FAmH1N4cpScQAACAzxECLbEvv3ROLQ0R3b+z1+tS4IG+8g3y4GjK40qApTUz19XaToaD+VVnPEYIBAAA4HOEQEtoOlfQk69e1AO3rlJTjKFgQTTTS4LJoeE3g8mUIiHTqhWNXpeCKumKxzQ8lfG6DAAAAFQRIdAS2nd4SBOZvH7yToaCBdXqtiaZicmh4TtnR9Ja096kcMi8LgVVQk8gAAAA/yMEWkJfOnROPa0NeufmLq9LgUdikZB6Wht0bpQQCP4ymEwxH5DPdcYbCIEAAAB8jhBoiSSnsnr26JAevmMNT8oDrq+9iZ5A8J3BZJoQyOe64jElUzkVi87rUgAAAFAlhEBL5KuvXlCu4PQTDAULvL6OZnoCwVemcwUNTWS0roNJof2sMx5Toeg0ls55XQoAAACqhBBoiXz50Dlt62nRLatXeF0KPNbX3qTzo2kVeJoOn5gJNdd20hPIz7paYpKkYYaEAQAA+BYh0BI4O5LS/tNJ/cSdfTJjKFjQre1oUr7oNDQx7XUpwJKYXR6enkC+1hkvhUDMCwQAAOBfhEBL4CsvnZMkPXzHGo8rQT3oK8+bwrxA8IvBZEqSmBPI594IgVgmHgAAwK8WFAKZ2QNmdsTMjpvZr1V438zsj8vvv2Jmu5a+1PrknNOXDp3TXRs7eUoOSdLa9nIIxLxA8InBZFrRsKm3tdHrUlBFXfEGSQwHAwAA8LMbhkBmFpb0KUkPSrpF0gfN7JardntQ0rbyn0ckfXqJ66xbr50f14nLU0wIjVkzPYEG6QkEnxhMptXX3qQQKx/6Wkc8KkkamSQEAgAA8KuF9AS6S9Jx59xJ51xW0hckPXzVPg9L+mtX8rykdjNbvcS11qUvHTqnWDik9781EP+5WIDmWEQdzVFCIPjG2ZEUPR0DoCESVmtDhJ5AAAAAPhZZwD59ks7OeT0o6R0L2KdP0oX5vumZkZR+6bFDCyyzfn3z6GXdu2Ol2pqjXpeCOrLWx8vEn0pM6amBIb0yOKogLoC2akWD7tvRo90bOxWL+H9atULRaTCZ0v07e70uBTXQ2RJTMnXjEGhofFpPfv+iDp5JBrIdqMQktTZG1BmPqb05ps54VO3NMTVEQhpN5ZRMZZWcyipZ/npjV1x7d/boltUr5l1UwjmnwWRptckNXc3LdvGJoYlpPTNwWS++PqLGaFgd8Zg6mqOzP6tIyEo/n1Su/DPKajSVU74ODq6maEjv2tKle7b3zM6bhaVRLDq9em5M+waGdCoxdc37Jukta1ZoT3+Ptva0LOr4H5qY1jNHLuvQmdHZ77GmvfK8dpOZvL59LKHvnkhodVuT7t+5+M9brELR6fjQpCYzuWvei4XD2tbbosZouGqfL0kXxtLad3hIB04n6+J3bTna2NWs99+2Wjt6Wz1pnzP5gk5enlJfR5NWNM5/L5rOFvTdEwl98+hlZfLF2Ta4ozmmjuaYVrY2aMeq1qofc0GWmMzo9PC17Zxz0sR0/ppz4MR0XtX8rVxICFTpiL66poXsIzN7RKXhYmpavUWvnRtbwMfXt57WBn34vZu8LgN1pq+9SceGJrwuY0lk80W9+PqI9h0e0tNH3rhQ62tvUkMAQpC5nKR/+n5af/GtU2ptiOju7d26b0eP7t3Ro+6W2LK9QZvLOadTiSl953hC3zk+rOdODmssndOm7rjXpaEGOppj864OlpjM6MnvX9RXXzmvF06NyDlpTVsjF41lRec0Pp3XaCp73WCsORbWisao/uHgOf3R149qTVuj9uzs0d7+Xu3a0KFjlyZ08ExSB04ndfDMqC5PlCbq7ozHtGt9u+5c36Fd6zt0+7o2NccWchlXe845Hb4woX2HL+kbA0N6+eyopNJ/Q9E5jaVzctf5GbU2RNTWHFUs7P05JpnK6u/2Dypk0p3rO7Snv0f37ehR/6pWmckX7X4tpbJ5fef4sPYdvqR9A0O6PJFRyKT1nc0KXfWzzBaKevzl8/qdJwe0tqNJe/t7dF9/j965ueua64+ik75/bkxPDZSuVV4ZLN1jNMfCeux7ZyRJ/atatae/R3v6S4He00cu6+mBIb1wali5glNTNKx0rqDf+9qA1nc2a09/j+7f2au7Nt38Q5+xVE4HzyZ16HRSB84k9fLZMU1m8vPuHwuH9Ja+Fdq1vkNv21D6nV/VdnPz8s0N3fYdvqTXzo9LknpXNChep21JPSs6p6++cl5/8tRxbe1p0fvfulo/dvtqbe1prdpnXhqfLp0bysfRa+fGlS0UZSZtXdmiO9e36451HbpzfbvisYieOTqkpwaG9NyJYWXyRTXHwmppiCiZyipXuLIRjoZNb1nTpl3rO7RrQ7vetqFDq9tYEOTNmpjO6XunRvSd48P67omEBi4u7L4wZKVrsdbGyDVt4lIyd72zsCQze5ek33TO/Wj59SclyTn3O3P2+XNJzzjnHiu/PiLpXufcvD2Bdu/e7fbv33/z/wVAHfpv//gDff6F0/rBbz1ww3lULo1P6z9/8WVlcsUaVVc6cWXyRaVzBaWzBWXypb9zBaeiK/1x0hUX6bFISO/a3DV7AbWuM5jDg6YyeX37eEJPly80L41fuZJSqHxTEDIpHDI1RsNqiobVWP7TFA0pEqrOjU3BOU3nCkrnCprOFjSdLyqdLShkUlMsrIZIWE2xUj0NkVDFk8vZZEoXxqYllW7w3721W+/Z2qUHb13NzX4AfOQvX9TzJ4f1ljVtV2zP5At69dyYik7asjKuh25bo4duW61tvdW72F2uikWn8emckqmcRqayyuQLs09b25ujs79HM71jvnH4kr51LKF0rnDF91nf2Vy++WtXJByaveg/ebkUxJtJ0QohSch0TbvTGA2p6KRMuX1IZwuazhWULRQVC4fUFAtf8W+iYZNd9XzPqXTemG1jckVNZwvKFK49dznnZm8wbl/Xrr39PVf0eioUS0HQTO+ofNGVfkbxqNqbYnXVy3LujfPTA0N69QYPMGeaVZt9bVe91uzPNhYJqTEauuJnP1/bXM8KzpWOqfyV555ChXuMfKGoopNaGiK6Z/tK7d1ZepAyXy+r86NpPX1kSE8dHtJ3TiQ0fYNrJTPpznXtpbCuv3TMHR+a1FMDpZvh/aeTKsxJabf2tMwGe7s3digxmdG+w6WQ5DsnhpXNFxUOmcI3OSdeNl+qO2TSztWlcOfO9e3qbmm4Zt+pTF4vDY7q4OmkXhkcU6b8b2PhUOXH7gs083sZMmnX+g7t3dlbk15Pflbp4cjmlXHFY5E5bWWpvcxWaCsXxWn2e8QiId3W16a3bejQLWtW6MxwSofOjurQmaSSqSt7l23satae/l7t6e/R2zd1qCESlnNOk5m8RsvnqQtj03rpbOmYe3lwdPaYa4q+cd0401Y1RsMKVzhe8sVi6bxQbgdmzhOV2oH5hM1K56NISI2xN9rFSp9Xz1K5vA5fmFCh6NQQCWn3xg69e0u3blmzouJ/S0tjRB3NMXXOhD9LNAenmR1wzu2u+N4CQqCIpKOS9ko6J+lFST/nnHttzj7vl/RxSe9TaajYHzvn7rre9yUEgp/9/YFB/acvvqz/9/H36q1r266772e/eUL/44kBvXNz5zUX3dVi5ZuEuQ16UzSsaDikkEmhcoih8t+3rmnTu7d21e1TZ6845/Ta+XF990RCU5mCXDk8KwVppe7e0+ULgHSuOHvjVahSt+tQSFcFTqX/x86pdOOXKyiTK85elFRq/jtbYnrX5i69Z2u3Ni7j4Sd4c5549YL+z3Onr9lu5ZuGh273rtu7n03nCnr+5LBeHRzTjlWtunN9h1a2XntzKEnJqaxeOjuqlwdHK94QF9217U4mX5CZqSkauqKNiEVCys4JdtLlG/hcvvLNSsNV/74xGlIsEqp47trU3az7+nvU47NVBYfGS8OMzo+lZ9vQ2aa0vMFd+VKuvMW5K9/LFYpzQvuZcK52D4SWynznnnCFBx6xsOmuTV1vqnfNdK6g58q/J8UKJ7ANXc03HLY3ls7pW8cuazSV0z3bV173gdZMr6VDSzDstbUxojvXt+v2te2KNyz8WiqbL+rwhXEdOJ3U0ETmxv/gBrb1tOi+foY2VsPMMOlnj16Wc64cZoRnw4xIhXB9sVa2NpSCn9UrKv7+OOd0ejilQ2eTGk/ndfe2bm1e2bKoz8gVSsfcwdNJDSbT5bapOCfkLahYoZlaTDswn0I5SHrjmrX0d6XPq2eRsOm2tW16z5Zu7drQ4dlD1JsKgcrf4H2S/peksKRHnXP/3cw+KknOuc9Y6WrwTyU9ICkl6UPOuesmPIRA8LPhyYx2//dv6BN7t+mX799+3X1/9s+f08R0Xk9+4u4aVQcAAAAA8KvrhUALiqKdc09IeuKqbZ+Z87WT9LGbKRLwk66WBt25rl1PDQxdNwQaTWV14HRSv3jPlhpWBwAAAAAIovoZdA34zN6dvXplcExD49Pz7vPs0csqFJ327OypYWUAAAAAgCAiBAKqZE9/Kdh5+sjQvPs8NTCkrnhMt69tr1VZAAAAAICAIgQCqqR/VavWtDVq3+HKIVC+UNQzRy7r3h09N73qBAAAAAAAN0IIBFSJmWnPzh59+3hC01ct/StJB8+Maiyd016GggEAAAAAaoAQCKiivTt7lcoW9MKpkWve2zdwSdGw6e5t3R5UBgAAAAAIGkIgoIretblLTdGw9h2+dM17Tx0e0js2dam1MepBZQAAAACAoCEEAqqoMRrWe7Z2a9/hITnnZrefGU7p2NDk7OTRAAAAAABUGyEQUGV7d/bo3GhaRy9Nzm57auDS7HsAAAAAANQCIRBQZfftKAU9+wbeGBK2b2BIW1bGtaEr7lVZAAAAAICAIQQCqmxVW6Nu7Vuhp8pLxU9m8nrh5Ij27uz1uDIAAAAAQJAQAgE1sKe/VwfPJDUyldW3jyWULRSZDwgAAAAAUFOEQEAN3L+zR0UnPXt0SE8NXNKKxojetqHD67IAAAAAAAES8boAIAhuXdOmla0N+sYPhvTCqRHds6NH0TAZLAAAAACgdgiBgBoIhUx7dvToiwfOquikvQwFAwAAAADUGF0RgBrZUx4SFjLpnu0rvS4HAAAAABAw9AQCauS9W7sVC4d0+7o2dcRjXpcDAAAAAAgYQiCgRuINEf3uT79VG7qavS4FAAAAABBAhEBADf3UrrVelwAAAAAACCjmBAIAAAAAAAgAQiAAAAAAAIAAIAQCAAAAAAAIAHPOefPBZhOSjnjy4ViOuiUlvC4CywrHDBaD4wWLwfGCxeB4wWJwvGCxOGZQyQbn3MpKb3g5MfQR59xuDz8fy4iZ7ed4wWJwzGAxOF6wGBwvWAyOFywGxwsWi2MGi8VwMAAAAAAAgAAgBAIAAAAAAAgAL0Ogz3r42Vh+OF6wWBwzWAyOFywGxwsWg+MFi8HxgsXimMGieDYxNAAAAAAAAGqH4WAAAAAAAAAB4EkIZGYPmNkRMztuZr/mRQ2oX2a2zsyeNrPDZvaamX2ivP03zeycmb1U/vM+r2tFfTCz183s1fJxsb+8rdPMvm5mx8p/d3hdJ7xnZjvmtCEvmdm4mf0y7QvmMrNHzWzIzP58RQcAAASmSURBVL4/Z9u8bYqZfbJ8TXPEzH7Um6rhlXmOlz8wswEze8XMvmRm7eXtG80sPaet+Yx3lcML8xwv856DaF+CbZ7j5W/nHCuvm9lL5e20L1iQmg8HM7OwpKOSfljSoKQXJX3QOfeDmhaCumVmqyWtds4dNLNWSQck/YSkn5U06Zz7n54WiLpjZq9L2u2cS8zZ9vuSRpxzv1sOmzucc7/qVY2oP+Xz0TlJ75D0IdG+oMzMfkjSpKS/ds7dWt5WsU0xs1skPSbpLklrJH1D0nbnXMGj8lFj8xwvPyLpKedc3sx+T5LKx8tGSf84sx+CZ57j5TdV4RxE+4JKx8tV7/+hpDHn3G/TvmChvOgJdJek4865k865rKQvSHrYgzpQp5xzF5xzB8tfT0g6LKnP26qwDD0s6a/KX/+VSkEiMNdeSSecc6e9LgT1xTn3TUkjV22er015WNIXnHMZ59wpScdVutZBQFQ6Xpxz/+ycy5dfPi9pbc0LQ12ap32ZD+1LwF3veDEzU+kh+WM1LQrLnhchUJ+ks3NeD4obfMyjnGjfKemF8qaPl7tWP8rwHszhJP2zmR0ws0fK23qdcxekUrAoqcez6lCvPqArL5xoX3A987UpXNfgRj4s6ck5rzeZ2SEze9bM7vaqKNSdSucg2hdcz92SLjnnjs3ZRvuCG/IiBLIK21iiDNcwsxZJfy/pl51z45I+LWmLpDskXZD0hx6Wh/ryHufcLkkPSvpYuessMC8zi0n6cUlfLG+ifcGbxXUN5mVm/1VSXtLny5suSFrvnLtT0q9I+hszW+FVfagb852DaF9wPR/UlQ+zaF+wIF6EQIOS1s15vVbSeQ/qQB0zs6hKAdDnnXP/IEnOuUvOuYJzrijpL0R3WJQ5586X/x6S9CWVjo1L5fmlZuaZGvKuQtShByUddM5dkmhfsCDztSlc16AiM/t5SQ9J+leuPAlneVjPcPnrA5JOSNruXZWoB9c5B9G+oCIzi0j6KUl/O7ON9gUL5UUI9KKkbWa2qfwk9gOSHvegDtSp8vjWz0k67Jz7oznbV8/Z7Sclff/qf4vgMbN4eQJxmVlc0o+odGw8Lunny7v9vKSveFMh6tQVT89oX7AA87Upj0v6gJk1mNkmSdskfc+D+lBHzOwBSb8q6cedc6k521eWJ6WXmW1W6Xg56U2VqBfXOQfRvmA+90sacM4NzmygfcFCRWr9geVVEj4u6Z8khSU96px7rdZ1oK69R9K/kfTqzJKHkv6LpA+a2R0qdYN9XdIveFMe6kyvpC+VskNFJP2Nc+5rZvaipL8zs49IOiPpZzysEXXEzJpVWqFybhvy+7QvmGFmj0m6V1K3mQ1K+g1Jv6sKbYpz7jUz+ztJP1Bp2M/HWLknWOY5Xj4pqUHS18vnp+edcx+V9EOSftvM8pIKkj7qnFvoJMHwgXmOl3srnYNoX1DpeHHOfU7Xzmso0b5ggWq+RDwAAAAAAABqz4vhYAAAAAAAAKgxQiAAAAAAAIAAIAQCAAAAAAAIAEIgAAAAAACAACAEAgAAAAAACABCIAAAAAAAgAAgBAIAAAAAAAgAQiAAAAAAAIAA+P830VzTJkI4FwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIUAAACMCAYAAADiDBl2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXTU1f3/8eedmewrkEDYUUQUcEdc0Eqtu22t+rVi+6taW7Vq69LW3Spo3evSurW0WuteW6lbXWpFVLSKbCIgILLJEshC9kxmu78/7mQyk5lAAoEk5vU4h8PMnTufuZM7cz+f+567GGstIiIiIiIiIiLSu3i6ugAiIiIiIiIiIrLrKSgkIiIiIiIiItILKSgkIiIiIiIiItILKSgkIiIiIiIiItILKSgkIiIiIiIiItILKSgkIiIiIiIiItIL+brqhYuKiuyIESO66uVFRERERERERL525s6dW26tLW5P3i4LCo0YMYI5c+Z01cuLiIiIiIiIiHztGGPWtDevpo+JiIiIiIiIiPRCCgqJiIiIiIiIiPRCCgqJiIiIiIiIiPRCCgqJiIiIiIiIiPRCCgqJiIiIiIiIiPRCCgqJiIiIiIiIiPRCCgqJiIiIiIiIiPRC2wwKGWMeM8ZsNsYsauPxScaYamPMgui/Gzu/mCIiIiIiIiIi0pl87cjzOPAg8MRW8rxvrf12p5RIRERERERERER2um2OFLLWvgdU7oKyiIiIiIiIiIjILtJZawodZoz51BjzujFmbCcdU0REREREREREdpL2TB/blnnAcGttnTHmJOBFYFSqjMaYC4ALAIYNG9YJLy0iIiIiIiIiIttjh0cKWWtrrLV10duvAWnGmKI28k6z1o631o4vLi7e0ZcWEREREREREZHttMMjhYwxJcAma601xkzABZoqdrhku8KIEbBmTVeXQmTXGD4cVq/u6lKIiIiIiIhIN7HNoJAx5llgElBkjFkH3ASkAVhr/wj8H3CRMSYENAKTrbV2p5W4M61ZAz2kqFtlzNfnfaTS1e/t6/73FRERERERkV5pm0Eha+1Z23j8QdyW9SIiIiIiIiIi0kN01u5jIiIiIiIiIiLSgygoJCIiIiIiIiLSCykoJLtGqAEq53V1KUREREREREQkSkEh2W7hMFRWtjPz+/8HbxwEa57fqWUSERERERERkfZRUEi225lnQr9+8L//bSNj9eew+V13e8HVO71cIiIiIiIiIrJtCgrJdlm8GF57zd2+/PJtZC79LxDd0r1x484sloiIiIiIiIi0k4JCsl1efx0iEXd7/vxtZN74JoQb3W1Pxk4tl4iIiIiIiIi0j4JCsl1efx2amtztrKytZLQWyj9suR+q3anlEhEREREREZH2UVBIOsxamD275X5Dw1YyN6yDsD/+2TurWCIiIiIiIiLSAQoKSYctX+4CQ81Coa1krl0OnvSdXiYRERERERER6RgFhaTDli4Fr7edmevXgN1a1EhEREREREREuoKCQtJha9a0rCe0TXWrIbS1+WUiIiIiIiIi0hUUFJIOW768A0GhmqW0ex2hAQPalyYiIiIiIiIiO0xBIemwZctabvt828hcv8r9v+cvYHIAcke2nbe0NHGxImtdmoiIiIiIiIh0OgWFpMO++sr9/9vfuhFDw4dvJbN/s/t/35sBD4y5amcXT0RERERERETaQUEh6bDyckhLg1/+EiIRuOKKlsf63NmHQfcMakkIVELenmB84PFCyXG7vsAiIiIiIiIikmRbk39EElgLVVUwfjwEApCVBccf3/J4lb+KKqrcnUjQLTJdPJHYukJZA3d5mUVEREREREQk2TZHChljHjPGbDbGLGrjcWOM+YMxZoUxZqEx5sDOL6Z0F1VVbjv6I46AjAyXtvvubWT2l4E3A4qPgLQ8lxZu3CXlFBEREREREZGta8/0sceBE7by+InAqOi/C4BHdrxY0l2Vlrpg0FFHQWamS2tsK87TVA6eNMgf3ZJmvDu9jCIiIiIiIiKybdsMCllr3wMqt5LlFOAJ63wEFBpjNEfoa6q8HDweGBm3iZgxbWQO1QEGsoe1pPmyd2bxRERERERERKSdOmOh6cHAV3H310XT5Guors79PyhuLenmEUNJQvXRDMUtaRopJCIiIiIiItItdEZQKNU4EZsyozEXGGPmGGPmlJWVdcJLy65WX+/WFMrLa0lLT28jc6gOvFkKBImIiIiIiIh0Q50RFFoHDI27PwTYkCqjtXaatXa8tXZ8cXFxqizSzdXXQ79+4Pe3I3OoHjKKINy008slIiIiIiIiIh3TGUGhl4Gzo7uQHQpUW2s3dsJxpRuqq4OiIgiF2pE5VA8Z/cC2J7OIiIiIiIiI7Eq+bWUwxjwLTAKKjDHrgJuANABr7R+B14CTgBVAA/DjnVVY6Xr19S4oZFNOEGwlVA9phTu9TCIiIiIiIiLScdsMCllrz9rG4xa4pNNKJN1aXZ1bT8iTYoxZIByI3bbWYkL14M0g9bJTIiIiIiIiItKVOmP6mPQiW7ZATo5bbLq1ukBd7HZTuAmCNeDL0ULTIiIiIiIiIt2QgkLSITU1LijkSzHGrLapNvF2sEpBIREREREREZFuSkEh6ZCaGsjNTR0Uih8pVBeoaxkp5NnmLEURERERERER2cUUFJIOqa6G/PzU08dqA7WJt4M14MsFT9ouLKGIiIiIiIiItIeCQtIhdXVQUJD6sfjpY3WBOgjVafcxERERERERkW5KQSHpkMZGKGwjzhM/fay2qRYiIUjP30UlExEREREREZGOUFBIOiQScVvSpxI/fcwFiCLgayOziIiIiIiIiHQpBYWkQ6x1u4+lkjBSKFALNtK56wk1VUCwdtv5RERERERERGSbFBSSDolEwNPGpyZpS3ps521HXzoD/jUEXhoOtSs655giIiIiIiIivZiCQtIh1oIxqR+raaqJ3a4L1LmRQqYTPmI2Av87ByJ+CFTB3Mt3/JgiIjvg5pk38/zi57u6GCIiIiIiO8TX1QWQnmVrI4UqGytjt6v8VS6Y0xlxx9L/QrAqesdC6ds7fkwR6XFGjIA1a7q6FM1uBODMLi6FJBs+HFav7upSiIiIiPQMCgpJh2wtKLTFvyXxtrfVsKLpJeDfBHjgB+H2v+gXf3Lb24tIr7ZmjRut2B2YqYZ0bzpNNzR1dVGklbZGs4qIiIhIMk0fk05T7a+O3a7yVwEmOlooyr8peiNCh5R/kHg/4t+u8omIdKZAONDVRRARERER2SEKCkmHeDxutFAq1U0tQaFqf7VbT2hHf9b3l0NgizvW6MtguCZriMjO4Znq4bgnj+vqYoiIiIiI7DKaPiYdsrWgUEVjRex2dVM0KNTRUUGtVS0EbxaUHAP73eaOuWXBjh1TRCQFi+XT0k+3na+7zGETEREREdlBGikkHWJM24N/tjS2rCnkFp32gO3A2kGpVC+GcBPsewv4sgEvjLtxx44pItKGpvC21wiqDdTugpKIiIiIiOx87QoKGWNOMMYsM8asMMZck+LxScaYamPMgug/9dq/pjweCLcR53HrCDlb/NEpX5EdXHOjcj5k9IOcEe6+Nw0Gf3fHjiki0oaGYMM281Q0VKRMt9YSjuxgIFxEREREZBfaZlDIGOMFHgJOBMYAZxljxqTI+r61dv/ov5s7uZzSTRgD9fWpHwtGgmR4M4DmRacNBGt27AUb1kLRITseXBIR2YrmRaODkeA285Y3lMduR+IW0391+av4bvFpepmIiIiI9BjtGSk0AVhhrV1prQ0AzwGn7NxiSXfl9ULNVuI8BZkFZPoyXcfKk+4Wid4RTZuhcH/w5bak7eiUNBGRVsrqy9qdNz4oFL/rops2m7jovoiIiIhId9aeoNBg4Ku4++uiaa0dZoz51BjzujFmbKeUTrqd7GyoTtHfaZ4ykeZJI8uX5RLT8iBY3eYiRG+seIMXP39x6y/YVAn9DgaPtyXNl7M9RRcRadPm+s3JiSUlbnhk/L+SkoSgUPzt5mOU1pXu9PKKiIiIiHSG9gSFTIq01r38ecBwa+1+wANAyp6+MeYCY8wcY8ycsrL2/yor3UdeXuqg0Kb6TQBsrNsY+5U85M2GUD20MR3jxKdP5NTnT936CwarIbtVDNKjTfNEpHOlDApt2pQyLX6nxfjbm+qi7WDtxk4vn4iIiIjIztCeoNA6YGjc/SHAhvgM1toaa21d9PZrQJoxpqj1gay106y1462144uLi3eg2NJV8vLc9LHWi003d4IiNhJbY6ORNBcUsqHte7FIGEINbqFpEZHOUrMMXh4Fz+fBmueAxKBQfaCNhdOimoM/kDhSaEOdOzVurFNQSERERER6hvYEhT4BRhljdjPGpAOTgZfjMxhjSowxJnp7QvS4qbdnkW7rv1/+FzM11cCwFvn5UFcHwVaDf1L9yl6DNxoUikaQMgd0rECBLeBJg7SCjj1PRKQtkSC8+12o+xJCdfDReRAJJbRhKUcNxVlfuz52Oz4o9FWNm2mtkUIiIiIi0lNsMyhkrQ0BPwfeBD4HnrfWLjbG/MwY87Notv8DFhljPgX+AEy22n6lx1lRuQJIXDi1tcJCt/tY65FC8R2jZrVhINQIzbvznNbBdTaC1eDNBG9Wx54nItKWVU9Aw3pis6DDTeDxsaG2ZQDstoJC8UGf+LZv1ZZVAKytXtt55RURERER2YnaM1IIa+1r1to9rbUjrbW3RtP+aK39Y/T2g9basdba/ay1h1prP9yZhZado7lTtLUOTUFB6qBQ/LoazarDIQg3krwEFQlbNjcGG1O/mA25UULajl5EttOpz53KPxb/oyXhiz9CuB76HACDv01z+9Q8yge2HRRaW9PSRsYvKt08gmhJ2ZJOKLmIiIiIyM7XrqCQ9A5f1bpO0daCQrm5bqHpSCQxvbKhMilvdSgU3ZI+eUpa/K/r8VMxEtgwGF/LSCMRkQ56cdmL3PjOje5OsAaqFkKf/eHYWTDxORhzNQCrqlbFnhMLCg1IMeV1wAA21LSMKoofYdTs8/LPO+8NiIiIiIjsRAoKSczKypUArKle02aenBwoL3c7M8fb4t+SlLcy2ARNFSl3C4sPBK2rWZf6xZqDQilGGomIbEvziMTaQK1L2DzLTUk97En3vy8HxrmA0eqq1bHnxYJCpaUQPxPaWigtpS5YR5bPTWttHikUirQsqN9moFtEREREpJtRUEhillcuB1rWxUglN9cFhdLSEtOr/FVJebeEAhAod52vVuIDQetrOtCBml4Czxh4xtv+54hIr1TWUAbEBXlqPoeM/pA7Ekzz6c+NRCxvKMdrXLsSP5WsteZA08DcgQBsqt+U8Br5Gfmd+h5ERERERHYmBYUkpvkX73kb57WZJycHKishPT0xPRB26/5keDPI8GYAUB8xbqefUPKaQfGBoDZHChkv2CAJ08/8zVtBa0qZiGzdyi1u9GMwEt0usWYZ9P9Gy46IAL6cpEBPm20SUNNUA0BhViHQ0pY1Lz5dlFUEpFgrLVgLcaOJRERERES6AwWFBEhc+Hl+6fw28+XkuBkUNTUtaU1NsFfRXgBcefiV/GLCLwAYULCby+BP3nUsfopac8ctifG6TpTRqCAR6biktqVmGRTuA2m5Ccl1gToABuUNAmBjXdtbyjevFzR/o2snq5uqE57TL7sfELcAdSQI738f/tkX/lEIm97ZgXckIiIiItK5FBQSACob3ULR6d70lOsDNcuN9qXWxf2Q7ve3rCm0e5/dGVE4AoCqcNgtEl2fvEbRisoVsdtfbvky9Yt50iBUlXJNIhGRbfmysqVt2dK4xbVF+Xsn5Wse7dMc4Il/Xmufl7mgkI1b6ywUCcVGCg3IcYtTxwJLsybDhlfdborhepj57ZaDhQPgL09ct0hEREREZBdSUEiAlpE7zR2aYDgYe8x7s5ch9w4BoH9/tx39ihWJz29eUyg7LZvstGwA1gWCbjv5qkVJ25XFr1u0rGJZ6kKl94FwE4Qatv+NiUiv9dnmz2K3V25ZCcEtkLtbUr731r4HwPIKt67a1gLjqXZnXFO1JrYLWUleCRCdTrZlAWx8HbKHwMS/w9jrIRydVrb+NXihH7w4GP5zmHZZFBEREZEuoaCQAC0dnZJc16GJ3z0nYiOx+yUlEAjAzJnQEI3VZGW1BIWy0rLISnO78mxo8rupE2XvQ6g24fW+qPwCAK/xtr1+R1qBmz4WrG7fmygpcduitf5XUtK+54vI18rcjXNjt1duWenak1ZTx8AFdSB59E8qqXYWW1G5gje/fBOA6UumAzBr7SxY+nvI6AfHfwxDT4ex18LBD0Hp2zDrDAjVucB55fy4ha9FRERERHYdXYUK0NIpGpo/NOF+68VS8/LcTIf334dQtM+0dClU+13gJn6kUGVTFaTlQ9kHEF18ull1UzXpnnTyMvKAloWqExiP2zK6qaIlLXNA229i06aOpYvI19rKLStjO4qtqlrlFpg2ydNRU+021tYujJvqktuTNVVrYmsNVfrdVNyP138Mpf+Bva8CbzZ4vK49G3EOfHIRpBfCCfPgTD+Mu2G736OIiIiIyI5QUEgA+GT9JwBUNLoAzOLNiwFYtHlRLE9lYyXGQGEhLFwIHg8Eg/Dqq1AbcCOBsnxZZPncSKHaplrI6OsWmm7cENt5Z0M0mBSIBGIjjD4t/TR1wdILoSGuw3Za8qLVMQPaCBi1lS4iX1vNgeZR/UYB0TbNeBN3HpteAs8YNi5/Mun5y8pTT2ttbiOzfFmkedIAt35QQyBxmmtFzVrwb4bhkxOD4lvmQuNG+OabUDjOPbbXFdv9PkVEREREdoSCQgLA61++DsAHaz8A4IWlLwCJ29M377ZTXOyWCLruOqiogN//vmX3nvjpYzVNNZAZnbr18fluGhmwoCn59RduWpi6YOn9oPxjNw1tW0pL3TCm+EVbrXXpItKrNI/0aQ5Sz904140SCtW1ZPK7UT+l0ThRpi8zcWRRCoPzBgNw2SGXcdKokwAYkj+kZdv7qEGRLZA1yE2DjbdlPvQ7FHKGu8X0IeWUNhERERGRXUFBIQGio3qAkHXDeJq3cv5w3YexPM3rcwwb5u4/8AAMHAibN0N9sB5InD5WF6iDvD1c5k0z4O2jAViUIii0tHxp6oJl9oeqBVpsWkQ65IXPXWC7ebTjkrIlkF4AdauT8pZEZ5RdOuFSDh96OAD9c/qnPG7zSKFjRx7LhMETACivL4+tR2QwAOTjh9yREG7VdpW+DcUTwZu5/W9ORERERKSTKCgkAEm/cpfXlwPw35X/jaW9v9aN9Nlrr+TnNwRdxyd++lhDsAHy93JTNuKsir5UuiedjOi0iubdz5LkjnAjhdSBEpEO+GyT23msuW2zWMLZQ6Hm85ZM0TXKtkQ3/jpj7BlMHDoRgPKG8pTHLWsoA6Ago4CCDDcKqLn9ykvPY8qkKQBkeXzgSU988vQSWP8yFB/WMkpIRERERKQLKSgkCYtJp0c7MYFwgEAowIbaDbGOz4xVMwDYYw/IbBWj8Yf8GExspJDBuKBQznC3yGqcAdEY0VnjzuK8A85zaTltrPvT5wA33WPLAnc/nGKYkYj0GtZaPFM9XD/j+q3mSzX6sMzbB6oWtUwhi65RVh6dPtYnsw/9svsBsKk+9QL1WxrddvX5GfnkZ+QDsLp6NeCmkd141I2ke9OpDQWwET9ERw4Bselq+PJa0qLrGvFMYvBcRERERGRXUFBIYlvCjywcyaZfu05LIBLglWWvAG4R6eYgT2ldKcOHQ0bCZmKWplATHuOJrSlkjMEf8kP2sKStltdEF5o+ZuQxnLjHiUBLpypJwVj3i/rC30CoEeK2jG4vvx9uvRVGjoSCAhg1Cu66C5oUXxLpceZsmIPFcu//7t1qvqaQ+4IPyx9GTloOAOXefrD5PVqf+ppHChVmFlKYWQjA2uq1KY9b3eR2WizILKAg0wXMm7epL8ouco9lFLApDLZmOURHTiYIVrfcbg4UEdnq+xERERER2RkUFJJY52dg3kAKswrpk9kHgJeXvwxAxEZi62W8+PmLjBnjdh2LSWvEYzyEbZgsXxbZadl4jIdAOIDN3xvCidvarwy7aRNF2UWxTlRbHTAK93XBoNK34MMfwIzjOvTegkE49FD48kv45BOoqoKPPoILLmgd2BKRnqA5GOQP+dlQu6HNfP6wH4AZ58zg3P3PBWCDyQf/xoQdDSMW6qLxmILMglj7t75mfdIxrbWxRfXjp49VNLh1hprXISrMLGRxAEzTZmiqbDlAdLoam2dBdHc0EREREZGupKDQLhaKhNjt97sxbe60ri5KTPN6GIPz3a46fbP6Ai2BmmH5w2KdndL6UnbbDdLilsNIy6nDYzx4jRevx0uWL4twJIzX46XBkwkZcQu2Gh/rM9xK1cXZxRTnFLvj1rWxQ1h6AWRFdzBb92JsBzMuBoxJ/FdSkvT0J5+EoUPdoth9+7ps/fpBYWGH/0wi0gkC4QD+oH+7n//c4udii9k/NPuhlHmstbGA0cC8gQwvGA7ALL+BsB/+d45bvD5UT2XEjT/M8Gbg8/hiI4VK65PbpOqmagwGn8dHhi+DgswCDIYafw0AJbmuDeqb1Re/Bb+vD6x6yr0mxKarseltiESDQpltTJ0VEREREdkF2hUUMsacYIxZZoxZYYy5JsXjxhjzh+jjC40xB3Z+Ub8ernv7OlZXrebCVy+M/brcJYI10FgKTRWsju401txxGpDrOimrq1YD8Pcz/s49x90DuHU6jIHDD285VEZeLcYY0rwuUuT1ePEYDx7joTZQCwMmtWT2ZbO5fjMGQ3FOMcXZxRgMlY2VWNvG1LD+R5GwLgckTUlry3vvwYEHQlaKGRwismuFIiGyfptF1m1ZrKhc0XbGkpLkoK9paQP8IRdkuX3W7YQj4aSnVzZW0hRuItOXSXZaNoPyBgEwt+JLyN8bKj6Gd46Dj3/C5pA7EeakuylmfbL64DGelO1zRUMFxpjYYvoFGQV4PV4aQ240ZHNQqDjbBbtXZ4+BpfdAsBYiIQjVRw/0MdQscWukndZGQFxEREREZBfwbSuDMcYLPAQcC6wDPjHGvGytXRKX7URgVPTfIcAj0f97hbpAHb/78Hd8e89vM37Q+DbzTZszjbs/vBuP8RCxEcY9PI4Nv7OYTSkWNB0wAEo7ubMQaoB5V0JaHgw60W33HgmwdM0bALGO0+A8N2JoXa1ba2hU31GxbZZnr58NwIknwjvvuPV6/JE6PBDbSQwgzZvWMtWi5Bg3yidURyDUQH0wgjGGouwisnxZeKIBnorGith0sgSjLoav/gXhaIfKkwlbolPSmjuKbQSUDjjATRdraIDc3MTHAgFYvx7qo4fNyYHBgyE9Pfk4IrLjjn/yeCLRtXNGPTCKNZevYVjBsA4fJ8uXhT/kJ2zDvLXyLU7Y7WhoXAfBOsCysuwLPJjYqMeBeQMxGBeIGn8ZzL8Syj4AYHM0ppSX7hZ/LswsxGu8VPmrkl63eUey5gBS80ihoA1iMLH2qzk49E7GPuxd9wm8cRCMvQ6qFrYc7J0T4Yjn3GL6XyMVFfDpp1BTA5EIeDyQnQ377Qd5fRuoaKhgaMHQri5m12oOENqwWzPPl5sQ9OxKTU3uvG6t21Ci9aYSItJD1a6AitnRDVts9MdVA3mjoN8E8GyzSyidqaQEWvf/dkbfT6Sd2tMCTABWWGtXAhhjngNOAeKDQqcAT1g31OMjY0yhMWagtXZjp5e4G4nYCBf/+2L+NPdPAEx9dyr9svqx6pRbyDNA/miwblXl2mATl7/x89jzwE1PaAzlk53y6MmC4SAPzX6IafOmUR+sZ2zxWG78xo0c2t4Cb5oBW+bC8R+1pE0v4ctNm/DQMkKoecRQOBImOy2bftn9MMbgMR6+qvmKplATJ52UwdVXu+vYfQ+u5TNrE4JC6d50/CE/tU21MPB4d/ELbMgeR5rncyI2EpsCkpueS0OwgXU161IHhYoOhZyhULMUjA+Gntbed8z558O998Kdd8INN0AoBF4vjB/v0k4+OTF/W4tP/3PJP5m+ZDr1wXoOHHggPz3wp0RshL8u+CsLNi4gNyOXU/c6le+O/i5eT/fdRejOWXfy7up38Xq8HDfyOM4/4DwyPbhOSvwi3sYDJi15kdwdPYl99FPoNx76T3KDv5pfcs1z7jX3uTGWdckSqK119RWJrvni8bg67NMHRo+OO275x27tlrRcsBHAEgj6mDvPR1ZhP8I5o7DWfV49HmhshP33d53VZvWBeuZsmMPyiuXkZeRxQMkBvPL4nmzebPjJTxLjj7NnwxtvwN/+Bj5dR7XLA7MfYMbqGQlpxz15HIsvXpz8nYn/PEX/8J9vXgL9ITctl+prq3lo9kNc+salDJr9I+B22OOnsaesXL8UjIkFZwblDcLn8bl1gkb+BD6/G+pXA7DZpoGJxKaN9cnsgzGGpnATgXCAdG9LlLg5KJSb7iLMeel5hCIhDAZjEoNQAHPrG2HoGfDVP+GTi1reU3ofN6Usfo20jGLwl8fOGdE3D8brPtfeTuyd+8tg4+tuIwDbvMC1gd89Dvc8kZz/qKPg3XcT0266CaZMSUj6+99h2jR4++3ErBUNFRz66KEJo8P+/J0/85MDfoJJEQypaqxiTfUaappqGJw/mCF5Q0j3dUK0fsoUmDp1m+8D2DkX7CsehfUvwZH/clOjm9kwsOvOG9ZCuNUAu5NPhtNOgwsvTFxvz+/vnoGhJUtg/nwYMsS9F2td2+73Q3k5/N//ufvNfL+dgve37ax72WnKy2HyZLj6ahgzpiU9GITf/AaOOw5+9COXFgrBI4/AsGHuR71w2J0O0r1+1iyv4IADLfuMjV+g3wseb8uSA1uToi1YwzBePP0pxl10ZOx3RmNcOZYuhXPPdZuVdJrVz7lRpHm7u3bf4spf/5V74d3P3a7DBsNBHpz9INPmTaMh0MDY/mO5b9/jGb3+SThhjssUCbpzi/FQW7eRdRVfUOWvYmDeQAblDupQe7twoStuJNLy+2zztdqwYVCU4rI+3pIl8O9/w0EHuec0f5cDAffYxRe7H217qnkb5nH9jOtZuGkhmb5MzjvgPK6ceCU74/j7XNIAAB8qSURBVPfniI3w2vLXeHLhk1Q0VLBX0V5cMP4C9n1kevK5D1K3ganOfQYYMgC+/IKkBzy+5OuT9p4/rQVs3HVI3HGNZ7t/LPnyS3jwQTj++MTzV2MjvPkmXHop7L57x49rrRtkEAq19EvAFdPnc30KTzsmsjQGG9lUt4maQA39s/tTlFOEz+MjGA5S01SDz+MjJz0H3y4O1Lbn1QYDX8XdX0fyKKBUeQYDHQoKzbz/GiYdWgaHPpr4wDMGfpA4EuTn957KQ7UvJh9kik0aNPLhs3/n8Fcvg2dSbzEc79P/zGS/urPgtMSim6nJH8whDSWsy3Yf8AE5A6htqqWisYINr97P6B8+BCVHu4wLp/D2u3fSGA5y2t6n8cL3X2Duhrkc+uiheO/xwykLoXCfhF7njOuP5o/fh/79XQe4sRGeys9ik225kltbvZbFq19nTYr38eatl/GvFTcwfmIxe+zhOtaVZcey4JnZ3FR0BRQfDpklEAkQbMrFmHpG93O97P1L9o8exXLQwIMAt0bG4LzB3JC1noxPr2bkQfdzzjnw5z/Ddb/K5/tvB9m9b8s3bLfC3fjs+e9x1+IDePZZYPRlsORO7D43EV5wKnsWtVwN7F28N/t9ls7+iy6HkpmJf3cD1hqY+By8dSRk9OPjdSdzyCuj4TvLEt90is9JduMnzJ9yBld/uJqhQ900ssZG+ObI51i16kw2bjSxP/u6dfCrH73Lu3+6H9L7QnqhO2EDZ/zjjNgxX17+MlNnTMG2uoZ/cuGTTEz3stBm8NH5nzCmeAwX//ti/jLvL3z75WeZfv90yN0dMoshVM9hZ3yHJ6Y+zqhhVe6XGuOD2hU892yAyReNhz77uK2rI0F+fdFKfv2jGZTsPR7y9nAn86YKuPxUmJ5Yjt+OuZZzbq5k6P4TIG9P12A3uW20r3m7Zfbnq1+8SviF57n8/8bBhEdc4vQStxvSCyQdd+ZJ32BSIHn0hNlUmrQn3A2P/IxbN/8pKe+6okEMnnwhFOzlEhZO4ZGXnuLiyJfR17+pJfMUS3U15Oe3JK2Yu5g9frcvvJB4Aql7NIfc0z6CwnGx465443lOvXdJ0jmoILuaGe8XJASEQpEQube3GkoGnPzq83xz8hmJASh/OaPnlfCjp0MJeffbfTnX3b4nZ57Z6iApPpez7/42E1YH4OG3WhI9wJMk5X39tis58ZgamJD490zVJu0x53IePzbMxG/2c22KJxOayjFPnpOU9/ivTmbacX0ZNul8F6QwXrfOzU/3T6r7WfsdxhF3RhIDym2UYZ/yAzlg1R/57o8PZsQI18H0++HS1y8FYMGFC9ij7x4c/ujhLFxWw5ghK1j299+4Ka3p+RCohdI34HvrIXtQ7Ljz184H9uasfc7CYzx8Z/R3+PVbv2bmW6czdsw6vA3rAQOf34N3zr1ELBw86GDAbRWf6cuk/p4FvLZ/Bicd9TLMOB4CFeTs+TPCG/7APv33AdxW87npubwYGkL66iddECkqJz2HcCTEmGLXfqV50xiYN5C86lq+8NQxqu8oAMYWjwXgse89yqPhMHgzYOVjkFbAL95YAlkDeODGD+G9U1wwc9CJsOHfkBl39bxwCuf+83H+5l3Dzyf8nPP2P4+nFj7FvR/dS/97S9k043aoWw3ZQ8CGef/tSo5c8iE8tS6hPi459gEeuv1L6Htw9O9pmfPau4wf/BYc90HstVg0FQ6EhN4QsPTDeey1diLMtImR0WcM1J0LuSNir7X3buUURlbz0kvjGTXKXSA1NcFezyX3Cs5/5XzOf+V8AAblDqIuWEdNUw19jGFLipGfdiFJn8sZV0zi6AtOgb0uT8rf+mJy7jUHctC558KUlvdRXmYZMgT8UxKfOuvuczgiVJd8yBRt3cz7r2HSojfh0QWJeVsdE+CHpcfx19MzSAvVgDcHFt0Mi2/FtL7OBg6t24OPcl0QLSctJzYyLpUjq/blvW+UwamJC68/cdHZnH35ITD4JJqnYC+dv5H9jjks6QeQ3C0v0NR0GqGQiV3s1m2poe/FBUl/97smX8UVV2aSNvLMltEG4SZ4fb+k9uuDm49h4g8mJwRtATjdJB33lfNP5js/PxD2vTkhPVU78623/syEb/yUH/4wMd1dMySmvXfPRXzjexlwS+Jn2Ew1SR2l31Qfxc1V5fDXxYkHOY2k8r539BF8Y/BX8GTiVViquh+/6rtkrXyJ995r9UCKv8PSsaPY6+489/2M72w9Y+BMv2tPojYt+pABa86HkxPLm+pvtq/P8Om4YXDK6oT06r8UUvC9N6Eo7tK+5gv47xFwWuJ18xOXXcrZ52bAAXdv8/UOIJf5tPoeVQ+meMGX7LdfBv3jlpv84O4f8GTuBjj7XTjbpfnJ4VLqkupz5r3XcfYR9S3nxOb2C5I+fzMf+R2TZv8FHm91vfg0xH4pinr/3qd57Y0juOxbrd7IM4bjz18H2YNjSfNe+y8HBn4M3/sqIeuRe73P+397wgXcc0cCEd55vYwrpl3BgsQmgtUvXcOIs56A/t+IvY/Kj37P60vO4ocXjoSN/3GjCMONRC4+Bs+/Ep8fMeC9iST9jKEi7o+2tmYtC1a9zp8bz+LkkdOg30Hu2nLp/ez1xmMss8m/hqZqb2f/ejwTzpsMe/8qIX2//ZK/c+//7icc+cVSmPZh4gMpvkev73sFn+5zL1de2aoQpxtOng5c1ZL08F4/44VBjyT98JDqe/TyHt/mKu8rLF267byfjRrHPrdvhNPLE9K/uHcUo344DQZ8M5b21eerGHrD7knHSPXeVhemc9DliZtK3PDODVy24nbSl7wLfQ9q+Qw2bOTZ627krGV/cJvs+HIhEuCM0xp4+NoXKB6xuxtsYLxsrlzCgOlXUZBRwJ3H3smGmg3c/N7NjCGLJbRs7vP26rd5aM5D2D1J/LxbyzG/Hcrb4alJbaBNseTj++dM5MhLDnQzTSDWV1i0YV/Gnf2A+wxHAzszH76DScFWfQUPlN5kKan6zF2bRs164lGOGPQ3OPb9hOyp2pPxtXswJy952YHHN57NOb+c4OrIuI7Z8lllfPjhEdx3X2Lei499mAduW4HXNxHKBwOGzSuWMeMf/2PyT0dDn3Hgy4GQnzNOKeOpe94lY9DBkLMbAHVlm8nf54ykz/uK+0ezxxn3Qe5JLYnBOvhHXlKbNOqWTFZE2rf99ZvmQI4781wY/YvEB1L0KwBYeCMfvPklE698ul3Hb820uY5LcwZjzgCOt9b+NHr/R8AEa+0v4vL8G7jdWjsrev9t4Cpr7dxWx7oAuABg2LBhB61Zk3giDTYF+f1xhfz6vYaE9FuOTOM3842LbACcFKDheMsXr/ajanYZDWmQFYJBtXDHkGP4ft5R5I7sD5GIi/Jby+nDr2do/hDeuuVzsj1hsh+x8EPg4EHQt8h9WfbbRHjfMu57IoNfrypw11CT6mBSPeunF/OPdWW8PxyCHtizAn48DwYO7kufhZWxFW+avHD7YT6mzAq553sB4wZiVFxyMUUPPhzLG/BC4TWZ9E8vpk9mYaxsH15yNNe+8Qoz38/CWhfICASgproGc9sU+j/gPuURA/5cyK4F/nMHFAwELFT8i71+cgd/enY0Rx3lLvCal+SYckQmUz6Ifhi9QATqfT78F15Avwcfjv3NG33gH9OH/M+24I1+REIeCPvgDxMNV77jEiMYPFi2/OIi8h56BF+kJa8fH/celsaNHzRP9XLF23LpJeQ9+FAsb9hAo8/D7lf1YXD+oIQ6mvJIGlNmBROeHzaGAdcVJtVn7pJsBmQMID8jNyH9zj/D1TPdjzBB0kgjyG2T4PpoWiAar/ftEyBy64GknfCOez1Puvs1JT2fJi9khOPK64WmsX0pXFgZ+/s0eeGWIz3cOilC/zrYuwze3Q2+lw3/GHcYvuPfdY3mS8PBv4lIxMDRb+Lpf5hr/AH+0cddeJy8qOULsHAKkc+mYo7+D2bgse4Yn02FRTdTuCifofmDeOdW11D+8+6+XJBbhufI52D4990v0AunwuJb4IeuXpr/7sFoHd1/uI/fzA6A1wP3hKAA8hfnMjh7IO/fsYqiuhAN+Ya0BzwMXl6YVEc3/ymNK/+X6b6f0fakwefhtQsn8FjFm2zKgbwAnP0plGVE69PgQtIRCFhYecmPqX3hrzR5ID0CfRvh+f3g2pmuzsJ4MVgwEQZdk83wwmGtPifR75wH98+4Y995JFw50xAgHYvBYJl6eAFnL90DX0lR9JgGayF9zxBDXnotoT5JgwcO9/DLGZYQPiJ4SPMGeOlsL6eNOB2y89x7zptHKGchdz+ew2X/S4y1P3V8LRdExkBWjss7+iuaRm5i5KoiirOLEt7Hi2/7+N7up0KfEvce0j8ikDaf/84r4aQ+0QvHvguh3yK+fLGY50rLWFTssu63CS47CjJ+8jhm92gQKHriXvlCGvf4g3wSjbEcUAq3ZRn6/fJcOPSx2OeMRVPJW5LDoKyBZKdlxcqW/qBh1qJ+TBr9o+ivQrPA+yGrXx7AHXWbmLGba4/GlsHYf1/E0mMeZnqri6O6a64m4+67SIt+/iIG/EPA97uBpB8/wwUsrIVX9iR7fg0l6QMoyMyPlSHzIYv3R5ZIbDKra0P9kUz+MNHLDbPqY+0tYSi75GL6PfQwHtuSt9Fm8ofDvfxmVn1Cm1L+i4vp+2BL3qAHGtPSGXNNv6Q62jR9EEXTN8Q+J0EP1Kb5MGP60mf+5tj7bfTBnYekM+WDQMJrBUjjjom+pHZxysQ0pnwUBG90OJu1fHkHjKqKYOOuj3KADYM85H/vAygc6zrl1hKaPopBnwWTvp8YH5wVt13kwimEF97Cb/+Yzk0f+lv+ZhZyr05uQzMfshQtKUj6zj3wrJdfNA2FwSNcQzpyFYxcE2tvI7jvXRpBGi+/mPQHHiQ93FL3DT648fRM7tur5Qo0MwizHktn90F9KZxb6qrSQGMaDPtVAUPyBzPj1uWAa+t+nLWFBRvGccjg46M/L88C7weYH1rG3b53Qrv446wtSd85e18WR9/4AFdddRzD9s6JjlqyNDU0ccac/RmQ2z/hPV923zjOqxuDtyA3VnUBazjx+JcZmFuSkPeLl0t4prSUBQNcxn03wXmf+Hh8/zRu+qDRtVNeIARLLjuXi6se53+D3THHlsHvXzPceaKPVwe31N2YzfDvj/L5qKmGRcUQ9sKIKjhhueG5/dK5elbihWbFQ9DvtP9CybdidW8/m8pt09L41f8ysHFr8917eE3snBgkDYshjQBF1ybX/dpSGHba0zDiB7Hjsmgq9z+RzuWbS9xPpodWwqFVNAXTmb9xHw4dEP2RzPsB+D6kz+J8huYNSajP87IqWRc+jN33vdD9IcqnQ8V05r3an3v9m1nUH7wWJq2Gqz6GJw40/PIdE2ubvYS56xsRrpyVhvX6Ym1+wHjZ6+rMpPpc+HJ/bg9tZu5A93IT1sOUGV4mXto3qT7zF+cyMLuED+5YHTsnpj9oGLQs+bpl7qvFTC4qY0U/95aL6uGup8fx1IAHuek3Y8kp8MWiV0fNGJzyO9eYOZac416CrP6w6Db4/A5u/aOP699P/DEiMhgqfjuC4hOehZyBsOw+WP57Nr59EPevncvLo915f2Ql/GYeZE8u5IBJN0NuEZS/AOUv0BjI4E9/y+DymTUJDc2cX+YyftIUyB8AFf+CiukEQ17MqJ/gO/he951bfBssuZ3Frw7kzVUbWVkIaRE4sBQmrvXx3yOzeT2rhroMd43+o09hznC4ZiaE8RAkDS9hwj7D7tf2Taqj2//cfB3gi10HWOCuiR5u/NgPnujF7X0Rbn8mjWtnBRP+PkGvl8HXJF+3NJ/n4uuz+Xrxqpkt1x1ewrzy4winj/427B5dLjX8DuHQu9wzLYOr3o/rQWcAjwGTA8RGUEwvYdEXRZz/1NPc/8Aoigb4Yu3tkxfkJPUV7DfB3Him+yE07love0lyXyHrYctnr5Tw+aJSNmdDZhj2qIA9K9LJ2bMPhfNcQC9iwO+DuyZkuOv/5tcLQ3VGGoGfnh/rm4SjeYdcmc+QvEFJbehDf83gl+8mBvrumARXzTQESSOCB4Ml7DWMuq4gqT4LFucxKLsk4doy+xHLXX8x/PodYsfwEqbouoyk75zvAR+3/qWYny93u4Q2f8d3/+nqpOsWe18WVz5yCD/L2htrW/JOPOpxBmaUkJuRE8ub8RAUL8lPauv+/Z6Hkw8/C8ad7M61Zf8gsvmFlOfE7CWZKa9bNr04iAHTN8SuL5q80OTNYN/r+yfUZ/YjFoqPhGOjkeOFN8KiW1ws5+RPXaAIYHoJkcZN/OAjw9+LEvvw059NY1J2n9i1iMWdPwf9Ormv8P2MSh7/MI9/hbdQmw4D6uHCOfDj0/IYkjuId2/7sqVtzq7krr/4uGF2wF2fRPsKZdU+iv/vXTfQAGDhFIILfsvQFclt6OIVhrGnPAjDjnHf2eV/ILTsYe74czo3zI0OA/xOCL4TYfbrJXxzWCkN0eFUxsKzfwfP0Dz+WlzLxlzICcLkRXDO+ZB32sduCmS0DCyamvK7nP500AX+Mvq5/tFnU7Gf3YIZMRkmPuvatM9ugkW3EAqD77S1bqZK3HFvn+bhV+96ifha+hVN+R7eOK0vZ9YOcl/k0Wth9DoefzGNc7MOgYxocH/4l1QPWkfglf4U/Wt9wjVO3Zg+FCzaQkbY1ZvfCwFfGn89JMV37oh0rpmVvIOtf/IAMp9N/CXcGDPXWtv22jbxedsRFDoMmGKtPT56/1oAa+3tcXn+BMy01j4bvb8MmLS16WPjx4+3c+bMaU8Zd55UPyl1A48/DtOnw/PPJw97S7lgcor3sXq1O0ZTE+TluSyNjfCznyWvrSNRC66HYDUc+Dv361zzr08/pN2fE3/QT9ZtiZU0dcwx3JhbCcfMdCf5V/aEpmjn8dC/wbDTEy6u8GTBEc+7NScMgHGjgsJ+iPghLd+lhRthjwvd1JJ4TZWw/jVoKgNvGrGo5N6Xd8vPu3Si8tmuU9D/KOg7Ht45AQIVgAd+kGKUQdgPdSshUO1OkMbnpvft4JDV8vKW6X/NQenjjkuxXtfcXwIW9r/D/frdPFINUv4K0k2b7J1qddVqdvv9brH7a855hWHzL4bvrSa24H5zW+XNgTNb/TJf+jZsmglpBW70I9a1J3te0vKrXxcKRUI8+9mzHDTwIMb0H7PtJ7TD1+lzEgwHeW/Nexwy5JDYtMUOiYTddyrcABjwZkHWwB1fwyjsd9Ncwg3uvObNgvw9ae8mECJfO9bCrO+7kRB7Xgzp/eBfA6PntDbOwa1FgrDuJTcK1JPmzsU2DLufl3ytJ52rI9OLdwZrYcs82LLQfQ4wrg9QOd/1TQad5D5bbx8du66bcdhbfOsJF/Tf+KuNsSnzXxd1gTrCkTAFmduYtxlqgIZ1cee57Oisilbnufqv3DVRqC42qohI0J0TG9ZH15jwuQvXooNh41vue5hW4I4bqnHr3Pag72JnB4V8wHLgW8B64BPgB9baxXF5TgZ+DpyEm1r2B2vthK0dV0Ghtlnr2qHPPnNzqwcPdot2Pv+8m66VpJu+jx4nsAXePg5GnuN+AfXlu8BMRmGH/r6z18/mkL+4YdjD8oex+vLVmOolsPpp1xB5s9xJPljnGvgt89x6IuAa/gPu2jmdNX1Oeg8bcZ/dSMCdHFuvDdVdrHsZPv8dTHrNjcx7adhWL6B760e4pqmGKTOncMORN9A3q4/reOSOhHHXuQsWPOAvhZzhXV3UbqG3fk5EpBtoqnQ7TDZVRhdB6gcDj1XAVHZM/AYFvpzYNNLmfnyq9flEOjUoFD3gScD9uAGHj1lrbzXG/AzAWvtH4z6JDwInAA3Aj621W434dIug0IgR0GoKm0iS4cPd0KsOGPfwOBaXLWbpJUsZXTR620/YFdRTku7oi2nwxcMuEJs9FBo3wt6/TJlVTba0x3Y02SIiIiJfK50eFNoZukVQ6OtCPSVpD/WUpLuKBKFmuRspl5YPBWN3fHqLiIiIiEgv1ZGgkDZT/jpQR19EejJPmls0WUREREREdilNcBURERERERER6YUUFBIRERERERER6YUUFBIRERERERER6YUUFBIRERERERER6YUUFBIRERERERER6YUUFBIRERERERER6YUUFBIRERERERER6YUUFBIRERERERER6YUUFBIRERERERER6YUUFBIRERERERER6YUUFBIRERERERER6YUUFBIRERERERER6YUUFBIRERERERER6YWMtbZrXtiYMmBNioeKgPJdXBzZcaq3nkt11zOp3nou1V3PpHrruVR3PZPqredS3fVMqreeK1XdDbfWFrfnyV0WFGqLMWaOtXZ8V5dDOkb11nOp7nom1VvPpbrrmVRvPZfqrmdSvfVcqrueSfXWc+1o3Wn6mIiIiIiIiIhIL6SgkIiIiIiIiIhIL9Qdg0LTuroAsl1Ubz2X6q5nUr31XKq7nkn11nOp7nom1VvPpbrrmVRvPdcO1V23W1NIRERERERERER2vu44UkhERERERERERHaybhMUMsacYIxZZoxZYYy5pqvLI20zxgw1xrxjjPncGLPYGHNZNL2vMeYtY8wX0f/7dHVZJZkxxmuMmW+MeTV6X/XWAxhjCo0x/zTGLI1+9w5T3XV/xpgrou3kImPMs8aYTNVb92SMecwYs9kYsygurc26MsZcG71mWWaMOb5rSi1t1Nvd0bZyoTHmX8aYwrjHVG/dRKq6i3vs18YYa4wpiktT3XUDbdWbMeYX0bpZbIy5Ky5d9dZNtNFe7m+M+cgYs8AYM8cYMyHuMdVdN7A9fe+O1l23CAoZY7zAQ8CJwBjgLGPMmK4tlWxFCPiVtXZv4FDgkmh9XQO8ba0dBbwdvS/dz2XA53H3VW89w++BN6y1ewH74epQddeNGWMGA5cC46214wAvMBnVW3f1OHBCq7SUdRU9500Gxkaf83D0WkZ2vcdJrre3gHHW2n2B5cC1oHrrhh4nue4wxgwFjgXWxqWp7rqPx2lVb8aYbwKnAPtaa8cCv4umq966l8dJ/s7dBUy11u4P3Bi9r7rrXjrU996euusWQSFgArDCWrvSWhsAnsM1LNINWWs3WmvnRW/X4jqng3F19rdotr8B3+uaEkpbjDFDgJOBv8Qlq966OWNMPvAN4FEAa23AWluF6q4n8AFZxhgfkA1sQPXWLVlr3wMqWyW3VVenAM9Za5ustauAFbhrGdnFUtWbtfY/1tpQ9O5HwJDobdVbN9LGdw7gPuAqIH7hU9VdN9FGvV0E3GGtbYrm2RxNV711I23UnQXyo7cLcNcpoLrrNraj793huusuQaHBwFdx99dF06SbM8aMAA4APgYGWGs3gvvwAv27rmTShvtxF1qRuDTVW/e3O1AG/DU69e8vxpgcVHfdmrV2Pe7X0rXARqDaWvsfVG89SVt1peuWnuM84PXobdVbN2eM+S6w3lr7aauHVHfd257AkcaYj40x7xpjDo6mq966v8uBu40xX+GuWa6NpqvuuqF29r07XHfdJShkUqRpW7RuzhiTC7wAXG6trenq8sjWGWO+DWy21s7t6rJIh/mAA4FHrLUHAPVoylG3F53bfQqwGzAIyDHG/L+uLZV0El239ADGmOtxw+6fbk5KkU311k0YY7KB63FTWJIeTpGmuus+fEAf3NSWK4HnjTEG1VtPcBFwhbV2KHAF0VHpqO66nQ70vTtcd90lKLQOGBp3fwgtQ9ekGzLGpOE+lE9ba6dHkzcZYwZGHx8IbG7r+dIlJgLfNcasxk3RPNoY8xSqt55gHbDOWvtx9P4/cUEi1V33dgywylpbZq0NAtOBw1G99SRt1ZWuW7o5Y8w5wLeBH1prmy+GVW/d20hcEP3T6LXKEGCeMaYE1V13tw6Ybp3ZuBHpRajeeoJzcNcnAP+gZZqR6q4b6WDfu8N1112CQp8Ao4wxuxlj0nELI73cxWWSNkQj/48Cn1tr74176GVcw0L0/5d2ddmkbdbaa621Q6y1I3DfsRnW2v+H6q3bs9aWAl8ZY0ZHk74FLEF1192tBQ41xmRH281v4eaBq956jrbq6mVgsjEmwxizGzAKmN0F5ZMUjDEnAFcD37XWNsQ9pHrrxqy1n1lr+1trR0SvVdYBB0bPgaq77u1F4GgAY8yeQDpQjuqtJ9gAHBW9fTTwRfS26q6b2I6+d4frzte5Rd4+1tqQMebnwJu43Vkes9Yu7uJiSdsmAj8CPjPGLIimXQfcgRsu+hNcZ+iMLiqfdIzqrWf4BfB0NHC+EvgxLrCvuuumrLUfG2P+CczDTWGZD0wDclG9dTvGmGeBSUCRMWYdcBNttI/W2sXGmOdxwdkQcIm1NtwlBe/l2qi3a4EM4C13Lc1H1tqfqd66l1R1Z619NFVe1V330cZ37jHgMeO2Og8A50RH6KneupE26u584PfRDTH8wAWg71w306G+9/bUnWkZUSsiIiIiIiIiIr1Fd5k+JiIiIiIiIiIiu5CCQiIiIiIiIiIivZCCQiIiIiIiIiIivZCCQiIiIiIiIiIivZCCQiIiIiIiIiIivZCCQiIiIiIiIiIivZCCQiIiIiIiIiIivZCCQiIiIiIiIiIivdD/B0s//A2cRL0RAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index 16\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index 17\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIkAAACMCAYAAAD4MPn4AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXRkZ3nn8d9Te0kqSW2pF0m9qE23l7aNbWgMGGIMGGMbBgMZ5piZYRzIpG2CM2EykxMImYThzDljyDJkEsAxxMFmEgwzicGJbQwOGEMCxN22oVd3t93qRZJ7l0pLlVTLO39UlVotVUkqVbVuqer7OUdHpVtX975uX92SfvW8z2vOOQEAAAAAAKCx+bweAAAAAAAAALxHSAQAAAAAAABCIgAAAAAAABASAQAAAAAAQIREAAAAAAAAECERAAAAAAAAJAW8HsBcOjs7XW9vr9fDAAAAAAAAqBs7duw45ZxbOXN7VUIiM3tA0rslnXDOXVnkeZP0p5JukzQu6Vecc8/Nd9ze3l5t3769GkMEAAAAAACAJDM7XGx7taabfVXSLXM8f6ukzfmPbZK+VKXzAgAAAAAAoAqqEhI5556RdGaOXW6X9JDL+amkdjPrqsa5AQAAAAAAULml6knUI+notK+P5bcNLtH54aF0Jqvnjgzph/tPaGd/XM45r4d0wfh9prUrourtaNaGjmZt7GzS2hVNigT9Xg8Ny8T39x3XV//5cF3/nCy1lbGwPvfLr1bAz1oNAAAAwFyWKiSyItuK/gVkZtuUm5Km9evXX8gx4QI6OTKhH+w7oaf3n9CPDpzSSDItv8902ZqYwoH6/UNtMpPVc4fPKp5MT20zk7rbourtbMoFRx3N2tDRpItXtmjTqhYPR4ta88P9J3XX13ZoVSyi1a1hr4dTF86MTepHB07pP990idZd1OT1cAAAAICatlQh0TFJ66Z9vVbSQLEdnXP3S7pfkrZu3cpb6cvQ8XhSN/3JDzWSTGtNa0S3XdmlGy9dqes3daotGvR6eBecc05D4ykdOj2mw6fH1HdqXH2nx9R3elyP/WJQw4nU1L4fesMGfeb2K5Tr7Y5Gtr3vjO762nZtWhXTw9ve0BA/K0vhO7te0d3/Z4fiydT8OwMAAAANbqlCokcl3WNmD0t6vaRh5xxTzerU//refiVTGf3tR6/Xa9a3N1wAYmZa0RzSiuaQXrN+xaznh8Yn1Xd6XI88d0wP/iTXUJ6gqLHt6h/Wh//qWXW3RfW1X72OgKiKYpHcy9zotOo+AAAAAMVVJSQys69LulFSp5kdk/QHkoKS5Jy7T9Ljkm6TdFDSuKQPV+O8qD37j4/om9uP6leu36jXbpgdkEBqbwrpmqaQrl7bplDApy//6JDMpP/+HoKiRnTwxKjufOBfFIsE9LX/+Hp1tjDNrJoKIdEIIREAAAAwL6vl5qhbe9vc9j94s9fDQBn2vRLXyERa16xrV9BXv72HqsXJ6cjpcQ3Gk1rdGlFvR5OsaAsv1KOJdEa7B3LN3Ld0tylKg/OqS6Qy+vmxIW1a2UIABwAAAOTZRx7f4ZzbOnP7Uk03QwMYTqY0lEhp3YomAqIFMpnWd+Sa6Q7GkzJJGwiKGkLGOe0dHFHGOW3paiUgukD8vtzPUjpb/TdEjpwZV3tTUK0RpgcCAACgPtR2SNS5WfrwY16PAguQzTp96Iv/pJPRCf3gnhsl/uBdMJO03jk99Nhe/eWPD+nXLt+oT71ri9fDwgX298/36+P7X9Bfffh1ar50ldfDqVvZVEZ3/Lfv6Ldffak+9tZN1Ttu1uktn3pcd76xV59+zxVVOy4AAACwJD5SvDCBcg9UxWM7B/WLY8P6LzdfqggBUdnMTL/3rsv1y69Zqy//6JDGJuifUu/+7vl+rV0R1Vs2r/R6KHUtHPAp6DeNVvlnanQyLefEqmkAAACoK4REqNhEOqPPPblPl62J6X3X9ng9nGXLzPS2y3IVJX2nxzweDS6kEyNJ/fjASb33mh75fEwtvJDMTLFIUCNVDnMKjbBpiA0AAIB6QkiEiv31T4/o6JmEPnnb5VP9P7A4vZ25/kR9p8Y9HgkupEdfGFDWSe8lVF0SLeGARqsc5sQTqfM+AwAAAPWAkAgVGU6k9GffP6A3b+rUDZs7vR7Ostfb0SyJSqJ698jz/Xr12jZtWtXi9VAaQiwSqHrFD5VEAAAAqEeERKjIl55+SWfHU/rErZfJjCqiSjWHA1oZC6vvFCFRvdp/fES7B+JMzVxCLeGARqrck2iqkoieRAAAAKgjhERYtL5TY3rgx4f0/mt7dGVPm9fDqRsbO5qpJKpjjzzfL7/P9K+u7vZ6KA0j15OoypVEE7lwiEoiAAAA1BNCIiza/3hsr4J+0+/cepnXQ6krvZ1NOkRPorqUzTp9+/l+3bC5U50tYa+H0zBikYBGJ6pb8RNPFKabpeScq+qxAQAAAK8QEmFRntl/Uk/tPa573rZZq1sjXg+nrvR2NuvU6ETVl+yG93526IwGhpM0rF5iF6YnUS50yjppbDJT1WMDAAAAXiEkQtlSmaw+8w971NvRpI+8udfr4dSdqebV9CWqO996vl/NIb9u3rLG66E0lMLqZtWs+JkeOo3QlwgAAAB1gpAIZXvoJ4d18MSofu9dWxQO+L0eTt1hhbP6lExl9PjOQd1yZZeiIX5ullIsElQ665RMZat2zOkNqwtTzwAAAIDljpAIZTk9OqHPP7VfN1yyUm+/fJXXw6lLvZ1NkqTDp+lLVE+e2ntcIxNpvf81TDVbai2RgKRzzaarIU4lEQAAAOoQIRHK8kfffVGJyYx+/91bWPL+AmkKBbQqFtYhppvVlW8936/VrWG94eIOr4fScFoLIVEV+xLFEyn5fbl7YJyQCAAAAHWCkAgLtqt/WA8/e1R3Xt+rTatavB5OXevtbKYnUR05PTqhp188qfde0zMVLGDptIRzIdFoFUOikWRaXW2RqccAAABAPSAkwoI45/TpR3froqaQ/tPbN3s9nLq3saOZnkR15LGdg0pnnd7HVDNPxCJBSVWuJEqm1NMezT1OUEkEAACA+lCVkMjMbjGzF83soJl9osjzN5rZsJm9kP/4/WqcF0tnx+Gz2n74rH7r5kvUFg16PZy619vZrFOjk/Q6qRNP7HxFl66O6bI1rV4PpSFNVRJVsSfRSDKtnhX5kIhKIgAAANSJikMiM/NL+oKkWyVtkfRBM9tSZNcfOeeuyX98ptLzYmm9cHRIkvTOK1i6eyn0dtC8ul5ks047+4f1uo0rvB5Kw4rlexJVM8yJJ1Ja2RJWyO+jJxEAAADqRjUqia6TdNA597JzblLSw5Jur8JxUUN29g+rqy2izpaw10NpCL2dzZJE8+o60Hd6TKMTaV3V0+b1UBpWrMqNqyfSGU2ks4pFAopFAvQkAgAAQN2oRkjUI+notK+P5bfN9EYz+7mZPWFmV1ThvFhCO/uHdSV/5C6Z3o5cSETz6uVvZ/+wJPHz46FqN64uhEKt0aBao0F6EgEAAKBuVCMkKrZUj5vx9XOSNjjnrpb0Z5K+VfJgZtvMbLuZbT958mQVhodKjU6kdejUGJUQSyga8mtNa0R9TDdb9nb1DysU8OmS1TGvh9KwAn6fmkL+qvX4KoREVBIBAACg3lQjJDomad20r9dKGpi+g3Mu7pwbzT9+XFLQzDqLHcw5d79zbqtzbuvKlSurMDxUanf/sJwTIdES29DRxApndWBn/7AuXxNT0M9ikl5qCQc0OlGdMKdQOdQaCao1EqTBPAAAAOpGNf5qeVbSZjPbaGYhSXdIenT6Dma2xsws//i6/HlPV+HcWAKF6TJX9LAy01La2NnMdLNlLpt12t0fZ6pZDahmxc+5SqKgYpEAq5sBAACgbgQqPYBzLm1m90h6UpJf0gPOud1mdnf++fsk/WtJHzWztKSEpDucczOnpKFG7R6Ia3VrWKtiEa+H0lB6O5t1emxS8WRKrZGg18PBIhw5M64RmlbXhJZIUCNVqiQqVA61RgNUEgEAAKCuVBwSSVNTyB6fse2+aY//XNKfV+NcWHo7+4f5I9cDvR1NkqTDp8Z11Vr+/ZcjmlbXjtZIoGphTmHJ+6lKogSVRAAAAKgPNMnAnMYm0nrp5Ch/5HqgtzO3wtkh+hItW7v6hxXy07S6FrSEA9Vf3SwSUGs0qEQqo1QmW5VjAwAAAF4iJMKc9gzGaVrtkQ0X5UIi+hItXzv7h3VZV0yhALdar1WzJ1E8kZKZ1BzKrW4miRXOAAAAUBf4ywVz2nksN12GkGjpRUN+dbVFCImWKeecdvUPU4VXI1rCweqtbpZMKxYOyOezqX5h9CUCAABAPSAkwpx29Q9rVSysVa00rfbCho4m9THdbFk6cmZc8WRaV3YTEtWCWCSg0Ym0MtnK10yIJ1OK5cOhQiURfYkAAABQDwiJMCeaVntrY2ez+k6Pez0MLEKhaTU/P7WhEOaMTVYe5owk02qN5kKiwmcqiQAAAFAPCIlQ0vgkTau91tvRrDNjkxpO8AfocrOzf1hBv+mSNS1eDwVSVXsHxROpqeNNVRIREgEAAKAOEBKhpD0DcWUdy3d7aUNHrnn1YaacLTu7++O6dE1M4YDf66FAuZ5EkqqywtlIMq3WfDhU6EkUp3E1AAAA6gAhEUpiuoz3NnbmQqJDNK9eVpxzTNWsMecqiSqv+IknU1Ph0LnG1YREAAAAWP4IiVDSrv64OlvCWt0a9nooDWtDR5Mkqe8UfYmWk2NnExpOpKjCqyEtVZxuNpJMT4VOLVONq5luBgAAgOWPkAgl7eof1lU9rTIzr4fSsCJBv7rbIqxwtsxQhVd7CtPDRiYqC4mccxpJpqYaVvt9ppZwgEoiAAAA1AVCIhSVmMzowIkR/sitARs6mgmJlplC0+pL18S8HgryYpHqrEI2NplR1p2bvpY7doDG1QAAAKgLhEQoas8gTatrRW9ns/roSbSs7Oof1iWraVpdS1rCuVCn0sbVhZCp0Iuo8LgavY4AAAAArxESoahdhekyawmJvLaxs0lnx1MaHueP0OWAptW1qSnkl88q70kUT+S+PzYtJIpFAlPbAQAAgOWMkAhF7ewfVmdLSGtaI14PpeH1duRXOGPK2bJw7GxCQ+MpXUFIVFPMcr2DRivsSTRVSRQ9N92sNRrUyAQhLgAAAJY/QiIUtat/WFf2tNG0ugb0duZCosOERMvCLppW16xYJFhx76DC91NJBAAAgHoUmH8XNJpkKqMDJ0Z10+WrvR4KJK2/qElm0t//fEBnxybPey4a8utdr+6e6rcC7+0aGFbAZ7qMptU1JxYJVKEnUe77W6c1rqYnEQAAAOpFVf6yNLNbJP2pJL+krzjn7p3xvOWfv03SuKRfcc49V41zo/r2DMaVyTqaVteISNCvK7pb9dTeE3pq74lZz//hky/q4zddojtet04BP8WBXtvZH9fm1TFFgjStrjWxSOVL1ccTJSqJkmk556i+BAAAwLJWcUhkZn5JX5D0DknHJD1rZo865/ZM2+1WSZvzH6+X9KX8Z9QgmlbXnkd+/U1FKyBePjWmzz6xT7/3rV366j/36Xdvu0xvvXQVf6h6xDmnXf3DuunyVV4PBUW0hAM6NTo5/45ziCcLjavP70mUyTolUhk1hajqAwAAwPJVjd9mr5N00Dn3siSZ2cOSbpc0PSS6XdJDzjkn6adm1m5mXc65wbkOHE+k9N3dr1RhiJByFSnNYb+awwE1hwJqCvkVDfllOj9Q+PnRYV3UHFJ3G02ra0XQ79OK5tCs7a9tDukbd71B391zXPc+sU8f+ep2Xf+qDt15fa/aokE1hwJT/8+jIb8m01mNT2Q0NpnW+GRaYxMZJVMZD/6LvBcM+KZ+DnI/E35FQn5NpLJT/zbjk2mNTWY0UeLfKBz0qznkV1P+33l0Iq0zY5P0I6pRsUhQh05V1tsrnkwpFPCdVylWCIxGkuklDYkyWae+02PqOzWmTNYt2XlrXeG1rimUf60L+xUK+JSYzGhsIq3xaZ9Tmeys7/f7TBs7m9Xb0Syfj8AdAJbK6ERau/qHp6p2UR6fmZpCfjWFA2qZ9joYCsyeaWAmqt7LlJjM6MXjIzoRT3o9lAuuGr/N9kg6Ou3rY5pdJVRsnx5Js0IiM9smaZskhdZs0rav7ajCEFGut1yykmqUZcLM9M4r1uhtl63S3/zsiD7/1H7dxc+Np65a2+71EFBES6Qaq5ulz+tHJJ2behZPpLS6CitCJiYzev7IWc3MfbLO6ciZce0ZjGvvYFz7BkeUaNCQdyk0h/y6vKtVW7pbdUV3q9Zd1CRfkdfFgM8U9PsU9PsUCuQe+32mdMYplclqMpPVZDqrVMYp6xYe5plyYXYof+yg/9yxvRYN+ou+cbFQzjkdj0+U9e8BXAhOUjbrNJnJKpXJKpU+9/hC8U/dM2zq5zvgt6L3l3p3dnxSPz86rBeOntULR4d04MSouC0snZWxsDavasl9rI5p86oW9ayILrtrMZPNvd6mpr3uptJZVXopJVMZ7T8+ot0Dce0ZiOulk6OzfjerV9UIiYpdRTP/+RayT26jc/dLul+Srrj6WveN33hzZaPDlGQqo7HJjMYn0hrNv4ta6g+Mt1/GdJnlJuj36c7re/XLr12rgydGNT6Rq4IZn8z9/05MZhQK+PLvKpx7lyEcaMx3EVKZ7FRFwVi+cigxmVEk6JuqDGoOB9QUCihc5B0YSZpIF6qOzlUehQN+Xc1UzZpU6B1UiXgipdZp/Yikc02s5zp2oWJvIe/affHpg/qz7x8s+XxrJKAt3a2647p12tLVqk2rWhSkH9mUiXRm6udxNP95Mp1VNOSfqh5syVdXFvt3m8xkdfD4qHYPDGvPYFx/u+OYHvoJYdx0ZtLfffR6Xbt+xaK+/y+eeVn3PrGvyqMCsFytaArq6nXtuu2qLl29tl0rY2Gvh7QsZZ3TeP53/7GJ3O+4oxNppYskG+lMVn2nx3XgxKj+345jGpvkda6UrraIruhu1a1XrtGW7jatXRH1ekhVc9Vni2+vRkh0TNK6aV+vlTSwiH1miQb9NE8GytQSDuiadVSyADPFwgFNprOaSGcWHY6OJNPn9SOSplUSzbHC2W8+/Lwk6S8+tHXecxw6Naae9qg+f8c1s57rbo+quy1CpecF9pr1K1T4tSWbzVVwDQwnZu/opIzLv3OZLryTmVU64xQMTKswyn/2lZHlOaf8cc9/d9R5/Da7c9Jnv7NPX/jBS/rKnfNfzzMlJjO6/5mXtXXDCn1g69oLMEKgPH7f+VU9wYBPQZ8Vf4u7CrJZnat2mFbB5Cque1h+mkIBvXptW34lX17XvOKc08BwUgeOj+j4MpxKZWYKB3xTr7mFyttKL6mAz6dNq1p0UQWVs8tVNUKiZyVtNrONkvol3SHp387Y51FJ9+T7Fb1e0vB8/YgAAKimQpgzmkwr3LK4kCieTKk1en4lUVv0XE+iUvYOjiz4HANDCW3oaNLrei9a1BhRXT6fqbezWb2dzV4PpWa8Ek/q808d0P7jI7pkdays7/3m9qM6Mzap+/79a3XdRq5xAPCamamnPaqe9vqpkEFlKq5Pd86lJd0j6UlJeyV90zm328zuNrO787s9LullSQclfVnSr1d6XgAAytESnj/Mmc+clUQlGm1ms06DwwkNDieUXcBk9oGhpLr5RQ017M439ioa9Ou+H75U1velMlnd/8zLeu2GFXpd7+KmqgEAgAurKsuwOOceVy4Imr7tvmmPnaSPVeNcAAAsRiHcqaR59UiyWE+iYP654sc9OTqhVMZNPZ6ruXUqk9WJkSSrS6KmrWgO6YPXrddDP+nTb73jEq1d0bSg7/uHXwyofyihz9x+BVNLAACoUXS6BAA0hIX0DppPPDG7kigS9Cngs5LHPXY2UfRxMcfjSWWdqCRCzfu1GzbKTPrKjw4taP9s1ulLT7+kS1fH9NZLWRwDAIBaRUgEAGgIU5VEi5xulspklUhlZlUSmZlao0GNlAiJBoYSRR8X3zfXMJKQCLWuqy2q917To4efPaLToxPz7v/9fSe0//io7r7xYvl8VBEBAFCrCIkAAA2hEBIttidR4ftmVhIVtsUTxY9bTkg0mF9Bq7ud6WaofXe95WJNpLN68J/75tzPOacvPn1QPe1RvfvV3UszOAAAsCiERACAhlBoXL3YnkSFSqGZq5tJub5EpSqJ+ocSikUCao0E1D9PSFR4vquNSiLUvk2rYrp5y2o9+JPDc/5cPdt3Vs8dGdJdb7lYQT+/egIAUMt4pQYANISWqUqixfUkKlQKxSKzQ6JYJKB4iQqlgaFEbmnZFU0LmG6WUHtTUM3hqqwrAVxwd7/lVRpOpPT1nx0puc8Xnz6ojuaQPvDadUs4MgAAsBiERACAhhAO+BUK+DRSaSVRkelmc1cSJXMhUXtE/fmeQ6UMDiWpIsKycu36FXrjxR36yo9f1kQ6M+v5PQNxPf3iSX34Tb2KhvwejBAAAJSDkAgA0DBaI4FF9yQqrF5WqpKo1HH7z46ruz2q7vao+s+Oz3mO/qGEeuhHhGXmoze+SsfjE/qrf+rTi6+MnPfxv//xgJpDfn3oDb1eDxMAACwA9ewAgIbREg4senWz+JyNq4OKJ2ZXEo0kU4on0+pZEZXljzGSTBUNmqTcdLPrNl60qPEBXvmlzZ26qqdN9z6xT/c+sW/W89tuuFhtTcWveQAAUFsIiQAADSM2x7Sw+RRCoKKNq6MBjU1mlM5kFZjWmHdw+NyS9jZtW7GQaHQirXgyzXQzLDtmpvv/w2v1/JGhWc/5faYbNq/0YFQAAGAxCIkAAA2jJRyoYHWz9NQxZiqEPqMTabU3haa295/NNarOTSGzqW2XrI7NOsZgvql1N9PNsAx1tUXVdRUBJwAAyx09iQAADWOu3kHziSdTioUD8vts1nOtUyunnX/swpL2Pe1NWrsiet62mc7tyx/aAAAA8AaVRACAhtFSQUg0kkwX7UcknaskGk6kNH2R7/6hhAI+08pYWCYp6LeSIdFAfuWzLkIiAAAAeISQCADQMOZaqn4+I8lU0X5EUq4nUW6f8wOogaGE1rRFpqqP1rRFNFAiJBocTshn0upYeFHjAwAAACrFdDMAQMMo9CRyzpX9vfFE6Uqi1nwlUXxGADUwlDhv+lhPe7RkSNQ/lNCa1sh5ja8BAACApcRvogCAhhGLBJR10vhkpuzvHZlITYVBMxW2z+pJdPb8kKi7PTrVzHqmgaEEU80AAADgqYpCIjO7yMy+Z2YH8p9XlNivz8x2mtkLZra9knMCALBYLSUaTC/EXJVEhe3xxLlKonQmq1fiSfWsOBf8rG2P6pV4UulMdtYxBoeT6iYkAgAAgIcqrST6hKR/dM5tlvSP+a9Leatz7hrn3NYKzwkAwKKcW6q+/L5Ec/UkihUJn46PTCjrdF7w090eVdblnpsum3UaHEqquz1S9rgAAACAaqk0JLpd0oP5xw9Kem+FxwMA4IKZqvgps5LIOaf4HKubBfw+NYX85zXFLkwrmxkSTX+u4NTYhCYzWXW3UUkEAAAA71QaEq12zg1KUv7zqhL7OUnfNbMdZratwnMCALAosXAu5BktMyRKpDLKZF3JnkRSri/R9MbVhQbV5zWuzk89m9m8enAoKUlMNwMAAICnir8lOo2ZPSVpTZGnPlXGed7knBsws1WSvmdm+5xzz5Q43zZJ2yRp/fr1ZZwCAIC5xUo0mJ5PPJE+7/uLHztw3nH7hwqVROemkBUqhfpnhEQDRfYFAAAAltq8IZFz7qZSz5nZcTPrcs4NmlmXpBMljjGQ/3zCzB6RdJ2koiGRc+5+SfdL0tatW8tfoxgAgBIKjavL7UlUmEZWarpZ4bnplUT9QwmtaAqqKXTue6Ihvy5qDs0KifqLVB0BAAAAS63S6WaPSroz//hOSd+euYOZNZtZrPBY0s2SdlV4XgAAylaswfRCFMKfUo2rC89NP+7AUOK8lc0Ketqjs6ebDScVDfrVNsfxAQAAgAut0pDoXknvMLMDkt6R/1pm1m1mj+f3WS3px2b2c0n/Iukx59x3KjwvAABlaw4tNiQqTDebq5IoqHji/MbVxRpRd7dHZjWuHhhKqLs9IjMra1wAAABANc073WwuzrnTkt5eZPuApNvyj1+WdHUl5wEAoBr8PlNLOLCInkT5SqI5G1efO65zTgNDCb1pU+es/brbo/rxgVNyzk2FQrmQiKlmAAAA8FallUQAACwrLeHAInoS5cKf1vkqiZIpOecUT6Q1NpnR2hLTzcYmM1PNsCVpYDhZtOoIAAAAWEqERACAhjJzFbKFmAqJ5uxJFFAq4zSRzurY0Lik4kvaF5pTF/aZSGd0cmSCSiIAAAB4jpAIANBQWiIBjU6U37g66DeFA6VfNmP5qWjxREoDQ0lJxVcrKzSzLuzzynDuc3d7pKwxAQAAANVGSAQAaCi5aWHlVhKl1BoJztlYujAVLZ5Mq/9s6UqiwrbCCmeFsIhKIgAAAHiNkAgA0FBi4YBGk+X1JIon0nOubCada2o9kkxpYDipUMCnjubQrP06mkMKB3zqnwqJcp8JiQAAAOA1QiIAQENZXE+i1Jz9iKRcTyIpX0k0lFBPe1Q+3+zKIzNTT3t0VkjU1cZ0MwAAAHiLkAgA0FBawuWHRPHk/JVEsWmVRP1nE3P2GOpuj6r/bD4kGk6qozmkSNBf1pgAAACAaiMkAgA0lFgkqEQqo3Qmu+DvGUmmFAvPXUlUCJHiibQGhhJzLmnf3R6Z1pMowVQzAAAA1ARCIgBAQymEOeWscBZPpKemk5VS6El0enRCJ0YmplYxK6anvUknRiY0kc7kQyKmmgEAAMB7hEQAgIbSkg+JyplyNpJMTU0nK6Up5JffZ9p/YlTS3I2oC6HQK8NJDQwl1DVH1REAAACwVAiJAAANpbXMkCidyWpsMjNVKVSKmSkWCWjfYFyStHaOkKhQZbR3cERjkxn1MN0MAAAANYCQCADQUFryvYUWOt2ssN98jasL+7x8akzS3JVEhVBoe9+ZefcFAAAAlgohEQCgocSmKolSC9o/nsiFRK3RuSuJpFxfokzWSZLWzLGkfRuPkMUAAAg2SURBVOG5Zw+flSR10ZMIAAAANYCQCADQUFrKbFwdz4dJC60kkqSVsfCcS9qHA36tioW1u39YkphuBgAAgJpASAQAaChTS9UvsCdRoXfRfD2Jpu+zkOlj3e1RpbNOQb9pZUt4QWMBAAAALiRCIgBAQ4kVehItMCQqr5Iod+yeBUwfK1QPrW6NyOezBY0FAAAAuJAqConM7ANmttvMsma2dY79bjGzF83soJl9opJzAgBQiUjQp4DPFtyTqFBJ1LaQnkTRXJC0kOljhRXOaFoNAACAWlFpJdEuSe+X9EypHczML+kLkm6VtEXSB81sS4XnBQBgUcxMLZHAwnsSJcqvJFrQdLN882r6EQEAAKBWzP8b7xycc3ul3C/cc7hO0kHn3Mv5fR+WdLukPZWcGwCAxYpFAlMVQvMp7NcSnv8lszUfJC20J5Ekdc2xChoAAACwlCoKiRaoR9LRaV8fk/T6JTgvAABFxcJBPb5zUD956fS8+44kU2oO+RXwz1982xot9CRiuhkAAACWn3lDIjN7StKaIk99yjn37QWco1iZkZvjfNskbZOk9evXL+DwAACU5zfetklPv3hywftftbZtQfvdvGW1Tt1yqbZ0tc677+VrWvXb77xU77qqa8HjAAAAAC4kc65kXrPwg5g9Lem/Oue2F3nujZI+7Zx7Z/7rT0qSc+5/znfcrVu3uu3bZx0SAAAAAAAAi2RmO5xzsxYgq7Rx9UI8K2mzmW00s5CkOyQ9ugTnBQAAAAAAwAJVFBKZ2fvM7JikN0p6zMyezG/vNrPHJck5l5Z0j6QnJe2V9E3n3O7Khg0AAAAAAIBqqnR1s0ckPVJk+4Ck26Z9/bikxys5FwAAAAAAAC6cqvQkulDMbETSi16PA8tGp6RTXg8CywbXC8rB9YJycL2gXFwzKAfXC8rB9YJSNjjnVs7cWFEl0RJ4sVgjJaAYM9vO9YKF4npBObheUA6uF5SLawbl4HpBObheUK6laFwNAAAAAACAGkdIBAAAAAAAgJoPie73egBYVrheUA6uF5SD6wXl4HpBubhmUA6uF5SD6wVlqenG1QAAAAAAAFgatV5JBAAAAAAAgCVQkyGRmd1iZi+a2UEz+4TX40FtMbN1ZvYDM9trZrvN7Dfz2z9tZv1m9kL+4zavx4raYGZ9ZrYzf11sz2+7yMy+Z2YH8p9XeD1O1AYzu3TafeQFM4ub2ce5x6DAzB4wsxNmtmvatpL3FDP7ZP53mhfN7J3ejBpeKXG9/KGZ7TOzX5jZI2bWnt/ea2aJafeZ+7wbObxQ4nop+frD/QUlrplvTLte+szshfx27jGYV81NNzMzv6T9kt4h6ZikZyV90Dm3x9OBoWaYWZekLufcc2YWk7RD0nsl/RtJo865P/J0gKg5ZtYnaatz7tS0bZ+TdMY5d28+jF7hnPsdr8aI2pR/TeqX9HpJHxb3GEgysxskjUp6yDl3ZX5b0XuKmW2R9HVJ10nqlvSUpEuccxmPho8lVuJ6uVnS951zaTP7rCTlr5deSf9Q2A+Np8T18mkVef3h/gKp+DUz4/k/ljTsnPsM9xgsRC1WEl0n6aBz7mXn3KSkhyXd7vGYUEOcc4POuefyj0ck7ZXU4+2osAzdLunB/OMHlQsagZneLukl59xhrweC2uGce0bSmRmbS91Tbpf0sHNuwjl3SNJB5X7XQYModr04577rnEvnv/yppLVLPjDUpBL3l1K4v2DOa8bMTLk30r++pIPCslaLIVGPpKPTvj4mAgCUkE/Dr5X0s/yme/Kl2w8wfQjTOEnfNbMdZrYtv221c25QygWPklZ5NjrUsjt0/i9W3GNQSql7Cr/XYD4fkfTEtK83mtnzZvZDM/slrwaFmlPs9Yf7C+bzS5KOO+cOTNvGPQZzqsWQyIpsq605cagJZtYi6W8lfdw5F5f0JUmvknSNpEFJf+zh8FBb3uSce42kWyV9LF+WC8zJzEKS3iPp/+Y3cY/BYvB7DUoys09JSkv66/ymQUnrnXPXSvotSX9jZq1ejQ81o9TrD/cXzOeDOv/NLu4xmFcthkTHJK2b9vVaSQMejQU1ysyCygVEf+2c+ztJcs4dd85lnHNZSV8W5bbIc84N5D+fkPSIctfG8Xx/q0KfqxPejRA16lZJzznnjkvcYzCvUvcUfq9BUWZ2p6R3S/p3Lt8kND9t6HT+8Q5JL0m6xLtRohbM8frD/QUlmVlA0vslfaOwjXsMFqIWQ6JnJW02s435d3HvkPSox2NCDcnPrf1LSXudc38ybXvXtN3eJ2nXzO9F4zGz5nyDc5lZs6Sblbs2HpV0Z363OyV925sRooad9+4b9xjMo9Q95VFJd5hZ2Mw2Stos6V88GB9qiJndIul3JL3HOTc+bfvKfMN8mdnFyl0vL3szStSKOV5/uL9gLjdJ2uecO1bYwD0GCxHwegAz5Vd5uEfSk5L8kh5wzu32eFioLW+S9CFJOwvLOUr6XUkfNLNrlCuz7ZN0lzfDQ41ZLemRXLaogKS/cc59x8yelfRNM/tVSUckfcDDMaLGmFmTcqtsTr+PfI57DCTJzL4u6UZJnWZ2TNIfSLpXRe4pzrndZvZNSXuUm1b0MVYeaiwlrpdPSgpL+l7+9emnzrm7Jd0g6TNmlpaUkXS3c26hTYxRB0pcLzcWe/3h/gKp+DXjnPtLze6rKHGPwQJYvroVAAAAAAAADawWp5sBAAAAAABgiRESAQAAAAAAgJAIAAAAAAAAhEQAAAAAAAAQIREAAAAAAABESAQAAAAAAAAREgEAAAAAAECERAAAAAAAAJD0/wF8o6Z6cQ6iOwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index 18\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index 19\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "reload(modisco.visualization.viz_sequence)\n", + "reload(modisco.visualization)\n", + "\n", + "def visualize_idx(idx_to_viz):\n", + " viz_sequence.plot_score_track(task0_transformed_scoretrack[idx_to_viz],\n", + " threshold=CUTOFF_VALUE)\n", + " viz_sequence.plot_weights(task_to_scores[\"task0\"][idx_to_viz],\n", + " highlight={\n", + " 'red': [(x.start, x.end) for x in\n", + " motifmatch_to_coordinatesbyregionidx[0][idx_to_viz]],\n", + " 'blue': [(x.start, x.end) for x in\n", + " motifmatch_to_coordinatesbyregionidx[1][idx_to_viz]]\n", + " },\n", + " subticks_frequency=20)\n", + "\n", + "for idx_to_viz in range(20):\n", + " print(\"Index\",idx_to_viz)\n", + " visualize_idx(idx_to_viz)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "include_colab_link": true, + "name": "(On Google Colab) With Hit Scoring TF MoDISco TAL GATA.ipynb", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/examples/simulated_TAL_GATA_deeplearning/TF_MoDISco_TAL_GATA_hitscoringdev.ipynb b/examples/simulated_TAL_GATA_deeplearning/TF_MoDISco_TAL_GATA_hitscoringdev.ipynb deleted file mode 100644 index 745fe7f..0000000 --- a/examples/simulated_TAL_GATA_deeplearning/TF_MoDISco_TAL_GATA_hitscoringdev.ipynb +++ /dev/null @@ -1,1383 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "view-in-github" - }, - "source": [ - "\"Open" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "oPV0Wsfg9OBZ" - }, - "source": [ - "# TF-MoDISco on the TAL GATA simulation\n", - "\n", - "### Note: we are still refining the multi-task version of TF-MoDISco. If you encounter difficulties running TF-MoDISco with multiple tasks, our recommendation is to run it on one task at a time.\n", - "\n", - "This notebook demonstrates running TF-MoDISco on importance scores obtained from the TAL-GATA simulation used in the DeepLIFT paper. See Generate Importance Scores.ipynb for a notebook demonstrating how to produce the scores. There are 3 tasks. Task 0 is positive when both TAL and GATA motifs are present in the sequence. Task 1 is positive when GATA motifs are present in the sequence. Task 2 is positive when TAL motifs are present in the sequence." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 541 - }, - "colab_type": "code", - "id": "CLiK1j6A8YrA", - "outputId": "50383cd1-4015-4627-893c-01c859c3791e" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Requirement already satisfied: modisco in /Users/avantishrikumar/Research/tfmodisco (0.5.8.1)\n", - "Requirement already satisfied: numpy>=1.9 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from modisco) (1.18.5)\n", - "Requirement already satisfied: joblib>=0.11 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from modisco) (0.16.0)\n", - "Requirement already satisfied: scikit-learn>=0.19 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from modisco) (0.23.1)\n", - "Requirement already satisfied: h5py>=2.5 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from modisco) (2.10.0)\n", - "Requirement already satisfied: leidenalg>=0.7.0 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from modisco) (0.8.1)\n", - "Requirement already satisfied: tqdm>=4.38.0 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from modisco) (4.47.0)\n", - "Requirement already satisfied: psutil>=5.4.8 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from modisco) (5.7.0)\n", - "Requirement already satisfied: matplotlib>=2.2.5 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from modisco) (3.2.2)\n", - "Requirement already satisfied: scipy>=0.19.1 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from scikit-learn>=0.19->modisco) (1.4.1)\n", - "Requirement already satisfied: threadpoolctl>=2.0.0 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from scikit-learn>=0.19->modisco) (2.1.0)\n", - "Requirement already satisfied: six in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from h5py>=2.5->modisco) (1.15.0)\n", - "Requirement already satisfied: python-igraph>=0.8.0 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from leidenalg>=0.7.0->modisco) (0.8.2)\n", - "Requirement already satisfied: cycler>=0.10 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from matplotlib>=2.2.5->modisco) (0.10.0)\n", - "Requirement already satisfied: python-dateutil>=2.1 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from matplotlib>=2.2.5->modisco) (2.8.1)\n", - "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from matplotlib>=2.2.5->modisco) (2.4.7)\n", - "Requirement already satisfied: kiwisolver>=1.0.1 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from matplotlib>=2.2.5->modisco) (1.2.0)\n", - "Requirement already satisfied: texttable>=1.6.2 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from python-igraph>=0.8.0->leidenalg>=0.7.0->modisco) (1.6.3)\n" - ] - } - ], - "source": [ - "!pip install modisco" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "en15RxNL8YFE" - }, - "outputs": [], - "source": [ - "from __future__ import print_function, division\n", - "%matplotlib inline\n", - "/\n", - "try:\n", - " reload # Python 2.7\n", - "except NameError:\n", - " try:\n", - " from importlib import reload # Python 3.4+\n", - " except ImportError:\n", - " from imp import reload # Python 3.0 - 3.3" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 86 - }, - "colab_type": "code", - "id": "uVOSJpXV8aIG", - "outputId": "3fa7a2eb-987f-49d6-8e8c-307a93d580b8" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "TF-MoDISco is using the TensorFlow backend.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WARNING:tensorflow:From /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages/tensorflow/python/compat/v2_compat.py:96: disable_resource_variables (from tensorflow.python.ops.variable_scope) is deprecated and will be removed in a future version.\n", - "Instructions for updating:\n", - "non-resource variables are not supported in the long term\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/avantishrikumar/anaconda3/lib/python3.8/site-packages/sklearn/utils/deprecation.py:143: FutureWarning: The sklearn.neighbors.kde module is deprecated in version 0.22 and will be removed in version 0.24. The corresponding classes / functions should instead be imported from sklearn.neighbors. Anything that cannot be imported from sklearn.neighbors is now part of the private API.\n", - " warnings.warn(message, FutureWarning)\n" - ] - } - ], - "source": [ - "import numpy as np\n", - "import modisco\n", - "import sys\n", - "import os" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "ROG0LVF_9ZZs" - }, - "source": [ - "## Grab the input data" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 443 - }, - "colab_type": "code", - "id": "bZ8jaBDZ8fmm", - "outputId": "87734ddd-01e6-4433-9650-5f5e0ef01b97" - }, - "outputs": [], - "source": [ - "#grab scores for tfmodisco\n", - "#!/usr/bin/env bash\n", - "![[ -f scores.h5 ]] || curl -o scores.h5 https://raw.githubusercontent.com/AvantiShri/model_storage/23d8f3ffc89af210f6f0bf7e65585eff259ba672/modisco/scores.h5\n", - "![[ -f sequences.simdata.gz ]] || wget https://raw.githubusercontent.com/AvantiShri/model_storage/db919b12f750e5844402153233249bb3d24e9e9a/deeplift/genomics/sequences.simdata.gz\n", - "![[ -f test.txt.gz ]] || wget https://raw.githubusercontent.com/AvantiShri/model_storage/9aadb769735c60eb90f7d3d896632ac749a1bdd2/deeplift/genomics/test.txt.gz" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "_ShCbHRM92_y" - }, - "source": [ - "## Functions for one-hot encoding sequences¶" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "KawKTu5P8-c6" - }, - "outputs": [], - "source": [ - "#Functions for one-hot encoding sequences\n", - "import gzip\n", - "\n", - "def one_hot_encode_along_channel_axis(sequence):\n", - " to_return = np.zeros((len(sequence),4), dtype=np.int8)\n", - " seq_to_one_hot_fill_in_array(zeros_array=to_return,\n", - " sequence=sequence, one_hot_axis=1)\n", - " return to_return\n", - "\n", - "def seq_to_one_hot_fill_in_array(zeros_array, sequence, one_hot_axis):\n", - " assert one_hot_axis==0 or one_hot_axis==1\n", - " if (one_hot_axis==0):\n", - " assert zeros_array.shape[1] == len(sequence)\n", - " elif (one_hot_axis==1): \n", - " assert zeros_array.shape[0] == len(sequence)\n", - " #will mutate zeros_array\n", - " for (i,char) in enumerate(sequence):\n", - " if (char==\"A\" or char==\"a\"):\n", - " char_idx = 0\n", - " elif (char==\"C\" or char==\"c\"):\n", - " char_idx = 1\n", - " elif (char==\"G\" or char==\"g\"):\n", - " char_idx = 2\n", - " elif (char==\"T\" or char==\"t\"):\n", - " char_idx = 3\n", - " elif (char==\"N\" or char==\"n\"):\n", - " continue #leave that pos as all 0's\n", - " else:\n", - " raise RuntimeError(\"Unsupported character: \"+str(char))\n", - " if (one_hot_axis==0):\n", - " zeros_array[char_idx,i] = 1\n", - " elif (one_hot_axis==1):\n", - " zeros_array[i,char_idx] = 1\n", - "\n", - "#read in the data in the testing set\n", - "test_ids_fh = gzip.open(\"test.txt.gz\",\"rb\")\n", - "ids_to_load = set([x.rstrip() for x in test_ids_fh])\n", - "\n", - "fasta_sequences = []\n", - "for i,a_line in enumerate(gzip.open(\"sequences.simdata.gz\",\"rb\")):\n", - " if (i==0):\n", - " next\n", - " a_line = a_line.rstrip()\n", - " seq_id,seq_fasta,embeddings,task1,task2,task3 = a_line.split(b\"\\t\")\n", - " if seq_id in ids_to_load:\n", - " fasta_sequences.append(seq_fasta.decode(\"utf-8\"))" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "m1xkAlvW97vL" - }, - "source": [ - "## Prepare the data for input into TF-MoDISCo\n", - "\n", - "You need a numpy array of importance scores and hypothetical importance scores for every task." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "xahZGqrA9Jpq" - }, - "outputs": [], - "source": [ - "import h5py\n", - "from collections import OrderedDict\n", - "\n", - "task_to_scores = OrderedDict()\n", - "task_to_hyp_scores = OrderedDict()\n", - "\n", - "f = h5py.File(\"scores.h5\",\"r\")\n", - "tasks = f[\"contrib_scores\"].keys()\n", - "n = 100 #since this is just a test run, for speed I am limiting to 100 sequences\n", - "for task in tasks:\n", - " #Note that the sequences can be of variable lengths;\n", - " #in this example they all have the same length (200bp) but that is\n", - " #not necessary.\n", - " task_to_scores[task] = [np.array(x) for x in f['contrib_scores'][task][:n]]\n", - " task_to_hyp_scores[task] = [np.array(x) for x in f['hyp_contrib_scores'][task][:n]]\n", - "\n", - "onehot_data = [one_hot_encode_along_channel_axis(seq) for seq in fasta_sequences][:n]" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "hQEQgz1w-QhL" - }, - "source": [ - "Double check by plotting" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 405 - }, - "colab_type": "code", - "id": "Ky6nlCFs-NcP", - "outputId": "1319f738-704a-4241-a804-ab54e6d3246b" - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABIUAAACMCAYAAADiDBl2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOy9eZgdR3kv/DvL7DMaabTZlhdZkm0ZG++W9wWzhbBznUsISYDgEMAEcEjy5Wa51yQhfIQkEHIJGAeDwWAghB2zJEaSbbxJtvFubHmRrZElzYw0M2c/p7vr++Ott7u6uqq7ekb+4gf373n0zKinTp/qqnrf9/cuVV0SQqBAgQIFChQoUKBAgQIFChQoUKDACwvl/+4OFChQoECBAgUKFChQoECBAgUKFPj/H0VQqECBAgUKFChQoECBAgUKFChQ4AWIIihUoECBAgUKFChQoECBAgUKFCjwAkQRFCpQoECBAgUKFChQoECBAgUKFHgBoggKFShQoECBAgUKFChQoECBAgUKvABRBIUKFChQoECBAgUKFChQoECBAgVegKj+d33xihUrxNq1a/+7vr5AgQIFChQoUKBAgQIFChQoUOBXDnfddde0EGKlS9v/tqDQ2rVrsX379v+ury9QoECBAgUKFChQoECBAgUKFPiVQ6lU2unattg+VqBAgQIFChQoUKBAgQIFChQo8AJEERQqUKBAgQIFChQoUKBAgQIFChR4AaIIChUoUKBAgQIFChQoUKBAgQIFCrwAUQSFChQoUKBAgQIFChQoUKBAgQIFXoAogkIFChQoUKBAgQIFChQoUKBAgQIvQBRBoQIFChQoUKBAgQIFChQoUKBAgRcgiqBQgQIFChQoUKBAgQIFChQoUKDACxBFUKhAgQIFChQoUKBAgQIFChQoUOAFiCIoVKBAgQIFChQoUKBAgQIFChQo8AJEERQqUKBAgQIFChQoUKBAgQIFChR4ASIzKFQqla4plUr7SqXSA5a/l0ql0qdKpdKOUql0X6lUOu3gd7NAgQIFChQoUKBAgQIFChQoUKDAwYRLpdAXAfxayt9fBeAY+e9dAD6z+G4VKFCgQIECBQoUKFCgQIECBQoUeC6RGRQSQtwEYH9Kk9cD+JIg3A5gaalUOvRgdbBAgQIFChQoUKBAgQIFChQoUKDAwcfBOFNoDYBnlP/vktcWhc99Djj2WODppxd4A78L/PRc4I53Zzb9ixv/Aq/48isW+EUS+24Bvns0sHdzeOmz2z+L064y7Kbbfzfw3XXA5A0L+qof7/gx1n9qffIP9SeA7x0DPH5NeOnOyTtx+D8dnmj6si+9DP/7Z/87du2xmcew6uOrEm2np4ETTwQ++tH49X/+Z2DjRmD3buVibx644RTgF38Ra3vNNTSfTz4ZXWu3gU2bgPe/P37fiY9NYF9jX+ya5wEXXAD83u9pnZv8IY3l/rujayIAbnw5cMubY003bwaOPhr4+c+ja5+47RM4+9/OTjzz7bdT2//6r8SfkjhwL/Vh1/dil//gD4BzzwV6vfSPb35yM9Z+cq3DF0nc93+AG04CunOpzZ6eexor/n6F+30f/Vfg+8cBjUic3/adt+F3v/27iaZf/jKwYQOwY0d07fIbLsebvv4m9+8z4Cc/AdatA+68M7vt2k+uxY1P3hi79uk7P40zPndGou327TSfP/5x9n1P+ewpuOaea2LXfvjoD7HhUxuSjWuPk8w9cW32jZu7aHwf/XR46eGph7H6H1Yn27angB+cADz4sez7GuAHPsY+OgYhhNsHnvoa8L31wPwvw0u9HnDeecBll2ltd32f1vuBXyyobxAC2PJaYOtr6XfG1G2kQ/f8LN7+lt8EbnwZyXUGLrsMOP/8uMw98giwfj3wta8trLs2vOLLr8Cf3/jnbo07M8APTwQe+Nvstr068KNTgV/8Wfz641+ktVZ7PLptBzjrLOB974s3Xf73y7Frbpdb3wz425v+Fhd94SKntkIAb3oT8Ou/Hp9OK279HeC/LgYCP7o2ez+tv2e+nfnxTVdvwqdu/1Ts2s07b8ZRnzjKqb8P7HsAh/5DMm+1bx/wohcBH/+4020S6PpdLPnoksT1d3znHXjrt966sJsynvmulLn7wku5eIsQwJZXA1vfkDlJNt5y992km29woC2nXnUqrrrrKre+5cDu3cQ5/uVf4tf/7u+Io8zMZN/DlbcIITD20TF4vhf7fB7e8qGffgiv+eprEn1Y/Q+r8dDUQ7FrH97yYVxy7SWJtnl4C6ZvlzpUIy4/fytw4yVOOhR3/AFx50BRovOPAt/bADz51ezPN3YC3z8WeOxz2W1be4AfHA88/E/x6w/9Pdm/tjKe3QPAD18M3P/h7Pt6DeBHpwH3/GlmUxtv+da3yG7cf390zfeBiy8GflenRLt/QvI5rRAXIYDNrwJu+h9OivHSS4FXvjLedOP/3Yj/eOg/Em3f9jbgoouoP4wHHqD+/ofefNvlwE/OAvxOeOmcfzsH/3SbNuYWXHLtJbhyy5Wxa7l5y8OfoHluPRtd684BN5wM3PtX8baPXU3rp/5UdM1rAT8+A7jriljTZR9bhunGdOzaFT++Aq+7/nWJrn3/+6S/fuFAW268kWTuttuia/946z/i3M+fm2h7223U9mcabfnN3wRe9jIgUETuhH89AV+93yBDd1wG/Of5MZk7/arT8dltn83uLEBj9f1jgR2fj1+/9y9pjHvzqR9/8sCTWPnxlck/5OEtFiz56BJ0vE7s2nt+8B5c+o1LE22/+U1aww8+GF3zPODCC4G3vz37u/Lwln+541+w6epNyT9M30k69NmfhpeuvfdanPSZk5Jtc/CWxx4jn+m66+LX/+RPgNNOAxoNh07ffyXpwO6B8NKrv/Jq/MlP/8Thw44QQmT+A7AWwAOWv/0QwPnK/28EcLql7bsAbAew/cgjjxQ2NJtCLFkiRKUixGWXCSFWrxaCdGX8X7mcvLZ6Nd3k8S8K8bUhIb42KMTsw+Z7yLYjHxkRuBJRB0xtTd+lft+PThfiKxDiBycKEQRCCCFO+PQJ8fsy/vNiavudo/M9m/y+t33rbeb7/vx3hPhKWYhvLBXCawshhPjwlg8b2+JKiLG/G4tdu/7+641t/+IvhOjrE2JoSIiZGbpWqwkxMiJEtSrE+9+vNH7w74W4foDGvblbCCFEuy3E0qX0SG97W9T0M58RYnCQ/j3+eLxvd+y6I9aHr3yFvn9oSIj775cXg0CI76ylsfyvS6LGz3xPiK8N07+p28KmJ5xAQ3jGGVHToz5xlPGZzzmH2m7cKERgmyOe+xtfQX349hFCBL4QQoiHHor6e+21wj7Pq1eLy394efb64+9r7qGxvb5fiAc+ktr2x4/92P2+vYYQXx8T4qsVIe54d2wu9PHpdISYmBCiVBLiLW+Jrpc/XF6UHAWBEBs20H8vuCCjv7Jv7/3Be2N9O+5fjjPO54UX0kfXr8+eT1wJcfpVp8c+/1vf/C2zzN3yWyRz/z4hhNdJ1TPijvfQ+H59VIheXQghxBfu+YL5vnf/P0J8tY90WOdA7rGstWsCV0K0e+3sufd7QnxzpRBfKQlx0/8Iu/ClL9H6HRwU4sEH5cXAF+LbR9J6v/HlC9PNz/5XJJ/P3hg98483SR36olCHiqnbo7bPfDf1Oe6/P5K5666LbvvGN9JaXbVKiF4v57pMeQ5cCTH8keHoi9Lm/t6/EuJ6OZ/t6fS2D32cdOj1g0I0dtE1ry3Evy+jtfbz3w6/8nOfi3ToY49FXcGVEJuf3Jw+9ynPtvxjy7NlWbbdulWI4WH69+MfZ4zDzHZpl4eE2PnN6P4/exXN/bfW0BpLuQeuhFj/z+tj4vKhn3zIWdf9653/apS5P/5jsmfDw0LMzuZcJ6tXi5nGjMCVEF2vG7tvQofm5ReBT+PyFQjxs18Lb+PEW3jcd/8kkqM9W1Lb2njLxRdTs6OPdtOhJ33mpIU9c8q6fN/7iBeOjhIHEUKI6WmS+f5+If7yL9PnPhdv6bUFroSYa8/FxiEPb+n/m34r/7rm7mti15b+v0sTbfPyFvGTc2idfH9jpEOnt0mZGxbi6W+l24LZhyL5fPza6L43XUr24ZsrhPC76WvttneSnfvGEiF6zfS2268Q4qtVIb42IkRXjnPnAPX1q31C3P2nUR/uu5J4z9eGhGjtS7/vw5+I5rP+dGrbBG8RQnieEIcdRnbj1389uv6Nb5B+GBoS4u67lUn67gYa959eEDWe/FEkc3tvSu3DzTdHOvSGG+Lr5DVfeU2sb/fcE9m5r389uv7qV1N/DzuM+i+EEGLuURqDrw0J8djVsfse+QnFB8vQt+MfHY/1wZm3CCFEd57m96tVIbZ/MGr7wN/J+RwUovmsHPiWEN8YJzt32+9FbX/5f8keXj8oRO1JOeyBwJUQ9+65N9aF6l9XE33zfSGOPJIe6+UvtzyvfOYgEOL44+m/Z58d3ePwfzrc+MybNlHbFym05fbbo/n87nejtrgS4iVffEn8Bgfuj2TuietibU/49AlRu7T1fuvbpe83TmMoBOmxrw2SHDz4sdRn/s7D3zHPpwtvSbFdXa8rcCXEVGMqdtvSlSWjzB16KK3h170uun799ZHM3Xtv+jjk4S0bPrXBokPPI1n+3jHhhJ599dnmtjl4y2/+Jj3b8uVCdCVF2LkzsiWf/KSlv3yP1j6ah+v7hbjvr2PrZOBvBpJ9UwBguxDZsR4hxEGpFNoF4Ajl/4cD2G1qKIT4nBDiDCHEGStXGqKSEjfK5L/vA9dfD2DvXnPDwJD14LaPfRbwW0DgAU99xXwPeU1AmO+R9V3ctrkbmJXncNcfB0olc1uAouNTMuXT2Zfv2eT3JfoLACIAnv53AAH927eVLpva8ke0v9HaSeKaayjzXi5TtB2giotymaK4X/qS0njHVUDQAVACnqaUxZYt9DhBAHzjG1HTz36Wsm5BAHz963TNl9ljL4hn5z77WaDVosz4l78sL87eD3Sm6Pd9N8f74Ddp/p/4AgDgqaeAJ56gP6uZH9P4TE0Bd91Fvz/9NFCyzdHevZSR4uqw7oGweuK662jMWi3qu3WeTfOZ9n27vg2gDARdYMfV6feV8xnOa9p99/wngBIgfOCp68ztJG65heZdCMqmMRLrJ6ccPfII8KxMJN1xR0Z/+Tsd1vCBA1T5BQB79mTMp+2+JjkKfOCZ/wAQUIZn6ma7nhGCxlX4AErAs/9pvy8APPkFQPSAUgWY/H7usWx5LQAIf6aO5fRtgN8GIIDJqNqNZa7XU7Ibs/cBXbmbeO+Whenmx/9NymeTfgeA1l6quAOA+pORDn3iCyTHfpPkOuU5rrsO6HYVmQP9/wc/oOFvteQ6yDOWac/hcj185s/TGimVgV3fTW+742rSoSXI9QVg302ysob1PIF1aGgrAQSyGoB/LmSOnGRZXvv854Fmk/5dfXV6WzzxJcpY+y2y0QDgNaPKht4cVX2m3cPQvzw61CZz115Leq1cBn74Q8s98sicDXn5xYF7aFwAYE9UGen0zOqaCmXu85njq2NuLqpU2bfPUYeqc3QQZE4Isv2+T+rhpzKR+73vAZUKyfrnP5/yHHv35uIt4Xz24vOZh7fYOJXpb6a2eXgL2lPAfklcGk8rOvSLpN8ddCieuo70lN8Cdkj5DHrSLgiS3enb0u3czuvJzgkAe3+WvtaevBYQHulFrpyf/AH9X/RC/gZA6tAugJKDDpXzKQTwzDfT+b9h3O+6C6jV6OM/jQoGcNVVpOfabWX9zD8SVcDM3BE13vE5ReauSe3DNdeQfWo2aZeECn2uv/Ql4sGqnWu3qZ9CUL+3b5eNn/oq2Q11PqMbJ/ph6psJzrwFAHbfIOfTA55UhG7H1cp8ykqLPT+THQtoHTEeuwoI2vI6CV1PVtV0/W68b4b5vO8+YL+kLVu2pDzb3r14/HFg50767z33pN93717gXklbnlRoyxe+EM3nVVrBZOI+T11HO1sMc5SpQ/fulb7f1wEEtAD2bqG/PfMtACWSgwy5t86nC29xsYmaDjV937ZtQL1Oj/CjH0XXWeY6HSlzeWQ5p9yjMwPs30a/N3eHE2ocnxy8xfOAb3+bnq3XIx8KoMooIUh+r7rK0l/u865vg+azG/FmiTQ/Py8ORlDoewB+V76F7GwAc0KIZ7M+lIY77ohKqVJsqh1CkPMCkCLatyW1eeBSUpuG/duBygD9XupLv++Bu4HqkOzbwr7OeN/5R4FylX73WsAMLWwRuJMSXxCx8ZWy/tlZ2j4G0JwwMbz9dhJggBY0fbBNpcMAKTgZmLrzThJqgAgZQMTukUfo926XSqSBiIip5YZCRIo3CICtW+Uf9m+PxrA6HD3IfraIgrb1gYxkVQ7PwIB9DLjtkJyiSiXx5zj236PMZxB+95YtRDwBMkhpSJujBPbdRCQDoO1IKejIcmHdaBoxfTvg1blDqU23bSODBwB90XJftGLavj0yqjz+WdDnL0Cy73fdFd0vLV6bel/TmNR+CZTlAPjtUOaMaD5DugigQOIMRamCQHPgAaCzH+jOyrb1KIicA2yEdWNsxP7tkpwBKA8CIJnjdev7kkgBwMz2aH1UHSdJx/Ttyd9jOrQa/X3qFoRCPrMdadi6NSqnZ33xwAPR3He7Clk+SHCyHb15ctgAmvupW+xt/Q4FxQBaU0zwZraRTgXCNRcEwENyB0qvF81R2yOFrJds54FJjmy49dbo9zvusLcDQPqL731Abvk9cK+iQ31Ff7v3L48OTQTLQTZuTsZd6vX4M7kil8zlwcx2GUxGTOZy8RbVWZ1OfzjTfe++210nM9ICIgvB7t3kGADERTjQf8stEReZnjZ/lpGHt4TzqQT58vAWwDyWiaBtSts8vIV0KBs6hbhM3YxQh3LQyIa9WyI7xRx67iGgLL886KTr4foToGg2AL8BzKTsA2/JpBpAdm5a7tWZvjXiIhwM7dVpqxlA/GfqZljhdyk5y/1lHWqBibds3x7xt2GFWt4tVZYQwE03yYv7FeJSUYREffbpdBv+859Hvo6+dV6f65tuivxw3gp1772RfHqeYuf2baEgDQDMPajeJpeOT6zVPLxl+rZoPsP5bhEnAkjm9kpSP3MnOdsAQvc08IhrAcRTpD/H8sn2ztZXgMaDxyxLj23fHvH+wcHoum2dsFxWFdpyyy3RfOqcIzHue7cCkPqdE2O2tibUHkc4Vn4zWnf7tkacoZF+DkvP78V+0n9y8BYLTDrUhu3bo23/6hxxYC7m+1mwmDUNgPRjRU664iyYfXl33vLww0B/P/3ebpMPBZD9YJumHsVhxL6bI9+vFQ+xLDqGocDllfTXA7gNwHGlUmlXqVR6Z6lUenepVOLDem4A8ASAHQCuBvDexXZq8+aI3Gc65SY0noz/fzbdK1/0gE7fQUYLiJQfoiBLDDPbZFYeZDQXAON91QUpemH1Crc1kQj9PqZMp+pQA1GEc+vWSOnxYseB+4CKYkElEd28OTKwLGePPhoPKLCxbfaasZ8AsGtX/IyQMGO275ZoDFn5dQ/E9lui/hgAIvlMBtW9m6axvPPOqE29nvhzHPu3R3u1/Saw72YIoWX1MrixcT5tmFY2OauBMAN4HtWxtGLfVoTOmuqUG7BlSzQfB5P3//zn0Xg3HboMJMdODWgytm2L7pc5n5b7BqZsyIxZ5ozYvz0KICEISRA7ETFis/+uOLlcgDE2yZEVe7fILDlC5/Ppp+MJoEjmlKCkv4Cgg9cEmpNKRyUxnLkj7iAAkgw+FrXtzVpvKxCXOdY3KrnvdJTg1kGCab0lsP/uuKymBfnmHohICaAQvM0RuZd47LE4EWXylGvuLXC1iZ1OlFUFUpPLFEycfzj6P8/3/m3kyAHSKb8p+Vm9f5o85tGhpmC5mggAgJtTfE4bDsa4G7Hvpsi+KX125i2qQw1EARALTGO5bVsURHE6+8Byn8Vg+/aIawRBJMvqWTvD6SYxF28xzWce3gKY54h1fdvPdmbz8BZM32nQoX7snLiss0UwayAuM9uioGTQJV1kw/7tVFUA0GfSAjL774oSARCR3KtV32wH1WQqAEylBDbnHgyTG2H/c+Kmm6LEV1eK3J49cV7CAXlM/VwJesgGvfn4eUjq+Tgaut34WZtTU/G/q3MdBPHzVrg/qkPdainOc+zcv7gzZeQ0FuhrMxdv2XcTwqAkz/fsvZrMyQjvvi1RUJLX0fwjUVCSvwd2mTMFb266KRqrTgZtscqcwdarBQz8Gc8j28yY1WhLbNyFAOZUmfPsbW2IyZwX8dBpJRGQ5Sv0DL5CHt5iQR6buHVrZGN4LauJACC+9k3I48vbdagUfMWXNweQ3HmLGpTsdiPbpQYM1QCkETHfLx7ZPJhBoXTvD4AQ4i0ZfxcALj9YHVIz1IC7ExfDzPZ4piTo2dvCkdinYd9mhA61Eqk03nfv5igrv0AYF8DULbFFzFlYJsBtr42hvvhC0vvX7pFEtnotjPaPAohXhQAUzdQNUzhH+7fFHRdJRNWD3bjtNs1O83VT9H/7diJiLT3YPK04yzymMzJbplU+3HRTxHHUw/lMc6QGsTKDHns3Rw41AEzfiqefjj4PZAc2WTkFIkC5lBKn7Ue8OiijAiicT6+FZViW3gk1cOqlC52qyFwdBBeojljW4dwsA/r8mWRj8+bs++nQ72s0IBaZM0LNlgEh+W75UXXBcJ80wDMKuQfigRFHOG9l4e9jyIDPtm3xdRtyE7XKIFhAUOjAL8ig8YQwMdy7OXI8mNRxhppluTIEwLzmn8LamKyy47Z1a5zIuxxgngdOxnjmzsipB6JKIGPbbXFiyI6FepC+XEdqZR0QPactg5oH+jYYG+67j4IpsQyfTdbmZWUdrxt2EPZulVsDJFTyY4Euj9xfL/BQLafTGh6XltfCQJX6oCYCAOCXvzR9Mh25ZC4P1PFQxsmZtxy4xyBz9uCAzSZ2c9KWgx0Uuu22OB984AHqE2+vAgwcQUGAUi7eYtr6kIe3AGYH1dbWNO55eAsFjllu5YfmH9FkbhA2HYoViOse5tBTSoYaSK8UmrpVs3Mpp/qqiQCAAsaBB9Qeja5xkGVGSb4B6YHN/UoQCwA6GeVjBqgHDLOjylUh7KSG9lENYvE6YoeaK50qg7ApxvvvJ4eQxVMPbKpytGNH3C5zlcqWLfG1f/vtoO0vauBR45Z55FO3B868RQRkx8Mbyb/PbAOEsg6bk7TQ1SAWr6OZbYhtq5BjyvLpYufUys+soJAqcyqPN42XWsDAn3noIZoX1pd6ZVLsPo2n4k5Guc/e1gY1KAnQGHoNoKWc4pLhA3OAuuW1MI5xupiHt1iQxyberhSQ81reto2C9yyD5YwyFlfeAlgCbobkG2Dz5d15y803x/nF9u10rIX6YgQ/bar7ENd5fnZF6kJxMLaPHVTs2hUXxAVVIugOWKnP3hYHgbyo2ZWs+2aV7zrAWOqnVxNIY6oS4Kz+mdqqVSEAGa/HH48LZyhbakYTAKpDiewKQ60K4fuq3632QS35BqRR9Lvm7MvMNqX8FIAIYtssdJiUiMvbCULs11hi4+kwiMXICmwasy4mHIl45D5Ib2/bz5vACmiCZlcwMzPAfEaycSHwUIllV7IQbpHRlKNpPu9OidXYYHM6Y8ZBl7m0LOzem7RteTTeauAuarslTs7VLJkjnLeyDIH2UWu4/fa4EatWQYYooww5E/u3x4OZHPAxVXPu3x4fM8+ebdqOM2JVMyxzKtEAsreX5IWT7di7JZ4IqKSkhBI6dJgCQ14y+nrrrXR+BIMdhIMRnHANOKiVWEAG4dbLq0MHQYvUZWyLBZJyzjrUZetWaOd6cTunPkdfOmUw4jnZPtaHqJpOgzNv2a851AbSm3XfuxZAWxadbNOwdWu8erFcjm8PBdIDV49jvTNvAcxbH/LwFhtszqyXqBLIx1uMb4NMyFxKxv5oxJ1S5tBTmrPTTXnF25RSFQKkJ0D3bokHb8p9FBhS7R2v1X1b4kmISsoeoH1aECvnNudmU3sznYRaFQLIgHzghdXoMezfHl9Twu6sbt8edwjZIebqflWOtm+Pc2/uj75td88exLdkA4lkXx4HOuEruPKW+Ufja4rvs29rPGBVHaYgRozPyXU0rQU9pP103ZrU6bi/xTpAKdweqsM0XqajIdSqECDp/8T04v7t8cr83gLmSN0eCtC47r8n7iv46WNktF15eEvGfXm92FCvyzWr4Y474vo2KyiUx+b0TIEyyxt1zbt+3HnLz7Uiq7k58kvUAHDq7ogjEa+sW0hC1hHPu6DQY48pZb0Lxex9iAvJQS7nVjEE6zaKWNAGoGhtmkF1BDvCMWWoO2tSgNPIsh5dNJHlRx+NNUGpRNmKqikZO/dw/P/Cx44d5rK4Bx6I/58jwaYs2n33GZRs8xmgYlgos/fFSa/fSHUEdaXbbOaoTishXiIMAJVB7NgRF/CswGY4n1nOxCHIPO9HRVpAMIbVSGQobNixI//ZEi7YjcNyOWI8VvoZDrrMdToUkc8L/TXEasVdCN1ZSyOqjSfi/5fjbZK5ZGWQ40FICpydlNUwkmajzDV2xknmQjD7QDyYGbSJCJmclflfxrfYpjizO7AhRti575OT8XbPxdrNRO3R7DaMOc0LDDygtsNIyHRCmqZD88LVYXjwwbiuSw0KzT8aD24Jn/RZWzuCME2OLP1TM51ZMOlFPSCdRT5NeE4qhVbAaTxSMXt/nERmOAi6Du313F71nrhPRnY6L57QVGi16nAOg4Id2ODMWwBzUiUPb7HBtVIoD2+B1zRX+CZkLkWuV0PTw5K4tHLYubpWwZOW0Khrk1eqkK4zHfw3r5fupZAqkw7NgSefNNuJ++6LB28aDVAgw5R0nr0/7lCnyNzDD8d1KAc2TQcpP/ZYnJ/6PvHLZzUVOjgIGsvY98bHLI98JvStK2+p74jv2mDM6zIXSDtnWC+zmtDJ8QiDqxkBh5074+dxpWEvVlt1v84J63WzI//LX8aDh5xUZ38rNu61HdoxInF+72SH9aq5ygCNe45iB6OvkIe3WOBqE9NkTuWhWTsT8gQ6E239dlTZpyEhKzl5y5fItZkAACAASURBVC4tXjQ4SLLsXH27GkhL1h9MPO+CQpOTGWVULtAjdmmGcLGYgDWCyuQqPM+ntSe+13mBSChkv5s8n0gqIOfAgKWtvr+506E5Mm7HaWuhXq+FyUnz4fR6JoadCZMSeUbjJL4PoDVpPvvGUFY8OWkPNOrCPjmZw3FcgmQwpVTBE0/Es85ZcJ6jZcgk9Mb7ZgWbJuBMnCYnD+45QuF9sSZfUIgJgXYugz6fzz6bLxDAxFyvQEoEYvkNSjGkDExX21gudZJx7jua0C1gu6lz1YJlV6FuxDwPUuYWcsibgvoTyWutSbMOrbl7fI9jfcJuzM8ndY/rQeMHFW19PlMiJ7oO9Zs0PoZgsB7wYoKRp6zeBtcqFN1RT0V9BxIy0plOOlVpW2gldDl31nWWtnrQI+9WKfV+B7VSaAJO45GKnGX/Om/Zs8fhvAMF/DmnFxy43hPR24MYnkcy0HZc5pNY48xbAHMlQh7eYoNNPvWtZnl4C5qTZqfEJHM2rEKSK3sN96BKCYCnVcum6RG9QjXo0nOY1o2efPNTJl07hDUPZwJo3E2BAb3aRAhQf00JtRwy9/jj5uth4kvhIjt2JPnX/v3JIwrKZdDWpBTuoAc58sCZtzQnzVuXWtrhc37Laudi26CAMKnkWik0Oel+Nm0aD9WDCJOTZr1oC1QbXwBRe9woI846tAzAq8WviYB84BzJCaP9zMNbLHC1ia4yl3XEUp5dPwkd2tpt9eV5zsKESQ7e0sKgMVn2zDPutgsTSNd5BxHPy6CQ80DZoBuQ5xLLYF0MiQMtWxYDkhMJhdx+FihrhCCIVzYshCzzay9VdDrkMCb27gsRP+CZOoHJSXP2WA82MUzlhsbDS5uOBgRJ50mFToDzGBAsA1DWWJvw8zlKyLH1YRVyRf+dieoyOCsc23wuFpNYkyvYZKsUYlljAz45aalqs91XjpVujNXztuiX3ckAr+3g5TEkgymaYxDe12sljW/GNkETnOd+AkbSZpe5RUbsTSW2TUuwqZl+IK6KJ3B04pqJtOU9W2rRqADwtQx+WpCvo3m+EJJYJ9dWlg496G/BMkAP2KdCryIApDOr6dAUJ5SDtrp8hjp0AcmPRiO5LhbCQfJUKzljGRYvc60UA2iAzlsmJ/Ntp+PxPZhBoQNYlnAaWi16ZbtrAG8XDnfmLYBZh+bhLTa4VhXl4S3WgH3GoeIxrDJcaxoC9rYKk3Ek+ZCNVwwiua79NtB8OmnvAs8QbEpR5Ilq/HxZrMlJc1LPtL2FAhmG++eQOdvWJlMlzFNPJdtNTiYrYTwP0RvYNPCaWUwlnzNvaT6TDMqJIPnSCOHLgKBBd1rOhHJNfuQpNJjEGuvfeLyyfIWdFpEzyr1eQS7BujNThy6FgYe25RvJFrGrIOjl4y0WuPJQW6FB6osrFgke27BCs2kpNIAhKZyDt0xiTSIx3e2aA7xWrMRzW9yi4HkXFMpbZZGAKXL6XGIC1snqamWO9NadxZdZJMqam5PR6+gZUoDzkGVdgJ991h4JTyzmzoyRlDz5ZJK0tdt20q33QYjk6f3UYNJMOAwGxFrZhEjRs9DbKpuMmDBc89uJKossOL+20UTaUuAcEFwNAG5Wc+fO5y4olOe+tvOSmCzz9byVTabsXOz7vDSZszzABAxl0ZZKvpRsRR44BwYMGYggiF7PHb+pRebywBSwb1mCTXrGNwWTODx5zZB9SjuI9jmBibTZMAxzKZMh49vp2PegH4xKIUbWa8WNjpINhoA9OU/aM6esMX4mfYuT8/lpSOpFW8Y3L56zSqGclQ4J5EyS6bwltw61BNYXg0msSTi+QWCvsjBhBzY48xYgOZ95eEsa8jizrrwlT5LMChOfMQWbbOtxAoYkmYXML4OhskmYq0Pbe93P1RuS91kETElPISxbKC0B+0SVRQpsOtQURDAFCicnk2aj1QLQMEfsec0clKBQFm+pOVaHAlRFnKhUa1qDkHkqhfJUE9qCzFyFwuNmCzbpW/nC/pqq25vm4KGzDl2GZKGB6CXfwJ2BhP1sPXtQdrW4zpFN5vTqUFdk8RYg4hChfNl0KAyJ+xy8ZRJrEsHDdtsePDQip++3GDzvgkL8asa+PuCYYxZwgyWIDNPQGqBv3PmjLgspgWWIyvTGT4j9iZVHbCGxER9/ERZyVghgUsgKaxs7NhbtbMj95CpRtR3GZSLLXGWxbl20DYezFQMDwIYNiPrAju/IUUB1BEC0vaBaBY49ln7fvTsi4UccASxZEvVBN4TT01EfDjsMWLpUNqw/KbNFJWDJ8XRNzVYMrgYGlgOIl+m96EXGR489MysnW9sQyxAZrCXHU1+EF0a3x8eBNfbEQ/Tdrg4Nk7bKMDCyNvO+xsMATVgpf5b7gbF0oWMSXq0Cxx2X2QVn7MRR6HSI3GSOO+zGphskHRp17rO2D9mMcdJoKgZkyXHWDAMAuUVLfvHYMTHibLwv32t03YIDRLnOFIIg4r+EJnTfvqgyYM0aVeaYtCkylwfq9oKBlfQPkBlCOUnjyuTz9oKB5cDgIam33iet5tKlpCeAeMZ340bK6h2srY/OtkIlbaPr0s/jmEDk/IwcBVTpDZCU9QOtCzlH6rbIww9P16GLQRopFYgC9itWAKuyiAtvL+ifAIYOpd/V7QVLjpdVt/YANa9nvUycX3m7kEohNeO7fv3CA0TPyZlCXB1aKltlLnUtqkmywVWRzKVA5y1qdaiTDu09N0EhDvBu2BBtq+JKtaEh4ihpeAprAbjxFiA5n3l4Sxqy2nKVax7eQtySeaiqQ2WSrH8iU4fyS4fQN07cGYhXhy45Ln378DIgDACMHZNeFa9uixxdH+m9piybqQzSde4D28yRo+MHrpruy87s8JGRDs2Bxx+ngGO5DBwvRW5uLlr3hx4KLONt142dknOWonFXj3MYXAUMrLB+l7otcsUKYPXq6G+mIAJXqi1bRv0A4sHDjRup30GAaFtk3xJgOEqa5Ala285oceYtXKlWHgDGpNCpVRYjayOZ463l5T7yY8K2PJ9HANWxRB+yqvO40KBUiubThqdxRC5fwdSWg4fLlwOHHJL8XNdT9CIH7PuWAkOHJdomzqXVsQxx349ljoNN1RE3X0H3KdVtkVm8JQWuvg0XGpTLtIaB+LbIww5TZM4BLrbH186OiyU9x+OTbyzwcOQtk1gTFhocd1zkz/JW5NFR4MgjMzq7XP6sDJMOfA7xvAsK8UD94z/SIcennJLzBktBi7k6CrzhaeClP3P+qF4d4ITlABAAR70FePUDwLq3h39ihRotpN1kQNa8Fnj1g8Bxf5j/+2DISLb2UiZ5+ZnAa38JnPLRZFuFqNrIiE6s9+whQV27lgzlF79I7Tjo8elP02FZxx8PyuagRMGY1z8FnP9NAFFm42MfowPYzjiDPl+tkgP39NPADTcoz6YRsT17yEEdHqZgVPjacj5Y+7j3A695CFjzGupDZZDm/7WPAa+kN2889RQ9xzveQQejvuUthjGV3/fMM2RALr2U2v7+7xuHirAURMQO/TXqw/EfghDR27k2b6Zo8GgGL3F2Jtgenv914PVPxoyICU15aGQmCWCn/7RPAq99FFj6YmtTroL6m78BHnkEOOec9Fu7YieOAgC85z007m98Y3r7rDHjZ969myrVXv96uu9735txX4tDk6i4a+2RMncW8JpHgJM/Yr/pOKi0dPxEGt/T/zn8U8KZbe+lYNPoOuB1jwNnXZPe4YznyJx7NjYn/m96jpUXYO9ecrpGRkh2Nm+WbVjmNl5B6/2wV+Xr1BgoQ1iqkP579QNkTBs7Kdh01Jvp+vp3UoaQs4av3Aa87rFkFloiQAnzIA9t61aSueFh0jOdDnDhhXSY51/9Vb7upsHZVoyDlM/wkTSf53w5vW2pTI7E658CLvwWXeds/8kfoTlavinUoePjpLN+8pPoNgczOJF2j1ksRblMRO7ee2mMrVtvK4gI1ytupbEoD5Dj4reAQ15Oa2rjH6f3x7Ke81QKNXrxRMneveREbdhA5PTqqzNvkdq3g1opxPK58UM0Poe+MtEkdS2Ogca5VAFe/RDw6/dlnlGk85bdu0mOXvta0qF/mEFb+HOZDk0O7MVqeB45X489RtwDiJzka68ljnLUUen3ANx4C6AEb6TTmYe36FBf6sFtWPfr4O/Nw1vQfIb05RGXSh36+yRvvDZeeUckczaw3/fSzcAbdhKHbu+he6w8n3TPi6+0f34c5CgtO4Xs3Kn/kN5W+OTIvm4HsOlzdJ2d5LP+ja6PrpfBDUGBjdc/AZz7lfT7lsoUiHnDTuDC79jbWsAc50//lN7+9rKXEQ8dGKCg4BNPKK+s56DHMe+hcT/8jRT8Lg9QkOQ1jwCv+gVsCeAaxlAqUcDinnuII7PTqG+R97zooN1bb6UE+uAgrct2G3jpS0kH/9mfyZvzFq2X/CfwhmcoOIR8dsGmy5x5S1s6C5s+Q5x8yXFyPkuUGHj9k8B535BfJktsTvk4+THLTqXPlypA/zLy5y7+YaJvtufhYDlvz7viCprPV6XQlp0ycHzZZSRz//N/GsZEft/OnTQnb34ztX3nO6l6lxNR27bFX5zEnwv1tQiiN9a+bCvw+p1hwJPb6m8kTGApANEFJk6Xvt/f03XeQnn+v9MYZwSEE7arvdedtzjcNytYzsH9//W/aA1fcglCHjo0RDJ3yy2pt4h/70LWeHMXFRoc8SaS5Q3vCduEQaFwfNx5y16sRqdDvtIjjwB//dd0nV+A893v0lpavtx6i8j3O/crpANl0P5gv+ETeB4GhfbvJwX5zndSad573pP9mRjGAKBEE+s1SQllVD8wFkTmuHrj+A/Rz41/ZL8vn6ex8Qr6edwH838fDA5qZx/t3z3mclI0G/4gbBsqb+XZbALDZJk/MzVFGYh3vIN+vv715GwdOECG661vJQX4rneBymWFD6x9K5GR1RcDA8vDqPm73kXE+/LL6b5CAL/xG2TkTjstipTydze7UR/KZfrudpsCVC96EaIsCI/hcVeQMS5ViTiLgCoMlm8KA40fklP0R8kpikX/1bb80wie+43chw9gvrUE5TJVRR17LBmJrACH8zavIVBG4ZCXE1Fb+zupzetd2hNsI58hRkFEat3bgcAHNrzb2pTfiPKe99B8vu99yTYLUVTPgozWB+VQmuZIRZaxUYN86v2uuCLjvmyMLW/bCMeyvZcCvMf9YULmEhgDtT3m3TS+694eOmYJ+WxPEbFe93v084g3LexVoHkDjcdeTkJ53PsxNUU6+A1voKq5Y46RVWFM8FjmNmYMpum7yn3AqosoO18epN/5/IWNig7tTNPfl59JBF8ERocYoOBEFR6OP54qPVot6vvu3aSfPvABerTLL8/X3TQ424olIGdt3dspiLjmtbFqhGTbADjqt6jqceUFVNnBFVPHvJv+fuz7Qh166aWkQ086iXSj2rdMuXdA2nNOYSX6+4HzzqPAd7VKjokRY6A5X3YKBbODHrDm1dImCsUmfiC9P5b1nOeFCmxbuO3UFAWOL7uM1stv/Ib722pMfTuolUJcvXHc++XPJGdIXYtLQIHY1S8h21gdJgffAXxfdpJZd34wg7bw5/SDkxeDKaxEp0M8wvOA3/5tCkDOzREned3raA7f/nb7PQ5gmTNvAZLzmYe36FDtFI8P8y0dfK88vCWsDGAeevyHSIdWBslhHFxNesgWyB8Cla2MHQssOZa48xFvJEdd9Gj9CQEck5JVWQLiJce8l8Z0/WWwVsOPgfTh+ssoYXLUmyno352lgMoRl5KOWP9O4nWBBxz9NqrCOexVsYqRxH2FTNJ6LWDlefTsDmDewknP90uR++AHIx76mtfQOluzBjj5ZERvIGIOuPGPZFCoDzjkpQAqQN8Y9cOAKazEwAA5jFx59rKX0U9eBxxEmJkhvXTSSVQdyoHaXbuIi31Aqs4//ENgqL9J4zByNLD0RHrD5xGXAsjn59hsiDNv6c7SWBz1FprD9b+vyNxvk8wd8lIK+nRnAJSADe+kvx9zOY2lEMCRb6Y1OXFGWPWUlQhgR57nk/VWGgd8FlR+xbKWx1f4oz8ifjw4CJx5JlV+BQHwylfGPxcmHLuzdATBkuOBsfUUZDjiDanPlEAoc5fTmG24jK73ajSmqy+hMV771tTbhImS0KeccuctKciaIw6Wc3CfEw4f+EAkc699La31I48ETjzR8XtzrPEosC4N3XFygRwfLZTwWIpYWzfesgeHoNulZwsC4N3SvWo0qJLs3HPJTzQF/UMMgYK6h72K5nvd78b7cxDxvAsKzc2RM+37ZPQvuCDnDZaAhGPlBUDfKDlhy890+uiCSDRnJnjr2FhyT03kSEorv+w0+jnssLfIADYS4X0bcjGvPJ/6UiqHJYMmB8Gq6LtxRT81RcJ4ySVUrdNqkSGcn6fATLdLjsDFF0Ma7h6w+qVkDPw2MHE6ZmeprLtUIgE/7zy6r+cBF11E1QjdLilR9bs5oDE1RYJ0/vnUVgjZtjNNSmpYVstMnBbt415xDv2tVAWWb8LUVHw7okmx8Jjw/u6TTqKfR6dV6nE548QZ9HNwFaZa6zAwAGzaRP0eG6O+pyERcDBhAMSvJk4n41EZAA65JPW+uvNjxRBo3QoPKFfIUUd8WwL/PjtLpfN9fTSf556bvN1CFNU0VmJwMHJssyoEeayyqt54f/epp9LPrDJN2xyEB83pJHzFeSRv5T7KqpiwDDS2qy6i8Q26wBKqkeU5inTEPgogrb6E7um3gaUnp3fagEY3HuC1YgSUsauOkJCuOCeUuQsuIJkLAlrP6MwQGR+SJHvZ6fk6tQQ0VsvPooBPZQCY2CSzwyUirwCVmXemaKyWb6JMYWWE5NqAaaxAPzo480zq68gIyRw7s2efTY82Ohovz18MnG3FGKSzeQk5PX6LMqC2tkGXHPjqEH1u+RlA7wBtbSlVaPxWnoepKbKRrEN7vUiHct9q3cWfrZf2nFNYiUqF1kZ/P5HhTZssjblKbPkmeobKCLDi3KgKim30wAoKfOfsT55AWOjAy5/79pGde8lLyJ6128CL7cWSVpiC8KoOXVBWbxS0nWdA7s0zcJnUZx4DLf7lZ9GaKg/QHDhAD06cJmlL1pbogxGM1PEsDoHnEdeoVokzHH88cZJTT6U56+8nrmLDPJY48xYgqUPz8BYdJv5lCyCpQShX3hImyZZK4jJ6NPGhcjUpcyYsAdADtRUBBTJWnB85SivOoXVUHYq2fupYBgABsOpC0lUiiLYM6RhHpOvKVRr3JSfQ286WnUz/L8tgZntKtn0pbTvyW8T3bM8hPNK3rEOZn2WAx33/ftqqMiGTfmeeSc6+EMR3RqRvTDZRBt54i86yUyQPLQHLz5Yy12/1QXQdOjxM9krtDwcRpqdpPbCOHR0lPs3BibPOkl1YBhxzxBTZ2BWbKBjTNwqsImcqj3zauJwTbxk/ibaLj59I81euUtC1M03/P4RlrkUy15uj4IgArZ9VF0TBidUXU0A76IbzmWXn+O8zM8TD2fafnkJbONGxXu5cNNkB1W6USpFcbthAMsvzWanQWuFqev5cGBTqTEdrQwTEwWTA3nmOeMvmyvOirZ28vWjiDOkrDMoApR0J29WZcuctKeD72QLgzN/376dKGT6q4KyzoiA8J52AFH5h+d5cbVmHTkjnQ9l2F8gzQMO2OXjLLnne5Xnnkc80MEDBoP5+0i2dDsn9xRdbOtgHitQsOy3y/Va/NPdzuuJ5FRTq9ci4n3FGtE2ShdMZTKw5G9Y3ajeEGhYUdRsDZVd4f6HhTUFRieU+KvvivZrewiY04aDyK51HpFMqvFBxmt6IYi0J5e1GXpQhDIIoQDIwQEEhIWiOeI//xo2IKieWS41bHUawdBOaTWrLJZVHHRUFm1hZjo4mDSErEa5WuuAC+r6xMRIudGdJSfEYlgekAfGBVReTAaoOAasuwswMcMIJCM8KMh3eqBKx9eujw6ZTD6YdB2WhOILuNTElzkWlQn1k8uAaFEpdf2OQpO3MaH+vjRhJmM6TSqAq/y1XiJOsrFO3JXT8DoQAajWaTx5Dk4OwkIq7/ViGk0+ODs91PftHf/uY3oepKQoE8Vq1Hc6rf05HcvvYbpoHDuwGvfgYqpgAGeywYrEUERtN5sIMBG/hK/fZ75sCNvI2JyXEEGSgkc/iWhlWTpx/viZzvVlacyxz1ZSzHUwYAymP1RcTua8MSJI4Rc4DO81eKyLWqy6i7ylXqK0BU1iJCgKcdx71tVwmfbFnD2VfV8gjHTqddEKYB862YgIAAnJ0ABkIs8znEkgdKolGdQRYdiZleSfOiN5uMXyEUYfy7+H2FIvTmQdpzzmFlRCCyMzgIJGcl7zE0ngJSKhXXkjPxcHn9l6qhuKzP/xmql7LlE8H3aNnL7makMl9tUo6Li9Y1jiYAMQPc13QGU/DoPHwWeaS2drUtcjVZ6tfQuS+MgCssk2S+b779pGe53PGMnXoc5C93IUjUC5H59iVy2TTBwZorriy62RL/LyBYQiUnHgLJkj+mIPUOuR05uEtOkyV2lkBzjy8Be0peQaPJC5eS57hVaIgjSpzJozJj648L1pjq86nSqHqWBSU9Lt2/TUBslejnEkL0tuq5/CUq8CyF9PnJ86IOPLSE8nWCi9y1iqD9vtyED7UoaPOQVAe99lZshM87uPj8YBgpUJzf8EFoLdFLj05somlkuShAdmrch/1d9XFxu/UdWhfX+Qc6pUlXDlxwQX0/eUybY3es4cCWOOyqrDVAs4/k5Mq50S6VVYrHZTtYy68ZdnJAMpyrmTAYvxF5HwH3Sg5XhmmBBNXAvEaHl1L69pvAyukoFVHKdiGSH5sHIf7NjtLAW3WW8MptGUGy3HiidHcm146o/oKGzZEh023WgirrC+6iL6nUlHmk1+ewxWUnSnihSvOoyBsqUzFDMgxR/wG5NG1UYfHX0R6fvmZ0flbE+nEJ1H51ZyEM29JAc8N61Agnijh75ubi8vc0qWR73fhhbTWR0ezfanwvgtZ4+0pGQiSzofBP49tr3PkLbtxKEZGovOlej1KaPT3U/ArFmQ2YQyAB/ID2PeTAbrn4g2zz6ugEJdHnn12FBlst2FP7+qvlgGAQ4flXmV56mCpTAEi0z20a+EAm9qavgsARkpS4HihJ9uF9+0eoLZMFMsD+Z5N9i0RROjsI2XMi7gyCqw4K/bdLtvH6p16rO3u3VSmynuch4YoQDQwEI/e9nogo9A3DvTJ8plyPw4MvAx9fbTwuW2rRfetVKjiBKDfL7yQfmdCrVYKdTrRIdUAcN65gg7PnDg92loTdCjy7neiigMAWL4pVDh83oXxDaLymQ8coLas6KtV2OdovCwJuyT7lSFMB6eH0W31YEzrPdT5TFt/YwCEJHh8MGZ1LPW+PJbhfJvajoIUzopzyDABYWAztmZ6LdRq9ExnnhnNJ+9xV8+PSP0+y7quYRynnx45Hp5n+by8r+v2sf37aT45KNnfn3Ffi2wknM7OPsrKhgESST5N917RR5VBfAh631gYqA7nKAzw7qaKI46KVYfJkc6jk1avxmybzhOY78yH1xLoA3G1iTNigc19+0im1YP+zztXyOCEInN+J5/+WjNGWxHUjNPEaRTgnTgdIRksVUiWhR8n9OMnGr9vGisgSmUKXEkceyxlVk89NSKDIyMys59nLE3XlfWnX0/gkH7KrPNZHhW5Zc7Uds2gdMDk5nIOCJarstJDCp3XxJ49tET4DBW1qjYky726vV8pz6YiTSdNj62D58UDbaecYvm+w8fJUZJ2CQCR186MpkOHaS1Y7LXz9rEcevHZZ6kilB2AkRE5ljllbr5NsqZmro121/W+JVCF6MTpERk0vOEk1W4cNhad88KYOC0XH2KbyEGJgQHLd8l7OMtGDpnb03ckjj026sPoaESsL7wwOgDapt+nsQID6DrxFg4+s+7kn3l4C6A5P4akXNOSFOS2eXhLxC0lcSlXpQ4N4jp06Ql2flEuyYoDOf5jG+gey06OByUnzjTfY3mVKub5wOvqKDnzxrXWR+fP8FlL1RH6bLmPKkTChEOJHNTBVZEMZOrQEWBwZTQOqy1tV69O8BbPI456+ulR8KDVIlvSbscPKj77bEQ8lINYgRdVwixTIpQTZ5jX5ZL18P14EJoDm7wOeIvN9DTpKA5EAtSfmRkKerBDPTICnHHiNI3dqgsieRohY+Esnyn61om3LH0xJX9Wngf0SX4R+CRz/RPhGUeo9AMTp8oqxrPJfwEosNnaTX/n8zPLFWD1hbE+qEF4PeAgBFCv03yyjuh0LM8LYF7yUPZ5jEEhLXjIbSoVmiPfjzv4nGxIjHtnGmGVD0MesO08RyuqxIs8RebGNtAuiVUXRQd6942n6mzWW7GkpytvSbGJYVBIsYnqeZ0tr4Vej+bkjDPiMjc1RTLHB08DcmfCYn15va2n61DpLBgOyo98bnfeMlU5NJbwHh2lwgMO6vJaW73a0t8xAEEpOnYBCPXjr/z2MS6P5BP0ASlwfOKxCiFI+tTrQgCXvYmqN9TXGA4fnryHEMCePWbDbWrL36VeDwJgRG7V4oisIXseLbpZiuiGEzsUfZft+9Rrss/hQZChg7o/fsJ8uRK+qSSxVxQWhYNkCeHeveR0qK9oXLKElJ/65infB9DaQ31QXlc63V4bzqd6AOnkZLQnmsFEi5UHR5YnJ6O9uYzDVtUAlEmBsoNaHpCvLq3G3k7h961Gq0WknxUOv7VHBY9PrUZbmGJtbXO0cpSemQ/ArQxguk1GXq2g8TyY15Scz8Shfaa2t/yIBn9UecWK30q9L49lSFRNcvTEvcDwknA7E90jiPdH/j49TaT7+OOj+WQ5Na4vRzlqNQX8Sj82bIjGfXAQ9nHfs8f5oOn5eZpPziSnzueePfa9QlvdqQAAIABJREFUz9DGpDMTZWcAKXMbzc988jpaJ+rrLuVbpBLGuLOP7qvqr7EN6WOpQj7HbIeCQgfa8jQ709wfeBroGyZdUZaWqVTB5CS9SUp93erhq+eozdhxisz15dNfH/4Teq4B5d3H/RN02OLIWoX0D0fEWj0PojJoHIepq78Lb2hJTOZ8n5zZtWujtVqtSoLhMpb8TKbryvqjS8I8xkIAF59Oz6a+tnhsvbnt6y4k4q46/tUR0i/jx9Mak5icJB2TpkM5yJ9rjrT3I6fppOk//yd0u8BK5YVW4+OWcfjUR2ju1a0npSrZxJG1EQGr9NvlKEU+E5nOFL2oHzS9bx/ZOQ4cAzIguliZw+L0IlrTQHUAGNsYcQY5Ts685f9cQVUW/Upp+8AK6/iqUDPtuXSoSScvUuamNpyDtWvjOmnZMvJBwzeJQcqDSUds24nKkhEn3sJc6kCL5pHnMw9vAeJVYuq6DbdUdO1VRb6PXLwFXk2+yUk2rgwpOlQ5ZFbV2QwhgH+/Bhgbjt46BpBz1JXckgNF5SowbpHPE46Udk5e4zfmmdpu2ijbKkLXt1SrqAXpjPZeOUeKXhxdZ77vmy6hinm17chauz7R5PPAAeI4GzdGBwT39dHcL1kS938PXdWixMXYBmXcB+V2aAFUldfTDa4069C//CQ6nfibG8fGov6o4GqlQ1UVWorkk53Lvj5gw5EyqaK8dYw5hbN8puhbJ97SNx57qynd16Pqs4SdW0Jrc3xjfJBbu+mtY2pbuU2fZS5MfEE7u8trYW4uelMuB4X6+mDUX72uQKc8hPXrI1lLkznmltxmeJh82G437tvz9ybGvS3PylKPEdHfiKXCNEcbD9d4aJk4FaD5Cu1Um5iocm3tdectKTaRdSgnKfVna/VamJlJyly1SkH4iYnYXWnt57BdTm15jffmJA+VE2by5cMgvDtvObD6eKxdGy3rSoWeS4j4ixHabUt/b/up9P2UbVN+MnFve1NgXjyvgkJciXC4osd4kTijO0tCpisnC9QtMrlLsYIeTdrYesWpSqkUCjqk0Bb4munEfUNC0CBjzsQRIEUKQ0QfcaFUMyXcNiQ4NXI81K08g4P0f37tMyCNUW9OKrdoQde6y1EuR8QJoPmcnaX7qiScT16f68wBiBT9gQPUVg1MjQ3WZJmyovSqQ+SoD6+JEbxGs4RqNYrMAlE1iopWr4UgoO9Zty5qYwuCAwCCFo2zMp817xAEQfx1taaybxVcTpq6/rwaBRUGV9nbaGCCqhJV431LpTh5kIrOVClUqcTP5WFHwaUSzYZ6ncZb3SqaddArf5/6VpfY3z3KEnU6pHhdXzOd1ffwOf2mlDnlxrYzhbw6rUs18yDHW5c59GqSmCsLz3aGQwrYkWGjbO5XjUjbiGKZKoNmmRuqkRM/dnSsbS5099P6Vd+W5DWJCI2ui8anXKZxKA/GX4FsqJIASE8JEZFpgPrebNJzqMSOz6xaLNT1nvr2J29ezqeqRC1vAmEdqq7pcj/ZlGFFiVYGjTqUCRTL+3w3Ist5YCrvNmF2lhxzVb+1zVNE81mqIPb2o6BNunr48Pgrb0ePTn6e+2ORz27QTf27Cr2qo16nsYw5fPlFzihzi9GLNGbV+HiUaZyceUt3PzB0SFx2hNtbwcK3H8lDPp116HNQ0s5zxI4vQHItRPy1z7Ztx7WaO29hG7u/Te8KZ4cmD28B7HNv2tqrnjfV8lpoNODMWyACCv6oOrRUjtaPancsOjTkF30KcQl6VIEwvCYun6q9iN2jYbVzCfSkTVT1O9uTQTXqUaakga5D+Vw7Hd05aqvq0JRXwutzVKvRuKtnSQ4NUcXxmjVx/TZYqUseqhCXygAlaYcOJX7IEObzxObmiCuqSU+u+NH1Ba9h1Z6129T+8MPj1w9dUZPBYMWr5qDQQg7hRXyNOvGWyiDoLWOK0JUqNJ+6zFUMdo4PHh9aEx8/WUk71yaZY9nT+8ucVZ9Pmx7LI3O9HsVCdF+hVqP7q0lwXjOJcfdqNAZ9CnFhO+Y6R+z7qW9mrQzT+h9QsjUZh/5zAimczzy8JQW6DgXyy5wahOetVia48hYdLa9FhiToxIs2bG2BXLyFeai67oaHaf2sUFSTqSoNQLROYgfml+L9wcGzu8+roBCXV6lRc1ciEsKrx7MdQDxApGFRpM1vUjBoxE5iw/sGPaQevLcAxIJNI0fFnbQhEmAOOKgExPbMemVJu51czEzK1Ozw0BAiJ1khBM32EEqlOGkbGoqERCXhLM9MqJlcMRlUg6edZjNpQIBo7hUD0qx1UK2anUE929pq0fOtW5dsa/gwRfnHNsQCgU1vAsuXxx1qV6SuP08+s/rWDUN5owqeR5WoGu8LxA2IVHR6pVCzSaREdZjCoNAilFOzmQw2ZX4m44A1NtxAvnPJsvoeGYWOzCooBmTIYjT9dtKAyPFOVHX4bUnCFaHr19IlDmDCpBrjBHhNqaSt3GeUuW6zSYRuSJG5jFdbJ9CryYC9Ihw9WYE0qgmdV6ND5P1sYt1sknFVyYMQJIPr18cdSdUpXAyc17vPTpWyTvqXWdpKHVpSOix8ELFW1lZlAI1GMmDPpILnPDUYnAI922oDJw1UXWcNgHsNGZxQ7hf4ZBc1HWp1JJEtny4HL/K2ujDb3UrauRV2P9IKlrnMSiFX+Gzn1IB9OXGvVLvBzprKgXw348Sl/UEQr8Zx+dzBRruddHz7+kjOlyniZEsmMLd04S2okOcRBoPkzzy8BbDPfaKCF8m3kzWbcOYt8FsyeKjr0LrUoWpA0OJ5eE1ytgNtbQQdYGRdfHxsSQrfkPS0vfnLbyeTKuU+ACLaPgtQYoB1qOr42g6j9xvJYFPZwclDNO6VSrzSu1xO46GV6CxPhscyp0QPLYmD+flksImDjrq+aDbJN1Lbsp3bsCEeiFg61qQtkbFXmicdSaFXeGhQ+6CuUSfewnZMDcpVhmg+dZnjbqjrpToUBRpV+yDndn+LAg5pgVieTzUxbUv0sswdZYh5qsnHNF+hViOOoZ5FGp45pOtFrwn0r9DWhjC3tcHv0PqrKoqRE0l9o8q1dF8hUXWVh7ekQNehgFnmyuU4N6tUEHKcWPFsyrC48hYdrV6L1m+pEg/w2toKkYu3dDoU8FILXPr7yVapQUdVfmNgH00N2JsS9wfJ7j7vgkKlUnRgGpBRqWGC15B7IZUZ0A2dgkWRNq9Jim8o6WkkopZ+i5yfFMKbF+GhhkE3GaXUBDh2zoHlmflQaiY4rRYpU5VocTRdJWeVCqSiPzRmFJoNIqJLNfvdaFBgQb0vO3RMqDnLzW1Vx87rSLKsV814dUlYlCBNQ6BSiQemwu/Usq1sFJwcR79tDEw1uqNYtSruHJmyDSakvi3Ib1JwQF3LZUNtq+F+M62Z9PuiFM9WlAyOhxwfIE7C1b+Hv+dUTmwU8rwZynS4oJ5t5fk8PIfIZfU9dDqNMmcJ3gQdChyrBkSOtydJW5jt8tuSWCv6K+vUbQP4fuyoGsHnRAzE+80yp65bry2V8+BKLBheLZ4F5j6YdGhvnmQ55sSYjUG9TmtHlblqlf6vEzy9HHmhcF7vYUBQIcvCUubrsQ5V5Lon50/T5zxHKtEIdajU3wt9+5irTZyfpz6opM26VMP5VAN7cm714H5aZt9S5crIEwjj8Wm3aZ2oY2klaClgQq3K3KJIGwdtDePhzFt6NWkT1YmxO4I6b2HnJ5cOVfqT5XS6gom1Oi++T1xRzbDakohsC1x4C5+pp1ci5OEtgH3ueZ3EtpcZEjCuvMXKQ00yZwvkew06TFoNHpb76P+jmhLtXw4jgg7ZRPU7+i1V+kE7vv0CIJtaGY5/nt82NrQm7vjaqt28FtkYdT5t1VEwBxFKpWRQuF6nuY+tv24TQDkZ+Ap5aLbM1Wp2HarrC9a3nmY+giCZUBsdbJKtVgMO0sF3rnJFcl0ynHhL0KI3TqpBuXJVzudhcTvnyfvouzr8ZvxsG/4uINyum+bb8HyudKAtzENNMmcL2uq+As+RqpPCIxYSlUJ1qnjTZQ45dCjLnIoSksGmSrqvwL5kmNDIw1tSwDo0K3CXJnMx3y+lC3l8+cQZqCEPXZPyKaXAA3DmLd1uMrjPazJWeWgrgPGbQN9EXOfJefmVrxRqtaiUMmu7TSr8FmXhY1sb7EK16EqhUtkYQU1ELT2ZzbEZ1AWg1q1FUUtbRobbKmQ565lZMXQ6STJYq1GQp6PbEs4UKBmaVtMPXyOvot0mJ04lV3qWOzzfqEnCowpMyW8hEcgAqCR5YEWMaLTaZZTLboGMViva75kJzs5piqDW6MeKFfFnztoKxQizLiZ4LVpnMQOSLr68xzSzWqRv3FhNp79Gt9WieVCVNGOxlULlcnzLXRZMDq/eB57P5TlELmuP7nxnngIVwkvKXMniSepnqQDxvdpQtpwE7fgec8CaZUyD0xYi1knaNjCuvIkZqcAic3ngSflUK2GCHo2bFphCrybbqg6CObpaq5GO0PVMuRyvOgXS3zySB+6VQm1gSFOitiRFILPnytlB8OqS0MWjLa0WPZtRh0qyvKC3XcHdJtbrtE5UR8mkGwCQgzqwArHnCHxyEgY0xl61r7GsvuUJhLGd63aTb1FM2DcHmM64WFylkGxvkDn3oGRD2kRlYmx6CknewkGhXDpU6U/XsSopC91uckvf/LyFi5j61HLnLVzhoW+/zsNbAPvcc4WDCpOtdeUtxEVsOnQlYjJnq5rxasDgCsS4Mute3c7ZtlcEveQWE9s5F36Xqpj0/vYvS9q7oAOMaA6YrfqfAw6xKhS7J2niDEB0GDmDeag69yXm/30acfHcZa5WS+pQTsboAW62cyp8n+RTd6j7S3VZcaXMp0yU59FJ+rrUkcpbejVgYFnyjcwccFBte69Oel+vBvbbtP7UNSfbcMAhbRdEq0UO+JgDbWEeOm6IY7r6CjyfKjUP39qojJ8QgsZncCXiczQQfgcj1Y4HvWSizWskfYWMqm7eURL6Cnl4SwrYFqYF7niO9K1hjQaNpav/lMeXT8hAqEOThi6WbFYLPBx4i++TjdB5aLdLul09I89aPOA1Kbiu2lJT4v5XtVJoYmJhW29C8F6/WLmh/TEXTdpMRsF035QA0kJR79RJUE3ZRM2wppXv6eC2JiLWaNAcJQJ3ficRZbXNJ++BVsHZEd0QNpsUjVedjQqapDxLmgfiNynbpRCfZova6EYesJcxmoxCAr4sHdbmc36eDLdqFFyzzqmvD/eb8rvyZ17VPdfJ+7aSFUgSpuzlsmVmEr4Y5cSOR56toqaxspUOO82nhPpKYZNs1Lt1WSVWTRqQwDAwQsjDPjWroJHaUD71g0EB67apNJheBZqA36QyfE1XsHyq67YcNOUB7vmrlkJ4DSJBMYLn0T0TxLpORleVcYtDMz+fJNa9Hq0pnbQtxNk3wXm9B91kQNA2n3476SixfFrmSNUzrENTq8Mc4GoTGw3SdWqFjZXA8XyqjhJ8ow61bnFx6FueSiF2aLrdZHY4LSNpg+lNK4uuFKqOwqTznXmL15Djrmbr7Qc12myiKThhg+r8HCyi2u0miTVzEd9BPTIXceEtPN76Nq88vAWwz70pSWOrynXhLWFFmV5l4dWSMmcL6PTmpb5VFIrfkc6PZudMSYrAl4kSzVGyBsC75gqbfn3Lk/w+3fG16QjfEJxIgYkzjI8n11SzSToiVk0Ic1IFXp3GoaxujTPLHOtQ1SFkHapynEAEYcBB5cK+bw5OBN35ZEBwAY6kvi51pPIWr04VDnpg0G8nbSLzW329sD9nAAcc1OSdSX8ND7sVW3Mg1nRuja0CSU9k1us0n+ocmeazF/SiRElsqyN90EmHBj3QdkvN9/PqwMBSLMRXiM2nK29JgWmrrE3mdN3capHvp8qGNemEfL58QgZsOhTxoFyj17D6fiadxL6NHrSdnc2xRZ054GJ4QA48L4NC1gOXXMClpirSSNBiSVt5yJgFUO9b79blvkBtn+cCoEYta91aVPamb13RDGvsnIOMZ2Zlq79ZBqBFzienxxB0Eka+2SpjYiJJsNvtZLCJhV3P9PJZAir6Sk1ShLoT7jWBkbin1Oz0Y+lSM8k3Kae+PsfIdKhE4lahNh8kHKU0qKWh6hwl0ONMXn6nPP2g6SZlGE0KzUBUTfMJLL5SKG8wWCXWPIZqH5q9ZhgUSjucTocp06uWmoaybDIKpuwlB231CkFtvMPAXdBb3BYtCS4LV4NcCfDca/3ms8RU9JflmRMLqFqKvq+RzOIGPSLVJU1gvLp8DbFaImjfPqbLHM+9vnV1UVWoCpzXe9AxzKdFhv1Oklj7HdLtmj5vt5Ol62GGeYHbxhiuNrHRIEdJ1ZdW0hY6SkpjliM9IGgKrkpkkeVUHaphrjMXnsmxkDOEdLBz4lIt4gS/SXrDUG3jzFvCw38dAgNI8hYOCpmCEzbYHICFoiff56HPEScpXBw+tjEuvIX1DOtO1qV5eAtgn3vTGX+mBIwrb6GzLfuS8xoG4R2yLVxVpHJldn7083tMds5v0VahBA81OJIioK0QiURm07wF25RUsenQoJM82y+lMs7k7NsSmUfou0Uqsr+6fHpNqrJQKz4tMtdoUPWZmhDj5Ia6ptpeO7Rzqr61Jb5EV1ahGM6SielQ1zMUYdYzqbzFa8nqNU3oTAFBvy15qF4p1EkGJ+QzGWXOwOmXL3dLBrHMmTiC6b6Dg0meX69T8FqdT3ZHEsmCMFGSdBbUNxNa58iTcq/z0DAgmN+9D3VTHt6SArYFWYE7U8Cez/pTkeZXLbRSqNlrRn502tvDIX2pHLzFxkPn5pLBQyt6XPWXHP8XRKVQni0kRvidZGYj5aC5rPLI9O9q0qteTYtBudd8Z15m5ccXFG1Vkcg48QKtJj1fNeCgVotkPXOtU4PvEyHRjU27TXOUIGJBJ6Gcms2KcT47nWQ5uimaDpBi0MlgX4m3POkZiBZVCql9aJWtil599lqnFhoFp+CEb66cqNdJwblWvajl9anbvHrzdHBgxoFxJmSeVdQ3DqPCMRDV8XEDscbi5CjNGNugjhWPofq9c525sL95sv4qYQ9fc63LXGhAHDwlbpvYAhIf7/nOfHQYvW5s8h7o7ArWXxppa7eT8hnK3GL0l980ZIdltZKeIfQa1Nbh2Xkbk06Wy+XkK2Vdqgpc4LTeeWuvnn3SKxwZQTe5BcTvGCtRO51kdpiff6EHTDNcZZkdGifwmSVqcMKXFZ+6TktZYyb5VAlnqg413KvbNWd8c59lqEA9lHRR/ILLxg3j4Xxfr5XrrTE6b7FVTqRBXX+5n9nUJ5ms0beA1GoUFHIh1swtXXgLSmYbm4e3APY5MgaFDAkYV96SrUMdSpW9OgU41ABSyC11R8lAAPwmBUGcbKKstE1UNsn1rvaXK237Na+qbNOhhvlMSQrrc2Rb7yYeWhHSfurnG/kt57fEcmDdBD24ygEHtXKCz7bRnWXBW/EMAUH1vi4v7DD9zkjlLUGbruk2POgm58jvmN8SHXSSgUI5ny4yl0d/5ZE5m6/ANtFkP1Qe3uw1o+30hoChyc4lEAZtNcXoybm3yUgKap1aft6SAtPbgU1ztHRpco7a7WRRQlpQKI+tTehjj335pPMXm3suxHDkLbbENNsup/NmvXnrfC6KX1jwvAoKtVpkZBdwrmqEoJM0Yik3XPRB05Uh42JQ71vv1clQVIbse6wdofYxCgqVDcGCUuwQOVXJZG2RqXVraLfJ2OhVM60WOVoxpcdKRDNArU7FOJ/dbvJsDyZ2+hkEprbwW0B1EAly4rcTpIT7azIK+pvXWq3oVYGZ8Fq0zrQMfqNZyhXYVPuQus3Lq9P3uRA8Danb0rwGGSWDjOiEgOXThMUeND04mK9CMHaYq/y+WJa7Uw/nPk9QyJTlTsgc7z92MZKebKsT01IpFrQlY9MiOS7rRG4Bp94CKGcFVPyWMWDe6Riqq/yWlO9FHBxrkE+S5aHklgGv6Xx+kSmZ0GzS3C+q6jTtO13Ku9n50Ym5SYZDHapFsYKOkTSa9CJnmBebMYrZrhTd0Wq5ndUAgPRMYotgi5IZKW8H1WHampVVhaFCJam1Ts26dXUhB00DSZlb3JmFdplzr1RruTnqhvvWewvTobbzIxYKPr9Dtz31OsmASwCvXnfnLSr5VuczD28B7HOvjo+pyrXRa+TiLaRDh2kLl4ocOtQonxb7YITfAmCwc6bqAraficqmevKg6aBH90j0I+X8Pl2HpjjHprNiTBzHbBObtHZ0x9d3l7lm065D9Vet2+zc6GhSPkt+g844MXCA2GHoGfIZ8xVkW2fe0mvIw8HV1/XJ8xhNdq7cj8R64cPHVUhfJxABSvpZe4bzagYHzYlMHWk8VLeJNr2YNp+xc115y5Ih4cPfYfruGFiOdN+vJ32FBQSFYscjuPAWB5SRbhN5jnS02/mq/F15i94HeuYWrTOTL5/Y9ePOWzihoduoRoNsiVNQqDcvfb/kfP7Kbx+bnydBWyghA2BWIilITHge+BwUMpA25b6NbkOeD2AOIOVBIogQ9kHTZKVSrA+qQjIpHL28jzMQNiIWmyOLEmk0yhgcjMcbhKBIvJ7BV1FRlE+nYwoKNQ2OMygzoQUEWdGbjIKpVH5w0DEoxJVC2nymGQUTnB2aXi2XomfDXS6VjdH66L5S4RhUgalSyBa0Xez2sTznCQHmt7zoxHohgQGTbCTeHOM1jQFBozr1LUHbUiXmSIQ6olSJv8EDiJeh50Aly4h7MuOhEatOxyCfnB1ZDIxBIYv+8lupBw6raDSSMsdnCSTI8mISDgqctshwlZg+bqb5ZIKht/XbMmgbX1vdrpsOXcjbn2x2Q0e7nWNbkd9KOqjh3LtHHGJl9Tb5TIF6PgDrfFOmfaEcRJe5RW8fs8icM2/x28YqYht03sI6NE+lUFbSKS8426oTaOYiLpVC8/PuvEUl35Ec5eMtgGGLgoS6htkGxGSuW8vFW8LgBPStN01nHUoVw3rFQVM6P7p8GpSo1yRuotscU2KC35amB5C8RjLx5cv7pgTuQgQe2ZEczqxpK4uJixh5qNdMfhdAVS+OMtdq2XVo7BxQ2TeTnTMFJ0q+Icgn4bQ1ScL0ghpn3uIbgnz8ghbTVsfqULytLWiroKLZUtM2L9eDivP6CiZumZYoSbyV0mtYg7b1ngO/8Cz2wW/IcXfbVcBHkpRQorOO8vAWByTmyCBztkBsmr7V4cpb9D6ER0JUBjMLPMJKIUfe0mxSYEuXT+asThXJPZajpM4z8aHF4nkZFFpw6baDEtFhy+A4wWtK5Zaeyat1arBmFXIisfA9ywItVRJOcvi5lGxrlQ86SyFiicAdlzFqRn5uvpRoy6WZaYq6T75lyA98dLsGI+01zSXBficREGw27SWHsfGRBNg1qxDOfSIoVMp1/kJinVi/r04OtWO0nqvEqllBpN48rR+DwtcrhebnaXxMDpPadiHbx1zPYGIksi4wG+5FVSDZKhFsRsFGgI1yH8lnpVShtz+EASS9qij/lkEgkiMrvAZQjUf5rM6P10ySvrzwk0HbiNjoVX/5sq2mt8WYqv4Wsy1IhVM1BFdx6uNmms/Q+dEUI8unYqo9j54rLZDKct/LUYXDSFS5WtBu53ibm99KOkpW2bBH7kwOTZ7EDrctl8roBb1wm6Fu55z2+hugy9zizyw0ZM+Rg7f4hsrpFOj26GBVcS4GnG01XR8acpurWs2dt6j6kOczL28B7OtSQIQBJFNgs96p5+IttE4MxCVPQDA81Fz9PMung53zm0BlJLmVysRXeNx1J8drkK5Tr3PAQU+qmHgNvxUoR/JC5y087qbqdnOixDBJhuSkDWnVEPpbDFutZFubnSv5hvmUcKpCSWnrzFt6tvk0BAR7Nen4qm8B7Ej7aZ/PPqVqSH8e5oCu3DItgKTbRG6ri1xakE+v/ELKHJn4bQKeTEzrQVuuEHTMgHGiJPQV8vAWB2TZxFwylwJX3qL3odFtKLouvcAj3J3jyFvYfuapKEuAd4kYfDTbSy0Wg+dVUChP5scIByWiY/GVQpagkGkhlRe5/QKGCKelYgWoxAiwWgmUlm1lJcsZVH0uuOwtdj003PFxr9WS2TlbBZKKfmkwau0WfN/moCYrHKhKLN44rQrFlJ1zzSrYqsRardKCK4UyDwWuuu9L4/v2p+ynp/vao9D6FhmeT5NjvZjgaloFkg2mbHSsiq49ly/Ix5/TDTcMMhcaY52JWQhwxVBVVK6G/Q6NptcESoYFmDNDw9UhA1IPWqtFevMJIsbOT0JmQl23mMNWkkHbKMutf18+Ym0KCpkqHA5WUMgp28oZN122TAs91KE6WZ5PZM9brewD8XlNLYQoJAiTBbnKu01BIWuVq32SsuQzVYcqbdXkhynokZeDcCCgXyPStmoRJ3gN2iadsbU3lbcEneRWjRTovGXROvQgVQqZtsjkybYauaWFtwBJHdpoCGfeYlqXuk3k9WcKbHKVqytviXSzhjxBIVMln5dDPrkSXndQTVusw6p5gzNbHUmeO2bSiyaEAYcc/F+bo3qdxr2sFazYEyUGHuoneagNxm1p3B+tSsdm54xB28AwnxJ5DoJP206fyVv8RrK63TafXi1ZJeYwn9wHDmzoSXPmli46wlXm1ISjjrRESSzI12uZK6clTMnJBHyLHPlNa5WYCaHvx/OZh7c4gG1iGCzXZM4UsA8C0vd5dhC48ha9D3OdOaXqL73AY66dtjsnuchsQdv8W+/Nr1DOE+B1xfMqKMRO54KDQos0ClkLKfl9LeP2C/2+8915u/OTE4kgQngmh+79VMM+6EQ1LdvKbW3bL+p1WszxjFtLKvr4xJnmkyuQ0qL33IcD822z8+PVZAZCPZBQ7lWuxsfYdcsTH0zsrIQsSmSh+2ArpUrD8k1qAAAgAElEQVQscJeAby81Tbtvf9UhKFQdNh5grUbbWXnb5HMxwVUe9zwOuxd4yWxrLzmfzkE+iawzS8JAbHUQgGYUTNlLDiC5yCc7zos8d4wJUpjltlWLWAIORucnDCAtwmSYyLJncWiCrrNDY5I521kCi9qarMB5z7/rlmErWZZBW2VtsQ5NW9vszC6EKLgGWXJl8vwOVRKosBGxlDWWINbKzz6HQ/htdm6xB5CzzPF9TW8iy510MgRtGc68xZAoSYPOWxaytdcpy50DtgBvq+X+YpI8vAWIdCbr0P3zbWfe4lLBpsunqWrZlbdYtzEFeYJChrZW5yfNzjnYRFsi0zc4P2FW3iEqGepQ94oGfY5M2ww7HeImCX3LnN50kLKjzKXpUN3G5LFzJVMQXsIUWLfBdKaQM2/x6slzjcJthnqVWNLORfNpN3ShHBkSg/VeNJ8u3JLPk8pKevIB/Cb72+3a+X+CM6QEbZ3OfbIFbf3WghLIPJa5eEsK2AZysJxtpJocqXfMc8Rn2uYKCuVJDpmq/123aufgLSyfetC23c4RFDJt7VX7Y+jnYvC8Cgrl2mdnQmjkF1YplLWQkt/XtAeFEtu8WrkqmGzQK3qi0uGkMU4Iu0Rsv6q8HwvqoAyq8KHLtuxcDCF58BNtR0biQQQ+NNJErjiSPFCl/u6vtcxt+Xyd2F5leT6AdtZQo2EPOOiKodXKsY3Jdkhvt+S+pULpgx64S35fG+hz35emz6e1WsR0wKSESu5rnVpqJZ8qO3mdnzyGW0WChBsODs8dFDI4NDyW1XIVvvBlMNiRLIcGNrn/gvs9yIQ+ZV9zHoSkrRwfnwQMVWLWoG3PkMnLAyFoa4EWtI3kyFT158YITOc92Mq7F5xw0OD0Wl/b1l4T+FBhvcNhBjXqOOtQ05aasMKhGifLeRDTi237GT1ZZ6zEEHTloaMKfItNTFlj+pYK9WemDlXaZtm5vLDJnKoL829Pl3NvOFTXibcEPumSPNvpNd6yaB16EIiq7dDlPCX4eXgLkKy0na13nHmL6a2VeuAuXH+9uI0BaI3n4S2kQ03bmHIEBI1VnC2L82OqiOW2DlVF4aGuDi8XsLU1wW8Bpf5ciQudt5iq23MlSjgB4yhzxuMRDH1r9prGAJItOFEK7OcamQLrNpjeJOjMW0wHKYfzqSWqvAb1N1Yp1JLb0gxBW58+H3JALylHjW7DOJ/WZ60hcQYqI5ZwbM9ZX4qUNp8JB970UiTui4sO5ZcXJYJCOc+R02xiLt6Sdl+tooy/R9WF9W7d6Fe47CixfR+QzlvUvgCKDrX458aD/R15i63SNlfxgNe0ng1nCtouFs+roNCiX0kfvonLnflnvSo0Fb1a8nA0CeM2L0sAKQ9ChcwCHFYtGNrqwi5hzLbKtkOSuNfqvjGDapyj8ODdZFDI9LYE62FuXjyINVvrmomYV0s4s9Fhd3FhTQs46OcnpBGxBCyVX8YDCVNgm6Pk97XyvUVGCwia3o4CIDUopGe504K2qhHLW3FnPATUAaHja6gUUkuH81S9GsultXVprfozfREfim4KCrHM9ZHMCT5scbFBIS3QaM801RPl+razxEKZW+BhgxS0rSQPiPcai8622oJCJnJ2sIJCpuBEAtatvQaEmXbdUWpQ1k9ZW7Y3WgBRNu5gVQr9f+S9ebAm2VUf+MvMb39LVVe9V1W9aZeQ1AJJSCBAyyA7HCBH2IRlAkkQxhIiZOMxNmGIMC3jIQxCbbMNmwnMeGyzG0xohsUgkFrqVd0tVXerpe6WWr23uvaqV2/5tvxymz9unsyb956T373vPTEdM0eheF3fy5df5r33nPM7v3PuudKJiGmqsl/OmTxuPqUDA1pO9Wur5FtqQ7Vryc8d1il1lc51mjqnP69/pRCTPS/FCbdUTV3312ORtkl421Am6XQQ2U9TV+4errgFsInGq7uxM26hf3NHfxNpO+gOGteaRI8PbpFtKHMSlyRc7ympilOs/nHsmZmWmNUKZpngR9p+Ld6X6bHSIiZukQJUtjKzOqRDb4w9c+5rRFtk2oh1PfHVlvywb86QfKX4VPJxW0GdcYvYvJw7KY87/U6oPoOtnxwJP0n8SKE2HGoSA1Ks0Fb5FWdxdVraLJ21zpFbJbJQsbLfWKHE0xn1dzqk5KRZzdXwicl43ztKpO8DlpzkjKa93VvsabaOieW5/kOOuKWtcb371nu5IECPtf4/eSR9knicZsJJkYoBmCQ6gFm2kCwhp8uVd5slZ3nKO25PsUiEPOUXqPYMlfEuAYm+X5WYRiuQjBO27C1NmcVMR0waRiRNbdBGTpDLzJrPMJ7P0ekwwChPlBPSwUmRgjvlibLZy7Y87S32KoPuRArlKWtE2B5ILWIGKaIUmehA2PsKQNW+b+rUkHCymCBJZBBuOmMfaZujNhmVIJYtHV6MkST+29KSPKmO0DQBe6VzReoeaFXAXO47Rus9qbJoB2xGb1ZDSJmmPLVAW5oKjriydftrNljrp3FzIgvMU0dQiHbNejSGnJD2ox/W6WO6DRWD/ZzsosN8VjbUMIzCHEnVLRIQ8xEXwiFNhS0VknCnAlU21JiUlqTOOJYbn5KfaxNzfOaL1LuRsst9adx10Oa9Pb1IRFLICbdIOtciJm4hPfKxoU5VdB5Cz2D1Uc7cgbUPbgHsQGkSx864hQtQSY/oAAhrnWg+czfe9cItNeFqTFKRu1enF5lNIBUytrTEh4AqBLuYp3aFA+FmFxtKh8x4VDiYuIW2/+jEQJoqv2HNBb2zrp95AiCAy6EMLja08uHpDHluX0t42vRrAXfseyk+zWnbKoWW4pacwZaSzuWJTQpJPhE2JpNIeNIjl6O/k8StPcJezMcKRaH+35YoaWAyzidqz859d0NyAYcW2b4qhcgmxdQg/JAORTKTtw2yfDFFmqq4Xx9L0g2fRLFPgYdVtFHhW7nAoxt21U4BD9wi4dAs8ygeKFIx9tPfc9mJa67ygiKFisLvOG/mDsJR0bKYW2T8JBe3VNAC7YZd1aEfhbjofITuO+rSIilE40/XVspeAhLdcNKiMpn3eRaz2bmiYIi7omANfZ7b81kULaSQEczOUwGIFbm9VxkFgMAKWvPcbcvTZDGprnUzRIXQYyXw2gdLc2QSd/bXFfs6WtgEqvx9eVKoUYqbTFr1U19TvtskisLeZth+vRojGjN6TvoZBRGSPPGcz1rM+1pBZyHrHPOwYiUf3Z/mKE7nfObHUyq9N7Yz2JJbe8+LQiAcilyBtv2yKkUOFiwXZEP1yS/f3zGg4YAY2ZnDaixtCmdDmScr/ZELKVQIQCy3SKE8l22oafP3kz1yqW7Jc7UU3DN5BQNgJRsqyzyrj5Q39Z6I9czMQmtS6VxZ0TNPlI/xaaTcdl/yXfRvk1j3kiIHem5be4UbAAi8SCETt+xXj8xxOIjQM5hC9t31Hq64BbDnk9aJC26pAlRtXoi4M20+t072FnteuKWyoVYVpzuxDsDWz8rPudh8Tr+lSwu1/Zq7h4VxPGwo2ROPCgcTt+S5XVFWFIqMsYjjogAiozF24a5zRaFsaBspRDatIkF8/JyAUXyqCzhc54xbWGxJa8oaTIZAysVKPsnP6UmD3fluNZ8usMVV58aLMXst+ZDW+WxgS1lnChT1oT/iHAk4tCi8Tpxk59NZ55bf1/QFrjrHndrVJj5VufqYztN5SdC1x/J14t4dt5B+mutP8mnCXZy2gnpvTxfkBUUKcUy4lxS5MsY+lUIH2fNfZOr7uK7jJnlT5GVAdMBKIaOyJMuTpcfWmlkprvmlyerOFwuWXefniMa9WHotfcaWYZvM8iIWnDHDsBd5WSXUvDjLVODCEQPkHHtRDwWK6lonAEzfZ2h7nvtVvFiZ63QuXEnv53nfzrJKITmbqBvOaTJt3S5iZjp9ZNnx2qZUW2SMd6P5JMdL8+nLY5gVNvSTdDkv0nIuXG6ciwDRnPtFOvcK4CQxKwR95j7PVVbNSee8pFR40+lWNlQbSyKQHPsXFYWdCczz/c29qzgBkMJHZ2mdmMDaHveiUO/WZkPNbUw+ogNr6d3ou91tXWGXV1fj4zdJ5PtI382tsm3vbF47TxZeJerL7lsFcVyPC9+ehUUuBvVOuIVw0D6201e2LvfwiZqY43AQIZtkCumB6z1ccQtgb6cnLOKEWwhn6Qc1lASRtFZNe+KDWyobCrPaEh5znzPbH0rM6mJEC9nPsd/F2UXuHpWNcGBtfa4txcQtHMahtWNXE3L9unJlzhx8FxHrbTZ0paeCwVk6U7G+ca3s52TfU6Coq/GXBM+cnXHHLdJ8MjrH4dCiUO/Qsn2sTed2F/x8SpJlcqNpenfqK8lhS5rPtiRkVd2ezkpWUMYHTviNneNiX83WaSwX2dzr78X7GsnUqn/aolnR06ZzPskaF9xi/r4meuRY3sTTPrhF0k8Os4pSFKJtPdD2dEFecKTQgTK7RV5OqvtK4vZ9e30fQnDDSPetSaFMXXfAIMU0hkkai05bKrFsdH8nUsis0kkW7FwUBTNH1bg3hZtPMpxte/ProDwWrs2Z4LKcC4aYkow0dfjXAXAYOgaS1dw3L2bHp0WkEkv7+wqvjLoVpIhlwvQetnDZS+nddEOvG2cXaZsjTpbtVTbn09emrHQVEKu2VtK6LAFgmi3gbDoLeXwr/Sz7SyzS+YErCQH7eeUqMVuPaC4snWOu9RIiekwDWNkOjhRyGwvKuOpyYF+yRMyGlvyDyXPPXhvY9kvdw3GOwASz+9i+Q3pUlUszQnbczVYSIWjtA4byiZ6kUAnOrCDFobm2q5/zFWnLpr42/DN5ss454ZZK59zFxC1Ztj89or8/DKAq6bKP3/DBLQCDnUQsIlcKNbYOGr7ECmbLcQqDEHEWe+GW6j0sYh1wnn8OX0g2m/17j7Umjnsh4zonkedTEhO3cONO68/JJ9JnDolpIpk480eNlHV7wq1hssOWcE5Rk6p36BKbRLsLAJuEX45bhDXFXmv7uTZsKpHwZhNjHxvRdi1hWvo+LlagueDjJrV4SGfV87fPEV0rzxEfg7TZNU5M+7VI5zgMasBsSC7Fn1KcKGEcSVxwi/69AGNDGSHbTXGBD25p813ufrXl2Q6yPV0Qp8cKguA7gyB4LAiCJ4Ig+HHm998eBMFOEASfL///v+3nYXwDauYO/k5BK5duPRKc/TpyxvavaIGu9lRJZFGQ9T7cRtNJLgeobb1FSFHNnkJ0bZzKpJCtCwX7DNx8tvkq09DPk7nsjK3vI0Bhk0LSmiIlImX3IoVQiFPpE+M4938RxnjZfZdnG2Sd0St+iNEXSaHUJhpdxTeAl8hO+t7Vsimb731p2wll56qg0yDukmxRzr1jWb1E2hoB/CKLHe/ZLtL4sM/GkJoyEXsA40wgmSUGTLvYDpY44TIx3OeHJWmeolNm1uUKENlGsNeyF9tj0baunavEWoTep96ibIsXKSQlaZYELpKQfptVrsvXu33tIlscyhqRnkE/Wth7e3oLUHXDLaIyi2LiljwvPOa5Dn5ojg6jz4G0THyWjw9uAfit7K64hTtRzAyopWCWKgl8cAsfHNJ2ep/FbV7rg6fpWhcCSbB1FUbe5zMQlvFY7yZukTCrTAoxONQRp7ViYSOxM02m7GvRPfj7yM9h2tA2IT9QrWFX3CKOTwDLJ3CD0ZLkF6tQDJ3zwYBt8SdVIBE25Pxf23xSdTuNWT3u9h9UNrS0wWKStWjDF+56b9qkRRYfBgyVEyVJM1HCzRGtdR9SyAW36N8L1PPZRoBbiZI8c7arbc/vHJtI9hLGVmLfSmRBlj5WEAQRgP8I4F0AXgvgfUEQvJa59M6iKN5Q/v+n9vMwh1IpxBmcFiEjUjtYH5GJHnMh5XkCltX1FJr4ihRKySAz28daAoRRTz0XZUrod/S8ccqDZXaOKme+nJBpDWgsQy9kcTln4/EMJBWJUBrfLPMAwFyFA/zjHLOnUGupqMeN3SuFZNBllia2jqXmuHyNkzcpJDgbmk8y9GmWewU0luMu34nehz5Pslgkgy1pyaCa+qnA1eFVCi2tnBAqhZx1zkukyE6qFAIOAq6/1pVCQL3O2is1PCuFHD5vA0yHUSlUBZ092Sd69eBpqxJzrUQAkJfrYrVvkEIe72z6ufkiORxSSKoAie3tF87iQAq14pZKv/0rp2l8kjT3SJTUlQVURaBv59ivSLrsk0T0wS0As52+paJMSsDovTooc22uPzOY1YNOV9xSVEEKU23pjDeFoNyn+sf5u1oqhbhm2T739a2MM3BLG2Z1IoWkik/uaVsqhcxqnL3yOd3xND8WJuHgUl1ABJKZQF6OW4T5ZI1JG4Fky7JdEFEQVRV3rjairSqSxqkmy/lKIYC/h+kfxouxGOwnuaoSW15tKeELn+o62yYddqWQuQtC94MScbcf/OaCW8xr13qqX2NRZEsLPOg90kyOuU2RCg3ECj9W2olxnTg+DHEZ9m8G8ERRFE8VRbEA8N8BfNehfLshh1Yp5AFYaSAJaPp9HZWR2Q9NBrSqLsgXh5K2rvZClga5ui9za7NBlg6WSRkoU2L2EmjbPmYnc3jj1lYpxPlMszHZTKoUkhxIELEJCKkk1HznJMs8ADBtcbG/z2cNV31wnII49xubZNN+thiYpYlt71YZzqi/tHTTlP1WCplO0yRMF2l6ILKJ7kcVU00Q5CotwIaccYcCsEPK0AjZaFtszySTmlx5t4dIZfXVVjEuy+14ay6e8SEt9ikEEFsbQTrb/JZKIUPvv9aVQvQ+NWCyB9O/Uoi7mMbHbYyItDX10+wl5lIpVCU/skPaPibonE6K+Jd3y7bDDbcIWfkWMXHLIvUjzcz1dxgl7W1nLxyoUqglA2sSjfOW7WPLmozrxJ2knzTua33SOXfckrEJRz/dUi8mBeVO2Q+/yRDvweE6n0n2U2YTt0hVC7JPlCqFlutcW5VPNcclNtgVKu7EitiC+1BVRgKafjok8GhNmgdvLMUtrZVC5scSgeS3C4JrIXCgLaalmFuI0izzqhQy9V7ZBv4PzG1XIrEuVtz5Zab5SqGDA1EpWUPVo3QgjFd1Xou44BYS8ku0flRLCN7WmfgiyRNn29o2FV6kUMt3EQl2WJVCLl3orgfwVe3fzwN4C3PdtwZB8BCAswB+rCiKR8wLgiD4EIAPAcCLXvQi6wb7rCbX7wDLsHzsFDC/oD7/XjtYtbIuRYHA2QkZQZX2XZP0nQBqhUizBdSJC0Hz2mgFeI97No2MXl21wJBN5b3Hl9Q/qSpols6qbCsZN/OYSX37mFSybRtOZuI+dgrF1l8hCF5v/f0yw0nGkIAY+xDcuHfW0HDGHzuF/KlfQPD672O/zzylKclSBFazRUHIIBfGfBYpfIJncz6dt/osWdfOjaZb7jtLcwTl76jR4bLs5ag7auxDdxFfvTedDX23Cc6TNMWw13O+t5mdI2dgNqVLOAcizUf1cva10ytoPC9bhr1kntn3cK4Usue++PK1CNLbURTMcRCCrXN7Lsax0T1e9xPMfWE9W9v3caSQT5WYjxDYWOuvAXttgW/LO4vrpLCvNca9+OJLEaR/Zc8RtLk/wJH0ZuVDkidVY1L9cQFHMrcCZ8x8vup/tT9Td7bm2fQPVOVqBgJt72yS5b6khySSztHaIADsJWZQpK2d8eLlAJbglmo7DeqhX6JHZpJikaUYRu56ZG57OQygeljbx1xxC+YXMNtRn9N8SngIYHpnGAHqam8VV+dX1e+EQIl+Ei7LshzBkiqxKnOdJ+joicF92lBuHPCyDzB/D+YeHrauZdzZ5918q/t9Pf2niVu8EpmSTzRP4hKeoS3gNUmPvXjM+jP5Hjyum2VB475t1QW0LdWMFUyc1Y5bmPE5/k3u166/pvmS9B57pX4aDdv1eG5vsedlI9qqN6x3TlMERpV125Z1C7MmzPYxerdUfVYldBctSScOhybbzcs8Y4VFekg4VKgUqgi23gp2410xqefrl11wC4k5n2meoKvjdC0+n2RMLM9iYYDT8YP6rlbsDWC9v44rsyvevVwlcYF0UvpSlwcAvLgoitcD+FUA/zd3o6IofrMoijcXRfHmzc1N+4uETIy7BLCOOqwmi2/8ZgZ8xKS7fZ1BZWrfZWZz0jwD6Gh6/drMDzSZ+8kXWWIPWnnvcfnKdO0smdVbZKhZZ8naVltktAokbi6CgDuFgZm4+QUEQWF93DbHplLH2Zy/1rxJNe6GI5xfQMg8A4lZSZUXmfv6owAuMObTU0xSUg5ojIBxybpuqxLzue+oO6rWMD/3Smj90Hv4iK/eVwC6ZMhNUqjKoCJFUbjf28yA0TuZ29KSPEVDlwF5PqqXs6+dlB/VFUgJLNO6ZJ7Z93CtFDJJiPkFBOo8G9thiTrn+lzGd+n3YO8L69navk+yM1+LiqEq27q0WWfLO4vrJLCvLRznCD5VYrKYWTTOdtB3S/aAvZibT3Hu7RubZe5U5WpWZLS9s+Xv8/hQ1ohUAVKgQD/qO5W0WxKEaFTWaWvHCbcEQUksaZ85+o3KhhaeNpQqsYzt6QcRyT/4+A0f3AIAs/JzGl8Ri0DePmZuOSmKwtJPmkf6STqXQ8Yipm/P8rw0ds13ULJPm93AVNx9zXt42LqWcV9qI5bd19N/mriFWye0zpx9omTHjWdoCwpNknCaTFg9lO/B4zpa1y6kkJkkqyqyjcqJdtziM58Cpg/ssaz00+gpZOJpLgaRpK0yxdRbTj/pMdlt3UaFap1IkueIvkueI5pjSUfNz9xihUV+SDhU6PtU2cVurXM+caIkLriFhLADPVuaZ02crsXnZq+iJE+dccth+C7JzmRFHaMBf7NH0j8P4Ebt3zdAVQNVUhTFblEU4/K//wJANwiCDe+HCR1BpiQEojwYxqpc2uE4W/b7kMPaEgEbwCaHFKGYQCOhxczcekxBpxYgmBVB9P5EDg2jkhQqYnYuWMMpNIMLg9y6B/196z5qqlbKZwJ7L5zuwMx9GKrjIzmxjhoPUhC+WirUq8EyZoXXGjb3wbYH8O43NrcZyvdtL3Ve6a1Uz9amn2meohN26p4IDqdvkESRn97TuxBgoqyL6bgLpH73NdYDOUubiPVpSC+P7165LqvAI0/apsJZJGdsSWAf7xCGubD+QwB+2wKb3xUCtG/bEsE2egR85p9/LfsJmdU4YjWEV9PTNj1sLuIwzJFLNs2Y+/1s3zEDVM52kB13e73y3dg5zuE60RbxYgQCVUVsCxg0KzPTfHEwzEHP1tLXaKW3sr+ehS222Q230N+7AyITtxRB4kfYC8TdQUTSZZ/tBT64BQBmJmGfz51xS+U3jK1483Ru6adJCtF8FkHqjFtS5FA2gnsXDyPK4QtX/fSxdW1bvFjc4KigJonqICZuCUMbv4nrLIiEZ3PrbdRmQys9InI15e046Ya9tvmok9a1C4Fu+jlao6YNbcUt7Hy4+Tn574FZ+bGZ/DB1EUEu6pEpbfjWrDAtmIRjK6lkYFZ1P2GOymdYakPbsLuH0a7ms0rGM4UG+5DKX0ftiRJJ5/z67rjhFvPZKhtaEUL2e1ttRqogcfkYSWvCj/Ti53lefkT+5W+yp9DnALwyCIKXBkHQA/BeAH+qXxAEwamgrF0OguCby/te8X2YtkoExzvAFwRRyRWVdvuV24fi4qD7UgZPVQq5A2BJduIdAPUCiLOkrFax77tdGsOqkmIxrRSF3pfIoO25KjncS/bK+/KZMXaOuCw3gIAhhVyqTeh5d+Md/lrKgFpiP0PYQtLQO9Pxn3mReAQ69AyF8al7ZgKo55OCNzmz6kedU7l61SxZCg6FsaSv6oZd9MJeeWk74TWIBsjLC6gizUV8yWAaI/q5M1djSGuZdC6Dz3zWToT+npwl9RSqdScViVhLzGocTbbLd6b1Pk9j+BB/ktA40E+5UWGgiJrGJ8IcOx6zK0pb0CAGHm7fJ2WaDiPY54R8BNlQuWzXg8gVbRqsz8MgtxKoJKTntHbJDvgIrXeyi5xP9CLdKh2QglZHUsjwXfSclQ2NSxvaAo4qP1eOzyL32+oqSZvO9cIeumEXgB9ZXvsYW5xwS0D67Y+HKhtaeCRKtOdYpOrvaU4OIm267KrjPrgFqKusqxMo06kzbrk6UzpHJxSST5ylM2tLMq1Hcz5zZM64pT1IcU5HC5Ps8fde3yVNHEcMfC2eoRYdtxSQMattbwUSynFvSFs1K+lRnCr7tFeeYuiOp/mxIMKB9HtntiM+n+XnzDXrhFvciR4fAon0s9K50s8VKBqN3cHEIJK04VDyMTW2tO0izSd3DxrLeaZw8W68K2JDIu7ou/aHL9z9zPbMZz7dpSIRk6ZvBGoiA2jXOR9xwS3mtTTGSZGp9ccsN/IBpItJddrnclsj6bh3JRRXeFL+fZqnCBB4t+2QZCm0K4oiBfDPAfwVgC8B+KOiKB4JguCfBkHwT8vLvhvAw2VPoV8B8N6ircuT9DCHVSnkIXm5+D9//vMAgCevPunxfZG4kJ7ZeQYA8PEnPg4AODe56MwutslDFx4CAPzhI38IAHhy+2nxnT9bxuW/98XfAwDc/uzteGLrCQDAA2cfAFAb/LueuwsA8DsP/Q4A4NFLD7NzwS/msmLK/JQhEdrY9E8//WkAwG899FsAgM+dvY93xgH/fVzTZK5aieTi5KL63mfU927Flz0qhfiG5j7lqgDwwDk1D3/w8B8AqOeBuTN8DPWdz94JoB7L2565TbiS1xlyuufG53B2rAoDi0AGqoACx09cVevr3N4552f11Xsaoz94RI0ZjeFXd1Xrs0889QkAwKXZBa/70n3+4vG/AAA8dfUpAMAXL34RAPBHj/yR+nz7GQ9dlhf83aXP+p0vKJ17+OKjjvdsl08+/UkA9dx/8qlP8hcymSaqFOJL5Q9knNUPEfjt/73bKoW+FuqDKyIAACAASURBVNvHaF2Qz8glvfQ69MA96xcEBbKcv5Zs6G8/9NsAgNuevs31ASqhIPe+M/cBAB678ph1jd/2vJYAyWNNfeHCFwAAtz51KwDg7J6yS/efvR8A8PsP/z4A4M7n7hTv8ZmvfgYA8Ltf+F0AwKOXeT/nK2RzSOduffrWCpRenF7E83vPA6gDKidpwTNuuKWlLFcQE7dcnJ3zItYfPP8gAOAvn/hLAMBT2085f7ckEmbwqRTywS0A8MmSV/ytz5dY5Nx9zrhF97VpkeKRS6q95nM7z1W/I5tPvmyWqbXyubOfAwCMk11n3HJ5tgUx4XhQQsVVP6u16lhV5FXh4PkMns1IdNySFHP3qgVRP92et41YJ9v7x1/6YwDAo5ceZV9Lrjbi8eLD5S7T2569DQBwYSK3PaBY4fTZ0wBqUv7u5+4G4IhbHJO36mNp/dnXfrrETqRzn3r6U9XvkizBY5eVz4qz2aGQQpcmqkHrHc/eAQDYjq+wlUKSfPbMZwEAf/LYnwAAvnLlK5B07sEytv+rJ/8KQG2TLWnFF+7Ah96JMMNDF794GDAUtz6t/DTZ0E889YmKfN2L9yqflRZ2tS6NpY8qu+AWEsIOhCUuTa5AwqFPbqnn/PPH/xwAcGbvrLNdbKsUcsYdgr18tmxR+MjFR8qGAocjTl11yy1hf2F89hvaf/8agF876MMcSqWQ1xGWtRCzTMrv9nVkeHOYzYWzsr6fSJdJMlXXHXDuiK0kVlAdbXgNey0xiXTt1nyrAhRp0dwCQ1twqvsme+gLQIzPuNkTJ1UKSTiV2P7qGdI9DNhrQ6vCQYntucOW8lEC1lW2NZ14ZEXl7LfPGqaKGnrnKzOhwM4zKCdWnu4rVgwIZeNb5Zjpme28SJHntsmgdyhQgLjgy9PLePmxlzs9axDAucQXqMeI3o2+n3S4ns8x8tx9Pi6OlW4scqruUzpC2YRa5yYAjrndtGXb38TQz3EyAYqh231bhDLVS+deqBTKssBD5xylcmwS8DtAQIK/2UohsqHLT9nbR6UQi4Ka30NEt4sNPcg+c1r/9L6NZ/DZPlY1WxACKMfAlZ6D9Ns85ruyoVO5SLmusK393PAQ1gmRPZWvnW1Vdkq3oVemV3Bs6Gg7HHSuFbe0VCmK9zNwyzSZIOd7dbJizlGa+2y15aWtL8OBtoa0+NSr5X1rPdrFuiNu2S2rOkj0OTKvNbee0njF2cwZt0ySWZmcPEClTwCh6sWR6PGp0mlLk3Pr3dkP+GEkDrckeWKNu1gpFNj+s3peh1PQ2oh10mfCHots0drvyL452F9cLB+3rkiTx6uKFQwdpjXrhFvENcWJ+9xvGfq5G+9q1V5FjQWL2MtGSNdS0F1hy8yOFdoqhS5Nm/NZHTrAzNGlcrgrPyftFa/wxcGwE1X01Ph2CmDg/PeSbM22Gvfdme9UW+EaOlcskOfN9UO23bfZNNCOW0jMWGGczsQxo2uqyq3FBK64pc13ueNT3q6RLvue9rxMvoadF/wlDIG5+64TW4IQyGIngwygMiK6UFmZ2/dF6vu47TeGosZZoq49YFmeWX4+zxZAHoMzDCYcmy6m4vtRyR3JIp9hIfSutOcoVM/AEDIzo4KP5phTdnObyyKbYz5nGPggBDKmNDBPYFUKhRniGEgdsGlSxIhj1+ap5Voze7IEORKPQ2ZMhZZPawmB3L0J+sK4Vu4tEgKZrXRXmTHIkFrzCQBb0y3rM5+MeBQBU4/tsOYYSUbRaz5Rl7mSkK6Z95+ni3IuHCuFhLLOhfHnszT2mmNJzK17ck8he+7DMMciLhidi4CD9Achm8wBnJy3oSjcAsoggKVzYQivufcRzoZyvkSNL51Ut0xKG8pda+yND4Mc8YIj7uzjaw+jpJh7X1ofLnZVSVDaZ0My3ndxsiccy2yC5rbtY6afS/I54kOoujZ1bppMq7J8XbwrhRg/xy011q9XOufukEzc4m1DjTk6jAwm6bIpQcB/zokPbgHqhBpJnM2ccUucxuw28J14x1qb0sEmaTnuLvoVZ4lsQ53nPgQK5trcxjisBGS/HL9Lupb7nDvdSnyGBVzDGg63ZFiImNWuBImATLA1DmQo3Y/DiybGyYvc08/xeHHXI36UYgVzzbbilpwJ6ASd43Coutaez4mpn2lskbGAaiHgii1pnl1IpDS37SIlSjidNW1ETiwjo597xruJNrTCF4wcIFaYpXMP3CKLaetm6awiinTJi8RD59zFJ5avbag9+eamJ3WtG/6n9+CSllx8zUoQsDHELmPuadv2QeQFRQoFAbB3oAbagTLSjseKcwG4FymEUH2fQ/ASZwsF8A7I6pmkkCKb+KAvMxbiNOFJoXk6t47LnaUzTKe2UgYBMDa3uAaBClyMIxrDoLCuDQJgNgM6zBSZRiTJlYPuds3vC4Fkjx9LwxmHQYHp1A1cpcUC06lr9rFca+YzsOBTFnM+xYAmCACh2SAnZvAjN8MNgNTes7zNkUJFyuonV4lCe7BdJAgUKeRKppljJPXpSHI1n64BjdT/wta5hahzlgQBD3Zgk7bzNC7vezBnbAaocn+nEEia9iCA0hdLP4MASPe8MlDGDco0GgP6U0aPAJFMs+5c2hTus6/F9jHOhvL6Rf7IJaAJ1NxzCQ2DrAyCArNpwdpQk/z1PQadI7c4MoYyYO6ESsAHCNnUeU1JvbGcbSjsCtl5Nsdstr+MpC5UwVvdN51jOz4EUiix7agZEAESbimrNw5ANC+yGLOZe0WOSUoehnD6DShsMnF0iT64BaibeJIs8tgZtyyyBbbmdvCzM9+x1nCap2w1VVJiERfcssjTA9tQ9TCMfqZTOFcKCX7OvjSQ/RyHcbKpY6I38LiWxy1ZkWLHUDkK4OxESaDGh7OxDna3zYaadpxsnHltq59jMMrYwx9yNoVbr624hZvPdAo29EwYcJlOWf2cGi5jkS2qCunGnxcL7O25YcAwhLPOJUysQD7EaT6pGTk3Rz4VJLmAQw8QKyhSyBG3tIiJO+M0Zv1fWiTYNZYakfiRPfWsuOIWSeIsKW3o8gKPebYQrzVF0k/Jpwl3YU8p32HMPed3fOUFRQr1egckhcKuyCxzwg2gFykU9Z0XxyxLS1LoYFGKCYBnWSI6Y3PNTJIJqyhb0y0r2xpjjNnMdoTdLjNHQbc0Ik0N7nZsZe92wQedsLvFZ8EcWcYY6bCnvo/LxhhBZ78Ts0QPZ0TyaOpOIoTdctyb89kJ+WoaSdxJoY6XoTcdt3zfLuuMt7kgIFpY8wnwgY6PHvX77s4YcCeF0mCK+dydFJICGjNTMG0hYi0JeyJgMknbcRqXQcrBzLKZyROrRaKeFXR2OwmShGteUNq6/W4HCbsAciETLAU0bkFGFNkOttvlydnDIIm4tc0647BbEj0OyCbolnPPGMa0+X3dKMF0GthkOWwg5rt9h8u2clvQul1lU51JIaYqTT2ga9DpTgrJ1ZZ2VVFc8H7OV8xs6yJbsJVCPmQ5wh4bdG65VgqFXYVNDtBMOw1mXuTqfk67WybdLljirtNxJ4V8cAsAxMb7ppg545Y0T9m531vsWb4rKzI2mM3DmTNumea5TK46Jy86/LVSJYwpYc+qaJS/i+wi42dEYsBBQaPyGUK3pDBL0EYxJpMmFul2FYawMvthX04KO+hcp6Puy5IIhg0rUIh+jtPPQphPjnBgq1zBB9VXZ1etyulW3MLNZzYFQsYnStcyPtEkbZMsYUm+IoydsSXhUJ9YwSSFpN0urE8KooORQmFX1jmPqm52Pl1xS4uYuHOR8z4RkSLu9LEknXONCVxxiySzPHMu2phlSZngWu4UST9N8fFdap7ti82KMgCsL/GVFxQpNBodkBSKRiUIcsuOXp3aAyif1MNIZ1UBXcMZczZ2nOdlSd7BohKTtdxJiRSyHaz5TZPFhH2/q3Pb0KfhLmYzm6ldWWEybp1RaUSaxnulP7ZIhNFILpszs61ZZw9ZxlSQdNaUMWQrhZo3Xx/tsplObhzyzh4WC0cSoTNiM7BEQrmKFdBIoDoaeJFCZvAjVot0VlhnvMMs005/jvHYHksu0PEhhdbW4JeNNktxi5wtm8w7YywW7gGNRJyZOrebpe4l7dFI6ScDmMxlpnSZD1J8xKwOEatFOitKb7Xfj3pTZEVk62h3tXSa+yWF+spOcgRVKkSdjgFNv2873tGIB2c+WzslYW0o40sQjcRMpyWdUQmWmYAm2WuMz6g3RZqFrL4clBTiQAX3vlGk/u9cFVmRo4a4Bq3gbeM8nbvbUNj2dhFuH7hMHWC2X2cL7Cxsu0gnJTpJh9e5q8y8s7glGqq/lbYYGMIGP542lAt+pKDTVUiXzTkaDhksIogPbgGAxCSFOrvOuCXNU7ZKbDfetbby5kXOBrPBYM8Zt+xlhC25iN9RQaM+TwC56mdH9nPytYxdZKqWpTmyJBqpjHrAsOWMcLglHEwxmzWD0dEIPA7trpX+U9gSvUTCUAWHnA3lsEivx/s5lpinhLUhHOEgxTzmdnpAxQqmDW3FLdx8SsmPhMGM+YJdU+bW+7RIWZIvYuZTkrU1nhTi7pt3xoiZnZUSCcBiy7DP6teUsbWsDe2MWracu8exZqywkybuuKVFTJ+YZrxdDPuyzrlusXLFLQAfC40z9/hcxfJuiRZJP4mAdBIh9ttjloRXJbIgLyhSaHUVzqV+rHRGCgQ5lktzC9SPFCJiwAgameffy7IDZewkqUghJutiPsY0nbLvtz3fZsEylxlbWYFdLRIRuGoup9XB2NoWJDpY2EYk74yRpoxS9dadqwtW+hPM55llvNnS4Yg39KxEIxZw9btzL1LIFDHLHY3U9h1HMUk+qXcBOquqEqFYvobDwZTNunCBjk/p5vo6vLZ5cQ6Wd9x7Xlv5uPtyZNN2spAznaZ0eN0AJFLIEQC3iOnkRWKgs1ZWOta/H/WmyDKOFCKd26dxDgKtus58YKFaxIMUMnWOAklzinwamkvC2lDGl1REj8t8VgCPkWza6Pcx6k+R5cwcwdZzvyPQebso+UQuSBEl6vNZTddKBPC2cWu6ZZG2bdvHrJ450Y64LchHTHub5Al25wfLXlY6Z+gzt7WXnaMglCtAGGF7ckR7Xj2XuF4604P0IoPSZS5B5ZNE9MEtgL21N4/G7rilyNmM+HgxtgIS6dqiM2Z7UbD6mWUQe3O5jr1AIqjPHJMf+RxOIUU0kkkEsbLE0YYWqXOLBg63hP2xRQyMRgrzWFiiu16OD1eh5QY8ej0+OORsXZufM6UI+UCS23oqHUTBbaffntmxQitu4Yge6dp0LBBsttKZpFCWZ+x8Bv09Z2xJyUnzWm588s4eGytwCSpA8EmCzk24SlDGNrfZL59YwZzPvTRzxy0tYiYj0yJlfWI0mLA651OJ7INbuF5iYyE+Tw8Yy0sJjcHAPaGBaMTaxf/fkEI+20gsiYZqe4Mji8cZEa898VQFYAjXpHcvy9z3XHtIHaAuZ3XjNGazqDvxjrVFJo32RFLIqhbp8BVaRArp1w6HsrKbRiSPJjwp1FktqwuWO+Nhb4Z4xpBCDLNMpJDTVtpoWO7Bb1486Mbuys6I2BS4wxsGSazgJxNKJLqrFjEAAHuMbw77tvEG+KogH3J1ZQXuZBz4MeKcQlrOp6twjpvtDZEu5EynKdFQBEHm6+5mqQJyjuXvkjiTQt01i+gZ9mZI8q4NNKvqvANk/aVqESlwcQxoBgO7FFdyxodCCjE+gq0AaQNt1rVDFcxwVV1pkxgY9mZI88jNhnrOFwcqJJLFixQSghTnoFN4Dk7vze08upjjkQZ7mEwOgRQydC7LM5YA8tqe3l1jg06ul4CIWySdY4T3iQcn1rnmoj4yHPJ9CEcjhugRxAe3AEBqBp0lKeSqc1yV2HgxtrYZFkXBEsqZUInAZsRzClK4igHX7V8DoarDdevWUF3LbQsypVNe61wt4ljeWdlQt6Qwp4scidDtCr1/OivgDhsBcKAqV4Cvduz3C5EUMv1cEQ7Z+TR78QDylhOOmNqOt61YoRW3sH0IC77iWNyKZ8+nRdoWOW9b+2OW6OGEdjH4JJCtrxMqQNidCWEPXK8Ys8k9IMxRNBR7ovnEChbJR+0RDtjGgPOJLLlV6pxumwcDgYgVxAe3cPO5l6Vskp9LwOwm8u4cUw6FFOqsWC0EAIE89OqJzMsLihSi8r19k0JhD6qxoja5g5Pi5Vz5qNeeeDO7W34Xt+e/CiRpIbU8lyRcYL+dLuygU7h3nMUseNyeb1skQhbtsf18VlaYOeqMbGc8OIn14S7LACcJD67M4LUIMnQ6jNOMjAot/X11Zzw4iVFvinhuo2ieRNh1B8CdMjMWNOdz2Js5KztXEtq+zUtT+CXrx3Tc8haikhigsS/vy+1XDQa28QZ4PfLJiFOJpSspxI0Rdwx1Eu6IJ8Zwwj3z2d2z1md1ubRmPqX56IwUYGL00yKF0lRVhOhOeh92wqxaEIkBynTS9YOT6HZSdbqVBYBHaJyeuI/nqvoSkdA9MuYzoAmYWr6P20YiOePDOI1MItYtqYJOza5J7xGVNjSz/UmjKnJwUpFCWdfNhno2UeLAleQT+32PffGREXTSu+lB55I1xQUpnB03t/O0SdrZ5QN9z22Gpo5lRcYCNK9KITPoLMeH29or4pbQqNBqGWOOvFl42lAOXxy0z8FoBJa4o0oh1yoAV9wC2LUfWWfPGbfkRc4nHBdjC8MVKFidkyq0uPW+m6bNZNg+bKgKMBn91Ct62v6+w1T/tNk6yX9mEwuLAGgSQ233zTMWk3PC2eyit2f1IQwCgQCPCP8zONRR5wYD90qh3iBn/VwcM9tfTVKofAYukBQrhThSiIkVWnFLamNLAKzONbbKNtawPZ9mP8a8yNn5zMqKHldSiNM5tjmyQJZzCSqAH8ss6AGJPUfcFj+WWK+q0Bmd00mhZbEC1x7BFbe0CIdD2eRZzybugkDuC8mJD27hSaGsmeRvieWvVj2XluOW0QjsgU0+CQ10VoCFHftxTeO9tqcL8oIihWgbyb6zuUFgZ8befV68/MCkkFktUn4X16RXVfRo1QXvPg98rx9g58DVXlqy9LphePd51ggmWcKyp9xCyjp7SFN7TydLClW9CzSL+u7zLCnU7dad5U0xgXWBgnfGRMho31WJHnS++zxG/Snmc3swOCOyCLfdm45GoyZLX87nqDd1LmnnyurlbV4rysmToW1Z14Bt6KVj2+stRM37ss3uGOMN8FvFfCqFhkO/E9u4MTo/scfDaz7Bb3346u5Xrc/qPddalCLNBwFHPagSrh1nmV0tsmSeOTHnXiSFOivKJlHQWX5XN7KPCLW2S+7juVS5tGZf6R56tUhDl5lrGRkO7W0kw6GyU+aWk79RUqjKXDftIiudkZp37lpDP6MwFxvam9k53yPBOV8gbWmVADArZtBJ76YHkkt8IjfuF/cuWp+Z1RhtQskPkwTyTUyZOpYXOW8XY89KZD3oLMdsh1nDci+6fpMYaNEjySf6nALDPYcUdLoKZfBN3WWxiCAsKSTgFoDZEBQlXriFPaFwMWGrNrlrM2HrMzdHdWIwrN+B9ChhdI6TjrE9Xbc9LvpZ9U/T+vm02Toz6NS/jz7X/56ZI/sZhoqccLkWPG6RWgjwOHTYJOP24bskYp1LfPX6qUUKkZ+zKoWiUTOJWD4Dt31M2nLCxQpsVXgbbtGr0JfNp35oj34tgztMNCvpnE+lo4RDufGREo6ST+Sq29Ogy+ocR9zxTdHLhGPI6JxeoeWJ1SZZ7o5bWoT1iUxSRNqK51OJ7INbuO2628kCyLWWEKWt4/r37SQJG/txQvppJjSGQ09SSCfLW9aJ10EWgrygSKG1NXidFsSKR7k0t7+xrR+BJRQoGWV2XMmZ5bj3IezR31kZSBj35VjENE/Z9+MUlcCyyZyz+26piaxRfrfSnyKOU1bZXcAVXcsGqBJ5YpRjqkqh3DLenANZhNt81oUTjqWH6mHkSgqxmVkpoOlQU8P9ldGJxEBvvczQNH/PnlJRNuI255MjgHz0qK35OCfcGJ3dsyt6fAMabtsJd99dOknQtYEwsy2Is3F7Fbg6WO8xK0iRqkXMirtSep2FQMTu/2hr9X1DtlxaHEvHEmiuiSxlaExnfBinj7FgmfEldY87h/kMu1BHj3Kns83AzZGrDfURKZjlZDj0IIU6/HYGn1NOOJB3bnrO+kzaKstVZqadXbahpW9iyiTfiqJgn9e7EplZD7vMs4n21uOAggMnSsAHPwfNXo5Gyl6axN3KCpybyK6vu+MWwK7izIvcC7dwmGqaTC3SFuDHJ4l22K3snH6qhGMMFs67NpwVDpxANmsGneLfl37O5SACqork/Ek2gx3yw833hFHZQ8uNBeBwS1ZiHFPYbUFRi0907JXGJTQAvpdht59Y11K/LcvPRavsfPpsOeFsFXuqXhtukU50Ek8hdevPxHk5nuTj55MTqhQydY7Tzzi6iji2saU0nxzJtwi6TdK2FK7RNEsKdUZlr0Ghl9g+Y4W9PHPHLS1i4s4ChaBzY3edE8QHt3Bbe1X1T2xhETmWd2sfQTjUPCl2ZUVhJyecIcR+3DrxqkQW5AVFClHJ/4GAu5mNbhG91DkoM9Vtx9la0uFPl9EbQIXlECt20bFhniC6caL7KoOcW85J72sUloRRVmTV+wVa6YJegUTX5tGU3dNJTqgBrqomsk1AOOpN2X4+vZ4dTCRJDa5CjeBimXciZLg9nYaRHfWnmE0Ky3jre1tpLJJoB5OJI4kgnHSxMphgZ8eN2OTmkwONAMqtPhMn0KUHP9V8SsFi1Rer+XsyOEH5P0Bl0djjNhcT61pfUojLdklCYxRq5uvS5FL13/p8SscIc0JATL/vhcmF6r/pc1Vem7k5XW5bEABdU2iOJnmZPT2k3mN0X7FahE6BMWTQnVskSx6WlXGO/V9YiYZ8zwiz0pEkcQsmV1aAbQMzSY2mD0M4G8pWxlUnrjnOZ9jjg4l0ApsUii27mKb1XIf7TD7o77HMJ3qVQEcrAAPGlE90Oy2ISFt93PVKIdJPqYeWnkWr7GJ5mIFp1/abmNJ1jrOLXvhC6FmoJ3yW3jcaOpOrOqCksfS1ofPyeXUbetDsJTX6NRNUq6vuwHp11R23ALW26Xrkg1v0gET3iVSxq1+rJ4foWiLjXHCL2s48EY75dhz7zoq61sQJRerWR66N6LG+i8hyxi6mE+EAEceSAcmGMsLpZxbtsdUJbA+Qasuc41HsjEg2lLb763rUHSywY0yntLWy6KyoahEDT840XEcikkKMn9PXqhNuSSf8+uH6vjF+rv68KZx+6jawms+OOn3YBQdIOFS3ixW2DPlYYTSCNUdAXd2uz+c86ACJTfbMy5fTr2XnSMCWAJxjBT3eoLGc5bkfbhGEwyK8zvFtO3z67vjglr25PZ+q+t9o84DmgTsN/G9WaAlCDbPNxAX5LqeK5O4aO5/TrPkOgOdBWYK8oEih4ZBXKC8J+8D8stOlrzr2KgDAW65/C77npu8BALzy2CvdvysaKaUO+42PbyzX1SuPvRIf/MYPAgCOr91Qlgruf8iPDI4AAE6unMSPfMuPAABWRyfUYjGcEC3XawbX4F+/9V8DAI4Nj+EV17wCAPDe170X33TdNwEAXnr0pepe3VX823f8WwDA+nAVnY4dbPX76jOLuAt7QNysfBn2Zti+mlkGud8HLhtTtFgAg84AAPDT7/xp9KN+eW2BS5ea1yb5EFhc5ZVyfqHxz2F3hqvbKsuny0uPqHe+afMmvP8N7wcA3Hh8A9vbsK5lJSpLhw1FXemPsbXl1jV/pbsCANgcbeJHv+1Hq/9mpbumxteBiKBKmlFnhH/37f9O/Xd3xF/cGbHB2mvKMfjOV3wnvvMV3wkAuPH4cezs2A721ZuvBgC88yXvxHd93Xepv994zdLnJBmNgKtXbTZdko3RBgDgR7/tR6vxojX86uOvxgffqHTuxmMb2N11rxS68ciNAIAPvelDePk1LwcAvOToSwAAp1ZP4V9+y78EAKwNTyhn7HLCAzW/N66lRqZrvTX8xDt+AgAw6q8rgMkAhf3IR975keXPtti2QO2gO7d0Li2GKmg4SBPsaAjMmDLkxVUgYpRufp4PEAxZWVH2RNc5qi4wM02ua6FNyEd8z03fg7dc/xYAwKuOv8q+kILOheP2mbAHxHZvLCy2YPqNfneBK8aliwUw7AwBAD/17T9V2VOxyTwjtO7feOqN+L6v/z4Ask8cjYBzdqEOL50VIL5oN431OC30ZUdfBgD4wBs+UNmXl16j9H5juIEf+7YfAyDbUAre13vr+Ddv/zcAgKMjZYNN3LEfUigMwkrnQoR47eZrAQDf8fLvwLte8S4AqD5zkmgIJFctoPqq0k464ZZoCMzdJunG9RurexFuueHYceztuRP2LznyEgDAD77pB/GKY69o3He/Mhwq8GzO0dqa8hsupNBw6I5bdNFtqA9ueeVxNR9ve9Hb8A9f8w8BAK/aeBXW++sAgJ94x09grbcGoPZdb7r2Tfjer/9eAMp3Xb1qYxEOt2ys3ajseMjZ0AtuyYvOSokvhABz6d8PWRzKCpHlHEm82OJJBC8b6tbYnMMtL97YxM6OTbIMBsBFY6dqihEQSzjUbbvNyoqyoaa9uXb1WgDAD7/lh3H92vUAgLW1CBcv2qf5cqR20Fll5/Nl5aO+/w3vx02bNwGo158p5Ave97r34c3Xvllde0xd64xbFltgiZ4FM0fcZwDrEyni+ul3/jR6JXb4uuNfBwB4x4vfgX/wmn8AAHjR8RPsfHIyGoHF/+R3Xrf5Ovzj1/9jAMoucteurADnz9s26Yb1GwAAP/RNP4QXH3kxAKDbPQLEly1S5yXlHH3wGz9Y2fUXHXmR/cCkcxwOXWw5NWiPy+9e6a7gJ/+XqDoRHQAAIABJREFUnwQArPbW/HCLIESifOSdH6mIoddsKr/9t176t/D3XvX3AKg52t62sdlgAAuHSlVfPrjlxUfV+L9m4zX4wBs+AKC0oQy+vbZ8ppcefSn+yZv/CQDgmtXrgGLhhFuIFDLJrdVVYGvLcYdE94jSZQMLv7Jce9/92u/GW298K4BaBw4iLyhSiILDAwH3aAjMzjhdSkzmW1/0VrznpvcA8MywUnl30ZxZUsWbTtyEH3jjD6jPgi6AnO0i7ipUgnjD+g34F2/5FwCABTrK6RsKTD7ixMqJCiwHCBCW6O49N70H33rDtwKoDcPR4dEKLBeF6udjKuVwqBaz3diubznCUW+Kq1sZq+xnjV05SVL3vfnw2z+Mtf5aeW2B5583ri1GylFETTIOADD9agNUjPpT7O3az5uWZM7rT74e3//67wcAdAcJssxxHyvtizcqH9YGe7h0ya1RKWVVr127tiL5xPXXWS2d4/IyOirhXx+sN+aTlWikDI5RqUG8z7te8a4qoOkPM2xt2Q6WmOq//bK/je96tQJXgUeJBul9n5lOTmiMfuRbfgTXrinwRFUEN524CR94ozL0ncECee6ebYjKTOsPfuMP4tUbCjDOEzVHLzryIvzwN/8wgFLnilQB8aUPW3r4uBlNUMbumuE1uPltN2vX94C5oXQeQvM87Axx89tvroIUVqKRAg8GqB30ZjhjmNBK50LHSeKks6ICVHPrp9nXg2R+if/ckLU1FazpDpbAsklqOxG+S4TW33tueg/e+iLljMVqLJ/5jGwbCkD9vQFWhl1mjrSqhQ+//cNVANp2GpcpeVkx+M3XfzPe9/XvU68gMAIrK8CFC82ARMx8dVfl+XSsZqDneP8b3o9vOPkNAOp3O7V2Cv/qW/8VANn2kP88NjqGH3/bj9eP1rX9nE+FGY35qDvCzW+/GZ2wgxx5tU6+4xXfgb/7yr8LoLYxTtLh/RytNCfc0lkBpmedAgSqTtBxS3eQIM/dK8IqG/rGH6yIO/GQA0fpdJT/NknQ0UhhEReha11wC0k/6uPmt99cEa2DQeGMW4iIfedL3ol3v+bd6qs0uH3z227GNcNrAACzsgrmW274Frz3de8FoMadI+M43JKE3TJJwej5/JLbNpDOGhBfAjgC2SVJQf2ZFgypbUoQKHsWM3ZRspVzu3cY/xx9ZxKUwy3dQYorV2w/MRzCwqGLbFQmJzkcesaJjFtZUWST7rvStLZ1/+yb/llF2gyGCZv8yDKbMA375XwaukfW5/tf//14/cnXq+8TKkpIl9/39e/DW25QyQ/CQ864Jb4EtrrYSN6qzy7xJ9Ix80lv9eG3fxirvVX1Wa7p3KuVznX7Ca5cccOWVOVjxis0Pm+89o34R6//RwCA3jDFYsFXL1661Pw8z+ux/KE3/xBedo0imZJooHChQS7Q1//AG38Arzvxusa7NS8csrEfgHLc3WOFI/0jVawA4MA4FFBYohN2cPPbb7aS0n/nZX8Hf//r/j4AZetcdU5KtvvgFqok/oaT31AR60lANrRJgNOov+r4q/ChN32oea0DbpFw6NGjap24bR8rCXtjPgmjfPdrvxvvePE7HG7kJi84Umhr64DAnUghaRuOJqQQo84I/Y6yGl5H0ndGAGxigAK+YWdYBWVX01gtJJdAUnre0ukPOoPqefdor6oZdJa8SL/Tr54hzuoj6fudfqWoVJrYi3rolMFHnMXo9+1M8OqqUNURDYBZEzGN+lNsXcktgzwcAmfO2NmRRbaowG2vzHr1hxnOnWuSLFlQ7qXlmNr4cqPscdSbIi9Ca58vzf2gO6jGZxFsI88dq9WoBNowyOvDXVy+3Hw3KVCiZ+hH9RzNpZLNzkhljR2279A66YW9KkASA0O6r5FlHOvrp1xrabSHrS1F6nHfp7+H7+ljWea+f5hITP37aA3rOrcIt5FltkGWpHqPTr/K/lK5/iCqdW4nK3WZA7WmULWI4WDJRvSiXpXpirO4NUhxEX1s6F0AoVqkM2IzzKPeDGfPNtdtHpT90xwqd0TprJYgyJEYiC87BbNra7aD7XbV85uBpGs1WptQiW6/08eoo2wo10sFQDmfjuU00UAF8KbEl63Ag4g73c4UhbbFKgjQLck+8dkYoWuH3VqPpL35q6s2GSc29eysqffg1o9jRpK2pPY7/SpQJzvTj2o7FQtEYmUXo15tI7IF+n1FbjUe16Mgjsgm0mOyHdyzee35j2ibdBMMku1wwi2dFTYbzUk195oNjYOrXjaUmyOf9SdJt2vP0eoq2AwzJ2I1KoNbknJ8aWyrn4PCGbeQP9Kx2ngxrtambvepF4quc4tQYREX3LK9WJQJKsmGOlQKdddLDMlU6XDVi6YEoQroXQPJsM8TA/FlvhrVy4a6JYU53LIItzEe86cFXbjQDEozjABkzcNNSCQ/ZwhnQ+O4tin9qMYivdECly41/XIUqX+b5GjQo/ls2g5qC9CP+hh22/Wz8nNRHSuQ/XLGLfFlvpKKS9zHl4VEr31tBlSxCvk50iNd55JI9ZV0Cb5HI+VDzS2inE+UYgVKUOnxynyuYX3NLsZBT2FIwyc25qjNhoZdpXcsGXcZPrFCN+pWxNUsmfnhFkZoW1q1dqOmXdTjiiTaYSv6RyNVdaXrhjSPPriF3nnYGVbPcDWJ2epF8rWDTm1vryaxTMYZQlWuZoXpkSM2NhWFYjQj8UP9wRrrxCMBKMkLjhTa2ztgpVBnpLIK3H5lQxokSznh3AlEokRltYhRrkqEzLBbLzrV3TyzyBsf0Q1LBdrSRRl0NhV4phkWeoZFtqj2WepOQTf0RCLM0zkGA+CrxuFL6+sKiFnMezS0siOj3hSzWWGVbA+HysHqyl6ANyL9YYaLF5vOuAhHAAq+/NjIjoz6ihS6augvzb0OrOPwKhtIskL7eQ1iYH24i0uXikamWWK3OZJPPE6ZKnq4EnHzvuU66XXUtd2wi7zI+WqhaMSWTY41g0NrLQl32GN5daJRB8CuQs7YNfCgMdLJG1rDus5RQGMaZEkoC9bQDR1oEHGXxqXOOZI3Yd8KPMhG9KJeFVDM07kCRdPnzTs4C819N1JAqSIGOGcRlaS2AWpHvYmV7VIEeMH3BHIVqhbhiAEu8HDMdq2vK1JI1zkK3MySf+fGyC2i21Baf6Izjgbu81klNAwiLI+tbaqj3syyi0FQVM8F1DbUByhwdlHqD0ZZUT1IFsF3d12eT8dAUifRqyCF0U/Jhup/TwA4TlXyw/RzrlWL+n1J1+gnNQfV/bXX6WOCznFAVcQtndUy8FhODFRgWbOhRKy72lA90K6CzkMAqv2+XV28vq6CYdcqAFfcQrbZnM/BIHfGLQ1CkOY+GVfBfhiEFimk6xyRQi64RSUcU8GGXoSLDUV3vdRDrqrD1c/1gJljIBn2efImvgSEA/vzyXOOvY2G6hkctnZwuCUJFaY0K+O4ip4iKoELV0nFVOlwQgkNM4lYkUIaxumP7G3dUaRsrunn4qwk4Y1AcqoRnsv0Uyd4TXvrjFtEoud5GwdITdHn5xukNm29H0SGzsW2zsXhNorCrdKRtpyLOtdtxgpZZscKNJ861E4Sg+Trlpgh6LE6pyf0l9rQsMvr3PySU88b3ScCyi4leeKHW7j7prxPpD6qZlwB2BX9Kyt21dWy73PBLRyBpEihDFjwxRW6T9xJF8reOuCWMFQJJjOh0eupdaYnn8StZBFtU23GfhMmcX8YCZgXFCk0VOu/ERx67+3vjEqnsNwg60Zv2UJihUpmzYBPz+RRNieNVXXL1D7i2lVYEiGL1WIZP80+w6AzqBj1eTpvvjOBFS0jQH8DqH4+zz/f3E41GMDakpMkKDNu5xpVOsOe+kM9i5HndS+KZtCp/o6MR00KpTh3rpkd6Q6GCiBwJcWzc9BB0LA3Q5aHVsVTVSXWredoEewgy2Bty2Al7KlnmDzX+HjUn+HShbRR7SZtJauyfhq4F4+kj1r6KJn31TLigFYtwulEyTCbBNtYAw81UFXXmFkpDgD7nLIzHKp1YRpOSWiM9KCc1nBjPksSyyxBlUQHYlQBQvcddAcNcpXTOVGiHjB+qlG9qJO2gEbchX1lIxwy+5zomR9AIwY4Z9EZAiisYGKlP7Wq87r9Fp1zlc5qqZ9M4MFlDmfnnE54oG1Mus5lmaoKeOaZ5rXO2ZkW4fyG6IwJXLkExowNrcTISo3KOdKBRNCtqxCAem0dtFJI8olra8qO62SceEhEd62cT6YKYPKs27NplXxm5rphpwQbqv89AERBhEWuKoWee67pj3xOQzTtLeleRQpF+yPLFb4oLPA5ZcCgiFvadM58D71yWguqksQmzSTRbehhVgr1+8DTTzdxQBAwWX3hq8jHuOAWvYoTqOezP8ydcQudRqjP0SSeIC/y6loTfzWIzUCRcS64ZSdZqIDmADZUbVW8xPd2Gz+z/O8BRfSMn3YD7VFf6b2JSbJZeaKSIbOzbo1vqYeWw7UcbiEyziRBqfePTnpHPfKJDHBxJMfIhuqVSUWhJb40crU7nOPcuWa1W1EoYui5JgzFeD5kK0xnWrJvWZVr5eciOVZYilvyhPd9s3P859xOCkE/O5HyJaRz27FGwpMvCHaQ5zZpxslwqOb3vMGBsnax1E8zVqD51AsbGvOpVwohAmYXrGB/rmHDZdVcCoc+ZROm8SWejDOk8l2dZpVrQSTfPgl9Mzm5bI6Kwk3npEpvH9zCkXwV0WMQ1dyun3EaAwiccUuvp3yXLlmmCC9914VYZR2V/TwN7DTRCz+WvLOPvKBIoVG57VAPDp36u+jSWXUuH60yBVG/WrRTrhRU/K6RyjCNn2x8XC0kjV2cpuVxd3tPuGU8GOHKuxfZonawmgLrxh9QADjN0+aWJQOo0r+JRBoMVbm0DpDpv3UjO59DlanPnm9kJEf9KYqiaWTnc6Xszz/fDCAmC6PCoQJiCc6caQYe3WFZpTM1PCGgDJmmPKPeFFnesYJDLis6xzbSFHiyOZ280LagvcebPYx6U2xtpQ3jJfWn0Ek+fdseK50RgMBpf7/J/tO9WccSlUpnABupUqgomhnb+by5fio98jx9LMuAZ91sbDVGnbBTOTHS5VF3VJc1F2MEAfD44273pa17HNk0iAziLuwDk2cA5qhRS4gY0E5QmWmkG1A7zaK6dn8nP1RVYkZAI1YKFYUVTKwMxnj++ea67QzKqkhO51ylu65sBFfttsco3fSsGrslQtuOTZ3r9ZQu6+SWE+G7RLhtSGKwHw3VfLo0U45W+AwqYCUeVvpjy4ZOTSDW8a8UagQCRHgJf7++ruy4DmzErd+dFUUoRkP7d3tPOG1L5LZUkN4PokEzc81IRcIbGeZBuS1ID/bNjHybSAC4QVhp1SLOQn3rjESSDgaX4pbuulpTHsmERrVlPkUUAU884RbrU/DTi3oY9UaN+x5EBgNYCarFQum5TvRKZB5hSxfcQrbZnM/+MHXGLXTimm4jqMJQ3GaoBUpUieCCW7bT8sAL1oae43XOlKq3ILNOxk/ZfeDYe/SVf3Co0ldkXNMnVsIdFONqQztkQ5cvVg63LEJFIugkaJapYP/555vkzWC1xKFccOioc5wN7Xa1xJdGIgS9uRVIhqGyuY8/3iRMr+yMVIWhAT7nGu4gYl3Sz4afM7a/euGWmGFkpk2dqx+QIdOmz0NP9FZV1mEz+VFtTYr0+VQkn06aSXaMcKikc3oyfhGohKMZK6ytKXysz1Gng8a2USJ65kUIJHZPR32Olm4LCgdK58xxLzJ+J4UhUqyQhwN3nePuKyRKiCxvbOGOti2dS1NViWzpnAAHfXALF0fvpuX2sb1msFAVeOhxRVoWYjjiFkpo6Pgiju0G8aJ/7YxUTsdIDFJyiNPPg8gLihRaX4e1OFwa9jakd0wFOQ7bbDjQ5pXVoj2d46caGQ+OXYzTWDnnCaPAjqLvhdTL3ysiTFNgvVIIgBWs6+9MikpgmTJZK6sZzpxpgqA4Vv/Wg6ssg+qQPj3TKFddH+4iL6KGQU4S4Jpr1N/rpXNnL9Z9cOj5AGDlSIwzZ5pl37uzdTXeHAiaNQPJlf4EWR7hiSdqxjlJ6nFoVOnkc0uBW4EwBXwasFkf7iIK0kYJqhQo6ZVCQRBUxB27zau7rhw8l5Uy72tkxGlMWSPZXS8Dj2Y5DZeNTrpXLPImjpvZo/1U3K2tKTD/xBPaOwhqWBQF0jxFFEQIgqAODkvAre8TjrMYg4ECBC7kMh1JrwMmuu+gqxF3aVyCzzPuTTxnZ5qBRzm+9Pykc3lFajuU/DNiOuPWSqHuunqmyTONj4+tbFk6tzMtdW7swpgK0jsGzK/wYHnyNN+A2qHic31dZeb0/f39vgJ5Z840Ha8J+PYjbcS6Jd0jJenmMJ+98lquabBRkXjNylWcOdMkwsiGmpUIPj6NSAvdP0gky9Gjaru3HneIpFB3HUDBHxc9c8tIcttGK/3U9KhAUTV/bnyNYRcJqK6u5VavGHOrUptIOkdbxRp20Wd7enddVU2Mn2p8vFf6MSfc0j9Wbslx33Zs4pbhUNlQMZOpid7TbGm/LQ9ZXVW6rGeNqQedXk0jVaqtr7vjFrNSiH6urifOuKWxlcXo+1TpZ8cOZuuKFUUKueCWeUpJiqfrSo1qMRdueLO7rpKWXJ+M2Rm3e3RW1bVO5M2aGneOvJkxyueY6EX3qDWfknC4ZdG5jDQFntJUbjYDjh1Ta0cPSsfzNfWue0/AkvkFp0MZjhxR99fX7WBgVEOX2406wymCoFntNhjUPTp1/Tx3eV0lR40q4JhpKyHpp171V/WK1LbrAo64heuTNzsDtnpxwpQkTs80Er0WaduRSfhF57JF3khYcHVV6ZhOgC8WfMwUFxN0uypWICI6z5WdSdNm3GrOJxE9kyICEFm9wPQ5qog7yYZWOJTBSRwZZ4hOeAHGfLriFu6+RnLS7DXK6ZxeTTObAcePw8KhZo81Eh/cwpF88zSuiyvI1hU5W+ARZ7GqsnfELYRDdVJoOlVkl558EtvmdNcBBNY2Xj2xvDQ56SEvKFJoY0Mp0yOP1I7Qu7/Q8HqVkXRwCnovnWXsoijdNQXatL+baAFfoxlb90hJIJVWxOWoT010QADUALjoHVP3JXSeZ9XeYbq2qhbRACyX0QRqY3t8M8VTTzUd4daWMnqPPFIbzk4HwPBapVAaIbOxdhmLtNeYzyAAbrhBgW49gHjiOfVcVBJKBNU1J6a4erXpNL96Vh0jjL3H+CZ/Wg+GMCww6k3x5JM1iJxOa+XRx2GezbG+rgABOdjW5se9a5qEYDrDxtpldMKsQYRJlULWfJbjzlYL9TcAFMAuA0AMsdj/qKVSqL+hgu+dRxpR0VQDxjQ+af884hh49NGm06Nsvc7++5BC/b4Kbh9/vN4OIO0jprGhsaoazmp73XWncOSImk+6X1tPGS6bQ0HnqDOqiLusyFD0jje3j7U18+xvlPpZAps8bzQTBOo5SrqlLjuU/nJC424GNOx89DcUqbX9aIOQueHYGauU97mzawByYPexfZcUo7+h3osDK+On7Kxx2OMDBEM2N5UNMkvojx1Tc68DvEcf3d+j66KTC6YNtWRwUq0Tl2z98HpF/nDXbj/cWGM3HDtjbSV48jk1x1WV5T50Udejyi4K4GpjQ+muXgkqngbV31BVCFyfgvFTNWHaEnzq+mkG39UWC6qMY2ydDu6BGgAf21B+TvdHX/6y+BjyfamXU0kQcD6G7ImTdI+qOd/9UmNc9jTbvBS3DE6Ux3QvbwqkE2w6biEbSsFPqw3ViLt9bckX5MQJ9Qyd2oTiyhX187HH6uukTPLmpjtu0TOw+s9jJ6fOuIWrQqE1SdeagXajeW8+w2gEZ9yC7nppQ8t1QuRr2HWyoehvqL6CXCXo+GlUwWEb4VP5uRK0tx32MjipruXIyl1G+SbPuNnQ0XXqHRyu5XDLonsBSQJ86Us1BkxT4PrrVaCqV6KdvdCvq8VNvQ468hHrmpAN1YnNq1drEiEKowrj9Nd20e02t8NTkvWpp+pKoTgGHn92Q8VARhXTnMF1ku/SKzO5XlmAI27ZYZzu5Nm6dUHj2kfsdTN7vrGtcWqQQpweVQF853JlI4gMkgoNokgRbE88Udu42axJ8OrVIhQr0H0nEzWfvV4zqTAe85Vf2+gqnTMSPrFu35f58ErnKPbTcChHVhpi4kUa00X3mDtuabmvua2Ws4uJFlcQTs8y4LrrFAmkV8BJrSB8cAv3DI34nOKvdFr5Amt3TveoM24hHEoxbJIo3xUETfJZ8l1V7Lf3lcbHeguKpTjUQ15QpNDx42pR3HdfzYZ7nxYzPKkczW45gC2OSd8+tqxJpSi9a4Ct+xs1blwDqCRLgP5x4OoDNQBxORVCE33fJFATPVl/A9h9tG7Ql44bDbKAWtl1Q29msMyqoo1TMS5erEHJZAJ84Qtqju65p56jMAQwukGRXNRzJItxdLSNNOvgs5+trx0MgGvVKeIVM5ymwGc+2yQy6kqhCQaDOpjLc+DOuwIFgrbutxnysAdsP9T46MhoB/ffX/+70+EzeYtsgWPHgPvvr9dda6VQNZ+l4cwX2Fy/hALAnXfWRJgUYOil4MCSbV79TbVeLt2+NGtnsv+tDWf7x5URvHJvo9GfTlpUJEuksk6f+1ztNIdDrfHuARqeHTmixp0cgNQ8tALW5ViZ5I3ZW+TYMeCBB2qDKx6ZjbrnErdHlzI2pEd5fwPYebgGNm0E7/Ba5aDpOOpsbFfyleB40dtoNlb0CSJhE4JVJQG7fawPBD3g6ulGBceJ9YsYDBQwBpQO3HFnoLK7W/fvu6QYg00Flq/cb/9u63771JkgBC7fs/S2m5vq55131vr66KPq84ceqreOTKdq7R5U9H4PSzM0oxtUQJ6Wzrpte/LoBkWMUT8KnRze+lxDP08dOY8wrDOgWQbcdW8zO7e0CTYjXPZc8ombmwpI62N6PzO16oabCgVd+oz9u60H622sLbZNz7aa27EIaJvJD130Shig1uWNUwucOVPbhvEYuOsu8THE+1aVmZ3mli49k+dFkASBas6+dX9jXPRTR5biln6pc1sPLP06tvFuluD4cXcbys7RIWQvr71WAWiCWeOxsk9JovRexyicbG664xaz3xv9PLqhvsQFt+jN6M1qLrL1VcUA47viNK58IkkbbkHvWGlDCTCXiyQIgcuMzpnS3wRQABfvtDHz9hfK7etot1/DUyppQESP1DgYAIbXqW2RtP0i0YKZS3cB5jbLxVZdUdFmz4Y3KLtJlUUt2964cZ9nU4xGatyJFBqN1Prp94EvfrH++7vuggokt+63t0KFXeDqg/JzlkI29L776s8+ezpBgaIKqCvssb6NIADuvrv2cw8/rIiIBx+s/dxsBnz2CzSfdzTmc8FUF9CaMoUjePX+V4Ajbrn8meb8AipxS0S1bvOv3Gevm6Koya08aRzSAdjJjwZmTWdYW1PzSYTesIXnOHpUXUsBfLcrbO/M4ipW0CsHNzeVXblHgy0PPlggyRMECBAGYTWf20Wpq5fubAQaFNFw427J4JRKGlBVmo5DL9y2tDelvlsBqMc07m244xbuvkZVLt2fnaNsUukcEWykc4OBIvKBMva7k/8+H9zCNSRv2lAiIPOKFNITJYtsoYgaR9xy8qSyG7TuJpO6AvS22+p1Kfbt62+qOPfiHQ3bp28zrPyORy9XSV5QpFAUqcVw+nStaHoWyEn6m2pSL92hSlNbHBMHgsSeLm3fN34KeinkrgbaGgtpcFKBD1JcjilvEb1BFlCD2qR/otzaUdKOYa9R9gbUjG3D0JMxXTQrVqrM2IkZwhD4/OfVvdJU/Xeno+aIyOmHH4Z6t7AHXPms+jCbIQiA1cEYp0/XJMsTT9QO9u671WeTCfD5R5qMNQGmwZE9dLvA7bcrJRqPgc98BoqM08EKSRABFz5dNrhT43x87TK+/OX6GYqiyRbrhmFzUynnMnJCPdxJVW5NzfE6I2yuXUKWd3DPPeq98hy44w7+z/WmkcCSk6KoquPK6aWkkFmB1BqQhF1FUl453SyhZ4jNeTrD+rqaewoQnn1WMvR+WySvuUatIzKcy05sMwETR/AmWYITJ1QWjpyNBAjyIkeapwgQIAojy8jS91DQmfQ3FTlCTTjbKntGNwAogJ2SZUFokbZVdqO3ASAArpZKB78j4E1CsCIGJJKOyFUtI7S5fgndrlq31Jz1nnsA9I6q5zJ1zlWIGLh4m1rD+hqZPMvs/SiDlGTSuo1sY0PZBgr4skw9+7XXqmCRsnbDYQtp4SHVFhndGUvk3ei6ZlDeth1usKnA3ZUyQtArp7ZON7YjbK5fQr9fkxfjMfD5RwRSyGf7GGMXJZ+4WU7n7bcr/Ypj4NOfFm7c31T++PJdKkDQEyLJNrAotzm0rC0922rqp+nnuHfWt18D9ThtnpojCBSBCKg1f/q0+BjifalKpLKBiZ2AkbKXonRtneOSTiJu6W8qu37x0ypAaAmodxdMT45sgZMnVS8ePRHASVEUFbHeCTv7a64tyI03qp8UIASBAtpxrOaKsv8PCNzXYOCOW3TfB9R6NDo6dcYtXDN6s8qVtgVxBFKcxTh+HM64BYPNkmQp9aqyFUVNsiyzPUWmSPh0YhwpOKsr/NoqB4bXq3tQRps7Wp5kdIP6uf2F+jlJtk6jIrVIGja0JSkx2CzxzL3ls8vBrIRbjh5V64hIlsuXlY/pdJStS1NVwXD33VA4VE8OVc8b1kF5S0C9uanm9Y47lK9aLIBb7zASX+W9w5Ut5Ln63slE+bnbbwdOnVLPQ1tRRiPgrs+VScTLZbKv3Ka30JN9RlLYFH0rqBkreOGWLcaYhj2FOQGDFDptr5uwD1wqWZZ0YpG21Wle+unMGjFw9KiKW2g+zWPkdTl2TJHNhPvxp8wYAAAgAElEQVSzzCAcNJ3b2FD4VyeQaD7vvFPNUZIAt97e1Ht6titZUOtcNq7IO5ojvVJIrAAZXVfqXFkVpG/N3zrN9+zSRPKJs+4xd9zC3XdJcrIZV6iKfl3nLl6sK8Ct2I8RH9zSuFYn1gcnVFUltYQIB1VVbj/qVzsF8iJHPjjpjFuuu075KapkpyKHJFEJNUpo6ERiQ/obZeL+dKNdRcwk7r0qkQV5QZFCgKoYoFMm0hT41Kc8b9AvyyYv3qGMcctees4pUF8RZxmcUD+1TNxEY/DCIEQURChQIBucVL+4fK+yHFxPnBah560ynUT0kEG+8GllILJpo0EWUCt7oxrCKD0nQ09jsXJ0hsEA+Ou/VouaMiVra8BXvqIY8SQBPvlJlOXHPeD8JxXwLAHy0dE2nn9eZV2yTAUNGxuKALztNqXo/T7w6FcMZrk09L21PQRBnQ3sdMqsSn9DOZPxk0YwWahsdDavPj+xfgl5XoJAKONT7UHVxiHJEpw8qf6Gst9ULcHK8Dr18/JnymzGM9hYu4w47eHee5WTmExkdls/RhFo3/qAzlARXlRp1kK6mBVlrX1lgLL0/EkAeRWszRiDM0tnOHpUNYLf3a2ZbsnQ+8jmplpLRALrmTPu3WisaH3rIDwKIwQIkBUZTp3KG/eTmk7T8xIQM7Pc5p7rRb/U+wu3KZ0zM2G6DE6prTPnby3Ht2j0HQO0OYpW1Pye/6TKcjo0q9TFrFpYur2kd0z1HYivVMBxY+0ywlAB1clEreN770WpczNVViweM9Ui/Y2SGLhHgQwTaJjgMU/VtUF7X4zNTQWm77tP2YfpVD379der3xO5demSfdzsfqTqPcWAZUvILp77hHLsbeRhf1PN9/lble/Sm2zPzpXgXgHHjbXLDRva6wEPP9YEYvs5Epxr2JhkPCDUybgsU3Nw773Su22o/jiX71H+2QSrl+5Wa0o4Bpd6iQFKB83qC9PPtVYKGXZxtfRzn/iEeodOx2+boZltpZ9V43qHPgei9I+rIH3y1UrnuCpOEbdUOnevCqZbGmPqSTIdt5w8qf7m3hK2SAcxEGnXCTsIguBQK4VOnlRr/NZblZ+gAwRGI0Xm9fsKo3zyk/I9XHGLWcVZ/VwfO+OWRkW2Tt5A08/S9lfkoRGknDgBZ9xSELa8UgKXXSrzJJ0L2pNJFHhcvlfZoMwILi7ertZR25ao0XUAIuD8p5TtbquEH5xQwf75W9Uz6ifrbD9cPoO2pqM+cP6v1Tu02tAN2YYaIuGW48fV/FKfsbvvrgnwu+5SBHgYlrZuUGbxd43sdVEoXLhE58iG3nuv+q44Bu75XBPj0LMVo4tYLJS9DUPl5+68s/Zzd92l7nH2LPDMeUoi3qe2XqXq0JdGFQoFkkJ1AUfCiyRCG27Z/ZLCrrq/D3vA+U8oP6DP0fQ5NWb62gkj4MKnlB3U9NMkbav5NMjVjQ01Z0+XsEUMvqHmOctq8vn0aaGCMk9w6lR9DaD+ZmNDxa333FMeHDmvK3hNbHk+y9S7Xr5Prf9siqRQ9GgURAiDcDmxProBQFgmwrNmk/et+9XYtvh/MVaIRu64hbuvmZxssYvzbI5jx1RMce6cWsN33aXGUo/9okjGFz64RSf5CM+neYpiUE5oZUO/XB+4U96T5jCluH8JbgFq/SRya3tbbR8jUmgwUO8nJtSinpqLqw82Yr9Y04P97tDg5AVHCh0/rn7+4i8qcPbrv+55g0FZNvn8nwDI1aQJopd3V5kx360Rw3LGH/lo9REtJLpntZD6peN+9D+o1f7IR7y+ithiqwdNtK4Wy1d+RRnfL/1cYy+k/iykKBxQNcmJ0ZEJOh3gv/5XBYD+y39RoPnYMaW4v/ZrKmD8T/8J5daQEHjm99Uifu6PAajgBQB+/ueVUv/qr9YO9o//WH32138NXN1rBjTVCTFr6jSI//k/lbE9fbrch0kg6OGfaTbtyVOVFU12gbFiz687qkoFPlIO90c/WgdxBIDDIESBAtddrwbullvUtT/zMy0TMroBQAB86efUMzz8M1gdjIEiwHPPKTBRFMCf/in/52ScLIMsGfHuunKMz/73VrLTdNxLiYH+MfXzy79UZWk4gxOncbVV52d/Vs3dL/8yv/dcOhZaEtpSSOP97/99+7tJW2Sqve7le5y6Pm3c7yOCykknCEmnec2jNbVd8yu/rHTu0Z+VX26wqZzq47+uxvexX7ZJW9pyEq4oQPXk/6n06In/Q74v9x6GMzaDZ/vZNtTPR2+pKsU21xSJ+ud/XoOoZ59FrXOPGDrnKlRddfke1YjTaJyHR29p/jubqyzs7uOtFZ/r68rZPv008NnPonr2a69V9ukXf1GB6FtuEW/hJeQj9N4F4ulP/U0150//lloDT/2WfGNKaDz7B2oNfPX/av7+Sz9X9evYXFNp4Y99TL3bpz8NbO02A9T9HAnONdVMhCwhbck5fVpVV1650rLtirap7j4GbH/RCFBDzYZ+lP1znbQNgsCyldZW2ZZKoUrnShs6OjpFtwv85/+siIff/M32LVLSfc0gpUEe7rdSiNG5qWabl+IWClov3aW2A8xk8Kr3qwFqG3qytKH/oYQtog1NjeBnSSWCj2xuqrn5jd9QOv0rv6Js09GjCpMQRvlv/02+hytusSoRyJau7zrjFppn3UaQTyRbT+uQC5SSLMF1Zc7JBbfkg/LiR0oj93DpSLNY9XTZebR9C0hnVf2cPldiZo30D3vAl/93NU6PCI4ZULYu6gOP/5qyeV/+hfZrwx7wxG8qW/e4BvSLFHj8Nxt9ZBB0gKd/W+Hcp3+n/b4ISozUBc78mXiphFtOlPHeRz+qbOvP/3xN3nz848rmffGLZQJrUAKXRwygWCSqyjW+Yp0eqAvZ0AceUIcgXL0K3HO6WQ1drYnuRSSJIkMfekit+49/XAWdUQT8wi+o5/3oR4E4Gagxm51ViasgQAI1q7RullW5Uqxg9mkEPHFLkQNf+Y9NoiiIgKd/V62BZ/+w+cVf+gWjWigAnvsf6m/Ofrw+pKPUteqId62CV+8Vc7I0oT9TmtCfbYFqpHOEQ2+5pXlqYCfsIECAvMhx7XV2rLC5qYighx9W8zQeA3fcw9vFy4uSMJw8rSoVi7x6N7q26kUnbQuiPo1f+VVFnj368/Xv0rEat8gjViCiMBi54xbuvgmPQ/XTKfW4gnTulltqndvcVPb6L/9SESgPPtg8jEYXH9yiz2cQBBrRU5JCj5Y27pGPNE5hBrSdAr0TcMEtgEpo9PvAL/2S0lNafysrqgfjn/2Z8kd/+IfiLVTsl82AZ36vIlG5irLD6N/XUt/5/45cd50yuD/1UwrMj33xxODakmleAB871Vr2xp0ik2QJiqJA4Br0rLxYGatzHwf+aB2AdnKTtpDiLEbcO45+OFB7SP9ovd6v6SjVaSbUu6AEtdPOuqpE2P1ydV+qVjJJoazMWjT2XpbGlAw9PffqcVWlc/Gi6sxPZW6nTqmM24//uAIs4zFUNUSRq3f6H0eqTPD11zyPB555E265RYGxvT3190lSd5hfLAB8XdOIVETJ0SuIY3X9dddpYH3lJernM79bEoCl5HP1HH/6clAJ8ks3n0YQAH/yJyqA3NsD3vY9zeagnbCjAMG1C/R6Q9x6a32tKMNrVTn15XuqcQ8CVR11ebyJd72rPF5UwOs6Y63PkXySzAkF7O/7IHD6n4uPZWbPyXnKxMB1CjR+8SeVkUOzNJEkzuL/p73zjrOrqhb/d98yfTJ9JskkIb0nkMxMSG8QI6IgxQYIKMKjI++JAhZ8Pt/TB099KmIDxIIgKiJKb6GIhBKKJKEJBBL6QMiUO3Pb+v1xertzb/CZmV/2lw+fZM6cnHvuWWetvfZaa6/NuHFGRca3vmVMnnp6YFzILhWlBoX22cf48ze/gRtvjH7uUbsauHfKAEOemXyG5rY05eVl3H23I8+rrgq5bsSExn9dW0aJesOheXfL0LpcMdqwEX0vwjW1Rs8v3/JOu0w4Vo2908A1tSU3o/f3TRlyS9OqCcafz1xsD/yj618jnTbeW0tXAcPWgeGc+wMWxVDe6CxvuGGO93cqAa/eattQwHBGcim4dX8K5S+UMipM334b1q0zkgmZjHHv5eVG6fiQulwkIhIeWM9ETPYtR2PwTbimZoieHGMMJzHbC7+tD27tvPUiePZHgCGjTMZwQJubTRszzbuMyS6r381KIbcDnMll7ICohbWjE8B++xlyiCwgiyWMnVKyvXD7SqcZLZjLPR4sqEdD6Wcx/dP8/cGsCU1NYy9KGVnK2trCjZRD7y2iUsgK1JQnnIxkqXbR1rnnf2YnWlIu/2JIv6WsyZigAvx5FoV2k/E3zLb8lqbWQSoqyrn3XkePrrwy+O/9/d6GqkQohdGjDYd62zZDRpZf2NpqVHScdhqcc05h2RXrt0RWCtXvLNpv8VRZmM/BqnTzV/KFTWZzkmOfiXmUihXlt6QrWqmMlcHrd3j1KFFpjCG3LfPqnB+ljKWK6bdgw0HeCXys3FjmVcw4F0sYS1mGOrdytBFkSu2wx0QPm86GJ77kOiBGgGVIGzq6sA11Eba7VjqXZoI5JF56qeGP9PQYCQar2n38eNcueDWmfm77Dey40bl4btC45z/PpJDOVVc7fbI6Osy4b60vKGQlHnI91NQYFRWrVhnjXDZrvNcVFUbVgWecK6s3ki93f8hoKeELOBSqcs3lc/ZcwTOBN9/Vkv2Wxz4PT37N+VkEsu965go2m/8Tnv6e83M+aywD/F0T5AcDlUKWj+PpZ+ayi5Zv+YtfwB/+UNgPmDjR+PPaa51nueRjQZ3L5DOMaU+TSFRw663OueXlxv+pFOy/vyFbqQoP8vVm+oyeVOm34c51EEvY3y1gQ6OWBVWOMZudPxOucw8cDw+dEvl9/ZVC1nMz5ElxfkvYdX3JmoCMInTuxz+GX//amScODDiN3gslakrxW/wbTiRiCbL5LOnyVpKxMqMqzZpH+yqFkvEkZGAgWU91EX4LGN+jrMwIFLr1s6nJ+PvHP+5UC0VS0WJs0LLxRHjkLAAyIUtBS046hTDsKoWmTHH+XnJACJzMGBjGxt8AzsVAdgCFkXVMxpIosy9QVIQxlKp2Z521+WL0+4yW9ZIOJJucqG2JASFwMm7uqgWFojde57Q0Mq/r3rbW/W+U+V88FjcipSh7kuN3gqobd9oTwr4+x+GfNMl1T5aMqtqd9Y7ZPnspytTRTq25pQzWAAuG8czlgET40gdVudP+XMtAAFAz0dXQ0PUsrcZf+UH7PRjXtN3ug2Ddg5XZd2dFFYrm0YP2euIhJ5GV7U5Gw3UPbXXGtvHZLAW3QnfvfgdGkE+hCkzgzXX4ki8YLAj0FBqqUqh2svN30zlLC7ZuWO9JOpdm6lTX/ZtfeTA7aJ9bnii3zy2FffZx+hQVeu6pbAqFCuxq4N6ZCBzdaGodKEqeqYz3uv51ydbPlp3oTdQ51TJD6XJVu7P1rvl8e32VfNb1343VuHaz66XULUGjynYjA4I1U7CNh/k9mmvfsvUslXLr3CQj+Ow6tyRUzJh4gBO4t/DZUMDIgoG51KxwrzcrG5jNOrbFyqCCI/vdKXBy4x4bkrGkrRvROtvukmcfBeVZ1e7dPShsu2bz+Yyuey1oQ5PvvVLIXYmnlLKXYoZ9P6Wcyt50OroPmE25WWaYz3grhWJDv1OWfiaU11l2N/2Gwktw/UF4K3hW0/Sup8l0qSsj/cuvLd2zepS5bWjJPQtrJjtLa8znM+CyzUP6LbG4uaUt5pgYbZfDnGWFoqltwN5xa3ds8z8ie9ne7rS5cfuF1mRCZOhgXrF+i7/fmx1wrO8u2m+xGstaVSjWcmYI9h9K59K2PK2+FTEVo3VMumi/ZbCs2dVs1m1DI3QujErTiErWO1G3eg0WM85ZDHWu1X8IIqpAxXvcs2NvAQWtLMKGmkT5LVOmBMeN2lrn2MCAK1FStY9rgxfXd07WmvddWOdCbWjS1CNf1XJvpteuqPCPc1YPVut+43GcKibJ2cFORbAKJazKNZVN2UtIYyrm8QFhN/0WjzyDcwXvua5nmTffxVw/SC5y+Vgml3HkGTfkmclnmDTJ6cs1lE8/fjwBnfNXglpjYtPowcC5YCRpwHhH3PL072bYl+lzKkElC7mBgIzsgGCUDa1sdx51mM4VOVfwy/OdWHXxfksI/p5Cll20xkS3XbR0zgqOWs+yrs65nmfuF/Z5JfgtYckPe37us6FWcYU9rzDH21SisSi/BQz99H83cKrS8vkhAkIAVWZTPQSyfeQFrMdhJRMU6v/PoJBbgXcL98RjCNxNl60XKaZipa3Lq2wPZGD6TafN7agqpehLFHdfUbib6br/3BWvDVRE9UaUQIM3Cq2Uy9D7nKDy+nfsgceNW4FtkvWh3vQ+zdsCzZrLyowMifffm5NZcxJrLWVLZftpaAjegxGQCVnnajlBLtobdgTeKWuS4XGAlaKhtT/43aKoag+1leObosuF3bjXKoOTuY6ewE8OP+7DCh7alUJDNZx1TzxM0oLRF8JcPma9JxMmBLdOHMwN2j0krHcqm88iJcyu2tu9W/1GEdUzx3KsPcEbpWho6y8qEGA3sHat43c7QfbnFdC5SCrbA0ENKyjkD9y9Q2XB7OaQ36PUSqHq8YHmoUoRrXMFejQUheUE+VEhSmf17CqCceOCx9rbXRld65K7t8OqTSpjOMt235Qhdrqgom3IHUBskqOis/k+W5dMZKmp8Z2T8AYE7SbsJTQftBIlfrsYZTusvgpF4Z40uikwcbNIZVNGqXfccZYVylONA9iTgbD33b/82rpGVePOwDhXSvDQrsw0xyxL57L5rGMXTRsa1ecgkhCdcy/tLcpvKY/QOR/9mf5Qv6W+pbj3J5UxZOS3of+ooJBfRvE4niTFUBTrt/j7vdmBHvqK9lsyuYxtH8riZQhiB+/8ybdMPuPpwWT5Z81tg0X7Lf2JhvdsQ52Jh48CiVXvZ7UX3O3L+1ntBZrghihfsWNtsibgy0QR5beMHSuh44QVvPFQ1R6+lN/qOVIEARuaCFZDKxT96X67P4kbd8DUorISqJ7gORYWcFCo0CrXsKo/pZQdeC7Nbwl5L6P6LIU9S59/kvIl1KrKDJ2z7a3ps4rpnLeNyUZv9+2jvT04/7R1zudbWhvx+BnrV7lEeI+o/nS/k+i1PsuUkX1ufAgbWtUOspu7wRJsYWHJdSdlxfstIfgTJYEx0TWvyOaztLcHdc4dMB2KUvwWK3lhV/+Y8kwlGwIDf9RcvjdZV5TfAuFVTpWV2FVpRVEzxfPjgEAc494SscSQzbVLYdgFhcaODU46S6ZIgzyYGzTW1voihqWU2xtK6TVwqTyeCYO1zKs3UVdyF3c3fZk+z8tcljCiou+qyoAC+8verO/oXkNpDQr+suaKRIURZac/MPGoqDAmYIFBUymjb4SP9oYdoTt4tfhjNwnvZNaa0PSke+x+Mx6q2sOdoKqgE9TeuCMQrxrIDngcMSsCXN/SV3w/iZDJPsCUtuIaiPel+zwGx9+hP0DNZKdSowDWMsPADlRR1/VNPKyGhNa9lcfLiREz+xxIIHhjB2RMBzgveeIqXlLUOszZCcPfO8gaNN2DDTiVQnXNvU5Wr9B1zQmNpatuJ9EtIytw9y5VxQdvyhoCA0iPb4lpZaIShaIvn3Gq3XYDO/OT9OpR5ISxsj20mXXoZD9K50ohcuIR4iRaS2eKYHJIvDRsIvmeEg6ELGOKG709IgfjWMKp1CiGEBtqXCdoRFv9w1zSGxSybGnkziUhDGZLGxMnTAg9HE71pPDjQ1SBgWvZ6BD6WSgA7g/CW+fm4r0Bn6OU4KF/WZqle7l8zraL1ntSarDc0DlvoHBQKM1vqQqJmIZgBd78fktdS5E2NBsymVUl+lMRjBoVDNRVVhKapIiiWL/F3+/NSVClivZbbNnHnV1rLPx9Nmz/y1eh1dDaX7Tf0peoDw/eWMvsi8E38bApdifRihZnqeJQJKqi+yKGJR6SdcFjUVgVpkMQ5be0jE7bVUFuApN9MJPCIceL1Dlwls7bJFOevmnuapFix7l4HKj1yjOVNwMOrmroKP20Js7+ipXAEshi/JawHevKGsPPLSLR6w/aWvrpHgusvkkxFaO5bbDoRG+YH2rrnM+3rG/pCySdIFqefp+1P9sfSPRaAS97nDMDJ5G+tLXzdBhFBEf9iRJ798RsujS/xYd/WZo7cBcjZs8r8pJHKUXrmIxd7eYmdO4XQil+y0DGZ0PNAFxvvC7QHN+/E6Wlkz2xUUX5LWDYDf+KkWTSSGgUnXyqmeSxl2EB3piKRScnS2DYBYXcpVa7TdTEw4d7LTeYD1iV2MHbXa5qMuCLLlov0i5VWXg7zSHwl71Z5e/9ubRTrmrSZ7409rlJZ6D1RKGVU9bsXnYgCKlsKjDxKCvzlqt6qAjOJNsbd4S++H7jm6gMX9vam+61t6O1z01gBmRCjGHIxKO9YUdg0LRKh/3KXtvUU3DJl4fy5lBHbGLLi0VVvfjL9Yes6KkqrlLDv0zC3oWo0HVdTqsREAJB7Ih+HsN4t40Jfl87K+pygGMqVtJkoL2dooM3EMxU5fJOryxw5Fnd2BNa7Ra4rjWhSXgdMX+wyfqO/fmM05xzKEImHv6gbUWywtC5TCq02q1Y/FViQ1aLVLWHVvj5dS6ZxCxVLqEDbxi1EdVuYVnjmuLLACZPDtqk6upgEMifUS0VK3joCayrIZYFlZA1pjLCCwqxof7qqERFhA0dLH4dtn9MtLNoEbZjSsQ8MpTaKYRnjYusFCJYheKfUBdaKhuwi64qumbfPLKU4KF1Xb/OWZlqq1Iol88VDiCG4V5mY+KuFIIi/JYonfNhZ1t9NrSyfldkXzw3VkbdP5n9R5S0h2WN4/HiK0yheL+lz7d8zJJnb7q3aL8lJznPuGFlriG4AYT1Xviz0XUtvUX7LT2x2nAbWjuV8KhFCO4l+W7CJuphlFClD0QHb0Irb4qrdgOibaiPKL+lsS0VOtn3B8BjMbzLg91EBcBDCFS7WUsS/T5Htt+ztM2iLiRels9jLm1zZGcFU9z6qVChE0m76s8VQLKC2u57K8pv8W8xD0bvpzCKqHbz92O0g/shOgfQ2JoqOtHb3h5cBm3rnCsQCzCqOXyuECVPz3O3xlRflb713fyVQpG+tHt5sJ/dmCt4+hCW4rf4sPxNf2DdCgKVJ8rtCteYitHUNhDqm/l1LixYC6X5LQM5b1WRFVjvidcE5vIpa8WEL3HfQ7LoSqHycmOXTD/jxoUfD8W3MiasP5h71c97YdgFhWbMCEa9S6ZhAd6vpkIHlXQu7R2MTWUvqdw5WROYHA4Q82bc7LW7g8H7mHtB0R/Vn+n3TlAT5YiIcb++iHOfmRXwBxzA28DOasjlybaahqE/08/s2d57yOcNGYU6ifXzfAcU0yfuDDWcCxZ4o6SxCtOIJLzNrnvSPSxc6DUGVVUYmRj/BLWiDRr2Czgxjc3JgJM/kPNGi+0Gj/E+GiOSGAGUcnafczFjwuue7GVUkLMv0+e5B0tGke/fqBnBYyHvdW+612P07Oh/1HVrZ3gqzfrzRmliXvIkY0mSsaSdRWuf1OeVp8oFgoqWoSpFj8aMKa6XR6BfkiuwGeYsp+kLVlQUuK6/ZNvdmN36XFvnwhy/KOe1dprnx15f0NYjo7pZxV/XR89gj+d61qC8a3BXxH1NNdbq+z5rwQKvztnl6P6gdinOOhg2wp9RrGgLZoIr2ozn4A+8RXzejBneAda6d79TUXTANwLrPfFkWxliMK6bHTwW9dzq5/sOKMPZ9k/4TBkVa0OLxZ9xs5zTKF2eM8e7FLhghc2omUazad/3CM2q+55PqH4qRT6fL9qG2pWZvglNf6afmTO955ay+9iu9C7PZ1s6F1MxcpKzd62xjpXkX1TvE6gCTkNpfkv9/GC2PuT982fE7X5t+X67Z1chomxoZBP2Epk+3ftzOm3ofbGB3mL9ll3m9ezlgObkc9fgrqJ1zh6PfHrkvp57jPFPUgDKanqL9lv68rlg9cXcC0ydK86GUjsjOJGsaAuvNoq8RkiUOOrcMH+mrCncr6vzbUwQ4dMD0LDvkOe6Gyn7/ZaW9t7Q/mgLF3qDitXVmJsD+ByXijbjHsKeZQizZ3ttaLLKm/y1/PRUJhUY55JJ4330j3MDAxjP13UP/WEBB6UYCKkEs8e5eOG5wpB+S1lTMGhW0QZ1c30nRo9zNOyHO7BpLb23N8Yx5ee/N7vibnRPUUFtMFYw+AMPts757GI+0RcakJs1C88Ki0SlN/nrCfSMmmFUzZn4NykaslIIwiv8yhoJTO9LnSuU4rf4sPxQyy5aY6OY/1nfL66M3j+t43oj54kBnQuhFL/FX21p29BcJhCoHkjUhc4r+rOpovwWC/9SsVTKGI9CkxRh+GxlQJd3s5drGMMuKDR6tNfo7VbVUPNi70AYK4PDvdsfW7vIuMs07SaVpZY7Ny7w/Dhovkih121a5P23879a9McMZAYIy8SlMiloXYXbcPaTALNBHDhVReBtNKeUYeitn8FrGFavxrP8K5MxBiC34bRf7NaVEHdprYrTdNxWj+G0HKqlS72GMxMzJ7Ou7dkVir50H4sWeY1BOo2Rfaj1eYmHvwZNXd7BOFGDOuI15vniVelsOlJGHR0UT/Ni78+jZtJ55i89TkWg94dJWLm9+3iAurneSHa8MvBeg3fLRXDkaWUFAlSN9TyzlMRQ8TLDYCtlZ9GUUiQrfSX0yRSJWIJcPhfYyriUirtYzBhMh8K/fMweoM0MhLtpt3UPXV1FXNe3q5lbNzw6F3fr3Eo8WdiK0aHyAKB1tacaq1/iKFz66V7i17rGmy2NVURf14ed+fENYpGyT1QH+04c/hqLF4fpXDJYvWIGdSIAACAASURBVFPkfdk0dnnLmhO1xjUaFgav2+QTXLIu8vO6urwTPuvely/3nlfsMsUo7N5Trma6Vq+YyGVBbWucZqQQOh7ZtKwI2FCOeMNwrp2DcPhrLFliNEC1yMa8/QFsG1pCT6F0Lu0dE2OFx8SuLu8YXbDCpqnLW/ViybN5ife82umB5xOqnyjyeMeuirgrc+3DCsL7x8RUJsWaNd6Kk1IqyvxbuVs2AozgTTxm6H08Fi9YdRVKvMyT8BGBjKjS/JbGLu+yY0vnfLgb7/qvu2hR4PQAqWwKQQI29B/R5wBgzRqvE51IGGOGu8K00FKyYv2Wnrxh08NsaDF+ixv3mGjZB/dOefZEO0TnBnKpkvwWGnyOy/yvQmOnN6OdHBVte5o6vQFI69xWnxGtGl94nHNPK8qaos9tW+t9L+NVhq3Lu2yEZStbV3kDm7FkARu63Ov/q3jQnmSj/ZZ8LBVcAgQsWuSdm+RyGJUt/mDI4a8ZOucewyN0DoI2NF6RQkQCPs5AdoCuLm/A2grCL13qveaECRiydwVZUqoSVDxgQ8MmklHjnN8fGtJvOeJNPD6SShjPoW2VNzmkEobs3VUvKmac27LMI88e8VbcuXXObX/srcZVqujeY0rBXF+8yt0IHrw6t3Ch/woE/M1kVfjYNZAdMN4T1/NPxStBxTxNxqOquWz8OlfeDIe94g2wxatKmiv0Z/pL81t8+JeluTc6yuazARlJPBW6FH3//b1+aNRqglL8Fr88Pbs+N3V6zh2IlXvnFe5zi/BbLFau9P7c2moEmd0NpqPmiQDUz/W0q0ipcoglAk3jc5KzV03sLkWFXJRS71dKPa2Uek4pdW7I75VS6nvm759QSoWoSvEscMVYCj6oKJo6vWub/dlJnJ06RCSQoSnJaQNzwmd5GHH7BXVHe+3rtq4uvhzXhz/C6THIzUs8hjMVK/dG9E2nBQl3Xt2RcHe5dGenNyg0c6ZhOOe7Etq20jZ1ess/zZ4g7iCLJc/OTm8T2Ipab4WDdS99mT46O70lnbbz3uJyVizj1bDAu32iKefVq52BN5k0tgsOi/6nMilWr3YmN0MGJf3OSstyxozxOg9RWQp/c7TKZGXkhAYwtuiumej8HLFm2K4oiwflGUnDfvZfU+ZgnXCV/dqBnqw3yFJdbzTeFcTWn6EmklGsXOkEDaOWBKQyxsTD3yxWRLxLH6ym3dmUJ7AZtYY30KvIfV3Xe+LVuaVe59MfxHDTvL/HDvXHKo3kWMKrn73pXjOw6XqnwjJwEfjLga0/C8q+aX/n7+b36ejwvrf2ZMutc2G9Aoaifp7XWbGCnG1rXO+zqXS107xrvAtsizp2rNdOWfZi+XLvGLLYF8MtFUs33Rkaa7IXuWtlY6ez6yQEg9lu/DbUykY1uoyoKaPOTu8EoSzEhiqlQrccDkNEAssDPE5QCLNne21zwV00/JV11nvQutI7QWheFvin/oCD9d1svXdV/1jnh10DCNjFvkwfXV3eKqc5/sKEAvgrkKw/ETy9ZNw2tCRanOeRMQNZJfktDfO91YARvdAK+S3+5FAY/h1n7OUp/6CgkH9SPn++EeRxVxAVWkpWrN/SF/NW/Vh/9qX7ivZbrAogv4z851pLDMOW7VnPvVi/hbbVriCLZUOnAK6gUKF3r3KMVw+tyWrzMt84tz+RNC82quctfAlTD01dkHApXf1cM8jiqlCwxpimTm/vu0JLixu9E7uwZtvWhgFRfos7yGK9cx0d3lUMti/hTg5ZQZGGfX1+aLQOzJzptaHpvG+JfNypFvEHNq37WbHCqxtLlwIVzZ4gSyrv3f3OvYGIn8A4Z1a3GF+8BL9FKUOuFlZVTGOnt1ea1T/QnRyy3rnGTtzvcK/y9sq0+6WaAYcwu+hODg3VL27VKq/OuZcZuj/PSiZYwWXr30yb5h2X03kjyOfxWZUZ6Kkaa/j1Jqlsxj7H+qwhlwU1L/bOcRs6jGu6G41HbGARNVfoGewpzW/x4U9O2nZRKU+ixB1gW+KKsVi2uaPDW90dVllTqt9ij3P+c7PW/Nz6zsoOwofOuYvwWyyWLvUm8Lq6DL+0mApcwEzIOhVhKczn56pYz0ueRCzxnpdrDxkUUkrFgR8ABwGzgU8opfx1ZQcB08z/TwJ++F5uas0aZ1JebNmfh0rfjgANwYEplTEzBZILDsalOm1Nixxjl6z2NLADV0Yya0YiLSOQqA27WiT+tZB27x8rwmllYWNlDKhyz4tvOSJ+x9qqEnK/+O4mzwsWOEqplDH4gDfIYitt3Ryvw2lGUt1ZWMtYTp7srbptaDMi1v6BMJVJ0dbmjRbvZ8Uv3BkEy3gla70lfKOMCfXixc7ksKJS7O0rw5o8d3U5A+yQQcnGTscRS9TYDvx+Towl0pn2B/mG3CkKvJPyiAaQ9i4yYQN3FK7AZsrMSrgdWfdWz+4JQj7mNCS0eiYU2ha6EEuWOM87auD2N1K23hNBjPJRl85ZutHZ6QQ1Iqu2Mr6B21xDb+0a4w6uhutcuRHYiKKxw8nCqgSpWKVX5xLuwdgd2FSm01kcftlbE7OC1SJtqwIBHn/Df0fnXFnYIpqeB/AHNmvMQEFTl2ND7ev7srBDrHF365ylv52u+UFlZTBjUyph1X05yZGIJQpMyvfzThBaV0R/wKhZ3gmElY1qc2VhzXdu4kRvkNOyoW7dgPAth8OwnCXEOyEWkUibZDVMtCjYeNo/QSgzt7hr6nL6TsSrg5UJuAIOvhJ8QUJtaFjZuH/nJrcD3NHhBLRiMWNiUCyWbvnHEkE8y4Z2O+nUstyuZElJsnS/JV7hbdoeMaEu5Le4k0O1EW6L9fn+MbzkHdcicE/K43HDrwDDJ7H0YKitfYvxW/p8SwbcNrQov8WcPFvLr8G7fMxe9uI7N2ySUorfEm1DXRHOoZowN7qMqOWnupMd8QqzKj3q33c6y4VU0qgeiTy3w5UgiDnXdQdZLNtV7wuyhNgIm1EzvUuWmoNBLHcj5TC/ZcUKx+e0gjCNjVDvaplkV3G5E7LWOJqo8i4v8S0fd5NIeAObdc2mHiWdIEJMxUz7jKd6zKrC7+x07rO62vHT3cmElFlh4294HFblmsp6q5Ui5wrF+C2tq7CnmpbP6q96t/xad2DTkmHtVE/1WG/CGDf8iUHr3vzVE6lsypMcGqpfnFvnKquETD7j8S3d1w2bK/ir3msaTHnGvXbRDvS4E7LKm7AvallQU6ez5DJW5vihza7IZkQiwD8mWr5DT7qnNL/Fh70pkn9MFPEkStxj4sqVzrO0bHRLi7HJgIW/chJK91sCNtQMzhs+vWulSaI2EIS32kfY5w7ht1h0djrVxxUVxjgE3iTlkD1VXXO/lBn4cc/lc5IjruLveWOHYiqFFgHPicjzIpIGrgYO9Z1zKPALMXgAqFdKFdk3PMj++zuTwt3aiUwpJxAUKzPKVH2ksinisTh5yYcvDSmFxk7bwEl20LMVLTjZ5FQmZSqaef2obRkjSGfT0Q5w9STHM4qVMyjKa7zLnIim+/taHfs9zqBpbHvTvdTUOLsuVFfDMjMY6l5eYg+UsaQTTY5X24PCokWOQ2kNXO6sXUUF1LcEs60KZytGa3KXTDrOoGc5Qi4YjIK4MeHFiMxa2ZiBtKN9HmU3DYM7Oj1kULJhPuQteeaNclBg7VonEBZWYgrmOlhipQVvWlY4WYGILertXWT81SKZAtdt3t+OeqfMqitr+2fwZtG6upzvlo8b391dVbS7yzDdpdFRzr31HdyNPW2HICzLnU2xYIFzvaheIYEJjZnNATwOgSdw517LHSuzZR9K5RiP4zhAPLw6L9NrZPcqzcBmosY7uA+BP/NjN6ksVC3S2OVkklzOtPXelpX5dc4c3SK3FB6CluUYTr9yBrrGDkeH3X2LWleBmRUJLNX04U4mWNWJM2c6g208HiztLpWwZUx5yROPFRiME1XO5geJmoIZJWNZrLl+PF7lTJSaulwVptb7Dvua7TPKy6Gx1Vcl5upFUdR3y7oSJZYDnIjOuFmsWGE4cUoFlzEEcFfVWpPNunle+x1ScWfrZ7ywfhaqigwE4V32tq7O2c2tuhpP1nIownr9WTbpH2EXjedhTNpSuYHd81ual2K8N7FQ597Ktkb5Lfvt54yJYU14rc/3Z8RjKhZdQVcira3OBKG62nGo3RM+f/N1P8X4Lf3x6nAbmukv2m8Bb3Np9xIXz9hl/t4T5EuU2c+9FL/FE2Rxb1PtXrocEiDx0LrWCT43mgNA7XSnYlMlClfEVo1z/n28ApoLrDssa3CWxSaqHb/NneyzEgGJSiewmajxJsf8xOJ2MtCwoasDp/i3XIfo5ZLuKh5r/EgknImdMSaaz8ddkde8DFBGYK6l8IR65UrHho6fZFRF2hVlcW/Fnbs6xbqfuXPD75O2tfa4kaocb28eAq6KRoJVrvY4l/AmPyBiVUEhv6XFVVFtJQLiZU7/qXi1Y5OaFjmTcis4pGJO3694RTBoGw+3t+5qka4uZ1I+VF9B91L0VHqQuDLsraevpGuuYAWq3XOFVaucuc74yWZ1e9IbxLIDPa1r7O+aqpwQSE5au2xGLk+vmuCMqbFyR+daV7rmCuGJAP9cwfrcvnRfaX6LD/8mOm676EmUxL3zCmsK636W1twvkXD5ob7vUKzfYvUS8wR63EUbjQtdNjQT6DvsqRQqwm+xmDbNef+SSUc/V692Yh3+/r0BWlbYepQqM/TMesetht0lL08PoZg2R+3Ay66ftwP+kSXsnHbg1ZLupvcF2HEja2bPpTy5hHg8yYlHvcz9v/4L7RPKcS/zfer2P7Lj8b8y98ADsOpCurds4Lob6+kfSLCm40xm8QDk4a6nPkjlxu8wc8kCrM4Mr2y9i2w2Q4wYb2/dACji2QzVA9XsuvqPvH5Ypee6T/51K3U1GcbNm4eVa3n5kXv43g9rWf6+caxMLKc+fSdvxBYCD5DLZen7+0N0l40iPtCP5GL89n8aaDu0lxUVB9M8cB19airP334ficG/0zZpH/veurdsYOO11zN/3RrGuY6l0v3kJUffC4/RvbOHWO87ANz203HM/Pt2VrWcQHv2YtL5GnYN9CP5PAMvb6a7X1A73zQuJIIaSNG9ZQNgRtbzcfKxHKmXttCdrSHbvR2Ajnce4I17/5fTjvsQX/zGJJA8h8y/Bp7Zyfv2nUM8tpREIs7Jx2zjl7+cRG0tzEqeyTTORHJ5Nr2wmK7cxayYPpfqyiX095Vxwie2w7b7QSU46/hZfPqxGSBQU/0S7BKyb26je8sGBl95BhCW5nbwys1f4YxjPsI9d89GgEOWPcq3v93JwgXT6VRTqGYzb5Z9kIdugJ4emNFwGvP5EwCPvnUUnVsuYmxTFx3zFnD/w6NYuvgV7kORzWXofXYjkqgkNpgiSZ72J38A8WrWLjuAm+9qZP6sHh679VHKs9tonTjBltFbmzdw0Xcb6FrRxsrqw2gZ+C39ah+e3riThVOv4NiDZvCfX19ERTmceexWNvz4NmbtP8fzTqUG+8jns/S/8BjduwZQu7oBaL7rRbZV/t5+37u3bGDz09VsuCfOkrXvZ21OUJTxnDqD1y7/CVPmjaXdde6ud7vJ53OkXt5CtzSQfetlFDB9U45nG6/EnbN65JYH+OOfylh84CLW5ZLESfBC/BByuauJx/L2exIXYYzKEr/v35k79zOMqllPX185hxy8jT/kspTHk/a5iVyeplQDb/z6Gl4/OOP5zo/f8xgtbeWMnTHLfpZvP/EnMs9fTfO0I5g1dR2b/lbD+tXdPHT9QzRU7aRh7Bj73Nde3mq8xu+8aTzDd55F8nkQyGbT9D77IInyWuID/cQlz4QtPyYbH8VBaw7k+lubmDmll8dvf4yywRdoneTIs3vHZqMFXs9OurdsoG/gbfL5HEqUocvPP0r32ztRps7d8uN2pj+3g5XNx9Pe/yPS+VHccH0FU5supX3GVI8u//CyeiZMbWBV+0mMT19ELpdkZ38OyecZ3L6V7kwVubd3GO/r72dx+ct/Z9Wk05nEl8nn4MYNM2kv/yET58/yXPfhm+9l8tx9PPJ8u/sVRISBV56lu2IDmdefBxHmba3mqRt/hruf7pMb7ufXvyln6YFTOUCaqKCfVyuOYezL14LkOPPYmdz/F0PnPrR0E9/5ThcL9ptJl5pIFVt5s/xQXvzDn2ms66Vh9Gj73rY9cDOb77iZjg9+wCP7O+9r4MUX86xaeRIdXAXAxrdO5b4LYdGiRuYnVtGQvo1d8QVsugu2b4cZo0+kgx8BSR7bdQo9l1zInJUdtLium+j9G32vP8cnDjiCb3xjmalzW2DrrSTq53HUYfP4+W9G09wwQNXrv+XJP2YZM22y197+8SbmrtifCa5jL2zZQfrt55m2ZKn9eW+8+Iix3bTLhsZVjGnvjmPzz79PbMVaWl3XuOKqeuqbalg19XQmcx75HNx03zxGP3AJk/ed7bmHq39fT7yiktWzz2Q6pyM54bqHP8YrN8O8uctYkq+ljD52lH+KcduuARXnrONmsukRQ6q1tS/Bu5B96yWPDe14oY0nr/sRY6bPtD/v+Xtv5Jn77mTBB9bbMtqx+Q4klydHjl1P/4U+FSeeTlOZrqD/NzfwWraB0a77TfY8Qs8br3LCYR/h51cYnttJhz/Chks2MHdVlz1Odm/ZwP0P17H5SWHlmmPZX74HJHgydSa3XAgLF5Yxr+wIWgeuJsU4brq6lxntP2PMlEmOvX35CSNT3beL7i0b6M30k81liEuMfC5L/wuP092TRu16C4C2DS/zYtXvmOi6h96+nUg+T/9LT9KdLif/9isALOy+lzfu+z6nHnswX71oIoo8c2qu45Gr3wzq3E33MHn+ZI/OvdP9GogwsOMZuss2kHn9BUBQoojlXDY0L7T1NfHKr67k9fe/69GNx+58mDET6mibOs3+vKfv+wtX/LKSpesmspYJVPE0LyXWk8vdTJwYb2+927huAb/ljvsaeGlbntXL/4UF/NbQudeOJ33Jhcxbvcj+rFefvA2AXDZD73MP0l1eR3ygnxjCxKd+SjpZz8EHHsh1NzUzdWIfT9z+WMBveWvHk14bOriTfD5Lx84Z/PXybzB10f4evd143Y3MXbXYq3Obd5De+SLTFi/2nKteuprcqPmcfMwH+ObFE4jHcqyb8mt4doBD9p/FSbmlJJMxTj/uee79+T1Mmtni8Z1igzsYeOkulk05nHhsXUG/5dV3jaBM5vXn6d6ygbRpQxcPPsdrt3+ds44/fEi/RQnEBNeYmCOZS5COZ8i++bJx7utbQYSYGL2x3n3qXpSKEc+kqSZHy2PfoXrfGB3zDizot+QzSa78ZjUNh6VZkVxL4+DN9MTm8+jdsG0bzBxzAh1yMZDkib7TePeSC5m9YqHHTj346CgefRSWr/kYy/L/CVSwNX0mt30H5syJM7fik4zpv4xBaeSGaxXTWi+jffoUj2784Kf1TJ7ZyMrRJzI+8x0y+QpuuKGRSfU/ZfysaZ5zf/rzetrGj2L1Pqeyz8DXyOdiXHXnB+hLwewZB7M0BzGSvJg4jXuuMKp0ZsXOYAqfR3LCTX/Zj7b7f8DkBXO8NvQP9cSTFayeexbTOBlywq2PrKDhge8xrXO+874/cy+5XJayWMLjtzTHclQ+8F9MnLeT9rb38ewLlRz5wTdg+0bIDXDGMTO44/a5CIojVm/iW9/qpKNjMh1qFjVsoju5nodugp07YUbTqezL70HggVePI+PTue4tG0j0PELvm6/y6UOP5PLLukDBvNnP8MSboEw96u/dgUierkSWHX/6LEevP5JvfWsJiQScccxm2HILyYb9+OiH5nHltW2MbU0x8MpWfvZoBzMmHM3++QuACp7PrkLkOWKpfkM/symy+QwLe2by4GUXMmPJElvn3ty2yegf1G+cKyLG8pR8HCFP/0ubh/RbfrPhQ+zqhzkz17MkFyNOgm2JU7j3F0Zwd3biDKZyNpIXrt14JK/fBPPmrGJJvpIk/bxcfiL3X20kpWZWnMUMToAcbN9ZDQgZU+fSrz4bqnPxXJYGlaXmwf9m7PxeJo5/H1ufqeLQ9W/y4B8eDPgtb//tBjJ//zV1Uw9n39kHsnHTKFYs28HdAtlclt5nN5KNlxEbTFFGnrFPXkwsXsWqxQdw2z0NLJi7C17fBP3bOfGwGfzohx0kk7Bw3nM8+RbEzLGrv+81RPJkXlzEf52zieWrP8Ey+YYho8xShKdQ/b2GjNK7yOWydOyayQM/+yZTuxZ57OL3f1LPtNmNrGw7gXHZ75PJV/HLP60gLzBryhEsyZ6Jopxn1Vm8fvmPmTp/HGNd/75n19uINVfI15F9y5j7PXH9HC7b8VxRfsumW+5nwqx2zFSWcfzNHYAw8Mpzhoxe+zuAIaO8eHSuxdS5KfPeZkzL+/h7fyUfPeR1ePkByKc545iZbLjLqHY8cvld3HfpE8xautC+h1L8lu1P3kqMGJlsmt5nNqLKqokPpshn4lz137U0HTbAyuQ6GgdvZJeaTTb/CEqg7/lH6K7cRqy/B0G49juttH+wm5XVhf2W7i0b4IUroHUlx31kPT/51VjqagdZ3PwLeC7Ox9bM5BxZTHm54qzjn+buS+9k+oJJjHH9+y3PVHPnhjhLD1hnz/2e5yDy+Z8RS6edZ6li5PJZHvrjZWTmf5zJ+/l2zygWESn4P/AR4FLXz58Evu875wZguevnO4COkGudBDwMPDxhwgQJ8NT3RY6bLgJyHR+Sddwsb9AsciXG79vaRECkqVru+8oSkVuWOsebqkWuRC7gAuMchcipiByCPDxvocj10z3n7volsuJzyEePxDgf5D9XIIecMEPkd82B63b/pF6ke5Pn+Iv/O8H5vPGIfBHJTETWfjYh7zsGSceM6/50ATLrxCrn3DbjXJmK3P9fc0RevCrweZ7vbB5b99VGWf7FBtlZblz3+unI7FNd37kOkXMR2Rf5wDmtsvj8Wnmzyjj3zonI5DOQeV8wvqf1nY/8CLL63DHSeX6V7Kg1jj3Qjsw5BZHDjZ97qJaD+ZNcwSdFDkHkU3NFQK7hSFnPTdJNg3MPSUTORuQARNYgcuxkEZA/c5AcyC3yGq32dTPE5SNcLRfxr3LGR8bL3PMSsmm08bsX65CFJzn3kEPJJ/m5/DtflrtZId8eZX7eVPNZtiEX8CX7e8kJiHwMkXZEjkyKgGxiP1nNHbIpPkvWnB2Xg45Ccso4/+IuZOWZzudtZpas5g55iA55/KJpItv/7JFH5hdx5zu3IHI+ItPNeznzUBGQr3OeHMWvJIcKlef6rzbL0vPr5O0K4zNvmmLI03NuW5vI4xfIyQdcIrcvNz9vDSL/aj7rkHOP+HK7LDy/Ul4aZVz3obHI3FMI1aNvH/NZuXqmed0ORL6A7GhDOj6PnH6Q856c8X7ky19C5JP7iIDczDo5gNvkb1Vtsvgc5FOHOueeewDy6RM6RP48J/y97n8lePyj1SIgG+mS1dwhW5kh715aK/LOE55zL76wUWafi9ww1fisdyqQxZ9G1nw2LuuPRjKmzv14IbL4dEeeTzFdVnOHPMAi2fiN2SLbrvFcd8NPkdnnIpfvZ5w/GEfWfRJZ9ZV6WfHFBtlVZhy/zq9z9Yich8h85L5Tlor87evRNqnGeL7ShXz4s2Ok8/xqeaXGuO5fxhs6Z59bicjnEFmO3PXhVSL3f7KwjTDledyXJ8i+55XJU03Gdbc2I/ueHH7uNWceKT8Za37eHPN7NHp17mh+Kf/BF+V21sp3G8xzrfe8Fcn+MibS83fPvT110TSRa+qCzyHxOUc/j0Xkk8h2xjrfud287kTkgspTnXM/ZuhzKlkWqkdyJSJnHiYC8jW+JEfzC0PnzO/xEuNkLbfL7ayVB85eJPLU/xZ+lqYe3fPl5SKPf8lz7ubLkflfQP7DZUM/eiRy8emrRDaeHC37ckT+DZEVyF0HrxS596PR5yYQ+SwiByKXc7xcMdE8Pt+UUb0joywx+RhXyX/zOfnsEeNl7nlxeXiM8bttdUjHSeZ3S73u+bzHvzFX5Np2z7G+XyIr/w358Mec73bRUmT9CRNFrioP3O9Ol86fzf/IKVws3TX1oTK6oPokR55HInKS8feADZ2JPHzuApFnf+q5xl8vReZ8AflBp/m9FfKBo5DVX2qWJV8cJd2VxvFbJ0fb0EO+MloWnV8tr5o6d994ZM6pzrN8l1o5iBvkV3xC7jp8lchfjy9K54798njZ97xyedrUuc0tyKxTkc7PI6d8wHlGZ61HzvpMuN8iVyKS6fccv+UL6+R7jebzmWE8n11jS/NbLoh/3qtzRyMvN48NyCjzK2TtWUG/pdNlQ59hqqzmDrmfxaF+yz2XGjb00gXG+ekY8r5jkJu/2CXy9PeL07mvLBN54t+D55r30E2DrOcmuYYjRY5G5MRFIiA/4zg5mD9JD9Wh15UrKdpv+dRxE2T+eWWypdkcO5qQff+Fov2W+f+CLD0HOeYwR0ZfXo10ntEuc86NyV/GG8deqTF8nBWfQw7/qHPufy9DDv1XivZbph/XFrShk5ALqk52ZP8RRD6DZGKxUP1cPetOefRQ8xqHYPjOyqWfDabtmYPcf+ZikS3/E22/ajH80IXI3Z9aIfLoedHnViFyDiKLkfP5uly/0Dy+FGP8q3SdW4bh96xC7nr/SpG7D4u+bty0oe9D7l2+VOS2VZ5z3/wFoX7L6eci8okWEZANrJQ13CEvsI8t+zzI8VwuX+JrspEuuaja/LzJ5nMfg1wQO9d57scjchSyrWWcyK8Tgft92/X5/8aF8i9cIr+ZWymzz0WumWUc700iq45Dth/inPsVLpDj+Jnkcd7LF5kga7hD7mKVrOcmeehg894+iMjpyMZ2w4Z+b5Fxfk4hBx+F/O6coN/yxOXGXOGbjPJZLwAAColJREFUy5zPPOKj1lyhOL/la3xJrp1vHl+MyOcNeQd0bg1yCSfLr6aaxxeY788onzzPROQg5LSPTZB55yXkUVPnnq9H5v0LsuQc5NgPO/f7pTXIiV9A5OMNhr1nqazmDnmOyaF+i1yJyJHlIiAPs9DUuZmy+uyYHPwJQ/YC8t1FyJqznOf+JLNlNXfIIyyQN1wyOpf/ks/wE7l+elxmn4tcOdc43p9A1hyLNLbcLY8fZn6/DyNyCnLfBGTOuYb/Khj+7PpjkBvPD/db7OczynxmC5AT+KncscI8foD5jCPmCod/uV06zq+Sl825wsZ2nzyL8FvCxsTPfGWCzD8vKU+2mGNHo3Hd/T+PfOZDzjM650DkrPMQOapVBOQuVska7pAXmeDRuWO5Qr7CBfL49Pfmt6R/ZcwVDjra8CEE5JJOZManGp3vPMbQ5dxkZN2ZZbL2WGQgbpz7i/k+/38Iv8U9du1gjBzAbXIz60ROQ+TUA4z3idPlcH4ngyRDZXTauu/LLUvMz1tl2MCnRyP7fgG5YJXznY86HFn2aWTn0U3iB3hYpHCsx/pfGedHo5RaAnxVRNabP59nBpO+4Trnx8AGEbnK/PlpYLWIRFYKdXZ2ysMPP1xyEEuj0Wg0Go1Go9FoNBqNRhOOUuoREekc+sziego9BExTSk1SSpUBHweu951zPXCsuQvZYuDdQgEhjUaj0Wg0Go1Go9FoNBrNnmXInkIiklVKnQ7cgtHx83IR2ayUOtn8/Y+AG4EPAM8B/cCn/u9uWaPRaDQajUaj0Wg0Go1G814pptE0InIjRuDHfexHrr8LcNo/9tY0Go1Go9FoNBqNRqPRaDT/VxSzfEyj0Wg0Go1Go9FoNBqNRvP/GToopNFoNBqNRqPRaDQajUazF6KDQhqNRqPRaDQajUaj0Wg0eyE6KKTRaDQajUaj0Wg0Go1Gsxeig0IajUaj0Wg0Go1Go9FoNHshOiik0Wg0Go1Go9FoNBqNRrMXooNCGo1Go9FoNBqNRqPRaDR7IToopNFoNBqNRqPRaDQajUazF6KDQhqNRqPRaDQajUaj0Wg0eyE6KKTRaDQajUaj0Wg0Go1Gsxeig0IajUaj0Wg0Go1Go9FoNHshSkT2zAcr9SawLeRXzcBb/+Tb0bx3tNxGLlp2IxMtt5GLlt3IRMtt5KJlNzLRchu5aNmNTLTcRi5hsttHRFqK+cd7LCgUhVLqYRHp3NP3oSkNLbeRi5bdyETLbeSiZTcy0XIbuWjZjUy03EYuWnYjEy23kct7lZ1ePqbRaDQajUaj0Wg0Go1Gsxeig0IajUaj0Wg0Go1Go9FoNHshwzEo9JM9fQOa3ULLbeSiZTcy0XIbuWjZjUy03EYuWnYjEy23kYuW3chEy23k8p5kN+x6Cmk0Go1Go9FoNBqNRqPRaP7vGY6VQhqNRqPRaDQajUaj0Wg0mv9jhk1QSCn1fqXU00qp55RS5+7p+9FEo5Qar5S6Sym1VSm1WSl1lnm8USl1m1LqWfPPhj19r5ogSqm4UupRpdSfzZ+13EYASql6pdTvlFJPmbq3RMtu+KOUOtu0k08qpa5SSlVouQ1PlFKXK6XeUEo96ToWKSul1Hmmz/K0Umr9nrlrTYTcLjJt5RNKqT8opepdv9NyGyaEyc71u88ppUQp1ew6pmU3DIiSm1LqDFM2m5VSF7qOa7kNEyLs5X5KqQeUUo8ppR5WSi1y/U7LbhiwO3PvUmU3LIJCSqk48APgIGA28Aml1Ow9e1eaAmSBfxORWcBi4DRTXucCd4jINOAO82fN8OMsYKvrZy23kcF3gZtFZCawL4YMteyGMUqpduBMoFNE5gJx4ONouQ1XrgDe7zsWKitzzPs4MMf8N5eYvozmn88VBOV2GzBXROYDzwDngZbbMOQKgrJDKTUeWAe85DqmZTd8uAKf3JRSa4BDgfkiMgf4H/O4ltvw4gqCOnch8O8ish/wFfNnLbvhRUlz792R3bAICgGLgOdE5HkRSQNXYxgWzTBERF4VkU3m33swJqftGDL7uXnaz4EP75k71EShlBoHHAxc6jqs5TbMUUqNAlYClwGISFpEdqJlNxJIAJVKqQRQBbyCltuwRETuAd72HY6S1aHA1SIyKCIvAM9h+DKafzJhchORW0Uka/74ADDO/LuW2zAiQucAvgN8HnA3PtWyGyZEyO0U4JsiMmie84Z5XMttGBEhOwFGmX+vw/BTQMtu2LAbc++SZTdcgkLtwMuun7ebxzTDHKXURGABsBFoE5FXwXh5gdY9d2eaCP4Xw9HKu45puQ1/JgNvAj8zl/5dqpSqRstuWCMiOzCypS8BrwLvisitaLmNJKJkpf2WkcOngZvMv2u5DXOUUocAO0Tkcd+vtOyGN9OBFUqpjUqpu5VSXeZxLbfhz2eBi5RSL2P4LOeZx7XshiFFzr1Llt1wCQqpkGN6W7RhjlKqBvg98FkR2bWn70dTGKXUB4E3ROSRPX0vmpJJAAuBH4rIAqAPveRo2GOu7T4UmASMBaqVUsfs2bvS/IPQfssIQCn1RYyy+yutQyGnabkNE5RSVcAXMZawBH4dckzLbviQABowlracA1yjlFJouY0ETgHOFpHxwNmYVelo2Q07Sph7lyy74RIU2g6Md/08Dqd0TTMMUUolMV7KK0XkWvPw60qpMebvxwBvRP17zR5hGXCIUupFjCWaa5VSv0LLbSSwHdguIhvNn3+HESTSshveHAi8ICJvikgGuBZYipbbSCJKVtpvGeYopY4DPggcLSKWM6zlNryZghFEf9z0VcYBm5RSo9GyG+5sB64VgwcxKtKb0XIbCRyH4Z8A/BZnmZGW3TCixLl3ybIbLkGhh4BpSqlJSqkyjMZI1+/he9JEYEb+LwO2isi3Xb+6HsOwYP75x3/2vWmiEZHzRGSciEzE0LE7ReQYtNyGPSLyGvCyUmqGeegAYAtadsOdl4DFSqkq024egLEOXMtt5BAlq+uBjyulypVSk4BpwIN74P40ISil3g98AThERPpdv9JyG8aIyN9EpFVEJpq+ynZgoTkGatkNb64D1gIopaYDZcBbaLmNBF4BVpl/Xws8a/5dy26YsBtz75Jll/jH3vLuISJZpdTpwC0Yu7NcLiKb9/BtaaJZBnwS+JtS6jHz2PnANzHKRU/AmAx9ZA/dn6Y0tNxGBmcAV5qB8+eBT2EE9rXshikislEp9TtgE8YSlkeBnwA1aLkNO5RSVwGrgWal1HbgAiLso4hsVkpdgxGczQKniUhuj9z4Xk6E3M4DyoHbDF+aB0TkZC234UWY7ETksrBzteyGDxE6dzlwuTK2Ok8Dx5kVelpuw4gI2Z0IfNfcEGMAOAm0zg0zSpp7747slFNRq9FoNBqNRqPRaDQajUaj2VsYLsvHNBqNRqPRaDQajUaj0Wg0/0R0UEij0Wg0Go1Go9FoNBqNZi9EB4U0Go1Go9FoNBqNRqPRaPZCdFBIo9FoNBqNRqPRaDQajWYvRAeFNBqNRqPRaDQajUaj0Wj2QnRQSKPRaDQajUaj0Wg0Go1mL0QHhTQajUaj0Wg0Go1Go9Fo9kJ0UEij0Wg0Go1Go9FoNBqNZi/k/wFXCn30/eY1IQAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "import modisco.visualization\n", - "from modisco.visualization import viz_sequence\n", - "\n", - "viz_sequence.plot_weights(task_to_scores['task0'][0], subticks_frequency=20)\n", - "viz_sequence.plot_weights(task_to_hyp_scores['task0'][0], subticks_frequency=20)\n", - "viz_sequence.plot_weights(onehot_data[0], subticks_frequency=20)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "uuvSgm62-Whl" - }, - "source": [ - "Run TF-MoDISco\n", - "TF-MoDISco first identifies seqlets, then splits the seqlets into \"metaclusters\" according to their pattern of activity across all the tasks, and then performs clustering within each task. Since there are 3 tasks, there are 27 possible metaclusters (consisting of a +1, -1 or 0 for each task). Consistent with the simulation, the [+1, +1, 0], [+1, 0, +1], [0, 0, +1] and [0, +1, 0] metaclusters turn up motifs.\n", - "\n", - "To demonstrate customization, the code below has slight modifications from default settings in the following ways:\n", - "\n", - "- Because the TAL and GATA motifs are relatively short compared to something like CTCF, it uses a sliding window size of 15 (rather than the default of 21) and flanks of 5 (rather than the default of 10). The sliding window size and flanks should be adjusted according to the expected length of the core motif and its flanks. If the window size or flank sizes are too long, you risk picking up more noise.\n", - "- During the seqlet clustering, motifs are trimmed to the central trim_to_window_size bp with the highest importance. trim_to_window_size is set to 10 rather than the default of 30. After the trimming is done, the seqlet is expanded on either side by initial_flank_to_add. This is set to 3 rather than the default of 10.\n", - "- The final_min_cluster_size is set to 60 rather than the default of 30. This is used to filter out small clusters with relatively weak support (in this case, fewer than 60 seqlets).\n", - "- It uses kmers of length 5 with 1 gap and no mismatches to compute the \"quick and dirty\" affinity matrix across all seqlets. The \"quick and dirty\" affinity matrix is used both for noise filtering and as a first pass to speed up computation of the continuous jaccard affinity matrix (the latter affinities are only computed between seqlets deemed to be close together by the \"quick and dirty\" method). I made the kmer length smaller to keep memory usage down when testing on my macbook pro. The default is to use kmers of length 8 with 3 gaps and 2 mismatches, which tends to run out of memory on many systems (I would change the default but want to avoid breaking reproducibility for older users)\n", - "- target_seqlet_fdr controls the noisiness of the seqlets. For a particular task, \"significant\" seqlets are identified by first smoothing importance scores with a window of size sliding_window_size and then fitting a laplace distribution to the left and right tails. This laplace distribution is assumed to represent the null distribution of window importance scores (note: as an alternative, it's possible to supply an empirical null distribution; see examples/H1ESC_Nanog_gkmsvm/TF MoDISco Nanog.ipynb for an example). A threshold is then identified such that the false discovery rate (computed as the ratio of the expected fraction of windows with a certain score in the null distribution relative to the observed fraction of windows with that score) is less that target_seqlet_fdr. Note: if the number of sliding windows that pass the FDR threshold is smaller than min_passing_windows_frac (default value 0.03 at the time of writing) or larger than max_passing_windows_frac (default value of 0.2 at the time of writing), the threshold will be adjusted." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - }, - "colab_type": "code", - "id": "--8gp-i2-TOm", - "outputId": "b39814f5-cb17-4eb6-b4fc-11638426529a", - "scrolled": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "MEMORY 0.435310592\n", - "On task task0\n", - "Computing windowed sums on original\n", - "Generating null dist\n", - "peak(mu)= -0.02237087196292123\n", - "Computing threshold\n", - "Thresholds from null dist were -1.0124836564064026 and 0.8997364044189453\n", - "Final raw thresholds are -1.0124836564064026 and 0.8997364044189453\n", - "Final transformed thresholds are -0.8494086021505376 and 0.8402150537634409\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Got 198 coords\n", - "After resolving overlaps, got 198 seqlets\n", - "Across all tasks, the weakest transformed threshold used was: 0.8401150537634409\n", - "MEMORY 0.43532288\n", - "198 identified in total\n", - "1 activity patterns with support >= 100 out of 2 possible patterns\n", - "Metacluster sizes: [195]\n", - "Idx to activities: {0: '1'}\n", - "MEMORY 0.43532288\n", - "On metacluster 0\n", - "Metacluster size 195\n", - "Relevant tasks: ('task0',)\n", - "Relevant signs: (1,)\n", - "TfModiscoSeqletsToPatternsFactory: seed=1234\n", - "(Round 1) num seqlets: 195\n", - "(Round 1) Computing coarse affmat\n", - "MEMORY 0.43532288\n", - "Beginning embedding computation\n", - "Computing embeddings\n", - "Finished embedding computation in 0.09 s\n", - "Starting affinity matrix computations\n", - "Normalization computed in 0.0 s\n", - "Cosine similarity mat computed in 0.01 s\n", - "Normalization computed in 0.0 s\n", - "Cosine similarity mat computed in 0.0 s\n", - "Finished affinity matrix computations in 0.01 s\n", - "(Round 1) Compute nearest neighbors from coarse affmat\n", - "MEMORY 0.455811072\n", - "Computed nearest neighbors in 0.01 s\n", - "MEMORY 0.455811072\n", - "(Round 1) Computing affinity matrix on nearest neighbors\n", - "MEMORY 0.455811072\n", - "Launching nearest neighbors affmat calculation job\n", - "MEMORY 0.455831552\n", - "Parallel runs completed\n", - "MEMORY 0.45723648\n", - "Job completed in: 0.55 s\n", - "MEMORY 0.45723648\n", - "Launching nearest neighbors affmat calculation job\n", - "MEMORY 0.45723648\n", - "Parallel runs completed\n", - "MEMORY 0.45723648\n", - "Job completed in: 0.55 s\n", - "MEMORY 0.45723648\n", - "(Round 1) Computed affinity matrix on nearest neighbors in 1.16 s\n", - "MEMORY 0.45723648\n", - "Filtered down to 191 of 195\n", - "(Round 1) Retained 191 rows out of 195 after filtering\n", - "MEMORY 0.457252864\n", - "(Round 1) Computing density adapted affmat\n", - "MEMORY 0.457252864\n", - "[t-SNE] Computing 31 nearest neighbors...\n", - "[t-SNE] Indexed 191 samples in 0.000s...\n", - "[t-SNE] Computed neighbors for 191 samples in 0.002s...\n", - "[t-SNE] Computed conditional probabilities for sample 191 / 191\n", - "[t-SNE] Mean sigma: 0.233285\n", - "(Round 1) Computing clustering\n", - "MEMORY 0.457252864\n", - "Beginning preprocessing + Leiden\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\r", - " 0%| | 0/50 [00:00" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "metacluster_0\n", - "activity pattern: [1]\n", - "metacluster_0 pattern_0\n", - "total seqlets: 82\n", - "Task 0 hypothetical scores:\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Task 0 actual importance scores:\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "onehot, fwd and rev:\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "metacluster_0 pattern_1\n", - "total seqlets: 75\n", - "Task 0 hypothetical scores:\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Task 0 actual importance scores:\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "onehot, fwd and rev:\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "from collections import Counter\n", - "from modisco.visualization import viz_sequence\n", - "reload(viz_sequence)\n", - "from matplotlib import pyplot as plt\n", - "\n", - "import modisco.affinitymat.core\n", - "reload(modisco.affinitymat.core)\n", - "import modisco.cluster.phenograph.core\n", - "reload(modisco.cluster.phenograph.core)\n", - "import modisco.cluster.phenograph.cluster\n", - "reload(modisco.cluster.phenograph.cluster)\n", - "import modisco.cluster.core\n", - "reload(modisco.cluster.core)\n", - "import modisco.aggregator\n", - "reload(modisco.aggregator)\n", - "\n", - "hdf5_results = h5py.File(\"results.hdf5\",\"r\")\n", - "\n", - "print(\"Metaclusters heatmap\")\n", - "import seaborn as sns\n", - "activity_patterns = np.array(hdf5_results['metaclustering_results']['attribute_vectors'])[\n", - " np.array(\n", - " [x[0] for x in sorted(\n", - " enumerate(hdf5_results['metaclustering_results']['metacluster_indices']),\n", - " key=lambda x: x[1])])]\n", - "sns.heatmap(activity_patterns, center=0)\n", - "plt.show()\n", - "\n", - "metacluster_names = [\n", - " x.decode(\"utf-8\") for x in \n", - " list(hdf5_results[\"metaclustering_results\"]\n", - " [\"all_metacluster_names\"][:])]\n", - "\n", - "all_patterns = []\n", - "background = np.array([0.27, 0.23, 0.23, 0.27])\n", - "\n", - "for metacluster_name in metacluster_names:\n", - " print(metacluster_name)\n", - " metacluster_grp = (hdf5_results[\"metacluster_idx_to_submetacluster_results\"]\n", - " [metacluster_name])\n", - " print(\"activity pattern:\",metacluster_grp[\"activity_pattern\"][:])\n", - " all_pattern_names = [x.decode(\"utf-8\") for x in \n", - " list(metacluster_grp[\"seqlets_to_patterns_result\"]\n", - " [\"patterns\"][\"all_pattern_names\"][:])]\n", - " if (len(all_pattern_names)==0):\n", - " print(\"No motifs found for this activity pattern\")\n", - " for pattern_name in all_pattern_names:\n", - " print(metacluster_name, pattern_name)\n", - " all_patterns.append((metacluster_name, pattern_name))\n", - " pattern = metacluster_grp[\"seqlets_to_patterns_result\"][\"patterns\"][pattern_name]\n", - " print(\"total seqlets:\",len(pattern[\"seqlets_and_alnmts\"][\"seqlets\"]))\n", - " print(\"Task 0 hypothetical scores:\")\n", - " viz_sequence.plot_weights(pattern[\"task0_hypothetical_contribs\"][\"fwd\"])\n", - " print(\"Task 0 actual importance scores:\")\n", - " viz_sequence.plot_weights(pattern[\"task0_contrib_scores\"][\"fwd\"])\n", - " #print(\"Task 1 hypothetical scores:\")\n", - " #viz_sequence.plot_weights(pattern[\"task1_hypothetical_contribs\"][\"fwd\"])\n", - " #print(\"Task 1 actual importance scores:\")\n", - " #viz_sequence.plot_weights(pattern[\"task1_contrib_scores\"][\"fwd\"])\n", - " #print(\"Task 2 hypothetical scores:\")\n", - " #viz_sequence.plot_weights(pattern[\"task2_hypothetical_contribs\"][\"fwd\"])\n", - " #print(\"Task 2 actual importance scores:\")\n", - " #viz_sequence.plot_weights(pattern[\"task2_contrib_scores\"][\"fwd\"])\n", - " print(\"onehot, fwd and rev:\")\n", - " viz_sequence.plot_weights(viz_sequence.ic_scale(np.array(pattern[\"sequence\"][\"fwd\"]),\n", - " background=background)) \n", - " viz_sequence.plot_weights(viz_sequence.ic_scale(np.array(pattern[\"sequence\"][\"rev\"]),\n", - " background=background)) \n", - " \n", - "hdf5_results.close()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "colab_type": "text", - "id": "UFQSYr9q_qI9" - }, - "source": [ - "## Load the saved hdf5 file\n", - "Load the results object from the saved file" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "colab": {}, - "colab_type": "code", - "id": "WVtrMZ9o_mu0" - }, - "outputs": [], - "source": [ - "import h5py\n", - "import numpy as np\n", - "import modisco\n", - "from modisco.tfmodisco_workflow import workflow\n", - "\n", - "track_set = modisco.tfmodisco_workflow.workflow.prep_track_set(\n", - " task_names=tasks,\n", - " contrib_scores=task_to_scores,\n", - " hypothetical_contribs=task_to_hyp_scores,\n", - " one_hot=onehot_data)\n", - "\n", - "grp = h5py.File(\"results.hdf5\",\"r\")\n", - "loaded_tfmodisco_results =\\\n", - " workflow.TfModiscoResults.from_hdf5(grp, track_set=track_set)\n", - "grp.close()" - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Getting the exemplar motifs\n", - "Numseqles: 82\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABIEAAACMCAYAAADr57kMAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOydd3gU1frHP7MlbZPQQu+9V6migPSigFTRi4rl6lVUVOxyrfeC7f6QoqgUBaQjIh0EqdJ774Tek5BkN1vn98dJgGVrdjf9fJ5nHsjO7szZPbsz53zP+35fRVVVJBKJRCKRSCQSiUQikUgk+RtNTjdAIpFIJBKJRCKRSCQSiUSS9UgRSCKRSCQSiUQikUgkEomkACBFIIlEIpFIJBKJRCKRSCSSAoAUgSQSiUQikUgkEolEIpFICgBSBJJIJBKJRCKRSCQSiUQiKQBIEUgikUgkEolEIpFIJBKJpACgy6kTx8XFqZUqVcqp00skEolEIpFIJBKJRCKR5Dt27tx5XVXV4u725ZgIVKlSJXbs2JFTp5dIJBKJRCKRSCQSiUQiyXcoihLvaZ9MB5NIJBKJRCKRSCQSiUQiKQBIEUgikUgkEolEIpFIJBKJpAAgRSCJRCKRSCQSiUQikUgkkgKAFIEkEolEIpFIJBKJRCKRSAoAUgSSSCQSiUQikUgkEolEIikASBFIIpFIJBKJRCKRSCQSiaQAIEUgiUQikUgkEolEIpFIJJICgBSBJBKJRCKRSCQSiUQikUgKAFIEkkgkEolEIpFIJBKJRCIpAEgRSCKRSCQSiUQikUgkEomkAOBTBFIUZbKiKFcVRTngYb+iKMoYRVFOKIqyT1GUJqFvpkQikUgkEolEIpFIJBKJJBj8iQT6GejqZX83oHr69k/g++CbJZFIJBKJRCKRSCQSiUQiCSU+RSBVVdcDN708pRcwVRVsAQorilI6VA2USCQSiUQikUgkEolEIpEEjy4ExygLnLvr7/Ppj10KwbEl2cy5pHN0n9GdWX1nUbdE3ZxujjOqCsnHIXEfGM9DajyknIDUc2C+Dg4rqHZABUUHGh2EFYWo8hBdBaIrQ2RZKFwXYuuARpvT7yhnMd+ApIOQchqST4j/Jx8Hy01w2EC1AYr4HLWRYKgAhepCTE3xecZUhdhaoGS9tdjQJUNpUb4FgxsMzvJzBcrMfTNZcHQBc/rPyemm+OTcOVi0CLZuhUOH4Px5sFhAo4FChaBGDWjUCDp2hDZtQBeKO0UmeGvlWzQr04wB9QZk74kzi+qAG9vh4nJI2A23jojfj2oX16DI0hBbG4o1g7I9ILZmtjbPYrfQ49cezO4/m6KRRbP13PkSVYVbR+HiMjj/G5gugc0IDgtow0FngJjqUL4vlO4KUWWyt332NEg6BIn74eYuuLFVtNFhFvdHRQsaPeiioXB9iGsJheqL/0eWBkXJ3vbmQqxW2LcPTp6E+Hg4dkxs586B0Qg2GzgcoNWK62JsLFSsCLVqQbVqUKEC1Kwp/s7qj/N0wmkenvEwM/rOoGGphll7snzO2C1j+f3o76wYvAKdJptveH4i+7tgcTX1Kl2nd2Vu/7lULVo1p5sjyYcoqqr6fpKiVAIWq6paz82+JcBIVVU3pv+9GnhbVdWdbp77T0TKGBUqVLgvPj4+qMZnC6VKwZUrOd0K75QsCZcvB30Yk9VE4x8ac/TGUcrFluPgSweJDY8NQQMDxG6Ba+vh6ka4vAoS9gCKGMg6zGLLDIoetBGAKgbEhetByQ5Q/AEo1V4M4PNzf9vNcG0TXFwK5xeC8awQdxw2sBsB39cCADThYsKjOsTfJdpB+UehVCcwlM98u3yQbE6m8KjCVCxckVOvnQr58UOBQ3VQ5psyXEm9wqZnNnF/+ftzukkunD4N06bB9Olw9qyYxBiNnp+v0YDBICY83brBP/4BjzwiHs9KVFUl/PNwGpZqyPbnt2ftyQJBVeHqWjg9Dc4tEGKpPS1dNPWAJlyIpWHFoOJjUOVJMfHOYpYcW8LDMx9mUs9JPNP4mdAdOC9cJyE090ZVFaLP2blwcQnYUgGH6HNP6AziuhpZGso9CpUGCSEwK0i7DvEz4fh3QszXRon22VJ8v1YTJu4BdrMQh8r3gWr/hLhWzgpGPu5vqxV27IA1a2DxYti9G8LCxL60NLHfX8LDxWa3i+tkq1bimtm2LdStG9pr503TTRpNaMS5W+eIi4pj34v7KB0ToiD8fNzf7th5cSfNJzbHoTp48b4X+f7h3OdqIfsb8QNyOHK6Fd4J0XdSVVW6Tu/KylMraVamGVue24ImVAuusr9DR4j6OytRFGWnqqpN3e4LgQj0A7BWVdWZ6X8fBdqpquo1Eqhp06bqjh07fLc+p8krK2N+9KP3l6v0m9OPZSeWYbKZCNeG80CFB1g5eGXoLjx+NcQBVzfAyUlwbr5YTbcbvU+wgkID+mghOJXpAm0XZtF5Qkxm+vv6Fjg4Ei4tFyKYNRWwh7Y9umgx6YkoCbWHQ82hITv0pF2TeG7RcwCcee0MFQtXDNmxQ8WM/TN44rcnAGhapinbntuGkkuuHUYjfPwxjB0r7qcWS2DHiY4WK94//wxN3d5OQsO+K/toOKEhkbpIUt9PzTWfIwC3jsPWZ0WURWaE07tRdGLCXWEANPkGwouFvJkZ9J/Tn3mH59GmYhvWPb0udAfOTX3ii2DujTd3w9ZnhLhiSyWg/kYrRPPSnaHpOIgqG3h7MrCb4cIiIfxc+1ssjNi9KLr+omiEiKQzQNXnoeozIoI2H/b3wYPimjhtmojoSUsL/NrojchIIbhHRMDQofDRR8EfM82WRuvJrTlw9QAWuwWdoqNq0ars+OcOosOigz9BPuxvT1xJuUK97+tx3XgdjaIhQhfBuO7jGNJoSIgaGDyyv/MYQX4nAX7Z+wsvL3mZVGsqkbpI/tvhvwxrOSwEjUP2d6gJQX9nJd5EoFDM7v8AnkyvEtYSSPIlAElyH19u+pLlJ5djspkAMNvNbD6/mff+fC97GmBJhH3/hvnFYd0jcOZXMai13cpCAQjAAdZb4EgT0TH5BbsFzsyAxXVgdQcxYXBYxHsNtQAEYtXZkQbGeNjzbkgPPXbb2Nv/n7JnSkiPHQpsDhtvrXoLAK2i5fC1w6w+vTqHWyXuSwsWQKVKMG5c8JOclBQxcWrTBp5+Gm7cCFVLnVl2fBkAJpuJfVf2Zc1JMovNCLvfhmUN4frfYA9UECA9csgE8bNgYWU4/sOdqLoQYraZWXJ8CQCbz20mKS0p5OfIt6Rdh81Pw6rWkLA3Paom0IGeXdzLLiyBRTVg/6feo4h8cWExLKwEW56BK3+JiNhQCEAgvoe2FEi7Aoe/hCV1YdsLoTl2LsBqFaJPw4bQrBlMmiRE8lu3skYAAjCZxLXz+nUYNSr44zlUB4/Ne4zD1w5jsYtG21Qb8YnxPDLjEWyOrBwv5S8sdgvdfu1GYloiAAoKRquRl5e8zLYL23K4dQLZ3wWPc0nnGLp0KKnWVECMhd5f/T7HbhzL4ZZJ8hv+lIifCWwGaiqKcl5RlGcVRXlRUZQX05+yFDgFnAB+Al7KstZKsoQVJ1bwybpPMFqdB5JGq5Fx28cx/9D8rDu5zQT7P4EF5eDw18JPw5YM+JgUafRQpDGU6w01XoZGX0CradB6FrSeDa2mQ+NvoOarwp+hWPP0VLB8jqrCud/h93Ji8H7rcOARC4FiTw3ZoU7cPMHRG0fRKsK/acKOCfgTvZidTNkzxWmCnWpN5bXlr+VoO+PjRQrC4MFw7ZqYiIQKkwlmzYLKlcUkKtT8dvi32/9fcXJF6E+QWS4sEZPuY+OEeKOGSER1mMW1bvebsKS+EBtCyMqTK297W4Rpw/jj6B8hPX6+5fgE+KOSSLGymwjZtVO1imvxoS/E9+lyJoXiW8fgz3aw8TFIu5x+n8xCHBbx/k9NzdrzZAOqCn/8Ia5ZL70kPH9MJuHvkxm0WoiKgpgYEeGT2fSutCC0vwyGrxzOqlOrbi/Y3T62PY1tF7fx3B/P5bp7ZG7lhUUvcOT6ERchxWQz0e3XblxOyfk0D9nfBQtVVXls/mOk2ZwvFma7mX5z+knRTxJSfLqfqao6yMd+FXg5ZC2SZCsnb56k/9z+LjeYDIxWI0/+/iQ1itWgfskQe1hcXg2bHhOr7L5WMhUNlGgrRJ+S7SGmRvoAHSEIaSPcGxTbTSIqBkAXCSln4Oo6uPAHXFohvIHyC6bL8Pc/RPpXZoQYRSM+zwzz7JgaEF5c+EWo6avYyScg5RSknoakI2BNzLr3cRcTd03EcVeURKo1lQ1nN9CmYptsOb8vzDYz769+//aKTQZnE8+y6Ngietbsme1tOnIEWreGpCThTZEVmM1ie/VVOH48NCvcIK43e67sQaNocKgO5h6ay9ut3w7NwQPh+I+wa9ida01WYEuFW4dE1Em75VDigZAcdsqeKSRbhFCQak1l0u5JDG6Ye43VcxxVhT3vwLHxoYuscYc9/X637hFoOQUqDvT+fIcN9r4n2uUwZ0nUmPfzh0C5yEHOn4chQ2DzZkj187YYEQEtW0L79iL1tXJlKF1apMTa7eKrotGIrIqkJLhwAU6dgo0bYe1a2LMna66947eN54edP7gs2GVgtBqZd2ge1YpW48M2HwZ+opIl84ZnSMmSAb/0+x3fM+fQHI9j32RzMl2nd2Xrc1sJ14UHfJ5gkP19D3nFIyYIxm8fz97Le13EHofq4FTCKUZuGMmItiOCOockhATZ3zmNX55AWUGe8QTKCwZaARpTJZuTaTChAWeTzt6eaOs1ekpHl+ZK6hXM9jvGy6WiS3HgXwcoFhUC/wpVhUOj4MBnvidXMdWhxitQ+R/C90BrCL6ql+oAa7I43rn5cGws3Ez3MX8jD9wM3fX3xWXpgppJrDj7IrIMlOkhDJ1LtBGfiWoXwo8uyvX5DpsQ63AII9HUeDj/uzCZvroel9Xyx4O/rjhUByW+KsEN0w20iha7akdBYWDdgczsNzPo44eC0VtG8+GaD2+LQBntBKhSpArHXzmerZ5a+/eLdK2kpOxLU46K8n9y5Ytlx5fx2PzHSLWkYlfthGnDuPn2TQxhhtCcIDMc+Rb2vp+1gsC9aA0w0A9DXx+k2dIo+kVRpwlOuDacy8MvUziicNDHz1OeAv78EFQHbHvxThpydqGNhIFezmdJgLWPiMpz2dmue3ki506dae7q73XrhDGzPwbPkZEwYAC88grUqydeExUFer3/p85IudXrYcMG+PZbWL7ced4a6HV58dHFDJg3wOk3bdAbeLrR00zZM8VJKIjURTKx50Qer/94YCcLBf5cI3Jo/rHp7CY6Tevk9FlG6iLRa/XcMt9yeqxfnX780vuXbPemk/2dBeTyNp68eZIGExp4FP1A9PWW57bQoGSDwE+UF+a1ELzpci7v7+wiqz2B8jeXL4svSaCbPwRzfFUN6EfiUB30n9ufS8mXnCItwrRhLP/HcpeVj5ummzwyMwT5x/Y0WN8TDvzHuwAUVQ4emAPd9kL1FyGsCOhjQ1PWXdFAWCFhCF3pH9BxHXRYI0o558X+PjsPNvQVfj++BKC4VtB2EfQ8AU3+B2W6CRNQfQyEFXYvAIEoEx8WK56jDYfYGlDrdWj7Bzx6Xgh1uhAYFN7FX6f/up0Dn4GKysKjC0mxBD9RDpZUSyofr/3YJQoog6spV5lzMPvKxe/cCQ88AImJ2Xtf81ZhLLMsOraIZPOdNJcIXQTr4kNoaOwvB0dmvwAEIUulXHFiBXqt8+xVr9Wz8Eg+8j0LFQ6bSLHKbgEIvN8DjedhaSO4uT3z7YqpJip91f8EHloO3XZDj0PQfT903gLNf4JqL0Dc/eL6nw+ZNw+6d4fkZO8CUOnSMGGCSJsdOxbuu09U+CpUKHMCEIgIothYISh17gwzZ4q51ogRotJioOy8uJOB8wc6CQJaRUvj0o0Z220s7Su1J0wbdnufyWbiuT+eY338+sBPmk85f+s8D8942Omz1CgampVpxs+9fsagv9NRJpuJ+YfnM377+Gxto+zvgofdYaff3H5OaWAaRUPp6NLoNXcuRGm2NPrO7usyNs4Uwc5zcvHcVpI5pAhUQPl47cdsPLvRKdrHoDfwcbuPqV28NqO7jHa6GVrsFvZe2cuw5UG60295VqSBeZvsVBwEDx+Bcr1ECpcmkyOxzKDRikFw8TbQNQ9Ept3LmZmw+UnfEVWFG0DXXfDQSijdTaxA64MUbTR6IcxFloFG/4U+l6H2W6L6UQgYv3387XSWu9FqtE6+MTnF6C2jsXpJJ0yxpjB85fBsyeHevBnatRMGp3mZRccWod4VVZZiSWHR0UXZ1wBVhb0j4MDnORt5ESRT9kxxWtEG8VlO2p0FJk55GbsF1j0sSr/npv5OPgnL7gPTBeHN4w+GylD/Y+h9QYg+LSZD3fehdBco0ggK1YbC9SCuBVR7TlSma7cE+l4XCwNluofs2p3TjB8PTz7pXaDW6eD99+HECWF0bzAIr59QEhsLcXHwzjtw9qyINMos8YnxdJrWySU6IEIXwfRHp6MoCpN6TSJC5+x5aLKZeHjGwxy5fiSYt5CvSLOl0WV6F5dxRbg2nMm9JtO7Vm+alml624MQRMrV26vezjaBRfZ3weSrv7/i2I1jTovy4dpwfun9C9q7Fr9VVC6mXOTDNUGk/0kk6UgRqACy8MhCvv77a5cIhpLRJW+XIHyq0VNUL1YdhTvhdEarkSl7pvDL3l8CO/HxH0QKkUfBQoGmY6HFT0KY0YR5eF4WoNF6joLJrZydL8pVexOAFB00+Bw6b4bCDYXwE4poqnvRRYs+q/dv6HEg6MMlpSWx7MQyt/tSLCmM2Tom6HMEQ1JaEqM2jXIaqBl0BqebNUBiWiK/7Anw9+InZ86IVeeUnA+OCopzSee4nnrd6TGH6mDRsWwUgU5MhCP/y12CQCYxWU0eDbW3XdhGgikhm1uUi9n1ukhnzU39bU0WBtDm6/6ZkMfWEtGsPQ5CnXcgqoy4HocVEhGcntAZ0iM7I4QA1HqGEISqv+TeXy+P8Pff8NZb3s3wixUTkZPvvSdSvsKz2PLFYICiRTNvpJ+Ylkjbn9uSZHau7GfQGxjVcRQVC1cEoIShBN/3+N5p4Q7EvbLdz+24kpIHUj+yGFVVeXLBk5xKOHU7ZRsgShfFG63eoGrRqiiKwuRek52ibEAILD1n9uRs0tksbaPs74LJwasH+XTdp07jSa2ipXPVznSq2onH6z3uFA1ktBoZt20cW89vzYnmSvIRefdOLwmIw9cO88RvT7iY4UXqIpn26LTb1WQ0ioapvae6rDYYrUb+tfhf7LiYyaiZ5BOw6w3vg+16I6DK0/k2PD2kpF2DLUO8C0CaMGi3FGoNEwJXZkuZBII+GqKrBX2YOQfnOK3G3cvBawc5nXA66PMEyhebvnA17sPBgDoDnNqdak3lvdXvYbaZ7z1ESLBaoWfP0Fb/yimWn1juIqIB3DDdyPLBNwCJB9NNoHORIBAAy08sdxow3o1eq+f3I79nc4tyKecWwKmfs9b0O7OoKvw9GMzX8FkhUx8L942BrjshrrWImg20AqaiAX0hIRw1+kJE4hYPjUF5dpKCgb59vV8PK1WC3buhZk1h9JydZOZ8ZpuZztM6cynFOWVfo2ioFVeLl5o5F+IdVG8QLcu1vD2GAxE1cMN0g/ZT25NqCV3VzrzIN5u/YcnxJS5Vl2IjYp1MlasUqcKbrd4kSu+8KJhiSaHztM5e/VqCQfZ3wcRqt9J3Tl+X76Veq+fLTl8C8OlDn7qMjUw2E33n9M2y76OkYCBFoAJEYloinaZ1cokACtOG0atmL+4vf7/T4/VL1mdIoyFE6iKdHjfZTHSd3jVzqw3Hv/deiatEW6jzdsh9ZfIt214UlWI8oQkXXhDFc8DzIQSRRmO3jfXotQNiVW/y7slBnycQrhuv8+3Wb11ytwfUHcDrrV53K5z+sPOHLGnLu+/CyZPBVaIpWhQaNIBWrUQlnGrVcsb3d8GRBW77XKtoWXlyZdae3GYSaUHBCgKGSlCkifBaKdwQIrK/csTdVcHuJcWSwsTdE7O5RbmQ1LPpabRBDKAL1YHq/4K6H4hoyzrviUWMqHKBH/PYeLj8p/drO4j03keOQdVn0wX+EEZ36qNFQYaHlkPjL4G8YwL+CmNJ9FK40mAQFbxKl8766J9gUFWVJ357ggNXD7h4f4Rrw5nVb5ZLwQFFUfil9y+Ea53fmM1h41TCKXrN6oXdkUXlInM5f578k3//9W+XCXOUPorJPSe73LM/aPMBhcILOT1mV+3EJ8Xzj9/+EfKS7LK/Cy4frf2Ic7fOOaXBaxUtj9R4hBrFagBQNrYsTzd82iVC7abpJm+ueDNb2yvJX0gRqIBgd9jpObMn14zXXPaFacMY0819es3IjiNdbpAASeYkuv7a1T9zMocdTk72blrc4DMZAeQvl1bBpeXevSKajoFiLfLkZ3rsxjFO3Dzh9JhG0TiJkWa7mR92/uC0YpZdfLruU5fBVaQukqHNh9KkdBNKRZdy2pdqTeWjvz4K+YrNtm3w/feBGTM3aQL//jccOAAXL8L69bB0KaxaJVbJExNh1izo31/4WmQ1dofdowF0qjWVeYfmZW0D9n0IaVdwqXLnC22EqLLXYhL0uSpSITusEV4rHddBrzPQ8xQ0+lJEVmRxmo3RamTVyVVen7Pz4k5uGG9kaTtyNaoKmwaJIgWZpUQbaPUL9L0GXbZC46+hwSdQ7wNo8KmIzHnkmOj3+0ZDbE3/j31zF+x527c5eKmO0HkThBfP2hRmnQGqvQRt8oaZeCKFmMkg0rx067hxUKSI8APKzbz757ssO7HMJWLboDfwUbuPqFbUfbRt2diy/F/X/3NJE0qzpbH5/GZeXPxiyAWM3M6phFP0ndPX5bPUaXQ8UOEBulXv5vKaCF0Ek3tNdokGSrOlseLkCr7Y9EVI2yj7u2Cy4+IORm8Z7TI21Gv1jOo4yumxj9p95BIdb7KZmLpvKn+d/ivL2yrJn8gS8VlNLilR9/qK1/lx548uFxuD3sAXnb7g5WYve3ztrAOzeO6P51xW6SN1kQyoO4Cfe//s/eQ3tsPqDmBzvzpNRAkxaNZGut+fl8iO/l7dEa6s9rw/riW0X533PI7SeWvVW3y75Vsn0+XiUcVJtiQ7Rd9Eh0WzaNAi2lVql21tu5h8kWpjqrkM1qoUqcKJV06gKArjto3jnT/fcfqtRemj+PDBD3nvwfdC0g6LBWrVgtOZzIirXRumTIG6dUXlG1+r4UlJIovwvfeE4OTwoLkF+5Xecn4Lnad1vh3BolW0zr4N+iiS3k1yCn0PGTd3waoHMh8FVHEgNB0vfLd0Md7TLR1WcXzTZdjyNFzf7Pm5jwf+Yc4/NJ8hC4c4RQIpKE6rjAa9gW+7fsuzTZ4N+Dx5ukT8iR9h5xuZq8RmqAjNvhcikDbSPzHPYRP9fmoS7P1AVG90R0Z/r2gBN7Z5P2bJDtB2YfaK+zYjlKuS60sKT2UwL/MdKbiPJq5bF7ZuDa5KV3bw5IInmbZvmtt9WkVL0ciiPo+RkJbgsSBBj2o9WPzE4qDa6Be5YOybYkmh4YSGnEk847JgFKWL4vDQw1QoVMHj67tN78afp/90+SwjdZH8/tjvdK7aOeg2yv7ORnJRG9NsadQcV9Ml1V2n0fFYvceY9qjrd2LY8mFM2DHBqaAPiPHxiVdPEBueDSt2GeSiz9IjeaGN2YC3EvFSBMpqcsGX8LVlrzF221iniUAGOo2O0tGlnQyg70VF5UrqFbdRPwoKj9d/nOl9pntuwMVlYuXVmuR+f1xLaLdMmFTmdbK6v20mmFfEe7pA931QuH7g58hB7A47xb8qTkLaHfNaBYV/3vdPlhxfwvlb550e71enH3P6Z18Z9mcXPsu0fdOcBKoofRQjO4zk1RavApBgSqDMN2VIuyfSIDosmvOvn6dQhHOYeSB89hmMGuV/FFB0NHz+OTz/vBB+tJnMHklJERFDTz8tKpHdS7CXsI/++oiRG0fe/lzvFYFiwmJY8Y8VtCrfKrgT3YvqgMV1IPmo/6+JrQ0tp0ChuoFV2LMZ4cIfsOPVdO+XewhCBOoxowdLjy91eqxcTDnOJ593eqxluZZsftaLEOWLvCoCWZJgQVn/BSBFA/U+gtrDhdinDaBYgc0kojZ3vARnZrjuf1yF69tg9UPe09Miywrz57Dgrx85QhbfG9u2FRGNnvjvf+GNN3J3Gtjn6z5nxNoRWX6eYS2G8X9d/y9rT5LDY1+Hw0GF0RW4kHzBZZ+CQmx4rEvK173YVBuXki+5HTtr0LBy8Eo6VOkQcBtlf2czuaiNryx9hUm7J7ksKEboIjg69KhbcfK68ToVR1d0rRynjaBPnT782ufXLG2zE7nos/RIXmhjNuBNBMrlQbGSYJm5fyZjtnmupGRz2Dh361zAx1dR+XX/r9xf/n4X47rb+KryZbcQMt+B30qlp3UEggYez+U51FdWC78fTyJQZFnh55BHWX16tcuKVkx4DL1q9kKn0fH9ju9vr+ipqCw6tohkczIx4SGu7euGM4lnmHFghktZeLvDzuAGg2//XSSyCN2rd2fBkQVOg0e7w86Xm77kPx3+E1Q7UlPhyy/9F4BKlxbCTfHiohJOIERHQ40aIl3s7bfhu+8CO44n5h+e7/K53k2aLY1lJ5aFXgS6uFSU4faXsg9D61mgiQjch0UXBeUehVKd4c8HIelQYMe5h1RLKqtPOUcIRumj6FKtC3MOznGKDtp1aRfXjdeJi4oLybnzDEfH4tNwOQNFBw/MgdKdg4uq1EUCkdD8R1HG/aCb3/++Eb6rPLZdBNq8Gd2ZHezZ433/gAG5WwCafXB2tggCAKO3jqZmsZq82OzFbDlfTtB+anu3AhCIsUOSOcmlCldmcOCgy/QunB12ljKxZTL9etnfBZcN8RvcCkB6jZ4n6j/hMTotLiqOoc2GMmbbGKeo+DR7Gr8f+Z0lx5bQo0aPLG27JH8hPYHyMRmVwLKDl5e+7LlcYXQV7/41SQfASyWoTBGwAAR+Tw5yksurPafVgZik+s04PhQAACAASURBVFNWOJcyftt4F1PbNFsa7Sq1o1fNXkSHOUde6DS6rPeLSeedP9/BZncNue5arStFIos4PfZKi1cwhDnnHZhsJkZvHR20H8vEif4vXlSoADt2QJkygQtAd2MwCAHqzRB6ESamJXL85nGnx7SK1qnCldVhZf7h+aE7aQb7RoAtxb/nlu8HrWeLVJxgjXi14aAvDJ02QZFGwR0rnaXHl7oYRwI80/gZl/BxvUbPgsMLAj9Zyew3vA6Iu9tpM8GRr/xL+9NGwEMr0gWgEOUP6QxQ9z1o/I3z40mH4dp6vPpR1XwNYmqA1n3VNwlevYBAGODnVnZc3MGgeYOy9Zz/WvovF9E4vzBizQiPHnOhxK7aaTChgcdULE/I/i64JJgS6D2rt4sABML7slfNXmw5v8Xj1qFKB7e3CqPVyKD5g7h462I2vAtJfkFGAuVTjBYjTX9q6jaMNato83MbLr1xiaJR94y2oiuLsuFJ+92/0GGBM79ClSGBhdsXJNKu4nWyEFs7T5pBgxAD3FWBuq/0fUTqI3mw4oMupdZTLCmM2TaGIY2HZGnbjlw/wqKji7CpzoO96LBoXmvxmsvz21ZsS3RYNCkWZ4HBoTr4bP1njO46OqB22Gzwn/+IaCBfVK0Kf/8tJj+hNEI1GOCTT8S/n34a/PFWn1pNhC7CKd3UgYMofRRW853ooBM3TpBgSnAR3ALm2ma4dcy/51YaDM0nhNZnS6MRZb47roM1nXz7wfjAXVUwvUZPq3KtKGEo4ZRKmWpNZeLuiTx/3/OBnezy5WCaKsjuUO2Tk/wTyDXh0OEvUYEr1L5qOgNU+6f4d3v6qvzx78HupWiCJgzqvQ/6vHldzy50OuGV5gmrl484J0lKS6Lv7L4ex2oaNNxX5j6XBRB/MFqNbL+wHYeHBa7H5z/OgZcOUNxQPNPHzq0sPb6Uzzd8nm3nu2G6Qbuf27HxmY1+PV/2d8Gm2U/NuJl20+0+FZXBCwa73Xfv89yRbEmmyY9NuDw8BPdnSYFAikD5lKcWPuWzGpE3HyBPeBOVLHYLfef0Zc1Ta1DuHeDXfBV2DvPsxbBvBFToC9oClp6QWVQfK06hNM7N5tS6mQdmotVo4a6XRWgj6F+nv/i/LoJmZZux8azzYOvI9SOcvHmSqkWrBthW3wxfOdwlmgKEyW7bSm1dHlcUhaHNhvKfDf9xWvFJs6Xx484feaf1O5SOKZ3pdsydCyY/AhliY2HDBihWLPP+P/5gMMBbb8H58zB5cnDHWnh0IbfMzqa51YpU42TCSafHwnXhrDm9hr51+gZ3wgz2f+xfVEjJ9qEXgDJQ0oWg9qtgSX0wnvX9GjekWlJZc3qNy+NtK7VFURQ6V+3M5N3OHbX38l6upV4rGBMChxUOfAo2P9TTZt9ljQCUgT4aKj0hRL9Tk0VJeLxcKys/CYqMAPJF8eIQH+95/+bN0KtX9rXHHyx2C91+7caVVPf32UhdJC83e5mvOn8V8DlGbhzJf9b/x6WwBwhD4fZT27P1ua0ulbDyIolpiQycN9DrcwIZ94L3se+mc5tYcHgBj9Z+1OsxZH8XbD5f97nLuOZuLHaLfxWXvXAl9QqvLXuNb7t9G9RxJAUDmQ6WD/lp108u5qB306BEAywfWrCOsGZ++9BKmwpt0Hj46my9sJWvN3/tuqPSIAgvikfvH/M1WPuwf4N0b0TkkTSFQAnzEQWRehbciBUBkc2pdeO2jXMZuGg0GqcSrgPqDHAqFQ8iumbS7kmBNdMP9lzew5rTa1yqi4RrwxnafCgaD5WCnmn8jNsS9nbVzr//+nem26Gqoqx7ih/ZS9OmQeHCWSMAZRAdDWPGiIpjgaKqKstOLHN5vF2ldpSMdv4tJ1uS+f3o74Gf7G5uHfWdggOicuEDc7O+0p42Etr+IbxfAmDJ8SUuqWBR+ih6VBf+AF2rdnWpHKLT6Pjt8G+BtTevET/LP8GvfD9R9S2r+1sfDU3HQGwtSD7h/bl13gZ91nue5XUef1xUPPTEzz/DLQ8F2nICVRWr/nsu73G7wABQ3FCcz9p/FtR53rr/LSoWruhW/LA6rJy4eYI+s/tgd+TdNHIQnnu9Z/V2iRbOIFIXyVedvgps3DvCyrlh51zGHnczeMFgDl3z7O8m+7tgczrhNP9em/lxXyCM2TaGPZd8mKRJJEgRKN+x5fwWXlv2mscooEhdJNP6TEOv1aPVaDO96bQ6JveaTLjOvcOiyWbio78+4s9Tfzrv0BmEx4I3Y8sbW0UpefMN7x5C3uhzWVRb8bTldYq1AJ2XMOFLy8Wqdx7j8LXDnE5wrXdu0BuoWazm7b/vFoQysNgt/LTzJ7eCSyh4fcXrTiZ8d/NM42c8vq50TGlal2/t8rjFbmH6/umcSTyTqXb8+SdcuuT7eQMHQvv2EOl5vBoyIiJgfhBWPcduHHO5VkWHRfNAhQdoWbaly/OXHV9GSCpaHvjcv99Jy5+zJ71Soxcps3XeCejlk3dPdkkFA2hfuT0gIoLu/Q5npIQVCPZ/4tv7Kbw4tJiYfem0mgio+366cbQHdDGiPL3EJ4MGeReBli2DpMB9gEPOh2s+ZPGxxW69QUCM1Wb1nUWELiKo8+g0Omb3m+3xOGm2NDac3cAry14J6jw5zbt/vsv2i9s9FhgoE1OGYS2HBTTu1Wq0lCtUjs/bf47BQ1qm0Wqk09ROJJgS3O6X/V2weWDyA9lqz/HQLw/hcOQBn1NJjiJFoHzExeSLdP+1u8ebTIQugqcbPU2Dkg2COk/VolV5o9UbHsNJTTYTfWb34VTCKecdhWpDq198C0FL6sC1TWD107C1IFH2Ye8CWeI+72WGcyk/7frJrbli9+rdnVILqxWt5hLRAGC2m1l7Zm3I27X53Ga2nt/q9ubdqlwrShpKYnfYPW6vNH+FaDdlxK12K++uejdTbfn+e99eQMWKwYQJIkonO9BqoXz5wF+/4uQKF1FHVVWalW1Gu0rtXFZeTTYTR29kopy7O+wWODfPtz9M+T5Q4kFh4pwd6A1CFMgkKZYUt9/9cG04VYuIFMkShhKUii7l8pz9V/ZzNfVqps+Zp0iN968CXLPvhSF0dqHRQko82L04GhdrLgytJT6pVw9KuX7Fb2M2Q58+/ldVzEom757M6K2jPS7WRegiGNJoSMiqIdYrUY83W73pccxmtBr5Ze8v/G/z/0Jyvuxm9sHZjN8+3uvi59RHp6ILMl3+1RavUjrafRq3isp103V6zerlEmUj+7tg89Wmr7iY4tmwOUwbRmx4bKa3cC9jk0RzIm/9+VZWvB1JPkJ6AuUTzDYzXad3dbsanEGkLpJRHUeF5HwftvmQybsne7yppVpT6Ti1I/v+tc/Z4K5CX7Hq/fcTYDPiNm0o7Sqsbg8lO0CTbyCmqjDH9FVqviAQURxiano22QbY8y7cN0akHOQB7A47U/ZMcVnBiw2L5dFarjn2D9d4mMm7JzsJMymWFMZvG3878iFUdJnexaOoui5+HfrPfHt1uBOQ7Kqd2Ydm89Txp9xGN92LwyEigXzx/vsiOic7CUZwmndonsvna1ftVCtajcS0RPRavdN+h+pgxYkV1IqrFfhJr20EJQzwMvlWNNB0nPeou6xAk3nBafGxxYRpw1xSDDL8gDLoUrULE3dNdPo+ajVafjv8Gy82zcelgy8swed6V3RVKNM9+wS/DEznvIv6xZpnfWpaPkFRYMYMeOghz75pO3bAe+/Bf/8rfM1yglUnVzF06VCP9xWAwhGFg/KFcceItiOYeWCmR08So9XIh2s+pHLhyj69bUJG0hHxr6IVfob6WFE1MRPVF/de3sszC5/x+HmGacPoVbMX95e/P+jm6jQ6fnn0FzpO7ej2fBa7hZ2XdvLWqrf4XxchsMj+vouM/tboROpzWGHQF/KvSEAe5WrqVT5b7znFL1wbzg8P/xCQEbjZbub5P57HaHM/D5uwfQKvNn+VioVlNKnEPVIEygeoqsqQhUM4cfOEx1KVBr2B8d3Hu42iCIQIXQSTe02m75y+boUgh+rgUvIlBswdwJLHlzgbRZfrCV13wJouwnfG4WEydmU1LGsEhetD5aegylNikqRo8mwFrJBQ/UXY87Zn/6RTU0QFmqJNgzOKjigZpC+Qf6w6tcptfnqaPc2tqNO7Vm/mHprrZCasorL0xFJumW+F7Dv+zd/feBVVQxHa+/TCp7ky3PdnvGOH72PFxsILL2S/CBQoZpuZbRdcK2LVK14PjaKhYcmGmKzOA+c0WxrzDs/jtZauFdn85vxC36lB5R7NfgEIAio9P2n3JJfvqUFv4OHqDzs91qVqF2YfnO30uzFajUzcNTF/i0DxM31HR9YbEdBnHzRWz9cXACJLikUTiV+0aAGvvgpjx3qO+BkzBq5fhx9/zH4haM+l/fSc1dNjejFAlC6KmX1nZs64V1XFeMB8Day3RAEJh12MlRQtaMMJC49jdt8ZPPhzO4+ChMlmYuC8gawfsp6W5VzTcX1iM0HycUg+CsUMcMNL6GohYEXzu9+ESNF1WIRHmj5WeCAaKkHRxhBbBwrVgpgatz2yrhuv02V6F69FUMK0YYzpNibz78UD95e/n961ejP/8Hy3Jr5Gq5Efdv5AszLNqFeiXtb0tx+EacOY3W82D055MOv6G0TEftIBiIuF615Mt5z6W+V2f6t2kfYaVkR48MXWFOJ34fpi8+WDGWpu7ADVcee3o4uCsGKiHZm8R6iqyuDfBnvs/0hdJG/d/xZPNXoq4OZeS73GB2s+cGsEbrabGTB3AJuf2+zRu1JSsJEiUD7g263fsvDoQo8XegWFeiXq8Vi9x0J63q7VutKmQhv+PPWnS+lsEJP49fHr+Xjtx3zy0CfOO2NrQo/9sOc9USHFYfGcnpG4H3YPh91viZtCXEtRsSeulbhpKBoRUn/79QriJqMR4f2KAmnX4aYfM+m8QLUX4Ng4uHUEj8a2GwdCl20QXixwIaiPjzKTM0KzejN221i3Yku94vWICXc1RH2o0kNub6paRcvcg3N5tsmzQbfJ4XDwwZoPgj6OL66mXmXOwTkMqDvA6/MWL4Y0L4ErAC/msXn83+f+JlwX7hTBoqDQrlI7QFQDq1i4IiduOhvnbr+wHbPN7NGXzCfnf8encXmDz/KEGW+yOZkN8RtcHneoDh6q/JDTY+58gQAOXD3A5ZTLbtPF8jw2I9zY7v05kaWhwoCciTT15X0XQGSYR7K52mNO8dlnsHw5HD3q+Zo5YwacPQuzZgkD/ewQg1JS4O+9V6kQW8Hr8/rU7nP7GuiEww4pJ8R4KGEvXN8Cxngw3xTCD6qIZFMyJqoZ92dViESqlfvsFj4qomNyklZEYmjDxRhJEy6+/+mvvZTsh/kcgCUBrm6ASyvh0gpIPSMEHIAxPm5YADYPIqjdKLa0y3DrsPA61BnEWM9mgshS2Eq05+FDR7hpcl9uG4QY/kXHL0JeAfHbrt+y6Ngij5WcjFYjzy16jv91+h8VrlvBS1HXPoeNtPvwIc9PCIL7gI9aw+TG3p5l5VL/rrA50b+DWhLh8mo4twCu/Ck8PHVRMM7mtcgh4Lm/rYliSz0tLCHOzhXit80kItpLtIXyfaHyP/xro9M5TZB8TBSD8ClMKrCm410PqEIQchInYyC8BBSqmy5O1hLzmeiqLmPtqfumsuncJo8+VVqNljfvfzPz7+kuXmj6Ap+t/8ytCGRX7Ry8dpAxW8cwrOWwoM6TJylZEq54ueeVzOeFhPxAikB5nA3xG3hz5ZteTXEjdBH83Ptn17Lt7lBVcVE3nhPCisPivCnaO6lZmjB+bP0SNePXYrO5v8ulWlP5bP1nNC/bnB41ejjv1MdAs3FQa5hIYbqwRAg5qifDVlV43iTugxM/3nlYFw1RZYVar9EDijiGJRGMF8TNJT+h0ULrGbDyfs8Vb4xnxapLly0QFgfa3LmanGBKYPWp1S6Ph2vD6V+3v9vXGMIMNCrZiG0XnaNIUq2pfLv125CIQB+v+9hjBY9Q8+LiF32KQPPmgdWLj3FYGLzzTs6lOATC4mOLSbE4R+TEhMc4+SI8UP4BFxEoXBfOxrMb6VClQ+ZPmnpWpJt6o0Q7iArC6CgbWXRskdtUsEh9JJULV3Z6LC4qjtLRpYlPcq6jrdVomX9oPi83fznL25vtXPlLTHAdXn7Ltd/OuXQEXxGtviKFMkM2V3vMKfR62LgRevQQEZSeIoI2boRq1WD4cHj3XTH0yQovtVu3wGKBN96A6dM74HD46WmmOoTYc3GpmBQnHUpPV9SkRzK66RMP47C7eaewhXcKg5ixm0FrBU2amCyHFYbSXcBbelDaVTgzE07+JKJ+NBHpk/v0BSlPE30AFAiPSxee0seRiiLGlnaL+J2ar4n37vxhOEdvGs/x2rZf2HFLi92Lt1uFQhV44b4XvH4eGdjtcO4cXLsm+uvuzWYT36uwsIytOENrfMm3R4Zj8pCKY7Qa+XDth1wbnbPi6TubxOYdH47p5htw6hc4/YtYfNSEO/ezNcRl9+ymO2NbS4JYuLn8p38ikDUZrv0tMgkuLoVbx+54vfkUJlWwevksbouTV4Qlw7n5wthfdYDDBkUaQZfNAJxLOsfQJUPdijMgqne+2/rdoCPXI3QRfNb+M95a+Zbbc6VaU3l/9ft0r96dGsVqBHUuJ/KCwHJZLGS/ueJN/m/L/6GiUjamLHte3ENcVFwONy53IEWgPE6YNsz9qtFd9K3d19VDw3hRiCkpp4RCnnQQUk6CKX0FSBuOSzl3VU1/6M7j5YEfSjj4OQGhgmsjQGsQg1ttpFgh0EV7r3gQUw0enCdK5R7/AU7/LAQou9HNYMANthTxHgoSRRpB9Zfh+HeeUx2MZ2F5U2izUKxW5EKPoBkHZqDVaF1WkPRaPd2rd/f4uv51+7Pv6j6XyIbjN49z/MZxqherHnCbbA4bIzeODPj1mSUhLYGJuybyXJPn3O6/dg1Ouk/rv02/fqDLY1fz34/+7iJeW+1WmpVpdvvvBys+yNxDc50GNymWFJYcXxKYCHRxmVhN9ka9D/KMD4u7VDAQ0XLuRP+u1bry484fnVIZjVYjk3ZPyp8i0Nl5PialQOUns9cQ+m58pTokHxfpFrnw2p2biY4WHmpPPAFLlngWgtLS4PPPYfRoeOwxePNNYXSvKBAVxCUgOVlcj3fuhK+/Fm3wQ58RY6zrm+HYeLi4OH1yabkTMWbLgsqfd0+4zdfgzHS4f5rr827ugr0fwpU1YjEwY9zhLppNGyWiI2JrQWxtKNpE/D+qHOBIX+xT74zvFA2g3PEGMl0SY7qEXUL8unVE/H3XBL2cTkQ3ekKn0fF1p6/F+CIdhwMOHRJRYqdOwcGDcOQInDkjUgTDw10rzGXULbj3cupQX8Dy0G6UwicJC4OISIg2QJRBVOY0GKBwdDiwzGMbcz0J++Dgf0QKta8+z0DRijF9ofpQpKGI3s+YD2jCxQdpN9/53iUdhsQ9IsLt1hHPVTu9pXDbUuHsfDj5I9zYJs5lTeX2wNLr70aByDJiUVoTDtowESXnsApR0mER0Xbma64vVa3Oq3M3toiHVZXH5j3m1QdKp9GFLDrn2cbP8vFfH3sUnMx2M33n9GX3C7uDNke/zeXLnEo4RbOfmt2uiNeqXCtWP7U66Ap3oeS7bd8xYecEVFS0ipZrqdfoNK0Tm5/dnKvamVPksWlDPuXY+PQcVK1zDmp4+hZWVKzQuJm8tCjXgtVPukZSuHDrOFxdK0J2r24QN1NtRPoKjJsLlbeV03sYbBCbiHlNEZuiuxMW7DCDPxO2mGrQ5Cto/IUYCJ2cLJR2h0Ucz5aCx/SnUKDPntzj774Tq05arRgoGgwQFwfFi4stLs7P8t6NvwDLDYifA3YPIa6mi7CyBdR4BRp+Dmhy1QR37NaxbvP5tYqW+iXqe3xdt2rd+Hjtxy6PO1QHE3dN5ItOXwTcpjdXvOnRWyurGLZ8mEcRaOVKMTi1eBl3DRokPIHyCldSrnD+1nmXx/VaPeViy93+u1mZZi5ihkN18PuR328bb2aK+Nne/WG0EVD8Ad9CUS7glvkWm866LvEa9AZ6VO/h5hXCF2jmgZlOvkAAh64d4lLyJUrHuK98k2e5tAKv94zCDXPWc6fofSKS1dME5/rfZOk9Lx+j18Ps2TBypBB6zGYhArgjJQUmThRbnTrQvj08/DDcf784jjl9OBQWJu7ZiiKOZbOJ67KiiHt2YiKsXQtLl8Lq1XDe9RLnHrtZeFft/xTMV9MrwvmxABZR8o53SrHmEFUhfSEuXExoVZs4tsMsIiRu7oSE9Al38lHPE+67ST0Hu14XURX2NDx+H8OLQ/lHocoQKNI4/bmKEAAy67dlqCC2kh3E2EZ1iPeVfAxO/Qxn5/EeZ3nvce9jX5tNRHytWwfLlsGuXWLcpdEI8/B7o2szVzlOAwtFRLo5fUtC3KvDw8Wxw8PBZTE1L5B2Hba/JIRIb1YNAJFloUI/cd8s0kj0m90s+kxn8G1HULqbEHEUxJzBdEksUF/bJMb/ycc9v9Z0CfaOgPgZYu6UcR11973WRghfqdiaUKgOFGkiPKYiywkxJ0OYdPp+K+LHrQkT7yc1XiyY39wlfj8Z4uQ9n8/47ePZe2Wvxyi1KH0UI9qMwBAWmtDtMG0YIzuO5LXlr7lEV4MYM51OOM3IDSMZ0XZESM55/tZ57p90PwmmBDSKBrtqZ/fl3Twy8xGWPr4UfS7IPlhybAnDVw13EuMsDgtHrx+l/5z+LBy0sMB7JSn3lufNLpo2baru8MftNK9ht4gbbdIBSDwAnb+HBC832kLAhAhAvTPxyBCDQFxcHBZxAYosI1ZTijYRF7HCDaFwPc8TlpQz4oZ5akq6iq34Vz5cGykEmZjqInT3rvSv2+1xWITfQuppcZHOiCDyxOMBfs9UVUS0XN8CV9fDlb9QU06AquBQwnGoGnDY0JKGgt1ptcaharATARo9GkVFo5oBO4qhAhRvAyXbCX+hmOpBTfrOn4c9e+DAAXjh41IUMXsOkbxCSSpFXEZVxUBEUcS/Wm26t6NNDDjDwqBKFWjSBJo2hbp1oXFjKFrUzeez/V9weprvvg2Pg+ovifQ7RSuMF4PBlyeQjz4/ePUgzX5q5na1ZGDdgczqN8vja1VVJe6rOLd+AEUji3J1+FWnFUB/sTlsFBlVhBSr51WnMG1g3iE2h81j2qaCwvInltO5WmeXfS+8IExMPaHVQlJS3koFm75vOv9a8i+XAUubCm1YN2Td7b9tDhuG/xpcvBfCteGcGXYm8z42cwt5D10v3QVaz4awQpk7bg7g6TOM1EVy6OVDVCpcyeU1N003Kf1NaZfPM0ofxagOo3ilxStZ2WRn/E1PDhSHFWZHep/A1P0Q6n2Y/VXBMkg+CUsbeLl2KzAgJTTCfbAeboHewzPI6v72wrFjMGQI7N0LqV4sQdwRFwcVK4qtXDlhvK/Vint1aqrwFoqPF/8m+ciqATdv8fJq+HuwiFjzFu2gaKBURyjXWwg+MTWEgGlPSxd+/FjVdtjvLBhpI8UiUcJeEd0TP+tOymBGX5+eAdueE6kuntL0C9WFRl9CqYfE8bM6as1mFN+lm7uhuGvFL1WFDRvEPXPhwnRLyDTv6dQZxMVB9epQtaqIJstI/9LpxOsz0sMSE+H4cbEl+wg0VPOKCKSme0edng47hqZHwXhYDFZ0otJvzWFC+FFVkRYVSuxmce1OOQVHx4gItYHp10lrChwaBUf+5/27qTNA2Z4i2rNkO3HMQIXJu3FYhFCrKOJ4F/4Qn9vlPznR5TANv2/osWIXQJGIIlx44wKR+tB9ZjaHjYqjK3Ix2XMp+khdJJuf3UzDUg2DOtfV1Ks0/bEpF5MvYlftaJU7aZlR+ig6V+nMvAHzAhqDh4pdl3bRZkobp+ioe9v5bONnQ2oan1tRFGWnqqpN3e2TkUDB4rCJqJXLa+DiIrHCoo0Qj9uNMM6fY/hhoAdCDDGeFbmxGYNCVYWB9wwcEvbAzteFcILqPaqnSBMo2VYISoXqQnRlIQ7YTeLYGl26QKJN/zc9hFe139kyQjyNF9JDePdAwm64vDLoXOEbNxV2767I7t0V2bhxILt2waVLKsULJVKxxAXKFL5AqdgLFDVcQa+1oNdYUBQViz0cu0NHgrEEl2+V5WJCWc5eL8vFG8UoXlyhYUN48EEhsjRqBGXK+N+mW7fgr7+EWe/SpXDzpljxMRrhPasPM2XwWpk6A5NJhCofPAhz54rjm0xQqZIIZb6NokCz78VN7fgE70KQ+Toc+BQOjRQme5WeEIZ7qOKm7s9Ew2ETqzYhSJ/4addPbg3zYsJi6Fu7r9fXKopC9+rdmb5vuss+q93KmtNr6FS1U6bbNHXvVI9Vv7SKlqcbPc3EnhMzfVwQpWzvn3y/28gnFZXhq4azt+pel8iXAwe8H7dFCxFZlpf47fBvLuKFVtG6pLbqNDpqFqvJ/qv7nR7Xa/WsOrmKwQ0H+39Sa4qYQHijXK+cqQoWAJN2TXK76mcIM7gVgEAIpGVjynI68bTT4xkpYdkqAmU1KWfERNfbxLriwJwTgACiq9xl5OsOVdzvy/TImepl+YQaNUREyPLlIuUrPl4stvhz3bx+XWw7d4a4UeabYgHnwmLv9+2oClDzVaj6THqkeLTzolVm7sUaLWjuWvwxVBRbqY7QaJQw5T3yf2LfwS/gwCeefQe1UdDsO6jQP91YWgvZ8RXNGKfEOVezstth5kzhjXfrlhDoPGmKERHQsSPcd58Y/9WuLdIANRohGGm1dyKGMjaH486WIShFRYlx35kzIs1szx7YvBk2bbor6syXd0puoGRJ8WHtHu57HFm2J7T46Y5JclaRcV0uXA+afANNvhZ/Jx6E1e2FaOrpuxkeJ4o7VH5SRMNlLHiGKu1Xk64OOWzu/QAAIABJREFUZlBhEJR5BLvDQv+fO5Fm9zzIN+gNfNzu45AKQCDGSl92/JIXF7/ocREzzZZG3zl9OfTyoYAXMxNMCbSe3JpLKZecIp0UFFRUjFYjK0+tZMjCIfzS+xf/vGhDTHxiPB2ndnQSgCJ0Edgd9tttzhjzVCtajVdbvJrtbcwtyEigQLm5C45/L9ILIL06lR9LDZpwEXkSU913DmryMaGCe1vJhDurNqnxsONVuLzKe9huXEuo8gyU75Me4aMPrSeC6hChx9oIIQadnCRuGv68VBWrdQsWiBt6fLwIszaZvKfDBEJGKpbZLFaABgyAb75x/1ybTeT1jxkjBpMREWIFyN+fT0SEWFnKCBXW6cT7MZvFduuWn54BeDnnpZWwaZCY6PorLKKI0O24lnfCZKOrpA80dUB6ZQTTxTveUUmHheGqL8NtLyvHabY0YkfGuhWBFBQerPAgOq13jfpa6jUOXTvkNuS2TvE6HHzpoPf23YPFbqHc/8pxzegm9xuxcrDpmU00KtUoU8e9m1rjanH0hnv/KoPewOx+s10M1MuUgUteAu1GjRKmo/d6GeRWHKqDwqMKu3jZxIbHMqvvLLpV7+b0+NClQ/lu+3cu4lzvmr1Z8NgC/0+csA9WPQg2L8J07wsQlQlFOIdITEuk5Ncl3Van6V+nP3P6z/H42peXvMz3O753+TzDteGcfPUkZWPLhry9bsnqyJCLy2DTY54XIsKKwKOXclYEAljdQURieKJIY+i0wbeJtC8KcCTQvezZI+7ls2aJyX6KF50wVMTEiPv+zZsIc+UVzUUEtSd/FV2MmPhWGixEn+z6nlqTxf190yDPYkB4MeiwVlRECnUESAAsXw4vvQRXr3qO9IqIgN694ZlnxAKg2SzGf6H00rNYxFhVoxELhBMnwqpVQR7U30l0sL+dPe/C0bGe+1xngNZzoGSbnFsouboR1nb3bg1Rc5iwPlC02e71Nmn3JJ7/43mPlUtVVSUmPIbzr58PvLqpF+wOO1XGVOFKyhWP4ovFbmFUh1G81fqtTB8/2ZxM68mtOXrj6O2xh4JChUIVuGa85rTAGaWPYkijIYztNjZbhaDEtEQaTWjEuVvnnCLvqxetzvNNnueTdZ84iUORukhm95vNIzUfybY2ZjcyEiiUXP5TCC2p8UKw8SbQFL0PijYT+dpFG0N0NTHwtBvTTZY16Ss66XlBqoowzUuPtMm4iKVdEQ73CbvEJPzqBmHifDdXN8K6HiJKw1ObSrSF+8aISb42IvDS4b5QNHfSKeJaQqF6Pl9y9qwwZ5w69U7oboboE2rxJwOb7U749vnz8O23riKQ2SwGi19+Kf6fEfrrqU2RkVCrlkjfatgQmjcXfxctKt5TxkqSqt5JBdNoxEDk8mUR+bNtG+zfL/5//Lj/4hClO0PPU7DnbZEe5iuXGwBVfK8Sdvl5ktAwasMoj2UzVVTWn10f1PEPXTtEfGI8FQtX9Ps1P+780W2UTgblYsoFJQABDGs5jOErh3us4jBsxTC6Ve92O0/ZbhfG0N7o2TPvCEAA+67scxttlWZLo1nZZi6Pty7fmql7p7qIRqtPr8ahOvzP6U454X1/VDnhvZYHWHhkIWHaMBcRKDos2qMfUAadq3Zm+v7pLr5AGkXDvEPzeK3layFvb46QfCI9/N8DheqIleScFoHK9xMRGDYPs9eE3SK6Nq5VcF5VESWDrBCWf2jUCCZPhrFjReXFBQtg/Xpxj1eUzKeMuSMmRowT4uJE1EnfvtCtG6LS0spWojiHp4XDuPuh7cL0IhvZLLJoI0U6kLdokBaTRTpagNEEoUJV4aOPxLjNk59PWJhIqf70UzHWyvDOi8gCfSDsrgCR/v3T+zsvcHGZdwFIGwUd/hJj+ZwS/cw3YW03L5GdCjT/ASo+HrxgHiBdq3Zl7PporzmCrc+ZCX87a8QpLbA8DtZU9v68btO+gOOZE4HSbGl0nNaRYzeOOY07IvWRLHtiGRvPbmTYimG3x9BGq5Epe6ZQKLwQ/+nwn8y+lYCw2C10md6FSymXnASgDKGnQckG/Lr/V/Zf3X97v8lm4rH5j7H2qbVux5/5HSkC+UviQRG6e3On95tj0abCGK/igPQ0Ka1rmo0mk14sUeXEVqKdyOdWtGIwd3qa8Pw5vwg2DfQcGqnRQ4tJwrQvJxR8LzniBw7ABx8I81uHwz/BJzxcCCv164vBXP36YkUnIuLOjd1sFmKSyQSHDwtDwAMHRMiupwHevaHhq1bB00+L/G9vhoFlysDjj8M//ynStYxGMdgwGMS/GfhacSpfXmwdO4o2ajTi/ezeDRMmwPz5ImLIK2GFxI2wxqtwcKQw1lNIjwzLPYzfPj7Lz/HBmg+Y3sc1XcwdRquREX+N8FrO89WWwYeMDqo3iNdXvO5x/6XkS8w/NJ/+dfsDomRtWJh3IbCi/zpXrmDZ8WVuI1hiw2Pdlu1sVraZWy8lFZU9l/fQpHQT/06cfNLzNRIgpmb6qnzuMU73xJQ9U9ymgtkcNp/VIttUbIPJ6vo5mGwmJu2elH9EoKQD3lOho6v5SMXKJqo8BXve8f6cXa+LyItgvIH6+EhVDjZSKA9iMMBTT4lNVUUVxnXrYMUKkXZ98SIkJLhWjcpYxMn4f0YZ8eLFhW9Q/frQpQu0aQOl7rUt+/t5YbbsUQBqBQ+tyLmKcDe2gcVLlK+hskgfy2EBCODJJ4WA52l8VqkSrFkj+iU6mz/OuwWnXM+e973Paxp/nbMCEMD+j4UdgScqPgYVB4E+58wRy8aW5eU1Pkyispja18XmnRuZOqbVbqX7r93Zd2Uf5rsWVgx6A190+oLaxWtTK64Wvx3+jTVn1twe3xmtRkZvHU1seCzvPODjHhckqqryxPwn2H9lv7NIpYvk5WYv07h0YwBm9ZtFkx+aOHmRGq1GOk/vzK5/7qJyER8KWj5DikD+cHY+bH4yfSLtoWJD8QdEfrShctZF2Wg0oEnPwY2uDHXeEUa/i2t4n9y0XSIM9HJIHXeH0QjDhsH06d6rdoAYgD30EAwcCJ06QYkS4vWKIm7sGh+Low89JJ5vt4sc7oQEseo3a5YY7N0bCm42C1Fn+XLv4k/btmJ1qXlz0f6MkrKFgvSU1emcj9G8uchZ/+47YXToF4XrQuvpkDZapC0e+Z+IMLN7iRQLJRElPe46fuM4100+71JBM+/QPL9FoG+3futWmMjAoTp4ov4TQbepUEQhetboydxDc91Gw6RaU3lz5Zv0qd0HrUbLyZPeo3yKFBHpDHmJeYfnuf2sm5Z2G61K1SJV3X5WFruF5SeW+y8CJe73nrIbUzVnK0X5SWJaIpvPbXa7L1ofTcnokqTZPIu+kfpIysWWc/EFAjh6/Sjnb513qtCWZ0n0YaYVW1OscOc0uiioPVwYnXq6j9/YDgc+g7ofyHLx3ihVKmD/FQWolr49e9fjdjRcNJbhLBVIxYAVPTZ06LGix0ohkqhIPCW4inIJuARsBya7OUlxYEy45+uQJgzaLs7ZPrYme484iyjhX1Uxf/itVMDRaav2d+a331Z4HKOVKycW/zLS8CQeSDwgrCc8EVZECNU5nfZ3eqp3m4MGn8prYxZgd9jpO6cvW85vcRpX6DV6WpRrwUtNXwKET+f0PtOpMa6GU8EWo9XIp//P3nmHR1Gu7/8z27NpJIQuoTfpCAhIE8RCEQUF1GPvCrajx370HBVFPV8sWBEUbEg7ilQBAUFEOkgPJbTQCembbfP749klbWc2ye4m4fy4r2uulN2ZebfMO897P/dzP7/9m1hrLI90eSRi43x+6fPM3zu/RKOZGtE1eK3fa+f/bpnUkhd6vcCbq94sovzPzM+k75S+bH5wMwlRFdMpuirg4tQYDHs+FrM0TXM8G3T/BupeW/Eki9EKu9/Xl7zXHSSZpSpEAP35p0ijz54VpY4W2rWD55+HoUMl0xYbW0D4lIVoMRiKZoFq1oSbbhJCyWYTk+exY6WjhMMB114rJVlaY6tTRwiZAQMqriNTrI/7G67vl1wStiRo+zK0fg5OrYZjC+Dwj9LVzWDVr60OBoOf7FSgVj+ofwPUvjqop8rzS54v3/nKiHxPPgtSFpTwmCmOzPxMxq4cq1kKpqAwuNlgqtnCUyo05vIxzN87P6CSAyDdkc7XW7/mrg53sXevfleTpk3lO2ut5IqW0iLbmc22kyUX5xajhSsbXRlwH0VRaFOzDWuPri3yf6fHycwdM3mh1wulO3nmDv3H41pKKUQVxwtLX8Cp4SNyJu8MMWODB8JaXeqcXidPLXyK6SO0PYUuGGSXJLmKoFr7qmO23OIx2DFO/zk7xokCo8YVFe51ccEgAga8RrzU5wj1KW2/dx30A5z52pF3w9sqn4iOa66voMsIQq6WBSGUJz4+dbxukm78+PB7/vxPIveIr8ucxuNxVUQhq7fOASGrwoEQiMn/NXhVL7f/93aWHlhaglyJtkQzbfi0In4/1e3VmX7TdIZ8P6SE0ubpX54mxhLDHe3vCPs4J26cyIdrPywRw0eZopg2fBo2U9H75XM9n+Obrd+w58ye8wlGr+rlePZxBnw9gN/v+T0ink1VERenRz1k7YVNf9cupTHaYMAqiGsVnhau5cHZjfoyzjpXVyl2/IcfpFWrHvmTnAyTJkGPHgXtOaMisDbzE0lXXw09e0ob2UGD9AmgVq3EGNrfPrSiUe6AxmCWLnC1+pDT7C1Stp8lM+VXTFlbiPFsJ96QQqLtCHZzFvluK6qqoKoKKGBQvBgNHhRF5VxebdJdDclUWuOwtMJYtzf127TlkvqGUvsXztkzp5wvoux4ednLQUmgt39/G49XWx0VbYkOa/eAK+pfQbw1XpMEynZm8+ziZ7m17a3s22fRDXSbNCm9b2RVwIrUFdhMthJKIJvJRtd6XTX369ugL+uPrsdbTIm5/dR2sp3ZxFhKMcflHNZ/vFrb0DxXKgjfbv1W8zEVNaBRellQkddnRKF3XwSIa1Yx4ygNLNWg2UOi2tRU9aqwcjhctUL8WCo7M38RZUcN9KPuhE6R7bhUGsQ0gno3SCl5IMWSO0fi4sver9Tk4v5TjXUf79evcmK0Cw6maHQTgflnw0dMRpJgSZsHyWHo9hjq+OKBjNAOEXHU0lbq+6GqKg/Pe5ifdv9Uglyxm+18N+w7akTXKLFf/8b9ua/TfXyx8YsiRFCeO4+H5j5ErCWWG1vdGPpr8GFhykIeX/B4CZLKZrJxd4e76V6/e4l9TAYTP9z0A90ndS+yn9PjZMepHYyaOYpZI2eV3m/yAkaplpSKolwLvI/4Tn2hqupbxR7vC/wE+FNvs1VV/XcYx1k52PiUvuy15VOSPa4sAgggqo74GmgF/ll75aYdjpt1SBO4gV9re4ISQHfeCRMmlKzBjyT8SqH0dFEpaY2vdm1YvVrqvIOVoFUVOBzSsvSXX8TrICVFPI7s9kRU9Sby8m4q4jdjNTuoHnMGs9GF2ejC4zXi8pjJddo5m52IiOaFePB3OnM6pRyuQQPo2FHMEO+4IzA5MWvHLE1D6Ehg47GNON1OLKbA0eCZ3DOMXzO+xA2kMOKscfRM7hm2MSmKwpiuY/jXin9pnjfHlcPEjRPJyHhU91iNGxeUIV4ImLN7Dln5JWvm81x5XFbnMs39utfvTow1poSZsc1kY3nqcgY3Hxz85ME65sXoLyqqAvaf3U+mM5gxWGjI9+Tzx+E/AgZPFxT0/CMATFXMsKPd63BkjnQE1So7d2XALz2gzxyo3q1S/S8uohwIZjjtSJOkYziUXiHFawpYEqUDaKDYct8kiTs7jS9oD18ehGBWHmfL5JRL+306dEgaclxEECRept9ZLGuPdIZNLGXZtR5CJViM0WJpEAibn4N6Q6SrbWUqPD8mtE6KFdUNLghum30bs3fOLuIBBGAxWOjToA8g/o6BcFWjq5i1YxZ52UXj2zx3HqNmjuLjQR9zb6d7A+5bFqxIXcGN028MWP4ebYrmtna3senYJs39R7UZxffbvi+yf547j4X7FnLfnPuYPDRQTe//FoKSQIqiGIGPgAHAEWCdoihzVFUtrq1fqapqKSLxCwjHl+r7pzQfXfllVs1Hw97PtLOH+yZC6xd8pTshTowhTOCpp+oz9EF9Auipp8Rjp6JKrIrjhRf0u4K8+KKUj1V1AujQIfjuOzGS3rpVxpybW9RcWMtgOt9lIy09eItoVRWCyVFo7t2zR7Z584TMC4R/rfhXGV5J6FBReWf1O7zY+8WAj7/+2+uapTEgJMPoLqPD3uLyrg538cryVzQfz3Hl8PKvLzMw90H0pulq1S4sufvPe34O6O9TK7oWsVbtDHiXul0C+ghl5WcxZ/ecUpJAwUiBqr+gfu2314I/KQwYu3IsP9/6c4WcK2JQg3zelV12UxymKOg7HxZ01F7ogCicll0tpFGLx8VHJlKdPi801KoVkZKwsGEt0AvQEivs+xLavByec4W04Fbhug2wuDc4jgduY7/3czj9B3T5REorjVFljzFDMCv/x5BxvPrTfzRjtieekFiksuLJCwal8SRb9xD0/7XyWsP7UXegKH4CqTzzjsGCy2DAb1IaVt77+cUuilw19SqWHlga8DGX18Xvh39n9eHVusfQUiQ7vU7u+/k+HG4Hj3bVT3LqYd3RdVw55cqA8SSAw+Pgum+Dt+fLd5csM3S4HXy5+UvyXHl8f9P35R7jhYDSRA5dgb2qqu4HUBRlGjAUCGKw8P8DwsQGhEMiabQHnhg9DljcU9o7WpNCk5CHMDm+M/dp8nVKegcNgtdeq1xVw19/6T8+YkRk2oqGAy6XmEa//XbB6/ATNHod1xITpcStVSvxYKpfX0rvbDaRUns8BWRPZqaQSjt3yrZ/f8mOalDSaNsPh8vBXyeDvMkRwIdrPwxIAh3LOsZnGz7TNdFVVZW7O94d9jHViqlFn4Z9+GXfL5rPyffk81daCtBK8zmRKJOMFFLPpXLOEbjrzOWXXK67b724eliN1hKflYrK3D1zSzeAYGVSShUjBQJg1s5ZFXKeX/Zrfy8vGAT9vMOULQ75/m2AW31jjWsG3SbBmnv0y9lUL2x5AfZ/CV0nSja/CpV9VxqOByEVgqE0ZH8oGXhVhXmtIXNn4Mcdx2Hrv8THr7JJ6egGcN1G+PN+OLbQZ4tQ7LWf+0viyxo9hZCsO0gII1NsxLNlj13zIR//8R+OHg0c46xYAfffDxMnyn2yqifvKhUtHpdOw7lHApcAnlkHyweLabnRWn4CPVSCpec0WD9Gxhpofsw5AD+3gFbPwKW+FuhlvY6CEZPwP91JcdgPwzQJIJCYq7giuzwYvWA0cdY4bm9/e5n3PZRxiB6Te2gSQIBmp9+yYNr2abRMaskrfbUTthc6SkMC1QMKmykcAQJF7N0VRdkCpAFPq6q6vfgTFEV5AHgAIDk5ueyjrWjU7A3Hf5GAKxD2fiqTTajlYOFgnVs8Brs/CDwxZu+D+W2h7b+g6f0S/JanbracWZusvBi++u1uXYPb//u/yi9rCRb/RVh9WS6oKvz8Mzz4oJAvWgQMCLFz3XUweLCUbTVpIuVceXmiJrHbgwdKN90kqiKjUY6XlgY7dki3tRkzpMWuFn7Z/wsWgyWgqa2CQvva7elWr1spX3lRTNs2jXP5gQmGM7lnSM9LL+H4/8/l/8QdRB3Su0FvascU7/EbHF6vkGb5+aLA8nrlPTMa5X2OiYEnLn+C1YdXa3oD5bpy2X5iD3okUEWVTIYDi/YuCqiospls5+XFeuhYpyPLU5eX+H+6I50D6QeCt/bUUXwBVZMUKISUMylkOSum/azT42TVoVVhLYOscChGfTVQMKVQaRHy/bvY97LBSDi5AvZPCe5rlJUCS/tCnWslFqnRQ8ivsix8vG797qIXET4oCnSbDEv7a3+2O8dJsq7V06ERQeFQNFirQ+/ZcGa9qEEyd4E7lxJk0KlVshksYl6efLP4G8U0kv958nxxZ3TwIEP1gjtPv5MjYDG5WLtWGnTs3h1YZf799xKffPQRtG9fuhgnnHC7LxClriUerv4DFnWFvLTAc+PJFbKO6D4VEjqWj3QOQfkFiGdfl4/k/JueFsKx+NzlyYVt/4KUCdD4bmj6IETVBZSLPmpBcM9P9/DfXf+tsPPd8eMdxFnjGNpyaKn3yXXm0vrj1kFj93Dh1RWv0rR607B0B66KKM30FOiqLL4c3gg0UFU1W1GUgcCPQAnXRVVVPwc+B+jcuXMVXFIXQ6fxsLCTdoC0422oPxximlT+5NLhTYhvA+sfFR+j4gGGKwM2PgE73xHWv/Fdvlb2ltCN1IJgU2pHzEbtG3rLllBXv6FUhaBzZ+kQpkX2TJkCY8ZUHfXFvn1SdrV5s34ZW+/e8PjjQgA5nSU7q5Wls5TFUtRssUED2a68El5+GY4ckc5pgTBh7QTNrkax1lgmXDeBK5KvKP1gCiHJnsS438cF9BuymqxM2zaNh7s8XOT/J7NP6hoKGw1GXu4dWJqfkyOB586dsG0bbNoEx45Jx7uMDHncZBLSx897qKpsbrf8jIm7GudtLTHG7cNgAKMJjIYCsggg1+TRbNoB+iqvqoZZO2cF7MBmMVh0TaH9uLLhlaw6tKrEzd+gGPhl3y882PlB/QMoBv1GeFWVFPDh9d9eD/G4ZcPYlWOZf9v8Cj1nWKGYAB35aQUFkeVC548ARTvjXRzHFspmrQENRskW38qnEM6TYymK7+amyoLcYIXcg3BypXi8XETFIKkb9J0Hywdpf7Z/vQonfoUe34A5oXIW3IVRvTNcsw5Or4Zd78HRuaIGcRcjpb1OSJsvmx+WBOkwFdsC4lv7vpc2sSgwWgFFupF58kVtlL1XFEaZu4MOKykJ1qyBRx4RwsfpLKlO3rJFGn/06iWWA9dcU7LbbDjhchUQUt9/Lwm6CwJRteCaNbB8IGSmBC5JzUmFJb2h3mBo+yrEXSr31QivIUqg6X1Clm97HfZ8KP8rvk7LPwM735UtuhEkD4OaV0ojH/slQjJ6XTIPBlu/FSYm/0c7M07fPp2vNn+l+5zyGiXrWS6MnDmSbY9so2li06DHUVWVrl901UycgiQVTeUoj85x5mgqi26ffTs96/ekQbUGZT5uVYeiBpE3KIrSHXhVVdVrfH8/D6Cq6ps6+6QCnVVVPa31nM6dO6vr168vz5grFjv/A1tf1mkRb4deM6Fmr/LXy4ajHMxvRObKhl3/gR3vAKp+AJnQAS65USb0mEYyfrfv+SZ76SWf7hyZTGcGbtG4cMs1jPpwGhl5gVtsd+sGCxaIv0ll4o8/4Kqr0OzGlJgoi/7ExMrP7mzcKN0vsrJEZRII7dvDF19AixZSF19RGbCcnJJ1+KdyTlF/fP0SJnN+2M12Mp7LKNfkDbDmyBqu/vpqTaVEy6SW7HxUQ4JfCpw8CcuWicfA4sVw+rRkFb1eeb3hUIn5VUJ+v6UGDUTps2uX9j7jxsE//hH6uSMNh9tB9NhozWCgQ+0OQQOMzPxM9qfvD3iMRtUasf/x/fqD+CFG32vlxuMSCIeKcEjFAxhLxr4Zqxv8hBtmgxnnyxFkGSNdejOjmiQ/tDBkD8SGoUNYhD5vVBX++rcoQ8qr1LEkQrU2UgpusArR6cmDzD2y2A6mjgs2xrIg0p93OFCRYzz5m3R7c2Vrm9YbrND4TvF1tFQPrRSnOIJ9b/U+b3eOEEGHZsHJ5UIGKSZwV9z8BBQZ45498PTTsGSJEDFuDY7XaoX+/WHkSOjeHS65RD52h0PuwaWNlTyegnt/VJTsf+iQxAczZwo55fWG4etS0UbBqhdSPoPNz4DHqa/IimkiapvGd4ryzJ0rBHN5S1PL8510nIYDU4QMcpyStUgQFRkoQgTFtZAtvq2QlUYfMamYhdD0OoSYzDsBGdtECZe5G/JPlX2cpUUlGEPP2zOPm2fcrNmoJN4az67Ru8qligdYuHchw6cPD5gENCgGkuxJrL9/PfXj6+se56VfX+I/f/wnoIWDUTHSqU6ncnfy3X16t2Yi2YCB5GrJbHpwE9VslbxQLQcURdmgqmrnQI+VZsW1DmimKEoj4CgwCri12AlqAydUVVUVRemKmOWcCW3YVQSt/i6T29oHfYFYsQvPkyvMee0B0OVjea7RXjaDvHDWoJpjoO0rUh6W+p1MjDkHZdjFA430zbL95at3NNohtqm0n41tBokdwVbHpxaySPCheuXG4M2X135uG2TsEFm6BmrEncKjar8f+/eXTY0SKXTvLlmiRYsCE0Fnz0LXrnJzj4+vPEXQn38KWaVX+vXSS/D885VjZB3IiPGbrd/oLvL7NOhTbgIIxDhYL9tw8NxBdpzawaU1Li31Mfftg6++gq+/FqsJi0VINz+0zLXLC4+n6PH1Suv8OHtWAt6qXhY2ZfMU3c9n8/HNIR3/wLkD5DpzsVt0akoNJnRlVe4sIAwkUASw+/TuCiWAQAwgL+iSMKNdnwTKDBMJFCkoCrR7BRLawerb5f4dzOeoOJxnhWy4iKqHmr3h+gOw6R9w4KvAnjvefDFg3vu5+D41eQDq3wCWaqJMKO+CW0ORW2qYokWJ0WCk/J1zSMqFjv8K57ZIhzt3jiQTVRVVdYMnH0Wr610xqChgsKF4A7wnfliSivzZvDnMmSOJuk8/halTC4iawomy/HyYP182P2rUkP2bNRNlert20gXWapX7vskk91mnU/Y/fVoU2P5mGCkp4Y8HKg2KAZo/DJcMlQT4QZ8xbiAiOnsfbH1JNlM0xF8qhEriZVC9K8Q1F8NwrxvwFCgRMch5/J2Ns/bC2XKKAmxJsk5r9XdZjxyaKebR57aK2swTqLRQhdzDsh1fUr7zao6nasYQWlieulyXALKb7Xx949flJoAArm16LXe0u4MpW6aUOI9X9XIm9ww9JvVg/QPrqRUT+P37ctOuj0m4AAAgAElEQVSXjF8zXtPDM9YSy8K/LSQxqvwtAY9lH+Pbv74tcQ4vXo5lHePab67lt7t/w2IM3G34QkRQJRCAr8TrPaRF/GRVVd9QFOUhAFVVP1UUZTTwMOAG8oCnVFXVtQ6/YJRAfpzdCGsf8NVE62STa/SCJvdC/Rvlb4MlPPLBULI22QckY5M2V2q7FcVH5pRCZh4GeL0KyY8d4mj6JZrP+fFHMYeubIWNyyW+N0uWaCuCqlWDd9+FW26RIMEYJiuR0sDhgDZt9AmCcePg0UerVleMph80ZV964EFHm6N5/9r3Q24ZOeT7IZomwWaDmUe7Psr4a8brHsPvsTR2rMjIvd7gJVcJCUXNtTt1kmDSbpfvs8kkRJzXW5ChzMgQhc+GDVJOtnOn/B3oO3e+iiMAbrpJ1F7FS/yqGq6YdAWrj+h3kwgVHw/8uETJXxHMriPGq1roOx/qBu8mERQRUIY8tuAxPlz7oebTo0xR5QpMXF5XwOycH6Naj4pcd4xIqy5+uULKV7TQ7g249NnQu2ZGSglUGFn7JP44vabC7tslcFEJJIjEGM9uhM0vwKkVEpsFI2lMMVJaVa0tJHaG6l0keWeyy6Ja9fhUXopvsW0CVPF7Sd8i36MdY/XPUcbP2+US/519+ySxt29XBo6TezDnH8CsnqFmtTPUrXaMWvHHSIw+g9HgwWjwYFBU3F4jHq+Rc7mJHM+ozbH0Opw4l4RDrY7bmoylegsaNK9OkybQuLHEQMGScB6PqLtnzYJffhGiJipKSrX0/CnDBZtNkjMhk0OV3TI8/wzsmwy73wfnOfluaSnXAsEU61PYFCr/8+T7VDb5+kR9cZTlO+lxwtl1cGIFnFkLmTuErFQUMFhRVS+q143Bm49WCXYRKCZZzykmMUnxOOTv6IZyHSZ1h5p9hLQPBRX4ea89upZ+U/ppmihHmaK4pc0tTBoaermww+2g9cetOZB+IGDZldlgpn58fdbdv64EkbNk3xKun3a9LlE19YapDL90eEhjzMrPoskHTTiVG1jpFWWKYlDzQUy/aXrYOwZHEnpKoFKRQJHABUcCgVx0R+fChjEyMbpz0MxSKAZI6iE354QOUK2d1KWaonySSf+N2c+IG3w3bY9PQ+rTsprsMvHOrqk/ttJOjqpXiKyTK30T407IThV5o8Gv9nEHNv/Tgp/ocmVp7vPx8n/wzLfjNImVhg2lxCk+vvK7OLjdUmP+zTf6Le07dIB//lO8dlwuqTGPFDIz5X15/HGYPl1bBdSihfjTVBXfIhCVxxWTr9BcbFqNVvY9to96ccFb0+thyuYpjJ4/mmxX4Dcn3hrP6X+c1lQcbdoE994rmT09j6XYWLj+erjnHvGRKqu5dmEUlpTb7UIO/fqrKJD8svboaO3xdOgAy5dXfRLI+ro1YIv3cKL7Jd1Zfa/Oon9RdzizRvvxDm9By2dCn4AiQAp0ndiVdWnrAj7VbDAzZ9QckqKTAj6uhxxnDv2n9tds59ossRl7xuwp83FLhUgvuNc+BHs/03680Z3Q+UMwhzhxVwQJ5EfaAunW5EyvWDLIVqt0imU9XCSBgiNrH6R8Avu+8CXqHKUobSkEv9eT0eor//MU+O14nZQ6poOg38ncXPj9d+nCtXChdCW1WuUtjATRYjJJXOM/fvPmkkApLfLyYO1aWLVK7vV79oiHYWam/77tJT9fxeEoLSmsYrermM0KbreCwwHVq0NysqiJOncWH6JOncr1cgtQ2SRQ4eNn7pQ56OB0OLdZ4n6PI3RlWWmgGOGWEH3cVBXyjnH25J88N+9eDM50Hm0/irZxSZB3vOB6U71yPsUkSruoujIHWqtLia2ttpSRWcuvOtFEBX3eW09spefknrrNJpLjk9n16C6izOFZUGw7uY2uE7tqkjkWo4Vmic34494/iLXKffmvE3/RY1IPzbjebDBzdZOrmXtrKbvEBsHifYu54YcbNNcrdrOdMV3H8NZVb4XlfBWBiyRQuKGqkmHc8xEc+UnKDFw56Nca+GCOF4lkbHPJ5hitPnbZX4Pqu1k704WsyUrxyYR18AhQBjI9IBQgAajp26oDFsDs2/y/ewBXoc0JZAMnfdspAnpx5qWeoPPAmqSkaAcHHTpIQOFvT17ZWLcO7rgDDh/WJwXi42HYMHjoIfHhcbvlNUZFla/MLS9PJMdWq5AEv/0Gn38uvknBVCljx8Izz1S+oqowHp77MBM3TtRcaDaMb8iBJw6EfJ7j2cdp+F5DTd+hWEss026axsBmA4v83+US5dQ334jSSmtK7NwZXnihwGA7Li7kIQeE1ytlYUajmG1/+aWQQ4EQGwtnzlTtcrD96ftp8kGTiJ/HYrCQ/7KOEfCae2H/ZO3HG98Dl70feqvtMJMCwfy06sbW5ehTR8t9qlYftWLX6cDGUzaTje2PbKdxQuNyH18TkV5w7/5QSm20stZJPcSg1xJijX9FkkAgGe5d/5EmD163z4clzHGcMUoWQjV6QucPpMwjVFQ2wVIaVJUxql44uwGOzoPDM6RcpiIX3Bqkn9MJc+dK2/VlyyRGyckpacYcCElJQtzUr19QZmWxyFvudBZsaWlC0Bw7FvyYZf4oHKcl+ZmVAlm7IWMnjvQ0Ug/b2H+iIftPN+NERk0cTisOl83304rTZcFqycdmzsdmySfK7CDK4qBe4lEaJ+2mcZ006l+iYopPlmsltqkYEFfvElqHNyg9KbDrA0kmG8yynjD4NkuCqFWik8NrauzOgVOrxcT7zBo4u0mM5hUzbhQMigEDqo9Y0SBvFJOQlf7EnNctayB7PajWXkzUq7WTroeWwJ6jZcX+9P30nNyT49ny/baZbLx79bs80uWRsBw/ZFQACbTnzB4un3i5ZkddENXL6ntX06F2h3KfJxDeW/MeL/36kqb6yGq00q5WO1bctYKzeWfp8FkHTudq2gsTa4klZUyKZhlZeXDrrFuZvXO2rofp+9e+z32d7gvbOSOJUD2BLqI4FAVqXCGbJx9OLIcTS6UjQtYeCaA8zsDBpysDzqyTLVwIlQACiSHP+jYdI9ryIqphLZafVOnYUW7ugcyMN2+GSy+FH34QMiUmxLVYWZGdXfScXbpIpmnqVHjtNTh1KrAJcEaGLNS//FK+GsnJ0Lq1SJa7dpUSoeRkCXj87cK9XhEc+DtB5eWJjHrTJli/HrZvl+1EGf3CLZbKV1IVhtPj5Nu/vtUkgAyKgRtb3RiWc9WOqc0lcZdolp1lObOYsHZCERLI4YAhQ2D1am3VV5068MEHMHBgQfmfLYINIgyGAmXPmDHwmY6YIStLXkNVJoEmrJ1QIedxep2knEmhWXUNn5dqbYRw11pEZe8LX4ewMGLWzlkYDUbNHMNVja8K6fiDmg1iz5k9mp5NP2z7ged7PR/SOSoFsc0kyaJFAmXskHv1hQajBVo/D63+Iaa8KZ/6ujWFaMzrXzja60GzR6DhrWALokC+iMhAMQiBUL0LtHsV8s9KzJjxl5RypW+W0haDST43f4m/1xlY8XN+sW0EFFEIeRyigotrBdW7iQdkQgcpMyu2EM3OlhL4//s/+dvvXZcfYI2UkCDGy61bQ8eOooqpX1/uaw6H/FQU+emPVfwGyv7YyGqVx44cEUJo0yYpmV6yRPz5So2cQ77OeYvh9O+i4DfYfMlWGbwNaFkbWtbeWoYDB0AukLtDzmeM8nVPy4NbykDa5Z8Rr7KcVPHyzNgJCWZIDyKrigc2PUNB+Z8iv/v/Vj3ijWOKhqh6ENNYurTFNIXoBlD7qgIiprQwRUOdAbL54fXw1R9vMGHlK1xiMfN/fZ6ncVQMOE4W/W4aLLJZk2SOsdaQn7YaYK8fPvPzYth6Yit9v+rLOcc5VFSMipE8dx7PLH6GE9kneLXvqxdUmU95kO3MpsekHkEJoFf7vhqUAFJVSE8Xj6zCW3q6JFf95LDRKInp+HhIrv44Teyz2Z65OuC6IN+Tz/q09dz4w43sS9/HOYf2OKPN0Xw06KOwEkAAHw/6mIV7F2qSQLmuXB5b8BjJ8clc3eTqsJ67onFRCRRuuHPkJp2xXWqvz22BrP3gzsKrmHEjkjdUX8mXWtgszdfGVTH5JmSfGYjqksnTmiQZhoSOUoNarT0kdpKg8EKAqpKaCn36CKGiV2p1223w5pvivxPJMiuQgMblgn/9C95/P/BzVFVkxB99BD/9JGRLbq52B4pAMBgkuLFaZUL0mww6nWUj9fXKg7p2lXKiquIH9OOuH7njv3doSk7jrHH8OPJHrmx0ZVjO98ziZxj/x3hN0slqtJL29zQSoxJRVejbVxRfWt/F9u0l42m3V455udcrhJOetH7TJlHRVVU0fK8hBzMOVsi5nrj8CcZfq+H7dGQO/HE7uDRMGmw1YejB0LOlYVaG6JWCxVpimThkIiPbjCz3qRbtXcSImSPIzA/8vjRNbErKGG3j/3Ij0qqLrL2woIO+h9/ArXIvDQUVrQQKBHcOHP5RTE7PrpfXriiymPL64wxPgRmrYpTf3bmyAKvWVpRRDW4Oj+onEKqKykYPFTHG2rXLnt0JBAWIRQiAuEJbFNKaxYhYnXgR1XYWkFls0xJOnjgBNWvidkvM88orEqdo3ScTE2HUKLj7bmjbVuIavydeOOAvm7ZY4MABadYwdaqQRCWQexRSv4W9EyH3iHzPg5VOGqxCjMQ2kY5Xca3AEl/Qxl4xFSj1PflCamTuksRB1l7IPaRt2q53bbuyxFA7bYEkkfPSClR4nryyJSXOW0qUAcYoIWNu1l5olxZe1cuTi57ki41f4HA58OLFbrbz7bBvuaHlDSEfP1SsPLiSgd8NLNJgwagYz8eKdrOd29vdzseDPi53K/SwIMJKIFVVGbtyrKYSB6CGvQaPd3u8yPtw9qx4bG3fLonqv/6C1FSJUS0WIXpUtaASonBnPD/pazbLnKDaT+FoNwGPr9Q1Lk7M2WvXlp/16sEfJxaz8fhGFAK/H4qi0Cu5F0vvWKpP3HkcMg/kHJLrNP+Mr4OcW376lWoGi48oN4PBxJxje7jlj2/I97ohwBhUVMwGM6lPpIZkml0RuFgOVgWwLW0tw6b2Jpp8nux4O3e0HOT7Mjp9ZJC3IDgz2aUdqLV6QQ2qtYY22XOhMNe+71penpQsTZ6sTwQpClx7LTzwAAwYIJNLdHTogYW/3MZqFWJn4kSYPVuOX5rLweWSDl0LFoih9d69UvrlcmmbSZcXiiLqJH8L044dJQg6eVJ7n2nTYPDgqkEE9ZvSj2WpyzQft5lsZDyXETa3/d8O/saQ74doLmjtZjvjrhrH6K6jmT8fRozQJtSSk+VGFxNTueqq+vU1gl0fXn4ZXnyxanTYKw6v14vpNVNAI8BIIDkumYNPahBOGTtgUTdfFzANXL8fYhqFNogwkgInc06SPD5ZMyNlNVpDDkKyndkkjksM2BoVJCu49eGtNE1sWu5zBESkF9xeF/wQpd9Rq/WL0Oal0Ii/UD/vcJRzB0J1oD6QiJRymxA1mRtwAEeQfq+l8W7xkQIh4SIJVPpzVAFkZqhcf70kSbTimqQk8UW87z6Jqyoq5vDHjUW8D7MPwJaX4Mhs+VvLRsFgkc5sl9wgZr7RDcEcJ0SRqgrpU5r5wJ0r8btikufnn5YxnFgKR+dIExbUkiSQ1yUdrFI+gTN/+vw0swlsTqwIORXdUBQ7MY2FpI1pLC3OTTE+HyiTjF1RCkzBvU4hq3IOSlvzrN3i/5lzUMrhCt8HQyShHW4HN8+4mV8P/EquK7cIuRJliuL1fq/zVPenQjpHKJizaw6jZo0q4kUTZYpCQSHXXfDltpvtXNvkWqbdNA2zsZLk1VXEAyo3V6woFi2SEtBDh+R6y82NnLG631czPx/iOizm7+9u1HyuQTFwZ4c7qRldE3LT5FrKOSikbNYe+T3vOHhyhOxUjLLW9jgBr48wDfQeKueTJN9lGTjsxndNuYUUNsf6fKFqYLbV4ImB32AwVW1F8UUSqJKxIW0D/ab0I9OZiUExYDPZeKTLI7x91dvhkR6GK7MUSdSqVULHu3y5ZI5On9Zvdw4yOfTqBf36QbduIjVOSioITvzSYqNR5lCPp0BarKoyefk7Mq1ZI5PbkiVCrBRGeS6HzEwpG9u+HTZt9LJ+nZu9+xQyM40YjSoWkwuj0Xte8FX4FAqSwEFVcHsM5LtMoChUT/DQsqVKl8vNtG+v0Lq1dJ+y2aR71ciR2gSa0QhTpsDQoRVfUlcYJ7JP0OC9BpoLWIArG17Jr3f+GrZzujwu4t6K02wjCdC8enN2j95N27b6xpLffAM331z5/lR9+4pXlhY6dpTHI62YKw/m7p7LkGlDKux8Cgrul90YArF27jyYEatPCnR8B1o8UXZpfGGEkQT6ZN0nPP3L00UC1cK4JO4SDj95OOTTtf64NTtO7Qj4mNVo5eXeL/Ni7xdDPk8RVMSCe3ZdcOiYi1RrBwN+D80HKtTP+7bQdq8wVAT5cZEEqhI4SwJdGp/l6NHAJV8g5dHTpkl2P5Ll0UHhzoP1j0orc69bWz1Tqz+0eAxqDxCCxBQTemfAQPBbQagqHJoOTe+X/7syYc8nsPNtOb9W6aatFtS7HurfIN2GUeQ1KSafcqecY/bk+4gxVY6TvR+O/izbgJXlOyZwJvcMV319FbtO7zofdxkVI17Vez75YzfbuaPdHUwYOEFKmysQkzdNZvT80SUIoFFtRnF/p/vpP7V/ice61uvKvFvnEW2phExqKeeHG4aqGI1y/fk9tqxWUdIkJxds9euX/vr0Vzx8+KEQP2azrM0C2XcUh8EgDX4aNpT1ln88ilJQ8eBwiMfqvn2lq6LQnGodp+DYIlHQnfhVPHSN1tJ5ppnjpeTQZC/wz/ITRF6XVN64MiHncHAFoTEKRlZSt84y4KInUCVi9eHVXPP1NeedzRUUcl25fLLuE3KcOXw08KPQiaAyFUkHQCUxz337ymTw44/w6qvye35+YJNBt1vKcpYVEpVERQkx0rRpgQmzzVZQe+7fUlOFoMnSEQCUGV4XnNsGZ/4k7uQKemTspEfiUeidDn2l3ln1esnIsnA6sxqnsmpwOiuJfJcVt9eE12s43yLVbs2lRuwpasSdokZ8BvYorxBDnnxhq61JcOIScHaAmr0YMvhvzJihMGJE4AydxwN/+5uQQJ9+Ktm5iiQIXC65eXyz9RtdWa3dbOfmS28O67nNRjO9knuxeP9izeccyTzCtpPb2Lu3je6xrr228gkgEG8pPRJo8+bS3aQrAxM3TqzQ86mo/LznZ4a2HFryQVOUZHyd6doHOPozNLlfSgGqACZtmqRJAAEMaDxA87GyYFCzQew+vVuzRn/y5snhJ4EqAnWvg/1fommcfG6rzxskBBLIVgscVTwJcxFVB7VqVfmk3bO2D3QJoJtvlg6WdnuFDqskcg7Br1dLmYeW8qdGL+g8QRSepmhf1i2CmXujpUC13/hu+XlyFay8UdRDWgvLeoOh9cvSYtzrDr1BQYlx+brG+RHfSnzTmj1U7kPuO7uPPl/14WTOyfNKUpPBRONqjUnLTjtfepXrymXq1qkcOHeA2SNnYzdXzBfnzVVv8tqK14qQPGaDmdY1WvPZ4M8wG81MGDiBMQvGnO8GlefO48+jf9Jjcg+W3bmsRLvycCE1FVauFM+r3btl/XP0KGymFrXRnx+OU4uffgr8mMEg6yGTSdYCeXlyndauDQ0aiDn7228XVe2pqlRDPP20WHXk+kRxWonm5s3F67R1a2mY0rq1lHA5nQXkjqIULC1VtWD56PfUPH5cfL78HqjbtonyXnOZ6cmHQzNg57vSpc5gLapm8xaarKzV5bqPayVd3GKbCvFjqwkYfCStTtCsGH1G/Plyb/er57JSxOLl1Gq5jj06pSwXCC4qgSKI5anLGfzd4CK1l8VrUEdcOoJJQyf9T9eglhYbNkid94wZotrxeLSDkHDDz6ZrEkWqCukb4fBPcOS/Ijc0WH3ywtJMBD5/BoPFxz4bfVkrn9+TRilGCZhiYIQMcvVqqcM/e1a7pMlqhVtugaeeErLM34o83PB6C9Rc338PDzyg0viDxqSeS9XcJ8oUxfZHttMoIcTym2KYuGEiTy56UrPm2WQw8VDnh5gy8kNdYjA1VW6alY3Zs0Uxl6lhZQOSkR1ZfluYiCHuzTjdFqSRwODmg/n5lp8DP7h8MKTN095ZMcHNGZIlKi9m1w6dFLhVLVW3u0nXT+Lm1qETqYv3LeamGTdpllFGmaLY/NBmmldvHvK5zqMiVBdH58Pvt4Bb5+Lp+C40exRMEZQz6KmFLiqBwneOUPG/MkYo9zgPHpTkmtYC0G6X8uSE8DRrKj9c2TCnCTjPaKs7L30e2rwYeoeuULB3Imx4XDtOtFaHrl+IwXJljrOMWHNkDdd+cy2Z+ZnnFT8KCrWia7Hl4S3sPLWT6769rggBYzPZaJrYlKV3LJUynghBVVWeXPQkEzdOLNHqu2Z0TbY9vI0a0TXO/+/ReY/y1ZavijzXYrRQN7Yuq+5eRb24eiGP6eRJmD9fFDbLl0vMbjIFbjZTGGazECzJyXLNmc0F3jperyRd3W65Xo8elbKtc0Esngqf76+/4N57YccO/S7IzZvD7bfDXXeJV6vHEx57Dr/fl18x9N13UsmwcaNvnJ582PYG7HlfiJuACjoFki6HBqOkzNNWW0hhv9onXPCr6YxRkJ0CqdOg/WvhO36EcLEcrBKwMGUhw2cMLzKpRJmiUBSlyP/sZjuDmw3m2+HfYgqlBCEUVBESqDB27RKF0MyZwhZDwYRZmnakejAYZPLyemXybNZMVDPDhkGnTsWenJsGu8bDgSlyE/fkC3ETCKZoiGvpq+FuBNVaQ2wLqeW2JiHFX55Ctai+Lg6KUYKYvBPSFSJjhzDd2QdEspu1uyhJVKh+2+WSzlWvvCLvS/HytsJIThYPnOHD5TXHxQnj738/Sut741dY+W9Ehw5Jid3XX4sptccDG9I20vvL3rrmc6G2ttbCoYxDtJjQQrckLM4ax5Bt6UyfbtCsb37oIXjnncotqQMhf2rUkCyLFq6/Xt7/SLWtLw+y8rOIe0t/QFqmf8Gg5zEUY4kh63kN4mn/FFg/Wr+LUq/ZIsePpGw9WAnRrSofrf2Ifyz5R4kg1g+L0cLhJw+HJZjOceaQMC5B0xfIarTyQq8X+Geff4Z8rvOoiAW3Ow9mJhTNEhaHrRZcf0CUYpHCRRLowiBYgpXWByhrr3BEOF5btEgSChkaPlWXXy7Pia9sseSGp2Dvp9rkSvLN0G2yJM4qC5kpsKC99hiNdhiyR4igcLZvjzBm7ZjF7f+9vQjBA5KYWHv/WlomtQRg6papPDT3oRJKnOr26iy/czktklqEfWxur5vb/3s7c3bPKXHvtJvt/HHvH7Sr1a7EPn2+6sOGtA1Fki4mg4kEWwIr715ZrrG63dJI5q23hGzxl1cFQu3a0jTn8suhRQspq6pTR2K6vLySChtFKbjE/UobRRGVjaqKoufwYfEs3bJFVEcbN0p87t/v008lQexwaE8XnTtLeVi7dqLiibT3pMslZNDhw9Cq1iZYORwcx7WvobqD4PKJsv7yd+WrKLgdkU0ehQkXSaAKxo+7fuTWWbeWYMBvaHEDD3V+qAQ7bjfb6d+oP7NGzKocM7IqSAIVP+2hQ9IFacMGWLPOyR87D0J2DVRHPA6Hcr6laHH5YX6+TLzVqslCuk4dmcy6dBEvlSZNNMiP7P3w17+kpttvshcIcS2g/jCof5O0VvVLko1RoXVt8zhkUwwyqZ1eI1LIw7NhWMkg9PRp+PxzeO89mdCzs4N/XDEx0r61VSvp6HHZZXIjslhkM5uFKHM6ZcvJEdnmxo1CzO3cKRN1oPM8MOdBvtj0hWbbaQWFBy97kE8Gf1KedycokscnczhT2ysl1hLLe91nM3rgVZoZT7MZfvlFviuVbbLdqZN8/7Xgb6dbp07FjSkYluxfwpDvh2iScT3r9+SapteU69jvrXmPM3lnAj5mMpjIfC6TKHOARX3eCfgpWb9uPPEyuGpFZLOypSCBOn3WiU3HtT/0+nH1OfTkobANqe0nbdl2Utskq1G1Rux/fH/YzldhpMDi3nAqiOdFt8nQ8DZRakYCep93pIyhw4lwkB8XAAk0e+ds7v7pbvJcebi8rvPKbb9qe8LACZXjE1IYEY7X1qyRRhxai9XkZLn3V3op2Ix47U6PEB6T/1Cx7hFI+YzAps/Apc9Bm39GloAOI1RV5d3V7/LK8ldKEEBRpijm3zafvg37Fvn/S7++xPg144sQMgoKsZZY5t46l14NeoVtfHmuPIZOG8qqQ6sCju/rG79m+KXDA+6bnpdO20/akpaVViTJpKAQZ41jyR1L6Fw34Dq6BFQVPvlEmnY4nYGvJUURwmfkSCmvrF5dnhuJRiQOhxzbbJYOX/36Sffl11/XNn2326Vpzg03FNhsVCiy9gmBqtXd02iHnjOgVp8LSkFXGbhIAlUgvt/2Pff+dG+RCcigGGia2JTND24myhzF27+/zb9X/LuISsJuttOjfg/m3jIXq6mC2/xUcRKoMDYf38x131zH8ZzjKCj0btCb72+YjZqbeF4WqaoFKpXExGIdJEqDvV+IfNffua04FAM0vg9aPQn2ZPm7IrI4rhxRJ+icy+sVxn/SJFi4UG4+BoO+zDPcMFrziXolqUgrzuKIs8bxw00/cG3TayMyhjHzx/Dx+o81SSiAqxtfzQjnIsaM0Za+m80iTb3++solgsaNE7WXXnnkgw/Cu+9WvnLJj8cXPs6EtRMCfgZx1jim3DCl3K1j7/3pXiZvnhzwsThrHDNvnsmAJhp+OT83l9puPVy9RuTFkUIQEujYkDQavd9I11T93o738sX1X4RtSM8teY53V78b0BcIJIje+ODG81nekFFRpEDKJ7DxaS5YlWUAACAASURBVH2Tx+hGMGh75BZjpSD9yo0L5f5dhUmgDEcG9/98P/NS5p1frCooGBTD+evBZrKRYEtg5oiZ9Kjfo1LGKQOL7Oft9YrHx65d2s+ZOhVuuqkcsVU48YNdvxR/2HFR+YWKcJT3aqHDOGj5ZHjUCyGN0wC36kvsPV4PD897mG//+jagwuaj6z7iro53ldhPVVVGzBzBvD3zShAzdpOdSUMnMarNqHKOuwCHMg7R+qPW5/1Xi8NitGALotrweD266vVx/cfxj57/0D3G0aOiuN+yRTvu7txZGo/UrSsEi7mCc//z5qHpKQqi8lu2TJLElXaNL7oczq7X9u65/AtocOsFQ6BWJi6SQBWELzd9yaPzHw0okdz80GYaJzQGZFK8/vvrWbJ/CY5CZnZRpiguq3sZi/62qMKM04ALJoj8ctOXjJ4/mlx3QQtKi9FCgi2B+bfNp1Od4rVcZYSqwpp7RP2jtWCwJ0OvmWI4Fm7jvgjgwAEp0ZozB9auFYmo3S4feThK6+x2uYE5HEK6NW0KPQcf4FNLM13D8xhLDGlPpRWoNbxuaWfqOC5tHR3H5GdOqq/VY5q0YPWbZaseipbWSUtHae1o5Pc86HvgXKHvdtGfKlA/7hIOPJHKjBlS56x1QwTpTPfFF6K0KUvpXChwuWSz20VK3L27PpnnN9urdJm+D43eb6TpCWUz2tj72N5y19p/tfkrRs8fHTBgMygGHu3yKB9c90HgnTe/IOaCWmWdIB1kes2SdqCRQBBS4MMmH/DskmdL3Ev8iLXE8uXQLzWzmuXB0v1LGTZ9mKYvkMVo4fmez/Nq31fDc8KKIgVyDsHPLcQMUg89f4B6Q4uap4YLF0mgKksCLd2/lFGzRpGVn3WedDUbzNSOrk2/xv2YsWNGibL+R7o8whv93qj4hB1UyOf9++9w9dXa98SoKPFu7NOnEpMOywdLhyCtbmBtXhKlTagqgXB0e9SCPVnI53DEkqGOU2cOOpl9ku6TunMo4xDuYu+3STHRsXZHXUWP2+vmh+0/cCrnFN5iqiijYmRI8yHMGjErcFfPUmDria10/ryzZjlzOPHE5U8w/trxAR9zOqXSYO9e7dj6nXfgkUcqSV2DkLwtWsgYtfDdd2KPEenSL11Ms+mXcQ8/LWWUFxEUF0mgCsBHaz/imcXPBJQgzrh5BoOaDyry/6z8LNp80obDGYeLSA9tJhtta7Zl6R1LibVWUEunKh5E5rvzeXDug0WCMYNiKKIwiDJF8cF1H3Bfp/vKf6LDs2H1HeDRWGnHtYBr1lZ83WkYkZ8PKSki596wxcHPa7azM/UcCZ4WRLnrkJVpJC9PbhT+GmNFEYInNlaM6apXl+qAevU437r+0kul3M7/Vcpz5Wn7triyMKdvwZyxGU6ugLMbpOWj0ep7XxXxQPI4CCijNsf5zLVNsoEEgqpbyCR3FqheHN5iexujClp/e92YVAeWYcfAVov164UISk3VJ1r69hWvoMGDRXUWEyN10uGCy1VQ//3dd1KzvW2bfBbVq0O6TmMrEPnxc89VvlT/WNYxXSVLvDWec88FcS/UwfaT2+k2qZum2qxBfANSn0gNvPOpP2DZNUU7SwTCkD3SPSUSCBKwd8hsz5YTWzQftxgtHHnySBFzy1CR68ql2lvVdANp3fe1rKhIUmBOM8jWiXpBfNuG7I1MZ7iLJFCVI4HyXHk8uehJpm6ZWiRusxqtNE1syoq7VlDdXp03Vr7B2JVji3o5muzUia3D7JGzS/iLRBwV9HkvWCBlKlr3Q0WBhx+WkhKLpeKVso4zh7AtaaWdsDNYoM9cSOoeGskSDhLIGK0dVyZ1k7IWS2JoDQkiRAJtO7GNyyZehtMTpPV2iGiS0IRtj2wLqtYpjuWpy+k/tb+u6jvcGNl6JNNumlbi/+PGwb//rU2eDh0K335buarydeukHEyr3LNePVkjVKrKD2BeO8jYhmZnz54zpKNeqFUYISv9gqvoKhsXSaAIw18jG0gi+fjljzO2/9iA++08tZMuE7uUyGbbjDaaJzVnxV0rqGarFrFxn0cVDiIPZRzium+v40D6gfOBmkExkGhLJMeVU8JbaXir4Xw+5PMy30gA+G99yDui/fhVv0FSj8gaxlYAXB4XH6//mH8u+ydOjxOH24HVaMVkMPFS75d4otsT5Xv/9JCZAqnfwcHvIOeAEDIeR0lvFoNVWqRW6wD2S8Rk214fomqDtYYQQKoH8LFU528Q/n6UBiF6XFmQfwbyjkHuETln7mE49xekbyqoMy4U+Hi9ItF94gkhY7RukiBB79VXizqnc2chwmrXFkWU11ugkNJCYXNts1k8r7ZtE8+r5cslE1vY9A+kM8O33+pfhna7tBqtXVv7OeFGdnbJbPCUzVMYPX+0pjS7b8O+LLtzWbnP6fF6iB4brUkyWY1W9j22L7DSyOuBmfHateZ+1OwLfedGpt5cJ2A/6oYmh6y6pWDJ8ckcfOJg2IfV7pN2/HXyL83Ho0xRrH9gPZfWuDT0k1UkKXDgW1j3kL4hOIi/W/ep4f/ML5JAVYoEWnd0HcOnD+d07ukiMUSUKYrL6lzGgr8tIMZSMKl9sfELHlvwWJHnKijYTDZe6v0Sz17xLMaKigsq8PP+6y+48UZRmGqRQXY7PPAAjBlTcN+JVBIiP1/uzVlZ4oH4ygOLxTjWnUNg3x0FWr8ArZ8HDOUrHQlHOVj7N2Hbv3UMom3Qfiw0fVASWZZydHgIdZwB5qC5u+dy/bTrdRsxhBPx1nh2PLKDunF1S/X8Lce30H1Sd03FLEhivTwNKPI9+bqeli/1eol/XfmvIor3W2+V7rhaeP99eOyxMg8lrFi4ULoKaxm/d+smBHC1Clh66uLcdljURfuaMVeDfosg7tLKJ3lDuX9XAC6SQBHE4O8Gs3DvwhI+CgYMJNmTGNBkgO4EdDDjIKsPrw64f6w1lnX3r6NZ9Qhlo/2ookGkv21xjjPn/PujoFAjugbr71/P9lPbGfbDsBJBXINqDVh420IaVCtjf++Kkh9WEvOsqiqzd87msYWPkeHICFhKE22Oxm62M/6a8dzS9hYMSgh6VVUVddWWF4SAUb0l31/FCLX6QZ3roN4gMXJ05wqRY4ySEq9wQPX6SCeXBIJ5xyBtETR7oMRTnU7pTPfuu7B1q0h2tTyDCsNkEqPxSy8VuW1cnATDUVEiq3U4JEOUmwtnzhSYax86pH9p+R/780/J4OiVrQH07y8dKSoi2+RySWapRzGLjKHThjJn95yA+5gUEy/3eTnkTlMdPu2gqZaJscTw4XUfcleHuwLvvH4M7P1c3yAaoNtXkDwi/HXnOoHH++nw/Lko3cD2gU4P8NmQz8I7JuCFpS/wzu/vlJD8+2ExWnj2imf595X/Dv1kFUkKeN3w33qQfzL4c7t8Bo3+FlpWvjgukkBVggRyeVz8c9k/ef/P90v6k5jtDGg8gOk3T8cSoKnDj7t+5LZZt5HrLjoBR5ujaZbYjJkjZtIksUlExw9U+Oft9cK0afD3vwvhr5ccadxY1A4jR0oH0tjYgvtVsMRIYbjdsp+qyv3T4ZDS9lmz4L//lYQJ+F5i1j5Yfp3c07VIXksCtPw7NHtQFEIGW2iNO4qjNNf32U2w6Wk4vVrmo0BzrMEKda+FRrdLXGQwy4s02SVWivQYC2FF6gr6Te2nS4REW6LLTLB4VI9mx0uABFsC2x7ZRt1YfSJo5cGVDPxuoKYaOMoUxYLbFtCnYZ8yjc+PPFcel31+GSlnU3B7S35WdrOd29vdzseDPj4fJ3/2mVwnWoRpr15CwlSmUnvrVkleasWRSUlw8GDlq8kBOLEcVo2QpK5WOXejO+AyX+m/Obbsa4ZwkLwXSaCy40IngbxeL90ndWdt2tqInsdkMLHpgU20qdUmciepYkGkV/Xy2orXGPf7uBKZt8SoRNbev/a8v1KgTmxGxYjdbGfGzTPK1n1owWWiEtHKenSfIgvCUOWHlcA8rz68mofnPcy+s/uKGpKb7IxsM5Lp26eT5847f8OPNkdTL64enwz6hH6N+pV9fLlHYflAyN4XWHGhGKDBKOjwtkzcxuiKV1h5vUGLsg8flqDzxx+la4rJJNlIvXbt4YLfu6lw0B2sS5gfn34Kf/tb5ImgjAwpCTxSSEDnVb3EvxWvGZzFWeOYftP0cncG8+OxBY8xYe0EzSzl4OaD+fmWnwPvnHtESoSC+cSYYmDwToiqGz5CEnTngHYH4S+d71esJZavbviKYa2GhW88Pvx64Fdu/OFGTV8gCGNXsoomBfZ8BJufDa4AM1ig/zJI6BA+IugiCVTpJNCc3XMYMWOEpsLOqBgDkj+F4VW9ugq9Ua1H8e2wb8vtbVIqVNLn7XLJvfCDD4T4N5uDN5yw28UnsFkzaN4cOnQQoshvhmuxyMtxOgtaQ/s7we7ZI2UpKSmQqTEdnX+JXo90T938D3Cm6yj+FOn+eMlQaSEf01gSAV6XEC5lTTypHklazQii3Cl8fWfuge1vweHpQuy4stHsHhbXEqpfLsmxuFYQ21SU0ZYESah53WjGq4pBXo/XKf6KPzct9Ri/2fIND8x9QDMREW2OZsaIGTSIL2Oi1YcFKQt48dcXA15LRsVIQlQCy+5cRpuagdc9c3bNYdSsUZrjs5vtvH3V2zza9dFyjc+PI5lHaPdJO9Idgevw7WY71zS5hmk3TcNitOD1Qu/eouh2aIQWDz4I//lPQQfeykCXLqC3/H7vPbj//ipCBLkyYeMzkDoVMAQu/zRYofZVQp7WuUaSyCrh822N5P27AnCRBAozvF4v7T9tz7ZT2u10wwmjYuSP+/6gS90ukTlBFQoizznOcfP0m1l9ZHWJbEE1azXW3LeGFkktivx/2rZp3PPTPQH9mJ7u8TSv9n21dIqW9M3wSw9t+aElAQb8DtHJoZULVCAJlHImhccWPsZvqb8VyWDaTDZqRddi7q1zaVOzDSlnUhjy/RAOZRwqUWLXpW4XPhr4Ea1rti7d2Nw5ML+9mDoH7DSkQJ+foOaVF4S5th8ejwSnS5dKm81t24QkMpnkZu7xSDBbFoLIHwwrigTARiM0aiTmgj17iqqnRaGv+7x5IuXVy8aCBBibN0vAHSlzv5wcyfjOm1d0atiQtoG+U/pqkkAWg4W0v6dR3R6aqu6HbT9w/8/3k+UM7O0TbY4m47kM7TKNVSPh8CyN72ghJHSAAavCWyKkMQcccUHTg5Cvc3lbjBbSngr9/QuEPFce1d6qhlNHIWU321l739rSzwdaqGhSwOOQrJ+rFP3YDVboMwdqXBGez/0iCVSqcS7+RRXhg6lgXjWZZJ6sU0d80Ur7cv1we90MnTaU+SnzyznwsiHOGseKO1fQoU6HyJygCnzep05JYmT2bLkXulySTwl2XwoX7HY5X1bxqd/rgaM/wZ6P4dRKuY71vN8UA0TVE3Ilpon4PlZrK7+b7KCYZUGpmKSRgNcthJErE7L2QPpWyE6BA1/rDzjQ9e11wcmVkLYAjv4sJesGm8Sfek0LQMijqHpgTfT5I5p9qiGPHNfrkgRHzuHg3neFxqiqKv9e8e8SCdjCsJvsLL5jccgd8l777TXGrRqn2Y0r2hzNT6N+on/j/kX+P3nTZEbPH605vihTFKPajGLy0MDdQ8uKNUfW0G9KP933o3Pdzsy/bT7Rlmiys+HRR2HmTG21zSWXSDnjlVcWeEtWFNxuaRIzYID2+MxmGX///pXrX1QEznOw70vYPV6sHvCp+wMhthnU7CPXcmwLiGkAtjpyL/fkFYv5Cs+nha5Tg1nmD9c5mBXEe/EiCVR2XKgkkFf10u2LbqxLW6f5HIvRgslvQFtaqJSQGReGUTGSMiaFRgmNynbc0qCUQcXMGSoGQ4GPiX9LSICGDUX6Gwq2ntjKdd9cx+m80yVM6OIscay6ZxVta7UNuK/WjcFutnN5vcuZNWIWCVEJwQexfwqse0THbNAMbV+DFmN8k0Q5qPwKkB+ezj3NC0tf4OutX+PyuIqUG9rNdoa1GsZngz8r0oUu353PU4ue4qstXxUh4AyKAavRyvBWw3l7wNvUia2jP7bjS+C3YdrBR0InGLAyvOUW5UXt2nCi/J+FF4XD1Gc3LThJTU6TxElqcpR6HKM2+dhwY8KLASMejHiIIZs6HKMeR6nBKZI4TR2O0ZJd1ORkSXH1iRNQsyYgcX3jxmJgHQxJSeItlJwsi6hwIjdXDLK/9sW+hW8jr614jddXvq5pJFkzuiYnng695e7+9P20/aStprQ81hLLr3f+Sue6Ae99wWvOC6NWf+jzoyiDwgENUuD/0uG506C3BGhYrSEHHj8Q/Bxet3TUc5wE5xnwOCX4Ud0FP/0eWorRZ7RupMOsR9lyJkXzsEbFyLNXPMsb/d8IPgY9VIYyZPtY2PaGfrt4PxQTXPG9lKqaI9xh6H+IBDp+XNqLp6XJlpoqPmVfL65Nkkf7uj+h1KJF3PGAj3m9Qq673eJV4W9M0KiRbHXrynbllUWN+lPPpdL7y94czjyseV6byRZUAVRiPKqXHGeOpgpRQeH74d8zss3IMh23VKhin7eqSqnWypXw229S4pyaKkSRX+3gcnvJy1VQ1dIzeP7yMbdbVBWJidCggSRFevWS7VI9azJnBqTNF4XQ6dWiEDLYfHFJBa97SnN9O9OFFMrcDZk7IStFOqM6TgAKGK3ykXryUIKRRIWgooDRjuLJRfN122rhGnqYu3+6m//u+q/mPTXKFMWkoZO4pc0tpT6/5rhUlTt+vIPZO2Zrrn2iTFF8NPAj7u54NwBjV47l9d9e1yRkzAYz7Wu1Z/W9qzEbwyez+XKzrzOxxvtiM9loXr05y+5cRmJUIgC//ALPPCNduPLzA3cLq11byif/9je47DKZ40wmKYEMl5jQ6RQ7A6tVQsm5c4Wk+uEHuPtubasDgwFefBGefbZAtVeR8Hh0mq5k7oGj8yBtHpxeI3Oiqvru6zrXmsEiXqP2+oVIXrPEP6q7gEB1ZULuISkxDZYkhIskUHlwIZJAHq+H22bfxk+7f8LhLslAmg1mOtXpxP2d7i/X8fee3ct//vhPwO4sCgrV7dVZfc/qkDyC3G4p3UhNlbrPAwfgibdqUy1ff1F2QqlF81gJ0IrHIF6vTCQWi2TrGjaEli1F/tuwody427bVn9QemPMAEzdNLPfrCgaDYuC7Yd+VLihL3wIrBgvzrCUrjm8tJn6NbvfJbm0ywYQL5Vw0nM09y80zbmZZqpjuFg9SFRQuibuEeJt2B5ys/CwOZx4OWAuuoNDtkm7MGjFLmwzK3g/z2movtCwJMCRFfoZaYhMSoWaA2yquo0RIKDRPT50qN/HSZF2rVZPgvGnT8BFBublw552SKQowPDp+1pHNxzdr7j+w2UDm3Tov5HGoqkrsm7GamUSL0cJLvV7i5T4vax9kyZVwcnnpTlijJ/RdENF2vkty4J10oM7Vmrve2eFObr10OGTsEKPz3MMFW94xIX6c6VKmYLT45qUA2a5CnuqFH/85y8mEs/nio4UiZIjBLMcx2sBo46HeY7kx1IVAZZBArkzxBgpmEH0eSkGraYOpfHO8OxemByGRLlASyOOBjRth1SpYvFgyzNnZMtd4vbJ4d2msV+12IXKSkiR28Kt/FEXiFJdLfp45I2SSVkmQXylkNMK5c/6XqjJ502QeX/g4ea68Em2pQczjX+nzSrnLUk/lnOK+OfdxPOe4pmfIgMYDmDx08vmFYVhQxUggLXg8cPSoyv/N/5H3F87BdK4V1yffQbypNg6HLIz9jRRstqJbXJz46zVuLFv9+mEonXGchNN/wKlVPgXPfnAcA09+QRmYJz94iXBhGO0yN+qpC221YFhgcrM4AsXnO3aonDpyBqMjlQTLQZrWTqVxrf3YzHlYTflYTfmYjU7MJicerwmXx4LTbcHptpLvtnAqsyZ70ppwNKMhDkMDLAn1adrcUiQ+b9Qii0HfD2RD2gbdEqtnr3g2ZC+/wnB5XFw55UrWp63XLLO0m+08cfkTqKi8uepN3ePVjK7Jtoe3Be2a6fEIWX3okMwv/rnG5ZLN4ylQIvrViJPSRrP4zJfkewPHtQbFQHJcMpsf2lwkvt60Sfwlf/pJ5qi8vMBzotEIHTsKGdSokZCdfoI7IUGuF7c78GXt7+IbFSWkz4kTolJPSSkoq1y1Ck6fluf7j+HvAOhyaSvY69WDsWPleW536Mn+YMjOlvdi6VLpwhsUqhcytgsZlL1fSNTsA5B3FJxnwWBBNVhQvaIcMuim2IrCq1jBYEXxZKHoEKilvb4rCxdJoDDA5XFx0/SbWHJgSUA22KAYaF69OZse3BRSZ6Xxf4zn5WUvB1zYKChUs1Vj5d0rSy3F93qlLGTJEpHvbthQMKm53ZxvBx4JWK0FpShaTvTZzmw6fdaJlLPamedw4p4O9zBp6KTgT/S64dB0MTXOP6utalGMUrNdd6B0loltIpJkb76PHLIXtCUvDTxOUSbMDGLNX2zR4HQ7eWjeQ3y1+asK6+QwsvVIvrrhq8Df99Rp8Oc9ElQFqnePvxQu/1J+Vqaz/1O1QlICVQhq1ZKIxQenU8jWs2dLt3tsLPz6qxCzociO/YHCLbfAz8Wsdvy3kaz8LJLeSdJUAVmMFt7o9wZP93i6/AMphO6TurPmyBrNx9vVaseWh7RbrXNyJSy7Trt9b3FU7/r/2nvvOKnK8+//fU/bmdkGS+9iQ4TYxRqsRMUWNWqsUWM0iS0aTUz85Rs1j4lGTeJPH0s0RpNYiF9FwZJAFMFOU5oI0llgKwssW6bezx/XOTuzyzmzbZaZDff79TrM7Mxw5ppT7vK5rwInzbDEkG7E2XVG5NVacmtVzZHQga3zJOeWNwRoiDcBaatVyivlzoMDZYDS8jikTfiATwZQ9gpYollyJTVXibAaqYIm67FtHp1srHzlKkfMqmdgwU86fs5BVg+PeEzyDng6uExrryquegoW3pb5s71IBEomRVh+6qnUxCYalUlKW4YMgaOOkm3//cUrcfBgCevy+UQEiMd3/Rm2qUrJoQ4G5bWtW6UpLC+Xic28eZKrzfaM1Boqd1Zy2WuX8Un5J64r94X+QqZePJVJ+0zq1rHY1ryNk58/meU1yx0XBgPeAEWBIl48/8Vu50BroYPn+5E/ied2elid3w+lpRKOMnx418LrOkpjrJGr37iaN1e+SXOsmSRJQr4Q9596PzdNuKlVVaUu001PXgCCQH9ggPVYAgQAf9rmQ9wzo0DceowBdUANUA3U4uzCmebJ25Z8GJ9rbzOD7vkGq7eudh07Bn1Bzh97Pv847x8Zz1siIT+3vBw2bZKQ8XSBxRYx0q/HqGc7/7PpUGpi6x3FWpvjhh+XsWqYz+Pjrm/exbiB40gkYMUKEdI2bBAxbcUKWLNGBOW6OhGebe+W9Eqs9mYLK2AXno3TfNwviBetR2s5dqEQFBVCcQkUhqG0qIDp1/6VYGDXMX88LqGTM2dKCP3SpSmxvLEx83n2eEQM6tOndRRGIpE6rs3NcszbWxwMBlt7/1RVwW23SWhnc7N7N1FSIl5L114r7XlzsxyXwsIMHjvtkEzKNZJIyLFctgyefloSwFdXd7zLcjvfa9ckie+spMS7gdGDNjB64Ab6FVVR4IsQsDdvFK8nTjzpJxovsMTTAiLxIBXbh7C2ciQbakbSwEjCfcvYZx/FAQeIeDpypBRr6ak2NFsYEaibROIRznn5HD7c8KHroKIkUMLiHy3ufEWqNmitOX/K+fxr9b8cBxUKRUlBCbO+N4tDhxzqsg+YPRueeQamTZO/7aR7ToTDckHbqwJ2haO995ZGx16h83rlpk0kpNGJRKSxX7ky5QK8fr08Vla2voGdLrPyHeUc8NgBriv5IIOozlaoiifjjitzNocPOZyPrvmIAl8HJnE6CVtmwOq/iOuhx585kR/IhKtotCQdLNwb+oyXmHNfIahAKvxCx60Y86isJO34Slb3d66RXCWZSJs0zFw9k+umX8e67etcP+5V3i65x8YTcddKQQBDiobw5FlPcvb+Z+86ONi2FObdAFvny2902s/AE2DsHfKIBjydC73ogbKonSJHE9knnhBX4/YSc9p4vfDjH8uKjr1y3hl27pRV/h/8QAZSbbF/4rQV07hi6hWuiYVLCkqYfsl0Jo6a2DkDXPjlu7/kgY8ecK1gEvAGqL6jmpICl8SdWsOMY0RYcdnHLgQHwuGPwLCzO58vxhYGOuIZ0rQFvvw9rPmr/B/UrsKFNyQi9MDjxVOpz0FiXyJi/R8tbY0n0DHRKpmQlXA74ajyiuCVjEl4Qs0nElpxzN8697udyJUIpDX8Z6KsHGZo2xzpfyzs830Ydpace63luCqf7CvRJMe6cROUT5UKdPUdWODoBSKQ1uKF+LOfyaSloWHXXfp8MHmylBWfPFkE6GhUxOeuThTcSCZTq8axmEyuvONf4+o3rqYp1uToUQ3SBv3niv9w5LDs5FhsijVx9ktnZxSdwv4wFx14EY9NfozCQMfajKYmSd66Zo2s6q9aJc9f/WgwA5KZ+7wKBrFXgSwceDypCa0tqkEqRKWsTMS6UaNEqBs1SiZ63fEcXb11Nae/cDrlO8ppjjfjVd6WkPSwP8wZ+57B899+vsPHwpV8n33ZpN0o+Tc+19wx4+fUR9xzBw0oHMCvJv4Kr/KzfLlM1svL5XpctUquz4oKWexNT3icTLYWVmyhw74OW4SW0g1Ej3iIBDESCQj4LYGlCEpKRYA4qN+R/N9rr3H0CLM9EmfNknCn+fPleNgCdSZxA8TmUCglTHm9rYUrW6hwQyk5Tz5fyhuxPSIRsXP1ajkvK1bI840bobpajA0WJABNLAbJpCKZhKRWJJMeK7RS4/FYm7JEX6/G64N43EtTs6K0VLVEaIwZI9fNjTfuas+CqNJOjQAAIABJREFUBdK2f/yxHCu36xHkt44ZI9fh+PHivTR2rKxXRiKtz7uNfb6DQfG+WrFCvnPJklSl3Lbenm7nrDee71xiRKBu0BRr4rR/nMb8zfMzJiJ77aLXOH2/07PynQ3RBsY/MZ4N2ze4Tm6KA8XMvGImRw0/quW1WEziPO+5B7ZsSZXYbEswCKeeKoO0yZNFYbZXHAIBeb+z8aixWOt9gKjer78Ob78tjVs6s9bO4rwp51EfqXdU//0eP9cddh0HDswU9O3O1OVTmb1+tuNAsMBbwL5l+/LOZe8wonREx3eajIkr8aa3oWqW5BSxvXziDey2OHPL/XBx5WJ+9NaP+KLiC8fBp8/jo9BfyMsXvNyta/OD9R/IuYrWO3p4FPoLGdN/DE+c+QQThk3YdQd1iyRx4tq/SYiYTjrkYVEyge03QSaz/SfIZNZXIkkSE1FaTWiVB/CkhZMlLa8GnSY4qU57VHWaHE1kk0k44ghYtKhzK4UDBsAjj8gkLRbL7Nprd6Y7d8J118nqlRv2T7x22rX85XN3Tzufx0fdz+soCmQnt067olOghL+d9zfOPeBc953Ur4K3D+pYbqB0+h8DR/9VEnR6fJmrBsZ3Al4RUD77gSQBzcReV8DGV6zr2WE01v9YOOgeGDhRPIG8oeyWPM5EdAcE2qmG0xFyWS2qYSO8Na7jSVOdKN4PBp4oYa2+kPQBTVug4l1o7qR7eJ6LQBUVcPrpMuFzE57PP18qRxUXy+StJwtkOXHHjDt46JOH8CiP48KR7Uk95+o5HND/AOedJJqlklLTFjmHzRWSWyZ9wcbuXzx+WdTxBohrxWXzXuXNLV8RTVqzh7TzorUmoRMMLR7KihtXOLZ/9fXisfmf/8i2erVMVBIJaYczTUr695ewjb59U6KAzyd9Qzye8hTYskW8BTIVL2jrKdBZpq+YzqWvXUpjrLFl/OpTPjweT8v4IegLMrR4KP++/N/sW9ZO1apM9CIRqDeNz20SCZlgv/uulDZfsCA1mW+vSmphoVyTgwZlDvesrhZByS3cE2SiHgzu+pl582Q8M22a/O3mkQgiUowdK94b++wjIsaoUeJMVliY8lKyBYx0ocrrle+2c5x99ZV4m2zYIGOwjWkpxzrUzOqkhC3VzpXQpZ2rJf9T02aIVKOjO6lrHsKGrXuxoWY4m2sHEo37iMX9xBJeYnE/0bgPnyeB3xfH743j8yXwe+P0KapnZP/NjOy3gWGlq/H7NQTKZN4QHgHFe8Nhf3BNxbBhAzz7rCSutiM43BJIt8Xvl3MeDMo5Lyhofa1EInIM3Sqn7XKY2hzLXnu+c4wRgbrIzuhOTvnbKSyuXOzolQOyqvHTY37KvSfdm9XvXlm7ksOeOiyjl0yhv5C3L3ubiaMmsnw5nH22KPxu7oBHHilK7+TJ0gD3xOpcW+zGwy41qLXmtx/+lvvm3JdRVHvpgpcyT9zaQWvNjW/fuEuSYxuv8lIYKOTVi17l1L1P7eKXJMV7p3aerPbuWC4NemM5OrqVBF5iQNAblLGK1oBOPSqF5OKwNvmQrOLrJAQHSKNdtI+UCi09APpNoDzh5aczfsr0FdNpjjc7uvCG/WEOHnQwr138GoOLBnft96VR21jLJa9ewscbP3a9JkO+EKfufSp/Ov1P7N13b4fjpSWHSdVsSR69dT40V8sEKhm3Mv23VTQUFPSD4GAIDYHQYCgYYOUpsap2KGV5WFgJb6O1MpBvrpCKb5nopSIQyErKoYd2bcA+YACcdhpcdJG4s9ru53bi91Wr4JVXpLNdsKD9n2C/P+ShIVQ0uE+As1Ze3GJL/RZGPzLaNZ+AQnHVIVe1Xylk2QOw9DedCxGyKR0Hw86EkRdLNQodl/tXWY1r9cewYYqEcjW6J6htbbjP2UvFG5K8RGWHW6Gmu3mmnU1yXDKc8mnw0SUdSxLd0+SxCBSNytjhyy9ToVtt+etf4Tvf2b1Vbtoye91s5m6a6/q+R3n47oHfYRj1sHWB9D8710GTFQIZ3Sr9iDdo3X9aFiCSUctLMNPxU2g8/G2nl6qEdT7sUEuPX+5VXxEFwTJu+s4HKEtEjcWkjf3jH2WCEwyKGOR0qoYPh+OOk1V322NnyBDx5EkkZDLU3im2k842NkoYSHm5CABLl4oHwMKFYlNXLpVEMsEv3/0lj859dJcKozdPuJk56+ewsGJhy1jaozyEfWFeuOAFzhlzTue/ELITDtbTDBrE8lkVvWJ8bvP55/Doo/DPf0oX4yb4FBVJaNDRR8uEe/RoEQEGDJBxREfC2exwz2RSctbYE+8VK+Czz+S6rLMqtNveJa+8ImLaunWpvFJt6d8fvv1tyWVzzDHymp1/KhsVUxsb5ZgEAnJO339fjld6rsQWElGo/RS2zISKGTIOVh5AZVhAVhLWHRoK4aHy6C+1xGdr/KsT1rg3LvOG5goRkho3W/muXNSWDvQ3Wss48L33JOz3gw8sx1dv+54yXcHjSVUii8Xkunr//V56vvMMIwJ1kQumXMDUr6a6uqwmdZIJwybw7pXvtlp50lo68upqadTSHysqxBUuXQmPx+Vi9Xpbr+JsLp3KBwMux6s8rdx57S2SiKCU4s/7VvHj75fS1OTceYdC8MAD8P3vd20VIVvsiOzgolcu4oMNH2SsPvDsuc/y3fHf7fb3aa25Zto1/HPZPzN+3y+O/wV3Tbyr02FnbizcspAb3voh5RXzGeHXjAyGueqgy5i01wl4ScpAU8dTmentpKuegIgc4ZHS+DsM7j/e+DEnPncisWSMsD/saHMimeCX3/wlv/zmL7P2m0CO56NzH+XO/9zpWHZba01DrAGv8vLWpW91LAdCbAds/VzKrTZtkbLyDVZW/ki1JLi1KmO0TKrl26x+077g04O37Y8kM6/0+0rgog6Ui85EjieyDz4onWNHw8Kc8HhSq/fRqKyAZHIFdkJrqdY1/vHxruIuwEUHXsSUC6d03VgHyh4oo665zvX9DlUjS8bh3xNkcNbZEKF0PAHwF1tVaBrk+utIdYmO8o174MCfZfY66i3kWgQCmH+zhPrmWgjKYxFo1izJBbFLOW6L8eNlstZ2IpkXJKJQ+R5s+TdUzJTFGk8A0LvmuQLwFacWG1oWHoZB4SgJ//P4pN9WXksgSshjbLslKG1OeRE1VThPxC4Vr5CHHoL770+NF9sSCEiJ5gsvlAW+wsKUOJDtMZydqDkYlJXuCQ4OvZmobazl3JfP5fOKz1uNtcL+MNcffj0Pf+thGmONTHxuIsuqlrUS7UO+EDdMuIH7T7nfcVzRo+yGNuj11+Gyy8j78TnIhP+GG8Tjwa2i1cEHiyfxxRdLaFFTU6qSWzZJJFJJ5rdskcn2ZZfJNneu+5jnwAMlX9kRR7Tv7Zxttm+XnFuAnOzauRISvGEK4LU84R3GF6UHQr+jYdAJUHaEeO34S63FTcsL3hZ/lOUBr7yW0JxEPOET1tzCWoDyhsSLOFIri9OV/5EQ6JrP4KIMblcuJJOwYnmCLxfv5MulEeYv8LB0eZDNlUEiUS8FgRh+bwKPSlpDc9UyRFct69warRWxuI9IzIffpxnUv5kDxzRzxOEJxn0jwNhvFDLuG358PjnvveZ85zFGBOoin2/5nOU1yx3fSyahusrDwG1n8vWyYubOFZexujrp0D2elAskpGJ07ZU0273RjmP0eKTRs7emJqsB3msW3j5b8PlSnUMiAbE4eBQUqGLUyrNoaHDuzPx+STy31165HaQtq1rGaf84jZrGGtdV+5AvxOOTH+eqQ6/K2vcmdZJLX72U6SunZ4zXP3b4sbxy0Sv0CbYTPpSB9dvWc9u/b+OdVe+0TITtWPhCfyFloTIem/yYc/6cDlLXVMc739oLtrs34uOq4OAeXBxb3h8+b6dK/MXLFN5kltqWENAHKEWSNHqtzWM9KiQvbgJxJEogyRu3A9uATAJJhqSNHSLHE1mtxXX8ww8zu2b3NFrD4/Me5/YZt2f08HvoWw/x4yN/nNXvPuVvp/De2vdc3w/5Qiz50RL2Kdsn846yESLU0+x1OUx4svO5iJzobmW9S7spbuWDCJSMwZxvQ+X7uRWC8lgE+uIL8UBxCwkYNkzyjuSVCFQ1B75+CspfF+EmvnPXnF++YgmnHHiCPPYZJ+FdyYgl3HokxLKjgquW6jOtcnF5QyIQ1S2SEPKqOSwbMpvzzhOPh0yhdU88ISvYxcX57fA3f/N8Jr8wmW3N21qF34f9Ya446AqeOPOJlvFOfaSeY589lpW1K1uFltuey2989412KztllR5ugzZvljAUN++ffBmfNzWJCPXGG+73+f77S9Leww4Tu7PhXdEZtmyBgw6Sibdbda3f/lby3RQU9LwXVUa2LoRPr5L8nolm54WggSfCftfDkNNEWIbsVB51Ixm1QsfbKWoRb4LtSyWnZ90XImQ1bpB2LN4IngJLkPIAGpIxYpEEWxv6UFPfn5qGYWxtHEA8GSCR9KHx4PNE8aoYfUJb6V9YTv/iGvoVbaUg6EkJW1qDjlrV+oLUNI1m7B1L2b5d5f/5znOMCJQFtJbVrrfflgSEixZJx+zkGjd4MIwbJytkdom/IUPEXa2sTJKc2Znd05OlQeuYxOZmWZWvrRUvIjuee9UqScy2bJkkpbJDOZy4+Wa5UQqzMGfoKtFElLIHymiKN1EccJZpo4koD016iB9PyO4EEcQz5vwp5/Pu2nfxOVTq0mh2RHYwae9JzLhiRqf3v615G79+/9c8veBpYolYSyLlAquhTehES6LqdvPndITeEgffG2hTeavT5MFEtrZWKn/V1uYuPlnr9sWY4kAx7175btYSstrcN+c+7pl9j2si2E6JT+XT4aPv5t4zxFfo7KkAsN+NcPC9Mnjyd2PZq7uV9XpxKGUrkgn45Eoof6Nr4YDZII9FIBDvgOeec58gXnihhIR5vd1LKNxtti2BuT+CbV/IhMUpzGLIt+Cg+yQHXaJJJl5qN8wgklG2VjVzwEElVFc7f8TjkbLNxx6b29C6jvLUgqe49V+37iL8h/1hLhh7Ac9/+/ldFrzqmuo46pmjWLdtXas2O+AJUBIs4a1L3+r62Kiz9HAbdOut8Nhj+T0+B7j0Upg61T1Xyw9+AH/6U+uF7d3NWWfJ3MttsevXv5ZiGbk+liz9LSz7P5YHoMO1UzoOjnwc+h7Ws6JPR0lEYNM0SdFQOUs8Gn0h6RfT+0PlldQUfcZLeorwKAlTCw6SlA2BviKso9PCZ9M99VXrELjYNojUSChu02ZZhKtfIeJT/QrOeuBVZn55dv6f716AEYG6QSQiydzuu08EmHRvHpu+feHyy8Vl98gjRZWMRFIlBLONXXYxHJZyza+95v7Zhx+Gn/wk9ytJcw/qR9MO95rWfZp71nsl7oFPh0MiQ58/tB7283dcFIgmojz62aPcPftu4ok4zZbbt1d5CfvDPPft5zh6+NGc9/J5LK1e2uKJpFAEfcHM+XMy0Uvi4LslrkD+TBIzkSc2fv21TBy2bu25krKZiMZjlNxf4po7DSTZe/0v6jtWla8TzFw9kwtfuZDtEffQvhP3OpFZ35vVsR2u+gssuKnziaKzyQnTYdFdUL/aEqTaXEOeAhh9BYz+nuQH0lb1MF+ha8LHXdhDK+s5f08S5t1oJa/fzUKQlei/y+wGESgel9Cl3/1OJmFOk9r+/eE3v4GrrpLxz+7IaWKTTELjxrkUfXqy8/0CEtp1wluS0DtHk6/bb5dcK24TmxtvlOOc7xObrY1bmfSPSSypXLKL+O73+Nm/3/5cMv4SV4/nhmgDj897nB3RHbsUP/F5fFx58JU8fdbTeHp64NrDbdDll8MLL7i/nw/j84UL4ZvfdBd4hw+X/Dy59vQLhTInFK6qklxEOWXzO/DBBe5jh5ID4LS5Vj6/HLuuNG6GFf8/rHpCrnEnD+jScbD3VTD4VCgZm8qP5guLN1A20YnUwpc3SCjsoznifmPkxfnuJRgRqIt8/bU0jg0Nzu6cJSXSoV94oQxCctFxv/66dDRubsUHHCDZ/XM+qOgNwgV0SLzQWvPPZf/kln/dws7ozlaJksP+MGP6jeH1777OyNKRgHgi3Tv7Xh78+MFWK2Y+jw+fx8c1h1zDb07+DWWhsp75TW3ZTSWFu00+TRLdyCMb166VhHg1NdlP2tcec9Z9wFkvnsWOqHuY4n5l+7HyppVZ/+66pjoGPzzYsXKdTdAXZPud2wl0tILW2hdh7rW5E4JsgaXqQ1j1lKzQRWpE/InX02qSqzxQOh76HgJlR8pjcCAUlEleAbvC2C4u6fa1q1u/5vGLu/hL7Sz5/jeJQPZ3Lf4VfPXH3eMJ5g3DMX+DkRd0bz+7sT3fuFGEnpdekq91ymUTDsOJJ0oeoZNOklAXe4JZUNB9T6FIJFWGOByW7nrOHDgjMpx+oU3u//Fbn0HZodmfvHSCq66C5593f/+BB8R7JNv5VbLJnHVzOPXvp7p6XgJ46Jiq4VQZ1mZ4yXAWXb+IsnAPjot6uA3qDePz996ThLpuOb8OPhg++ij3c4hRoyRXkRvvvy8LYTm9dz6+HNZlUP0O+wOMuaXjCzU9xZrnYN6PUmODtpQdId5KpeOsfKW73/2rV5zvXoIRgbrIqFEy6HE7RB9+KMmodndsbFvOOUdKirpVCTrrLPj732XwlVNX7e6SB5OGpxc8zb2z76W6sXqX3EZ+j5/T9z2di8dd7Jjg8Kuar/jDJ3+gKdbUEjJm/z+P8nDhgRfy6ORHu5WXqEMYEagD+02Km2pLgs9K+TteD9FtUjY4vgNOeL39fb06JC3mOZ5K5GcnvPaGZGXFWyQr1P5imbz7+0CgFPwlUDAwLVnpYCn56XB8ystFCKqocHdBzzbhMNz0xp089PFDJDIkQb76kKvbr9LVRdqrSlZSUML0S6YzcdTEju9041T4+LLdLwS5eYY0VUL1h7B1HlR/BNuXycqZJyjXgk7KgC7ZRgzzFUNokOzXVyxu3cprVRexEkrquCTRjVTLdR6pbj+h9X+bCGSz6i+w8CdWUs5OZkjvCN5CCJTAsS/CoBO7v78ctOfRqITGP/ecJI62Kws6LZaFQpLLY8QIyR80cqQklB0xQsLkS0tb50ZUKpUbMZmUkPjKylQlq/XrJdfKpk2ST8WevG57upTScIaEp+esgaLR3f/x3fCg+2zVBE66bxZNUWe3isGDJcy/qChVyjufuGfWPdw95+7d9n1+j58ZV8zgxL1O7Jkv2A1tUL6Pz5uaJH3FunXuP/XNN0XYzaUQNGsWnHmm+3EcMUJSdpSU5NDO5X+QhQS3RYShZ8LxU/Igp18GQsPg7BXZsbEb9Irz3UswIlAXGTgQ19htgCVLRMnPVYysTSQCP/0pPPus+w3Tr59kUD/zTBmw7c5483g8S8coh5OGd75+h8tfu5ytze4hbSFfyDHnUDoaTVOsyXWyrFBcf/j1PDr50Xb31WX+i0SgeEy3lK20q+Z1moaNMrmufA/qPofGcqmo4PFZlWSUTB7CIyA8HELDITxMSnYecglU1brve9Ag2LSB1iUSHCo7xJukElq0Vjr2ps3QuElKih/ye/Hq6CAVFSIEbd7c88miw2Epb/xwdAwra929fAr9hTw2+TGuOuSqHrHj3JfPZdqKaa7ve5WX2465jd9P+n3ndrzpbfjwwp73DFE+EfsmfQSlB3T8/0W2WtdrlYhEkSqryt56uYaaK+UzdpUyrWkRIG1h0l6NV1aWdW+BxPc3VbhXSutuCBPkrwgEcv9//jNY/5J7bofOoqwV1XF3wdifZk7O2an95rY911rEmU8/FY+c2bNTE0q72lEiIaEc2RKmvV4Rl7xeEYoiEbjsmOd49kc3uN+r/SbAyTPlXvN1I7alm7m0Hp/5Q26f8gTNze6l4B97TBL+h0K5D+UHKbDxq/d+xe8+/B3a5V7w4CHg67xypbV2LRYCIgRNvXgqZ+5/Zqf33S67oQ3qDePzVavg+OPFY8kp5Mrvh9tug1/9SsbyuVr4fvZZuOkm98ploZBUS73hBjm1PZGOIyPJBLx3qiRTdmuH9r0eDn3Qaoe6YWB3c/q5UbQ3nLlUFie7SzeLTzzbnMjv891L6LYIpJQ6HXgEqcXzjNb6/jbvK+v9yUAjcJXWemGmffYGEeizz2DSJMm/49QwDh0KL78Mhx8uDWOuV25mzIBbbhHvpcZG575rwAC44AK4+mpx82xuzn55x2RSOhOfTzL5v/EGXH99Fnacg0lD5c5KLv7fi5m9frbrZzzKQ8gX6lTFr1gilnHgE/KFeOvStzhp9EmdsrdD7OZJQyQig4yKChFVq6ulil5treSwqauTBOfRaCrZut8PUz8ZTN+oeweyIzyIe39UgVIykEkmU5udcD2ZlNVpe7PDCJJJOHm/17jvvJvxxGulOkPbmOhBJ8GYW6VyjPLKhNhjVYvZHe68OinJTbuQv6KuTnINvPKK+8CzO4TD0KePeAIcelwNQx8emjE8oChQxKff/5RxA8ft+qbWVkWdZEqU0HZSQe3wGlj1RrHFjD/NfZw7Z92d8Z7qcjja1gXw8ZXQuN49WXN38IblGpvwZygcAXffLSObnsSurGc7pXX2Vq+v7/5MJZ9FIJu6xfDZtbBjuXXuu2CPssTkoWfCEY9IbposkUyCx9ux9ry2RmxXKuVxk76lv+b1Sv/d6hQlYyJK71wrImN0K0TqIFojj/Edcr78RaAC1DeXsrm2jM21A9hU05/Ntf1Yu2Ugazf3o7yqhKraEJGIj0RSkUgqktamNXi8Gq8ntfn9CQaUNTFsUD2jh9Sy99AqhvarYWi/Wob238rQsmr6FG5DDfkWLLxVPLicPPj8JTD2djjgNkjGu5bbIgsr8IvHay69VLyaGhqcL/PjjpPJzZmW9uH39+wkJ70kd/okf2vTVs6bch7zN893rLBa4C1g/MDxzLl6DmF/18S1FTUrOPovR7OteZvj+yFfiJuPupn7Tr4vu2Xkd2MblO/j8x07JBTxxRflM04LSIMHy2+4+GJ5HouJJ0ZPYnsX7twp37lmDVx5peQyikadxYFRo+A735Hwy/32k+PYUznKolEZYwWDMmeceFwUvnoYlv4fq2y7w5jE3wfG/wr2uVrGnsrbeUGou+2QXUK+bdVEkL7qqD+Dr0jazK6SheITeX++O+Fcniu6JQIppbzASmASUA7MAy7RWn+Z9pnJwE2ICHQU8IjW+qhM++0NIhBI8qknnpDM+PG4s7vz/vtLZ33aaVINrKlJBlSFhT2zipNIpGKMA4HWLqRawwcfwL33ymNBgXusbzAoMZUTJsDYsfI7RowQDyi7pL2NPTi0Lxf70V6Ra2gQ9+y1a+HLL2V7771UTGdW+tHd2GE3RBv4/Ue/56FPHiKWiDlOcP0ePxeMvYDJ+03uUsn3Dds28NAnD7EzutNx/2F/mAlDJ/DY5MecJ89dpYdFoEQC/vAHqeTw5Zfiym+vaNqDiwsvlGvvyCPlnrEHEnYjbyc3ticn9n3UduJi/xStd93s1+0qfPb/9/lkUOV/vRQVzxA+cOaXksivu9XYuj1p6Ho57nnzpGO0JxvdxRa777wTfvYzaV/W1a3l0CcPsnLypAs39vWjGVYQZvmpP8TrK5S8Nv5iGVx4Q6mQOG9I3vMGUl4pSsnvtwWfVnlsUt+zrGYl33zle0Ra5QVKu361Zp+i/iz68VcolwqFGdFJWPU0fH6HhFtlI0zIGxaPm6OflYpF3cC+ryIRKO3Tset13drOiQKBgJzvXcSBrtIbRCDbhoqZsOF/YdN0KZULmcMEfUVynYRHwojzYdTFUHbYLh/btg3+9S8RxisqZIJYWSn3ql0A4rjjxFPALjRRUiIDXDt8ZNKVgymoy9y+xPsPYs1HFS0/x95swVzrVJ9vD3Kbm2WLNWzj8mBf2ZHySZiAHT6oYyJwXVCTqlQXb7BEXWjl+ah8Vmnhbl48dlhtMm55tyVoudcDfSC2E1Y8Irm0IrVii27Tv3oKYMCxMPg0ufdKD5BVfB0XW73B7uUOam/yc6kmmRSvqT/+UQQCv995fOnxSFnu44+XMeahh0qV2XhczpXWKYGovfFmNCrnNJmU+zgYFEFi40YJWXr/ffHmqrWcWz/f8jlnvHAGdc11jjnXAt4AY/qN4aNrPqK4oBuVCoEllUs4/q/HsyPi3CeH/WEOG3IYr1/8Ov3C/br1XS3s5jaoN4zP16yBJ5+EP/85JRg5FZsYOVImwKecIo+DB8t12NwsYy77u9uLAkgkpL2xQ0qDQbGnslK8C2fOlGO1YkVrO5ctk8TaL78s31tf73yq+vSR3K6nnir3jn0Mfb7UveD3p/o126s8fVExHpfN/k1NTdJeb9gg+ZJmzRJbW3n3NW6WMcOqJyG+U/oLpwiA0vEwZJIkX+43QVIBJJpkzKG8Mj7ydMLDIJmEZDP8s50YqdPnw7IHpE9TWB6v6SgYejrsc520lf4S+Yw3KFtHyGLxibw/33lMd0WgY4C7tdanWX//AkBr/bu0zzwFvK+1fsn6ewVwotZ6i9t+e4sIZBOLSZK3qVOlQaqsFIW+ubl1YxwKwTe+ITG2hxwiquTAgVI5o08fGbzZnbfdsKZPUO1Hjye1GlNfLyv7NTXyvcuWweLF8vjll+4u1nV1Erf/+uvw7rspO92qANgoJTaPHi2DDb8/tSUScixs76gNG2TLlLU//Td2i93QYSeSCZ794ll+PvPnNMebdyl9CrLyVRYqY/ol0zl86OHd+r6GaAM/mP4D3ljxhuMqm0d5KPAWcP7Y83lw0oMMKc7CKnIPi0Br1sA++7QelKTTr59cy2CtZOfK3b12vkzqaz6RTjYZk87TpuQA2OsyGHY2lI6VUpo6YeVTCXQ8nCMbsdvdyL+STMIzz0hlGq2dJxrtYd//J54oovjIkWlvJpphitMqlkJZehXsAAAW3klEQVTb/2ayP93rp6WUqMs12k334q6KaS1EamHh7bBhSioHT2fxFgIaxv0Cxt7R6jqqrpZqj7W1MjErL5fXGhpkIKK15JgoLZX+p7RURIHiYul7gkGYcM5g/FszH6PEgEFUftFaFLAFAfu1eFzaeTsRry0K7NwJZ5zRvWoxWmtUR2787nYcPVGQYBBwEHAk0BcoAHxADIgAW5ClssVABo0Z4GUu4hKmtHotXdj+xjekr3cj/ZzZ44auki4OtRLZ440w+2zYuVryRSXj1qq1Qu5ZjwiZpeNECCroL6/ZychbygW3/MK0+7vN47Lfwpe/o0t4C+HitMZNa9i+FNa/DJveFG8uT1Bs2iVUQ0HxvhL2GxwiedfCI6FoLwn7LRhoJUi1XOiUh1Q+rYS0gc0V0LRJSiwvvDWzrW3aw9paEQNffVVEmIaG1ETHjX79JHTM3kaNEk+SQCC12fdwNCrjvvXrpU0pL5f2xS1kWGt4ZuEz3PzOzY5jIJBFsNF9R/PZtZ9lLY/hwi0LOeG5E9gZde6kAt4AfYJ9eOvStzhiqOOcpnPkUIjO9/F5LCYi5bRp8M47cu2EQmKf25yjsFDyfqVflyNHylzGviaVkmvOXrTYvDnV19nbDpd208nOxkY5fq+9JkJmVVVmcc2mpEQEgpEj5dH2uPL7ZfJv3zuxmNhjH8uNGzMfz11s1FrGmOVviOBSvyrlheM0fvAVS+n1UNpWOFrCtAJ9LCHdl5bTLy5j10TE8tRcLSHiq57KfADsNqi5Ctb+HTa/DVvny76U3/J8TRsvBQdCn4OknS87TNIjFAyQ8vD2gl4iIoJ7y0FI89wGq1PxyZgnGYUp7QwiHMaNeX++85DuikDfAU7XWl9r/X0FcJTW+sa0z7wJ3K+1/tD6+13g51prV5Wnt4lAbdm2TbL6L1sGc+dKgsJ162SgXlAgF5bt+RCPt1YMS0tFFCooSLld23Hz8XhKGbcH/5BSyG310l75jcU6VglIa1i5UhTMJUvgq6/E3ooK2YftZmwP+DuLxyM3ldebmjjYg5R994UpU9rfR7v0cIc9a+0srpl2DRu3b3TN2RP2hzltn9N4/tvPd3vlK50XFr/A9W9eT1O8aZeSqSBikFd5uf3Y27nnxHvwe7uxSrkbwsHmzZP7YsEC2daskWvZvjdGjZJkoQccIBMdWygtLpbryF5Bshvltt49bU1M/0npYqrt+RMIpPJS2NX+amrg6KORSc22RVKJqe4LqF8JjRuguVo6WG9QvDbCwyQfUGiweHAUDJDXgkMgOEBW/5XXKv1pJd9tWQVvM2lou03bO/MBPeQB59eVz9HDwIntO7y8ObMff39lMO9/UkpBQNPY5CEed5o5asKhJFrDoAFRLj2/kgvPruGQ8c6D86JRRzC4TwUDS6oYWFLFgJJqCgsaKCxooChYzy9+2gj+MCmRx9va20d5ZODh8ctkSylLE2rjBfT5HRJ20gU+WzWB2f45ruLdwIFSyagjhOKr6N/0vwxu+juh+GqSyo9XN1iyV2s0XhIqjEdHqA8cSUXoSmqC3ybmHbjLZ+fMgV//uvVrtkcOyP2ydKm7XenhkND6Xkgn/W+n+yn977aeQQA//7/XUN6wjiYiNOkozTpKk47yVWwj23XHXM62PAiDM3y0ohCG3NH+fvYvGsno4uEU+oKEfSEKfSGKfCEG1JzOj++4heLGmg7Zkwu2FsBvjx3FshNvYsd2L/Xb/Wyt9hNpVtREN0KkhOJAKcP69qeooIiiQJiigjBFwSABr58CXwEFfh8FAQ8FAQ+BgMKjFB6PwqNAKevR48FrjUc0Gp3UJJKQTGq01iTRxOManfC1tLmJZJJEMkk8kWTc+dPY3LSWndGdJCK1FEZr8MS3s7l2OSq2gxIPhD0QVlDqgT6+AGWhPpQGCikKFBL2h/H7wnh9hXh9YZTy4vF4UHgsGz14lAeUB4VC6wRJnURrjdZJkiRJJpMMrZiK10V4TXgCeC+odg9fSERFFNq6AKo+kMdIlST6Vx7xDrLbaacE69miA/m0ystTK87Ll8tEpLpaxoV2LqTu5lkKhaRf1DqVc6OsDAYPjXPQ/1zNi0tedByLAPiUj+Glw5n3g3n0D/fvmgEufLLxE079+6mOi2I2XuXlqbOe4vuHfb97X5Yn3oi9YXxeXy/hL3PmyPhuwwbR17dtk+vIDlnrqo2Q8jb1eFJCVkmJpFYcMUK8gtqjqkps/OADOY7r18OWLTLms8eViYSICU4eTu3h86W87uxj2aePJLkfPVpEs4wkmmWcWfOZ5KHcuUqEmGidJe4UWJO8uOVt2gUj28OtDdIaGtZJbsy6xZLbaPsSyTdIUkR0jzVu0wnLK9pqJ5VPclcG+spz2/vT/i3a8tyMbZdKpxnSB7TQgcXPvD/feUB3RaALgdPaiEATtNY3pX3mLeB3bUSgn2mtF7TZ13XAdQAjR448fP369V3/VXlKLCarOjU10mnbj9XV0rFv2SKNZrrgY+czsStk+HyprV8/yT00bJhMkgcMSD0OGCAXY3fjHrdvlxtn3Tp5XLlSEj02N6cUe3tgaOdrsRv9QEBsHDdOboi99pIJ/tChPRCP2d6qbgfKu2fidx/8jn8s+Yfr+x483HbMbVx1yFVdCv9qj9VbV3Pd9OsyVjkqDhTz8fc/lgFzV+nI6ng3j6UT8bjkAKqulnukvl62HTtk2749lSdo2za5J+ySwrZXkZt3kRP25NX21tNaBNiyMrlmS0vhxhvb8WiIN1iJmq2ku/EGce2NN8gW2y6TiNgO2VrcfjUtSZ9bqoFZfqd4LHHDI+KSvxgq3m3thZTOq8BrnTnS7dNEkFmcxCIOYjEHsYr9aKYAL0n6U8PBLGIsyzmJWezDmnb399uJb7NhznoUmgQeknjQeIjjI0IB3/rJgQwZU0JSe0iiSKJQXi/aEnm08ojQ4FV4fQrlUWmLR/YTUPIPWuuWRaaWPkwDWhOPaZJJ631LEVE6yd2P9OWcL+/nbu7J7sHsA4wHhgKjrL+9QByoBjYggdRLgQ7kZ2qqqqe6qYiqKhng1NbKAKaxMRUiZC8w2NgeIFrLczvk0V40SL9/bNI9TtIfbZJJ+S7bNTpdWLqbjrV/HuXB5/Hh9/jxe/34PX752+vHp3x4PCJu2+1ZQidIJpMkdIJ4Mk4sUkcstpM4ENPW1qFvhuIXZ1C/cpLr+889B9/7Xjs76eE+Z96meUx4ZkKHPutV3l2Oof3c6/HiVV68HjmWSZ0kkUy0PMaSMTmeyVhLeHMsEctYza8rdPt8W3bFk/GUnR2ZLAAHDzqYL374ReeN1lra8aYKy5tnizw2lMuEKFJjifWx1pMZezW+JczNJ5OrotFSYSc0WPI/BQfL613I7daW5mYJ60n3mli1SsZtkUhqnGavatvjyXRvkb59JbRo1KjWHhv9+lnzNZ1k4l8nUtdc52rHgPAAXv7OywwuGtzt3+TE7HWzueVft2Q895P2nsSfTv9T976oh+/vbJDv4/NEQvqpdG+edevg669lIm7bZl+XdviivTjn84kH0d57y5Z+TdohZtkgEpF7x/bwWL9eQswqK1PHMH1h3b5v7GNZUCBC1P77izeJvQ0ZkqVjqbV4GjdtTm2NmyzPnk2W4BJLa4ditAqztdsgf6l4NRaObO1NFBrSvWIE8UZpCyPVskDa8rxSPI+aKkTg0vHW4brolCjU0l4GrPbRWlQt6G95FfWXBdWC/taiatfnWXl/vncjJhzMYDAYDAaDwWAwGAwGg2EPIJMI1BF3gnnAfkqp0UqpAPBdoK0D1DTgSiUcDWzPJAAZDAaDwWAwGAwGg8FgMBh2L+3kbQetdVwpdSPwb8TJ/Vmt9TKl1A+t958E3kYqg61CSsRf3XMmGwwGg8FgMBgMBoPBYDAYOku7IhCA1vptROhJf+3JtOcauCG7phkMBoPBYDAYDAaDwWAwGLJFroozGwwGg8FgMBgMBoPBYDAYdiNGBDIYDAaDwWAwGAwGg8Fg2AMwIpDBYDAYDAaDwWAwGAwGwx6AEYEMBoPBYDAYDAaDwWAwGPYAjAhkMBgMBoPBYDAYDAaDwbAHYEQgg8FgMBgMBoPBYDAYDIY9ACMCGQwGg8FgMBgMBoPBYDDsARgRyGAwGAwGg8FgMBgMBoNhD8CIQAaDwWAwGAwGg8FgMBgMewBGBDIYDAaDwWAwGAwGg8Fg2AMwIpDBYDAYDAaDwWAwGAwGwx6A0lrn5ouVqgbW5+TLO0d/oCbXRrSDsTF79AY7jY3ZozfYaWzMHr3BTmNj9ugNdhobs0dvsNPYmD16g53GxuzRG+w0NmaP3mBnb7BxlNZ6gNMbOROBegtKqfla6yNybUcmjI3ZozfYaWzMHr3BTmNj9ugNdhobs0dvsNPYmD16g53GxuzRG+w0NmaP3mCnsTF79AY7e4ONmTDhYAaDwWAwGAwGg8FgMBgMewBGBDIYDAaDwWAwGAwGg8Fg2AMwIlD7/DnXBnQAY2P26A12GhuzR2+w09iYPXqDncbG7NEb7DQ2Zo/eYKexMXv0BjuNjdmjN9hpbMwevcHO3mCjKyYnkMFgMBgMBoPBYDAYDAbDHoDxBDIYDAaDwWAwGAwGg8Fg2AMwIpALSqnTlVIrlFKrlFJ35toeJ5RSzyqlqpRSS3NtixtKqRFKqVlKqeVKqWVKqVtybVNblFJBpdRcpdQiy8Z7cm2TG0opr1Lqc6XUm7m2xQ2l1Dql1BKl1BdKqfm5tscJpVQfpdT/KqW+sq7NY3JtUzpKqTHW8bO3HUqpn+TaLieUUrda981SpdRLSqlgrm1qi1LqFsu+Zfl0HJ3acKVUmVJqplLqa+uxbx7aeKF1LJNKqZxXxnCx8UHr/l6slJqqlOqTSxstm5zs/I1l4xdKqRlKqaH5ZmPae7crpbRSqn8ubEuzw+k43q2U2pTWZk7OpY2WTY7HUil1kzW+XKaU+n2u7LNscTqWU9KO4zql1Bd5aOMhSqlP7XGGUmpCLm20bHKy82Cl1CfWmGi6UqokxzY6jsnzqd/JYGPe9DsZbMyrfieDnXnT77jZmPZ+zvudDMcx7/qdTqG1NlubDfACq4G9gQCwCDgw13Y52DkROAxYmmtbMtg4BDjMel4MrMy3YwkooMh67gc+A47OtV0utt4GvAi8mWtbMti4DuifazvasfF54FrreQDok2ubMtjqBSqAUbm2xcG2YcBaIGT9/U/gqlzb1cbG8cBSIAz4gP8A++XaLsu2Xdpw4PfAndbzO4EH8tDGscAY4H3giDw9jt8CfNbzB3J9HDPYWZL2/GbgyXyz0Xp9BPBvYH2u23eX43g3cHuuz3EH7DzJaoMKrL8H5puNbd5/GPiffLMRmAGcYT2fDLyfp+d7HnCC9fwa4Dc5ttFxTJ5P/U4GG/Om38lgY171OxnszJt+x81G6++86HcyHMe863c6sxlPIGcmAKu01mu01lHgZeDcHNu0C1rrOcDWXNuRCa31Fq31Qut5PbAcmTjmDVrYaf3pt7a8S5allBoOnAk8k2tbejPWStxE4C8AWuuo1npbbq3KyCnAaq31+lwb4oIPCCmlfIjQsjnH9rRlLPCp1rpRax0HZgPn5dgmwLUNPxcRKbEev71bjWqDk41a6+Va6xU5MmkXXGycYZ1vgE+B4bvdsDa42Lkj7c9Cctz3ZBhX/BH4GXnQN/aGsQ+42vkj4H6tdcT6TNVuNyyNTMdSKaWAi4CXdqtRbXCxUQO2V00pedDvuNg5BphjPZ8JXLBbjWpDhjF53vQ7bjbmU7+Twca86ncy2Jk3/U4788S86Hd6w1y2KxgRyJlhwMa0v8v5LzjZuUYptRdwKOJpk1coCbP6AqgCZmqt885G4E9IY5jMtSHtoIEZSqkFSqnrcm2MA3sD1cBflYTWPaOUKsy1URn4LjkehLuhtd4EPARsALYA27XWM3Jr1S4sBSYqpfoppcLIqvGIHNuUiUFa6y0gAw9gYI7t+W/gGuCdXBvhhlLqPqXURuAy4H9ybU9blFLnAJu01otybUs73GiFODyby3CWdtgf+KZS6jOl1Gyl1JG5NigD3wQqtdZf59oQB34CPGjdNw8Bv8ixPW4sBc6xnl9IHvU9bcbkednv5PO8wSaDjXnV77S1Mx/7nXQb87XfcTjfvaHfccSIQM4oh9dyvvrVm1FKFQGvAj9po0DnBVrrhNb6EES1n6CUGp9rm9JRSp0FVGmtF+Talg5wnNb6MOAM4Aal1MRcG9QGH+Ky/YTW+lCgAXF/zjuUUgFkAPlKrm1xwurwzgVGA0OBQqXU5bm1qjVa6+WIW/ZM4F9IeG88438y/NeglLoLOd8v5NoWN7TWd2mtRyA23phre9KxhNO7yJNJQgaeAPYBDkEE6Ydza44rPqAvcDRwB/BPy+MmH7mEPF2AQDyqbrXum1uxPHvzkGuQcdACJIwkmmN7gPwfk0PvtjHf+h0nO/Ot30m3ETl2edfvOBzH3tLvOGJEIGfKaa3WDycPXE17K0opP3LTvKC1fi3X9mTCCgt6Hzg9x6a05TjgHKXUOiQ88WSl1D9ya5IzWuvN1mMVMBUJr8wnyoHyNG+v/0VEoXzkDGCh1roy14a4cCqwVmtdrbWOAa8Bx+bYpl3QWv9Fa32Y1noi4q6fjyvbNpVKqSEA1mNOw0V6M0qp7wFnAZdprXvDQs6L5DhcxIF9EJF3kdX/DAcWKqUG59SqNmitK63FnCTwNPnX79iUA69ZYehzEc/enCbadsIK7z0fmJJrW1z4HtLfgCyS5OX51lp/pbX+ltb6cERQW51rm1zG5HnV7/SGeYObjfnW73TgWOa833GwMe/6Hafj2Iv6HUeMCOTMPGA/pdRoayX+u8C0HNvUK7FWuP4CLNda/yHX9jihlBpgZ/BXSoWQie1XubWqNVrrX2ith2ut90Kux/e01nnlcQGglCpUShXbz5EkeXlVvU5rXQFsVEqNsV46BfgyhyZlIp9XYkHCwI5WSoWte/0UJFY6r1BKDbQeRyITm3w+ptOQCQ7W4xs5tKXXopQ6Hfg5cI7WujHX9rihlNov7c9zyL++Z4nWeqDWei+r/ylHEmRW5Ni0VtgTWIvzyLN+J43XgZMBlFL7I4UJanJqkTOnAl9prctzbYgLm4ETrOcnk6fCflrf4wH+P+DJHNvjNibPm36nl8wbHG3Mt34ng5150+842Zhv/U6G49hb+h1ndB5kp87HDckbsRJR7e/KtT0uNr6EuJ/FkBvk+7m2ycHG45FQusXAF9Y2Odd2tbHxIOBzy8al5LgSRgfsPZE8rQ6G5NtZZG3L8vjeOQSYb53z14G+ubbJwcYwUAuU5tqWduy8BxlALAX+jlX1Jp824ANE6FsEnJJre9Ls2qUNB/oB7yKTmneBsjy08TzreQSoBP6dhzauQnL72f1OTqtuZbDzVeveWQxMR5J25pWNbd5fR+6rgzkdx78DS6zjOA0YkqfnOwD8wzrnC4GT881G6/XngB/m+hhmOI7HAwusNv0z4PA8tfMWZC6xErgfUDm20XFMnk/9TgYb86bfyWBjXvU7GezMm37HzcY2n8lpv5PhOOZdv9OZTVk/zmAwGAwGg8FgMBgMBoPB8F+MCQczGAwGg8FgMBgMBoPBYNgDMCKQwWAwGAwGg8FgMBgMBsMegBGBDAaDwWAwGAwGg8FgMBj2AIwIZDAYDAaDwWAwGAwGg8GwB2BEIIPBYDAYDAaDwWAwGAyGPQAjAhkMBoPBYDAYDAaDwWAw7AEYEchgMBgMBoPBYDAYDAaDYQ/AiEAGg8FgMBgMBoPBYDAYDHsA/w9304rDivHlGgAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "After filtering: numseqlets 82\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Numseqles: 75\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "After filtering: numseqlets 74\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Getting labels\n", - "Getting impscores data\n", - "Computing fwd sims\n", - "Took 0.113922119140625 s\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Parallel(n_jobs=10)]: Using backend LokyBackend with 10 concurrent workers.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Getting impscores data\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Parallel(n_jobs=10)]: Done 1 out of 1 | elapsed: 0.1s finished\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Computing fwd sims\n", - "Took 0.12588191032409668 s\n" - ] - } - ], - "source": [ - "from modisco.hit_scoring import exemplar_based_hitscoring\n", - "reload(exemplar_based_hitscoring)\n", - "\n", - "instance_scorer = exemplar_based_hitscoring.prepare_instance_scorer(\n", - " patterns=(loaded_tfmodisco_results\n", - " .metacluster_idx_to_submetacluster_results[\"metacluster_0\"]\n", - " .seqlets_to_patterns_result.patterns),\n", - " trim_window_size=25,\n", - " task_names=tasks,\n", - " bg_freq=background,\n", - " track_set=track_set)" - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[(array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n", - " 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n", - " 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n", - " 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n", - " 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]),\n", - " array([1. , 0.98780488, 0.97560976, 0.96341463, 0.95121951,\n", - " 0.93902439, 0.92682927, 0.91463415, 0.90243902, 0.8902439 ,\n", - " 0.87804878, 0.86585366, 0.85365854, 0.84146341, 0.82926829,\n", - " 0.81707317, 0.80487805, 0.79268293, 0.7804878 , 0.76829268,\n", - " 0.75609756, 0.74390244, 0.73170732, 0.7195122 , 0.70731707,\n", - " 0.69512195, 0.68292683, 0.67073171, 0.65853659, 0.64634146,\n", - " 0.63414634, 0.62195122, 0.6097561 , 0.59756098, 0.58536585,\n", - " 0.57317073, 0.56097561, 0.54878049, 0.53658537, 0.52439024,\n", - " 0.51219512, 0.5 , 0.48780488, 0.47560976, 0.46341463,\n", - " 0.45121951, 0.43902439, 0.42682927, 0.41463415, 0.40243902,\n", - " 0.3902439 , 0.37804878, 0.36585366, 0.35365854, 0.34146341,\n", - " 0.32926829, 0.31707317, 0.30487805, 0.29268293, 0.2804878 ,\n", - " 0.26829268, 0.25609756, 0.24390244, 0.23170732, 0.2195122 ,\n", - " 0.20731707, 0.19512195, 0.18292683, 0.17073171, 0.15853659,\n", - " 0.14634146, 0.13414634, 0.12195122, 0.1097561 , 0.09756098,\n", - " 0.08536585, 0.07317073, 0.06097561, 0.04878049, 0.03658537,\n", - " 0.02439024, 0.01219512, 0. ]),\n", - " array([0.65678624, 0.89705327, 0.93625358, 0.95313614, 0.95494318,\n", - " 0.9556915 , 0.96611831, 0.96639921, 0.97099519, 0.97261431,\n", - " 0.97608759, 0.97744753, 0.97891236, 0.98174708, 0.98207847,\n", - " 0.98316659, 0.98370227, 0.98505885, 0.98531423, 0.98581885,\n", - " 0.98619415, 0.98755134, 0.98756805, 0.98814205, 0.98868663,\n", - " 0.98894266, 0.9890422 , 0.98916952, 0.98978332, 0.99024676,\n", - " 0.99076272, 0.99120682, 0.99129641, 0.99178473, 0.99211901,\n", - " 0.99290701, 0.9929094 , 0.99303012, 0.99308176, 0.99343159,\n", - " 0.99364083, 0.99389209, 0.99435999, 0.99458476, 0.99475498,\n", - " 0.99532409, 0.99553223, 0.99558805, 0.99573062, 0.99580233,\n", - " 0.99582343, 0.99655394, 0.99663574, 0.99683224, 0.99685669,\n", - " 0.99703242, 0.99712932, 0.99723375, 0.99723838, 0.99725946,\n", - " 0.99727703, 0.997686 , 0.99771562, 0.9978073 , 0.99781418,\n", - " 0.99784923, 0.99806169, 0.99817138, 0.99820317, 0.99839801,\n", - " 0.99857778, 0.99867491, 0.99878419, 0.9987898 , 0.99883347,\n", - " 0.99887053, 0.99891155, 0.99899106, 0.99903135, 0.99904085,\n", - " 0.99915221, 0.99918308])),\n", - " (array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n", - " 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n", - " 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n", - " 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n", - " 1., 1., 1., 1., 1., 1., 1.]),\n", - " array([1. , 0.98648649, 0.97297297, 0.95945946, 0.94594595,\n", - " 0.93243243, 0.91891892, 0.90540541, 0.89189189, 0.87837838,\n", - " 0.86486486, 0.85135135, 0.83783784, 0.82432432, 0.81081081,\n", - " 0.7972973 , 0.78378378, 0.77027027, 0.75675676, 0.74324324,\n", - " 0.72972973, 0.71621622, 0.7027027 , 0.68918919, 0.67567568,\n", - " 0.66216216, 0.64864865, 0.63513514, 0.62162162, 0.60810811,\n", - " 0.59459459, 0.58108108, 0.56756757, 0.55405405, 0.54054054,\n", - " 0.52702703, 0.51351351, 0.5 , 0.48648649, 0.47297297,\n", - " 0.45945946, 0.44594595, 0.43243243, 0.41891892, 0.40540541,\n", - " 0.39189189, 0.37837838, 0.36486486, 0.35135135, 0.33783784,\n", - " 0.32432432, 0.31081081, 0.2972973 , 0.28378378, 0.27027027,\n", - " 0.25675676, 0.24324324, 0.22972973, 0.21621622, 0.2027027 ,\n", - " 0.18918919, 0.17567568, 0.16216216, 0.14864865, 0.13513514,\n", - " 0.12162162, 0.10810811, 0.09459459, 0.08108108, 0.06756757,\n", - " 0.05405405, 0.04054054, 0.02702703, 0.01351351, 0. ]),\n", - " array([0.77684711, 0.83341283, 0.90725741, 0.91377449, 0.92101767,\n", - " 0.95534211, 0.96754378, 0.96835405, 0.9685044 , 0.9688225 ,\n", - " 0.97561621, 0.98190854, 0.98233506, 0.98283539, 0.98409881,\n", - " 0.98441852, 0.98470097, 0.98471698, 0.98563756, 0.9884187 ,\n", - " 0.99077162, 0.99199793, 0.99244273, 0.9925711 , 0.99259755,\n", - " 0.99263917, 0.99315988, 0.99319414, 0.99387562, 0.99390085,\n", - " 0.99401059, 0.9945448 , 0.99545792, 0.99550508, 0.9955907 ,\n", - " 0.99603051, 0.99607055, 0.99613181, 0.99633447, 0.99669391,\n", - " 0.99673971, 0.99687127, 0.99709408, 0.99740961, 0.99747868,\n", - " 0.99748133, 0.99762514, 0.99767821, 0.99769793, 0.99773233,\n", - " 0.99787421, 0.99801789, 0.99810313, 0.99810556, 0.99813886,\n", - " 0.99830408, 0.99831698, 0.99838589, 0.99839679, 0.99851889,\n", - " 0.99852858, 0.99860751, 0.99867825, 0.99870549, 0.99873476,\n", - " 0.99884999, 0.99902065, 0.99908039, 0.9991059 , 0.99925669,\n", - " 0.99928319, 0.99938742, 0.99957424, 0.99961321])),\n", - " (array([0.99954107, 0.99954086, 1. , ..., 1. , 1. ,\n", - " 1. ]),\n", - " array([1.00000000e+00, 9.99540863e-01, 9.99540863e-01, ...,\n", - " 9.18273646e-04, 4.59136823e-04, 0.00000000e+00]),\n", - " array([0.26942209, 0.33525055, 0.37973795, ..., 0.99814724, 0.99836229,\n", - " 0.99865282]))]" - ] - }, - "execution_count": 43, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "instance_scorer.precrecthres_list" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "colab": { - "include_colab_link": true, - "name": "(On Google Colab) With Hit Scoring TF MoDISco TAL GATA.ipynb", - "provenance": [] - }, - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.3" - } - }, - "nbformat": 4, - "nbformat_minor": 1 -} diff --git a/modisco/coordproducers.py b/modisco/coordproducers.py index a881c18..fbd3b61 100644 --- a/modisco/coordproducers.py +++ b/modisco/coordproducers.py @@ -575,7 +575,7 @@ def fit_pos_and_neg_irs(self, score_track, null_track): pos_ir=pos_ir, neg_ir=neg_ir, pos_threshold=None, neg_threshold=None) - show_or_savefig(plot_save_dir=self.plot_save_dir, + util.show_or_savefig(plot_save_dir=self.plot_save_dir, filename="scoredist_window" +str(sliding_window_size)+"_" +str(VariableWindowAroundChunks.count)+".png") @@ -602,9 +602,13 @@ def __call__(self, score_track, null_track, tnt_results=None): np.concatenate(precisiontransformed_score_track, axis=0)) from matplotlib import pyplot as plt - plt.hist(subsampled_prec_vals, bins=50) - show_or_savefig(plot_save_dir=self.plot_save_dir, - filename="final_prec_vals_dist" + plt.plot((np.arange(len(subsampled_prec_vals))/ + len(subsampled_prec_vals)), + sorted(subsampled_prec_vals)) + plt.xlabel("Tranformed IR precision value") + plt.ylabel("CDF") + util.show_or_savefig(plot_save_dir=self.plot_save_dir, + filename="final_prec_vals_cdf_dist" +str(VariableWindowAroundChunks.count)+".png") #Pick a threshold according the the precisiontransformed score track @@ -797,22 +801,6 @@ def refine_thresholds_based_on_frac_passing( return pos_threshold, neg_threshold -def show_or_savefig(plot_save_dir, filename): - from matplotlib import pyplot as plt - if plt.isinteractive(): - plt.show() - else: - import os, errno - try: - os.makedirs(plot_save_dir) - except OSError as e: - if e.errno != errno.EEXIST: - raise - fname = (plot_save_dir+"/"+filename) - plt.savefig(fname) - print("saving plot to " + fname) - - def make_nulldist_figure(orig_vals, null_vals, pos_ir, neg_ir, pos_threshold, neg_threshold): from matplotlib import pyplot as plt @@ -823,6 +811,7 @@ def make_nulldist_figure(orig_vals, null_vals, pos_ir, neg_ir, ax1.hist(orig_vals, bins=100, density=True, alpha=0.5) ax1.hist(null_vals, bins=100, density=True, alpha=0.5) ax1.set_ylabel("Probability density\n(blue=foreground, orange=null)") + ax1.set_xlabel("Total importance in window") precisions = pos_ir.transform(orig_vals) if (neg_ir is not None): @@ -992,7 +981,7 @@ def __call__(self, score_track, null_track, tnt_results=None): pos_threshold=pos_threshold, neg_threshold=neg_threshold) - show_or_savefig(plot_save_dir=self.plot_save_dir, + util.show_or_savefig(plot_save_dir=self.plot_save_dir, filename="scoredist_" +str(FixedWindowAroundChunks.count)+".png") FixedWindowAroundChunks.count += 1 diff --git a/modisco/hit_scoring/exemplar_based_hitscoring.py b/modisco/hit_scoring/exemplar_based_hitscoring.py index 92043cb..dce9cc6 100644 --- a/modisco/hit_scoring/exemplar_based_hitscoring.py +++ b/modisco/hit_scoring/exemplar_based_hitscoring.py @@ -10,6 +10,7 @@ from .. import visualization from matplotlib import pyplot as plt import sklearn +from joblib import Parallel, delayed def flatten_seqlet_impscore_features(seqlet_impscores): @@ -32,20 +33,21 @@ def compute_continjacc_sims_1vmany(vec1, vecs2, vecs2_weighting): sign_vec1, signs_vecs2 = np.sign(vec1), np.sign(vecs2) abs_vec1, abs_vecs2 = np.abs(vec1), np.abs(vecs2) intersection = np.sum((np.minimum(abs_vec1[None,:], abs_vecs2[:,:]) - *sign_vec1[None,:]*signs_vecs2[:,:])*vecs2_weighting, axis=-1) - union = np.sum(np.maximum(abs_vec1[None,:], abs_vecs2[:,:])*vecs2_weighting, axis=-1) + *sign_vec1[None,:]*signs_vecs2[:,:])*vecs2_weighting, axis=-1) + union = np.sum(np.maximum(abs_vec1[None,:], + abs_vecs2[:,:])*vecs2_weighting, axis=-1) return intersection/union -def compute_pairwise_continjacc_sims(vecs1, vecs2, vecs2_weighting=None): +def compute_pairwise_continjacc_sims(vecs1, vecs2, n_jobs, + vecs2_weighting=None): #normalize vecs2_weighting to sum to 1 if (vecs2_weighting is None): vecs2_weighting = np.ones_like(vecs2) assert np.min(vecs2_weighting) >= 0 - return np.array([compute_continjacc_sims_1vmany( - vec1=vec1, vecs2=vecs2, - vecs2_weighting=vecs2_weighting) - for vec1 in vecs1]) + return np.array(Parallel(n_jobs=n_jobs, verbose=True)( + delayed(compute_continjacc_sims_1vmany)( + vec1, vecs2, vecs2_weighting) for vec1 in vecs1)) def make_aggregated_seqlet(seqlets): @@ -59,7 +61,7 @@ def make_aggregated_seqlet(seqlets): def get_exemplar_motifs(seqlets, pattern_comparison_settings, seqlets_per_exemplar, max_exemplars, - affmat_min_frac_of_median): + affmat_min_frac_of_median, n_jobs): """This identifies the exemplars among seqlets Args: @@ -75,6 +77,7 @@ def get_exemplar_motifs(seqlets, pattern_comparison_settings, affmat_min_frac_of_median: Kick out seqlets that have poor within-cluster similarity relative to the median within-cluster similarity. + n_jobs: number of jobs to launch when computing similarities Returns motifs: Exemplar motifs, sorted by number of seqlets (only exemplars @@ -99,7 +102,9 @@ def get_exemplar_motifs(seqlets, pattern_comparison_settings, fwd_seqlet_data_vectors = flatten_seqlet_impscore_features(fwd_seqlet_data) #compute the affinity matrix orig_affmat = compute_pairwise_continjacc_sims( - vecs1=fwd_seqlet_data_vectors, vecs2=fwd_seqlet_data_vectors) + vecs1=fwd_seqlet_data_vectors, + vecs2=fwd_seqlet_data_vectors, + n_jobs=n_jobs) #Let's kick out seqlets for which the sum of the affmat across all # neighbors is less than affmat_min_frac_of_median sum_orig_affmat = np.sum(orig_affmat, axis=-1) @@ -141,7 +146,7 @@ def get_exemplar_motifs(seqlets, pattern_comparison_settings, def get_exemplar_motifs_for_all_patterns( patterns, pattern_comparison_settings, - affmat_min_frac_of_median): + affmat_min_frac_of_median, n_jobs): print("Getting the exemplar motifs") #Take each pattern @@ -159,7 +164,8 @@ def get_exemplar_motifs_for_all_patterns( pattern_comparison_settings=pattern_comparison_settings, seqlets_per_exemplar=30, max_exemplars=10, - affmat_min_frac_of_median=affmat_min_frac_of_median) + affmat_min_frac_of_median=affmat_min_frac_of_median, + n_jobs=n_jobs) exemplarmotifs_foreach_pattern.append(exemplarmotifs) exemplarmotifs_indices.append(len(exemplarmotifs_foreach_pattern)) withinpattern_affmats.append(patternaffmat) @@ -233,11 +239,12 @@ def get_coordinates_and_labels(shift_fraction, patterns, track_set): class FeaturesProducer(object): def __init__(self, motifs, pattern_comparison_settings, - onehot_track_name, bg_freq): + onehot_track_name, bg_freq, n_jobs): self.motifs = motifs self.pattern_comparison_settings = pattern_comparison_settings self.onehot_track_name = onehot_track_name self.bg_freq = bg_freq + self.n_jobs = n_jobs #Get imp scores data (allexemplarmotifs_impscoresdata_fwd, @@ -287,7 +294,8 @@ def __call__(self, coordinates, track_set): features_matrix_fwd = compute_pairwise_continjacc_sims( vecs1=impscoresdata_fwd, vecs2=self.allexemplarmotifs_impscoresdata_fwd, - vecs2_weighting=self.per_position_ic_allexemplarmotifs_fwd) + vecs2_weighting=self.per_position_ic_allexemplarmotifs_fwd, + n_jobs=self.n_jobs) print("Took",time.time()-start,"s") #We ignore the rc because we want to annotate seqlets as @@ -300,14 +308,23 @@ class InstanceScorer(object): def __init__(self, features_producer, classifier): self.features_producer = features_producer self.classifier = classifier - - def __call__(self, coordinates, track_set): + + def _call_batch(self, coordinates, track_set): features_matrix = self.features_producer(coordinates=coordinates, track_set=track_set) if (hasattr(self.classifier, 'predict_proba')): return self.classifier.predict_proba(features_matrix) else: return self.classifier.predict(features_matrix) + + def __call__(self, coordinates, track_set, batch_size=None): + if (batch_size is None): + batch_size = len(coordinates) + to_return = [] + for idx in range(0,len(coordinates), batch_size): + to_return.extend(self._call_batch( + coordinates=coordinates[idx:idx+batch_size], track_set=track_set)) + return np.array(to_return) def compute_precrecthres_list(self, coordinates, track_set, labels): """ @@ -345,7 +362,8 @@ def prepare_instance_scorer( n_jobs=10, max_iter=3000)), shift_fraction=0.3, - min_overlap=0.7): + min_overlap=0.7, + n_jobs=10): onehot_track_name = "sequence" score_track_names = ([task_name+"_hypothetical_contribs" @@ -370,7 +388,8 @@ def prepare_instance_scorer( filt_trimmed_patterns) = get_exemplar_motifs_for_all_patterns( patterns=prefilt_trimmed_patterns, pattern_comparison_settings=pattern_comparison_settings, - affmat_min_frac_of_median=affmat_min_frac_of_median) + affmat_min_frac_of_median=affmat_min_frac_of_median, + n_jobs=n_jobs) #get the flattened list of exemplar motifs and make FeaturesProducer @@ -381,7 +400,8 @@ def prepare_instance_scorer( motifs=all_exemplarmotifs, pattern_comparison_settings=pattern_comparison_settings, onehot_track_name=onehot_track_name, - bg_freq=bg_freq) + bg_freq=bg_freq, + n_jobs=n_jobs) #get coordinates, labels and their features all_coordinates, labels = get_coordinates_and_labels( @@ -400,3 +420,72 @@ def prepare_instance_scorer( track_set=track_set, labels=labels) return instance_scorer + + +def get_windows_to_be_scanned(scanning_window_width, contrib_scores, + val_transformer, cutoff_value, plot_save_dir="."): + sliding_window_sizes = val_transformer.sliding_window_sizes + transformed_scoretrack, transformed_scoretrack_bestwindowwidth =( + val_transformer.transform_score_track(np.sum(contrib_scores, axis=-1))) + #scores cdf + scores_cdf = np.sort(np.concatenate(transformed_scoretrack, axis=0)) + values_above_cutoff = [x >= cutoff_value for x in transformed_scoretrack] + frac_vals_above_cutoff =\ + np.sum(np.concatenate(values_above_cutoff, axis=0))/sum( + [len(x) for x in values_above_cutoff]) + print("Fraction of values above cutoff:", frac_vals_above_cutoff) + #prepare the coordinates for the windows to be scanned + coordinates_to_be_scanned = [] + for rowidx, row in enumerate(values_above_cutoff): + #a mask of which positions are start positions (given + # window length scanning_window_width) + window_start_mask = np.zeros(len(row)-(scanning_window_width-1)).astype(bool) + colindices = np.nonzero(row)[0] + bestslidingwindowwidths =\ + transformed_scoretrack_bestwindowwidth[rowidx][colindices] + bestslidingwindow_startindices = ( + colindices-(((bestslidingwindowwidths-1)/2.0).astype(int))) + for slidingwindowstart, slidingwindowwidth in zip(bestslidingwindow_startindices, + bestslidingwindowwidths): + scanning_window_begin_startrange = max((slidingwindowstart + - max(scanning_window_width-slidingwindowwidth,0)),0) + scanning_window_begin_endrange = min((slidingwindowstart + + max(slidingwindowwidth-scanning_window_width,0)), + len(window_start_mask)-1) + window_start_mask[scanning_window_begin_startrange: + scanning_window_begin_endrange] = True + coordinates_to_be_scanned.extend([ + core.SeqletCoordinates( + example_idx=rowidx, start=start_idx, + end=start_idx+scanning_window_width, + is_revcomp=is_revcomp) + for start_idx in np.nonzero(window_start_mask)[0] + for is_revcomp in [True, False] + ]) + return coordinates_to_be_scanned, transformed_scoretrack + + +def collect_coordinates_by_regionidx(coordinates): + regionidx_to_motifmatchandcoords = defaultdict(list) + for coordinate in coordinates: + regionidx_to_motifmatchandcoords[ + coordinate.example_idx].append(coordinate) + return regionidx_to_motifmatchandcoords + + +def scan_and_process_results(instance_scorer, track_set, coordinates): + scan_results = instance_scorer(coordinates, track_set=track_set) + matching_motifidx = np.argmax(scan_results, axis=-1) + #get motifmatch to coordinates + motifmatch_to_coordinates = defaultdict(list) + for motifidx,coordinate in zip(matching_motifidx,coordinates): + if (motifidx < scan_results.shape[-1]): + motifmatch_to_coordinates[motifidx].append(coordinate) + motifmatch_to_coordinatesbyregionidx = {} + for motifmatch in motifmatch_to_coordinates: + motifmatch_to_coordinatesbyregionidx[motifmatch] =\ + collect_coordinates_by_regionidx( + motifmatch_to_coordinates[motifmatch]) + + return (motifmatch_to_coordinates, + motifmatch_to_coordinatesbyregionidx) diff --git a/modisco/util.py b/modisco/util.py index 4965973..16bdf77 100644 --- a/modisco/util.py +++ b/modisco/util.py @@ -613,3 +613,19 @@ def fetch_tomtom_matches(ppm, background=[0.25, 0.25, 0.25, 0.25], tomtom_exec_p os.system('rm ' + fname) return r + + +def show_or_savefig(plot_save_dir, filename): + from matplotlib import pyplot as plt + if plt.isinteractive(): + plt.show() + else: + import os, errno + try: + os.makedirs(plot_save_dir) + except OSError as e: + if e.errno != errno.EEXIST: + raise + fname = (plot_save_dir+"/"+filename) + plt.savefig(fname) + print("saving plot to " + fname) diff --git a/modisco/value_provider.py b/modisco/value_provider.py index de2fbb5..b340b23 100644 --- a/modisco/value_provider.py +++ b/modisco/value_provider.py @@ -186,12 +186,13 @@ def save_hdf5(self, grp): @classmethod def from_hdf5(cls, grp): from .coordproducers import SavableIsotonicRegression + sliding_window_sizes =\ + np.array(grp["sliding_window_sizes"]).astype("int") + print("Loaded sliding window sizes:",sliding_window_sizes) pos_irs = util.load_list_of_objects( grp=grp["pos_irs"], obj_class=SavableIsotonicRegression) neg_irs = util.load_list_of_objects( grp=grp["neg_irs"], obj_class=SavableIsotonicRegression) - sliding_window_sizes =\ - np.array(grp["sliding_window_sizes"]).astype("int") return cls(pos_irs=pos_irs, neg_irs=neg_irs, sliding_window_sizes=sliding_window_sizes) diff --git a/modisco/visualization/viz_sequence.py b/modisco/visualization/viz_sequence.py index 9092fa6..89bf8d2 100644 --- a/modisco/visualization/viz_sequence.py +++ b/modisco/visualization/viz_sequence.py @@ -135,3 +135,19 @@ def plot_weights(array, ax = fig.add_subplot(111) plot_weights_given_ax(ax=ax, array=array,**kwargs) plt.show() + + +def plot_score_track_given_ax(arr, ax, threshold=None, **kwargs): + ax.plot(np.arange(len(arr)), arr, **kwargs) + if (threshold is not None): + ax.plot([0, len(arr)-1], [threshold, threshold]) + ax.set_xlim(0,len(arr)-1) + + +def plot_score_track(arr, threshold=None, figsize=(20,2), **kwargs): + fig = plt.figure(figsize=figsize) + ax = fig.add_subplot(111) + plot_score_track_given_ax(arr, threshold=threshold, ax=ax, **kwargs) + plt.show() + + From 95a5c5d7c95859f514ac40ba16444816c3bdf182 Mon Sep 17 00:00:00 2001 From: AvantiShri Date: Tue, 22 Dec 2020 13:41:08 -0800 Subject: [PATCH 16/30] some adjustments --- modisco/coordproducers.py | 13 ++++---- .../hit_scoring/exemplar_based_hitscoring.py | 33 ++++++++++++++----- 2 files changed, 32 insertions(+), 14 deletions(-) diff --git a/modisco/coordproducers.py b/modisco/coordproducers.py index fbd3b61..1829ed2 100644 --- a/modisco/coordproducers.py +++ b/modisco/coordproducers.py @@ -405,12 +405,13 @@ def irval_to_probpos(irval, frac_neg): # = 1 + f_n(1 - 1/a(x)) #If solving for p_pos=0, we have -1/(1 - 1/a(x)) = f_n #As f_n --> 100%, p_pos --> 2 - 1/a(x); this assumes max(a(x)) = 0.5 - return np.minimum(np.maximum(1 + frac_neg*(1 - (1/irval)), 0.0), 1.0) + return np.minimum(np.maximum(1 + frac_neg*( + 1 - (1/np.maximum(irval,1e-7))), 0.0), 1.0) class SavableIsotonicRegression(object): - def __init__(self, origvals, nullvals, increasing, min_frac_neg=0.99): + def __init__(self, origvals, nullvals, increasing, min_frac_neg=0.95): self.origvals = origvals self.nullvals = nullvals self.increasing = increasing @@ -434,7 +435,7 @@ def __init__(self, origvals, nullvals, increasing, min_frac_neg=0.99): if (implied_frac_neg > 1.0 or implied_frac_neg < self.min_frac_neg): implied_frac_neg = max(min(1.0,implied_frac_neg), self.min_frac_neg) - print("Adjusted frac neg is",implied_frac_neg) + print("To be conservative, adjusted frac neg is",implied_frac_neg) self.implied_frac_neg = implied_frac_neg def transform(self, vals): @@ -602,9 +603,9 @@ def __call__(self, score_track, null_track, tnt_results=None): np.concatenate(precisiontransformed_score_track, axis=0)) from matplotlib import pyplot as plt - plt.plot((np.arange(len(subsampled_prec_vals))/ - len(subsampled_prec_vals)), - sorted(subsampled_prec_vals)) + plt.plot(sorted(subsampled_prec_vals), + (np.arange(len(subsampled_prec_vals))/ + len(subsampled_prec_vals))) plt.xlabel("Tranformed IR precision value") plt.ylabel("CDF") util.show_or_savefig(plot_save_dir=self.plot_save_dir, diff --git a/modisco/hit_scoring/exemplar_based_hitscoring.py b/modisco/hit_scoring/exemplar_based_hitscoring.py index dce9cc6..ece8e94 100644 --- a/modisco/hit_scoring/exemplar_based_hitscoring.py +++ b/modisco/hit_scoring/exemplar_based_hitscoring.py @@ -422,13 +422,11 @@ def prepare_instance_scorer( return instance_scorer -def get_windows_to_be_scanned(scanning_window_width, contrib_scores, - val_transformer, cutoff_value, plot_save_dir="."): +def get_windows_to_be_scanned_interior( + transformed_scoretrack, transformed_scoretrack_bestwindowwidth, + val_transformer, scanning_window_width, cutoff_value, plot_save_dir="."): sliding_window_sizes = val_transformer.sliding_window_sizes - transformed_scoretrack, transformed_scoretrack_bestwindowwidth =( - val_transformer.transform_score_track(np.sum(contrib_scores, axis=-1))) #scores cdf - scores_cdf = np.sort(np.concatenate(transformed_scoretrack, axis=0)) values_above_cutoff = [x >= cutoff_value for x in transformed_scoretrack] frac_vals_above_cutoff =\ np.sum(np.concatenate(values_above_cutoff, axis=0))/sum( @@ -463,6 +461,22 @@ def get_windows_to_be_scanned(scanning_window_width, contrib_scores, for is_revcomp in [True, False] ]) return coordinates_to_be_scanned, transformed_scoretrack + + +def get_windows_to_be_scanned(contrib_scores, val_transformer, + scanning_window_width, + cutoff_value, plot_save_dir="."): + print("computing the transformed score track") + transformed_scoretrack, transformed_scoretrack_bestwindowwidth =( + val_transformer.transform_score_track(np.sum(contrib_scores, axis=-1))) + print("done computing the transformed score track") + return get_windows_to_be_scanned_interior( + transformed_scoretrack=transformed_scoretrack, + transformed_scoretrack_bestwindowwidth= + transformed_scoretrack_bestwindowwidth, + val_transformer=val_transformer, + scanning_window_width=scanning_window_width, + cutoff_value=cutoff_value, plot_save_dir=plot_save_dir) def collect_coordinates_by_regionidx(coordinates): @@ -473,8 +487,10 @@ def collect_coordinates_by_regionidx(coordinates): return regionidx_to_motifmatchandcoords -def scan_and_process_results(instance_scorer, track_set, coordinates): - scan_results = instance_scorer(coordinates, track_set=track_set) +def scan_and_process_results(instance_scorer, track_set, coordinates, + batch_size=None): + scan_results = instance_scorer(coordinates, track_set=track_set, + batch_size=batch_size) matching_motifidx = np.argmax(scan_results, axis=-1) #get motifmatch to coordinates motifmatch_to_coordinates = defaultdict(list) @@ -488,4 +504,5 @@ def scan_and_process_results(instance_scorer, track_set, coordinates): motifmatch_to_coordinates[motifmatch]) return (motifmatch_to_coordinates, - motifmatch_to_coordinatesbyregionidx) + motifmatch_to_coordinatesbyregionidx, + scan_results) From 804655e51fd1e83e138e2d09440d32ac68ed38b9 Mon Sep 17 00:00:00 2001 From: Avanti Shrikumar Date: Sat, 26 Dec 2020 05:35:03 -0800 Subject: [PATCH 17/30] precision scores for the hits --- .../TF_MoDISco_TAL_GATA_hitscoring.ipynb | 1246 +++++++++++++---- modisco/core.py | 5 + .../hit_scoring/exemplar_based_hitscoring.py | 132 +- 3 files changed, 1094 insertions(+), 289 deletions(-) diff --git a/examples/simulated_TAL_GATA_deeplearning/TF_MoDISco_TAL_GATA_hitscoring.ipynb b/examples/simulated_TAL_GATA_deeplearning/TF_MoDISco_TAL_GATA_hitscoring.ipynb index ba3ae7d..57767eb 100644 --- a/examples/simulated_TAL_GATA_deeplearning/TF_MoDISco_TAL_GATA_hitscoring.ipynb +++ b/examples/simulated_TAL_GATA_deeplearning/TF_MoDISco_TAL_GATA_hitscoring.ipynb @@ -41,7 +41,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Requirement already satisfied: modisco in /Users/avantishrikumar/Research/tfmodisco (0.5.8.1)\n", + "Requirement already satisfied: modisco in /Users/avantishrikumar/Research/tfmodisco (0.5.10.0)\n", "Requirement already satisfied: numpy>=1.9 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from modisco) (1.18.5)\n", "Requirement already satisfied: joblib>=0.11 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from modisco) (0.16.0)\n", "Requirement already satisfied: scikit-learn>=0.19 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from modisco) (0.23.1)\n", @@ -50,14 +50,14 @@ "Requirement already satisfied: tqdm>=4.38.0 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from modisco) (4.47.0)\n", "Requirement already satisfied: psutil>=5.4.8 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from modisco) (5.7.0)\n", "Requirement already satisfied: matplotlib>=2.2.5 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from modisco) (3.2.2)\n", - "Requirement already satisfied: scipy>=0.19.1 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from scikit-learn>=0.19->modisco) (1.4.1)\n", "Requirement already satisfied: threadpoolctl>=2.0.0 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from scikit-learn>=0.19->modisco) (2.1.0)\n", + "Requirement already satisfied: scipy>=0.19.1 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from scikit-learn>=0.19->modisco) (1.4.1)\n", "Requirement already satisfied: six in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from h5py>=2.5->modisco) (1.15.0)\n", "Requirement already satisfied: python-igraph>=0.8.0 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from leidenalg>=0.7.0->modisco) (0.8.2)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from matplotlib>=2.2.5->modisco) (1.2.0)\n", + "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from matplotlib>=2.2.5->modisco) (2.4.7)\n", "Requirement already satisfied: cycler>=0.10 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from matplotlib>=2.2.5->modisco) (0.10.0)\n", "Requirement already satisfied: python-dateutil>=2.1 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from matplotlib>=2.2.5->modisco) (2.8.1)\n", - "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from matplotlib>=2.2.5->modisco) (2.4.7)\n", - "Requirement already satisfied: kiwisolver>=1.0.1 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from matplotlib>=2.2.5->modisco) (1.2.0)\n", "Requirement already satisfied: texttable>=1.6.2 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from python-igraph>=0.8.0->leidenalg>=0.7.0->modisco) (1.6.3)\n" ] } @@ -68,7 +68,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": { "colab": {}, "colab_type": "code", @@ -90,7 +90,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -145,7 +145,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -176,7 +176,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "metadata": { "colab": {}, "colab_type": "code", @@ -246,7 +246,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "metadata": { "colab": {}, "colab_type": "code", @@ -363,7 +363,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 8, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -379,21 +379,21 @@ "name": "stdout", "output_type": "stream", "text": [ - "MEMORY 0.32499712\n", + "MEMORY 0.367886336\n", "On task task0\n", "Fitting - on window size 5\n", "peak(mu)= 0.00486588878557086\n", "Computing window sums\n", "Done computing window sums\n", "For increasing = True , the minimum IR precision was 0.2954850349262155 occurring at 5.7220458984375e-06 implying a frac_neg of 0.41941626448668695\n", - "Adjusted frac neg is 0.99\n", + "To be conservative, adjusted frac neg is 0.95\n", "For increasing = False , the minimum IR precision was 0.35928651361524633 occurring at -5.638343282043934e-06 implying a frac_neg of 0.5607600296390388\n", - "Adjusted frac neg is 0.99\n" + "To be conservative, adjusted frac neg is 0.95\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -412,14 +412,14 @@ "Computing window sums\n", "Done computing window sums\n", "For increasing = True , the minimum IR precision was 0.31974367348777494 occurring at 6.765127182006836e-06 implying a frac_neg of 0.47003410483096586\n", - "Adjusted frac neg is 0.99\n", + "To be conservative, adjusted frac neg is 0.95\n", "For increasing = False , the minimum IR precision was 0.4258213778275138 occurring at -2.9428978450596333e-05 implying a frac_neg of 0.7416183072374903\n", - "Adjusted frac neg is 0.99\n" + "To be conservative, adjusted frac neg is 0.95\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -438,14 +438,14 @@ "Computing window sums\n", "Done computing window sums\n", "For increasing = True , the minimum IR precision was 0.3469747405521833 occurring at 1.621246337890625e-05 implying a frac_neg of 0.5313343328335832\n", - "Adjusted frac neg is 0.99\n", + "To be conservative, adjusted frac neg is 0.95\n", "For increasing = False , the minimum IR precision was 0.11749949829420027 occurring at -1.7642974853515625e-05 implying a frac_neg of 0.13314383172256963\n", - "Adjusted frac neg is 0.99\n" + "To be conservative, adjusted frac neg is 0.95\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbIAAAEGCAYAAAAAKBB/AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3debwcVZ3//9f7ZiEhbLIouyyyuLFIhCAugKDAgLigooKCC18QBGVUlJmfCKODC6ggAmbYFWEcBYmKImoQUCL7jiAGDAFkhwQIITf3/fvjVCedSy91+3Z3Vff9PB+PfnR3VZ2qcxutT86pcz5HtgkhhBB61UDRFQghhBBGIwJZCCGEnhaBLIQQQk+LQBZCCKGnRSALIYTQ08YXXYFOGxgY8OTJk4uuRggh9JTnn3/etnuisdP3gWzy5Mk899xzRVcjhBB6iqQFTfafBewJPGr7dTX2CzgJ2AN4HjjA9o2dqGtPRNsQQgilcw6wW4P9uwObZK+DgNM6VZG+b5G16tH5L7Bw0VDDY9ZYcTkmTRjXpRr1jhcHh3hk3gtFVyOEMW/NlScxYVxn2iu2r5S0QYND9gbOc8q6MUvSKpLWsv1wu+sSgayOI//3Fq6+9/GGx+zwqtU4/5PTulSj3vHp82/g93c9WnQ1QhjzrvzCTqy/2vJFXX4d4IGq73OzbRHIuuVTb92Ivbdau+7+c6+5n8fnv9i9CvWQuU8t4LVrr8QBb9qg6KqEMKatusLE0RQfL+n6qu/TbU8fQXnV2NaRnIgRyOp426ZrNNz/x789yj8ee7ZLtektCxYtZqv1VuH9U9cruiohhNYN2p46ivJzgeqbwLrAQ6OrUm0RyFokwdAYz7f82Qtv4tr7nnzJ9n/Ne4E3bbxaATUKIZTIDOAwSRcC2wHPdOL5GEQga5kQY33lgD/+7VFesdIktlpvlWW2S/DBN65fUK1CCN0g6QJgR2B1SXOBY4AJALZPBy4lDb2/lzT8/sBO1SUCWYukDnX29pAFixazy2tewVG7bV50VUIIXWb7Q032Gzi0G3WJeWQtksRYbpAtWjzEosVmckw/CCEULFpkLRoQY6pr8ZKbH+Trv75rSSu08qcvPzECWQihWBHIWiTG1mCPm+Y8zVPPv8g+2ywdhDRhnNjtdWsWWKsQQohA1jJJeAw9JbPN8hPHc/x7X190VUIIYRnxjKxFEmPqGdmQU3dqCCGUTQSyFqXh90XXonuGbAYUkSyEUD4RyFqkMTbYY8gwEE2yEEIJRSBr0cAYm0dmO7oWQwilFIGsRUIMjakWWXQthhDKKQJZi8bmYI8IZCGE8olA1qI0/H7sGLKJOBZCKKMIZC0ac4M9hqJrMYRQTqUJZJImSbpW0i2S7pB0bI1jdpT0jKSbs9dXiqgrpMweYyiOxTyyEEJplSaQAQuBnW1vCWwF7CZpWo3jrrK9VfY6rrtVXGpABQ72mHl81y8Zgz1CCGVVmhRVWcr/ypLLE7JXads8Y20ZF5t4RhZCKKUytciQNE7SzcCjwOW2/1rjsO2z7sffSHptnfMcJOl6SdcPDg52pK4DY2wZl2iRhRDKqlSBzPZi21sB6wLbSnrdsENuBF6ZdT9+H/hFnfNMtz3V9tTx4zvX6Ix5ZCGEULxSBbIK208DVwC7Dds+z/az2edLgQmSVu9+DbNutrETxxiKrsUQQkmVJpBJWkPSKtnnycAuwN+GHbOmlG6nkrYl1f+JbtcVsq7FIi5cEEeLLIRQUqUZ7AGsBZwraRwpQP3U9q8kHQxg+3RgH+AQSYPAAmBfFzSZKy2sOTZC2d3/ms9j8xcyUJp/9oQQwlIdCWSSXgasTQo299sealbG9q3A1jW2n171+RTglDZWtWVjJUXVosVDvOuUq1k4OMQOr1qt6OqEEMJLtC2QSVoZOBT4EDAReAyYBLxC0izgVNsz23W9og2MkRWi578wyMLBIT71lg05bKdNiq5OCCG8RDtbZD8DzgPekg3WWELSNsD+kjayfWYbr1kcpQEQ/Wjm3Y8y6x/p0eO8F9L0hc3XXImVl59QZLVCCKGmtgUy27s22HcDcEO7rlUGon9nRJ9w2d3c9fA8Jo5PD8VWWX4Cm625YsG1CiH0M0k7AF8FXkmKTSkToL1Rs7Lt7Fp8Q6P9tm9s17XKIC2s2Z+RbPGQ2eXVr2D6R6cWXZUQwthxJvA5UqNn8UgKtrNr8cQG+wzs3MZrFU593LUYQggFeMb2b1op2M6uxZ3ada5ekFJU9W8kiyljIYQumynp28BFpCTyQL7evHZ2Lb630X7bF7XrWmWQ5pEVXYvOsLNngCGE0D3bZe/VzzRy9ea1s2txrwb7TIqy/SOaLCGE0Daj6dVrZ9fige06Vy+oLDJpG/VZUDOOOB1C6KpsLvIxwFuzTX8CjrP9TLOybc/sUW/V5iIXweyEStfbkGFcn930Y+2xEEIBzgJuBz6Qfd8fOBto+NgKOpOi6rmqz5OAPYG7OnCdQqmqRUafPU/q00d/IYRy29j2+6q+H5utT9lU2wOZ7WWG4Us6AZjR7usUbUnXYrHV6JgY7BFC6LIFkt5s+2pYMkF6QZ6C3ch+vzzQdGZ2r6k8F+vHDPhOwxZDCKGbDiGtgLIy6Q70JHBAnoKdeEZ2G0sbKuOANYC+ej5WrQ/jWN+2MkMI7SNpN+Ak0n3+DNvfGLZ/ZeDHwPqkWHOC7bPrnc/2zcCWklbKvs/LW5dOtMj2rPo8CDxie7AD1ylUvy8y2d9/XQhhNLJ1I38A7ArMBa6TNMP2nVWHHQrcaXsvSWsAd0s63/aLw861n+0fSzpy2HYAbH+nWX068Yzsn9kf+Yrs/GsrZcGY0+5rFakSx/qxaxHTd1MKQghttS1wr+3ZAJIuBPYGqgOZgRWVbiYrkLoKazVqpmTvLWcm70TX4mdIcwEeASoLahrYot3XKtLSeWTF1qMT+vBPCiGM3HhJ11d9n257evZ5HeCBqn1zWZqZo+IU0kC/h0hB6oO1Flm2/cPs/diWK9pqwQaOADaz/UQHzl0aS+eR9edtP9pjIYx5g7brLYFR6xYx/Gb4TuBmUoqpjYHLJV1V79mXpG8BXyONVPwtsCXwWds/blbRgWYHtOABoOlM7F6nPh5+n7KVFF2LEEKJzQXWq/q+LqnlVe1A4CIn9wL3AZs3OOc7siC3Z3b+TYEv5KlMJ1pks4ErJP2aZTMYN3xgJ2kScCWwXFavn9k+ZtgxIo2S2QN4HjigqHXOlj6ILOLqndWHf1IIob2uAzaRtCHwILAv8OFhx8wB3g5cJekVwGak+FBPZQn6PYALbD+Z91l9JwLZnOw1MXvltRDY2fazkiYAV0v6je1ZVcfsDmySvbYDTuOl/bJdUfl5+3Upl2iQhRDqsT0o6TDgMtLw+7Ns3yHp4Gz/6cB/AedkU7IEHGX78Qan/aWkv5G6Fj+djXR8IU99OjFqsaUHdk4R4dns64TsNTxK7A2clx07S9Iqktay/XDLFW6R+nmwR4xaDCE0YftS4NJh206v+vwQ8I4RnO9Lkr4JzLO9WNJzpHt+U514RoakL1a/j6DcuCy31qPA5bb/OuyQWiNl1qlxnoMkXS/p+sHBzkxhq8wj68M4hvvyrwohlJGknbP39wI7AXtnn3cD3pTnHB0JZKT+0ur3XGwvtr0V6cHhtpJeN+yQPCNlsD3d9lTbU8eP70wWrsLnkc08vqOnj/ZYCKFL3pa971XjtWe9QtU6nWuxpfuh7aclXUGKyLdX7cozUqYrlj4jK+LqndWHCf1DCCVVGdQ3mjUtO9UiGzFJa0haJfs8GdgF+Nuww2YAH1UyDXimiOdjUDVqsQ+74VLO4IhkIYTukfTflRiQfX+ZpK/lKVuaQAasBcyUdCtpaOfltn8l6eDKSBjSg8XZwL3A/wCfLqaqxQ32+O7l93DN7Ce4ZnZfzzcPIYw9u9t+uvLF9lOkofhNdWMZl1xs3wpsXWN79SgYkxJRFq7SYunHrkWIFaJDCF03TtJythfCkp655fIU7FQguyJ7n9mh8xduoOjBHh1kOzoWQwjd9mPgD5LOJg3i+zhwbp6CHQlkto+sfu9H/ZyiKoQQus32t7JHS7uQhpv9l+3L8pTtRPb75YF/B9a3/SlJm5CSCP+q3dcqUtVaOQXXpP1MdC2GEApxFylZ8e8lLS9pRdvzmxXqxGCPs0npprbPvs8lZTTuK/0+/D5GLYYQuknSp4CfAT/MNq0D/CJP2U4Eso1tfwtYBGB7AX04K6m/kwb34R8VQii7Q4EdgHkAtv8OvDxPwaaBrEZ2jWZezEabOCu/MVVZ8PvFkoU1+/SmH12LIYQuW2j7xcoXSePJOQwhT4vsdEnXSvp09WS1Bo4hLYq2nqTzgT8AI8q52AuWpqjq7nWnzZne/KBRSkmDO36ZEEKo9idJRwOTJe0K/B/wyzwFmw72sP3mbMDGx4HrJV0LnG378jrHXy7pRmAaqUvxiCap+3vS0nlk/dci67+/KITQA44CPgncBvw/UgKMM/IUzDVq0fbfJf0ncD1wMrB1tsjl0bYvqj5W0huyj5XUUetLWhn4p+3OpKIvQP8Pv48mWQihOyQNALfafh0pa9OINA1kkrYgLVn9b8DlwF62b5S0NnANcNGwIqcCbwBuJd0NX5d9Xk3SwbZ/N9JKllFfD7+PrsUQQhfZHpJ0i6T1bc8Zafk8LbJTSBHy6GwEYuXCD2WttOHuBz5h+w4ASa8BvkBaLfQioD8CWfbeh3GMfm5nhhBKay3gjuzx1XOVjbbf1axgnkB2ke0fVW+QdITtk4Zvz2xeCWJZJe6UtLXt2f206nA/L6wJ0bEYQui6Y1stmCeQfRT43rBtBwAn1Tn+bkmnARdm3z8I3CNpObK5Zf2gEpPPvOo+VlthYt3jBiT22WZdNlh9SpdqNnrRtRhC6Dbbf5K0JrAtqY1wne1/5SlbN5BJ+hDwYWBDSTOqdq0INFpD5ADS8iqfJf3D/mrg86QgtlOeSvWCV662PCsuN56Lbprb8LhFi82ioSG+vPurR3/RDq8KXdGvrcwQQnlJ+iTwFeCPpNjxfUnH2T6rWdlGLbK/kEYerg6cWLV9PmnwRk3Zc7QTh5WpeLZZhXrFa9demduOfWfT4179//22J5+jRYqqEEKXfQHY2vYTAJJWI8Wh1gOZ7X8C/2RpzsRcJO0AfBV4ZfX5bW80kvP0k14b2Wg7uhZDCN02l9RQqpgPPJCnYKOuxauzydDzWba3SaQ1LleqU/RM4HPADcDiPJUI5WJisEcIoeseBP4q6RLSbWhv4FpJlWXBvlOvYKMW2Zuz9xVHWJlnbP9mhGX6VrRsQgghl39kr4pLsvemMSjPhOiNgbm2F0raEdgCOM/203WKzJT0bdKcsSXJgm3f2OQ66wHnAWsCQ8B02ycNO2ZH0h93X7bpItvHNfsbitZjPYvZqMWIwCGE7rHd0eH3PwemSnoVqdtwBvATYI86x2+XvU+triOwc5PrDAL/nmUNWRG4QdLltu8cdtxVtvfMUe/Qol57phdCGNvyBLIh24OS3gN8z/b3Jd1U72DbLQ2xt/0wWX5G2/Ml3UVaWG14IOsp0a4JIYTOyhPIFmVzyj4G7JVtm9CogKR/A14LTKpsG0kXoKQNgK2Bv9bYvb2kW4CHgM9XZxGpKn8QcBDAxIn1Jyt3S8faNzOPh52+3PbTmni2F0LoHXkC2YHAwcDXbd8naUPgx/UOlnQ6sDxp8vMZwD7AtXkrJGkFUnfmZ23PG7b7RuCVtp+VtAdpGexNhp/D9nRgOsCUKVMK7SfryWdNjnlkIYTukPR9Gvx73/bhzc7RdGFN23faPtz2Bdn3+2x/o0GRN9n+KPBU9vBue2C9ZtcBkDSBFMTOH748THbtebafzT5fCkyQtHqecxcpHjmFEEJd15Oma00irZzy9+y1FTmncOUZtTh8gnNlHlm9Cc4vZO/PZ0u9PAFsmOM6Ig0muavefIEsD9cjti1pW1IgbpQuK7QguhZDCN1i+1wASQcAO9lelH0/nZyrpeTpWhzpBOdfSloF+DapK9DkWyhtB2B/4DZJN2fbjgbWB7B9Oqmb8hBJg8ACYF+XfIhdL8YD2z1Z7xBCT1ubNGfsyez7Ctm2pvIEstwTnLNVPv+QzTH7uaRfAZNsP9OsrO2raXLft30KaX20nuIeS8PbW7UNIfSJbwA3SZqZfX8bqTewqTyBLPcE52yVzxPJ8jPaXlhdJvSO6FoMIXST7bMl/Yalc5G/NOplXKqMdILz7yS9j5R1I/5xr94b7BGZPUIIzUjajbQu5TjgjFqDALNsTN8jTdl63Pbbmpx2HPAYKTZtKmlT21c2q0vTQNbCBOcjgSnAYkkLaJ5kOJRMr3WFhhC6S9I44AfArqSs9ddJmlGdiSkbK3EqsJvtOZJe3uSc3yQtxHwHKU0hpEbT6AOZpFcA/w2sbXt3Sa8Btrd9Zq3jW0gy3Nd6tV3Tq/UOIXTFtsC9tmcDSLqQlK2+OhPTh0k9c3MAbD/a5JzvBjbLHkmNSNN5ZMA5wGUsHT1yD2n157okvUvSCdkr8iL2GMc6LiEEGC/p+qrXQVX71mHZtcLmZtuqbQq8TNIVkm6Q9NEm15tNk6xRdSua45jVbf9U0pcBsryLdYfhS/oG8Ebg/GzTEZLebPtLrVQwdF90LIYQgEHbU+vsq/VP3eG3jvHANsDbgcnANZJm2b6nzjmfB26W9AeWHVjYNLNHnkD2XLbktAEkTQMaDaffA9jK9lB2/LnATcCYDGS9OmgiUlSFEBqYy7IZm9Yl5b8dfszjtp8jxZErgS1JvXq1zMheI5YnkB2ZnXxjSX8G1iBNTG5kFZZOalu5lYr1k54bvOkYfh9CaOg6YJMs9+6DwL6kZ2LVLgFOkTQemEgaAf/deiesZPhoRZ5RizdKehuwGak5eXclhUgdx7N0UpuAtwLtT9HeI3ohINjmtgef4dkXBgEY6rXAG0LoquwR02Gk8RPjgLNs3yHp4Gz/6bbvkvRb4FbSKMQzbN9e75yS7qPGk40G6RCXqBvIJL23zq5NJVErqW920QskXUF6TibgqLyT2vpV2cPCXQ/P512n/HmZbSssl6exHkIYq7LE7ZcO23b6sO/fJqUrzKP6edwk4P3AqnkKNrpbVdYeeznwJuCP2fedgCtImT5qyhbJbKmvM3TfswtTS+w//+3VvH6dlRkYEFusO+Z7hEMIXWR7eAL470m6GvhKs7J1A5ntAwGyfImvyYITktYiTYQLOfRAz+KSZ3ibr7kS2220WsG1CSGMRZLeUPV1gNRCyzUvOU//0QaVIJZ5hDQ/IOTUK4+ceuF5Xgihb51Y9XkQuB/4QJ6CeQLZFZIuAy4gPe7ZF5jZuEjoJZU4G3EshFCUFtIhLpFnhejDgNNJ4/+3Aqbb/kzeC0i6K3sd1mole5mk0ucudESyEELBJK0s6TtVmUROlJTrYX2uoWm2LwYubqVytl8taXWWZtEPJVP2QBtCGBPOAm5naXfi/sDZQL0R9Et0ZYy17ceBX3fjWmXTE42cLI5FNo8QQoE2tv2+qu/HSro5T8G2BTJJ82kwZWosL+MSgz1CCKGpBVle3qsBJO0ALMhTMM8yLnsCl1ZyJ9ZTWb5F0nHAv4AfkRokHyHnEMpQjHhEFkIogYOB86qeiz0FfCxPwTzLuOwL/F3StyS9Osfx77R9qu35tufZPg14X7NCktaTNDMbGHKHpCNqHCNJJ0u6V9Ktw+YdlFIvtHIqLcZeTXAcQuht2UKd+9neEtgC2ML21rZvzVM+z6jF/YCtgX8AZ0u6RtJBkuq1shZL+oikcZIGJH0EqLvsS5VB4N9tvxqYBhyaLeJZbXdgk+x1EHBajvMWruw9i5XBHhHHQghFsL2YtOQLWQNo3kjK52mRkZ3058CFwFrAe4AbJdUahv9h0qiTR7LX+3lpVuRa13jY9o3Z5/nAXbx0oba9gfOczAJWyTKNlFj5o0OvPMMLIfS1myTNkLS/pPdWXnkK5nlG9i7gQGBj0nOvbW0/Kml5UrD5fvXxtu8nBZyWSdqA1Ar867Bd9VYlrc48QraS6UEAEydOHE1V2qKjgWLm8bBTexYXKH/IDSH0sVWBJ4Cdq7aZBnl9K/KMWtwH+K7tK6s32n5e0seHHyxpDeBTwAbV57f9kmNrkbQCqfX32RrNyzyrkmJ7OjAdYMqUKdHeaGLJYI+IZCGEglTy+7YiTyB7eHgQk/RN20fZ/kON4y8BrgJ+T75nY9XnnUAKYufXWSYmz6qkpdK24DDz+Dad6KUcqT1CCAWTdHKNzc8A19u+pFHZPM/Idq2xbfcGxy+fBbmf2v555dXsIkpD5s4E7rL9nTqHzQA+mo1enAY8MyyhcUmVu1EYLbIQQglMIqVB/Hv22oLU3fgJSd9rVLDRwpqHAJ8GNpZUPQRyReDPtUsB8CtJe2SLro3EDqSUJLdVzeY+GlgflizYdimwB3Av8Dzp2V0YrSWZPUIIoTCvAna2PQgg6TTgd6TG1G2NCjbqWvwJ8BvgeOBLVdvn236yQbkjgKMlLQQWke6PbpbZI5vN3fBe6tQHdmijY8qmF4JD5FoMIZTAOsAUUnci2ee1bS/O4kldjQKZbd8v6SWBQ9Kq9YJZJcNHWKpXhrfHhOgQQoG+Bdws6QpSG+CtwH9LmkIac1FXsxbZnsANpM6n6rucgY1qFZL01lrbhw8YGSt6ITY4uhZDCAWzfaakS4FtSbejo21XBvN9oVHZuoHM9p7Z+4YjrE/1BSdllbqBZecGjCllb5EtTVFVbD1CCGNXNuDv7cBGto+TtL6kbW1f26xso8EeDfMYVrJw1Ni+17DzrEdqMoY2u2b2EwDMGryHz+26acvnWTr4PiJZCKEwpwJDpEbPccB80nSsNzYr2Khr8cQG+0z+FtZc4HU5j+07ow0O3738HgCmzXmiHdWpyWVvMoYQxoLtbL9B0k0Atp+SlCs1U6OuxZ1aqYmk77P0H/kDpHkBt7Ryrn7RK6MCo2sxhFCgRVkWfMOSLFENlw+raNS1uLPtP9ZL2lgn8wbA9VWfB4ELbDeadxYK1hthNoTQ504GLgZeLunrpPSI/5mnYKOuxbcBfwT2qrGvbiJH2+dmzcHKQ5u781SkX0kx2COEEBqRNADcB3yRNOBDwLtt35WnfKOuxWOy9xFlz5C0I3AucH9WmfUkfWysDr/vDdl6ZDHYI4RQANtDkk60vT3wt5GWb5prUdJq2arMN0q6QdJJklZrUORE4B2232b7rcA7ge+OtGL9ohdCQ7TIQggl8DtJ71MLmRnyJA2+EHgMeB+pz/Ix4H8bHD/B9pLuRNv3ABNGWrF+UvKexRBCKIMjgf8DXpQ0P3vlWik6zzIuq9r+r6rvX5P07gbH3yDpTNIinAAfIU2IDiUV2e9DCEUbTXrDPIFspqR9gZ9m3/cBft3g+INJiX0PJ/WsXUma6DYm9UL+wqUpqspf1xBC/5L0LlKORYArbP8qT7lGw+/nszTH4pHAj7NdA8CzwDE1ygwAN9h+HVBvTbExp/SjFiuDPSKOhRAKIukbpCwe52ebjpD0ZttfalAMaDxqccTNvGzkyS2S1rc9Z6TlQzEiaXAIoQT2ALayPQQg6VzgJpZdRqymPF2LSHoZsAkpCTDQMJv9WsAdkq4Fnqs6/l15rtWPyp7ZI56RhRBGStJuwEnAOOAM29+oc9wbgVnAB23/rMlpVwEqS4StnLcuTQOZpE+SFstcF7gZmAZcQ/1ci8fmvXgIIYTek6WS+gFp9ea5wHWSZti+s8Zx3wQuy3Ha44GbJM1k6XpkX85TnzwtsiNI/ZazbO8kaXMaBCvbf8pz4bGiG62caXOmAye0XH5p0uBokoUQctkWuNf2bABJFwJ7A3cOO+4zNMlgL2mHLI3hRcAV2bECjrL9rzyVyTOP7AXbL2QXXM7234DNGlRqvqR5w14PSLpYUs3FOLNyZ0l6VNLtdfbvKOkZSTdnr6/kqHs5lLtncYnoWgwh5LQO8EDV97nZtiUkrQO8Bzi9yblOzt6vsf2w7Rm2L8kbxCBfi2yupFWAXwCXS3oKeKjB8d/J9v+EFFX3BdYk5Vw8C9ixTrlzgFOA8xqc+6rKgp9jSWpxdU4M9ggh1DBeUnUS+Om2KzejWreL4f9k/x6pVbW4yTSkRZLOBtaRdPLwnbYPb1rRZgfYfk/28atZ3+XKwG8bFNnN9nZV36dLmpWt+Hl0g+tcKWmDZvXpNVL5G2RLh99HKAshLDFoe2qdfXOB9aq+r8tLGzhTgQuz+8rqwB6SBm3/YthxewK7kMZdtJQ8I++oxTcAbybdk/9s+8UGhw9J+gBQGZ2yT9W+0d7Tt5d0C+kH+7ztO+rU9yDgIICJE3OtyxaIFlkIIbfrgE0kbQg8SOp5+3D1AbY3rHyWdA7wqxpBDNuPkwLeXbZbWrsyT9Lgr5Cy2a9GiqpnS2q0RsxHgP2BR4FHss/7SZoMHNZKJTM3Aq+0vSXwfVJXZ022p9ueanvq+PG5YnXH9EK2jLJP2A4hlIvtQdL9/DLgLuCntu+QdLCkg1s8Z8sLMOe5y38I2LpqwMc3SEHla3UqM5vaa5gBXN1KJbPzzqv6fKmkUyWtnkXzUnPJI0Vkvw8hjJTtS4FLh22rObDD9gGdrEueUYv3UzURGlgO+Ee9gyVtKukPldGHkrZo0oLLRdKalfT+krYl1f2J0Z43VE2I7oHWYwghDNco1+L3Sfe4haRMHZdn33elccvqf4AvAD8EsH2rpJ9QpwVXdb0LSCMaV5c0l5TLcUJ2jtNJz9oOkTQILAD2ddmbOnSxlTPzeNgp19zBl6j8jNEiCyF0m6QjG+233TRvb6OuxcqwyxuAi6u2X9HknMvbvnbYCLjBZhWx/aEm+08hDc/vOaWPtiGEUJxKXt/NSJOhZ2Tf9yKtntJUo6TB51Y+S5oIbJp9vdv2ogbnfFzSxmT3b0n7AA/nqUw/6oVGTgTaEEJRbB8LIOl3wBtsz8++f5W00GZTeXIt7kgatXg/6b68nqSPNUgafCgwHdhc0oPAfaSRjGNW6TtAY7BHCKF46wPVU7teBDbIUzDPqMUTgXfYvhvSYA7gAmCb4QdmCSIPsaH/RFkAABaWSURBVL2LpCnAQCW6hvKKCdEhhBL4EXCtpItJ/7x+D40zPS2RJ5BNqAQxANv3SJpQ68AsFck22efnah0z1vRCcIgUVSGEotn+uqTfAG/JNh1o+6Y8ZfMEshsknUmKlpC6CRulEblJ0gxS32b1emQX5alQP+qRnsXoWgwhFG15YJ7tsyWtIWlD2/c1K5QnkB1Meu51OOkf7VcCpzY4flXS/K7q9cpMStEfSizmkYUQiiLpGFJ+xs2As0nTr34M7NCsbMNAJmkAuMH260hZ7ZuyfWCe48aKXggNpR+MEkIYC94DbE3KHIXthySt2LhI0jCzh+0h4BZJ6+etiaR1s7XHHpX0iKSfS1o3b/l+VPZ520sHexRckRDCWPZiluSiMnVrSt6CeboW1yJl9riWZZ95vavO8WeT1iJ7f/Z9v2zbrnkr1Vd6IDjEYI8QQgn8VNIPgVUkfQr4OHBGnoJ5AtmxI6zMGrbPrvp+jqTPjvAcfWXuUwuYcctD7Lz5y1lhuWKz8deypL0YkSyEUBDbJ0jaFZhHek72FduX5ylbt2tR0qQsAL0f2Jy0DtmfKq8G53xc0n6SxmWv/RjDyX1Xn7IcNz/wNIdfcBM/u/6B5gUKFIM9QghFkfRN25fb/oLtz9u+XNI385Rt9IzsXNIIktuA3UkTo/P4OPAB4F+k1FT7ZNvGpHM/vi2//WyaFvHC4FDBtakjkgaHEIpX6/HT7nkKNurneo3t1wNk88iubXSiLJoeBWzX4PnZmDN54jg2WC09syzrmI+SViuEMAZIOgT4NLCRpFurdq0I/DnPORq1yJYkBs5WA21mjyzjR2triYwBLmnIiMEeIYQC/YSU6X5G9l55bWN7vzwnaNQi21JSZVVmAZOz7wJse6Vhx/8WeByYUn1cg+PHjEqXXWlbZI5ciyGEYth+BngG+BCApJeTFnNeQdIKtuc0O0fdFpntcbZXyl4r2h5f9fklQSl7QLcy8Ovq4+odP5ZUBlF0fD7ZzONHVTzCWAihKJL2kvR30oopfyKtuPKbPGUbTohuhe29233OXlf6Fln2Hg2yEEKBvgZMA+6xvSHwdtrwjKxlkn5a/T7WVeJDK3Fs2pzp7axKTUufkUUkCyEUZpHtJ4ABSQO2ZwJb5SnYqdm5r8reN+nQ+XtK5dlT2VtkIYRQoKclrUBKTH++pEeBPAMNO9Mia4Wks7L8jLfX2S9JJ0u6V9Ktkt7Q7Tq2ammLrJwhwzFsMYRQvL2BBcDnSIMH/0EavdhUaQIZcA6wW4P9u5NaeJsABwGndaFObVH2Z2QV8YwshFAU28/ZXkxak+yXpCVcct01S5P4z/aVkjZocMjewHlZduRZklaRtJbth7tSwVFY0rVYcD2aiTgWQiiKpP8HHEdqlQ2xdArXRs3KdiqQdeKeuA5QnaxwbrbtJYFM0kGkVhsTJ07sQFVGTirvci5LehajSRZCKM7ngdfafnykBTvVtfjtYe/tUOsuWzMy2J5ue6rtqePHl6PRmWaFF12L2sr67C6EMKb8A3i+lYIducvb/kn1e5vMBdar+r4u8FAbz99RkkobMGKsRwihBL4M/EXSX4GFlY22D29WsO0tMkmbSvpDZfShpC0k/WcbTj0D+Gg2enEa8EwvPB+rKHeLLImexRBCgX4I/BGYBdxQ9WqqEy2y/wG+kFUK27dK+glp1nZdki4AdgRWlzQXOAaYkJ3jdOBSYA/gXlLz88AO1L1jpF4Y7BGRLIRQmEHbR7ZSsBOBbHnb1w4bONB0UpvtDzXZb+DQUdatMEIjb5GNMndiPZfd8S+OnXEHQ1l9nluY/vNEiyyEUKCZ2UC9X7Js1+KTzQp2IpA9LmljsgaIpH2oMbJwrEktsnK0yW5+4GkenvcCH9hm6SPH9VdbnkkTxhVYqxDCGPfh7L16KbDCht8fCkwHNpf0ICmTca41ZfqZKjMiSsCGCQMDfHOfLYquSgghAJAlCm5J2wOZ7dnALpKmAAO257f7Gr1IqCxxLLUMoxsxhFACkna2/UdJ76213/ZFzc7R9kAm6SvDvlcqc1y7r9VLJBgaKkkoK0k1Qgi9S9JuwEnAOOAM298Ytv8jwFHZ12eBQ2zfUuNUbyONVqyVV9FA9wMZ8FzV50nAnsBdHbhOTylRzyIQDbIQQuskjQN+AOxKmuN7naQZtu+sOuw+4G22n5K0O+mR03bDz2X7mOzjcbbvG3adXN2NnehaPHFYRU4gzQEb06QWRi12iIkRiiGEUdkWuDd7lISkC0n5cJcEMtt/qTp+FimJRSM/B4avavIzYJtmlelG/qblyTHqpN+lFlm+SPbdy+8BYNqcJ0Z+oZnHw05fbniI7ZgzFkJoZryk66u+T7ddWem3Vu7bl7S2qnwC+E2tHZI2B14LrDzsOdlKpF695hXNc9BISLqNpb1o44A1SBmNxzaVJ7NHWeoRQii1QdtT6+zLnftW0k6kQPbmOufajPQIahWWfU42H/hUnop2okW2Z9XnQeAR27lW+exnZWv/RNdiCGEUcuW+lbQFcAawu+2aXUy2LwEukbS97WtaqUzbci1KWlXSqqQoWnktAFbKto9pAwMqzTIupnyBNYTQU64DNpG0oaSJwL4MGwshaX3SiMP9bd+T45zvkbSSpAlZvt7HJeWag9zOFtkN1L9H5pqd3c+6OmqxyXMyO9YeCyG0zvagpMOAy0iPkM6yfYekg7P9pwNfAVYDTs3uN426KgHeYfuLkt5DavG9H5hJWim6obYFstHMyh4LJDFUmhZZOeoRQuhdti8lJXOv3nZ61edPAp8cwSknZO97ABfYfjLvP7g7MmoxG3nyZlIj5Crbv+jEdXpJ2ZZxifZYCKFkfinpb6RHUp+WtAbwQp6CnViP7FTgYOA24HbgYEk/aPd1ek3Xl3FpkDnf8ZAshFAytr8EbA9Mtb2ItFzX3nnKtj2QkdKNvNP22bbPJjUTd+zAdXpMeSZEQ8SxEEI5SPpi1dddbC8GsP0c0HR1aOhMILsbWL/q+3rArR24Tk9JXb0limQhhFAO+1Z9Hj5Kbbc8J2jbMzJJvyTdqVcG7pJ0bfZ9O+AvjcqOBSN5RjZtznRmrX/QiM5/zeylUzS232i1hsfajlGLIYSyUJ3Ptb7X1M7BHie08Vx9ZyByLYYQQi2u87nW95raGciudJMZv5JU75gcSwLsCFxCyqgMcFEvLQ0z0hWip82Z3vygFjmWIwshlMeWkuaRbkuTs89k37uea3GmpJ8Dl9ieU9mYzfp+M/Ax0uS2c4YXzLkkAKSh/HsOL98LBJRlObIQQigL2+NGe452BrLdgI8DF2RryDxNiqbjgN8B37V9c52yTZcE6HXlWsYlnpGFEPpHOzN7vACcSkpHMgFYHVhg++kcxfMuCbC9pFtIySk/b/uOWieTdBBwEMDEiRPz/xEdVpaMGtG1GELoJx3J7JFNZnt4BEXyLAlwI/BK289K2gP4BbBJnetPJ61GypQpU0oRPVSiJaJjsEcIoZ90Yh5ZK5ouCWB7nu1ns8+XAhMkrd69Ko5O1zN7hBDCGFGWQJZnSYA1lT3YkbQtqe4tLKFcDFGiZVwM0bkYQugXHelaHKmcSwLsAxwiaZCUVHLfZsP9y2SgVC0yR9diCKFvlCKQQa4lAU4BTul2vdol16jFJuuItUsM9ggh9JOydC32vRKN9QBisEcIoX9EIOsWUczCmjWWc+mdDtkQQmiuNF2L/a5Z8vvvXn4P0+Y8wazBe5jW4boYo+hcDCH0iQhkXSKJfz75HOf/9Z8ATJk4nj23WIvx45ZtFHcyx2KFHV2LIYT+EYGsS9ZaeRJX/f1x/uPi25dsW3uVyWy74aqF1CfiWAihX8Qzsi4564A3cu3Rb+fao9/O2Qe+EYBnFy7q7EUrz8eGvccjshBCP4kWWZdMGDfAy1dKKxI89XwKYC8sGlqyv+NdilWDPlLXYrTJQgj9IQJZASZPSKsWXHTjXG5/8BkAHnx8o6blBmR2Wulh1pjwwqiuX5bkxSGE0A4RyAqwxorLsc4qk/nTPY/xp3seA2Bo8XpNSsFiBrj4yQ3YZ9X7eN9q97d8/cvvfISVJk1ouXwIIZRJBLICTJ44jj9/aedltl1z5ueblrtm/hqc89im/HPhCo2Pm700BeX2G622zL4FLy5m/guDDETXYgihT8Rgjx6y/YqP8bLxC0fVMbhoKD2X+8zOr2pPpUIIoWARyIpUI+tGMwPA0CgGzy9enMLg+IFokYUQ+kMEsjIYQUATZsitB6HBoRTIxo2L//QhhP4Qz8gKdM3sJ2B282dj1UabfHjx1ScDr4kWWQihb0Qg6zEDSpkS8xo+8GMwa82Ni0AWQugTEch6zABmqMUm2TWzn+CRF9Ok7N/f+QgPPrWAaXOms/0nTmhjDUMIobviQUmPEaMb7PGC02TsdR+7ctlsIi0MPAkhhDKIFlk3zTye7w6+D2g9JZU0urwclYEiq4x/ccm26iVkPrfrpjXLfffye5Z8rndMHu06TwghVEQgK8Bo8ioKRjVqcXHWCJ+goZr7qwNNPXmOySOCWgihHUoTyCTtBpwEjAPOsP2NYfuV7d8DeB44wPaNXa9oTpWb9LQ505m1/kHZ5ydg/dGddwCzeBRdi5XBHuO1tF1XHVir69tNeYJjo2AXQTGE7irTPbsUgUzSOOAHwK7AXOA6STNs31l12O7AJtlrO+C07L04M4+Hnb685Gu9m/GywWx0We4HNLoW2ZJRi3VaZPDSYFZUcBsub0uwXS3G0eh0F20IRSrbPbsUgQzYFrjX9mwASRcCewPVP8rewHm2DcyStIqktWw/3O3KLm1tpedKlRt9dZAa/r1dy7QMYO59YSUOvPctLZWvtOYm6KVP2mrVt14AaxTcyhL4itTNLtoyyhOk6wX10QT7VsrW++/QjWsXcc42KdU9W+kaxZK0D7Cb7U9m3/cHtrN9WNUxvwK+Yfvq7PsfgKNsX1/jfAcBlTvpG4AFHf4TijAeGCy6EiUSv8ey4vdYVvwey8rze0wGqrsCp9ueDu2/Z49WWVpktfrKhkfYPMekjenH7vBKlcWSdL3tqUXXoyzi91hW/B7Lit9jWW34Pdp6zx6tsswjmwtUL8i1LvBQC8eEEELovFLds8sSyK4DNpG0oaSJwL7AjGHHzAA+qmQa8EwRz8dCCCGU655diq5F24OSDgMuIw3lPMv2HZIOzvafDlxKGsZ5L2ko54FF1bck+rrrtAXxeywrfo9lxe+xrFH9HmW7Z5disEcIIYTQqrJ0LYYQQggtiUAWQgihp0Ug6zGSdpN0t6R7JX2p6PoUSdJ6kmZKukvSHZKOKLpOZSBpnKSbsnk8Y1o2Cfdnkv6W/e9k+6LrVCRJn8v+v3K7pAskTSq6Tu0QgayHVKWF2R14DfAhSa8ptlaFGgT+3fargWnAoWP896g4Arir6EqUxEnAb21vDmzJGP5dJK0DHA5Mtf060iCNfYutVXtEIOstS9LC2H4RqKSFGZNsP1xJQmp7PukmtU6xtSqWpHWBfwPOKLouRZO0EvBW4EwA2y/afrrYWhVuPDBZ0nhgefpkLm4Est6yDvBA1fe5jPEbd4WkDYCtgb8WW5PCfQ/4IlA/K/TYsRHwGHB21tV6hqQpRVeqKLYfBE4A5gAPk+Z1/a7YWrVHBLLe0rWUL71E0grAz4HP2p5XdH2KImlP4FHbNxRdl5IYT8q1eprtrYHngDH7XFnSy0g9OBsCawNTJO1XbK3aIwJZb4k0XcNImkAKYufbvqjo+hRsB+Bdku4ndTvvLOnHxVapUHOBubYrrfSfkQLbWLULcJ/tx2wvAi4C3lRwndoiAllvyZMWZszIFu47E7jL9neKrk/RbH/Z9rq2NyD9b+OPtvviX9ytsP0v4AFJm2Wb3s6yy4yMNXOAaZKWz/6/83b6ZPBLKVJUhXzqpYUpuFpF2gHYH7hN0s3ZtqNtX1pgnUK5fAY4P/uH32zGcGo723+V9DPS0iyDwE30SequSFEVQgihp0XXYgghhJ4WgSyEEEJPi0AWQgihp0UgCyGE0NMikIUQQuhpEchC10haTdLN2etfkh6s+j5x2LGflbR8jnNeIWlqje1ndDuBsKSju3m9Yddu698raaqkk0dY5quSPt+uOoSQVwy/D4WQ9FXgWdsn1Nl/PylL9+NNznMF8Hnb17e7jnllk0sFzLO9QlH1KFqz/6YhdEq0yEKhJL09S+h6m6SzJC0n6XBSLriZkmZmx50m6fpsLaVjc5x3SUtN0rOSvinpBkm/l7Rttn+2pHdlxxwg6RJJv83Wezum6lxHZus33S7ps9m2DbL1rU4lTTA9k5RV/GZJ52fH/CK75h2SDqo637OSvi7pFkmzJL0i2/4KSRdn22+R9KZs+36Srs3O/cNsOZ9mf+9Lzj/s+NuU1uqSpCckfTTb/iNJu0jaUdl6ZllL66yq3+zwqvP8R/Z7/R7YrGr7Vtm1b83+ppdJermkG7L9W0qypPWz7//I0wIPoZYIZKFIk4BzgA/afj0p08whtk8m5ZDcyfZO2bH/YXsqsAXwNklbjOA6U4ArbG8DzAe+BuwKvAc4ruq4bYGPAFsB78+617YhZYPYjrTm2ackbZ0dvxlwnu2tbR8ILLC9le2PZPs/nl1zKnC4pNWq6jPL9pbAlcCnsu0nA3/Ktr8BuEPSq4EPAjvY3gpYnNWx2d9b6/zV/kzKjPJaUsaLt2TbpwGzahy/OfDO7Dc6RtKE7LfZl7TqwHuBN1Ydfx5wlO0tgNuAY2w/CkxSWl7lLcD1wFskvZKU7Pj5Jn9XCDVFIAtFGkdKYnpP9v1c0vpRtXxA0o2ktDqvJS0smteLwG+zz7eRgsWi7PMGVcddbvsJ2wtICVXfnL0utv2c7Wez7ZWb/j9t17rpVxwu6RZSYFgP2KSqPpXVm2+oqsPOwGkAthfbfoaUD28b4DqlNFxvJy1P0uzvrXX+aleRfuu3Ztd8vdLCi09mf+dwv7a9MOvqfRR4Bel3uNj289mqAzMAJK0MrGL7T1nZ6v+ufyEF0LcC/529vyWrTwgtiVyLoUjP5TlI0obA54E32n5K0jmk1lxei7z0YfAQsBDA9pDSAoMVwx8Ym9pL51TUrb+kHUnZxre3/Xz2LK9S5+r6LKbx/w8FnGv7yw2OGS7P+a8EDgXWB/6D1Drdh/oBZWHV5+pzjvQh+1WkwPVK4BLgqOwcv2pUKIRGokUWijQJ2EDSq7Lv+wOVf8XPB1bMPq9EChrPZM97du9QfXaVtKqkycC7Sd1vVwLvVsoYPoV0w693s1+ktKwMwMrAU1kQ25zUZdfMH4BDACSNy7rg/gDsI+nl2fZVs664UbH9ALA6sInt2cDVpH8sjKRldCXwHkmTJa0I7JWd+xngKUmVlmv1f9crgf2Av9seAp4E9iD91iG0JFpkoUgvkJ4//V/WMroOOD3bNx34jaSHbe8k6SbgDtLznE7d9K4GfgS8CvhJZSRk1gK8NjvmDNs3Ka1IPdx04NasC/TjwMGSbgXupvZzp+GOAKZL+gSp1XOI7Wsk/SfwO0kDwCJSS+qfrf2Jy/grqXsXUgA7nvQb5GL7Rkn/C9yc1ac6CH4MOD0bwLEk67zt+yVBCmhk11vX9lOj+DvCGBfD70MgjVokDfc/rOi6hBBGJroWQwgh9LRokYUQQuhp0SILIYTQ0yKQhRBC6GkRyEIIIfS0CGQhhBB6WgSyEEIIPe3/B6MStza1i7FNAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -464,14 +464,14 @@ "Computing window sums\n", "Done computing window sums\n", "For increasing = True , the minimum IR precision was 0.4006572406407763 occurring at 7.033348083496094e-06 implying a frac_neg of 0.6684943371454617\n", - "Adjusted frac neg is 0.99\n", + "To be conservative, adjusted frac neg is 0.95\n", "For increasing = False , the minimum IR precision was 0.41327328308403144 occurring at -4.0531158447265625e-06 implying a frac_neg of 0.7043709978920574\n", - "Adjusted frac neg is 0.99\n" + "To be conservative, adjusted frac neg is 0.95\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbIAAAEGCAYAAAAAKBB/AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deZicVZn+8e/dWUhIIMgqhLAaQFDWCEFQFkWBYRFFRQUFHfmhOKC441wijAqOooIKmGERFHAYQYgIKoNBwAEh7JsssoQACkRIQgghnb5/f5y3uitFLW93qrreqn4+19VX1buf6kA9fbbnyDYhhBBCp+ppdwFCCCGEFRGBLIQQQkeLQBZCCKGjRSALIYTQ0SKQhRBC6Gij212AVuvp6fH48ePbXYwQQugoL7/8sm13RGWn6wPZ+PHjWbRoUbuLEUIIHUXS4gbHzwX2A561/aYqxwWcBuwLvAwcbvv2VpS1I6JtCCGEwvkZsHed4/sAU7OfI4EzW1WQrq+RDdWzC19hydK+/u1xY0ax1iortbFEneelJb28sOjVdhcjhBHr9ZPGMWZUa+ortq+XtFGdUw4ELnDKunGzpNUkrWv7mWaXJQJZDcf9913c+Mjzy+27/Ohd2HbKam0qUefZ43vX8dzCJe0uRggj1vVf3IMN1li5XY+fDDxZtj032xeBbLh88u2bcOC26wHw5AuLOf3ah5n3Unwp59XXZ55buIS9tlyHd225TruLE8KItPrEsSty+WhJs8u2Z9ieMYjrVWVfS3IiRiCrYbfN1up/f8/c+Zx+7cNEWsr8evvSL2ub9Sfx/mlT2lyaEMIQ9NqetgLXzwXK/+dfH3h6xYpUXQz2yEHZ3xV9Ecly6+1L/YujW9Q+H0IovJnAR5VMB+a3on8MokaWSymQRRjLr1QjG91TrXUhhNDpJF0M7A6sKWkucAIwBsD2WcBVpKH3j5CG3x/RqrJEIMtBWVNvLHmT37JlEchC6Ga2P9TguIGjh6MsEchy6Mlax0ZqHLPN3XPns+jV3rrnLX51GXfPnc+S3j4WZ+dG02IIodUikOVQqpH1DXcgm3Uy7PHVYX7oa909dz4H/uTPuc8fM0pIYuJKo3nD2hNbWLIQQohAlktPfx/ZyKySvbQk1a6+sf+WbLHuqnXPnbzaeKas3rZ5KyGEESgCWQ4DoxbbW452KY3W3GryJN6y0eptLk0IISwvOjBykEb2YI/Sx45xGyGEIopAlsNI//4emD830n8TIYQiikCWQ49Kgz1GaI0se40aWQihiCKQ5dA/IXpkxrH+JtVSQA8hhCKJQJZD24bfF0QpgEccCyEUUQSyHAZqZCMzkvX1D/aISBZCKJ4IZDlE0+II/eAhhI4QgSyHUk1kpE6IjhpZCKHIChPIJE2RNEvSA5Luk3RslXN2lzRf0p3Zz9eHp2zpdVgrJrNOHsaH1fbK0mW8+PKrQPSRhRCKqUiZPXqBz9u+XdIqwG2SrrF9f8V5N9jebzgLNjD8fjifWgz7nHYDjz2/CICVRhfm754QQuhXmECWLbj2TPZ+oaQHgMlAZSAbdqWKyEhsWnz6xcW8fbO1OOQtU9h4zQntLk4IIbxGIf/ElrQRsB3wlyqHd5Z0l6SrJW1V4/ojJc2WNLu3t/7SIznLA4zMGtmyPvPmyauy75vX7f89hBBCkRSmRlYiaSJwKfBZ2wsqDt8ObGj7JUn7ApcDUyvvYXsGMANgwoQJKxx++r+/R9joPdv09pnRPYX8eyeEEICC1cgkjSEFsQttX1Z53PYC2y9l768Cxkhas9XlGql9ZMv6YpXnEELxFSaQKbVbnQM8YPv7Nc55fXYeknYklX9ey8uWvY60+VS9pUAWqzyHEAqsSE2LuwCHAfdIujPbdzywAYDts4CDgU9J6gUWA4d4GKLLSKuRLXxlKX/867O8/OoyIGpkIYRia0kgk/Q6YD1SsHncdl+ja2zfSIN1Qmz/GPhxUwo5GP0rRI8Ml8yey39cOTBYdO1VV2pjaUIIob6mBTJJk4CjgQ8BY4HngHHAOpJuBs6wPatZzxtOPSMs1+KiJWmk5x8/vxsrjRnFepPGtblEIYRQWzNrZL8CLgDeZvvF8gOSdgAOk7SJ7XOa+MxhMbBCdJsLMkyWLuujR7DJWhPbXZQQQmioaYHM9l51jt0G3NasZw23kTYh+tVlfYyJAR4hhGEkaRfgG8CGpNgkwLY3aXRtM5sWt6933PbtzXrWcBtpgz2W9pqxEchCCMPrHOBzpErPssFc2MymxVPrHDOwZxOfNaxGyjIuP/3T3/j+NQ+xdFkfr1t5bLuLE0IYWebbvnooFzazaXGPZt2raEqBrK/LI9l9Ty9gpdE9HL7LRrx58qR2FyeEMLLMkvRd4DJgSWlnnta8ZjYtvrfe8WqZOjqF6s8K6Bp9NmtOXImv7vPGdhclhDDy7JS9Tivbl6s1r5lNi/vXOWZSlO1IpeH3T8xbxE1/m9e/b5spqzFuzKg2lqy57FhzLITQHivSqtfMpsUjmnWvoumRWHnsKC6ZPZdLZs/t3/+Fd23GZ/Z8Tc7ijtVnxyrQIYS2yOYinwC8Pdv1J+Ak2/MbXdv0zB61Vm22fVKznzVcenrEVce8jWfmv9K/76Pn/oWFS1Z8iZgiiUAWQmijc4F7gQ9k24cB5wF1u62gNSmqFpW9HwfsBzzQgucMq43WnMBGZQtL9khdl7OqL5oWQwjts6nt95Vtn1iWd7eupgcy28sNw5f0PWBms5/Tbt34he+okYUQ2mexpF2zvLulCdKL81w4HNnvVwYazszuNELdViGjzxBraIYQ2uRTwPlZX5mAfwKH57mwFX1k9zDQ6DYKWAvo2P6xWqTuSyIcfWQhhLwk7Q2cRvqeP9v2KRXHJwG/IC3FNRr4nu3zat3P9p3ANpJWzbYX5C1LK2pk+5W97wX+Ybu7RkVkuiyOZX1kEchCCPVJGgX8BNgLmAvcKmmm7fvLTjsauN/2/pLWAh6UdKHtVyvudajtX0g6rmI/ALUWWi7X9IYk20+QPthSUqReT9IGzX5Ou4lhGusx6+TheApQ6iMbtseFEDrXjsAjth/NAtMvgQMrzjGwilJEmkhqKqxWqSmNolulxk9DrWha/DfSXIB/AKUFNQ1s3exntZOkrquR2UTTYgihZLSk2WXbM2zPyN5PBp4sOzaXgcwcJT8mDfR7mhSQPlhtkWXbP81eTxxyQYd6YR3HApvbnteCexdGK7/uf3DNQ0yfk359O2+yRguftLy+qJGFEAb02p5W41i1b4rKP+3fDdxJSjG1KXCNpBtq9X1J+k/gm6SRir8DtgE+a/sXjQraijFqTwINZ2J3PHXf+mR9dvSRhRDymAtMKdten1TzKncEcJmTR4DHgC3q3PNdWZDbL7v/ZsAX8xSmFTWyR4HrJP2W5TMYN+yw6zTd1rTYZ6JGFkLI41ZgqqSNgaeAQ4APV5wzB3gHcIOkdYDNSfGhljHZ677Axbb/mfcP61YEsjnZz9jspyt14/e9bXpiIlkIoQHbvZI+A/yeNKjvXNv3SToqO34W8B/Az7IpWQK+bPv5Orf9jaS/kpoWP52NdHylzvn9WpHZY8gddp0kDfboripZXwz2CCHkZPsq4KqKfWeVvX8aeNcg7vcVSd8BFtheJmkRrx0JWVVL/vyW9KXy127UhakWsz6ydpcihDCSSNoze30vsAdwYPZ+b+Ctee7RqnakQypeu043ft/39UVmjxDCsNste92/ys9+tS4q1+pci139rdhNLYsvvvwqd82dz65vWLPdRQkhjCC2T8heh7ymZfTsD5Gkrhp+//xLKWvMVuut2uaShBBGIknflrRa2fbrJH0zz7URyIZIdFeNrNTjt9XkSW0uRwhhhNrH9oulDdsvkIbiNxSBbIi6bbBHKSh3dVtwCKHIRklaqbQhaTywUp3z+7Wqj+y67HVWi+5fAN35lR9jPUIIbfIL4FpJ55HqCR8Hzs9zYUtqZLaPK3/NQ9IUSbMkPSDpPknHVjlHkk6X9IikuyVt38xyD1Y3NS120UcJIXQg26Vci28EtgL+I9vXUCuy368MfB7YwPYnJU0lJRG+ssGlvcDnbd8uaRXgNknXVKxvsw8wNfvZCTiT12ZcHhap5tI9X/8DTYtRJQshtM0DpGTF/ytpZUmr2F7Y6KJW1MjOI+VY3DnbnkuKsnXZfsb27dn7haQPNLnitAOBC7IklDcDq0lat2klH4TuG+yRRNNiCKEdJH0S+BXw02zXZODyPNe2IpBtmlUHlwLYXswgO5QkbQRsB/yl4lC1NXAqgx2SjpQ0W9Ls3t7WLE4tdVcg66apBCGEjnQ0sAuwAMD2w8DaeS5sGMgkvWmQhXk1G23i7PpNKcuCn+N5E4FLSevQVK5bk2cNHGzPsD3N9rTRo1sznkV01zyyGLUYQmizJdlq0wBIGk3O/ps8NbKzJN0i6dPlk9XqOIG0KNoUSRcC1wK5ci5KGkMKYhfavqzKKXnWwBkW3doE162fK4RQeH+SdDwwXtJewP8Av8lzYcNAZntX4COkADJb0kXZQ2qdfw3wXuBw4GJgmu3rGj1HaeGZc4AH6qxdNhP4aDZ6cTow3/Yzje7dKl3VtNhFnyWE0JG+DDwH3AP8P1Jm/X/Pc2GudjfbD0v6d2A2cDqwXRZ4jq+sOZUNiS8FmA0kTQKesF2vw2oX4DDgHkl3ZvuOBzbIynAW6YPtCzwCvExagbQtRDeNWSzvI4sqWQhheEnqAe62/SbgvwZ7fcNAJmlrUsD4F+AaYP9siPx6wE1AZRPgGcD2wN2kb8U3Ze/XkHSU7T9Ue47tG2nwLeq0ANjRjco8HNJ6ZO0uRQghdD7bfZLukrSB7TmDvT5PjezHpAh5fDYCsfTgp7NaWqXHgU/Yvg9A0pbAF0mrhV4GVA1knagrB3tEhSyE0B7rAvdJugVYVNpp+4BGF+YJZJfZ/nn5DknH2j6tcn9mi1IQywpxv6TtbD+qLvqWVLe1LWa6518ohNBhThzqhXlGLX60yr7D65z/oKQzJe2W/ZwBPJQlg1w6lEKGEELobrb/BDwITAJWBR7M9jVUs0Ym6UPAh4GNJc0sO7QKMK/OPQ8HPg18lvQH/o3AF0hBbI88heoEXZv9votqzSGEziHpX4GvA38kxY4fSTrJ9rmNrq3XtPh/pJGHawKnlu1fSBq8UVXWj3ZqxTUlLzUqUKcQwl002qPU3xdhLITQJl8EtrM9D0DSGqQ4NPRAZvsJ4AkGcibmImkX4BvAhuX3t73JYO5TdN1WIwshhDabS6oolSxk+ZSENdVrWrzR9q6SFrL8d3bKl2uvWuPSc4DPAbcBy/IUohN1W9LgGLUYQmizp4C/SLqCFHMOBG6RVFoWrFaijLo1sl2z11UGWZj5tq8e5DUdqVVxbPqcGcvvmHUy7PHVFj0t6Z8OHYEshNAef8t+Sq7IXhvGoDwTojcF5tpeIml3YGvSUiov1rhklqTvkuaM9ScLLi3R0i1iUEQIITSP7SEPv88zj+xSYJqkN5CaDWcCF5FSRVVTWuhyWnkZgT2HWsgiytpX212Mpil9llhYM4TQafIEsj7bvZIOAn5o+0eS7qh1su2uGWJfV5cN9uj/LBHHQggdJk8gW5rNKfsYsH+2b0y9CyT9C7AVMK60z/ZJQy1kEQm6K5KFEEKHyhPIjgCOAr5l+zFJGwO/qHWypLOAlUmTn88GDgZuaUJZC6crcy22txghhBFG0o+oUy2wfUyje+RZj+x+28fYvjjbfsz2KXUueavtjwIvZJ13O7P8Yphdofuy32d9ZDGIJYQwvGaTpmuNI62c8nD2sy05p3DlGbVYOcG5NI+s1gTnV7LXl7OlXuYBG+cpTCeJr/sQQlhxts8HkHQ4sIftpdn2WeRcLSVP0+JgJzj/RtJqwHeB20l/6g96obSik7p0QnR7ixFCGLnWI80Z+2e2PTHb11CeQJZ7gnO2yue12RyzSyVdCYyzPT/P9Z1EqLv6yLLXaFkMIbTJKcAdkmZl27uRWgMbyhPIck9wzlb5PJUsP6PtJeXXdJNuq5GFEEI72T5P0tUMzEX+iu2/57k2TyAb7ATnP0h6H2lBzq7+qu+mDzfQtBhVshBCY5L2Bk4DRgFnVxsEmGWD+iFpytbztndrcNtRwHOk2LSZpM1sX9+oLA0D2RAmOB8HTACWSVpM4yTDoQC6/G+OEEITSRoF/ATYi5S1/lZJM23fX3bOasAZwN6250hau8E9vwN8ELgP6Mt2G1jxQCZpHeDbwHq295G0JbCz7XOqnT+EJMMdqfuG3yfRRxZCyGFH4BHbjwJI+iUpW/39Zed8mNQyNwfA9rMN7vkeYPOsS2pQ8jQt/gw4D/hatv0Q8N+k0YxVSToAeHu2eZ3tKwdbsKJL3/etj2Q3PZoW47659yEAPrfXZi15Tv9gj5bcPYTQgUZLml22PcN2aWmOySy/VthcBrqhSjYDxki6jjQa8TTbF9R53qOkJsiWBLI1bV8i6asAWd7FmsPwJZ0CvAW4MNt1rKRdbX9lsIUrshjsEULocr22p9U4Vu1v3spvxNHADsA7gPHATZJutv1QjXu+DNwp6VqWH1jYMLNHnkC2KFty2gCSpgP1htPvC2xruy87/3zgDqCrAhnAM/Nf4Yo7n+rf3nCNCWw7ZbU2lmjoHFWyEEJ+c1k+Y9P6wNNVznne9iJSHLke2IbUqlfNzOxn0PIEsuOym28q6c/AWqT8ifWsxsCktklDKVjRrTFxJa5/6DmO/eWd/fsmrjSae098dxtLNXSlOXExajGEkMOtwNQs9+5TwCGkPrFyVwA/ljQaGEtqevxBrRuWMnwMRZ5Ri7dL2g3YnPT3+oOlFCI1nMzApDaR+spau7xxG8w4bAeefnFx//bZNz7G/8x+ss4VIYTQHbIups8AvycNmT/X9n2SjsqOn2X7AUm/A+4mjUI82/a9te4p6TGqDDyokw6xX81AJum9NQ5tlkbs+bJqB21fnHXuvYUUyL6cd1JbJxk3ZhSbrDWxf/t1K4/p7D6z0jyyqJCFEHKwfRVwVcW+syq2v0tKV5hHeX/cOOD9wOp5LqxXIyutPbY28Fbgj9n2HsB1pEwfVdl+hiG2dYbhc+eTL3LrY6kF+LF5i4DoIgshtIfteRW7fijpRuDrja6tGchsHwGQ5UvcMgtOSFqXNBEulGl139L0OTO4eYMjm3rPE39zH3fMebF/e+yoHtZedVydK0IIoTUkbV+22UOqoeWal5xnsMdGpSCW+QdpfkCo0Gkti0uX9fG2qWty5qE7ADC6R4wbM6rNpQohjFCnlr3vBR4HPpDnwjyB7DpJvwcuJn1XHwLMqn/J4Ek6F9gPeNb2m6oc3500CuaxbNdltk9qdjlGEhvGjOph4kp5/jMIIYTWGUI6xH55Ri1+RtJBDGTqmGH713kfIOmB7O1PbP+4zqk/A34M1Jv5fYPt/fI+ezilCdKdVieLPrEQQjFImgScwECs+RNwUp5lwHL9KZ4FrtzBq+LaN0pak9emL6k873pJGw3lGWFo7BilGEIojHOBexloTjyMlB6x1gj6fsPSpmT7eeC3TbjVzpLuIs0g/4Lt+6qdJOlI4EiAsWPHNuGx3ak0BTqEEApgU9vvK9s+UdKdNc8u07RAJmkhdcY7NGEZl9uBDW2/JGlf4HJgao1nzQBmAEyYMGFY2vtE5w326MSm0BBC11qc5eW9EUDSLsDiBtcA+ZZx2Q+4qpQ7sZbS8i2STgL+Dvyc9P3+EXIOoWxw/wVl76+SdIakNbPaXhiiaFoMIRTEUcAFWV8ZwAvAx/Jc2JPjnEOAhyX9p6Q35jj/3bbPsL3Q9gLbZwLva3hVA5JeL6WvXUk7kspeOYGufTp0fbKIYyGEdssW6jzU9jbA1sDWtrezfXee6/OMWjxU0qrAh4DzJJnUAXex7YVVLlkm6SPAL0mtbR8Cai77UvZBLgZ2B9aUNJc0emVMVoazSImKPyWpl1TdPMTRNrZCYrBHCKEIbC+TtEP2fkGj8yvlHbW4QNKlpDVlPgscBHxR0um2f1Rx+oeB07IfA3/mtVmRqz3jQw2O/5g0PD80iTuuVy+E0MXukDQT+B9gUWlnrby+5fL0kR0AHAFsSur32tH2s5JWBh4Algtkth8nLXk9ojStYjPr5GbdKZdYtiWEUBCrk7qL9izbZ+rk9S3JUyM7GPiB7evLd9p+WdLHK0+WtBbwSWCj8vvbfs25ob2iaTGEUBSl/L5DkSeQPVMZxCR9x/aXbV9b5fwrgBuA/yVH31i3sY06JDqYCGQhhGKQdHqV3fOB2bavqHdtnlGLe1XZt0+d81fOgtwlti8t/eR4TkfrxIBgO5oWQwhFMQ7YFng4+9ma1Nz4CUk/rHdhvYU1PwV8GthUUvkQyFVIAzhquVLSvtmia6HAYqhHCKFA3gDsabsXQNKZwB9Ilal76l1Yr2nxIuBq4GTgK2X7F9r+Z53rjgWOl7QEWEqW9KIJmT0KrVSz6bh+p04qawihm00GJpCaE8ner5cNzV9S78J6gcy2H5d0dOUBSavXCmalDB+hAzjiWAihMP4TuFPSdaSvprcD35Y0gTTmoqZGNbL9gNvIxgWUHTOwSbWLJL292v7KASPdqpOa69JgjwhlIYT2s32OpKuAHUnx5njbT2eHv1jv2pqBrLTul+2NB1me8geOywp1G8vPDeg6nRgPIjFKCKEoshSE7wA2sX2SpA0k7Wj7lkbX1hvssX29C23fXmP//hX3mUKqMoYC6sD4G0LoTmcAfaRKz0nAQuBS4C2NLqzXtHhqnWMmfw1rLvCmnOd2vFTL6YzwEPPIQggFspPt7SXdAWD7BUm5FpSs17S4x1BKIulHDHQV9ZDmBdw1lHt1khWNBz+45iGmz5nRlLLk5RjsEUIojqVZFnxDf5aousuHldRrWtzT9h8lVV1muk4ix9ll73tJWfLrzTvrKi3vdZp1Muzx1abcynROFpIQQtc7Hfg1sLakb5HSI/57ngvrNS3uBvwR2L/KsZqJHG2fn1UHN8t2PZinIJ0u4kEIIQyNpB7gMeBLpAEfAt5j+4E819drWjwhex1UIkdJuwPnA49nhZki6WMjZfh9J4mmxRBCEdjuk3Sq7Z2Bvw72+oa5FiWtIel0SbdLuk3SaZLWqHPJqcC7bO9m++3Au4EfDLZgnaqTRrR30LiUEEL3+4Ok92kI/R15kgb/EngOeB+pzfI54L/rnD/Gdn9zou2HyFZ67mad2tcUSYNDCAVxHGlRzVclLcx+cq0WnWcZl9Vt/0fZ9jclvafO+bdJOoe0CCfAR0gTokeETlt1uUPjbwihy6xIesM8gWyWpEOAS7Ltg4Hf1jn/KOBo4BhSw9X1pIluoWAis0cIoUgkHUDKsQhwne0r81xXb/j9QgZyLB4H/CI71AO8BJxQ5Zoe4DbbbwK+n7v0oS2iiyyEUBSSTiFl8bgw23WspF1tf6XOZUD9UYuDruZlI0/ukrSB7TmDvb6TlZropn/72uX6yw6dviHH7bVZjavaq+OWnAkhdLN9gW1t9wFIOh+4g+WXEasqT9Mikl4HTCUlAQbqZrNfF7hP0i3AorLzD8jzrE6135vX49kFS1jWN9Bcd/W9f+eOOS+0sVT1mVghOoQwNJL2Bk4DRgFn2z6lxnlvAW4GPmj7Vw1uuxpQWiJsUt6yNAxkkv6VtFjm+sCdwHTgJmrnWjwx78O7yQZrrMw3DthquX33P7Ogo4bjhxBCHlkqqZ+QVm+eC9wqaabt+6uc9x3g9zluezJwh6RZDKxHliuNUZ4a2bGkdsubbe8haQvqBCvbf8rz4JFANHcU4/Q5M2CTelP4BieaFkMIQ7Qj8IjtRwEk/RI4ELi/4rx/o0EGe0m7ZGkMLwOuy84V8GXbf89TmDzzyF6x/Ur2wJVs/xXYvE6hFkpaUPHzpKRfS6q6GGc3K3KNLLLfhxCGaDLwZNn23GxfP0mTgYOAsxrc6/Ts9Sbbz9ieafuKvEEM8tXI5kpaDbgcuEbSC8DTdc7/fnb8IlJUPQR4PSnn4rnA7nkL1+mkggeylGO63cUIIRTTaEnlSeBn2C4t0VHti6Py2+6HpFrVsgYJI5ZKOg+YLOn0yoO2j2lY0EYn2D4oe/uNrO1yEvC7OpfsbXunsu0Zkm7OVvw8vtHzukknDKSIGlkIoYZe29NqHJsLTCnbXp/XVnCmAb/MgtiawL6Sem1fXnHefsA7SeMuhpQ8I++oxe2BXUkR98+2X61zep+kDwCl0SkHlx0rcP2kBVT0TB9FLlsIocBuBaZK2hh4itTy9uHyE2xvXHov6WfAlVWCGLafJwW8B2wPae3KPEmDv07KZr8GKaqeJ6neGjEfAQ4DngX+kb0/VNJ44DNDKWSnEi1qWpx1clNuE9nvQwhDYbuX9H3+e+AB4BLb90k6StJRQ7znkBdgzlMj+xCwXdmAj1OA24Fv1ijMo1RfwwzgxloPkXQuqYr5bJYZpPK4SHMW9gVeBg63fXuO8rdVkes8MdgjhDBUtq8CrqrYV3Vgh+3DW1mWPKMWH6dsIjSwEvC3WidL2kzStZLuzba3blCDK/kZsHed4/uQJmVPBY4Ezsxxz7ZSGn9faJ3QjxdCCPXUy7X4I9LX8BJSpo5rsu29qFOzAv4L+CLwUwDbd0u6iBo1uBLb10vaqM4pBwIXOGW6vVnSapLWtf1Mvfu2kyh2JIukwSGEdpN0XL3jthvm7a3XtFgadnkb8Ouy/dc1uOfKtm+pGG7Z26ggOdSat1DcQFbwwR7RtBhCKIBSXt/NSZOhZ2bb+5NWT2moXtLg80vvJY0FSplvH7S9tM49n5e0KVlVRNLBNCfY5Jm3QPbMI0nNj4wdO7YJjx66Ild6YrBHCKHdbJ8IIOkPwPa2F2bb3yAttNlQnlyLu5NGLT5O+t6bIuljdZIGHw3MALaQ9BTwGGkk44rKM28BgGzS3gyACRMmtC2UpBpZcdnu2JWtQwhdZwOgfGrXq8BGeS7MM2rxVOBdth+ENJgDuBjYofLELEHkp2y/U9IEoKcUXZtgJvCZLKfXTsD8IvePQeoji36oEELI5efALZJ+TaoDHARckOfCPIFsTCmIAdh+SE1tDHsAABYDSURBVNKYaidmqUh2yN4vqnZOLZIuJqWvWlPSXNLCnWOye51FGua5L/AIafj9EYO5fzsUvbITITaEUBS2vyXpauBt2a4jbN+R59o8gew2SeeQoiWkZsJ6aUTukDST1LZZvh7ZZfUeYvtDDY6b1GzZUQodLCL7fQihWFYGFtg+T9Jakja2/Viji/IEsqNIAeQYUh/Z9cAZdc5fHZjH8uuVmZSif8QpcsuiiXlkIYRikHQCKT/j5sB5pBa5XwC7NLq2biCT1APclmXaaDiWH8B24Zv8houkYtfIiBpZCKEwDgK2I2WOwvbTklapf0lSN7OH7T7gLkkb5C2JpPWztceelfQPSZdKWj/v9d1EUOgqWQxECSEUyKtZF1Jp6taEvBfmaVpcl5TZ4xaW7/M6oMb555HWInt/tn1otm+vvIXqFkWv7aSmxRBCKIRLJP0UWE3SJ4GPA2fnuTBPIDtxkIVZy/Z5Zds/k/TZQd6jaxS5zuMY7BFCKAjb35O0F7CA1E/2ddvX5Lm2Xq7FcaSBHm8A7gHOyVL3N/K8pENJc80gZc+fl6cw3aZly7g0UUyIDiEUgaTv2P4ycE2VfXXV6yM7nzSC5B5S5vlTc5bn48AHgL+TUlMdnO0bcdJgj+JGMuNoWgwhFEW17qd98lxYr2lxS9tvBsjmkd1S70ZlkXOnOv1nI0rRg0TRa4shhO4n6VPAp4FNJN1ddmgV4M957lGvRtafGDhnk+K+WcaPr+Z58EggFTtYpKFB7S5FCGGEu4iU6X5m9lr62cH2oXluUK9Gto2kBdl7AeOz7dT1Y69acf7vgOeBCeXn1Tl/RChyIIOYEB1CaC/b84H5pPEUSFqbtJjzREkTbc9pdI+aNTLbo2yvmv2sYnt02fvXBCXbX7Q9Cfht+Xm1zh8Z8k+Inj5nRktLUlWMWgwhFISk/SU9TFox5U+kFVeuznNt3QnRQ2H7wGbfs1OlpsXiVsmKPBAlhDDifBOYDjxke2PgHTShj2zIJF1S/jpSFb2yEwtrhhAKZKnteUCPpB7bs4Bt81yYZ0L0ULwhe53aovuHJjDRtBhCKIwXJU0kJaa/UNKzQJ6Bhq2pkYVEgifmvVzo5sUY7BFCKIgDgcXA50iDB/9GGr3YUASyFhrd08Pipcu47Pan2l2UqmxHjSyEUAi2F9leRlqT7DekJVxy1QIikLXQ5/baDIAXFy9tcGZ7FLeeGEIYaST9P0n/AO4GZpMWcJ6d59pW9ZHF3/nAWqus1O4i1BWDPUIIBfIFYCvbzw/2wlbVyL5b8TqiFbmPLNoWQwgF8Tfg5aFc2JIame2Lyl9HqtwxYtbJLS1HPRHGQggF8VXg/yT9BVhS2mn7mEYXNj2QSdoMOBNYx/abJG0NHGD7m81+VtGVgkQRK2SFriWGEEainwJ/JK240jeYC1tRI/sv4ItZobB9t6SLSLO2R5TSWl9FzKBRimPRshhCKIhe28cN5cJW9JGtbLtyyZdck9rC8It5ZCGEgpgl6UhJ60pavfST58JW1Miel7QppVVCpINJC2yOOIVuWsxeo0YWQiiID2ev5UuBGdik0YWtCGRHAzOALSQ9RcpknGtNmW5TChItiWOzToY9hr70W6mPLOJYCKEIskTBQ9L0QGb7UeCdkiYAPbYXNvsZnaLUbFfkGlkIIbSTpD1t/1HSe6sdt31Zo3u0YtTi1yu2S4U5qdnPKroiN9vFYI8QwoqQtDdwGjAKONv2KRXHPwJ8Odt8CfiU7buq3Go30mjFankVDQx/IAMWlb0fB+wHPNCC53SMlo1aXMHmRRj4QyOEEPKSNAr4CbAXMBe4VdJM2/eXnfYYsJvtFyTtQ+py2qnyXrZPyN6eZPuxiufkam5sRdPiqRUF+R4ws9nP6SRFalq0zdcuv5cn/zmkCfQhhACwI/BI1pWEpF+Sstf3BzLb/1d2/s3A+g3ueSmwfcW+XwE7NCpMq3ItlluZHKNOulERKzsLXunlor/MYfJq49lhw9cxfZM12l2kEEIxjZZUnrR3hu0Z2fvJwJNlx+ZSpbZV5hPA1dUOSNoC2AqYVNFPtiqpVa9xQfOcNBiS7mFgLMEoYC2gYf9YjvbW3YErSNVVgMuK3u82MNijTpVsRdNTla7P2cRYKssndt2Yj+865EFCIYTu12t7Wo1j1f5Mr/pFJ2kPUiDbtca9Nid1Qa3G8v1kC4FP5iloK2pk+5W97wX+YbvuhOic7a0AN9je7zU36FA/uOYhps+ZN6zPjEEeIYQmmAtMKdteH3i68qQsReHZwD62q37Z2b4CuELSzrZvGkphmpbZo2wW9sKyn8XAqjlmZ/e3t9p+FSi1t3a0/nlkReojy157IpKFEIbuVmCqpI0ljQUOoWIshKQNSCMOD7P9UI57HiRpVUljJF0r6XlJueYgN7NGdhvpe7JWlbNeP1ne9tadJd1FivxfsH1ftZtJOhI4EmDs2LGNS94i/Zk92laC1+orTYSOOBZCGCLbvZI+A/ye1B10ru37JB2VHT8L+DqwBnBGNjq6XlMlwLtsf0nSQaQY8H5gFmml6LqaFshWZFY2+dpbbwc2tP2SpH2By4GpNcoygzTUkwkTJrQtjgzMoWvePW96dKB2vvMQBmr0Ny02q0AhhBHJ9lXAVRX7zip7/6/Avw7ilmOy132Bi23/M+/0oJaMWsxGnuxKCkY32L68wSUN21ttLyh7f5WkMyStOZTVRIfLQI2sOHWyUlli/lgIoWB+I+mvpC6pT0taC3glz4VNz34v6QzgKNKaMvcCR0n6SYPL8rS3vl7Zt6+kHbOyD+9IiS4Qgz1CCEVk+yvAzsA020tJq0XnGivRimVcdgPebfs82+eRqom717sgG9VYam99ALik1N5aanMFDgbuzfrITgcOccFXhyzkYI/+psWIZCGE9pP0pbLNd9peBmB7EdBwdWhoTSB7ENigbHsKcHeji2xfZXsz25va/la276xSm6vtH9veyvY2tqdXzBovpIGFNYtjoGmxzQUJIYTkkLL3lRNi985zg6b1kUn6Dek7exLwgKRbsu2dgMIHnZYqUJWsVJSeCGQhhGJQjffVtqtq5mCP7zXxXiPC9DkzGp/UZP3D76NpMYRQDK7xvtp2Vc0MZNc36rOSpKL3azWbVLCmxf6lodtajBBCKNlG0gLSt9L47D3Zdq5ci83sI5sl6d+y2dz9JI2VtKek84GPNfF5HUEUqmWxX2T2CCEUge1Rtle1vYrt0dn70vaYxndobo1sb+DjwMXZGjIvkqLpKOAPwA9s39nE53UESYWaRzbQtBhCCN2hmZk9XgHOIKUjGQOsCSy2/WKzntGphqVGlnORzZhHFkLoNi3J7JFNZnumFffuNEWLF/1dZEUrWAghDFEr5pGFMsUb7JFKE31kIYRuEYGsxYSGb7BHjkU6+4oUVUMIoQkikLWaipU0mEgaHELoMhHIhkOB4lhk9gghdJsIZC3W1nhRpamxL5IGhxC6TASyFivcYI9IGhxC6DItGX4fBqTBHsMcyuoM+oimxRBCt4lANgzK49hN53yBmzc4EoDpbShLXyRbDCF0mWhabLFaTXjtyHwPkdkjhNB9okbWYqJ1fWQ3PTqv//3Om6yR3uSYSwZRHwshdI+okbWY9NoJ0e2qjUF5H1mEshBCd4gaWYulGln7xy3e+PDzzH3hZea+sBiIpsUQQveIQDYM2r0e2au9fXzsvFtY1jcw9H7NiSu1t1AhhNAkEchard01n1kns2yXL7Gsz3x69005bOcNGTd6FK+bMLbNBQshhOaIQNZi7Y5jMDDkftL4Maw7aXybSxNCCM0Vgz1aLA32cO7RhEN106Pz+n8qlVo2Y4BHCKEbRY1sGAx3F1nlsPxSjSziWAihG0WNrMUkYO5taaPFtbJafP33s7JEJAshdJ+okbVYKydE52WnANas/Io/uOah/vef22uz5tw0hBCGKAJZi0nimQVLqvZdDYebHp3HwmXpn/m6B59ji7/+ZCDX45wZ/e9LBhuYIqiFENotAtkweGLJRK58Ycqgr9ti/Iu8YdzCFX5+qUaWp0JWHphCCKETRCBrkVJAGDuqh4cXTeLhVyYN+h5Tx83npCm3r3BZ+vPdZ+2c1Wpi1fYNVq3aWdTaQgitFIGsxd4/bX22e+LcQV/3o2e2ZF7vuKaUwVldbON/3girNeWWDdWq2Q02qEUQDCE0UphAJmlv4DRgFHC27VMqjis7vi/wMnC47RWvrjRRaa2x6XNmQOkVhjQ2dKWeZfS6OaMzBuaRDQw7KU9cXHrfjFrZYAy2GXNFmz2j/y+E5inSd3YhApmkUcBPgL2AucCtkmbavr/stH2AqdnPTsCZ2Wv7zDqZH/S+r39zOssHhRUxWqbXzZkdUW/UZK1yloLacAe3VlqRQLgi10YQDN2maN/ZhQhkwI7AI7YfBZD0S+BAoPyXciBwgW0DN0taTdK6tp9pVaEafXlNnzOP6aRA0Owv+7Hq49ne8RzxyNtW+F6lpsWeHBMBygNXZa2t/DNWC3Sl8+uNihyJijiAplZwLWJZmyX+oGiqQn1nFyWQTQaeLNuey2sjd7VzJgOv+aVIOhIofYNa0uLmFbWWU1t149FAbzNu9LXcZ1Z+llOHuL/aseU07bMVTOE/13FDv7Twn62WHJ+5Yz9bA0P9XOMlzS7bnmG79NdtU7+zV1RRAlm1zqDK6kOec9LO9Mtu3+qVTSRptu1p7S5HK3TrZ+vWzwXx2TpRiz5XU7+zV1RRUlTNBconWq0PPD2Ec0IIIbReob6zixLIbgWmStpY0ljgEGBmxTkzgY8qmQ7Mb2X/WAghhJoK9Z1diKZF272SPgP8njSU81zb90k6Kjt+FnAVaRjnI6ShnEe0q7zDrCuaSGvo1s/WrZ8L4rN1oqZ/rqJ9Z8tud0rbEEIIYeiK0rQYQgghDEkEshBCCB0tAllBSdpb0oOSHpH0lXaXp1kkTZE0S9IDku6TdGy7y9RskkZJukPSle0uS7Nkk1l/Jemv2b/dzu0uU7NI+lz23+K9ki6W1Jwkp20g6VxJz0q6t2zf6pKukfRw9vq6dpaxFSKQFVBZ+pd9gC2BD0nasr2lappe4PO230jK6nV0F322kmOBB9pdiCY7Dfid7S2AbeiSzydpMnAMMM32m0gDFw5pb6lWyM+AvSv2fQW41vZU4Npsu6tEICum/vQvtl8FSulfOp7tZ0qJQ20vJH0hTm5vqZpH0vrAvwBnt7sszSJpVeDtwDkAtl+1/WJ7S9VUo0lZLEYDK9PB81NtXw/8s2L3gcD52fvzgfcMa6GGQQSyYqqV2qWrSNoI2A74S3tL0lQ/BL4E9LW7IE20CfAccF7WZHq2pAntLlQz2H4K+B4wh5Q6ab7tP7S3VE23Tmn+Vva6dpvL03QRyIpp2FK7tIukicClwGdtL2h3eZpB0n7As7Zva3dZmmw0sD1wpu3tgEV0SfNU1l90ILAxsB4wQdKh7S1VGKwIZMXU1em4JI0hBbELbV/W7vI00S7AAZIeJzUH7ynpF+0tUlPMBebaLtWcf0UKbN3gncBjtp+zvRS4DHhrm8vUbP+QtC5A9vpsm8vTdBHIiilP+peOlC22dw7wgO3vt7s8zWT7q7bXt70R6d/sj7Y7/q97238HnpS0ebbrHSy/XEcnmwNMl7Ry9t/mO+iSgSxlZgIfy95/DLiijWVpiUKkqArLq5X+pc3FapZdgMOAeyTdme073vZVbSxTaOzfgAuzP6wepUtSxNn+i6RfAbeTRtTeQQenqpJ0MbA7sKakucAJwCnAJZI+QQrc729fCVsjUlSFEELoaNG0GEIIoaNFIAshhNDRIpCFEELoaBHIQgghdLQIZCGEEDpaBLIwbCStIenO7Ofvkp4q2x5bce5nJa2c457XSZpWZf/Zw52MWNLxw/m8imc39fNKmibp9EFe8w1JX2hWGULIK4bfh7aQ9A3gJdvfq3H8cVJG8ucb3Oc64Au2Zze7jHllE2kFLLA9sV3laLdG/6YhtErUyEJbSXpHloj2nmwtpZUkHUPKezdL0qzsvDMlzc7WjToxx337a2qSXpL0HUm3SfpfSTtmxx+VdEB2zuGSrpD0u2wduBPK7nVctlbVvZI+m+3bKFuX6wzSZNpzSBnU75R0YXbO5dkz75N0ZNn9XpL0LUl3SbpZ0jrZ/nUk/Trbf5ekt2b7D5V0S3bvn2bL/DT6vK+5f8X59yitMSZJ8yR9NNv/c0nvlLS7svXUsprWuWW/s2PK7vO17Pf1v8DmZfu3zZ59d/aZXidpbUm3Zce3kWRJG2Tbf8tTAw+hmghkoZ3GkdZP+qDtN5MyzXzK9umk3JJ72N4jO/drtqcBWwO7Sdp6EM+ZAFxnewdgIfBNYC/gIOCksvN2BD4CbAu8P2te24GUxWIn0vppn5S0XXb+5sAFtrezfQSw2Pa2tj+SHf949sxpwDGS1igrz822twGuBz6Z7T8d+FO2f3vgPklvBD4I7GJ7W2BZVsZGn7fa/cv9mZRlZStSpo63ZfunAzdXOX8L4N3Z7+gESWOy380hpBUM3gu8pez8C4Av294auAc4wfazwDilZWHeBswG3iZpQ1Ky5ZcbfK4QqopAFtppFClh60PZ9vmkda+q+YCk20kphLYiLTia16vA77L395CCxdLs/UZl511je57txaTksbtmP7+2vcj2S9n+0pf+E7arfemXHCPpLlJgmAJMLStPafXo28rKsCdwJoDtZbbnk3L/7QDcqpTS6x2kZVUafd5q9y93A+l3/fbsmW9WWmTyn9nnrPRb20uypt5ngXVIv4df2345W8FgJoCkScBqtv+UXVv+7/p/pAD6duDb2evbsvKEMCSRazG006I8J0naGPgC8BbbL0j6Gak2l9dSD3QG9wFLAGz3KS2mWFLZYWyqL6lTUrP8knYnZVbf2fbLWV9eqczl5VlG/f8PBZxv+6t1zqmU5/7XA0cDGwBfI9VOD6Z2QFlS9r78noPtZL+BFLg2JCWv/XJ2jyvrXRRCPVEjC+00DthI0huy7cOA0l/xC4FVsverkoLG/Ky/Z58WlWcvSatLGk9aRffPpC/89yhlR59A+sKv9WW/VGmJGoBJwAtZENuC1GTXyLXApwAkjcqa4K4FDpa0drZ/9awpboXYfhJYE5hq+1HgRtIfC4OpGV0PHCRpvKRVgP2ze88HXpBUqrmW/7teDxwKPGy7j7Sa8b6k33UIQxI1stBOr5D6n/4nqxndCpyVHZsBXC3pGdt7SLoDuI/Un9OqL70bgZ8DbwAuKo2EzGqAt2TnnG37DqXVrSvNAO7OmkA/Dhwl6W7gQar3O1U6FpihlKV8Gam/8CZJ/w78QVIPsJRUk3piaB9xOX8hNe9CCmAnk34Hudi+XdJ/A3dm5SkPgh8DzsoGcPRny7f9uCRIAY3seevbfmEFPkcY4WL4fQikUYuk4f6faXdZQgiDE02LIYQQOlrUyEIIIXS0qJGFEELoaBHIQgghdLQIZCGEEDpaBLIQQggdLQJZCCGEjvb/ATsePbCgJaRPAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -483,7 +483,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -501,12 +501,12 @@ "Got 318 coords\n", "After resolving overlaps, got 318 seqlets\n", "Across all tasks, the weakest transformed threshold used was: 0.8499\n", - "MEMORY 0.352284672\n", + "MEMORY 0.378642432\n", "318 identified in total\n", "1 activity patterns with support >= 100 out of 2 possible patterns\n", "Metacluster sizes: [298]\n", "Idx to activities: {0: '1'}\n", - "MEMORY 0.352301056\n", + "MEMORY 0.378646528\n", "On metacluster 0\n", "Metacluster size 298\n", "Relevant tasks: ('task0',)\n", @@ -514,7 +514,7 @@ "TfModiscoSeqletsToPatternsFactory: seed=1234\n", "(Round 1) num seqlets: 298\n", "(Round 1) Computing coarse affmat\n", - "MEMORY 0.353816576\n", + "MEMORY 0.379379712\n", "Beginning embedding computation\n", "Computing embeddings\n", "MAKING A SESSION\n", @@ -522,41 +522,41 @@ "Starting affinity matrix computations\n", "Normalization computed in 0.0 s\n", "Cosine similarity mat computed in 0.01 s\n", - "Normalization computed in 0.01 s\n", + "Normalization computed in 0.0 s\n", "Cosine similarity mat computed in 0.01 s\n", "Finished affinity matrix computations in 0.02 s\n", "(Round 1) Compute nearest neighbors from coarse affmat\n", - "MEMORY 0.407293952\n", + "MEMORY 0.42725376\n", "Computed nearest neighbors in 0.02 s\n", - "MEMORY 0.407527424\n", + "MEMORY 0.42819584\n", "(Round 1) Computing affinity matrix on nearest neighbors\n", - "MEMORY 0.407527424\n", + "MEMORY 0.42819584\n", "Launching nearest neighbors affmat calculation job\n", - "MEMORY 0.408334336\n", + "MEMORY 0.429064192\n", "Parallel runs completed\n", - "MEMORY 0.43649024\n", - "Job completed in: 1.38 s\n", - "MEMORY 0.436494336\n", + "MEMORY 0.45375488\n", + "Job completed in: 1.31 s\n", + "MEMORY 0.453758976\n", "Launching nearest neighbors affmat calculation job\n", - "MEMORY 0.436494336\n", + "MEMORY 0.453758976\n", "Parallel runs completed\n", - "MEMORY 0.438632448\n", - "Job completed in: 1.42 s\n", - "MEMORY 0.438632448\n", - "(Round 1) Computed affinity matrix on nearest neighbors in 2.89 s\n", - "MEMORY 0.438632448\n", + "MEMORY 0.457424896\n", + "Job completed in: 1.27 s\n", + "MEMORY 0.457424896\n", + "(Round 1) Computed affinity matrix on nearest neighbors in 2.66 s\n", + "MEMORY 0.457433088\n", "Filtered down to 286 of 298\n", "(Round 1) Retained 286 rows out of 298 after filtering\n", - "MEMORY 0.438816768\n", + "MEMORY 0.457617408\n", "(Round 1) Computing density adapted affmat\n", - "MEMORY 0.438816768\n", + "MEMORY 0.457633792\n", "[t-SNE] Computing 31 nearest neighbors...\n", "[t-SNE] Indexed 286 samples in 0.000s...\n", "[t-SNE] Computed neighbors for 286 samples in 0.002s...\n", "[t-SNE] Computed conditional probabilities for sample 286 / 286\n", "[t-SNE] Mean sigma: 0.232937\n", "(Round 1) Computing clustering\n", - "MEMORY 0.438870016\n", + "MEMORY 0.457699328\n", "Beginning preprocessing + Leiden\n" ] }, @@ -580,7 +580,7 @@ "output_type": "stream", "text": [ "\r", - " 8%|▊ | 4/50 [00:00<00:01, 30.37it/s]" + " 8%|▊ | 4/50 [00:00<00:01, 29.02it/s]" ] }, { @@ -595,7 +595,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 50/50 [00:01<00:00, 27.61it/s]" + "100%|██████████| 50/50 [00:01<00:00, 29.37it/s]" ] }, { @@ -605,11 +605,11 @@ "Got 5 clusters after round 1\n", "Counts:\n", "{4: 17, 0: 79, 2: 67, 3: 47, 1: 76}\n", - "MEMORY 0.440193024\n", + "MEMORY 0.45828096\n", "(Round 1) Aggregating seqlets in each cluster\n", - "MEMORY 0.440193024\n", + "MEMORY 0.45828096\n", "Aggregating for cluster 0 with 79 seqlets\n", - "MEMORY 0.440193024\n" + "MEMORY 0.45828096\n" ] }, { @@ -626,66 +626,66 @@ "Trimming eliminated 0 seqlets out of 79\n", "Skipped 16 seqlets\n", "Aggregating for cluster 1 with 76 seqlets\n", - "MEMORY 0.440193024\n", + "MEMORY 0.45828096\n", "Trimming eliminated 0 seqlets out of 76\n", "Skipped 6 seqlets\n", "Aggregating for cluster 2 with 67 seqlets\n", - "MEMORY 0.440193024\n", + "MEMORY 0.45828096\n", "Trimming eliminated 0 seqlets out of 67\n", "Skipped 8 seqlets\n", "Removed 1 duplicate seqlets\n", "Aggregating for cluster 3 with 47 seqlets\n", - "MEMORY 0.440193024\n", + "MEMORY 0.45828096\n", "Trimming eliminated 0 seqlets out of 47\n", "Skipped 3 seqlets\n", "Removed 1 duplicate seqlets\n", "Aggregating for cluster 4 with 17 seqlets\n", - "MEMORY 0.440193024\n", + "MEMORY 0.45828096\n", "Trimming eliminated 0 seqlets out of 17\n", "Skipped 1 seqlets\n", "(Round 2) num seqlets: 223\n", "(Round 2) Computing coarse affmat\n", - "MEMORY 0.440193024\n", + "MEMORY 0.45828096\n", "Beginning embedding computation\n", "Computing embeddings\n", - "Finished embedding computation in 0.09 s\n", + "Finished embedding computation in 0.08 s\n", "Starting affinity matrix computations\n", "Normalization computed in 0.0 s\n", "Cosine similarity mat computed in 0.01 s\n", "Normalization computed in 0.0 s\n", - "Cosine similarity mat computed in 0.01 s\n", - "Finished affinity matrix computations in 0.02 s\n", + "Cosine similarity mat computed in 0.0 s\n", + "Finished affinity matrix computations in 0.01 s\n", "(Round 2) Compute nearest neighbors from coarse affmat\n", - "MEMORY 0.44713984\n", + "MEMORY 0.463536128\n", "Computed nearest neighbors in 0.02 s\n", - "MEMORY 0.447148032\n", + "MEMORY 0.463794176\n", "(Round 2) Computing affinity matrix on nearest neighbors\n", - "MEMORY 0.447148032\n", + "MEMORY 0.463794176\n", "Launching nearest neighbors affmat calculation job\n", - "MEMORY 0.44720128\n", + "MEMORY 0.463802368\n", "Parallel runs completed\n", - "MEMORY 0.448659456\n", - "Job completed in: 0.73 s\n", - "MEMORY 0.448659456\n", + "MEMORY 0.464019456\n", + "Job completed in: 0.75 s\n", + "MEMORY 0.464019456\n", "Launching nearest neighbors affmat calculation job\n", - "MEMORY 0.448659456\n", + "MEMORY 0.464023552\n", "Parallel runs completed\n", - "MEMORY 0.450830336\n", - "Job completed in: 0.66 s\n", - "MEMORY 0.450830336\n", - "(Round 2) Computed affinity matrix on nearest neighbors in 1.45 s\n", - "MEMORY 0.450830336\n", + "MEMORY 0.464023552\n", + "Job completed in: 0.68 s\n", + "MEMORY 0.464023552\n", + "(Round 2) Computed affinity matrix on nearest neighbors in 1.5 s\n", + "MEMORY 0.464023552\n", "Not applying filtering for rounds above first round\n", - "MEMORY 0.450830336\n", + "MEMORY 0.464023552\n", "(Round 2) Computing density adapted affmat\n", - "MEMORY 0.450830336\n", + "MEMORY 0.464023552\n", "[t-SNE] Computing 31 nearest neighbors...\n", "[t-SNE] Indexed 223 samples in 0.000s...\n", - "[t-SNE] Computed neighbors for 223 samples in 0.003s...\n", + "[t-SNE] Computed neighbors for 223 samples in 0.002s...\n", "[t-SNE] Computed conditional probabilities for sample 223 / 223\n", "[t-SNE] Mean sigma: 0.279578\n", "(Round 2) Computing clustering\n", - "MEMORY 0.450830336\n", + "MEMORY 0.464023552\n", "Beginning preprocessing + Leiden\n" ] }, @@ -710,7 +710,7 @@ "output_type": "stream", "text": [ "\r", - " 6%|▌ | 3/50 [00:00<00:02, 20.19it/s]" + " 6%|▌ | 3/50 [00:00<00:02, 20.16it/s]" ] }, { @@ -724,7 +724,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 50/50 [00:01<00:00, 31.00it/s]" + "100%|██████████| 50/50 [00:01<00:00, 30.32it/s]" ] }, { @@ -734,11 +734,11 @@ "Got 11 clusters after round 2\n", "Counts:\n", "{3: 27, 1: 28, 4: 26, 6: 6, 2: 27, 5: 17, 10: 2, 7: 5, 0: 80, 9: 2, 8: 3}\n", - "MEMORY 0.451018752\n", + "MEMORY 0.464105472\n", "(Round 2) Aggregating seqlets in each cluster\n", - "MEMORY 0.451018752\n", + "MEMORY 0.464105472\n", "Aggregating for cluster 0 with 80 seqlets\n", - "MEMORY 0.451018752\n" + "MEMORY 0.464105472\n" ] }, { @@ -754,49 +754,49 @@ "text": [ "Trimming eliminated 0 seqlets out of 80\n", "Aggregating for cluster 1 with 28 seqlets\n", - "MEMORY 0.451018752\n", + "MEMORY 0.464105472\n", "Trimming eliminated 0 seqlets out of 28\n", "Removed 7 duplicate seqlets\n", "Aggregating for cluster 2 with 27 seqlets\n", - "MEMORY 0.451018752\n", + "MEMORY 0.464105472\n", "Trimming eliminated 0 seqlets out of 27\n", "Removed 10 duplicate seqlets\n", "Aggregating for cluster 3 with 27 seqlets\n", - "MEMORY 0.451018752\n", + "MEMORY 0.464105472\n", "Trimming eliminated 0 seqlets out of 27\n", "Removed 8 duplicate seqlets\n", "Aggregating for cluster 4 with 26 seqlets\n", - "MEMORY 0.451018752\n", + "MEMORY 0.464105472\n", "Trimming eliminated 0 seqlets out of 26\n", "Removed 11 duplicate seqlets\n", "Aggregating for cluster 5 with 17 seqlets\n", - "MEMORY 0.451018752\n", + "MEMORY 0.464105472\n", "Trimming eliminated 0 seqlets out of 17\n", "Removed 6 duplicate seqlets\n", "Aggregating for cluster 6 with 6 seqlets\n", - "MEMORY 0.451018752\n", + "MEMORY 0.464105472\n", "Trimming eliminated 0 seqlets out of 6\n", "Removed 3 duplicate seqlets\n", "Aggregating for cluster 7 with 5 seqlets\n", - "MEMORY 0.451018752\n", + "MEMORY 0.464105472\n", "Trimming eliminated 0 seqlets out of 5\n", "Removed 1 duplicate seqlets\n", "Aggregating for cluster 8 with 3 seqlets\n", - "MEMORY 0.451018752\n", + "MEMORY 0.464105472\n", "Trimming eliminated 0 seqlets out of 3\n", "Aggregating for cluster 9 with 2 seqlets\n", - "MEMORY 0.451018752\n", + "MEMORY 0.464105472\n", "Trimming eliminated 0 seqlets out of 2\n", "Removed 1 duplicate seqlets\n", "Aggregating for cluster 10 with 2 seqlets\n", - "MEMORY 0.451018752\n", + "MEMORY 0.464105472\n", "Trimming eliminated 0 seqlets out of 2\n", "Removed 1 duplicate seqlets\n", "Got 11 clusters\n", "Splitting into subclusters...\n", - "MEMORY 0.451018752\n", + "MEMORY 0.464105472\n", "Inspecting for spurious merging\n", - "Wrote graph to binary file in 0.010948896408081055 seconds\n", + "Wrote graph to binary file in 0.010771989822387695 seconds\n", "Running Louvain modularity optimization\n", "After 1 runs, maximum modularity is Q = 0.00217811\n", "After 2 runs, maximum modularity is Q = 0.002238\n", @@ -804,10 +804,10 @@ "After 4 runs, maximum modularity is Q = 0.00238416\n", "After 7 runs, maximum modularity is Q = 0.00281675\n", "After 8 runs, maximum modularity is Q = 0.00286134\n", - "Louvain completed 28 runs in 0.3195309638977051 seconds\n", + "Louvain completed 28 runs in 0.3291330337524414 seconds\n", "Similarity is 0.9561275; is_dissimilar is False\n", "Merging on 11 clusters\n", - "MEMORY 0.45109248\n", + "MEMORY 0.4641792\n", "On merging iteration 1\n", "Numbers for each pattern pre-subsample: [80, 21, 17, 19, 15, 11, 3, 4, 3, 1, 1]\n", "Numbers after subsampling: [80, 21, 17, 19, 15, 11, 3, 4, 3, 1, 1]\n", @@ -861,7 +861,7 @@ "Trimming eliminated 0 seqlets out of 83\n", "Trimming eliminated 0 seqlets out of 87\n", "Unmerged patterns remapping: OrderedDict([(0, 1), (6, 2), (8, 3), (9, 4), (10, 5)])\n", - "Time spent on merging iteration: 6.260226011276245\n", + "Time spent on merging iteration: 6.14963698387146\n", "On merging iteration 2\n", "Numbers for each pattern pre-subsample: [87, 80, 3, 3, 1, 1]\n", "Numbers after subsampling: [87, 80, 3, 3, 1, 1]\n", @@ -886,7 +886,7 @@ "Collapsing 0 & 2 with crosscontam 0.5389527458492975 and sim 0.8992981860964258\n", "Trimming eliminated 0 seqlets out of 90\n", "Unmerged patterns remapping: OrderedDict([(1, 1), (3, 2), (4, 3), (5, 4)])\n", - "Time spent on merging iteration: 0.8045527935028076\n", + "Time spent on merging iteration: 0.8070740699768066\n", "On merging iteration 3\n", "Numbers for each pattern pre-subsample: [90, 80, 3, 1, 1]\n", "Numbers after subsampling: [90, 80, 3, 1, 1]\n", @@ -907,9 +907,9 @@ " [0.32 0.29 0.25 1. 0.71]\n", " [0.07 0.38 0.34 0.64 1. ]]\n", "Got 5 patterns after merging\n", - "MEMORY 0.451518464\n", + "MEMORY 0.46477312\n", "Performing seqlet reassignment\n", - "MEMORY 0.451518464\n", + "MEMORY 0.46477312\n", "Cross contin jaccard time taken: 0.01 s\n", "Cross contin jaccard time taken: 0.01 s\n", "Discarded 2 seqlets\n", @@ -918,9 +918,9 @@ "Skipped 7 seqlets\n", "Skipped 2 seqlets\n", "Got 2 patterns after reassignment\n", - "MEMORY 0.451518464\n", - "Total time taken is 17.63s\n", - "MEMORY 0.451518464\n" + "MEMORY 0.46477312\n", + "Total time taken is 17.2s\n", + "MEMORY 0.46477312\n" ] } ], @@ -972,7 +972,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 9, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -1005,7 +1005,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 10, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -1026,7 +1026,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1267,7 +1267,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 11, "metadata": { "colab": {}, "colab_type": "code", @@ -1280,38 +1280,38 @@ "text": [ "Loaded sliding window sizes: [ 5 9 13 17]\n", "For increasing = True , the minimum IR precision was 0.2954850349262155 occurring at 5.7220458984375e-06 implying a frac_neg of 0.41941626448668695\n", - "Adjusted frac neg is 0.99\n", + "To be conservative, adjusted frac neg is 0.95\n", "For increasing = True , the minimum IR precision was 0.31974367348777494 occurring at 6.765127182006836e-06 implying a frac_neg of 0.47003410483096586\n", - "Adjusted frac neg is 0.99\n", + "To be conservative, adjusted frac neg is 0.95\n", "For increasing = True , the minimum IR precision was 0.3469747405521833 occurring at 1.621246337890625e-05 implying a frac_neg of 0.5313343328335832\n", - "Adjusted frac neg is 0.99\n", + "To be conservative, adjusted frac neg is 0.95\n", "For increasing = True , the minimum IR precision was 0.4006572406407763 occurring at 7.033348083496094e-06 implying a frac_neg of 0.6684943371454617\n", - "Adjusted frac neg is 0.99\n", + "To be conservative, adjusted frac neg is 0.95\n", "For increasing = False , the minimum IR precision was 0.35928651361524633 occurring at -5.638343282043934e-06 implying a frac_neg of 0.5607600296390388\n", - "Adjusted frac neg is 0.99\n", + "To be conservative, adjusted frac neg is 0.95\n", "For increasing = False , the minimum IR precision was 0.4258213778275138 occurring at -2.9428978450596333e-05 implying a frac_neg of 0.7416183072374903\n", - "Adjusted frac neg is 0.99\n", + "To be conservative, adjusted frac neg is 0.95\n", "For increasing = False , the minimum IR precision was 0.11749949829420027 occurring at -1.7642974853515625e-05 implying a frac_neg of 0.13314383172256963\n", - "Adjusted frac neg is 0.99\n", + "To be conservative, adjusted frac neg is 0.95\n", "For increasing = False , the minimum IR precision was 0.41327328308403144 occurring at -4.0531158447265625e-06 implying a frac_neg of 0.7043709978920574\n", - "Adjusted frac neg is 0.99\n", + "To be conservative, adjusted frac neg is 0.95\n", "Loaded sliding window sizes: [ 5 9 13 17]\n", "For increasing = True , the minimum IR precision was 0.2954850349262155 occurring at 5.7220458984375e-06 implying a frac_neg of 0.41941626448668695\n", - "Adjusted frac neg is 0.99\n", + "To be conservative, adjusted frac neg is 0.95\n", "For increasing = True , the minimum IR precision was 0.31974367348777494 occurring at 6.765127182006836e-06 implying a frac_neg of 0.47003410483096586\n", - "Adjusted frac neg is 0.99\n", + "To be conservative, adjusted frac neg is 0.95\n", "For increasing = True , the minimum IR precision was 0.3469747405521833 occurring at 1.621246337890625e-05 implying a frac_neg of 0.5313343328335832\n", - "Adjusted frac neg is 0.99\n", + "To be conservative, adjusted frac neg is 0.95\n", "For increasing = True , the minimum IR precision was 0.4006572406407763 occurring at 7.033348083496094e-06 implying a frac_neg of 0.6684943371454617\n", - "Adjusted frac neg is 0.99\n", + "To be conservative, adjusted frac neg is 0.95\n", "For increasing = False , the minimum IR precision was 0.35928651361524633 occurring at -5.638343282043934e-06 implying a frac_neg of 0.5607600296390388\n", - "Adjusted frac neg is 0.99\n", + "To be conservative, adjusted frac neg is 0.95\n", "For increasing = False , the minimum IR precision was 0.4258213778275138 occurring at -2.9428978450596333e-05 implying a frac_neg of 0.7416183072374903\n", - "Adjusted frac neg is 0.99\n", + "To be conservative, adjusted frac neg is 0.95\n", "For increasing = False , the minimum IR precision was 0.11749949829420027 occurring at -1.7642974853515625e-05 implying a frac_neg of 0.13314383172256963\n", - "Adjusted frac neg is 0.99\n", + "To be conservative, adjusted frac neg is 0.95\n", "For increasing = False , the minimum IR precision was 0.41327328308403144 occurring at -4.0531158447265625e-06 implying a frac_neg of 0.7043709978920574\n", - "Adjusted frac neg is 0.99\n" + "To be conservative, adjusted frac neg is 0.95\n" ] } ], @@ -1320,6 +1320,11 @@ "import numpy as np\n", "import modisco\n", "from modisco.tfmodisco_workflow import workflow\n", + "reload(modisco.tfmodisco_workflow.workflow)\n", + "reload(modisco.tfmodisco_workflow)\n", + "reload(modisco)\n", + "reload(modisco.core)\n", + "reload(modisco)\n", "\n", "track_set = modisco.tfmodisco_workflow.workflow.prep_track_set(\n", " task_names=tasks,\n", @@ -1335,7 +1340,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 80, "metadata": { "scrolled": false }, @@ -1353,8 +1358,8 @@ "output_type": "stream", "text": [ "[Parallel(n_jobs=10)]: Using backend LokyBackend with 10 concurrent workers.\n", - "[Parallel(n_jobs=10)]: Done 30 tasks | elapsed: 4.6s\n", - "[Parallel(n_jobs=10)]: Done 83 out of 83 | elapsed: 4.7s finished\n" + "[Parallel(n_jobs=10)]: Done 40 tasks | elapsed: 0.0s\n", + "[Parallel(n_jobs=10)]: Done 83 out of 83 | elapsed: 0.1s finished\n" ] }, { @@ -1412,8 +1417,8 @@ "output_type": "stream", "text": [ "[Parallel(n_jobs=10)]: Using backend LokyBackend with 10 concurrent workers.\n", - "[Parallel(n_jobs=10)]: Done 40 tasks | elapsed: 0.2s\n", - "[Parallel(n_jobs=10)]: Done 81 out of 81 | elapsed: 0.2s finished\n" + "[Parallel(n_jobs=10)]: Done 40 tasks | elapsed: 0.0s\n", + "[Parallel(n_jobs=10)]: Done 81 out of 81 | elapsed: 0.1s finished\n" ] }, { @@ -1465,8 +1470,7 @@ "text": [ "Getting labels\n", "Getting impscores data\n", - "Computing fwd sims\n", - "Took 0.18344807624816895 s\n" + "Computing fwd sims\n" ] }, { @@ -1475,19 +1479,19 @@ "text": [ "[Parallel(n_jobs=10)]: Using backend LokyBackend with 10 concurrent workers.\n", "[Parallel(n_jobs=10)]: Done 40 tasks | elapsed: 0.0s\n", - "[Parallel(n_jobs=10)]: Done 2100 tasks | elapsed: 0.2s\n", - "[Parallel(n_jobs=10)]: Done 2362 out of 2362 | elapsed: 0.2s finished\n", + "[Parallel(n_jobs=10)]: Done 4090 tasks | elapsed: 0.2s\n", + "[Parallel(n_jobs=10)]: Done 4724 out of 4724 | elapsed: 0.3s finished\n", "[Parallel(n_jobs=10)]: Using backend LokyBackend with 10 concurrent workers.\n", - "[Parallel(n_jobs=10)]: Done 1 out of 1 | elapsed: 0.1s finished\n" + "[Parallel(n_jobs=10)]: Done 1 out of 1 | elapsed: 0.0s finished\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ + "Took 0.2695131301879883 s\n", "Getting impscores data\n", - "Computing fwd sims\n", - "Took 0.18466782569885254 s\n" + "Computing fwd sims\n" ] }, { @@ -1495,9 +1499,22 @@ "output_type": "stream", "text": [ "[Parallel(n_jobs=10)]: Using backend LokyBackend with 10 concurrent workers.\n", - "[Parallel(n_jobs=10)]: Done 40 tasks | elapsed: 0.0s\n", - "[Parallel(n_jobs=10)]: Done 2100 tasks | elapsed: 0.2s\n", - "[Parallel(n_jobs=10)]: Done 2362 out of 2362 | elapsed: 0.2s finished\n" + "[Parallel(n_jobs=10)]: Done 40 tasks | elapsed: 0.0s\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Took 0.2630581855773926 s\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Parallel(n_jobs=10)]: Done 4090 tasks | elapsed: 0.2s\n", + "[Parallel(n_jobs=10)]: Done 4724 out of 4724 | elapsed: 0.3s finished\n" ] } ], @@ -1517,14 +1534,83 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 89, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.07060099, 0.39592812, 0.43990814, 0.46051812, 0.46358678,\n", + " 0.477134 , 0.48289524, 0.48303023, 0.4852053 , 0.48598942,\n", + " 0.48748475, 0.48771762, 0.48974793, 0.49179656, 0.49354536,\n", + " 0.49425378, 0.49595822, 0.49642561, 0.49781634, 0.49815178,\n", + " 0.49975331, 0.50083468, 0.50237827, 0.50284284, 0.50577822,\n", + " 0.50698624, 0.50707468, 0.50790746, 0.50900005, 0.5093652 ,\n", + " 0.50968138, 0.509743 , 0.51138583, 0.51156751, 0.51275761,\n", + " 0.51303825, 0.51366061, 0.51438559, 0.51468357, 0.5147146 ,\n", + " 0.51476555, 0.51484839, 0.51511623, 0.51568231, 0.51600813,\n", + " 0.51601327, 0.51669353, 0.5168097 , 0.51685902, 0.51739562,\n", + " 0.51783374, 0.51800729, 0.51860958, 0.51861522, 0.51920012,\n", + " 0.51921313, 0.51930455, 0.51933883, 0.51937165, 0.51975825,\n", + " 0.51977374, 0.52013972, 0.52026368, 0.52042973, 0.52045827,\n", + " 0.5205568 , 0.52058087, 0.52066148, 0.52098923, 0.52103312,\n", + " 0.52116053, 0.52125391, 0.52155886, 0.52160719, 0.52212082,\n", + " 0.52217797, 0.52282433, 0.52306766, 0.52308391])" + ] + }, + "execution_count": 89, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "instance_scorer.get_prec_for_threshold(motif_idx=0,\n", + " threshold=instance_scorer.thresholds_list[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 91, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Fraction of values above cutoff: 0.1572\n", + "computing the transformed score track\n", + "done computing the transformed score track\n", + "Fraction of values above cutoff: 0.1572\n" + ] + } + ], + "source": [ + "from collections import defaultdict\n", + "from modisco.hit_scoring import exemplar_based_hitscoring\n", + "reload(exemplar_based_hitscoring)\n", + "\n", + "CUTOFF_VALUE = 0.9\n", + "coordinates_to_be_scanned, task0_transformed_scoretrack =\\\n", + " exemplar_based_hitscoring.get_windows_to_be_scanned(\n", + " scanning_window_width=SCANNING_WINDOW_WIDTH,\n", + " contrib_scores=task_to_scores[\"task0\"],\n", + " val_transformer=(loaded_tfmodisco_results.\n", + " multitask_seqlet_creation_results.\n", + " task_name_to_tnt_results[\"task0\"].val_transformer),\n", + " cutoff_value=CUTOFF_VALUE)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ "Getting impscores data\n", "Computing fwd sims\n" ] @@ -1534,42 +1620,26 @@ "output_type": "stream", "text": [ "[Parallel(n_jobs=10)]: Using backend LokyBackend with 10 concurrent workers.\n", - "[Parallel(n_jobs=10)]: Done 40 tasks | elapsed: 0.0s\n" + "[Parallel(n_jobs=10)]: Done 40 tasks | elapsed: 0.0s\n", + "[Parallel(n_jobs=10)]: Done 9764 tasks | elapsed: 0.4s\n", + "[Parallel(n_jobs=10)]: Done 13072 out of 13072 | elapsed: 0.5s finished\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Took 0.5228831768035889 s\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Parallel(n_jobs=10)]: Done 9764 tasks | elapsed: 0.4s\n", - "[Parallel(n_jobs=10)]: Done 13072 out of 13072 | elapsed: 0.5s finished\n" + "Took 0.5234172344207764 s\n" ] } ], "source": [ - "from collections import defaultdict\n", - "from modisco.hit_scoring import exemplar_based_hitscoring\n", "reload(exemplar_based_hitscoring)\n", "\n", - "CUTOFF_VALUE = 0.9\n", - "coordinates_to_be_scanned, task0_transformed_scoretrack =\\\n", - " exemplar_based_hitscoring.get_windows_to_be_scanned(\n", - " scanning_window_width=SCANNING_WINDOW_WIDTH,\n", - " contrib_scores=task_to_scores[\"task0\"],\n", - " val_transformer=(loaded_tfmodisco_results.\n", - " multitask_seqlet_creation_results.\n", - " task_name_to_tnt_results[\"task0\"].val_transformer),\n", - " cutoff_value=CUTOFF_VALUE)\n", - " \n", "(motifmatch_to_coordinates,\n", - " motifmatch_to_coordinatesbyregionidx) = (\n", + " motifmatch_to_coordinatesbyregionidx,\n", + " motif_scores, motif_precisions,\n", + " besthit_isrevcomp) = (\n", " exemplar_based_hitscoring.scan_and_process_results(\n", " instance_scorer=instance_scorer, track_set=track_set,\n", " coordinates=coordinates_to_be_scanned))" @@ -1577,7 +1647,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 103, "metadata": { "scrolled": false }, @@ -1591,7 +1661,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1603,7 +1673,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1613,16 +1683,9 @@ }, "output_type": "display_data" }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Index 1\n" - ] - }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1632,9 +1695,17 @@ }, "output_type": "display_data" }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tal hits: [MotifHitAndCoord(motif_idx=0, motif_score=0.6288662472752831, precision_at_motif_score=0.3034387831986581, example_idx=0, start=114, end=139, is_revcomp=True), MotifHitAndCoord(motif_idx=0, motif_score=0.9917175077370958, precision_at_motif_score=1.0, example_idx=0, start=123, end=148, is_revcomp=False), MotifHitAndCoord(motif_idx=0, motif_score=0.5309194727615236, precision_at_motif_score=0.0, example_idx=0, start=157, end=182, is_revcomp=True), MotifHitAndCoord(motif_idx=0, motif_score=0.9904592739684515, precision_at_motif_score=1.0, example_idx=0, start=166, end=191, is_revcomp=False)]\n", + "gata hits: [MotifHitAndCoord(motif_idx=1, motif_score=0.9979175245102603, precision_at_motif_score=1.0, example_idx=0, start=151, end=176, is_revcomp=False)]\n" + ] + }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1648,12 +1719,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Index 2\n" + "Index 1\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1665,7 +1736,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1675,16 +1746,9 @@ }, "output_type": "display_data" }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Index 3\n" - ] - }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1694,9 +1758,17 @@ }, "output_type": "display_data" }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tal hits: []\n", + "gata hits: [MotifHitAndCoord(motif_idx=1, motif_score=0.9955329648255107, precision_at_motif_score=1.0, example_idx=1, start=27, end=52, is_revcomp=False), MotifHitAndCoord(motif_idx=1, motif_score=0.9984405620577878, precision_at_motif_score=1.0, example_idx=1, start=94, end=119, is_revcomp=False), MotifHitAndCoord(motif_idx=1, motif_score=0.9995610910908511, precision_at_motif_score=1.0, example_idx=1, start=118, end=143, is_revcomp=False)]\n" + ] + }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1710,12 +1782,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Index 4\n" + "Index 2\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1727,7 +1799,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIcAAACMCAYAAADm+clLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3df3Ac533f8c/3fgB3IAkQkEhZJhBRcWipsmsnLqso8cSRnDqRUtdqO82MPInj5sdolNpp2mmT2MlMmj86bSbp5FcjR1VtVcnUtcbj2InaKJZdi3YaO1ZEyT9lkQ4lKyZE2SRFEgcSd7hf3/6xu4fD4Q63oADe7t77NcMBbnePem4e8bnd7/N9vo+5uwAAAAAAADCecqNuAAAAAAAAAEaH4BAAAAAAAMAYIzgEAAAAAAAwxggOAQAAAAAAjDGCQwAAAAAAAGOM4BAAAAAAAMAYK4y6Af1cffXVfvDgwVE3AwAAAAAAIDOefPLJs+6+r/f40OCQmT0g6a2STrv7a/ucN0m/J+lHJa1I+pfu/lR47vbwXF7S+939N+I09uDBgzp69GicSwEAAAAAABCDmf1dv+NxlpU9KOn2Tc7fIelQ+OduSX8Y/gfzku4Nz98k6e1mdlP8JgMAAAAAAGCnDQ0OuftfSjq3ySV3SvpjD3xe0l4zu1bSzZJOuPtz7l6X9FB4LQAAAAAAABJiOwpSH5B0suv1Ynhs0HEM8PzZS/r1h59Wq+2jbgoAYBP3feZZffbE2VE3AwAAJNRvf+K4vvDN86NuBhDbdgSHrM8x3+R4/7/E7G4zO2pmR8+cObMNzUqfTx07rQc/97xOXaiOuikAgE3c+9gJffSpF0bdDAAAkECNVlu//9gJ/fmXXxx1U4DYtiM4tChpoev1vKRTmxzvy93vd/fD7n54374NhbPHwlK1se4nACB5Wm3X8mqTsRoAAPRV4bkOKbQdwaGHJf2kBW6RtOTuL0p6QtIhM7vezCYk3RVeiwGiQaTCIAIAicVYDQDA5as1Wnrs2LdH3YwdFQWFKjXuFZAeQ4NDZvYhSX8t6QYzWzSznzGze8zsnvCSRyQ9J+mEpP8u6V9Jkrs3Jb1b0qOSnpH0YXd/egc+Q2ZUGEQAIPGiMZqxGgCArfvfXzqln37wqE6eWxl1U3ZMpdaUROYQ0qUw7AJ3f/uQ8y7pXQPOPaIgeIQYWFYGAMnHWA0AwOV76VJdknTuUl0Lc1Mjbs3O6GQOVZsjbgkQ33YsK8M26cxGM4gAQGJFYzTLygAA2LpxmGSh5hDSiOBQgozDQAkAaReN0ZfqLTVa7RG3BgCAdBmHZ54l6hMihQgOJUhnNpo6FgCQWN1j9HKNTE8AALZiHIJD0b3C8mpTrbaPuDVAPASHEmQcBkoASLvuMZrxGgCArRmHJVfdn22ZiX+kBMGhhKg326o2WpJIPwSAJOseoxmvAQDYmnFYctVdQ5Z6skgLgkMJ0b1MIctRdABIOzKHAAC4fBdWGut+ZlGFewWkEMGhhFg3E00NCwBIrO4xmhpxAABszTiU0ui+P+BeAWlBcCghosHxFdOlTA+UAJB2S9WGXjFd6vwOAADiabe9EyzJ8nco9wpII4JDCRHNRC/MlTO9/hYA0q5SbWhhrhz+TqYnAABxLa825eHmXVkOmqy/V8ju50S2EBxKiGhwXJid0mqzrVpYnBoAkCyVakP7p0sq5i3TN7YAAGy3KFCSs2wHh5aqDS3MTnV+B9KA4FBCRAPl/FwwiLA2FQCSqVJraKZc1Ey5yFgNAMAWRIGSa2eyu1rC3VWpNfWKmZLyOeNeAalBcCgh1jKHSD8EgKRydy1VG5ouFTVdKjIbCADAFkTfm98xN6Xl1aZabR9xi7bfpXpLrbZrplzUdKnAvQJSg+BQQlRqDU0UctrfKVxGHQsASJpao61GK7zhKxcJ5AMAsAXdwSEpmxPi0WfqZBnzXIeUIDiUEJXOTHSh8xoAkCzRTe10uUBwCACALeoEh67Kbj2etXuFYCIpi58R2URwKCEq1aZmygXNlIvBa9amAkDiRGPzWs0hZgMBAIirU0pjLrvBoQ2ZQzzXISUIDiXEUrXRiS5HrwEAydKZDSxRRwAAgK1aqjZUyJmunSl1XmfN+nsFMoeQHrGCQ2Z2u5kdN7MTZvaePud/0cy+GP75qpm1zGwuPPe8mX0lPHd0uz9AVkS730yXwswhBhEASJyNdQQacs9eMU0AAHbCUnVtx8/oddZEWcVr9QnJMkY6DA0OmVle0r2S7pB0k6S3m9lN3de4+2+5+3e7+3dLeq+kz7j7ua5LbgvPH97GtmdKtPvNRCGncjGfyYESANKut45As+1aqbdG3CoAANJhHIJD6+sTFphIQmrEyRy6WdIJd3/O3euSHpJ05ybXv13Sh7ajceOkEg6UkqhqDwAJ1Zs5JFEjDgCAuJZWGpqZynZwKLpX2FMKPme91dZqsz3iVgHDxQkOHZB0suv1YnhsAzObknS7pD/pOuySPmFmT5rZ3Zfb0Cxzd1VqTU2Xg53KpsvUsQCAJFoKA/d7SoXOMmDGawAA4okyh0rFvCYLuUx+hy5VG9ozWVA+Z9wrIFXiBIesz7FBeXH/RNJne5aUvdHd36BgWdq7zOxNff8jZneb2VEzO3rmzJkYzcqOS/WWWm1fnznETDQAJE6l1tCuibyK+dxa5hCZngAAxLLUs1piaSV7zzyVWqOzydDavUL2PieyJ05waFHSQtfreUmnBlx7l3qWlLn7qfDnaUkfU7BMbQN3v9/dD7v74X379sVoVnZ0V7SPfhJdBoDkiXaWlNTJ9mS8BgAgng3BoQx+h1bW3SuQOYT0iBMcekLSITO73swmFASAHu69yMxmJP2gpD/rOrbLzPZEv0v6YUlf3Y6GZ0l3DYvoJ5lDAJA8vfXhomMAAGBz7bZ3dmiWshwcamomnECiPiHSpDDsAndvmtm7JT0qKS/pAXd/2szuCc/fF176zyR9wt0vdb39GkkfM7Pov/W/3P3j2/kBsqB795voZxZTLAEg7aKdJSVRRwAAgC1YXm3Kff2E+ItLtRG3avstVRu67qopSdJ0iSxjpMfQ4JAkufsjkh7pOXZfz+sHJT3Yc+w5Sa9/WS0cA72ZQ9PlopZXm2q3Xblcv5JPAIBRqNSaOrC3LCkoSh0c44YPAIBhKj0T4jPloo59a3mUTdoRvdlREvUJkQ5xlpVhh22sOVSQexBdBwAkR1BHIAgKFfI57Z5kd0kAAOJY6jMhnsWl2UvUHEJKERxKgN6BkjoWAJBM3YU0pezWSwAAYLv1e+ZZXm2q1R60EXb6NFptrdRbnc9YzOc0NZHnuQ6pQHAoASq1IENod7hEgQgzACRPs9XWxdVmJ8tTCpaWkSoOAMBw4zAh3lk6V1qr3sJO1EgLgkMJUKk2tKdUUD6sL5TFgRIA0m45DOT3Zg4xVgMAMNyg4FCWAiedzzjVc69AfUKkAMGhBKh07X4jrdUeYhABgOSIxuTpruDQNDd8AADEEgVO9oaBk+hnloJD0YqQdc92ZeoTIh0IDiXAhhoWGRwoASDtemc8o98ZqwEAGO7CSkPFvKlczEta+z69kKHv0UH3CixBRxoQHEqASm1t9xtpbY0qgwgAJEc0JvfWEWBZGQAAw0UT4mbrS2lkaZKlU3OovH5VSJY+I7KL4FAC9GYO7Z4sKGfZGigBIO0G1RG4VG+p0WqPqlkAAKRCpWuLdymbwaF+mUMsQUdaEBxKgEp1/e43ZsYgAgAJ06k51FNHQForVg0AAPrrnRCfzuAmPP3vFYparjXVavuomgXEQnAoAXoHSok6FgCQNIPqCHSfAwAA/fU+85SKeU0Wcpn6Dl2qNjSRz6lUXHvMjj7zRSaSkHAEh0as3myr2mitS7GUqGMBAElTqTaUz5mmJvKdY53dJRmvAQDY1MAJ8ZXsfIdWqk1NlwudukrSWq3CLAXBkE0Eh0YsSj0kcwgAkq23kKbE7pIAAMQ1DqsleusqSWvPeZQMQdIRHBqxSp9lCtHrCqmHAJAYlVqz71gdnOOGDwCAQdptV6U2BsGhAZ9RYiIJyUdwaMSWOtsdFtYdny4XGEAAIEGWqo1129hLa8vKGK8BABhsebUp9+yvlgjuFXrKhWSw8DayieDQiEXZQb0D5XSZmkMAkCSbpopXyfQEAGCQSmdCPNvBocqApXMSE0lIPoJDI9bJHOqNMJeKWm22VWu0RtEsAECPfsGhUjGnYt644QMAYBP9dvyUsjchvlRt9FkRwhJ0pEOs4JCZ3W5mx83shJm9p8/5W81sycy+GP75tbjvHXeb1RySGEQAICn61REws7BGHGM1AACDRMGhvT3fo3unilpebarZao+iWdvK3fvWJ9w1kVc+x0QSkq8w7AIzy0u6V9JbJC1KesLMHnb3r/Vc+v/c/a2X+d6xtTQgxbJ7ber+PaUr3i4AwBp371tHQAoyPbnhAwBgsAvhdvXRLp+RtQnxpuZ2TVzxdm2nS/WWWm3fcK9gZpouFViCjsSLkzl0s6QT7v6cu9clPSTpzph//8t57zq/+3+/rj/63POX89ZEq9QamijkVCrm1x1fW5vKIAIAo1ZrtNVo+YbZQCl7KfEAAGy3QcvKslSPZ9CKkOhYFj4jsi1OcOiApJNdrxfDY72+z8y+ZGZ/YWav2eJ7ZWZ3m9lRMzt65syZDec//MRJfewLL8RobrpUBs5EFzrnAQCjNWhnyeAYwSEAADYzDsGhQStComMsQUfSxQkOWZ9j3vP6KUnXufvrJf1XSX+6hfcGB93vd/fD7n543759687Vm229WKlp8fxKjOamS6Xa1Eyfhw1qDgFAckRj8aDZwGjnSQAAsNFStaFi3lQeuFoi/c88ZA4h7eIEhxYlLXS9npd0qvsCd6+4+8Xw90ckFc3s6jjvjePUharcpbMX61qpZ+sGfKnP7jfSWsSZQQQARm/QzpLBsQJjNQAAm1gKt3g3W587kKXg0Ob3CmQZI/niBIeekHTIzK43swlJd0l6uPsCM3uFhf/Szezm8O99Kc5741g8X+38/kLX71nQb/cbaW1QYRABgNEbNhtYqTbk3jcxFgCAsVcZMCGepeBQlEU8qD4htWSRdEN3K3P3ppm9W9KjkvKSHnD3p83snvD8fZL+haSfM7OmpKqkuzy4S+773q028mTXcrKT51d06Jo9W/0rEmup2tDBq3ZtOD5RyKlczGdioASAtBtWR6DZdq3UW9o1OfRrFQCAsRNlDvXq3qE57TavT1igXAgSL9ZdbLhU7JGeY/d1/f4Hkv4g7nu36uS5ruDQuYxlDg0YKKVoNpoIMwCM2rDMISnIBCU4BADARkvVhq7avXGr+lIxr8lCLhMT4tG9wp4+y8pmykXVm23VGq0Nu1QDSRFnWdnILZ6van62rFIxl6mi1O6uSq3ZN7osBRHmLAyUAJB2USr4nlKf2cBSdlLiAQDYCYMyh6SwWPNK+r9Dl6oN7ZksKJ/buCcTJUOQBqkIDp08v6LvmJvS/OxUpjKHLtVbarV988wh0g8BYOQqtYZ2TeRVzG/82uxkDpHpCQBAX0ODQxkImlRq/esqSdmqrYTsSkdw6FxVC7NTmp8tr6s/lHabVbSPjjOAAMDoDdpZUlqrLcB4DQDARu22q1JraO+A79G9U9l45hlUdFvqqq3ExD8SLPHBoVqjpbMXVzU/W9bC7NS6+kNpF6VPZj2KDgBpN2zGM7oGAACst7zalHv/TR2k7DzzBPcK/cuFcK+ANEh8cCiqMbQwN6WFubIqtWZm/lFFkePNIsysSwWA0atUG5tmeUbXAACA9Tbb1EGKtnlP/3dopdrc5F6h0LkGSKrEB4eiGkMLc0HmkKTMFKVeijFQLq821W77lWwWAKDHZsvKoiLVWbixBQBgu10Yk9USZBkj7ZIfHAoDQfOzQUFqKTvb2VeG1hwqyD1IxQQAjM7yJjtLFvI57Z4sUEcAAIA+hk2Iz5SLurjaVLPVvpLN2nabFaTu1BwiOIQES3xwaPF8VROFnPbtntTCXDk8Nh6ZQzMMIgCQCJvNBkrZmfUEAGC7dZ55poY889TSOyHeaLW1Um8NvFco5nOamshzr4BES3xw6OS5Fc3PlpXLmWbKRe2ZLGjxfEYyh8IBcHep/2z0NOmHADByzVZbF1cH1xGQgqVl1BEAAGCjuBPiaX7mWVsR0v+5LjhXJMsYiZb84ND5lc5yMjPTgdlyZnYsq1Qb2lMqKJ+zvufJHAKA0VsOA/nDMocYqwEA2GgcgkPDsqMksoyRfIkPDi2er2phttx5vTA3lZ3MoU12v5G6dsAhwgwAIzNsZ8noHGM1AAAbLVUbKuZN5WK+7/ksBIeiFSGbPtuVyTJGsiU6OLRca+jCSkMLc1OdYwuzUzp5fkXu6d/Ba2gNi6n0D5QAkHbDZjyjc4zVAABsFD3zmG2+WiLN36PcKyALEh0cinYlm+/KHJqfLWul3tK5S/VRNWvbBBXtN1uXGpwjwgwAoxONwUPrCHDDBwDABpXq4F28pGwEhzo1hzbLMqbmEBIu0cGhaFeyhdmuzKEwiygLS8uGZQ7tngzqEaV5oASAtItbR+BSvaVGyrfhBQBguw175snCNu9xMoemyRxCwiU6OHQyDACtW1YWbmd/MgPb2VeqzU0HEDPTdKlAhBkARigagzdPFQ+yipZTvA0vAAA7Yana0N5NvkNLxbxKxVyqAyfx7hWKurjaVLud/vIoyKZYwSEzu93MjpvZCTN7T5/zP25mXw7/fM7MXt917nkz+4qZfdHMjm6lcSfPrWjXRF6zXbO10c5l0ZKzNFsaUpBaIsIMAKMWjcGbF5lMf0o8AAA7YVjmkBTW41lJ73foUrWhiXxOk4XBj9fT5aLcmUhCcg0uoBAys7ykeyW9RdKipCfM7GF3/1rXZd+Q9IPuft7M7pB0v6Tv7Tp/m7uf3WrjFs9XNT87ta542e7Jgmanip0lZ2lVb7ZVbbRiDZRpTrEEgLSrVBsq5ExTE/13WZHWZgoZrwEAWC92cCjF36GValPTmxTdlrruFWqNTZeqA6MSJ3PoZkkn3P05d69LekjSnd0XuPvn3P18+PLzkua3o3GL51c6y8i6LcxNdZacpVWcrZGlYKY6zQMlAKTdUlhIc7MbPjKHAADYqN32IBgSIzh0oZreDYeCotub511EG1twr4CkihMcOiDpZNfrxfDYID8j6S+6XrukT5jZk2Z2d9yGubtOnlvpLCPrNj9b1uK5dGcOVWIULYvOV0g9BICRqdQ2rw8nrZ8NBAAAgeVaU+7DJ8SDzKH0PvPEDYBJBIeQXHGCQ/2mSvtW0TKz2xQEh3656/Ab3f0Nku6Q9C4ze9OA995tZkfN7OiZM2d0YaWhS/XWum3sIwuzU1q8UE11Ma9ODYthEeZygQEEAEYoqA83bDaQGz4AAHrF2cVLCoJHaV6aHbeWrMQSdCRXnODQoqSFrtfzkk71XmRmr5P0fkl3uvtL0XF3PxX+PC3pYwqWqW3g7ve7+2F3P7xv377ObmTdO5V1GjA3pXqzrTMXV2M0P5mibKCsD5QAkHaVcFnZZtZqDqV31hMAgO0WNziU/ppDZA4h/eIEh56QdMjMrjezCUl3SXq4+wIz+w5JH5X0Dnf/etfxXWa2J/pd0g9L+mqchkW7kS0MWFYWXJPepWVxdr+Jzq8226o1WleiWQDwspw4fVH//H2f1enl2qibsm3iBIdKxZyKeeOGDwCALlsJDl1cbarZal+JZm27pTg1h1iCjoQbGhxy96akd0t6VNIzkj7s7k+b2T1mdk942a9JukrS+3q2rL9G0l+Z2Zck/Y2kP3f3j8dpWLQb2Xy/gtRhwGgxxUWpt1JzSGIQAZAOf/qFF/TUNy/o0ae/PeqmbJs4dQTMLKwRx1gNAECkExwasjvX2jNP+jJw3T1WfcJdE3nlc0wkIbmGbmUvSe7+iKRHeo7d1/X7z0r62T7ve07S6y+nYSfPr2imXOybWZOpzKEYy8qkIJi0f09px9sFAC/HY8dOS5KOHDutd9xy3Yhb8/K5e6w6AhK7SwIA0GsrmUPR9XO7Jna8XdvpUr2lVtuH3iuYmaZLBZagI7HiLCsbiZPnqn23sZekUjGvfXsmO3WJ0qhSa2iikFOpmN/0urWBkkEEQLJ9a6mmr71Y0e7Jgj737NlMLIetNdpqtHzoTa1EjTgAAHpdTnAobeKuCImuSeNnxHhIbHBo8fxK33pDkYXZcuqXlcWbiS50rgeAJPvM14OsoZ9/83ep1mjr88+9NOQdyRd3Z8ngGoJDAAB0W6o2NJHPqTxkQnzvVHqDQ3FXhETXsAQdSZXg4FC17zb2kYW5qXRnDlWbmonxsEHNIQBpceTYGV07U9I7v/+gSsWcPn38zKib9LJFY2/c2cA01koAAGCnLIWbOpjZpteROQSMXiKDQ82Wa7XZ7ruNfWR+tqxTF2opr2gfL7ocXQ8ASVVvtvVXJ87qthv3q1TM642vulqPHTstdx91016WuDtLBtcUGKsBAOgSbPEeL/tWSuczz9buFcgyRnIlMjhUDwM+my8rm1Kr7fpWJZ3bJcfZ/UZaG2QYRAAk2dHnz+nialO33bBfknTrjfv1zXMreu7spRG37OXZ6mxgpdpIfUAMAIDtslSN98wzU07vM0+UNRy3PiG1ZJFUyQwONYPg0LBlZVJQuDqN4u5+M1EI1uimMYoOYHwcOX5aE/mcvv9VV0mSbn31vuB4uHtZWm21jkCz7Vqpp78QNwAA2+FCtR4raDJZyKtUzOnCSv0KtGp7ba0+YYFyIUisZAaHWlFwaPPMIUmprTtUiRlFl6LZaCLMAJLryPEz+t7vnNOuyeDGaGFuSof270593aGtZg5J1IgDACASN3NISm89nuheYU+Mif+ZclH1ZjsTO7oiexIZHGo027p696TKE4Or2l+7t6ScKZU7lrm7KrVmrOiyFESY0zhQAhgPJ8+t6MTpi50lZZE337hfj3/jJV1cTW9wO0r93lOKMRtYSm+9BAAAdsLSSvaDQ0vVhvZMFpTPbV50W6JkCJItkcGhequ96ZIySSrmc7p2pqzFc+nLHLq42lSr7ZkfKAGMhyPHg6Vjt924Pjh06w371Wi5Pnvi7CiatS2Wqg3tmsirmB/+ddnZaWWF8RoAgHbbtbzazPwzTyXmRkNSundlQ/YlMzg0ZKeyyPxsOZXLyqKiZXFqDkXXsUwBQFIdOXZaB6+a0vVX71p3/PDBWe2eLOjTx9Nbd6hSi3/DF2WDsp09AADScq0p93h1+6QoOJS+79Ct3SuwBB3JlcjgUKPV1sKQzCEpqEmUxoLU0axy1qPoALKv1mjpc8++pFt7lpRJQYbnDxy6WkeOnUntDl5brZUQvQcAgHG3tIW6fVIQOEnjcqvgXiFeuRDuFZBkiQwOuTYvRh1ZmCvr28s1rTbTVdArihRvJcKcxoESQPb99bMvabXZ1ptv3BgckoKlZt+q1PTMi8tXuGXboxJzZ0mJOgIAAHTbanAorRPilWpzC/cKhc57gKRJZHBICgI/Q6+ZnZK7dOpC7Qq0aPtcThR9ebWpdjudM+8AsuvI8dMqF/O6+fq5vuc7W9qndGnZ0hbqCERFq9N4YwsAwHa7nODQxdWmmuHO1WlBljGyIrnBoRiZQ1HR6pMpK0odzSpvJcLsLi2neMcfANnj7nrs2Gm98buuUqnYf3fJ/dMlvfbAdGrrDi1vYWfJQj6n3ZMF6ggAAKC1AMjeqYlY1+/t1ONJ1zPPZdUcIjiEBEpscOiVe2NkDoVFq9O2nf3lRNElBhEAyfLsmUtaPF/tW2+o22037NeTf3c+lbt4bWU2UEpvSjwAANtty888U+nLqmm02lqpt2J/xmI+p6mJfKo+I8ZHIoNDxXxOE4XhTbtmuqRi3lK3Y1kUDd9dijcbPU36IYAEOnKs/xb2vW69Yb/aLn3mb89ciWZtm2arrYur8esISMHSMuoIAABw+RPiaXrmWVsREu+5LriWnaiRTLGCQ2Z2u5kdN7MTZvaePufNzH4/PP9lM3tD3Pf2M5GPF7PK50yv3FtO5bKyPaWC8jmLdT2ZQwCS6Mjx07rhmj06MCTT87sX9mp2qqhPH0vX0rLlMJC/1cwhxmoAAIIgz0Q+p1Ix3rNdGoNDnQDYFFnGSL+h/1LNLC/pXkl3SLpJ0tvN7Kaey+6QdCj8c7ekP9zCezcoFuIFTaSgNlHalpVtZfcbqWsHHCLMABJiudbQE8+f06037ht6bT5n+sFX79Onv34mVYX1t7qzZHQtYzUAAGubOphtbUI8TYGTaEXIlp7tymQZI5nihHFvlnTC3Z9z97qkhyTd2XPNnZL+2AOfl7TXzK6N+d4N4mYOScGuZospW1a25RoWKVx/CyDbPnviJTVartuG1BuK3Hbjfp27VNeXX1ja4ZZtn62mw0fXMlYDACAtVeuaibmpg9RVSmOlvlNN2nbcKyBL4vxrPSDpZNfrRUnfG+OaAzHfu0GcekOR+dkpnb1Y1y3/6VOx3zNq5y7V9Q+um419fTTY/Mc/f0a/88m/3almAUBsF1eb2lMqxB7L3nRon3Im/eQHHtfURPwbxVGqh1vpbvWG71uVWqq+kwAA2AnnVup67SunY18ffd/+5seP694jz+5Us7ZVrdmStLV7helyUUeOn+FeAYkT5w69Xx5g77qAQdfEeW/wF5jdrWBJml65cF2MZgXe9vpX6tSFqpqt9CxVkKQ7/v4rYl+7e7KgX7r9Bv3d2XRlSAHItlteNadizEzP2V0T+vW3vUZPv1DZ4VZtr92lgl43PxP7+h87PK+VelPt9g42CgCAlHjLTdfEvnaykNev/OiNevb0pR1s0fab3TWh79y3O/b177jlOk3kc/J0Pb4iQx4fcNx8yP+VZvZ9kn7d3X8kfP1eSXL3/9x1zX+T9Gl3/1D4+rikWyUdHPbefg4fPuxHjx4d+qEAAAAAAAAQj5k96e6He4/HmfJ9QtIhM7vezCYk3SXp4Z5rHpb0k+GuZbdIWnL3F2O+FwAAAAAAACMydFmZuzfN7N2SHpWUl/SAuz9tZveE5++T9IikH5V0QtKKpJ/a7L078kkAAAAAAACwZUOXlfgtnGcAAAYVSURBVI0Cy8oAAAAAAAC216BlZYkMDpnZsqTjo24HRuJqSWdH3QiMDP0/vuj78Ub/jy/6frzR/+OLvh9v9P9oXefu+3oPJnU/4eP9IlnIPjM7St+PL/p/fNH3443+H1/0/Xij/8cXfT/e6P9kircHMQAAAAAAADKJ4BAAAAAAAMAYS2pw6P5RNwAjQ9+PN/p/fNH3443+H1/0/Xij/8cXfT/e6P8ESmRBagAAAAAAAFwZSc0cAgAAAAAAwBWQqOCQmd1uZsfN7ISZvWfU7cHOMbMFMztiZs+Y2dNm9gvh8Tkz+6SZ/W34c3bUbcXOMbO8mX3BzP5P+Jr+HxNmttfMPmJmx8Jx4Pvo//FgZv82HPe/amYfMrMSfZ9dZvaAmZ02s692HRvY32b23vA+8LiZ/choWo3tMKDvfysc979sZh8zs71d5+j7DOnX/13n/r2ZuZld3XWM/s+IQX1vZj8f9u/TZvabXcfp+4RITHDIzPKS7pV0h6SbJL3dzG4abauwg5qS/p27/z1Jt0h6V9jf75H0KXc/JOlT4Wtk1y9IeqbrNf0/Pn5P0sfd/UZJr1fw/wH9n3FmdkDSv5Z02N1fKykv6S7R91n2oKTbe4717e/wPuAuSa8J3/O+8P4Q6fSgNvb9JyW91t1fJ+nrkt4r0fcZ9aA29r/MbEHSWyR9s+sY/Z8tD6qn783sNkl3Snqdu79G0n8Jj9P3CZKY4JCkmyWdcPfn3L0u6SEF/wMhg9z9RXd/Kvx9WcGD4QEFff5H4WV/JOmfjqaF2GlmNi/pH0t6f9dh+n8MmNm0pDdJ+oAkuXvd3S+I/h8XBUllMytImpJ0SvR9Zrn7X0o613N4UH/fKekhd191929IOqHg/hAp1K/v3f0T7t4MX35e0nz4O32fMQP+7UvS70j6JUndhW/p/wwZ0Pc/J+k33H01vOZ0eJy+T5AkBYcOSDrZ9XoxPIaMM7ODkr5H0uOSrnH3F6UggCRp/+hahh32uwpuDtpdx+j/8fCdks5I+h/hssL3m9ku0f+Z5+4vKJgt/KakFyUtufsnRN+Pm0H9zb3gePlpSX8R/k7fjwEze5ukF9z9Sz2n6P/se7WkHzCzx83sM2b2D8Pj9H2CJCk4ZH2OsZVaxpnZbkl/IunfuHtl1O3BlWFmb5V02t2fHHVbMBIFSW+Q9Ifu/j2SLollRGMhrC1zp6TrJb1S0i4z+4nRtgoJwr3gmDCzX1VQYuCD0aE+l9H3GWJmU5J+VdKv9Tvd5xj9ny0FSbMKyon8oqQPm5mJvk+UJAWHFiUtdL2eV5Bqjowys6KCwNAH3f2j4eFvm9m14flrJZ0e9H6k2hslvc3MnlewhPTNZvY/Rf+Pi0VJi+7+ePj6IwqCRfR/9v0jSd9w9zPu3pD0UUnfL/p+3Azqb+4Fx4CZvVPSWyX9uLtHD4H0ffa9SsHEwJfC+795SU+Z2StE/4+DRUkf9cDfKFg5cLXo+0RJUnDoCUmHzOx6M5tQUJjq4RG3CTskjBR/QNIz7v7bXacelvTO8Pd3SvqzK9027Dx3f6+7z7v7QQX/1h9z958Q/T8W3P1bkk6a2Q3hoR+S9DXR/+Pgm5JuMbOp8HvghxTUnKPvx8ug/n5Y0l1mNmlm10s6JOlvRtA+7BAzu13SL0t6m7uvdJ2i7zPO3b/i7vvd/WB4/7co6Q3hPQH9n31/KunNkmRmr5Y0Iems6PtEKYy6ARF3b5rZuyU9qmD3kgfc/ekRNws7542S3iHpK2b2xfDYr0j6DQVphj+j4CHix0bUPowG/T8+fl7SB8PJgOck/ZSCCQv6P8Pc/XEz+4ikpxQsKfmCpPsl7RZ9n0lm9iFJt0q62swWJf0HDRjr3f1pM/uwgmBxU9K73L01kobjZRvQ9++VNCnpk0F8WJ9393vo++zp1//u/oF+19L/2TLg3/4Dkh4It7evS3pnmDlI3yeIrWVzAgAAAAAAYNwkaVkZAAAAAAAArjCCQwAAAAAAAGOM4BAAAAAAAMAYIzgEAAAAAAAwxggOAQAAAAAAjDGCQwAAAAAAAGOM4BAAAAAAAMAYIzgEAAAAAAAwxv4/EK5hMYEGkyUAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -1737,16 +1809,9 @@ }, "output_type": "display_data" }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Index 5\n" - ] - }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1756,9 +1821,17 @@ }, "output_type": "display_data" }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tal hits: [MotifHitAndCoord(motif_idx=0, motif_score=0.6940629318048525, precision_at_motif_score=0.5054178960428508, example_idx=2, start=1, end=26, is_revcomp=True), MotifHitAndCoord(motif_idx=0, motif_score=0.9892230296698091, precision_at_motif_score=1.0, example_idx=2, start=10, end=35, is_revcomp=False), MotifHitAndCoord(motif_idx=0, motif_score=0.602743025674392, precision_at_motif_score=0.22250912915793472, example_idx=2, start=58, end=83, is_revcomp=True), MotifHitAndCoord(motif_idx=0, motif_score=0.9985116869126707, precision_at_motif_score=1.0, example_idx=2, start=67, end=92, is_revcomp=False), MotifHitAndCoord(motif_idx=0, motif_score=0.8429574686878377, precision_at_motif_score=0.9666926784028752, example_idx=2, start=140, end=165, is_revcomp=True), MotifHitAndCoord(motif_idx=0, motif_score=0.9994729032358728, precision_at_motif_score=1.0, example_idx=2, start=149, end=174, is_revcomp=False)]\n", + "gata hits: []\n" + ] + }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABI0AAACMCAYAAADx21mCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOydd3hUxdeA37slvZEECD10CL0pXSkqYAFBBRsWFLt8Vixogr13sSsWVAQVkaooRemdECCEXhIgCel9d8/3x2STbHYDiQQC/Obl2Se7y+zcuXNnzpw5c+aMISJoNBqNRqPRaDQajUaj0Wg0ZTHVdAE0Go1Go9FoNBqNRqPRaDRnH9popNFoNBqNRqPRaDQajUajcUMbjTQajUaj0Wg0Go1Go9FoNG5oo5FGo9FoNBqNRqPRaDQajcYNbTTSaDQajUaj0Wg0Go1Go9G4oY1GGo1Go9FoNBqNRqPRaDQaNyw1XYATER4eLpGRkTVdDI1Go9FoNBqNRqPRaDSa84b169eniEjtk6U7q41GkZGRrFu3rqaLodFoNBqNRqPRaDQajUZz3mAYxv7KpNPb0zQajUaj0Wg0Go1Go9FoNG5oo5FGo9FoNBqNRqPRaDQajcYNbTTSaDQajUaj0Wg0Go1Go9G4oY1GGo1Go9FoNBqNRqPRaDQaN7TRSKPRaDQajUaj0Wg0Go1G44Y2Gmk0Go1Go9FoNBqNRqPRaNzQRiONRqPRaDQajUaj0Wg0Go0b2mik0Wg0Go1Go9FoNBqNRqNxQxuNNBqNRqPRaDQajUaj0Wg0bmijkUaj0Wg0Go1Go9FoNBqNxg1tNNJoNBqNRqPRaDQajeYcJSM/gyJ7UU0XQ3Oeoo1GGo1Go9FoNBqNRqPRnKOEvBrCuNnjaroYmvMUS00XQKPRaDSnEYcNdn8O+cnQbCz4N6npEmk0Go1Go9FoqonswmwA0vLTargkmvMVbTTSaDSa8xV7Piy9CpKXg6MA4t+GkUfBZK3pkmk0Go1GozlbiIiAo0fdv69bF44cOfPl0VSJhNQEAPam7a3hkmjOV/T2NI3mbCAiAgzD/RURUdMl05zLxL0Eyf8qg5HJGwrTtcFIo9FoNBqNK54MRif6XnNWEZ8aD8C+9H01WxDNeYv2NNJozgb0YK2pbuz5sONtCGgKg5eBNQg2PFrTpdJoNBqNRqPRVCPbk7cDkFOUU8Ml0ZyvaE8jTc2iPWw0mtND4gIwLDBgIVhrKQ+jzi/VdKk0Gk0leGflO/y247eaLoZGo/lfoW7dqn2vOatYdXhVyfvcotwaLEnN0/r91rSf0r6mi3HeoY1GmppFe9go9GDtQl5RHoO+HoRDHDVdlHOX1DVQu5/yMDIVi3qTb82W6VxFG7c1Z5iH/niIEdNH1HQxNBrN2YrDDsfXQ3osiJx6fkeOqHzK5iWi4xmdIyw/sLzk/a7ju2qwJDXPzuM7iUuOq+linHdoo5GmZtHGEoUerF1YfmA5f+/7u8TdVvMfSFkBEYPAHFD6nUmL/P+ENm5rziBF9qKaLsL5gTb2as5X0uNgXntYdDEs7AmLLgKxn7nr6751ViEi5BTlEO4bDkB8SnwNl6jmsDlsJe/1wnP1omcQmprFaSxx4jSc/I8aSzSKZQeWAfDPgX/UF/8DCsrEPydiTDaqL8PMHRDes1oMRdNjp7N47+JqKNQpIAJ5R6DgeM2WQ/O/hyf5cxplz+ajm0ve/69vMzgltLFXcz5SmA5/XQRFWdAhGqIeh4ytYJjd054u3Un3rbOKpOwkAJqHNgdgR8qOmixOjRJ3rNTD6H+5Hk4H2mik0WjOCAnHEwh+JRi74+SrYT/E/qD+blV/q6SgnKMGpu9jvwcgOSe5ejK054Nv9dzzmF/GMPCbgdWS138iZRXM6wC/RcKv9eDvy5Rr/pniLPKIjDsWR+8velcucfY+2PQErLod9k8/s3VWU9hy4fA8ODwXirKrJ09PcuY0To5WHFxR8n5d4jr15gwbrs4LzqJ+q9FUG3Evg3c4XB4HrR6Eto/DsFjPaU+Xced871unW97aciHnINgLqiW7DYkbALAXe5st2rOoWvI9F1l1qDS20+pDq2uwJOcf2mikOXc4R40BHkleDkuHw5woWDYSUs5/wfbN5m/ILMh0mRB5wu6wsyttFybDxLL9yxCRqiko5+gK2KGsQwD8uefP6slQBCjjufRLBHxvwPceViNPQFJWUsn7yhj8qp30OPhrMIS0h0tXqMDe9lwwVe0+TomzaPvomyvfZOWhlexM3XnihAmfwty2cOxfKMqADY9A4XnupbXnG9XO19wNa+5VBkZbNXjqeJIzp3Fy9MfuP0ren0xeak6A9mTWnI8cmA6dXgKLP5i9wOIL3qGe054u485ZNCaeU9hyYPV4+DkM5rSBn8OVx9gp4lxgdRqPVh5aecp5nqss3lfqFb9k/5KaK8h5iDYana+IQwmi82k/5zlqDHBj+9uwbBQEtYXOL6sj0QMia7pUp52vN30NwLdbvj1huq3HtgLQKqwVAPvS97kr/1CxgnIOroCVDVro9LI6ZUxeyo3dSb6zn1RNJsxLmFfyfs3hNdVQsCqy/kFoehNc+DmEdoW6F8OABZ7Tnk+G5QqYsW2G+hs3o+JE6bGw8VHoP0vV1YVfwhU7wKd25S90rtXlkUWwfgL0/AKuSoCrdkLv78DiVw15ezA+nMbJ0dyEuSXvF+5eWCNl0JxniAOOLoWtL8K21yBtS02XSFNZ8pNh16cQ+zwkfKbG8nqXgslSmsZcwSEXFRl34NyR7TXB6ZC34oDFQ1TogEtWwKhj0P83sAaeWr7AlmOqPzuK9bsiRxEOx3k0/6sCZXXW+Qnza7Ak5x/aaHS6OdOKd34yrBgLvzaGP/rArMauE8dzmXPQGOBGzn7YOhkGL4YOz0LD4dDxefA5h+7hP5CRn8HBzIMAfLbhM+U9VAG/bv8VgCCvIAB+i6/isdNVMTCdJTgHNi+zF3MS5lQ9eJ8nObMjBY6vq/AnInLC5+BkWuy0kvdVfhanSlEmJP+r+oilTEBvi/+ZLcfppApu8Cm5KWQXqi1Xryx/peI8d34IkTdCeB+wBoBXsPpbjRw5AvHxkF1NO8BOmc3PQMfJUP9yMHurV8SlNV2qKuMM/m81WQFYsm/J/6zyf15zmra/iMDatfDMM3DHHfDmm7B/xxGY2wG2vQomKziKYPU4KEyrhhvRAKdvO9POD2Fue8jarTyKji0G79pgWE7+2xNxhrfcaoAjf0H+Mbh4LoR2UXpMnYuqJetDmcpTPcArAKPYw3x32u6qZXIebIE+lHmIrMJSz63k3GSOZR+rwRKdX2ij0fmELRfmd4HgtjB8F1z6L1y1C7xCarpk1cP54Gq+eyo0vAr8GpaugFfHSvhZzm87lLGhS0QXANYnra8w7YfrPgRg45GNALyz6p3TXLqa562VbwEQ7B0MwPxd86tmcPak7CWgVpadrs9lDJM2hw3TcyZqv35iz5PcolwW71uMt9kbgE/WfVL1mzsVcvaDXxNXg9GJOBdd5qugvM/cNhOAtuFtyS7MZl/aPs95Jv2hvLNOxVBUgfH1lylHiIqCRx+FKVPgmmsgNfW/X6ZasOcrA2nTW1zlqaWC1fezmG82fwOolWInJQcCaM4fTsOkvagIrr5aGYwuvhgefBCaNIH6e6+DhiOg3wxo+yhEPQGDl4JXrVO6nuY0k7Iatr8FQzdCh5jiZ/ekkndlg17/l63nZ3jLrQbY9x00vlYZbp1U0zZ7S7ER8fOrPqddnXYAHMk+i/We04QnT/3pcdNroCTnJ9ViNDIMY4hhGPGGYewyDOMJD/9vGIbxXvH/bzEMo2t1XPec4ExOYnZ/DnX6Q6sHwOwD1iD1txoQgY0b4YMP4KWX4J13YNEisNlO/ltNGbJ3q21pTnfUkw32Z9jyv2IF3H473HwzjB0LY8bAd99BYeGp5fvYoscAiEtWpxpMmD/BYzoRITVXzUB9LKrtOldQzlcy8zPZl7EPUKsiAG+veLtqmXhS9vYAu34p/TyyVOZ8tv4zAFLzUks8Gzzx4RplwCsoDtaYXpBeGpj3TGDyAns2GGWGqv8Ym+mspQrK+5OLngRUUHmAR/54xHOeYgeTd+nncnWWmZ9JVkHV4yjMnQuvvALLlimD0UsvwYwZEBZW5ayqF3sBYLh6oJ2j7cRpLDeK/wEsP7i8JoukOR2chkn7xx+rwzJ//hkGDYKOHWHEpYewZm2BjjGqfxgmNVH9H1isOqN4WtSEU9tpEP8OtLhDbSt2GsCD24AtSy2ouFEFj0S93fXMU5AC/o1L52XVNEYV2gtJyUvBZJi4Luo6Lqh/AQDxqfEV/iazIBNjssHdc+4u/fI8aBPOe/Y2e+Nl9gKKT1A7D7yozgZO2WhkGIYZ+BAYCkQB1xuGEVUu2VCgZfFrPPDRqV5X44HMHeDXSE204D8aJOpC8grY9qba977tNTJWv0ufHhksXy7cdBM88QTcdRfk5kJ6RTvf8o/BsX8gcSEcXQyZO8+9+EoxMe71ExNzankGtlSBfZ3eH/8xzszpICYGPv0U3n1XGQffew+mToVRo8DL67/nm1eUx7Ec5R7qFOLrkjwbHnan7UYQwn3D+fbqbwnwCsAudo5mn79u08v2LwOUkaxBYAMAdqTuqNiz7u673dvl3Xe7p12UAl5FsPIW5YVYfJLUURvcO+/ekqTDfxheYdkW71UBBa0mK5bi+Anzds6rMH21E9ACbHmQvgXctuicYp85W2L2VHKykeZjkF6gBK7ToFph0PTwnnDwF1V3LjjYm7aX4FeDCXolqMRAW1lefhn+7/8gNBSCgsDfHwJPPRzDqWMNAmtwBdsxa162VgVn4Pmlty7l/aHvA8Vx3TQnZcuRLbyz8p2qb++tCU7DBO2XX+DKK1W/dGIhp3iSWuZaJ9INRdRplTs/hPj3IP592PkRHN/o7nmoOb0UZaoFRqdnyi8R8KOX8jTa8Xbp6ZAjz62J/f8stbqo7fZup3qemrzafVxtQ6vjXwfDMGgZ1hIojQ/qiVHTRwHwyfpP2Ja87ZSuf1JOx1yqApzxQX8d/SszrlVxH3el7TrRTzxis0FyMiQmKk9qLfoU1eFpdAGwS0T2iEgh8CNQfhYyHPhGFKuAEMMw6lXDtTVlqTdUCSQpKvcfVRBID6RBVgK0vh9a3AUtxvPV8ntp2jqIO+80CAlRK1m+vnD55RAeXu732ftgYS9IXQO1OkHEIAjvpQa5woxTvMEzTEyMu1J3qoKu2a2Q+Dtk71WnKJwsltEZtPy//TZMmqQmgcHBEBICPj7qWZ8KzqM/u9Xrxpo71hDmG0ahvZD4FPdVEKcBpXej3gxvM5xu9boB5/f2DOfEf1K/SeydsBcDg8NZh8nIr6C/VLZdeodBo1Fw+HdY0BWWXQXAneXsbwlpCfy87WePl9p0dJP6e/cmfhz1IwBLDyyt9L2dMiYzNL9NnYZly1TK1pUnOTXsLCe/KP8/TWrnqbjw9GvcjyW3LMHL7EVWYZZnF/RW98HuLyD3oDJQj1DeevGF0Oy9ZiXJGrzVgOO5lT9RLTISDhyA/PwqF//0YhjQYjxseFTdr70AhpeuxNscNubtnMehjGKvRU9K7GlUZJ0kpCacML5Ckb2I7SnK869TRCc6RXQCVFwjzYn5fP3ndPqkEw/98RAt3mtBSm5KlfPILMjk8T8e58uNX549hidxQMZ2SFwAh+bAod/V68jfkJfkkrR3bxXPKCenzJeBLcHiA0mL3E8SvNfh2v4tBrxrhYLj0PxOpa80uwWaj4OgNipNZajqJNFeoBYacxMh72j1nHh4NnCq8RWb3gL7ZyhdsTx7voY9X4G9EOzlFwc0p4PMTOWNP3++8rqdNw8WLoQtW9TW0JPS/HY49JuaYxVln9zYV8l+FJ8aj4FB/cD6ADQKaoSBUeK1Wp47Z9/Jor2LSj63m9KOnEIPbay6OB1zKQ+ICBuS1OlxbWu3pW14WwDWHV5X6bnUihVqoXzmTOUUYbOpZHnV1MVEhO3J28krOjf77ClGUgOgAXCwzOdDwIWVSNMASKKKLP3kHVpf0Apv31LXWnPuLrL2rSY1+CZy8gOx2w38fO38vfFtene7gLYNlOIVl76b9dvjWXFsCZa6YQR4+ZFdlEu4TwiJO/cx07GqJE8TBp/WH8m4pikweIlrIba9RlFqHEd8bycxOQAvq1Bgi2dT/BxGDroFq8UHu8PO2tRt2NYdp2XLCOq2aI1z93h67K8U7Z5OXsTNJGfWJb/AhJ+vg6jguXhb8smvNYQt2wMwm4XIiGTi/lpAh8uucNkHu3BJKAcPOOg2MIogRyxgkGIbRtDWb7iAq7B0exWGbVYrEwB7vkb8mhC73R+73aBdqwxWPHINHYZcTljHYQCkbV+M7/rr8Apsg0nsas903EtcZv+Vj1av4cCBAOrVM7DZlOxatGgG9oLNXNJ1MADZRXkcSfyFHgg0uEKtcosdZjVh+55QCmtdROO+Y1yqctWs+bTr043GxZ/TdizBlLeHvIPLCW43kgNHwknLsNK+TQ4b5i6kRbco6pdNm3+QvP1/YWtwPcfSwsgvMBESZKON7/eY/OuT79+TLdv8CQ6ykVu4jbVxfzJqwK2YzF44xMGalDiK1qbQOqoxdSKbl5QrOSmDA+uW0WnIUGqXud4vc2uRnWOiU/8O+BXtwG7yJz3Ll5wtX9D/6guxltmqPOfPWhw/lkevvt5YyAXDICM3hIQ1L3G7YxCm5tdj6voWrLiRtbu7EbLwG8KbNC5pJ0kb/2Tj7Fl0H3EVdcqUYcVKSD6cSte+TbBalRLncBh4J35FUJshmKwhJOz1pWG9AjbFL6bQlsTA7leDYSKzKIetabtg6S46XzYYv6DgkvLeM9qf52I688EUCyIGIuDtrVzeW7dyEOa9C6sjFbvhx+bde8krWM7oQcOwWgzybAVsPL6DVbN607JZEFGt8zA5chDDymubVLyeoWFdiUg9ykW1O/HLgb+Z8OS/jIoy07ZTGH627dgNf77YrFYGOljrkLZjCV1867MU2PH9TBL6ZdGyTNtJ3zKdgj2z8Wt9HYdT65GaZqFF0zx2r/yH+s3CiCyTdt2fP7B03a+MGXYbft6+OMTB2tRtRBXuxqvQh/AOQ9i0NQCr1UFwyD5+//tHrr3sdrytasl2Q+oOtq3bTpPwAPp2HYxhGKTkpxN3ZC/W1bvocfVwrGXcsf5eXouEnQ56DG5PIAkY2MmgPZ98ajB6VC6RYTsxOXJwGL58v04ZY6LsPmQnLKdNUCTbM/fy+0sPMPCqa13ae/yGvZgLk2jaoyfhZb5f9fNvdBjcn4Zlvtu4NZANq8ZyX7eleGfuxpQZT5IN5uYABnzdZzLb0vfwatzXfP3XA/TeOQ9T5GiSUkPJLzCR67ubpOwkfExW6qYcgQI14B5LXErirFsIaXcth5Jrk5pmJapVDsHpP2HzbsyO4xeTmW3GahEahe4lwvYbaUE3sjcpnPwCE0EBdtoGTMfsE0Kmz0XExfvj4+2gVnARM2d507NfKD6mVEySj90UwNwl0dzdvD+1Z0dhbngZFGVTaLOy53gn8pfEYneoYcww4NDGpbRuJdRu3gbnAcQHVs0nbtFcug0fjrVMB419YRIhQTYaduhEaNRAAHat/o1f5n/FtRtmE+KnArFvPr6TzNh0GgWZaNypK86dWClxS3jpzVr0GRRBvQg7Pra9FJrr4W0/hGQl0KZbC7Yn+FNkM9Gq5XEu++F21knpMGjCxHthj9DdP5jmF/RyfZ4P3kj7i/vQqI9aDUzbvpj35jwAOVu5MqwLzTKz6B3egSVH17Nlzijyw8dyXLqRm2fGYhEyMoOpnXoJneZdiLmJiqGW54D2+9Szd1JgL+CqDzrwauDNmJtcjcU7EDAwDAeH18yhU896NCnTjybdMouBN1yMv18Q4+4w4eOjwrAsXgwWC9SpbSfAFovNCCQ13Y+ihO/ofWUPrGU0jZ8W/kbjesH07HgxAEfyUtlx8AB+cfvoesUVWMo8o18WzadOqBd9ugx07XNrivuctUyfWzuC3sav1J7TDUuza8EwcazATPd9Vg4+X0YwAx/Xepwe371Kky7dCWs3qKSO2TkFY+N34B/Jjl1+NGmYT/LuHVhsR6nX/sIS2Zy2Ywmy+zOoOwiHX2t27vGlbu1Cdh9aTlrWLi698BowzOTZCliXEscLS99nLftcyvBK2IP0s4bQqm9/zGbl8bHpeDw2h41giz/2vRuoX5CJCQPLQQdLP3iKqIsHuYxHxqGfKbQ2IbRFD7Zs86d2WBGNau2BpIUket3EoeQwimwGfr4OVm39gs5tmtEmsgcAh3KPkZaVQOu07fi3uRaLby127vGlQ9scVs5ZRf3IWgQ3bF1S3uPHstmz6i86D70cS5kHumnxBurU86Ze6yiMYqOCYcumaNc3eLccg29wGLHb/enULpuf5v9BWAj0iLoEDIPUggw2Hz3Esmm9GHRFY2qFWfGzxZNnaUlS3DoahCbSumsTTMVtNjs/jx9++4yRQ28kLEj1xK1pu/hgxY/8lP1XSZn2pu+l9uu1mWXcTY+hw1xkqDk7jpzErdTqMJzdB0LJzTPTunUqPb69mZ1SatAbN3scT3g/QdDRoVx4WQdMZlOxs44wf+Z++lyYScvW/hgmQQSs+bspOr6Dhl36sPdgENk5Ztq0yGXrnwto0S0K39D6JXkf3JVM+r5NtL14oMvzXDN3Kc07RhLWqLTXOba9TVjLrtAh2qX9LJ82jUZNUgkML41Ld/cV6Qy8tgdPWyOY+ISZ4GA4cMAgMf97+v1zJeYOEzE1vBwGLCB1xkAC7Tl4UWbvuQUcoWCE98JwFCgdcOuLZK57n42HetJxzNMuZfh9yV8E+BdyUfchmIqfZ9zRPViMZHpsWkCdzkPUvW1fjCVzPdm/P4it/jUcTfHH4YAmAWuomzkFLo8Fc52SfDcv+gdr7jbqtSptf3aHnS9//oihA4bTMLwRANvS9xBcuJ/w9KPU6jiCxGMhpGda6BiVzQPfRHMotIgg7xBsYsdkGHQuuI68re0ZMMiLAN88DLFjN/xIWLGUCwa2ILROqdvk2tht7E5cw6iBN2G1Wihy2FibEkeX3Fgsfm3xqX8BcfH+BPrbCTDtJ2XnOpr3HuwiI9bOW0bTdo1c9JYdf/5KUuwK2l9ymUs/Mo4u4OCRcPJDBlBks2AyCdlZzWmUYtDcMQxL58kweBnMac3Pa0bS6YJaNN3wJOYtk8BhIy0niNij/emwY4nLM9qybAuhodCgXYeSMfHQ2oVsmfc73a921S23rtxOoG8ejTp1KRnnDmycz/jZj7LF5ygCFImNFoGNuI9RtAv2p0nXbiVp03YsQRI+wmhwOfg3I363H43q57M5/h9yCw4yqMdIMExkF+Wx8fgOti1bztCLr6Bx7UgAtmfsZWvsLqyFKVx50XWYzUqGrk/dRtw/q7i09yU0rd8CgF1ZB9m8dSeSnciIAddjsVgotBexLnUbW/9ZQ//uvWjTpD0Au7MOEbt9N3mpe7hm8M1YrRZsDjtrU+PolBuL1aclQZGlcwU/DpMUt4aWfUuf587ly+k4qI/bgknS7kPsXfoj2V7dXb6fOTuEvHwLPXoH4eVIQrBwJKsJx9a/xFj7IMyRIzFCOwOwZnd36iz5hpB6jXAO0JnpuWyzJtNty0Jqd7ystB+lryR77iPY6l3NkWNqRXfF8XkIQkOTH2k7lhCSnoJhGNRN30jSnAmEdbqSnbuDKbIZ+NTbxucbPwegf52u7Mo6SGJeMtGv38n1jTrSpPsFLrqI7PoYo94Q8iyt2HvAh7BaNvYkLiU7bx+XXDAKDBO5tnw2pu4g7p/lXNJnKE3rNSt5ninxGdQuyKBl774u+X7waS0atQimRZsQ/GzbKTKFknioCL+sJXQd2B5LGSfIb2Z9Q7dOnWjXtFPJs0/Y603c4hb0HtKScP9ErI7j7Lb5kV2YjcWwEJi0B4cIFsNM4HFf/njrYbpcOsxF3pqOziO/yJ+CWpeSdMwLq0X48MPadOnWmDFjSue6IrD2l5lE1CkiJKLU32X7dgcPxnTn59mBLh7Xzz6UQL3mDbnmOu+SMfFg8h5u+qMnR8yl3t0Ww8xfPW4msiCUtKBrycn1QgT8vQs4vmkanYddgWEpDTGzbU0CvuY0mnTpjslU6vOzasZMOg8bgo9/aQzLHRv2YC06SmT3CzGbS9NmHDtK4mGh9/Wuc/FK4zxB57++gGuBz8t8vhl4v1yauUDfMp//ArpVkN94YB2wrnHjxuLGyJJNGiWvJ9u/IPffUyRHj9ilqNAhdptDjqcVCjG4vfo90cTj955eV905VOwL+okU5YrYC0U2TRKZhsQOaic9rWtk3NgC+eT9PHnntTzpcv8lQgwSfbEq0/sXqDxkGiKFmarsdeuKhPnLnrcj5dJWm+T9d4skId4mhw/aJS7WJvYRyLNES7hvllzcI0v6dsmSi5ovEZkZ5vJ7mYZEWx4ViULkPUQ+V699zzaWaJ4V6YLI/yHyIiJTkeThyGHqSV+WiR/Z4k+WXOi9QpWtXL4v171BZLAh8kEfkd9vF5lzh8h3XpI0rK68zES5NWqV3DVwp9zRfYPUe8ZXiEFWN1D3fPMIdc9T290s8mhTkV9vEfnzIZHvfWXZs31EtkS7Xc+lDHXrimyOFpmG7Bo9QnqwWvzIliDSJYBMj2mPTKkjl0cul4fuL5RlfxfKutVF8tO0QpGRyByGSm2OSiDp4kuONHuwuRjRyHcdVHm/b48Y0eXKACJh/rIy5gKReV3d651oleYqRL5C5Etk06AOIrOauKXdH91AZO+PIgUZIg67iMMmW9/uJy9ao0UiEbkPkRdUPvvfry9ybLlLHsc+Cvf4jGQaIll7S/tEcZ3ZrjbJw7wuvuRIEGniQ66ERlvFiEbiaqt7vmEkQjQe+5E8gKwc+YCM85oqN3faKGN7bJMxoQvkh27XiXwRIbIhRmT3jyLbPpJO0bWEGOSnKPXbcVciwc8hCU+1FYl7UyRzj0hBukjeMRn7TKR0f9JXdtVSaf9pjHS8G3kt6BGRJxCZ3VVk2TiRv8fIHdCr/GMAACAASURBVJOaSdcnvWVbuEq7IQLpfJfnZyTTkAUDb5TG5oNyxeBcuX1MtvTolK/S2vJc0t4SEyHEII9eovL9onNx/xyJ/EMfacw+CSBT/MmSpmMuFSMaebGfSru8kaozczRieQbJtqrve45Dmj3aSOR7i3s78blfxILI/aqNyJdI2oNBsv2xDiLrJoqkbBTJ3CuSGisj7vOWAWORLDVeyJedVf14evZrnususnNKpfrR2H5TZcnF0SJBiExAJBpJ7IF0eRx5cqC6VqEJGXYD8tOz3nJ/1HTpd4GSZ198lC+33r1Huj2OTBxc2kZGX4N8HoPsGHWldGG9+JuyJcIvXXzIkQeavSv3jc+XDetsknTYLgf322XRJ1/K5c2Wy8RHCmXlv0WyZaNN5s4ulPQrg2QUM6RD6wIZf3OOjL02Rzo32iZH324nEvuayPE4VT8zQlWfMyMyGJHJiDyNfHXbWBkyxH14KPzaIpKZ4FI/8W+0EPkp2K3OEqfUEUle5fL9k68FCNHInVeo+91UV8mILa+3EDk0xyVt3lfe8kath0SeQeSnxiJzBoj83FocnyMv9/5aGgRlyLVX5MiNV2dLZMN0IUblVfdRJPgJ1f5+e/JCke1vVep5Xvdsfen5VKAcDFJlW9AcaXNzhPRtuEFm/mSTlGS75Oc5JDvbIeNut8vv3Z4VaYfIY4g8j+R9jvg8i9wyHHGA5JuRITci3S74WB57zL0uK+pzmWPayfvcJwP5U7oY62U0P6hnZEXkSUS+UDJt1ZgeInM7utzb4a9VP/J7SpVBQDrdjfR6qL3ILw1c0h79GrFEI16TStMOGou0fLSJyA/e7n3O+0HVTvqrti4xSNybgUIMUmsiMvQGJUuIQda+0lZk/0z3eh+JzGCkBJEuQcXjxtLH+4okfOqWNusqf7mG6RJozZWe7TKkXkiOhD7jI0Y0sjFClffxwUp2EKNkR5fxSOv71OePHu4vsv4Rl3z3TUW6Po5MGlDa58aMQt685yKRlbd6LG8OvtKLf8WfTPEhV17v/H8ypNcx+WOBTZKP2SU9zS5z1q8VUzTS6KHSfJs+iFz/OiI3NRQHyGD+EAO7vM+9HvWWdS90Efm9tVsZ7N8aIll73Mt2ra8IyCh+EjNFMs77DTFHI9ZnkAJz8fO8GWFCY9V+GiPyCSKfIfIpsv2tpiKJC1zyfe0dqxCN3HS1+n1CKGJ6Fhn0gJfUfwhZH4Gk+RTXewwVjp8HbrlZ+vCP+JEtgWRIhHmPEIM0eBj5v8tKdZnBPT+RSZPK9YuC46X5Oikegz/p+6I0DEiVm67JlXtvzSkdj8r15cVPXyTy7/Un7vfFfW7mhKtlZ/QokfmPiaz7SOSPqypMK9OQ/NGN5Qtuk0uZL51ZL9c5+2coItcoWSDRyKbJnvWWN2o9IDLcS+SLS0Xm3iky5w5JeKO1yPQAl7S27xDfZ1T9JwWUjol1nvCstywf2EIG+Chdbe6sQpn/e6G8NmmXbH2sv8iqKSLxs0QWjxGZhqx/oYvIri9c8ljwqXomne9S19oWrj7/+gEi914iLzFRfMgVf7KkH0s86vRvThgk9tUTRPJTRexFSi+bWcfjM4p6NlCIRn5rra73Wm/VlwtGWOUupkioX6707pgp7Zpmy8TLXhJZenWlnuc/z/YW+bO/S9qMzwLFZBJJSXFtVvPmiXwQ/qxIN0QeKdbpvyqjh/YolnVPIVt7txW5zs9Nr0v9NETk+EZXOfOuZ71l59tNRJL+dPl+/0cBHuty1ctRIvume5RJH3KP+JNVoofWedZbiFb6nKD6rzOfruPVd/uD1eewZ73FiEbW1VPfPzVQ1bsRjVxwh/quwKzGhTrP+IoRjSxp4vqMiEEiHlHjRro3Yn4WaTgpSIxo5Nc2Ku17F5TqwuXnCjGDnhH5e4hre//WJB90ulfeHr1cvn3tsPzyebL88lmyfPrgZyI31ner948jx4u8ESCy+iGRPT+JJEyTv95+Ud4JiRZpisiDxfr/l0jBF1aRjB0u8qQivWX9oFZysfdyue+uAvn5R/Uaft+n0mFi6b2l+SD9b0WOXIUkEyaDWVgy9+tY7xvpOBF5+0KV9og/0vc2ZEVMJ5E937hdb9vgNtKZ9XLZgAKZMD5Hrh+ZJyHPeospGtlaPK/4v8tK6z1ygqr3+DD1+fPH+opsesot38nmSSK3Fs+jvm8k8o2/LH7sIpHVd7ukTfpa5WOdhKT6ILtqFY+ngx6RhQPGi7yOyLRQkRlRcuwLk1z4GHLfsNLncPflyGN39BFZNMCtDBsHdpJevuvlwXsKZNrUfPnqk3yJvm2WfNH7YYkZsFjenLBP3pl4WF67Z7dq27mJLnmsntxdWrcWN3qG/iszZrh+9/fyP4QYxP8p1eYbPqTqbHj96fL6K0WSeNguBQUOKShwSPymYx5l6In0lvLtb+3j3UQeuMJ9nneTB7uKiADrpDI2n8okOmEG0AtYWObzk8CT5dJ8Alxf5nM8UO9keXfr1s3jzZVnxAiRt4r17pwckaws9f5QxiHp/HHnEuF0+bTLJa8or1J5VkRGhkidOiKxsaXXERFZtmutEIMEvBQgr/zzitR5vY4Qg/yx6w+3PK69VuT110Xsdtfvo6NFevUSOXpUJD1dXSshofg/yj/4F+8R+dFPZM39qiHnHBb50Vfk57pu17PZRKKiRPz9RR54QOThh0WCg0+pGkRE5NZfbxVikFf/fVVEROq/WV8p5IfXnviHznuogPR0kYgIkZEjRQ4cEMnLE5k2zXPaAQNEvv1WJDe39Du7XWT9ehFfX5GrrhJZtkzk++9FAm4YJ8Qgk5dMFhGR55c+L8Qgt/56q2u5TlA2EVHC/UffUqVgRi33e7Pli8wIFUnbor4vyhHZ+JRK/6P/ifM/GbYC9bwzdolk7BTJiBfJTJBHHrFLZKTITz+JpKaKLF4s4nffRUIM8u3mb0VEpNm7zYQYZPHexZW7VuoGkdmtlAHIVtx3HHb59vMgIQZp8W4LeWHpC2KabJJLXkMc8zoXp3Gov8XKtNs9O+wq3/gPRIqy1aswUylwHtqwJ9avF2nYUGTrVtVXMjJEsrM9p91yZIsQg/i+4Ctvr3xbmrytjMcfLlgg/v4iQ4eKrFol8tdfIg3GvCDEIDf/crOIiHy/5XsxYgyxPmcVI8Yoad+BLwWKEWNIfEq8ukj5trP8ZpEffYpffqoeVo1TyqqIus+yimUNcuedIhMnqvpzPrqK6jIlRSQsTOT++1WdFxWJfPyxeBw8L71U5MsvVR8uS9++Ik88oeR1ZqbKp/CPoSI7PxJx2FSiE9SP3a7k5K5dIjt2iGzfrv4WFVVwg55kaHS0W7Jft/8qxCBdPu4iIiLfbv5WiEH6f9nfPU9bgcivDUViX1QLCwVpIkU58vYtE6V3z1xJTVWyLD294ro8Vf79t7Te8/LUdap6rZwcNZ6tWSOycqXIihXqb2FhFQuz5EqRH3xKn9mPfqX/V1znBbYCMU82i3myWdLz0kVEJPTVULE8Z5GkR+5yeT4pvoh3tFmMGEMKbaownT/uLObJZpm2ZZpLvtXFv/+qcaNNG5HHHlPt1M/Pc9r+/UWuuaZ0rM7LE4l4rr2YJpvktx2/iYjIiB9GCDHIOyvf8ZyJczJZ9lW3cvLPydChIj4+pT83mdSY6OzHIiKbk7aI9/PeEvBSQMl3wS8Hi9fzXrI+cb2sWKH0A1B/XfBUxxXVe7nvN29W9Qci3j52MU82i9fzXpKUlSQiIm3ebyPmyWZZsPU7kelBpW2nfJ8vznf2jtlixBjSYUoHEZGSz+0/bF/p+iooEGnRQr2mTxf5+2+RwYMr/XNFYZZIzkGRzN3KSJ25W3746ph06+aQ5GTVHrKyivuip2dc0XP2JKcqkFVVyrc6KfOMe37eU4hBZsbNlEJboZgnm4UY5Gj2UZefOBwiDRqIrF7tKp/K6m0nu15+Ub74v+gvxCAT5k+Q3p/3FmKQhxc8LF9+WdrOQMTbu4K8ll0jsu119d6WJ7LxSVf9pMy9jf99vBCDxCyOERGR4T8MF2KQbpftkEsuEUlLU30/J0dk/vzKVl4x5Z5zAVa5pdMG+ewzJXs3bxbZtEnJ4szMKuZdw/zwg3oWN92kjF5PPSVivUnJwSlr1IKXU/8yxZiEGGRz0mZ5bulzQgwS/HKwmCabZGacmhyP+FH91ogxJPTVUBERSUhNEPNks5hiTGKabCrRb8fPVs8s4EVl6Hpx2Yty75x7lRHpDbVw+NKyl0REZNxvaj5w96efip+fyLBhShZ89ZWIJ3+FKlGQLvJTLZHsfUr3d1IF/dYTRUVqbrR+vWs/KjsXLYvDIdKzp4jVquZT118v4uVV+eulp4vUri2yYIFqh9nZSrY1e6u1mCabZO7OuSIiMuS7IUIMEvJyiBCDNHu3mYS+GirEIBP/nOg58xW3iizsXVpHtlxlmHbWT5m+OOy7YW5Gy+fn3qGMagmfqb5cmCkys3al6zc9XemxO3dWri5dqCa9w25XfWXnTvXZOY+p1LWqWfeprNGoOranrQVaGobRFDgMjAFuKJdmNnC/YRg/orauZYhIlbemVcSvv8Lu3SoIYFGRipdqMsHVVzdg410bsTvsAJir4WjD2FioUweaN3eN9dKveXcCvQLJKsziib/UAXJWk5XBzQa75TFxItx/P3TuDL16qSDDqanwxhtqb2ydUi9dFdAwJsZ9/+fS4eA7Frq8UnpijD3P497m779XAb02boQGDZS73SMVHLpTFUa3H83UzVN5Y8UbLD+wnMSsRPwt/iVxaP4rX34JrVvDN9+UBnQcNcpz2tq14dgxsNtLn3tBgarfa69VJ/z4+6t9qfsiOvLUMtiZqmKiJKSqE4jG/54IV5fbq28YEB3ted/tpqeKT+spxu4hwIfZG0alqODkh34Dhw3CukP/2VB/aBVrpHzeXuBX3+Wr48fhww9VPIPWrcFqhf794fGiK4hZsZR1iesY3W40e9L2YGBwYYPyO0grIH0LBLZWburOEx9in+M670xuRgWYm7R4EgA7zA0wWtwFa+6BkA7gGwFBraHdUxA10TXfY8tUu212W+kpLr9EQEHF8T7K89xz6tjvli1PHqi7Q90OhPiEkJ6fzkMLHwLAZJj467NLGDRI9RFnW3sxuAW3zoH96SomSmJWIoJQL7AeBzIOsC15G5EhkWQVZuFv9adlaEv3C2bthoMzoP6V0PtrwATTfVRcitQ1ENajNK3Z3/33Z5i5c+H3310DqPpXUKxPP1Vy65VXStOMHQvLl8PTT6vT92rXVn0uJETJtDFjIDtbbWHavBn27VOnL3qXOeCLdg/C1heg7sUQ0LzMf7iH3jOZlJwsKytPiCcZ6gFnv3AGU9xydAuARznOgRkQ2AraTFAn2/zSFPKP8tzMVFau9yU01P0n1U2fPmrv/XvvqThDFovSJGw2mDBBxSQ7GX5+0L79KRYkPQ6OLIKQdtBzKuQfgb8vVX26TNwGL7MXIT4hpOWnkZiVSKB3IBn5GQiC34uvwRsfl6T1t+VjeykAi2Eh35aP1Wwl36Zkrb/19PSZO++Eiy5SderlpU6NnDzZPd26dbB/PyxY4KoHXNC8FbMTtnI48zAABzIPANA8tLl7JtVAbCwsWaLG9VdeUZ+fe06NA9u2qdOzfH1hR2ItBCiwlY5bzrqs5VOLj2eVxqkyVTXSZUSE+1HxhgF16zJ93JGSWB8mw0SQdxCZBZmk5qYSERBBWn4aAB2PLwRHgRonmo+HeR3d2g5Al3pdEIT9GUo270zdiSD0atSr0sWdOlX9XbdOyS+LBS64oIr3bA1QrzJMflUdIOEW57EqVFJOnS1c3+56Vh1axdN/P83UTVOxi50WIS2o4+8qmB0OSEmBRo1c+0tV4iV6W7wZ2HQgv+/8nXdXv1vy/Z1d7qb/zUrW/fabusbtt1eQSb8ZkHsYDs9XeltoN+j3iwqnUI6BkQP5dP2nrD68GigeCzIakrCqJQf2q7iPTi66qPL3Abg9Zy9gahWzOBtxOOC++5Qe8OCDEBCg6sYxeySvxM9ietx0GgY1ZH/GfiyGhfZ127PpyCa6ftq1JIZYxzod+efgPxzOKpahGUqGGobB8bzjFNgK2JO2B7vYCfUN5Xje8ZLDA5yn0HaO6My/B//l6b9Lt1Ne0vQSvo39ls1HNwOlQaKXfHQNI0eqMAz+/krmDxt2ihWRf0yFE/GtV3ow0ZYYpd+egr6Xm6v6Udu2rn0nIMBz+vnzIS4O/vgDuhfvnnvC7Xzzivn+exgwQOkZZa8RVbcVezLjScxKBNQJxwYGo9uP5pP1n7AnbU9J2kd7P+qecV6S0p9G7FexN53YsmF8NowqMx8zDL5oEk6920q/CvQK5MlwLwgbA5HXq7mJ2QcKkit9b3v2qMM8Gjd21UMrqssTjXP/Nc6syaTm5kuWwN9/l26FA7jlFg/622koQ1U5ZaORiNgMw7gfWAiYgS9FJM4wjLuL//9jYB4wDNgF5AK3VZTff6V5c/XyRHUYi5x06QJpaUrh6NxZdVy7Xb0+GPYBt8y6hSbBTdifsZ+XB71csp+xLN26qWBbW7aoTp2XpwKsBQWpAc+l7J6Kbi+EpD/gyvhSg5EzdpEHvvtOHa7UoIGaIEDl4xmeiL6N+wLqmPDZO2cD0Ci4kcd7BtwbfAWNfepUFZC57KTVZXJZLm1MjDoivk8fNZDHxsL69UqBcOZhsUD7CBVJdm/aXoASwZb2xAT4YmHlbtpRBEkLAAf4NVZGuoJkjwouhgHBbdXrNPP77+r+mzShJK6SyQQ9G6lJ8AdrPmDqpqmAOmHB11pJba3xNRD3Mhz8FZpcq9pe1ON4NRnNY2u+4vUVr1M/oD6J2Yl8M/I7iLy4kiUuIx3dqNysJTVVKeiVPdntw6EfcuOvN5b0z0d7PsEHr5pYv961rbWtqwSJU2nZm67aS5eILhzIOMAn6z5h6X4VDLpNeBvP7X3Pl6p99JoK5jJ1nXdYTY4SPoK2j4FhgZZ3u//+DDNunDI8TJmiHovZrAzwnk7G+v57ddR62Trz9VVG3pwc2LQJdu5U7fCZZ5Sx+qablGzz8oJdu9T/uT3++kOgdl848qdS6ts8quqn1b2cKeoF1iuZ2L78z8vM2jELUIHZ3ciKh+AoyrfXrPxAatVyT366aN++Gow+p0rCFKX8DVqsTvuxtwKkzOmQpTQJbkJqXiqJWYmE+YVhFzsBXgEEeQe5pPM2e+MQBxaTMhoFegeWGD38varfaJSYqIyZS5eWtm2r1fMcfsUKZZS32Vy/71q/I7MTfuFQ5iEAjmSpMaF5rQqUk1NU9D76SPXRVavUiXZDhyqD7f33u6YbXFiLSa/asTvs2Bw2zIaZQnshZpOZWr61+PlnpcOAmphUF999VxogNi8PGvqFk56fzvE8FXw9qzALETt1k2apoMvtn1E6jT1HvcrRILABAV4BZBZkklmQSeyxWAB6Nay80ei77+CBB5QuZCnWgCsykFcFmw2XmIYlnC5l/iw4CrtP4z6ACsTrPOq6VXgrt3Rmsxo3rroKXn8dunZV6tGOHdCjh1vyCvlq+FeEvx6OgYEgXNnqSg5ubkl+PixbpibT3t5qklwhfg3U6yQ4Zf6SfUu4bsZ1Sg84Oozu3dzH+1M9LOR8YcMG1a8efrh0wuvnBzf17ccr8eqgk3WJ6oTLcL9wHu75MGNnjUWK/5kME8NaDuOfg/+UGIadMrSuf12SspPYn7G/RHdvGdqS1YdXlxjnnUaMh3s9zL8H/y0pl7/Vn3t63MO3sd+q49cp1v/zA9m9NYSlC0plgJeXmoudEkEtlSFy7QNqYd/kA+2eVEHlA5r+92yD1NzoxhuVgTqs2N6Smgr167un/+YbtXjevXupMaRFi8pfz2TycGgt0KFOR+Yk/F4yzh3LOYYgPNb7MTYe2ciaw2sA+OKqLwj382BFP7oU6vRX+p2TE8xhI/LNLLt1Gf2n9gdg3fh1mFcOhx5TKjUH9kTHjmrR8dNP4Y47lLOBYShZVaHh6DTg51eBkTImxnXFyjCqZ6A6RarD0wgRmYcyDJX97uMy7wW4rzquVdP4+akV9fvvV8+wSxfV2BYtgrVrb+b2324vEXYTek6oMB/DgE6d1AvUKvzjjyurY9nO7/SecaEwTX3pV8bC5EE5BzUxW75cnYzlVxo7vFIr0CcjwCuA9nXas/XYVmr71SY5N5mJfSae/IcnITlZDf6VwdcXXn1Vvc/PV4pp8+bw77+u9wvQrthodChLCTqnwGsV5q7kVMjx9crrps7FMGABiA1+Cqiw/s8Ue/cqDyNLuR59UQulkdnFTkaBOo2raUgVBi2LPwzdqE7pWHa1Wj0RB/g3Iab/y7y+4nUSsxNpX7s9F1faYATU6aeMJ7s+VaceiUOdiuWwgXflXDTuvBO++AJGjFDtwGRSbaCitn19h+u54/c7SvrnLU2eYWqAu7G5RZgK4pecq1YtnEZG58RvxaEVrDi0AsBtolvCkb+h5b0uwetLqDtAvc4iYmKUEtKzJ/Ttq8amuDh1Okh58vJKlZXy+Psr42VZ2rdXRl0nItCunVJobrih1PBus4GfXwA0urra7uu/4GP2IZNMopdEU+RQM96o2lHuCUM6wfY3wHmUdbHR+MqfbEyZAo89VjrG5+ScFeP96ePo39D6/0pXVc0VW3LbhLdhw5ENJUYjgIaBDd3SGYaBV/GBBXk25UFbYjQ6DZ5Gixcr5br8AoUnpTk4WCnq5YkMUhr57jR1BLLzBK+mtf77ROFELFigVvb9/ZX88/dXBuDy+Fn9EFGTsuzCbCwmC4ZhYHfYyc8I4mCZY0qcxqNKU4Hx4sgROBrp+l29wHokHE8gNS8Vu8NOblEuzaxgiAM6Plc6AagAwzAI9AokuzCb8NfCsTmU1a5FaOVnQhs3wtdfV2DgOQUmTlQTujlz1DhssSivhTM5ATnTdKvfrcTDPsArgOzCbJ7s96THtCNHwqWXqsW8lStVO2vQQC2iVta7LcwvjKf7Pc2L/7wIwPtD3+fzN1W/bd68tO9WdiHpRDQKVvp1ni2PGdvUAR0+IRnsXWm45W+3V7DA+z/G8uVq/C8ocNXDWkdEYjFZsDlsJTs/Lml2CTd1vIm7595NbpGyVD8/4PkSo+Ou1F2ICMdylfd581rNScpO4uGFD3MwQwmsdrXbsfrwaval7wOU8QKga72uPNTzId5e9TagFvSdJ1FuPrqZ2q/VJiUvBdORgbRr5z42V8f8iJ5fwLF/Yf2jYEsHTODXELq8Dqb/PvWOjlYL4y+/rNbgnWvvb77pLtOWLFFes2VlUPl50Ym44Qa18PfXXzBoUOl+yhCH8q7fnbYbESE5R+nKjYMb8/WIr2n7oZrA3dr5Vs8ZmyzgKPTsvTDFBDe4D0L9gOGth9MwqKGas1lD1GmLDrs6Zbc080rdm9msFog++gguu0zptA6HcuCYP99DGzjTRvqz1Ou0WoxG/2s0aaI8O7Kz1dYob294/nml0Hw38juu//l6Xhr4EpYqCIaAADUJvuUW1cmd5OcrgeCCxR/sRWolzlIsDXzqFhsuXDtMXp7KoyrW5aoQfVE01864luzCbABu6nRTxYkr2enq1IHt2yEqqmqu8j4+6mW3q/osvwrcJLgJoNxdB349sMR4EBkSWfmLHFsGUgS9p6ktaI6q+vKfHgICICFBreqWXfUyi0+JJ5BTuRvXxcOs4kRYfJW3RzmPDz9gVJtR/LzjZz664qOq5WmYYPBSWHUb7PsOQrsr19Rj/8KIfZXK4sYb1aDYvz889JBqN1u3qlUuj5c0DKaOmMromaMZ12UcVpMPXl7uk8JQ31C8TF5kFmSy9dhWEo6rbYyj24/mrVXqJDiLYcEmNoa0GOLZg+5LQykNTqNRFVdBzjQmk3Inf+AByMpScqOi7VW9eqktwZ07V00BcWIYaiX4qqvUBKJ3b6VkzpypttTUND0b9WR2/OySCanJMFEvsJ57woYjYPPTsPkp6PSykgsmL6Y8MpWL7ribvXuVsczLS93vCy+c4Rs5UzjskL0bGo1UMvEktK+j3KLijsVhF6UcVrR9y9viTW5RbslWqgL76fM02rdPLVaUn/x5mvSPGAH33qu85tq0UTLXZoMGfuo+4lPiWZ+4nkJHISHeIfhYqmMW4orNBgcPqq2hZWW+JyOXYRj4WdXJMk6jkYjga/Vl+zYTvr7KwFGdxMWp8bigzE5u5xicmptKen46AL38fTCC27l6ZJ6A+oH1ScpOKjHogpokVhZlnK508kozbpzSB9u3VwYSf3/l8bxgQfVf62xiYp+JTFo8iezCbHwtviUe6J4ICFDj9qnwcK+HefGfF/G3+tMkpAnLl8Pll7tO/KvLIFjXvy5Hc47iY/Yh355P924mUv5Wi7ATJqh+V1SkvPPOpHfp2Up2ttqSXr7+LRYY3208U9ZOoVloM7Ylb+O5Ac9hGAYvDnyxJGTA7V1uLzH8bEjawPur38fmsBHiE4K3RY0tcxPmluTrHJed24GdRvoGQQ1cjEbXt78eb4s3JsOEQxyk5Kl0VgIIDjZKvCGrnTp91aua6dAB3n//xGlsNiWPOnf+79cJDFSGwLFjVZtv3Vot6q9Oag5DIPZoLIv2LkIQwv3CsZqttAlvw8M9H6Zv476YjArmRxGDYMVY5QBh9ldGn5FHwJZzwoWDWWNmlX5oeQ/EvwsNhwN+xb/PU/OVSuLtDf/3f+qlqRxnx4z3HCUgAJo1U6slTiF5TdQ1jO00lvsvuP/EP/bAG2+o1ZKoKKWA3HabEg5uWAPUlqf900vj6Yw8AqNzPVpo4QQ7gU6RIS3Ukap5tjyGtx5eJUNZRdx6q/J6KHu0ZVnF82TUr6+2x5S3FJtNZsyGmhEs3re4xB22SmVOXqH2wTvjGTiNAvfiajU3DGVMOENcWhqqRgAAIABJREFUcolaKS8/4SkshAcufACgZFX/ho7lQ479d94b9h6T+k06oaJYIT614eI5MOhvaD4O2j0Nw/dW+udms4p/NXWqimk2a5YaBE60Uj6y7Uh61O9B9EXRNGigBsC0NPd0zuMse33eqyS+TauwVjQLUV5IdQOUJffOrne67zG2AhaBgGal39WwJ1plMQzlAl23bsWK94QJ8NVXqo9lZSmFuapbWho2VK7sb70FTZsqxebff0/+uzPBPd3vAaB9bWXcGBBZgVeYyQyXrlCrXb9Fwl+D4LfmRBTOIDZWTRx//BE++0wZ7T1N5s8LsveoxQu/Mt5CJzCSFtqVdeLNVW9y15y7AFwMAGXxsfjgEEeJ0ciZ7nR4Gjm9eiuzdTs4WD3XSy9VK77Llys5dP9Y5Sa8+ehmLpqqAp3YxHaCnP47CQmqrzYot9OmIo+2QK9ABCGrIIusgiwEIcAawM6d1W8wAmXAL388tdPL9Xje8ZItaj38vFXsOyfOtuMcU8uNqxfP3w6o7YugYkdWxYgYGgrx8VW7l8pgGPDUU0ouDh+uvDY/quJayrnIyLYjS94/cMED1ZdxRIRHnSrUN5Sltywl7t44QBkn+/T5D7G4TnYtw+DRP9QWyZ6NegLwVL8nmTtXbeO+4Qa1WDxpktpxoFEGo+Rk3IwwhYVwXdR1AGxLVitDkbUiAbi5Y6kbckRABA0ClUA7lHWIiX+pnQtF9iKPW8RHtxsNqPhEnT7qhEMc+Fp8sZgsNApuRJhvGD0b9iwxODljbTmN+M0a+rNnz/m5vbCoSPWJU/W6a9lSeQbOnAnjxyudbfHvqh63HN3CyOmq/xfZSx/6m5e9ydVtT+Ax7lUL2jwEi4dCygq106AgBTZ4iH9UEZE3gFeo0rsOTIeU1RB3vq7MnT1oo1E1YzFZ+HrE1wR6ewgGcrLfWlQwtthYZTgZP14F6/JI1ETY9DSkbVYeGrYcOL7BLZmvrzKe7NpV5eJUigCvAGr5qCWW2zpXT6iq229XiteNN6pgo7m58NNPlf99VJSysv/1l+vglZOD23MJ9Kric8rZCxGXVnpV9EzRsaNShm+9Vd1nRobyFnnxRUq2je1L30dEQAR+1upbZq0fWJ/nBz5/aplYg1Rg6OD/b+/Og+Mqz3yPfx91a5e1WPKK5X3DNgYcB7NDDCZAjNl8SUwCTiCYJCQZcrMAwwzM1GQqDMkNIcyQKhch5uaSEAgkYSbksmaS4RabAyTBEwiEsHjBNsYWlixZkvXeP94+0pHULanV3erT0u9T5VL36Vb3W35bp895zvM87+HDarZ1xBE+Zff2232pxkBp4vGiOM9e8SyNNY1UVMCKFT6ttyXUPqOlxX+uAZo7mnGJ8qPastruL8Jt+7dRWVxJXXld/1TAOL5iKVyaVhY8p/B3ucuX+wPlE07wvYq+/OX0+lKELVjgD74vuCB1ZtNIO2WGP9lvavflnMGBaVKl4+Gke+Hc1+H4H8HqLXDa45SU+BPHO+6AH/7Q/11mdFITZR1NUD7Nl5sGBgiSBmWenV2d3QGkxurGpM+tiPuyqiBo1H6oHYfLSabRpEnw1lv9T3ha+68tAfjP7WOP+e+oK6+En/wEvnGdD5w5HC0dfqcSfD9m29at/oA+1fj6qi7zpbT72/d3ZwZXl1Xz0ktDf410vPiiv9izapUvnz72WP99Ab6MZE+rr++bVloKlY09CyIMEmDf8N/+hC8oN1kzf01a41qzxgf8mpt7tqVzUWowZWW+eew55/iA+Gi3sGFh9+2LFl80Iu958syTmVHrs9YOHOjfCzRbPrTdn3EHPXSObzye2bP9cfmll8K+fT4b4+EhtsQc7U491V/86XvBqaODXs3qN3xgQ/ft+op6Vs1axfc+8r3u+4Fgvz+5ajIXLPTBiYrEfiJmMRZPWOxfv6uDP+z6Q7/xvPu1d3nq8qe671+x7AoAjp/mA1BfPm8VTU1+4YDwxcbwvqFQBaWa772XnddraPClpDNn9pQDO1z3d0nS3kUDOfLrvjXFb8/3LT5+dhgc2Dr03y+Kw6m/hAVfhD//Gzx1qW9yn+IClGTHaD2MLWjjx8Pq1XDmmQPUw89YBzM+Co9/CB45ER4+Dp5Y1e9pZr5HyY9+1DsboO8VwEwEV+LPmHNGVl6vutp/8Wzf7ssFpkzxwYChMvPP/9zn/NXY5mZ/UHz77XB4g6+1LU6c0C+oXzDQS/XX+o7vR9O3V83t9F/8dgRrYM18yeRvfuODZhdf7LM3vvtdeq1m94mlA5QPjkFf/7r/XNxyi/+MNDX58rYgoyhQkujRctL0k7q3nbfwPH/jnXd6z/v+NogX9V5V74J34GKXMhOw0Fx9tV8FbcECv1/5yldyl8040sqLy6kpreleteXYaccO/kvxSt/8sqQ2x6OLINfp+7yFPwADBEmD5rlhR046MulLVxRX4HC0dvioRmdXJ865nGQanXyybyjdty/cQBliRx7p++O89BI8+iicf34Rcev9Amn1zEtDe7svsxpqBlsQvGpub2Z/+34Aakpr+KPvJc0ll8C2bTA/S8N92feb5c47/YnGxo10X/G/4/k7WHf/OiDRI8Hi/jMEPZ+d24uSLSjP3Jd9/4y/vOf7Rq2cvTKtcV15Jdx/v79yfuCAz5bM1UW1scDMGF/uI/7plAkOqu/3aopjqq6uLCzskuy9nOPIP/gA5ltNb2EYNWV+ybSSEr+i7y23wA03+O9B8ceeJSW+n19wIa652WeBl8RKqC3134/nL+ydhfLIpY/wmeU9C4L0LeddNGFRd5C4rNg/dsqMUygqKuquHghMqJiQcnwnz/CNlIP934kzjufSS30j5F27fD+blha/fyh0RUW+dPo//zP7Wc7J/t/DweMhMYOFV8MFO2HNX+DCPXDqv6c5kBjM+jic8aRfGOq4Tcn7iErWKGhUqMxg+a1wxlMwZZVfeejDzyZ96iWX+AO2t9/2B0mtrX7Zxmz54QU/5LUvvDb0FbmGYM4ceOYZf7XykUdgx470fv/66/2V4xUr/JKfCxb4bJQgGyr40rrs6FRrsybhHLS/B5XT0xvMCJk1y/fl+MIXfIbZ2rX+fnGsuDvocfqsJEuHj2EnnQQ33+xXAxs/3pc2/vjHPcGh4OAlKKsIBxBWzkpxshIrhZIaaIpAg54cmjvX/9/ddZcvpc3GioxRsXbR2u7bSZtgS49Ymc82Ch+sDRAkDTeFLkocgqRqol9R4q8qt3W20eW6fNAIl9VsycCCBT5L8R/+oeeEp6XFNzZOR5BNE+w7ghOVbCsqSi9QW1/ur+AH5Wngr+q/9Zb/273tNl+lEywskak33/T9fWoTcdR588DwO4l9B/d1N69tdQYd70OiX9VgAfYiK6KxurE7UyndQMVRR/llp6+6yq/idcYZPgtKhu/py5/m4Y8/nHrl3BwqLvaBv1yIF8UZX+YDYuuOWJebNxlFzHzp+qZNfiXHW2/1AZkNicSi4PhpsH3isYf55x01yTfkueDwCzAzZtTM6C5rDTKXgqzwwEBN8Y+a7F/vz3v+3P3cb3zDZ0ItWgTr1vljws+N3IKtOXX22T6TPpwkEM6qz0SQHVxT6gOpp806bXgvVBSD8ik9LT8k0hQ0KnR1R/pu/EffDLXJ113+2Md8ts4HPuBLSa65xu8gs6WiuCJlI9NMzZ/vAz/prjxUUuKXRf7mN/3V2GXLfN+Jwyf4TKOdLf4KUnB/SA7u9ldES0NXMiLW4Liiwmd9/PSnvjStIZExevRkX3SfdOnwMe6qq3xG2re+Bd/5ji9RWb1gNdATXAxKlIJeRjDIMs91H4BtD/rGfIFDWayBkJwKsidLY6XEigaodxSonAmtW9P6fAcNkYNGposnLk76vOCEoK2zrXvltHhRPCdzYua/L26/3Z/kPPaYz0RMthrZQC5cdCEAZ809q9fPbKuq8u3UhtqzYkKl/94Kl6dNqJjArl2+5NTMB6JOz8J1ha4u39vk7LN7SlU6O5MHYFtKJ8P+V+HQ0GvkPjLvI923l05amvb4brjBrww5dao/Ybz55tGTKZkzKXoMAcyrn8cZc7OTaZ6u6dN9f7xcWT3fHwvk6u94tDn9dF+q+8orcN11Puj+z36xO2476zZuOu2mQYP+q+b4qomg5OmYw44BevcXDAJAQbBixWErgFAGeBLB6zUdbKK6tJpYUYyqKp81vWGDX4jDudGRaQTwmc/4nl9XXukTBg4e9BfUs2HNAl8WHPQzPX22LkiPBQoajQGxmM/WOeYYv8z1nXf6tMXRLhbzO83/+i+fHnv00T2lAsFVzrRKB9r3+f474SvqBdLg+IplV1BbVjusXltjwWGH+eDRFVf4K+Oz63x5WlACkezq1YKGAXLSp3wYXrvTLysaUK11wQiuiAYHpjKAklooroG9fc7cOlN3Rw+CB9v2b6M8Xp5ylZWg51xbZ1t3f4vSIazQNlxBqcLPfuZXZLrtNt+7Kx1ByfNf9/qm/rm6oLJwYfKeh6kWAphc5U/ww+Vp42PTaGvzWQHBwhHZKGXYt89//65Y0dNbo6qK7h4kYQfHHQ5NW3zG2hCFMz6Hm3V2yinwxBOweTN89rOjK1MyJ/ou+JBq2whbscLPY6760ASfNV1wG7rVq32p62uv+aqGYHWqufVzuebEawb9/b7H6cHx2AcP62meeMREv0rQSTN8Vniwfxss83BenV8uPgh6gN83/cu/+N5rL7zgW4OMBrNn++b8Dzzg235UVfl+btkQlKMF33PBHMnopqDRGDF5sm8MvXmz79vw9NP5HlF+BPXOO5p9vdukykkDPb23rg7fu6QAT/4vX3Y5e69JskyYJBWs4BH0tQmf+AVZWymXEwWY/Uno2AuPnQzvvwz7/wJPpNd7Q/InOADKVT+aUad2Kbx8C3QM7cwtOOAHOHpK6qWHqkt98+Zw0CgXy9cHzHxJxa9/7U8i7r03/SXTg33Fm01vAnT3e8m2CRN8ltFzz/Xenqr8wCVSaf712X/l1qdvBaD5vWrKy315VpCxlI2G7fv2+d5QfVd/DcoNw8obVvgGprt+A12JiNcgkavgMzNQ/xIZG447Dn75y97bshlAWj1/NTNqZnSXqMvQxOM+k6/vKsZDEVykC/ahwT4//L0RPGdm7Uyg51gtXP6cTNAD7eTpuSkbjpq/+zufLDBzpr84euut2cmqDL7ngsBeLhankOhR0GgMMfONpZcsGcUr+QzCzCguKqb9UDsxi6VXg+86E1lGymMf7YLyl3dafOPNYMUngOevfB534yCfgbIGWHw97H8N/uNw+Pe5sG9LzsYr2WVmtFzXwg/O/UG+h1IYZq2Hnb+G7b/0gaPOA7A59fLb4WDc0ompy4uCfgmtna0jEjQKrFjhr46ffXb6GSjBvmJv296c9F4KW7TIl9WGT5IPpEjwCi6UbNm9hZd2vwTA9l0HiMV6N/JNufhGGoJMo6lT+z8WNOSeW+dP+o6fcxaMPxqe+xy07/Wfn46BL3AEC1rMGz8v88HK0PRdJTTVthG2Zo1fIeqSS/xnv6UF7rsve6/fWNPIG1e/kZd+TWNVsA/t6OroLmUGOGJST9AoOEYLgnnb9m8DejKOUgn6JA10sWK0ufBCn/X1xhs+kzYbH+Vgjg50Hkjv4rsUtDEaOpCx7IRGX2+QdrqxxcAdAkJ73FG0lLr0Fu6/MbFyYvovsPhvYenXoajE98JadG0WRye5VlFSoX5GQzXjIv85/3/r4LfnwiPHweubUj49nMo+UF+5YLWits42WhP9wXIdiMlUY03P+t8fnPrBAZ6ZuU99ymdF3XefP2FuboYLLkj+3GT7sCp8T6lkwZ1MNDVBTU3/pbehp6w3KJWeUTsDlvw9tO6Eh5bAM5fBQ0f0/8WQ4lgxMYtxzvxzsjtwSW2Iq5mNtIYGuOgin220aJEvO7wsjfVNJHrCbRSC43WA2rL+q5MGmUa7W/yqigNmgNMTLEpWKitDN72mZ0GgIa0wK6OCznRlzDll5inAMFa1KSqGQ+09SwPDqFtKXXqED1aGdZXRDA7/Eny0FT7aBkf8fRZHJxIhsTI4/kcQK4edT/iVA8tTX/ENl3uGs/j6StbTKOpBo3hRvPt2uAdHLnz84343c9llcOKJfoWyzZuTPzfZFfjyrklUV2c/83jfPp+EEl61JxCsuhOUk5TFy2DqR2DqWdCxH966D9qbBn2Pzhs6ufYkBeIFvv1tv3rsjh3wu9+lv3CKRE/Quy5ZX8Fp46Z13w4uLDjcgCunBVZMW4G70WV1teexqDjWc0UgaNkgo5+CRjLmBKntwc8hi1VA+x4Y5EqGjA7BlajZtRk2+LMiv6yoyGg29cOw8jGYfAY0roUzUy9pFPQMg4EbRQcBotaOnvK0yuLonxEGV8SDpti5UlUFGzdCeblv4Lpnj+9bkUz4/zxQfmgSU6YkD+5koqkJxo1L3pooKCfZ07qHkliikZIZnPgTWHg11C2D+Z/XcmYyZA0NvrfXVVfBJz4BTz6Z7xFJpoIA0Lz63iWo7kbH2//z7aS/E6ygJiMjuKjTd45k9IoP/hSR0SXop5F2k9vyydDVBgf3DHgVXUaH4GR2bv3gV69EBJhwHKx8eNCnhcv+gvKCZILmmi0dLd1Bo6rSLDTdybFZtbN44Z0XBsyiypZ163wZ2D/9E0ybBps2JX/etOpp/baVHZpIfX0aK6ZNntx7xSwzn1LUp0xp377UvZHC4+i14o4VwZH/7P+JpKm62mccyegwp24OW3ZvGVL20IL6Bbyy5xWWTFwyAiOTwPSa6WzZvWVEvuckGpQyIWNOEBVPu4lmUTHEx0Hr9hyMSqImOKHRqikiuTNQY+sgq6i5vbk7aBRc3YyyYJ8xUBZVNq1dC7//ve/rMiHFgmLhHhSBkkP1VFSk0Rh1iMuu79sHFRXJy96mjJvSfVurE4pIMkFvuKEs5R7sR7Ts+8gKLviM1Pec5J+CRjLmVJVU4W501Jb3b6o3qLLJsOdZcKFLs0NcZloKS3DiF/TgEJGR1XTQ97a56/d3cfH9FwOwszlJ4CJiplT5wEiykrB8mTrOd7sui5d1l/1Zax2VldnvabRrF9TW+hXU+gr+b0ABeRFJbmHDQmBoPexm1sz0PwfIWpXsqy+v7/VTRj8FjUTSUdEI7zwKnft7tqnH0agUNEpcMU118iLZtnzq8kH7E+0/6PezbZ1t3QGkAx0p1pSPkFNnnUqRFUVq9b1gLPGieHeT2b17Y1RXJ1/lLBMtLX71tJKS/o+FM42SZT+JiHz+mM/jbhxaX7PptX4/oiD0yFp/1HoW1C8Y3kIxUpDU00gkHXVHwWsbwUJH2W07oUpfVqPRUA9aRCSJAXrgPHfFc4P+el15Xb9t4eWYo2rtorUcuiF6K2qWxkppbu/JjN27109HtoNGhw75oFGy1w1nGoVvi4gMR5BF2VDRkOeRjC0rZ63k5c+/nO9hyAhSioRIOiad6n/+8R+hs9X/e+aKvA5JRCSShtgDJ5W6sv5Bo6qS6DfCjqoJlT0NjxoqGti3D+rqkpeRJTVp0pC2HTqUOhAVXuo6nHUkIjIcFx9xMe5Gp4wXkRxTppFIOiac6FdQe/l/QWczHNwNOx/P96hEREad+or+vRLGlYwb8ipe0tvkyslsfX9r9+1Dh6A+nXYUQ/z/7ewcWiBKmUYiIiKFQUEjkXSU1EDtkfDec/Dq7YmNStgTEcm2hvL+5QbjSsdlnME0VoXLNyZWTaSjCyoHbis1LF1dQyt5U6aRiIhIYdDZrki6Fv8txEJH2ommoiIikj0Nlf2DRjWlNXkYyegQLk+bUDGBrq40StPSYOYDRykfx5eRjCuJfn8qERERUdBIJH3TzoX6D0JRGcQqYN5V+R6RiEj0DLEHTirJGpvWlCloNFyTqnr+7ydWTuTQISjKwVFgPO5L1FIJ+lKpB4mIiEhhUHmaSLrM4NSH4JXvQmk9zLks3yMSEYmeDHsMxYv6H6LUltVm9JpjWbjcLwgaxXNwFFhU5Jthp1IWL2N/+/7sv7GIiIjkhDKNRIYjXg6Lr4G5nwbTn5GIyEioK++/opoMTfj/rq6sDjNwLvvvE4tBa2vq116zYA315el04BYREZF80tmuiIiIRFLQ/6YsXgbAnLo5GZe9jVV1ZaGgUXndoBlBw1VcDHv3Qnt78sfvWHMH737t3ey/sYiIiOSEgkYiIiISSePLxwNwQuMJAEyrnubL3pzr/S/DUrixIFzaV1dWRyw2cMPq4Ro/HpqaUgeNREREpLBkFDQys/Fm9qiZvZr4mTRv3MzuNLNdZvZSJu8nIiIiY0fQ+Lqtsw2AyuIcrBE/RvQqT8thplFDA7z/fm4CUiIiIjLyMs00uhZ43Dk3D3g8cT+ZTcCZGb6XiIiIjCHVJdUAHOg4AEBliYJGw9WrPK3MB42am7P/PjU10NKSm35JIiIiMvIyDRqdC9yVuH0XcF6yJznnfgu8l+F7iYiIyBgSBImC1baKi4rzOZyC1jfTKB6HPXuSPHHyZL9KqFnPNjO/fQhqa33QSEREREaHTINGk5xzOwASPydmPiQRERERGFcyDoCmtiYALBzIkLTUlNZ0364tq6W21jes7leitnNn8hdItb3v+9T4nkbx+DAHKiIiIpEy6Fe6mT0GJLu8dH32hwNmtgHYADB9+vRcvIWIiIgUgHGlPmgUZBrJ8MWKYt23S2Il1NX53kPt7VBenr33qa2FbdugrCx7rykiIiL5M2jQyDl3eqrHzGynmU1xzu0wsynArkwH5JzbCGwEWL58uSriRURExqjqUt/TqK2zDUNZRtlUXw/bt0NnZ3Zft6YGOjp8FtOECdl9bRERERl5mZanPQisT9xeD/wiw9cTERERAXpWT4OeAJJkR12d7z2U7VXOamt9ydvrr2f3dUVERCQ/Mg0a3QSsMrNXgVWJ+5jZVDN7KHiSmf0YeApYYGZbzezyDN9XRERERrlwHx4FjbJr3Dhobc3+Kmd1dXDwIGze3LOtoyO77yEiIiIjJ6M2hc65PcBpSbZvB84O3V+XyfuIiIjI2FNZXNl9O7xkvGSuuhp274aiTC8f9lFR4XskPfkkXHKJf5/WVijWwnciIiIFKcuHCiIiIiLZUVnSEzQaXz4+jyMZfaqrYceO7DbBDkydCg89BKWl/n4sNvDzRUREJLoUNBIREZFICmcaVZepPC2bqquhuTlJ6dikScl/IdX2JGbP9iuz/epXvtH23XcPf5wiIiKSXxmVp4mIiIjkSjjTqLpEQaNM3Xz6zXQc8lGiceN8P6Pt22HuXP94VxcUvfNOxu+zdCk8/DCsXw8XXgj33AMbNmT8siIiIpIHChqJiIhIJIUzjcIrqcnwfPWEr3bfDlY5e/nlnqBRS4sPJmVq6VKorPTZRj/4QeavJyIiIvmj8jQRERGJpHCmUXglNcnc1KnQ1gZPPeVXO4PsraS2eDGYZee1REREJL8UNBIREZFICmcajSvNQgqMdCsv9/8eegja27P72gsXZv81RUREJD8UNBIREZFICmcahQNIkh2TJsGLL/oAz6FDvnF1NpSVwYknZue1REREJL8UNBIREZFICgeKwgEkyY7p0/3PT3/a9za65prsvfYnPwlVVf52tXqYi4iIFCwFjURERCSSlGmUW0cc4X/+/OewZAm8+Wb2Xvucc3r6GpWUZO91RUREZGQpaCQiIiKRpEyj3FqyBCoqcvPaNTVw772wbBn84he5eQ8RERHJvXi+ByAiIiKSTHGsuPt2RXGOohtj2Pz5UFw8+POG68wz/T8REREpXMo0EhERkchTeVr2LVkCra35HoWIiIhEmYJGIiIiEnkqT8u++nqYPbvnflz55yIiItKHgkYiIiISeco0yo21a3uCReXl+R2LiIiIRI+CRiIiIhJ5yjTKjfPP71ndLFjtTERERCSgoJGIiIhEnjKNcmPZMjjrLH/7u9/N71hEREQkelS9LiIiIpFXXqzaqVy55x7YsQMaG/M9EhEREYkaZRqJiIhI5BWZDllyJR5XwEhERESS0xGYiIiIiIiIiIj0o6CRiIiIRFZxUXG+hyAiIiIyZiloJCIiIpEVL1L7RREREZF8UdBIREREIktBIxEREZH8UdBIREREIitWFMv3EERERETGLAWNREREJLK0apqIiIhI/uhITERERCKrtqw230MQERERGbMyahRgZuOBnwAzgTeAi5xze/s8pxH438BkoAvY6Jy7NZP3FRERkbHhL1/8S76HICIiIjJmZZppdC3wuHNuHvB44n5fncCXnXOHA8cCV5nZogzfV0REREREREREcijToNG5wF2J23cB5/V9gnNuh3Pu+cTt/cCfgMMyfF8REREREREREcmhTINGk5xzO8AHh4CJAz3ZzGYCRwPPZPi+IiIiIiIiIiKSQ4P2NDKzx/D9iPq6Pp03MrMq4H7gaufc+wM8bwOwAWD69OnpvIWIiIiIiIiIiGTJoEEj59zpqR4zs51mNsU5t8PMpgC7UjyvGB8wuts598Ag77cR2AiwfPlyN9j4REREREREREQk+zItT3sQWJ+4vR74Rd8nmJkB3wf+5Jz7dobvJyIiIiIiIiIiIyDToNFNwCozexVYlbiPmU01s4cSzzkBuARYaWYvJv6dneH7ioiIiIiIiIhIDg1anjYQ59we4LQk27cDZyduPwlYJu8jIiIiIiIiIiIjK9NMIxERERERERERGYUUNBIRERERERERkX4UNBIRERERERERkX4UNBIRERERERERkX7MOZfvMaRkZruBN/tsbgDezcNwJHOau8KkeStcmrvCpHkrXJq7wqR5K1yau8KkeStcmrvClGreZjjnJgz2y5EOGiVjZpudc8vzPQ5Jn+auMGneCpfmrjBp3gqX5q4wad4Kl+auMGneCpfmrjBlOm8qTxMRERERERERkX4UNBIREREREREfG/h4AAAGOElEQVQRkX4KMWi0Md8DkGHT3BUmzVvh0twVJs1b4dLcFSbNW+HS3BUmzVvh0twVpozmreB6GomIiIiIiIiISO4VYqaRiIiIiIiIiIjkWEEFjczsTDN7xcxeM7Nr8z0eSc7MGs3s12b2JzPbYmZ/k9g+3sweNbNXEz/r8j1W6c/MYmb2gpn9R+K+5q0AmFmtmf3UzF5O/O0dp7mLPjP7UmI/+ZKZ/djMyjRv0WRmd5rZLjN7KbQt5VyZ2XWJ45VXzOzD+Rm1QMq5+2Zif/kHM/uZmdWGHtPcRUCyeQs99hUzc2bWENqmeYuIVHNnZl9IzM8WM7s5tF1zFwEp9pVHmdnTZvaimW02s2NCj2neImA4597pzl3BBI3MLAb8G3AWsAhYZ2aL8jsqSaET+LJz7nDgWOCqxFxdCzzunJsHPJ64L9HzN8CfQvc1b4XhVuD/OucWAkfi51BzF2FmdhjwRWC5c24JEAM+huYtqjYBZ/bZlnSuEt95HwMWJ37n9sRxjOTHJvrP3aPAEufcUuDPwHWguYuYTfSfN8ysEVgFvBXapnmLlk30mTsz+xBwLrDUObcY+FZiu+YuOjbR/2/uZuAfnXNHATck7mveoiWtc+/hzF3BBI2AY4DXnHOvO+fagXvwOx6JGOfcDufc84nb+/Enr4fh5+uuxNPuAs7LzwglFTObBnwEuCO0WfMWcWZWDZwMfB/AOdfunNuH5q4QxIFyM4sDFcB2NG+R5Jz7LfBen82p5upc4B7n3EHn3F+B1/DHMZIHyebOOfeIc64zcfdpYFrituYuIlL8zQHcAnwNCDdm1bxFSIq5+yxwk3PuYOI5uxLbNXcRkWLeHFCduF2DP04BzVtkDOPcO+25K6Sg0WHA26H7WxPbJMLMbCZwNPAMMMk5twP8hxuYmL+RSQrfwR+IdYW2ad6ibzawG/hBorTwDjOrRHMXac65bfgrrW8BO4Am59wjaN4KSaq50jFLYbkM+FXituYuwsxsDbDNOff7Pg9p3qJvPnCSmT1jZr8xsw8mtmvuou1q4Jtm9jb+mOW6xHbNWwQN8dw77bkrpKCRJdmmpd8izMyqgPuBq51z7+d7PDIwM1sN7HLO/S7fY5G0xYFlwPecc0cDLaikKfISteXnArOAqUClmX0iv6OSLNExS4Ews+vxqf13B5uSPE1zFwFmVgFcjy+R6fdwkm2at2iJA3X48pmvAveamaG5i7rPAl9yzjUCXyKR1Y7mLXLSOPdOe+4KKWi0FWgM3Z9GT3qcRIyZFeM/tHc75x5IbN5pZlMSj08BdqX6fcmLE4A1ZvYGvvxzpZn9HzRvhWArsNU590zi/k/xQSTNXbSdDvzVObfbOdcBPAAcj+atkKSaKx2zFAAzWw+sBj7unAsOmDV30TUHH2T/feJYZRrwvJlNRvNWCLYCDzjvWXxWewOau6hbjz8+AbiPnjImzVuEpHnunfbcFVLQ6DlgnpnNMrMSfPOmB/M8JkkicdXg+8CfnHPfDj30IH7HQ+LnL0Z6bJKac+4659w059xM/N/XE865T6B5izzn3DvA22a2ILHpNOC/0dxF3VvAsWZWkdhvnoavQ9e8FY5Uc/Ug8DEzKzWzWcA84Nk8jE9SMLMzgWuANc65A6GHNHcR5Zz7o3NuonNuZuJYZSuwLPEdqHmLvp8DKwHMbD5QAryL5i7qtgOnJG6vBF5N3Na8RcQwzr3Tnrt4doecO865TjP7PPAwfoWZO51zW/I8LEnuBOAS4I9m9mJi298CN+FTUS/Hnyz9jzyNT9KjeSsMXwDuTgTVXwc+hb8woLmLKOfcM2b2U+B5fHnMC8BGoArNW+SY2Y+BU4EGM9sK3EiK/aNzbouZ3YsP3nYCVznnDuVl4JJq7q4DSoFH/fE2TzvnPqO5i45k8+ac+36y52reoiXF39ydwJ3ml3NvB9YnMvw0dxGRYt6uAG5NLNjRBmwA/c1FTFrn3sOZO+vJxhUREREREREREfEKqTxNRERERERERERGiIJGIiIiIiIiIiLSj4JGIiIiIiIiIiLSj4JGIiIiIiIiIiLSj4JGIiIiIiIiIiLSj4JGIiIiIiIiIiLSj4JGIiIiIiIiIiLSj4JGIiIiIiIiIiLSz/8HrenWSc0gXK0AAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1772,12 +1845,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Index 6\n" + "Index 3\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1789,7 +1862,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1799,16 +1872,9 @@ }, "output_type": "display_data" }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Index 7\n" - ] - }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1818,9 +1884,17 @@ }, "output_type": "display_data" }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tal hits: [MotifHitAndCoord(motif_idx=0, motif_score=0.7396519082923678, precision_at_motif_score=0.6466523942825104, example_idx=3, start=8, end=33, is_revcomp=True), MotifHitAndCoord(motif_idx=0, motif_score=0.9925835180934502, precision_at_motif_score=1.0, example_idx=3, start=17, end=42, is_revcomp=False), MotifHitAndCoord(motif_idx=0, motif_score=0.7552320976497837, precision_at_motif_score=0.6949197693348133, example_idx=3, start=44, end=69, is_revcomp=True), MotifHitAndCoord(motif_idx=0, motif_score=0.9989573753258589, precision_at_motif_score=1.0, example_idx=3, start=53, end=78, is_revcomp=False), MotifHitAndCoord(motif_idx=0, motif_score=0.5618840852404383, precision_at_motif_score=0.09592826695380294, example_idx=3, start=75, end=100, is_revcomp=True), MotifHitAndCoord(motif_idx=0, motif_score=0.997376173301304, precision_at_motif_score=1.0, example_idx=3, start=84, end=109, is_revcomp=False)]\n", + "gata hits: [MotifHitAndCoord(motif_idx=1, motif_score=0.9998595508158103, precision_at_motif_score=1.0, example_idx=3, start=117, end=142, is_revcomp=False), MotifHitAndCoord(motif_idx=1, motif_score=0.9276210105708627, precision_at_motif_score=1.0, example_idx=3, start=161, end=186, is_revcomp=False)]\n" + ] + }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1834,12 +1908,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Index 8\n" + "Index 4\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1851,7 +1925,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1861,16 +1935,9 @@ }, "output_type": "display_data" }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Index 9\n" - ] - }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1880,9 +1947,17 @@ }, "output_type": "display_data" }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tal hits: []\n", + "gata hits: []\n" + ] + }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABHsAAACMCAYAAADsiaVcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3dd5xU1d3H8c+Z2V5YFhZY6lKlg1JUQMQSW2LFLvFRgxoLxhQTY9QIJkbzkJg8amKiUbF3IvZeQAHpRToCS98CbK8zc54/zmwZdhd2gd2dXb7v1wt27plbzsyZuXPu755irLWIiIiIiIiIiEjr4GnuDIiIiIiIiIiIyJGjYI+IiIiIiIiISCuiYI+IiIiIiIiISCuiYI+IiIiIiIiISCuiYI+IiIiIiIiISCuiYI+IiIiIiIiISCsS0Rg7TUlJsT179myMXYuIiIiIiIiIHJUWL16cba3tcLD1GiXY07NnTxYtWtQYuxYREREREREROSoZY9Lrs566cYmIiIiIiIiItCIK9oiIiIiIiIiItCIK9oiIiIiIiIiItCIK9oiIiIiIiIiItCIHDfYYY7obY74wxqwxxqwyxtzeFBkTEREREREREZGGq89sXD7gV9baJcaYRGCxMeYTa+3qRs6biIiIiIiIiIg00EFb9lhrd1lrlwQf5wNrgK6NnTEREREREREREWm4Bo3ZY4zpCRwHfNsYmRERERERERERkcNT72CPMSYBeBP4ubU2r5bnbzTGLDLGLMrKyjqSeRQRERERERERkXqqV7DHGBOJC/S8aK2dWds61tonrLWjrLWjOnTocCTzKCIiIiIiIiIi9VSf2bgM8BSwxlr7cONnSUREREREREREDlV9WvaMA64GTjPGLAv++2Ej50tERERERERERA7BQadet9Z+DZgmyIuIiIiINIac72D9P2DYNIjp2Ny5ERERkUZ20GCPiIiISK169oT09ObOhTTIv5o7Ay1XWhps2dLcuRAREakXBXtERETk0KSng7XNnYvDZ0zreB11yV0LH44EfxF4ouGKkqY9fmt5f40auouISMtR76nXRURERKQFyp5LZY98T1SzZkVERESahoI9IiIiIq1Z5lfgL3SPra958yIiIiJNQsEeERERkXBXng+B8kPbNuvrqsf+4iOTHxEREQlrCvaIiIiIhLPCdHgjGT4e1/Cxb3xFULitcfIlIiIiYUvBHhEREZFwtvxewEDeGtj9ScO2LdwC3pjGyJWIiIiEMQV7RERERMLZzvfcWDu+Qtg+q2HbFm0Ho+qeiIjI0Ua//iIiIiLhqnBrtXF2bMNb9hRtg4AGZRYRETnaKNgjIiIiEq6yvgYTUbVcsKVh2xduA3/REc2SiIiIhD8Fe0RERETCVcYX4MuvWo6Ibdj2+esBCzGpMOhOjd8jIiJylIg4+CoiIiIi0iz2LgldDpQ1bPui7e7viL9Cz6savr2IiIi0SGrZIyIiIhKuineELvtLGrZ9Sab72+0C97fXNYefJxEREQl7CvaIiIiIhCMbgNI9h7ePsj2Q2A+wbrnNgMPOloiIiIQ/BXtEREREwlFJBngiD28f5XnQ/ngXOAIIlB5+vkRERCTsKdgjIiIiEo4Kt7pgj/HC6V/AoN82bHtfIVg/tB0OEQmNk0cREREJSwr2iIiIiISjkt3ub49LIOVEGPJ7iEyq//Zl+8ATDW36gQlW+bwNnM1LREREWiQFe0RERETCUUkGBHzQ9Tw3ZXqgDFLG1H97X5EL8sT3rEo73G5hIiIi0iIo2CMiIiISjop3gb8YOk5wyxHx0PHk+m/vDwZ7Yjs3Tv5EREQkbCnYIyIiIhKOCtMhMhGiO7plTwSk/qD+2/sKAQORbRsleyIiIhK+FOwRERERCUdFOyC+l2vdUyG+R/239xW5MXqM98jnTURERMKagj0iIiIi4ag8PxjcsVVpUe3rv72/CKLbQ6DkiGdNREREwpuCPSIiIiLhyFcA8WluRq0KgbIGbF8IkckQ8B/5vImIiEhYU7BHREREJBz5CyG2K3gPNdhT5Gbxqt4ySERERI4KCvaIiIiIhCNfsZs23Rxidc1fEewRERGRo42CPSIiIiLNYMMGyMs7wAr+EojrFppmIup/AF9RsAuYOZTsiYiISAumYI+IiIhIE5s1CwYNgmHDoKCgjpUCJW6A5eo8UfU/iK8AImIOvWWQiIiItFj69RcRERFpQtbCTTeBzweZmfDEE3WsGCiDiLjQNE9k/Q9UngveOAV7REREjkL69RcRERFpQkuXQn6+e1xcDE8/XctKgXKwAResqc7U0SUrNdU9V/3ffx6DiPiGdf0SERGRVkHBHhEREZEm9OKLUFpatbxxYy0r+QpdK576DrCckVEzLRrXMsijYI+IiMjR5qDBHmPM08aYTGPMd02RIREREZHW7L33XBeuCpG19czyFboWOZ7oWp6sJy8QkQDGe+j7EBERkRapPi17ZgBnN3I+RERERFq9QAA2bw5NKyysZUVfoQvSHE6rHANEtjn07UVERKTFOmiwx1o7G9jbBHkRERERadW2bIGIYPwmLs4NrWNtLSv6Ct14O9Z/6Afz0LDZu0RERKTV0Jg9IiIiIk1kzRrXbWvAAMjJgfffr2PFQLkL9gR8daxQT+rCJSIiclQ6YsEeY8yNxphFxphFWVlZR2q3IiIiIq3Gpk1ucOa77waPB046CYYNq23NAHiPQMseTbsuIiJyVDpiNQBr7RPW2lHW2lEdOnQ4UrsVERERaTXWrXODM194IXi9EBUFV11Vy4rWBsfrCRz6wUzlfyIiInKU0e0eERERkSayejUMGeIGagYX7PnhD2tbM3D4rXIM6sYlIiJylKrP1OsvA/OA/saY7caYyY2fLREREZHWJzPTBXtMtQY3ffrUsqIN0KB7cp061fFEtdGfZ6bCSwZeUgBIRESktTvofJ7W2iubIiMiIiIirV1engv2xMdXpZnaelrZwAGm6qrF7t01d3jGmcGgUVBJRvDBYXQNExERkRZB3bhEREREmkh+vgv2eKrVwEpLa1vTctjVNOMJDfaIiIjIUeOgLXtERERE5MgoKqrZbctTa0zHENIFC1w3rJIMwANX1WOWLuMBDmM2LxEREWmx1LJHREREpAmUl7t/ycmh6VFR7q+1lqKyIrdQW6ucBnfD8kBAwR4REZGjkYI9IiIiIk0gNxeioyEhITQ9Otr93V2wm/gH4ynxlQRb5QTqGNCnnowHAiWHvr2IiIi0WAr2iIiIiDSBnByIjISYmND0inhOVlEWAJmFmYA5/PF2jAfK8g5vHyIiItIiKdgjIiIi0gRyciApCfx19KzKKqwW7DEesD7c2D2HyBMF/kIIlB/6PkRERKRFUrBHREREpAnk57tgT1lZ7c+7Fj0Vfz3gKwbjPfQDRiSCrzAYNBIREZGjiYI9IiIiIk3A5ztwy56Mgoyqv54I1yrHcxgTp0a2AV+RBmkWERE5CinYIyIiItIEAgE3Zo+1tT+fUeiCPZmFmeCNc61yTOShHzAqCfxFhz/2j4jIwdgArH8cFv8CSrKaOzciAhzG7SIRERERqS+/HzwHuM2WnpMOwLa8bRAR78basb5DD/h448BfQuVU7TGdqk3fLiICPXtCevqR2JMHuPlI7EjCUFoabNnS3LmQhlKwR0RERKQJBAIHDvas27MOgLXZa12wx/rBXwqeQwz2RMS57StM3A0vHcaAzyLS6qSn193asN4KNsF7Q8Bf7Ja9cXB54WHnTcKH0U9Hi6RuXCIiIiJNwNoDV5g35WwCYMOeDVUteyounsC1zGmIiHgIlB58PRGRw7HxCQhUGwjeX9R8eRGRSgr2iIiIiDQBr7fuwZkBckpyANiat9VNmw7BblhBE3c38IDBcX8OZ/p2EZGDSX8FbDkMuRdOeh2iOzR3jkQEBXukmeWV5DH6idHNnQ0REZFG5/W6rlwHElEx+5YxLuBzOHfII+KgdG9V4EhE5EgryYLiXdB9Igy6E7qdD2Oebe5ciQgas0fq4cgN3FabNsBCzE8ba//SVDRwm4jIgXk8UF5ee1euMn8ZAIlRiewr2UfABvB4o6Fs36Ef0BsHZXvAq2CPiDSS7HngjYERf3VdRwE6nlz3+qmpkLHfQPGdOsHuBrZcFJGDUsseOaiKgdsa49/zy1+AqYbFO5c02jH0r2n+NV5AUESkdfB6IS/P/d1fdlE2AEnRSUCwS5c3Bop2HPoBKwZ59hUffF0RkUNRsAliUiG6Y1WaOUB7gv0DPXWlichhU7BHmlXFNLOb921u5pyIiIg0roQEyM2FyFom18oocBc77WLbVS1746Bwy6EfMCLORePL9h76PkREDiR/I6Sc6ALLFbzRzZcfEamkYI80q/V71gOwad+mZs6JiIhI42rbFnJyag/2ZBZmApASl1K1HBEHxTtCp09vCG8cEICi7YeYYxGRg8jfAIn9wRvf3DkRkf0o2CPNaumupQAsz1juElJT3WAG+/9LTW3GXIqIiBy+5GQ3Zk9JSWh6IFAV7Gkf1x6oCPYkQOHW0Bm5GiIiAawPCtV6VkQaSeFWSOrvBiWrj06d6pcmIodNwR5pViuzVgIwb/s8l1BXn1315RURkRYuKQnKyqCgIDS9vLyqG1dKrGvZk1GQARGJUJgO2EM7YHQ71yoody0Eyg8j5yIidSjLhvhedT590zs38czSZ6oSdu923UsrWKvBmUUaiYI90mxs8ERvMOrGJSIirV5UlBucOScnNL2sDGatnwXAowsfBeDdDe9CbCc3Zo835tAO6IkEbyzsWwy+wsPIuYhIHQI+iEqu8+l/L/k3U96f0oQZEpEKCvZIs9lX4qaTTY51PxABG6i7GWdDm3cW74YvfwSzesHCKYc+3oGIiMgRFB8Pm/a7v+H31xy7bsOeDRDfE0qzwRdsChTw02BRbWHPAhf0ERE50qy/ztm3/MFzVpGvqClzJCJBCvZIs6mYgatLQhcAdubvrNm0Eyqbd1prWZ+9nkAgcOAdF26F9wbBro/dHdFNT4MvvxFegYiISMMkJMB337lxeipERUFeaV7IevtK9kFsF9eqJ2uuS/Tt1/+rPqJToHSPZuQSkUZiCOlqOjMVXjLwkpfv933fbLkSEQV7pKlVC+RU3MXsntQ9ZLkuW3K20P8f/Q/+w7HwZnecMc/ChdthwC9dZVdERKSZtWnjgj2F1XpVeTxQ6gttgVpUXgQxncATBTvfA1/RoU1nHBNsGbv24dB0a2HrG/DRifDJBMj4suH7FhHxeEPHBCupGGczwPLdyyuT9xYfPOC8NWcrWYVZRziDIkcvBXukaeR/D5+dDi9HwOtJsO5R1mWvAyAuMg4INlk/gK+3fh3yt1aF22D35zDuFeg+EeK6wuC7jsxrEBEROUwpKTVb9mzaBL6AL2S98kA5xKYCBra8CIFSSH+14QdMCA6cuuav8HafqvQFN8G8ayFvDexd5Lo+p3aqczbML76Aiy6CiRNhzpyGZ0NEWilPNJTUPsDy4l2LKx9XD/zUJe3/0uj4l45HLGsiRzsFe6TxFe2AD0dC/nrofxt0OhWW/ZbnVjwHwHvr3wPg+eXPH3A3s9a5wSvfXvd2SPqwx4eR9vc0t5A1B9oOgY4nVQ1oGRF/BF+MiIjIoRs4EFauhIjgEBfl5fDRRxYb7AYxpOMQIDiOXVx3d8fcVwhvtIP51zb8gAl9guNpWCio1oJ2ywsw/I8wMQsuyYZ+N0NGZs3tMzL42c/g3HNhyRJYtAjOPhvy8mquKiJHodhUKKi91f1XW76qfLw848DBnv1bN4rI4VOwRxrfoimQNBh+tBqGPwhjnofxb7gxeoASfwkA6/esP+Bu3lzzJgBvrXsrJH1l5kq25m51s3tlfAEpJ+L6D4uIiISXgQNdg5kPPnCte0pK4LnXXOQkJS6FlTevpE10GwBKItu5Fj2HI6577YMz95wEfa8Hb5R7fti0WidD+LDtFTz7LDz7LKxdC+vWwZNPuu5oItK6WQsbNrgAdXl5HSvF94K8dW5WLqjqOgrM3zG/8vHcbXMPeKxvd3xb+TizsJbAc3XlebD6z/DJSfDVebDrk5pjfoqIgj3SyPwlsPMDOPFpiEyEiFj3t8NJbjyCavaW1N2Xt6Kfb2q8a06eXZQNwPa87ZXrrMle4+4stD8eIuKO9CsRERGp2/Z34P3hrrvya21g0W1QWvN3rXdviI6GBx5wy6tWwbL17sKmIsiTGJUIQFbxPohse3j5iusGppbq3sBfQURC1XJEfM1JEqxl+oiXmTIFzjkHYmPdvwsuOLwsiUj4++Yb6N8fjj8ezjzTxYKLglX3/o/2Z+oXU91Cm2MgZ6VrgQgw0XXpygjGfiomYvls82cHPN6nmz6tfPzlli8rH2/N3Uq7P7ejzF/mEoq2wzvHuDHHOp0Osd1g3tUuAFSWC5uegzUPw+5PwR5kUheRVk7BHmlc2d+6JuRxPUKS/d64yibrXuMFao5XUN03W78B4NjUY0OW313/buU676x7x91V8FQbwLLajAAiIiIAE1+dyPMrDtx1uEE2/BsW3uImBJi4G86cB0U73ZTE+xkwwE21vmwZdOkCEyYACW5A07YxLrCTFJMEQEZhBsR1Oby8xXWruuNewRsDCb0PumlZmbvgu+kmN2V8hXj1jhZp1VaudN01f/Yz2LULtm6F11+HuDjIKMhg/d71TJs9za0c3wv2LKwxgPzLwYlwdxa4lvx7i/dSVFb3FOyvrqoak+yDDR9UPn584ePsK9lXVef/ZhJ0OQd+8BUMuRdG/AXOWQLbZsKsNBfkKUyHVQ+5mQhFjmIK9sgR9+n3n2KmGXJLcqE0G+LTajRD35G/A4C0pDR8v/cRHxmP3/opLi+udZ8Pff0QAB9+/2HI8osrX6xc55llz0BUW3eCDwQr2NVmBBAREdmau5X/rv0v//Pf/zkyO/QVw9JfwYS3Ie0KN/tj28Ew9jmI6VBj9d69XRAFICMj+DjetexpF9MOgOSYZCDYlSFp8H57MCHdJA4qrkfNoJMnNvSOdx03RvbtA68Xunat/+FEpOWbOhVuuw2uuw5iYiAyEsaPd889t/y5yvV25O2ApIHgL4Y9C6rq38BXtcR1Pvr+o1qPl1Ocw/o964mPdJHkl1a+BIC1loe+cXX+e7+4140Dum8JjHzEteL3RLhWifmbYPndcNZ8GP0POPZBmDCr1nOwyNFEwR454q5/53oAHpjzgDsRl+0DU60COTOVTa+7AZVTE1y3rA7x7mS8JWdLrfusPpo/wNLdS9lbtLdyZi6DYd2edexJGAzZ88BX4FasXiHOWwcrfg9zr4H5k2H1dCiuffYAERFp2ax1gwm//jq8/DJ8/rkLrDw458HKdVZkrDj8A2V8DknDIbFf6J3tOiYH8HqhR2hjV6KSXbAnJT4FgPZx7YFgsKfT6eCtti9PZGU3iXrxeF3wqTp/Edjap0quLjISfD7XEklEjh4ffQQ33hjaii8qygVf7v3i3sq0Z5Y944ZP8BfDghvdzV2fi/JkB88b3RK70TbatVqsPvxCdU8ueRKAwnLXFawsUMbinYtZsmsJAF0Tu7I6azXZu76C5BE1u2et+zsccyvE9wwOGxGnCVoawZtvwmWXua68F14Iv/sd7NzZ3LmSA6lXsMcYc7YxZp0xZqMx5reNnSlpueZum0t6bjpRniimz53OnpjesG9pjbuKm4N1zG5tugHQOaGzS8/ZXGOfJb4SSv2uZdCwjsMAKPWX8siCRyrXqegS9vzO7yHr66rjVa8QL7sLel8HY56BE56A1NNdpVlERFqVJUtg5EhYsACGDXNjTuTlwYbdO/nX4n8R5YkC4Jb3bqnc5vHH3Tg606bB9Okwf349x/v0F7uLi+q/cwfpQnz22S7oUyEQ64ItneLdDYqO8W7q4czCTOhwUuicAw1p1VOh02lUVvkiEt3sObs+rXVA1eqSkyEpyb2PInL0CARcsHd/zy9/nlJ/KZ7gOGD3fXEfARMFbYe7m6qfngzzrgFgVzAe88GPP2DqKVOB2uv5ALPTZwNuaIeKfX+w4QOufetaINilFfjf+Y+5m8jV6+8zU2Hbmy7oVDETr4ZxOKIqBuf+/nuYMQNeeglefRUuvtgFAWsoyYLV/wvzroWFt7luzvMnu3FcNZB2kzposMcY4wX+AZwDDAKuNMYMauyMSSNLTXXTgVT/l5pa/+3z1sH6f8Kq/4U1f3X/Vk/ntBmnAC4iDzD+5YugzQBYdmfVwG0XbGVD8KTRK7kXAN3bdAdg075N7G/RzkWAC/Qsv3k5x3Zy4/bM2z7P7a7/BVw2+DIAPs8PdhCeexWUF7jB2gC8cTDuZUjo5QaqNF5IPhai29f/NYuISIvwox/B00/D5MlugNE+feC88+A3X98AVP1GfbPtG277rbspcNll8Mtfwh13uO4Lw4e7n8Ya9v/9PPZS2PEFtXcXrr0L8aRJbqDjCrGdtwJuNi6AjnEu2LM9bzu06R+6ccdTAJiTPoeEPyXw3zX/Pfgb0mEcRAYHY7Z+6HEpLP+da+ET8MEF6bVuZoyrzN9zDxQWVqVXfywirc9JJ8ELL1QNyAyulV/FjVaP8WAwBAgwa90s6H2Nq2vvXQzb3sBnIT1Y1++d3Ju+7foCVXX3/X2/z03d/snVn/DYOY8Bbqr277K+A1wLfoDHNi3AFm6G3NUQ2G96sJ3vVV1rVGr6YRysheJiyM93sy22htjGO++4v7fc4sZtio93Ew0ceyykpMC8bfM447kz2Ja7zY1X9+Eo6HoejHoUhv8Bhv/Jda/rMK6OH1ZpLBH1WOd4YKO1dhOAMeYV4AJgdWNmTA4sYAOk56TTIb4DCVEJB9/gSMr6Br6dDOeudU01Az4w8OWOJZQGyon2RjOi8wjmbZ/Hmuw1ZP/ov6R8e5UbJG3AL6FgI6uC4xVUBHkqgj7r9qyrcbiKaP+oLqMAGN11NMsyllV24frjaX8kKTqJ11a9xudb5hC4/J94Ft0M7w2C5OFuJ4FSdycgsi1ExMCKqfDdNNc0/vKCWl9mwAbwB/xEeoN3D1JT3QAL1XXq5GYv2V9t6w5Igc9fDt79rXbmN143rlGbYw6+j7qOJ2HFWsve4r0kRCUQHRF98A1aEH/Az5JdSwjYACO7jCTCU5+fEWlp9hTt4Ztt3zCy80i6tmm8AVtmzoQdO9w03rGxrg6Ymem6Xw0aBN26gcfj7jJbC6Wlblaog92biI52le1AtXp+SXkZc9LnAHDHmDtYtHMRX6Z/yX8eT+BRXCsWz6F0bt8HLDfQ5RI46VXwRMEFm+HVumeFPOEEl8eCAjceRqd+2ymwhnaxbsyeim5c23K3uTel4wR3RzQiHtvlh5z74o94f+P7AEx8bSIndjuRuT+Zi6mrEp0yDoIBLiLiYdBdsPEpeH8YDP5dZbeL2tx7rxtU+txz4cEH3Xt6220weDBcdJEbzyc62nWR274d3noLfv5zOO64hr+Vddr6OuSshqT+EJUMeKA8H4q3u7+D7nRjdwSVlrr31hdsuOTxuM9XfHwt1xkBf7BbW8Ug1h7XOsDbus7d1QUC7iK0onue1+s+h4f0+ZcWJWADfJf5HVtytnBqz1NJjE6sdb1p0+CHP3TB8rPPdp+Ztd8XsXz3cgC+vf5b3l3/Lvd9eR+vrHqFiy54ClZOdd8lYH2ZC7MkRScRFxlHn3Z98Bova7LW1DhWQVlBZf3/xG4nVp4HP9zoxukc020Mz174LGc8fwbpuels7nIFvb+5AsY+D8kj4fxN8Fo8bHgcUs+ATqfAuWsperELk/8zgzNLXfA+MdH9juzb57r3duoEv/51tYzUVu+Gete9Z8+Gv/3N7bNLF3deLClx58haW780BmuhaJubCbLinI9x3Xkj27jrjYpWUYFy2P2ZmzkZqk6O1gIWUsa4VqC4GybgPgdlZVWvp6jIcsHM0/liyxcA9Ph7Dx4bMZFbo5LddU3FMB4zU6Ekg/IAfHz8u3y66VPOPeZcJvScQMT9f3QfuP1NvRvu/JnLp7Uuf95Y9zqq1z2Ld0PmV8FZJz1UXmNVbNPlh/Wapdlay5qsNeSW5jKyy0iivFWFVuYrI9IbWfdvbBirTy29K7Ct2vJ24IQGH+klA1eFhjYnPTSGl0rn12vzO/NO46GJnWDcSwfd79czHueknu/CKe+FpJtpNQvospxRvHpOJJw5tzItEIA/XXEPXc+6l9Qu0ZWf/XmrHuH+gttr7GP8a19yy70TuOKKqrR13y6n/19PhNdLQtbdd2YyyR/vC0nb2S6VLqfshpmh+/34jvM58ycTYOAvK9O2Z2yn+7+618jDx54xnHHltdD3xqrE4gweu/0RptxznKt8Gg9YyzfPP8O4z3/hKkfBF1fuKyPqj1EM+sdgJg2bxJ6iPTyx+AlGl7QD0kPeu+4R8FnSaPrt+gQ6jIWoNrD89/x25j/AA387+2/cPOpmrnvrOmYsn0GHXhdiNz0JC2+G3Z9AwMe6gkSMya/sxpWWlIbB8Oi+x8D+X8hre2/+6wAc3/X4yr9PLnmSovIi4iJiGdRhEAZXSd67/ESOm3g1y1/a5YI5mXMAw+kPfMQH8T8kqs9l7uTVcTwrtx/H0GOyaryXSfd7yNsvDN+/oCdrS2r+AEwfeQ2eP+cz9uTEykpSflYmP6hl3cDde/C06edOtAAzU/EXZeL1GrgytJvb/OkXcaK/lsr3wzX3+8b9D3LJmRvc9PbV1PZ5P9WXxhcRNe/g2n7U+B49+r87SSl9mysvKQyeJI374TjhdsgN3f6Oq/oCG2oec6rF7w+tQM595TXGvvcreGG/ftsTqfEdWNL7OP45/Emu+cXIygtBgMHTYoh5J3TQ7zdHpHHJ+TVf20BvJGv85UR63Em6zF9Gt6JObI/LoEtiF07oegLbcrexaNciRnjiWRIorGxGXB4op01ZIrlr82vkbfG0cYyc9BPo85PKtFJfKTEPxNTIw5uBCUzMjoJ/fhL6xIvUeN+fufc5Fu46j9t/nVz5vlnrKlz73x26+qFxvFA6l/q4t/Bk7r+wO4x9IfSJWs6h0+9ayLx1o5m532uu7TN1/r7RzHp2KeSEzvZTOiOK6ImrIbFPZeVVsFwAABufSURBVNryT+cw/D/nwauhH6Cxfebz6+kncNFFVWkffvk253xVc37nrLntSPk4dDrr3W07knpaZo0yWvHAKIZN+pUbNDdoX3YJHVJjKi8CK0y79kXyki/jnt9HYox7r/3WR4dHIzEY2se2p9RfSn5ZPuMDqczx1Kz41fY9+nD6VM4+eafrOlpNbe/lTflnkWam0WvUCURFuc97aSlcsdatmxCVgLWWwvJCTisZwOcxa2vsIwLAE8HIziMBN97ZmPy+zImvua7tB1y0G2KruvBMf+5efrP5jzXWze2WSJtL5kNSVcPeOe+sZnyNNeG0oXO54XdjufLKqrT0FWtot/piEi/4PNii0r1PF18cRXp66Bg2r75YwLZtCTzzTOh+j/tDW5YFcuHfVWldvPB5m+Ppf/W/3fS7xu36w/vvZvJtf+CMczty1lmuO8IL874gvyyfgSkDmX7mdFZnrWbwPwfzs8kXw9/g7bdh9GiIiIDN6eWM+SCKCwdcyD3j72Fv8V5u//B2bt7Rm9veudjdoaxWMY6OLKV04mR4q6e7yVCyGzAUdLiGx6fD11+74EP37jDjTIPnKstf/+rGxGjTBiIjNkK5rWzZ0yGuAwbDW1f+l4JzIWHYH12wJyqZKe+/y/tZLtAT7Y2m1F/K/O3zsS96MRdtrvqNAb78Em64ATZsSIG0q2DT0zD0Pjp0a8ecWZ8yIGsiLLkDsKzbNYD+aZk1yrPL4v589NKLXHbzKM4806V1bLuH3bvbh3xnAWLnnMizf7gDelxSmbZ2+1oGAP9Y8A9uPf5Wtudt58JXLqTtrq18H+fn3xNfpmdSTx5b+BiPLniU8THwP2c8yfUjrqewrJBJMyfxUNYqBlzwYNV+V0xlz7xHuf/tP3PK9T8jObuqXn/nLRu58Vd9mTy5WsYC5Vxzyss8+2SOu1gwEYDlu/deYsipE2DovdVfRq3fz2uyzmVGjVTY/lg3ul31DrSrim49ct8CPlp0PO+FVkNr3e+Eoj6cX3g3CcOuIy7Off7KyuD9x1/lB5Mv5fzzPZUftQ3z5jE2cDlcuDVkH8MfiCI7Kom7Tr6PpJgkHl3wKNkbdrI5fkfNDE+17NwJnTtXJW1em83f7vyMs396ecgYLQ//9gtOu+JUbq9W9fWX+/FeEVHjfHvG79rxaZQ7NxtMZff62s6Ls6dfz8lnd4OhUw/6/pzh68UnEbV3/dnfrdnn8tglHjcwb3W1/M7NfvrfnNz7HTilalZXAuU8eNXv+c2fBuONq3iDDPe9/iT3732lxvESHspj0bJE+ldrfLfw/TmMLr8GLghtqR4zzVC63/bH5fVnybZt8Hpofe/UAbO54d7xXHVVVdq2NZvpfk8fmBn6OkZOi2eJDW3NUle9ZfDUBFZT2w1Oi5lmQsrty76pzPjDP5l8/UUkJ7tA6RrfV/gu9TG041BGdB5Bckwy9315HzP/8gPuWpzAg7c9D3MmAh42Jo/Cbv2K3slu1r9ebXthjOHX2cfCgpvh+Mcrj74iYwUBG6Bn257ERrp6fZQ3ipSiKAoi4dpjr6Vf+35MGjqJP339J/qMfwK79B747HSI7gC+QmZ8dR3LC67lb9FXuhkIoztSWJrIW0su44lLXKCnwvrZn9KldBeJba/mxRddsLO8HH5cnMH+n8C5sScy6+Sf8uc1fwFPjAteWB+B42/HkxdaFhvbXkvZ2GcYOzZ0H7++9CV+8/O9dOiSXNnNbFd6Lr3O+AkloZeJnHbsYq771UiuvroqLXtfNh0eqTnQ9IdmHGddOQn63VyVuGchfHNFjc/f6kdPZ9A5V0HfaifGvUth0a1w/vdVaTNT+WppfyZklsETVdfo7ta5ZcIEuP56GDjQtVy6f95QlsSuCjnWlCUz2bPyXn6feAX0vx3i3SQBN6ztyX+8W+D7cwH4+7d/d3s9BvCXQbXgyvIXH2B42kqI6Riy79rOEVPpzX0/PAtG/7PyNVCSQV5xsN5SLdCzavYCBl8wBnJCW3wlTjUUEFqe3QpT2R5fs66XntKVHpe+6G7CVLyVu3Po2K1tjbrl6D8ksyiQU2MftZ0X502/lDHnjYMBPw9duXAbzOpRY/36qk+wp7YQVo2jGWNuBG4E6LH/yIPA14+lcdKk0F2dc2IvdoxJJLM0nxgflETAoCxIjUxidptcIgMQMBDth+7f72D9mmyO+SB0H5+dmMbp++23U+c+LL+uM8MLpruEko+h7FPu/D6FN5KzKQ0GGSP9MHRFJgvozPG597tE/xcEyudw7+s+9j0BbdtW7bddl+N5+7l4VsQX4rHg80D/bIjJXU/m5pFkZcRWXoyZ6FSeHnASF274DW3HXI7xF2MeK+G2BQP51W3nkDbghMr0NtPz+Ne68Vy24d6QdaNmfwOZadBtqyuGdQ/TftUj/HRLEr3X5zJ8N+yNgxWdIKsgHX7/U+CnVRnuC1P+NgB6POCWg61ZYgLH8dWSNIZGfULblGSMvxjfy1H0KIpgdfZq7v787spd9N7YiS+AcVshphwKo6DPXnhxUSJT7zkTugBRgB/uu6QveRvaccnxt4C9hUei4OKesChtAvSeDXFAHyAfHovvSeZxPbhw8MVgYbIXevSGO8+dwA09nqR3SjKe7H3Y5Bj+7M1my9o0Lr//JgjcxDUe6NIH9vbszHHLduG5xxXovPbwbdwqdnkvgiGzoCPQsRjSYXzqnURdsBS6LYW2QAA6Faew4rIUhqU85V5szizIe4cHVnXmu6Jd9NsDseWwvBN0L9jLk7eeysXX3RVSRn+/4Tpm/DyRMWOq3vbigkT+9dPxXHb93bQde2Xlun+e3pe7/tAfeneDNglw1h5MlOX9mQP54Z6bITIGouZB9Ld4S0by9SM3Mmj0WSHH+/YfPThhv8/7cef1gjNPqUoIlvNZmXF81KGo8hscWwbD13qJ6NGG3II8YnxQHAF99sFXH6YxYb/9Xvf7eBImPws9bnK16P92hpIM8ssjSSS06eyE70r4K9CxAKL8UOaFoRnQf8AUXp18Hl2GVnWXy8mN5/VhJ3D6hqdDvxsLx3PLZxfT//JplWW/9uz+bNs4snIGiAo39B7Nzz46n669j63cx6DJuZy9Op7vTaE7n0RC91wYXZjA+sH7KK+W58E78inuYdjJTv67tqoLxDlLolk5pJDyCD/+4Pgbx28t5l99x3PJurtoN25SZX7XP7KZkfdNBqp+OKOAm37chvY78jhuF+yLhdUdoKQ0n9k3nMyQX/w65DV/9kE/Ti+5HRKSAQP+L1i28CLihyaHVB4BftD5Jd7713hSe8dWXtQcG3M5WzNXk1mWQ0y5e82DsqBDZBs+6JCHNe4cmlAGScszWeqN4LhtU90OA1+C/YpPH03jB/uV/aROnYkYfBnfTOpXce0MwEOBY4jevJ6x28BYmNcDIiN2UezzEkvoL9ynj6fyo2v7hqR1atuR5345lnM3/CLkfUi9+0vSF6SxoV9b99qAiPJenLQ3keVx+XgtlHvduef2gf351ZRz6DnwxMp9JP4l351D199D27FXVO53zSO7GHb3lUBV1CGaWEZ3eIu574wgNqGqL/+G7OPp3SOS5OSq/Jb5AxyXG8/SpEKyi7MB8ATg2DUJeLslkV+Q675HkTAwC+Z+1IOx+72XPUYOYG/3frTrGqw0bfkPbH2Ka7cl8V67XAIG/AbalsDaNy+j609P4PLLQ8v+tVs7MrNjJgVlwUq6hb4bC8lNi2V9VDFRPvf+HLsbkr3xzOpeyLc7vq3cvuu2XAZ0i2ZtfCkeCwEPDMyEDz7owTmTQpvInNajEz8/tT2nzt9Dn72wKwHmd4Ovytpy3vWhg/wOSXQ/kLNve919RoJRsqSCTexY3o/NI5MqPzyleaXERxW4ViWeyMrz1CuneylO68Oc9gMJJLXDGkPXwizuGLyAhfH9KUrtDVHRmPJSfjZuMO8XzyXSDzE+yIqHY33Q//JNkNgXIhIq9zsgAp7q+wFR0yJIn5ZGPpH82LOboRf35ayP1sAUwyBgbjdo1/NjAAZcNIC1dKWcSGIis0n6jZe31r7FW2vfqnzNmzZ6+GhZF0YnV/1+mpcMd3U5BcZ9CUlA2lwohPWl/Til4K/8aXo5L78cSXS0m774s1vg9EmGa4CBjKZH5lbWPhfFjtEDuXjo5WAv50oPtO8DC3qPISEx+NnpDuRt4ydtv2D4+H5c/voGkkpLKYyEj/vAbWefxK2dZ5KaNqQyb/2+68rk8lFg3oZIoBewYQq39nuKAeOWghfoD/ggZWcGT/9iJBceG/raZj4LEz8ezfdEMpexGCzjyr5m3sAYlppj2Ne+LzYmFlNawuOTDL9evJy+ZUmV30/vdHd3ecoHU5jywZTK93LS+jZ8dkweZ71wVsjnak4JzHvrBsaedQNvHwOzzoS1809n6uszuKLgGuiUAsaQcUIqbyy7nv/bL+D031ey+fr305j/RDKByGgwHtp02sSzd66B/t9VrbhiKmX5e3j3/gWcGzsOIjzQZyv02srV25J4pUsuPo/7CMeXw0kZK912vkLAwHd/hNUPUpTVFjJWQFTwYmztw1zc4VWKCn/M7MkDMdWqzL8r68MHcd8TMO48FzDg/fAWdl1yHdOr3asDmDalH9d09dCx2rWOHd6L5ddEMfyi0PPMsKsTeaFPNrd9eFtl2oCiBAb5IlmdVPXb164I7h0zkC0njWBrt64EMGA8LMntxtfmVh75YWgeZuybyd7Faaxe2ImKL3PAb/m673guXv0b2p/8P5Xn21M3JjHPl0OhN1AZMDhhG6wsSGVozycgPgUyX4Ws10gsH86W2Xvpuc8Nykvu25D/LhftiufDlEL8wd+u9sUwYLNl9TGR7Igux1iXi1E7YURRGz5vl+fOaQbiyuGEnaspzulFbMEOdz5a+1dY9zCfP5rGafudmzt368PaIbEMOLVaejTc9TTQy1fVImHFVH5QPpvNu5NJSt9HjxzYkQTFXijp/iBfP3Ypeyd0AGsxxlCwx5Ll99Jh91L3nm36N2x5gj+t7cyisl10KoDIAGxpC8Ozs3h6/Nga1wop93zFjsV92TAsufK6oigvnvePGc+lG+4JWffK9xLZ3K2QfXHud9lYmPB97fWWe97uws6t6zlpK7QphWWpsDoFKsL7FeUWVwalb+ymf9TP2L3nUubtGUMxsYzwzGfWqr6c9fBKuMXQC5jfFZaVvIAp+gQeeh06AMnwow1f8eSlAzjjb0vhJkM0sCAV0rtn8eEx/Ti+XdV5ZszscTyzvAsnf7kFfm6IBBZ2gvn9kkjoksRl9/8UAj/lnggY2wsW9hoPx30D8UDvrVAMJ2ycx96+++ClndB7JyRCh+3w5skeMtr0ZnFsP/xJ7TABP08WnE/3W6/mlzeEft5vWTyeKeddSGra0Mr3eNhfVjB25AYY+EBoXdgXSdJ+deGflM+gf+A1lpl+7E3qhT86Dk9xIdP/NQuO3VIViF8xlYT1f+XEdh2Z++YIvJFVd0SH+P9C5ms38o3pGfzOuZuUk7a3hz17SMuBgmjIiYE9eaVsXfECPd6sGnsOA48NH8+UR3pCh3YwKAP67iR37wl8+8/3OaHDHLfbtsug7XL+8oeTueO+NtA91TVFOieb5PiOfHrCWEb8+v6QzxqTYOGyCJZNOZY9tCeZYu4cFkHJcYO49MXVxPpgTyx83gtWFX0Jp82BtDdcOfng0svj6Lm5MxPf3UWnQtiRCJ/1gt/knMyN3Z8KufaL3/0Urz7Xl8uTRkJsDPTdBr238cf1nZhnM0gqdZ/1PXFQvqacf81az02R7aBzRzg/G2Lgqydr1ls6tkmh2B9BLGUh6X/5oh155Xs4cTvE+uDbLrA3roBNvRNpvyOfgVmwOxF2JsBsj5cf77wXBp0cvOnzFbFlCxnf4WW+eW00EVEVrYsMk9cPIsE7l9xod31UGgHDMmDRxz0Ytd85KXLYCNLnbydt5i9C0gNXpuJ56dD7Ahp7kI6ExpgxwFRr7VnB5bsArLUP1rXNqFGj7KJFiw45U+HC73dN/crKXMuE6GgX/GlRLbisdTNTleW4JsrG6yrEUcm1vpB9xfv4w+w/0D+lP9cfdz1ej5eePSG99u78IpXS0mDLlubORcP4Aj7mbZvHkI5DSI5NPvgGIo2sqAh27arqguT1ui401QfzrY/dBe5uVMWMh42mohlUS1fH63h11atc8YZrGbbiphUM7TS03rs87TQ3bfGll7ouMked6l0CjMFMrXrqx8N+zPMXPc+yXcs47gnXIuaXJ/6SP5/xZ4Y9Pow12aFdPT7/n885tdeptR7GWjeGUEUr0oppomuslDXHTc9MABdq8bjHPa+sGtS1Pq/pCH/e/X5Yswa2bSPkrvCZZ7p6Z30VlBVw07s3sTV3Ky9MfIEeSTVvvB5MIODOPX6/O+fExbWwOu+RUlF3DpS5VvGeGIiIPfh2LZTq+VIfLbGe35oZYxZba0cddL16BHsigPXA6cAOYCFwlbV2VV3btJZgj4iIiBxAKw/2HI4hQ+Dhh+EHPzhKx0LZL9iTVZDJ0MeHcuOIG7n/tPsrVwvYAIFAgAiva2w+O302E2ZMIDYilmJfMb3a9mLT7TUnb2gWreXzLiIiLVp9gz0HrX5Ya33AFOAjYA3w2oECPSIiIiJHuz//GX77W9diIz8fcnJcq4lWrfpMZRWCjzvEd2D3HbtDAj3gZvWpCPQAnJx2MpOGTqLY596sd696FxEREWm4g7bsORRq2SMiInIUUPt/qQ+Pp2rqp3rYlb+LLg93ISk6iZzf1hzcstmoZY+IiISB+rbs0Zy5IiIicmhaSwd+Ba0aVyDQoMFfOlMxHHAu3BVGg8akpR18HRERkTChYI+IiIgc3VpL0EpEREQk6GgcMlBEREREREREpNVSsEdEREREREREpBVRsEdEREREREREpBVRsEdEREREREREpBVRsEdEREREREREpBVRsEdEREREREREpBVRsEdEREREREREpBVRsEdEREREREREpBVRsEdEREREREREpBVRsEdEREREREREpBVRsEdEREREREREpBVRsEdEREREREREpBVRsEdEREREREREpBUx1tojv1NjsoD0/ZJTgOwjfjBpCiq7lknl1nKp7FomlVvLpbJrmVRuLZfKrmVSubVcKruWqa5yS7PWdjjYxo0S7Kn1QMYsstaOapKDyRGlsmuZVG4tl8quZVK5tVwqu5ZJ5dZyqexaJpVby6Wya5kOt9zUjUtEREREREREpBVRsEdEREREREREpBVpymDPE014LDmyVHYtk8qt5VLZtUwqt5ZLZdcyqdxaLpVdy6Rya7lUdi3TYZVbk43ZIyIiIiIiIiIijU/duEREREREREREWpEmCfYYY842xqwzxmw0xvy2KY4pDWeM6W6M+cIYs8YYs8oYc3swvZ0x5hNjzIbg3+TmzqvUZIzxGmOWGmPeDS6r3FoAY0xbY8wbxpi1we/eGJVd+DPG/CJ4nvzOGPOyMSZG5RaejDFPG2MyjTHfVUurs6yMMXcF6yvrjDFnNU+uBeosu+nB8+UKY8x/jTFtqz2nsgsDtZVbtefuMMZYY0xKtTSVW5ioq+yMMbcFy2eVMeZ/q6Wr7MJAHefKY40x840xy4wxi4wxx1d7TuUWBg7l2ruhZdfowR5jjBf4B3AOMAi40hgzqLGPK4fEB/zKWjsQOBG4NVhWvwU+s9b2Az4LLkv4uR1YU21Z5dYy/B/wobV2ADAcV4YquzBmjOkK/AwYZa0dAniBK1C5hasZwNn7pdVaVsHfvCuAwcFt/hmsx0jzmEHNsvsEGGKtHQasB+4ClV2YmUHNcsMY0x04A9haLU3lFl5msF/ZGWNOBS4AhllrBwN/Caar7MLHDGp+5/4XmGatPRb4fXBZ5RZeGnTtfShl1xQte44HNlprN1lry4BXcCcMCTPW2l3W2iXBx/m4i86uuPJ6Nrjas8CFzZNDqYsxphvwI+A/1ZJVbmHOGNMGOBl4CsBaW2atzUFl1xJEALHGmAggDtiJyi0sWWtnA3v3S66rrC4AXrHWllprNwMbcfUYaQa1lZ219mNrrS+4OB/oFnyssgsTdXznAP4G/AaoPmCoyi2M1FF2NwMPWWtLg+tkBtNVdmGijnKzQJvg4yRcPQVUbmHjEK69G1x2TRHs6Qpsq7a8PZgmYcwY0xM4DvgW6GSt3QXuQwl0bL6cSR3+jqtABaqlqdzCX28gC3gm2AXvP8aYeFR2Yc1auwN3Z3MrsAvItdZ+jMqtJamrrFRnaVl+AnwQfKyyC2PGmPOBHdba5fs9pXILf8cA440x3xpjvjLGjA6mq+zC28+B6caYbbg6y13BdJVbGKrntXeDy64pgj2mljRNARbGjDEJwJvAz621ec2dHzkwY8y5QKa1dnFz50UaLAIYATxurT0OKERdf8JesO/0BUAvoAsQb4z5cfPmSo4Q1VlaCGPM3bgm8C9WJNWymsouDBhj4oC7cV1JajxdS5rKLbxEAMm4bia/Bl4zxhhUduHuZuAX1truwC8ItiJH5RZ2GnDt3eCya4pgz3age7XlblQ1I5MwY4yJxH3YXrTWzgwmZxhjOgef7wxk1rW9NItxwPnGmC24bpKnGWNeQOXWEmwHtltrvw0uv4EL/qjswtsPgM3W2ixrbTkwExiLyq0lqausVGdpAYwx1wDnApOstRUVXZVd+OqDC44vD9ZVugFLjDGpqNxagu3ATOsswLUiT0FlF+6uwdVPAF6nqruPyi2MNPDau8Fl1xTBnoVAP2NML2NMFG5Qobeb4LjSQMEo/VPAGmvtw9Weeht3wiD4d1ZT503qZq29y1rbzVrbE/f9+txa+2NUbmHPWrsb2GaM6R9MOh1Yjcou3G0FTjTGxAXPm6fj+lmr3FqOusrqbeAKY0y0MaYX0A9Y0Az5kzoYY84G7gTOt9YWVXtKZRemrLUrrbUdrbU9g3WV7cCI4G+gyi38vQWcBmCMOQaIArJR2YW7ncCE4OPTgA3Bxyq3MHEI194NLruII5vlmqy1PmPMFOAj3IwlT1trVzX2ceWQjAOuBlYaY5YF034HPIRrsjkZd5FzaTPlTxpG5dYy3Aa8GAyGbwKuwwXiVXZhylr7rTHmDWAJrhvJUuAJIAGVW9gxxrwMnAKkGGO2A/dRx/nRWrvKGPMaLujqA2611vqbJeNSV9ndBUQDn7h6MvOttTep7MJHbeVmrX2qtnVVbuGlju/c08DTxk3rXQZcE2xRp7ILE3WU2w3A/wUnkigBbgR958JMg669D6XsTFXrVxERERERERERaemaohuXiIiIiIiIiIg0EQV7RERERERERERaEQV7RERERERERERaEQV7RERERERERERaEQV7RERERERERERaEQV7RERERERERERaEQV7RERERERERERaEQV7RERERERERERakf8Hq33lwtgHYaMAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1896,12 +1971,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Index 10\n" + "Index 5\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1913,7 +1988,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1923,16 +1998,9 @@ }, "output_type": "display_data" }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Index 11\n" - ] - }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1942,9 +2010,17 @@ }, "output_type": "display_data" }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tal hits: []\n", + "gata hits: []\n" + ] + }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABI0AAACMCAYAAADx21mCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOydd3hUxdeA37slvZEECD10CL0pXSkqYAFBBRsWFLt8Vixogr13sSsWVAQVkaooRemdECCEXhIgCel9d8/3x2STbHYDiQQC/Obl2Se7y+zcuXNnzpw5c+aMISJoNBqNRqPRaDQajUaj0Wg0ZTHVdAE0Go1Go9FoNBqNRqPRaDRnH9popNFoNBqNRqPRaDQajUajcUMbjTQajUaj0Wg0Go1Go9FoNG5oo5FGo9FoNBqNRqPRaDQajcYNbTTSaDQajUaj0Wg0Go1Go9G4oY1GGo1Go9FoNBqNRqPRaDQaNyw1XYATER4eLpGRkTVdDI1Go9FoNBqNRqPRaDSa84b169eniEjtk6U7q41GkZGRrFu3rqaLodFoNBqNRqPRaDQajUZz3mAYxv7KpNPb0zQajUaj0Wg0Go1Go9FoNG5oo5FGo9FoNBqNRqPRaDQajcYNbTTSaDQajUaj0Wg0Go1Go9G4oY1GGo1Go9FoNBqNRqPRaDQaN7TRSKPRaDQajUaj0Wg0Go1G44Y2Gmk0Go1Go9FoNBqNRqPRaNzQRiONRqPRaDQajUaj0Wg0Go0b2mik0Wg0Go1Go9FoNBqNRqNxQxuNNBqNRqPRaDQajUaj0Wg0bmijkUaj0Wg0Go1Go9FoNBqNxg1tNNJoNBqNRqPRaDQajeYcJSM/gyJ7UU0XQ3Oeoo1GGo1Go9FoNBqNRqPRnKOEvBrCuNnjaroYmvMUS00XQKPRaDSnEYcNdn8O+cnQbCz4N6npEmk0Go1Go9FoqonswmwA0vLTargkmvMVbTTSaDSa8xV7Piy9CpKXg6MA4t+GkUfBZK3pkmk0Go1GozlbiIiAo0fdv69bF44cOfPl0VSJhNQEAPam7a3hkmjOV/T2NI3mbCAiAgzD/RURUdMl05zLxL0Eyf8qg5HJGwrTtcFIo9FoNBqNK54MRif6XnNWEZ8aD8C+9H01WxDNeYv2NNJozgb0YK2pbuz5sONtCGgKg5eBNQg2PFrTpdJoNBqNRqPRVCPbk7cDkFOUU8Ml0ZyvaE8jTc2iPWw0mtND4gIwLDBgIVhrKQ+jzi/VdKk0Gk0leGflO/y247eaLoZGo/lfoW7dqn2vOatYdXhVyfvcotwaLEnN0/r91rSf0r6mi3HeoY1GmppFe9go9GDtQl5RHoO+HoRDHDVdlHOX1DVQu5/yMDIVi3qTb82W6VxFG7c1Z5iH/niIEdNH1HQxNBrN2YrDDsfXQ3osiJx6fkeOqHzK5iWi4xmdIyw/sLzk/a7ju2qwJDXPzuM7iUuOq+linHdoo5GmZtHGEoUerF1YfmA5f+/7u8TdVvMfSFkBEYPAHFD6nUmL/P+ENm5rziBF9qKaLsL5gTb2as5X0uNgXntYdDEs7AmLLgKxn7nr6751ViEi5BTlEO4bDkB8SnwNl6jmsDlsJe/1wnP1omcQmprFaSxx4jSc/I8aSzSKZQeWAfDPgX/UF/8DCsrEPydiTDaqL8PMHRDes1oMRdNjp7N47+JqKNQpIAJ5R6DgeM2WQ/O/hyf5cxplz+ajm0ve/69vMzgltLFXcz5SmA5/XQRFWdAhGqIeh4ytYJjd054u3Un3rbOKpOwkAJqHNgdgR8qOmixOjRJ3rNTD6H+5Hk4H2mik0WjOCAnHEwh+JRi74+SrYT/E/qD+blV/q6SgnKMGpu9jvwcgOSe5ejK054Nv9dzzmF/GMPCbgdWS138iZRXM6wC/RcKv9eDvy5Rr/pniLPKIjDsWR+8velcucfY+2PQErLod9k8/s3VWU9hy4fA8ODwXirKrJ09PcuY0To5WHFxR8n5d4jr15gwbrs4LzqJ+q9FUG3Evg3c4XB4HrR6Eto/DsFjPaU+Xced871unW97aciHnINgLqiW7DYkbALAXe5st2rOoWvI9F1l1qDS20+pDq2uwJOcf2mikOXc4R40BHkleDkuHw5woWDYSUs5/wfbN5m/ILMh0mRB5wu6wsyttFybDxLL9yxCRqiko5+gK2KGsQwD8uefP6slQBCjjufRLBHxvwPceViNPQFJWUsn7yhj8qp30OPhrMIS0h0tXqMDe9lwwVe0+TomzaPvomyvfZOWhlexM3XnihAmfwty2cOxfKMqADY9A4XnupbXnG9XO19wNa+5VBkZbNXjqeJIzp3Fy9MfuP0ren0xeak6A9mTWnI8cmA6dXgKLP5i9wOIL3qGe054u485ZNCaeU9hyYPV4+DkM5rSBn8OVx9gp4lxgdRqPVh5aecp5nqss3lfqFb9k/5KaK8h5iDYana+IQwmi82k/5zlqDHBj+9uwbBQEtYXOL6sj0QMia7pUp52vN30NwLdbvj1huq3HtgLQKqwVAPvS97kr/1CxgnIOroCVDVro9LI6ZUxeyo3dSb6zn1RNJsxLmFfyfs3hNdVQsCqy/kFoehNc+DmEdoW6F8OABZ7Tnk+G5QqYsW2G+hs3o+JE6bGw8VHoP0vV1YVfwhU7wKd25S90rtXlkUWwfgL0/AKuSoCrdkLv78DiVw15ezA+nMbJ0dyEuSXvF+5eWCNl0JxniAOOLoWtL8K21yBtS02XSFNZ8pNh16cQ+zwkfKbG8nqXgslSmsZcwSEXFRl34NyR7TXB6ZC34oDFQ1TogEtWwKhj0P83sAaeWr7AlmOqPzuK9bsiRxEOx3k0/6sCZXXW+Qnza7Ak5x/aaHS6OdOKd34yrBgLvzaGP/rArMauE8dzmXPQGOBGzn7YOhkGL4YOz0LD4dDxefA5h+7hP5CRn8HBzIMAfLbhM+U9VAG/bv8VgCCvIAB+i6/isdNVMTCdJTgHNi+zF3MS5lQ9eJ8nObMjBY6vq/AnInLC5+BkWuy0kvdVfhanSlEmJP+r+oilTEBvi/+ZLcfppApu8Cm5KWQXqi1Xryx/peI8d34IkTdCeB+wBoBXsPpbjRw5AvHxkF1NO8BOmc3PQMfJUP9yMHurV8SlNV2qKuMM/m81WQFYsm/J/6zyf15zmra/iMDatfDMM3DHHfDmm7B/xxGY2wG2vQomKziKYPU4KEyrhhvRAKdvO9POD2Fue8jarTyKji0G79pgWE7+2xNxhrfcaoAjf0H+Mbh4LoR2UXpMnYuqJetDmcpTPcArAKPYw3x32u6qZXIebIE+lHmIrMJSz63k3GSOZR+rwRKdX2ij0fmELRfmd4HgtjB8F1z6L1y1C7xCarpk1cP54Gq+eyo0vAr8GpaugFfHSvhZzm87lLGhS0QXANYnra8w7YfrPgRg45GNALyz6p3TXLqa562VbwEQ7B0MwPxd86tmcPak7CWgVpadrs9lDJM2hw3TcyZqv35iz5PcolwW71uMt9kbgE/WfVL1mzsVcvaDXxNXg9GJOBdd5qugvM/cNhOAtuFtyS7MZl/aPs95Jv2hvLNOxVBUgfH1lylHiIqCRx+FKVPgmmsgNfW/X6ZasOcrA2nTW1zlqaWC1fezmG82fwOolWInJQcCaM4fTsOkvagIrr5aGYwuvhgefBCaNIH6e6+DhiOg3wxo+yhEPQGDl4JXrVO6nuY0k7Iatr8FQzdCh5jiZ/ekkndlg17/l63nZ3jLrQbY9x00vlYZbp1U0zZ7S7ER8fOrPqddnXYAHMk+i/We04QnT/3pcdNroCTnJ9ViNDIMY4hhGPGGYewyDOMJD/9vGIbxXvH/bzEMo2t1XPec4ExOYnZ/DnX6Q6sHwOwD1iD1txoQgY0b4YMP4KWX4J13YNEisNlO/ltNGbJ3q21pTnfUkw32Z9jyv2IF3H473HwzjB0LY8bAd99BYeGp5fvYoscAiEtWpxpMmD/BYzoRITVXzUB9LKrtOldQzlcy8zPZl7EPUKsiAG+veLtqmXhS9vYAu34p/TyyVOZ8tv4zAFLzUks8Gzzx4RplwCsoDtaYXpBeGpj3TGDyAns2GGWGqv8Ym+mspQrK+5OLngRUUHmAR/54xHOeYgeTd+nncnWWmZ9JVkHV4yjMnQuvvALLlimD0UsvwYwZEBZW5ayqF3sBYLh6oJ2j7cRpLDeK/wEsP7i8JoukOR2chkn7xx+rwzJ//hkGDYKOHWHEpYewZm2BjjGqfxgmNVH9H1isOqN4WtSEU9tpEP8OtLhDbSt2GsCD24AtSy2ouFEFj0S93fXMU5AC/o1L52XVNEYV2gtJyUvBZJi4Luo6Lqh/AQDxqfEV/iazIBNjssHdc+4u/fI8aBPOe/Y2e+Nl9gKKT1A7D7yozgZO2WhkGIYZ+BAYCkQB1xuGEVUu2VCgZfFrPPDRqV5X44HMHeDXSE204D8aJOpC8grY9qba977tNTJWv0ufHhksXy7cdBM88QTcdRfk5kJ6RTvf8o/BsX8gcSEcXQyZO8+9+EoxMe71ExNzankGtlSBfZ3eH/8xzszpICYGPv0U3n1XGQffew+mToVRo8DL67/nm1eUx7Ec5R7qFOLrkjwbHnan7UYQwn3D+fbqbwnwCsAudo5mn79u08v2LwOUkaxBYAMAdqTuqNiz7u673dvl3Xe7p12UAl5FsPIW5YVYfJLUURvcO+/ekqTDfxheYdkW71UBBa0mK5bi+Anzds6rMH21E9ACbHmQvgXctuicYp85W2L2VHKykeZjkF6gBK7ToFph0PTwnnDwF1V3LjjYm7aX4FeDCXolqMRAW1lefhn+7/8gNBSCgsDfHwJPPRzDqWMNAmtwBdsxa162VgVn4Pmlty7l/aHvA8Vx3TQnZcuRLbyz8p2qb++tCU7DBO2XX+DKK1W/dGIhp3iSWuZaJ9INRdRplTs/hPj3IP592PkRHN/o7nmoOb0UZaoFRqdnyi8R8KOX8jTa8Xbp6ZAjz62J/f8stbqo7fZup3qemrzafVxtQ6vjXwfDMGgZ1hIojQ/qiVHTRwHwyfpP2Ja87ZSuf1JOx1yqApzxQX8d/SszrlVxH3el7TrRTzxis0FyMiQmKk9qLfoU1eFpdAGwS0T2iEgh8CNQfhYyHPhGFKuAEMMw6lXDtTVlqTdUCSQpKvcfVRBID6RBVgK0vh9a3AUtxvPV8ntp2jqIO+80CAlRK1m+vnD55RAeXu732ftgYS9IXQO1OkHEIAjvpQa5woxTvMEzTEyMu1J3qoKu2a2Q+Dtk71WnKJwsltEZtPy//TZMmqQmgcHBEBICPj7qWZ8KzqM/u9Xrxpo71hDmG0ahvZD4FPdVEKcBpXej3gxvM5xu9boB5/f2DOfEf1K/SeydsBcDg8NZh8nIr6C/VLZdeodBo1Fw+HdY0BWWXQXAneXsbwlpCfy87WePl9p0dJP6e/cmfhz1IwBLDyyt9L2dMiYzNL9NnYZly1TK1pUnOTXsLCe/KP8/TWrnqbjw9GvcjyW3LMHL7EVWYZZnF/RW98HuLyD3oDJQj1DeevGF0Oy9ZiXJGrzVgOO5lT9RLTISDhyA/PwqF//0YhjQYjxseFTdr70AhpeuxNscNubtnMehjGKvRU9K7GlUZJ0kpCacML5Ckb2I7SnK869TRCc6RXQCVFwjzYn5fP3ndPqkEw/98RAt3mtBSm5KlfPILMjk8T8e58uNX549hidxQMZ2SFwAh+bAod/V68jfkJfkkrR3bxXPKCenzJeBLcHiA0mL3E8SvNfh2v4tBrxrhYLj0PxOpa80uwWaj4OgNipNZajqJNFeoBYacxMh72j1nHh4NnCq8RWb3gL7ZyhdsTx7voY9X4G9EOzlFwc0p4PMTOWNP3++8rqdNw8WLoQtW9TW0JPS/HY49JuaYxVln9zYV8l+FJ8aj4FB/cD6ADQKaoSBUeK1Wp47Z9/Jor2LSj63m9KOnEIPbay6OB1zKQ+ICBuS1OlxbWu3pW14WwDWHV5X6bnUihVqoXzmTOUUYbOpZHnV1MVEhO3J28krOjf77ClGUgOgAXCwzOdDwIWVSNMASKKKLP3kHVpf0Apv31LXWnPuLrL2rSY1+CZy8gOx2w38fO38vfFtene7gLYNlOIVl76b9dvjWXFsCZa6YQR4+ZFdlEu4TwiJO/cx07GqJE8TBp/WH8m4pikweIlrIba9RlFqHEd8bycxOQAvq1Bgi2dT/BxGDroFq8UHu8PO2tRt2NYdp2XLCOq2aI1z93h67K8U7Z5OXsTNJGfWJb/AhJ+vg6jguXhb8smvNYQt2wMwm4XIiGTi/lpAh8uucNkHu3BJKAcPOOg2MIogRyxgkGIbRtDWb7iAq7B0exWGbVYrEwB7vkb8mhC73R+73aBdqwxWPHINHYZcTljHYQCkbV+M7/rr8Apsg0nsas903EtcZv+Vj1av4cCBAOrVM7DZlOxatGgG9oLNXNJ1MADZRXkcSfyFHgg0uEKtcosdZjVh+55QCmtdROO+Y1yqctWs+bTr043GxZ/TdizBlLeHvIPLCW43kgNHwknLsNK+TQ4b5i6kRbco6pdNm3+QvP1/YWtwPcfSwsgvMBESZKON7/eY/OuT79+TLdv8CQ6ykVu4jbVxfzJqwK2YzF44xMGalDiK1qbQOqoxdSKbl5QrOSmDA+uW0WnIUGqXud4vc2uRnWOiU/8O+BXtwG7yJz3Ll5wtX9D/6guxltmqPOfPWhw/lkevvt5YyAXDICM3hIQ1L3G7YxCm5tdj6voWrLiRtbu7EbLwG8KbNC5pJ0kb/2Tj7Fl0H3EVdcqUYcVKSD6cSte+TbBalRLncBh4J35FUJshmKwhJOz1pWG9AjbFL6bQlsTA7leDYSKzKIetabtg6S46XzYYv6DgkvLeM9qf52I688EUCyIGIuDtrVzeW7dyEOa9C6sjFbvhx+bde8krWM7oQcOwWgzybAVsPL6DVbN607JZEFGt8zA5chDDymubVLyeoWFdiUg9ykW1O/HLgb+Z8OS/jIoy07ZTGH627dgNf77YrFYGOljrkLZjCV1867MU2PH9TBL6ZdGyTNtJ3zKdgj2z8Wt9HYdT65GaZqFF0zx2r/yH+s3CiCyTdt2fP7B03a+MGXYbft6+OMTB2tRtRBXuxqvQh/AOQ9i0NQCr1UFwyD5+//tHrr3sdrytasl2Q+oOtq3bTpPwAPp2HYxhGKTkpxN3ZC/W1bvocfVwrGXcsf5eXouEnQ56DG5PIAkY2MmgPZ98ajB6VC6RYTsxOXJwGL58v04ZY6LsPmQnLKdNUCTbM/fy+0sPMPCqa13ae/yGvZgLk2jaoyfhZb5f9fNvdBjcn4Zlvtu4NZANq8ZyX7eleGfuxpQZT5IN5uYABnzdZzLb0vfwatzXfP3XA/TeOQ9T5GiSUkPJLzCR67ubpOwkfExW6qYcgQI14B5LXErirFsIaXcth5Jrk5pmJapVDsHpP2HzbsyO4xeTmW3GahEahe4lwvYbaUE3sjcpnPwCE0EBdtoGTMfsE0Kmz0XExfvj4+2gVnARM2d507NfKD6mVEySj90UwNwl0dzdvD+1Z0dhbngZFGVTaLOy53gn8pfEYneoYcww4NDGpbRuJdRu3gbnAcQHVs0nbtFcug0fjrVMB419YRIhQTYaduhEaNRAAHat/o1f5n/FtRtmE+KnArFvPr6TzNh0GgWZaNypK86dWClxS3jpzVr0GRRBvQg7Pra9FJrr4W0/hGQl0KZbC7Yn+FNkM9Gq5XEu++F21knpMGjCxHthj9DdP5jmF/RyfZ4P3kj7i/vQqI9aDUzbvpj35jwAOVu5MqwLzTKz6B3egSVH17Nlzijyw8dyXLqRm2fGYhEyMoOpnXoJneZdiLmJiqGW54D2+9Szd1JgL+CqDzrwauDNmJtcjcU7EDAwDAeH18yhU896NCnTjybdMouBN1yMv18Q4+4w4eOjwrAsXgwWC9SpbSfAFovNCCQ13Y+ihO/ofWUPrGU0jZ8W/kbjesH07HgxAEfyUtlx8AB+cfvoesUVWMo8o18WzadOqBd9ugx07XNrivuctUyfWzuC3sav1J7TDUuza8EwcazATPd9Vg4+X0YwAx/Xepwe371Kky7dCWs3qKSO2TkFY+N34B/Jjl1+NGmYT/LuHVhsR6nX/sIS2Zy2Ywmy+zOoOwiHX2t27vGlbu1Cdh9aTlrWLi698BowzOTZCliXEscLS99nLftcyvBK2IP0s4bQqm9/zGbl8bHpeDw2h41giz/2vRuoX5CJCQPLQQdLP3iKqIsHuYxHxqGfKbQ2IbRFD7Zs86d2WBGNau2BpIUket3EoeQwimwGfr4OVm39gs5tmtEmsgcAh3KPkZaVQOu07fi3uRaLby127vGlQ9scVs5ZRf3IWgQ3bF1S3uPHstmz6i86D70cS5kHumnxBurU86Ze6yiMYqOCYcumaNc3eLccg29wGLHb/enULpuf5v9BWAj0iLoEDIPUggw2Hz3Esmm9GHRFY2qFWfGzxZNnaUlS3DoahCbSumsTTMVtNjs/jx9++4yRQ28kLEj1xK1pu/hgxY/8lP1XSZn2pu+l9uu1mWXcTY+hw1xkqDk7jpzErdTqMJzdB0LJzTPTunUqPb69mZ1SatAbN3scT3g/QdDRoVx4WQdMZlOxs44wf+Z++lyYScvW/hgmQQSs+bspOr6Dhl36sPdgENk5Ztq0yGXrnwto0S0K39D6JXkf3JVM+r5NtL14oMvzXDN3Kc07RhLWqLTXOba9TVjLrtAh2qX9LJ82jUZNUgkML41Ld/cV6Qy8tgdPWyOY+ISZ4GA4cMAgMf97+v1zJeYOEzE1vBwGLCB1xkAC7Tl4UWbvuQUcoWCE98JwFCgdcOuLZK57n42HetJxzNMuZfh9yV8E+BdyUfchmIqfZ9zRPViMZHpsWkCdzkPUvW1fjCVzPdm/P4it/jUcTfHH4YAmAWuomzkFLo8Fc52SfDcv+gdr7jbqtSptf3aHnS9//oihA4bTMLwRANvS9xBcuJ/w9KPU6jiCxGMhpGda6BiVzQPfRHMotIgg7xBsYsdkGHQuuI68re0ZMMiLAN88DLFjN/xIWLGUCwa2ILROqdvk2tht7E5cw6iBN2G1Wihy2FibEkeX3Fgsfm3xqX8BcfH+BPrbCTDtJ2XnOpr3HuwiI9bOW0bTdo1c9JYdf/5KUuwK2l9ymUs/Mo4u4OCRcPJDBlBks2AyCdlZzWmUYtDcMQxL58kweBnMac3Pa0bS6YJaNN3wJOYtk8BhIy0niNij/emwY4nLM9qybAuhodCgXYeSMfHQ2oVsmfc73a921S23rtxOoG8ejTp1KRnnDmycz/jZj7LF5ygCFImNFoGNuI9RtAv2p0nXbiVp03YsQRI+wmhwOfg3I363H43q57M5/h9yCw4yqMdIMExkF+Wx8fgOti1bztCLr6Bx7UgAtmfsZWvsLqyFKVx50XWYzUqGrk/dRtw/q7i09yU0rd8CgF1ZB9m8dSeSnciIAddjsVgotBexLnUbW/9ZQ//uvWjTpD0Au7MOEbt9N3mpe7hm8M1YrRZsDjtrU+PolBuL1aclQZGlcwU/DpMUt4aWfUuf587ly+k4qI/bgknS7kPsXfoj2V7dXb6fOTuEvHwLPXoH4eVIQrBwJKsJx9a/xFj7IMyRIzFCOwOwZnd36iz5hpB6jXAO0JnpuWyzJtNty0Jqd7ystB+lryR77iPY6l3NkWNqRXfF8XkIQkOTH2k7lhCSnoJhGNRN30jSnAmEdbqSnbuDKbIZ+NTbxucbPwegf52u7Mo6SGJeMtGv38n1jTrSpPsFLrqI7PoYo94Q8iyt2HvAh7BaNvYkLiU7bx+XXDAKDBO5tnw2pu4g7p/lXNJnKE3rNSt5ninxGdQuyKBl774u+X7waS0atQimRZsQ/GzbKTKFknioCL+sJXQd2B5LGSfIb2Z9Q7dOnWjXtFPJs0/Y603c4hb0HtKScP9ErI7j7Lb5kV2YjcWwEJi0B4cIFsNM4HFf/njrYbpcOsxF3pqOziO/yJ+CWpeSdMwLq0X48MPadOnWmDFjSue6IrD2l5lE1CkiJKLU32X7dgcPxnTn59mBLh7Xzz6UQL3mDbnmOu+SMfFg8h5u+qMnR8yl3t0Ww8xfPW4msiCUtKBrycn1QgT8vQs4vmkanYddgWEpDTGzbU0CvuY0mnTpjslU6vOzasZMOg8bgo9/aQzLHRv2YC06SmT3CzGbS9NmHDtK4mGh9/Wuc/FK4zxB57++gGuBz8t8vhl4v1yauUDfMp//ArpVkN94YB2wrnHjxuLGyJJNGiWvJ9u/IPffUyRHj9ilqNAhdptDjqcVCjG4vfo90cTj955eV905VOwL+okU5YrYC0U2TRKZhsQOaic9rWtk3NgC+eT9PHnntTzpcv8lQgwSfbEq0/sXqDxkGiKFmarsdeuKhPnLnrcj5dJWm+T9d4skId4mhw/aJS7WJvYRyLNES7hvllzcI0v6dsmSi5ovEZkZ5vJ7mYZEWx4ViULkPUQ+V699zzaWaJ4V6YLI/yHyIiJTkeThyGHqSV+WiR/Z4k+WXOi9QpWtXL4v171BZLAh8kEfkd9vF5lzh8h3XpI0rK68zES5NWqV3DVwp9zRfYPUe8ZXiEFWN1D3fPMIdc9T290s8mhTkV9vEfnzIZHvfWXZs31EtkS7Xc+lDHXrimyOFpmG7Bo9QnqwWvzIliDSJYBMj2mPTKkjl0cul4fuL5RlfxfKutVF8tO0QpGRyByGSm2OSiDp4kuONHuwuRjRyHcdVHm/b48Y0eXKACJh/rIy5gKReV3d651oleYqRL5C5Etk06AOIrOauKXdH91AZO+PIgUZIg67iMMmW9/uJy9ao0UiEbkPkRdUPvvfry9ybLlLHsc+Cvf4jGQaIll7S/tEcZ3ZrjbJw7wuvuRIEGniQ66ERlvFiEbiaqt7vmEkQjQe+5E8gKwc+YCM85oqN3faKGN7bJMxoQvkh27XiXwRIbIhRmT3jyLbPpJO0bWEGOSnKPXbcVciwc8hCU+1FYl7UyRzj0hBukjeMRn7TKR0f9JXdtVSaf9pjHS8G3kt6BGRJxCZ3VVk2TiRv8fIHdCr/GMAACAASURBVJOaSdcnvWVbuEq7IQLpfJfnZyTTkAUDb5TG5oNyxeBcuX1MtvTolK/S2vJc0t4SEyHEII9eovL9onNx/xyJ/EMfacw+CSBT/MmSpmMuFSMaebGfSru8kaozczRieQbJtqrve45Dmj3aSOR7i3s78blfxILI/aqNyJdI2oNBsv2xDiLrJoqkbBTJ3CuSGisj7vOWAWORLDVeyJedVf14evZrnususnNKpfrR2H5TZcnF0SJBiExAJBpJ7IF0eRx5cqC6VqEJGXYD8tOz3nJ/1HTpd4GSZ198lC+33r1Huj2OTBxc2kZGX4N8HoPsGHWldGG9+JuyJcIvXXzIkQeavSv3jc+XDetsknTYLgf322XRJ1/K5c2Wy8RHCmXlv0WyZaNN5s4ulPQrg2QUM6RD6wIZf3OOjL02Rzo32iZH324nEvuayPE4VT8zQlWfMyMyGJHJiDyNfHXbWBkyxH14KPzaIpKZ4FI/8W+0EPkp2K3OEqfUEUle5fL9k68FCNHInVeo+91UV8mILa+3EDk0xyVt3lfe8kath0SeQeSnxiJzBoj83FocnyMv9/5aGgRlyLVX5MiNV2dLZMN0IUblVfdRJPgJ1f5+e/JCke1vVep5Xvdsfen5VKAcDFJlW9AcaXNzhPRtuEFm/mSTlGS75Oc5JDvbIeNut8vv3Z4VaYfIY4g8j+R9jvg8i9wyHHGA5JuRITci3S74WB57zL0uK+pzmWPayfvcJwP5U7oY62U0P6hnZEXkSUS+UDJt1ZgeInM7utzb4a9VP/J7SpVBQDrdjfR6qL3ILw1c0h79GrFEI16TStMOGou0fLSJyA/e7n3O+0HVTvqrti4xSNybgUIMUmsiMvQGJUuIQda+0lZk/0z3eh+JzGCkBJEuQcXjxtLH+4okfOqWNusqf7mG6RJozZWe7TKkXkiOhD7jI0Y0sjFClffxwUp2EKNkR5fxSOv71OePHu4vsv4Rl3z3TUW6Po5MGlDa58aMQt685yKRlbd6LG8OvtKLf8WfTPEhV17v/H8ypNcx+WOBTZKP2SU9zS5z1q8VUzTS6KHSfJs+iFz/OiI3NRQHyGD+EAO7vM+9HvWWdS90Efm9tVsZ7N8aIll73Mt2ra8IyCh+EjNFMs77DTFHI9ZnkAJz8fO8GWFCY9V+GiPyCSKfIfIpsv2tpiKJC1zyfe0dqxCN3HS1+n1CKGJ6Fhn0gJfUfwhZH4Gk+RTXewwVjp8HbrlZ+vCP+JEtgWRIhHmPEIM0eBj5v8tKdZnBPT+RSZPK9YuC46X5Oikegz/p+6I0DEiVm67JlXtvzSkdj8r15cVPXyTy7/Un7vfFfW7mhKtlZ/QokfmPiaz7SOSPqypMK9OQ/NGN5Qtuk0uZL51ZL9c5+2coItcoWSDRyKbJnvWWN2o9IDLcS+SLS0Xm3iky5w5JeKO1yPQAl7S27xDfZ1T9JwWUjol1nvCstywf2EIG+Chdbe6sQpn/e6G8NmmXbH2sv8iqKSLxs0QWjxGZhqx/oYvIri9c8ljwqXomne9S19oWrj7/+gEi914iLzFRfMgVf7KkH0s86vRvThgk9tUTRPJTRexFSi+bWcfjM4p6NlCIRn5rra73Wm/VlwtGWOUupkioX6707pgp7Zpmy8TLXhJZenWlnuc/z/YW+bO/S9qMzwLFZBJJSXFtVvPmiXwQ/qxIN0QeKdbpvyqjh/YolnVPIVt7txW5zs9Nr0v9NETk+EZXOfOuZ71l59tNRJL+dPl+/0cBHuty1ctRIvume5RJH3KP+JNVoofWedZbiFb6nKD6rzOfruPVd/uD1eewZ73FiEbW1VPfPzVQ1bsRjVxwh/quwKzGhTrP+IoRjSxp4vqMiEEiHlHjRro3Yn4WaTgpSIxo5Nc2Ku17F5TqwuXnCjGDnhH5e4hre//WJB90ulfeHr1cvn3tsPzyebL88lmyfPrgZyI31ner948jx4u8ESCy+iGRPT+JJEyTv95+Ud4JiRZpisiDxfr/l0jBF1aRjB0u8qQivWX9oFZysfdyue+uAvn5R/Uaft+n0mFi6b2l+SD9b0WOXIUkEyaDWVgy9+tY7xvpOBF5+0KV9og/0vc2ZEVMJ5E937hdb9vgNtKZ9XLZgAKZMD5Hrh+ZJyHPeospGtlaPK/4v8tK6z1ygqr3+DD1+fPH+opsesot38nmSSK3Fs+jvm8k8o2/LH7sIpHVd7ukTfpa5WOdhKT6ILtqFY+ngx6RhQPGi7yOyLRQkRlRcuwLk1z4GHLfsNLncPflyGN39BFZNMCtDBsHdpJevuvlwXsKZNrUfPnqk3yJvm2WfNH7YYkZsFjenLBP3pl4WF67Z7dq27mJLnmsntxdWrcWN3qG/iszZrh+9/fyP4QYxP8p1eYbPqTqbHj96fL6K0WSeNguBQUOKShwSPymYx5l6In0lvLtb+3j3UQeuMJ9nneTB7uKiADrpDI2n8okOmEG0AtYWObzk8CT5dJ8Alxf5nM8UO9keXfr1s3jzZVnxAiRt4r17pwckaws9f5QxiHp/HHnEuF0+bTLJa8or1J5VkRGhkidOiKxsaXXERFZtmutEIMEvBQgr/zzitR5vY4Qg/yx6w+3PK69VuT110Xsdtfvo6NFevUSOXpUJD1dXSshofg/yj/4F+8R+dFPZM39qiHnHBb50Vfk57pu17PZRKKiRPz9RR54QOThh0WCg0+pGkRE5NZfbxVikFf/fVVEROq/WV8p5IfXnviHznuogPR0kYgIkZEjRQ4cEMnLE5k2zXPaAQNEvv1WJDe39Du7XWT9ehFfX5GrrhJZtkzk++9FAm4YJ8Qgk5dMFhGR55c+L8Qgt/56q2u5TlA2EVHC/UffUqVgRi33e7Pli8wIFUnbor4vyhHZ+JRK/6P/ifM/GbYC9bwzdolk7BTJiBfJTJBHHrFLZKTITz+JpKaKLF4s4nffRUIM8u3mb0VEpNm7zYQYZPHexZW7VuoGkdmtlAHIVtx3HHb59vMgIQZp8W4LeWHpC2KabJJLXkMc8zoXp3Gov8XKtNs9O+wq3/gPRIqy1aswUylwHtqwJ9avF2nYUGTrVtVXMjJEsrM9p91yZIsQg/i+4Ctvr3xbmrytjMcfLlgg/v4iQ4eKrFol8tdfIg3GvCDEIDf/crOIiHy/5XsxYgyxPmcVI8Yoad+BLwWKEWNIfEq8ukj5trP8ZpEffYpffqoeVo1TyqqIus+yimUNcuedIhMnqvpzPrqK6jIlRSQsTOT++1WdFxWJfPyxeBw8L71U5MsvVR8uS9++Ik88oeR1ZqbKp/CPoSI7PxJx2FSiE9SP3a7k5K5dIjt2iGzfrv4WFVVwg55kaHS0W7Jft/8qxCBdPu4iIiLfbv5WiEH6f9nfPU9bgcivDUViX1QLCwVpIkU58vYtE6V3z1xJTVWyLD294ro8Vf79t7Te8/LUdap6rZwcNZ6tWSOycqXIihXqb2FhFQuz5EqRH3xKn9mPfqX/V1znBbYCMU82i3myWdLz0kVEJPTVULE8Z5GkR+5yeT4pvoh3tFmMGEMKbaownT/uLObJZpm2ZZpLvtXFv/+qcaNNG5HHHlPt1M/Pc9r+/UWuuaZ0rM7LE4l4rr2YJpvktx2/iYjIiB9GCDHIOyvf8ZyJczJZ9lW3cvLPydChIj4+pT83mdSY6OzHIiKbk7aI9/PeEvBSQMl3wS8Hi9fzXrI+cb2sWKH0A1B/XfBUxxXVe7nvN29W9Qci3j52MU82i9fzXpKUlSQiIm3ebyPmyWZZsPU7kelBpW2nfJ8vznf2jtlixBjSYUoHEZGSz+0/bF/p+iooEGnRQr2mTxf5+2+RwYMr/XNFYZZIzkGRzN3KSJ25W3746ph06+aQ5GTVHrKyivuip2dc0XP2JKcqkFVVyrc6KfOMe37eU4hBZsbNlEJboZgnm4UY5Gj2UZefOBwiDRqIrF7tKp/K6m0nu15+Ub74v+gvxCAT5k+Q3p/3FmKQhxc8LF9+WdrOQMTbu4K8ll0jsu119d6WJ7LxSVf9pMy9jf99vBCDxCyOERGR4T8MF2KQbpftkEsuEUlLU30/J0dk/vzKVl4x5Z5zAVa5pdMG+ewzJXs3bxbZtEnJ4szMKuZdw/zwg3oWN92kjF5PPSVivUnJwSlr1IKXU/8yxZiEGGRz0mZ5bulzQgwS/HKwmCabZGacmhyP+FH91ogxJPTVUBERSUhNEPNks5hiTGKabCrRb8fPVs8s4EVl6Hpx2Yty75x7lRHpDbVw+NKyl0REZNxvaj5w96efip+fyLBhShZ89ZWIJ3+FKlGQLvJTLZHsfUr3d1IF/dYTRUVqbrR+vWs/KjsXLYvDIdKzp4jVquZT118v4uVV+eulp4vUri2yYIFqh9nZSrY1e6u1mCabZO7OuSIiMuS7IUIMEvJyiBCDNHu3mYS+GirEIBP/nOg58xW3iizsXVpHtlxlmHbWT5m+OOy7YW5Gy+fn3qGMagmfqb5cmCkys3al6zc9XemxO3dWri5dqCa9w25XfWXnTvXZOY+p1LWqWfeprNGoOranrQVaGobRFDgMjAFuKJdmNnC/YRg/orauZYhIlbemVcSvv8Lu3SoIYFGRipdqMsHVVzdg410bsTvsAJir4WjD2FioUweaN3eN9dKveXcCvQLJKsziib/UAXJWk5XBzQa75TFxItx/P3TuDL16qSDDqanwxhtqb2ydUi9dFdAwJsZ9/+fS4eA7Frq8UnpijD3P497m779XAb02boQGDZS73SMVHLpTFUa3H83UzVN5Y8UbLD+wnMSsRPwt/iVxaP4rX34JrVvDN9+UBnQcNcpz2tq14dgxsNtLn3tBgarfa69VJ/z4+6t9qfsiOvLUMtiZqmKiJKSqE4jG/54IV5fbq28YEB3ted/tpqeKT+spxu4hwIfZG0alqODkh34Dhw3CukP/2VB/aBVrpHzeXuBX3+Wr48fhww9VPIPWrcFqhf794fGiK4hZsZR1iesY3W40e9L2YGBwYYPyO0grIH0LBLZWburOEx9in+M670xuRgWYm7R4EgA7zA0wWtwFa+6BkA7gGwFBraHdUxA10TXfY8tUu212W+kpLr9EQEHF8T7K89xz6tjvli1PHqi7Q90OhPiEkJ6fzkMLHwLAZJj467NLGDRI9RFnW3sxuAW3zoH96SomSmJWIoJQL7AeBzIOsC15G5EhkWQVZuFv9adlaEv3C2bthoMzoP6V0PtrwATTfVRcitQ1ENajNK3Z3/33Z5i5c+H3310DqPpXUKxPP1Vy65VXStOMHQvLl8PTT6vT92rXVn0uJETJtDFjIDtbbWHavBn27VOnL3qXOeCLdg/C1heg7sUQ0LzMf7iH3jOZlJwsKytPiCcZ6gFnv3AGU9xydAuARznOgRkQ2AraTFAn2/zSFPKP8tzMVFau9yU01P0n1U2fPmrv/XvvqThDFovSJGw2mDBBxSQ7GX5+0L79KRYkPQ6OLIKQdtBzKuQfgb8vVX26TNwGL7MXIT4hpOWnkZiVSKB3IBn5GQiC34uvwRsfl6T1t+VjeykAi2Eh35aP1Wwl36Zkrb/19PSZO++Eiy5SderlpU6NnDzZPd26dbB/PyxY4KoHXNC8FbMTtnI48zAABzIPANA8tLl7JtVAbCwsWaLG9VdeUZ+fe06NA9u2qdOzfH1hR2ItBCiwlY5bzrqs5VOLj2eVxqkyVTXSZUSE+1HxhgF16zJ93JGSWB8mw0SQdxCZBZmk5qYSERBBWn4aAB2PLwRHgRonmo+HeR3d2g5Al3pdEIT9GUo270zdiSD0atSr0sWdOlX9XbdOyS+LBS64oIr3bA1QrzJMflUdIOEW57EqVFJOnS1c3+56Vh1axdN/P83UTVOxi50WIS2o4+8qmB0OSEmBRo1c+0tV4iV6W7wZ2HQgv+/8nXdXv1vy/Z1d7qb/zUrW/fabusbtt1eQSb8ZkHsYDs9XeltoN+j3iwqnUI6BkQP5dP2nrD68GigeCzIakrCqJQf2q7iPTi66qPL3Abg9Zy9gahWzOBtxOOC++5Qe8OCDEBCg6sYxeySvxM9ietx0GgY1ZH/GfiyGhfZ127PpyCa6ftq1JIZYxzod+efgPxzOKpahGUqGGobB8bzjFNgK2JO2B7vYCfUN5Xje8ZLDA5yn0HaO6My/B//l6b9Lt1Ne0vQSvo39ls1HNwOlQaKXfHQNI0eqMAz+/krmDxt2ihWRf0yFE/GtV3ow0ZYYpd+egr6Xm6v6Udu2rn0nIMBz+vnzIS4O/vgDuhfvnnvC7Xzzivn+exgwQOkZZa8RVbcVezLjScxKBNQJxwYGo9uP5pP1n7AnbU9J2kd7P+qecV6S0p9G7FexN53YsmF8NowqMx8zDL5oEk6920q/CvQK5MlwLwgbA5HXq7mJ2QcKkit9b3v2qMM8Gjd21UMrqssTjXP/Nc6syaTm5kuWwN9/l26FA7jlFg/622koQ1U5ZaORiNgMw7gfWAiYgS9FJM4wjLuL//9jYB4wDNgF5AK3VZTff6V5c/XyRHUYi5x06QJpaUrh6NxZdVy7Xb0+GPYBt8y6hSbBTdifsZ+XB71csp+xLN26qWBbW7aoTp2XpwKsBQWpAc+l7J6Kbi+EpD/gyvhSg5EzdpEHvvtOHa7UoIGaIEDl4xmeiL6N+wLqmPDZO2cD0Ci4kcd7BtwbfAWNfepUFZC57KTVZXJZLm1MjDoivk8fNZDHxsL69UqBcOZhsUD7CBVJdm/aXoASwZb2xAT4YmHlbtpRBEkLAAf4NVZGuoJkjwouhgHBbdXrNPP77+r+mzShJK6SyQQ9G6lJ8AdrPmDqpqmAOmHB11pJba3xNRD3Mhz8FZpcq9pe1ON4NRnNY2u+4vUVr1M/oD6J2Yl8M/I7iLy4kiUuIx3dqNysJTVVKeiVPdntw6EfcuOvN5b0z0d7PsEHr5pYv961rbWtqwSJU2nZm67aS5eILhzIOMAn6z5h6X4VDLpNeBvP7X3Pl6p99JoK5jJ1nXdYTY4SPoK2j4FhgZZ3u//+DDNunDI8TJmiHovZrAzwnk7G+v57ddR62Trz9VVG3pwc2LQJdu5U7fCZZ5Sx+qablGzz8oJdu9T/uT3++kOgdl848qdS6ts8quqn1b2cKeoF1iuZ2L78z8vM2jELUIHZ3ciKh+AoyrfXrPxAatVyT366aN++Gow+p0rCFKX8DVqsTvuxtwKkzOmQpTQJbkJqXiqJWYmE+YVhFzsBXgEEeQe5pPM2e+MQBxaTMhoFegeWGD38varfaJSYqIyZS5eWtm2r1fMcfsUKZZS32Vy/71q/I7MTfuFQ5iEAjmSpMaF5rQqUk1NU9D76SPXRVavUiXZDhyqD7f33u6YbXFiLSa/asTvs2Bw2zIaZQnshZpOZWr61+PlnpcOAmphUF999VxogNi8PGvqFk56fzvE8FXw9qzALETt1k2apoMvtn1E6jT1HvcrRILABAV4BZBZkklmQSeyxWAB6Nay80ei77+CBB5QuZCnWgCsykFcFmw2XmIYlnC5l/iw4CrtP4z6ACsTrPOq6VXgrt3Rmsxo3rroKXn8dunZV6tGOHdCjh1vyCvlq+FeEvx6OgYEgXNnqSg5ubkl+PixbpibT3t5qklwhfg3U6yQ4Zf6SfUu4bsZ1Sg84Oozu3dzH+1M9LOR8YcMG1a8efrh0wuvnBzf17ccr8eqgk3WJ6oTLcL9wHu75MGNnjUWK/5kME8NaDuOfg/+UGIadMrSuf12SspPYn7G/RHdvGdqS1YdXlxjnnUaMh3s9zL8H/y0pl7/Vn3t63MO3sd+q49cp1v/zA9m9NYSlC0plgJeXmoudEkEtlSFy7QNqYd/kA+2eVEHlA5r+92yD1NzoxhuVgTqs2N6Smgr167un/+YbtXjevXupMaRFi8pfz2TycGgt0KFOR+Yk/F4yzh3LOYYgPNb7MTYe2ciaw2sA+OKqLwj382BFP7oU6vRX+p2TE8xhI/LNLLt1Gf2n9gdg3fh1mFcOhx5TKjUH9kTHjmrR8dNP4Y47lLOBYShZVaHh6DTg51eBkTImxnXFyjCqZ6A6RarD0wgRmYcyDJX97uMy7wW4rzquVdP4+akV9fvvV8+wSxfV2BYtgrVrb+b2324vEXYTek6oMB/DgE6d1AvUKvzjjyurY9nO7/SecaEwTX3pV8bC5EE5BzUxW75cnYzlVxo7vFIr0CcjwCuA9nXas/XYVmr71SY5N5mJfSae/IcnITlZDf6VwdcXXn1Vvc/PV4pp8+bw77+u9wvQrthodChLCTqnwGsV5q7kVMjx9crrps7FMGABiA1+Cqiw/s8Ue/cqDyNLuR59UQulkdnFTkaBOo2raUgVBi2LPwzdqE7pWHa1Wj0RB/g3Iab/y7y+4nUSsxNpX7s9F1faYATU6aeMJ7s+VaceiUOdiuWwgXflXDTuvBO++AJGjFDtwGRSbaCitn19h+u54/c7SvrnLU2eYWqAu7G5RZgK4pecq1YtnEZG58RvxaEVrDi0AsBtolvCkb+h5b0uwetLqDtAvc4iYmKUEtKzJ/Ttq8amuDh1Okh58vJKlZXy+Psr42VZ2rdXRl0nItCunVJobrih1PBus4GfXwA0urra7uu/4GP2IZNMopdEU+RQM96o2lHuCUM6wfY3wHmUdbHR+MqfbEyZAo89VjrG5+ScFeP96ePo39D6/0pXVc0VW3LbhLdhw5ENJUYjgIaBDd3SGYaBV/GBBXk25UFbYjQ6DZ5Gixcr5br8AoUnpTk4WCnq5YkMUhr57jR1BLLzBK+mtf77ROFELFigVvb9/ZX88/dXBuDy+Fn9EFGTsuzCbCwmC4ZhYHfYyc8I4mCZY0qcxqNKU4Hx4sgROBrp+l29wHokHE8gNS8Vu8NOblEuzaxgiAM6Plc6AagAwzAI9AokuzCb8NfCsTmU1a5FaOVnQhs3wtdfV2DgOQUmTlQTujlz1DhssSivhTM5ATnTdKvfrcTDPsArgOzCbJ7s96THtCNHwqWXqsW8lStVO2vQQC2iVta7LcwvjKf7Pc2L/7wIwPtD3+fzN1W/bd68tO9WdiHpRDQKVvp1ni2PGdvUAR0+IRnsXWm45W+3V7DA+z/G8uVq/C8ocNXDWkdEYjFZsDlsJTs/Lml2CTd1vIm7595NbpGyVD8/4PkSo+Ou1F2ICMdylfd581rNScpO4uGFD3MwQwmsdrXbsfrwaval7wOU8QKga72uPNTzId5e9TagFvSdJ1FuPrqZ2q/VJiUvBdORgbRr5z42V8f8iJ5fwLF/Yf2jYEsHTODXELq8Dqb/PvWOjlYL4y+/rNbgnWvvb77pLtOWLFFes2VlUPl50Ym44Qa18PfXXzBoUOl+yhCH8q7fnbYbESE5R+nKjYMb8/WIr2n7oZrA3dr5Vs8ZmyzgKPTsvTDFBDe4D0L9gOGth9MwqKGas1lD1GmLDrs6Zbc080rdm9msFog++gguu0zptA6HcuCYP99DGzjTRvqz1Ou0WoxG/2s0aaI8O7Kz1dYob294/nml0Hw38juu//l6Xhr4EpYqCIaAADUJvuUW1cmd5OcrgeCCxR/sRWolzlIsDXzqFhsuXDtMXp7KoyrW5aoQfVE01864luzCbABu6nRTxYkr2enq1IHt2yEqqmqu8j4+6mW3q/osvwrcJLgJoNxdB349sMR4EBkSWfmLHFsGUgS9p6ktaI6q+vKfHgICICFBreqWXfUyi0+JJ5BTuRvXxcOs4kRYfJW3RzmPDz9gVJtR/LzjZz664qOq5WmYYPBSWHUb7PsOQrsr19Rj/8KIfZXK4sYb1aDYvz889JBqN1u3qlUuj5c0DKaOmMromaMZ12UcVpMPXl7uk8JQ31C8TF5kFmSy9dhWEo6rbYyj24/mrVXqJDiLYcEmNoa0GOLZg+5LQykNTqNRFVdBzjQmk3Inf+AByMpScqOi7VW9eqktwZ07V00BcWIYaiX4qqvUBKJ3b6VkzpypttTUND0b9WR2/OySCanJMFEvsJ57woYjYPPTsPkp6PSykgsmL6Y8MpWL7ribvXuVsczLS93vCy+c4Rs5UzjskL0bGo1UMvEktK+j3KLijsVhF6UcVrR9y9viTW5RbslWqgL76fM02rdPLVaUn/x5mvSPGAH33qu85tq0UTLXZoMGfuo+4lPiWZ+4nkJHISHeIfhYqmMW4orNBgcPqq2hZWW+JyOXYRj4WdXJMk6jkYjga/Vl+zYTvr7KwFGdxMWp8bigzE5u5xicmptKen46AL38fTCC27l6ZJ6A+oH1ScpOKjHogpokVhZlnK508kozbpzSB9u3VwYSf3/l8bxgQfVf62xiYp+JTFo8iezCbHwtviUe6J4ICFDj9qnwcK+HefGfF/G3+tMkpAnLl8Pll7tO/KvLIFjXvy5Hc47iY/Yh355P924mUv5Wi7ATJqh+V1SkvPPOpHfp2Up2ttqSXr7+LRYY3208U9ZOoVloM7Ylb+O5Ac9hGAYvDnyxJGTA7V1uLzH8bEjawPur38fmsBHiE4K3RY0tcxPmluTrHJed24GdRvoGQQ1cjEbXt78eb4s3JsOEQxyk5Kl0VgIIDjZKvCGrnTp91aua6dAB3n//xGlsNiWPOnf+79cJDFSGwLFjVZtv3Vot6q9Oag5DIPZoLIv2LkIQwv3CsZqttAlvw8M9H6Zv476YjArmRxGDYMVY5QBh9ldGn5FHwJZzwoWDWWNmlX5oeQ/EvwsNhwN+xb/PU/OVSuLtDf/3f+qlqRxnx4z3HCUgAJo1U6slTiF5TdQ1jO00lvsvuP/EP/bAG2+o1ZKoKKWA3HabEg5uWAPUlqf900vj6Yw8AqNzPVpo4QQ7gU6RIS3Ukap5tjyGtx5eJUNZRdx6q/J6KHu0ZVnF82TUr6+2x5S3FJtNZsyGmhEs3re4xB22SmVOXqH2wTvjGTiNAvfiajU3DGVMOENcWhqqRgAAIABJREFUcolaKS8/4SkshAcufACgZFX/ho7lQ479d94b9h6T+k06oaJYIT614eI5MOhvaD4O2j0Nw/dW+udms4p/NXWqimk2a5YaBE60Uj6y7Uh61O9B9EXRNGigBsC0NPd0zuMse33eqyS+TauwVjQLUV5IdQOUJffOrne67zG2AhaBgGal39WwJ1plMQzlAl23bsWK94QJ8NVXqo9lZSmFuapbWho2VK7sb70FTZsqxebff0/+uzPBPd3vAaB9bWXcGBBZgVeYyQyXrlCrXb9Fwl+D4LfmRBTOIDZWTRx//BE++0wZ7T1N5s8LsveoxQu/Mt5CJzCSFtqVdeLNVW9y15y7AFwMAGXxsfjgEEeJ0ciZ7nR4Gjm9eiuzdTs4WD3XSy9VK77Llys5dP9Y5Sa8+ehmLpqqAp3YxHaCnP47CQmqrzYot9OmIo+2QK9ABCGrIIusgiwEIcAawM6d1W8wAmXAL388tdPL9Xje8ZItaj38vFXsOyfOtuMcU8uNqxfP3w6o7YugYkdWxYgYGgrx8VW7l8pgGPDUU0ouDh+uvDY/quJayrnIyLYjS94/cMED1ZdxRIRHnSrUN5Sltywl7t44QBkn+/T5D7G4TnYtw+DRP9QWyZ6NegLwVL8nmTtXbeO+4Qa1WDxpktpxoFEGo+Rk3IwwhYVwXdR1AGxLVitDkbUiAbi5Y6kbckRABA0ClUA7lHWIiX+pnQtF9iKPW8RHtxsNqPhEnT7qhEMc+Fp8sZgsNApuRJhvGD0b9iwxODljbTmN+M0a+rNnz/m5vbCoSPWJU/W6a9lSeQbOnAnjxyudbfHvqh63HN3CyOmq/xfZSx/6m5e9ydVtT+Ax7lUL2jwEi4dCygq106AgBTZ4iH9UEZE3gFeo0rsOTIeU1RB3vq7MnT1oo1E1YzFZ+HrE1wR6ewgGcrLfWlQwtthYZTgZP14F6/JI1ETY9DSkbVYeGrYcOL7BLZmvrzKe7NpV5eJUigCvAGr5qCWW2zpXT6iq229XiteNN6pgo7m58NNPlf99VJSysv/1l+vglZOD23MJ9Kric8rZCxGXVnpV9EzRsaNShm+9Vd1nRobyFnnxRUq2je1L30dEQAR+1upbZq0fWJ/nBz5/aplYg1Rg6OD/b+/Og+Mqz3yPfx91a5e1WPKK5X3DNgYcB7NDDCZAjNl8SUwCTiCYJCQZcrMAwwzM1GQqDMkNIcyQKhch5uaSEAgkYSbksmaS4RabAyTBEwiEsHjBNsYWlixZkvXeP94+0pHULanV3erT0u9T5VL36Vb3W35bp895zvM87+HDarZ1xBE+Zff2232pxkBp4vGiOM9e8SyNNY1UVMCKFT6ttyXUPqOlxX+uAZo7mnGJ8qPastruL8Jt+7dRWVxJXXld/1TAOL5iKVyaVhY8p/B3ucuX+wPlE07wvYq+/OX0+lKELVjgD74vuCB1ZtNIO2WGP9lvavflnMGBaVKl4+Gke+Hc1+H4H8HqLXDa45SU+BPHO+6AH/7Q/11mdFITZR1NUD7Nl5sGBgiSBmWenV2d3QGkxurGpM+tiPuyqiBo1H6oHYfLSabRpEnw1lv9T3ha+68tAfjP7WOP+e+oK6+En/wEvnGdD5w5HC0dfqcSfD9m29at/oA+1fj6qi7zpbT72/d3ZwZXl1Xz0ktDf410vPiiv9izapUvnz72WP99Ab6MZE+rr++bVloKlY09CyIMEmDf8N/+hC8oN1kzf01a41qzxgf8mpt7tqVzUWowZWW+eew55/iA+Gi3sGFh9+2LFl80Iu958syTmVHrs9YOHOjfCzRbPrTdn3EHPXSObzye2bP9cfmll8K+fT4b4+EhtsQc7U491V/86XvBqaODXs3qN3xgQ/ft+op6Vs1axfc+8r3u+4Fgvz+5ajIXLPTBiYrEfiJmMRZPWOxfv6uDP+z6Q7/xvPu1d3nq8qe671+x7AoAjp/mA1BfPm8VTU1+4YDwxcbwvqFQBaWa772XnddraPClpDNn9pQDO1z3d0nS3kUDOfLrvjXFb8/3LT5+dhgc2Dr03y+Kw6m/hAVfhD//Gzx1qW9yn+IClGTHaD2MLWjjx8Pq1XDmmQPUw89YBzM+Co9/CB45ER4+Dp5Y1e9pZr5HyY9+1DsboO8VwEwEV+LPmHNGVl6vutp/8Wzf7ssFpkzxwYChMvPP/9zn/NXY5mZ/UHz77XB4g6+1LU6c0C+oXzDQS/XX+o7vR9O3V83t9F/8dgRrYM18yeRvfuODZhdf7LM3vvtdeq1m94mlA5QPjkFf/7r/XNxyi/+MNDX58rYgoyhQkujRctL0k7q3nbfwPH/jnXd6z/v+NogX9V5V74J34GKXMhOw0Fx9tV8FbcECv1/5yldyl8040sqLy6kpreleteXYaccO/kvxSt/8sqQ2x6OLINfp+7yFPwADBEmD5rlhR046MulLVxRX4HC0dvioRmdXJ865nGQanXyybyjdty/cQBliRx7p++O89BI8+iicf34Rcev9Amn1zEtDe7svsxpqBlsQvGpub2Z/+34Aakpr+KPvJc0ll8C2bTA/S8N92feb5c47/YnGxo10X/G/4/k7WHf/OiDRI8Hi/jMEPZ+d24uSLSjP3Jd9/4y/vOf7Rq2cvTKtcV15Jdx/v79yfuCAz5bM1UW1scDMGF/uI/7plAkOqu/3aopjqq6uLCzskuy9nOPIP/gA5ltNb2EYNWV+ybSSEr+i7y23wA03+O9B8ceeJSW+n19wIa652WeBl8RKqC3134/nL+ydhfLIpY/wmeU9C4L0LeddNGFRd5C4rNg/dsqMUygqKuquHghMqJiQcnwnz/CNlIP934kzjufSS30j5F27fD+blha/fyh0RUW+dPo//zP7Wc7J/t/DweMhMYOFV8MFO2HNX+DCPXDqv6c5kBjM+jic8aRfGOq4Tcn7iErWKGhUqMxg+a1wxlMwZZVfeejDzyZ96iWX+AO2t9/2B0mtrX7Zxmz54QU/5LUvvDb0FbmGYM4ceOYZf7XykUdgx470fv/66/2V4xUr/JKfCxb4bJQgGyr40rrs6FRrsybhHLS/B5XT0xvMCJk1y/fl+MIXfIbZ2rX+fnGsuDvocfqsJEuHj2EnnQQ33+xXAxs/3pc2/vjHPcGh4OAlKKsIBxBWzkpxshIrhZIaaIpAg54cmjvX/9/ddZcvpc3GioxRsXbR2u7bSZtgS49Ymc82Ch+sDRAkDTeFLkocgqRqol9R4q8qt3W20eW6fNAIl9VsycCCBT5L8R/+oeeEp6XFNzZOR5BNE+w7ghOVbCsqSi9QW1/ur+AH5Wngr+q/9Zb/273tNl+lEywskak33/T9fWoTcdR588DwO4l9B/d1N69tdQYd70OiX9VgAfYiK6KxurE7UyndQMVRR/llp6+6yq/idcYZPgtKhu/py5/m4Y8/nHrl3BwqLvaBv1yIF8UZX+YDYuuOWJebNxlFzHzp+qZNfiXHW2/1AZkNicSi4PhpsH3isYf55x01yTfkueDwCzAzZtTM6C5rDTKXgqzwwEBN8Y+a7F/vz3v+3P3cb3zDZ0ItWgTr1vljws+N3IKtOXX22T6TPpwkEM6qz0SQHVxT6gOpp806bXgvVBSD8ik9LT8k0hQ0KnR1R/pu/EffDLXJ113+2Md8ts4HPuBLSa65xu8gs6WiuCJlI9NMzZ/vAz/prjxUUuKXRf7mN/3V2GXLfN+Jwyf4TKOdLf4KUnB/SA7u9ldES0NXMiLW4Liiwmd9/PSnvjStIZExevRkX3SfdOnwMe6qq3xG2re+Bd/5ji9RWb1gNdATXAxKlIJeRjDIMs91H4BtD/rGfIFDWayBkJwKsidLY6XEigaodxSonAmtW9P6fAcNkYNGposnLk76vOCEoK2zrXvltHhRPCdzYua/L26/3Z/kPPaYz0RMthrZQC5cdCEAZ809q9fPbKuq8u3UhtqzYkKl/94Kl6dNqJjArl2+5NTMB6JOz8J1ha4u39vk7LN7SlU6O5MHYFtKJ8P+V+HQ0GvkPjLvI923l05amvb4brjBrww5dao/Ybz55tGTKZkzKXoMAcyrn8cZc7OTaZ6u6dN9f7xcWT3fHwvk6u94tDn9dF+q+8orcN11Puj+z36xO2476zZuOu2mQYP+q+b4qomg5OmYw44BevcXDAJAQbBixWErgFAGeBLB6zUdbKK6tJpYUYyqKp81vWGDX4jDudGRaQTwmc/4nl9XXukTBg4e9BfUs2HNAl8WHPQzPX22LkiPBQoajQGxmM/WOeYYv8z1nXf6tMXRLhbzO83/+i+fHnv00T2lAsFVzrRKB9r3+f474SvqBdLg+IplV1BbVjusXltjwWGH+eDRFVf4K+Oz63x5WlACkezq1YKGAXLSp3wYXrvTLysaUK11wQiuiAYHpjKAklooroG9fc7cOlN3Rw+CB9v2b6M8Xp5ylZWg51xbZ1t3f4vSIazQNlxBqcLPfuZXZLrtNt+7Kx1ByfNf9/qm/rm6oLJwYfKeh6kWAphc5U/ww+Vp42PTaGvzWQHBwhHZKGXYt89//65Y0dNbo6qK7h4kYQfHHQ5NW3zG2hCFMz6Hm3V2yinwxBOweTN89rOjK1MyJ/ou+JBq2whbscLPY6760ASfNV1wG7rVq32p62uv+aqGYHWqufVzuebEawb9/b7H6cHx2AcP62meeMREv0rQSTN8Vniwfxss83BenV8uPgh6gN83/cu/+N5rL7zgW4OMBrNn++b8Dzzg235UVfl+btkQlKMF33PBHMnopqDRGDF5sm8MvXmz79vw9NP5HlF+BPXOO5p9vdukykkDPb23rg7fu6QAT/4vX3Y5e69JskyYJBWs4BH0tQmf+AVZWymXEwWY/Uno2AuPnQzvvwz7/wJPpNd7Q/InOADKVT+aUad2Kbx8C3QM7cwtOOAHOHpK6qWHqkt98+Zw0CgXy9cHzHxJxa9/7U8i7r03/SXTg33Fm01vAnT3e8m2CRN8ltFzz/Xenqr8wCVSaf712X/l1qdvBaD5vWrKy315VpCxlI2G7fv2+d5QfVd/DcoNw8obVvgGprt+A12JiNcgkavgMzNQ/xIZG447Dn75y97bshlAWj1/NTNqZnSXqMvQxOM+k6/vKsZDEVykC/ahwT4//L0RPGdm7Uyg51gtXP6cTNAD7eTpuSkbjpq/+zufLDBzpr84euut2cmqDL7ngsBeLhankOhR0GgMMfONpZcsGcUr+QzCzCguKqb9UDsxi6VXg+86E1lGymMf7YLyl3dafOPNYMUngOevfB534yCfgbIGWHw97H8N/uNw+Pe5sG9LzsYr2WVmtFzXwg/O/UG+h1IYZq2Hnb+G7b/0gaPOA7A59fLb4WDc0ompy4uCfgmtna0jEjQKrFjhr46ffXb6GSjBvmJv296c9F4KW7TIl9WGT5IPpEjwCi6UbNm9hZd2vwTA9l0HiMV6N/JNufhGGoJMo6lT+z8WNOSeW+dP+o6fcxaMPxqe+xy07/Wfn46BL3AEC1rMGz8v88HK0PRdJTTVthG2Zo1fIeqSS/xnv6UF7rsve6/fWNPIG1e/kZd+TWNVsA/t6OroLmUGOGJST9AoOEYLgnnb9m8DejKOUgn6JA10sWK0ufBCn/X1xhs+kzYbH+Vgjg50Hkjv4rsUtDEaOpCx7IRGX2+QdrqxxcAdAkJ73FG0lLr0Fu6/MbFyYvovsPhvYenXoajE98JadG0WRye5VlFSoX5GQzXjIv85/3/r4LfnwiPHweubUj49nMo+UF+5YLWits42WhP9wXIdiMlUY03P+t8fnPrBAZ6ZuU99ymdF3XefP2FuboYLLkj+3GT7sCp8T6lkwZ1MNDVBTU3/pbehp6w3KJWeUTsDlvw9tO6Eh5bAM5fBQ0f0/8WQ4lgxMYtxzvxzsjtwSW2Iq5mNtIYGuOgin220aJEvO7wsjfVNJHrCbRSC43WA2rL+q5MGmUa7W/yqigNmgNMTLEpWKitDN72mZ0GgIa0wK6OCznRlzDll5inAMFa1KSqGQ+09SwPDqFtKXXqED1aGdZXRDA7/Eny0FT7aBkf8fRZHJxIhsTI4/kcQK4edT/iVA8tTX/ENl3uGs/j6StbTKOpBo3hRvPt2uAdHLnz84343c9llcOKJfoWyzZuTPzfZFfjyrklUV2c/83jfPp+EEl61JxCsuhOUk5TFy2DqR2DqWdCxH966D9qbBn2Pzhs6ufYkBeIFvv1tv3rsjh3wu9+lv3CKRE/Quy5ZX8Fp46Z13w4uLDjcgCunBVZMW4G70WV1teexqDjWc0UgaNkgo5+CRjLmBKntwc8hi1VA+x4Y5EqGjA7BlajZtRk2+LMiv6yoyGg29cOw8jGYfAY0roUzUy9pFPQMg4EbRQcBotaOnvK0yuLonxEGV8SDpti5UlUFGzdCeblv4Lpnj+9bkUz4/zxQfmgSU6YkD+5koqkJxo1L3pooKCfZ07qHkliikZIZnPgTWHg11C2D+Z/XcmYyZA0NvrfXVVfBJz4BTz6Z7xFJpoIA0Lz63iWo7kbH2//z7aS/E6ygJiMjuKjTd45k9IoP/hSR0SXop5F2k9vyydDVBgf3DHgVXUaH4GR2bv3gV69EBJhwHKx8eNCnhcv+gvKCZILmmi0dLd1Bo6rSLDTdybFZtbN44Z0XBsyiypZ163wZ2D/9E0ybBps2JX/etOpp/baVHZpIfX0aK6ZNntx7xSwzn1LUp0xp377UvZHC4+i14o4VwZH/7P+JpKm62mccyegwp24OW3ZvGVL20IL6Bbyy5xWWTFwyAiOTwPSa6WzZvWVEvuckGpQyIWNOEBVPu4lmUTHEx0Hr9hyMSqImOKHRqikiuTNQY+sgq6i5vbk7aBRc3YyyYJ8xUBZVNq1dC7//ve/rMiHFgmLhHhSBkkP1VFSk0Rh1iMuu79sHFRXJy96mjJvSfVurE4pIMkFvuKEs5R7sR7Ts+8gKLviM1Pec5J+CRjLmVJVU4W501Jb3b6o3qLLJsOdZcKFLs0NcZloKS3DiF/TgEJGR1XTQ97a56/d3cfH9FwOwszlJ4CJiplT5wEiykrB8mTrOd7sui5d1l/1Zax2VldnvabRrF9TW+hXU+gr+b0ABeRFJbmHDQmBoPexm1sz0PwfIWpXsqy+v7/VTRj8FjUTSUdEI7zwKnft7tqnH0agUNEpcMU118iLZtnzq8kH7E+0/6PezbZ1t3QGkAx0p1pSPkFNnnUqRFUVq9b1gLPGieHeT2b17Y1RXJ1/lLBMtLX71tJKS/o+FM42SZT+JiHz+mM/jbhxaX7PptX4/oiD0yFp/1HoW1C8Y3kIxUpDU00gkHXVHwWsbwUJH2W07oUpfVqPRUA9aRCSJAXrgPHfFc4P+el15Xb9t4eWYo2rtorUcuiF6K2qWxkppbu/JjN27109HtoNGhw75oFGy1w1nGoVvi4gMR5BF2VDRkOeRjC0rZ63k5c+/nO9hyAhSioRIOiad6n/+8R+hs9X/e+aKvA5JRCSShtgDJ5W6sv5Bo6qS6DfCjqoJlT0NjxoqGti3D+rqkpeRJTVp0pC2HTqUOhAVXuo6nHUkIjIcFx9xMe5Gp4wXkRxTppFIOiac6FdQe/l/QWczHNwNOx/P96hEREad+or+vRLGlYwb8ipe0tvkyslsfX9r9+1Dh6A+nXYUQ/z/7ewcWiBKmUYiIiKFQUEjkXSU1EDtkfDec/Dq7YmNStgTEcm2hvL+5QbjSsdlnME0VoXLNyZWTaSjCyoHbis1LF1dQyt5U6aRiIhIYdDZrki6Fv8txEJH2ommoiIikj0Nlf2DRjWlNXkYyegQLk+bUDGBrq40StPSYOYDRykfx5eRjCuJfn8qERERUdBIJH3TzoX6D0JRGcQqYN5V+R6RiEj0DLEHTirJGpvWlCloNFyTqnr+7ydWTuTQISjKwVFgPO5L1FIJ+lKpB4mIiEhhUHmaSLrM4NSH4JXvQmk9zLks3yMSEYmeDHsMxYv6H6LUltVm9JpjWbjcLwgaxXNwFFhU5Jthp1IWL2N/+/7sv7GIiIjkhDKNRIYjXg6Lr4G5nwbTn5GIyEioK++/opoMTfj/rq6sDjNwLvvvE4tBa2vq116zYA315el04BYREZF80tmuiIiIRFLQ/6YsXgbAnLo5GZe9jVV1ZaGgUXndoBlBw1VcDHv3Qnt78sfvWHMH737t3ey/sYiIiOSEgkYiIiISSePLxwNwQuMJAEyrnubL3pzr/S/DUrixIFzaV1dWRyw2cMPq4Ro/HpqaUgeNREREpLBkFDQys/Fm9qiZvZr4mTRv3MzuNLNdZvZSJu8nIiIiY0fQ+Lqtsw2AyuIcrBE/RvQqT8thplFDA7z/fm4CUiIiIjLyMs00uhZ43Dk3D3g8cT+ZTcCZGb6XiIiIjCHVJdUAHOg4AEBliYJGw9WrPK3MB42am7P/PjU10NKSm35JIiIiMvIyDRqdC9yVuH0XcF6yJznnfgu8l+F7iYiIyBgSBImC1baKi4rzOZyC1jfTKB6HPXuSPHHyZL9KqFnPNjO/fQhqa33QSEREREaHTINGk5xzOwASPydmPiQRERERGFcyDoCmtiYALBzIkLTUlNZ0364tq6W21jes7leitnNn8hdItb3v+9T4nkbx+DAHKiIiIpEy6Fe6mT0GJLu8dH32hwNmtgHYADB9+vRcvIWIiIgUgHGlPmgUZBrJ8MWKYt23S2Il1NX53kPt7VBenr33qa2FbdugrCx7rykiIiL5M2jQyDl3eqrHzGynmU1xzu0wsynArkwH5JzbCGwEWL58uSriRURExqjqUt/TqK2zDUNZRtlUXw/bt0NnZ3Zft6YGOjp8FtOECdl9bRERERl5mZanPQisT9xeD/wiw9cTERERAXpWT4OeAJJkR12d7z2U7VXOamt9ydvrr2f3dUVERCQ/Mg0a3QSsMrNXgVWJ+5jZVDN7KHiSmf0YeApYYGZbzezyDN9XRERERrlwHx4FjbJr3Dhobc3+Kmd1dXDwIGze3LOtoyO77yEiIiIjJ6M2hc65PcBpSbZvB84O3V+XyfuIiIjI2FNZXNl9O7xkvGSuuhp274aiTC8f9lFR4XskPfkkXHKJf5/WVijWwnciIiIFKcuHCiIiIiLZUVnSEzQaXz4+jyMZfaqrYceO7DbBDkydCg89BKWl/n4sNvDzRUREJLoUNBIREZFICmcaVZepPC2bqquhuTlJ6dikScl/IdX2JGbP9iuz/epXvtH23XcPf5wiIiKSXxmVp4mIiIjkSjjTqLpEQaNM3Xz6zXQc8lGiceN8P6Pt22HuXP94VxcUvfNOxu+zdCk8/DCsXw8XXgj33AMbNmT8siIiIpIHChqJiIhIJIUzjcIrqcnwfPWEr3bfDlY5e/nlnqBRS4sPJmVq6VKorPTZRj/4QeavJyIiIvmj8jQRERGJpHCmUXglNcnc1KnQ1gZPPeVXO4PsraS2eDGYZee1REREJL8UNBIREZFICmcajSvNQgqMdCsv9/8eegja27P72gsXZv81RUREJD8UNBIREZFICmcahQNIkh2TJsGLL/oAz6FDvnF1NpSVwYknZue1REREJL8UNBIREZFICgeKwgEkyY7p0/3PT3/a9za65prsvfYnPwlVVf52tXqYi4iIFCwFjURERCSSlGmUW0cc4X/+/OewZAm8+Wb2Xvucc3r6GpWUZO91RUREZGQpaCQiIiKRpEyj3FqyBCoqcvPaNTVw772wbBn84he5eQ8RERHJvXi+ByAiIiKSTHGsuPt2RXGOohtj2Pz5UFw8+POG68wz/T8REREpXMo0EhERkchTeVr2LVkCra35HoWIiIhEmYJGIiIiEnkqT8u++nqYPbvnflz55yIiItKHgkYiIiISeco0yo21a3uCReXl+R2LiIiIRI+CRiIiIhJ5yjTKjfPP71ndLFjtTERERCSgoJGIiIhEnjKNcmPZMjjrLH/7u9/N71hEREQkelS9LiIiIpFXXqzaqVy55x7YsQMaG/M9EhEREYkaZRqJiIhI5BWZDllyJR5XwEhERESS0xGYiIiIiIiIiIj0o6CRiIiIRFZxUXG+hyAiIiIyZiloJCIiIpEVL1L7RREREZF8UdBIREREIktBIxEREZH8UdBIREREIitWFMv3EERERETGLAWNREREJLK0apqIiIhI/uhITERERCKrtqw230MQERERGbMyahRgZuOBnwAzgTeAi5xze/s8pxH438BkoAvY6Jy7NZP3FRERkbHhL1/8S76HICIiIjJmZZppdC3wuHNuHvB44n5fncCXnXOHA8cCV5nZogzfV0REREREREREcijToNG5wF2J23cB5/V9gnNuh3Pu+cTt/cCfgMMyfF8REREREREREcmhTINGk5xzO8AHh4CJAz3ZzGYCRwPPZPi+IiIiIiIiIiKSQ4P2NDKzx/D9iPq6Pp03MrMq4H7gaufc+wM8bwOwAWD69OnpvIWIiIiIiIiIiGTJoEEj59zpqR4zs51mNsU5t8PMpgC7UjyvGB8wuts598Ag77cR2AiwfPlyN9j4REREREREREQk+zItT3sQWJ+4vR74Rd8nmJkB3wf+5Jz7dobvJyIiIiIiIiIiIyDToNFNwCozexVYlbiPmU01s4cSzzkBuARYaWYvJv6dneH7ioiIiIiIiIhIDg1anjYQ59we4LQk27cDZyduPwlYJu8jIiIiIiIiIiIjK9NMIxERERERERERGYUUNBIRERERERERkX4UNBIRERERERERkX4UNBIRERERERERkX7MOZfvMaRkZruBN/tsbgDezcNwJHOau8KkeStcmrvCpHkrXJq7wqR5K1yau8KkeStcmrvClGreZjjnJgz2y5EOGiVjZpudc8vzPQ5Jn+auMGneCpfmrjBp3gqX5q4wad4Kl+auMGneCpfmrjBlOm8qTxMRERERERERkX4UNBIREREREREfG/h4AAAGOElEQVQRkX4KMWi0Md8DkGHT3BUmzVvh0twVJs1b4dLcFSbNW+HS3BUmzVvh0twVpozmreB6GomIiIiIiIiISO4VYqaRiIiIiIiIiIjkWEEFjczsTDN7xcxeM7Nr8z0eSc7MGs3s12b2JzPbYmZ/k9g+3sweNbNXEz/r8j1W6c/MYmb2gpn9R+K+5q0AmFmtmf3UzF5O/O0dp7mLPjP7UmI/+ZKZ/djMyjRv0WRmd5rZLjN7KbQt5VyZ2XWJ45VXzOzD+Rm1QMq5+2Zif/kHM/uZmdWGHtPcRUCyeQs99hUzc2bWENqmeYuIVHNnZl9IzM8WM7s5tF1zFwEp9pVHmdnTZvaimW02s2NCj2neImA4597pzl3BBI3MLAb8G3AWsAhYZ2aL8jsqSaET+LJz7nDgWOCqxFxdCzzunJsHPJ64L9HzN8CfQvc1b4XhVuD/OucWAkfi51BzF2FmdhjwRWC5c24JEAM+huYtqjYBZ/bZlnSuEt95HwMWJ37n9sRxjOTHJvrP3aPAEufcUuDPwHWguYuYTfSfN8ysEVgFvBXapnmLlk30mTsz+xBwLrDUObcY+FZiu+YuOjbR/2/uZuAfnXNHATck7mveoiWtc+/hzF3BBI2AY4DXnHOvO+fagXvwOx6JGOfcDufc84nb+/Enr4fh5+uuxNPuAs7LzwglFTObBnwEuCO0WfMWcWZWDZwMfB/AOdfunNuH5q4QxIFyM4sDFcB2NG+R5Jz7LfBen82p5upc4B7n3EHn3F+B1/DHMZIHyebOOfeIc64zcfdpYFrituYuIlL8zQHcAnwNCDdm1bxFSIq5+yxwk3PuYOI5uxLbNXcRkWLeHFCduF2DP04BzVtkDOPcO+25K6Sg0WHA26H7WxPbJMLMbCZwNPAMMMk5twP8hxuYmL+RSQrfwR+IdYW2ad6ibzawG/hBorTwDjOrRHMXac65bfgrrW8BO4Am59wjaN4KSaq50jFLYbkM+FXituYuwsxsDbDNOff7Pg9p3qJvPnCSmT1jZr8xsw8mtmvuou1q4Jtm9jb+mOW6xHbNWwQN8dw77bkrpKCRJdmmpd8izMyqgPuBq51z7+d7PDIwM1sN7HLO/S7fY5G0xYFlwPecc0cDLaikKfISteXnArOAqUClmX0iv6OSLNExS4Ews+vxqf13B5uSPE1zFwFmVgFcjy+R6fdwkm2at2iJA3X48pmvAveamaG5i7rPAl9yzjUCXyKR1Y7mLXLSOPdOe+4KKWi0FWgM3Z9GT3qcRIyZFeM/tHc75x5IbN5pZlMSj08BdqX6fcmLE4A1ZvYGvvxzpZn9HzRvhWArsNU590zi/k/xQSTNXbSdDvzVObfbOdcBPAAcj+atkKSaKx2zFAAzWw+sBj7unAsOmDV30TUHH2T/feJYZRrwvJlNRvNWCLYCDzjvWXxWewOau6hbjz8+AbiPnjImzVuEpHnunfbcFVLQ6DlgnpnNMrMSfPOmB/M8JkkicdXg+8CfnHPfDj30IH7HQ+LnL0Z6bJKac+4659w059xM/N/XE865T6B5izzn3DvA22a2ILHpNOC/0dxF3VvAsWZWkdhvnoavQ9e8FY5Uc/Ug8DEzKzWzWcA84Nk8jE9SMLMzgWuANc65A6GHNHcR5Zz7o3NuonNuZuJYZSuwLPEdqHmLvp8DKwHMbD5QAryL5i7qtgOnJG6vBF5N3Na8RcQwzr3Tnrt4doecO865TjP7PPAwfoWZO51zW/I8LEnuBOAS4I9m9mJi298CN+FTUS/Hnyz9jzyNT9KjeSsMXwDuTgTVXwc+hb8woLmLKOfcM2b2U+B5fHnMC8BGoArNW+SY2Y+BU4EGM9sK3EiK/aNzbouZ3YsP3nYCVznnDuVl4JJq7q4DSoFH/fE2TzvnPqO5i45k8+ac+36y52reoiXF39ydwJ3ml3NvB9YnMvw0dxGRYt6uAG5NLNjRBmwA/c1FTFrn3sOZO+vJxhUREREREREREfEKqTxNRERERERERERGiIJGIiIiIiIiIiLSj4JGIiIiIiIiIiLSj4JGIiIiIiIiIiLSj4JGIiIiIiIiIiLSj4JGIiIiIiIiIiLSj4JGIiIiIiIiIiLSj4JGIiIiIiIiIiLSz/8HrenWSc0gXK0AAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -1958,12 +2034,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Index 12\n" + "Index 6\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABIcAAACMCAYAAADm+clLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXScd33v8c93Vs3II42sxXtsk9gEZzOJMUtCFtaEpWlLgaRsDXDTtKSHblzIvedcOD2n50IpvS0tEJaEBtqQ0kLaHBpCKJQsZHUWEgdI4tiOt1iSLWu0zGjW3/1jZhRFHkkz0kjPI+n9OsfHmkczzlfKM888z+f5/n4/c84JAAAAAAAAy1PA6wIAAAAAAADgHcIhAAAAAACAZYxwCAAAAAAAYBkjHAIAAAAAAFjGCIcAAAAAAACWMcIhAAAAAACAZSzkdQG1dHV1uU2bNnldBgAAAAAAwJLxyCOPHHPOdU/ePmM4ZGY3SnqHpD7n3Jk1vm+S/k7S2ySlJf2ec+7RyvcurXwvKOkbzrnP1lPspk2btGvXrnqeCgAAAAAAgDqY2fO1ttczrOwfJV06zfcvk7Sl8udqSV+p/AeDkr5U+f42SVea2bb6SwYAAAAAAMB8mzEccs7dLWlgmqdcLulbruwBSUkzWyNpp6Q9zrm9zrmcpFsqzwUAAAAAAIBPNGPOoXWSDk54fKiyrdb2Vzfhv+crBwfS+sxtTylXLHldiq+1xcL6/QtfprPXJ70uBZhRJlfUTffv18/3HPO6lEXJzHTZmav17vPWKxRk3QOv5YslffLfnlD/SNbrUtBkiZaQPvuus9XWEva6FAAAsMg1IxyyGtvcNNtr/yNmV6s8LE2nnHJKE8paGN+4Z6/ufrZfZ61r97oUX9t9OKX/fOIF/eb2tfrzt75c6zviXpcEnKRQLOm7uw7p737yjHqHsnrFmjbFwoQbjUpl8rru+0/qmz/fp+ve9gpdvLVb5enp4IW9/aP6/mOHdWp3q9pjhAhLhZN0z7PHtG1Nm659wxavywEAAItcM8KhQ5I2THi8XtIRSZEpttfknPuapK9J0o4dO6YMkfxkJFvQ9x49rHecvVb/773bvS7H14bG8rr+Z8/phnv36fbdR/Xh8zfrDy85lbud8AXnnG5/8qi+cOfT2ntsVOeektQXr3ilXv2yTq9LW5Scc/rRU0f12R/+Wld982FdcFqXrnvb6TpjLSG6F54/PipJ+sJ7tmv7Bro3l5KrvvmQbrh3nz58wWbFI75cgBYAACwSzbglfpukD1rZaySlnHMvSHpY0hYz22xmEUlXVJ67ZPz7Y4c1ki3o/a/Z6HUpvtfWEtb/vPR0/fTPL9Y7zlqj6+96Thd//me6Y/dRr0vDMpfK5PVbX75PH7v5UYWCpq9/cIe+9wevIxiaAzPTpWeu0Z1/cpE+/c5t2n0kpXf8/b369H/slnOLIvtfUg4MpCVJp6ykY3OpufYNW3QindfNDx7wuhQAALDIzRgOmdl3JN0v6eVmdsjMPmJm15jZNZWn3C5pr6Q9kr4u6Q8lyTlXkHStpB9J+pWk7zrnnpqHn8ETzjn90wPP64y1bTr3FO7E1mtdMqa/ee92/eCPLtCqthZ98ntPaHgs73VZWMZuuGevHj84qM+96yz98OMX6s3bVjEEqkkioYCuOn+z7vrEJfrN7et00/3P6/Bgxuuylp2DA2kloiF1xOnUXGrO29ih176sU1+/Z6/G8kWvywEAAItYPauVXemcW+OcCzvn1jvnbnDOXe+cu77yfeec+5hz7lTn3FnOuV0TXnu7c25r5Xt/OZ8/yEJ7eP8J/frosD7wmo1cSM7Cmeva9bl3naVUJq8b793vdTlYpgbTOd348/267MzVeu+rTlEwwHt5PrTHwnrPjvIo4/3H0h5Xs/wcGEhrw8o4n1VL1LVvOE29Q1n92yOHvC4FAAAsYsy0OkvffuB5JVpCunz7Oq9LWbTOXp/Um7et0jfu3atUmu4hLLxv3LNPI9mCPv4mJnOdb5u7WiVJ+yrz32DhPD+QZkjZEva6Uzu1fUNS19/1nPKsnAoAAGaJcGgW+obHdMfuF/Tu8zYoFgl6Xc6i9idv2qrhsYK+ce9er0vBMnNiNKdv/nyf3n7WGp2+us3rcpa8VW1RxcJB7T9GOLSQSiWnQwMZndJJOLRUmZmuveQ0HTqR0W2PT7nuBwAAwLQIh2bhXx46qHzR6f2vOcXrUha9bWvb9LazVuvGe/fpxGjO63KwjHz9nr1K54t0DS0QM9PGzjjh0ALrHR5Trliic2iJe+MrenT66oS+/LM9KpWY9B0AADSOcKhBhWJJNz90QK/f0qWXda/wupwl4Y/ftFXpfFFfvZvuISyMgdGcbrpvv95+1hptXZXwupxlY3NXK8PKFtiB46xUthyYmT52yWl6rn9UdzzFKqAAAKBx5sdlhXdsane7Pn2B12XUNDCa0zN9w9q6KqGV8YjX5SwZz/YN60Q6r1duSCocJLPE/DowkNaRVEZnr29XPBzyupxl48BAWi+kMtq5eaVMTI68EPqGx7T32Ki2r0+qJcww6KXMyekXB1MKBKSz1rXzHgMAADXZh29/xDm3Y/J2rsIb1Ds0pkgwwJLATba+I66SczrCMteYZ/liSUeHxtTZGiEYWmAt4YCcpGyBSXMXSvV3HQnxcb/UmUxrky1K54oaZJEHAADQIH9eGXVtka76T6+rOMlz/SO67At36RNvfbnOveQ0r8tZUmKS/vW7v9APnjiie66+RD1tLV6XhCXqr2//lb7+3F79+NqLJIaGLqj9+wZ0xVfv100X7dRFW7u9LmdZ+OtbHtOu3An9/MNv8LoULICOYkl/9vmfKTNQ1AdfvlHve/VGdSeiXpcFAAD85MO1u4u5ldiAf3rgeYWDpve+aoPXpSxJH3/jFhVKTl/+2XNel4Ilqn84q5vu36/Lt6/TqQRDC25TV3neGyalXjgHBtLayEply0Y4GNBXP3Cezlnfrr/9r2d1/md/qj//11/oqSMpr0sDAAA+RzjUgB888YLesm21ulZwF24+nNIZ17vPW6+bHzygo6kxr8vBEvT1e/YqVyjpj95A558XuldE1RoJah/h0II5OJBmMupl5sx17frmVTv1kz+7SFfs3KDbn3xBb//ivXrvV+/XoRNpr8sDAAA+RThUp1LJ6fhIVpu7Wr0uZUl7/2s2Klcs6eH9A16XgiXovueO6fzTWGnQK+Xl7Fu1nxXLFsRItqBjIzltIBxalk7tXqG/uPxM3X/dG/WJt75cD+4b0H//us/rsgAAgE8RDtVpJFdQyUlJJqKeVz1t5a6swXTO40qwFKUyeTr/PLa5q5VhZQvk4ADL2ENqj4X10ddvllQ+BgIAANRCOFSnVGXlj7YY4dB8SsYikqQTrLSCeTCYzqud97CnNnXFdfBERvkiK5bNtwOVcIg5hxANBRULBwmHAADAlAiH6lQ9oeLCcn5FQgGtiIZYhhdNVyw5DY8VeA97bFNnq4olp0MnMl6XsuTROYSJ2mNhwiEAADAlwqE6EQ4tnGQ8zLAyNN3wGO9hP6jO28bQsvl3YCCtREuIfR6Sqp+thEMAAKA2wqE6VcMh5hyaf8l4WCcIh9Bk1Ysi3sPe2lQJh1ixbP49f7y8UpmZeV0KfKCNziEAADCNusIhM7vUzJ42sz1m9qka3/+EmT1e+bPbzIpmtrLyvf1m9mTle7ua/QMslOqFJXdg519HPMKcQ2g6uv/8obM1okQ0xIplC4Bl7DERw8oAAMB0ZgyHzCwo6UuSLpO0TdKVZrZt4nOcc593zm13zm2XdJ2ku5xzE9civ6Ty/R1NrH1BcWG5cJLxCMPK0HS8h/3BzLSpq5XOoXlWndfpFCajRkWScAgAAEyjns6hnZL2OOf2Oudykm6RdPk0z79S0neaUZyfpDJ5RYIBxcJBr0tZ8jriYTqH0HSDDA31jU1drXQOzbPeoTHliiU6hzCuPcacQwAAYGr1hEPrJB2c8PhQZdtJzCwu6VJJ35uw2Um608weMbOrZ1uo11KZvNpiYeZuWADJeERDY3kVS87rUrCEVO+Yt9E55LnNnXEdPpFRrsBy9vPl+eOsVIaXSsbDyuSLyhaKXpcCAAB8qJ5wqFYaMtVV+zsl/XzSkLLznXPnqjws7WNmdmHN/4jZ1Wa2y8x29ff311HWwkplcmqPhbwuY1lIxsJyThqi/R1NNMSwMt/Y1NWqkiuvpoX5wTL2mKx67GNoGQAAqKWecOiQpA0THq+XdGSK516hSUPKnHNHKn/3SbpV5WFqJ3HOfc05t8M5t6O7u7uOshZWKpPnonKBdLSWf8+sWIZmGkznFAsHFQ0xNNRrm1jOft4dGEgrGDCtTca8LgU+0R6PSOLGCwAAqK2ecOhhSVvMbLOZRVQOgG6b/CQza5d0kaT/mLCt1cwS1a8lvUXS7mYUvtBSmbySlRMrzK/q75l5h9BMBLz+sbmzEg4x79C8OTCQ1tpki8LBuhYlxTJA5xAAAJjOjOOknHMFM7tW0o8kBSXd6Jx7ysyuqXz/+spTf0vSnc65iWf7qyTdWpmnJyTpZufcHc38ARbKYDqvLT0Jr8tYFjoq4RArlqGZCIf8o6M1ovZYmBXL5tEBlrHHJNXjH5NSAwCAWuqaRMc5d7uk2ydtu37S43+U9I+Ttu2VdM6cKvQJLiwXTkecE1g032A6r3ZWKvMNViybXwcG0nrrGau8LgM+kqRzCAAATIN+8zoUS07DYwXCoQXy4rAyOofQPAS8/rK5M679x5iQej4Mj+U1MJrTBjqHMAGdQwAAYDqEQ3UYHmOVo4WUiIYUME5g0VxDhEO+sqmrVUdSGY3lWVa72Q4OZCRJG1e2elwJ/KSNziEAADANwqE6VEMKLiwXRiBgSsYjdA6hqQYJh3xlc1erHMvZz4sDLGOPGoIBU6IlRDgEAABqIhyqQ/VEKsl8JQsmGQ/TOYSmyRdLSueK43NuwHubKiuWMSl18x0YKP9OCYcwWTIeJhwCAAA1EQ7VoXoiRdfBwumgcwhNNP4eJuD1jU1dleXsCYea7sBAWm0tIfZ3nKQ9RjgEAABqIxyqwyDh0ILroHMITUTA6z/tsbBWtkZYsWweHBjIaGMn8w3hZO2xsAa58QIAAGogHKoDF5YLrz0W4QQWTcO8Yf60qTPOsLJ5cHAgzZAy1JSMRegcAgAANREO1WGociLVxoXlgumIh3WCziE0yRABry9t6mxlOfsmK5acDp1Is4w9ampjWBkAAJgC4VAdUpm8WsIBtYSDXpeybHS0RpTJF1nmGk1B958/bepq1dGhMWVyvM+b5YVURvmio3MINVUnpHbOeV0KAADwGcKhOgymc1xULrDqynDMO4RmqA5RTMYjHleCicYnpWbeoaZhGXtMpz0WVr7olCaQBQAAkxAO1SGVySsZ46JyIXVULuIHM8w7hLlLZQqSpLaWkMeVYKLNnaxY1mwHK+HQxk7CIZwsWbnRxdAyAAAwGeFQHVKZPJ1DC6x6AntilBNYzF0qk9eKaEihIIc8P9nUVQ4w9tE51DQHBtIKBkxr2lu8LgU+1E44BAAApsCVUh0G03kmo15g1eE/rFiGZhjMMDTUjxItYXWtiNA51EQHBjJal4wRhKKm6nGQIdsAAGAyzh7rMETn0ILraK10DnECiybgPexf6zrieiE15nUZS8aRwYzWJukaQm3tcTqHAABAbYRDdUhl8uMTJGNhVOccOkHnEJqAoaH+1ZOIqneIcKhZeofGtLqNcAi1vTisjM9WAADwUnWFQ2Z2qZk9bWZ7zOxTNb5/sZmlzOzxyp//U+9r/S5fLGk0V+TCcoG1hINqCQcYVoamGEwT8PrVqrao+oazXpexJDjn1DeU1SrmG8IUqkO26RwCAACTzbh0j5kFJX1J0pslHZL0sJnd5pz75aSn3uOce8csX+tb1RMowqGF1xGPMC8CmoLOIf/qSbRoMJ1XtlBUNBT0upxF7UQ6r1yxpFUJwiHU1hoJKhgwPlsBAMBJ6ukc2ilpj3Nur3MuJ+kWSZfX+e/P5bW+UA2H6DpYeO2xMHMOoSkIh/yrJxGVJPXTPTRn1eF5qxhWhimYmZKxMJ1DAADgJPWEQ+skHZzw+FBl22SvNbNfmNkPzeyMBl/rW9UTKFYrW3jlziGGlWFuxvJFZQsl3sM+1dNWDod6hwiH5qoaDq1uj3pcCfysnXAIAADUUE84ZDW2uUmPH5W00Tl3jqS/l/TvDby2/ESzq81sl5nt6u/vr6OshZFKM6zMKx2tYSakxpzR/edvPZUhUP3DTEo9V9VwqIdhZZhGG+EQAACooZ5w6JCkDRMer5d0ZOITnHNDzrmRyte3SwqbWVc9r53wb3zNObfDObeju7u7gR9hfjHnkHeSzDmEJuA97G/VziEmpZ67avdV9XcK1JKMEw4BAICT1RMOPSxpi5ltNrOIpCsk3TbxCWa22sys8vXOyr97vJ7X+t141wEXlguuIx7WYCYv52o2mwF1GaT7z9c6W6MKmNTHsLI56x0a08rWCBN7Y1rtsTA3XgAAwElmXK3MOVcws2sl/UhSUNKNzrmnzOyayvevl/Q7kv7AzAqSMpKucOUr+pqvnaefZV4w55B3krGIiiWn4WxBbS38/jE7Lwa8EY8rQS3BgKlrRXR8SBRmr3dobHyCb2AqTEgNAABqmTEcksaHit0+adv1E77+B0n/UO9rF5PBdF6tkaDCwXqarNBM1TliBkfzhEOYNYaV+d+qthaGlTVB71CWlcowo/ZYWENjeZVKToFArakhAQDAckTiMYNUJq9knI4DL3RUfu9MSo25IBzyv55ElHCoCXqHxrSacAgzaI9H5Jw0PFbwuhQAAOAjhEMzSGXyDCnzSEdr+fdOOIS5SKVzMpMSLXU1SsIDPW1RViubo0KxpGMjWa1iMmrMoBqUM7QMAABMRDg0g1Qmp/YYF5VeqHZsMXEm5iKVKQ9LZPiEf3UnWnRsJKd8seR1KYvWsZGcSk7qoXMIM6iGQ4MZbrwAAIAXEQ7NIJXJMxzFIx3j4RAnsJg93sP+V+12OTbC0LLZqk7ozbAyzKQ6nx+dQwAAYCLCoRmkMnlWOfJIW2UY0Ak6hzAHg5n8+MUQ/KknUQ40WM5+9o5WwiEmpMZMxjuH+GwFAAATEA7NYDCdVzsXlp4IBQNqawnROYQ5oXPI/6rLrzMp9ez1jYdDzDmE6SWZcwgAANRAODSNsXxR2UKJC0sPdbRG6BzCnDCpvP/1tFXDISalnq3eoayCAVPnCsIhTK+NcAgAANRAODSNIZbA9lwyHmG1MsxJKp0fv1MOf+paEZVZOeDA7BwdGlP3iqiCTLyOGbSEg2oJBwiHAADASxAOTSNFOOS5jniYE1jMmnOOYWWLQDgYUGdrhOXs56B3aIwhZahbeyysFF25AABgAsKhaQwSDnkuGQvTOYRZS+eKKpQc7+FFoDvRwoTUc9A3lGUyatStPRZmKXsAAPAShEPTqN5V48LSO8l4RIOj3N3E7FQDXlYr87+eRJQJqefg6NAY4RDqloxF6MoFAAAvQTg0jRQXlp7riEc0nC0oXyx5XQoWIQLexWNVW1S9Qwwrm42xfFGpTJ5hZahbWyzMUvYAAOAlCIemwbAy73W0ln/3nMRiNqoBL6uV+V9PokXHRrIqlpzXpSw61eF4dA6hXsl4eHzRDQAAAIlwaFrVC8tECxeWXknGI5KkFHMjYBaq+w0Br//1tEVVctLxUYaWNaq3MpE34RDqVZ5ziHAIAAC8iHBoGkOZvNpaQiwN7KGOypC+E3QOYRZeHBoa8bgSzKQnUR4SxaTUjTuaIhxCY5KxsNK5IkO2AQDAOMKhaaQyebUz35CnkrHyRf2JUTqH0LgUQ0MXjZ5KsNHHcvYNq87VtJpwCHWqntswKTUAAKiqKxwys0vN7Gkz22Nmn6rx/feZ2ROVP/eZ2TkTvrffzJ40s8fNbFczi59vg+kcF5Ueq04GzpxDmI3BdF7BgKk1EvS6FMyAzqHZ6xvOKhoKqC0W8roULBLVcxs+WwEAQNWMZ5JmFpT0JUlvlnRI0sNmdptz7pcTnrZP0kXOuRNmdpmkr0l69YTvX+KcO9bEuhdEKpMnHPJYR2ulcyhN5xAal8rklYyFZcbQUL/rroZDLGffsKOp8jL27OeoV/Xchs4hAABQVU/n0E5Je5xze51zOUm3SLp84hOcc/c5505UHj4gaX1zy/RG+cKSuUq81BoJKhw05hzCrBDwLh7RUFDJeJhhZbPQOzTGkDI05MVwiBsvAACgrJ5waJ2kgxMeH6psm8pHJP1wwmMn6U4ze8TMrp7qRWZ2tZntMrNd/f39dZQ1/1KZPEtge8zMlIxHOIHFrPAeXlxWJVrUy7CyhvUNZ9XTFvW6DCwiL64Eyo0XAABQVk84VKtP3dV8otklKodDn5yw+Xzn3LmSLpP0MTO7sNZrnXNfc87tcM7t6O7urqOs+eWco+vAJ5KxsE6McgKLxqUy+fF5q+B/PW1RhpU1yDk3PqwMqBdzDgEAgMnqCYcOSdow4fF6SUcmP8nMzpb0DUmXO+eOV7c7545U/u6TdKvKw9R8L5MvKl90XFj6QEc8wpxDmBUC3sWlOxFV/xDDyhoxnC0oky8yrAwNaWspTzlJ5xAAAKiqJxx6WNIWM9tsZhFJV0i6beITzOwUSd+X9AHn3DMTtreaWaL6taS3SNrdrOLnE0tg+0cyHubuJmaFcGhx6Um0qH8kq1KpZnMqauirhGkMK0MjQsGAEtEQ4RAAABg342plzrmCmV0r6UeSgpJudM49ZWbXVL5/vaT/I6lT0pcrq6UUnHM7JK2SdGtlW0jSzc65O+blJ2myahjBhaX3OuIRPX5w0OsysMiUSm58tTIsDqvaosoXnU6kc+pcQdhRj6Op8jA8hpWhUW2xsFLceAEAABUzhkOS5Jy7XdLtk7ZdP+Hrj0r6aI3X7ZV0zhxr9ASdQ/6RbA1rMJOXc46lmlG34WxBzokJqReRnkQ54OgbzhIO1am30jnEsDI0KhkP0zkEAADG1TOsbFkiHPKPjnhEuUJJmXzR61KwiAzxHl50qkOjmJS6fr3DDCvD7LTHyjdeAAAAJMKhKaUYVuYb1WFBJ2h/RwOqQ0OrSzbD/3oSlXCISanr1psaU6IlpHikrkZgYBydQwAAYCLCoSmMdw6xWpnnqhf3J0ZZsQz1o/tv8Zk4rAz16R3KMqQMs9IeY7EHAADwIsKhKaQyeQUDpkSUu7Fe66gEdJzEohGEQ4tPLBJUoiVE51ADeofHmIwas9Iei2ioMp8fAAAA4dAUUpm82lpCTIDsAx2tlc6hNJ1DqN9gpry/EA4tLj2JKJ1DDegbyjLfEGalPRZWrljSWL7kdSkAAMAHCIemMJjJc1HpE8lq5xBzI6AB1c6hJENDF5WeRAvhUJ1KJafeoTGGlWFWquc41SAdAAAsb4RDU0gRDvlGMlbuHBpkziE0IJXJKxIKqCUc9LoUNGBVW1R9wwwrq8dAOqdCyTGsDLNSDc6ZlBoAAEiEQ1NKZfJqZ5UjX4iEAmqNBFmtDA1JpQl4F6Oethb1DmWZB6UOvZW5mVYxrAyzMN45xGcrAAAQ4dCUUukcF5Y+koxHNMicQ2hAKpNXkvfwotOTiCpXKGkoU/C6FN97MRyicwiNq57j0DkEAAAkwqEplYeVsVKZX3S0hpmQGg1haOji1J0od8EwtGxmvUPluZkIhzAb4+EQnUMAAECEQzU55zQ0Vhif6wbe64hHmJAaDRlkWNmiVA06mJR6Zr1DYzJ7MVADGsGcQwAAYCLCoRpGsgUVS44LSx9pj4WZFwENKc8bxnt4sempBB3VIVOYWu/QmDpbowoH+ShH41ZEQwoGjNXKAACAJMKhmqohBOGQf6zviOvAQFp3PdPvdSlYJIYYVrYo9dA5VLfeoSyTUWPWzExtLSE6hwAAgCTCoZqqJ0ptXFj6xh9cfKq2rkromm8/okcPnPC6HPhcoVjScLZAOLQIrYiGFI8E1TdEODST3qEx5hvCnCTjEaWY/B0AAIhwqKahSjiUZEiKb7THwrrpw69ST1tUV33zYT3TO+x1SfCxobHyxQ6rlS1Oq9pamJC6DoRDmKu2WJiVQAEAgKQ6wyEzu9TMnjazPWb2qRrfNzP7YuX7T5jZufW+1o+qEx/TdeAvPYkW/dNHXq1oKKAP3PCgDg6kvS4JPlXt/mPOocWpOxGlc2gG+WJJx0ZyDCvDnCRj4fEbYgAAYHmbMRwys6CkL0m6TNI2SVea2bZJT7tM0pbKn6slfaWB1/pOinDItzasjOtbH9mpTK6oD974kI6NcAGJk/EeXtx6ElE6h2bQP8wy9pi79liYlUABAIAkKVTHc3ZK2uOc2ytJZnaLpMsl/XLCcy6X9C3nnJP0gJklzWyNpE11vPYk6VxBu/YPNPqzjAsETJ2tEXUnoopH6vkRy5xzGkzntf/4qCSGlfnV6avbdOPvvUrvv+FBfejGh/Tpd56hgHld1fxpjYbUnYhqZTyiwFL+QZuoOkyiPRbxuBLMRk+iRX3DfV6X0RR9Q2M6MA9djnv6RiRJqwmHMAfJeFgDo7k5nXMtVhs7W9WdoPOuEfliSU8dGVKhWPK6FEVDQXUnoupcEWloxcZ8saTjIzn1D2e1riOmla2cJwB+5JzTSLag/uGsTqRzcs7ripaHepKTdZIOTnh8SNKr63jOujpfe5Ln+kf1O9ffX0dpM2uNlD88uhNRtUZDmnxpXXTlC8n+4ayOjWSVL5b3vEQ0pFg42JQa0Hw7Nq3UV953nv7Ht3bpPV9tzr7id8EJoefK1ohCdQZFATNtW9umC7d265Ubkgot8WWv9x0b1R27j0qic2ixWtUWVTpX1Ei2oBXR+gN+v3DO6f69x/Xt+5/Xnb/sVbE0f2c0G1bG5+3fxtK3qq1Fw2OFpp1zLSbBgOmC07r02+eu01u2rVYssnjO+YolpycPp3T3M/164tBg3ceYYMB0xtp2vX5Ll87ZkKwrVHHO6akjQ/q3Rw7ptl8c0cCo/+aoWtkaUfeKqLoSEUVq/Ey5YknHhnPqH8m+pP5IMKC3n71GH3jtRr1yQ1Jm3CFh5k8AAAvQSURBVIADvNA3PKZ7njmmn+85pv3HR9U/klX/cFZjee+D6OWmnrPuWkfKyZ9CUz2nnteW/wGzq1UekqbV6zfp2x/ZWUdptRWKTsdGsuofyY5/GPQNjdX8QDOVP1RevioxHiJ1J6I6fXUbHxI+d8npPfrxn16kQyeW7txDzknDYwX1D4+9ZH8+PpqTqzNCzxVK+u+n+/T3P92jRDSk153WqQu3dmvnppVqj4UVrwShwTrCJuecsoWSRrMFpXNFlZxTPBJSazSoWDhY13umUCxpNFvUcDavkWxBhUogayZZ5ZBh9uLj8t/lx6FAQPFoUK2Rcs2BgMk5p6d7h3XH7qO6Y/dR/fpoebLynZtWan1HrK7fEfylpzKPTu/QmFZ0r/C4mvoNj+V162OH9e37n9ezfSNKxsP66AWb9brTuualu7GtJazTehbP7wf+85ELNuuVG5IqLrNbsiUnPbj3uP79scP6+C2PqzUS1KVnrtE7z1mjrhUndxMFA6YV0ZASLSG1RkMNdapMViiWlM4Xlc4Wlc4Vap8U11AsOT1+cFB3P9Ove/cc02A6LzNpS88KtdR5MzObL+knv+7T3/3kWa2IhvSal3VOCIpMJlMgUL6pVCw53f1Mv77/6GE93TusSDCgN23r0dvPWqu2mPehfTpXLJ/rD7/459hIVsOlk1ffCwVMGzvj2rGpY/w8v7M1ovufO67vPXpYtz52WGesbdOHXrtJ7zxnrWKR4Pj5TjpX1Gi2oGyhJOecSk4qOaeSc3JOagkHlWgJja+0ybVDY/LF8jnl8FhBI9nCeND5knPAyeeHlb/DwUDD56DNUCq5ynu4oNHKufBkATPFI8HKn1BD59jVfS7ngw69+dSbGtNdz/br7meO6VcvDEmSOlsjOn1NQued0vGS6/KOeKSu3yHqd+Hnam+3mS4wzey1kj7jnHtr5fF1kuSc+78TnvNVST9zzn2n8vhpSRerPKxs2tfWsmPHDrdr166ZfyoAdUll8rpvzzHdXTkIHx7MnPScWLj8IVbrpLfknDK5okZzBU11g9JMioeDikVCNbuaCiWn0WxBmXxxzj9PVbXeVKZ8kvyqjSv11jNX69IzV2tdkmBosbpvzzH97jceVGdrY8MFvDaYyWksX9LZ69v1gdds1DvPWVv3RRuAhVcqOT24b0C3PnZIP3zyqIazJwcLtbSEA1oRDSkUqO/45OSUL7rxkGEuuhNRXbilWxdu7dIFp3Wps0aYNZ3BdE73PXdc9zx7TPfu6dfBgZPPBybaviGpd523Xu88e42S8aU3BGskW6iE+vv1TO+IYuGgQgGb9nxnKmbSikhIsUhQAUKiaRVKJY1kC03rDJnpHLQZCqXyzc3ZnMe2hANqjdQOlkvOKZMvKp0rzmunsR+FAqbzNnbowq3dumhrt7ataWMKjQViZo8453actL2OcCgk6RlJb5R0WNLDkn7XOffUhOe8XdK1kt6m8rCxLzrndtbz2loIh4D545zTc/2j2n04pdFcQelsOfSpDuMpFk8+JphJsUi5Y6fauROvnPxMvHsyfhelxodbIGBaEQ1qRTSsFS0hJaLVO7A2fue0fDgq341zlcduwuN8oTT+30vnyndd07miXrGmTW85Y5V6Esy/shSM5Yv6/I+e1shYfRdqfhGPBnX59nXaviHpdSkAGjSWL+qhfQM1w5t8sXwhOzJW0Gi23OEwPMXn5VQioXLnazxc7nSIR0KKRQINhQhbVyV0+upEUzskDhxP6+ne4UonzMTOGOmMtW06dRF1b86Fc04P7RvQD3cfVcBs/P9R9e9IKKCgmQLVThYr97KMFUoaGStoJJvXyFh5v0hnm3cTbKkKBExtlU68FdGQVlS6r0IBGz//m3w+WNkyvi1XKCmTe+n5ZzpXUGmeGm6CQRvvEKueD8enCAJLzpXPUyvn2JnKOXahjnPseDioeDSkaGjx3BybjbaWsF61eeWinD5gKZh1OFR58dsk/a2koKQbnXN/aWbXSJJz7norf0r9g6RLJaUlXeWc2zXVa2f67xEOAQAAAAAANNecwqGFRjgEAAAAAADQXFOFQ0u7Xw0AAAAAAADTIhwCAAAAAABYxnw5rMzMhiU97XUdWDS6JB3zuggsGuwvaAT7CxrB/oJGsc+gEewvaAT7C6ay0TnXPXmjX6cHf7rWGDigFjPbxf6CerG/oBHsL2gE+wsaxT6DRrC/oBHsL2gUw8oAAAAAAACWMcIhAAAAAACAZcyv4dDXvC4Aiwr7CxrB/oJGsL+gEewvaBT7DBrB/oJGsL+gIb6ckBoAAAAAAAALw6+dQwAAAAAAAFgAvgqHzOxSM3vazPaY2ae8rgf+YmYbzOy/zexXZvaUmX28sv0zZnbYzB6v/Hmb17XCH8xsv5k9WdkvdlW2rTSzH5vZs5W/O7yuE/5gZi+fcBx53MyGzOyPOcagysxuNLM+M9s9YduUxxQzu65yTvO0mb3Vm6rhlSn2l8+b2a/N7Akzu9XMkpXtm8wsM+E4c713lcMLU+wvU37+cHzBFPvMv0zYX/ab2eOV7RxjMCPfDCszs6CkZyS9WdIhSQ9LutI590tPC4NvmNkaSWucc4+aWULSI5J+U9J7JI045/7a0wLhO2a2X9IO59yxCdv+StKAc+6zlRC6wzn3Sa9qhD9VPpMOS3q1pKvEMQaSzOxCSSOSvuWcO7OyreYxxcy2SfqOpJ2S1kr6L0lbnXNFj8rHAptif3mLpJ865wpm9jlJquwvmyT9oPo8LD9T7C+fUY3PH44vkGrvM5O+/wVJKefcX3CMQT381Dm0U9Ie59xe51xO0i2SLve4JviIc+4F59yjla+HJf1K0jpvq8IidLmkmypf36RywAhM9kZJzznnnve6EPiHc+5uSQOTNk91TLlc0i3Ouaxzbp+kPSqf62CZqLW/OOfudM4VKg8fkLR+wQuDL01xfJkKxxdMu8+Ymal8A/07C1oUFjU/hUPrJB2c8PiQuPDHFCrp9yslPVjZdG2lRftGhglhAifpTjN7xMyurmxb5Zx7QSoHjpJ6PKsOfnaFXnpCxTEGU5nqmMJ5DWbyYUk/nPB4s5k9ZmZ3mdnrvSoKvlPr84fjC2byekm9zrlnJ2zjGINp+Skcshrb/DHmDb5iZiskfU/SHzvnhiR9RdKpkrZLekHSFzwsD/5yvnPuXEmXSfpYpf0WmJaZRST9hqR/rWziGIPZ4LwGUzKz/y2pIOmfK5tekHSKc+6Vkv5U0s1m1uZVffCNqT5/OL5gJlfqpTe5OMZgRn4Khw5J2jDh8XpJRzyqBT5lZmGVg6F/ds59X5Kcc73OuaJzriTp66KtFhXOuSOVv/sk3aryvtFbmb+qOo9Vn3cVwqcuk/Soc65X4hiDGU11TOG8BjWZ2YckvUPS+1xl8s/K8KDjla8fkfScpK3eVQk/mObzh+MLpmRmIUm/Lelfqts4xqAefgqHHpa0xcw2V+7aXiHpNo9rgo9Uxs7eIOlXzrm/mbB9zYSn/Zak3ZNfi+XHzForE5fLzFolvUXlfeM2SR+qPO1Dkv7DmwrhYy+528YxBjOY6phym6QrzCxqZpslbZH0kAf1wUfM7FJJn5T0G8659ITt3ZWJ8GVmL1N5f9nrTZXwi2k+fzi+YDpvkvRr59yh6gaOMahHyOsCqiqrNlwr6UeSgpJudM495XFZ8JfzJX1A0pPVZRkl/S9JV5rZdpXbafdL+n1vyoPPrJJ0azlTVEjSzc65O8zsYUnfNbOPSDog6d0e1gifMbO4yqtmTjyO/BXHGEiSmX1H0sWSuszskKRPS/qsahxTnHNPmdl3Jf1S5eFDH2MloeVliv3lOklRST+ufD494Jy7RtKFkv7CzAqSipKucc7VOzkxloAp9peLa33+cHyBVHufcc7doJPnTZQ4xqAOvlnKHgAAAAAAAAvPT8PKAAAAAAAAsMAIhwAAAAAAAJYxwiEAAAAAAIBljHAIAAAAAABgGSMcAgAAAAAAWMYIhwAAAAAAAJYxwiEAAAAAAIBljHAIAAAAAABgGfv/F0wFZDM0GYUAAAAASUVORK5CYII=\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIkAAACMCAYAAAD4MPn4AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXiU5b3/8c83M9kTkkASAglhJ4hQ1EYQcaNoRWqLrcetPa1VT62t/rpdv9p6znW695xudu9p6zn1nNMVPZ76k1ZU3KkLyiI7BMIekpCEkBDIPnP//shEA0kgYSbzTDLv13XNlZl7Hp/7G3NzzzPf517MOScAAAAAAADEtwSvAwAAAAAAAID3SBIBAAAAAACAJBEAAAAAAABIEgEAAAAAAEAkiQAAAAAAACCSRAAAAAAAAJDk9zqAM8nNzXWTJk3yOgwAAAAAAIARY/369XXOubzTyyOSJDKzhyVdL6nGOTe7j/dN0k8kLZXULOnjzrkNZzvvpEmTtG7dukiECAAAAAAAAElmdqCv8khNN/svSUvO8P51kqaHHndL+mWE6gUAAAAAAEAERCRJ5JxbLan+DIcsk/Rb12WNpGwzGxeJugEAAAAAABC+aK1JVCjpUI/XFaGyqijVDwAAAADAiNHU2qF1+49pzd6j2lHdJOfcgP47f4LplouLde35Y9W1MgzwjmglifpqeX22YDO7W11T0lRcXDyUMQEAAAAAMGy8ua9ez+04ojV7j2rr4UYFnZToM5UUZCrJN7CJQjVNbbrn9+t1+fRcffX952tafsYQR43hJFpJogpJE3q8LpJU2deBzrmHJD0kSaWlpQNLhQIAAAAAMII9/Mo+feOv25XkS9AFxdm6b9E0XTJljC4szlFqkm/A5+kMBPW7NQf0w2d3acmPV+uOhZP0mcXTlZmSOITRY7iIVpJohaT7zGy5pPmSGp1zTDUDAAAAAOAMnHP68XO79ZPnd2vJ+QX60S0XDCopdDq/L0F3LJysD8wdr+8/U6b/eGWfHn+rUt9cdr6um8PSwfEuIgtXm9mfJL0uqcTMKszsLjO7x8zuCR2yUtJeSeWS/l3SpyNRLwAAAAAAI1Uw6PT1v2zXT57frZveXaSff/jCsBJEPY3JSNZ3bnyXnrh3oXIzkvSFRzcpGGQyT7yzgS5u5YXSSVlu3Vcv8zoMAAAAAACiyslpT+1J1Z1o07hRKSoekybrc7nf8FUfb9X+oyd1UXHOgNc2wvBmd65c75wrPb08WtPNAAAAAADAaTqDQZ0+gMc5p/1Hm3WsuV1FOakqzE4dsgSRJCX7uxJDbZ0BkkRxLraTRLnTpTue9DoKAAAAAAAibnvlcV3/s7/1ShJ1+/oHztcll04a8jhqqpt0649X62cLLtT7544f8voQA+7sO+kY20kiAAAAAABGqD++eUCJvgT98/WzlGCnfmmflp+heZNHRyWOwpxUSdLhhpao1IfYRZIIAAAAAIAoa2kP6Im3KvW+OeP095dM9DSWjGS/slITdfgYSaJ4x2RDAAAAAACi7KmtVWpq69TNF0/wOhRJUmF2KiOJQJIIAAAAAIBoW772kCaNSdP8KE0pO5vCnFRGEoEkEQAAAAAA0bS39oTe3Fevmy+eILOh27VsMLpHEjnXzyraiAskiQAAAAAAiKJH11XIl2D6u4uKvA7lbUU5qTrR1qnjLZ1ehwIPkSQCAAAAACBKOgJB/e+GCi0qyVf+qBSvw3lbUWiHs4qGZo8jgZdIEgEAAAAAECUv7qxRbVObbomRBau7FWanSZIqWJcorpEkAgAAAAAgSh5dd0j5mclaVJLndSinKAyNJGLx6vhGkggAAAAAgCg4crxVL+ys0Y3vLpLfF1tfx3PSEpWa6NPhBpJE8Sy2WiUAAAAAACPUY+srFHTSzaWxNdVMksxMhTmpjCSKcySJAAAAAAAYYsGg06PrDmn+5NGanJvudTh9KsxOZSRRnCNJBAAAAADAEHtjX70OHG2OuQWreyrMIUkU70gSAQAAAAAwxB5Ze1CZKX5dN3uc16H0qzA7VfUn29Xc3ul1KPBIRJJEZrbEzMrMrNzMvtzH+1eZWaOZbQw9vhKJegEAAAAAiHUt7QGt2n5E179rnFKTfF6H068idjiLe/5wT2BmPkm/kHSNpApJa81shXNu+2mH/s05d3249QEAAAAAMJy8vKtWze0BvW/OeK9DOaPuJFFFQ4umj830OBp4IRIjieZJKnfO7XXOtUtaLmlZBM4LAAAAAMCwt3JLlXLSEnXJlNFeh3JGhdlpkhhJFM8ikSQqlHSox+uKUNnpFpjZJjN7yszOj0C9AAAAAADEtNaOgJ7fcUTXnl8gvy+2lwXOz0xWos9YvDqOhT3dTJL1UeZOe71B0kTn3AkzWyrp/0ma3ufJzO6WdLckFRcXRyA8AAAAAAC8sXpXrU62B3TdnNhdsLpbQoJpXFYqI4niWCTSmBWSeu7hVySpsucBzrnjzrkToecrJSWaWW5fJ3POPeScK3XOlebl5UUgPAAAAAAAvPHU1mplpSbq0qljvA5lQAqzUxlJFMcikSRaK2m6mU02syRJt0pa0fMAMyswMws9nxeq92gE6gYAAAAAICa1dQb03PYjeu+ssUqM8alm3QpzGEkUz8Kebuac6zSz+yQ9I8kn6WHn3DYzuyf0/q8k/Z2kT5lZp6QWSbc6506fkgYAAAAAwIjxyu46NbV1aum7Yn+qWbfC7FQdaWpVe2dQSf7hkdhC5ERiTaLuKWQrTyv7VY/nP5f080jUBQAAAADAcLByS7VGpfi1cGqfq63EpKKcVDknVTW2aOKYdK/DQZSRFgQAAAAAIMLaO4N6dnu1rplVMKxG5BTmpEoSU87i1PBpqQAAAAAADBOv7qnT8dZOLZ1T4HUog1KUnSZJqmDx6rhEkggAAAAAgAhbublKmcl+XTZ9+Ew1k6SCrBSZMZIoXpEkAgAAAAAggjoCQa3afkRXzxqrZL/P63AGJcmfoLGZKTrMSKK4RJIIAAAAAIAIen3PUTW2dOi62cNrqlm3wpxURhLFKZJEAAAAAABE0MotVUpP8umKGXleh3JOCrNTGUkUp0gSAQAAAAAQIZ2BoJ7ZVq3F541VSuLwmmrWrTAnVVWNLQoEndehIMpIEgEAAAAAECFr9tbrWHPHsNvVrKeinFR1BJxqmlq9DgVRRpIIAAAAAIAI+c0re5WdlqgrZ+R7Hco5K8xOlcQOZ/GIJBEAAAAAABGw6VCDXiyr1Scun6LUpOE51UzqGkkkiXWJ4hBJIgAAAAAAIuBnL+xWVmqiPrZgotehhGV8aCRRBSOJ4g5JIgAAAAAAwrT1cKOe21Gjuy6brMyURK/DCUtakl+j05MYSRSHSBIBAAAAABCmnz6/W5kpfn184SSvQ4mIwuxU1iSKQySJAAAAAAAIw/bK41q1/YjuXDhZo4b5KKJuhdmpjCSKQySJAAAAAAAIw89e2K3MZL/uXDjZ61AipjCnaySRc87rUBBFJIkAAAAAADhHZdVNemprtT6+cJKy0kbGKCKpa4ezlo6A6k+2ex0KoigiSSIzW2JmZWZWbmZf7uN9M7Ofht7fbGYXRaJeAAAAAAC89NMXdisj2a+7Lhs5o4ikrulmkphyFmfCThKZmU/SLyRdJ2mWpNvMbNZph10naXrocbekX4ZbLwAAAAAAXtp9pEkrt1Tp9ksnKjstyetwIqowJ5QkYvHquOKPwDnmSSp3zu2VJDNbLmmZpO09jlkm6beuazLjGjPLNrNxzrmqM534eEuHVm2rPufA0pL8mj9ltBJ98T2rzjmndQeO6VgMDBNMS/LroonZSks6c9M73tqhbYeP611FWUpPjkQzBYB3lNc0KSXRp6KctLMeW9vUprcOHutVbma6qDhbYzKShyJESOoIBPX6nqNq7QgM6Hgz03njMs/6dw0EnbYcblTN8dZIhDlgJQWZmjgmPap1AgDC55xTec0J7as72eu95WsPKTXRp7sum+JBZEOrKLvr8/TlXbXyJdgp72WlJmr+lDFehBVTnHNaf+DYiJqSF4lv34WSDvV4XSFp/gCOKZTUK0lkZnera7SRkgqm6e7frQ8ruNyMZN1cWqTb5hVrwuizfxkYadbur9d3ntqp9Qd6f8HxSpI/QZdMGaP3lORp0cx8TRyT/nbH+8LOGr1YVqN1+4+pM+iUkezXsgvG68Pzi3X++CyvQwcwjDW3d+qvm6r0xzcPauOhBvkSTLdcPEGfWzxd+aNSeh1/vLVDv355jx5+Zb9a+klSpCf59A+XT9EnrpiiDBLaEeOc08ot1frBqrI+L8jPZnp+ht4zM19XleSrdFKOEn0Jamzu0Mu7a/XSzhq9tKvWk4s5X4Lp5tIJ+tzV0zW2jzYHAIgdLe0Bvb63Ti/urNULO2vOOOXq01dN1ej0kTWKSJJGpfqVn5ms5WsPafnaQ73eX/X5KzRjbKYHkcWGtfvr9d2ndmpdDH3XjgQLd6VyM7tJ0rXOuX8Ivf6opHnOuf/T45gnJf2rc+6V0OvnJd3vnDtjBuj8uRe6R1a+dM6xVTW26pG1h/TCziNyki6blquPzC/Wgqm5Oi0RKjNTepJPZtbnuYabsuomff+ZnXpuR43yM5P12auna25Rttdh6ejJdq3eVasXd9Zob+jCf0peuto7g6oIDWOcWZCpRTPzNbcoS6u2H9GTm6vU1hnU3AnZ+si8Yi2cnqvapjZVNbSoqrFVVY0tOnK8TYU5qbpkyhiVTsxh9BEQh9o6A2rvDPYqP1TfouVrD+rxDYfV1NapafkZum1esQ4cPak/vnFQfp/pzoWT9ckrpyorNVGtHQH97vUD+sVL5Wpo7tD7547X7QsmKiXRd8p5m9sDeviVfXp6W7XGpCfpvvdM04fnFyvZ7+sVAwbutT11+u5TO7WpolEzxmbo81fPGPBNno5AUOsPHNOLZTV6c1+9OgJOmcl+Tc5L19bDjQo6KSctUVfO6LpJMTUvY4h/m3cEndOfNxzWH944IF/CqW0OADC0nHM62R7otUuXk9TY3KHKhhZVH29VZUOrqhtbtLfupN7cV6+2zqDSknxaOC1Xi0ryNacwS6d/XUww04yxGfKP0NkrdSfaVN146sjbyoYW3f279frhzXP1oYuKPIrMOzurj+v7T5fp+Z1d37U/s3i6Lpjg/XftwZpTlL3eOVd6enkkkkQLJH3NOXdt6PUDkuSc+9cex/xa0kvOuT+FXpdJuups081KS0vdunXrwopPkqoaW/TI2kN6ZO0hVTX2P7Q8KzVR0/IzNC0vQ9PyMzQ1P12F2Wm9EkrR5tQ1NL4jEFRHIKj2zq7nncHeX4ack57aWq0/b6hQerJf91w5VXcunKzUpNj70rK/7qReKuu6o5voS9CiknxdVZKn8aEF0ro1NLfrzxsO649vHlR5zYle50n2JygvM1nVja3qDDr5EkyzC7N0yeTRumBCtpITe3fYZqYkX4ISfQlK9FnoZ0LYf+ug09t/p47AO38zJw1JfcBI4dT1JToQfOcRdE6dAaeA6112vLVTB+ubVVHfrIOhR01TW7/nT/InaOnsAn14/kRdPCnn7RsCB46e1IOrdmnFpkplpSbqpncXaeWWKlU2tuqKGXm6/9oSzS488yjGjYca9N2ndur1vUdVlJOqe66cqrzMrilo3f/Ee96AeKes6+FP6N03+H2m07sHJ6kz4NQZPPtnQXedQ9HvdH8mvf047e/2dlmg6+/lD9Wd5EtQkr/r4UswdQac2gNBdYb6ypNtnfrDGwf18q5ajc9K0eevmaEPXVTUa3j7QJ1o69Qru+v0UlmN9tae1Pwpo3VVSb4umJB9zueMhINHm/Xgs2V6YmOlstMSdc+VUzVj7MCTVQndf1f/O3/bnLSkXp+diD2tHQEdqm8eknP3df3RHgiOqG2ru/vKJP87/ZmZ1NHZ1Zd0//6dASengf/ePf9N+RO4RhtuAs71agNtHUFVNbbowNFmHahv1qHQdUJz+8CmLmem+FWYnaoFU8foPTPzNW/yaG4AnaYjENT5X3lGd1w2SQ9cd55ncUSiX+2+vmoPBNXe2X2N1dWH9jrWSau2V+vxtw4rI8a/aw+EmQ1ZksgvaZekxZIOS1or6cPOuW09jnmfpPskLVXXVLSfOufmne3ckUoSdesMBLV6d6321vYeut4RcDp0rFnlNSe0p+aEjg7jOYVJ/gR9/NJJ+tSVU5UzgoY9dq+tVFbdpIJRKSrIStH47FTlpCXKzHSyrVMbDh7Tmr1H9cbeem2qaFBHYORcHAE4lZk0PitVE0anqnh0mopy0pTWx4d0RrJf155fcMb+cFtlo773dJle3lWruROy9aUlJbp0au6AY3HOafXuOn3v6Z3aVnn8nH4fSNlpibr3qmn6aB8jt0aarYcb9b1nyrR6V23Y5zKTnv38FZqWH79D/mNdRyCoG37xKv0DEEXJ/gQVj07TxDFpKh6droKsZCX0MWtkVEpi6HtFigqyUpk+PkDX/eRvGjsqWf91x1m/1g+Zjz38ZkQ+Rwcjufu79lVTh/1C5UOWJAqdfKmkH0vySXrYOfdtM7tHkpxzv7KuW6g/l7REUrOkO5xzZ83+RDpJNBjHTrZrT+0JVUd5Ucv+9Lyz0X0XxZeQ0OtOsySNz059+y52PGtpD6i85oSCfbTxQGg0Qvedto7Orjtvg7nz1BeTdd2x93fdNfcndD2XNCT1ASNJgpl8CSZf98/QI8FMfl/oZ6gsPbnrLl+SP7JDu+tOtGlMetI5Tz0OBp3Ka090jSDs4593d1n3v/2gkwLBU0cFtXe6fkcHDeazYKj6ue44Ek77O/X3twsE37k7131nLhB0b/ePST1GT03Pz1BmSnxNvyqvOaGTbZ0DOvb0kcVdo+o69NnlG/XFa0t076JpQxssztl/vrpPX//Ldn3x2hJNHBP5NTL7u/7wjZBlFLru9J86SrsjEFTQ6Z2RdaHfubt/GqiukSinjsAa7GgkeOeU0ZWhNpDoS9C4rBTlZSQrgSFhQ+bzj2zUmr1H9foDiz2pf/2BY7rxl6/po5dM1Pwpo8M6lz/BukY7+3xK8r8zAruvrqRgVMqI2bSkvyRRRNKkzrmVklaeVvarHs+dpHsjUVe05KQnqTQ9vMYGb6Um+TSniMWuAQxcbpgf+gkJFtcLOGLwpuWHvy7Sw6/s03M7jpAkilH1J9v1o2d36fLpufr0VVNHzPqXAOJbSUGmHn/rsBqbO5SVFv0bPD97YbdGpyfpgaUzz7pzNgZnZK6uBQAAECcWnzdWGw81qO5E/+tywTsPrirTyfaAvnL9LBJEAEaMkoKum2JlR5qiXvfmiga9VFaruy6bTIJoCJAkAgAAGMbeMzNfzkkv7KzxOhScZnvlcf3pzYP66CUTNZ1RhgBGkJndSaLq6K+19tPny5WVmqiPLZgY9brjAUkiAACAYez88aM0LitFz+844nUo6ME5p6//ZZuyUhP1+atneB0OAERUwagUjUrxa2d1dEcSba88rud2HNGdCyfH3TqG0UKSCAAAYBgzM71nZr7+trtOrR0D2+IZQ2/llmq9sa9e//faEk/W6wCAoWRmmlkwSmVRThL9/MXdykz26+MLJ0W13nhCkggAAGCYu/q8sWpuD2jN3qNehwJ17bD6Lyt36Lxxo3TrxcVehwMAQ6KkIFNlR5oUiR3TB2LXkSat3FKtjy+cpKxUku9DhSQRAADAMLdg6hilJvr0/A7WJYoFD63eq8MNLfrq+2fJxxbcAEaokoJMNbV2qrKxNSr1/fyFcqUn+XTnwslRqS9ekSQCAAAY5lISfbpseq6e33Ekand00bfDDS365cvlet+ccbpkyhivwwGAIRPNxav31J7QXzdX6u8XTFROetKQ1xfPSBIBAACMAFefl6/KxlbtqIr+dsR4x9dXbJMkPbB0pseRAMDQ6t61MRqLV//ixXIl+RP0icunDHld8Y4kEQAAwAiwaGa+JLHLmYdWbavWqu1H9LmrZ6goJ83rcABgSGWlJmp8VsqQL159qL5ZT2ys1EfmT1RuRvKQ1gWSRAAAACNCfmaK5k7I1nM7WZfICyfaOvXVFds0syBTd13GehkA4kNJQeaQJ4me2VatQNDpDnY0iwqSRAAAACPE1TPztelQg2qOR2cRUbzjR8/uUlVjq779wTlK9HGJDSA+lBSM0p7aE+oIBIesjtf2HNWU3HRGaEYJn2AAAAAjxOLzxkqSXmA0UVRtPdyo/3x1nz4yv1jvnpjjdTgAEDUzCzLVEXDaW3tySM7fEQjqjb1Hdek0NgKIFpJEAAAAI8R54zI1PitFz+0gSRQtgaDTPz6+RaPTk3X/EharBhBfSgq6F68emh3ONh1q0Mn2gBZOzR2S86M3kkQAAAAjhJlp8Xlj9Up5rVo7Al6HExd+9/p+ba5o1FffP0tZqYlehwMAUTU1L0P+BBuydYleLT8qM2nBVEYSRQtJIgAAgBFk8Xn5au0I6rU9dV6HMuJVNbboB6t26YoZebr+XeO8DgcAoi7Jn6ApeelDlyTaU6fZ47OUnZY0JOdHb/5w/mMzGy3pEUmTJO2XdLNz7lgfx+2X1CQpIKnTOVcaTr0AAADo2yVTxigtyadfvLhH6/afelnmTzB97NJJbCEcIV9fsV0dgaC+tWy2zMzrcADAEyUFo/TWwV5pgLA1t3fqrYPHdCc7RkZVWEkiSV+W9Lxz7jtm9uXQ6y/1c+wi5xy3tAAAAIZQSqJPN15UpOVrD2pzRcMp73UEnOqb2/WtG+Z4FN3I8Vp5nZ7eVq0vXlui4jHsuAMgfs0syNRfNlXqRFunMpLDTTG848199eoIONYjirJw/4LLJF0Vev7fkl5S/0kiAAAARME3b5itb94wu1f5A3/eokfXVeizi2coL5PRROcqGHT69sodKsxO1V3c4QYQ50rGdi1eXVbdFNEdHl/bc1RJvgRdPGl0xM6Jswt3TaKxzrkqSQr9zO/nOCdplZmtN7O7w6wTAAAA5+CTV0xRZyCoh1/d53Uow9oTmw5rW+VxffHaEqUk+rwOBwA81b3DWaTXJXq1vE4XFmcrNYl+NprOmiQys+fMbGsfj2WDqGehc+4iSddJutfMrjhDfXeb2TozW1dbWzuIKgAAAHAmk3LTdd2ccfr96wd0vLXD63CGpdaOgH7wzC7NLhylD8wd73U4AOC5opxUZST7VVZ9PGLnPHayXdurjuuyaUw1i7azJomcc1c752b38XhC0hEzGydJoZ81/ZyjMvSzRtLjkuadob6HnHOlzrnSvLy8c/mdAAAA0I9PXTlVTW2d+sOag16HMiz956v7dbihRf+49DwlJLBYNQCYmWaMzdDOCI4ken3vUTknXUqSKOrCnW62QtLtoee3S3ri9APMLN3MMrufS3qvpK1h1gsAAIBzMLswS5dPz9VvXtmn1o6A1+EMK/Un2/VvL5Zr8cx8XcpCqgDwtpKCUSo70iTnXETO92p5nTKS/ZpblBWR82Hgwk0SfUfSNWa2W9I1odcys/FmtjJ0zFhJr5jZJklvSnrSOfd0mPUCAADgHH3qqqmqO9Gm/91Q4XUow8pPn9+t5o6AHlg60+tQACCmzCzIVENzh2qa2iJyvlfL6zR/8mj5feGmLDBYYe1u5pw7KmlxH+WVkpaGnu+VNDecegAAABA5C6aM0dwJ2fr1y3t1S+kELsIHYF/dSf1+zQHdcvEETcvP9DocAIgp3YtX76xu0thRKWGd63BDi/YfbdZHF0yKQGQYLK4IAAAA4oyZ6VNXTtXB+mY9tbXa63CGhe8+tVPJ/gR97urpXocCADFn5ts7nIW/ePWr5XWSpIXTxoR9LgweSSIAAIA49N5ZYzUlL12/fGlPxNaQGImcc1q1rVpPb6vWJ6+cqvzM8O6QA8BIlJ2WpLGjkrWzamCLV9c0teq1PXV9vvdaeZ1yM5JUMpZRm14Ia7oZAAAAhqeEBNM9V07V/Y9t1urddbpyBrvKdgsEndYfOKantlbpma3VqmxsVWF2qv7h8slehwYAMat04mg9salSk3PT9elF0+TrZwfIZ7cf0f2PbdKx5g7dcMF4ffOG2cpMSZTUlZh/dc9RXTo1V2bsIOkFkkQAAABx6oYLCvXDVbv0w2d3aUpuuiaMTvM6JE81t3fqu0/t1JNbqlV3ok1J/gRdMT1XX3hvia6ZNVZpSVw6A0B//vXGOfIlmB58dpf+Vl6nH99ygcZnp779fmtHQN9+cod+t+aAZo0bpVsuLtZDq/do/cFj+smtF+qi4hztrjmh2qY2ppp5yGJ5eHFpaalbt26d12EAAACMWI+tr9D9j22Sk3T59DzddvEEXT1rrBLjcDHrLz22WY+uP6Sls8dpyewCLZqZr4xkEkMAMFDOOf15w2F95Ymt8vsS9N0b52jJ7HEqq27SZ/70lsqONOmuyybr/iUlSvb7tG5/vT67fKOqj7fqC9fMUEqiT9/863b97f5FcX/jYqiZ2XrnXGmvcpJEAAAA8a2qsUWPrq3QI2sPqrKxVbkZybqptEifuHyKRqcneR1eVKzcUqVP/2GD7l00VV+8li3uASAc++tO6jPL39LmikYtnpmvV8rrlJni1w9umqurSvJPObaxpUP/9PgW/XVzlRJ9pnFZqVp9/yKPIo8fJIkAAABwRoGg0+pdtfrjmwf1ws4aLSrJ13/c3uv6ccSpbGjRkh+v1uS8DD12z4K4HEUFAJHW3hnUg8+W6dcv79WVM/L0g5vmKi8zuc9jnXP6n/UV+tqKbbptXrH++fpZUY42/pAkAgAAwIA9uKpMP3+xXKu/OLKH/AeCTh/+9zXaerhRT37mck3KTfc6JAAYUWqb2pSbkTSghahPtnUq0ZegJD/J+qHWX5KI//MAAADo5bZ5xTJJf3jjoNehDKlfvbxHb+yr19eXzSZBBABDIC8zecA7laUn+0kQeYz/+wAAAOhlfHaqrpk1Vo+sPajWjoDX4QyJjYca9KNnd+n6d43TjRcVeh0OAACeI0kEAACAPn1swSQda+7Qk5urvA4l4k60deqzy9/S2FEp+vYH5wz4LjcAACMZSSIAAAD06dKpYzQlL12/XXPA61Ai7msrtulQfbN+dF4OAT8AAAhKSURBVMsFykpN9DocAABiAkkiAAAA9MnM9NFLJmrToQZtrmjwOpyI+evmSj22vkL3LpqmeZNHex0OAAAxgyQRAAAA+nXju4uUluTT714fGaOJDje06IE/b9GFxdn6zOLpXocDAEBMIUkEAACAfo1KSdQNFxZqxaZKHTvZ7nU4YQkEnT6/fKOck35yy4VK9HEpDABAT3wyAgAA4Iw+tmCi2jqD+p/1h7wOJSz/9mK53txfr28sO1/FY9K8DgcAgJgTVpLIzG4ys21mFjSz0jMct8TMysys3My+HE6dAAAAiK6ZBaM0b9Jo/X7NQQWDzutwzsmGg8f04+d36wNzx+uDF7LdPQAAfQl3JNFWSR+StLq/A8zMJ+kXkq6TNEvSbWY2K8x6AQAAEEV/v2CiDtY36+VdtV6HMmhNrR363PKNKhiVom99cDbb3QMA0I+wkkTOuR3OubKzHDZPUrlzbq9zrl3ScknLwqkXAAAA0bXk/ALlZiTrt6/v9zqUQfvqim2qONasn9x6gUalsN09AAD98UehjkJJPSewV0iaH4V6AQAAECFJ/gR9eN4E/fSFcl3yL897Hc6AOTkdOd6mzy6ertJJbHcPAMCZnDVJZGbPSSro461/cs49MYA6+hrP2+9kdjO7W9LdklRcXDyA0wMAACAa7lg4WQ0tHWrrCHodyqCMz07VvYumeh0GAAAx76xJIufc1WHWUSFpQo/XRZIqz1DfQ5IekqTS0tLhuTIiAADACJSTnqRvLJvtdRgAAGCIhLtw9UCslTTdzCabWZKkWyWtiEK9AAAAAAAAGKCwkkRm9kEzq5C0QNKTZvZMqHy8ma2UJOdcp6T7JD0jaYekR51z28ILGwAAAAAAAJEU1sLVzrnHJT3eR3mlpKU9Xq+UtDKcugAAAAAAADB0zLnYXfbHzJoklXkdB4aNXEl1XgeBYYP2gsGgvWAwaC8YLNoMBoP2gsGgvaA/E51zeacXhjWSKArKnHOlXgeB4cHM1tFeMFC0FwwG7QWDQXvBYNFmMBi0FwwG7QWDFY2FqwEAAAAAABDjSBIBAAAAAAAg5pNED3kdAIYV2gsGg/aCwaC9YDBoLxgs2gwGg/aCwaC9YFBieuFqAAAAAAAAREesjyQCAAAAAABAFMRkksjMlphZmZmVm9mXvY4HscXMJpjZi2a2w8y2mdlnQ+VfM7PDZrYx9FjqdayIDWa238y2hNrFulDZaDN71sx2h37meB0nYoOZlfToRzaa2XEz+xx9DLqZ2cNmVmNmW3uU9dunmNkDoWuaMjO71puo4ZV+2sv3zWynmW02s8fNLDtUPsnMWnr0M7/yLnJ4oZ/20u/nD/0L+mkzj/RoL/vNbGOonD4GZxVz083MzCdpl6RrJFVIWivpNufcdk8DQ8wws3GSxjnnNphZpqT1km6QdLOkE865H3gaIGKOme2XVOqcq+tR9j1J9c6574SS0TnOuS95FSNiU+gz6bCk+ZLuEH0MJJnZFZJOSPqtc252qKzPPsXMZkn6k6R5ksZLek7SDOdcwKPwEWX9tJf3SnrBOddpZt+VpFB7mSTpr93HIf70016+pj4+f+hfIPXdZk57/0FJjc65b9DHYCBicSTRPEnlzrm9zrl2ScslLfM4JsQQ51yVc25D6HmTpB2SCr2NCsPQMkn/HXr+3+pKNAKnWyxpj3PugNeBIHY451ZLqj+tuL8+ZZmk5c65NufcPknl6rrWQZzoq70451Y55zpDL9dIKop6YIhJ/fQv/aF/wRnbjJmZum6k/ymqQWFYi8UkUaGkQz1eV4gEAPoRyoZfKOmNUNF9oaHbDzN9CD04SavMbL2Z3R0qG+ucq5K6Eo+S8j2LDrHsVp16YUUfg/7016dwXYOzuVPSUz1eTzazt8zsZTO73KugEHP6+vyhf8HZXC7piHNud48y+hicUSwmiayPstiaE4eYYGYZkv5X0uecc8cl/VLSVEkXSKqS9KCH4SG2LHTOXSTpOkn3hoblAmdkZkmSPiDpf0JF9DE4F1zXoF9m9k+SOiX9IVRUJanYOXehpC9I+qOZjfIqPsSM/j5/6F9wNrfp1Jtd9DE4q1hMElVImtDjdZGkSo9iQYwys0R1JYj+4Jz7syQ554445wLOuaCkfxfDbRHinKsM/ayR9Li62saR0PpW3etc1XgXIWLUdZI2OOeOSPQxOKv++hSua9AnM7td0vWSPuJCi4SGpg0dDT1fL2mPpBneRYlYcIbPH/oX9MvM/JI+JOmR7jL6GAxELCaJ1kqabmaTQ3dxb5W0wuOYEENCc2t/I2mHc+6HPcrH9Tjsg5K2nv7fIv6YWXpogXOZWbqk96qrbayQdHvosNslPeFNhIhhp9x9o4/BWfTXp6yQdKuZJZvZZEnTJb3pQXyIIWa2RNKXJH3AOdfcozwvtGC+zGyKutrLXm+iRKw4w+cP/QvO5GpJO51zFd0F9DEYCL/XAZwutMvDfZKekeST9LBzbpvHYSG2LJT0UUlburdzlPSPkm4zswvUNcx2v6RPehMeYsxYSY935Rbll/RH59zTZrZW0qNmdpekg5Ju8jBGxBgzS1PXLps9+5Hv0cdAkszsT5KukpRrZhWSvirpO+qjT3HObTOzRyVtV9e0onvZeSi+9NNeHpCULOnZ0OfTGufcPZKukPQNM+uUFJB0j3NuoIsYYwTop71c1dfnD/0LpL7bjHPuN+q9rqJEH4MBsNDoVgAAAAAAAMSxWJxuBgAAAAAAgCgjSQQAAAAAAACSRAAAAAAAACBJBAAAAAAAAJEkAgAAAAAAgEgSAQAAAAAAQCSJAAAAAAAAIJJEAAAAAAAAkPT/AZ/CJdfb+C9PAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -1975,7 +2051,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABIUAAACMCAYAAADiDBl2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3xUVfr48c+Zkp6QhJLQQxUQBRRBFARFxMKKImCX9beuuxZ013Vdv67r4trrWtey9oYFG2sBBEFE6UiVFiCd9F4nM/f8/jiTKSmQQKh53q9XXpm5c+bOmXrvfe5znqO01gghhBBCCCGEEEKItsV2pDsghBBCCCGEEEIIIQ4/CQoJIYQQQgghhBBCtEESFBJCCCGEEEIIIYRogyQoJIQQQgghhBBCCNEGSVBICCGEEEIIIYQQog2SoJAQQgghhBBCCCFEG+TYXwOl1BvAJCBXaz24kdvHAV8Ce7yLPtNa/2t/6+3QoYNOSkpqUWeFEEIIIYQQQgghRNPWrl2br7Xu2Jy2+w0KAW8BLwDv7KPNj1rrSc15wDpJSUmsWbOmJXcRQgghhBBCCCGEEPuglEptbtv9Dh/TWi8FCg+qR0IIIYQQQgghhBDiqNJaNYVGKaU2KKW+VUqd2ErrFEIIIYQQQgghhBCHSHOGj+3POqCn1rpcKXUh8AXQr7GGSqkbgRsBevTo0QoPLYQQQgghhBBCCCEOxEFnCmmtS7XW5d7L3wBOpVSHJtq+qrUerrUe3rFjs2oeCSGEEEIIIYQQQohD4KCDQkqpRKWU8l4e4V1nwcGuVwghhBBCCCGEEEIcOs2Zkn42MA7ooJTKAP4JOAG01i8DU4GblFJuoAq4QmutD1mPhRBCCCGEEEIIIcRB229QSGt95X5ufwEzZb0QQgghhBBCCCGEOEa01uxjQgghhBBCCCGEEOIYIkEhIYQQQgghhBBCiDZIgkJCCCGEEEIIIYQQbZAEhYQQQgghhBBCCCHaIAkKCSGEEEIIIYQQQrRBEhQSQgghhBBCCCGEaIP2OyW9EEIIIfYjKQlSU490L4Q49Hr2hJSUI90LIYQQQrQSCQoJIYQQBys1FbQ+0r04OEod+88BzPNoypF+fsfDa7yv11cIIYQQxxwZPiaEEEIIIYQQQgjRBklQSAghhBBCCCGEEKINkqCQEEIIIYQQQgghRBskQSEhhBBCHFG7doHHc6R7IYQQQgjR9khQSAghhBBHzJtvQt++MHPmke6JEEIIIUTbI0EhIYQQQhwRWsNf/2ouv/UWZGcf0e4IIYQQQrQ5EhQSQgghxBGxdStUV5vLDgcsWdKMO1VmgOU+lN0SQgghhGgzJCgkhBBCiCNi2TKTLQRQVgYLF+7nDumfwRfdYcX1h7xvQgghhBBtgQSFhBBCCHFEzJsHlZX+64sW7aOx1rDmNnM5/VMoSz6kfRNCCCGEaAskKCSEEEKII+Knn4KvZ2buo3HFHnAVeq8o2LvgUHVLCCGEEKLNkKCQEEIIIQ47lwvy84OXhYfv4w45P4Dy7rZ4KiHzq0PWNyGEEEKItmK/QSGl1BtKqVyl1OYmbldKqeeUUslKqY1KqVNav5tCCCGEOJ5kZOwnCFRf1tfgrvBfz1vW6n0SQgghhGhrmpMp9BZw/j5uvwDo5/27EXjp4LslhBBCiONZSoqZcSxQ3UxkjaofBNKextslJLRsuRBCCCFEG7bfoJDWeilQuI8mk4F3tLECiFVKdW6tDgohhBDi+JOaCm7vzPKdvXsNLlcTjS031NQba2ZzNt42O9s/pRmYy1qb5UIIIYQQIkhr1BTqCqQHXM/wLhNCCCGEaFR6OlRVwbnnQlYW3HnnPhpXZoAtNHiZ1VQEaT8q0iB7UXDgSAghhBCijWqNoJBqZFmje1pKqRuVUmuUUmvy8vJa4aGFEEIIcSxKSQHLgnvuMdf/9rd9NK7Y0zAzyFPV8gd1V8L8kbD4Akif0/L7CyGEEEIcZ1ojKJQBdA+43g3Iaqyh1vpVrfVwrfXwjh07tsJDCyGEEOJYlJYGSsGIEeZ6RAT06NFE4/IU0G6wh8GQhyG6/4E9aMp7UFsKuhbW7Ss1SQghhBCibWiNoNBc4DrvLGSnAyVa672tsF4hhBBCHKf27oUTTzTZQmDqC40Z00TjygxwV8EJt8Ogu2DUuwf2oKkfmensAapzD2wdQgghhBDHEcf+GiilZgPjgA5KqQzgn4ATQGv9MvANcCGQDFQC1x+qzgohhBDi+JCXB+ed5y/tExMDw4c30bhiD2BB0rWg7BA3FJyxLXtAjwvyfvZfV61xXkwIIYQQ4ti236CQ1vrK/dyugVtarUdCCCGEOO6VlUFSkhk2VmfAgCYaV6SBPQKi+5nrniroNLplD1iwAmwhYHnnva/LGBJCCCGEaMPkNJkQQgghDiutzfTzAweCI+D0VK9eTdyhKhPaj/AHchxR0Glcyx60eLOpJSSEEEIIIXwkKCSEEEKIw8rlnU2+d+/g5YmJTdyhpgCi+4DyRpBsdog9qWUPWrLlwGYsE0IIIYQ4jklQSAghhBCHVUUFOJ2QkBC8PDKyiTt4qiCqrxlCVieqdxONm1C8oWXthRBCCCHaAAkKCSGEEOKwqqgAux3atw9eXtvU6C5PNbQbCLaA3Zbwzi170PI95v/QR2FyCoTEt+z+QgghhBDHof0WmhZCCCGEaE3l5aaWUFRU8HKXC8LD6zW23KA9ENE9eLktrPkPqDXU5EFoBzOtPTYY8KcD6boQQgghxHFFMoWEEEIIcVhVVEB0NHg8wcvrpqcP4q4AmxPC6o01a0l9IFcRoKDzRLBcYA+B7tNa2m0hhBBCiOOOBIWEEEIIcVhVVJj6QW53Mxq7y02B6ZC44OW6OXf2qkwHexh0uwScMWZZVFNTnQkhhBBCtB0SFBJCCCHEYVVeDhERDTOFlDL/X1r9EiEPhJgrdUEhewuGi9VXlQUoiBvmXyYzkQkhhBBCSFBICCGEEIdXRYUJCllW8PK6OtILdy+k1vJWnXZXgCOikcwg1fwHdJWAtiCia8Dd91FWMTHRRKgC/xITm/94QgghhBDHCAkKCSGEEOKwqqgwBaXr1xCy281/jw5IIXKXgyPKFJwOpFqwC+MuhZD2QMADBk5vX19OTvOWCSGEEEIc4yQoJIQQQojDqrwcwhoZDebwJu+4PC4AtNZQWw6OSDMDWaB9ZfrUV1sK4QngXS8QPL29EEIIIUQbJXtEQgghhDisamrM8DFVbwSY02n+V9ZW+v+7y01Wj64/1qylQaHOB9FjIYQQQojjkwSFhBBCCHFYWZYJCtVP1qkLEpXUlABQVF3kHT4WQdDQLzDT1DdXTYGZ0r4l2UVCCCGEEG2ABIWEEEIIcVhZFoSENMwUqlNaXQpAcXUxWDXgCD+4B6wpAGc02FsQSBJCCCGEaAMkKCSEEEKIw8qyTJZQU0GhMlcZ4A0KaQvsUbRotrH6aovB2Q5sIQe+DiGEEEKI45DkUQshRAslJUFq6pHuhTi66AYxi549ISXliHTmqGdZ/pneG1PhqgDqgkLaDBVrqnFzuEogtMOB318IIYQQ4jglQSEhhGih1NSGU2kfUk0dDB/WToh9UqrB+3EwMYzjndb7fn0q3abQdHF1MYRaLZt+vjG1pRASd3DrEEIIIYQ4DsnwMSGEEEIcVvsbPlbHN3wMOKjhY+6KlgWFEhKat0wIIYQQ4hgnmUJCCCGEOKwaSaxqVFFVEURHctDnsLTb1BRqruxs878uaiVZeUIIIYQ4TklQSAghhBCHlc1m4iyNxVp0wMLcylwgqWFK0WeJUJ0D2OAqz/4fUFvgiDyYLgshhBBCHJeadepNKXW+Umq7UipZKXV3I7ePU0qVKKXWe//ua/2uCiGEEOJ4UJcp1FhQqMpd5bucW5HrrSdkBTeqzvFeqLe8Sa1Ql0gIIYQQ4ji030whpZQdeBGYAGQAq5VSc7XWv9Zr+qPWetIh6KMQQgghjiM2m6kr1Jji6mLf5czSTMCbVsRBDOHSWoJCQgghhBCNaM4e0gggWWu9W2vtAj4EJh/abgkhhPCRorfiOGOzgcfTeKZQYFAoqyzLG8w52Jo+FjK3hhBCCCFEQ83ZQ+oKpAdcz/Auq2+UUmqDUupbpdSJja1IKXWjUmqNUmpNXl7eAXRXCCHaoOzs4KNnrf2FcIU4BtlsUFlpAkP1BQaFfMPHLOvg4kJaB9cl+iwRPlDwgf0gViqEEEIIcexrTlCosTlg6++arQN6aq2HAM8DXzS2Iq31q1rr4Vrr4R07dmxZT4UQQghxXHA4oKqqYaaQx+OdcQxw2BxU1FYACqwqml8/qBHKFjC1PQdQk0gIIYQQ4vjUnKBQBtA94Ho3ICuwgda6VGtd7r38DeBUSnVotV4KIYQQ4rgREWEyheqrrfVnCsWExJiFyg7u8oN8RBUcFBJCCCGEEEDzgkKrgX5KqV5KqRDgCmBuYAOlVKJSJi9bKTXCu96C1u6sEEIIIY59kZFQXd1wudvtDwrFhccBYNnDIGBGsgOi7EhWkBBCCCFEQ/udfUxr7VZK3QrMB+zAG1rrLUqpP3pvfxmYCtyklHIDVcAVWjdWPlIIIYQQbV1UlBk+Zqt3asqyoKjaDB+LCTWZQtU4iHBX0vho9mZSCjyNRKGEEEIIIdq4/QaFwDck7Jt6y14OuPwC8ELrdu3YlZQEqalHuhfiWNCzJ6SkHOleiCPGXQUrfwdlO2Hoo5A4vsWrUPcrbMqG575GKvYKcZSKjDTDxxoLCuVX5gPQLrQdAOUWRHgqvdk+B0jZwFV64PcXQgghhDhOyfysh0Bqqimeedj+UE3/Hc5+yF+L/yR42MatvAHSP4fCNbD0ErDcgAn0dHi8+WXZrObWSindDj9fC+vulKwJcdiNe2sc6n6T7RMZCRUVpuB0fbkVuQDEhscCUGpZpqaQLaBxWELLHtweAbXF+28nhBBCCNHGNCtTSBx/3B43SinsNpmOV4gjImseZHwJljc446kMOugtqGrlsmw1BbBwHFRngy0MKlJh9MfB03QLcQgFTjUfFQXl5eB0NmxXlynUIdwERotr3eCuABXQeEq2mVK+uZzR4Co6oH4LIYQQQhzPJFOojXI+6KT94+2PdDeEaLt2PA+eCog7BZKuAtV6MXqtNZWuelM7rbwBXIXmslUNWd9KQEgcVgWVJtBZ7ir3FZp2u4Pb2O2wOms1AK/98hoAa/O2e4On+sAf3BljAqNCCCGEECKIBIWOZlrDmttgTgdYNMGcKQXeWPcGjn8FHEAmNJFG39RyrzJXWWv1VAjREh4XZH8PsSfDhKUw4r8w4lUAaj21zV5NYOZF4P3yKvKIfCSSwipvEKimwASB0ND7/0HiuSYgJcRhlFORA0BqcSpRUSYgVFQveScszASNAm0ryQDtAfdBbLOccSZTyDtEs8XDzwLMmwcjRsC0aVBScuBdEkIIIYQ4GkhQ6Gi2/m+w63VwFUD+Mvh+ImjNgt0L8GiPv45IdrYJINWpK1iTnd3oausmhmt2HRIhROsqWAG2EDj9TbCHgyMCekwFIKM0w9dsf5M4ppWk+S5nlWX5Lu8s3Gn+F5j/ZH4FNiec9goMfx7O+hK6XNRaz0aIZqm1TOAypTiFyEgTFMrLC27j8YDHCi6avreqzARzqus1bonQeHCXgrcPTGl8+7g/ixfDZZfB6tUwdy6cfXbw5lcIIYQQ4lgjQaGjVflu2P68qTMS1gksFxSvB6XYW7YXgMzSzP2u5p0N7/gKe9bZW773kHRZCNFMpdsgrCO0G2hmRQKwhQLmgLlOXWZFU1KL/ZXKU0v8l+uCQXXBIdI/h6g+0HO6CUA5IkxASojDJDDAmVKcQkSECQplZAS3KywEXW+YWHZ1sckUqjqIbVdIPNQU+oNCB8DthssvN7OmAbhcsHWrjMIUQgghxLFNgkJHq50vm53gUW/DJZlwwXrA7HnuKtoFwI6CHftdzdqstUDwMJNdhbt8l1syVEUI0UpKd0KHUf6hLOArMh0YFAq83JjAQFBggGhb/jYAtudvNwtKtkCva0x2Uh176IH1XYgDUFTtHye2s3AnNpspMr1tW3C71NSGGax5FfkmaFqefOAdCInzBpUOPEP2229NHaSpU83/LVsgIuLAuySEEEIIcTSQoNDRKuV96Hk5dJtiDhaj+sHw5wDILDMZQs0JCtVlCmzN2+pbVhdUguDhJ0KIw6RkM8QMAEdkg5t2F+32Xd5fUCjwuxwYIFqattT8T11qxrZUZZrhYraA2Zvs4QfYeSFaLvCzvCFnAwDh4ZCc7M+8AVizveGwruKaYrCHmQw7j+vAOuCMMUGhgyjo/uabkJgIb70FoaHQpw98+ukBr04IIYQQ4qggQaGjkbsCqnNh0F/BGWWWOcKgxxVBKfibczfvd1V1waCt+f6gUGAwKfCgUghxmJTvhtjB/qFjAX7N/9V3eX9BobqMoPqXV2auBGB5xnIz45i2ILJ78J1tjcwFLsQhEvhZXp+9HoD4eBMUcnnjPDU1sGp7eoP7VtZWminly/eAp+rAOuCMhuqcg8qQW7UKbrsNQrwJd6GhpuC0EEIIIcSxTIJCR6PS7RDaEWIGBi+3asityPVd/Sn9p/2uKqUkBYBfsn/xLduYs9F3OXAoGQBlyZC/AtwHuOMthNg/dwVE9mz0pk05m3yXAzP8GvNrnj+AVBfs1VpjaYsQewi1Vi26PNXUJVMSBBJHzp6iPQDEhMb4hjMnJMDKlf4hWNXVsHm9+Zx2CO/A9EHTAYgLjYOwRCje6BtmibuSFnHGABpq8g+o/7W1kJMDl15qhr0JIYQQQhwvJCh0NCrZCtH9Gu702kKDsnzqUvCb4gpIs1+4e6Hv8tq9a32XfdkFnmpYeSN8c7KZ5ex/fUxxayFE69NuX2Hp+nzFoQnO/mlMWkkaTm/GT13busBxYlQiAMWVORDSHqyag+62EAeqbtvVJ64PYKad79rVTOme6Z0zISwMtuysAOCkhJN4auJTAGilIaIblO30F4rWwTOU7VfdFPSl+x923ZjkZIiJMYGsQFJTSAghhBDHOgkKHY2qcyCyB3WFpX0c4b4d66TYJGDfhaKTC01RTofNEXRwmV2eTXRINBAwBG3t7ZDyHiSMg97XmYBQYFFaIcRB2Vu2l9Lq0oAlATMsfZYIHyhc75uf5O4xZqjX5rymh4iW15QDYLfZsSs7Za4yLMvyBZV6xPQAILMkxTtUTObNFofG3r2QlRU8NfuW3C2U1ZT5rtcNGYtwmihKSlEKSUnmtk8+AcuCn3+GWrvJIooJjSEqxAyfLqspg6jepnHOD2Y4ZP3t4/5EdDPbtcyvDigTNjPT1BCqbGGCkhBCCCHE0U6CQkcjy2WmjLbZG9xUN1ykb1xfAPYU72lyNXVtA8/MFlWZGWA6RHQAYF32OjNkbM+7cOpzMPpjGPo4TDqws6lCiMZ1eboLnZ/ubK7YnCY7r061mXp+ZbU5qt5btheForK2EnfgDGUBVmWtMnd1V+PxZk3sLNzpm46+V1wvANLK9prMpMCDaG8Qig8a/sYI0VwpKXD22dCrF/TuDaNHm2nb3ZabwS8NZvqc6b62dRmqa7LWAPDZ1s/o3t3U5Xn4YXjtNfjDH4Bws41qF9aOSKcpxF5RWwER3U123ZYHTS2uXx9pWWfDOptt695vAMsbWGq+mhqIjjbBKyGEEEKI44kEhY5GSpmT+nWnXX0HcIov1zwN+IeOLdqzqMnV1GUB9W/fHzDDS77Z+Q3gn3WsuLoYK/1LiB8BSVeCIwoc4d76C0ZJdQkVropWfYpCtCWFVYWAt2AugMNbNLeeVd44kVu70d7Mns05jWcL/bL3lwbLVmeu5v1N7wMwe/NsAL7etRBqCoKHq3mDUAczPbdo28rK4MwzTYbQK6+YoE5JCTgc5nMI/s+oZVm+wGWNxwxj3Jy3mZ49TVCopMQEhHbuBMJMplBcWBxOuxO7spvAZ3hX8xkuXAMfR8OWh1vWYZsdnO2g5Fczi1kjRd73RangTCghhBBCiOOFBIWORrYwqC3210zwHcDBHm/SQF5lHgDzds5rcjVvb3gbgPm75gPwya+f+M7SegLqMVSkfAjdJgcfNNr80/bGPhZL1CNRB/58hGgjKirg0UdN5kRiIlx1FWzbBt/v+d7XJr8yH6L7QMkmsLzfQ2+9k82NlP2pywiqL7DIdJ1NuZt8w3TqMowW5ewwvyG66aGmQrTUk09Cx46wdi1cfTVceSWsWGFum5dstks5FTlY2mo0o3VHwQ7f8LFAzmiTKRQbFgtAmCMMgIqQjv5kN3f5gXU6opv5v2g8fD24RXetC17ZJblOCCGEEMcZCQodjSJ7mCwCFVwzwWU1PK+/JW9Lk6tJLzFT+9YVnF60e1HjNUrKk6HTmKBAUJ2ssiz/43uk8LQQTamqgjPOgK+/hn//Gz791Aw3iYuDL7d/6Wu3aPciaDcYSraBx5uBNyUbgBxv0Ndhc2BX5ugzszSz0cezeTMdukZ39RWVRkFJTUlQu12VxSYroiJgqu+wetVyhaiT9zMsHAeznebv+/P8xZ0DvPcePPAAhIeb7CC73V90+bVfXvO125iz0VffTqFweLczBVUF9OxpZhwLpKLMCY+6und1QaEie+zBz4rZzhsIqi2BEu+282bMtrb+X2Ji0F179IBdu0wxbCGEEEKI44kEhY5GMQNNoMbm3fv0HsDt8O6XKxQh3iLQdcNS6gusM1InuTDZV2t2RNcR9I41hTtt2gJ7QJZQQL2RjzZ/5Fv83a7vDvaZCXFUsCxYvhyeeAIeeQS++w5cBxnzfP55EwCaNw8uvtgMrXnqKejUSfPexvd87eZun2tmF8xf0aCYe6g3DvzW5Le4d8y9Zpmj8VnKSmtM0epnz3+WB89+EICy6jJfhlC4IxwAt+VBh3eBrG/9B/feIJQQDSy9BPrfAtPLYFoJJF3lLVTuV1UFqalwzjnBmTM2m/lcZpVl+bYv85Pnm5pAwKUDLmX1783QslB7KHFxDc594Akzs+fVFZmOcEagUBR6rEZPXLRI3BBQB7aOXr1MJmBmvRhthYysFkIIIcQxToJCR6PoPlBbBrneWVamZMNVmixvFsHYnmPZMdMUgtZNFDlIKU4xqwqJ5uL+FwNgaYv8qnwAXrjgBW4ZcQsAFTihfLf/zgH1Rp5d+axv8Ru/vNFKT1CIIyczE4YMgTffNP9HjIAlS6C4+ODW+8or8Pe/Q2SkOTgGiIqCH9N+BPBl/szePBsrZiC4CqFgFQQUkt7lvdi/fX/6xJsC8Vvztzb6eLuKdgGQEJVAQpR3+Jm3jljnqM5U/r2ShEizvCayr5ld0JJsP9GEum3JyP9C19+APcxMeNDj8gZNXS4TDGosa+al1S8BkF5qMtMe++kx9hSZ4WN94/vSN95MkrC3fC9KwcCB9boRXoBC+YJCdcWmi6uLIbp/wwdsSdZbzAnmOQV6IyG4WJDW5i87OHDqcECXLvDxx6bodB3bkdiL0trURspeCNnfQ9muI9AJIYQQQhwvJCh0GG3bBjfeCFdcATfcYOowFIcnNkxbt4fAXg2b/wUeb7q8u5yd3pP8AzsOpGdsT0JsIRTXFPuL1wY+lncK+jE9xvDFFV/gtDkpc5WRWpwKQJfoLnSJ7gLAKk8MZH5tAlHg28leWQWpJam+dX627TOzYy7EMezqq+HWW+Hpp+G882D8eLjnHujU6eDWm58P/Rs5Zv3Pqv8A/jpeGs2CogJTM2z5b8133G2+w5neoFBiVKJvSFjdbGL1ZZRmAJAQmeAL/uwuNsHdztFmlrPOUeZ/WswwKNsJ6Z+Zx3LLvNptXmK9bU+8d3egy0UmIFTHm3EWKCrKBEPS0hqu9s31bwJQ681KK6ouYmPORgC6xXQjKiQKp81JZW0lZTVlTJwYnG0UHl+IUoroUDN8LCo0CqUURdVFpm+BmT7RJ7Qs663j6OBZ/5SzRfcfPRpefBFqvdviqipYsKD5D98qClbDvNMgbQ5gM78jO/9jisnXV/89bmJonBBCCCHatmblUSulzgeeBezAa1rrR+vdrry3XwhUAr/VWq9r5b4e09auhd/+FubPN5kEdWIWAdWN3GFFOHRdB2tugyEPQsYXbPKenewdZ9LyO0Z2JLMsk+TCZE5OODno7nVFaAd2HIhSii7RXUgtSfUFdRKiEnxBoa/KapmU8SWc/ADYw81O8geKZ7zxn1B7KB7twW25eXnNy9w9+u7WelmOX9W5UFMIaDOjW0S3huMkxGGnNSxdCp9/bg5s6wR+Jw9Ur17w88/QtavJKqizu8gEas7sfia5FbnsLNzJxrxfOb/LRZA+xxS8jeqFS0Oxt2hYQlSC77taN1NgIEtbFFSZjIpOkZ0IdYSiUKaINZDULgmAHrE9WJ+znjV0pr9VCytvgLyfoCK1wTr3JzsbFi0yGVWWZT7OXbqYIUSxsc1bR0YGrF4Nld6YVGQkDB8O3bq1uDuimdxu+OEH2LzZ/77Z7fCHWggavFiXRGZVg8375fgs0Zs5aoOr/MOR7XYYO9Zkx917r/+7VFEBuRVm+NekfpNYlbmK3Mpc1u01uwN1gc648DjyKvJILUnl7LMH89JLUFoKISEQGlNCdUCmUHRINFpr833oPB52vgC1paZOVpcLWvZihLaHqD5Q6s2+s7esQND118PcuTB5Mrz7rjnRc9VVTQwhs2oh90fzWFqbF77eMLwWqy2H7yfABeshrJM/66njGeBohR8xIYQQQrRJ+w0KKaXswIvABCADWK2Umqu1Dpz65gKgn/dvJPCS9/8xzW25fUUxD9b//mdqjLRvb2Yx8QlMUa8LGmgNrmL4vAvsfsP8ARtdZvKV7jHdAZPtk1WWxY6CHQ2CQnVTAveJM0NQerTr4cv6aRfaDofNQdfortiVndmFRbzcOQG+OwNGvQNRJui01husenri02SVZfHQjw/xU9pPjT6/7dvNQUdtrT+dXmuIiYHTTze1VtqETQ9AZQb0+6MpGI6CmnyozgNXPrhKMeXClfeAZNgh6YbHA4WF5ky2ZZkgRXy8vxBsa6uoMJkydWfQw8PNzEQhIfu+3+GmFPTrZwITY8aYfoIZDgT9TrgAACAASURBVHOwff3LX+Chh2DiRDOsJjQUyivdbMrbBMDcK+eyeM9ipn4ylW92fsNdFz0EWV9DZRpUppFea77fkc5IQuwhJEYl4rA5yKvMw9KWr7A0+A+87TY7MaExJiiklG+677qhZ/3i+wGwsSSLqzqfB1nzIPkVf6ebOfTm1VdNAe33zWz3eDzgdJrn2ZzhM5ZlgkfXXmsOouvu4/Hs+35HI5fL1NMJDI6FhMDQQ/BY27aZ4EN8vCl0HBJigifp6eY1vPXW4OBmfZWV5vP+xRdmyvfqatPf8HDw3JAN4fi3OxXewMXGB+Dk++oFGepPcQB33glTppig3kUXmd/7j+alUVRdRHRINHOvnMuDSx/kviX3kVqSil3ZfUGhjhEdya/MJ6U4hbNGDabKmxAbGgqWowybx+YLCsWExgDe4WMdTvdn+tgjIfHclr+o3afCr496Z+Nr2Rzz55xjtmXff2+Cv9DEb2pNAXw7DMb+D/rcYPqs6n7z/9DyPtepLTVDysO7mIxiaDJwBzS9f9GE9JJ0Rr0+isyyTOZMm8Nlgy478L4eq6pyzO+yVWMyyVCg3YAFYYlmaGUr7RcebcpqysgozWBAhwGouoyynJwG7TyJnXh6zp18uf1LXrzwRYYkDkFryMsz+x0ej/l9iow0qziYbevateZ3sO63FsxHODISzjoLOnQIaKwtqMw0+1zag9nPCoHwrhAaf+CdwGxzJ743kYLKAuZfM5+BHQaY7NuKVG+tPu/3yhYG0b0hMumgTgRqrdmSu4UesT18v4Et9UPKDyxJWcKtI26lfUR788K5y8FV5P1M28xJy9B4E2QP6oAFVXu9bT3etuHmt6f+EFzReqr2QulO8ARkc6sQiOxuSovUf5+aYGmLkuoS4sLbxsGX1mbfqK42aGiomeilJV/B2looLzcn0ux2s291tB3DHGrN2bKNAJK11rsBlFIfApOBwKDQZOAdbQrcrFBKxSqlOmut97akMztWb6Jqy5v0P2dK0PKb3v0rCx078CiFQmFXNv7Ubjx/6boBfcEGlHcDrbXFDy8+xMAhscT09B9sZ6cVsXfFBwyddrPZ0Hn9efb9fOT+iTKPC5tS2JSNyXFjWZS/lAL8RQMcys6djosZ3DueS0fNQCnF1uI9bMnbzNiMteyJepBaFY/Gjk15gP5U/3gzW12/Y29OGFrDaX1q+fObPVlyaTvGjbP5DkJ/mfsZCZE7SRx8JnVJ+lVpy7j+pk7ccd1LnKpuwq6r8KgItlW7UHjoWFVAVdoyeoREsRqNnv0WJVc4aRdw/zW7f0IBnV3lVKUto09YO340LxLxjnCq0pYR664GNGXJQ3go43b+Nvr32L47Gxu17KqFnW5wKgfXdBxEblRnHgLSftnGE3kTuH7SXUQ6wylxlfPBqmQevPVWCuvVvE5e9yvl6/9LWNllVJX5l8989//4ISQZbXdgUwpLW1wZdSGTKis56dI/BL1H/5z9KNUdXZzVfzwhNgcrczeTtWIYu5ffxg8/BD/e0jdeITHBotvgk3w/BEX5Fez69lVOveZ2VMCP6X2f/JvZru8ptqpxKAcazYT2o3jywzSSluwIWu+9fzqLVzuso8BdgcNmxjkMsyaT+doc0tODmlK96UVCz5+Hih9qDgS+TDI77O0Gw0Wbgtq+9eGzwDDyd31HpDOc3aWZzM9YwXVVW9jpvplydQKWtqMUlKWtYVDCapLGTME/LzPc+dZfGHXaGM7qPRa35WbJ3nV8/uzZDB50Do88Ety3e56YzNhTT+OsvuPQWrM0+xdWrv+V5cULiemcREJ4PNlVBdiwEfvlLYyaeBaDh5ohHEpBVkoeaxes4trfdSIkRJl4l0vR7/TTcbmgZ0//Y61at5wZ71yD1T6euNBoymorCLOFclHmJIYPaE+PQX19TyMvT/PmKxXM+H0EkRF2lNJorXh10StEd7W4dPgUQu1OVuf9yta0bOY9dAuvfNCHkFBl9sMUROa+T8r2fHSncygrd6K1whFSwqLtNzFj8l/oG9cLl6eWeRnL+defPfz2mjv457/CuXiyDbsdfvzRImH39Qybcg02p3+4zDeL4li1SjFlio1I0lDU4rJ3Bk5h3nur6N2zHJvNAq04s8MmesWOY9jQk5g6zUaHDorZP66gemQ1HUPbEZ73K4PRKOCnZZqZi9vx10t+R9eq17BTRbInGk05sY4wqtKWEaEtLMvD8NKBrH/tZgacdzV1u2Lbt3+JZXlo54ygOt0EakNsDhw1DsodlXSx3FSlLaOLt17RnBe70e/M6VzbbRVOnYNFGPOKzuXR0k2UPt+PSEc4le5qOobFcXPl2UTGnElM9yFY3jdp9Q+KxIREoqIcFBebHX6XC0JSX2HbnlhyXCfjsRxooKQ0nflpM5lx0Z/oE9ONIlcZ81PWsPznh/jgA4cJXnl/Xj3lmdgWn4OevABC/OlGH872kL11A2efbcNpK0NpTYnbyVcrHuaaqTeTFNsNS1t8n7WGLSu30T62jCvH/QG7zUFq2V6W527ih2d/w/VXlpDYWWG3WWit+G5ZIsm77cyYnktEmNmRd3vsPPb93zj3zPM4s+cIqj0uvs9cTfguJ9f+3zM4S/w7Z1sZwDmJW9lbb8u2e/6LNOXTjyoYdLI/IyVz8y+c9buxhJQFD+FbPG08J95xNdFd+vmW/f1P3Rl7YU9uu81cr0s4KVr+LMk5/VizuB+WZUMpKM/LoEPJ6wyd+nvqvlxlZXZKioeTlOSgtlb5fhdzUvaSNf8+Tp48I2i7Ew6UbnybyPJU7EmXwanPUrzgD/zp/ee5obuHKNdaQjx7cdm70MO9hcvOOYkZ1w0lIdGOzQZZHb+C8+Gk2CSq039iSIj5xFbUVKAUxJamU5W2jARnBL9qi55rZuI4tZpJE8bxxbft6RhfTaa7BK09OAq2U+VxEeWpQaN5855B9LyxkjHhl9Gx8iNqrXD+89G5UJ3GuafvIdThAmXez+SFH3Hm9EnEBzy3n1bF8L+v7Fxx5RWM4EkUir1hv2Pnv+9i6LkjiQ1ou21dKrb8ZfSbcJXvO1eVtgy141nef/BiLrz5Ksor7ISFephwzlye/s8bzDj/diIcYZTXVvJT6kJ+4yrHFt0fZXk/7JsfZvWS9zgNyNr5LXGh0ZTXVjIvfTmb/nchXePiOX1MFFGu1WhCyChOwpH8NGdcdU3Qju3m3OkM+/Fq7COfQ4W0B2BbSSw35NrJ/nd3IuyhVHlqSAiP55ayczljcCc6nRiwf7F7AVWr72dH5GMUV7TH0jZsyuLFnTfxlce/UZ36yVScxT2I/2A323fYadeOYJsfhMH3+q7W1sKG126lKmE6hHdHY0NpzdJNb2CL+4Vrxt1IlCOCnaXpLMpczeVP/kDvJcGzp/4yaCjhd46h5znTgvbm73vrb0waewkjeo1Ca833WWvI21zCMHsx/c6ZErTP8PN77zDsgnOI6NDdt2zH+jQGXXsDztLg2etePG0mcTfMpEsvf3C8596b6DVyHJxwW1DbmU9eTHJkBj3i38WGIr0ih1NrR5D8xRXMvHcIyubfHqUtfJ7TRkWR0P9E3/2zckJ45GGLG39XRbtoNzZl4bFshJUsZm9ZH6oiRlBV7UABsRH5nGq/m8JuD7IluQMVlXYiIzwMKrueLuP/Cj39db4qSyv49ZXLGHzFPSi7/wgm+4+z6Pm/+UHPwYqCgqd60uHyBRDuf873vPkXHs1+PahtQng8qeUV1J/m4P8u7s6jp6TDwrsAGPrKUMgZTPevNpGWFjwMe84Xb5KR9zXXjb+JcEcoeyvzWZi5ikklm9lVdQ2uiCFYlh2bTVObvxl3cSodT7kYS5uMut0pDu78R+cGv7fbV26gZus7RFZeSlVdIm1tKeGrLoYr3eYA2mvHds37r+5m2qRfCXPWgALLUmz5fhHDx/WhQy//mO/MlBL+86Kb39xwNjabzfd+3r1sNCvY4Gs36D+DeKBdJ+4deT6Mejuob57tr7NzfTZZ1VV4tBM0lFfuZe3uv/Db6XfTNTKBWsvNgoyVpC3rQ6JNM2J0J+wOhQKyy4q48MfLKVI1Qev9nedtEoqGc+GlHWnnWYvCTYXzFGJT/4+YodeyO6MjBYVOYqLdfJnyMP8u8U8SM+uHWYwMd7LihK4weQ84o323PXnfDtbv7sB77wU8WPEWWHweXJoJEV19izcu+omQvDfoecaFvmXV1Yrep57Muo3R9OrlX8Wn377Ps7/MwtkhlpiQSIpdZcSGRDMg3cm4kWdw1oAJAKzI2UR5QTIddlZS1e1mbI5INAqFRfHaVzljYj+iuw7wrTd9Vz7FGz9j8CW/D/7ef/IVA4d3J67XEN+yjCwbb7yYy9UzoomIdKBsGm0pzp8+gJfeSmD8eH9/C/I1f5yRzszfpdClkxubTWNZNpYuzCehcwinjGrva5tdlM+li68jVfkPbMLtoTwTfTux7tPpfNJIf9+0m/apfyIv7k+4bJ3Q2oZSmpKdi5n86F9wFAekmQ4BHh0O568Oeu9f/eAJ9pQ/xpQRVxEfGsOWot38lLMB+6ZkLplwFSd1HYrWmh/2rmPhqhX8u+jDoNMd7UPb8a5rEiMvnkx4fGff8lXrolnwVSHTplpERmhQFh6PnW2L/seoi88gJqGLr+22DXkU7FjNqReNx2bzj/e+7+N/0XtgbyYOmAjAkr3rcKV7mPrJd3T5dn3Q8/j+5isZdMVY2vX0/y6mpcEHr+dw+XVxhIXbsSmwNDz93ZOkxWfTv/MJhNgcbC9J40SrLxNzSxh2xa1B733CwOEsXxXGif7VUlxYyz9u3cp1V5bicHh86/3gnTKsuJFMmmK2+FrDmlW1vPJaBOvWBScwLPloCe2cqSQNCji40RYrPniDM66+FkeY/1jh6a/f5rmij8j3VGBXNrSGkZ0Gcsue8zln+lmER/sDu8sX57Bqa2/GXWxG8nh/ZnhwyXC2RObhsDtxazfRzghutl3GObEWfcZeFrRN/OndNznlwvMIb+//fgLsWfYVutsUTjxrBAdCNVWo2NdAqanA+VrrG7zXrwVGaq1vDWjzFfCo1nqZ9/oi4G9a6zX11nUjcCNAjx49Tk1NDR7CsOydtxi96AF4Z3fQcjWrYb/G5JzJ0ouK4SLvFOsbZ8Hm+3F95CBkrjuo7YYBJzNkaBp8GFwPJ+luRWpY8PPvU96NXVEZhNdClzIoCoPCJoLisRuvY1TV23zzTfBypeCsk4u4c1YUQ08xB/XbNpUx6tUufDx3OktjLsJq3wlbSRGX3Powk6+eAf1vNqdU3OXwXAWzrv4ns7gfTgPGADvgigFdcDlcvP10PtEuWNgLHh4D308ErtL+OgEL/si1c96k1FXGm88VEV8FP3eHv0yA6DiYvBRu8f7m3HwR/LjnXh4MsTN59/1wGRAPBcvhmtPhrFXwf8tM29sugGUnduKXqFz65sNVm+GV4ZATofhw3jQKoqcTcvIAQmLCwNJUZ33Fja5/w7vBw18aez/PLz6Vb3PT4YPc/bYdXHQiZ658lukzBxER6zRfKktzwgt9iJtXGtQ2JaEHSaOz4NPgz8Qpdzj4JSZ4WYfqePJOKvS/lt734pyVYSyODx7jp0q68puvZnPHU0Po1N3fh/vuKeLRE26hT88S6NYLamcDVSya8xvGX9YZErtB1TIoXcAZ2+NY/q9CmBWwx585nL6LV7OzXhmZJc/ew7gtC+G/wRuLxl6fKwrGMDj975x8Vm8sZygohVXrZkpJ7wZtz6jow8+RDYuUOu53kbzHGRToWf/R8wxNmAfjvjYLNs7C2vgvnnrsT3QceSntBnZFhTrBsvg5+1WeCH24wXp1P+CyfDOMw7uOtCWv02PIKTD2S98yNt9P7FZFiSP4+9mlsgvlL2dSEjDrutYwqesnjLnlUm640Ub7DgqlFEt/WcfYuac26MP2NdD+q3g+ZjrfcgG1ODmbxdw15Qn4LLjtbfHP8MC9z9JuxHjofok565gyGzX6jYYn3D+KQC8axuL/hvIqv6eUdpwR8yFLf/8uFy+FW1ebfcwbfwMrd/6TB8Ph4g33w1QgETIXwv+7ACb+BHesMKv880RI7HoWf/ttRxgzx/e5zHu6ghkb4MzV8HdTx5q/nwO/DOqNOyKLl/5bTZ8iSI433/Ez3vX+nnTBfMeL4amCvtw5IrnB68Ms3eC56dyfWHblg/zw64Vw2ghURDiuonL+teAMSkpMRmCdL77/hEt/nN5gtZuXt2f5wsvIOv1SQnqanQ0rewv33HQrXJZnzoB53/tffu7DsOunwoDbzMGLggVvJDAxo4CoGnj7c1icBC+cDnHaSZEKnjL93Aj4bvAwuCB4FHPa8z3pMflJ6DHNt8zzaQKOzcG/OwBPl5zFn99eA4X+4E0FEbx+yh+JGXYJzh6JhEaFYLk9ZG5dwJ/fugmq8gEFvz4G2x5HXa3JzDTD7Oosff1lzvrr7VBUr+j3FBp8/gqHxzE34kaKwscS1q8HyumgvNDFX98+qcF7tPbr7zj1/atgdn7Q8vQL45k/fyppwy8lpHsiSltYuav4x5/uhyl7g37ruBoIBU4HhgMW7OrQm/VfDeOyG7+DE2aYA66KNDIefYFuc+FHRvMMt6OxMbr343w1ZSV3zIVJO6A8BGZcAqHtIqCwkre+gBAPfD4Anh8B35eb55xJF+7kSe7gaR69Kx27TfPWU7lE1MJ3veGR0XDWO97PcAxwLbAIkqf3pu9vZ0Gva/1PuC5zpt428d77HJye4WbS2vvhDGAw8BbwJg3aLvlkMeMmJsLoj4Jfn09Nf1cygse5ix6ksf3Gx/i2Sw6TtsG9P8J942BBP3jimTu484wXYMJI6NQZ3G5u372GZ+9Pa/C7/dDjd3DPH5+G0SdA+zPBcrFhxW6GbPi1wX7LrJA/M6vzv2Es0C0aLIuvouP4TW0G9W2M7MtJVz0PXc73PY85V5/Pc7/MYelS08bl0oSEKC6cGcFOVcVT882+z7MjYU7vrvT5cDWfL06gc2f/dioqxgbf3wAjZgEKtj3Fpu8WMPG5TWRlBfdh5ANdWWXVW4h3W1D/df94MePyXPDqCl87lx1C/9Hg7txXOob7p/WD073BDO9vR917FOiHCWMYu2YVFAUfaCsa/tZ98UEmXRfezmmnK+iaBK4VULUM1Uhpt+EZE6havoDNm4OXW+1s2EqDV5x6QXd6/v1MOHO2b1ntx9045ff/47H3T+bc80xwVwF7k3fz2wsKmXTrMKZcpoiKVpSValL+fhrj/t+ZcPL1gA12v0z+xk/oEO3dbwl4HRYkn8J518yE3r/1vfeeZyqxO8PN760jwtd20s6OfE0ew/ZCQjms7QJ5kfXeI+934IrtXZlLFnf9oBmQDx+fCJ/3juGR+X+ix7hJOBLa4wx3YLktHis8l9XOevsXOSfSde5mMup9XP8wfT0xPYfyxBMBr6MFc0ZNJy9yOqFDBuKMDkN7LNy5c7jh01nBv6E2+Hr8BVx0eUfo0QcioqHoW3bu2E2/s6fAsMf9bT9LxP1OHo4vgzMgF3Q/l9sjv2NrvbkdTrnLRk2F5uFFEFVj9rt3tRvIeyUDGD0hzr9fV/496mpNRoY/kxDgkx8/Yvr3VwCgNOi6eEE/zHsR2sH33qUuf4Kk7Eo6lsNpWZATZd6Ph16eyj1T58B5p0AXb7Za3g98cG8H/pX2H66/OZy+/W3kZlt8nnMSi0KTuW499CyGr/vDru4wd8e5jJ42AuI7mfTxgq945sMTWO15mnfeNZ3SGpS7jMVXXs65l/eFhC4QEgGFX7NkpYtx2aXw+i++51ZDCOPbL2TW2yMYMtzh+z7d+85l/LfqS5qj/3fPMW3cTB58sN4Nl6kG3+VVw4YzYmA6fBCcwVb6WjQxU1dCu4G+z+ueezvQa8RZcMY7ppF323DrfU/Qb9rVTJgWi837XtRuf4mTuq2A0R/7V/pZIp6KXOyXbDczxnrfo1+XPseJBUWgzfbMYzN/HR/J4ovvO3PGGf5VfPFZLU8+7WTZsuDnseKJyzj98e8gP+CMeTjMP/diJl4SY44fan6GskWctSOeH1XjM03XN76mB4tC0+hWYr7Lu+KhOBz0Rhq8lltnDmDgTb+HgXcEPWfez2nQ9ucLR3LG3d1hzCe+14HN9zf6uzi96HQ+utAG5/0U9NthzQHb58Ftd17ch373jIORrwWtN2I7VNVLijq1dABrMtLh4+Dx2o8Mnkn8sGkkjekJTgfa0oSXzmHskG/h7HlB6x1z+wJueHICM2b475+WXMwLV3zKmCvOJKR9tDnraVmcnHsSna9+E7pNDloH0OD39vwdHZivgve9nICrX0Bbb/vf396VrmN/z6xZwc9P3d8wremJwrHcWVkOr60NvqGR/UUAruwAH+QFr1eptVrr4Y20bqA5QaFpwMR6QaERWuuZAW2+Bh6pFxS6S2u9trF1AgwfPlyvWbOmqZuPOhWuCgb9Z1BQfY8Pzl7B5vkj6dXLpLCGhpphNNOmmRTa2Njjr4yMy+Mi7tE4KgMK1SZGJZJ5R2bQ8JbWpLUmrSSNKncV/dv3P2SPcyQoBcNePoU9RXuYMXQGN/T9J7PujuPyy6FvX5Mi7XZDbi4MG0bDs7VAcmEyr6x5hdiwWG445QbfTFT1uS03jy57lH8u/ic2m42nznuKW0+71ZwRawmtvenE3vi2sh/cB93yQGUquEoC0rAVxA+jrLaaj7d8THZ5NtcNuY7u7bo3vLtlXqdt20xtmrp6NWFhsKdkB9d9cR0rM1cC8MzEZ7j99Nub37dvT4XB/zDDVJzecTpzOqGm5aJ3vmqGsNhDIfVDSP8U7BFw+fExR7Xb7R8GYLMFFwMG8zF47jl8WWLt2pllRUVw4UUelud+x3sb3mNkt5HMGDqjZSnwH4bBb3aYVHVtweYHYMuDnJqmWFcTvM3a8IcNTHh3ArmV/sDOi+f8k5ujPRDZzQyRS5sDqd6xbwnjoc/vTGByz7tmVjZ7BGkTt/L2xrfpGt2VaYOm+QodN5tSDYbmNLLooGlthi/l55v3pa52sGXBpEn+IZEHpLEO56+CFTPg3KVmqIEjHD5NMG1bUuT5UNj9NpRsgY5jzIHVrtdh9+uH9XtYUl1C3GNx6IBzszZlo+TuEt8QuCBKBQWFJvSewPxuNlRUHxj2hPm8o2Fu30PyGi9cCA88AG+/bbI6QkJMlk+LPjdNfLCrq833v7ra3GyzmWPP2ogUHvvpUTblbuLGU2/kysFXEuJofl5+aXUpM7+dyTsbzcHdA2c/wD2j72n5tutwaWzYVT/gjiEw6QGI6ALJr1Oz9XW6zcxk4Y8dGDIEysrMS3vXXWbow0MPBdenO9Zorbl93u08v+p537JXz5tN1oIr6NjRvEwREWY7k59vhqNGRprrgZ+fRjX2GickNJg1kJKtZth0SDtTMzP900O6rX7qKfN96t/fX2uvqAhWRPydJ1f5T5T1iOlB8i2bcdYWgrvC+70HUBAzAGz1Nrg/XWVqU540y+xzYGP14+fz27e+5OcVYb4h6x6P+f61Rp3EQyGnPIfRb44mudCckDqp00l8OXkpu7fG4nIF/6yMH1+v3Ma+zJoF998fvMwJPHgjXHe52WdddjnUFtHoUNvqXDNsVIWYE1Rpn0LGwX9O0tLgmWfgxBPNyaHwcDN7ZU4OXHJJ8Am1fXF73CxJWcL6nPVMHTSVpNgk5m6fy+QPJ/vaRDojSf9zevOHjKV/YWa57nSWqVG3680D2n6W1ZTx6a+fYlM2Lh14acv2nTw1ULrdBI58xxWYoeI2s42wLKvlv/WW2wzvdJV412sBNuhwmm+9bUVrB4VGAbO01hO91/8PQGv9SECbV4AlWuvZ3uvbgXH7Gj52rAWF6nz666dszNnIP8b+o9F6Q3UbsjfegCuvND/OYH7YDmpn/ShS7a6my1NdKKou4tTOp7LihhWtVnuprTkUB41tUX4+fPkl7N3r34lwueDPfz7IOkofR8OFGyHKmxddd3bk6oZnmEUrqkiF1I9MDRWnNxLqLqOq70x6vngieZXmTMj7U97nqpOuAuDu7+7m/U3vs/yG5XSLOQKVqw9TUOiQaqzDq/4IIXFw8r9MoWRfDRuCz4C1Yd/s/IaLPrgIZXJPWHjtQsb3Ht94Y6XYmL2BybMn89YlbzG2Yy/4dihcmt1InSAO2WtcUABZWf56aiee2Lz6YHXP4dj6YB+9LMvUY9y+3V9jLSUFPvrIBO4GDDBBBqfz2K1vUe4qZ1XmKsYljTuuTuq11M6CnYx6fRS3j7ydf4xtJP2tKVrDbAdcluvPsv4skcc+mcHW0Id44QXHPmvLHY12FOzAYXP4Js4RB6a0ppQJ70zg1C6n8uKFLwYNqxICWj8o5AB2AOOBTGA1cJXWektAm4uAWzGzj40EntNa73NA27EaFGqOpCRTiFSI/enZ0+wAiqPUjpcg4zNTgN0ZY87mKYVyRskx0RGSV5FHpyc7cfVJV/PelPf2f4fD5XgNCm19Cop+gRGvmOLT+yps3IY9/tPj/G3h33j5opf5w/B9FJOu/xoXb4El58Nvkr0ZABz9r/Ex98E+9pSXw7x5sGOHP3B3xx0mA1a0QZ8lwrhvIfYkM3Tss0Q27ejIlP+u4ucV4URGmhNgLpf5O9aCREKIQ6NVg0LeFV4IPIOZkv4NrfVDSqk/AmitX/ZOSf8CcD5mSvrr69cTqu94DgoJIY4jhetg69NmRkClQdlJmvElqalyRkbs2zEX9G3sYN9TDfNOg84TTWFhZzuoLTbZQ8JHa01ORQ4JkQn7Pltb/zXWFsztA6c+B4nn+Gd9c1ccvdPMS1BIiMMr8xtYMxNOfwM6jTajbMq28e3PJ3LnnXD++dC7tyk18OmnNKhzJYRom1o9KHQoSFBICCHEcUNSREVzNBYpLPwFFk+EPv8PEs8Dqxp2vwujcMGjlgAAB4RJREFUZze6iiNOgkJCHH4lv8L2FyB3sRl32P40GPUGFiEkJ5shoTEx0KePZJQJIQwJCgkhhBCiZSSwJf5/e/cbcmddx3H8/cGlNcU0lmXbSAutVEzFxJL+aZGRzJ4EiwypKBIzlf65hKJnolH5oALRNaGhmFpJUDks6tFmNjVdZoqW3mptEv2hSFt9e3BdssN2H/Hc053fxfV+PbnP+Z37Zj9475xd13fnus9zMbi3wEmSND6zDIX87cCSJMkTfUmSpBEa78cASJIkSZIkjZhDIUmSJEmSpBFyKCRJkiRJkjRCDoUkSZIkSZJGyKGQJEmSJEnSCDkUkiRJkiRJGiGHQpIkSZIkSSPkUEiSJEmSJGmEHApJkiRJkiSNkEMhSZIkSZKkEXIoJEmSJEmSNEIOhSRJkiRJkkbIoZAkSZIkSdIIparm8wcnO4A/LvLQCuDJfbwd7T27DZfthsluw2W7YbLbcNlumOw2XLYbJrsN12LtXl1VL38uPzy3odA0Se6oqpPnvQ/Nxm7DZbthsttw2W6Y7DZcthsmuw2X7YbJbsO1t+28fEySJEmSJGmEHApJkiRJkiSNUItDoavmvQEtid2Gy3bDZLfhst0w2W24bDdMdhsu2w2T3YZrr9o19zuFJEmSJEmS9MJr8Z1CkiRJkiRJeoE1MxRKcmaS+5M8mOSSee9H0yVZneTnSe5Lsi3Jhf36y5JsSvJA//XQee9Ve0qyX5I7k/yov2+3AUhySJIbk/yuf+692XbtS3Jx/zp5b5LrkrzYbm1Ksj7J9iT3TqxNbZVkXX/Mcn+S98xn15rS7Yr+tfI3Sb6f5JCJx+zWiMXaTTz22SSVZMXEmu0aMK1bkgv6NtuSXD6xbrdGTHm9PCHJ5iR3JbkjySkTj9muAUs59561XRNDoST7Ad8E3gscA3wwyTHz3ZWexU7gM1X1BuBU4Py+1yXAbVV1FHBbf1/tuRC4b+K+3YbhSuAnVfV64I10DW3XsCQrgU8DJ1fVccB+wFrs1qoNwJm7rS3aqv83by1wbP8z3+qPZbTvbWDPbpuA46rqeOD3wDqwW4M2sGc7kqwG3g08MrFmu3ZsYLduSd4JnA0cX1XHAl/t1+3Wlg3s+Zy7HPhKVZ0AfKm/b7u2zHTuvZR2TQyFgFOAB6vqoap6Grie7oVFDaqqJ6pqa3/7H3Qnpyvpml3bf9u1wPvns0NNk2QV8D7g6olluzUuycHA24BrAKrq6ar6K7YbgmXAS5IsA5YDj2O3JlXVL4G/7LY8rdXZwPVV9VRVPQw8SHcso31ssW5VdWtV7ezvbgZW9bft1pApzzmArwOfByZ/8antGjGl23nAZVX1VP892/t1uzVkSrsCDu5vv5TuOAVs14wlnHvP3K6VodBK4NGJ+wv9mhqX5AjgRGAL8IqqegK6v7zAYfPbmab4Bt2B1v8m1uzWvtcAO4Dv9Jf+XZ3kQGzXtKp6jO5/Sx8BngD+VlW3YrchmdbK45bh+Cjw4/623RqXZA3wWFXdvdtDtmvb0cBbk2xJ8oskb+rX7da+i4ArkjxKd8yyrl+3XYOe47n3zO1aGQplkTU/Fq1xSQ4CbgIuqqq/z3s/enZJzgK2V9Wv570XzWwZcBLw7ao6EfgnXnLUvP7a7rOBI4FXAQcmOWe+u9LzxOOWAUhyKd3b7jc+s7TIt9mtEUmWA5fSXcKyx8OLrNmuHcuAQ+kubfkccEOSYLchOA+4uKpWAxfTvysd2zVnhnPvmdu1MhRaAFZP3F/FrreuqUFJXkT3l3JjVd3cL/85yeH944cD26f9vObiNGBNkj/QXaJ5epLvYrchWAAWqmpLf/9GuiGR7dr2LuDhqtpRVf8Bbgbegt2GZForj1sal+Rc4CzgQ1X1zMGw3dr2Wroh+t39scoqYGuSV2K71i0AN1fndrp3pK/AbkNwLt3xCcD32HWZke0aMuO598ztWhkK/Qo4KsmRSfan+8VIt8x5T5qin/xfA9xXVV+beOgWuhcW+q8/3Nd703RVta6qVlXVEXTPsZ9V1TnYrXlV9Sfg0SSv65fOAH6L7Vr3CHBqkuX96+YZdNeB2204prW6BVib5IAkRwJHAbfPYX9aRJIzgS8Aa6rqXxMP2a1hVXVPVR1WVUf0xyoLwEn9v4G2a9sPgNMBkhwN7A88id2G4HHg7f3t04EH+tu2a8QSzr1nbrfs+d3y0lTVziSfAn5K9+ks66tq25y3pelOAz4M3JPkrn7ti8BldG8X/RjdydAH5rQ/zcZuw3ABsLEfnD8EfIRusG+7RlXVliQ3AlvpLmG5E7gKOAi7NSfJdcA7gBVJFoAvM+X1saq2JbmBbji7Ezi/qv47l42P3JRu64ADgE3dsTSbq+qTdmvLYu2q6prFvtd27ZjynFsPrE/3UedPA+f279CzW0OmtPs4cGX/gRj/Bj4BPucaM9O591LaZdc7aiVJkiRJkjQWrVw+JkmSJEmSpH3IoZAkSZIkSdIIORSSJEmSJEkaIYdCkiRJkiRJI+RQSJIkSZIkaYQcCkmSJEmSJI2QQyFJkiRJkqQRcigkSZIkSZI0Qv8HocfSaFfRNx4AAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1985,16 +2061,9 @@ }, "output_type": "display_data" }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Index 13\n" - ] - }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2004,9 +2073,17 @@ }, "output_type": "display_data" }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tal hits: []\n", + "gata hits: [MotifHitAndCoord(motif_idx=1, motif_score=0.8735744116604658, precision_at_motif_score=1.0, example_idx=6, start=171, end=196, is_revcomp=False)]\n" + ] + }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2020,12 +2097,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Index 14\n" + "Index 7\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2037,7 +2114,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2047,16 +2124,9 @@ }, "output_type": "display_data" }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Index 15\n" - ] - }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2066,9 +2136,17 @@ }, "output_type": "display_data" }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tal hits: []\n", + "gata hits: []\n" + ] + }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2082,12 +2160,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Index 16\n" + "Index 8\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2099,7 +2177,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2110,15 +2188,575 @@ "output_type": "display_data" }, { - "name": "stdout", - "output_type": "stream", - "text": [ + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tal hits: []\n", + "gata hits: [MotifHitAndCoord(motif_idx=1, motif_score=0.9981759716448624, precision_at_motif_score=1.0, example_idx=8, start=50, end=75, is_revcomp=False), MotifHitAndCoord(motif_idx=1, motif_score=0.999767182191173, precision_at_motif_score=1.0, example_idx=8, start=96, end=121, is_revcomp=False), MotifHitAndCoord(motif_idx=1, motif_score=0.9994275624967489, precision_at_motif_score=1.0, example_idx=8, start=158, end=183, is_revcomp=False)]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index 9\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIEAAACMCAYAAADr57kMAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3de3yb5X338e8lyZZsS47jWMrROQdCoBBoCFACZS20lJVROlpou44VOsa2Pivb89ratWu79em2rjs8XZ92pQzYWlqgbAN6oqW0o5zGIQmEk0PIiRydRD7rYEuydD1/SHJCsBObyLql+/68X6+8Gh1s/1Lf3JK+9+/6XcZaKwAAAAAAALibz+kCAAAAAAAAMP0IgQAAAAAAADyAEAgAAAAAAMADCIEAAAAAAAA8gBAIAAAAAADAAwiBAAAAAAAAPCDg1A/u6OiwixcvdurHAwAAAAAAuM7GjRt7rLXR8R47bghkjLld0nslHbLWnjbO40bSP0u6TFJa0u9Ya5893vddvHixNmzYcLynAQAAAAAAYJKMMbsmemwyy8H+XdKlx3j8PZJWlP7cIOmbUykOAAAAAAAA0++4IZC19lFJfcd4yhWSvmOLnpLUZoyZW6kCAQAAAAAAcOIqMRNovqQ9R9zeW7qvuwLfG1XQPTis7z61Sy/sHXS6lLpkjNHbT4rqg2sWKBJqcLocAMAkWWv15PZe3bNhj3pTWafLwQm46q0LdMXq+U6XAdSNkVxe9z+3Tw++fECjBet0Oa4R8Bm969Q5et/q+Wpq9DtdDjCuSoRAZpz7xj2TGGNuUHHJmBYuXFiBH403y1qrZ3cP6N+e2KmfvXRAeWv1lvkzFPCN9+vEsSQzo/o/P+7SP/18iz6wplPXvm2xlnS0OF0WAGACQyM5/dfGvfruU7u0PZ5SW3ODlnLerluvHkxKEiEQMAndg8O648lduuuZ3epP57Sko0Uzm7mIWSn96Zz+/N4X9Xc/e0UfWrtQHz13kea1NTldFvA6lQiB9krqPOL2Akn7x3uitfYWSbdI0po1a4icHfLjF/brXx/doef3DioSDOjaty3Wtect1sJZzU6XVree31MM1L739C59+8nX9Gsnx3Tj25dp7ZJ2p0sDAJR0Dw7ra7/cpvuf26fhXF6rO9v0jx84Q79++lyFGrhiW68+etvTGhoZdboMoKa9tG9Q33xku3720gEVrNUlp8zWx85fonOXtqu4zw8qwVqrp3f26d+e2KlvPbJdtzy6Q5eeOkd/+GvLtWpeq9PlAZIqEwL9UNInjDF3SzpH0qC1lqVgNeqxrXF94s7ntLSjRV+84lT95lkL1BKsxGHgbWd0tumr15ypz1x2ir779G7d+fQuXXPLk7r3D87X6s42p8sDAEj61iM7dM+GPfrNs+bro+cu1lsWzHC6JFRAJBTQ/oFhp8sAatau3pSuuvl/1OD36WNvW6xr37ZYne1c/J0Oxhidu3SWzl06S3v60rrjqWLX1cZd/XrqM+90ujxA0uS2iL9L0kWSOowxeyV9QVKDJFlrb5b0gIrbw29TcYv4j01XsThx9z67T62hgH560wUKBrjqWWmx1pD+5JKT9PELluhd//SoPvWfL+hH/2udGgOT2YgPADCd4smMFrU36ytXneF0KaigSLBBCTqBgHEVClaf/q8X1eDz6cGbLmRpUhV1tjfrM5edotZQQP/w81c1ksvTdYqacNwQyFr7oeM8biX9YcUqwrRJZUb1s5cO6H1nzicAmmatoQb99ZWn6fpvb9A3Ht6mP77kJKdLAgDPG0zn1MbsC9cJhwJKZgiBgPHctX63ntzRq799/1sIgBwSi4QkSfFEhg4s1ATaEzzkoa6DGs7ldeWZDE6shneeMlvvWz1P33h4mzZ3DzldDgB4Xn86q5nNjU6XgQqLhAJKZ/MazRecLgWoKfsHhvW3D7yity2bpWvO7jz+F2BaRFuDkqRDiYzDlQBFhEAect9z+zS/rUlrFs10uhTP+Pzlp2pGU4P+7D9f4M0pADhsIJ1TGyGQ64RLsw1TmbzDlQC1w1qrz973ovIFqy+//3SGPzsoFimGQPHEiMOVAEWmuJqr+tYsnmE3fGGdIz/bi7L5gp7d3a95M5q0kDbEqupNZbT1UFIL25s1bwZtuADglGde61MsEtTiWWwH7yaHEiPa0ZPS6s42hVjuDkgqzkDbHk9qUXuz5vL+01Hlz2GLZ7VoTmvI6XLgEea6BzZaa9eM9xidQB7Rmyq2H3ZEuAJabe0tjZrZ3Kg9/WkN57hKCQBOKFirgrVq8HM13G38vuLvNF9w5sImUGuy+YJ29aYUDgY0Zwahg9PKrzs5VgWgRji3N3jHCuljP3Hsx3vNjV9/XKMdVj+54QKnS/EcI2nm0Ig+8E+P6ORCRN+/9jz5fHwIAYBqig+N6Jq/+aW+dN5p+q1zFzldDiqoa2tcH73tGd3zrvO0dkm70+UAjrvpexv1i9whPfAH62RiEafL8Twj6Y/++he6aGGU3SlRPddN/HmTTiAP2B5P6vm9gwyEdlCsNaTPvXeV1r/Wr7vW73a6HADwnP50VpIYDO1CkVBxx7fESM7hSgDn/aLroB548YA+efEKLScAqhmx1iCDoVEzCIE84AfP7ZPPSJefMc/pUjztqrcu0KJZzXp8a4/TpQCA5wykiwHBTLaId53yYGi2iQekJ7b3qKXRrxsuXOp0KThCLBLSoSFCINQGQiCXs9bqvk37dP7yDs1mEJmjjDGaN6NJca4CAEDVDZQ6gdgdzH1aQ8UQaGiEEAjoS2XVEQmqwc/HvFoSiwQVT/IZALWBs4PLPbu7X3v6hnXFapaC1YIoLwAA4Ij+UidQG51ArhMuhUBJQiBAvcms2lsIu2tNLBJUbzLDAHvUBEIgl7v/uf0KNfj07lNnO10KVAqB6AQCgKpjJpB7NTX45fcZZgIBknpTWc0iBKo50daQClbq5WIwagAhkItlRwv68Qv7dcmqOWNDE+GsaCSodDavFHMLAKCqBtI5BQM+NTX6nS4FFWaMUTgYYCYQIKkvldGslqDTZeAo0XDxd8JwaNQCQiAXe/TVuPrTOV15JgOha0X5BYBuIACorv5Uli4gF4uEAkqwHAweZ61VXyqr9jDnuloTay2HQCMOVwIQArnafZv2qb2lUResiDpdCkqikVIIRCsoAFRVfzrHPCAXCwcJgYChkVHl8pblYDUoVvoMwA5hqAWEQC724t5Bnb+8g90BashYCEQnEABU1eAwnUBu1hpqYCYQPK8vVZx9NotOoJrDZwDUEtIBl7LWKp7IaHaENcG1hBcAAHBGfzqnmS10ArlVOMRMIKAvVXx/2c5MoJoTDPjV1tzATCDUBEIgl0pl8xrO5cdCB9SG9uZG+X2GEAgAqmwgndWMJq6OuxUzgQCpJ1nqBGI5WE2KRYLMBEJNIARyqZ5SyEAIVFt8PqOOcCMvAABQRdZaDaRzmslMINdidzDg8HKwdkKgmhSNBOkEQk0gBHKp8uDhjjAhUK2JRoJ0AgFAFSUyoxotWGYCuVikNBPIWut0KYBjCIFqWywSYjA0agIhkEvF6QSqWdFwkN3BAKCKBlLFgcHsDuZekVBAubxVZrTgdCmAY3qTWYWDAYUa/E6XgnHESheCCavhNEIglyIEql10AgFAdfWni1fH6QRyr0goIEnMBYKn9aYydAHVsGgkqGy+oKFhzlNwFiGQS/UkM/L7DG94a1A0ElRPMqtCgasAAFANA8PFTiB2B3OvcgjEXCB4WV8qSwhUw2KtIUliNigcRwjkUvFE8UqA32ecLgVHiYaDyhfs2JVpAMD0Giidb9u4MOJa4WAx4EuM5ByuBHBObzKrjjDnuVoVK63QYDg0nEYI5FLxREZRhkLXpGikeBWAuUAAUB39pWGpbU10ArkVy8EAloPVuuhYCEQnEJxFCORS8WSGeUA1qvx7YS4QAFRHf7rYHTKDEMi1wkFCIHibtba0HIz3/7VqrBOIHcLgMEIgl4onCIFqFSEQAFTXQDqr1lBAAT9ve9yqNcRyMHhbIjOqXN5qFp1ANSscDKipwc9yMDiOd0MuZK1VD51ANYsQCACqqz+d00w+GLlamMHQ8Li+ZHHZ6yxmAtUsY4xirUFCIDiOEMiFBodzyuWtOpgJVJNaGv1cBQCAKupPZxkK7XIsB4PX9aaK7yuZCVTbYpGg4swEgsMIgVyo3GFCJ1BtKl8FoBMIAKpjcDinmc3MA3KzxoBPwYCPTiB4Vm+5E4iZQDUtFglxIRiOIwRyobEQiE6gmhUNEwIBQLX0p7PsDOYBkVADM4HgWX0ploPVg2gkqDiDoeEwQiAXKm89TidQ7YpGgmwRDwBVMpDKsRzMAyKhAMvB4Fm9pRCI5WC1LRoJKpEZ1XA273Qp8LBJhUDGmEuNMVuMMduMMZ8e5/GLjDGDxphNpT+fr3ypmCw6gWpfNEInEABUQy5fUCIzqpmEQK5HCAQv601m1dLoV6jB73QpOIaxbeKZCwQHBY73BGOMX9I3JF0iaa+k9caYH1pru4566mPW2vdOQ42Yongyo0a/T61Nx/31wiHRcFCDwzllRvMKBnixBoDpMpAuLg+a2cJyMLcLBwPMBIJn9aUyamcpWM2LtYYkSYcSGS2a1eJwNfCqyXQCrZW0zVq7w1qblXS3pCumtyyciHiiuD28McbpUjCB8lK9ntIQPwDA9BhIF8+zLAdzv2InEDOB4E29qSxDoetAuROIFQFw0mRCoPmS9hxxe2/pvqOdZ4x53hjzU2PMqRWpDm9KTzKrDuYB1bQoLwAAUBX95U4gdgdzvXCwQUmWg8GjepNZzWIeUM0bWw42xHIwOGcyIdB47ST2qNvPSlpkrT1D0v+TdP+438iYG4wxG4wxG+Lx+NQqxaTFExlFaQetaYRAAFAd5U4gZgK5HzOB4GV9qSxDoevAzOZGBXyGbeLhqMmEQHsldR5xe4Gk/Uc+wVo7ZK1Nlv7+gKQGY0zH0d/IWnuLtXaNtXZNNBo9gbJxLOXlYKhdUYbCAUBVlGcCzWCLeNdrDQWUzI6qUDj6WiXgbtbaYgjEReCa5/MZdYSDhEBw1GRCoPWSVhhjlhhjGiVdI+mHRz7BGDPHlAbQGGPWlr5vb6WLxfHlC1Z9qQw7g9W48pptOoEAYHr1lzuBuELueuFQQNZKqSzdQPCWZGZU2XxBHcwEqguxVkKgybDW6rGtcQ0x663ijhsCWWtHJX1C0oOSNku6x1r7sjHmRmPMjaWnXSXpJWPM85K+Jukaay2XYRzQl8qqYEUnUI1rDPjU3tJICAQA06w/nVOD36ilkZ0Y3S4SKnZ7sUMYvKa3tNEIy8HqQywSZCbQJPzLr7bro7c9ozuf3u10Ka4zqT3ES0u8HjjqvpuP+PvXJX29sqXhzSiHCh10AtW8aDhICAQA02wgnVVbcyM7ZnpAOFh8W5sYGdXcGQ4XA1RRb6oUArEcrC5EIyFt2jPgdBk17XtP79LfP7hFkvTqwYTD1bjPpEIg1I94shgq0AlU+6KR4NjvCwAwPfrTWXYG84hI6HAIBHhJXykEYnew+hCLBNWbymo0X1DAP5npLN7yo+f36y/uf0nvWBlTMjOq7YeSTpfkOhx1LlPuLCEEqn3RCJ1AADDd+tM5tbEzmCccDoGYHwFv6UsV30/OYiVAXYhGgrJW6ikt48Nhj7wa15/cs0lnL2rXv3zkLK2cE9H2eEpMmqksQiCXYTlY/SiHQJzUAGD6DKZzdAJ5RHkmEJ1A8JpymEAnUH2IsUvwuDbu6tONd2zUilhEt/7OGoUa/FoeCyuZGdXBIS6cVxLLwVymJ5lRS6NfLUF+tbUuGg4qM1pQIjOq1hAfUABgOvSns1rd1OZ0GaiC8kwgBkPDa/pSWTU3+hVqYAB+PYi1hiRJhzwYbOQLVr/cfFDDufzr7s/kCvrST7o0Z0ZI375u7dhno+XRsCRp26Gk5swIVb1etyIpcJl4IqMOloLVhfKSvXgiQwgEANPAWquBdE5tLZxjvYDlYPCqvlSWncHqyOFOIO+FQL/ackg33LFx3MfmzgjpjuvXvm6sybJYMQTaHk9q3YqOqtToBYRALhNPZBRlKVhdODIEWlZKuQEAlZPO5pXNFzSTmUCe0NIYkDFSkuVg8JieZIZ5QHWkPLbDi8vBXtg7KGOkn37yAjUcNRR73owmNTW+vpstFgkqEgxoG8OhK4oQyGXiyYxWxAgU6kHUw1cBAKAa+tPFORnMBPIGn88o3BjQECEQPKYvldXsVpbK1IvGgE/tLY2e3CBmc/eQlna0aOWc1kk93xijZbGwtscJgSqJwdAu05PMsDNYnSh3bHnxBQAAqmEgXVwWxO5g3hEOBZgJBM9hOVj9iYaDnrwQ3NU9pFPmTi4AKlsWDdMJVGGEQC6SGc1rIJ1jZ7A60dbcoAa/IQQCgGlSDoFYDuYdkVCAmUDwFGutelNZzQpznqsnsVbvhUCDwznt7R/WqnlTC4GWx8I6lMhoiHN7xRACuUhvaXtIOoHqgzFG0XCQEAgApkl5OVgby8E8IxykEwjeksyMKjtaYHv4OhONBBUf8tZMoFe6hyRpyp1Ay8vDoekGqhhCIBcphwkMhq4f0UhQ8SQhEABMhwFCIM+JhBqUYCYQPKQvVTzPtbfw/r+exCIhxZMZWWudLqVqukoh0KlTXg7WIkksCasgQiAX6SmFCXQC1Y9ohE4gAJgu/eWZQE1cIfeKSCjA7mDwlN5SCEQnUH2JRYLK5e3Y65QXdO0fUke4ccqfVRe2N6vR79M2hkNXDCGQi5TDhA5CoLpBCAQA06c/nVU4GFBjgLc7XhEJsTsYvKWvNA6CmUD1JdbqvQ1iNh8oDoU2xkzp6wJ+nxZ3NGv7odQ0VeY9vCtykbEQiBeBuhENB9WXyihf8E4rKABUy0A6x1Iwj4mEGpTMeOfKOtCbKr7/Z3ew+lIe33Eo4Y25QLl8Qa8eSGrVFJeClS2Lsk18JRECuUg8mdGMpgYFA36nS8EkRSNBFezhF3AAQOX0p7PsDOYx4WBAI7mCcvmC06UAVXF4ORgrAepJrDUkSTo05I3PANvjSWXzhSnvDFa2PBbWrt6UMqP5ClfmTYRALtKTzDAPqM6Uf19eagUFgGqhE8h7IqGAJDEXCJ7Rl8yqqcGvpkYuAteTWKTcCeSNzwCb3+TOYGXLomEVrLSrN13JsjyLEMhF4okMS8HqTNRjLwAAUE0D6aza6ATylHCwGAKxQxi8ojeVZR5QHWoJBjSrpVFbDyacLqUquvYPqTHg09KOljf19eVt4tkhrDIIgVwknsgoGgk5XQamIBou/r7oBAKAyutP5zSTTiBPiYSKv+8Ec4HgEb2pLDuD1alzl83S49t6PLFNfFf3kFbOiSjgf3Pxw9LSNvHbCYEqghDIReKJzNiQMdQHloMBwPTIF6yGRnJ0AnlMeTkYnUDwir5UhqHQdeqC5R06lMhoq8uDDWutNncndMqcN7cUTJKaGwOa39bENvEVQgjkEunsqFLZPDOB6kxTo1+RYIAQCAAqbHA4J2tFJ5DHMBMIXtOXzKqdodB1ad2KDknSY1t7HK5keh0cyqgvlX3TQ6HLlsXCLAerEEIgl+hJFHcGIASqP9FIUPEkIRAAVFJ/uvi6yO5g3jI2E4jlYPAAa616UllmgtapBTObtaSjRU9sc3cI1NU9KEknHAItj4a1I55SoeD+5XPTjRDIJeLJEUniRaAOdUSCdAIBQIUNlEIgdgfzlrGZQHQCwQNS2byyowWWg9Wxdcs79NSOXmVHC06XMm269hd3Bls5J3JC32dZrEXDubz2Dw5XoixPIwRyiXKIQCdQ/YlGguohBAKAihpIFztBmAnkLcwEgpf0JYthNyFQ/Tp/eYfS2bye293vdCnTZnN3Qgvbm8dC+jdreZQdwiqFEMglCIHqVzRMJxAAVFp/KQRiJpC3BAM+NfgNIRA8oTdVfP/IFvH167xls+QzcvWSsK7uIa2ae2JLwaTD28Rvj6dO+Ht5HSGQS8STWfmMNIvBcHUnGgkqkRnVcDbvdCkA4BqHl4Px4chLjDEKBwNKMhMIHtBb6gTi/X/9mtHUoDM62/SYS0OgVGZUr/WmdEoFQqD2lka1NTfQCVQBhEAuEU8Ut4f0+4zTpWCKyt1bPQyHBoCK6U9n5fcZtZaWB8E7IqEGOoHgCX0ploO5wQXLO/T8ngENDrsvvH7lQELWnvhQaKkY8i+PhrWdbeJPGCGQS8QTGXWEuQpQj+bOCEmS1r/W53AlAOAe/emc2poaZAwXR7wmHAywRTw8obcUArEcrL6tWxFVwUpPbu91upSK6+ouDoWuRAgkFZeEbacT6IQRArlEPJlhHlCdOnfpLJ3R2aa/+lGXupl2DwAVMZDOsjOYR0VCATqB4Al9qYyaGvxqbqTjsZ6dubBNLY1+V84F6to/pNZQQPNKF71P1LJoWL2prPpLASjeHEIgl+hJEALVqwa/T1+9erVy+YL+9z3Pq1CwTpcEAHWvP5XTTOYBeVIk1KBEhhAI7tebzLIUzAUa/D6ds3SWHndhCLS5e0ir5rVWrCv38HBouoFOBCGQC1hri51ALAerW0s6WvSFy1fpf7b36tbHdzhdDgDUvYHhHJ1AHlXsBHLfbA3gaL2pLEvBXGLd8g7t7Elpb3/a6VIqJl+weuXAUEWGQpeVQyCGQ58YQiAXGBoZVXa0QCdQnfvgmk69+9TZ+vsHt+jl/YNOlwMAda24HIwPR14UCQWUpBMIHtCXohPILS5Y0SFJenyre7qBdvakNJIrVGR7+LJ5bU0KBnyEQCdoUiGQMeZSY8wWY8w2Y8ynx3ncGGO+Vnr8BWPMWZUvFROJJ4q7ShEC1TdjjL78/tM1s7lRn7x7E1vGA8AJ6E9nNZNOIE8KB4szgaxleTXcrTeZYXt4l1geC2t2a9BVS8I2V3gotCT5fUZL2SHshB03BDLG+CV9Q9J7JK2S9CFjzKqjnvYeSStKf26Q9M0K14ljKG8tznKw+jezpVH/+MEztO1QUn/7081OlwMAdWkkl9dIrkAnkEdFQg3KF6xGcgWnSwGmjbWW5WAuYozRuuVR/c/2XtfMB+3qHlLAZ8aWcFXK8lhY2wiBTshkRsmvlbTNWrtDkowxd0u6QlLXEc+5QtJ3bPGSy1PGmDZjzFxrbfdE3zSdHdWGadgSO+D36bR5rQr4nVvpNpLL6+X9Q1W7ArV+Z/H/xw46gVzhghVRXb9uiW57fKdWzW094RPn8ljYcx+EdsST6mxvVoOD54FKGBrJ6dUDiTfcb4zRafNbFQz4K/rzBtM5bT30xp/nVa1NDTppdsTpMupOPJHRrt6UozX0lXYNYTC0N4VDxbe3iZGcmhore54EptNovqAX9w0qP4kQIDtaUGa0wHIwF1m3Ypb+69m96uoe0mnzZ7zusYleW/0+o9Pmz5jUe97dvWkdSoxUrN7jWb+zT8tj4Yq/X10RC+tHz+/Xmi/9QkujLVra0aKl0RYt6QjTATxJkwmB5kvac8TtvZLOmcRz5kuaMATaHk/pqpufnGSZU3Pa/FZ9+f2nv+E/nuk2kM7qjid36d//5zX1VnnbuoDPaHZrZbbeg/P+9N0n64ltPfr0vS+e8PcKNfh09ZpOffyCpepsb65AdbWrULD6yoNbdPMj2zW/rUkfv2CJrj67sy63Tt3cPaTr/n29ugfHf7GORoK67vwl+vA5CzWj6cRe8Pb2p3Xb4zv1/fV7lGYZ4uv83oVL9alLV8rnq8yuFm732Na4/uC7z9bMzkxzK7QlLepLazkEyowq5nAtwGSks6P6/vo9uvWxndo3MDylr53X1jRNVaHazl9enAv02Naesc+x2w4l9K1Hduj+TfuUy48fDs5va9L165bomrVvfM9rrdWGXf26+Vfb9ctXDk3vP2AcV6/prPj3/Oi5i9QY8GlHPKkd8ZR+3nVw7OIPJmcyn4zGe+d79BE4mefIGHODisvFNGfBYt1x/dpJ/Pip6R4Y0d//fIuu+MYT+vi6Jbrp4pOm/SrQvoFh3frYjrEPUO9YGdMH13SqJVi9q0/RSPCEPwiidoQa/PrP33+bntvdf0LfZ7Rg9cAL3brzmd367tO79etvmasbLlxa9YC0GkZyef3JPZv0wIsHdMXqedo/MKy/+lGX/vmXW/Xb5y3Wtect0qw6WTL58JZD+sT3nlU4FNA3P3LW2FXtsuTIqO58Zrf+7mev6BsPb9OHz1mo685fojlT/MC7uXtItzy6Qz98fr+MpN9YPU+Xnz5PAT+BhyT99KUD+tajO7SrN63/e/VqOgqO486nd+tzP3hJK2JhferSlY4fR6EGv85aONPRGuCMcLDcCVQbYSQwkd5kRt9+cpe+8+RrGkjndPbimfqzS0+edHdPo9+nty7iPOcWsUhIK+dE9MS2Hp29eKZufmSHfrH5oEINPn147UK945TZOvqaVH86p+8+uUtf/HGXvvbfW/Xb5y7Sb79tsdqbG/XQ5oP61iPb9ezuAbW3NOqmi1dU/Xg5o7Ot4t9zZkujbnz7stfdN5DOakdPSqkauQhVCy78u4kfM8dbsmSMOU/SX1pr3126/eeSZK392yOe8y1Jv7LW3lW6vUXSRcdaDrZmzRq7YcOGyf8rpmAwndOXf7ZZdz2zRwvbm/U3V75F60oT16diOJvX1kMJvXIgoS0HEuMmjImRnB7eEh/7AHXDhUu1ck7lhl8BlXBgcET/9sROfe/p3UpmRnX+8lk6b+ksnTynVSvnRLRgZpOMeXMf2JKZUW0p/Tfy6sGEBoffuC2v32d00clRXbJqdsVbQqVii+zHv7NBL+wd0GcvO0XXr1siY4w27urTzY/s0ENdBxUM+PSOlTGFGt7482OtQa2cE9HKOa1aFg2rMXC4pXY4m9erB4v/vlcOJBQJBXTVWxdMW1fVHU++pi/88GWdMrdVt1179jGDnZf2DeqWR3foxy/sL/1/HBv78HM8BwZH9OSOXjU3+vWhtQt1/bolXE08irVWtz/xmr70ky6dPn+G/vXaNYpF6Cw5WqFg9eWfvaJbHt2hi06O6usfPmvSxyEwHZ7Z2acPfutJfff6c97U+z+gUgbSWd3/3Oe8pIIAAA1rSURBVD49v/eNu76O5PJ6eMshjeQKumTVbN349qV666J2B6pELfnSj7t06+M7JUkzmxuKFzLftvi4weDGXf361iPb9dDmg2r0+zS7NaTdfWl1tjfpdy9Yqg+8tZOLWR5jjNlorV0z7mOTCIECkl6V9E5J+yStl/Rha+3LRzzn1yV9QtJlKi4V+5q19phtPtMZApU9ub1Xn7nvRe3sSenCk6Jqm2SnzEgur22HknqtN6XyktxgwKdYa1DmqKYnv8/oHStjfIBCXRgczunOp3fr7vW7tas3PXZ/OBjQSbPDmj+zedy2vvGks6PacjChPX2H25ZbGv3jdtskRnLqT+c0s7lBV565QFef3amT51Rm1sqrBxP62L+tV18qq69es1rvPnXOG56z7VBS//roDj21s1dHn/IK1urg0MhYi23AZ7Q02qJ5bU16rSelXX3psa8JNfiUHS3ISlq3vENXn935hmCrP5XVpj0Dem7PgHqSGb1l/gyt7mzTSbMj8h9jSVG+YPXXP9ms25/YqYtPiemfrzlTLZP8IL2nL61bH9uhR16Na7KzBIMBn9535nz91jmLNIP108f0UNdB/dFdz6m9pVG3/87ZFTt23WA4m9dN339OD758UNeet0ife+8qR2fyAZLUtX9Il33tMX3zI2fpPW+Z63Q58BhrrZ7e2ae7n9mtB146oOxoQXNnhN4ws8UY6Zwl7brhwmUVH5yL+rW5e0h/cf9Luvz0ufrgmxhpsO1QUrc+Vuxi/tA5C3XZaXN4XfaoEwqBSt/gMklfleSXdLu19q+NMTdKkrX2ZlNsIfi6pEslpSV9zFp7zISnGiGQVAx0vv7f2/TAS91v+PA3kfKHwJPntOqUORGdPCeiRbNajvkBDqg3iZGcXj2YLHXxDOmVAwkdSmQm/fXBgE/LYmGtnF38b+SUua2a39Y07uyUfMHqsa1x3bNhjx7qOqhc3uqMzja9c2VsbMlIOWAtNySVv8vh269/XJIyowXd/Kvtamr067Zrz9ZbFry5ZW65fEE74im9cmBorKtp38CwlnS06OQ5Ea2cE9HJc1q1sL1ZB4dG9B8b9uqeDXu0b2BY7S2Nuvz0uRoczmnTngG9VgrXfEZqKW1TLEnNjX6dvmCGVnfOVGycIe6PbY3r4S1xXXf+En3210/hfFNjXto3qOu/vV6pTF6/f9EyNY3TUTYenykuSyr+8Y39PVDDv99c3mpkNK9MLq/h0i5bmVx+3IDx/k379OK+QX3+vav0sfOXVL9YYBx7+tK64CsP6ytXna4PHjWPIp0d1ebuoUm/J0R1HHneGckVNJzLT3jeMWPnVZ+aGvwKNvgVCvhlZZUpfW15h8DMaH7c37XPSE2NxfNxMHD4/FzcVe5wDSO5vLKjk99lbmgkpx9s2q+dPSlFQgG9b/V8XX12pyuX4QOobSccAk2HaoVAAGpLbzKj+57bp3s27NGrB098e8dVc1t167Vrqt6Jly9YPb6tR3c/s1sPdR3UrHCjVne2aXXnTK3ubNPpC2aoudGvXb3pYmfQ7n5t2jOgru6hcQf7NfiNPv/eVfroeYur+u/A5HUPDut3v7NBL+0bcrqUmhEOBvTVq1fr4lWznS4FGDOQzmr1Fx/S5967Steve304+af/8bz+Y+NehyqDF6xd3K5r1nbqPafNZfkNAMcQAgGoSSO5wztRlU9FtjRT/vDt8uP2qNvFG5FQwPGdm3L5wqS3o8+M5jWSfeNVxcaAjzeLdaBQsFMaNpu35avKr7+6na/hNgS/MQo1Fq+sF6+U+xQM+OUfZ25YqNE3LXO+gBMxmi9o+Wd/qpsuXqGbLj5p7P50dlRrvvQLXbgiqo+cu9DBCnG0I887oYbi6+FE5528tcXX0lxBI2Mdi3kZmbFzVvH7+BUM+OQb53uMForbq7+uayiXl99nxjo2m0rdRo0B3xvGQUz47/AbZqIBqAnHCoE4SwFwzHhDmuvRZAMgSQoG/HxormM+n2GGElDjAv7iMqHkUYHtgy8fUDqb13XrlmjtEgbwAgC8iSlRAAAAcJVIKPCGrr17n92nzvYmrWFLbQCAhxECAQAAwFUioYCSmcMh0IHBET2xrUdXrp7v+BJiAACcRAgEAAAAVwmHGjQ0khu7/YNN+1Sw0pVnLXCwKgAAnEcIBAAAAFdpPaITyFqre5/dp7MWtmlJR4vDlQEA4CxCIAAAALhKOHh4JlBX95C2HEzQBQQAgAiBAAAA4DKRUGBsd7B7n92nBr/R5afPdbgqAACcRwgEAAAAVwkHG5QYyWk0X9APNu3XO1bG1Nbc6HRZAAA4jhAIAAAArhIJBZTK5vXo1rh6khm9n6VgAABIIgQCAACAy0RCAUnSd57cpbbmBv3ayTGHKwIAoDYQAgEAAMBVyiHQr7bEdfnp89QY4C0vAAASIRAAAABcJhxsGPv7lWfNd7ASAABqCyEQAAAAXKXcCbSko0VndrY5XA0AALWDEAgAAACuUg6B3n/mfBljHK4GAIDaQQgEAAAAVzlt/gz98cUn6bfPW+x0KQAA1JSA0wUAAAAAldTg9+mTF69wugwAAGoOnUAAAAAAAAAeQAgEAAAAAADgAYRAAAAAAAAAHmCstc78YGMSkrY48sNRjzok9ThdBOoKxwymguMFU8HxgqngeMFUcLxgqjhmMJ5F1troeA84ORh6i7V2jYM/H3XEGLOB4wVTwTGDqeB4wVRwvGAqOF4wFRwvmCqOGUwVy8EAAAAAAAA8gBAIAAAAAADAA5wMgW5x8Gej/nC8YKo4ZjAVHC+YCo4XTAXHC6aC4wVTxTGDKXFsMDQAAAAAAACqh+VgAAAAAAAAHuBICGSMudQYs8UYs80Y82knakDtMsZ0GmMeNsZsNsa8bIz5ZOn+vzTG7DPGbCr9uczpWlEbjDGvGWNeLB0XG0r3tRtjHjLGbC3970yn64TzjDEnH3EO2WSMGTLG3MT5BUcyxtxujDlkjHnpiPsmPKcYY/689J5mizHm3c5UDadMcLz8vTHmFWPMC8aY+4wxbaX7Fxtjho8419zsXOVwwgTHy4SvQZxfvG2C4+X7RxwrrxljNpXu5/yCSan6cjBjjF/Sq5IukbRX0npJH7LWdlW1ENQsY8xcSXOttc8aYyKSNkp6n6QPSkpaa//B0QJRc4wxr0laY63tOeK+r0jqs9Z+uRQ2z7TWfsqpGlF7Sq9H+ySdI+lj4vyCEmPMhZKSkr5jrT2tdN+45xRjzCpJd0laK2mepF9IOslam3eofFTZBMfLuyT9t7V21Bjzd5JUOl4WS/px+XnwngmOl7/UOK9BnF8w3vFy1OP/KGnQWvtFzi+YLCc6gdZK2mat3WGtzUq6W9IVDtSBGmWt7bbWPlv6e0LSZknzna0KdegKSd8u/f3bKgaJwJHeKWm7tXaX04WgtlhrH5XUd9TdE51TrpB0t7U2Y63dKWmbiu914BHjHS/W2p9ba0dLN5+StKDqhaEmTXB+mQjnF4871vFijDEqXiS/q6pFoe45EQLNl7TniNt7xQd8TKCUaJ8p6enSXZ8otVbfzvIeHMFK+rkxZqMx5obSfbOttd1SMViUFHOsOtSqa/T6N06cX3AsE51TeF+D47lO0k+PuL3EGPOcMeYRY8wFThWFmjPeaxDnFxzLBZIOWmu3HnEf5xcclxMhkBnnPrYowxsYY8KS/kvSTdbaIUnflLRM0mpJ3ZL+0cHyUFvOt9aeJek9kv6w1DoLTMgY0yjpNyT9R+kuzi94s3hfgwkZYz4raVTS90p3dUtaaK09U9KfSLrTGNPqVH2oGRO9BnF+wbF8SK+/mMX5BZPiRAi0V1LnEbcXSNrvQB2oYcaYBhUDoO9Za++VJGvtQWtt3lpbkPSvoh0WJdba/aX/PSTpPhWPjYOl+VLlOVOHnKsQNeg9kp611h6UOL9gUiY6p/C+BuMyxlwr6b2SPmJLQzhLy3p6S3/fKGm7pJOcqxK14BivQZxfMC5jTEDS+yV9v3wf5xdMlhMh0HpJK4wxS0pXYq+R9EMH6kCNKq1vvU3SZmvtPx1x/9wjnnalpJeO/lp4jzGmpTRAXMaYFknvUvHY+KGka0tPu1bSD5ypEDXqdVfPOL9gEiY6p/xQ0jXGmKAxZomkFZKecaA+1BBjzKWSPiXpN6y16SPuj5aG0ssYs1TF42WHM1WiVhzjNYjzCyZysaRXrLV7y3dwfsFkBar9A0u7JHxC0oOS/JJut9a+XO06UNPOl/RRSS+WtzyU9BlJHzLGrFaxDfY1Sb/nTHmoMbMl3VfMDhWQdKe19mfGmPWS7jHGXC9pt6QPOFgjaogxplnFHSqPPId8hfMLyowxd0m6SFKHMWavpC9I+rLGOadYa182xtwjqUvFZT9/yM493jLB8fLnkoKSHiq9Pj1lrb1R0oWSvmiMGZWUl3SjtXayQ4LhAhMcLxeN9xrE+QXjHS/W2tv0xrmGEucXTFLVt4gHAAAAAABA9TmxHAwAAAAAAABVRggEAAAAAADgAYRAAAAAAAAAHkAIBAAAAAAA4AGEQAAAAAAAAB5ACAQAAAAAAOABhEAAAAAAAAAeQAgEAAAAAADgAf8fW0Fs1UVh/QQAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIcAAACMCAYAAADm+clLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAYnklEQVR4nO3df5Cd5XXY8e/R7kq7ErsCgkCyfhgcCwR2zNhVCanb+ldJRepYaSedgckP101GJWOSNG3TQjPj/NFO6saZtmlDzGhshaR1zGQcSDSpbGDcTukkA0EQbANaEVUQs5YEAuO9i7Srvbt7+sd973JZ3dVehd373r33+5nZ2fs+7/Ounp2jH1dnz3OeyEwkSZIkSZLUm9aUvQBJkiRJkiSVx+SQJEmSJElSDzM5JEmSJEmS1MNMDkmSJEmSJPUwk0OSJEmSJEk9zOSQJEmSJElSD+svewHNXHHFFXn11VeXvQxJkiRJkqSu8eSTT76amZsWji+ZHIqIA8DHgVcy871N7gfwm8CPAGeBf5KZTxX39hT3+oAvZOZnW1ns1VdfzeHDh1uZKkmSJEmSpBZExF81G29lW9l9wJ4L3L8V2Fl87AM+X/yCfcA9xf0bgNsj4obWlyxJkiRJkqSVtmRyKDMfBb57gSl7gd/LmseASyNiC3ATcCwzj2fmNHB/MVeSJEmSJEkdYjkaUm8FXmq4HivGFhuXJElSjxs9VeHXDh0hM8teiiRJPW85kkPRZCwvMN78i0Tsi4jDEXH49OnTy7AsSZIkdaqvPXOK/Y8eZ3yyWvZSJEnqecuRHBoDtjdcbwNOXGC8qczcn5m7M3P3pk3nNc6WJElSF6knhUwOSZJUvuVIDh0EfjpqbgbGM/Mk8ASwMyKuiYi1wG3FXEmSJPU4k0OSJHWOVo6y/zLwYeCKiBgDfhUYAMjMe4FD1I6xP0btKPtPFfdmIuJO4CFqR9kfyMxnV+B7kCRJ0ipTmZx5y2dJklSeJZNDmXn7EvcT+PQi9w5RSx5JkiRJ8ypWDkmS1DGWY1uZJEmSdFEqU9W3fJYkSeUxOSRJkqS2s+eQJEmdw+SQJEmS2q6+raxickiSpNKZHJIkSVJbVWfnODM9C1g5JElSJzA5JEmSpLaamHrzhLLKlKeVSZJUNpNDkiRJaqvGaiErhyRJKp/JIUmSJLVVY58hew5JklQ+k0OSJElqq3q10OaRQZNDkiR1AJNDkiRJaqvKVC0htP3yofnXkiSpPCaHJEmS1Fb1yqHtl61nfLJKZpa8IkmSepvJIUmSJLVVZbJ2Qtm2y9dTnU2mqnMlr0iSpN5mckiSJEltNT5ZZaAvuGpk3fy1JEkqj8khSZIktVVlqsrGoQE2Dg3MX0uSpPKYHJIkSVJbjU9WGRkcYGRwYP5akiSVx+SQJEmS2qoyWWWksXLI5JAkSaUyOSRJkqS2qieHRoasHJIkqRO0lByKiD0RcTQijkXEXU3u/3JEPF18PBMRsxFxeXHvxYj4VnHv8HJ/A5IkSVpdKlMzb+05ZHJIkqRS9S81ISL6gHuAW4Ax4ImIOJiZz9XnZObngM8V838U+KXM/G7Dl/lIZr66rCuXJEnSqlTrOdTP8GB/cT1T8ookSeptrVQO3QQcy8zjmTkN3A/svcD824EvL8fiJEmS1F0yk8pk7bSygb41bFjb52llkiSVrJXk0FbgpYbrsWLsPBGxHtgD/GHDcAIPR8STEbHvr7tQSZIkrX5np2eZmcv5fkMjQwP2HJIkqWRLbisDoslYLjL3R4E/XbCl7IOZeSIirgQeiYjRzHz0vF+kljjaB7Bjx44WliVJkqTVpl4lVO83tHFowJ5DkiSVrJXKoTFge8P1NuDEInNvY8GWssw8UXx+BXiQ2ja182Tm/szcnZm7N23a1MKyJEmStNrUq4RGBgfmP1s5JElSuVpJDj0B7IyIayJiLbUE0MGFkyJiI/Ah4I8bxjZExHD9NfDDwDPLsXBJkiStPpWi+fTGhm1llSkbUkuSVKYlt5Vl5kxE3Ak8BPQBBzLz2Yi4o7h/bzH1HwIPZ+aZhsevAh6MiPqv9fuZ+bXl/AYkSZK0esxXDg31z38+ctLKIUmSytRKzyEy8xBwaMHYvQuu7wPuWzB2HLjxba1QkiRJXaPeX8ieQ5IkdY5WtpVJkiRJy6JZz6GJczPMzi123okkSVppJockSZLUNvXk0PBgrYC9XkFk9ZAkSeUxOSRJkqS2qUxVuWRdP/19tbehI/Xk0JTJIUmSymJySJIkSW0zPlmdrxaCNyuHPM5ekqTymBySJElS21QmZ+a3lAGMFK/rR9xLkqT2MzkkSZKktqksrBxab+WQJEllMzkkSZKktqlMVef7DMGbp5bZc0iSpPKYHJIkSVLb2HNIkqTOY3JIkiRJbVOZrM5XCwGsX9tH35rwKHtJkkpkckiSJEltUZ2d48z07FsqhyKCjUMDVg5JklQik0OSJElqi4mp2olkI0P9bxkfGeynMuVpZZIklcXkkCRJktqiXh3UWDlUv7ZySJKk8pgckiRJUltUFkkOjQwN2HNIkqQSmRySJElSW9Srg0ZMDkmS1FFMDkmSJKktKlOLbyur35MkSe1nckiSJEltMV85NLigcmiw1nMoM8tYliRJPa+l5FBE7ImIoxFxLCLuanL/wxExHhFPFx+fafVZSZIk9YbKZO1EsmaVQ9XZZKo6V8ayJEnqef1LTYiIPuAe4BZgDHgiIg5m5nMLpv7fzPz4X/NZSZIkdbnxySoDfcHgwFt/Plk/2n58ssrQ2r4yliZJUk9rpXLoJuBYZh7PzGngfmBvi1//7TwrSZKkLlKZqrJxaICIeMt4vZLIvkOSJJWjleTQVuClhuuxYmyhH4qIb0TEVyPiPRf5LBGxLyIOR8Th06dPt7AsSZIkrSbjk9Xz+g3Bmz2Ixj2xTJKkUrSSHIomYwu7BT4FvDMzbwT+G/BHF/FsbTBzf2buzszdmzZtamFZkiRJWk0qk9XzjrGHhsohk0OSJJWileTQGLC94XobcKJxQmZWMvON4vUhYCAirmjlWUmSJPWGxZJD9TErhyRJKkcryaEngJ0RcU1ErAVuAw42ToiIzVFsHo+Im4qv+1orz0qSJKk3VKZmzjupDKwckiSpbEueVpaZMxFxJ/AQ0AccyMxnI+KO4v69wI8DPxcRM8AkcFtmJtD02RX6XiRJktTBaj2Hzn/7OTxYP61spt1LkiRJtJAcgvmtYocWjN3b8Pq3gN9q9VlJkiT1lsykMlltWjk00LeGDWv7PK1MkqSStLKtTJIkSXpbzk7PMjOXTXsOQa3vkD2HJEkqh8khSZIkrbh6VVCzyqH6uD2HJEkqh8khSZIkrbh6VdDI4CKVQ4NWDkmSVBaTQ5IkSVpx42cvXDnktjJJkspjckiSJEkrrjJVO4lsZKj5eSgjQ/1MTHlamSRJZTA5JEmSpBVXrwq6UM8hK4ckSSqHySFJkiStuEoLPYfeODfDzOxcO5clSZIwOSRJktRxnn7pe3z7tbNlL2NZ1auChgebbyurVxS5tUySpPYzOSRJktRh/tl/P8y//5/Plb2MZVWZqnLJun76+5q//RwpkkP1I+8lSVL7mBySJEnqIK++cY6XK+c4cqpS9lKW1fhkddF+Q/Bm5ZB9hyRJaj+TQ5IkSR3k6KkJAF767iQTXVRFU5mcWXRLGcBIca8y6bYySZLazeSQJElSBzly8s2KoedfnihxJcurslTl0HorhyRJKovJIUmSpA4yemqCdf21t2hHTnZRcmiqOt9XqJn6KWb2HJIkqf1MDkmSJHWQ0VMVbrrmcoYH+xntor5D9hySJKlzmRySJEnqEDOzczz/8htcv2WE6zePMNpNlUNLJIfWr+2jf01QMTkkSVLbtZQciog9EXE0Io5FxF1N7v9ERHyz+PiziLix4d6LEfGtiHg6Ig4v5+IlSZK6yYuvnWF6Zo7rrhpm15ZhRk9NkJllL+ttq87OcWZ6dn7rWDMRwcjQgJVDkiSVYPEjIwoR0QfcA9wCjAFPRMTBzHyuYdoLwIcy8/WIuBXYD/xgw/2PZOary7huSZKkrlPvMbRryzDnZuZ449xfMfb6JNsvX1/yyt6eianaCWQbhy781nPj0ACVKU8rkySp3VqpHLoJOJaZxzNzGrgf2Ns4ITP/LDNfLy4fA7Yt7zIlSZK63+ipCn1rgndfeQnXbR4uxlb/1rJ6NdCFGlJD7Th7K4ckSWq/VpJDW4GXGq7HirHF/Azw1YbrBB6OiCcjYt/FL1GSJKk3jJ6c4Ps3bWBdf9+byaGTq78pdb2P0IV6DkEteWTPIUmS2m/JbWVANBlruvk9Ij5CLTn0txuGP5iZJyLiSuCRiBjNzEebPLsP2AewY8eOFpYlSZLUXUZPTfA33nkZAJes62fH5et7q3JoaIDvvD7ZjiVJkqQGrVQOjQHbG663AScWToqI9wFfAPZm5mv18cw8UXx+BXiQ2ja182Tm/szcnZm7N23a1Pp3IEmS1AUqU1W+871Jdm0Znh/btXm4K46zr0y1VjlU6zlk5ZAkSe3WSnLoCWBnRFwTEWuB24CDjRMiYgfwAPBTmfl8w/iGiBiuvwZ+GHhmuRYvSZLULY4WFULXbx6ZH9u1ZYQXXj3DVHW2rGUti/nKoQucVla/Pz5Z7YoT2iRJWk2W3FaWmTMRcSfwENAHHMjMZyPijuL+vcBngO8DfjsiAGYyczdwFfBgMdYP/H5mfm1FvhNJkqRVrN5bqLFy6PrNw8wl/OXLb/AD2zaWtbS3rTJZP61s6cqh6mwyVZ1jaG1fO5YmSZJorecQmXkIOLRg7N6G1z8L/GyT544DN77NNUqSJHW9I6cm2Dg0wOaRwfmxXVtGinuVVZ0cGp+sMtAXDA5cuGh9pDjqfnyyanJIkqQ2amVbmSRJklbY6MkKuzYPU1RcA7Dj8vUMDfQxenJ1N6WuTFXZODTwlu+tmXplkX2HJElqL5NDkiRJJZubS46emuD6LSNvGe9bE1zbBU2pxyerS/Ybgjd7Eo17nL0kSW1lckiSJKlkY69PcmZ6lus2D5937/rNwxw5WVnVTZork9Ulj7GHhsohk0OSJLWVySFJkqSSHSkqg3Y1SQ7t2jzM62ernJ441+5lLZtWk0P1OVYOSZLUXiaHJEmSSjZ6coIIuPaqJsmh+abUq7fvUGVqZsmTysDKIUmSymJySJIkqWSjpyq88/L1bFh3/kGy9Wqi+lH3q1Gt59DSh+QOD9ZPK5tZ6SVJkqQGJockSZJKNnpqgl2bR5reu3T9WrZsHGR0lVYOZSaVyWpLlUMDfWvYsLbP08okSWozk0OSJEklmpye5cXXzrBry/lbyup2bR5etcmhs9OzzMxlSz2HoNZ3yJ5DkiS1l8khSZKkEj3/8gSZLFo5BLW+Q8demaA6O9fGlS2PeqKnlcqh+jyTQ5IktZfJIUmSpBKNFieVXb9E5VB1Njl++ky7lrVs6lvERgZbrBwaHLAhtSRJbWZySJIkqURHTk6wfm0f2y9bv+icelVRPZG0moyfvbjKIbeVSZLUfiaHJEmSSjR6qsJ1m4dZsyYWnfOuTRsY6AuOnFx9fYcqU7WTx0aGlj6trD5vYsrTyiRJaieTQ5IkSSXJzAueVFY30LeGd185vDorh+w5JElSxzM5JEmSVJKXK+f43tkquzYv3m+o7vrNw4yuxsqhyYvvOfTGuRlmVmHzbUmSViuTQ5IkSSU5UlQCtZIc2rVlmFOVKV4/M73Sy1pW9Sqg4cHWtpXVK4zcWiZJUvuYHJIkSSpJvRJoqW1ljXNGT62u6qHKVJVL1vXT39fa286RIjlUP+VMkiStvJb+lY6IPRFxNCKORcRdTe5HRPzX4v43I+IDrT4rSZLUq0ZPVXjHxkE2rl96y9Wu4qj71dZ3aHyy2nK/IXizcsi+Q5Iktc+SyaGI6APuAW4FbgBuj4gbFky7FdhZfOwDPn8Rz0qSJPWk0ZMT7NqydNUQwKZL1vF9G9auur5DlcmZlreUAYwUcyuTbiuTJKldWqkcugk4lpnHM3MauB/Yu2DOXuD3suYx4NKI2NLis5IkST1nemaO/3f6jZb6DQFEBLu2rL4TyyoXWzm03sohSZLarZUf42wFXmq4HgN+sIU5W1t89jyjJye4+de+3sLSJEmSVqfZTGbmkutaTA5Bre/Q7/zpC6vqfdKrb5zjo7uubHl+PZF09wPf5N/9yXMrtSxJktSgleRQNBnLFue08mztC0Tso7YljY3veBcfunZTC0uTJElavYbW9l1U4uT2m3ZwdnqWubmmb6c61o+9f2vLczePDPILH9vJy+NTK7giSZJ60+OLjLeSHBoDtjdcbwNOtDhnbQvPApCZ+4H9ALt3787/+OPva2FpkiRJvePdV17Cf/hHP1D2MlZURPAvbrm27GVIktSVfn2R8VZ6Dj0B7IyIayJiLXAbcHDBnIPATxenlt0MjGfmyRaflSRJkiRJUkmWrBzKzJmIuBN4COgDDmTmsxFxR3H/XuAQ8CPAMeAs8KkLPbsi34kkSZIkSZIuWmR23p713bt35+HDh8tehiRJkiRJUteIiCczc/d5452YHIqICeBo2etQKa4AXi17ESqN8e9dxr63Gf/eZex7m/HvXca+txn/cr0zM887AayVhtRlONosk6XuFxGHjX3vMv69y9j3NuPfu4x9bzP+vcvY9zbj35laaUgtSZIkSZKkLmVySJIkSZIkqYd1anJof9kLUGmMfW8z/r3L2Pc249+7jH1vM/69y9j3NuPfgTqyIbUkSZIkSZLao1MrhyRJkiRJktQGHZUciog9EXE0Io5FxF1lr0crJyK2R8T/jogjEfFsRPxiMX55RDwSEX9ZfL6s7LVq5UREX0T8RUT8SXFt/HtERFwaEV+JiNHi74EfMv69ISJ+qfh7/5mI+HJEDBr77hURByLilYh4pmFs0XhHxN3F+8CjEfH3y1m1lsMisf9c8ff+NyPiwYi4tOGese8izeLfcO9fRURGxBUNY8a/SywW+4j4+SK+z0bErzeMG/sO0THJoYjoA+4BbgVuAG6PiBvKXZVW0AzwLzPzeuBm4NNFvO8Cvp6ZO4GvF9fqXr8IHGm4Nv694zeBr2XmLuBGar8PjH+Xi4itwC8AuzPzvUAfcBvGvpvdB+xZMNY03sX7gNuA9xTP/Hbx/lCr032cH/tHgPdm5vuA54G7wdh3qfs4P/5ExHbgFuDbDWPGv7vcx4LYR8RHgL3A+zLzPcBvFOPGvoN0THIIuAk4lpnHM3MauJ/abyB1ocw8mZlPFa8nqP3HcCu1mP9uMe13gR8rZ4VaaRGxDfgHwBcaho1/D4iIEeDvAl8EyMzpzPwexr9X9ANDEdEPrAdOYOy7VmY+Cnx3wfBi8d4L3J+Z5zLzBeAYtfeHWoWaxT4zH87MmeLyMWBb8drYd5lF/uwD/GfgXwONjW+NfxdZJPY/B3w2M88Vc14pxo19B+mk5NBW4KWG67FiTF0uIq4G3g88DlyVmSehlkACrixvZVph/4Xam4O5hjHj3xveBZwGfqfYVviFiNiA8e96mfkdaj8t/DZwEhjPzIcx9r1msXj7XrC3/FPgq8VrY98DIuITwHcy8xsLbhn/7nct8Hci4vGI+D8R8TeLcWPfQTopORRNxjxKrctFxCXAHwL/PDMrZa9H7RERHwdeycwny16LStEPfAD4fGa+HziD24h6QtFbZi9wDfAOYENE/GS5q1IH8b1gj4iIX6HWYuBL9aEm04x9F4mI9cCvAJ9pdrvJmPHvLv3AZdTaifwy8AcRERj7jtJJyaExYHvD9TZqpebqUhExQC0x9KXMfKAYfjkithT3twCvLPa8VrUPAp+IiBepbSH9aET8D4x/rxgDxjLz8eL6K9SSRca/+/094IXMPJ2ZVeAB4G9h7HvNYvH2vWAPiIhPAh8HfiIz6/8JNPbd7/up/WDgG8X7v23AUxGxGePfC8aAB7Lmz6ntHLgCY99ROik59ASwMyKuiYi11BpTHSx5TVohRab4i8CRzPxPDbcOAp8sXn8S+ON2r00rLzPvzsxtmXk1tT/r/yszfxLj3xMy8xTwUkRcVwx9DHgO498Lvg3cHBHri38HPkat55yx7y2LxfsgcFtErIuIa4CdwJ+XsD6tkIjYA/wb4BOZebbhlrHvcpn5rcy8MjOvLt7/jQEfKN4TGP/u90fARwEi4lpgLfAqxr6j9Je9gLrMnImIO4GHqJ1eciAzny15WVo5HwR+CvhWRDxdjP1b4LPUygx/htp/Iv5xSetTOYx/7/h54EvFDwOOA5+i9gML49/FMvPxiPgK8BS1LSV/AewHLsHYd6WI+DLwYeCKiBgDfpVF/q7PzGcj4g+oJYtngE9n5mwpC9fbtkjs7wbWAY/U8sM8lpl3GPvu0yz+mfnFZnONf3dZ5M/+AeBAcbz9NPDJonLQ2HeQeLOaU5IkSZIkSb2mk7aVSZIkSZIkqc1MDkmSJEmSJPUwk0OSJEmSJEk9zOSQJEmSJElSDzM5JEmSJEmS1MNMDkmSJEmSJPUwk0OSJEmSJEk9zOSQJEmSJElSD/v/ZgHFbpUROpIAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tal hits: [MotifHitAndCoord(motif_idx=0, motif_score=0.6470172153354097, precision_at_motif_score=0.3596704221616013, example_idx=9, start=91, end=116, is_revcomp=True), MotifHitAndCoord(motif_idx=0, motif_score=0.9985564582348262, precision_at_motif_score=1.0, example_idx=9, start=100, end=125, is_revcomp=False)]\n", + "gata hits: [MotifHitAndCoord(motif_idx=1, motif_score=0.9969703204925457, precision_at_motif_score=1.0, example_idx=9, start=20, end=45, is_revcomp=False), MotifHitAndCoord(motif_idx=1, motif_score=0.9975591077917395, precision_at_motif_score=1.0, example_idx=9, start=158, end=183, is_revcomp=False)]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index 10\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIcAAACMCAYAAADm+clLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXyV5Z338e8vywlLQiALiARkFaECLgjua6uotXbaTovazaVop3SbmVZ9Zp7a9pmpts7UarW1uFZbRVvrlE5x17pCZd8UCJsQ9gRITkhOcpbf88c5YAwJOYEkJ+fk83698iLnXpJfyH2u+873vq7rNncXAAAAAAAAeqasVBcAAAAAAACA1CEcAgAAAAAA6MEIhwAAAAAAAHowwiEAAAAAAIAejHAIAAAAAACgByMcAgAAAAAA6MFyUl1AS0pKSnz48OGpLgMAAAAAACBjLFq0qNLdS5svbzMcMrOHJX1S0i53P7GF9SbpbkmXSaqT9FV3X5xYNy2xLlvSg+5+RzLFDh8+XAsXLkxmUwAAAAAAACTBzD5oaXkyw8oelTTtMOsvlTQm8TFD0q8T3zBb0n2J9eMlXWVm45MvGQAAAAAAAJ2tzXDI3d+QtOcwm1wp6TGPmy+pv5kNljRF0jp33+DujZJmJ7YFAAAAAABAN9ERcw4NkbSlyeuKxLKWlk/tgO8HAAAAoBOs3RnUA29s0I6aUKpLySgfO7ZQXztnhIrz81JdCgC0qCPCIWthmR9mectfxGyG4sPSNGzYsA4oCwAAAEAy3t9eo1++Wq65K3aoTyBbY48paPFiHu0XjblmvbFej83bpGvPGq4Z54xSYZ/cVJcFAB/REeFQhaShTV6XSdomKdDK8ha5+yxJsyRp8uTJrYZIAAAAADrGyq3VuueVcr343k4V5OXomxeO1nVnjdCAvoFUl5ZR1u2q1S9eXqv7Xluvx+Z9oBvOHqnrzh6ugl6ERAC6h44Ih+ZImmlmsxUfNlbt7tvNbLekMWY2QtJWSdMlXd0B3w8AAABAkuobo7rmwfnaWdOgSCymSNTVGI3/Wx+Oql+vHH3n42N07Zkj6NHSSUYPzNe9V5+ib1xQo7teWqu7Xl6rR97ZqLs+f5IuOGFgqssDgKQeZf+kpPMllZhZhaTbJOVKkrvfL2mu4o+xX6f4o+yvTayLmNlMSS8o/ij7h919VSf8DAAAAABasXlPnRZv3qfTRxbpuKK+ys0x5WRlKTfbdExhb/3j5DL1owdLlxg3uJ9mfXmyVlRU6+ZnluuGxxbqZ5+dqM+eWpbq0gD0cG2GQ+5+VRvrXdI3Wlk3V/HwCAAAAEAKBENhSdLXzx+t844vTXE1kKQJZYV66sbTddPvFulf/rBMlbUNmnHuSJkx0xOA1GjzUfYAAAAA0lcwFJEkFfTqiBkl0FEKeuXq4a+epssnDtbtz63Wf/71fcViTL0KIDU4QwAAAAAZrCbRc6gf4VC3k5eTrV9OP1ml+Xl68K2Nqqxt0M8+N0mBHO7hA+hanCEAAACADPZhzyHmFeqOsrJMt10xXqUFebrzhTUKx1z3XX1KqssC0MN0z3Coslx65PJUVwEAAACkvQv21Wt2oE4lf7xPYk6bbskUn8T10uJa7V7dIH+kSCZ+VwC6Dv0VAQAAgAwWTcxjk0XW0O31zs2W68PfGQB0le7Zc6hkjHTtX1NdBQAAAJD2HviflfrL8m1aeu3FqS4FbZi/pELffWqZXv3UeRpZmp/qcgBkoutavlNAzyEAAAAggwVDYZ5UliZK8vMkSZW1jSmuBEBPQzgEAAAAZLBgKKKCPCajTgcfhkMNKa4EQE9DOAQAAABksGAoQs+hNFGcH5AkVREOAehihEMAAABABqsJhXmMfZoo6hOQmbSbYWUAuhjhEAAAAJDBgqGI+tFzKC3kZGepqE+AYWUAuhzhEAAAAJDBmJA6vRTnBxhWBqDLEQ4BAAAAGcrdVdsQYVhZGinJz+NpZQC6HOEQAAAAkKH2N0YVc9FzKI3EwyF6DgHoWkmFQ2Y2zczWmNk6M7ulhfXfM7OliY+VZhY1s6LEuk1mtiKxbmFH/wAAAAAAWhYMhSWJnkNpJD6sjJ5DALpWm7cQzCxb0n2SPiGpQtICM5vj7u8d2Mbd75R0Z2L7KyR91933NPkyF7h7ZYdWDgAAAOCwgqGIJHoOpZOS/DzVNkQUCkfVKzc71eUA6CGS6Tk0RdI6d9/g7o2SZku68jDbXyXpyY4oDgAAAMCR+7DnEOFQuijNz5Mk7Q4ytAxA10kmHBoiaUuT1xWJZYcwsz6Spkl6pslil/SimS0ysxlHWigAAACA9qk52HOIYWXpojg/IEmq2s/QMgBdJ5lbCNbCMm9l2yskvd1sSNlZ7r7NzAZKesnMVrv7G4d8k3hwNEOShg0blkRZAAAAAA7nwLCyfvQcShsliZ5DlfQcAtCFkuk5VCFpaJPXZZK2tbLtdDUbUubu2xL/7pL0rOLD1A7h7rPcfbK7Ty4tLU2iLAAAAACHw4TU6aekIBEO8cQyAF0omXBogaQxZjbCzAKKB0Bzmm9kZoWSzpP05ybL+ppZwYHPJV0saWVHFA4AAADg8JiQOv0U92VYGYCu1+ZZwt0jZjZT0guSsiU97O6rzOymxPr7E5v+g6QX3X1/k90HSXrWzA58ryfc/fmO/AEAAAAAtCwYCis7y9QnwFOv0kWv3GwV5OUwITWALpXULQR3nytpbrNl9zd7/aikR5st2yBp0lFVCAAAAOCIBEMR5eflKHGzFmmipCCPYWUAulQyw8oAAAAApKFgKMKQsjRU3DegqlqGlQHoOoRDAAAAQIYKhsJMRp2GSvLpOQSgaxEOAQAAABmqhp5DaamkIEA4BKBLEQ4BAAAAGSoYiqgf4VDaKe6bp711YUWisVSXAqCHIBwCAAAAMhTDytJTSUGeJGkPj7MH0EUIhwAAAIAMxYTU6ak0PyBJ2s3QMgBdhHAIAAAAyEDurtoGwqF0VJwf7znEE8sAdBXCIQAAACAD1TVGFY05w8rSUEkiHGJSagBdhXAIAAAAyEDBUESS6DmUhkoSw8oIhwB0FcIhAAAAIAMFQ2FJoudQGsrPy1EgJ4thZQC6DOEQAAAAkIFq6DmUtsxMpfl5TEgNoMsQDgEAAAAZ6EDPoX6EQ2mpJD+gSnoOAegihEMAAABABvpwziGGlaWj4vw8VdFzCEAXIRwCAAAAMhATUqe3eM8hwiEAXYNwCAAAAMhATEid3kry81RV26hYzFNdCoAeIKlwyMymmdkaM1tnZre0sP58M6s2s6WJjx8kuy8AAACAjhcMRZRlUt9AdqpLwREozs9TJOaqSYR8ANCZ2uxjambZku6T9AlJFZIWmNkcd3+v2aZvuvsnj3BfAAAAAB0oGAorPy9HZpbqUnAESvIDkqTK2gb17xNIcTUAMl0yPYemSFrn7hvcvVHSbElXJvn1j2ZfAAAAAEcoGIowpCyNlebnSZJ2B3liGYDOl0w4NETSliavKxLLmjvDzJaZ2XNm9rF27iszm2FmC81s4e7du5MoCwAAAEBrakIRJqNOY8WJcKhqP5NSA+h8yYRDLfVDbT4r2mJJx7n7JEm/lPQ/7dg3vtB9lrtPdvfJpaWlSZQFAAAAoDXBUFj96DmUtg4OKwsSDgHofMmEQxWShjZ5XSZpW9MN3L3G3WsTn8+VlGtmJcnsCwAAAKDjBek5lNYG9Akoy6TKWoaVAeh8yYRDCySNMbMRZhaQNF3SnKYbmNkxlpjpzsymJL5uVTL7AgAAAOh4wYYw4VAay8oyFfXNY1gZgC7R5tnC3SNmNlPSC5KyJT3s7qvM7KbE+vslfU7S180sIqle0nR3d0kt7ttJPwsAAACABCakTn8l+QEmpAbQJZK6lZAYKja32bL7m3x+r6R7k90XAAAAQOdxd4aVZYDSgjxV1tJzCEDnS2ZYGQAAAIA0Uh+OKhpzeg6lueK+AYaVAegShEMAAABAhgmGIpJEz6E0V5Kfp0qGlQHoAoRDAAAAQIYJhsKSCIfSXUlBnurDUe1viKS6FAAZjnAIAAAAyDA1iZ5D/RhWltaK+wYkSVU8zh5AJyMcAgAAADIMw8oyQ0lBniRpN5NSA+hkhEMAAABAhvlwWBk9h9JZaX48HOKJZQA6G+EQAAAAkGHoOZQZivMZVgagaxAOAQAAABmGCakzQ3Ffeg4B6BqEQwAAAECGCYYiMpP6BgiH0lkgJ0uFvXMJhwB0OsIhAAAAIMMEQxHl5+UoK8tSXQqOUnF+gGFlADod4RAAAACQYWpCYR5jnyFK8vN4WhmATkc4BAAAAGSYYCjCfEMZojQ/j2FlADod4RAAAACQYYKhMOFQhmBYGYCuQDgEAAAAZJh4zyGGlWWCkvw8VdeH1RiJpboUABksqXDIzKaZ2RozW2dmt7Sw/hozW574eMfMJjVZt8nMVpjZUjNb2JHFAwAAADgUw8oyR0l+/HH2VfsZWgag87R5xjCzbEn3SfqEpApJC8xsjru/12SzjZLOc/e9ZnappFmSpjZZf4G7V3Zg3QAAAABawbCyzFGcH5AkVdU2anBh7xRXAyBTJdNzaIqkde6+wd0bJc2WdGXTDdz9HXffm3g5X1JZx5YJAAAAIBnuzrCyDHKg5xBPLAPQmZIJh4ZI2tLkdUViWWuul/Rck9cu6UUzW2RmM9pfIgAAAIBkhcIxRWJOz6EMUZoIhyqDhEMAOk8yZwxrYZm3uKHZBYqHQ2c3WXyWu28zs4GSXjKz1e7+Rgv7zpA0Q5KGDRuWRFkAAAAAmguGwpJEz6EMUVKQGFa2nyeWAeg8yfQcqpA0tMnrMknbmm9kZhMlPSjpSnevOrDc3bcl/t0l6VnFh6kdwt1nuftkd59cWlqa/E8AAAAA4KCaUESS1I+eQxmhTyBHBb1ytGVPXapLAZDBkgmHFkgaY2YjzCwgabqkOU03MLNhkv4k6UvuvrbJ8r5mVnDgc0kXS1rZUcUDAAAA+KgPew4RDmWKE48t1Mqt1akuA0AGa/OM4e4RM5sp6QVJ2ZIedvdVZnZTYv39kn4gqVjSr8xMkiLuPlnSIEnPJpblSHrC3Z/vlJ8EAAAAgIKJnkMMK8scE8sK9cjbm9QYiSmQk8z9fQBon6RuJ7j7XElzmy27v8nnN0i6oYX9NkiadJQ1AgAAAEjSh+EQPYcyxYSyQjVGY1q7M6gThxSmuhwAGYjYGQAAAMggTEideSYO6S9JWl7B0DIAnYNwCAAAAMgg9BzKPEOLeqt/n1yt2Lov1aUAyFCEQwAAAEAGCYbCMpPyA4RDmcLMNGFIIT2HAHQawiEAAAAgg9SEIsoP5Cgry1JdCjrQxLJCrdkRVCgcTXUpADIQ4RAAAACQQYKhCEPKMtCEIf0ViblW7wimuhQAGYhwCAAAAMggwVCYyagz0MSy+FPKVlQw7xCAjkc4BAAAAGQQeg5lpsGFvVSSH2DeIQCdgnAIAAAAyCDBhjDhUAZiUmoAnYlwCAAAAMgg8Z5DDCvLRBPK+qt8V1B1jZFUlwIgwxAOAQAAABmEYWWZa+KQQsVcem9bTapLAZBhCIcAAACADOHuTEidwSYkJqVmaBmAjkY4BAAAAGSIhkhM4ajTcyhDDerXS4P65WnFVsIhAB2LcAgAAADIEDWhsCSpH+FQxpowpL+W8zh7AB2McAgAAADIEMFQfKJihpVlrollhdpQuV/BRBAIAB0hqXDIzKaZ2RozW2dmt7Sw3szsnsT65WZ2SrL7AgAAAOgYH4ZD9BzKVBPKCuUurWJSagAdqM1wyMyyJd0n6VJJ4yVdZWbjm212qaQxiY8Zkn7djn0BAAAAdIADvUnoOZS5Jg6JT0q9gkmpAXSgZHoOTZG0zt03uHujpNmSrmy2zZWSHvO4+ZL6m9ngJPcFAAAA0AHoOZT5ivPzNKR/by1nUmoAHSiZs8YQSVuavK6QNDWJbYYkue8hynfV6rK730yitJbl98rR9WeP0MXjB8nMWtzG3fXy+7s0+93NOntMia6ZepwCOR0zBdP26nrd80q5lm1JvsEuG9BbP/3sRA3oG+iQGtLV4s17dcdzq1WbuLDpSUoL8vTNC0dr8vCidu+7syake14pV0Mkph9cMV79juBu4dqdQd39crk2Vu5v977prldulm6edoKmjixOdSk9Sjga0w/nrNKSzZ0zqWa/3jm68dxROn9saavngtZU14X1q7+tU8Xeet12xXgN7NfrsNvPXbFdv3ljg8KR2NGU3CEmlhXq3z85Xvl5rZ/i3V2PzftA8zdU6fbPTFD/Pj373IOO9Wb5bv36b+u1ry695kMJ5GTpqilD9blThyo7q31tRkMkqsfnfaA5y7YpEvWjqmP0wHzd/pkJ6nuY9/DhfNhziHAok00sK9QKJqVOmT37G3XzM8u1dW990vtc/LFB+vZFY9q8JvntO5v09MIt8iSbkoJeOZpx7khdeMLAdl/vpMKfFlfo4bc3Kpb6S6ZuIdlzz4JNe3Tvq+u0O9jQabUkc9ZoqcLmh2pr2ySzb/wLmM1QfEiaCo4dqWP7906itJat312rGx9fpMnHDdCtl43TqccN+Mj6JZv36va5q/Xupj3q3ydXr6zepUfe3qTvTxuryycMPuI3VU0orPv/tl4PvbVR7tJZo4uVnZVM4OT629rduubBv+uJr03tkRfp7q6H3tqoO55brUH9emnc4H6pLqnLLa/Yp8/dP08Xjx+k7087QaMH5re5TzAU1qw3NujBNzcqEovJXXp34x796ppTdGKiy3FbdtaEdNdLa/X0wi3qG8jR1JFFavmtm7lW76jRVx9ZoN9eN0VTRrQ/nEP7haMxzXxisV5YtVPnjClRXk52h3+PtTuDuvbRBTpzVLFuvXScJpS1/Z4IhaN6bN4m3fvqOgUbIsrNztLfN+7RPVedpDNHlRyyfUMkqtvnrtaj72zS8YPyNayob4f/HO0RicX09MItenfjHt13zSkttqU1obBu/uNyPbdyhyRp8546PXHD6SrswxAUHJ1V26p1x3Or9WZ5pYb075125/Jt++p18zMr9NBbG3XLpSfogrFt/6EVi7n+snyb7nxhjSr21uvkYf01sODwYfLhuLv+umK7dlSH9Mi1px1RQMSE1D3DhLJCPbdyh6rrwrTfXWzP/kZd/cB8bazcr3PGlCiZ6+bq+kb94uVyBUMR/fvl41ptW+5/fb3ueG61JpUVqjTJtqR8V1DX/3ahpo4o0q2XjdNJQ/u358fpUk8v2KLvP7NcJxxToLIBfVJdTrfQ1rln3a5a/ez51XrxvZ0a1C9PE4Z03u/XvI1I0szOkPRDd78k8fpWSXL325ts8xtJf3P3JxOv10g6X9LwtvZtyeTJk33hwoVH9hNJikRjenphhe56ea12Bxt06YnH6HuXjJWZ6c4XVmvuih0qyc/Tdz8xRl+YPFRvravUHc+t1uodQU0qK9Stl43T6e3oQdAYien3f/9A97xSrr11YX36pGP1LxeP1dCi5A/419fu1tceW6gxA/P1+xt6VkBUXRfWv/5xmV56b6cu+dgg/exzk1TYu+ed5OoaI3r4rY26//UNqg9HNf20ofr2x8e0eJEZjsb05LubdffL5ara36grJh2r7108VrtrQ5r5xBJV1TbqB1eM1zVTh7V68jkQLD3w5gZFY64vnT5cMy8craIe2Httd7BB02fN0/bqkB67bsoR9d5C8sLRmL75xBI9v2qHbrtivK49a0SnfJ/GSOJ98kq59uxv1KcmHavvXdJy2xyLuf68bKv+64W12rqvXuePLdXN005Qlpn+6feLtLFyv77z8eM184LRykrc1dmyp04zn1isZRXVuv7sEbp52gkd1gP1aMzfUKVvPblE1fVh/b8rT9Q/Ti472A6s3FqtbzyxWBV763XztLEaPTBfNz2+WCcMLtDj10/tkW0vjl7F3jr9/MW1enbpVhX2ztU3LxyjL54+rFNC387k7nph1Q799Pk12li5X1NHFOn/XDZOk1r5Q+uddZX6yXPva+XWGo0f3E+3XnaCzhlTetR1/GXZNn3nqaU69bgBeuSr7Q+Ifv7SWt3zSrnW/+SydveAQvp4q7xSX3zo7/rd9VN19phDb16gc+zd36irH/y7Nuyu1YNfmZz0e97d9aO/vKdH39mkG84eoX9rISCa9cZ6/WTual0x6Vjd9flJyslO7poiHI1p9oItuvvltaqsbdQnJw7W9y4Zq+OKU3vDqrk/LqrQ9/64TGePLtEDX56sXrnpdY7oLO6u51fu0E+fX61NVXU6fWSRbr10nAb376W7Xy7X7AVb1Ds3W18/f5SuO2uEegeO/v/NzBa5++RDlicRDuVIWivpIklbJS2QdLW7r2qyzeWSZkq6TPFhY/e4+5Rk9m3J0YZDB9Q1RvTgmxv1m9fXqyHR1T+Qk6UZ547U184Z+ZGTbTTm+tPiCv38pbXaXh3SxLJC9Q0kdzLevKdOW/fV66zR8bvTyfbYaO5va3ZpxuOLdPygfP3u+p4REC3bsk/feGKxdlSHdOtl43TdWcPTojtkZ6qqbdAvX12n383/QIGcLE0sK5Q1uyOxZW+dKvbWt3jhumd/o7771FK9vna3PjXpWP3kMxOUn5ejaMxVviuoZVv2aVlFtV5YuUNViT+Y//XisRpW3LPT+101IU2fNV87a0J67Pqph/Q4RMcIR2P61pNL9NzKHfrBJ8frurM7JxhqKhgK6zevb9CDb21QLCadPKy/spq1MzuDIW3YvV8nDumnWy8dp7NGf3ihvb8hon97doX+Z+k2nTOmRL/4wklavHmf/uXppXJJd35ukqadeEyn/xztsTvYoO88tURvr6vSZ04Zov/49In60+Kt+vH/vqeiPgHde/XJB0PQV97fqZt+t0jjjy3U49dPOaJhqehZQuGoVm2r1rIt1Vq6ZZ+eX7VDJum6s0fopvNGpX3IGI7GNPvdzfpF4gbMycP6q1ezoKu2IaIVW6s1pH9v/eslx+vKSUMOBscd4S/Ltunbs5do8vAiPXrtaeqT5DWpJP3oL6v0h4UVWvmjSzqsHnQ/1XVhTfrxi/r+tLH6p/NHp7qctBeLxcPhv67YrgvGDtQVk4495IbP3v2NuubBv2vd7lo9+OXJOvf49oXBTQOiGeeO1K2XnnDw754H3tig/5z7fruDoaZqGyLxG79vbFAkFtPJwwYou9n1TnaWafTAfE0sK9Skof01orhvh7ZdrXl2SYX++ellOmtUiR78CsFQS5rf/M/LyVI05vri6cfpmxeOVnF+Xod9ryMOhxI7XybpF5KyJT3s7v9pZjdJkrvfb/Gj+l5J0yTVSbrW3Re2tm9b36+jwqEDdgcb9JvX18sl3XjeyMN29w2Fo3rk7U16bc2uVgbAHap3IFvXnjVc5x3f/nktmnttzS7d+NgiHX9Mvn5/fWq7+VfWNmj+hiot27JP4RbGzw/oE9DUkUU6eVj/Vu8ObtlTp3nrq/T+jppDxs2GwlE9s7hCAwt66ZdXn6xThvHHeFObKvfrnlfLVbHn0LHMvQLZ+uqZx7Xa5T0Wc/369fX67xfXaFhRHw0s6KUVW6tVH45Kkvr1ytGUEUX61kVjNLGs+3Y97Wo7qkOaPmueKmsb9fj1U3Qyx2SHCkdj+vbsJZq7Yof+7yfH6/ouCIaa2lEd0r2vlWvtjtpD1uXmmD4/eaiumHhsixdJ7q7ZC7botjmr1Ds3W9X1YZ04pJ9+dfWp3TZYjcZcv3y1XHe/Uq7C3rnaVxfWuceX6q7PTzrkAuPFVTv0T79frAllhXrsuikMR+mhQuGolmzep/kbqlRdf+h8QXWNEa3cWqO1O4OKxOIn9WP69dL5Y0v1rYvGHNWUAN1RbUNED7yxQfPWVx2yzky6aNxAffmM4Z32R86cZdv0ndlLNGVEkR7+avIB0b/+YZneXlepebde1Cl1ofs4787XNH5wP/36i6emupS05e566b2duuvlcr2/vUZ9A9na3xjV4MJeuu6sEZo+ZagKeuVqX108GCrfdWTBUNPv98M5q/TbeR/oxnNH6pZLT9BDb23Uf/z1fV0+cbDu/sJJRxQMNbWrJqR7X1un1duDh6xriMZUvjOousb43wQFvXI0saxQI0vyW+xpOLK0r84YWazRA/OP+O/cPy/dqu8+tVSnjyzWQ185rUN6vmSyYCisB9/cqF3BBt147kgNL+n4HmBHFQ51tY4Oh9LNa6t36cbHF2nsMQW6/TMTlJtoIJq+H5u+NT/6PrU2trVWlkvu0pqdQc1bX6V566u0Zme8QcnLyWrxwicYCivm8fWThw/QGSOLddrwIm2rrte89VV6Z32VKhKTtPUJZB/8OZo6Y2Sxbv/MhB4/EXdnmbe+Sj+cs0p987I1say/ThraXxPLCjW8i+4SpKPt1fWaPmu+9tQ26jdfPlVjBxWoTyBHvXKzenyvNil+UVPXGNX+hoj2N0bV2I4JmO95tVx/Xb5d/375ON1wzshOrLLzrNpWrVueWaFTjxugWy49IS3ufL1VXqkf/WWVPn3yEH39vFGtvvefX7lDM59YrElD++tnn5uo3GZz5plJeblZ6hPIUZ/cbNqQDtQYiam+Maq6cESRqKtPILtd7Y67q+Hg14jK3dU3kKPegWzl5Rz6NcLRmOoao6pvjGrrvrqD5+yFH+xVYySmLGt5vprcbNO4wf3id5zL+mvS0P4a1MZk7Tg6B/6omjqiWD+4YryyzGQWv4aL/1o/fC3Fr/Num7NKO6rr9eJ3z0td4egSM59YrCWb9+ntWy5MdSkpE4u5QpHowTatpT9tzeI38/sEstU7N1tmJnfX39bs1s9fWqsVW6s1vLiPvv3xMbpi4rF6c12lZr2+QfM2VKmgV46umXqc3izfrfJdtXrgy5N13hEGQwe4u26bs0qPzftAZ44q1jvrq3T5hMG6e/rRB0PJiMZc63bVJkYTxD+2tHAzOhZzBRvic5iV5OfpzFHFOmNUsU49bsAhvSlb8+6mPfr+H5e1O+RG5yIcSjOvrt6pmx5frMZo10/j3is3S6cNL9IZo4p1xshiTRhS2GJDVV0f1rsb9+id9ZWat75Kq3d8mE4X9s7V6SOLdMbIYp05ukRjjiJtBjfy2FgAAAggSURBVLratn31+sKseR85UZpJvXPjFxY5SU00n1liB0KhxkjST89oSToHQz3Bcyu2a+aTSxSNtf1LzsvJUp9AtgI5WYcMfUXbYu4KhaOqD0db7J0rtd3uRN0VSgRCrf3OskyJoClbjZHWv9+4wf105qhinTmqWKeNKGJ4YTdyICBK4m150NQRRXrqxjM6ryh0CwfmqDmmB4a0B0PuRK/49uidGz93VdeHNbSot7514Rj9w8lDDvl7Z3nFPv3mjQ16bsV25WRnadaXTtX5Ywd2SP3urh/8eZUen/+BLptwjO6efnKLN9JTyd21ZU+95m2o1DuJmwhH8qSsKcOL9Oh1BEPdCeFQGirfGVT5rvjwh6a/Jm8y3u2jyw8sa/l32tbXcJfKBvTWSYcZJnY4VbUNWrx5nwYXxp82xiSISGeVtQ16bfUu1TUeuBsV7ylT1xhVrD1X6BnCEn9g5udlq09ejvrmxT8PZGcr2dx3UL88nXock313dysqqrV256Fd0Q+EGQffE+Go6hojCkd63vuho/QOZMfvZucm/g3kKCfLEv+38f/fusO0O03vhvcJ5BwMkszUpO368PeVl5N1yPcrzg/otOFFPfJhBOlk5dZqfVBVJyl+Decev+47cM0Xf+0Hr+lOGtpfI0vbfuop0tuumpB++eq6dvXizRTZ2aa+gWz1DuQk2sBs9crNPmSOHSkepNc3uZ6rS4TqE4cU6rOnlrUZymzZU6f6cFTHDyro0J/B3bV48z5NKmv5Rnx34+5av3u/Vm6tTuomkhSf7/eicQMJhroZwiEAAAAAAIAerLVwqPtHlAAAAAAAAOg0hEMAAAAAAAA9GOEQAAAAAABAD9Yt5xwys6CkNamuA2mjRFJlqotA2uB4QXtwvKA9OF7QXhwzaA+OF7QHxwtac5y7lzZf2F2nDV/T0gRJQEvMbCHHC5LF8YL24HhBe3C8oL04ZtAeHC9oD44XtBfDygAAAAAAAHowwiEAAAAAAIAerLuGQ7NSXQDSCscL2oPjBe3B8YL24HhBe3HMoD04XtAeHC9ol245ITUAAAAAAAC6RnftOQQAAAAAAIAu0K3CITObZmZrzGydmd2S6nrQvZjZUDN7zczeN7NVZvbtxPIfmtlWM1ua+Lgs1bWiezCzTWa2InFcLEwsKzKzl8ysPPHvgFTXie7BzMY2aUeWmlmNmX2HNgYHmNnDZrbLzFY2WdZqm2JmtyauadaY2SWpqRqp0srxcqeZrTaz5Wb2rJn1Tywfbmb1TdqZ+1NXOVKhleOl1fMP7QtaOWaeanK8bDKzpYnltDFoU7cZVmZm2ZLWSvqEpApJCyRd5e7vpbQwdBtmNljSYHdfbGYFkhZJ+rSkz0uqdff/SmmB6HbMbJOkye5e2WTZzyTtcfc7EiH0AHe/OVU1ontKnJO2Spoq6VrRxkCSmZ0rqVbSY+5+YmJZi22KmY2X9KSkKZKOlfSypOPdPZqi8tHFWjleLpb0qrtHzOynkpQ4XoZL+t8D26HnaeV4+aFaOP/QvkBq+Zhptv6/JVW7+49pY5CM7tRzaIqkde6+wd0bJc2WdGWKa0I34u7b3X1x4vOgpPclDUltVUhDV0r6beLz3yoeMALNXSRpvbt/kOpC0H24+xuS9jRb3FqbcqWk2e7e4O4bJa1T/FoHPURLx4u7v+jukcTL+ZLKurwwdEuttC+toX3BYY8ZMzPFb6A/2aVFIa11p3BoiKQtTV5XiD/80YpE+n2ypL8nFs1MdNF+mGFCaMIlvWhmi8xsRmLZIHffLsUDR0kDU1YdurPp+ugFFW0MWtNam8J1DdpynaTnmrweYWZLzOx1MzsnVUWh22np/EP7gracI2mnu5c3WUYbg8PqTuGQtbCse4x5Q7diZvmSnpH0HXevkfRrSaMknSRpu6T/TmF56F7OcvdTJF0q6RuJ7rfAYZlZQNKnJP0hsYg2BkeC6xq0ysz+TVJE0u8Ti7ZLGubuJ0v6Z0lPmFm/VNWHbqO18w/tC9pylT56k4s2Bm3qTuFQhaShTV6XSdqWolrQTZlZruLB0O/d/U+S5O473T3q7jFJD4hutUhw922Jf3dJelbxY2NnYv6qA/NY7UpdheimLpW02N13SrQxaFNrbQrXNWiRmX1F0iclXeOJyT8Tw4OqEp8vkrRe0vGpqxLdwWHOP7QvaJWZ5Uj6jKSnDiyjjUEyulM4tEDSGDMbkbhrO13SnBTXhG4kMXb2IUnvu/vPmywf3GSzf5C0svm+6HnMrG9i4nKZWV9JFyt+bMyR9JXEZl+R9OfUVIhu7CN322hj0IbW2pQ5kqabWZ6ZjZA0RtK7KagP3YiZTZN0s6RPuXtdk+WliYnwZWYjFT9eNqSmSnQXhzn/0L7gcD4uabW7VxxYQBuDZOSkuoADEk9tmCnpBUnZkh5291UpLgvdy1mSviRpxYHHMkr6P5KuMrOTFO9Ou0nSjakpD93MIEnPxjNF5Uh6wt2fN7MFkp42s+slbZb0jymsEd2MmfVR/KmZTduRn9HGQJLM7ElJ50sqMbMKSbdJukMttCnuvsrMnpb0nuLDh77Bk4R6llaOl1sl5Ul6KXF+mu/uN0k6V9KPzSwiKSrpJndPdnJiZIBWjpfzWzr/0L5AavmYcfeHdOi8iRJtDJLQbR5lDwAAAAAAgK7XnYaVAQAAAAAAoIsRDgEAAAAAAPRghEMAAAAAAAA9GOEQAAAAAABAD0Y4BAAAAAAA0IMRDgEAAAAAAPRghEMAAAAAAAA9GOEQAAAAAABAD/b/AesD5haldCuZAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tal hits: []\n", + "gata hits: [MotifHitAndCoord(motif_idx=1, motif_score=0.998810229513942, precision_at_motif_score=1.0, example_idx=10, start=134, end=159, is_revcomp=False)]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index 11\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tal hits: [MotifHitAndCoord(motif_idx=0, motif_score=0.5891716112073493, precision_at_motif_score=0.18046493206611938, example_idx=11, start=125, end=150, is_revcomp=True), MotifHitAndCoord(motif_idx=0, motif_score=0.9986918443818005, precision_at_motif_score=1.0, example_idx=11, start=134, end=159, is_revcomp=False)]\n", + "gata hits: [MotifHitAndCoord(motif_idx=1, motif_score=0.9971011527533985, precision_at_motif_score=1.0, example_idx=11, start=87, end=112, is_revcomp=False)]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index 12\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tal hits: [MotifHitAndCoord(motif_idx=0, motif_score=0.8168112706641384, precision_at_motif_score=0.8856918434803535, example_idx=12, start=78, end=103, is_revcomp=True), MotifHitAndCoord(motif_idx=0, motif_score=0.9988549902881714, precision_at_motif_score=1.0, example_idx=12, start=87, end=112, is_revcomp=False)]\n", + "gata hits: [MotifHitAndCoord(motif_idx=1, motif_score=0.9991710670547282, precision_at_motif_score=1.0, example_idx=12, start=9, end=34, is_revcomp=False), MotifHitAndCoord(motif_idx=1, motif_score=0.9987750034461544, precision_at_motif_score=1.0, example_idx=12, start=54, end=79, is_revcomp=False)]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index 13\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tal hits: [MotifHitAndCoord(motif_idx=0, motif_score=0.5458333821414315, precision_at_motif_score=0.04620324188764962, example_idx=13, start=166, end=191, is_revcomp=True)]\n", + "gata hits: [MotifHitAndCoord(motif_idx=1, motif_score=0.9967916625348455, precision_at_motif_score=1.0, example_idx=13, start=7, end=32, is_revcomp=False)]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index 14\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tal hits: []\n", + "gata hits: [MotifHitAndCoord(motif_idx=1, motif_score=0.9754941959328381, precision_at_motif_score=1.0, example_idx=14, start=48, end=73, is_revcomp=False)]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index 15\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tal hits: [MotifHitAndCoord(motif_idx=0, motif_score=0.7170648136313933, precision_at_motif_score=0.5766776497955829, example_idx=15, start=5, end=30, is_revcomp=True), MotifHitAndCoord(motif_idx=0, motif_score=0.9977790829683072, precision_at_motif_score=1.0, example_idx=15, start=14, end=39, is_revcomp=False)]\n", + "gata hits: [MotifHitAndCoord(motif_idx=1, motif_score=0.9987429074356223, precision_at_motif_score=1.0, example_idx=15, start=71, end=96, is_revcomp=False)]\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIUAAACMCAYAAADiDBl2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXTU1f3/8eedmewrkEDYUUQUcEdc0Eqtu22t+rVi+6taW7Vq69LW3Spo3evSurW0WuteW6lbXWpFVLSKbCIgILLJEshC9kxmu78/7mQyk5lAAoEk5vU4h8PMnTufuZM7cz+f+567GGstIiIiIiIiIiLSu3i6ugAiIiIiIiIiIrLrKSgkIiIiIiIiItILKSgkIiIiIiIiItILKSgkIiIiIiIiItILKSgkIiIiIiIiItILKSgkIiIiIiIiItIL+brqhYuKiuyIESO66uVFRERERERERL525s6dW26tLW5P3i4LCo0YMYI5c+Z01cuLiIiIiIiIiHztGGPWtDevpo+JiIiIiIiIiPRCCgqJiIiIiIiIiPRCCgqJiIiIiIiIiPRCCgqJiIiIiIiIiPRCCgqJiIiIiIiIiPRCCgqJiIiIiIiIiPRCCgqJiIiIiIiIiPRC2wwKGWMeM8ZsNsYsauPxScaYamPMgui/Gzu/mCIiIiIiIiIi0pl87cjzOPAg8MRW8rxvrf12p5RIRERERERERER2um2OFLLWvgdU7oKyiIiIiIiIiIjILtJZawodZoz51BjzujFmbCcdU0REREREREREdpL2TB/blnnAcGttnTHmJOBFYFSqjMaYC4ALAIYNG9YJLy0iIiIiIiIiIttjh0cKWWtrrLV10duvAWnGmKI28k6z1o631o4vLi7e0ZcWEREREREREZHttMMjhYwxJcAma601xkzABZoqdrhku8KIEbBmTVeXQmTXGD4cVq/u6lKIiIiIiIhIN7HNoJAx5llgElBkjFkH3ASkAVhr/wj8H3CRMSYENAKTrbV2p5W4M61ZAz2kqFtlzNfnfaTS1e/t6/73FRERERERkV5pm0Eha+1Z23j8QdyW9SIiIiIiIiIi0kN01u5jIiIiIiIiIiLSgygoJCIiIiIiIiLSCykoJLtGqAEq53V1KUREREREREQkSkEh2W7hMFRWtjPz+/8HbxwEa57fqWUSERERERERkfZRUEi225lnQr9+8L//bSNj9eew+V13e8HVO71cIiIiIiIiIrJtCgrJdlm8GF57zd2+/PJtZC79LxDd0r1x484sloiIiIiIiIi0k4JCsl1efx0iEXd7/vxtZN74JoQb3W1Pxk4tl4iIiIiIiIi0j4JCsl1efx2amtztrKytZLQWyj9suR+q3anlEhEREREREZH2UVBIOsxamD275X5Dw1YyN6yDsD/+2TurWCIiIiIiIiLSAQoKSYctX+4CQ81Coa1krl0OnvSdXiYRERERERER6RgFhaTDli4Fr7edmevXgN1a1EhEREREREREuoKCQtJha9a0rCe0TXWrIbS1+WUiIiIiIiIi0hUUFJIOW768A0GhmqW0ex2hAQPalyYiIiIiIiIiO0xBIemwZctabvt828hcv8r9v+cvYHIAcke2nbe0NHGxImtdmoiIiIiIiIh0OgWFpMO++sr9/9vfuhFDw4dvJbN/s/t/35sBD4y5amcXT0RERERERETaQUEh6bDyckhLg1/+EiIRuOKKlsf63NmHQfcMakkIVELenmB84PFCyXG7vsAiIiIiIiIikmRbk39EElgLVVUwfjwEApCVBccf3/J4lb+KKqrcnUjQLTJdPJHYukJZA3d5mUVEREREREQk2TZHChljHjPGbDbGLGrjcWOM+YMxZoUxZqEx5sDOL6Z0F1VVbjv6I46AjAyXtvvubWT2l4E3A4qPgLQ8lxZu3CXlFBEREREREZGta8/0sceBE7by+InAqOi/C4BHdrxY0l2Vlrpg0FFHQWamS2tsK87TVA6eNMgf3ZJmvDu9jCIiIiIiIiKybdsMCllr3wMqt5LlFOAJ63wEFBpjNEfoa6q8HDweGBm3iZgxbWQO1QEGsoe1pPmyd2bxRERERERERKSdOmOh6cHAV3H310XT5Guors79PyhuLenmEUNJQvXRDMUtaRopJCIiIiIiItItdEZQKNU4EZsyozEXGGPmGGPmlJWVdcJLy65WX+/WFMrLa0lLT28jc6gOvFkKBImIiIiIiIh0Q50RFFoHDI27PwTYkCqjtXaatXa8tXZ8cXFxqizSzdXXQ79+4Pe3I3OoHjKKINy008slIiIiIiIiIh3TGUGhl4Gzo7uQHQpUW2s3dsJxpRuqq4OiIgiF2pE5VA8Z/cC2J7OIiIiIiIiI7Eq+bWUwxjwLTAKKjDHrgJuANABr7R+B14CTgBVAA/DjnVVY6Xr19S4oZFNOEGwlVA9phTu9TCIiIiIiIiLScdsMCllrz9rG4xa4pNNKJN1aXZ1bT8iTYoxZIByI3bbWYkL14M0g9bJTIiIiIiIiItKVOmP6mPQiW7ZATo5bbLq1ukBd7HZTuAmCNeDL0ULTIiIiIiIiIt2QgkLSITU1LijkSzHGrLapNvF2sEpBIREREREREZFuSkEh6ZCaGsjNTR0Uih8pVBeoaxkp5NnmLEURERERERER2cUUFJIOqa6G/PzU08dqA7WJt4M14MsFT9ouLKGIiIiIiIiItIeCQtIhdXVQUJD6sfjpY3WBOgjVafcxERERERERkW5KQSHpkMZGKGwjzhM/fay2qRYiIUjP30UlExEREREREZGOUFBIOiQScVvSpxI/fcwFiCLgayOziIiIiIiIiHQpBYWkQ6x1u4+lkjBSKFALNtK56wk1VUCwdtv5RERERERERGSbFBSSDolEwNPGpyZpS3ps521HXzoD/jUEXhoOtSs655giIiIiIiIivZiCQtIh1oIxqR+raaqJ3a4L1LmRQqYTPmI2Av87ByJ+CFTB3Mt3/JgiIjvg5pk38/zi57u6GCIiIiIiO8TX1QWQnmVrI4UqGytjt6v8VS6Y0xlxx9L/QrAqesdC6ds7fkwR6XFGjIA1a7q6FM1uBODMLi6FJBs+HFav7upSiIiIiPQMCgpJh2wtKLTFvyXxtrfVsKLpJeDfBHjgB+H2v+gXf3Lb24tIr7ZmjRut2B2YqYZ0bzpNNzR1dVGklbZGs4qIiIhIMk0fk05T7a+O3a7yVwEmOlooyr8peiNCh5R/kHg/4t+u8omIdKZAONDVRRARERER2SEKCkmHeDxutFAq1U0tQaFqf7VbT2hHf9b3l0NgizvW6MtguCZriMjO4Znq4bgnj+vqYoiIiIiI7DKaPiYdsrWgUEVjRex2dVM0KNTRUUGtVS0EbxaUHAP73eaOuWXBjh1TRCQFi+XT0k+3na+7zGETEREREdlBGikkHWJM24N/tjS2rCnkFp32gO3A2kGpVC+GcBPsewv4sgEvjLtxx44pItKGpvC21wiqDdTugpKIiIiIiOx87QoKGWNOMMYsM8asMMZck+LxScaYamPMgug/9dq/pjweCLcR53HrCDlb/NEpX5EdXHOjcj5k9IOcEe6+Nw0Gf3fHjiki0oaGYMM281Q0VKRMt9YSjuxgIFxEREREZBfaZlDIGOMFHgJOBMYAZxljxqTI+r61dv/ov5s7uZzSTRgD9fWpHwtGgmR4M4DmRacNBGt27AUb1kLRITseXBIR2YrmRaODkeA285Y3lMduR+IW0391+av4bvFpepmIiIiI9BjtGSk0AVhhrV1prQ0AzwGn7NxiSXfl9ULNVuI8BZkFZPoyXcfKk+4Wid4RTZuhcH/w5bak7eiUNBGRVsrqy9qdNz4oFL/rops2m7jovoiIiIhId9aeoNBg4Ku4++uiaa0dZoz51BjzujFmbKeUTrqd7GyoTtHfaZ4ykeZJI8uX5RLT8iBY3eYiRG+seIMXP39x6y/YVAn9DgaPtyXNl7M9RRcRadPm+s3JiSUlbnhk/L+SkoSgUPzt5mOU1pXu9PKKiIiIiHSG9gSFTIq01r38ecBwa+1+wANAyp6+MeYCY8wcY8ycsrL2/yor3UdeXuqg0Kb6TQBsrNsY+5U85M2GUD20MR3jxKdP5NTnT936CwarIbtVDNKjTfNEpHOlDApt2pQyLX6nxfjbm+qi7WDtxk4vn4iIiIjIztCeoNA6YGjc/SHAhvgM1toaa21d9PZrQJoxpqj1gay106y1462144uLi3eg2NJV8vLc9LHWi003d4IiNhJbY6ORNBcUsqHte7FIGEINbqFpEZHOUrMMXh4Fz+fBmueAxKBQfaCNhdOimoM/kDhSaEOdOzVurFNQSERERER6hvYEhT4BRhljdjPGpAOTgZfjMxhjSowxJnp7QvS4qbdnkW7rv1/+FzM11cCwFvn5UFcHwVaDf1L9yl6DNxoUikaQMgd0rECBLeBJg7SCjj1PRKQtkSC8+12o+xJCdfDReRAJJbRhKUcNxVlfuz52Oz4o9FWNm2mtkUIiIiIi0lNsMyhkrQ0BPwfeBD4HnrfWLjbG/MwY87Notv8DFhljPgX+AEy22n6lx1lRuQJIXDi1tcJCt/tY65FC8R2jZrVhINQIzbvznNbBdTaC1eDNBG9Wx54nItKWVU9Aw3pis6DDTeDxsaG2ZQDstoJC8UGf+LZv1ZZVAKytXtt55RURERER2YnaM1IIa+1r1to9rbUjrbW3RtP+aK39Y/T2g9basdba/ay1h1prP9yZhZado7lTtLUOTUFB6qBQ/LoazarDIQg3krwEFQlbNjcGG1O/mA25UULajl5EttOpz53KPxb/oyXhiz9CuB76HACDv01z+9Q8yge2HRRaW9PSRsYvKt08gmhJ2ZJOKLmIiIiIyM7XrqCQ9A5f1bpO0daCQrm5bqHpSCQxvbKhMilvdSgU3ZI+eUpa/K/r8VMxEtgwGF/LSCMRkQ56cdmL3PjOje5OsAaqFkKf/eHYWTDxORhzNQCrqlbFnhMLCg1IMeV1wAA21LSMKoofYdTs8/LPO+8NiIiIiIjsRAoKSczKypUArKle02aenBwoL3c7M8fb4t+SlLcy2ARNFSl3C4sPBK2rWZf6xZqDQilGGomIbEvziMTaQK1L2DzLTUk97En3vy8HxrmA0eqq1bHnxYJCpaUQPxPaWigtpS5YR5bPTWttHikUirQsqN9moFtEREREpJtRUEhillcuB1rWxUglN9cFhdLSEtOr/FVJebeEAhAod52vVuIDQetrOtCBml4Czxh4xtv+54hIr1TWUAbEBXlqPoeM/pA7Ekzz6c+NRCxvKMdrXLsSP5WsteZA08DcgQBsqt+U8Br5Gfmd+h5ERERERHYmBYUkpvkX73kb57WZJycHKishPT0xPRB26/5keDPI8GYAUB8xbqefUPKaQfGBoDZHChkv2CAJ08/8zVtBa0qZiGzdyi1u9GMwEt0usWYZ9P9Gy46IAL6cpEBPm20SUNNUA0BhViHQ0pY1Lz5dlFUEpFgrLVgLcaOJRERERES6AwWFBEhc+Hl+6fw28+XkuBkUNTUtaU1NsFfRXgBcefiV/GLCLwAYULCby+BP3nUsfopac8ctifG6TpTRqCAR6biktqVmGRTuA2m5Ccl1gToABuUNAmBjXdtbyjevFzR/o2snq5uqE57TL7sfELcAdSQI738f/tkX/lEIm97ZgXckIiIiItK5FBQSACob3ULR6d70lOsDNcuN9qXWxf2Q7ve3rCm0e5/dGVE4AoCqcNgtEl2fvEbRisoVsdtfbvky9Yt50iBUlXJNIhGRbfmysqVt2dK4xbVF+Xsn5Wse7dMc4Il/Xmufl7mgkI1b6ywUCcVGCg3IcYtTxwJLsybDhlfdborhepj57ZaDhQPgL09ct0hEREREZBdSUEiAlpE7zR2aYDgYe8x7s5ch9w4BoH9/tx39ihWJz29eUyg7LZvstGwA1gWCbjv5qkVJ25XFr1u0rGJZ6kKl94FwE4Qatv+NiUiv9dnmz2K3V25ZCcEtkLtbUr731r4HwPIKt67a1gLjqXZnXFO1JrYLWUleCRCdTrZlAWx8HbKHwMS/w9jrIRydVrb+NXihH7w4GP5zmHZZFBEREZEuoaCQAC0dnZJc16GJ3z0nYiOx+yUlEAjAzJnQEI3VZGW1BIWy0rLISnO78mxo8rupE2XvQ6g24fW+qPwCAK/xtr1+R1qBmz4WrG7fmygpcduitf5XUtK+54vI18rcjXNjt1duWenak1ZTx8AFdSB59E8qqXYWW1G5gje/fBOA6UumAzBr7SxY+nvI6AfHfwxDT4ex18LBD0Hp2zDrDAjVucB55fy4ha9FRERERHYdXYUK0NIpGpo/NOF+68VS8/LcTIf334dQtM+0dClU+13gJn6kUGVTFaTlQ9kHEF18ull1UzXpnnTyMvKAloWqExiP2zK6qaIlLXNA229i06aOpYvI19rKLStjO4qtqlrlFpg2ydNRU+021tYujJvqktuTNVVrYmsNVfrdVNyP138Mpf+Bva8CbzZ4vK49G3EOfHIRpBfCCfPgTD+Mu2G736OIiIiIyI5QUEgA+GT9JwBUNLoAzOLNiwFYtHlRLE9lYyXGQGEhLFwIHg8Eg/Dqq1AbcCOBsnxZZPncSKHaplrI6OsWmm7cENt5Z0M0mBSIBGIjjD4t/TR1wdILoSGuw3Za8qLVMQPaCBi1lS4iX1vNgeZR/UYB0TbNeBN3HpteAs8YNi5/Mun5y8pTT2ttbiOzfFmkedIAt35QQyBxmmtFzVrwb4bhkxOD4lvmQuNG+OabUDjOPbbXFdv9PkVEREREdoSCQgLA61++DsAHaz8A4IWlLwCJ29M377ZTXOyWCLruOqiogN//vmX3nvjpYzVNNZAZnbr18fluGhmwoCn59RduWpi6YOn9oPxjNw1tW0pL3TCm+EVbrXXpItKrNI/0aQ5Sz904140SCtW1ZPK7UT+l0ThRpi8zcWRRCoPzBgNw2SGXcdKokwAYkj+kZdv7qEGRLZA1yE2DjbdlPvQ7FHKGu8X0IeWUNhERERGRXUFBIQGio3qAkHXDeJq3cv5w3YexPM3rcwwb5u4/8AAMHAibN0N9sB5InD5WF6iDvD1c5k0z4O2jAViUIii0tHxp6oJl9oeqBVpsWkQ65IXPXWC7ebTjkrIlkF4AdauT8pZEZ5RdOuFSDh96OAD9c/qnPG7zSKFjRx7LhMETACivL4+tR2QwAOTjh9yREG7VdpW+DcUTwZu5/W9ORERERKSTKCgkAEm/cpfXlwPw35X/jaW9v9aN9Nlrr+TnNwRdxyd++lhDsAHy93JTNuKsir5UuiedjOi0iubdz5LkjnAjhdSBEpEO+GyT23msuW2zWMLZQ6Hm85ZM0TXKtkQ3/jpj7BlMHDoRgPKG8pTHLWsoA6Ago4CCDDcKqLn9ykvPY8qkKQBkeXzgSU988vQSWP8yFB/WMkpIRERERKQLKSgkCYtJp0c7MYFwgEAowIbaDbGOz4xVMwDYYw/IbBWj8Yf8GExspJDBuKBQznC3yGqcAdEY0VnjzuK8A85zaTltrPvT5wA33WPLAnc/nGKYkYj0GtZaPFM9XD/j+q3mSzX6sMzbB6oWtUwhi65RVh6dPtYnsw/9svsBsKk+9QL1WxrddvX5GfnkZ+QDsLp6NeCmkd141I2ke9OpDQWwET9ERw4Bselq+PJa0qLrGvFMYvBcRERERGRXUFBIYlvCjywcyaZfu05LIBLglWWvAG4R6eYgT2ldKcOHQ0bCZmKWplATHuOJrSlkjMEf8kP2sKStltdEF5o+ZuQxnLjHiUBLpypJwVj3i/rC30CoEeK2jG4vvx9uvRVGjoSCAhg1Cu66C5oUXxLpceZsmIPFcu//7t1qvqaQ+4IPyx9GTloOAOXefrD5PVqf+ppHChVmFlKYWQjA2uq1KY9b3eR2WizILKAg0wXMm7epL8ouco9lFLApDLZmOURHTiYIVrfcbg4UEdnq+xERERER2RkUFJJY52dg3kAKswrpk9kHgJeXvwxAxEZi62W8+PmLjBnjdh2LSWvEYzyEbZgsXxbZadl4jIdAOIDN3xvCidvarwy7aRNF2UWxTlRbHTAK93XBoNK34MMfwIzjOvTegkE49FD48kv45BOoqoKPPoILLmgd2BKRnqA5GOQP+dlQu6HNfP6wH4AZ58zg3P3PBWCDyQf/xoQdDSMW6qLxmILMglj7t75mfdIxrbWxRfXjp49VNLh1hprXISrMLGRxAEzTZmiqbDlAdLoam2dBdHc0EREREZGupKDQLhaKhNjt97sxbe60ri5KTPN6GIPz3a46fbP6Ai2BmmH5w2KdndL6UnbbDdLilsNIy6nDYzx4jRevx0uWL4twJIzX46XBkwkZcQu2Gh/rM9xK1cXZxRTnFLvj1rWxQ1h6AWRFdzBb92JsBzMuBoxJ/FdSkvT0J5+EoUPdoth9+7ps/fpBYWGH/0wi0gkC4QD+oH+7n//c4udii9k/NPuhlHmstbGA0cC8gQwvGA7ALL+BsB/+d45bvD5UT2XEjT/M8Gbg8/hiI4VK65PbpOqmagwGn8dHhi+DgswCDIYafw0AJbmuDeqb1Re/Bb+vD6x6yr0mxKarseltiESDQpltTJ0VEREREdkF2hUUMsacYIxZZoxZYYy5JsXjxhjzh+jjC40xB3Z+Ub8ernv7OlZXrebCVy+M/brcJYI10FgKTRWsju401txxGpDrOimrq1YD8Pcz/s49x90DuHU6jIHDD285VEZeLcYY0rwuUuT1ePEYDx7joTZQCwMmtWT2ZbO5fjMGQ3FOMcXZxRgMlY2VWNvG1LD+R5GwLgckTUlry3vvwYEHQlaKGRwismuFIiGyfptF1m1ZrKhc0XbGkpLkoK9paQP8IRdkuX3W7YQj4aSnVzZW0hRuItOXSXZaNoPyBgEwt+JLyN8bKj6Gd46Dj3/C5pA7EeakuylmfbL64DGelO1zRUMFxpjYYvoFGQV4PV4aQ240ZHNQqDjbBbtXZ4+BpfdAsBYiIQjVRw/0MdQscWukndZGQFxEREREZBfwbSuDMcYLPAQcC6wDPjHGvGytXRKX7URgVPTfIcAj0f97hbpAHb/78Hd8e89vM37Q+DbzTZszjbs/vBuP8RCxEcY9PI4Nv7OYTSkWNB0wAEo7ubMQaoB5V0JaHgw60W33HgmwdM0bALGO0+A8N2JoXa1ba2hU31GxbZZnr58NwIknwjvvuPV6/JE6PBDbSQwgzZvWMtWi5Bg3yidURyDUQH0wgjGGouwisnxZeKIBnorGith0sgSjLoav/gXhaIfKkwlbolPSmjuKbQSUDjjATRdraIDc3MTHAgFYvx7qo4fNyYHBgyE9Pfk4IrLjjn/yeCLRtXNGPTCKNZevYVjBsA4fJ8uXhT/kJ2zDvLXyLU7Y7WhoXAfBOsCysuwLPJjYqMeBeQMxGBeIGn8ZzL8Syj4AYHM0ppSX7hZ/LswsxGu8VPmrkl63eUey5gBS80ihoA1iMLH2qzk49E7GPuxd9wm8cRCMvQ6qFrYc7J0T4Yjn3GL6XyMVFfDpp1BTA5EIeDyQnQ377Qd5fRuoaKhgaMHQri5m12oOENqwWzPPl5sQ9OxKTU3uvG6t21Ci9aYSItJD1a6AitnRDVts9MdVA3mjoN8E8GyzSyidqaQEWvf/dkbfT6Sd2tMCTABWWGtXAhhjngNOAeKDQqcAT1g31OMjY0yhMWagtXZjp5e4G4nYCBf/+2L+NPdPAEx9dyr9svqx6pRbyDNA/miwblXl2mATl7/x89jzwE1PaAzlk53y6MmC4SAPzX6IafOmUR+sZ2zxWG78xo0c2t4Cb5oBW+bC8R+1pE0v4ctNm/DQMkKoecRQOBImOy2bftn9MMbgMR6+qvmKplATJ52UwdVXu+vYfQ+u5TNrE4JC6d50/CE/tU21MPB4d/ELbMgeR5rncyI2EpsCkpueS0OwgXU161IHhYoOhZyhULMUjA+Gntbed8z558O998Kdd8INN0AoBF4vjB/v0k4+OTF/W4tP/3PJP5m+ZDr1wXoOHHggPz3wp0RshL8u+CsLNi4gNyOXU/c6le+O/i5eT/fdRejOWXfy7up38Xq8HDfyOM4/4DwyPbhOSvwi3sYDJi15kdwdPYl99FPoNx76T3KDv5pfcs1z7jX3uTGWdckSqK119RWJrvni8bg67NMHRo+OO275x27tlrRcsBHAEgj6mDvPR1ZhP8I5o7DWfV49HmhshP33d53VZvWBeuZsmMPyiuXkZeRxQMkBvPL4nmzebPjJTxLjj7NnwxtvwN/+Bj5dR7XLA7MfYMbqGQlpxz15HIsvXpz8nYn/PEX/8J9vXgL9ITctl+prq3lo9kNc+salDJr9I+B22OOnsaesXL8UjIkFZwblDcLn8bl1gkb+BD6/G+pXA7DZpoGJxKaN9cnsgzGGpnATgXCAdG9LlLg5KJSb7iLMeel5hCIhDAZjEoNQAHPrG2HoGfDVP+GTi1reU3ofN6Usfo20jGLwl8fOGdE3D8brPtfeTuyd+8tg4+tuIwDbvMC1gd89Dvc8kZz/qKPg3XcT0266CaZMSUj6+99h2jR4++3ErBUNFRz66KEJo8P+/J0/85MDfoJJEQypaqxiTfUaappqGJw/mCF5Q0j3dUK0fsoUmDp1m+8D2DkX7CsehfUvwZH/clOjm9kwsOvOG9ZCuNUAu5NPhtNOgwsvTFxvz+/vnoGhJUtg/nwYMsS9F2td2+73Q3k5/N//ufvNfL+dgve37ax72WnKy2HyZLj6ahgzpiU9GITf/AaOOw5+9COXFgrBI4/AsGHuR71w2J0O0r1+1iyv4IADLfuMjV+g3wseb8uSA1uToi1YwzBePP0pxl10ZOx3RmNcOZYuhXPPdZuVdJrVz7lRpHm7u3bf4spf/5V74d3P3a7DBsNBHpz9INPmTaMh0MDY/mO5b9/jGb3+SThhjssUCbpzi/FQW7eRdRVfUOWvYmDeQAblDupQe7twoStuJNLy+2zztdqwYVCU4rI+3pIl8O9/w0EHuec0f5cDAffYxRe7H217qnkb5nH9jOtZuGkhmb5MzjvgPK6ceCU74/j7XNIAAB8qSURBVPfniI3w2vLXeHLhk1Q0VLBX0V5cMP4C9n1kevK5D1K3ganOfQYYMgC+/IKkBzy+5OuT9p4/rQVs3HVI3HGNZ7t/LPnyS3jwQTj++MTzV2MjvPkmXHop7L57x49rrRtkEAq19EvAFdPnc30KTzsmsjQGG9lUt4maQA39s/tTlFOEz+MjGA5S01SDz+MjJz0H3y4O1Lbn1QYDX8XdX0fyKKBUeQYDHQoKzbz/GiYdWgaHPpr4wDMGfpA4EuTn957KQ7UvJh9kik0aNPLhs3/n8Fcvg2dSbzEc79P/zGS/urPgtMSim6nJH8whDSWsy3Yf8AE5A6htqqWisYINr97P6B8+BCVHu4wLp/D2u3fSGA5y2t6n8cL3X2Duhrkc+uiheO/xwykLoXCfhF7njOuP5o/fh/79XQe4sRGeys9ik225kltbvZbFq19nTYr38eatl/GvFTcwfmIxe+zhOtaVZcey4JnZ3FR0BRQfDpklEAkQbMrFmHpG93O97P1L9o8exXLQwIMAt0bG4LzB3JC1noxPr2bkQfdzzjnw5z/Ddb/K5/tvB9m9b8s3bLfC3fjs+e9x1+IDePZZYPRlsORO7D43EV5wKnsWtVwN7F28N/t9ls7+iy6HkpmJf3cD1hqY+By8dSRk9OPjdSdzyCuj4TvLEt90is9JduMnzJ9yBld/uJqhQ900ssZG+ObI51i16kw2bjSxP/u6dfCrH73Lu3+6H9L7QnqhO2EDZ/zjjNgxX17+MlNnTMG2uoZ/cuGTTEz3stBm8NH5nzCmeAwX//ti/jLvL3z75WeZfv90yN0dMoshVM9hZ3yHJ6Y+zqhhVe6XGuOD2hU892yAyReNhz77uK2rI0F+fdFKfv2jGZTsPR7y9nAn86YKuPxUmJ5Yjt+OuZZzbq5k6P4TIG9P12A3uW20r3m7Zfbnq1+8SviF57n8/8bBhEdc4vQStxvSCyQdd+ZJ32BSIHn0hNlUmrQn3A2P/IxbN/8pKe+6okEMnnwhFOzlEhZO4ZGXnuLiyJfR17+pJfMUS3U15Oe3JK2Yu5g9frcvvJB4Aql7NIfc0z6CwnGx465443lOvXdJ0jmoILuaGe8XJASEQpEQube3GkoGnPzq83xz8hmJASh/OaPnlfCjp0MJeffbfTnX3b4nZ57Z6iApPpez7/42E1YH4OG3WhI9wJMk5X39tis58ZgamJD490zVJu0x53IePzbMxG/2c22KJxOayjFPnpOU9/ivTmbacX0ZNul8F6QwXrfOzU/3T6r7WfsdxhF3RhIDym2UYZ/yAzlg1R/57o8PZsQI18H0++HS1y8FYMGFC9ij7x4c/ujhLFxWw5ghK1j299+4Ka3p+RCohdI34HvrIXtQ7Ljz184H9uasfc7CYzx8Z/R3+PVbv2bmW6czdsw6vA3rAQOf34N3zr1ELBw86GDAbRWf6cuk/p4FvLZ/Bicd9TLMOB4CFeTs+TPCG/7APv33AdxW87npubwYGkL66iddECkqJz2HcCTEmGLXfqV50xiYN5C86lq+8NQxqu8oAMYWjwXgse89yqPhMHgzYOVjkFbAL95YAlkDeODGD+G9U1wwc9CJsOHfkBl39bxwCuf+83H+5l3Dzyf8nPP2P4+nFj7FvR/dS/97S9k043aoWw3ZQ8CGef/tSo5c8iE8tS6hPi459gEeuv1L6Htw9O9pmfPau4wf/BYc90HstVg0FQ6EhN4QsPTDeey1diLMtImR0WcM1J0LuSNir7X3buUURlbz0kvjGTXKXSA1NcFezyX3Cs5/5XzOf+V8AAblDqIuWEdNUw19jGFLipGfdiFJn8sZV0zi6AtOgb0uT8rf+mJy7jUHctC558KUlvdRXmYZMgT8UxKfOuvuczgiVJd8yBRt3cz7r2HSojfh0QWJeVsdE+CHpcfx19MzSAvVgDcHFt0Mi2/FtL7OBg6t24OPcl0QLSctJzYyLpUjq/blvW+UwamJC68/cdHZnH35ITD4JJqnYC+dv5H9jjks6QeQ3C0v0NR0GqGQiV3s1m2poe/FBUl/97smX8UVV2aSNvLMltEG4SZ4fb+k9uuDm49h4g8mJwRtATjdJB33lfNP5js/PxD2vTkhPVU78623/syEb/yUH/4wMd1dMySmvXfPRXzjexlwS+Jn2Ew1SR2l31Qfxc1V5fDXxYkHOY2k8r539BF8Y/BX8GTiVViquh+/6rtkrXyJ995r9UCKv8PSsaPY6+489/2M72w9Y+BMv2tPojYt+pABa86HkxPLm+pvtq/P8Om4YXDK6oT06r8UUvC9N6Eo7tK+5gv47xFwWuJ18xOXXcrZ52bAAXdv8/UOIJf5tPoeVQ+meMGX7LdfBv3jlpv84O4f8GTuBjj7XTjbpfnJ4VLqkupz5r3XcfYR9S3nxOb2C5I+fzMf+R2TZv8FHm91vfg0xH4pinr/3qd57Y0juOxbrd7IM4bjz18H2YNjSfNe+y8HBn4M3/sqIeuRe73P+397wgXcc0cCEd55vYwrpl3BgsQmgtUvXcOIs56A/t+IvY/Kj37P60vO4ocXjoSN/3GjCMONRC4+Bs+/Ep8fMeC9iST9jKEi7o+2tmYtC1a9zp8bz+LkkdOg30Hu2nLp/ez1xmMss8m/hqZqb2f/ejwTzpsMe/8qIX2//ZK/c+//7icc+cVSmPZh4gMpvkev73sFn+5zL1de2aoQpxtOng5c1ZL08F4/44VBjyT98JDqe/TyHt/mKu8rLF267byfjRrHPrdvhNPLE9K/uHcUo344DQZ8M5b21eerGHrD7knHSPXeVhemc9DliZtK3PDODVy24nbSl7wLfQ9q+Qw2bOTZ627krGV/cJvs+HIhEuCM0xp4+NoXKB6xuxtsYLxsrlzCgOlXUZBRwJ3H3smGmg3c/N7NjCGLJbRs7vP26rd5aM5D2D1J/LxbyzG/Hcrb4alJbaBNseTj++dM5MhLDnQzTSDWV1i0YV/Gnf2A+wxHAzszH76DScFWfQUPlN5kKan6zF2bRs164lGOGPQ3OPb9hOyp2pPxtXswJy952YHHN57NOb+c4OrIuI7Z8lllfPjhEdx3X2Lei499mAduW4HXNxHKBwOGzSuWMeMf/2PyT0dDn3Hgy4GQnzNOKeOpe94lY9DBkLMbAHVlm8nf54ykz/uK+0ezxxn3Qe5JLYnBOvhHXlKbNOqWTFZE2rf99ZvmQI4781wY/YvEB1L0KwBYeCMfvPklE698ul3Hb820uY5LcwZjzgCOt9b+NHr/R8AEa+0v4vL8G7jdWjsrev9t4Cpr7dxWx7oAuABg2LBhB61Zk3giDTYF+f1xhfz6vYaE9FuOTOM3842LbACcFKDheMsXr/ajanYZDWmQFYJBtXDHkGP4ft5R5I7sD5GIi/Jby+nDr2do/hDeuuVzsj1hsh+x8EPg4EHQt8h9WfbbRHjfMu57IoNfrypw11CT6mBSPeunF/OPdWW8PxyCHtizAn48DwYO7kufhZWxFW+avHD7YT6mzAq553sB4wZiVFxyMUUPPhzLG/BC4TWZ9E8vpk9mYaxsH15yNNe+8Qoz38/CWhfICASgproGc9sU+j/gPuURA/5cyK4F/nMHFAwELFT8i71+cgd/enY0Rx3lLvCal+SYckQmUz6Ifhi9QATqfT78F15Avwcfjv3NG33gH9OH/M+24I1+REIeCPvgDxMNV77jEiMYPFi2/OIi8h56BF+kJa8fH/celsaNHzRP9XLF23LpJeQ9+FAsb9hAo8/D7lf1YXD+oIQ6mvJIGlNmBROeHzaGAdcVJtVn7pJsBmQMID8jNyH9zj/D1TPdjzBB0kgjyG2T4PpoWiAar/ftEyBy64GknfCOez1Puvs1JT2fJi9khOPK64WmsX0pXFgZ+/s0eeGWIz3cOilC/zrYuwze3Q2+lw3/GHcYvuPfdY3mS8PBv4lIxMDRb+Lpf5hr/AH+0cddeJy8qOULsHAKkc+mYo7+D2bgse4Yn02FRTdTuCifofmDeOdW11D+8+6+XJBbhufI52D4990v0AunwuJb4IeuXpr/7sFoHd1/uI/fzA6A1wP3hKAA8hfnMjh7IO/fsYqiuhAN+Ya0BzwMXl6YVEc3/ymNK/+X6b6f0fakwefhtQsn8FjFm2zKgbwAnP0plGVE69PgQtIRCFhYecmPqX3hrzR5ID0CfRvh+f3g2pmuzsJ4MVgwEQZdk83wwmGtPifR75wH98+4Y995JFw50xAgHYvBYJl6eAFnL90DX0lR9JgGayF9zxBDXnotoT5JgwcO9/DLGZYQPiJ4SPMGeOlsL6eNOB2y89x7zptHKGchdz+ew2X/S4y1P3V8LRdExkBWjss7+iuaRm5i5KoiirOLEt7Hi2/7+N7up0KfEvce0j8ikDaf/84r4aQ+0QvHvguh3yK+fLGY50rLWFTssu63CS47CjJ+8jhm92gQKHriXvlCGvf4g3wSjbEcUAq3ZRn6/fJcOPSx2OeMRVPJW5LDoKyBZKdlxcqW/qBh1qJ+TBr9o+ivQrPA+yGrXx7AHXWbmLGba4/GlsHYf1/E0mMeZnqri6O6a64m4+67SIt+/iIG/EPA97uBpB8/wwUsrIVX9iR7fg0l6QMoyMyPlSHzIYv3R5ZIbDKra0P9kUz+MNHLDbPqY+0tYSi75GL6PfQwHtuSt9Fm8ofDvfxmVn1Cm1L+i4vp+2BL3qAHGtPSGXNNv6Q62jR9EEXTN8Q+J0EP1Kb5MGP60mf+5tj7bfTBnYekM+WDQMJrBUjjjom+pHZxysQ0pnwUBG90OJu1fHkHjKqKYOOuj3KADYM85H/vAygc6zrl1hKaPopBnwWTvp8YH5wVt13kwimEF97Cb/+Yzk0f+lv+ZhZyr05uQzMfshQtKUj6zj3wrJdfNA2FwSNcQzpyFYxcE2tvI7jvXRpBGi+/mPQHHiQ93FL3DT648fRM7tur5Qo0MwizHktn90F9KZxb6qrSQGMaDPtVAUPyBzPj1uWAa+t+nLWFBRvGccjg46M/L88C7weYH1rG3b53Qrv446wtSd85e18WR9/4AFdddRzD9s6JjlqyNDU0ccac/RmQ2z/hPV923zjOqxuDtyA3VnUBazjx+JcZmFuSkPeLl0t4prSUBQNcxn03wXmf+Hh8/zRu+qDRtVNeIARLLjuXi6se53+D3THHlsHvXzPceaKPVwe31N2YzfDvj/L5qKmGRcUQ9sKIKjhhueG5/dK5elbihWbFQ9DvtP9CybdidW8/m8pt09L41f8ysHFr8917eE3snBgkDYshjQBF1ybX/dpSGHba0zDiB7Hjsmgq9z+RzuWbS9xPpodWwqFVNAXTmb9xHw4dEP2RzPsB+D6kz+J8huYNSajP87IqWRc+jN33vdD9IcqnQ8V05r3an3v9m1nUH7wWJq2Gqz6GJw40/PIdE2ubvYS56xsRrpyVhvX6Ym1+wHjZ6+rMpPpc+HJ/bg9tZu5A93IT1sOUGV4mXto3qT7zF+cyMLuED+5YHTsnpj9oGLQs+bpl7qvFTC4qY0U/95aL6uGup8fx1IAHuek3Y8kp8MWiV0fNGJzyO9eYOZac416CrP6w6Db4/A5u/aOP699P/DEiMhgqfjuC4hOehZyBsOw+WP57Nr59EPevncvLo915f2Ql/GYeZE8u5IBJN0NuEZS/AOUv0BjI4E9/y+DymTUJDc2cX+YyftIUyB8AFf+CiukEQ17MqJ/gO/he951bfBssuZ3Frw7kzVUbWVkIaRE4sBQmrvXx3yOzeT2rhroMd43+o09hznC4ZiaE8RAkDS9hwj7D7tf2Taqj2//cfB3gi10HWOCuiR5u/NgPnujF7X0Rbn8mjWtnBRP+PkGvl8HXJF+3NJ/n4uuz+Xrxqpkt1x1ewrzy4winj/427B5dLjX8DuHQu9wzLYOr3o/rQWcAjwGTA8RGUEwvYdEXRZz/1NPc/8Aoigb4Yu3tkxfkJPUV7DfB3Him+yE07love0lyXyHrYctnr5Tw+aJSNmdDZhj2qIA9K9LJ2bMPhfNcQC9iwO+DuyZkuOv/5tcLQ3VGGoGfnh/rm4SjeYdcmc+QvEFJbehDf83gl+8mBvrumARXzTQESSOCB4Ml7DWMuq4gqT4LFucxKLsk4doy+xHLXX8x/PodYsfwEqbouoyk75zvAR+3/qWYny93u4Q2f8d3/+nqpOsWe18WVz5yCD/L2htrW/JOPOpxBmaUkJuRE8ub8RAUL8lPauv+/Z6Hkw8/C8ad7M61Zf8gsvmFlOfE7CWZKa9bNr04iAHTN8SuL5q80OTNYN/r+yfUZ/YjFoqPhGOjkeOFN8KiW1ws5+RPXaAIYHoJkcZN/OAjw9+LEvvw059NY1J2n9i1iMWdPwf9Ormv8P2MSh7/MI9/hbdQmw4D6uHCOfDj0/IYkjuId2/7sqVtzq7krr/4uGF2wF2fRPsKZdU+iv/vXTfQAGDhFIILfsvQFclt6OIVhrGnPAjDjnHf2eV/ILTsYe74czo3zI0OA/xOCL4TYfbrJXxzWCkN0eFUxsKzfwfP0Dz+WlzLxlzICcLkRXDO+ZB32sduCmS0DCyamvK7nP500AX+Mvq5/tFnU7Gf3YIZMRkmPuvatM9ugkW3EAqD77S1bqZK3HFvn+bhV+96ifha+hVN+R7eOK0vZ9YOcl/k0Wth9DoefzGNc7MOgYxocH/4l1QPWkfglf4U/Wt9wjVO3Zg+FCzaQkbY1ZvfCwFfGn89JMV37oh0rpmVvIOtf/IAMp9N/CXcGDPXWtv22jbxedsRFDoMmGKtPT56/1oAa+3tcXn+BMy01j4bvb8MmLS16WPjx4+3c+bMaU8Zd55UPyl1A48/DtOnw/PPJw97S7lgcor3sXq1O0ZTE+TluSyNjfCznyWvrSNRC66HYDUc+Dv361zzr08/pN2fE3/QT9ZtiZU0dcwx3JhbCcfMdCf5V/aEpmjn8dC/wbDTEy6u8GTBEc+7NScMgHGjgsJ+iPghLd+lhRthjwvd1JJ4TZWw/jVoKgNvGrGo5N6Xd8vPu3Si8tmuU9D/KOg7Ht45AQIVgAd+kGKUQdgPdSshUO1OkMbnpvft4JDV8vKW6X/NQenjjkuxXtfcXwIW9r/D/frdPFINUv4K0k2b7J1qddVqdvv9brH7a855hWHzL4bvrSa24H5zW+XNgTNb/TJf+jZsmglpBW70I9a1J3te0vKrXxcKRUI8+9mzHDTwIMb0H7PtJ7TD1+lzEgwHeW/Nexwy5JDYtMUOiYTddyrcABjwZkHWwB1fwyjsd9Ncwg3uvObNgvw9ae8mECJfO9bCrO+7kRB7Xgzp/eBfA6PntDbOwa1FgrDuJTcK1JPmzsU2DLufl3ytJ52rI9OLdwZrYcs82LLQfQ4wrg9QOd/1TQad5D5bbx8du66bcdhbfOsJF/Tf+KuNsSnzXxd1gTrCkTAFmduYtxlqgIZ1cee57Oisilbnufqv3DVRqC42qohI0J0TG9ZH15jwuQvXooNh41vue5hW4I4bqnHr3Pag72JnB4V8wHLgW8B64BPgB9baxXF5TgZ+DpyEm1r2B2vthK0dV0Ghtlnr2qHPPnNzqwcPdot2Pv+8m66VpJu+jx4nsAXePg5GnuN+AfXlu8BMRmGH/r6z18/mkL+4YdjD8oex+vLVmOolsPpp1xB5s9xJPljnGvgt89x6IuAa/gPu2jmdNX1Oeg8bcZ/dSMCdHFuvDdVdrHsZPv8dTHrNjcx7adhWL6B760e4pqmGKTOncMORN9A3q4/reOSOhHHXuQsWPOAvhZzhXV3UbqG3fk5EpBtoqnQ7TDZVRhdB6gcDj1XAVHZM/AYFvpzYNNLmfnyq9flEOjUoFD3gScD9uAGHj1lrbzXG/AzAWvtH4z6JDwInAA3Aj621W434dIug0IgR0GoKm0iS4cPd0KsOGPfwOBaXLWbpJUsZXTR620/YFdRTku7oi2nwxcMuEJs9FBo3wt6/TJlVTba0x3Y02SIiIiJfK50eFNoZukVQ6OtCPSVpD/WUpLuKBKFmuRspl5YPBWN3fHqLiIiIiEgv1ZGgkDZT/jpQR19EejJPmls0WUREREREdilNcBURERERERER6YUUFBIRERERERER6YUUFBIRERERERER6YUUFBIRERERERER6YUUFBIRERERERER6YUUFBIRERERERER6YUUFBIRERERERER6YUUFBIRERERERER6YUUFBIRERERERER6YUUFBIRERERERER6YUUFBIRERERERER6YUUFBIRERERERER6YUUFBIRERERERER6YWMtbZrXtiYMmBNioeKgPJdXBzZcaq3nkt11zOp3nou1V3PpHrruVR3PZPqredS3fVMqreeK1XdDbfWFrfnyV0WFGqLMWaOtXZ8V5dDOkb11nOp7nom1VvPpbrrmVRvPZfqrmdSvfVcqrueSfXWc+1o3Wn6mIiIiIiIiIhIL6SgkIiIiIiIiIhIL9Qdg0LTuroAsl1Ubz2X6q5nUr31XKq7nkn11nOp7nom1VvPpbrrmVRvPdcO1V23W1NIRERERERERER2vu44UkhERERERERERHaybhMUMsacYIxZZoxZYYy5pqvLI20zxgw1xrxjjPncGLPYGHNZNL2vMeYtY8wX0f/7dHVZJZkxxmuMmW+MeTV6X/XWAxhjCo0x/zTGLI1+9w5T3XV/xpgrou3kImPMs8aYTNVb92SMecwYs9kYsygurc26MsZcG71mWWaMOb5rSi1t1Nvd0bZyoTHmX8aYwrjHVG/dRKq6i3vs18YYa4wpiktT3XUDbdWbMeYX0bpZbIy5Ky5d9dZNtNFe7m+M+cgYs8AYM8cYMyHuMdVdN7A9fe+O1l23CAoZY7zAQ8CJwBjgLGPMmK4tlWxFCPiVtXZv4FDgkmh9XQO8ba0dBbwdvS/dz2XA53H3VW89w++BN6y1ewH74epQddeNGWMGA5cC46214wAvMBnVW3f1OHBCq7SUdRU9500Gxkaf83D0WkZ2vcdJrre3gHHW2n2B5cC1oHrrhh4nue4wxgwFjgXWxqWp7rqPx2lVb8aYbwKnAPtaa8cCv4umq966l8dJ/s7dBUy11u4P3Bi9r7rrXjrU996euusWQSFgArDCWrvSWhsAnsM1LNINWWs3WmvnRW/X4jqng3F19rdotr8B3+uaEkpbjDFDgJOBv8Qlq966OWNMPvAN4FEAa23AWluF6q4n8AFZxhgfkA1sQPXWLVlr3wMqWyW3VVenAM9Za5ustauAFbhrGdnFUtWbtfY/1tpQ9O5HwJDobdVbN9LGdw7gPuAqIH7hU9VdN9FGvV0E3GGtbYrm2RxNV711I23UnQXyo7cLcNcpoLrrNraj793huusuQaHBwFdx99dF06SbM8aMAA4APgYGWGs3gvvwAv27rmTShvtxF1qRuDTVW/e3O1AG/DU69e8vxpgcVHfdmrV2Pe7X0rXARqDaWvsfVG89SVt1peuWnuM84PXobdVbN2eM+S6w3lr7aauHVHfd257AkcaYj40x7xpjDo6mq966v8uBu40xX+GuWa6NpqvuuqF29r07XHfdJShkUqRpW7RuzhiTC7wAXG6trenq8sjWGWO+DWy21s7t6rJIh/mAA4FHrLUHAPVoylG3F53bfQqwGzAIyDHG/L+uLZV0El239ADGmOtxw+6fbk5KkU311k0YY7KB63FTWJIeTpGmuus+fEAf3NSWK4HnjTEG1VtPcBFwhbV2KHAF0VHpqO66nQ70vTtcd90lKLQOGBp3fwgtQ9ekGzLGpOE+lE9ba6dHkzcZYwZGHx8IbG7r+dIlJgLfNcasxk3RPNoY8xSqt55gHbDOWvtx9P4/cUEi1V33dgywylpbZq0NAtOBw1G99SRt1ZWuW7o5Y8w5wLeBH1prmy+GVW/d20hcEP3T6LXKEGCeMaYE1V13tw6Ybp3ZuBHpRajeeoJzcNcnAP+gZZqR6q4b6WDfu8N1112CQp8Ao4wxuxlj0nELI73cxWWSNkQj/48Cn1tr74176GVcw0L0/5d2ddmkbdbaa621Q6y1I3DfsRnW2v+H6q3bs9aWAl8ZY0ZHk74FLEF1192tBQ41xmRH281v4eaBq956jrbq6mVgsjEmwxizGzAKmN0F5ZMUjDEnAFcD37XWNsQ9pHrrxqy1n1lr+1trR0SvVdYBB0bPgaq77u1F4GgAY8yeQDpQjuqtJ9gAHBW9fTTwRfS26q6b2I6+d4frzte5Rd4+1tqQMebnwJu43Vkes9Yu7uJiSdsmAj8CPjPGLIimXQfcgRsu+hNcZ+iMLiqfdIzqrWf4BfB0NHC+EvgxLrCvuuumrLUfG2P+CczDTWGZD0wDclG9dTvGmGeBSUCRMWYdcBNttI/W2sXGmOdxwdkQcIm1NtwlBe/l2qi3a4EM4C13Lc1H1tqfqd66l1R1Z619NFVe1V330cZ37jHgMeO2Og8A50RH6KneupE26u584PfRDTH8wAWg71w306G+9/bUnWkZUSsiIiIiIiIiIr1Fd5k+JiIiIiIiIiIiu5CCQiIiIiIiIiIivZCCQiIiIiIiIiIivZCCQiIiIiIiIiIivZCCQiIiIiIiIiIivZCCQiIiIiIiIiIivZCCQiIiIiIiIiIivZCCQiIiIiIiIiIivdD/B0s//A2cRL0RAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index 16\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIEAAACMCAYAAADr57kMAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAASqklEQVR4nO3df4zk530X8Pdnb9e368Z7CfhKU5/LuZUDuJWrRNcQKFDagrBpFBcRJIf+CCVVFJSEFvEjDhXlDyTUFgQFyallJcZFRLWqJG2tyiWNQkWFqjhxUprWpG4Pp8SXGOy0ZeeCZ+9mvQ9/zMxl7zx7N5fOfGd35/WSTjvf5/u9m0f63O3Nve95Pk+11gIAAADA0bay6AkAAAAAMH9CIAAAAIAlIAQCAAAAWAJCIAAAAIAlIAQCAAAAWAJCIAAAAIAlsLqoN7755pvb6dOnF/X2AAAAAEfOJz/5yS+21k5OurewEOj06dN54oknFvX2AAAAAEdOVf2v/e7ZDgYAAACwBIRAAAAAAEtACAQAAAAd+G+/+8U8+Kv/c9HTYIkJgQAAAKADH/zUudz/K0IgFkcIBAAAAB3Y6g/S2x5kd7cteiosKSEQAAAAdGCrP0hryfkLO4ueCktKCAQAAAAd6PUHl32FrgmBAAAAoANbo/BnSwjEggiBAAAAoAO97cFlX6FrQiAAAACYsws7L2Z7sJvEdjAWRwgEAAAAc9br70x8DV0SAgEAAMCc7e0DpCcQiyIEAgAAgDnb2wdITyAWRQgEAAAAc2YlEAeBEAgAAADmbG8zaI2hWRQhEAAAAMzZOPj5ms11K4FYGCEQAAAAzFlve3gi2KlXbFx6DV2bKgSqqruq6qmqOltV913luW+pqher6o2zmyIAAAAcblv9QY6vruTkTcetBGJhrhkCVdWxJPcnuTvJHUneVFV37PPcjyf58KwnCQAAAIdZrz/IiY21nNhY0xOIhZlmJdBrk5xtrT3dWruY5JEk90x47p1JPpjkuRnODwAAAA69rf4gmxtr2dxYsxKIhZkmBLolyTN7rs+Nxi6pqluS/I0kD8xuagAAAHA09La/vBLows5utgcvLnpKLKFpQqCaMNauuP7JJO9qrV31d3FVvbWqnqiqJ55//vlp5wgAAACH2lZ/kM311WyuryYZhkLQtWlCoHNJbt1zfSrJF6545kySR6rq95K8Mcl7quq7r/yFWmsPttbOtNbOnDx58iucMgAAABwuvf5OToy2g42voWurUzzziSS3V9VtST6f5N4kf3vvA62128avq+rhJL/YWvv5Gc4TAAAADq29PYHG19C1a4ZArbWdqnpHhqd+HUvyUGvtyap62+i+PkAAAACwj93dlvN7egIltoOxGNOsBEpr7bEkj10xNjH8aa39nT/6tAAAAOBo+NLFney2ZHN9LZvr4+1gQiC6N01PIAAAAOArNA58LlsJJARiAYRAAAAAMEfj/j+bG6vZ3Fi9bAy6JAQCAACAORqfBLa5sZbjq8eyvraS3rbTweieEAgAAADm6NJKoFE/oM31tWy9YCUQ3RMCAQAAwByNTwIb9wM6sbHmdDAWQggEAAAAc9S71BNo7dJXPYFYBCEQAAAAzFGvP0hVctPxYVNoK4FYFCEQAAAAzNFWf5Cbjq9mZaWSJJvrq1YCsRBCIAAAAJijrf4gJ25cu3R9YkNjaBZDCAQAAABz1NveuXQyWDLsCXT+wk52d9sCZ8UyEgIBAADAHG31B5dOBkuGK4FaS85f2FngrFhGQiAAAACYo15/cPlKoNHrnr5AdEwIBAAAAHN05Uqg8VHxmkPTNSEQAAAAzFFve5DNjdVL1+PXjomna0IgAAAAmJMLOy9me7D7kp5Aie1gdE8IBAAAAHPS6w+bP29uTOoJpDE03RICAQAAwJyM+/5cthLoRj2BWAwhEAAAAMzJuO/P3tPBXnbDaqr0BKJ7QiAAAACYk/Fqn73bwVZWKpvra1YC0TkhEAAAAMxJb8J2sPG1xtB0TQgEAAAAc9K7tBJo9bLxzY1VK4HonBAIAAAA5qS3PTodbH3CSqBtp4PRLSEQAAAAzMlWf5DjqytZXzt22bieQCyCEAgAAADmpNcfvKQfUKInEIshBAIAAIA52eoPLjsZbGxzw0oguicEAgAAgDnpbe+/EujCzm62By8uYFYsKyEQAAAAzMlWf5DN9dWXjI/HettWA9EdIRAAAADMSa+/M3El0HiLWK/vhDC6IwQCAACAOblaT6DxfeiKEAgAAADmYHe35fxVegIltoPRLSEQAAAAzMGXLu5ktyWb6xNWAq2Pt4MJgeiOEAgAAADmYBzwXHUlkBCIDk0VAlXVXVX1VFWdrar7Jtz/nqr69OjHr1XVN89+qgAAAHB4jPv9bG5MOB1sNKYnEF26ZghUVceS3J/k7iR3JHlTVd1xxWOfTfJtrbU7k/yLJA/OeqIAAABwmIxP/prUGPr46rGsr62kt+10MLozzUqg1yY521p7urV2MckjSe7Z+0Br7ddaa384uvxYklOznSYAAAAcLpdWAk3oCTQe33rBSiC6M00IdEuSZ/ZcnxuN7ectSX5p0o2qemtVPVFVTzz//PPTzxIAAAAOmav1BBqP2w5Gl6YJgWrCWJv4YNW3ZxgCvWvS/dbag621M621MydPnpx+lgAAAHDIjI9/n7QdbDzuiHi6NE0IdC7JrXuuTyX5wpUPVdWdSd6b5J7W2u/PZnoAAABwOG31B6lKbjr+0sbQiZVAdG+aEOgTSW6vqtuq6oYk9yZ5dO8DVfV1ST6U5Ptaa78z+2kCAADA4dLrD3LT8dWsrEzaYJNsrq9aCUSnJseRe7TWdqrqHUk+nORYkodaa09W1dtG9x9I8qNJ/niS91RVkuy01s7Mb9oAAABwsG31Bzlx4+StYMloJZDG0HTomiFQkrTWHkvy2BVjD+x5/YNJfnC2UwMAAIDDq7e9s+/JYMmwJ9D5CzvZ3W37rhaCWZpmOxgAAABwnbb6g31PBkuGK4FaS85f2OlwViwzIRAAAADMQa8/uPpKoNG9nubQdEQIBAAAAHNwrZVA46PjnRBGV4RAAAAAMAe97UE2N/ZvxTu+54QwuiIEAgAAgBm7sPNitge71+wJlNgORneEQAAAADBjvf6w2fN0IZDG0HRDCAQAAAAzNu7zs6knEAeIEAgAAABmbNzn52oh0MtuWM1K6QlEd4RAAAAAMGOXVgJd5Yj4lZXKTetrVgLRGSEQAAAAzNi42fPVegKN72sMTVeEQAAAADBjvUs9gfY/In5830oguiIEAgAAgBnrbQ9P/LradrBktBJo2+lgdEMIBAAAADO21R/k+OpK1teOXfW5TT2B6JAQCAAAAGas1x9csx9QoicQ3RICAQAAwIxt9QdXPR5+bHPDSiC6IwQCAACAGettT78S6MLObrYHL3YwK5adEAgAAABmbKs/yOb61U8GS3Lpmd621UDMnxAIAAAAZqzX35lqJdB4y1iv74Qw5k8IBAAAADN2PT2Bxs/DvAmBAAAAYIZ2d1vOX0dPoMR2MLohBAIAAIAZ+tLFney2ZHN9ipVA6+PtYEIg5k8IBAAAADM0DnSuayWQEIgOCIEAAABghsb9fTY3pjgdbPSMnkB0QQgEAAAAM/TlEOjaK4GOrx7L+tqKEIhOCIEAAABghsbHvU/TE2j8nCPi6YIQCAAAAGboenoCjZ+zEoguCIEAAABghsbHvU+zHWz8nCPi6YIQCAAAAGZoqz9IVXLT8Ws3hk6sBKI7QiAAAACYoV5/kJuOr2ZlpaZ6fnN91UogOiEEAgAAgBna6g9y4sbptoIlo5VALwiBmD8hEAAAAMxQb3tn6pPBkmFPoPMXdrK72+Y4K5gyBKqqu6rqqao6W1X3TbhfVfXvR/c/XVWvmf1UAQAA4ODb6g+mPhksGa4Eai05f8Ex8czXNUOgqjqW5P4kdye5I8mbquqOKx67O8ntox9vTfJTM54nAAAAHAq9/uD6VgKNnu1pDs2cTbMS6LVJzrbWnm6tXUzySJJ7rnjmniT/sQ19LMnLq+qVM54rAAAAHHjXuxJofJS8E8KYt2nOq7slyTN7rs8l+bNTPHNLkmf3+0V/+9nzed2//OiU0wQAAIDD4bnzF667MXSSfP9DH88Nx7TuZX6mCYEmnWl3ZbeqaZ5JVb01w+1iOfG1X59ve9XJKd4eAAAADo+VleRvvubU1M+/+utenrf8hdvypW09gfije/wq96YJgc4luXXP9akkX/gKnklr7cEkDybJmTNn2o+/8c4p3h4AAACOrvW1Y/lnr7+y9S58ZX7iKvemWWf2iSS3V9VtVXVDknuTPHrFM48m+f7RKWGvS7LVWtt3KxgAAAAA3brmSqDW2k5VvSPJh5McS/JQa+3Jqnrb6P4DSR5L8teTnE3yQpIfmN+UAQAAALhe02wHS2vtsQyDnr1jD+x53ZK8fbZTAwAAAGBWapjfLOCNq84neWohb85BcHOSLy56EiyE2i839V9ear/c1H95qf1yU//lpv6L8ydbaxNP4ppqJdCcPNVaO7PA92eBquoJ9V9Oar/c1H95qf1yU//lpfbLTf2Xm/ofTNM0hgYAAADgkBMCAQAAACyBRYZADy7wvVk89V9ear/c1H95qf1yU//lpfbLTf2Xm/ofQAtrDA0AAABAd2wHAwAAAFgCCwmBququqnqqqs5W1X2LmAPdqKpbq+pXquozVfVkVf3QaPyPVdVHqup3R19fsei5Mh9Vdayqfr2qfnF0rfZLoqpeXlUfqKrfHn0P+HPqvzyq6h+Mvu//VlX9TFWtq//RVFUPVdVzVfVbe8b2rXVVvXv0GfCpqvpri5k1s7JP/f/V6Hv/p6vq56rq5Xvuqf8RMqn+e+79o6pqVXXznjH1PyL2q31VvXNU3yer6if2jKv9AdF5CFRVx5Lcn+TuJHckeVNV3dH1POjMTpJ/2Fr7M0lel+Tto3rfl+SjrbXbk3x0dM3R9ENJPrPnWu2Xx79L8p9ba386yTdn+PtA/ZdAVd2S5O8nOdNa+6Ykx5LcG/U/qh5OctcVYxNrPfoMcG+Sbxz9nPeMPhtyeD2cl9b/I0m+qbV2Z5LfSfLuRP2PqIfz0vqnqm5N8leTfG7PmPofLQ/nitpX1bcnuSfJna21b0zyr0fjan+ALGIl0GuTnG2tPd1au5jkkQx/o3AEtdaeba19avT6fIb/CLwlw5r/9Oixn07y3YuZIfNUVaeSfFeS9+4ZVvslUFWbSf5SkvclSWvtYmvt/0b9l8lqko2qWk1yY5IvRP2PpNbaryb5gyuG96v1PUkeaa1daK19NsnZDD8bckhNqn9r7Zdbazujy48lOTV6rf5HzD5//pPk3yb5J0n2NqBV/yNkn9r/vSQ/1lq7MHrmudG42h8giwiBbknyzJ7rc6MxjriqOp3k1UkeT/InWmvPJsOgKMlXL25mzNFPZvgBYHfPmNovh69P8nyS/zDaDvjeqvqqqP9SaK19PsP//ftckmeTbLXWfjnqv0z2q7XPgcvn7yb5pdFr9V8CVfWGJJ9vrf3GFbfU/+h7VZK/WFWPV9V/rapvGY2r/QGyiBCoJow5ouyIq6qXJflgkh9urfUWPR/mr6pen+S51tonFz0XFmI1yWuS/FRr7dVJ/l9s/Vkao/4v9yS5LcnXJvmqqvrexc6KA8LnwCVSVT+SYWuA94+HJjym/kdIVd2Y5EeS/Oik2xPG1P9oWU3yigzbgPzjJD9bVRW1P1AWEQKdS3LrnutTGS4R54iqqrUMA6D3t9Y+NBr+P1X1ytH9VyZ5br+fz6H1rUneUFW/l+G2z++oqv8UtV8W55Kca609Prr+QIahkPovh7+S5LOttedba4MkH0ry56P+y2S/WvscuCSq6s1JXp/ke1pr43/sqf/R9w0Z/gfAb4w+A55K8qmq+pqo/zI4l+RDbejjGe4GuDlqf6AsIgT6RJLbq+q2qrohwwZRjy5gHnRglPy+L8lnWmv/Zs+tR5O8efT6zUl+oeu5MV+ttXe31k611k5n+Of8v7TWvjdqvxRaa/87yTNV9adGQ9+Z5H9E/ZfF55K8rqpuHP098J0Z9oRT/+WxX60fTXJvVR2vqtuS3J7k4wuYH3NUVXcleVeSN7TWXthzS/2PuNbab7bWvrq1dnr0GfBckteMPheo/9H380m+I0mq6lVJbkjyxaj9gbLa9Ru21naq6h1JPpzhaSEPtdae7HoedOZbk3xfkt+sqv8+GvunSX4sw+WBb8nwHwt/a0Hzo3tqvzzemeT9o8D/6SQ/kOF/Pqj/Eddae7yqPpDkUxluBfn1JA8meVnU/8ipqp9J8peT3FxV55L88+zzvb619mRV/WyGofBOkre31l5cyMSZiX3q/+4kx5N8ZJgD52Ottbep/9Ezqf6ttfdNelb9j5Z9/uw/lOSh0bHxF5O8ebQSUO0PkPry6kwAAAAAjqpFbAcDAAAAoGNCIAAAAIAlIAQCAAAAWAJCIAAAAIAlIAQCAAAAWAJCIAAAAIAlIAQCAAAAWAJCIAAAAIAl8P8BIMMrYM99HBkAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tal hits: [MotifHitAndCoord(motif_idx=0, motif_score=0.6887544010946807, precision_at_motif_score=0.4889720854762052, example_idx=16, start=151, end=176, is_revcomp=False)]\n", + "gata hits: [MotifHitAndCoord(motif_idx=1, motif_score=0.9987333675412913, precision_at_motif_score=1.0, example_idx=16, start=93, end=118, is_revcomp=False), MotifHitAndCoord(motif_idx=1, motif_score=0.9939796094680625, precision_at_motif_score=1.0, example_idx=16, start=141, end=166, is_revcomp=False)]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Index 17\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", "text/plain": [ "
" ] @@ -2128,6 +2766,14 @@ }, "output_type": "display_data" }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tal hits: [MotifHitAndCoord(motif_idx=0, motif_score=0.6991793707241977, precision_at_motif_score=0.5212686068774202, example_idx=17, start=51, end=76, is_revcomp=True), MotifHitAndCoord(motif_idx=0, motif_score=0.9890048345603109, precision_at_motif_score=1.0, example_idx=17, start=60, end=85, is_revcomp=False)]\n", + "gata hits: [MotifHitAndCoord(motif_idx=1, motif_score=0.9809579313367828, precision_at_motif_score=1.0, example_idx=17, start=22, end=47, is_revcomp=False)]\n" + ] + }, { "data": { "image/png": "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\n", @@ -2149,7 +2795,31 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", "text/plain": [ "
" ] @@ -2159,6 +2829,14 @@ }, "output_type": "display_data" }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tal hits: [MotifHitAndCoord(motif_idx=0, motif_score=0.7118732661068118, precision_at_motif_score=0.5605942527506326, example_idx=18, start=55, end=80, is_revcomp=True), MotifHitAndCoord(motif_idx=0, motif_score=0.9945691767749727, precision_at_motif_score=1.0, example_idx=18, start=64, end=89, is_revcomp=False)]\n", + "gata hits: [MotifHitAndCoord(motif_idx=1, motif_score=0.9987356972101512, precision_at_motif_score=1.0, example_idx=18, start=81, end=106, is_revcomp=False)]\n" + ] + }, { "data": { "image/png": "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\n", @@ -2180,7 +2858,31 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIcAAACMCAYAAADm+clLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAZmElEQVR4nO3df4xlZ3nY8e8zv3Zmzc6C2eWXd8GmWtoYBAnaOlAKhKSkdkJxK6WSrSRQmmhFhNO0atPaRSLqPxVNqrZpY7AscJy0BCsikGwrg0E0ClUI4DXh1wJOF0PwYhMvPzp38c7s3Dvz9I9z7szdmXt3zsb33jNzz/cjrfae95yzfkePvff18z7v+0ZmIkmSJEmSpGaaqrsDkiRJkiRJqo/JIUmSJEmSpAYzOSRJkiRJktRgJockSZIkSZIazOSQJEmSJElSg5kckiRJkiRJarCZujvQz6FDh/Laa6+tuxuSJEmSJEkT46GHHvpOZh7e2r5jcigi7gHeADyRmS/pcz+A3wR+CrgA/JPM/Gx578by3jTwnsx8Z5XOXnvttZw6darKo5IkSZIkSaogIv6yX3uVZWX3Ajde5v5NwLHy1wng3eU/cBq4s7x/PXBrRFxfvcuSJEmSJEkatR2TQ5n5CeB7l3nkZuB3s/Ap4OkR8VzgBuBMZj6SmavAfeWzkiRJkiRJ2iWGsSH1NcCjPddny7ZB7ZKkHufOX+SOD36BlfZa3V2RJEmSdo319eTf/c/TfO3cD+ruysQbRnIo+rTlZdr7/yERJyLiVEScOnfu3BC6JUl7wye/9h3e/5lH+eq3z9fdFUmSJGnX+HZrhd/+02/w8a/8Vd1dmXjDSA6dBY72XB8BHrtMe1+ZeXdmHs/M44cPb9s4W5Im1tJy+5LfJUmSJDlOHqdhJIdOAm+KwiuApcx8HHgQOBYR10XEHHBL+awkqcfSBb/0JEmSpK1aJofGpspR9u8Hfgw4FBFngV8DZgEy8y7gfopj7M9QHGX/lvJeJyJuAx6gOMr+nsw8PYKfQZL2tNZK8WXX8ktPkiRJ2tBNCrWWOzX3ZPLtmBzKzFt3uJ/A2wbcu58ieSRJGsByWUmSJGm71kqRFHKcPHrDWFYmSXoKujMh3QoiSZIkST2VQ46TR87kkCTVbLNc1i89SZIkqcsK+/ExOSRJNdvcc8i11JIkSVJXyz2HxsbkkCTVzBkRSZIkabtWT4V9sd2xRsXkkCTVrOVaakmSJGmb7vh4dW2di531mnsz2UwOSVKN1teT8xc9hUGSJEnaqnd87Fh5tEwOSVKNzl/s0K2QdUNqSZIkaVPvXkOOlUfL5JAk1aj7JfecxXlaKx3XUkuSJEmlpeU2z1mc3/is0TE5JEk16n7JHb16gbX15MnVtZp7JEmSJO0OrZU2R69e2Pis0TE5JEk16lYOHX3GfsAZEUmSJAmgvbbOhdU1x8ljYnJIkmrUnQE5cnXxpedaakmSJGlzXLw5Tu5c7nE9RSaHJKlGG8vKnrFwybUkSZLUZN1x8RHHyWNhckiSatSdATlq5ZAkSZK0obVSjJMPPW2O/XPTjpNHzOSQJNVoabnNVMDzDjojIkmSJHV1x8WL87Mszs86Th4xk0OSVKPWSpvFhVkO7p8tr11LLUmSJHUrhQ4uzHJwYdbTykbM5JAk1Whpuc3i/CwH9s0QYeWQJEmSBD2VQwuzLC7MOE4esUrJoYi4MSIejogzEXF7n/u/GhGfK399KSLWIuLq8t43IuKL5b1Tw/4BJGkvay23Obgwy9RUcGDfjGupJUmSJDZP9d2oHPK0spHaMTkUEdPAncBNwPXArRFxfe8zmfkbmfnDmfnDwB3An2Tm93oeeV15//gQ+y5Je97ScpvFhRmgmBUxOSRJkiQV4+S56Sn2zUy559AYVKkcugE4k5mPZOYqcB9w82WevxV4/zA6J0mTrrXS4eBCsd+Qa6klSZKkQmu5w+LCLBFRTKI6Th6pKsmha4BHe67Plm3bRMR+4EbgD3qaE/hoRDwUESf+uh2VpEnU3XMIcEZEkiRJKrW2VNifX+mwtp4192pyVUkORZ+2QRH5B8CfbllS9qrMfDnFsrS3RcRr+v5DIk5ExKmIOHXu3LkK3ZKkva+75xDgWmpJkiSp1Fq5dJwM8ANP9h2ZKsmhs8DRnusjwGMDnr2FLUvKMvOx8vcngA9RLFPbJjPvzszjmXn88OHDFbolSXvbSnuNi511FssvO09hkCRJkgqXVtjPbLRpNKokhx4EjkXEdRExR5EAOrn1oYg4CLwW+KOetqsi4kD3M/CTwJeG0XFJ2uu666YX3XNIkiRJusTWCnvAsfIIzez0QGZ2IuI24AFgGrgnM09HxFvL+3eVj/4j4KOZ+WTP688GPhQR3X/W72XmR4b5A0jSXtU9maw7E7I4P8uF1TXaa+vMTlfJ3UuSJEmTaeupvt02jcaOySGAzLwfuH9L211bru8F7t3S9gjwsqfUQ0maUEvl/kIbMyL7yxmR5TbPfNq+2volSZIk1Skzt53qC5uTqxo+p6YlqSYblUMLm6eVgTMikiRJarYnV9dYW8/NPYesHBo5k0OSVJPul9vWGRG/9CRJktRkLcfJY2dySJJqsrEh9fzmaWVFu0d0SpIkqbmWtlTYXzU3zfRUuCH1CJkckqSaLF3ofukVSSFnRCRJkqTtlUMRweL8jOPkETI5JEk1aa20mZ+dYt/MNLBZQeRGe5IkSWqyjcqhcnwMRRVRa9kK+1ExOSRJNVlabm/MhoAb7UmSJEmwuc1C71j54MKs4+QRMjkkSTVpLXcumQ2Zn51mbmbKtdSSJElqtM09h2Y22hbnZx0nj5DJIUmqydbKIShmRFxWJkmSpCbrjocPzFs5NC4mhySpJq2V9sZSsq7F+RnXUkuSJKnRlpbbHNg3w/RUbLQtLjhOHiWTQ5JUk0GVQ86ISJIkqcn6TqKWFfaZWVOvJpvJIUmqSWu5zeL8zCVtiwuupZYkSVKztZb7VdjPsrq2zsXOek29mmwmhySpBuvryfmLHSuHJEmSpC1ayx0OLlw6iXrQk31HyuSQJNXg/MUOmWybEXFDakmSJDXdoO0XAMfKI2JySJJq0No4nnN7uWxrpeNaakmSJDVWa6XN4vz2PYfAyqFRMTkkSTXofqn1mxFZW0+eXF2ro1uSJElS7S5bOeT+nCNhckiSarBRObRtRqRYW+2MiCRJkpqovbbOhdW1PhX2jpNHqVJyKCJujIiHI+JMRNze5/6PRcRSRHyu/PWOqu9KUhN1ZzxcSy1JkiRtal2mwr643xl7n5pgZqcHImIauBN4PXAWeDAiTmbml7c8+n8y8w1/zXclqVGWNvYc2nKU/bxrqSVJktRcrZUi+bNtnOyeQyNVpXLoBuBMZj6SmavAfcDNFf/8p/KuJE2s7ozH1hmRRSuHJEmS1GCD9uacnZ5i/9y04+QRqZIcugZ4tOf6bNm21Ssj4vMR8eGIePEVvktEnIiIUxFx6ty5cxW6JUl719Jym6mAq+YunRE56IyIJEmSGmzQ3pzdNsfJo1ElORR92raesfxZ4AWZ+TLgvwF/eAXvFo2Zd2fm8cw8fvjw4QrdkqS9q7XSZnFhlqmpS/+a3KgcWnEttSRJkppnUOVQt83TykajSnLoLHC05/oI8FjvA5nZyswflJ/vB2Yj4lCVdyWpiZaW231nQw7smyHCyiFJkiQ1Uzf5s/W0sqJtxnHyiFRJDj0IHIuI6yJiDrgFONn7QEQ8JyKi/HxD+ed+t8q7ktREreV239mQqangwL4Z11JLkiSpkXasHPK0spHY8bSyzOxExG3AA8A0cE9mno6It5b37wJ+BviliOgAy8AtmZlA33dH9LNI0p6xtNzedgJD1+LCrMkhSZIkNVJrucPc9BT7ZrbXsizOz/KV5fM19Gry7Zgcgo2lYvdvabur5/NvAb9V9V1JarrWSofnHJzve8+11JIkSWqqYhJ1lnJx0iUWHSePTJVlZZKkIRu05xB4CoMkSZKaqzi4ZXCF/fmVDmvrfc+50lNgckiSajBozyFwLbUkSZKaa6dxMsAPPNl36EwOSdKYrbTXuNhZ73sCA3gKgyRJkpqrddkK+6KiyLHy8JkckqQx6242PSg5dHDBZWWSJElqpqUKlUOOlYfP5JAkjVl3E73uzMdWi/OzLLfXWO2sj7NbkiRJUu1aK53L7jlUPGNyaNhMDknSmHVnOgbOiOz3S0+SJEnNk5lWDtXE5JAkjVl3s+mBew6Va6xbfulJkiSpQS6srrG2noP3HFpwnDwqJockacx2rBxyRkSSJEkN5Di5PiaHJGnMNvccGnxaWfGcR3RKkiSpOTbGyQOSQ1fNTTM9FW6/MAImhyRpzJYudL/0+m+054yIJEmSmqg7Th5UORQRLM7POE4eAZNDkjRmrZU287NT7JuZ7nvfPYckSZLURN3K+UEV9lBUFXX38NTwmBySpDG73AkMsFlG64yIJEmSmmSnPYe69xwnD5/JIUkas9Zy57KzIfOz08zNTLmWWpIkSY3SrZwftP0CFFVFjpOHz+SQJI3ZTpVDUMyIuKxMkiRJTdKtCDpwmYlUK4dGw+SQJI1Za6Vqcsi11JIkSWqO1kqbA/MzTE/FwGfcc2g0KiWHIuLGiHg4Is5ExO197v9sRHyh/PXJiHhZz71vRMQXI+JzEXFqmJ2XpL1oabk98HjOLk9hkCRJUtMsLbcvu/0CFEvOWsttMnNMvWqGwQv5ShExDdwJvB44CzwYEScz88s9j30deG1mfj8ibgLuBn605/7rMvM7Q+y3JO1ZrYrLyr775OqYeiRJkiTVr7XcqTROXl1b52JnnfnZ/qf/6spVqRy6ATiTmY9k5ipwH3Bz7wOZ+cnM/H55+SngyHC7KUmTYX09OX+xw+L85XPzi66lliRJUsO0ltuX3YwaNo+5d6w8XFWSQ9cAj/Zcny3bBvkF4MM91wl8NCIeiogTV95FSZoc5y92yGTHZWVuSC1JkqSmqXpwC+BYech2XFYG9NsJqu/ivoh4HUVy6O/2NL8qMx+LiGcBH4uIr2bmJ/q8ewI4AfD85z+/Qrckae/ZPJ5zpz2HZmmtdMhMIgZvyCdJkiRNitZKlT2HrBwahSqVQ2eBoz3XR4DHtj4UES8F3gPcnJnf7bZn5mPl708AH6JYprZNZt6dmccz8/jhw4er/wSStId0v8SqzIisrSdPrq6No1uSJElS7a6ocmjF5NAwVUkOPQgci4jrImIOuAU42ftARDwf+CDw85n5Fz3tV0XEge5n4CeBLw2r85K012xUDlU4hQGcEZEkSVIztNfWubC6VulUX3CcPGw7LivLzE5E3AY8AEwD92Tm6Yh4a3n/LuAdwDOBd5XLHzqZeRx4NvChsm0G+L3M/MhIfhJJ2gO6MxxXspb6mqcvjLxfkiRJUp1aV1BhXzzfGXmfmqTKnkNk5v3A/Vva7ur5/IvAL/Z57xHgZU+xj5I0MZY29hzyFAZJkiSpq7VSJHt2HCe759BIVFlWJkkaku4Mx04zIouewiBJkqQGqbo35+z0FPvnph0nD5nJIUkao6XlNlMBV81dfkbkoDMikiRJapCqe3N2n3GcPFwmhyRpjForbRYXZpmauvzx9BuVQyuupZYkSdLkq1o51H3G08qGy+SQJI3R0nK70mzIgX0zRFg5JEmSpGboJnt2Oq2seGbGcfKQmRySpDFqLbcrzYZMTQUH9s24llqSJEmNcMWVQ55WNlQmhyRpjJaW2zuewNC1uDBrckiSJEmN0FruMDc9xb6ZndMU7jk0fCaHJGmMWiudSrMh4FpqSZIkNUcxiTpLxOX35oRyEtVx8lCZHJKkMaq65xA4IyJJkqTmKA5uqV5hf36lw9p6jrhXzWFySJLGaKninkNQVA6ZHJIkSVITVN2bEzb3JTpv9dDQmBySpDFZaa+x2lmvdAIDFKcwuNGeJEmSmqB1RRX2M+U7jpWHxeSQJI1Jd3PpqskhK4ckSZLUFFdaYd99R8NhckiSxqS7aV53pmMni/OzLJfVRpIkSdIka610rmjPoeIdk0PDYnJIksakO7NReUZkv196kiRJmnyZaeVQzUwOSdKYdNdEV95zqFxz3fJLT5IkSRPswuoaa+tZfc+hBcfJw2ZySJLG5Iorh5wRkSRJUgM4Tq6fySFJGpPNPYeqn1ZWvOcpDJIkSZpcG+Pkismhq+ammZ4Kt18YokrJoYi4MSIejogzEXF7n/sREf+1vP+FiHh51XclqSmWLnS/9KpttOeMiCRJkpqgO06uWjkUESzOzzhOHqIdk0MRMQ3cCdwEXA/cGhHXb3nsJuBY+esE8O4reFeSGqG10mZ+dop9M9OVnnfPIUmSJDVBt1K+aoU9FFVG3T099dRVqRy6ATiTmY9k5ipwH3DzlmduBn43C58Cnh4Rz634riQ1wpWcwACbZbXOiEiSJGmSXemeQ91nHScPT5W1DdcAj/ZcnwV+tMIz11R8d5uvPn6eV/z7j1fomiTtHd+/sMoLnrm/8vPzs9Psm5niXX98hv/+Z385wp5JkiRJ9XlytagAutLk0J997bvmDoakSnIo+rRlxWeqvFv8AREnKJakcfB5L+S1LzpcoWuStLe8+kWHruj5t//0D3H6W60R9UaSJEnaHY5evcDB/dWTQyde80Ked3BhhD2aTJ8e0F4lOXQWONpzfQR4rOIzcxXeBSAz7wbuBjh+/Hj+h595aYWuSdJke9Mrr627C5IkSdKu8+pjh3n1MYtKrtSvD2ivsufQg8CxiLguIuaAW4CTW545CbypPLXsFcBSZj5e8V1JkiRJkiTVZMfKoczsRMRtwAPANHBPZp6OiLeW9+8C7gd+CjgDXADecrl3R/KTSJIkSZIk6YpFZt8tgGp1/PjxPHXqVN3dkCRJkiRJmhgR8VBmHt/WvhuTQxFxHni47n6oFoeA79TdCdXG+DeXsW82499cxr7ZjH9zGftmM/71ekFmbtusqcqG1HV4uF8mS5MvIk4Z++Yy/s1l7JvN+DeXsW82499cxr7ZjP/uVGVDakmSJEmSJE0ok0OSJEmSJEkNtluTQ3fX3QHVxtg3m/FvLmPfbMa/uYx9sxn/5jL2zWb8d6FduSG1JEmSJEmSxmO3Vg5JkiRJkiRpDHZVcigiboyIhyPiTETcXnd/NDoRcTQi/jgivhIRpyPiV8r2qyPiYxHxf8vfn1F3XzU6ETEdEX8eEf+rvDb+DRERT4+ID0TEV8u/B15p/JshIv5F+ff+lyLi/RExb+wnV0TcExFPRMSXetoGxjsi7ijHgQ9HxN+vp9cahgGx/43y7/0vRMSHIuLpPfeM/QTpF/+ee/8qIjIiDvW0Gf8JMSj2EfHLZXxPR8Sv97Qb+11i1ySHImIauBO4CbgeuDUirq+3VxqhDvAvM/OHgFcAbyvjfTvw8cw8Bny8vNbk+hXgKz3Xxr85fhP4SGb+LeBlFP8eGP8JFxHXAP8MOJ6ZLwGmgVsw9pPsXuDGLW19412OA24BXly+865yfKi96V62x/5jwEsy86XAXwB3gLGfUPeyPf5ExFHg9cA3e9qM/2S5ly2xj4jXATcDL83MFwP/sWw39rvIrkkOATcAZzLzkcxcBe6j+BdIEygzH8/Mz5afz1P8j+E1FDH/nfKx3wH+YT091KhFxBHgp4H39DQb/waIiEXgNcB7ATJzNTP/H8a/KWaAhYiYAfYDj2HsJ1ZmfgL43pbmQfG+GbgvMy9m5teBMxTjQ+1B/WKfmR/NzE55+SngSPnZ2E+YAf/tA/xn4F8DvRvfGv8JMiD2vwS8MzMvls88UbYb+11kNyWHrgEe7bk+W7ZpwkXEtcCPAJ8Gnp2Zj0ORQAKeVV/PNGL/hWJwsN7TZvyb4YXAOeC3y2WF74mIqzD+Ey8zv0UxW/hN4HFgKTM/irFvmkHxdizYLP8U+HD52dg3QES8EfhWZn5+yy3jP/leBLw6Ij4dEX8SEX+7bDf2u8huSg5FnzaPUptwEfE04A+Af56Zrbr7o/GIiDcAT2TmQ3X3RbWYAV4OvDszfwR4EpcRNUK5t8zNwHXA84CrIuLn6u2VdhHHgg0REW+n2GLgfd2mPo8Z+wkSEfuBtwPv6He7T5vxnywzwDMothP5VeD3IyIw9rvKbkoOnQWO9lwfoSg114SKiFmKxND7MvODZfNfRcRzy/vPBZ4Y9L72tFcBb4yIb1AsIf3xiPgfGP+mOAuczcxPl9cfoEgWGf/J9/eAr2fmucxsAx8E/g7GvmkGxduxYANExJuBNwA/m5nd/wk09pPvb1BMDHy+HP8dAT4bEc/B+DfBWeCDWfgMxcqBQxj7XWU3JYceBI5FxHURMUexMdXJmvukESkzxe8FvpKZ/6nn1kngzeXnNwN/NO6+afQy847MPJKZ11L8t/6/M/PnMP6NkJnfBh6NiL9ZNv0E8GWMfxN8E3hFROwvvwd+gmLPOWPfLIPifRK4JSL2RcR1wDHgMzX0TyMSETcC/wZ4Y2Ze6Lll7CdcZn4xM5+VmdeW47+zwMvLMYHxn3x/CPw4QES8CJgDvoOx31Vm6u5AV2Z2IuI24AGK00vuyczTNXdLo/Mq4OeBL0bE58q2fwu8k6LM8Bco/ifiH9fUP9XD+DfHLwPvKycDHgHeQjFhYfwnWGZ+OiI+AHyWYknJnwN3A0/D2E+kiHg/8GPAoYg4C/waA/6uz8zTEfH7FMniDvC2zFyrpeN6ygbE/g5gH/CxIj/MpzLzrcZ+8vSLf2a+t9+zxn+yDPhv/x7gnvJ4+1XgzWXloLHfRWKzmlOSJEmSJElNs5uWlUmSJEmSJGnMTA5JkiRJkiQ1mMkhSZIkSZKkBjM5JEmSJEmS1GAmhyRJkiRJkhrM5JAkSZIkSVKDmRySJEmSJElqMJNDkiRJkiRJDfb/AWbXMImKGC1+AAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -2190,6 +2892,14 @@ }, "output_type": "display_data" }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tal hits: [MotifHitAndCoord(motif_idx=0, motif_score=0.8537087137453788, precision_at_motif_score=1.0, example_idx=19, start=37, end=62, is_revcomp=False)]\n", + "gata hits: [MotifHitAndCoord(motif_idx=1, motif_score=0.9060133574960566, precision_at_motif_score=1.0, example_idx=19, start=50, end=75, is_revcomp=False), MotifHitAndCoord(motif_idx=1, motif_score=0.999371099425408, precision_at_motif_score=1.0, example_idx=19, start=162, end=187, is_revcomp=False)]\n" + ] + }, { "data": { "image/png": "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\n", @@ -2210,6 +2920,12 @@ "def visualize_idx(idx_to_viz):\n", " viz_sequence.plot_score_track(task0_transformed_scoretrack[idx_to_viz],\n", " threshold=CUTOFF_VALUE)\n", + " \n", + " viz_sequence.plot_score_track(motif_precisions[idx_to_viz][:,0])\n", + " viz_sequence.plot_score_track(motif_precisions[idx_to_viz][:,1])\n", + " \n", + " print(\"tal hits:\", motifmatch_to_coordinatesbyregionidx[0][idx_to_viz])\n", + " print(\"gata hits:\", motifmatch_to_coordinatesbyregionidx[1][idx_to_viz])\n", " viz_sequence.plot_weights(task_to_scores[\"task0\"][idx_to_viz],\n", " highlight={\n", " 'red': [(x.start, x.end) for x in\n", diff --git a/modisco/core.py b/modisco/core.py index abbd35c..30b82bd 100644 --- a/modisco/core.py +++ b/modisco/core.py @@ -132,6 +132,11 @@ def get_example_idx_len(self, example_idx): list(self.track_name_to_data_track.keys())[0]] .fwd_tracks[example_idx]) + @property + def num_examples(self): + return len(self.track_name_to_data_track[ + list(self.track_name_to_data_track.keys())[0]].fwd_tracks) + def add_track(self, data_track): assert type(data_track).__name__=="DataTrack" if len(self.track_name_to_data_track)==0: diff --git a/modisco/hit_scoring/exemplar_based_hitscoring.py b/modisco/hit_scoring/exemplar_based_hitscoring.py index ece8e94..1add96b 100644 --- a/modisco/hit_scoring/exemplar_based_hitscoring.py +++ b/modisco/hit_scoring/exemplar_based_hitscoring.py @@ -1,8 +1,9 @@ from __future__ import division, print_function -from collections import defaultdict, OrderedDict +from collections import defaultdict, OrderedDict, namedtuple import numpy as np import time from sklearn.metrics import average_precision_score, precision_recall_curve +from sklearn.isotonic import IsotonicRegression from .. import affinitymat from .. import aggregator from .. import core @@ -13,6 +14,11 @@ from joblib import Parallel, delayed +MotifHitAndCoord = namedtuple("MotifHitAndCoord", + ["motif_idx", "motif_score", "precision_at_motif_score", + "example_idx", "start", "end", "is_revcomp"]) + + def flatten_seqlet_impscore_features(seqlet_impscores): return np.reshape(seqlet_impscores, (len(seqlet_impscores), -1)) @@ -188,14 +194,15 @@ def get_shifts(seqlet_coordinate, shift_fraction, max_seq_len): seqlet_coordinate.start)*shift_fraction) coordinates_to_return = [] for shift_size in range(-shift_size_in_bp,shift_size_in_bp+1): - new_start = seqlet_coordinate.start + shift_size - new_end = seqlet_coordinate.end + shift_size - if (new_start >= 0 and new_end <= max_seq_len): - coordinates_to_return.append(core.SeqletCoordinates( - example_idx=seqlet_coordinate.example_idx, - start=new_start, - end=new_end, - is_revcomp=seqlet_coordinate.is_revcomp)) + for is_revcomp in [True, False]: + new_start = seqlet_coordinate.start + shift_size + new_end = seqlet_coordinate.end + shift_size + if (new_start >= 0 and new_end <= max_seq_len): + coordinates_to_return.append(core.SeqletCoordinates( + example_idx=seqlet_coordinate.example_idx, + start=new_start, + end=new_end, + is_revcomp=is_revcomp)) return coordinates_to_return @@ -212,7 +219,8 @@ def get_coordinates_and_labels(shift_fraction, patterns, track_set): for coor in get_shifts( seqlet_coordinate=seqlet.coor, shift_fraction=shift_fraction, - max_seq_len=track_set.get_example_idx_len(seqlet.coor.example_idx)) + max_seq_len=track_set.get_example_idx_len(seqlet.coor.example_idx), + ) ] patternidx_to_positivecoordinates = OrderedDict([ @@ -326,6 +334,12 @@ def __call__(self, coordinates, track_set, batch_size=None): coordinates=coordinates[idx:idx+batch_size], track_set=track_set)) return np.array(to_return) + def get_prec_for_threshold(self, motif_idx, threshold): + if (hasattr(threshold, '__iter__')==False): + return self.prec_ir_list[motif_idx].transform([threshold])[0] + else: + return self.prec_ir_list[motif_idx].transform(threshold) + def compute_precrecthres_list(self, coordinates, track_set, labels): """ Prepare the attribute self.precrecthres_list which, for each @@ -336,14 +350,28 @@ def compute_precrecthres_list(self, coordinates, track_set, labels): corresponds to the "no pattern" class. """ preds = self(coordinates=coordinates, track_set=track_set) - precrecthres_list = [] + assert np.min(preds) >= 0 #relevant when assuming min threshold is 0 + prec_ir_list = [] + precision_list = [] + recall_list = [] + thresholds_list = [] for pattern_idx in range(labels.shape[1]): + ir = IsotonicRegression(out_of_bounds='clip').fit( + X=preds[:,pattern_idx], y=labels[:,pattern_idx]) + prec_ir_list.append(ir) precision, recall, thresholds = precision_recall_curve( y_true=labels[:,pattern_idx], probas_pred=preds[:,pattern_idx]) - precrecthres_list.append((precision, recall, thresholds)) - self.precrecthres_list = precrecthres_list - return precrecthres_list + precision_list.append(precision) + recall_list.append(recall) + thresholds_list.append(thresholds) + + self.prec_ir_list = prec_ir_list + self.precision_list = precision_list + self.recall_list = recall_list + self.thresholds_list = thresholds_list + + return (precision_list, recall_list, thresholds_list) def prepare_instance_scorer( @@ -426,19 +454,20 @@ def get_windows_to_be_scanned_interior( transformed_scoretrack, transformed_scoretrack_bestwindowwidth, val_transformer, scanning_window_width, cutoff_value, plot_save_dir="."): sliding_window_sizes = val_transformer.sliding_window_sizes - #scores cdf - values_above_cutoff = [x >= cutoff_value for x in transformed_scoretrack] + #boolean arrays containing which values are above the cutoff + values_above_cutoff = [(x >= cutoff_value) for x in transformed_scoretrack] frac_vals_above_cutoff =\ np.sum(np.concatenate(values_above_cutoff, axis=0))/sum( [len(x) for x in values_above_cutoff]) print("Fraction of values above cutoff:", frac_vals_above_cutoff) #prepare the coordinates for the windows to be scanned coordinates_to_be_scanned = [] - for rowidx, row in enumerate(values_above_cutoff): + for rowidx, above_cutoff_mask in enumerate(values_above_cutoff): #a mask of which positions are start positions (given # window length scanning_window_width) - window_start_mask = np.zeros(len(row)-(scanning_window_width-1)).astype(bool) - colindices = np.nonzero(row)[0] + window_start_mask = np.zeros(len(above_cutoff_mask) + -(scanning_window_width-1)).astype(bool) + colindices = np.nonzero(above_cutoff_mask)[0] bestslidingwindowwidths =\ transformed_scoretrack_bestwindowwidth[rowidx][colindices] bestslidingwindow_startindices = ( @@ -490,13 +519,67 @@ def collect_coordinates_by_regionidx(coordinates): def scan_and_process_results(instance_scorer, track_set, coordinates, batch_size=None): scan_results = instance_scorer(coordinates, track_set=track_set, - batch_size=batch_size) - matching_motifidx = np.argmax(scan_results, axis=-1) + batch_size=batch_size) + #convert scan_results into a tracks that have dimensions of + # num_regions x num_motifs x region_len. Nan in locations that aren't hits. + # Four such tracks for: score, prec, recall, pos_strand + #In each case, take the max score over all scores mapping to that strand + + #for now, we are assuming windowlen is the same for all the motifs + windowlens = (set([x.end-x.start for x in coordinates])) + assert len(windowlens)==1 + windowlen = list(windowlens)[0] + del windowlens + + def initialize_return_track(): + return [np.full([track_set.get_example_idx_len(i)-(windowlen-1), + scan_results.shape[1]-1], + 0.0) + for i in range(track_set.num_examples)] + + motif_scores = initialize_return_track() + motif_precisions = initialize_return_track() + besthit_isrevcomp = initialize_return_track() + for coordinate,row_of_scan_results in zip(coordinates,scan_results): + row_of_scan_results = row_of_scan_results[:-1] + precs = np.array([instance_scorer.get_prec_for_threshold( + motif_idx=motifidx, + threshold=row_of_scan_results[motifidx]) + for motifidx in range(scan_results.shape[1]-1)]) + precs = np.array(precs) + is_revcomp = coordinate.is_revcomp + existing_scores = motif_scores[coordinate.example_idx][ + coordinate.start] + new_score_is_better = row_of_scan_results > existing_scores + motif_scores[coordinate.example_idx][ + coordinate.start][new_score_is_better] =( + row_of_scan_results[new_score_is_better]) + motif_precisions[coordinate.example_idx][ + coordinate.start][new_score_is_better] = ( + precs[new_score_is_better]) + besthit_isrevcomp[coordinate.example_idx][ + coordinate.start][new_score_is_better] = is_revcomp + + ### #get motifmatch to coordinates motifmatch_to_coordinates = defaultdict(list) - for motifidx,coordinate in zip(matching_motifidx,coordinates): + matching_motifidx = np.argmax(scan_results, axis=-1) + for motifidx,coordinate,row_of_scan_results in zip( + matching_motifidx,coordinates,scan_results): if (motifidx < scan_results.shape[-1]): - motifmatch_to_coordinates[motifidx].append(coordinate) + motif_score = row_of_scan_results[motifidx] + prec = instance_scorer.get_prec_for_threshold( + motif_idx=motifidx, threshold=motif_score) + motifmatch_to_coordinates[motifidx].append( + MotifHitAndCoord( + motif_idx=motifidx, + motif_score=motif_score, + precision_at_motif_score=prec, + example_idx=coordinate.example_idx, + start=coordinate.start, + end=coordinate.end, + is_revcomp=coordinate.is_revcomp) + ) motifmatch_to_coordinatesbyregionidx = {} for motifmatch in motifmatch_to_coordinates: motifmatch_to_coordinatesbyregionidx[motifmatch] =\ @@ -505,4 +588,5 @@ def scan_and_process_results(instance_scorer, track_set, coordinates, return (motifmatch_to_coordinates, motifmatch_to_coordinatesbyregionidx, - scan_results) + motif_scores, motif_precisions, + besthit_isrevcomp) From f55a9ce33969e02f6c98db6c77d4adde1eb3605f Mon Sep 17 00:00:00 2001 From: Avanti Shrikumar Date: Sat, 26 Dec 2020 23:35:12 -0800 Subject: [PATCH 18/30] avoiding intermediate storing as dictionary --- .../seqlet_embedding/advanced_gapped_kmer.py | 93 ++++++++++++++----- 1 file changed, 69 insertions(+), 24 deletions(-) diff --git a/modisco/seqlet_embedding/advanced_gapped_kmer.py b/modisco/seqlet_embedding/advanced_gapped_kmer.py index 6ea53ea..c6460a0 100644 --- a/modisco/seqlet_embedding/advanced_gapped_kmer.py +++ b/modisco/seqlet_embedding/advanced_gapped_kmer.py @@ -143,6 +143,22 @@ def prepare_gapped_kmer_from_seqlet(seqlet, topn, min_k, max_k=max_k, max_gap=max_gap, max_len=max_len) +def prepare_gapped_kmer_from_seqlet_and_make_sparse_mat( + seqlet, topn, min_k, max_k, max_gap, max_len, take_fwd, onehot_track_name, + toscore_track_names_and_signs, template_to_startidx, embedding_size): + + gapped_kmer_to_totalseqimp = prepare_gapped_kmer_from_seqlet( + seqlet=seqlet, topn=topn, min_k=min_k, + max_k=max_k, max_gap=max_gap, max_len=max_len, + take_fwd=take_fwd, onehot_track_name=onehot_track_name, + toscore_track_names_and_signs=toscore_track_names_and_signs) + + return get_sparse_mat_from_agkm_embeddings( + agkm_embeddings=[gapped_kmer_to_totalseqimp], + template_to_startidx=template_to_startidx, + embedding_size=embedding_size) + + class AdvancedGappedKmerEmbedderFactory(object): def __init__(self, topn=20, min_k=4, max_k=6, max_gap=15, max_len=15, @@ -195,40 +211,69 @@ def __init__(self, topn, min_k, max_k, max_gap, max_len, self.toscore_track_names_and_signs = toscore_track_names_and_signs def __call__(self, seqlets): - advanced_gappedkmer_embeddings_fwd =\ - Parallel(n_jobs=self.n_jobs, verbose=True)( - delayed(prepare_gapped_kmer_from_seqlet)( + + template_to_startidx, embedding_size =\ + get_template_to_startidx_and_embedding_size( + max_len=self.max_len, min_k=self.min_k, + max_k=self.max_k, alphabet_size=self.alphabet_size) + + sparse_agkm_embeddings_fwd = scipy.sparse.vstack( + blocks=Parallel(n_jobs=self.n_jobs, verbose=True)( + delayed(prepare_gapped_kmer_from_seqlet_and_make_sparse_mat)( seqlets[i], self.topn, self.min_k, self.max_k, self.max_gap, self.max_len, True, self.onehot_track_name, - self.toscore_track_names_and_signs) + self.toscore_track_names_and_signs, + template_to_startidx, + embedding_size) for i in range(len(seqlets))) - advanced_gappedkmer_embeddings_rev =\ - Parallel(n_jobs=self.n_jobs, verbose=True)( - delayed(prepare_gapped_kmer_from_seqlet)( + ) + + sparse_agkm_embeddings_rev = scipy.sparse.vstack( + blocks=Parallel(n_jobs=self.n_jobs, verbose=True)( + delayed(prepare_gapped_kmer_from_seqlet_and_make_sparse_mat)( seqlets[i], self.topn, self.min_k, self.max_k, self.max_gap, - self.max_len, False, + self.max_len, False, #'False' determines doing rc self.onehot_track_name, - self.toscore_track_names_and_signs) - for i in range(len(seqlets))) + self.toscore_track_names_and_signs, + template_to_startidx, + embedding_size) + for i in range(len(seqlets))) + ) - template_to_startidx, embedding_size =\ - get_template_to_startidx_and_embedding_size( - max_len=self.max_len, min_k=self.min_k, - max_k=self.max_k, alphabet_size=self.alphabet_size) + #advanced_gappedkmer_embeddings_fwd =\ + # Parallel(n_jobs=self.n_jobs, verbose=True)( + # delayed(prepare_gapped_kmer_from_seqlet)( + # seqlets[i], + # self.topn, self.min_k, + # self.max_k, self.max_gap, + # self.max_len, True, + # self.onehot_track_name, + # self.toscore_track_names_and_signs) + # for i in range(len(seqlets))) + #advanced_gappedkmer_embeddings_rev =\ + # Parallel(n_jobs=self.n_jobs, verbose=True)( + # delayed(prepare_gapped_kmer_from_seqlet)( + # seqlets[i], + # self.topn, self.min_k, + # self.max_k, self.max_gap, + # self.max_len, False, + # self.onehot_track_name, + # self.toscore_track_names_and_signs) + # for i in range(len(seqlets))) - sparse_agkm_embeddings_fwd = get_sparse_mat_from_agkm_embeddings( - agkm_embeddings=advanced_gappedkmer_embeddings_fwd, - template_to_startidx=template_to_startidx, - embedding_size=embedding_size) - sparse_agkm_embeddings_rev = get_sparse_mat_from_agkm_embeddings( - agkm_embeddings=advanced_gappedkmer_embeddings_rev, - template_to_startidx=template_to_startidx, - embedding_size=embedding_size) + #sparse_agkm_embeddings_fwd = get_sparse_mat_from_agkm_embeddings( + # agkm_embeddings=advanced_gappedkmer_embeddings_fwd, + # template_to_startidx=template_to_startidx, + # embedding_size=embedding_size) + #sparse_agkm_embeddings_rev = get_sparse_mat_from_agkm_embeddings( + # agkm_embeddings=advanced_gappedkmer_embeddings_rev, + # template_to_startidx=template_to_startidx, + # embedding_size=embedding_size) return sparse_agkm_embeddings_fwd, sparse_agkm_embeddings_rev @@ -288,8 +333,8 @@ def get_sparse_mat_from_agkm_embeddings(agkm_embeddings, row_ind = [] data = [] col_ind = [] - for (this_row_idx, - (single_agkm_data, single_agkm_cols)) in enumerate(all_agkm_data_and_cols): + for (this_row_idx, (single_agkm_data, single_agkm_cols)) in enumerate( + all_agkm_data_and_cols): data.extend(single_agkm_data) col_ind.extend(single_agkm_cols) row_ind.extend([this_row_idx for x in single_agkm_data]) From 7215cef5044357d4a6385ddf448c6f34d372d9ca Mon Sep 17 00:00:00 2001 From: Avanti Shrikumar Date: Sat, 26 Dec 2020 23:56:54 -0800 Subject: [PATCH 19/30] small changes to test runtime now --- .../seqlet_embedding/advanced_gapped_kmer.py | 59 ++++++++++--------- 1 file changed, 30 insertions(+), 29 deletions(-) diff --git a/modisco/seqlet_embedding/advanced_gapped_kmer.py b/modisco/seqlet_embedding/advanced_gapped_kmer.py index c6460a0..618cd44 100644 --- a/modisco/seqlet_embedding/advanced_gapped_kmer.py +++ b/modisco/seqlet_embedding/advanced_gapped_kmer.py @@ -143,9 +143,9 @@ def prepare_gapped_kmer_from_seqlet(seqlet, topn, min_k, max_k=max_k, max_gap=max_gap, max_len=max_len) -def prepare_gapped_kmer_from_seqlet_and_make_sparse_mat( +def prepare_gapped_kmer_from_seqlet_and_make_sparse_vec_dat( seqlet, topn, min_k, max_k, max_gap, max_len, take_fwd, onehot_track_name, - toscore_track_names_and_signs, template_to_startidx, embedding_size): + toscore_track_names_and_signs, template_to_startidx): gapped_kmer_to_totalseqimp = prepare_gapped_kmer_from_seqlet( seqlet=seqlet, topn=topn, min_k=min_k, @@ -153,10 +153,9 @@ def prepare_gapped_kmer_from_seqlet_and_make_sparse_mat( take_fwd=take_fwd, onehot_track_name=onehot_track_name, toscore_track_names_and_signs=toscore_track_names_and_signs) - return get_sparse_mat_from_agkm_embeddings( - agkm_embeddings=[gapped_kmer_to_totalseqimp], - template_to_startidx=template_to_startidx, - embedding_size=embedding_size) + return map_agkm_embedding_to_sparsevec( + agkm_embeddings=gapped_kmer_to_totalseqimp, + template_to_startidx=template_to_startidx) class AdvancedGappedKmerEmbedderFactory(object): @@ -217,34 +216,36 @@ def __call__(self, seqlets): max_len=self.max_len, min_k=self.min_k, max_k=self.max_k, alphabet_size=self.alphabet_size) - sparse_agkm_embeddings_fwd = scipy.sparse.vstack( - blocks=Parallel(n_jobs=self.n_jobs, verbose=True)( - delayed(prepare_gapped_kmer_from_seqlet_and_make_sparse_mat)( - seqlets[i], - self.topn, self.min_k, - self.max_k, self.max_gap, - self.max_len, True, - self.onehot_track_name, - self.toscore_track_names_and_signs, - template_to_startidx, - embedding_size) - for i in range(len(seqlets))) + sparse_agkm_embeddings_fwd_dataandcols = ( + Parallel(n_jobs=self.n_jobs, verbose=True)( + delayed(prepare_gapped_kmer_from_seqlet_and_make_sparse_vec_dat)( + seqlets[i], + self.topn, self.min_k, + self.max_k, self.max_gap, + self.max_len, True, + self.onehot_track_name, + self.toscore_track_names_and_signs, + template_to_startidx, + embedding_size) + for i in range(len(seqlets))) ) - sparse_agkm_embeddings_rev = scipy.sparse.vstack( + sparse_agkm_embeddings_rev_dataandcols = ( blocks=Parallel(n_jobs=self.n_jobs, verbose=True)( - delayed(prepare_gapped_kmer_from_seqlet_and_make_sparse_mat)( - seqlets[i], - self.topn, self.min_k, - self.max_k, self.max_gap, - self.max_len, False, #'False' determines doing rc - self.onehot_track_name, - self.toscore_track_names_and_signs, - template_to_startidx, - embedding_size) - for i in range(len(seqlets))) + delayed(prepare_gapped_kmer_from_seqlet_and_make_sparse_vec_dat)( + seqlets[i], + self.topn, self.min_k, + self.max_k, self.max_gap, + self.max_len, False, #'False' determines doing rc + self.onehot_track_name, + self.toscore_track_names_and_signs, + template_to_startidx, + embedding_size) + for i in range(len(seqlets))) ) + assert False + #advanced_gappedkmer_embeddings_fwd =\ # Parallel(n_jobs=self.n_jobs, verbose=True)( # delayed(prepare_gapped_kmer_from_seqlet)( From 0acaa10c633084f1bf23a82b89032e99d87dd36e Mon Sep 17 00:00:00 2001 From: Avanti Shrikumar Date: Sat, 26 Dec 2020 23:58:44 -0800 Subject: [PATCH 20/30] fix --- modisco/seqlet_embedding/advanced_gapped_kmer.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modisco/seqlet_embedding/advanced_gapped_kmer.py b/modisco/seqlet_embedding/advanced_gapped_kmer.py index 618cd44..a106e0f 100644 --- a/modisco/seqlet_embedding/advanced_gapped_kmer.py +++ b/modisco/seqlet_embedding/advanced_gapped_kmer.py @@ -231,7 +231,7 @@ def __call__(self, seqlets): ) sparse_agkm_embeddings_rev_dataandcols = ( - blocks=Parallel(n_jobs=self.n_jobs, verbose=True)( + Parallel(n_jobs=self.n_jobs, verbose=True)( delayed(prepare_gapped_kmer_from_seqlet_and_make_sparse_vec_dat)( seqlets[i], self.topn, self.min_k, From e33a0baffb6e53313a9491f41ce9e5f8c75e69a7 Mon Sep 17 00:00:00 2001 From: Avanti Shrikumar Date: Sun, 27 Dec 2020 00:02:07 -0800 Subject: [PATCH 21/30] fix --- modisco/seqlet_embedding/advanced_gapped_kmer.py | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/modisco/seqlet_embedding/advanced_gapped_kmer.py b/modisco/seqlet_embedding/advanced_gapped_kmer.py index a106e0f..180a509 100644 --- a/modisco/seqlet_embedding/advanced_gapped_kmer.py +++ b/modisco/seqlet_embedding/advanced_gapped_kmer.py @@ -225,8 +225,7 @@ def __call__(self, seqlets): self.max_len, True, self.onehot_track_name, self.toscore_track_names_and_signs, - template_to_startidx, - embedding_size) + template_to_startidx) for i in range(len(seqlets))) ) @@ -239,8 +238,7 @@ def __call__(self, seqlets): self.max_len, False, #'False' determines doing rc self.onehot_track_name, self.toscore_track_names_and_signs, - template_to_startidx, - embedding_size) + template_to_startidx) for i in range(len(seqlets))) ) From 8ae8bd74125a694e399910c6374d898786aed328 Mon Sep 17 00:00:00 2001 From: Avanti Shrikumar Date: Sun, 27 Dec 2020 00:07:23 -0800 Subject: [PATCH 22/30] fix --- modisco/seqlet_embedding/advanced_gapped_kmer.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modisco/seqlet_embedding/advanced_gapped_kmer.py b/modisco/seqlet_embedding/advanced_gapped_kmer.py index 180a509..f9a70cb 100644 --- a/modisco/seqlet_embedding/advanced_gapped_kmer.py +++ b/modisco/seqlet_embedding/advanced_gapped_kmer.py @@ -154,7 +154,7 @@ def prepare_gapped_kmer_from_seqlet_and_make_sparse_vec_dat( toscore_track_names_and_signs=toscore_track_names_and_signs) return map_agkm_embedding_to_sparsevec( - agkm_embeddings=gapped_kmer_to_totalseqimp, + gapped_kmer_to_totalseqimp=gapped_kmer_to_totalseqimp, template_to_startidx=template_to_startidx) From 8d4b7b75d207ec11e3248b47c63e528df206470b Mon Sep 17 00:00:00 2001 From: Avanti Shrikumar Date: Sun, 27 Dec 2020 00:45:43 -0800 Subject: [PATCH 23/30] fix --- modisco/seqlet_embedding/advanced_gapped_kmer.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/modisco/seqlet_embedding/advanced_gapped_kmer.py b/modisco/seqlet_embedding/advanced_gapped_kmer.py index f9a70cb..201a1b9 100644 --- a/modisco/seqlet_embedding/advanced_gapped_kmer.py +++ b/modisco/seqlet_embedding/advanced_gapped_kmer.py @@ -153,9 +153,10 @@ def prepare_gapped_kmer_from_seqlet_and_make_sparse_vec_dat( take_fwd=take_fwd, onehot_track_name=onehot_track_name, toscore_track_names_and_signs=toscore_track_names_and_signs) - return map_agkm_embedding_to_sparsevec( - gapped_kmer_to_totalseqimp=gapped_kmer_to_totalseqimp, - template_to_startidx=template_to_startidx) + return list(gapped_kmer_to_totalseqimp.items()) + #return map_agkm_embedding_to_sparsevec( + # gapped_kmer_to_totalseqimp=gapped_kmer_to_totalseqimp, + # template_to_startidx=template_to_startidx) class AdvancedGappedKmerEmbedderFactory(object): From fc94c49b655860add857d759e7f76e5141b4d72a Mon Sep 17 00:00:00 2001 From: AvantiShri Date: Mon, 28 Dec 2020 02:16:38 -0800 Subject: [PATCH 24/30] cap on size of agkm embedding and sorting by avg imp per base --- .../seqlet_embedding/advanced_gapped_kmer.py | 151 ++++++++++-------- 1 file changed, 85 insertions(+), 66 deletions(-) diff --git a/modisco/seqlet_embedding/advanced_gapped_kmer.py b/modisco/seqlet_embedding/advanced_gapped_kmer.py index 201a1b9..6eec6dd 100644 --- a/modisco/seqlet_embedding/advanced_gapped_kmer.py +++ b/modisco/seqlet_embedding/advanced_gapped_kmer.py @@ -95,7 +95,8 @@ def unravel_fast_recursively_get_gappedkmersandimp(posbaseimptuples, **kwargs): def prepare_gapped_kmer_from_contribs(contrib_scores, topn, min_k, - max_k, max_gap, max_len): + max_k, max_gap, max_len, + max_entries): #get the top n positiosn per_pos_imp = np.sum(contrib_scores, axis=-1) per_pos_bases = np.argmax(contrib_scores, axis=-1) @@ -122,12 +123,15 @@ def prepare_gapped_kmer_from_contribs(contrib_scores, topn, min_k, if (len(gapped_kmer_rep) >= min_k): gapped_kmer_to_totalseqimp[gapped_kmer_rep] = ( gapped_kmer_to_totalseqimp.get(gapped_kmer_rep, 0) - + gapped_kmer_imp) - return gapped_kmer_to_totalseqimp + + gapped_kmer_imp/len(gapped_kmer_rep) + ) + #only retain the top max_entries entries + return sorted(gapped_kmer_to_totalseqimp.items(), + key=lambda x: -abs(x[1]))[:max_entries] def prepare_gapped_kmer_from_seqlet(seqlet, topn, min_k, - max_k, max_gap, max_len, + max_k, max_gap, max_len, max_entries, take_fwd, onehot_track_name, toscore_track_names_and_signs): @@ -140,20 +144,24 @@ def prepare_gapped_kmer_from_seqlet(seqlet, topn, min_k, for track_name, sign in toscore_track_names_and_signs ], axis=0) return prepare_gapped_kmer_from_contribs( contrib_scores=contrib_scores, topn=topn, min_k=min_k, - max_k=max_k, max_gap=max_gap, max_len=max_len) + max_k=max_k, max_gap=max_gap, max_len=max_len, + max_entries=max_entries) def prepare_gapped_kmer_from_seqlet_and_make_sparse_vec_dat( - seqlet, topn, min_k, max_k, max_gap, max_len, take_fwd, onehot_track_name, + seqlet, topn, min_k, max_k, max_gap, max_len, max_entries, + take_fwd, onehot_track_name, toscore_track_names_and_signs, template_to_startidx): gapped_kmer_to_totalseqimp = prepare_gapped_kmer_from_seqlet( seqlet=seqlet, topn=topn, min_k=min_k, max_k=max_k, max_gap=max_gap, max_len=max_len, + max_entries=max_entries, take_fwd=take_fwd, onehot_track_name=onehot_track_name, toscore_track_names_and_signs=toscore_track_names_and_signs) - return list(gapped_kmer_to_totalseqimp.items()) + return gapped_kmer_to_totalseqimp + #return list(gapped_kmer_to_totalseqimp.items()) #return map_agkm_embedding_to_sparsevec( # gapped_kmer_to_totalseqimp=gapped_kmer_to_totalseqimp, # template_to_startidx=template_to_startidx) @@ -162,13 +170,14 @@ def prepare_gapped_kmer_from_seqlet_and_make_sparse_vec_dat( class AdvancedGappedKmerEmbedderFactory(object): def __init__(self, topn=20, min_k=4, max_k=6, max_gap=15, max_len=15, - alphabet_size=4, n_jobs=10, - num_filters_to_retain=None): + max_entries=500, + alphabet_size=4, n_jobs=10): self.topn = topn self.min_k = min_k self.max_k = max_k self.max_gap = max_gap self.max_len = max_len + self.max_entries = max_entries self.alphabet_size = alphabet_size self.n_jobs = n_jobs @@ -179,6 +188,7 @@ def get_jsonable_config(self): ('max_k', self.max_k), ('max_gap', self.max_gap), ('max_len', self.max_len) + ('max_entries', self.max_entries) ('alphabet_size', self.alphabet_size) ('n_jobs', self.n_jobs) ]) @@ -187,6 +197,7 @@ def __call__(self, onehot_track_name, toscore_track_names_and_signs): return AdvancedGappedKmerEmbedder( topn=self.topn, min_k=self.min_k, max_k=self.max_k, max_gap=self.max_gap, max_len=self.max_len, + max_entries=self.max_entries, alphabet_size=self.alphabet_size, n_jobs=self.n_jobs, onehot_track_name=onehot_track_name, @@ -195,7 +206,7 @@ def __call__(self, onehot_track_name, toscore_track_names_and_signs): class AdvancedGappedKmerEmbedder(AbstractSeqletsToOnedEmbedder): - def __init__(self, topn, min_k, max_k, max_gap, max_len, + def __init__(self, topn, min_k, max_k, max_gap, max_len, max_entries, alphabet_size, n_jobs, onehot_track_name, @@ -205,6 +216,7 @@ def __init__(self, topn, min_k, max_k, max_gap, max_len, self.max_k = max_k self.max_gap = max_gap self.max_len = max_len + self.max_entries = max_entries self.alphabet_size = alphabet_size self.n_jobs = n_jobs self.onehot_track_name = onehot_track_name @@ -217,63 +229,70 @@ def __call__(self, seqlets): max_len=self.max_len, min_k=self.min_k, max_k=self.max_k, alphabet_size=self.alphabet_size) - sparse_agkm_embeddings_fwd_dataandcols = ( - Parallel(n_jobs=self.n_jobs, verbose=True)( - delayed(prepare_gapped_kmer_from_seqlet_and_make_sparse_vec_dat)( - seqlets[i], - self.topn, self.min_k, - self.max_k, self.max_gap, - self.max_len, True, - self.onehot_track_name, - self.toscore_track_names_and_signs, - template_to_startidx) - for i in range(len(seqlets))) - ) - - sparse_agkm_embeddings_rev_dataandcols = ( - Parallel(n_jobs=self.n_jobs, verbose=True)( - delayed(prepare_gapped_kmer_from_seqlet_and_make_sparse_vec_dat)( - seqlets[i], - self.topn, self.min_k, - self.max_k, self.max_gap, - self.max_len, False, #'False' determines doing rc - self.onehot_track_name, - self.toscore_track_names_and_signs, - template_to_startidx) - for i in range(len(seqlets))) - ) - - assert False - - #advanced_gappedkmer_embeddings_fwd =\ + #sparse_agkm_embeddings_fwd_dataandcols = ( # Parallel(n_jobs=self.n_jobs, verbose=True)( - # delayed(prepare_gapped_kmer_from_seqlet)( - # seqlets[i], - # self.topn, self.min_k, - # self.max_k, self.max_gap, - # self.max_len, True, - # self.onehot_track_name, - # self.toscore_track_names_and_signs) - # for i in range(len(seqlets))) - #advanced_gappedkmer_embeddings_rev =\ + # delayed(prepare_gapped_kmer_from_seqlet_and_make_sparse_vec_dat)( + # seqlets[i], + # self.topn, self.min_k, + # self.max_k, self.max_gap, + # self.max_len, True, + # self.onehot_track_name, + # self.toscore_track_names_and_signs, + # template_to_startidx) + # for i in range(len(seqlets))) + #) + + #sparse_agkm_embeddings_rev_dataandcols = ( # Parallel(n_jobs=self.n_jobs, verbose=True)( - # delayed(prepare_gapped_kmer_from_seqlet)( - # seqlets[i], - # self.topn, self.min_k, - # self.max_k, self.max_gap, - # self.max_len, False, - # self.onehot_track_name, - # self.toscore_track_names_and_signs) - # for i in range(len(seqlets))) - - #sparse_agkm_embeddings_fwd = get_sparse_mat_from_agkm_embeddings( - # agkm_embeddings=advanced_gappedkmer_embeddings_fwd, - # template_to_startidx=template_to_startidx, - # embedding_size=embedding_size) - #sparse_agkm_embeddings_rev = get_sparse_mat_from_agkm_embeddings( - # agkm_embeddings=advanced_gappedkmer_embeddings_rev, - # template_to_startidx=template_to_startidx, - # embedding_size=embedding_size) + # delayed(prepare_gapped_kmer_from_seqlet_and_make_sparse_vec_dat)( + # seqlets[i], + # self.topn, self.min_k, + # self.max_k, self.max_gap, + # self.max_len, False, #'False' determines doing rc + # self.onehot_track_name, + # self.toscore_track_names_and_signs, + # template_to_startidx) + # for i in range(len(seqlets))) + #) + + advanced_gappedkmer_embeddings_fwd =\ + Parallel(n_jobs=self.n_jobs, verbose=True)( + delayed(prepare_gapped_kmer_from_seqlet)( + seqlets[i], + self.topn, self.min_k, + self.max_k, self.max_gap, + self.max_len, + self.max_entries, + True, + self.onehot_track_name, + self.toscore_track_names_and_signs) + for i in range(len(seqlets))) + + #from matplotlib import pyplot as plt + #plt.hist([len(x) for x in advanced_gappedkmer_embeddings_fwd], bins=20) + #plt.show() + #assert False + advanced_gappedkmer_embeddings_rev =\ + Parallel(n_jobs=self.n_jobs, verbose=True)( + delayed(prepare_gapped_kmer_from_seqlet)( + seqlets[i], + self.topn, self.min_k, + self.max_k, self.max_gap, + self.max_len, + self.max_entries, + False, + self.onehot_track_name, + self.toscore_track_names_and_signs) + for i in range(len(seqlets))) + + sparse_agkm_embeddings_fwd = get_sparse_mat_from_agkm_embeddings( + agkm_embeddings=advanced_gappedkmer_embeddings_fwd, + template_to_startidx=template_to_startidx, + embedding_size=embedding_size) + sparse_agkm_embeddings_rev = get_sparse_mat_from_agkm_embeddings( + agkm_embeddings=advanced_gappedkmer_embeddings_rev, + template_to_startidx=template_to_startidx, + embedding_size=embedding_size) return sparse_agkm_embeddings_fwd, sparse_agkm_embeddings_rev @@ -310,7 +329,7 @@ def map_agkm_embedding_to_sparsevec(gapped_kmer_to_totalseqimp, template_to_startidx): data = [] cols = [] - for gkmer, totalimp in gapped_kmer_to_totalseqimp.items(): + for gkmer, totalimp in gapped_kmer_to_totalseqimp: template,offset = get_template_and_offset_from_gkmer(gkmer) gkmeridx = template_to_startidx[template] + offset data.append(totalimp) From 367327cef0f2e207be3a1555959de387ec17ba52 Mon Sep 17 00:00:00 2001 From: Avanti Shrikumar Date: Mon, 28 Dec 2020 03:35:50 -0800 Subject: [PATCH 25/30] updated hit scoring noebook --- .../TF_MoDISco_TAL_GATA_hitscoring.ipynb | 1434 ++++++++--------- 1 file changed, 712 insertions(+), 722 deletions(-) diff --git a/examples/simulated_TAL_GATA_deeplearning/TF_MoDISco_TAL_GATA_hitscoring.ipynb b/examples/simulated_TAL_GATA_deeplearning/TF_MoDISco_TAL_GATA_hitscoring.ipynb index 57767eb..45dc15b 100644 --- a/examples/simulated_TAL_GATA_deeplearning/TF_MoDISco_TAL_GATA_hitscoring.ipynb +++ b/examples/simulated_TAL_GATA_deeplearning/TF_MoDISco_TAL_GATA_hitscoring.ipynb @@ -68,7 +68,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": { "colab": {}, "colab_type": "code", @@ -90,7 +90,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -122,7 +122,9 @@ "output_type": "stream", "text": [ "/Users/avantishrikumar/anaconda3/lib/python3.8/site-packages/sklearn/utils/deprecation.py:143: FutureWarning: The sklearn.neighbors.kde module is deprecated in version 0.22 and will be removed in version 0.24. The corresponding classes / functions should instead be imported from sklearn.neighbors. Anything that cannot be imported from sklearn.neighbors is now part of the private API.\n", - " warnings.warn(message, FutureWarning)\n" + " warnings.warn(message, FutureWarning)\n", + "/Users/avantishrikumar/Research/tfmodisco/modisco/seqlet_embedding/advanced_gapped_kmer.py:190: SyntaxWarning: 'tuple' object is not callable; perhaps you missed a comma?\n", + " ('max_len', self.max_len)\n" ] } ], @@ -176,7 +178,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 3, "metadata": { "colab": {}, "colab_type": "code", @@ -246,7 +248,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 4, "metadata": { "colab": {}, "colab_type": "code", @@ -267,10 +269,14 @@ " #Note that the sequences can be of variable lengths;\n", " #in this example they all have the same length (200bp) but that is\n", " #not necessary.\n", - " task_to_scores[task] = [np.array(x) for x in f['contrib_scores'][task][:n]]\n", - " task_to_hyp_scores[task] = [np.array(x) for x in f['hyp_contrib_scores'][task][:n]]\n", + " task_to_scores[task] = [np.array(x)[::rc,::rc] for x in\n", + " f['contrib_scores'][task][:n] for rc in [1,-1]]\n", + " task_to_hyp_scores[task] = [np.array(x)[::rc, ::rc] for x in\n", + " f['hyp_contrib_scores'][task][:n] for rc in [1,-1]]\n", "\n", - "onehot_data = [one_hot_encode_along_channel_axis(seq) for seq in fasta_sequences][:n]" + "onehot_data = [one_hot_encode_along_channel_axis(seq)[::rc, ::rc]\n", + " for seq in fasta_sequences[:n]\n", + " for rc in [1,-1]]" ] }, { @@ -379,10 +385,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "MEMORY 0.367886336\n", + "MEMORY 0.651464704\n", "On task task0\n", "Fitting - on window size 5\n", - "peak(mu)= 0.00486588878557086\n", + "peak(mu)= 0.004865888827480376\n", "Computing window sums\n", "Done computing window sums\n", "For increasing = True , the minimum IR precision was 0.2954850349262155 occurring at 5.7220458984375e-06 implying a frac_neg of 0.41941626448668695\n", @@ -393,7 +399,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -419,7 +425,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -445,7 +451,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -460,18 +466,18 @@ "output_type": "stream", "text": [ "Fitting - on window size 17\n", - "peak(mu)= -0.03528579294681549\n", + "peak(mu)= -0.03414142362773419\n", "Computing window sums\n", "Done computing window sums\n", - "For increasing = True , the minimum IR precision was 0.4006572406407763 occurring at 7.033348083496094e-06 implying a frac_neg of 0.6684943371454617\n", + "For increasing = True , the minimum IR precision was 0.40074974232407007 occurring at 6.67572021484375e-06 implying a frac_neg of 0.6687518898670086\n", "To be conservative, adjusted frac neg is 0.95\n", - "For increasing = False , the minimum IR precision was 0.41327328308403144 occurring at -4.0531158447265625e-06 implying a frac_neg of 0.7043709978920574\n", + "For increasing = False , the minimum IR precision was 0.2519079426947738 occurring at -3.814697265625e-06 implying a frac_neg of 0.3367338821938512\n", "To be conservative, adjusted frac neg is 0.95\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -483,7 +489,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -497,66 +503,144 @@ "name": "stdout", "output_type": "stream", "text": [ - "Thresholds from null dist were -0.85 and 0.85 with frac passing 0.17035\n", - "Got 318 coords\n", - "After resolving overlaps, got 318 seqlets\n", + "Thresholds from null dist were -0.85 and 0.85 with frac passing 0.17135\n", + "Got 639 coords\n", + "After resolving overlaps, got 639 seqlets\n", "Across all tasks, the weakest transformed threshold used was: 0.8499\n", - "MEMORY 0.378642432\n", - "318 identified in total\n", + "MEMORY 0.652726272\n", + "639 identified in total\n", "1 activity patterns with support >= 100 out of 2 possible patterns\n", - "Metacluster sizes: [298]\n", + "Metacluster sizes: [597]\n", "Idx to activities: {0: '1'}\n", - "MEMORY 0.378646528\n", + "MEMORY 0.652726272\n", "On metacluster 0\n", - "Metacluster size 298\n", + "Metacluster size 597\n", "Relevant tasks: ('task0',)\n", "Relevant signs: (1,)\n", "TfModiscoSeqletsToPatternsFactory: seed=1234\n", - "(Round 1) num seqlets: 298\n", + "(Round 1) num seqlets: 597\n", "(Round 1) Computing coarse affmat\n", - "MEMORY 0.379379712\n", - "Beginning embedding computation\n", - "Computing embeddings\n", - "MAKING A SESSION\n", - "Finished embedding computation in 0.15 s\n", + "MEMORY 0.652726272\n", + "Beginning embedding computation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Parallel(n_jobs=10)]: Using backend LokyBackend with 10 concurrent workers.\n", + "[Parallel(n_jobs=10)]: Done 30 tasks | elapsed: 4.5s\n", + "[Parallel(n_jobs=10)]: Done 181 tasks | elapsed: 6.5s\n", + "[Parallel(n_jobs=10)]: Done 578 out of 597 | elapsed: 13.1s remaining: 0.4s\n", + "[Parallel(n_jobs=10)]: Done 597 out of 597 | elapsed: 13.5s finished\n", + "[Parallel(n_jobs=10)]: Using backend LokyBackend with 10 concurrent workers.\n", + "[Parallel(n_jobs=10)]: Done 40 tasks | elapsed: 0.7s\n", + "[Parallel(n_jobs=10)]: Done 340 tasks | elapsed: 4.9s\n", + "[Parallel(n_jobs=10)]: Done 578 out of 597 | elapsed: 9.2s remaining: 0.3s\n", + "[Parallel(n_jobs=10)]: Done 597 out of 597 | elapsed: 9.4s finished\n", + "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n", + "[Parallel(n_jobs=1)]: Done 597 out of 597 | elapsed: 1.4s finished\n", + "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Constructing csr matrix...\n", + "csr matrix made in 0.14378023147583008 s\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Parallel(n_jobs=1)]: Done 597 out of 597 | elapsed: 1.4s finished\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Constructing csr matrix...\n", + "csr matrix made in 0.1436150074005127 s\n", + "Finished embedding computation in 26.21 s\n", "Starting affinity matrix computations\n", - "Normalization computed in 0.0 s\n", - "Cosine similarity mat computed in 0.01 s\n", - "Normalization computed in 0.0 s\n", - "Cosine similarity mat computed in 0.01 s\n", - "Finished affinity matrix computations in 0.02 s\n", + "Batching in slices of size 500\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 2/2 [00:01<00:00, 1.11it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batching in slices of size 500\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "100%|██████████| 2/2 [00:01<00:00, 1.15it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Finished affinity matrix computations in 3.55 s\n", "(Round 1) Compute nearest neighbors from coarse affmat\n", - "MEMORY 0.42725376\n", - "Computed nearest neighbors in 0.02 s\n", - "MEMORY 0.42819584\n", + "MEMORY 0.691224576\n", + "Computed nearest neighbors in 0.03 s\n", + "MEMORY 0.6969344\n", "(Round 1) Computing affinity matrix on nearest neighbors\n", - "MEMORY 0.42819584\n", + "MEMORY 0.6969344\n", "Launching nearest neighbors affmat calculation job\n", - "MEMORY 0.429064192\n", + "MEMORY 0.696938496\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Parallel runs completed\n", - "MEMORY 0.45375488\n", - "Job completed in: 1.31 s\n", - "MEMORY 0.453758976\n", + "MEMORY 0.697053184\n", + "Job completed in: 1.17 s\n", + "MEMORY 0.697053184\n", "Launching nearest neighbors affmat calculation job\n", - "MEMORY 0.453758976\n", + "MEMORY 0.697053184\n", "Parallel runs completed\n", - "MEMORY 0.457424896\n", - "Job completed in: 1.27 s\n", - "MEMORY 0.457424896\n", - "(Round 1) Computed affinity matrix on nearest neighbors in 2.66 s\n", - "MEMORY 0.457433088\n", - "Filtered down to 286 of 298\n", - "(Round 1) Retained 286 rows out of 298 after filtering\n", - "MEMORY 0.457617408\n", + "MEMORY 0.697061376\n", + "Job completed in: 1.17 s\n", + "MEMORY 0.697061376\n", + "(Round 1) Computed affinity matrix on nearest neighbors in 2.45 s\n", + "MEMORY 0.697069568\n", + "Filtered down to 422 of 597\n", + "(Round 1) Retained 422 rows out of 597 after filtering\n", + "MEMORY 0.697069568\n", "(Round 1) Computing density adapted affmat\n", - "MEMORY 0.457633792\n", + "MEMORY 0.697069568\n", "[t-SNE] Computing 31 nearest neighbors...\n", - "[t-SNE] Indexed 286 samples in 0.000s...\n", - "[t-SNE] Computed neighbors for 286 samples in 0.002s...\n", - "[t-SNE] Computed conditional probabilities for sample 286 / 286\n", - "[t-SNE] Mean sigma: 0.232937\n", + "[t-SNE] Indexed 422 samples in 0.000s...\n", + "[t-SNE] Computed neighbors for 422 samples in 0.002s...\n", + "[t-SNE] Computed conditional probabilities for sample 422 / 422\n", + "[t-SNE] Mean sigma: 0.377335\n", "(Round 1) Computing clustering\n", - "MEMORY 0.457699328\n", + "MEMORY 0.69709824\n", "Beginning preprocessing + Leiden\n" ] }, @@ -572,137 +656,191 @@ "name": "stdout", "output_type": "stream", "text": [ - "Quality: 0.6567098406851998\n" + "Quality: 0.688869450647686\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "\r", - " 8%|▊ | 4/50 [00:00<00:01, 29.02it/s]" + "100%|██████████| 50/50 [00:03<00:00, 14.47it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Quality: 0.6569711466883117\n", - "Quality: 0.656986269551227\n" + "Got 11 clusters after round 1\n", + "Counts:\n", + "{7: 7, 4: 53, 3: 65, 1: 72, 5: 37, 0: 80, 2: 66, 9: 3, 8: 5, 6: 32, 10: 2}\n", + "MEMORY 0.697397248\n", + "(Round 1) Aggregating seqlets in each cluster\n", + "MEMORY 0.697397248\n", + "Aggregating for cluster 0 with 80 seqlets\n", + "MEMORY 0.697397248\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 50/50 [00:01<00:00, 29.37it/s]" + "\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Got 5 clusters after round 1\n", - "Counts:\n", - "{4: 17, 0: 79, 2: 67, 3: 47, 1: 76}\n", - "MEMORY 0.45828096\n", - "(Round 1) Aggregating seqlets in each cluster\n", - "MEMORY 0.45828096\n", - "Aggregating for cluster 0 with 79 seqlets\n", - "MEMORY 0.45828096\n" + "Trimming eliminated 0 seqlets out of 80\n", + "Skipped 5 seqlets\n", + "Skipped 1 seqlets\n", + "Aggregating for cluster 1 with 72 seqlets\n", + "MEMORY 0.697397248\n", + "Trimming eliminated 0 seqlets out of 72\n", + "Skipped 10 seqlets\n", + "Removed 3 duplicate seqlets\n", + "Aggregating for cluster 2 with 66 seqlets\n", + "MEMORY 0.697397248\n", + "Trimming eliminated 0 seqlets out of 66\n", + "Skipped 3 seqlets\n", + "Aggregating for cluster 3 with 65 seqlets\n", + "MEMORY 0.697397248\n", + "Trimming eliminated 0 seqlets out of 65\n", + "Skipped 11 seqlets\n", + "Aggregating for cluster 4 with 53 seqlets\n", + "MEMORY 0.697397248\n", + "Trimming eliminated 0 seqlets out of 53\n", + "Skipped 8 seqlets\n", + "Removed 4 duplicate seqlets\n", + "Aggregating for cluster 5 with 37 seqlets\n", + "MEMORY 0.697397248\n", + "Trimming eliminated 0 seqlets out of 37\n", + "Skipped 1 seqlets\n", + "Aggregating for cluster 6 with 32 seqlets\n", + "MEMORY 0.697397248\n", + "Trimming eliminated 0 seqlets out of 32\n", + "Skipped 5 seqlets\n", + "Aggregating for cluster 7 with 7 seqlets\n", + "MEMORY 0.697397248\n", + "Trimming eliminated 0 seqlets out of 7\n", + "Aggregating for cluster 8 with 5 seqlets\n", + "MEMORY 0.697397248\n", + "Trimming eliminated 0 seqlets out of 5\n", + "Aggregating for cluster 9 with 3 seqlets\n", + "MEMORY 0.697397248\n", + "Trimming eliminated 0 seqlets out of 3\n", + "Aggregating for cluster 10 with 2 seqlets\n", + "MEMORY 0.697397248\n", + "Trimming eliminated 0 seqlets out of 2\n", + "(Round 2) num seqlets: 312\n", + "(Round 2) Computing coarse affmat\n", + "MEMORY 0.697397248\n", + "Beginning embedding computation\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "\n" + "[Parallel(n_jobs=10)]: Using backend LokyBackend with 10 concurrent workers.\n", + "[Parallel(n_jobs=10)]: Done 40 tasks | elapsed: 1.1s\n", + "[Parallel(n_jobs=10)]: Done 293 out of 312 | elapsed: 7.0s remaining: 0.5s\n", + "[Parallel(n_jobs=10)]: Done 312 out of 312 | elapsed: 7.3s finished\n", + "[Parallel(n_jobs=10)]: Using backend LokyBackend with 10 concurrent workers.\n", + "[Parallel(n_jobs=10)]: Done 40 tasks | elapsed: 1.2s\n", + "[Parallel(n_jobs=10)]: Done 293 out of 312 | elapsed: 6.9s remaining: 0.4s\n", + "[Parallel(n_jobs=10)]: Done 312 out of 312 | elapsed: 7.3s finished\n", + "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n", + "[Parallel(n_jobs=1)]: Done 312 out of 312 | elapsed: 0.8s finished\n", + "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Trimming eliminated 0 seqlets out of 79\n", - "Skipped 16 seqlets\n", - "Aggregating for cluster 1 with 76 seqlets\n", - "MEMORY 0.45828096\n", - "Trimming eliminated 0 seqlets out of 76\n", - "Skipped 6 seqlets\n", - "Aggregating for cluster 2 with 67 seqlets\n", - "MEMORY 0.45828096\n", - "Trimming eliminated 0 seqlets out of 67\n", - "Skipped 8 seqlets\n", - "Removed 1 duplicate seqlets\n", - "Aggregating for cluster 3 with 47 seqlets\n", - "MEMORY 0.45828096\n", - "Trimming eliminated 0 seqlets out of 47\n", - "Skipped 3 seqlets\n", - "Removed 1 duplicate seqlets\n", - "Aggregating for cluster 4 with 17 seqlets\n", - "MEMORY 0.45828096\n", - "Trimming eliminated 0 seqlets out of 17\n", - "Skipped 1 seqlets\n", - "(Round 2) num seqlets: 223\n", - "(Round 2) Computing coarse affmat\n", - "MEMORY 0.45828096\n", - "Beginning embedding computation\n", - "Computing embeddings\n", - "Finished embedding computation in 0.08 s\n", + "Constructing csr matrix...\n", + "csr matrix made in 0.06708884239196777 s\n", + "Constructing csr matrix...\n", + "csr matrix made in 0.06825685501098633 s\n", + "Finished embedding computation in 16.3 s\n", "Starting affinity matrix computations\n", - "Normalization computed in 0.0 s\n", - "Cosine similarity mat computed in 0.01 s\n", - "Normalization computed in 0.0 s\n", - "Cosine similarity mat computed in 0.0 s\n", - "Finished affinity matrix computations in 0.01 s\n", + "Batching in slices of size 500\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Parallel(n_jobs=1)]: Done 312 out of 312 | elapsed: 0.8s finished\n", + "100%|██████████| 1/1 [00:00<00:00, 1.11it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batching in slices of size 500\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "100%|██████████| 1/1 [00:00<00:00, 1.16it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Finished affinity matrix computations in 1.78 s\n", "(Round 2) Compute nearest neighbors from coarse affmat\n", - "MEMORY 0.463536128\n", - "Computed nearest neighbors in 0.02 s\n", - "MEMORY 0.463794176\n", + "MEMORY 0.697454592\n", + "Computed nearest neighbors in 0.01 s\n", + "MEMORY 0.697454592\n", "(Round 2) Computing affinity matrix on nearest neighbors\n", - "MEMORY 0.463794176\n", - "Launching nearest neighbors affmat calculation job\n", - "MEMORY 0.463802368\n", - "Parallel runs completed\n", - "MEMORY 0.464019456\n", - "Job completed in: 0.75 s\n", - "MEMORY 0.464019456\n", + "MEMORY 0.697454592\n", "Launching nearest neighbors affmat calculation job\n", - "MEMORY 0.464023552\n", - "Parallel runs completed\n", - "MEMORY 0.464023552\n", - "Job completed in: 0.68 s\n", - "MEMORY 0.464023552\n", - "(Round 2) Computed affinity matrix on nearest neighbors in 1.5 s\n", - "MEMORY 0.464023552\n", - "Not applying filtering for rounds above first round\n", - "MEMORY 0.464023552\n", - "(Round 2) Computing density adapted affmat\n", - "MEMORY 0.464023552\n", - "[t-SNE] Computing 31 nearest neighbors...\n", - "[t-SNE] Indexed 223 samples in 0.000s...\n", - "[t-SNE] Computed neighbors for 223 samples in 0.002s...\n", - "[t-SNE] Computed conditional probabilities for sample 223 / 223\n", - "[t-SNE] Mean sigma: 0.279578\n", - "(Round 2) Computing clustering\n", - "MEMORY 0.464023552\n", - "Beginning preprocessing + Leiden\n" + "MEMORY 0.697909248\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "\r", - " 0%| | 0/50 [00:00" ] @@ -1043,13 +1211,13 @@ "metacluster_0\n", "activity pattern: [1]\n", "metacluster_0 pattern_0\n", - "total seqlets: 83\n", + "total seqlets: 142\n", "Task 0 hypothetical scores:\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1068,7 +1236,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1087,7 +1255,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABHcAAACMCAYAAAD2tUXSAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd5ycZb3//9c1dftukk02gVRCSAFCkY4K0psFREWOisfjQQ4/lGrhoMf41fMVREGkKIiKighfQSxIF5BeEkhIsoGQStomuynbp1+/P67ZMjszW+/ZZOD9zGMembln5jPXzM41c9+fua7PZay1iIiIiIiIiIhIcfLt7gaIiIiIiIiIiMjwKbkjIiIiIiIiIlLElNwRERERERERESliSu6IiIiIiIiIiBQxJXdERERERERERIqYkjsiIiIiIiIiIkUsUIigtbW1dvr06YUILSIiIiIiIiLyvrRo0aIma+34vtsLktyZPn06CxcuLERoEREREREREZH3JWPM+lzbNS1LRERERERERKSIKbkjIiIiIiIiIlLElNwRERERERERESliSu6IiIiIiIiIiBQxJXdERERERERERIqYkjsiIiIiIiIiIkVMyR0RERERERERkSKm5I6IiIiIiIiISBFTckdEREREREREpIgNmNwxxkwxxjxtjFlhjFlujLl0NBomIiIiIiIiIiIDCwziNgngSmvt68aYSmCRMeYJa219gdsmIiIiIiIiIiIDGHDkjrV2i7X29fT5VmAFsHehGyYiIiIiIiIiIgMbUs0dY8x04BDglUI0RkREREREREREhmbQyR1jTAXwAHCZtbYlx/UXGmMWGmMWNjY2etlGEREReR976y341Kdg+nQYPx723ReuuAKKYncjGYN3bod/HAgP1MGDe8PjH4TNj4K1u7t1IiIi8h5h7CB2LIwxQeAh4DFr7Q0D3f6www6zCxcu9KB5IiIi8n61Zg1cdRU88gjE45BM9lxXUgI+H1x0EfzP/0B19e5rZ042Bat/BUuugWQHJNozrw+UQ/k+cNhNUPeR3dNGERERKTrGmEXW2sOytg+U3DHGGOC3wA5r7WWDeTAld0RERGQk3n4bjjoKWlszkzp9hcMwcya89BJUVY1e+/plLbx2Eaz9AyTb+7+tvwyOvBOmf3Z02iYiIiJFLV9yZzDTso4FPg+cYIxZnD6d4XkLRURERHAjdo49Fpqb+0/sAESjsHo1HH88tA+QRxkV1sLrV8DauwdO7IAb1fPKf8CGvxS+bSIiIvKeNZjVsp631hpr7Xxr7cHp08Oj0TgREREZmQ3NG/jBv36wu5sxaJs2wTHHwM6dgy9JE43CihVw8snu/G61dAGsusMlbQYr2Qkvng9bHi9Ys0REROS9bUirZYmIiEhxeWjlQ3znme+QTA0wBGYP8YUvQFMTpFJDu18kAkuWwHXXFaZdg9L0Cqy4fmiJnS7JTnj+M963SURERN4XlNwRERF5D1u1cxUA63at270NGYR//ANeeWXgqVj5dHTAtdd626ZBSyXh5S+6JM2wY0Q8a46IiIi8vwR2dwNEREQEli+HW291y37H4zBxohvFcuaZblWoYcfdthyA+sZ6Zo6d6VFrvReJwJe/PPK6OfG4N+0ZstW/hPYNI4uRVHJHREREhkfJHRERkd3omWfg29+G11+HWCxz1Mqjj7oVoP77v+ErX4HAML613256G4Dljcv56OyPetPoArjuOmhpGXmcRGLkMYYsuh3e+MbgCiiLiIiIFICmZYmIiOwmN9/sRua88AJ0dmZPR2prg82b4RvfcLeLDHFgh7WWTa2bAHht82setdp7zc0uudMxjFI1OU2cCMYU5jRxYvbjLb8WUjGPGi8iIiIydEruiIiIjDJr3Widb31rcAmNjg549ln40IdcImSwNrZsJJ5y85SWbl06zNYW3q9+5fImntm61cNgA8RORmDV7ZDa3ct0iYiIyPuZkjsiIiKj7JvfhBtvHNpIlUgEli6Fo44a/H3qG+sJGDeXa33zelJ2iEtQjYJUCn7848G9FnPnwtFHw9SphW/XoK2/DxjEmu2hsTDuCBhzCPhLCt4sEREReX9RckdERGQUPfcc3HLL8KYgRaOwfv3gb7+8cTnWWgyGgC/AhuYRFvwtgGefddPP+nPWWa7Q9KuvwsMPw4oV8OSTcMgho9PGfr11AyT6eQIldXDYLfCJDfCRx+DEp+HszTDnciV5RERExDNK7oiIiIyS9nb49KddfZ3hGsp9F21eRBJXyCfoC1LfWD/8By6Qn/+8/+TOLbfAH/8Is2dDRQXU1EBZGRx/PDz/PJx33qg1NVvrKmhdmf/6qtlw1gqY+R8QKINQDYSqITQG5n8fTn0FAhWj114RERF5z1JyR0REZJRceins2jV6j7d46+Lu852Jzj0uudPRAX/7m6tBlMt118EFF7ikTl9+v0vy3HknfOIThW1nXmvugnxT3Sr2gZNfgEB17hE6gXKomAUn/hP8pQVtpoiIiLz3KbkjIiIyChYudCNQhrri1XBZa1m7c2335VgytsetmPX88xAK5b7u3HPh4otzJ3Z6Ky+HP/wBZs3yvn0D2vBA7lWyTABOeBKCNeDrZ1crUArVB8IRtxeujSIiIvK+oOSOiIjIKLj66pFNxxqqhrYGbJ9Cv29ufXP0GjAIjzzipqr1VV4Ov/jFwImdLqGQG8EzqmI7oW1N7utmXwbh8eDzDxwnUApTPgnjDve2fSIiIvK+ouSOiIhIgS1fDi+8kH/6UZe5c+ErX4FLLoFTThnZ8uD1jfWE/eGMbWt3rcUO1IhR9Pe/QzKZvf1734PSIcxUCgTg0EPh4x/3rm0D2vpM7ulWJRNh/gIIDqGWjr8EjroLjHbLREREZHgCu7sBIiIi73XXXw+xHLN3uhxyCPzsZy5BYa2rJxOLQWsrfPvbcNddQ3/MFU0riCajWdu3tG1hr8q9hh7QY01NsCHH4l11dW461lCSO+BG+dx8s6vhM5iVyUds00MQb83efuD33LSsoTA+KJviRvCIiIiIDIN+IhIRESmgXbvgvvtyj1ABOPlktzz6Bz/oCgSXl0NJCVRVwd57u9Wibrhh6I+7aPMiIonMAj9hf3iPKar81FMQDmdvv+ii4cesqYETTxz+/Ydky6NkZZEClTDjc+DP8cQGEqyEeVd70jQRERF5/1FyR0REpIDuv9+NxMnl9NPhL39xCZ18ysvhP/8T7rhjaI/7RsMb3ee7au9EEpE9Jrnz97+7kUm9GeOmpA111E6X8nK4/PKRt21AHRshuiN7+7Tz8q+eNRhVs4d/XxEREXlfU3JHRESkgO65J3fR4Npad11Z2cAxKirg/PPhox8d/OOu3rm6+3xX7Z1oMsqiLYsGH6SAnn8+e9tHPpJ/9azB8PnghBOGf/9Ba3oZfDkaOvuSodXa6Wuo07lERERE0pTcERERKZDOTnjxxdzX3XXX0EaolJfDb38LY8cOfNvG9kbiyTgAIX+IMSVjuq9bvGXx4B+0QBIJ2LQpe/v55w9+hax8YjFc4Z5CqauDXcsg0SdjVzIRKvcbWWz/CDJbIiIi8r6m5I6IiEiB5Ksrc8opcNxxua/rT1kZ/OQnA99uRdMKSgJuJaeSQAlTqqd0X7d65+rdvmLW2rW5n/vpp7vRNyNRVQU0NLjK1P2d8hnofg0NsOM1oE8RpYknQqqfqtkiIiIiBaTkjoiISIH86U/ZdWUArrtueCNUwmH4zGcGvl19Yz2xZE+iYd74eRjcuuqJVILGjsahP7iH6uuzkziTJ8OYMblvv8fZtTx7294fg2DV6LdFREREBCV3RERECsJatyx330Eihx8O++47/LjGDHyb17e8TmeiE3BFlA+eeDClQTcHrCRQstuLKi9fDh0dmdtOPNFN19rjpRLQmWNO2cTRWqZLREREJJuSOyIiIgWwaRNEItnbr7xy+KtBgVsmfSCvb3m9+7zBMLd2LkFfEIBYMrbbkzuvvpqdyPnoR6Gycve0Z0jaVoO/zx+hct/sbSIiIiKjSMkdERGRAli8GILBzG1+P5x1Vv6l0b2yaseq7vN1FXXMGDODpHU1YjoTnRnJn91h6dLsbYccMvrtGJbmejB9dp+qD3QjekRERER2EyV3RERECuD117OnHh17bOGnHu3s3ElHvOeBp1ZNZWr1VDrjnd3b3tjyRmEbMYAtWzIv+3yu5k5RaF8HyT5Dsqr3h8Ag1rQXERERKRAld0RERArghReyEzmf/KRb0ryQVjSt6K6vAzBr3CxKAiWUh3oeeNXOVbnuOiri8ezpatOnp5cwLwadDdmrYo07HHzB3LcXERERGQVK7oiIiBTAkiXZ2845BwKBwj7uisYVJNJThAK+AHNq5wCwV+Ve3beJxCPs6NxR2IbksX179jLo8+ZBMpn79nucjhzFlGsOGP12iIiIiPSi5I6IiIjHWlthR5/cSUUFTJhQ+Mde3LC4e1pWaaCU6TXTAZhRM6P7NqXBUlY0rih8Y3JoaoJQKHPbnDkjKzI9qiJbsreVTRn9doiIiIj0ouSOiIiIx9aty05WzJ+fXYOnEBZtWdR93hjTndyZWzu3e3s8Fd9tK2Y1NWUv577XXtkJnz1WZFvm5UBl9nr3IiIiIqNMyR0RERGPNTRkJzAOPnh0Ehgrt6/sPh9LxphWPQ2AmWNnUhpwGaeOeAeLGxYXvjE5NDVBKpW5rWiKKQPE+gzJCtdCKrp72iIiIiKSpuSOiIiIx7Zuza4hc8wxUFbgBZVao620RFu6LydTSSaUu7lg02umE/L3ZJd6j/AZTU1N2YWmJ07cLU0ZnnhL5uWS8WCLpWCQiIiIvFcNmNwxxvzaGLPNGLNsNBokIiJS7LZuhWifwRxz5hT+cd9qeitjpazxZeMx6SFE06qnkbI9Q2Z6j/AZTdu3Z6+WVVu7W5oydNZCoj1zW7hYGi8iIiLvZYMZuXMXcFqB2yEiIjJs7+56l6Vbl+7uZnTbtMkt+d3baBRTrm+sJ5nqGUUypbqn0O+0mml0Jjq7L7fGMkf5jJZIJLtEzZgxo96M4ck1QidcC8Y/+m0RERER6WXA5I619llg96yXKiIiMggfv+/jHP2ro7F7SGHb9euzt41GAmPJ1iW0x3tGlswaN6v7fEWogrC/Zw3ysmBZ/hWzJk50RYMKcIr/4IdZD1c0xZRtEkyfXSdfOHubiIiIyCjT3oiIiBS11mgrS7cupT3ezqubXt3dzQFcQeXeAoHRWep74eaF3ef9xs+ccZlzwSZVTuo+n0wl86+YtXVrQdoHECeYtc1fLANfbALoUynbF8jeJiIiIjLKAl4FMsZcCFwIMHXqVK/CioiI9OtP9X8imZ4uc/ui2zly8pG7uUXQ2Zl5ubbW1eApdEHlt7e/3X2+LFjGjDEzMq6fXj2dVTtWAdAeb2fJ1iWFbVAOSbIzOX1XFttj2RRZiRzjy96Wz58nQmSgxJkPzleBZhERERkaz0buWGvvsNYeZq09bPz48V6FFRER6dctr94CgM/4uG/5fUQTu39Z6r6rQYXD2ct/e60j3sGOzp5Z1D7j614Gvcuc8ZkjeXqP9BktARJZ2wr92njG+IE+U/9Syext+QyY2AEolhdDRERE9iSaliUiIkVr7c61rGhydWMMBr/x8/eVf9/NrcpeBj0QyC4i7LW3m96mLNgzNCiWjDG9ZnrGbWaNnZVRd6f3SJ/REnyvJXfsEJI7IiIiIgUymKXQ/wi8BMw2xmw0xvxH4ZslIiIysN8s/k1GEeXWWCu3vnrrbmzR7lPfWJ+x1HksGcuosQNuOfRwoCe5syuyi/ZYn6W9CyxILGtb32Xj91gmkJ6a1UuyI3ubiIiIyCgbzGpZn7XWTrLWBq21k621vxqNhomIiPTHWssdi+4gmnSZAV96xaKXNr7E1rbCFQQejL4FghOJwteVWbptaUaiZlzZuO7XpEvfkTxlwbJRH71TQhRfn9E7O4plTc5c9XWiTbmXSBcREREZRZ4VVBYRERlNL254sXvZ74pQRXetHZ/x8Yelf+CKo6/YbW0L9Pl2jcXAV+CJ0He/eTe21/Sgpo4mqq+tzriNtZbWWGv35ZZoC/fX38+hkw7NDFZXV7AVs2ppooQYHb12QbZtg/33L8jDecsYCJRDouc1JNq0+9ojIiIikqaaOyIiUpR+sfAX3SNVek9B6kx0cutru3dqVklJ5uWmJldUuZC2tG3JuJyyKVqiLRmn3omdLk+ueTI7WEODKxI00CmXAe5T+8AdBKoylw0r4Mrr3gvVZF6ONLrpWiIiIiK7kZI7IiJSdDrjnTyw4oHukSrzxs/jnDnndE9DamhrYEnD6C/z3WXixMzL8ThEIoV7vJZIS0a9naF4Z8c7Hremf+PHZ09R27hxVJswMqGxmZejTeAvcOZOREREZABK7oiISNH569t/xe9zhW1C/hDnzj2Xs/Y7i4pQBQCxRIxfvv7L3da+qVOzt+3cWbjHe3JtjtE3g9QSbfGwJQOrrc1eHWvjxsImvzxVMiHzcrJDNXdERERkt9M4YhERKTq3vHoLbbE2wCV3zph1BvPGz+uuu5OwCX7/5u+58dQbCfqDw36cVAreeQdefRUWL3YJmrY2t7pTaSlUVrpkxQc+AEceCZMnu1EpkydDMOhG7HTZts1tL4Rn1z877PumbIpdkV3UlNQMfGMP1NZmvi4Ab73lkjt9p7PtkUonZW9rfxeq9hv9toiIiIikKbkjIiJFZXPrZhZuXth92WA4aOJB+IyPI/Y+gufefQ5wxYMfW/0YZ+131pDiNzbC3XfDvffC0qU9K1+1teW+vTFQUeFWxAqFXKJn5kxXY6d3EuPtt+HQQ3PHGKner8dwPLnmSc6dd65Hrenf2LHZS5/X17tkWFEozZGh2/WmkjsiIiKyW2laloiIFJXfLfkdplfRlpP2Oam71s6n5n2K0kApAK2xVm577bZBx33zTTj9dJgyBa65xo3W6ex0SZ3eiR2fzyVuuppgLbS2uts2N8NTT8Hvf5+9HPqLL0JHx/Ce80DeanprRPd/bv1zHrVkYH4/lGXWU2bDhuzXa49VWge+PjV2tr8KydjuaY+IiIgISu6IiEgRsdby84U/J5JwBVoqQhWcM/ec7utP3ffUjMTPU2ufYkfnjn5jdnTAl74ERx0Fjz/uRpV0drrr6urgk5+EW291I29iMTdCp60Nkkk3leiNN+Daa11iqDq98ngkkr2Y1JIl7v6FsCuya0T3H+nIn6GaMiV727p1o9qE4auYmV1Aubne1d4ZSEldYdo0FBMnusxkoU59q4mLiIjIqNC0LBERKRqvb3md7R3buy/HkjFOmXlK9+VZY2dRHiynI+4OtAO+APcuu5eLD784Z7wtW+Ckk2DNmsyCvgceCD/6ERx/vEv2VFa6ETtdAulvz3AYDj4YDjgALrrITcu691749rfd9K7elizJHrHihY5YB8kRFvR9a/vIRv4M1fz5rs5Ob6+9BnPmjGozhqd6HqQSmdt2LckezZPLOQ3Z2+4x2dsKqdDrzhfVuvYiIiLvHRq5IyIiReP2RbfTmejsvjy1eioTyntWLzLGcOasMzG4A+b2eDu3vnprzlhtba4I8sqVPYkdvx9uuAFefhlOPtkV+K2uzkzs5BIIuNuVlsL557uYY8Zk3qalBZqahv6cB/LM+mdGHKM50jzyhgzB4Ye7RFhvDz3kXqM9Xvk0sH0qQndshHgBl0MTERERGYCSOyIiUhTaYm3c+fqdpGzPOtprd66l5AclGae7l96NpWdOVH1TPY+teiwr3oUXutE1iV6DMH72M7e9rGz4NWDCYSgvd6NT+vrLXzIfzwvPrHtmxDGSNklHrEAFgXKYN88lwnp76in32u3xjA/Kcqx1v/lRsKns7SIiIiKjQMkdEREpCv/77P9mJG3AJSWiyWjGKdF3ygzw7ae/nXG5oQH+/OfMqVgf/zhccIFLzHjh2GOzE0QPPADt7d7E77K5ZXPWNp/xEfAF8p5yWbZtmbcN68e8ednLoTc1wcaNI4+dGo38Ss2B2ds2PQTx1lF48BGqK3Ddn0LHFxERkZxUc0dERIrC7YtuH/Z9F21eRCwRIxRwc4EefDA78fLNb3qX2AG37Hl5eeZUo+ee837J75ZY5lym6nA193/6fk7a56S89/n3v/w7dy25q/tyVaiKDS0bOIIjvG1cHlOn5h7B9Pe/wyWX9NQ0Go7W1p7C1gUz7giXzLG9nsTWp8FfUuAH9kBDjro/fZk8dYD6VgkXERGRPYZG7oiIyB7v7aa32RkZfk0Ti+Wnr/y0+/LmzdnLks+aNezwOR18cPbolHgcHn3UrbTllb4jbpKpJNOqp/V7nzm1czJG8LTH20d15I7PB9NyNPGeezJHUw2H18mznKr3h0Cf6tjxXbBj0Sg8uIiIiEg2JXdERGSPd/U/rx5xjJtevqn7fG2tK5bc24YNI36IDFOmZBcNBvjxj3uWWh+OaLTnfDKVZGNL5lymzkQnU6tz1ITpZXrNdEoDPUVvkjbJa5tfG36jhuGEE7IHiLz2Guzof+X6fiWT8Le/jaxdg1J7NCRzZKFW3gzxYqgKLSIiIu81Su6IiMge77l3n8vaNr5sPBMrJuY+lU/sXjGrS0N7A61RVxPlE5/IfowbbnAraHnFGDjrrOztL70E69cPP27vmjLrdq0j5M/MIFWEKggH+q9MPK1mGj6TuQuwfNvy4TdqGM480y0x39cNNwy/LlEkAjfeOLJ2DUrJeCibnL19w4Oj8OAiIiIi2ZTcERGRPdrybcvpiGfOoZpUMYltX9/Gliu35D5dtYWPz/54xn3KgmXcX38/4KYEHX985siau++GRx7Jnq41Ep/+NFRVZW//1reGl0iKRt2KW13qG+vx+zKLB+1dufeAcaZVTyOajGZs29i6MWcx6kI57rjcU7B+85vhx1y3Dl59dfj3H5K9znQrZ/WWisLK2yAxgqFZIiIiIsOg5I6IiOzRfvn6L4klY92XDYYz9ztzwPudM/ccKkIV3ZfbYm3c8uot3ZfvvtslXny9vgm/8AV46KGRrWiVTPYkiE46KXMaVZeHHoKXX4ZYLPu6/kQicNllPZeXN2YnvmaMmTFgnLqKuqxETtgfZu3OtUNr0AhUVeWuc9TSAgsWDD351dEBX/mKJ00bnL3OgEBF9vb6H0JqhIWDRERERIZIyR0REdljJVIJfrv4txmJiMpwZdaonFxOmXkK8WRmReP6pvruBMa4cfDiizBpUs8InkgEPvMZ+OhHYckSl2AY7Eie1lZ32yefhCOPdNvKyuCIPAtQfe5zQyse3NYGX/4ybNvWs+21za9lJWnmjp87YCyf8VFbVpuxze/zU99YP/gGeeATn8i9MtZPfwrbtw8+TjQK//gHvPCCd20b0IQPQTLHCJ14Cyz8GsQ9nOMnIiIiMgAld0REZI/15JonSdrMpaUiiQjHTz9+wPvWVdSxd1XmFCVrLXctvqv78qxZ8Oabrrhv72XQn37arXZ1zDHw9a+7Jbp37HAjbdrbe5I+8Ths2uRWefra1+CAA+C002BZr4Wnzj8/9xLrW7fCBRcMLnnU1uYKBd9/f+b2pVuXZlwuDZQyc8zMgQMCU6qmZFzuiHewvHF06+6ceqpLgPWVSMAXvzj4EVTRqHv9R1Wg3K2alcu6u6HlLUjmGLYlIiIiUgBK7oiIyB7rttduozXWmrHtwAkHZky36s/Zc87Gb3pq0kSTUe5YdAfW2u5tY8e6Wjt//SvMnw+lpT3LaS9dCrfdBh/7mBvpM2GCSwgdeCDssw+MGQOTJ8O//RvcdResTc9q6r0S16c/nX/p87/8Bc47r/8kRlubSx597nOZ21M2xfrmzMrMQX9wwGXQu8wamzknKpFK8Nqm0V0x66ijMgtE9/bMM3DFFQMneNra4JRToKHB8+YNbNpnwV+a+7qnT4WOTZDsZ+5dIseTuxhXjbtQp4kTPXnqIiIismdRckdERPZIzZFmnlj9RMa2kD/EufPOHXSMs/Y7i/JQ5rCZtngbL2zInr9z4oluKtbrr8NXvwpTp7okT1UVhEIuGdTcDFu2uMK9W7f2JB5KS93tgkGYMwe++92euGPHwjnngN+f9ZCAGxV08snwxhsuXjTqRq60tEBTkyu+/JWvQK98FAAbmjcQ8GXOaUrZFNNrpg/qtZk7fm5G4gtg6baleW5dGMEgfPaz+V+bO+6Aa65xo5sSfWo9RyIusXPmmfDKK4Vva04zPg82T3YqtgOeOBo6N+eeohVvhW3PZm9v9raJWbZuLfADiIiIyO6QY6a7iIjI7nff8vvcSlC9Rr2E/CFO3/f0Qcc4ZsoxGcWYwU0/+sXCX/DBqR/MeZ85c+AnP3Gntja486E3uOLX91LS8GGOqD2JRDRMJOKmE5WXu+TNMce4Ojvz50M4xyrk3/gGPPggdOZZROmll+DQQ+Gww+DDH3Y1gN5+2yV++iY1utQ31hP0BTO2dcY7mVo9dcDXBWB6zXRKg6W0xXoSD+82v0vKprKWSS+kr3zFjUzKN0LnpptcHaNrr3XTuBIJNwDlzjvhBz/YzbmK0kkw7nBofD739ZFt8NAc2PfLcOD/gUAp4If2tfDGVbDpoez7VFPYBE9dXQGDi4iIyO6i5I6IiOyRbnn1FtrjmUf8fuNnft38QccI+UMctfdRPLP+me5tKZviwRUP0hnvpDSYZ0pN2t/W3sN/r/4yHBshyvWsrKjjX1/8F/uN229Iz+Wgg+Dww+G557JH4PS2cKE7DUZ9Yz2dfZbcLg2WZo1Uymd6zfSskTtBf5B3m98d9OgfLxx6qCtqvWpV/tssX+6KXJeWQmUl7Nzp6h3tEeZcATuXQKI19/WpKKy81S2RHh4LqQTE+8ne3Aac38+bpIsx2dv6e3OJiIjIe5qSOyIissfZ0LyBpduWZoxMSdkUJ+9zMsYYdxAb2wmdm1xdk85N0LkFEh3uYDoVAxMAX4hP1ZTy0oYAKWu7D4hjqRiPrHqEc+aek7cNP3rhRyx4ZgGdiU4CJoDP+NjatpXDf3k4j33uMY6afNSQntO117ql0Qe7+tZAFm5ZmDUqaVLFpEHff1r1NOKpzAxJwBegvkQKFuMAACAASURBVLF+VJM7xsDVV8Ollw68/HlnZ/7RT7vN3h8FX2gQN7QQHcISYCIiIiJDoOSOiIjscfau2pvbzriNjng6E5Joh9aVnFsWg7/NhPYNLivgC7uCtuFaCI+DkgngD7vEjk2BjfOF8giJyXXE422QikAqCTbJCZMOyPnYKZviqw9/lbuW3EVnopOyYBkXzL+Ap9Y9xeqdq2mJtnDi707kj5/8Ix+b/bFBP6ejj4azz4YHHhjaEuj5vNnwZta2GWNmDPr+e1XuRTSRuZpTZ7yT+sZ6zph1Rs77tLfD+vXQ2OiWZP9UjtucfTb4fK6eTjDo6vfutReMH+8KUk+YAHvv7S53+exn4bLLBt30PYsvAHOvhGU/gKRHmbvdKJXKX5Bx2TK3dH3X37brfEkJVFTkHkwkIiIio0PJHRER2eP4jI//Ovy/YPtCWPhV2Pm6S+Q0t0L5DNjvYjdiYuwHIFAJyU6wCSC9IhDpo0xrqSDF14wPfCVAClpWwpbHoCZ7alU0EeXcP53LU2ufoiPeQdgf5pjJx3DzGTfT0NbA/F/MZ0fnDjriHZx3/3n8+JQfc/HhFw/6ed12Gzz++MiTO9Za1uxak7V9zrg5g47h9/kZWzqWxo7G7m3xVDxjxawVK+CJJ+DRR13B56YmNzVq6lTYd184tayOqo6eojeRmjouvthNmYpE3Cibjg5491033eydd2DNmsyl4sHFvO46t+z8YJc/36PMvhTeurFokjuRCLzwAtTXuylvq1fDpk3uuqoqeCRcx5hoZjGj9so6nnsOYjFX9Dsed/9v2wYbNrjVylpb4cUXobZ2aO2xtmdFOb9fSSIREZHhUHJHRET2TIsuh1W3QzICWDf15bBbYZ8vuusDZT239Q1uaXQAxsyH6nlZm9fvWs+HfvMhtrRtIZFKYDBUhCo4YZ8TuOmVmwD4wvwvcOtrtxJPxelMdHLZo5fxyDuP8Nfz/orPN3AR4qoq+OMfXf2Y4U4vKi2FLW1bMGQeAYf9YWaNm5XnXrlNrpqckdwBeHPrm7zyClx+OSxe7A68IxE44gj41a9cwWefzx3kB8MN0KtsUQlwco7HicXc8/X5XMHpUI5ZTBde6Ionv/32kJ5CllwFrQsuUAZH3A4vfT738ubDEWuGlhXQuspNO2xbB+3rINoE5Ml+vPwf6RFryfT/KVcLKLYdElHW7dyPr/38Gzyx8ABCQUss7ufYD/q58ko47jiXVIlGwZgGOoLutfT53PZy4L96PZS1rrh11+puPp97b/p8bsW5xYtdUm/NGlf0Ohx214fDrh+MHesuBwI9I4CMcUmjeNwle6JRV1+pudm9f37+cxgzxpuXV0RE5L1GyR0REdnz7HgjndjplQGZ/z2Y+SXwl4w8fp8lxF/Z+ArH/vpYkrZnaS6LpSXawnef/m7GbVO9lr6Op+I89M5DzPjZDFZcvIKyUBkDOfFE+Pd/h7vuGnr9na5pTvWN9YT8oYyCyuFAmGnV04YUb9+x+/JGwxsZ29asNpzwTUtHR08C4cor4f/8Hzf9piuHVTbwU+0WCuVO6PTm97vX5IQTRlZXZ6DHKZjJn4Cag2H7S/mXRx8MfwU8cgg017sph6FxMO0zbsWtylngL4dUJ9TNhK3beu5XNwE+8FPAgsX9T7rAsvGDP8w9/9fw9xcCgCGSnpH361/DlCk9o2VK+68x3s2YnulZXb7zHbeCWWWlm96VSsHzz7ui2a2tLmHTdb9QyCV1+pNK9YwSSqWgpmZwbRMREXk/UnJHRES8Zy2k4m6aSiqePti16f9TPQe/xgf43P9d5/0hN9Wqr/YNbkTCYPx5IkQGWiPbB+cnWbZtGR/6zYcyEjsApYFStxR7DrFkLKOY8bvN73Lo7Yey8CsLqQgNPIrollvcge2ddw4+wVNSArNmwdNPw93vLCeSyJzbZa1lWs3QkjtzaudgMFh6VlkyyVKSKUvv0SFdB9WDGJw0IkcdBZ/4BPz5z+6gfqjKyuD6671v16AYA0f9Gh45ODMpORThWjcyZ+didzkVg0N+7BI7vfkqoCHH+3uA9/0lEyvxfeZifrvkWtascYmc006Dc85xp332cYmZSKRnNbKupI/pmemY8b8xLlETDEJLS89jdV3flWzrfXsY3HvJmJ7TaLLWFfdubnbTBLsKeXd2ulFoXW2zNvP1yPXcUin32pSW9pzKytzopaoql9QUERHxgrGDWDbTGHMacBPgB+601l7b3+0PO+wwu3Cwa7mKiEhxWvNbWHcPxFvcylWJNjjoB26kgT8MwRoIlEOg1NW7MV3FNNLzPLpHGKTSR0kJd1Cc7HSx2jfCqxe61a+6Dpb3/pib/hIod0WTA3mGGQwquQP/OuYZzvrjWbTFepZpCvvDXHfydZw166y897PWculjl/LPNf8kmnRZiLAvzIyxM3jmgmeoq6gb1Ev4wx+6kQ4DJXhKS+EDH3C1b8rL4YIHL+B3b/4u4zYBX4CmrzdRXVI9qMcGuGvxXVzy8CUZS85Xh6u5avxT/Ob/Hsq2ba5tqZSbSva978H++/dMsSorG/zBaUeHOzAuKXGnfFpaXJJn9eqeA+nBKCuDs85y094GlYTKlzEY6XLia+6C1y4eeoInUAknPQ2NL7q+1bzUjVILjYOpn4Kp57qRO4HKdGHw3iudpetM/X0WRLfle4Qe51u2b4e33nJ1kDZsgJWrEqx4p4OGrSlKwn5qx6cYWxMk4PcRDPgJB/z4/ZBMGlIp938yCTt2uFpMPh/MnrGDX333z7y1wvLG0hLe3RhidcNUtrdPoLSqmrKqMsJlIaqrfYwdC+VlBn/AEApZQiHwGYjGIB43xOOWaBR27LA077R0dsa5514PRu31o+9b4qSTXM2p9xJrLbsiu2jqaGJc2TjGlIxxKxCKiEjRMMYsstYelrV9oOSOMcYPrMRNo98IvAZ81lpbn+8+Su6IeGzBAndUVSjf/a57DJGhePJ42PavnsuBCvh0a86b2q4aIKR/6l72fczy/+0/vr8czmmAt26Atb91S577Qi7xUzMf6o6DuhOhYiaU1rlkkk2k643Y9MATnyvEnGyHP2UmPe5tgS9tL82Y2lQWLOPrx3ydBccvGPDpRxNRjvn1MSzbuoxYymUhgr4g48rG8ewXnx10/Zs//aWda64xbFxXSjQCqVTPgVZFhatRctVVcMUVPaMgDvr5Qby5LXO1rNJAKR3XDG2e19Nrn+bs+86mOdrcvS3sD3PtSddy6ZGX8czTlkcfifPYY4a3V/rx+aGq0jJ7tmWfmT72289w4IGGsjKXsOmqp9NViyUadaNAXBHlFKtXW95ZCatW958R2rEDDj/cJR3i8X5vCrjEzoknwoMP9kk2WetGvyQ7IRl157tONdl1lwDY/nr6TDph0vXnMAH3/vOH3f++kEu++EuzswIrb4U3vjH4AsuBcjjhn1B7ZM+2eAu0vA2t72A7NtG6czmdu1ZgOxsI+PyY8DgCJePx+4L4/UH8vhB+XwCwGGsxuBMbHnDPt0t4AjvPeIs3Gt7guuev4/E1jw+ujXn86KQfccrMU5g3fh7BV//T9dXezs+xn9lrmIu1LnmYSIB9cBqB+Cb8vmTu3NvZW6B0IgCReIRXNr3C+l3r2RHZwfaO7azdtZa1u9ayZucaGtoaGFMyhvZ4OzOqZzB9zHRm1MxgavVUqkuqmVg+kbnj5zK7djY+47KBZ5+0knc3lhJPWNo7guw1tZyf3lpBKmXw+917KxzuOXWNKuqqS9Q1kqfrFIu593806qakHXJI4ZIozZFmVjStYGvbVra2b+XmV25m1c5VRBPRjJF5AzEYQv4Qe1dO4asfuJKJFROZVFXHAXVzGFeugkciMjqs7dmPiEbd52k87r4r3A8M7tT1ddJ7JGVfvUeg+nzus3zczQsYf1vhjq02ffm7NFy0gFDI7R91jdysrh54SvJgjCS5czSwwFp7avry1QDW2h/mu08hkzvW9vxhE4meP2zXH7lrJ6HrD9z1x85+XpmXu76Yx9Sfhy/V3jMUuHo//DM+0/XogMVai8WSstbt+hlfehfQZOwHZhY8TP9KbYwLs/5eaH2n5+pAOXzwXi9eIqy1xJIxNrVuoiXaQiQeoT3eTku0hZZoC62xVlqjraRsioAvQGW4kqpwFZWhSirDlZQHyykNlFJdUs2kykkEfUH3q855NXBf88ANGK7vfgeu+YbbEX35i26bCbjaGB98AGoO6PXHHMyOSk9P3ti2lTuW3ENHIkJHIsILG1/l3ZZNxFJxEqkEiVQio46Gz/gyLhsMAV+AgC9A0BckHAhz9pyzKQuWURYsY3btbKrCVXTGO+lMdPLnFX9mZ+dOOuIddCY6iSQidCY6u68fUzKG5mgzpYFSSoOllARK3PlAKWWhMqZXT+fEfU7svn7BYzfyxs5nBnzGW66HiX1qeTaUw6Sv93MnC1+YcBPRZJS2aDvro2+yMfkaCdNJwsZImRjxVCzvzqEPP0FfiKAvSNAXJuwv4YMTT6OudDLlwXKmVO7DKVPOBiwJG6c5sY3W+A7idEKgg2Sw1b0vo620xlqJJ+JgoCpc1X2qDFVSHiqnJFBCZbiSyVWTCflD3TvkXe/5aDLKisYVNEeaaY+30xxtpjXaSnOkmZaYe//78GGMoaqkiqpQFdXhaqpK3GNUhCqoq6hjes10wv4wAV8Ak+yAeKtLGqQS6eQBdI82IZ2wcA0Z8G/UM2Il/aFjfD2fC76Ae88bf/oX+5r0VKU900UPXcQdi26n2gdjfDDWD5U+KDNQGQgwNlzFmFAZpcEyQsEyAsaPz/jwGR8Bn5+UTZGyNv1/igtTS6gwie74L60/nZV7PUxrq5siEYht5sBJLzDJ/y8mBN6g3LeZEtOInwhJSrAEITwmfeAdTC95HneFaVMRgrR2f/Yv6oTDNkLY5yecnnqVtJbTphzBn068GkO6KK37w3R/hPd8ebgNTZEW5v/5a7QlIt0FjtsTEcaFK9nyb3fj84dg6zMQb2FDtJOXdzawKhpluZnIY2seo6mjqecF3XQYvPI1zI7ZVPlrGT8hySmfbOArn69l/l5zu29mraXyh5UZo20AZtTMYM2l2Sto9WftzrXsf9v+GQkuANs3L1V7FPbkl1i3DtatcyskbdvmCuW++y5s2dJTWDeRcDtOXYVyx493NV322qtnKfQTTsis1ZLL1q0uwdPY2P/qYmVlbpn5Rx5Jx1zxE3jjqswbfabDJWF6mzjRPUhvdXVu2Scv1F8PSxf0n+Axfjeq7SMPw4QPA7BqxyqWNCxh2bZl/OXtv7C4YfGImjGtajrn7X8+B9YdQG1ZDafdk3uZ+6DxUR0spSpYQkUgjN/no+t71AKxVJLWeISWeCfN8dyjkgLAi4efSjS6nUR0F6taNlIdqmTi2NlUl9ZSWTqO0lAFwUA5vlA1Pl8Y4/Nj8GOMj7Il38CXaMkZG6BmNTSPoJzRQLLe95M/AR9+sPtiMunei131hHrvc6aW/gjf29dhjMVnUhn/hwNRgoEEnN3gEtEFcNCCz/OmubsgsQGOn3Y8T3/x6YLFX/21zzPz5sK1n/++Ev7n6p4krS8Eeabdvu+kku5zyibS35u9fiTpHlmbApOertvfvk7vUbm9p1t37+8EevZ1/CXuu3oPtuqr/8a+t9xTsPjRqy4k/J2vu/eiLwgm6Kam+0u9qS9YxPoeq3v59ZxMZidYfvADuOaaHDfuu6/gZUNGYCTJnXOB06y1X05f/jxwpLX2knz3KWRyZ4FZwAIKOILhD30uz7wQjrx9cPd9cwEsy9+2P9Yfyfn/+3LGtt//Hj73uaE1MZ/yb+5DR9lab4LlcMuYco6uaE8ntCAYqmHGqU8AFpOumWGMITz3JMy27Rn3tWNLMTcPMET9AeDPhWn7L04bx38dtX3gGw7TNBtivRnC/IGhWn0STHkJOsZBpIpgeQeHza1jStUUJlVOoqakhuqSaipCFfhIJzywdMY7aYm2sCu6i23t29jUsolNLZvAQCKZYHvndna2t4I/MUADhq9i8wdo22tRweKbRAgbKNxrb9+kYO9LgNM+fxxMckcUzb5G2sqaKK3M/YXuNz6SNpm1SlJvs8oPotRf7uLV1/Knn3wt4/rf/Q4+/3lv2v7lT5/KwnGPM74dxndA1A9Tm2GfnTCpFeraYGwEfDm+ZmJ+aCpzycctlfD2ONhV4nJejWXQWA4rbs2844c/DP/6V3YskhHo3Awdm90UrlTc7Zwaf8+OZHgClO0NwWowhmjbBh69Z2pGmMCsizjpQz8lHBjEcku9Pu83J+C1PsmHiIWHOwxLzUTqWxuJpkbexwyG2TVTOHDsDDpfXUFjZ+b0m88sh8tfznPnPBI++OwnYUNV5vZv7l/NxAkVJBIRkrFWyipqmXn4tfhsMmOkiPGXYvwh6PUd4Fv9G/xrf93/A5dNy6wjUzIRKvfNutmu5gDX3zaFm345mWQKIpGeg7HysgRlpSn+9+q1fPEzDQSD7v3ym1+2EV37EMmUn6A/Tlmog89ddjSUTel1wGLdgYYv5N4nkN6TNLD297Au/0HmE+9eziuJGzK2HXlk7mRVTfRpZjZfSWlyJQHbk4xL4ccSZHvJGaytupbOQE9W4SP/yu7fJf4S9p+wP3Nq57DPmH2oq6jr/qzvYrE0dTSxZucaVm5fybJty2iNZY6kOzoMX6qGmUG67+075nccMOMsxpQOflSGtZaV21fS0Nazg9seb+f2hbfzt5V/G3Scobp621kcOv+h7kSyMYaS0xcxqWoqY0vH9j+9KN1nYxa2JqAx6VLzCQs7U7A9CTMerebYh5vdCnClQBkQAoJAdTlUlkF5+ufXUHrojj+dBAv4IJk+CE6m32PHLoOwq+W1dNtkxl8eZyIDTxcdjoVzPsCvOv4D/7vu8VL4+NAlBzFxTg0pa0gZP0nrw+LD+LuSdl2/SBqMMVibcl0j/YOFTT+PgEnxs20381zr01hjsSRpL1+LP31wZNP/3AV3LugLEU/F0gdopvt7y6R/Dq0KjmF8ySTA4DM+6psHd9zQ90esAX/AAuZF9mL5gZszN574FNR9ZFCPOZDH77udfRuvc6+bTZCylsln3EBwwmE5pn/2M7ygS8aPCPC5G2/ghaZlQIpEop0d1aspq+z5nur58c39H/SFiaei3ffvvc9gjGFcaCKTSqbR9Xd/+p8PFmw/55HaQ3il6WMFO3a7f/99ufPoA2HsONa9C9vLVzJ+mo9wiftc7/25bOj92uRW6i9nVvlB3Zfv3PD9QbVjWD+uAizIfC9cdZV3deP+cv9bnP2pORnbtm1zP7h44aYbH+fnN7v9qEgEUibBT2+eydw57kUfzgTn3r1l3u2zoa0OkmFIhvAlSzlk2ix8BAj5Sgj5Q/gJEvD73Y+xpuf97j7P0p9jXQMzrCWeSpBI/7D/7JaHIVID8VJIlDImPI4Dpkwj7C+hNFhKyB8iaEIEA34Cfn/6U8zFNviwpLoHfFgsiWSSeCJJ3LqajP/v6gsoKS3caM2RJHc+BZzaJ7lzhLX2q31udyFwIcDUqVM/sH79eq/anuEbP6zlQKpIpvwkUwGgkv2Pu52UdUPZDcYNaTduRE3v5xdqfJHw9ud6RXNfwtZafCQwJLn6tzHO4mFKEu5ApSUMNRGojkJlFMriUBp339Vdf66UcbftDEBnEJrD0FziTuM63A5UJADv1s7jupf/6jLf1t37mivH8O/nV2Gt7fVGdFnvwcyB7rq9MbD20e+y+K5N+Jf48aWf94yPH0rlmGr8+HpGMWU8VlqvIU4JksRMPL3JkjKQ8CW5oOktdpUthWgVxEsI1Gzl7FPHM7F8IuPLx3cnFypCFfjTO8sWS0e8g7ZYG63RVpo6m9yQ4bathANhQv4QrTE3cmPl7RcQNoaAL4XfpDjywEr+89yZGFL4fQZww7QNYHy+jNVIprb+hqltfYaC9/LiyqPZ2lxHyvbsDJ/8+ZOomnYo6Z8X3P/zzoTGHZl3Hj8W/nY2rPlV3vh3PPVl9pv4DjZdmhTg+P/vandA2fPXgrmnQJ/EF2NLYaDEV7CaZDxGNB4mEi8hYvYm/pEXiMctiTgkUoZEomsfredvaS3Y9fdh3r03/XfvmhaThFQCv4nit53MeO5tIn8tIUGg+2RLy0gFQthAkKQviPX53RC39C9dtmtIvfFh0n8L0/WeSrnhdL5Ugp2z4KnUPIJLfO5HH6Du2FlM2HdvAukaLCa9M2iArM+k9PNJkiJm4nQFSQFJk+CVrS2U/3MDl3bc2n0Xn4VQMvNLYiAWiAYyv4wSPhhzzHeoaJ6B358k4EsyvjrAj644EEjhMxa/sW6Uh8991Pe+/webPk441ef91Id5p9+rR+SATcfxyV9+mAUMbudkqH504mPctOKU7supFPzjH+5Hjq7Rj9bChIMm4m/MPKBJjq+jaWkDuT6GukZdlv3k+zT++C7aqKCNClqpJF5aRbJ6LKmKKlLllSTDZfjCQXzhILZrFJTP585b696b6f9tPEEyEscX7cQf6eBjH4PAdb2mhhnc0IMArsJc1yl9zN99G2NccZBU1/yL9HXfB9JJkp/vgot7rTBe0+kSXodvhsM2w0ENLiGWT0sYlk6ARXvBK3vDhmpoKu+5fknpbOZP7rNmeK7pL7lGp4wrh5/1v1x3vvelz/gI+UOE/e7zO+gPEjABMJBMJYkn467YdCpGNBHNKlINUONL1wsewsHETmr4KZfxPMfSTDW1NHEOf+aL/JYQmfO2ljOPA47+EvjikCiBaBVfOH1/5k4fC9YPqQABn5+SUIDSEh8Bv9tZ8xmTft8aUik3Otda65JK0RSRqHt+nVdex4LO2wbfeIB5wEnAOCABbAH+kf6/j4u+FGP95mD3iOQJE+Cyy9z53tN/wF3O81Wecbln0GuKQ6e9SjC6FuK7ILbLjUwMVvX8qm4A0r8i+0Kkd6jc/Tf+DTb9tf/nekkQdg5iLt0wrCo9kC2d1cQJEiNElDBVR+9PyvhJ+QIQDJEKBDF+PyboTycvsr+rSE9bsxZs3A038yXjnHL8twfVjuEkGOpiVSy+zjAxWaAR0MeR3gvv5dTXYFyfff98I9Yev6jfHyiv/clefOv1zXmvH6mTD3ic0lAnxlhC/hjHHmO57Jvj0gnZriL86T2FrtEhXaNI1v0B1ucfXbGwqZa7X/gCvb/hTz9zP444er/cw/z7XC7Z9FtKt/w+b/wbF57I5Yf9M3PjWW9B1eyBn/gAPwwDhF+eRWxc4XYWajprKatocl9/qQAlARhXPo5wIESJP0zQFyCUHr0eSGf0bModP50d2MzZgfwJy1d21HDU/ZeB6ep7huMOns7xB093x1/G7TVfeek5VLbszLhvW9UYfnLTg917Vr2PldwBNvzupetZs9fDBXhVnEOfeo7omhqC/jihQIyq8hhPPOmmv2aMbOp6S3YxFlb/Jnuaah+P3XYcvhd6MlCBsVVUHZr+oSP9Puw+tuj9vrS25zOt95yjXrd/q241k99txPdcyn0WAuHpkyiZMiHvcadNfza6eD3HWjYjYeK+K68vncgfHs8c6tLUBOPGDfVVzmNMEHYV7sfnb9zovkPH+KDUQMmY+Yw/ZAETyicwvnw8Y0rGdM8Q6Cu5/IfsWPYTGpPuh4KtSYhbaE//WFBh4H/mHAcnP1Ow9r9npmWJiIiIiIiIiLwf5UvuDKaYw2vALGPMDGNMCDgPKNyYWxERERERERERGbQBazVbaxPGmEuAx3AD1H9trV1e8JaJiIiIiIiIiMiABrUQl7X2YaBwExpFRERERERERGRY9tw1dkVEREREREREZEBK7oiIiIiIiIiIFDEld0REREREREREipiSOyIiIiIiIiIiRUzJHRERERERERGRIqbkjoiIiIiIiIhIEVNyR0RERERERESkiCm5IyIiIiIiIiJSxJTcEREREREREREpYkruiIiIiIiIiIgUMSV3RERERERERESKmLHWeh/UmEZgveeBnVqgqUCxFX/3xVb83Rdb8Xdf7GKPX8xtL/b4xdz2Yo9fzG0v9vjF3PZij1/MbS/2+MXc9mKPX8xtL/b4xdz20Yg/zVo7vu/GgiR3CskYs9Bae5jij378Ym57sccv5rYXe/xibnuh4xdz24s9fjG3vdjjF3Pbiz1+Mbe92OMXc9uLPX4xt73Y4xdz24s9fjG3fTTi56NpWSIiIiIiIiIiRUzJHRERERERERGRIlaMyZ07FH+3xS/mthd7/GJue7HHL+a2Fzp+Mbe92OMXc9uLPX4xt73Y4xdz24s9fjG3vdjjF3Pbiz1+Mbe92OMXc9tHI35ORVdzR0REREREREREehTjyB0REREREREREUkrquSOMeY0Y8zbxphVxphveRz718aYbcaYZV7GTceeYox52hizwhiz3BhzqcfxS4wxrxpjlqTjf8/L+L0ex2+MecMY81ABYq8zxiw1xiw2xiz0OHaNMeZ+Y8xb6b/B0R7Gnp1uc9epxRhzmVfx049xefrvuswY80djTImHsS9Nx13uVbtz9SVjzFhjzBPGmHfS/4/xMPan0u1PGWNGVJU+T/zr0++dN40xDxpjajyO//107MXGmMeNMXt5FbvXdVcZY6wxptbjti8wxmzq9f4/w8v46e1fTX/uLzfG/Mjj9t/Xq+3rjDGLPYx9sDHm5a7PNGPMER63/SBjzEvpz82/G2OqRhA/53eUF/22n9ie9Nt+4nvSb/uJ71W/7Xf/YCR9t5+2e9Jv+2u7F/22n/Z71W/zxR9x3+0ntif91uTZ7/Oizw4Q36t+my/+iPttP7G96rP97nOPpM8O0P4R99v+2u5Rn83Xdq/6bL74nnzf9hPfy+/bjGMpr/psP/E920fOE9/LfeS+sT3ps/ni99o+4n3kPO33bB95SKy1RXEC/MBqYB8gBCwB5nkY/8PAocCycggLxgAACjZJREFUArR9EnBo+nwlsNLjthugIn0+CLwCHFWA53EFcA/wUAFirwNqC/Te+S3w5fT5EFBToMfxAw3ANA9j7g2sBUrTl/8f8EWPYh8ALAPKgADwJDDLg7hZfQn4EfCt9PlvAdd5GHsuMBt4BjisAG0/BQikz1833Lb3E7+q1/mvAb/wKnZ6+xTgMWD9SPpYnrYvAK7y6P2YK/5H0u/LcPryBC/j97n+J8D/eNj2x4HT0+fPAJ7x+LV5DTguff5LwPdHED/nd5QX/baf2J70237ie9Jv+4nvVb/Nu38w0r7bT9s96bf9xPek3/b32vS6zUj6bb72j7jv9hPbk35Lnv0+L/rsAPG96rf54o+43/YT26s+m3efe6R9doD2j7jf9hPbqz474PHICPtsvvZ78n3bT3wvv28zjqW86rP9xPdsHzlPfC/3kfvG9qTP5ouf3ubJPnKe9o+4zw7nVEwjd44AVllr11hrY8C9wMe9Cm6tfRbY4VW8PrG3WGtfT59vBVbgDtq9im+ttW3pi8H0ydNiSsaYycCZwJ1exi20dHb9w8CvAKy1MWvtrgI93InAamvteo/jBoBSY0wAl4jZ7FHcucDL1toOa20C+Bdw9kiD5ulLH8cl2Uj//wmvYltrV1hr3x5OvEHGfzz9+gC8DEz2OH5Lr4vlDLPv9vMZdiPwjeHGHUR8T+SJ/1/AtdbaaPo22zyOD4AxxgCfBv7oYWwLdP26V80I+m2e+LOBZ9PnnwA+OYL4+b6jRtxv88X2qt/2E9+TfttPfK/6bX/7ByPqu6Ow75Evvif9dqD2e9Bv88Ufcd/tJ7Yn/baf/T6vvmtzxvew3+aLP+J+209sr/psf/vcI/6+LeQ+fT+xveqz/bbdgz6bL74n37f9xPek3+Y5lvKkz+aL7+U+cp74nnzX5ontSZ/NFz/Nk33kPek4uZiSO3sDG3pd3oiHOymjxRgzHTgElw32Mq4/PcxxG/CEtdbT+MBPcW/+lMdxu1jgcWPMImPMhR7G3QdoBH6THip3pzGm3MP4vZ3HML+w8rHWbgJ+DLwLbAGarbWPexR+GfBhY8w4Y0wZ7teOKR7F7qvOWrsF3E4vMKFAj1NoXwIe8TqoMeZ/jTEbgH8D/sfDuB8DNllrl3gVM4dL0sNmfz3S4cQ57Ad8yBjzijHmX8aYwz2O3+VDwFZr7TsexrwMuD79d/0xcLWHscH134+lz38Kj/pun+8oT/ttob7/BhHfk37bN77X/bZ3fK/7bo7XxtN+2ye+5/02z9/Ws37bJ76nfbdPbM/6bZ79Ps/6bKH3KwcRf9j9Nl9sr/psrvhe9tl+XpsR99s8sT3rswP8XUfcZ/PE96zP5onvVb/NdSzl5fdsoY/VBoo/ku/anLE9/J7Niu/x92y+16aQ+8g5FVNyx+TY5unolEIzxlQADwCX9clGjpi1NmmtPRiXMT3CGHOAV7GNMWcB26y1i7yKmcOx1tpDgdOB/88Y82GP4gZw0xl+bq09BGjHDXv0lDEmhPvg/5PHccfgsvozgL2AcmPM57yIba1dgRtC+QTwKG6qY6LfO72PGWOuwb0+f/A6trX2GmvtlHTsS7yImU7YXYOHyaIcfg7MBA7GJR9/4nH8ADAGNyz668D/S//y57XP4nFiFvdL6OXpv+vlpEcPeuhLuM/KRbhpH7GRBizkd1QhY/cX36t+myu+l/22d/x0ez3ruzna7mm/zRHf037bz3vHk36bI75nfTdHbM/6bSH3+3Z3/JH223yxveqzOeLP5/9v7/5B5KriKI5/r6BiRETFYGCRiEQ7EdOIBg27QaLIQrQRLLawsbMU0cbOyloIASFREXSNsbKICFb+27hJ1BAUAw4h659WkIA/i3tXx8m7d9Z552UZOB8YdrOBMzdv5uTeuTvvjbCzlfFLelvJlnV2yvOmd2cr+bLOVvJ793bo11Lbnd+ns61sRWe78pVr5Mb4h14jd5qnzZ0R/90pXUB3esrgUkrXkif4tyJidaj7iXzK0afAQWHsw8BySukC+XS4xZTSMWE+EXGxfP0F+IB8Gp7CCBiN/ebgPfJmj9rjwFpEbIhzDwA/RcSvEXEZWAUeUoVHxJGIeCAiHiGf9qF858K4jZTSLoDydebTa7ZDSmkFeBJ4NiKG3FR+mx6n10y4m7wpuF66uwCspZTuEOUTERtlIfQXcBhdbzeNgNXyVukvyL8R6XXBu0kpn+74FPCuMhdYIfcV8qav9NhExLmIeCwi9pIXyz/2yavMUZLeDj3/1fJVvd3C+Hv1tiNf1t2usSt7Wzk2st42HltJbyv5ku5Wjr20tyVzfN0nn2sHWldW85XzbWPskrl2LH/zl3DS+XZ8/Or5duLYyOfajsdVOtdO5Mvn24ljr+ht7bWUqrNDv1ar5gs6u5Wx9+nsFfnAUXSd7Rz/VVgjd5qnzZ0vgT0ppbvKuySeAU5s85i2pOx+HwG+j4jXB8i/PZWrk6eUbiBvCJxT5UfESxGxEBG7ycf9k4iQvHsEIKV0Y0rpps3vyRfnknxqWURcAn5OKd1bfrQEfKfInjDEb/4hn471YEppR3keLZHP3ZdIKe0sX+8kT7pD/Bsgd3WlfL8CfDjQ/cillA4CLwLLEfHHAPl7xv64jKi7EXEmInZGxO7S3RH5Ap+XFPnwz0Jk0yFEvR1znDwJk1K6h3xB9N/E93EAOBcRI3HuReDR8v0i4o3Tse5eA7wCvNEjqzZH9e7tVZj/OvNVvW3kS3rbla/qbmPskt42HltJb6c8d3r3tpHfu7uNYy/pbWPdJ5lrh15X1vIVvW1kqzrblX9KNd82xt+7t43HVdXZ1vNG0dlavmS+bRz73r1tvJaSdHbo12q1fEVnG9mSzlbyn1Z1tjH+odfI1QHNzY18TZDz5B3Tl8XZ75DfMnWZ/AA/J8zeRz6F7DTwTbk9Icy/DzhV8s8y41Xot3hf+xF/Whb5ujjr5fbtAI/t/cBX5fgcB24R5+8AfgduHuiYv0r+D+0seaf5emH2Z+TNrnVgSZR5RZeA24CT5An3JHCrMPtQ+f5PYAP4WDz2H8jX+9rs7sxX66/kv18e29PAR+SLtUqyJ/7+Av0+Latr7EeBM2XsJ4Bd4vzrgGPl+KwBi8r88vM3gecHeM7vA74u3foc2CvOf4E8H54HXgNSj/zOOUrR20a2pLeNfElvG/mq3k5dH8za3cbYJb1t5Et62zo2ot7Wxt+7u41sSW+prPsUnZ2Sr+ptLb93bxvZqs5OXXPP2tkp4+/d20a2qrPVYyPqbG38kvm2kS+bb0vefv79RCVJZxv5sjVyJV+2Ru7IlnS2lj/x85k72xi/bI38f26p3LmZmZmZmZmZmc2heToty8zMzMzMzMzMJnhzx8zMzMzMzMxsjnlzx8zMzMzMzMxsjnlzx8zMzMzMzMxsjnlzx8zMzMzMzMxsjnlzx8zMzMzMzMxsjnlzx8zMzMzMzMxsjnlzx8zMzMzMzMxsjv0NVIkWHxC4lQYAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -1099,7 +1267,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1114,13 +1282,13 @@ "output_type": "stream", "text": [ "metacluster_0 pattern_1\n", - "total seqlets: 81\n", + "total seqlets: 109\n", "Task 0 hypothetical scores:\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1139,7 +1307,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1158,7 +1326,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1170,7 +1338,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1285,7 +1453,7 @@ "To be conservative, adjusted frac neg is 0.95\n", "For increasing = True , the minimum IR precision was 0.3469747405521833 occurring at 1.621246337890625e-05 implying a frac_neg of 0.5313343328335832\n", "To be conservative, adjusted frac neg is 0.95\n", - "For increasing = True , the minimum IR precision was 0.4006572406407763 occurring at 7.033348083496094e-06 implying a frac_neg of 0.6684943371454617\n", + "For increasing = True , the minimum IR precision was 0.40074974232407007 occurring at 6.67572021484375e-06 implying a frac_neg of 0.6687518898670086\n", "To be conservative, adjusted frac neg is 0.95\n", "For increasing = False , the minimum IR precision was 0.35928651361524633 occurring at -5.638343282043934e-06 implying a frac_neg of 0.5607600296390388\n", "To be conservative, adjusted frac neg is 0.95\n", @@ -1293,7 +1461,7 @@ "To be conservative, adjusted frac neg is 0.95\n", "For increasing = False , the minimum IR precision was 0.11749949829420027 occurring at -1.7642974853515625e-05 implying a frac_neg of 0.13314383172256963\n", "To be conservative, adjusted frac neg is 0.95\n", - "For increasing = False , the minimum IR precision was 0.41327328308403144 occurring at -4.0531158447265625e-06 implying a frac_neg of 0.7043709978920574\n", + "For increasing = False , the minimum IR precision was 0.2519079426947738 occurring at -3.814697265625e-06 implying a frac_neg of 0.3367338821938512\n", "To be conservative, adjusted frac neg is 0.95\n", "Loaded sliding window sizes: [ 5 9 13 17]\n", "For increasing = True , the minimum IR precision was 0.2954850349262155 occurring at 5.7220458984375e-06 implying a frac_neg of 0.41941626448668695\n", @@ -1302,7 +1470,7 @@ "To be conservative, adjusted frac neg is 0.95\n", "For increasing = True , the minimum IR precision was 0.3469747405521833 occurring at 1.621246337890625e-05 implying a frac_neg of 0.5313343328335832\n", "To be conservative, adjusted frac neg is 0.95\n", - "For increasing = True , the minimum IR precision was 0.4006572406407763 occurring at 7.033348083496094e-06 implying a frac_neg of 0.6684943371454617\n", + "For increasing = True , the minimum IR precision was 0.40074974232407007 occurring at 6.67572021484375e-06 implying a frac_neg of 0.6687518898670086\n", "To be conservative, adjusted frac neg is 0.95\n", "For increasing = False , the minimum IR precision was 0.35928651361524633 occurring at -5.638343282043934e-06 implying a frac_neg of 0.5607600296390388\n", "To be conservative, adjusted frac neg is 0.95\n", @@ -1310,7 +1478,7 @@ "To be conservative, adjusted frac neg is 0.95\n", "For increasing = False , the minimum IR precision was 0.11749949829420027 occurring at -1.7642974853515625e-05 implying a frac_neg of 0.13314383172256963\n", "To be conservative, adjusted frac neg is 0.95\n", - "For increasing = False , the minimum IR precision was 0.41327328308403144 occurring at -4.0531158447265625e-06 implying a frac_neg of 0.7043709978920574\n", + "For increasing = False , the minimum IR precision was 0.2519079426947738 occurring at -3.814697265625e-06 implying a frac_neg of 0.3367338821938512\n", "To be conservative, adjusted frac neg is 0.95\n" ] } @@ -1340,7 +1508,7 @@ }, { "cell_type": "code", - "execution_count": 80, + "execution_count": 12, "metadata": { "scrolled": false }, @@ -1350,7 +1518,7 @@ "output_type": "stream", "text": [ "Getting the exemplar motifs\n", - "Numseqles: 83\n" + "Numseqles: 142\n" ] }, { @@ -1358,13 +1526,13 @@ "output_type": "stream", "text": [ "[Parallel(n_jobs=10)]: Using backend LokyBackend with 10 concurrent workers.\n", - "[Parallel(n_jobs=10)]: Done 40 tasks | elapsed: 0.0s\n", - "[Parallel(n_jobs=10)]: Done 83 out of 83 | elapsed: 0.1s finished\n" + "[Parallel(n_jobs=10)]: Done 30 tasks | elapsed: 5.0s\n", + "[Parallel(n_jobs=10)]: Done 142 out of 142 | elapsed: 5.1s finished\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIEAAACMCAYAAADr57kMAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOyddXhUx/6H37OSjRM0eHH3AqV4oVjRUsWqaOXW2x+lt7T31uW2pUVaoLhTpLgWSnGCBoIFh6CBuO3u+f0xCcmyks1ahHmf5zwte86ZmRyZM/OZryiqqiKRSCQSiUQikUgkEolEIinaaPK7ARKJRCKRSCQSiUQikUgkEu8jRSCJRCKRSCQSiUQikUgkkvsAKQJJJBKJRCKRSCQSiUQikdwHSBFIIpFIJBKJRCKRSCQSieQ+QIpAEolEIpFIJBKJRCKRSCT3AVIEkkgkEolEIpFIJBKJRCK5D9DlV8WlSpVSq1Spkl/VSyQSiUQikUgkEolEIpEUOSIiIm6qqlra1r58E4GqVKnCvn378qt6iUQikUgkEolEIpFIJJIih6Io5+3tk+5gEolEIpFIJBKJRCKRSCT3AVIEkkgkEolEIpFIJBKJRCK5D5AikEQikUgkEolEIpFIJBLJfYAUgSQSiUQikUgkEolEIpFI7gOkCCSRSCQSiUQikUgkEolEch8gRSCJRCKRSCQSiUQikUgkkvsAKQJJJBKJRCKRSCQSiUQikdwHSBFIIpFIJBKJRCKRSCQSieQ+QIpAEolEIpFIJBKJRCKRSCT3AVIEkkgkEolEIpFIJBKJRCK5D8hVBFIU5XdFUa4rihJpZ7+iKMo4RVFOK4pyWFGUZp5vpkQikUgkEolEIpFIJBKJxB2csQSaDnR3sL8HUDNzGw5MdL9ZEolEIpFIJBKJRCKRSCQST5KrCKSq6t9ArIND+gIzVcEuIExRlHKeaqBEIpFIJBKJRCKRSCQSicR9dB4oowJwMce/L2X+FuOBsiUSK8yqmZ5zetKqYivGdhyb382xy487f2T5yeWsH7wevVaf380ptKiqSp95fXi44sN82P7D/G6OXb7f8T0rTq5g3eB1GHSG/G6OTS7EXaDn3J7Mf2I+9cvUz+/mFGo+3/o5q06vYsOQDQT5BeV3cwonabFw+wAkXYDEs5BwAhKjIfUamNJBNQEqKDrQ6MBQGoKrQWhtCK4KgQ9A8cYQUNbrTV1xYgUrTqzgtz6/eb0uV0lMhGPHIDIS9u+HffvgyhVIT4eMDNBowM8PgoOhfn146CFo2FD8f+XKoCi+a2t6OmzfDitXwoYNEB8PKSlgNkNgoGhj27bQty907Ch+8yVrTq1h5amVjH9svG8rLqIkJcG6dfD333D4MERHi98A/P2hShVo1Ahat4aePaF48XxtbsEm6SJcXgG3dkPcMUi+BOZ0UDSgLwYhtaB4Eyj7KJRpL/pOSaHi1i3Rj589K96VyEg4fRpiY8FoFJuigE4HAQGi/65bF+rUgWrVoEYN8f8aL0f+VVWVfvP70apiK0a3G+3dyvKIqsL583DgAFy8CJcuiWt58SJcuwapqWAyiW+OViu2wEAoX15cz2rVoEIFqFoVHnwQSpfO77/I8yiqquZ+kKJUAVaqqtrAxr5VwJeqqv6T+e9NwPuqqkbYOHY4wmWMypUrP3j+/Hm3Gu8TypYVT0tBRqMRT3FBJjwcrl71SFFvrn2Tn3b/BMCaQWvoXsORt2L+8M+Ff+gwrQNmzDzX6Dmm95uO4qkRdmF4Jj14v7/65ytGbxqNgsKuobtoWaGlR8r1JOtOr6PHnB6oqPSv05/FTy/23P32EEnpSTT9tSmnYk9RIaQCR0YdoXiAh0baheGZBI89lxP3TuSV1a8A0Lx8c7Y8v8VzQlBhuJauXsfU63D9b4hZD1c3QMoV0AaA2QimZCD38YhAEedp9GBKBb8SEN4JyncXk56gynlvWy48POVhdl/eTewHsYT5h3m8fFc5fx7mzIEpU8QgNyBADGyzJtiO0OvFoDcjQwyYH3sMhg2Dzp3F5MLTxMXB3LmwcCHs2iUEqaQk0V5bKAqEhIjBetOm8NRTMGiQeEW8zWNzHmNd9DrSPkpD58lJdFF+v+8hORkWLIBZs2DHDnG/ExIcnxMSAmlp0LgxPPccDBwIJUrYOfg+upYknoWzs+DcbCGaK9rMPtMeGtAFAWYo1wOqDoYKvYVQdC+F4TpCkZ7rpKYKUXz1avjzT7hwQfTlRqN4j5yYqgNgMIgt6zJ16ACPPw5dughhw9OM2z2ON9a+gUbRsH/4fhqXbez5SpwkPR22bBFC85YtQmw2GsV3Li1NbHklIED0WykpEBoqxKBHHhELEy1b+nbhxFUURYlQVbW5zX0eEIF+Bbaoqjov898ngI6qqjq0BGrevLm6b9++3Fuf3xSGO1xYcLYXc8DUA1P515p/kWpMxayaCdIHsWfYHuqVrueBBnqGs7fP0vTXpsSlxaFRNPjr/Pm046e82/pdz1RQWJ5JD9zvv8//TffZ3UkzpmHGTKnAUkS9GkWpwFIeaKBnOHT1EG1+b0NSRhJaRYu/zp+RzUfyXdfv8rtpd1FVlV7zerH57GZSjan4af14qMJDbH5+s2cmOIXlmQS3n8uJeyfyzvp3SDGmoFW06LV6GpZpyF/P/+UZIaiwXEtnr6MpDS4tg+M/wO2DoDGAMQHnBZ88oAsG1QhBVaHO21BjqEeKTclIIfSrUIxmI9P6TuOFJi94pFxXiY8XYsqkSXDihPgtNdX9chVFWOAoCjz7LAwfLga97mI2w++/w7vvCsEp2dHc1QH+/mIeOGYMvPOOmOx4i9LflOZmyk22v7Sd1pVae67govZ+2zl1+XLx/CQnOydI2iIgQIiR330HQ4fasGq4D64lxmQ48gmc/BlUs7D4cQVdsLCcfHg6lLxnPlhYrmNhIQ/3e9cu+OILYSXn7+9YFHeVoCBRZpkyog9+/XXPlHsg5gBtfm9zd3xeMaQiUa9FEewX7JkKnCA9HTZtghkzYMUK0V944xrmxM9PbAYD3LzpvXo8hSMRyBOGYn8Cz2VmCWsFxOUmAEkkrvD3+b95ffXrJGckoyA+WskZyXSe0ZkbSTfyuXWC+LR4Os3sREK6WO5SUEjOSObjvz5m9anV+dy6wkVMQgz95vcjxZhy16omPi2e/gv6YzJ7sYfPAxfjLtJpZieSMrJHuUkZSUzcN5EJeyfkY8ssGbtlLFvObSHVKGaK6aZ0ImIieHPtm/ncssLFrxG/3hWAskg1pnLk+hE6z+xMcoaLs9uiSOJZ2Pc6/FEadg8TrgvmNDDG4xUBCMCYKCyD4qNg/1seK3b1qdUYzUYAJkdM9li5ecVohIkToVIlMZg/dEiIP54QgEDMXRIShMg0dSq0bw+9erlX5o4dUK8evPmmsARyVQAC8XcmJ4tJU9WqwpXMA2sNVlyOv8zNFDG6X3NqjecrKMKcOiWsDwYPhhs3XBeAQKy+JyTA228Lt8XCsG7sMVQVLi6F5VXg5C+iX3NVAALRN8YfhY3tYecLkHbLUy2V5JH0dCHi16sHjz4q+rH0dNHvekO8SEoSfeeFCzDaQx5bCWkJ9J7X22J8fjPlJi8tf8kzFeRCTIzoF0qUEAsWCxeKb4O3rmFO0tOF6/WtIvAK5WoJpCjKPKAjUAq4BowF9ACqqk5SxN3/BZFBLBl4UVXVXLtqaQl0H+LGaC06NppmvzUjPi0eAK2ixaSKN12v0dOgTAN2vrwzX2OxGM1GOs/szO5Lu0kzpVm1M0gfxK6hu2hQxsqgLm8UlmfSjfttNBtpNaUVh64ewqgara7jm63e5LNOn3mqpS5xJ/UOTX9tysW4i3fblrOdAboAFj61kF613JxFuckfx/5gyNIhFsJFFoH6QH7u8TMvNXXzw11Ynklw+bn8LeI33lz7psV1zHm//XX+NAlvwqbnNxGodyOASWG5lvauY1osHP43nJkm3LzUjLyXrdGDoRQoenE9zBmQHismQnlhoGcUgh5zerD29Fq0ihatRsulty5ROsi3AQI2bRKWFdeuuTexzis6nbDeySvx8fDii7BmjZjMe4OgIGjWDObPF3EcPMWMgzN4YfkLADQo3YAjrxzxXOGF/f22Q0YGfPQR/PyzcLvwhtdOQAA8/bSoIySEInstSToPO4ZA7H4weeFl1xhA4wcP/gDVXy4817GwYOd+qyosXQojRghRJjHRx+3K0Q73zld5YuETrD61mjRTmsU4KFAfyC+P/cKLTV70QEutuXkTxo4VlqWq6pyLl0YDtWpBkybQvDm0aiVijvn7C2uerG9c1oLKtWvwzz8irt7Bg0I8s4c3FiE8jdvuYN5AikD3IS4+a3GpcTSa1IiLcRdRM1eQdRodJrPp7r8DdAH0rt2b+U/Mz7dYLCNXjmTW4VkW1gA5O0cFhdJBpTky6ghlgsq4XlFheSbd6FveWPMGUw5MuXstc15HEPd7yTNL8i0eVJoxjfbT23Pw6kHSTel32whYtDNQH8iW57fQokKLfGnnoauHaP17a4cWKgG6ADY+t9E9l4fC8kyCS8/l5P2TeWPNGxYCkL/WnxBDCDeTb97th/x1/jQt25RNz20iQB/gWvsKQ3wGW3EPVBXOz4O9o0RQZ7Mzgo0CxeqLOD7lukFITQgoB7oQYTWkZs4kFUVMXEwpkHoVEs+IuELX/xaBpVU7S38eEIES0hIo/W3pu4Ndf50/33X9jpHNR7pdtjPcuSNWOrdtc8+Kxh3y+srcvAnt2omgpq7EYcgLWi2UKiUsjqpV80yZ/eb3Y/mJ5WgVLRpFw433blDMv5hnCi8sfWUebnpaGvTuLSZO3hL8sjAYoGZN8T6EFS9615K447ChDWTE2e/XPIU2EGq/Dk2/9m499xs27ndMjIhntmdP3kR8jQZq1xZ9W7Vq4tkvXVq4I5lM4psQHQ1nzoj+NioKbt/Oc/PyxJT9U3hj7Rt2x+eB+kD2DdtH3dJ13avoHpYuFXHCMjJy/65UrSoE48GDhQCUlib+7qAg8c3IDaNR3CedTnTZBw/C9OmiDTldwKQI5CKFRgQqDAPyIhwszWg20nF6R/Ze2Xt3sg1QIbgCsamxFpOyIH0Q/9f2//io/UceaXJemLBnAu9tfM9isu2v9adiaEWib0ffnSTqNXrqla7HrqG78Nf5u1ZZERxE5mRp1FIGLRlkcW91ig69Vm/xW6ghlCOjjlC5mBei3TlAVVWeXPgka06vsWhPiF8Inap2Yu3ptXctwQDCDGFEjIigWnEPzVCc5EbSDRpMbMD1pOt3fzNoDVQrXo1zd85ZtD3MP4zDIw9TqVgl1yorDP0kuNQPTT0wlddXv25xvQL1gQx/cDgvN32ZhyY/RLIxx3uv86dZ2WZsfG6j60KQOzjbP3jy2282wq6X4OIS51auS7aAWq9DxccR2b+ygpjmgSz3CI0eYjbCiZ/g2mYsXM08IALNOTyHUatGkZCecHew27RsU/aP2O922blx9Ch07SoGnelueIK4S14elcuXoU0bkZXMFQsiV9BooFgxkTnHXVRVJezrMOLT4tEqWoL8gpjZbyZ96/R1v3Aoct/vlBTo1k24anlbAMrCz09kEztxsmhdS+4cgQ3thQDkLZfZe9EGwrPSjdmj3HO/V6+GAQPE++FMn1ihgnDD7d9f9KVmsxB8DAZhDXcvWcGjzWax/8IFEZNr9WrYutV6eujOp//YjWO0mNzCYq6jU3RoNJq7czQFharFqxI5KtIjY6C0NHjjDRFg3tFCiE4nFkzGjMnOdmnrerlKQoLoe/buhU8/hY0bC78I5OXkcUWAq1fFXXZ1cwZ3yldV0Tt4u43uttPF7AijVo3iwNUDFgJQgC6AhU8v5L3W71m4XSRlJPHFti9YdnyZS3W5ysbojby74V1LAUjnz0tNX2LJM0ssxJ4McwYnb51k8JLBuCzAhoe722Tv42IbT8eetnJdyrqW5ULKWRyblJ7EY3MeI83o5aXme3hvw3usjV5rJUD+8tgvTOs7zcoVKD49ng7TOnAr2XcOxOmmdHrM6cHtFMslIX+dPxuGbCDEL8Ti94S0BLrM6uJ6TBt3+0lf9ZV57IemHZhmJQBpFS01S9Tkm0e/oUGZBvzY/UeLe55qTGX/1f10mdWFlAwfzYryE2MS/NUVLv6RiwCkQJVB0CcaOm2GBwaAPhj0IXkXgAC0/qAPFVnCKvSE9kvh8StQ619CGPIQk/dPvhvjLYtjN45xOf6yx+qwxdatwmw9JiZvAlD58vDCC/DTT8I65tYtcb7JlD1ZOHUKFi0ScYXat/dcGuHoaBFI+vJl3wlAICY5d+54pqwj149YxJxLSEtg5cmVnim8iJGYKLLk7N3rOwEIxPN89qzv6vMJsRGwvi1k3MFnAhDkkmFM4i4LF8KTTwr32Nz6xDZthHBz6hR8/71YAAgKEq6PYWH2BQ2dTmSuCgvLtpR7801Ytkz0xW++mek+6SbJGcn0nNvTYpyooNCiQgsM2uxQHCoqMQkxjFo1yv06k+Ghh3IXgHr3hnPnYMIEqFNHZL30pAAE4hoaDNC2LSxZItzFCjtSBJIUWH7e/TNzj8y16HAMWgPP1H+G1pVaM6b9GKssUSnGFAYtGcSBmAM+aeOJmyfov7C/VbyVYL9gvu7yNQ3DGzKqxSgCdNm9UYoxhbWn1/Lfv//rWqW+ECbB56JfckYy3Wd3txIi9Bo9Xz36FVN6T7GYbJtUE2dun7mbqtsXTNgzgYn7JlqtgrSs0JIhjYZQPKA40/tNt2inWTVzLekaj8561CeigKqqDPtzGMduHCPDnD3qCNIHMa7HOCqEVmBq36lW1/J83HkGLB7gujhZxJh+YDqvrn7V6t0O1AeyYsAK9FohNAxtNpTu1bvjr80We1ONqeyP2U/XWV3vBuMukqTfgbUt4eZOx5OJ4k2g5xFoMQmCqwnxx5NptxWNEJMCykLjz6HPGZEy3k1iU2LZdWmX1e8aRcPCowvdLt8eq1aJdO2Jic512aGh8NJLwtUgOhrGjYPXXoOHHxaBM/V6IfRotWJgXKOGmJh89pnIqHLzpjinSRPX23zsGLRoIYIBG42ul+Mqnuq21p1edzcIOIgJjUzqYE1cnJgMHT7sucDkecGXIqPXubETNnbMDJovKSrMni0E+dwE0iZNhLvR2rXCqi4gQIg/7pAlDJUtC//9r1hMGD1afAtcZfiK4VxNtBzb++v8mdx7Mv995L8E6bMbnWJMYdGxRSyIXOByfaoKzzwjMmDaE4D8/OC332DePGFB5QmxyxlCQqBxY9/U5U2kCCQpkKw/vZ4PNn5gJQgE6AP4ofsPAPhp/ZjTf46V5UVyRjJdZnUhJsG7SepiU2LpPLMziemW0d0C9YFM6zPtbprEzx75jGIGy3gCSRlJfPXPVyw+ttirbSwsqKrKi8tf5HLC5buucyCEi68f/ZriAcV5pOojtH+gvUVK8xRjCvMj5zP78Gyvt3HFiRVWFl8gPoKzHp91NxZVn9p96Fq9K35av7vHZJgzOHHzBE8uehKz6l3XzXF7xrE4arGFeKGgUK90PYY0GgJAr1q9aFu5rcW1TDWmsunsJj7d+qlX21cYmHlwJq+sfsWmADSn/xwLtzlFUZjebzolA0taHJtiTCEiJqJoC0G7XoLEaMcBm6s+D122Q0hdIf54G30wBFaEDn+6XdSSqCUW70gWKcYUJu/3TpawqCgRy8CZ+D86nTCTv3QJfvxRiDD+/mKA6ox1j8EgJgrFi8PIkSLOyoYNQiTKC3FxIsvN7dsF3zM9N5YcX2LhzgsQmxrLhTgH0UHvM8xmsfIeFZU/AlCRIvGcsKQ05lOUYCgc1uWFjEWLRCB/RwKQTgdffgnbt4vsd8HBnrPKzElwsBCVPvxQuBi7wpwjc1h6fKnFWEav0fNkvSepX6Y+r7R4xSpuWnJGMi//+TLRsdEu1Tl2LGzebL+PMRiEtevAge6LZq7gjXvla4rAnyApahy/eZwnFj1hNQEL0gfxW6/fCPMPu/tb28pteaLuExamiABxaXFetbzIMGXQY04PbiTfsBAt9Bo9j1R5hF61szNCBegDmPn4TCuxKsWYwvPLnifiSoRX2liY+DXiV1aeXGk1WQ4PDmf4g8Pv/nvCYxPQ3+PqkZyRzIiVIzh63cWvmxPsvbyXZ/941uYz+WP3H6kQWsHi9ym9p1hYf4G431vObeH11a97rZ2bz25m9MbRNoWqmY/PtAiaPqX3FAuhCoQ4+e32b1l+fLnX2ljQmXVoFiNXjbS61wG6AF5q8hK9a/e2OifEEMKqgats3vN9V/bRbVa3oicEnZ0LMetEAGd7NPgYWowHXaDvR0yuuJjdw+T9k0nKsO3idvbOWc7e9qxPSny8WAl2xrWmc2dh9fPZZ0L0cXcFVK8Xk4WOHUXq+XHjhEl9bqiqiMPgiXg8+U2qMdWmFbFW0bIhekM+tKhg8vXXwhUiP+NUFQnMGbC1jwh4n58UFnfuQsL16/Dyy477cT8/Yfnz+uuin/XF5zE4GKpXz/t5p26dYsSKEVbjSp1GxzddvgFAr9Uz/rHxFtZAIMZAveb1ynPYhlu34JtvHC+GzJwJdevmjwBUVJAikKRAcSv5Fp1mdLKyrtEqWlpWaMmT9Z60Ouen7j9ZTb6MZiNnbp/h6cVPe9zyQlVVXv7zZY5cO2IRqwiEddLk3tYrxF2qd6F7je5Wk+7kjGS6zu7q9fgSBZmIKxG8ve5tqw9MoD6QqX2motVkh/KvWrwqr7V8zXqynZFC99ndiU/zvDn1mdtn6Dqrq1X7tIqWpuWa2kyvXjKwJFP7TLVppTb90HS+3/m9x9sZHRtNv/n9bIoXr7d8nTql6lj8XqlYJT7p8InVRzvZmMzAJQM5cs2DaZELCaM3jualP1+yuoYKCqGGUCqEVuDb7d/a3NZHr6dbjW5WImWKMYUdl3bQcGJD4lOLiLl/6nXYO8KxC9gDA6De+x4RY/KD60nXOXT1kMNj5kfO91h9WWLK9eu5z3fGjhWBPytXFgN7T6LTiUnJ0KFCDKpSxfHxP/8sLIhczQIWHCysSj7+GH74QcQy+uQT4QZQooRrZbrKjos7MOgMVr8nZSSx9PhS3zamgLJ7t3AvyUuGo3vR68XkrWVLEe+jfn3nBMcix8H/E5aU7mQB8ysBYY2g1MNQojmE1AAKScDsIsqIEY77Q39/WL9euOv6WsDIq9iUZkyj17xe1l4ZugDebf0uZYPL3v2tb+2+1CpZCyXH82dWzZy/c5631r2Vp3qnTXPc1o4dhcv0fdlveBCZHczbOJMJIr8V7vzIJmODdFM6rae25vC1wxaxTEAIAlGvRtnNBLUgcgEv//my1aptkD6I11u+zpePfumxdn67/Vs+2fqJVacYpA/imy7f8EoL2zFqbiTdoPq46lZBRnUaHTVK1CBieISVaOAVCsj9BuFSV298Pa4lWWaW0ipaulbvyupB1rEYEtMTqfxDZW6nWgc97lS1EysHrLSweHGHW8m3aDKpCVcSr1iJiUH6II69esxhdrKec3uyMXoj6WZLsTBAJ6zDbImarhCfFk+jiY24EHfBwjINIDwonLNvnLWZpcFoNlLnlzpE37Y21w0PCifylUiruFteI5/7yldWvcLEfRPt7tcpOqfG1iazyeoeZBFmCOP8m+cJ9Q91tZm544v3+/hPcGi0/RXswErQ86iI01NIGb9nPO9vfN+in783FW614tWI/pdrpu738ssv8MEHjlc+tVqYMQP69vW8+GMLo1FYJ9kTY6KjoVGjvKeuDwgQ7meDBkGDBsLcP6cLm6qKTCwGg6hj0SIhDnk79fE769/hx10/3u3rc97vYL9g4v4vDo3i5tppIc4Olpoq0i1fvJj34sqVg549hbjXpo2I6ZPlOqjRiHsdEQHz54uYWGfOONHEwiJ22Howb+6BTR1dswIq3gwq9IIHnobgGpnuuJl1KDrADFfWiGD9MesgI5fFBw9kUfTJ97sQZCFdH/Y0j6cvcNgnTpkisoUVBgFj+IrhzD4822phrLh/cS69fclqzrL38l46TO9g7UqvC2Tek/PoU7uPU/VWq+Y4+PuyZWLxoCi4ZHkbmSI+P5EikFOYzWYemfkIOy/utBKADFoD/ev2p1etXnbOFtY5n237jBM3T1hNwPw0fnzc4WPGtB/jdjt/2f0Lb69/26qNAJVDK/N5588dDhK3nNvCzEMzrWIO6DV6GpZpyO5hu23GoPAoBeB+g1gh6DyzMzsu7rCyqArQBXDs1WNUCati89xZh2YxatUoK9EvUB/Ipx0/5d3W77rdvtjkWCr9WMluxiytorWwUrKFqqo2n5UsJvWcxIjmI9xqp8lsotOMTuy6tMum2DS7/2y6VOti9/zdl3fTe25vUu+J66JX9DQIb8Cul3fhp/Ozc7YHyce+8tXVrzJh7wSvlH0vYf5hnH/Di0KQL97vVQ0hLtL+/ha/QvUXPZqly9c0mdSEQ9eyLYG0injXc4pAAboA9o/Yb2Vll1dSU8UkObcMV7/+KoQTX64em822B9pms7DkOHhQZB5zlqeegvHjxQTI2b8jNVW4Ho0eDZMm2Y875G73UPPnmpyOPX333/eKQFue38KD5R90r5JCMJElPNxmcocPPhBiZV5Ev+Bg4bI4fLh4TnITL7PKXr5cxLu6ccP+sYVWBDKlw8o6kJRHd9LQutBqGhSrL/pWrbXVmgUZcYBGCPanJoI9q/jCIgK5iw/a2LmziGNjj9atRdy1wiAALY1ayuClg20ueI/rMc6mFTzA4wseZ+WJlRhVywwBIX4hRL4S6XDhNIuAAMfxxq5fh9Klc/8bJFIEyl+KSscIXm1nt1ndWH9mvc19CgpBfrmPFlVVtRu/AWBy78kMbTbU5Tb+cewPnlxk33IjUB/o1CphckayXRe1FuVbsGfYHpfb6BQF4H4DvLPuHSbsm2AVK8WgNTCk0RDea/Oe3XPNqpk+8/pwKvaU1T6D1sDyZ5fTrUY3l9tmNBsp/315biQ7GIF6iLWD1rrV1ha/tWBfjO2+VEFxSlQ0qSa7z2SN4jU49S/r6+xx8qmvfGvdW/y460ePl+uI4v7FufxV7y4AACAASURBVPL2Ffz1/rkfnFe8/X4nX4Y/q9uPBaRo4Ilb4Bdme38h4FL8JWqMq2Eh1ocaQvHT+nEz+ebd3/y0frzf+n3+28nFTI+ZjB8vJtiOXGwGDhRZUApK/IM5c4Tbg7NuQVWrwoIFwg3IVSumxEShTTz9NBywkQDUne7hZvJNKvyvgsWCRE4RyE/rx9gOY/mw3YeuV+IJ8un7fewYNG+et1TwTz8NEycK95e8TnrT0oS10IcfirTPtoTGQisCHfkvHPvK+fTsumBo9BnUGAYaA+Sy+GRFRiKkXIFdL4hMjvciRaBs3GhjcrKwmnTkCnbkiLB+LOicv3OeBhMbWIXmAKhevDonXjthdxH03J1z1Btfz8oaSKtoaRjekL3D9uY6Ls1NBLpxA0r5yEi9sCNFoPykqHSM4LV2frjxQ77c7jl3LXsoKGx/aTsPV3o4z+cevX6UhhMb2nXz8CTDmg3jt96/ea+CAiACfbXtK0ZvHm13f7BfsIVfsS1MqsmulY6CwuGRh2kQ7trXtsGEBhy94b1A0znRKBoOjzxM/TL183zuqJWjmBQxyQutsuTJuk+y6OlF3q0kH/rKBUcXMGTJELvWWkH6INpUboPGhfB55+LOcerWKQvLkSy0ipaOVTqyetBqqzhhbuPt9/vaFvi7X+Yqsw2KNYCu20HvRZc3L/Ptjm/5+K+PLQRqg9bAgAYDmH5ousWxFUIqcPGtiy67oGZkQPnyIk27PerWhb17C44AZDYLc/3z5507vn592LoVihUTMYfcJTERevUSZebEne5hQeQChq0YZuGufa/7X/Nyzdk7fK/rlXiCfPp+P/mkcMFwxupLUeD338U57rotJiaKZ79HD+vJdaEUgYxJsKSs89nAAspB151gKC0C7LuDMQkOvA+n7rF6lSJQNm60ccUKGDxYuNDaomJFOHlSCBwFmeT0ZKr+VJXrydet9ukUHb1q9bLIkGqLv8//TeT1SKvxj07R0aV6F5uhHnJStSqcO2d//4oVIiaQdAfLHUcikJf9TiQSxyw8utAnAhCAikr76e05/8Z5yoeWd/q8O6l3aD65uU8EIBAZaZqVa8bI5iN9Up+v2Xt5r0MBCLC5+pAXVFRaTW3Fzfdv4q/Lm7XFkwuf9JkABMKq6cHfHuTmezcJNjg/Yp5xcIZPBCCAxVGL+d/O//H2w2/7pD5fsPDoQl5c9qJDAejwqMNUK17NpfJVVeWxOY/x17m/rNw/TaqJHRd30GtuL1YOXOl5IcibGHNZvdaH2Hc7yCtLykKqq64zGhjoWsDVqfunWlkoNi3XlF61erHk+BKLAPR3Uu9w+NphGpdt7FJdc+fmnmb7p5+ENUVBYeVKkb3FGVq0EO4Pzqatd4bgYBE35plnxH89wfITy63i9SmKQs7P/uHrh0nOSPZN7L4CxIUL4jo7IwBptTBvnpigeUK0DA4WwaM3b4YuXe5xRQsPLxyudTk5PcV5oSGwMnTbCX6lQesB11pdEDT9BrQBcNzzySnudzZtErHM7NGrl31X1oJEm9/b2BSAAIyqkWUnlrlctlE1sub0Gr7Y9oVDq8pRo0SCAHuWhz/8IIJD+yI2XlFGikCSfONq4lUG/DHA7v4sN7DcLELuxZGFiNFspOWUlpx/83yu8VxATOQenvKww/TOgfrAu/Ei8kJieqJdYemVVa/QtXpXlyegBZXE9ETaT2/vk7qSMpJo+3tb9g133uJw8bHFrDixwu7+kgEl6VenX56fSYCTsSfZcWGHlZ80iOey34J+rB281in3rYNXD/Li8hfz3AZ3eGf9OzxY7kE6VOng03q9waJji3hh2QtW5spZBOoDmd5vulvvn6IozHtyHnV+qWMV+BxE1rB/LvxDn3l9+HPAn4VHCMot21dGHLjQH9rEZQEIwLXRdnRsNOfjLE1c/LR+9K3dl45VOlp9C9JMacw6PMstESjRgebdoIEIpKv10CV1F1UVsXkctTmLVq2EAOSNgXpQECxcKFbel7qZuEtVVdZHW7qjB+gCrGLV+ev82XZ+m1vuu4WRb75xbvKq08GSJdCpk2et1gIDoWlTkYWuY8ccE20bcYvyhK+tV8xGOPo5mJzwoQyuDl13iOxfnowTqQuCRp+K/0b+x3PlSrhxw/HjUqdOwbHmtMd/tvyHg9cOer2eMZvH0KtWLxqFN7K5/6WXRMZIe2zeLDKsde9eOOIrFVSkCCTJF1IyUugyqwuKavsj7Kf1482H3qRZuWYulT9l/xS2nt9qc5X/Vsot3lr3FuN6jMu1nE+3fsq5uHM292kVLS3Kt+DNVm+61MbjN4/z+bbP7VoiPDrzUQ6OPEioofC6VdxLy8ktHQpqniYiJoIxm8bweefPcz12x8UdPLf0OavgylkE6ALY+fJOapas6VJbVFWl44yO7Li4A6PZUggyqSZ2XtrJ8BXDmdpnqkPXklRjKs8uftaugKigUK90PafiaN1LSkYKkdcj7ZY9aMkgol6NIsRQeLM+/XHsD55f+rxdAShAF8CABgM8krktzD+MFQNW2MyWAUII2nZ+G33m9WHFgBXoPbHa621Ca2dmo7FDXBQ4CIZe0Jl7ZC73uskbtAYerfYoJQNLUjGkImfuZKcuMpqNzDw0k2+7fJtnlzBVhV27HB/zn/+AXwHSB7dscc4NrFQpYTHkzZXawECYOVPEqjlxwvVyTsWesno/dRodZYLKWAiCiemJrDq16r4SgW7fFq5d6bY/ixb8+qvnBaAsAgKgXj34809RR357FrnEhUXOZQPTh0KXbeBXMu/xf5xBFwT13oPkS3Dmd8+Xf59itF7fs8ATrrDeZH/MfsZuHeuz+lpPbU3s+7E2E4+UKgVvvQXjxtkPRD9okPh+1qwphSBXKeCPpKQooqoqA/4YwOnY05iwti/Wa/R0rdaVr7t87XIdj9V8jGrjqlkE8cwi1ZjK1ANTaVimIcMeHGa3jIVHF/LN9m/sihZBfkGsGLjCrRTaZ26fYcHRBVbuIioqVxKu0G9+PzYM2eCU1VJBZ17kPE7csj9SN2gNLokLqqoSmxJrV7j4dse3vNzsZYdWHSdvnaTHnB4OLUM+bv+xywIQCMuQOf3nUOeXOlYiEIiA4QuOLqBa8Wp81P4jm2WoqsqQJUO4EHfB5n6D1sCghoOY2neqy+18b8N7jN8z3ua1uJl8k/4L+7Nu8Dr3UyXnA0uiljBk6RC791lBoVJoJX557BeP1dmiQgv+88h/+GTLJzYD1ycbk9l2YRt95/dl+bPLC74QFFBWZKe5vd/OASqcmws1hkNhsW7Kwe8Hf7fqj41mI03LNgXEt2XCvgkWgdRTjCnsubyHhyo+lKe6oqMdTxw0GujWrWBNHj780Llg0H/84RtT/YAA4apUr57rZayPXm8l/KUaU+lYpSMzDs24+5tZNbPi5AqnFpCKCr842RX27y/c87xp6eDvLwS/994T1kmFClWFwx87Fwvo4VmgD/OOAJSFLhiaj7MdKFriEiVKON5//rxw/S1Irr1ZmMwm2k/zjZV+FkkZSXSb3Y2/XvjL5v7PPxfZJ7dsse0ynZoqrE0nThRZJwu6lVVBpAANLST3C//+699sOLPBrrhi0BmY3GeyW3WEGEL4vc/vPPvHszZdw5Izknlj7RvUKlnLpntLxJUIXlz+ot3JYlaKRHcEIIAfu//Inyf+tJp0gHAz2H15N/9a8y/G9xzvVj35TdSNKIb+OdRuBqpAfSDR/4qmbHBZl8pfdnwZg5cMtjnJNqkmeszpwcERBwnQW0fku550nQ7TO5CQZtuZW0GhWlg1j6Sdrxhakf91+x9vr3vbtiCQkcwX276galhVBjUaZLX/y3++ZPXp1XafS3+dP993c8/X/9OOnzLr0CybdaSZ0thxcQcfbPyAb7t861Y9vmZp1FKeXfysXcs7EM/hyoEr8xxHSlVFMMi0NBE3IyuttlYrVqjebvUO606v4+8Lf1u5mIC475vPbqbf/H4se3ZZwReCagyF/e/az25z9DOoOqTQiUBHrx/lepJ1LIRWFVvdFeK71+jOzMMzLeICpWSkMOPQjDyLQNu3O46TU79+7qvLviQyEg4fzv24oUOhWTMw5JLB2hNotSLr+mefuV7GkqglVv1dteLVaFe5HYuPLbboq2MSYriWeI3w4PB7iylypKbC99/nnhGsdGmYNs03k7DgYBg7VliZFSquboTUmNyPe+AZCO8EOh9ED9b4Q7s/vF/PfUKrVjB7tn1X2TVrHLs45Scf//WxzXkIiOQlNUvUpE6pOi6VveXcFuLSbCeS2H5xO3+f/5v2D1gLUBoNLF4sYoKdOWO7H0pNhRdfFIGix48XfVCIDwzVExJE4OqGDb1flzeRIpDEp8yPnM//dv7PobjyzaPfuCwG5KR37d50eKADG89stDnxSzGm0Gd+HyKGR1CjRI27v1+Ov0zX2V3txhXSKBoalmnIc42ec7uNxQOKM6nXJF7+82W7osD0Q9NpFN6IEc1HuF1ffpCYnkj3Od1JybBvZTOm3Ri37nnf2n1pWKYhuy/vtrIIMqtmLsZdZNiKYczuP9tiX1J6Eo/MeISbyTftWhL56/xZ8NQCj1ljDWs2jOkHp7Pn8h6bmaNSjCkMWzGMCqEV6Fil493fV51cxWd/f+bw3Rnfczxh/u6l5g7UB/J73995atFTdgXU8XvG07RsUwY2HOhWXb5k2YllBOntz1I0ioaJvSbatPaKi4Pjx8UWGSlWp65dg9hYIf4kJYnJqFYrwkwoihCGVFVM4lVVIajUAtRn26ENuoKiyT5eqxWDHQXhvpiQnkCJgFyWFPObys/AwdHYMOQUpF6Dnc9Bm7m5xxByhH+4m3GB8sbsw7PJMFl+K/y1/vSp3efuv9s90M5qAcOkmpgXOY+fe/ycp34iIsJxbJ22bQtOLCAQ2aFyE6WKFxdBO30ZsDMoCF591bVzM0wZ7LxkbQ3RplIbmpdvbmXx6Kf1Y+OZjTZF+qLGhg3OuV1NmeIbwS8LgwHmz/ddfR7h1ESRncsRhpLQYhLoffTyaLQQ6DjLk8R5evaE4cPt74+MFGOFghbM+K+zf/HDrh9sWqiDcGvfP2K/ywHx917ea9clPsOcweMLHufEaydsLqoHBcG+faJ/nz/fvmvYkiVCCBo0CD76CMqVE+MqT1pdJSYKq9xDh0TQ6rVrC6lbag6kCCTxGXsu7+Gl5S85dMWoUaKGR8WOKX2mUOvnWnZX/xPTE+k0oxOHRx0mzD+M5IxkHp31KHGpdtIfI1xuZvWf5XJK4Ht5uv7TTNg3wWasGBCT7rfWvUWtkrV4pOojHqnTV6iqyuAlg7meeN2uyBJqCOWdh99xqx5FUZjcZzItJ7e0G3tl6fGlTNk/haHNhgLCxaPv/L6cuX3G7scvUB/I/7X5P+qVdsPXwEZb5z4xl/oT6tsVGlOMKfSe15tdL++ifpn6RN2I4pnFz9h9d7KEyYENPCPKPFbzMTo80IENZzbYvDYpxhSG/TmM2iVr82D5Bz1Sp7eZ0W9G7gchPupnzggT5FWrRBrqhAThdmI2i0GcrQ+/2SzSfdsj/loJ+Ck765xZA1lhm5JShDVDly5QwkfpY7/+Ottayc8PSpYUK/pZW6lSDmLRGErAwzNg+0D71kCX/4SDH0KTL11Pbdw/l8Cvcz2XIlpVVWYcmmH1rdBpdXSu2vnuv0MNoVQvXp2om1EWx5nMJv658E+eAqffueN4f/XqBcvEff783GPDvPVW/ghXeheN5/Zc3oNeoyeVbGEvSB9E28ptqVe6npXgl5CewPITy+8LEWjJEsfZjkC4Z3Xu7FsRSKuFKlV8V5/bqGZhCZQb9T8ErY99hXwlON0HlCoFdesKkcAe774r3JcKihB0Pek6Tyx8wuHi4nddv3MrI2KLCi3oVqMbK0+stJkYJSEtgacXPc3G5zbaDDPg7w9Tp0LXrvDyy2KcZes7lJEB06eLrVYt4Z46aJBIN5/lThYc7FyWSpNJiD5arRB+jhwR1o5LlhT8hIR5QbnXD9pXNG/eXN23z/msPYUWX2cfcAVnxQw32nkx7iKNJzXmduptu8cE6ALYO2wv9cvUd7keW4zfM54PNn5g09IGxMpe8/LN+ev5v+g3vx9/nfvLrqtaoD6Q91u/z9iOng2edu7OOYeiAECIXwj7hu+jVsla7lXmg/udxU+7fuLDzR/a/buC9EHM6T+HvnX6ul0XwPAVw5l5aKZds9ZAXSDbX95Ok7JNGLlyJJP3T7brogZQu2RtIl+JdCpjl6oKi5Hr10WWiOvXxYfHaBQCQZbVR3AwlCkDa279zLcH/o9kBym3SwWWYudLO+kwvQMxiTF2hbQAXQAHRx50/9nIwaX4S9T+pbbDZ7JkQEmOjDpCuZBy7leYj32lqsLeveIjv2iRMDtWFOdin+TEz09sOp0YkKSl5d2dx5U/MTZWtP/oUXhpTFnCcrGeuUo4lXRCYNFoxKbXi/+qanbbswa1LVpA48Ziq18/xyBqx3Mi2KnZQaDoiv2g9WzQGDyb5QZyF4EGOn8x98fsp/209lbfiRC/EO783x2LwekHGz7g+53fW1jyaRQNzzV6jmn9pjld55NPitg59pg4EUaOdLo4r3LzJlSo4FgECg6GK1d8Y47vKT7a/BFfb//aQuwO9gtmx0s7aBjekHrj61kJfmH+YcS+H+uxhaA84aPvt6qK79RN67CKFqxYAT16FCyLNafx1Tfn5h7Y/CgYHShq+lB4/Ip7lpP5SVGZ67jZxt9+g7ffdjx2+Ocf4eKU37HezKqZjtM7suvSLrsL5TVK1OD4q8fdtoQ/d+cc9cbXcyg2/bvDv/mgzQcOy7l2TbjUzZwpxtXOBKzX6URmtiZNxFimVSsICxPikp+fGPukp4sxT2qqqGP7dmGpe/AgnD1r/7HI70faGRRFiVBVtbmtfdISSOJ1kjOS6TyzM3dS7S97BugCeL3l6x4XgABGtRjFrxG/2s16lG5KZ8/lPTT/rTlRN6PsWoUAhAeFM7rdaI+3sUpYFcZ2GMunWz+1O+lOTE+k84zOHHnliNsuP75g16VdjN402qHlV+PwxhauFu7y1aNfMS9ynl0RKNmYTI85PYh6NYoGZRrQr3Y/u2VpNVr+88h/rASg9HSIihIrA/v3i+wEJ0+KVf0sqwqtNtsdKOdHIstVSFHAaHqVlNYXUEqcwc8PQkNFYMGwMPH/wUHgp9MzZOkQbqbYd1cL1AXyRqs3PCoAgYhf9J+O/2HslrF2BdT4tHi6zu7K3mF78xxHpyCQng6TJ8N33wnhLjVVrADZw2AQmSjq1BHiyIMPClGkYkUxoDCZxKaq2eKKoggT5nPnhDl4RES2a9nZs47rc9TuHTtEjIFly0TZ/v6i/e+kO5k2+Z5uzlbgxevXxfb339kWKYoiXOAAaDEB4o9DXKT9rDeXlsGapsJyqFjDArvyPPPQTNKM1v1G28ptrVYnu1bvyqSISRZxgcyqmcVRi/mt929Ox3QKyMXqy57pe36wZo3o2xwNukeOdG6VtSCx7Pgyq29+uimduqXrAuL+3ysCZZgyOHbjmFfGKwWF48dzf/6qVxdWQIVSAPIll1c6zqgIUKOAqL0St3j5ZRFMPTLSvkDwzDOwZ4+wuHXVgtETfPnPl+yP2W9XAArUBzKp5ySPhEKoElaFEc1HMGnfJJuL7EkZSXy65VMeqfIILSu0tFtOeLjIQvjvfwtr5t9/FyJPfLzdUzAaxf2IjBQxmyTZSEsgb1NU1HFwuZ3ppnQeGxFMgmLfV6J8Asz7A/y9FAQzqhSM7AWpjmRPFRGYww46M4xbAw86EdvPFYwaeO5xiC5u/xiDCVavL03wJevgpU7jg5XEG0k3qDu+LrdSbtk9JkAXwL7h+zzqagXw8+6fGb1ptF3hwqA10K5yO9YNcT7D1enTYhK0YIGwuDAYxOWx5xrkKhqNWE3PEgZqPDmdQ1VfJNQQimLj4VRRCdYHE/1GtFdEGKPZSL3x9biaeNXutYpPi+fbrt+67dLny75SVYV48uqr2TF97FG7Njz7LAwZApUrZ0+MgoJcW8lLTxeWRln+6keOiIHMkiUQE+P4T9y3TwwwFy0SdSclOS8iZbl8GQxi8/MT56aliS0pSaSDdgaLNprS4J9n4OoG+65hWZTvCY3+K9LMKzr3A0d7yBLIrJop820Zq/4qUB/I912/Z2RzywlaSkYKYV+FkW62VERC/EJY9NQip1OIv/oqTJhgf/9bb8EXXxSMbDK9egn3SHvodGIFNbcMOQWJuNQ4ynxXxipYe/3S9Yl8JRKA6Qen8/qa10lMzw7e5K/z54tOX/DWw2/5tL2AzyyBvvtOTLRsicNZTJ0Kgwc7cBst6Pjqm7OyHsRH2d+v8YP+MeBXiF6eeykqcx0PtPHIEWHp4yigevnyYgExPDx/3p8dF3fw6MxHHS7Stn+gPVte2OKxOuNS46j0QyUS0u1bxIUHhXP8teNOL3SnpcH69cIFbM0aIaolJgorIW+h14tvslbr/JgpP3FkCSRFIG/jTKeTcl34DCtaEahNGwhaHzpY+2JQkR9m00UZX9wLF+swmU20n96ePZf32LWqMmgNPN/keX7t9Wuey88yAc3aVDXbDcfPD1TFSM2fa3Luzjm7Zfjr/Pmo3UeMaT/G7jGXLwsrkd9+y47dkVuWFI9jiGd9gwfgtn0ruvo3hIjqLa4HwaFcEuE0M5am5Hk3hElwsq+8Aahi0Hx3y9sq1e3b0Lu3MPO1J/5oNMKXfMwYqFTJ8wEG7yUrsPS+fSIY8L2sXAmjR4tYRVkZyOyh0wlrpfr1oVEjaNlS/H94ePb7YjZnv95ZFks6ndh/+rSwVoqIEO5lR48Kd7OcWHUNqhki3oToqbkLQQAhtaDmK1BlAOhCQM0Q7hB5ISMRFuXid+SkCLTj4g66ze5mMdEHIQIdHHHQZrDwZr8248DVAxa/KSg8Vf8pFjy5wKl6J04UMSLsWVw89BCsWwfFijlVnNfIyBBtcNT/PfIILF2a/23NC8uPL2fI0iFWk5LhDw6/+22KvB5J66mtrY5pW7kt217c5rO23sVHIlCLFqI/skdoKFy9mrs1W4HGF6JA6g1YVhHMDkzoqgyEFhPz3gcWJKQIZMGYMfDjj46t6cLDhTtw48a+iRGU5fKUoYulzi91uJF8w+6x3lqkHbd7HB9u+tDhIm2nqp1YNXBVnt1t09Jg40Zhubxli7D8ATG2SktzznXMqj2Zi2bp6aKva9oUOnWCDh2gdevCYfkq3cHyA7MREqOhdBjccBD9sRiwrLKwQFFVQBXnavTig+BXHAylIagylGgOxeqJLbCS74WViLczRaqAzPgOejEJ8ysOwdUguCoElAcnrSskRZPE9ETOxJ4hwEGK01KBpfiy85dWvxuNcOGCmOxGRws3q8hIMTGNiREdec74OlkdsNksNqMRFEWHrvp0NE/1R9Fm3J3k5txApK20JQIdOCAi/69fL/7taCU0izJlxIS7YUPhb9y4sYiLoddnu4cZjdkB7W7dEgPsvXvFqtGRI3bMWdNC6RKRS/RYL1MmCbqcye0o+4MJh5iNkHwBEs9AqVC46cCmtxiwLCuTiVkID6oRUEQ/5F9W9EPF6kGxupl9UnUIeuCuqH75MrRrJ/5rb0DQurWIDVSunO9im2S5Wt0rAJ07J8zLd+92bK0UFAR9+wp3nIceEs+sqlpbK+Vmem4wiEFO06YwcGD2wOfOHZgxQ2zHjtk4UdFA83FQrhvsehGMifbdwwASTsL+N8UWWBHKtIfwzuK+BVYS3zxFI+5xVvkAaTch+ZI4/+pmx39MHphxcIZNN1x/rb9F5sic9K7Vm8jrkRam9CoqK0+sJM2YhkGX+0JO27aOB5H79xcMK6CDB3O3env88YIVxNoZVpxcYSXuBPsF06ZSm7v/rlOqjk334r2X95JuSsfPXWu2AkhiIhw+7PiYRx/N7h8kDohZL8bLjkSgBwYUbgFIYsVnn4nFk5kz7QtB166J8ciwYcLyTqPxTh9qMgkB/59/YOgwlfpfDLCbsh1EnNSn6j/lcQEIYFTzUXy9/Wu7IlCaKY2/z//N+L3jea3la3kq22AQGdp69gTMRtS4KKIPnOLA7ttcvGjiwuVAzsaU5uKNMlyLK0NahgGTWYdZ1aDVmNBqjAT6JVOu+HUqlb5OtQo3qFg+nSpV9TRvU4pydeqJcWURMmqQlkCewpgE17fBlTVwZTUknRNR/hUNGJMzJytuovETZZozxOA4tA5U7AuNPs1bOUkX4MZ2uH0A4o7C4+vgTi4+BcUAC7N1RVguKRrRLkUrPnLmjEzR6gEIrQvFG0LJh6BMGzsFS1yiAFsC5YVbt8SH6a+/xIr36dOiI88KrOupmBj+/qLcrI9h5cpiEPvbb9nHxMcL94v588Uk2pE5abVq8OKL0L27yELg5yfO8ffP26QtKUn8nYGBov5jx4Rb0Jw52QE5VUc+igUJZ56XtFtw4x+49hfErIOE09kBg80ZzlmROIPGXwg/qkmIEYGVSS/ZjRoDJxITYz9Y88CB4pkoCJPZX38Vz2NGhv32VqoEY8fCgAHimFAvziPS00Vbzp+Heo7GhsYkOPoVHP9efKfMtuNz5Yo2UCw0oAhLodzSK9vCCUsgk9lEyW9K2hwUP1H3CRY/vdjmef9c+Ieec3taxAUC4RI26/FZTgW7N5vFCrAjC5utW3MXi7zN3LlCYHSUKerSJRE4ujBR/vvyxCRa+ncH+wWze+huiwlQwwkNibwRaXFcqCGUP5/9M0/Z4DyCD77f27YJa8k4+/NE5swRbrKFYSXcLr6wDNkzAk7/Zn+/ooWn4gpvQOgspCWQzaLefBOmTMl9LBsWJsSg994TY0hPLEBlLQZt2ABffinczwiIxe/DclYusDkpZijGiddOEB5swwTcnAEJ0SIWYHwUb9tjDwAAIABJREFUxEVBSgyk3YD0WMiIy5zzmhExNlRAI+aKWn/QF2NVso4+p8/jyGOrWdlmRIyIcP6PNaXD9a0iUcX1rZB4NjPTnioWpdxCA7rgzHm8GULqQLkuUPkpKNnCzbK9j7QE8hZpsXB+njCBj4sUFjLGxOzVS7cfvHswp1uuJtw5BHHHcheBki+LdL2XV8HNnWJSpOgy26fCeFcao4oXQsV6hSM1Rmy3dsF5g29d2+4HwnPxzSngXLggJhXTpmUHtM3pw+som5Kfn5hoZMU08fMT3/Wc7mFXrlhPqlJTLS16zp7NdvUCWL0anntOiDL2LH90OnjqKXj/fREnRqOxTIvryop9TrGhVClo314EG/7qKzEQ//JL4K+8l1ugSLoA5+bCmWlCHNf4Z/Y9mTfcZAR7GrTGDwIqiD4ky/1LUcQHP6s/TLlibXViTrXMWJV0lt+WaoiNtf98PfRQwRGAfvwRPvzQvjig04nB4pgx2dZm3ibrfXMoAIGYzDT+L9R6FU5NhFMTRNwgR5lxbGFKtv9ceJCt57fazBAY7BdM71q97Z7XskJLm4GkE9ITmHpgqlMikEYDzZqJTCT2+Phj4Q6YnymFT550bIlWvToUdxDLriBy/s55m9lKM0wZ1C5Z2+K3tpXbWolAyenJrDm9xvcikA84fTr3rIY9ehRyAchX3Il0vL/kQ2KxQlLkUBTxLQ8Jgf/9z7HYf+cOfPutOK53b7Gw06VLtvVuYGDu71tWdit/f+HGvWSJiJVz+XKOg1JKkDomd/P2u65YyZfEot2V1cLQIfWqmOsqGjCmiAWaXMm03DYmgjGRngoY7xrYajIFUFV88/1KQqlWUKFXpleMA5nClAqXV8C5ORCzIXNemyDKAjA60zZnMIMxx2LPnYNizn9qIjztxVgMPkCKQK4QGwFHvxQR/xVt9uq1nQjrgDBxz3LlKtEcwhoKZfHuxEYrRJWsiU1arLDUid0P8ceE2JNmI1envRcwPQ4uLICTv0D8Sct22kPrL9wnQmqKLawhBJTLXKk3gFaf6XeTJtpoTBKWRPHHIeGUWNVPvSczjTlNbOHhwvaxoBMeLhzdXaUwrIbkExs3wkcfCdcCRckWW2y55VSsKCabNWsKF6tGjcREo0SJbCudnJm3si57VuyWhAThUhYZCYcOwalTIttJdLR1XXPnwtChjj/Q7dqJlc+wMO+7CGWJEJ07w8MPAzUKwbtjS5i8uhEOfQS3DwJKtihjyyw+sKLoG0NqigxSxRuJvsivRGZWlawgNlnvTuYNz1pdykgQLmVxkXD7kOiP4o8Ll9xMvlg+xuFE9vvvC4Zrw7RpQtyx9zz6+8PatdC8ecEQrOwSUFYsUDT4GK5tguM/wLXN4n4Zk7w/8dE7F5xm2sFpVrGAQARFf6TqI3bP89P60axcM3Ze2mm1b330epLSkwjyy/0GPfGEcEG1t1K8dauYlDdpkmtRXuPQIceWkd2ci4NdoFgfvR6tYh1PrHbJ2lbZcNpUbsPsI7MtnhOjamT58eV89ehXXm+rrzl50rHlQuPG+Z/eutCQeNbx/gp9xKRaUiRRFOEa1qWLWERMTHQ81jSZRNKKZcvEv+vWFePA6tWhQQOoUSM71IDJJMbPly+LjLXHjwtr8m3bHIv2DmPtqCrc2i0W7S4tF3NJjc7SqMEDBg7ZTTCDKYeQkn4DrqwQY4Waw22fnHZLjCdO/izam5cFJo2fGGfqi4mxiNZfWByb0sRY05wmrJoSz2QbdNhCNXre0CMfkN14XkiJgb2vQcza7ImJPUo9DFWfg/COEFRFDHjNGdkPXW4EV4OSzYVZnTldfCTM6WJSc3klnJsN8Sesz8tIgKjvIeo78W+Tg56geDOo1A/KPwZBVYVPsilZvFTaAOcyt5TrkXmOUQhFigLJV+D2friwULh8ZMS7J6xkIQWWQsm+ffD66yLujaMPU+PGInXmgAFCU0hLE5Y2907MnVkRL1FCbM2bZ1sB6fVCHFq8WLh8bd8ugvI5EoAURWRjev5530+4szKFuf3u+Nr979Y+2Pc63DniuP8JawwPPCPiIfiHi4+vxgD3xpLSOHHDDSXEVrK56JtNqeLDnpEAFxbDhfnEJjrOvFK3bv6vbKemwjvvOJ6ALV0qgrYGBvquXW6h0UK5rmLLSBTWqNc2Cdfp+OOg9RePnjkVxVHcjJwo+szVSEV8f4KqinhEZbtAmbYiTp0TpJvSWRq1FBXrZz/MEEblYpUdnt+3dl8iYiKsTOv9tH6sPLmSZxo8k2sbhg4V1j6O+Ne/hPCXX/f8hI2hRk6aNStEz2Mmy44vsxmXot0D7ax+e7DcgzbLOHPnDLdTblM8oJCZQeXC4cOOPwedOuVvautCg9kkJpSOqNgn0+1VUpTp0EEsTP7738LV25Gbd06iosTmdTIS4NSvcOJH4dJlSsleqLE51VUyjRvqiNAkxZtCWCOxoKfxE8+0ohXHqUZh1WPOEF4id45kGjgcF1vSOetFIVtjR1MqHPkUTowTjTLlYtGkDYAyHcRct1QrKN5YGDaYUhwLPIpO/A1J58Rc9uZuiN0nxi5FzGpPikDOoKrioTv0YWY8HjvWN/5loOZrUHNkptgT4NiUzRl0gUDm6EprgOJNRKydOm8LN4io77OPPTMDIv6VGVvDzqw26AGo/YYQqLKskHK6a2nyGFRCo7GepIVUE1u5rmJSd2t33sqUeBdnrLI84HKmqiLA8nffCZHF3qCyb19hBluuXLbLCXjOKiNnnJ6gIBHb4vnnxerJgw86XpWZNEnEiSnQFhcFBVWFI58IAdqUAjYm1oCIY9b0W/ExVvxyiM0euuE5hXZdkOiPqz1P8ZJ6rjp47E+cEC5h+SkEzZjhOINFq1bCKq2wTbjvog8WvvTlukCTr8CYwrnzqxi9YjCNg4vzTsO+6JPOChdmc5oYOKJmJiHQi+DfobXESl5gZZEwoVg9l4OqbjyzEY2dRAZdqnfJ9fzO1Trz+bbPrUSghPQEpuyf4pQIFBICb78t+kB7fdG2bcJF9P3388ct7MIFx/sbNPBNOzyFWTWz9fxWq9+D/YJpXam11e+1StYiw2Q97jNoDWw+u5kn6j3hlXbmF6dOOd7fpEnBCFhe4Em+KMbYJgez/aAHfNceSb4SHAw//ACvvir6+1mzMtfNPRQK0RmsxjdmE5yZCgfezz0uY2hteOBZsXAXVFXMhZ0ybsgZN6GU8DKp9ER2aBKtQXzzLy6Gc/OE8HIvtw/D3/2Et4mjpBPaAKj8pJjjlm4rLHx0AeI9vHsRnBRdQ2uJrWI/UY6iEW5xZ2dBzBrHQlIhQYpAuaGqEPGG49S3Gj3UeQcafITwb/SyaWeWaBNSQ0ymzCY48DacnmK/jYaS0PgrqDJIqLO+yGiRNTAv0977dUmc5+pVjt04Rrtp7biTegezakZBIcQQwqbnNtG8vM34YXnCaITBg0UsC3sfuAceECav1av7LgsTCDP2kBBYuNDxame3bkIAys9YHIUGsxF2DBZWivb6oKAHoP0y4eal9+EN1+hAE8LoD0WcHXvWaO++KzLC5afgl5sZ9xNPFAyXNU9x+NYp2i8aSnxaOgvirrPAtIctz2+hmL9v8oy/u/5dq+xQIFK9r49eT41xtjODZaGi2nQlA9h0dhMX4i7kak0EIgD4d985Puazz0TMsLZtfTsBv30799S6Vav6pi2e4kDMAZsuEaqq2rT60Wq01ClVh0PXDln8npCewJ8n/yxyIpBFDBEb1K3rm3YUehKjM11N7Oz3K55pLSG5n6hRQ1gDffONCBr99dfCCtjVNObOEBIiyu7RI8ePccdhay8hrNhLvKDxg+pDoe47wmJb0eYQfNyYR2rviRcbXAVq/wtqjBBtOflz9r6oH+DwmEzLHzuDdn0xqPuuMHKA7DGmM543ubY1h8hV+Sko30N46Rwe637Z+YwM65Ybe191LAAZSkGPw1B/jFh19rYAdC/6YCFSORKAijWAx45C1SGifUUwpanEeXZf2s3DUx4mNiX2bkBUFZX4tHg6Tu/IX2fdj0T8yy+wYoX9CW3DhiL9cYMGvhWAcjJhgmMroE8+kQKQ05z8RQTos+f+FdYQeuwXfZEvBaAcjBwpYjpp7Yy5d+yAV17x7arcveRmhVSUvF33XN5D29/bEpcWh0bRoKISdSOKVlNbcSv5ltfrv5N6h6ibtu3sVVSuJV0j+na0w+3M7TM2Xcmyyvhs62dOtSUsTLjMOhL4VBX69xfxeXz5jEZFOW6XXi9cbwsT66LX2cyOY1JN1CxZ0+Y57Sq3Q7GRqXHt6bUeb19+4ih4fhZVqvikKYWfhNOOY4WG1MjdpUVSZClWTLh/x8Rkx8xs0kRYw4eGuh53S1HEYlZgoEg4MmiQEJsuXxbu5IBwcVr3kIh9Y08AqtQf+p6HJl+LECW6IM+IKvbQ+InxYUBZMacGODkeDn/k2Lq8fA/oe1Z4yOhDvDvGVDTCwCGgLDT7PvfjCzhSBHLE7YNwdrp9cUUXAt32ipdDn0+zxbhjwpTPbhuD4dGt4F9aZumSsCF6A51mdiI+Pd7m/qSMJHrN7cWy48tcruPOHeH3bG+ioigiJk+JEvkbXPLOHcf7a9XyTTsKPf/P3nnHOVWlb/x7c5NMMpVhgKG3oYM0EQRUVAQRXBsWhBXbqriua1vLrm3tva1YFl0rYm8I0pEuSu+9wzAwwzBMycyk3Pv7403IlNwkM0mm+OP5fO5nSm7uPcm959zzPud5n9eZB+sfDSIjVmDwF2LyHGl6bASwWuHXX8V03Kia1iefyErZrl3By2HHCueeG5x4/Pzz4MRlfcGifYs4/+PzK6lwSj2l7M7dzRnvnUFWYRR85ILgucXPxfT4AF9s+iLsfZ98Uozwg42JBQXiLTFzphiMxhIul6iAbrstuK1Y27b17578bst3AUmgro26GqYHDmo1iERr5c5ZUFrArtwAFQfqKXwVO41gtda/SnC1hsJdwdNrEjMgALF4Cv+/oKrQv7/Mm9f8msOxrUv5/JUZPH3HbMZftJQBXbaSnpqD2eTGai7FZikm3urAbnUQZylBNblJtBfRueV+Rp65mvuvm8cbD85k7YzZHN25jcmfuLn6akhL857wxGaYN9Rb8cqAWOn7Ggz8WMiO2ohvzfFw8CdYc3/wPtT3dTjra1HVmWs4T7624v4oIqwZuaIoI4A3ABV4X9f15yu8fi7wI+Czwf9O1/Uno9jO2sGahyQP0Ahd7xMfoNpU1mx/O3gbff5EBhObU/j/g683f831319Psds/Y4+3xDOs/TDm7J6DwyUDrcPtYOy3Y3nzoje5ue/NVT7PqlXBFQ29ekGrVlU+bNRht4v81gg5OfVvhbtWkLsq+PiS2ksMBOsAWrUSBdpFF0kJ1UBKtUWLhAC8/nqp0tW0qQTmcTHk0B0O6TOdOsl9aRTgr1kjBMCIEfXXp2rmjpmM/nr0yfEGJP0qTo2j1FOKU3NyIP8A/Sb1Y9nNy8JKp6oOPlz7YUyOWxYFzgK25Wyjc6POIfe1WmH6dFFHnjhhvF9pqaQF/u1v8Nxzcm9GOz2ssFDG8XHjZPU4JUh2XlKSVKmpL3C4HGw4uqHS/xWUgKbQPvRr3u+kcrbc+xSFObvnkNEwI6rtrC04HMFJvzZthPSrLQVvvYIrSEcGr7qivhq8nULEcOVL2fXMGZC9WFQ5mpNE1c7IJBcj+zugv393j2YivzgZl9uCy2NBNXmwqC7s1mLi4yow8YoFjthhltdA2d5UKq+2uBgOfBfcV6fHo9DhFm/p9lqC2wHLxoZuZ8bNtdvOeo6QJJCiKCrwFjAMOAisUBRlqq7rmyvsuljX9Ytj0MbaQ84SglYA63Br7Q/gzlwMmVwAe8votfG7plBS3VLVJhhbj2aKfzD8d9V/uWfmPeUIIJvZxrD2w/j+mu+5eerNfLnpy5OBWbG7mDtn3Mmx4mM8MPiBKp0rVEqLpoVfsCqWuOIKMeZzGai1X3gB3njjVEpYSIQimHWNqK12RmEMatgQli+XKnF33inqioqqNU2TUu0ffihB+ZgxcN11Yl7uC5ISEoxTy4LB5fIfIz5e0m0++EDac/CgqORuvNFYXTFmDHz3HZx3Xv27N7/b8h3XfXcdDrf/C4+3xHNTn5tYsHcBW3O24tbcuDU3WYVZJ4mgDg2De/NUFVmFWWQ7QlTtiRKeWvQUk6+YHNa+LVuKT9rIkaHVNRMnyr3y/PNSUdFiibxiU0GBpAPddhvMmhXee4xUdXUVi/ctxma2VVICJVoTGdSysim0DxkNM/AEqAzjcDn4bst3TOg3IeptrQ2E8iSpb6RfrSJUqpelQa2qY0+hFnBiK+z5BA7+4PWMsnlLjZeJNQ2qZKomjdSEEBJ2H3RX+cmt46BsR+Z752wGsa2lAXR7sPaJlT2TCRrbpvatG+2s5whn9OkP7NR1fTeAoihfAJcCFUmgPx5COX8rURq8IwpsQuDAt9DhL9HpKBG1sf67qNdXPLP4GZ5d/Gw5AkhVVNqktGHK6CkoisK7F7/L+iPrWX9kPS5vDnuxu5gnFj5BtiObFy94MaCRZiD06xec5Fm/XtJtTjutdisxPfIITJliTAJ9+qkEQ6ed9scy4406GvYjKMmTt14mOw1Oi1yRGKUxSFHgqqvgT38Sg8aXX5b0QIdDCKCy2LhR7pVHHhHSplMn6NIFunWT6nJdu0rwrqripaFpsqmq3N+qKuqNfftEfbRyJWzdKtuuXZXvv2uukXbccUdgIsDtlop6t90mxpIWS/2o1PPpuk+5bdpt5cYhi8lCr/RevHbha2QVZnHa26eRVyqTXI/u4VjxMfq/15/FNy6me5PuUWvLM4ueidqxQuH7Ld+H3qkMzj1XFD7//GdoIignR0rMv/yyeF5dd50og6pCUBYVyb6//y7VEL/+OrzSxT5UhwitTUzfMT2gmbdH9wQtimBSTHRr1I3VWZUr1yw9sBSP5kE11bMvIwBCkUD1jfSrVQRT6YNUMjqFPz7cxbDvC9jyIhTtk0IavirTBoSPvwR7V6kI3bCvt/y611DZZJVy5R6nVNJ0FUDeOjixEU5sgfxtgdOotFIxUTZS2KR0Ce5jVVPY+rKxVxFA9weFQDuFiBAOi9ECOFDm74PAgAD7DVQUZR2QCfxD1/VNFXdQFOVW4FaA1q1jI/GOKlJ6QO4K49f3fw0ZN0VulBUrAghEYrjvC2h9zR8if/EUwoeu69wz6x7eW/1eudQLkFXP2dfNJt4iKjGrauXncT/T/e3u5DhyTu7ncDl4Z8U7ZBdl879L/hfWJDcpSYKYf/zD2BdozBhJu0lJqb1JZbt2UpXnjTcCt9PlgqFDYeFCCfzrm+qixmBJgt7Pwep/GOduLx0DFyySyUcdMqa32eCuu+Dvfxdj6A8/FEWO2y1GvBXvC4cD1q6VrSJ8KWNWqxAzTqe/2kdVV85vvFGIx1tukWNUJIp0XQL2b7+F++8XQkjXpe/Filj1qZfWroWBA6v23ndWvMN9s+8rRwABNLA1YOq1UzGbzLRMbskPY37gos8uOrmfpmvkleQx6INBzB8/n9ObV67cVB1M3hCeMicacLgdrD28lt7Neof9nrvukvHmzjvD89vZuhXuvltKzZ9zDlx8MQwYIGRlcrLcgz4FpqrKtmePpBcuXCj3UU5O6PMEghGJXlfx0/afAqZ16bpO+9T2Qd97TttzWJO1ppIZuKqorMxcyYCWgabG9QuhCMD6RvrVKkIF0+GWqg4Hp5T6dQ+6Dvs+h5V3CtnjDmLkZkmWUuQtL4UGPYUA0t1hlmD3ovmFQpzoumSAOPOgYAccXQT7vxSfWxDyyAiOg0I0RQOxFDg0OQ/+AKR7bSOc6WKgJd6KGq3VQBtd13sBbwIBXWV1XZ+k63o/Xdf7NW7cuGotrQ30eQHUIKlUG58UNlWrA4OnJcV4lf23v8CmZyTHMtTKRDDY0qv/3lOoUXg0D+O/Hx+QALKb7fx07U+VvDaaJDRh1p9nnSSGfChyFfH15q+54ssrApppBsKtt0qKQrxB99m6VbyBVq6MvcFpMDzzDNx0k3E7CwvFsO/ppyUIjlX5TiPUZqWqKiHjVmhzrfF4mb8VZvSC3JXgiuCCx2gMUhQYPFgqaBw/Ln4or74Ko0b5icqUlOA+PG63qCqOH4ejR0VZVFxsTAApipA2viogTZuKB4sPY8bAzp1wySXG92d2NjzwgBg+jhsnFfkcDjlvXp6Una0OPB7Iz5fN5YIdO8S4uFMnGGScMRMQLy19KSABZDfb+XnczzSKb3Tyf0PaDuGJ854oNwaVrVy4dP/S6n2gMthzfA95JWFK6qOEJxY+UeX33HyzpP0lJoZP7GkaLFggBPzZZ0PjxnJv9OgBZ5whlWc6dBCCsWtXGDtWlHDVJYBAxsS6kN4bDrIKszhccDjga90bdw+pdh3YcmBAc+gSdwmzdoWZP1fHESqlsCoqsf/3CLXgYagCqQZOKfXrFvI2woze8PutYtsRiABSTNB8FJw/F644Av0mSkWupA6i9jEngLVB+EIDRRUyyZoiBKOtMTQeJFWzhi2Gyw5Cj8fA1tT4GI6DcOjH6FSti6XAIVr4rilMUSLY6jcRFY4S6CBQ1tWzJaL2OQld1/PL/P6zoihvK4rSSNf1CKYWdQDp50GTc+DowsDSuZIjMOtMGLZEVsOrqwiypUfeWS5aI27vJUcCr8Zvfh72fga9noHWV4kcsarKoCtCVGuZUk9mgn9wFJYWMuKzEaw6vIoSd/mB3Ga2cdeAu0iKS2JtVmU5g0kx8fDZD/PUoqfKvdfhcjBr1yzOfP9M5l43l4bxwR2TVRXeew86d4bHHxc1Q8U0m8OHJfAeOlTSGTp1kmAn1qktTqdsR49C+/bwn/9IIP7aaxI0VyzD7fGIP9Dnn8O//iUpF263vCcW0DQhn9xueP11Cb7rPEwqDHgPkjvDhsdFclxxtb34MMwZDOlDoe/LkNRJJkFVGTdrYAxSFLlvO3cWhQ1IkLxts4ut63LYsNbB2g1WjmZbOZ5vJb/IRrEzDqvZhap4UBS5gXQUdB08mhm3x0yCvYTkhBJSU5w0Ty/l9L5uuvdKpkvPhnTqogY0Wk1PF2XSokViUr1qldwXFdUXbreYCk+fLn83awbdu0vw368f9Okj97qqyv3l8fiVIb6UNVWVPrFli6QGrVsn6WvbtlWP/NR1nccXPM4rv75SiQCKt8Tz+ojXA6bf/GPgP1iybwmzd88uNwYVugq5cPKF/DjmR4a2H1r1Bnnx5MKa71Azds6o1vtGjBC1zogRkJUV2Mg8FAoLY0u0Z2dH7kVUU5i7ey4W1UJphcUwBYVz2p4T8v39mvcL6Avk0lx8t+U7HhvyWNTaWlsIpcyt6YWQeo1Q6SrBTG/rE7QwmcFvm8hPxSSEhTlZiApbU4hvAfZmkNAGUrpDUsf6W9H46BJYcFFw5U/jwTDgf2Bv7i9pHqvy66oVsEq16G4PQaNBsPgKY+X277dBQjtJ4a9t31sjZM2VWDZST62Iiar6TaAqesWIp+IOimIGtgNDgUPACmBs2XQvRVGaAkd0XdcVRekPfIMogwwP3q9fP33lypVR+AgxhscJiy7zEkEGHSYuDfq+Cq2uFBldLCRqoYKbsboofba+Dpuf8+aKGjxgrKnQajS0HQeNzhTGVzFLZ4/EsyOcNkaCcJYbQ9zPMUcttzGrMIuOb3YM6HkA4sFht4TOQy9xlxiqfmxmG5v/upl2qe3CatOmTZKqsGxZcGVLx45w5ZWiaOjQQdQMqirqi+qmuGiaHMflklSdrCzxAfrmG0lrKXsp1q0T9dL+/cGDLbsdLrtMqvP07SsBuMcjao3qBEOlpdLGuDg5zrx58PbbMHeutD/i2yXcZfpo3Zd5m2DV3ZCzLHhpz6SOMma2HScrX55imRiqEVzwaI1Bmgfy1sKRhZD5M5zYBKXZ4uGgmGTMLLOK69FMHC9Kxem24vaY0XQTqsmDavIQb3WQbM/HZCpzbpNNJriaS45jbw4NT4fmF0HGXwyv2fbtotz44AM/GRSswl1F2O1yn/k2j0fe77sHw13lD3WraJrGFV9dwYydMyqNIxaThTNbnskdZ9xh+P4Sdwn3z7mfHEdOpdQbq8nKCxe8wN0D7w6vsRXQ6MVGHCs+Zvh6clwySjWMzB0ux0k/tUDY9NdNdGvcrcrHBbnO774rJLTbXX2FV3WRmGhMJCmKtKc+eMWc9vZpbMzeWOn/CgrNk5qTFBei5JUO245tq3RP+o6ReV8mTRODrLJHAzEez5cuFQWkUYW6du3E1+8PkR4d6/na77fDzneNX+/2IPR8KjppYZEugIT7bNR1STHKmivPxryNUHwIbndDsGJoKcDbIY6tmP0+SR6HLJAnd5XnYtMLJE0qEtlhTczPjyyABaOCz336vAIdb6tdU+NtE2HtA8ZxoilO4tr2N4j/UHXIlkjTwcwJxr5ADXrB8KWRf4fREC9EGtvGGIqirNJ1PaDhXUgSyHuAkcDrSIn4D3Rdf0ZRlAkAuq6/qyjK34DbATdQDNyr6/qyYMesNyQQCMu94g7Y+6lXImfwnaX2ge6PQIuRMrG3RFEqUJXgxnkCtrwE298SMshdiGGbVTuknSEBWVJnSO0tAZm9hT8f1ei9ikne78qHor0w09hUsVIbq4NTJFBQ7Di2g9PeOa3SKmcsYDaZWfGXFVXyuVi2TFRBixcLuROMEEpLEz+Ljh0lbaFPH1EKNWsmgavHI1+jT11kMvlVDRaLKBp27PCrGXbskBS0rApCkkCqn0mT4IknpH0FBcE/k6JA27bQs6dsgwaJkXR6enmTYF0vr7pQFDhwQFb5ly+HDRtkYl2xfYHaWGXUNAnkQ/YyWP+4+JIpavBJUVwaJHeRcSi5q4ylyZ1kZVD3eDfdry5STIAiP00WKDngIahTAAAgAElEQVQqE9N55wVvU7AxqPSYlE7d84mkrSkWL0lTgxG3Gg/XhJZ7aJrcL7Nni5/L2rWioPN4qqcWCQWLRQgkl0vS4g4HzqgBwK256fZWN3bk7gj4ukkxkWAJPXHTdI0il/GH+Vv/v/HmRW+GPE5ZHC06SqtXW+E0SMNon9qeyZdXzy9oxs4ZvLzs5UqqJxDPtSfOfYKHznqoWsf24fhxUYR9+KFci1hXaUpMlJSy/fuDn2vvXikdXpehaRrqU7GV7j92zmM8cV7VU/+qhBiP5+vWia9Ufn7g11VVSD/zH6GoVazna2v/CZtfwHAO3epKGPC+pO9EiliSQB4nZE6HfV9C1hx/HFRTSiZTnDznrw4xIQuFWF9vzQNT24HjgPE+Z7wDbf9cNzxa930Ny68vb1RdEUkdofeL0HxE9TJIgiHUPWtOAneQa971QejxSGRtOkUC1U7j6xUJ5EPualh+AxTuDu5abk6CVpdBxi3i6I5J0iNM1qpL63RNFD5fh1ihCnQTah4pB7jnUylH6AugPGFGCfbmENdYBl+T1e9Grzll8xQL+RNu7ugpEkjgciASQq8k1mSJ2FRhfdZ6+k7qG1CqHiuYFBMLb1jIWa3PqtL7jh6VCjT/+59UXrLbhXAJR4WgKBKU+Ax4rVYhVnwGvKWlkroTTnBkMhnv5/HAtGmSprZihQTBVUmpsFhEwWSzSVt9RsElJbIVFYUfwNVbEsiHkqNior/rf7JqaLbLmKaHIztRRC5uivOPQYp3PPVVxSjNCW50WBYVxyBdl0ntlldE7WkyBx/bQSTVyZ29W1cpVZrcSVakFIscQ1G9JLpbxkrXCTixWZ4hBdukckfBTml/qDaGgeJiIYU2bYLVq8Vra/t2OHFCRzG7scepqCaTpKf5+DTvaXwEqs/w1e2WfmQyQatW4t11xhmSWtazJwSr6VDiLqHTm504kB9kEhxFjO85no8v/zjs/d9e8Tb3z7m/kk8aiLnvA4Mf4Nmhz1arLQdOHKDTxE6VUnB9yEjNYOffd1br2BWxfbukr06ZItexsDB63dduF5KxTx9RO44ZI35VwXyD5syBCy6IzvljhR+3/shlX14W03N0bdSVzXfEuHBujMfz/HxZhAn2PD58WO6Jeo9Yzyl3fQCr/m78TEntDUMX1F0SqGAXbH0N9nwMKMED8rKIbwkp3SC5m1S3MieWMTdWJGbwlEoskr8d8jfL87Fob/CqzHU9htjzGayYYJwG1qAnDP+1bqVYOQ7Cqnshc1pwkUNcGrS8XIohpfb1ZpAo3nlPNcn1UPfsuT/D4tHBycbeL0CnO6qvCIqGefUpEqjqqJckEMgAtf9r2Pi0kEGaM3QwY2sig2GD7tJ5UvtAYnsJhnxl5nXN25E0CRzchTI45q6A4+tg9wfBzxHqJtQ1CTyyl0rQc3QxlB6VlWfFJANyLFe8bemh/TxCoS6TQJpL7ocOZ0J2ENPRFOAdFfFb1/0SETUBrMmSqhfXWPKiG/QSdURKV3moGqTq7Ti2g0EfDCpX1assTJjo26xvaKl7ABS5iliZuTJgNRWAlLgUFt24iJ7pPat8bBAyZPlyMTOdOVMUMSDkiabJ6xW9hKoKRZFULbNZiBi3W/xeLrxQSJ5QyM6GWbMkhWzuXD95FCvTZkURAknT5OfRo1E4YDioib7jLoKc5SKZPjwT8rwXXLV5Ce8iYpZjXVFlk/MbrLgdCrYHJ36sDaHlJdBuvIzd5ngp+errt1VJ/9VcQoApirTHmSuVO/ZOhsOzZbITpQlFZkEmQz44n52HjpHOabx2zmQsJc0pKJD71+2We9lsFjI1LU0IVt9mZEZtBKfHSevXWnOkqGbNIK/udjVfXvVlWPv2+W+fgF5oIGlgP475kXPbnlvttjR/pTmHCwPLpOxmO2tuW0PnRp2rffyKcLvhl1/E0Pynn4Rs9o2b4XZnq1WIn9JSUfNMmOAnfnw44wwhFo3wyiuS8hurynTRwKWfX8rU7VNjeg5VUXE/FmPn5BoYz5OSgi96LFtW9QqBdRKxnlMeWQiLLpVFgEAwJ8GVx+peOljJUVh5Fxz6QRaTjVQiIHPVlpdDo4GQ2hMS2noXi8OsauVxikpYMYt3TdEBKXOe85sYFJ8oQ6rWdRJo2fWw9xPj13u/AF3vqz5pEkscWynKtezF8j0FW9w3J0jmSEoX8W9KPV1+tzeX6657OBnf+KCYvMptq9xf+dtgfghvv7E67HwfVt0VXEmefj6c9aVkpsQixS7WVicxxikSKFY4vg52vieGy5qTassjFVUGQN0VnAUPhmrchK6SYo7s2kvugT04ju6Bgm0kuDaTat1Nqv0oZpMb1eTGrHrwaCY03YSCjmryoOsmPJqKW1MpdiWSU9yafL0zzvhuWBu2J6V5e5q0b0dKkybRKx1Sl0igkhxRDhyeBVmzwXHI+7AzyT0Q7KEZLkxxckzNJcdL7AjNR0Lfl07usjZrLed9dB4nSk8E9CmIt8Tzzsh3GN97fLWbMXXbVMZ8MyZgmgNAkjWJmX+eyaBWVSwbFAC6LqTL7t2wa5dsGzeKOe2BA37fEp+KxqdeKPu3L6ht2VLSyXr0kJ/t20NGhgQ31Q1WPB5RWqxaJQqhlSsl1QwkAFMUv89KsNLJVqsohEwm+cwlJRKIdekipZ379pWqZF26RKH7hHmASf/VT6bTld1SU8UHokWLGJQH1nWKcrPJ2rmbE4d24czdhdWxkRTTNhrZD2A1F2M2uTGbPOiAR5MGiAEzuDUVj2bG6bGS62hJntaRElsPLKkdSW7eniYZGaSkNy1PoLodsOw6ODwj+HjdbAR0fwjSBkgftFSdRA3vO9BkhdVkhYNToc01ER9y49GNnPfxeRwvPo5H92BSTCRbk5l93WzOaHFGFBpdHsWuYkZOGcmSfUtwB1gUURWV7k2607VR1yofW9d1ftn7S0B/IBCPoEeGPMKj5zwa9DgH8w/S4T8dDNNlraqVEw+dwGauvjnn9T9czyfrAgcBVtXKQ4Mfilm6UEkJzFmeyc3vvcbwhPvZs6kJW7dKChlI3/UpweLihPDp1UvGm+7dJY21RQuDz3U9fBIktrn6aikEECuz/Ggg5fkU8ksNcpyiiN//8ntM+thJ1AAJ1K2bGMQb4f33pXpdvUes55SOg/BTp+DPmavyo/NsiQYJpGuw7T+w/hG/X10gmBMlpanTHZCY4f1faK/JKsFTKgvsJUdh5yTY9T6Mzo7smLVOAr0IXe+NDgkUkYLFBGMN1NOOTFmU2jnJWy7eGr4CTDGBrZn4HfrU2yeV26VyP5VkeW1GwoAvrt3+Dqz5h7cfGVwfcyJ0vgu6/kPOWVt2LHUQp0igWEPXpQRy1jw4+D3k/Aoowu67HdEhBIIhDJXNoUOyYjhjhqgtDh0S4z+bTYJmt1sC7MCqCx2z6sZqduLRVFxuC5oeeBDzGY6C39i3aVMJ5iNeJaxtEih/u/iF7P0MijPF3NVdgOGgFBOoMFaCrMX7FjPys5EUGpTcjrfEc2PvG5k4cmLEZ33sl8d49ddXDT064i3xfHv1t4zoMEL+0bQpHImtIsCDCSdWNEzEUYqKp+p2ro0bC+sUAXTgMM04TDOO0oSjNCGbxmTSnCIScGHBg4qKGysuksmnOZnePWVrwSHSyA18giNHoEmTsNricAiBtmeP+HRs2wZPvteUhs7g1+II6bSPlzHElx7k626K4jcgbthQUoQ6dpTAsV078UQaODA8gig/XypPLVkiKSQbNsg4YbfLeXwmxYFgUjxYzU5MJo1SV5yXEKp8xa1Wf4W54mIZ37p2lXSV55/IQZl3vvgHGSkfG/SCAZNEvVnTefuaJ+LCAnN3zeXyLy8POC7EW+L5fPTnXNL5kojOURaFzkKGfjKU9UfWB0yFsqk2hmUM48cxP4YswW2E3OJcur/VnayiwM+5eEs8d5xxBy9c8ILhOV5Z9gqP/vKoIZndr3k/Vtyyolrt8+GrTV/xl6l/ocAZeNLcMrkl++/eX+3vIRhcHhenTzqdDUc30DalLZvv2HyyCIAvxc9HkFf19K+8IqbURpWhGjQQPzPfs7+uoaC0gOTna4ahurnPzbx/yfuxO0ENkECXXw4//GD8+h13wIsvVl0tWOcQ6zmlrsEXtuAxwEVrJC0sUkRKAo1xwdJrxezZSHWhmCXQPu3f8ndNPR/dDkCJnGiKeTrYZFEX10Q6WE0YgTsyZbE7cwYcmSu+iapdSJxgypxowBQHY8rMJ05sgUWXi99SsHObrNDyMiEpm14gxJMaF1nltVMkUPTxhyKBKkLXoGi/VJQ5sRmOrYATGykuOojqKcICKKpNBtRAg5KuyUPD45Qb15IiRE9qb6kgk9JNNlu64aDmcsHChfDll/Dzz3DsWHi+Jg0bSlDXpo1saWl+Ysdq9ascnE6RnB88KMHmvn2i1DDKI4/oNtN1SZuwNQq97/SegO715iizmRMgIQOS2kN8K/9mC6FU0jyw/ysx9yvY7vdEMoQipS6Tu8jWoDek9pL0P9Xu9wtRTN5jeWS1w1Uggenx1ZIik79VttIAKV5jdaZtm8Y1314T0NsCZNW5X/N+LLxhIeZISygiJq0XT7mYX/b8QomBTNRutvPBpR8wpseY6Km/TkFg0IFcLlEkzZwpk/atW4UACUWoRAOqKuSNqkJekAzInTvhq69g8mT5PT5exo5wPKASE0XRVdYDCuRzO52yZWYGP78PVouL0m+6ythsNClvdQUM/ARM9rqd22KAj9Z8xF9//qsh0QHST5+/4Hn+PuDvEZ8vrySPIR8NYVvOtoAKGwWFNg3asOH2DSRaIwsY1mWtY9AHgwzHvHhLPON7juftUW8HJFm6vtWVrTlbA77XYrLw2JDHeOScRyJq49Gio7R6rZVhZcUESwLLbl5W7fTZYLh75t28t+o9HG4HcWoc13S/pkp+ScHw448wfryxWTCIQrJPn6icLup4ffnr3DPrnho5V9PEphy+L4hzeqSoARLoscfgmWeMU7E7dZLrnVCLxY2igppYWPyhlSgqjNDjUej+cOTl0CMlBZqPlDRtowA7oS2cP0/mzHXB1Lg6qBFj6LbBr/cZ70K7caJciQQ1VQ2uLEqyIX8rWt42ijLXo+WswVy6B7Oej0UpwqOZcWsWPJqKrkv7dGSpTlFkIc+sujCbXLi0eNymZDzWlpDam4SWvVAbeOMme7PA18rjlOrXW16SODlU5o3JCo0HS+ycNkDS+RPahrZxMXknmgU7pUjIbyFkj/WYBPoj+PvXPSgmSGwrW4tRALy/+n1u+ekWAM5vPZifrviIeK3IL3n0eQIpqhAWtsbiRVHFAP7YMSkv/eqr8gAvLPQ/yMsGhBaLyMAvuADOP18In/R0Gf98+/lMbY3g80XxeGSF0WaTSeKhQ2JSOmOGqI8yM8NsvOaG42uFeT72u3jsFGdKaWZMkKLAiSCdLQXIWx/8HKY4/8PW4x0IrA0hvjkktJMA0PeAO7IAfrsVSg4bM/sgebCtroD2N0p+rK+qmiku+MqFonrlE17DcHs6NDlL/El8+dS6WzxUdn8Eh34CVz6frvuU26bdFjTQS7On8dO1P0WFAAIxgf7qqq/o9W4v9ubtDegRVOwu5qYfb+JY8TGMiz+fQqTQdSkjP2kSTJ/ur9biSz+rmIaWkOBX7LRr56+41q6dVHqyWOQYvtQ0n19Maan03R07YPNmURjt3Ssqo8OHZT8jUlnTxPz7qadEBVh2XKlYethkkrQUXzW4nj3Fs6l1axlTSkrKGxn74FMrxcVJew8eFMPc9evl5/btkrbn+z5uOuc9KM4yJoDSBkj/r82yrdWEruui1lv+arlxwW62c3u/23ln5Tsn/1/sLuaf8/7JjtwdvDHiDUwGXmOhkF2UzeAPBrPvxD5D0iPeEs/sP8+OmAAC6NW0F+9e/C4Tpk0ISAQ5XA4+Wf8Jha5CPrr0I9Qyiqrdx3ezN2+v4bHtZjsXtI/c2bhJQhOaJTZj34l9AV93epx8uv5TXhr2UsDXq4uft//MpFWTTl7jUk8p32z5hhEdRnDtaddGfPzu3YOntwJ88YX0YXuUs0KigSkbptTYubIKs3Br7qg9e2sDHTsKWW80vm/fLq/VexKoJpCYEZwUODQNut4fOQkUKYIRQIkZMHw5WBtUr1T4/xeYVJlDLLjY+LtcMUHIiw63RDbXsKVHbmgcBrKz4ddfparvokWN2bevMTk5Z58seOKLAzVNJyX+BGmJx0hNOI5ZdaOaPCjouDUzHk3lhCOFnIJG5DkaAKaTXp1ut8zzUlNFaT5oEAwZAldeWYELUq1w2uPQ+W7YPhG2vuL10DVIV9OccOQX2XxQTBLrWVL8nlUmqzdlrUS20uzgffYPhFNKoBrA80ue58mFT1LsLkZVVCyqhU5pnVhw/QJS7alROYfTCY88Am++KZ2mOAA/EBcHo0bBjTcK+VNaKhM23+p6tFFQIINEZqb4sVSCrkP+Fjj4k1QvO75WVDuaM3DVHB/MCaLiSWjtVfOkeysH+XJQFW/1slIJ+EqywbFfDOccB4xN+kAYXXcRLLlGBo5gssMWF0P3R0Tpo3tiGzy68sFk5effn2XU7Kcwm8yoBnnFZpOZ5X9ZTo8mPQwPV1oqQfP+/bIdPuxXjvg2l0sC9LJKsELLbt7V++BRSiUIh3IZOZqu4dJcON5MwX4syPdcV2AyRe48HWukp0NWFi6XKGoef1wyxIwm6HFx0r9HjZKtaVMZD3RdXqtOkOZLF/V4/N5Hy5fDd9+J0nD3btlP18VA+x//gNxc4zbabNK2MWNg+HD//32TgkhQ1lDcahVF5Oefw/MDmtOsQZAV+uHLhAiqJilSW3B5XIz/fjxTt08tR47EW+K598x7eer8p3h9+es8PP/hcq8nWBI4t+25fH3V1yfThsJFZkEmA/83kMMFh3EZ5PfbzXY+H/05l3a5tHofzAC3TbuNyesnB1UEDW8/nK+u+gqLKoarTy96mqcXPW3oB2Qz2yj4Z0FUAvfbp93Of1f9N6B/EQhRlHVfVtRSwg7lH6Lb290C+t0kWBJYO2EtHRp2iOgcui7jSDCT+q5dRZVYF4kB61NWw/s0Fvjyyi+5uvvVsTl4DSiBfv0VRowIrvyaNAluuikGPnE1iZpQAq34G+x4K1gj4MrjkVcIi0apayNcsBAaDY44VbnWUVOWEkcXw4KRwRePG58FA96XReRY+A1WM4XJ6YT584XUnzVL5nE2W3lBQTiwWMort12u8L9aRREVeLDxB5DF8swZsHcKZE5HKs85wq8WGw1Eo+hRjHEqHayWoOs6D8x5gLdXvn1ywqoqKh7dg1W10iKpBUtvWkqzpGYRnWf3brj4YknJMqpYdN558NlnMkGrdfNGdxHs/Ry2vCiGyronMOljskDDftBkCDQdDontRIpqsnjNlzVvRQG78cNJ9wizq7kAxZsXqgvTW7RffJyOLhC1jacYrsiGeedKaUxDz5CeMngnd61xWWxWfiZfb/k26D4DWg6gf4v+5OdLFY8dOyQNZ9s2uUcyMyVILusHVVISfslyS6t1qO0WAfJeHRmwUxtAo0bCWbxy6yV0btomsg9b2x5Q4aCG2rhjh/TxzExjYqVPH3jgAfjTn+S6JCbGfoLu8Ba6stvlnho7VlRKRQbFtlJShCC6+26ZUNTUWFRQAInTbSjByOXRxyCuYeQni7jkaBDTxgrIL83nos8uYs3hNZUUQBd3upgvr/zyJNkwYdoEPl3/aTnyxG620ymtE3PHz6VRfBjptojiJuM/GRwpPGJIdNjNdu7sfycvDHshrGNWBS6PiwHvD2D9kfV4DCZ7CgqXd72cb6+WsbL9G+3Zk7fH8Jhntz6bRTcuikr7pm6bynXfX2doQpxoTWTe+Hn0b9E/4nN5NA9nvn8ma4+sxa1VlrebFBOd0jqx9ra1xJkjUxpMmCDmz8ECgfXrxWC6LmFX7i46vBkZCVZVjOwwkunjpsfm4DVAApWUiM9TsHTiiy4Scj0lCtXNaw018fw+8B0sv1EW8oww+IvICwJEo9R1ICRmwMj1dauseXVRk3PKvA2wbJxkNBhVH1VMkobX+R5JW9Kc0SOEqkgCbd4ML70kCm5VlTmT0VcRFycL+x06yNa9u98jMi1N4gqPp3zBFlWVv/PyRFG+ZYs8L3btkvhk167K88YqXQrNAznLpHr3kQVi36GY5Tt2FxKRd6svQ0dzitVISjcpHNJ6NDSoYw+8ADhFAtUCPJqHm6fezNebvy436faRQCCKjUbxjVhy4xIyGmZU6zylpdL59uwxnpy9+aaof2p9hU7XRMK37l+AEpglN1mg1Wivqdf5fl+kWEllNaeUe1ZtkL1ETN0K94Fu4PvTfJSUIqyDniElJVJqfdYsUWfs3StETzjeMDabpN+kpvqrQpnNck+5XH4lyKFDoUuWq2p4fi8hcYoEAuRaXn21sXG7xQJPPgl//7tcx9q4LXNz4cwzxResxIA7HTlSggazuZYMRb9vBcVBJL5DF8jqXKSrndFYkQ0jx/xg/kHO/ehcDuYfLKdwsapWeqX3YslNS7CqfpmnR/Nw4eQLWXpgaTkDZ6vJSuOExiy8YWFYzyFd13l2VBIFToOJLdDIAfcsBzVG3fNIAkzsD64g93qfLLgmJ53NG+bTb1I/w/TZODWOZ85/hvsG3ReVtuWV5JH+UjpOA+84VVGZ0G9CVAz7/zXvX7zx2xvl5hgmxVQuXddutnN9r+t55+J3IjrX7Nlw1VXBV2cvvhimTJES43UF982+j1d/fbVGz5loSaTgX2FW1KkqaoAEAjjnHEkBMYLdLqkitT6vjAQ1Mcdw5cO3jYN7Sba4BAZ9Gt2KRhVR3edS2gA4b6akgkWKWFW0Chc1PafUdVGprLrTG2sYPzOxpEDLS6Hl5dCgB8S3lkwGnzVEOMbGuiZxla7DNyGul3eOsWULPPSQFOpwOo0XgzMy4NJLRb3dq5c/TT+UbUgwOJ3+rBW7XRY7v/xSPOjWr4/US1YTT5/jayB3lSzsFx+S+6/0mHxPvrL1KN6TeZ+b5mSISwN7U4hvCUmdxY+3YR+wt6h3nqenSKAahtPjZPRXo5m/Z355+b05gd7NerMyc+XJSbtJMZESl8LCGxZyWnrVGcUXX4QnnjBWAF1yiUzKav1BXZoLv1woDu8eg4GwyRAY+LF49MSqHHMw7PoAVt1lLOFM7Q3DltQpzxBdh99+gxdeEHNgq9VYthkXJ2XHTz9dcv47dRIvqKZNZQD2pfsYQVHk+GYz5ORIOtnu3fIQ2b4dFi0SksjXrohxigQiO1tWWowCL1WValudO9duH7/hBiF4jKoH/fnP8N//1nI1mV0fymTMaCIWrf5dAyTQuqx1DP1kKHkleeXUMAoKLZJbsG7COhraK6uaCp2FnD7pdHYf311OOWJSTCRZk5j555mc2fLM0O2rR5Ogh+f+i5d/fdnQtyjRmsjiGxfTu2kUKvR40XliZ7Yf2274egNbA449cKzafkwA8/fM5+IpF5cjtxIsCdzZ/07e/P3NcpUc4y3xfHbFZ1zW5bJqn6+0VNQhRiQvyG2xa5esCNcVhFKBxQrHHzxOA1sUAueKqCES6O234f77jeeWAC+/LJXCbGHEp3USNTXHmNFXglHDdpjgsoNiiBsrVPe5ZEmGyw9FbmQcSRt8iNSAt7bmlG4H7PtSsh+K9omPTciq0YpYXiR3hZSukNpXis6oNr/1hS+LwlMqccvxdXBio8RZx1cHPbp+rc7TT8NzzwUnfy69FJ5+WpQ/PtV3LOGzosjJgbZnxrDKsIK4IquACfAgHJCbqomGqlC9t7ZwigSqQRQ5ixgxeQSrDq+qJM//+qqvOafNOfR8tyf7T+wvt1rnm4APajWoSucbO1aCLyO88YYoBGoVui4E0NGFxqsh3R+B7g/VLsHyQ2vxDDLC+fOEqKojedHTp8N99wkZ43AEfna1bAlXXCFBeM+eMoGPi4vupM3jERmnxSKmv9Onw80hzPTDwikSiPvvlz5sZMp6661SvjmxFot17Nwp91YgHzKQlK8DB+pAGqrmgRm9ZHXIKC2s2XA461vvRKua/jDRkOUHmew+t/g5Hv3l0YCpUKqiMqjVIOItxmxbibuEZQeWBfRIMSkmHhj0AM9d8Fzw9tUTEkgHWr7SnMwC4+oECZYE8v+ZHxEhUxH3zb6P15e/HtBAH+R5P23sNM5pc061jn+06ChdJnbheMnxcv/v3rg7G27fwNkfns2yA8vKpeslWZPY+NeNtE5pXa1zgniNzZsXfJ9rrxXCt6bVQA5HYJI58dnEcoRYWaiKGh7pGQD7TuzjYH5gZaHZZGbqmKlc1PGiah07KGqIBNqzB7p1C076NWsmpF9dNAMPCzU1x9j0Amx4PLjXZYfboM/LsbMYCEnAKBhGv6c9LubVtb1AUgMk0No1+sliN6oqP31bWprMtSJ6/J3YAns+ER/Ugl1iZ+EuIKJ0pSqi1GXlqm9LmTfPmOTt3Bm+/15iiFpTdtaTeUatxyEhcKo6WA0htziX8z4+r1K53HhLPP8865+M6iSVwuZcN4e+/+1LgdMvFy5wFjDs02F8e/W3jOgwIuxz9usn0jmjjjxjhgTktaoEOva75GoaEUAJbaH7v4JX0qoJlITIc0rtXScIoPx88WcIdt1bt4b334ezzxaSxnf9qyvbDAZV9Qf4druoQk4hOsjMDF6Vp2vXWlbXICSQ1WpMAnXtWke8t00qDFsKv4yQKoKBTN8Pz4aZfaHfW9B4UPXSPsMxCazmZHj89+P5dP2nhq97dA+L9wfJ4QgBTdd4funzbMrexNRrpxrvmJ4euxW6KGJdt4acKAluUD+49eCoEkAAF2ZcyPur3zf0BSpyFfHx2o+rRQJpusbor0ZT6CyvWI23xPPfi/+Loii8Peptznz/zKxI6w8AACAASURBVHILUQ6Xg0s+v4QVt6w4aZhdVVx7rRjCG3l+gZjXP/20PHNqMjW1tLTyWLgrd5chEQdy7RfesLBa5/tp20/8+fs/B7zGmq4xd8/c2JBANQSfv4dP3RsIhw9LcYCrr5ZFoFMwQIuRsPEpIAgJtOdj6B19D7WwodqNC6FseBLi20Cbq+tFRau8PNi0Se7PI0dkHrVnD7xpSSfNZXz+I0o6Q4aU/5+vMqmvwqmiiG1Co0aiom/dWiqvNm0q28iRIfpCSlfo/ZxszhOQvVjMjbOXiH+QL/1LcwUvTBMBnpv+DHPnGs/ZzjpLbAji4+u58fsphMQpJVCUcLjgMIM/GMyhgkPlZOc21cbwDsP54ZofylUDmb1rNpd9cVklnwK72c4Hl37AmB5jwjqvyyWr8Dt2GMv5nntO1EC1FixmzYdFlxmX8WvQUyrzREMFFCtzPIARq6Bh38iPE0EbNU3h7CcXs2r/YEOfnwkTRKZttdbzidkpJRAffyxye6Ogq18/qX5Vm0TQhg3iB2RESDZpIhOw2iarTsLjhJV3wN7PZGXWKEhsNFBWP5tfJHLrSKu3lEUVTRs1TWPwB4NZfmh59NoQAt0bd2f1rauxmmNUPrIG+vd9s+7jP7//J6BpMsjz9qVhL3FH/zsiOk9FFDmLSH0hNWhFqiRrErkP5la5ItnTi57muSXPVfIaHNZ+GDP+POPk/8Z9O45vNn9Tzpso3hLPhH4TeGX4K1U6pw/Z2RL0BFOHgKQcL1pUc32+sFDUrj/8UP7/76x4h3/M+UfASnKqovLw2Q/zxHlPVOucmQWZZPwno5y/VllkpGaw8+87q3XsoKghJRDA3/4G77wTnMTv3BlWr6758b2wMAoK2JqaY+g6fJsGzuPB9+vxKHR7KDYmzKGeOUOmw5KrghMPne6EXs+Kd2csfDqrUdGqpERS4pculbnQmjVw/LhfneZ0Bh6vEhP9xE2TJqKO9yl/fL6WHo/8dDggK0u2I0cqH09R5P0+NXxEKMmB/C0U5Kxg/saPyT22nt4N0ume3ASru0DS2XXNWxhH8fraWMSzKa4x2NPFt8beDJI6iolxYnu5ZggxlpFhTABZrTJfa948ws8RDTSNYTpYtOCt3luXcSodLMbYlbuLsz44i5zinEo+CxmpGaydsDagPP+FpS/w5MInK01Q7GY7Lw1/iTvOCG9ieuAAXHYZbN1qHIgNGCAl/xo2lMGvRs1jPSUwravkwhpJHodMhfShkT/8IpWbqvHGD8H086WdtSiJnTT/L9w7+TWKSgPPfs4+W7yB6kzAHQlOkUDoOgwaJJNsI7+d226DV18VlVdtrdpceKGUFTUyBH/4YTEfrM20tUo4sQVW/s1bGbCEk6aAFaHaodmF0O7PYpJpS5f9dU/4ho0+uB2iiPwmNfh+ZSa7To+Ty7+4nJ93/my4u0kxVUvNoulaUKXEwJYDmTt+btD0smoj5n1Hp8nLTchx5BjuE2+JZ9Wtq+jSqEu1z2OEXu/2Yv2R9YavJ1mT+PbqbxmWMSzsYy47sIwLPrmg0uKRzWxjw+0bypWCzyzIpMN/OgRcaPr+mu+5sMOFYZ+3LG66CSZPDq5QBHjqKakCGOs+73DAtGlwzTWVb5fhnw5nzu45Ad+XHJfMlCumnFRoVwepL6SSV5IX8DWrauXgPQdpnNC42scPiBokgebOlXTyghAe15MmCQlXU2lhLpcE/eeeG+GBanKOsew6WXgIlvajxsMlu8SQNtoIh2DxLdhqpcbK/bjG0PMpaHcd6O7omlmHSQIVFYntwAcfSDGUuDghNSqOSQkJcMYZ0LevzI07doTGjcXbTFH8VXEVpfJWVgHk28xmIXtcLiGajh6FjRvlXly1CtauNZ6nhQu35mbi7xN59JdHcXqcOD1OLCYLFtXCw2c/zH0D74uo0uPs2aLcMyKrzjhD+n2tp+9HA/UhhqgBnCKBYog5u+Yw+qvR5VK7fIi3xPPxpR/TNCnwgK7rOo/+8ii/Hvy1kmllnBrH+F7jeXfUu5jCYGw8HnjmGTEIhsBkkNkM558v6Tp/+pOs7litsTH10zSZONhsolLq0XITzBksZdgDPVxMVkkJ63q//F5bfhxxjaE0B8MHdae7oPezkZFVEZBAYyd+xue/jjV8vU54QEUL9WEAr4E25uZKgPPrr8aKoI4dJQ0jI8O/IlWT2LdPVv9PnDAmgu66C5591l99rs4g5zfY+rrk6JssxopFHxQVEttBUidI7gwNekOD7mKcabLKMRSzTJA9Tqk0WHoc8tZK2dj87XAkhLGKd7KbV5LHiMkjWH9kfcDqVjbVxsWdLubDSz8spzStCu6ZeQ+TN0wOePw4NY6OaR2ZP35+7QSzEfSd5QeXM+zTYZXSpsoiJS6F4w8er/Z3FwyPzn+U55c+b6hCUlAY02MMU0ZPCet4ucW5dJ7YuRKpFafGcUPvG3j34ncrvefheQ/z2vLXKl3blLgUttyxhWZJVTeiDccrBmShadEiUSvGIg0ZZN6zfz/06FHZF8+tuUl5PiWgCgjke9t7916aJlY/4D7vo/NYsG9BwNeSrElM+tOksFXdYaMGSSC3WxQB2dnB90tMlCIRjaM8RBihsFDuwf37IzxQTc4xcn6DeeeHTvFJHwpDfoy+P2a4KpuSHFh9Lxz4RubrRjAnSDWrjFtENespEVWKGkEeaIg2Fl+u89prMo8wmQKTk2lpomC78kopfuJwyJwolublRUXSVyL125y3ex5/mfoXsh3ZAX3MEiwJJMclM+lPkxjVcVS1nlu//grDh0sfCoS2baVcfL31+SqL+hBD1ABOkUAxwrsr3+X26bcbvp5gSQhL6l3gLDBcje3euDtrJ6wNWzJeUAD/+x88/7wMfg5H4DQxk0nK/A0dKsRQu3bysI+P91eJsliEJFLV8mO6rsvrHo+/TKBPhZCdLcqkdetEkbJggeTn6jpQkg2//QWy5hqvvCe0FZPo1ldIsGWKi67sNNSD8OJtMPccKSGoG0SzzUfBgPfFwK86FRMiIKqe+/FBnvrhUYqdgScIV1whKUR1SnFRXdSHAbyG2qjr8Oab8MgjQrAakUH9+8P110sZT6tV+m0sVGEej0wibDZRKQ0cKDLjCy8UjyAjqXGnTpKeepHXKqOmJhqlpdLmoN+FuwgOTYe9k+HoYiGrFSV4WddYYazO/hP7GfLREDILMgNWtrKqVvo07cOiGxeVKwVfVXg0Dxd9dhGL9y8OmNpiMVloFN+IBTcsoFNap2qfpxJi3Hdun3Y7761+L6CBtg+Xdr6UH8b8YPh6JFi4dyGXfHGJoS8QyEJR7gO5IVd2dV3nwskXsnDfwkr3QoIlgX137yMtPq3S+wqdhbR6rVUltYrFZKFPsz4su2kZajV87kaPFk+6YNUkQZTHixdLZZloB2EuFxw7JkrJPd7iX2Vvl+UHlzP80+EBF+gAUm2p5D6YG1Eb/r3g3zyz6BncBnOFa3tcGzbJFzZqkAQCee7885/BfaBASsrPmBF7FXJhIfz1r/Dpp1H4iDU9xwhVJcyHM94V5Wk0iaCqplodWwGr74PcFVJUIVg1KzUekrtI6lGDnpB2hvwdlyZEkq4TcGFVMYmS1pUviyNzBhueIisvnX7PZnH8eOBFbqtVyKHbb6+ZKlbRxJ7je5gwfQJL9i8pR1rbzXaGZwxn9q7ZlapA9m3Wl0l/mlRlFaumwWmnCdFjhI8+gquu+gNkFNSHGKIGcIoEigGeXPAkjy98vEbO1Sq5Fdvv3I7NHP4sStMkT/brr2HqVFkxsdmEJAp2yW02yflv00YY4YYN/Sv3Phmk0yk/S0qE8Nm3D/buDb5aVO6cOb/Bllfg0E/yEAi4MqJAWj9ocr6Y6jU8XVbYPSWSC2uySJpGuCkQuibv/SrEQ3WsDsWHZcXGccA4ADTFSX50t/u9KSHx1VcvBYLBA7vUZaX7A5vYk9PBME9/4kRRe9WqGXg0UB8G8BpuY3ExfPihpFoUFvoJ20Do0kWq+VxwgSiEWrYUctDhkPHBYvGTtxU/hi8X3kfy2mxCKB05In199WoheRctKr8CX1oKL70kikSPx5gMat1a0gfGjoUOHeR9CQnRS2fzeKRdZrOQU199BZ98EnziUw66DoW74OgiyJwpKp6i/fJFmeK8po2lSF3RKsKnEjKCLZ01A2cw9JOhnCg9EXCBwKSYaJncknUT1kWlDHWRs4h+7/VjZ+7OgMoVBYWkuCRmjJtR5QqWhohx32n/RnuOFh01XEBxepxMHDmRm/rcFPgAmhuKM+W6Ow7IVrATSrKEINTc3p8uuZ6KRZ5L3q1UsdBg8c/EqRbA5PVuUOR3LwqdhSy+cTEDWw0M+lle/fVVHvvlsUqrw/GWeB4b8hgPDn7Q8L3vrX6Pe2beE/C99555L0+d/1TQcwfCpk2SNmDUv8siKUnSC3r0iF5QUVoqZq+DB0v/9qHs7fLvBf/m2cXPGvoynd/2fOZdH0KRFwI/7/iZsd+O5URp4NyKhvaG5NyfE12lWQ2TQEVFYs1hpBwoiyeekIqlsZp7OBwyn732Wvm73pFAh6bD0jFSzjsYTFa4aK14uURrEbQafjsA5O+Anf+F3R94x7wgqWIVodogoQ2YbPI5THHynXtK/aXNHQdCfx/A6Q+vZP3B0w2Vxp9/DpdcUr+IiyJnEU8sfIKJv0/E6XGeXLAwm8wkWBL4YcwPnNv2XH4/9DujpowivyT/pMebSTERp8Zxc5+befr8p0mxhe9ZuHIlDBlibB9itco885JL6vmCcn2IIWoAp0igKOPeWffy2vLXavScafY0DtxzALulevR2bq6Yps2cCevXC3lz9KgEdj6pdqCc2qpAUWQANpv9AWRSkiiMNm0K8IbSY7D/G9j3hfhymCwyodYMdOaWZIhv5d8S2kByJ4hvKQ9Nxew1P1Nk1ULzbsVZULAdivbCjneCfwjfg1DzwK73Ye2D8sAzlMUq0HgwtB0nlRNMNtnfZK1+ypiuwefG0fC+7NZc9tE+tm83HsTPOkt8G1JToxtc1yjqwwBeS230kbyffy4r8llZ8uAO5d0QFycETLt2svlIXp+M2e32jwMlJUIe79kjxE+OsbVKpY+Ynw+vvSZeRboevF2NGokisUsXUSd26gStWkl7ir2LiL48fZ8iUdP8efogq34eDxw8CNu3yxi3bZv4FB0sU8VZT4/QaDAFaAY0BZK9fzfw/p6E1Ns0IdV2NWTx0wkUACeA40C+9/fD3q1CH/7598+4as4thmksIOk8a25bQ7vUdtX/LBVwuOAwPd/tGdRDx2628/FlH3NV96siP2GM+862nG3sP2GcL6KaVIa0GYJami0VWrKXQv428a4rzgL3CRnPTRbvIkJxcPIuALY64YDHctKUU55LHrAkgTUN1d6U80bOQLEaGzB8ufFLxn03LqCiKU6N45LOlwRV8+i6zrTt0wKmF6iKylsj3+K2frdV6XMBDBsm5eLDuUQ2m3h49O8feVDhcMiYdM45Mq8pi7JtCebJZFbMPDbkMR4d8mhEbTlSeIQ2r7cpVw22LOIt8ay+dTWdG3WO6DzlECYJdCRLx2QqX+JaVWW8ryon9eijUmwiVAogwH/+AzfeGP3gsahIxvPRo/3z1HpHAuk6TG0vc9FQiGsk1SwTWlfNd84I1SWBfNA8shhyeDYc+EF+V21CDMWoilVZJNxYiMNAAQ8yB0pPj3kzogJd1/l84+fcOeNOil3F5VQ+drOdTmmd+HnczzRP8rsz5zhyuPTzS1l7ZG25uYHNbCNOjePl4S9zU5+bwvYG/P13UWTn5xun8F9+ObzyiszRarpMfEFBFM5ZH2KIGsApEiiKmPj7RO6ddW/A1SUFhSRrEkPaDqmWSeee43vYmL0x4Mqvqqic3vx05lw3h+S46Dh26boEdnv3+tQ8Ot8s3sDv6/Jo4OpOotoQt1vB7fY75ZtMfgd9s1kmFCkpojTo2lUCy7ZtRUnUqlUVvAA0N+StgyOLIPNnOLFBSCJF9a+EeJzGBFFUoMDYCt+9qwC2vAzb35Q2hvILsTcTGWxyF2jQS8rKJ3UQAkt3+1390Sm3OqxYoPSoSGJzV8Oa+4KexnONzksviQ8UBF6lU1UxThw3TozDfT4ssWD23W5pQ3y8BOD9Ag43VUR9GMDrSBuzsiQgmzZNqnUdOiQPUbtd7gOXy5gwrArMZjmmyeRXCaWnG3szuN0wZ45I93/6yZtd5Q5fQZCRIeOI1erfTCZRAjidsh0+LClox0MUXgHQib73SzQxtx0MHw+Kydjo2apamTd+Hme2PNP4QJpHFCtF+8GxX9SNWqmfGPeUyE/f+Or1YduQn8PA+W9T6nEDChW/Lp+R9DdXfcPobqMj+7C11XecJyDLG8gc+QWcufL53YUYm7YqYGtSZhGipZD8voUHxVxm4cEt6Q0+9ZDjQPCqQEGCr4P5B2nzepug5t2RQkFh01830bVx1yq9b+VKIWLC6csgY8ddd8G//+03WK0KXC7Z3nwTnnwy8Hjmu10KSgto9FKjgGmUIKbQX135VbXNscsi7cU0cosDp5XZzXZeHPYif+v/t2od+9gxWbDzVSXKyoLbn2hKcnFwIjuLdNrZpGKNrvtJc02T8TMlRbxTmjaV8bVtW1msS0+X/w0YINfIh5wcWTwI91q/8IJUtYyWIqioSEpWX3tteeVrvSOBAHZ/ItUpw1C/YGkAwxbLHDJSIihSEqgiPCVwbCXkb5Y5a+5qKNiB7i7AjVSsMqsWFF2TcRHN/136FJEmszyDwK8yUm2QmAGpfSQDIKUbpJ3Bg48kMXGi8Tzm6qtFvWK1lr936xqmbJjCfbPu41jxsUpxpMVkoVfTXozqOApVqUzsa7rGnN1z+O3Qb5UUuxaThZS4FJ4Z+gy3nn5rWG05fBhuuUXI1dLSwFUAFUXK3k+YIIt1TqfEENFeWC7rI7t8Obz7rixyRoQ6Mj+vbZwigaIAXdd5YuETvLTsJcMV2ob2hmy8fWO1zBZ9uPGHG/lq01c43JXPEafG0S61HYtuWBR1k8780nzGfjuWBXsXUOQqwm62079Ff7675jsa2htG9VzhQtd0jh3OIXvfAfIP76c09wBa4R7i3dtJtewjLf4wVnMpqsmNavJgUjTMqswQ3B4VTTfh0VQ8uorLbSW3OJ280tYUqh0hoQPW1FYkN21F4zataNQyHZMahLjT3HB4lqiDMmd6VUtVkcXaJb/b5Au4LN5UAu8xXPneB2WY8D6wi4ul6ttzz4niQdeNV+s6dhRSyFcloWVLKY2paZwsN+9LDfKpLnxqC03zbz4iID9fHiJ79ogH1Pz5YjpX0aCz2qgPA3g4bdzymlSS8gWMJrM/dSSusQSU8S2jW4Jcc1NyPJP9O7LZuz2fPbud7NwJW3Yms+tgE47kNcTlseD2qHg0X18xo6ChmjyoqgfV5MFs8pBkL6JN+lE6tz1Gl05O2mWotM1IoF3nVNJaNkeJC6/dHo8QVL/+KsTQsmWyku/L3S8pibyyhg8Vyar4eAlsZsys2yRQZhJ8dhrw4ouG+wxsNZCzWp8F7mI49hsU7IDC3aJiKdwtKUw+YsNkFdJZK/US0B6MiQ4TKCorSk0sKFZkP80FJhXMSRKQ2BpDXCNGn/0S7RtVjTSohJrs37ouatOtr8ChaV7Sx4DQj28FTc6GpsMgtRfYm4O1oT/9C/zFCxTVn5Ks60ig4w16NCeg+IO30mxwHIJjy6UKT/YSuU4GwZemaTR/tTlHimJfIjclLoWcB3KqXK7+jjsk8AqXHAAxD37lFVF0QOj0DV8FnyVLxO/D5/8TCL7bZdr2aYz7bpyhH5NVtXLo3kM0im8UfsMNcMEnFzBvj3Fa2bltz+WX638JeZy8PBkbf/tN0mzXrfP7rvnI89LSyqv2qirfaXq6EOdllT+axslFPKdTUvazsir7+yiKLNhZrfJ7XoCCZ7feKl4h4arFH30UHnwwciKosBC+/VbURRWHg3pJAnmc8H0z6fvhwJwEQ+fLwqIlghW8aJNAFeDRPEzZMIVH5tyHpzSbJiaFgU06cHefP9MxMc2bNut9/ihm2XxlzW2NRPkU18jQB0nX4f774a23/Pd0RXTrJr5Aw4bJvV+XUpk2Z29m1JRR7M3bG/NzNU9szo/X/ki/5uGtxm7YIH31F+8wZRRDWCySZTByJPTpI6n8zZr5xxdVlf5u5Auu6xIfuFx+z9mjR8VU3ucjO3++/3lSL/t3HcQpEihCaLrGnT/fyUfrPjIkgOLN8fxywy/0b9E/onM5PU7OfP9MNh7dGFBtZDFZaJrYlKU3LaVVSquIzuXDxqMbGTF5BDmOnHKyZqtqpYGtAdPHTg97MKkuPB4ZBBYtEtn4xo2yClY2Xc3pDE+OLEFO8M4fF1f+uG63pE5lZYVR2EBzyarHkfnia5S72hsQmI2rn0UTtnS4IqvSv3fsELXFjz+K1NNikc9WGlipfhING/p9oFJT/R5QFotcF5fLn9538KCoxg4dCj4ZrPaw4sqXQKn4EDQLo3TyVw3wTypUr5m4WYI0ezNIaAdJGUKy2FtAfAv5aU2tmibekQm5K0VZUbTPm164D8auhxNBPmwK8K7Vm9PkzRM6+VOR9vpSTRRVJkH25t7qUx1FCt7u+uC+AK4CyF4m9+Ph2dKuaqSy+NKugkMRQvPkcUuk3dcU+lf0qoC8PFEi+lLOtm2D1RscrN2ah6egEZrLgqIoJ83py6aDaZrcn7ou92qTJnIPd+4sqsS2bWVr107kzNL8uk0CnUSgDqS5JGXp8GzInA75W8vI8YsxJneQa+O7732+NYoZ8BEW3mMUH5I+GAwmK4wJMaiEg5qaoB1fC0vHSb/wFBOwIEGDXpLS2/ZasKaJqieapY/LQvOICkC1icdQg+4Bdxv33TimbIiyqXAQDG8/nFnXzarSexwOSd88dKjq58vIgFGjZAW/Xz+/shDk1rDZJI38669lTrBhQ+hj+t4/YdoEJq2ahG7QJxrZG5H9QIiSV2Hi6UVP8+TCJw29h2xmG/kP5WNRK5dE3L8fvvxSiLSdO4W4djgqB7hpaVLm+vTT5bvyLeCkpUnQVVoqz+NQ3UVV5XvVNBl7s7NlIWfbNpkzrFoFW7cG9pnbv1/G1aooSgcOFOKoefOqB+RFRaIMuOUWUbgGQr0NEre/A2vuB0+YRQcUFTr+FXo9K/ObqqqCXIXwdYjcmmqSQL5007/P/DvZRVLVSlXUk+mr8ZZ4BrUcxOsjXqd7k8BjXVWwd68UyPj+eyE68wM8rtq0kQpYl1wi92BiohALPm/TaKhYfHNij0f6bXa2EBjXXVd+P5fHxbOLn+XfC/9teCwFhXhLfJVM+jVdo8hZZDjGAdxz5j08O/TZsP1k9+8X1fZHH8lc32wOzwusWTMZzzt08Kfy22z+hbjiYtlKSvzK7V275BxG3qZQj/t3HcMpEigCuDU3474bx7Tt04wJIEs8b130Fjf0uSEq5zxSeIQe7/Qw9GZQFZVUeyqLb1xcZWf4ivh47cf89ee/BvWf8Ema7zjjjqgaHObmwjffiORv+XIZoH1eJIGQlCQDjG9r21YmoC1aCKNsscig5Vs188nHs7JkkrN3r0irfVug9JHqdAePy0Pugb3kH9yK89hWLAWrSfJsxKrnEKfmE6c68GhmXJoVXVPKpaQoio5J0bCopZgUnWJ3Ik4thVJTOoXmXniSe2Nr0oWUVl1o0Kw5iim879/jgbVrhVTbsEEIogMHRFLu8fiNfp1O3cu6V+26ms26d4BXcLlkEtqggUz2MjLkAR0U7mIhVbKXQdYcyN/ircjm8Rt+33JCvFOMkAK8HU5rTV7iwlxGFaFDXEMYtUkqWFREwS5pV+ZMyFkmRItqDZ2SaLIKiWNvXiFdRBUSxhdwuwvAcVBSdgxTPbyEyzUBJop5m8RL68A3YmCs2sFVRGCjYkUUHPGtvV5arSChPSR3lID3JCmgeqVfZUiBor1ewquMOa7joLe6XxlEuIoIspL46vJXefyXxylxl6AoCmn2Rv/X3nnHSVWdf/g5U3dmKywLu3QQC4IFu2JXFBtqVIwYS9SYaNRo1Kg/Y0+ihtiiRmOXRI1YUOyIEbEiiKI0KdJZYFnq1mnn98d7787s7tzZNjCz4Tyfz2Vmdoa579xyyve8hX+d+iKH9T6mISF9LBZftU6851tFaQdzAm0PevSQRstmw7cwbyysfNMSmmuSC3rKDV33gS77SkLRgt0gr79ci95CuW5jKTyB7EotsQjUrbMSIS8UD6OtCyVvTr3VJ7XzfNfVyU8rL4eDD2n5pA3aSaN1PJ+J7eEQCEi7P2CAPJaVNd4avEt+uBPm3mNdr0ls9pfAfg9Dr5PjHppZwLsL3+WkF0/a7vt9/rTnOX+v89v0f776SiqMtsUbqCk5OSLe5uVJv1RVJROFlnKcNcXuv/s80IeVW1Y6fm7EwBFMOm9S+w1O4INFH3D2q2c7Jocu8Bfw7ph3Gd43Xvlo1iy48kqYPl3armTH7rDDZEJ5/PHSJNTWynXta38hQEcSK0663c7eWfffD7fe2nKlsERcLvHguvtu2U9urnO4jh0S4vNJDqK//CX1wl+nnSTqGLy/H2ycRVJR2gl/Cez7EPQ5XcYS3hTCjj1WiVTBtEtl4SAV7WjTpy6bypXvXsnijYsbco55lAePy4NGNywq20mMT97lZP464q/0L+rf5n01pb5eEs7/618ivmzZIuMCJxF12DDpL0pLZe7Qp4+MV7t1k7Gr3cfYoZMuK1NDNCr72rhRhJ5Vq+IFcdaulbnFrFnxeyLxcpm0eBKXTLyEyprKpNEdPrePod2Hcu1B17Yr32t9tJ5Hv36Ur1d/nTT0NeAJUOAv4PGTH+fUXU9t0/xt2TLxDPrvfyWfbHm5tAuRSBq9/ROwK7p5vdLWFRdLWV1kcQAAIABJREFU8v8Of2lLGBHIiEBO1EXqGPXSKD5f8bmjSBLwBLhgrwt47OQWEg63kW9Wf8Phzx6etOEAUY4L/AV8dP5H7Ntz3zZ/f12kjt+8/RtemftKs5KEl+9/Of+Y/o9mJQmP3+l4nj/9efJ8HfOx/PprcQefOFEa3WQDCqVk1evoo2W1cJ99ZGBQVxevbGSrzK0hFouHm9irjFqLQPLOO9LQffGFc4I0kI7g++8lF8Inn8iqWUVFfNBiu1LbOU9shVupGIWBzRTnV+LzhPC4IrhcMQlVi7mpqQ9SWVVMVV0ethhj50ywOyXbW6moKJ7Qu0VCm2SQUbNCxIaalVC1lM3rN7F8pY/l5QUsX9eDnyoG8dO6gdSFA4QiXkIRH+Goh1DEh8cVxesJ4XWH8Xoi+NwhSgrWs2vpXPp2W0nf0o3061VDWU837vzekqw7UAaDLm3eAG+eawkXr8vE0h20JqZJPKe8hVbuDctzJ9hbPHpyB0huDtuTQVnxa7GolXMpIhPVqmVQtVB+s+1ZVLNChKZEEgc+tWulAsaCRy1XbZU84aFyS66nbodIOdS8gSKs+LuDJ8/B68YKr0nE5ZXwwPCWeP6WrYukhOx6K0ltoo3REKx4DebeK8JMLELSsq3uIPQ4CkqPhbLjJZ9AYiiL29+2lURbENJRK4dMAMKbRcArf0/EslMWtv77kvDj+h8Z/epoFm9YnHQl8YzBZ/DIiY+kLR9au9meg4o1k2HmdSLAxOotV/om5HSH3qeJF0vx/nKNuLxyftuRly4psZCItu4cuU5XvgW7ps5xUlkp7eO0aTBligyUN26UNjQnR9q3H7eU0kM7C3Jr6EEZzT0em2ILgi6XDNjr6qTdPP/I8fzzwl+iYg4LHIVDJPGqOyd9FXjSQHWomt0e3c1RxHApF2cMPoPCVoZhNvrucDXj54xPmmQaoFuwGwuuWECXQJc2fe/YsVIZqi3iwLZAa8mjtPPDO1MXSa4eeFwe7jjyDv7vsP9Lyz7X16yn1/29HPMPeVwebhx+Y0MVthtvlOTJiZ5PiRxyiLy/664y6WrtGGd7EI3KZHr27LY3cz6f5JA67TTZunePey95vTKOeusteP11GY+15lrqtCIQSP/+3rAURUdS4C+Rvr3vaCg9mnjFSZe0/1sXwYpXYOVE2PANKb1EbdogAn1b/i1XvX8VM8tnNpo/2KXLx581niUbl3DG+DPYWLex4V70KA8et4fz9zyfO4+6kx556cvkXF4uVUtnzJDFzzlzZKHZrm7qtta4WooosPOeRiLOp94WLBIXnevq4gLG4g2L+fXbv+bLlV+mnDvefuTtXH/I9R1aXNda88Q3T3DNB9c0mrMlkuvNZa8ee/HkqCfZvWT3du1n82ZZWF6yRLx45s4VoX7lSnkv0cMq1c+x00vU1oro36uXLBzvvrs8DhggBUJK0pHxxIhAgBGB2s3Zr57N+DnjCXqDqCSeEjEdY6/Svfj0l582i6Wvq5NkehUVjR/XrZMBsu2pYse2xmKNVzo9HliS/wJTCy9FoRrytCRu9dF6vC4vK65ZQXEwiTeDA0s2LuGEF05g+eblzbLS/+PEf3DhsAt5Y/4bjHltTKP3czw59MjtwXvnvtfmJJIgv//ii0W9t8WcpvTvDzffLPkCPB4ZOLQ6uXQ7CYWkQXK7m7ssz50rnkoTJ8K8edLwh8PJV+4GDpRGrKxMVhv69ZPf06uXNGg+n+zDDm2JRmWzG8S1a6VBXbIkngyyvFzcsxMdA5LesrGwJOmr+FSSnW78Fuo3iDeKjkopzmaCgRIvmJxSCJRKmJknPx7aZnvO6EhcRKivkMo5dWugbm1zjxA7B8bZVscXrYcl4+DHB6FqibNwEegFPUfKwKZkOPi6xUNclAc8gbaHG9lhULGwZZdfVsXWfyX5ncrfF/GiZhVMv1z+plzJB2U5pdB7FPQfA8UHyrFQnvZXgEtFeCsNotGaybLqV/ElfH62JJh1SihZNhIGXyfHL1ovglQb3IvbRaRabG3ncYjGovz1879y19S7qIvUNbg2e5QHt8vdsJKY484hz5/Hv0//d1qSubab7TGoiFTDjKtEMHWquhIog/3/KSGTsUjHckW0lVhE2oYEwmFJTP7yyzBpkrT1dmhL07BRnw+GDJGQlrIyWY3t319CUnv2bLwqaw8q7dC/aFQGnGvWiOv6Tz/JamF5uTzOnh0PV1n7WHe6F6QI+TnhOyjcI7tm2cCY18YwYf6EpCKG3+3nwr0v5PGTH2/399/80c088NUDSScMfrefo/ofxbvnvtumiYnWkidiypTWhmxvG7SG5757jivfu5KqUPJ2ssBfwGujX+PYgcembb8lY0tSVtUbUjKE2ZfP5vnn4fLLnUOqhg+HDz7YdiXW08GPP8qiXEcLDeTmNvb8aqvXF3RyEQhg7lj44Y7Wh4UlQ7lk3ObJS8gv2Y5w3VaIQAsrF3LtpGuZ/NPkRv21QhHwBPjLMX/hqgOvamg7ttZv5ddv/5o3f3yzkRjic/twKzdXHXgVNx16U5vKm7cFreXaspOqL1lRy8ez5zJ19iJ+WhJDb+6JP1JKoa8rQXchbnzN5mOJ87Ju3eJRCKWljbcePSDiquK2j2/jka8fIaIjSRP6e1we8n35vPnzNzms32Fp+60zVs/gxBdOZHP95qSCtELhcXm4aNhF/OPiCbjWrUvbvkN4WUlvqsgjhK9hC+Mlhgs/9fgI4SWMjxBBaujDCnJo4Tpdu1bU4vaS6fs7SzAiUDuZvmo6s9fNTvqeBjZWuuhVdSpL5xfx9dciGFRWSmcWiYh4YSvFtjeHnZ/F5RLVOJkoYOdh0RoY9AHerqtxW66JWkM0BpEweLwQ8HlZ9Pq5lJS0bsA2cf5EfjHhF1SHqxs1UAFPgIdOeIhf7fOrhr+NnzOeC9+4sNFgUaEIeAM8dcpTnLPHOa0+lnPnygpXbW3y5K8+H9x0E/zhD5nP7l9bK8nnHntMOg47rCwRt1vK3R53nJRZ3GMPOTfhsLxnr063l/r6eLZ+u1T2zJkSG//AA9aHYmERCX56TpKdKk9yzxp3DhQfIJUWSg6HoqGSe8abb1UKqkfEFnfcs6ahzrWWTWsRk2wPF2XFpeuwCBPVKyXRaeU02U5dCms+gi8vEI+kpIMcJaLKHneIx8/2nMzaHnZLX4Jvfmd5WiRxA/PkwR63w86Xiai0PSfbNvMfhFn/57xiGOwLBz4JJYeIvZ2EuRVzGf3KaJZuWtqofHXQE+SpU5/i02Wf8vys5xsNHoPeIKN2HcVjJz1GUU7R9jd6Ww8qtIaPjpJ7qJnAajHgAtjvEQlfcm+D2JA2sGSJVCgcP15eV1U1//mFhXDUUSISHHGEDKATPTo7kqOhqYdnMChi0Oefw88ieeR4UkyuTl8tYlpHeb1UBPF244Ix4pkzbtY4LnvnMsfV41xvLsuuXtamRZ+mVIeq6f1AbzbVJcn+a+3Dnsy1hZoa8dqdNq1joWEdQWsY9dIo3lrwluNnfG4fa65d02Zvp1SM/PdIPljsnE/J5/ax7rp1/PaSQl54wfl77r9fKqhlmS7ZjOeek6Tg6ag42RE6vQikNfz3WBk7betcki2RQgSasXoGF795MXMq5jTzInQrN/m+fE4ffLpju7SwciHvLnyXSCzSKIeNW7lxKRcjB43kuVOfo2sw/UVoKqorePPHNxk3axzTVk3D7/azNbS1ofpmTMfwu/24lIuS3BLGDB3DWUPOYljpsDZ76ExZOoVTnjyaWArPqz3XwusvQ1krcu20lcoAjD4Lvurt/BmXhq13p3/f24yO3H+Zvr+zBCMCpYmZM6VM5eTJ8jwSibv/JYoExcWy0jlkSNwTpKxMvEGKi2VQHAjEY0/tLbEqE4g77ObNcQ+i8nLxFFm8WFwd586Vz7TmFEZiEW748AYem/FYsxXAgCfA30b8jcsPuLzZ//v39//m0rcubfZ/gt4g5+5xLg+f8DB+T2pXnbo6cfVbutTZ1okTpfxgS5VCtjUTJsCvfy3HNdkAJycHrrhCEtOBnMdtEaPvRE0NBAMxWPYyzLxawjSSlTZ2+WGni2UrHCITyraGAbWVWFS8GFweWP6KeNc4eTIUDoFDx4uAkQlhBUQ4+2y0s7iSvzMc96VV2S1DF2bldJh8hLONOd3hpHmyEpgk8Wg2EolFuPvTu7n7s7sbrSYC5PvyeWfMOw0rZGO/GMttH9/WqP3xu/3k+nIZd9o4TtplO+dN2daDisXPiBeQ08pwt4Ph6MmZux4t6utFtH/8cRFgkiWS7d9f8oCcfrr0Afn523dyW//FVfhXPOV87/QfAwc84ViNptW0VHWnNYzRLKhcwLB/DkuZe/DWI27lhuE3dHh3T818iqvfv7qR+JpIwBPg84s+Z1jZsDZ9bygEZ50lY6TtLRDk5EB1TYyie4rYGnJ2K+me252116U3L9g9n93DrR/f6pgcusBfwPOnPU9g2WmcfrqzSLbbbiKi5eRs33FFezj7bAnfypTgB/8DIhBIiPrbu1mh6hmckCYRgRZvWMwZ489g1tpZ23z3CsU5e5zD06OebnUiYyeWb17O6/NeZ9ysccypmIPX5W1o6/J9+XhcHq484EoGdhnIo9MfZfa62YSiIaI6itflxef2EfAGGL37aM4eejbD+wxvfdLmzlJ8ojPQND9iW8mG+zsLMCJQBwiFpDzlX/4irufJvEIKC2HMGDj5ZClDbGei9/nSL2rEYjK4sjPSr10r7ompmL1uNqNeGsWqrauauQn63D7OGHwGIweNdPz/U5dNZdyscc0GOF6Xl+653Xlt9Gsc2PtAx///8cdw6qnO7r577in5eDLtAj1hAvziF86D16FDxd3d789g6clYFKaOgnWfWKE4SRh4EQwbK54CmRBYqpfD24OdBSBPPoxaJN5I6cpb0h5aWsEfOQOK9t72IVWp+PKXsOQ55/f3+gvsdm3GPUJayw9rf2D0K6NZvmV5o8mux+Wha6ArUy6Y0izUNJlHIsik+MSdT+SfJ/+TroH0ryAmZVsPKj4fA8tecn5/nwdht9+1//vTgNYy0X/3XecJ4O9+JwKQxyMLJRkhGoIPD4HN851Ftd6nwQFPiqjWXmGtw55AUDe6lj0f25NFGxY5Vnvpntud5Vcvb3HRpTVEY1F2eXgXftr0k+NneuX3Yt5v55Hvb6GqUNPvjsJFF8m4aXvlCAoGZex1/4vfcdizhzmGggGcMOgE3j333bTuf/JPkzlz/JmOyaEVil8O+yVPj3qaZ5+VhSQ74WxT+vWDO++Ue0zrzC+MOREKybhu6tTMeQT9T4hAAFsWSlsV2pCiUMQ2JkEEqgpVcd8X93Hn1DuThjTZ5HhycLchTF+jiUQjhFJ4PRX4Cnhy1JOcufuZDd46LRGLxXh74ds89NVDzCifQXV9taR0TPBacis3XXK6sE/PfRhQNKDRd2+o3cCsNbNYuEFyGyb+P69VLGBgl4GcM/QcrjnoGgpyUuQm7IzFJ9pDttw7DlTWVOLv05+8Dc59QbikK951lY7v/69gRKB2snixVGjYujV5mbz8fAnNOeccudYzLWIk4+FpD/O793/nOLD0uX34XC1PIMOxcKPy8U2588g7ueWIW5K+N22aePk4DQj79xevpkDbk+Onla5dk1cMs5k/H3beOcOu2nPugdl3OQssfX4GB4/r+Op2RyifJB42YYfSXsX7w9H/TY9AlYYJmCOnrYJgz45/z7a0cfC1sMed6fEM6ZCd8ZCWZNSEajhvwnm8teCtZmKyR3noFuzG9cOvdwzxWlC5gIe+eoi6JiFSHuXB6/byf4f+H3884o/ttL0NbOuBzw9/grl/cfZe6TsaDnw6o/fOFwsO5rh7JlFdn9yGQYOkWkpWTF5jEUmkPufPEs6abPLhDsLg62HgheJZB+n3tGrBW+iSvIt58YcXUyb2fHrU05w99Oy0mTRp8SR+9vLPHL2Bctw5nLDzCbw2+rU2h0VoDb//PTz55LYXgnJzYcQICUm8f9q93DblNsexitfl5U9H/4k/DP9DWm3YWLuR0vtKHZNDA5TllbH6Wil3U1EBt90Gzz/vXOa6d28RWUaNklB6l0sWIFNV12ov1dXi2R4Misf2zju37v9FIjB6tOQxyoTnV4e9kLJpIlu1BCYdLIUtHBK3b1PGaELREI/NeIzbPr6NcDSctDBNjieHQ/scyv3H39/ukOz56+dzyVuXsLZqbdJ7NdebS8/8njx8wsMct9NxSdsfrTXTV0/n1o9vTRmKuS3wu/2MO30cJww6oc0ieYu0tq3NtAdLNt07CXxb/i1jvxjLhPkTUKiGPjXHk0M0FsWlXNRH63EpFzmeHPoX9eemQ2/irN3PSssCSzZiRKB2MmCAJJ9MlsAYpELUAQdIZ5RtxGIxRr4wkg9/+nC77fOg3gfxyQWf4PM0FpW0ljKnn3ySPB8QwC23wA03ZFZI69ZNcjo5MXu2uGu3N39FWvjyAkm07MTe98Ju16Sn1PG2Ei9cfjjpB8jt33E7OxqK4Q6mENTOhIOfy45wESdcPjh+ulQo66gw0FE7HXIKvDz7Zc6bcJ5jqITdGSdLvp9ITMccJ8kApbmlTLlwCrt227X1NreVbT3widTCO4OhegWOpYMPfBr6nZ2x63LaogM45i8fOYpAAwZIuHKmRf1GVC+HBY/AQiuhcsTBLTVvJyg7DnqeKAnWG6r9xUB5rQT1bVgFsCvrveK8cvzqVrigMugYBgaSWPiHy37oUBWZZBz2zGF8vuJzx0WioDfIQyMf4pJ9LmnX97/6qiRCdgqv7gg5OeJlds89EsLtdsNBTx3EtFXTHP9Pgb+AN85+g6MGHJVeY4DSv5Wyttq5v8zx5DD/t/PpV9Sv4W92mevnnoMPP4znFEyWW6tvX0nIPHiweAvZidRLSqBLFzkWoVDyFAN2mgFbcKqsjBeiWLpUcnt9+61US3WqWuZENArnnw9vvLH9hKBAAPbbT7yQOkS2TWRrVsIHB0vhjWQ5CrcRUX93Xhg0lusmXUdNuCapMOxSLikec9I/OG/P8zrcFtVF6rj2g2t59rtnU4rfg0sG8/AJD3NQ74OIxCJMXTaVl2a/xGtzXyMcC1MbqiVKY9HM5/bhd/s5esDRHNz7YILeton6Gs389fP5cPGHLN28lJiONfOIyvflE4qGOLDXgZy/1/mM2nUUJblpKGllRKA2E4qGeG3ua9z92d0s3riYukhdw/nK9ebSp7APT5z8BINLBnPTRzfx7+//TSgaavhMni8Pl3Jx2X6XccUBV9C7IEVSpU6IEYHaSUmJ5ONxYvZsKeOZySTGydhUt4lT/3MqU5el7iFbmnQlw2mwaLN36d5M+sWkZo1hZaUIQfPnO68MHnWUDIa6dBEvq+3Ne+/BmWc6D2R22UXCwfLzMxgOtnEWfDjcORTMXwIjvwFfl8yLAu6AlXA5yWQ2UAb7Pw6lx8jn2hsW1lGhqscxUPmV8/HscZRMuv0l7T+e6RDTvEUiViXzZFAe8Qgaegvgkolqe+ionU1EoFA0xLHjjuXT5Z+2/zvbwS2H3cKdR9+5bb58ewx8ti6GT0ZB9VJngbLHMXCI5fHnyW/f/dPO8601XPD487z6zfmOK/GXXAIPPRRPkp81REOw6i2pvFb+gbXirpzDxTx5EOwDuX3kMdgXCnYVAdsTFBFbeeX466gk2tdhCG2BqsWwdQHUrIAl/0r69UvCsMcyqE5xyQS9QSb9YhLD+w5P/gEds9pYa+aPlWwQHf97w3tY14ooAz+sm8OBzx6ZUlzN8eTwzaXftLu0cG2thNPff7+IFJEOzm1dLrmmzjtPBKAuVn7nukgdhfcUpvTG8bq8VFxfsU2qEZ304km8u9A5zCzXm8uDIx90FNS0FjFmxgz4+mv49FMRU+vqRPDyeOQzkYimtha0btwW5eRAQUHjakaxWLwCbSgEmzY1b558Pm1VLlUNJbTb6mETi8GvfgX/+c+2F4KCQfGMevvtNLQtWTSRbaB2jXgE1a7e9smi3UH0sPsZ8uFDzFs/D4/Lgy9JaLlCMbBoZ/5x+ATyo/3ZtIlG25Yt8dxw9vUWDjcudGM/17px1a3ywGQ+LBpNVNUn7M/+RxNB8gbuWXg4i6q+pSYqAr7P7WtWlTmmY+zbYw9u2u8iRpYNxR3dKoVJwpusAiV1VoXaSLzqrV3wpOHvUUv0d4HysLiuhgeXzuHZVT/iQhFNmAPFNNTHImjrGB3SY3c+PeNplL8L+IrAWyi5ONuCEYFazex1s3l42sO8+MOLRHW0We5Iv8fPDcNv4JRdTmkU/rd442Lu+uQu5lTMafR/vC4vCsWBvQ7kN/v/hp8P+TmubM/S3wo6LAIppUYCDwFu4Cmt9T1N3lfW+ycCNcCFWuuZqb6zM4hAX34pwkU4nLzsae/eUhJ3771lFSZjuQ8S+Lb8W0568SQ21G5I6mYZ8AS4bP/LuPeYe9ut5N/7+b38aeqfkg4cvcpLQU4BE8+ZyCF9Dmn0XiwGjzwiCUXtsqDN/r9XysOfd56IQqGQDG621UQiHJZBi98fr2ryq19JWFgyscrrlXwHf/pTvPrb9lzxrqqCvJrP4IsxEj+eTLxw58CgS2HobVLty56stJWOigInz4cvL4TNsy07k7Q13Q6S6lslh8uAxxMQ75Z00ZKQdU5MJmgzrhD7kpVfV26pyLTTRVJhLVovk29XGtXfluw8Yz18/WtY9Q4QSz44DPSUZLcDzof8XWTAk84y8S3ZmCACzSyfyehXRrNs8zIiseazPpdy0a+wH4O6DmqzGB2JRZhZPpMt9VuIJfGW8bl8jNhpBM+c+gzdcztQXjQZ22vgE4tI2Oe8v+EoUrh8UDoCBpwHvU6ylv497RcBm5LifIcjHv78U5ixY5PnyQNJjXDHHeIlUF+/bcJYnIjFJIy7MNVcX2vYuhDWTYXy92H9l1BXIYN/e+AeCzlXaUsDL22Bi9Yh7bMt3Ihx1lPNqd3K+M++J8cT+7sD0v64A9bzALhzrbbTb1V4jAs94Iq/BksYsoWiGJd9Mpbn5r8X32/DQ/w6vm/EvVx+0O879FtXrJBcOB98INdBW8PE7H52r73gqaek8EYik3+azBnjz2BLfZLYKovEkKx0M/bzsfzx4z+mFKFOHjSSt46/Qyb4tauhZhXUrpIJamQLhLfKAklOWcP5rgkVsHZzCWs3dmHNhi6s2VBIeUUBy1bns3x1kDXr/GzY5CESVUSjilgUojFFNKZwKY3LBW63xu3SuN2aYCBG95IQvUvr6Nezit6lWygt3kJp10306LKR0i7rKT70GlQbhWWt4Ykn4PrrG1fCTRcej+TZvPFG2dIy3s6CiWxSQhthxtWw4hXn0OCO4A6KSHHQc1A2gpdnv8yKdVtYuRJWrBQxcsMG2LpF7tPQ1gI8C89k0EA3Q4ZI2969uyyUd+0KRUXyWFgoi6Rer4zxE7fEojd2UZxYTLb11ZW8s/hNwpEodfUyDq+pgZpqqK6xUnJscXHKybUEWQW1K6FqqXhMhbdAuAoVq+XwgItd8rtDl70g2BtyekjuSX83WRj1NRVnXI0r4irLULsyboLAXhOq4q2F77GlbrMI/dFaqTIbqZHxbaSKoK7l3ONfAF8HRGYjAqUkFovx5MwnuW3KbSk9L21vsFTz3EgsQm241tG5wePycPaQs7n/uPvpnpfmseR2pEMikFLKDSwARgArgenAOVrruQmfORG4EhGBDgQe0lo7Zwqmc4hAIC6zjz4KDz8sKnay5Ma77SblMo8/Xtx0a2tF5d5W3iLRaHwA5ffHBZInvnmCq9+/2nFVL+gN8qt9fsUDxz/QYVfOuz65i3s+v8fRhT3gCXDXUXfx+4N/32xf1dXw0ktw771SztcpQaLPJy6/hx8ux3bAAOl07IpssVhchHEK0YrF4tXblIqH7lVUyKB08mTx7vnqK+l07DLvzzwjgtWiRfK3pvYpJYmi7RLxw4bJClVdnbxnlz5uj4icaDPI965fL6uD77wjeRaIReCnZ2H+/dIZgpSHT8Tlk2pCpcdCz5OgcHB8tcPllQlFG5L6NaM1ooDWsPZjCcVY/Z7sN1kohssLJYeKGFQ2Aor2kk46WicrM8olE57WilmtCMNosBGkE1/2Msy7TzwwdFS8mJriyZMwke6HQ9lIyBsAngI59rEwoKyJWitUy0htXMx5tYXYetvOqiWw4FFY9IRcaJGq5J5W/mLoNlzOfclwEYj8xXLu7UmKy2ddAw7nMRZOOP7uVh3L+kg9t3x8C498/YhjOxTwBPj7CX9vd4gJQDga5sI3LuSNH99I2gb53D5yPDk8cfITjB4yOn1hNNt74BOukvDPufdK9RgddlgdVlA0FLofCT2OkLCmQC8Z9MZC1v9xiXCZOOBN9BixV0Tte+0/LYixYzSrV8Pf/gbjxkkbWVPTPHw6JwcOPVTayaOPlv7SXhl2uTpWCcleoEn8rkWLJEzkrbfgvvukqqa9bdggAv+mTdKXFxVJ/+H1ig1+v6YoUElX/wq6+FfQNbCCYv9Sir0/kudaSoByvGxFEUURQxFDo9C4rNeaGG7ARQw3YYqooRdbogOpDO9CZW0/Kuv6sLFett2CL3Nmn0udf2DxAXC8c3jTdsGOK+rQV2g21m1k1ZZVzFq4nonv1jF/6lAWfNMTjwfCIRehUON9eDzS94VCkvR59GgZB+y0U/J9/P6D3/PQVw8lFYZtTtnlFCaeM7FDv8WJKUuncNp/TnNMDg1weRcfj3ZL4d3xP3C+Kyvh2mslR1O6KocFgzIO/Oc/JQyugUitLIbF6qVfi9XLIk2s3mr3okhYbYJXnI4LoPT9Wcs7Xz6h+d8UkOiJpUjwuksUFJqKsUqEerdf+l+X33puPfq7NR7jVE6XhbSaZc7eym1BeWS/u98Iu/8B3H7WrIFjj5V2087D/vtOAAAZdklEQVSzlJi2IRCQcfJee8nrcFjuTds7bXsQjULsq1/jXfGcjFlikeZesnvcDrteJYJ4tEaOvX1ctwc6Jtedu4OLMEYESkptuJaXZr/ETZNvYl3NOsfPeVyeFsWfpoSjqXPeunDx2wN+y9UHXc3ALgPbZHc20FER6GDgdq318dbrmwC01ncnfOafwBSt9UvW6x+BI7XW5U7f21lEIJtQSKpHTZgAn38u4pA96U8UCIJB2GMPWaUaNkwS7JWUSL6ZwkIRhmzXXHuwnHgK7OvWdnl2ucTVctOmeKn4OXPg++8lHG3uXNhcU8PFb17MxAUTU5aXvWCvC3j0xEfTNiH643//yANfPeC4z1xvLkf0P4KXzniJAn/zCaTWYv9bb0k8+XffyUC8pVWkvDypiNa3rzz26CH/Twbxcszq6+XchMNy3JYvF9FnxQo5lk40vR2WLpXBzJtvwjffxFefknkx9egBAwdCWZmslPTqJa/79JHXfr+IVW632Gi7x0ajMnlavVrsXLJEnq9ZIxOXBQsaJ45sdstWLYFl42HlBNj4XXwQ0cyrRUH+TlAwGHJKIdADcgdImEOgDHJKZIVI2asj1iQxcYIY2iDeQTWr4LOznA8kNM8RE9okZdlXviHVzcJbpZOObCWpl5A7KImZA70g2Ese8wbKCo/Lb4VieMTOmDU51mGoLZeQmtpVqfMnJbMRYPM88bhZ8Vr8eOqI84qc8kCgVOwK9JbH3P7gzbcGej6ZfNs2xkJQv0HEppqVsm1M6TjZ3M5oCCqmwoo3xIuherl4AoSrcMwlg5JzHLRCW3L7yopY4mA0FokPoKN11mr1Cvn+qsUpTZx+xNeMfmU062rWpWwTXj3rVUbu7FyNsLVorbnl41tabIMO63sYz532HD3yenR4nxlbOdYaNs+BlW/KtmkWuHKsfDXJcy0Bcm/klMq5zu0H3i5yPdtbQwhTRM53zUqoXibnvKVJR8I1GYtJvzh+PLz/vrSbwaC0w03bcpdLJvK9e0tbWVYmbWT//vK3bt3i4QJua5HWDjOIRkXIWb1a9rFsWVzgWb1a2kqncCOlGp+ajz4SUarpYW6ImlKtON1ax0MIlCdhVbmF/2LtwxWrhYpP454hVUvkMWx5hURqoGh3afvcQZlg+PIlPNSTa3kEWX9vEJ9VwuQz4fHHv8OCh1v4QQ6UHAEjpiR9qyZUw6y1s5hbMZe1VWupqKmgvKqclVtWsrByYcoBO1E3rN4fVhwCtUVQ14V8bxFdu7oo7uJh56Gb2PuAavoW92DP7nuyW8luzUJAbAb9fRCLNzq3UR6Xh3uOuYdrD7m2Lb+81Wyu20zJ2BLH3GcABR4v0099gF2CuSnPtw70QrtzwB1EeQvEe8GTi3ZLFTvtzkG5AlZVSBdaKfGobBAeXKgFD6O2wfluLTNmwIUXyj2aTBxuCaVkrFdQAM8+K8m/G/HOUGkTnTjyPejZQj/TUiWndFRR6ig6BoufgpnX4eit3BLKau97HAn7Pyb9gcXixZLWwhZcm7bXhYXSvgYCMnYOBtsv2neIDw+H9V9Y/V6SvumQF6H/ORDaLOOt9qYZ6HD4fuoiGS1iRKBGLNu0jIemPcSTM59Ea500X1XAE2BAlwH8+eg/M6RkSJJvaZmqUBUPfy2hZZFYpFGFOJBQMbfLzYG9DuSmQ29ixE4jWl29LtN0VAQ6Exiptb7Een0ecKDW+oqEz7wN3KO1/sx6/RFwg9baUeXpbCJQUzZulE5uzhzx0PjuO+nsamtlsm+7Q8ZiIkTU18cXWAoLZaBriwIeT1wUsAe6tbXirWKLDfYqp8dayI3FrAY7uISdbh/hGHYBIgD9fOjPeeqUp9KaWFJrzR8m/4F/TP+H4yTMrdyU5ZUx6bxJzUo/NyUSkeP4yScSmvXTTzKwX78+LoqB/O5k4XmtIdFzys5P0LWrTEQGDBCRz4loVCYZM2bAZ5+JjWvXyrUQjcr5cbvl3NTXOyfBbg326rhSYmNdndjdtasIWY7EorD1R9gwE9Z/BRWfW4PMjXIBNnj/6PjKWQt5ntr3A3rAz1oYPNWWSwjGuqmwYQbUrIb6ClnFcQWkI7dXV7ZFbLzywjktfG8sKuFsFZ+JcFX1k9hdXwEoK/zCEqGitbTvWLpwFm5o3bEMbZYB0topsOkHmcjXlUuFNleONeGPWZ49KUQDRyz36CRENVy3McDfK+sdV+FdykWhv5DJ509mn7J92rF/Z56a+RRXvXeVo+eRndAyLdWVsiV8IBqCDdNh7Sew6XuoWiTCbP16uW/skMpoXTvvHefzDbR4TVZXS1s+YwZ8/DHMmyf92ZYt8bAOlyvetkXbOWZ2uWRyYudLCYVky8+X7eabYdUqEdaXLxcByU5SXFICRxwhOWUKCuKhDYWF0v7am98v9tp9r9OWmJC36WaPAezFibo66eM3bYIzfrhd4uba/OMBr7WBnLKWNp1kg3jzk/gYBiLymUfePJvvNv3EqprNLKvZxOq6LWwOb7swudZQklNE77wS+uX1oFduN1asqKBy+WxyKpN74vii8Ng70M/ZUafDXHccfJdCa9bAbmWDqRq6ExvqN7O+fhOrNq9hU6SKrTq124wbyFHgV9bpVHIJ2KfW1eRvLmt/tn9KTMdPuf23fF8BXYPFFAe7UxjsQVGwO8W5Jfyp/8646iucjSnYDbwteIYiY6FPviji5Te78+rb3aivdxGJKurqk3sg+3xR/D4x9JTjKxlz+lpGHLERn695W3TOhV3YsmYlXXI34vfU4/OE8Hvr8Xvq8XvrOfc8L7sOLU74H01uVrQcVVs4SzqhU7IYtDLFwDAFm6oLeWLa3bDLZUnf93gk2XdrcMc2U1z3NqW1/6Kwfgpa+XHpGlw0H/drIKaCoDUhdw/WBsawPnAWVd69k3738OGSg+r77yUNxnffNW+ve/QQb6Bdd5WE5LZgX1Qk7WdeXjzk1879k2wD5zbUnjPV1Mjcx14A37BBxr2/+fkc6fcqZ0gux+oVku9Hx0QA9+RB4VAo2kO8n3P7SsVHXxdZ8PLkWcJ5TpOwWNsjVsObA6A+hXDdGhyKZLQKIwIB8NXKr/jjf//If5f8F6VUs8TcIHPbAn8Bj574KKfvdnpa5rdLNy3lqveu4qMlHznOa13KRWluKdcPv54rD7gSd7pSLmwjOioCnQUc30QEOkBrfWXCZ94B7m4iAv1Ba/1Nk++6FLgUoG/fvvsuW7as/b8qSwmHxR12/XppRO3HigqpxFBeLo1aouATiUjDZ6982kn9PB4oLpYGt1cvaXBtr6KSEtkWVn/NJW9flDJh8zEDjuHBkQ9uE9XSXo2fMN+5k1QoHhz5IMcOPLad+5BjanvyrFghq8ALFohLv52TwhZ1tI7naLK33FxZfbY9c2wvopKS9JR8r6pqHHZQXh63c/36eHI8O2leNNr4PHu98lhaKjb27BlfJbc9izpchS5cJTHUtWvksW6tCC/VS0UwiIXjXgF22JiVHE/ciD0inPgKINjP6mB7WF5FpfLo79bxHDTR+sb5EmpWiahRtVhWwWIRy+vHshMd9wqyPRzcAfHGyRsY9yIK9pKBQTrKP2stAovtyVOz0vKWWSjHNRaJJ4mNheOeAnYiWZdXJurBXpA/yPLO6W099up45SebWEREq5oV8W3rQgkhjNUnnHPrUbnjLuP2sfQVQ8Eu4knS4EXUp2ESoLXmqOePoqLGedJQHChm3Onj6F/UPz2/qwnvL3qfGybf4CiEA5w46ETGHje2YzvK9pVjrUWgrF4m12PNcti6SMTLaF1jjzn7fLu8oHxx8chfLN6Cuf3iHkTB3jJw7iCxmAzom7aVtldPTU3jdtLuG+320W4rc3KkDe/fP95WlpbKY0lJQnjw7be3SmDRQAgfdeQ0bLUEiOJGo4jhssK+4s+bPrqscDD7MfF54t98hBL2UkfelnJUfgdix1u6JqHD16W6o/ng2h2DLrWQXwf+KAzYCIPXw8CN0H+TiC2F7cgLo4F1ubC0CJYVwaIuMK8EyvOgzgNb/LApSRP+YWxfjt31m+Zv2Bz0HAy8IPXOW3N/T/oNzG6HaAfMqIX9Vzq/73f7Kcopol9RP3rl96Ikt4TiQDHFgWK6BrpSlFPUqnFcjBhb6rZQWVtJZU0lG2o3UFFTwaqtq1i6aSkbazemDH/Q3wOvt+MHpkAD3zKMLzmY2QxhNnuwhQJiKPKoZjBz2ZMf2I8ZHMyXuFMtjADTOICDRhwu3xz1Q8QHkSCEghAJsOfAMo49sCfRiAu0C7fy4Pd68Hk8eNwufB4PPq8Lr0fh87lwuxUuRcNEUqEaxoYKhdYyytYaNBp77hTTEI1qQqEYoYgmFIoSCkeJxKIsW+Kh/yNPcTvtu14c8QK7A32trRTwWAd5K7AMWA3MBVqjZ2zdmjR/RSwmi5wVFbB5M80SQldWSnRCZWU8xBcae10mij9NSfS2tB+1js+DunSR3EO22HThhQ45OMNVItyErATQ4c0JCaE3ypisrsLynI02DnlsJALZhjXdgSWp2vfeuk+cF1f83eGMDngSbYf2PC1s47HQfV/cxzPfPeP4vkJx/l7nc/VBVydNZt5RvlzxJTd+dCPra5yrQ3XJ6cKnv/w07VU7040JBzMYDAaDwWAwGAwGg8Fg2AFIJQK1xgdiOrCzUmqAUsoH/BxomllvInC+Eg4CNqcSgAwGg8FgMBgMBoPBYDAYDNuXFnO7a60jSqkrgA+QsORntNZzlFK/sd5/HHgXqQy2CCkR/8ttZ7LBYDAYDAaDwWAwGAwGg6GttKrAn9b6XUToSfzb4wnPNfDb9JpmMBgMBoPBYDAYDAaDwWBIF52jvpnBYDAYDAaDwWAwGAwGg6FDGBHIYDAYDAaDwWAwGAwGg2EHwIhABoPBYDAYDAaDwWAwGAw7AEYEMhgMBoPBYDAYDAaDwWDYATAikMFgMBgMBoPBYDAYDAbDDoARgQwGg8FgMBgMBoPBYDAYdgCMCGQwGAwGg8FgMBgMBoPBsANgRCCDwWAwGAwGg8FgMBgMhh0AIwIZDAaDwWAwGAwGg8FgMOwAGBHIYDAYDAaDwWAwGAwGg2EHwIhABoPBYDAYDAaDwWAwGAw7AEprnZkdK1UBLMvIzttGN2B9po1oAWNj+ugMdhob00dnsNPYmD46g53GxvTRGew0NqaPzmCnsTF9dAY7jY3pozPYaWxMH53Bzs5gYz+tdUmyNzImAnUWlFIztNb7ZdqOVBgb00dnsNPYmD46g53GxvTRGew0NqaPzmCnsTF9dAY7jY3pozPYaWxMH53BTmNj+ugMdnYGG1NhwsEMBoPBYDAYDAaDwWAwGHYAjAhkMBgMBoPBYDAYDAaDwbADYESglnki0wa0AmNj+ugMdhob00dnsNPYmD46g53GxvTRGew0NqaPzmCnsTF9dAY7jY3pozPYaWxMH53Bzs5goyMmJ5DBYDAYDAaDwWAwGAwGww6A8QQyGAwGg8FgMBgMBoPBYNgBMCKQA0qpkUqpH5VSi5RSN2banmQopZ5RSq1TSs3OtC1OKKX6KKU+VkrNU0rNUUr9LtM2NUUplaOU+lopNcuy8Y5M2+SEUsqtlPpWKfV2pm1xQim1VCn1g1LqO6XUjEzbkwylVJFS6lWl1Hzr2jw40zYlopTa1Tp+9rZFKXV1pu1KhlLqGuu+ma2UekkplZNpm5qilPqdZd+cbDqOydpwpVRXpdSHSqmF1mOXLLTxLOtYxpRSGa+M4WDjWOv+/l4pNUEpVZRJGy2bktl5l2Xjd0qpSUqpntlmY8J71ymltFKqWyZsS7Aj2XG8XSm1KqHNPDGTNlo2JT2WSqkrrfHlHKXUXzNln2VLsmP5csJxXKqU+i4LbdxbKfWVPc5QSh2QSRstm5LZuZdS6ktrTPSWUqogwzYmHZNnU7+Twsas6XdS2JhV/U4KO7Om33GyMeH9jPc7KY5j1vU7bUJrbbYmG+AGFgMDAR8wC9g903YlsfNwYB9gdqZtSWFjGbCP9TwfWJBtxxJQQJ713AtMAw7KtF0Otv4eeBF4O9O2pLBxKdAt03a0YOPzwCXWcx9QlGmbUtjqBtYA/TJtSxLbegFLgID1ejxwYabtamLjUGA2EAQ8wGRg50zbZdnWrA0H/grcaD2/Ebg3C20cDOwKTAH2y9LjeBzgsZ7fm+njmMLOgoTnVwGPZ5uN1t/7AB8AyzLdvjscx9uB6zJ9jlth51FWG+S3XnfPNhubvH8fcGu22QhMAk6wnp8ITMnS8z0dOMJ6fhFwV4ZtTDomz6Z+J4WNWdPvpLAxq/qdFHZmTb/jZKP1Oiv6nRTHMev6nbZsxhMoOQcAi7TWP2mtQ8B/gFMzbFMztNZTgQ2ZtiMVWutyrfVM6/lWYB4yccwatFBlvfRaW9Yly1JK9QZOAp7KtC2dGWsl7nDgaQCtdUhrvSmzVqXkGGCx1npZpg1xwAMElFIeRGhZnWF7mjIY+EprXaO1jgCfAKdn2CbAsQ0/FREpsR5P265GNSGZjVrreVrrHzNkUjMcbJxknW+Ar4De292wJjjYuSXhZS4Z7ntSjCseAP5AFvSNnWHsA452Xgbco7Wutz6zbrsblkCqY6mUUsBo4KXtalQTHGzUgO1VU0gW9DsOdu4KTLWefwicsV2NakKKMXnW9DtONmZTv5PCxqzqd1LYmTX9TgvzxKzodzrDXLY9GBEoOb2AFQmvV/I/cLIzjVKqPzAM8bTJKpSEWX0HrAM+1FpnnY3Ag0hjGMu0IS2ggUlKqW+UUpdm2pgkDAQqgGeVhNY9pZTKzbRRKfg5GR6EO6G1XgX8DVgOlAObtdaTMmtVM2YDhyulipVSQWTVuE+GbUpFD611OcjAA+ieYXv+F7gIeC/TRjihlPqzUmoFcC5wa6btaYpSahSwSms9K9O2tMAVVojDM5kMZ2mBXYDDlFLTlFKfKKX2z7RBKTgMWKu1XphpQ5JwNTDWum/+BtyUYXucmA2Msp6fRRb1PU3G5FnZ72TzvMEmhY1Z1e80tTMb+51EG7O130lyvjtDv5MUIwIlRyX5W8ZXvzozSqk84DXg6iYKdFagtY5qrfdGVPsDlFJDM21TIkqpk4F1WutvMm1LKxiutd4HOAH4rVLq8Ewb1AQP4rL9mNZ6GFCNuD9nHUopHzKAfCXTtiTD6vBOBQYAPYFcpdQvMmtVY7TW8xC37A+B95Hw3kjK/2T4n0EpdTNyvl/ItC1OaK1v1lr3QWy8ItP2JGIJpzeTJZOEFDwG7ATsjQjS92XWHEc8QBfgIOB6YLzlcZONnEOWLkAgHlXXWPfNNVievVnIRcg46BskjCSUYXuA7B+TQ+e2Mdv6nWR2Zlu/k2gjcuyyrt9Jchw7S7+TFCMCJWcljdX63mSBq2lnRSnlRW6aF7TWr2fanlRYYUFTgJEZNqUpw4FRSqmlSHji0Uqpf2fWpORorVdbj+uACUh4ZTaxEliZ4O31KiIKZSMnADO11mszbYgDxwJLtNYVWusw8DpwSIZtaobW+mmt9T5a68MRd/1sXNm2WauUKgOwHjMaLtKZUUpdAJwMnKu17gwLOS+S4XCRJOyEiLyzrP6nNzBTKVWaUauaoLVeay3mxIAnyb5+x2Yl8LoVhv414tmb0UTbybDCe38GvJxpWxy4AOlvQBZJsvJ8a63na62P01rviwhqizNtk8OYPKv6nc4wb3CyMdv6nVYcy4z3O0lszLp+J9lx7ET9TlKMCJSc6cDOSqkB1kr8z4GJGbapU2KtcD0NzNNa359pe5KhlCqxM/grpQLIxHZ+Zq1qjNb6Jq11b611f+R6/K/WOqs8LgCUUrlKqXz7OZIkL6uq12mt1wArlFK7Wn86BpibQZNSkc0rsSBhYAcppYLWvX4MEiudVSiluluPfZGJTTYf04nIBAfr8c0M2tJpUUqNBG4ARmmtazJtjxNKqZ0TXo4i+/qeH7TW3bXW/a3+ZyWSIHNNhk1rhD2BtTidLOt3EngDOBpAKbULUphgfUYtSs6xwHyt9cpMG+LAauAI6/nRZKmwn9D3uIA/Ao9n2B6nMXnW9DudZN6Q1MZs63dS2Jk1/U4yG7Ot30lxHDtLv5McnQXZqbNxQ/JGLEBU+5szbY+DjS8h7mdh5Aa5ONM2JbHxUCSU7nvgO2s7MdN2NbFxT+Bby8bZZLgSRivsPZIsrQ6G5NuZZW1zsvje2RuYYZ3zN4AumbYpiY1BoBIozLQtLdh5BzKAmA38C6vqTTZtwKeI0DcLOCbT9iTY1awNB4qBj5BJzUdA1yy08XTreT2wFvggC21chOT2s/udjFbdSmHna9a98z3wFpK0M6tsbPL+UjJfHSzZcfwX8IN1HCcCZVl6vn3Av61zPhM4OttstP7+HPCbTB/DFMfxUOAbq02fBuybpXb+DplLLADuAVSGbUw6Js+mfieFjVnT76SwMav6nRR2Zk2/42Rjk89ktN9JcRyzrt9py6asH2cwGAwGg8FgMBgMBoPBYPgfxoSDGQwGg8FgMBgMBoPBYDDsABgRyGAwGAwGg8FgMBgMBoNhB8CIQAaDwWAwGAwGg8FgMBgMOwBGBDIYDAaDwWAwGAwGg8Fg2AEwIpDBYDAYDAaDwWAwGAwGww6AEYEMBoPBYDAYDAaDwWAwGHYAjAhkMBgMBoPBYDAYDAaDwbADYEQgg8FgMBgMBoPBYDAYDIYdgP8Hz/qMksJ10rYAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -1376,7 +1544,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1390,12 +1558,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "After filtering: numseqlets 79\n" + "After filtering: numseqlets 141\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1409,7 +1577,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Numseqles: 81\n" + "Numseqles: 109\n" ] }, { @@ -1418,12 +1586,12 @@ "text": [ "[Parallel(n_jobs=10)]: Using backend LokyBackend with 10 concurrent workers.\n", "[Parallel(n_jobs=10)]: Done 40 tasks | elapsed: 0.0s\n", - "[Parallel(n_jobs=10)]: Done 81 out of 81 | elapsed: 0.1s finished\n" + "[Parallel(n_jobs=10)]: Done 109 out of 109 | elapsed: 0.1s finished\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1435,7 +1603,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1449,12 +1617,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "After filtering: numseqlets 79\n" + "After filtering: numseqlets 105\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1479,17 +1647,29 @@ "text": [ "[Parallel(n_jobs=10)]: Using backend LokyBackend with 10 concurrent workers.\n", "[Parallel(n_jobs=10)]: Done 40 tasks | elapsed: 0.0s\n", - "[Parallel(n_jobs=10)]: Done 4090 tasks | elapsed: 0.2s\n", - "[Parallel(n_jobs=10)]: Done 4724 out of 4724 | elapsed: 0.3s finished\n", - "[Parallel(n_jobs=10)]: Using backend LokyBackend with 10 concurrent workers.\n", - "[Parallel(n_jobs=10)]: Done 1 out of 1 | elapsed: 0.0s finished\n" + "[Parallel(n_jobs=10)]: Done 5540 tasks | elapsed: 0.3s\n", + "[Parallel(n_jobs=10)]: Done 7376 out of 7376 | elapsed: 0.4s finished\n", + "[Parallel(n_jobs=10)]: Using backend LokyBackend with 10 concurrent workers.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Took 0.35634303092956543 s\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Parallel(n_jobs=10)]: Done 1 out of 1 | elapsed: 0.2s finished\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Took 0.2695131301879883 s\n", "Getting impscores data\n", "Computing fwd sims\n" ] @@ -1506,15 +1686,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "Took 0.2630581855773926 s\n" + "Took 0.3716139793395996 s\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "[Parallel(n_jobs=10)]: Done 4090 tasks | elapsed: 0.2s\n", - "[Parallel(n_jobs=10)]: Done 4724 out of 4724 | elapsed: 0.3s finished\n" + "[Parallel(n_jobs=10)]: Done 5540 tasks | elapsed: 0.3s\n", + "[Parallel(n_jobs=10)]: Done 7376 out of 7376 | elapsed: 0.4s finished\n" ] } ], @@ -1534,43 +1714,7 @@ }, { "cell_type": "code", - "execution_count": 89, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0.07060099, 0.39592812, 0.43990814, 0.46051812, 0.46358678,\n", - " 0.477134 , 0.48289524, 0.48303023, 0.4852053 , 0.48598942,\n", - " 0.48748475, 0.48771762, 0.48974793, 0.49179656, 0.49354536,\n", - " 0.49425378, 0.49595822, 0.49642561, 0.49781634, 0.49815178,\n", - " 0.49975331, 0.50083468, 0.50237827, 0.50284284, 0.50577822,\n", - " 0.50698624, 0.50707468, 0.50790746, 0.50900005, 0.5093652 ,\n", - " 0.50968138, 0.509743 , 0.51138583, 0.51156751, 0.51275761,\n", - " 0.51303825, 0.51366061, 0.51438559, 0.51468357, 0.5147146 ,\n", - " 0.51476555, 0.51484839, 0.51511623, 0.51568231, 0.51600813,\n", - " 0.51601327, 0.51669353, 0.5168097 , 0.51685902, 0.51739562,\n", - " 0.51783374, 0.51800729, 0.51860958, 0.51861522, 0.51920012,\n", - " 0.51921313, 0.51930455, 0.51933883, 0.51937165, 0.51975825,\n", - " 0.51977374, 0.52013972, 0.52026368, 0.52042973, 0.52045827,\n", - " 0.5205568 , 0.52058087, 0.52066148, 0.52098923, 0.52103312,\n", - " 0.52116053, 0.52125391, 0.52155886, 0.52160719, 0.52212082,\n", - " 0.52217797, 0.52282433, 0.52306766, 0.52308391])" - ] - }, - "execution_count": 89, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "instance_scorer.get_prec_for_threshold(motif_idx=0,\n", - " threshold=instance_scorer.thresholds_list[0])" - ] - }, - { - "cell_type": "code", - "execution_count": 91, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -1579,7 +1723,7 @@ "text": [ "computing the transformed score track\n", "done computing the transformed score track\n", - "Fraction of values above cutoff: 0.1572\n" + "Fraction of values above cutoff: 0.1872\n" ] } ], @@ -1588,7 +1732,7 @@ "from modisco.hit_scoring import exemplar_based_hitscoring\n", "reload(exemplar_based_hitscoring)\n", "\n", - "CUTOFF_VALUE = 0.9\n", + "CUTOFF_VALUE = 0.2\n", "coordinates_to_be_scanned, task0_transformed_scoretrack =\\\n", " exemplar_based_hitscoring.get_windows_to_be_scanned(\n", " scanning_window_width=SCANNING_WINDOW_WIDTH,\n", @@ -1602,7 +1746,7 @@ }, { "cell_type": "code", - "execution_count": 102, + "execution_count": 16, "metadata": { "scrolled": false }, @@ -1621,15 +1765,15 @@ "text": [ "[Parallel(n_jobs=10)]: Using backend LokyBackend with 10 concurrent workers.\n", "[Parallel(n_jobs=10)]: Done 40 tasks | elapsed: 0.0s\n", - "[Parallel(n_jobs=10)]: Done 9764 tasks | elapsed: 0.4s\n", - "[Parallel(n_jobs=10)]: Done 13072 out of 13072 | elapsed: 0.5s finished\n" + "[Parallel(n_jobs=10)]: Done 10220 tasks | elapsed: 0.5s\n", + "[Parallel(n_jobs=10)]: Done 29060 out of 29060 | elapsed: 1.0s finished\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Took 0.5234172344207764 s\n" + "Took 1.0475728511810303 s\n" ] } ], @@ -1647,7 +1791,7 @@ }, { "cell_type": "code", - "execution_count": 103, + "execution_count": 24, "metadata": { "scrolled": false }, @@ -1661,7 +1805,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1673,19 +1817,7 @@ }, { "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1699,13 +1831,18 @@ "name": "stdout", "output_type": "stream", "text": [ - "tal hits: [MotifHitAndCoord(motif_idx=0, motif_score=0.6288662472752831, precision_at_motif_score=0.3034387831986581, example_idx=0, start=114, end=139, is_revcomp=True), MotifHitAndCoord(motif_idx=0, motif_score=0.9917175077370958, precision_at_motif_score=1.0, example_idx=0, start=123, end=148, is_revcomp=False), MotifHitAndCoord(motif_idx=0, motif_score=0.5309194727615236, precision_at_motif_score=0.0, example_idx=0, start=157, end=182, is_revcomp=True), MotifHitAndCoord(motif_idx=0, motif_score=0.9904592739684515, precision_at_motif_score=1.0, example_idx=0, start=166, end=191, is_revcomp=False)]\n", - "gata hits: [MotifHitAndCoord(motif_idx=1, motif_score=0.9979175245102603, precision_at_motif_score=1.0, example_idx=0, start=151, end=176, is_revcomp=False)]\n" + "tal hits:\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.6504827158037557, precision_at_motif_score=0.3163707407503883, example_idx=0, start=114, end=139, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.997667879007509, precision_at_motif_score=1.0, example_idx=0, start=123, end=148, is_revcomp=True)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.5525896556967879, precision_at_motif_score=0.08588468275708364, example_idx=0, start=157, end=182, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.9986260150648937, precision_at_motif_score=1.0, example_idx=0, start=166, end=191, is_revcomp=True)\n", + "gata hits:\n", + "MotifHitAndCoord(motif_idx=1, motif_score=0.9993490999238629, precision_at_motif_score=1.0, example_idx=0, start=146, end=171, is_revcomp=True)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1724,7 +1861,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1736,19 +1873,7 @@ }, { "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1762,13 +1887,18 @@ "name": "stdout", "output_type": "stream", "text": [ - "tal hits: []\n", - "gata hits: [MotifHitAndCoord(motif_idx=1, motif_score=0.9955329648255107, precision_at_motif_score=1.0, example_idx=1, start=27, end=52, is_revcomp=False), MotifHitAndCoord(motif_idx=1, motif_score=0.9984405620577878, precision_at_motif_score=1.0, example_idx=1, start=94, end=119, is_revcomp=False), MotifHitAndCoord(motif_idx=1, motif_score=0.9995610910908511, precision_at_motif_score=1.0, example_idx=1, start=118, end=143, is_revcomp=False)]\n" + "tal hits:\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.9986260150648937, precision_at_motif_score=1.0, example_idx=1, start=9, end=34, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.5525896556967879, precision_at_motif_score=0.08588468275708364, example_idx=1, start=18, end=43, is_revcomp=True)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.997667879007509, precision_at_motif_score=1.0, example_idx=1, start=52, end=77, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.6504827158037557, precision_at_motif_score=0.3163707407503883, example_idx=1, start=61, end=86, is_revcomp=True)\n", + "gata hits:\n", + "MotifHitAndCoord(motif_idx=1, motif_score=0.9993490999238629, precision_at_motif_score=1.0, example_idx=1, start=29, end=54, is_revcomp=False)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1787,19 +1917,7 @@ }, { "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1811,7 +1929,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1825,13 +1943,17 @@ "name": "stdout", "output_type": "stream", "text": [ - "tal hits: [MotifHitAndCoord(motif_idx=0, motif_score=0.6940629318048525, precision_at_motif_score=0.5054178960428508, example_idx=2, start=1, end=26, is_revcomp=True), MotifHitAndCoord(motif_idx=0, motif_score=0.9892230296698091, precision_at_motif_score=1.0, example_idx=2, start=10, end=35, is_revcomp=False), MotifHitAndCoord(motif_idx=0, motif_score=0.602743025674392, precision_at_motif_score=0.22250912915793472, example_idx=2, start=58, end=83, is_revcomp=True), MotifHitAndCoord(motif_idx=0, motif_score=0.9985116869126707, precision_at_motif_score=1.0, example_idx=2, start=67, end=92, is_revcomp=False), MotifHitAndCoord(motif_idx=0, motif_score=0.8429574686878377, precision_at_motif_score=0.9666926784028752, example_idx=2, start=140, end=165, is_revcomp=True), MotifHitAndCoord(motif_idx=0, motif_score=0.9994729032358728, precision_at_motif_score=1.0, example_idx=2, start=149, end=174, is_revcomp=False)]\n", - "gata hits: []\n" + "tal hits:\n", + "\n", + "gata hits:\n", + "MotifHitAndCoord(motif_idx=1, motif_score=0.9933627532372303, precision_at_motif_score=1.0, example_idx=2, start=22, end=47, is_revcomp=True)\n", + "MotifHitAndCoord(motif_idx=1, motif_score=0.998124872090949, precision_at_motif_score=1.0, example_idx=2, start=89, end=114, is_revcomp=True)\n", + "MotifHitAndCoord(motif_idx=1, motif_score=0.9994427100002803, precision_at_motif_score=1.0, example_idx=2, start=113, end=138, is_revcomp=True)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABI0AAACMCAYAAADx21mCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3hUxfrA8e/spicEAoSEGqpUEekCCiogiPxEFAURK3bsXhW9V1HsXa+Vq14rF1EsCCqC0kEh9N4TkkBCes9my/z+mN1NNgUJ2QDi+3mePNk9e3bO7O6p73lnRmmtEUIIIYQQQgghhBCiPMvJroAQQgghhBBCCCGEOPVI0EgIIYQQQgghhBBCVCJBIyGEEEIIIYQQQghRiQSNhBBCCCGEEEIIIUQlEjQSQgghhBBCCCGEEJVI0EgIIYQQQgghhBBCVBJwsitwNI0bN9atW7c+2dUQQgghhBBCCCGEOG2sW7cuQ2sd/WfzndJBo9atWxMfH3+yqyGEEEIIIYQQQghx2lBKJR7LfNI8TQghhBBCCCGEEEJUIkEjIYQQQgghhBBCCFGJBI2EEEIIIYQQQgghRCUSNBJCCCGEEEIIIYQQlUjQSAghhBBCCCGEEEJU4pegkVJqhFJql1Jqr1LqkSpev1QptVkptVEpFa+UGuSP5QohhBBCCCGEEEKIuhFQ2wKUUlbgbWAYkAysVUrN1VpvLzfbr8BcrbVWSnUHZgOdartsIYQQQgghhBBCCFE3/JFp1BfYq7Xer7UuBWYBl5afQWtdoLXW7qfhgEYIIYQQQgghhBBCnLL8ETRqDiSVe57snuZDKXWZUmonMB+40Q/LFUIIIYQQQgghhBB1xB9BI1XFtEqZRFrrb7XWnYAxwPRqC1PqFne/R/Hp6el+qJ4QQgghhBBCCCGEqCl/BI2SgZblnrcADlU3s9Z6GdBOKdW4mtdnaK17a617R0dH+6F6QgghhBBCCCGEEKKm/BE0Wgt0UEq1UUoFAeOBueVnUEq1V0op9+OeQBCQ6YdlCyGEEEIIIYQQQog6UOvR07TWDqXUFGABYAU+0lpvU0rd5n79PeBy4FqllB0oBq4q1zG2EEIIIYQ4jbVuDYmJJ7sW4q8gLg4SEk52LYQQQnioUzl207t3bx0fH3+yqyGEEEIIIWpBKTiFTzlrT1XVxSen+YeuG6f9uiKEEKcIpdQ6rXXvP5vPH83ThBBCCCGEEEIIIcRpRoJGQgghhBBCCCGEEKISCRoJIYQQQgghhBBCiEokaCSEEEIIIYQQQgghKpGgkRBCCCGEEEIIIYSoRIJGQgghhBBCCCGEEKISCRoJIYQQQgghhBBCiEokaCSEEEIIIYQQQgghKpGgkRBCCCGEEEIIIYSoRIJGQgghhBBCCCGEEKISCRoJIYQQQgghhBBCiEoCTnYFhBBCCHH6ad0aEhNPdi3EqUSpytPi4iAh4YRXxf9iYiAtrfI0IYQQ4i9OgkZCCCGE8LvERND6ZNeijlQV/fA4bT907ShV9VdztK/yLyU11fz3fCBZD4QQQpwmpHmaEEIIIYQQQgghhKhEgkZCCCGEEELUgNPlxOlynuxqCCGEEHXOL0EjpdQIpdQupdRepdQjVbw+USm12f23Sil1lj+WK4QQQgghxIkWMD2Ahi82PNnVEEIIIepcrYNGSikr8DYwEugCTFBKdakw2wFgsNa6OzAdmFHb5QohhBBCCHGyuLTrZFdBCCGEqHP+yDTqC+zVWu/XWpcCs4BLy8+gtV6ltc52P/0daOGH5QohhBBCCHFSOFyOk10FIYQQos75I2jUHEgq9zzZPa06NwE/VfeiUuoWpVS8Uio+PT3dD9UTQgghhBDCvyRoJIQQ4u/AH0GjqgZLrXKcUaXU+Zig0cPVFaa1nqG17q217h0dHe2H6gkhhBBCCOFfEjQSQgjxdxDghzKSgZblnrcADlWcSSnVHfgAGKm1zvTDcoUQQgghhBBCCCFEHfFHptFaoINSqo1SKggYD8wtP4NSqhXwDTBJa73bD8sUQgghhBDihNO6yoR6/7Dnw+rrYPd7dbcMIYQQogZqnWmktXYopaYACwAr8JHWeptS6jb36+8BjwONgHeUUgAOrXXv2i5bCCGEEOKEi4mBtLSqp4vTXomjpO4KX30dHJoPB7+GyA4Qe2HdLUsIIYQ4Bv5onobW+kfgxwrT3iv3eDIw2R/LEkIIIYQ4qVJTzX/l7taxLjNPxCknz5ZXNwWXpMOhH8FVCpTCjpckaCSEEOKk80fzNCGEEEIIIf4W6ixolDgLlLXsedqSulmOEEIIUQMSNBJCCCGEEOIY1VnQ6MCn4Cwqe24JqpvlCCGEEDUgQSMhhBBCCCGqs++/sHYK2AsA36CR3Wn3zzK0htztvtMcBf4pWwghhKgFv/RpJIQQQgghxGknZR7ETwHtgMIDMGS+T9AovzSfhqENa7+coiTA3TdWaFMozQFnce3LFUIIIWpJMo2EEEIIIYSoyuYnTJMxVymk/gb4Zhr5rala7jbTHK1RH7j0IFy01rd/IyGEEOIkkaCREEIIIYQQFeVuh7wd5Sa4gDoKGuXvAWcJdHsclAXCW8rIaUIIIU4JEjQSQgghhBCiokM/gXaVPXeVApBry/VOyi3Jrfiu45O9GSyBEDvUBI0CIqDdzf4pWwghhKgFCRoJIYQQQghRUeqv4LJVmpxdnO197L9Mo13QsKfJNgITOIoe5J+yhRBCiFqQoJEQQgghhBAVZcWb//0+gFHbILQ5ABlFGd5Z/BY0smVAg7PAElw2LdgPHWwLIYQQtSSjpwkhhBBCCFGeoxBKsyGqB8RNAEsAdH0EgKySLO9sfgsaleZC1FkQEFquDsUQFOSf8oUQQojjJEEjIYQQQgghysvbBQFh0GWqyf6xWKHtjQBkFmWWzeavoJEjHxqc6TtNKf+ULYQQQtSCNE8TQgghhBCivPy9oDEjmFmsZprLDsCRwiPe2XJKcmq/LK3BUQQhTX2nl2+qJoQQQpwkEjQSwp8O/wIrr4GsdSe7JkIIIf4qyo/QJU4NtnQIioKA8LJp1hDAt0+jjOKMiu+sOUe+CUwFRvpOt0rQSAghxMknzdPEKal1a0hMPNm1OB7D3X/iRIiLg4SEk10LIYQ4TkWH4LehJqul7wxod/3JrpHwKEmHeu3NaGbuYJEniJNdUjZ6WlZRVlXvrpnSbFBBpjmcEEIIcYrxS6aRUmqEUmqXUmqvUuqRKl7vpJRarZSyKaUe9McyxektMdFka/9l/lwaPe9M9BfK/M0MrH7emFg0yvcvJvbkf4a/4N9fM7AohPir+WD9B4Q9UwcX9Gtuhvw9oO0Qf4f/yxfHrzgFIs8AS9UdUUcGmayg8gGk42bLgsCI2pcjhBBC1IFaB42UUlbgbWAk0AWYoJTqUmG2LOBu4OXaLk+IU1L2Big8UPZcO7wPC0oLyCgsl76ellb5/VVNE0IIcUqYt3sexY5i/xaasQbSlpQdL9z95YhTRHEqhMSUZRlV0DC0IeCnPo0c+RAYBa7S2pclhBBC+Jk/Mo36Anu11vu11qXALODS8jNorY9ordcCckYkTk8p88wJf0isGZq3XL8ELV5tQfTL0bUqPqc4B4fT8eczCiGEOCarklbxwIIHjmleT8DI6XL6rwIJX5imTx5a9vGnlJI0CG0OyvdU2eawARAVGgVAdvHxZRodyj+EelKhtQbthKD64JJ1QAghxKnHH0Gj5kBSuefJ7mlC/H2k/GBO+oYugf4fwcAvvS/ZnLZaFx/1YhTXfndtrcsRQghh3Pvzvbz6+6vHNG96YToAaYV+zApN/g5wQf+P4ZKdENnJf2WL2ivNhNCmlSbn2fIAiAgyzckyizOPq/g9mXvK3q9doAKPs6JCCCFE3fJH0EhVMU0fd2FK3aKUildKxaenp9eiWkKcIC4n5GyFttebu5LWEIge5H25xFFS/XuPpXj3qDp+bxohhBB/YzXZN3uCRYfyD/ln4bYsKDkMcVdBqysgoj0M/J9/yhZ/SmtYsgS++QZKqlsN7AUQ0qTS5AM5pin6yqSVAOTaco+rDin5KQAk5yWbm07KQi1On4UQQog644+gUTLQstzzFsBxn1VprWdorXtrrXtHR9euSY8QJ0RxsjnZa3tTWUeW1sodppY63X0VxMRULqOqaW6eO9yZRcd3N1MIIURlWcVm1Kt8W/6fzuvZ/6bkpfhp4fHmONF9uhnS3WKFiHb+KVv8qXffhVGj4NprYexYE0SqRDshqEGlyfuy9gFlN3SOV3JuMgBJuUnuTKMK92C/iYWZCmZaa7UcIYQQorb8ETRaC3RQSrVRSgUB44G5fihXiL+GohSTXdTw7LJplsqblvdiIzXV9wxVazOtGkl5pvWn566kEEKI2vME5D372KPxNDP22364MNF0fBxW7p5bNR0uC//asAEefBCKiqCwEJYtqxyvAdyBnMoBmyOFRypNK3XUvANrz3qXlJdkbjxVjFyVeJpC1i44JYQQQtRWrYNGWmsHMAVYAOwAZmuttymlblNK3QaglIpVSiUD9wP/VEolK6Uiqy9ViL+Q4hTTtKCKUU/K34lMzks+ruIP5h4EIK2gQl8azlLY/wnsed+k0QshhDhmpe59dlLunweNPGoy71EVHjQ3Gsr3eWeRPm1OhGefNU3SrFYICTGBo6o5qwwaZRRlVJp2uOBwjeuxO3M3AAk5CWY52knVPT4IIYQQJ1eAPwrRWv8I/Fhh2nvlHqdimq0JcfopSoHQGHNXsoLydySPN2jkuUgptJc7s9UuWDkeDi8ANOz/GIavquZ2qRBCiOr8WaZR+eZre7L2+GehBXuhXnuwhvqnPHFMSkth3jxo0gS2bIH69eGSS47xzd/EQkkamVX0hX4o/xBxDeJqVJetR7YCsCF1A3S/2IzAKsdwIYQQpyB/NE8T4u+tMNF0lqkqx2DLB4qON2i0L3uf97H2pK/vfM0EjJxF4CyGnE1ysimEEMeo2F42sEBiTqLvi1pDaY73RkD5zq+3pW877mX+nvQ7B7JNJ8oUJEBEW7AGHXd5ouZWrICgIJg1ywSMgoLgq6+qm9uT/ePmbi6WVUVrsePJNDpUYNarzWmbTaaRPbfKzCYhhBDiZJOgkRC1VXwIQltAQOU7xuUDReWDPzXhuRsJkFPivpDZ/jy4SqDrY3DW88iIK0IIcRRFKZD8AxSYoE35ffOuzF1l85Xmws+9YU4T+LYF5O/z6cfIM0z68Tjno3M4+31333clqdLx9UmwYQM0bgz9+pmAEVTZBaGhLOByVJqcU0XQqFLz8QqsT1pp/kpz73PPDSCLspiM5MB6UJoNluBj+hxCCCHEieSX5mlC/K25SiEkuso7hOUvTDz9F9TU5rTN3sdJeUlE5W8z/WD0fhfaXAMoaNjjuMoWQojTXvoqWDzCZGO6HHBFlk+TtC1pW8wD7YJF50HeLtB2k1myoB+HzngdgKiQKLJLsmtVlTxbnnngtEFobK3KEjW3bRtccAE4yyUQ1atXzczKCvacSpOznZVnTS9KP+pyXbi8mUUAubZcABqENCCrOAsdGIVyFCI3gIQQQpyKJNNIiNpy2au9O5iQk+B9vCNjx3EVn1mcSUiAGVUnKTcJDv8CwdHQZhIEhJkMp8YDj6tsIYQ4rRWnweLh4MgHe55p0msN9unQemfmTvMg6Rso2A+RHaHXm9B0KDgKvcH/FpGma8byTduOVXaxCTZpT1BAO6Xj65Ngxw7o3RsiIo5h5sAIKKk8UlpT9/2hC1pfQMdGHQFoXq95pfk8dMVR0Sjrq7BxWGMAMpwucNnAUW5Qi5CYY6ikEEIIUfckaCRErSl87g5+EwszFcy0ejtNDbYGk1qQWuOS7U47AC3qmYuVg7kHIXsdxF3hO6N0piqEEJVtfwFcTjj7ZRiXC/3/C5SNStk0oingvrDf8QqEt4JhK6DjXXDut9B0GAdyTJO22AiTGVS+uVpVvtj8BepJ3z7myt80MEGECsO5lztuiLpz4AB06XKMMwc1Ms3PK/B0H/jggAf5v47/B/iOlFpR+Yxjp8ukKXky3TzrX1JhFqDBXtbpOmNrfs4ghBBC1AUJGglRW5YA00TNo8TTt4GLhOwEANo1NH1XeIJAx8rTAavnLmZCTgLk7oDowb59KFnkQkMIIXxoDfs/hA63QYdbITASWo0DypoLt6rfCoDsojTIioceL4I1zLw/IAz6vO1tvlbqMPv5Sh1nV7Bg3wJTZnFZU7Yd6WVBo0P5h0zAqHx/OeWOG6LuFBRA3LEOchYSY/rC8gSE3Jk/nj6NwgLDiAyOBMo1O6zC9vTt3see7GNPIKlZvWYAJOUlm/Wu+OgBSSGEEOJkkKCRELVlCTIp7LpyRweek8VDeSb4U9Phmj13w0MCTfO0zWmboTgZ6neuTY2FEOL0V5hgLvi7PQYB7vZIAeEAbDliAkEKkzaSmrIUgqIgdqhvED6wAesPrwdgdfJqAL7b+d1RF7spdRMA6w6vK5uWtsn7eEfGDhM0Kt8USZwQTieEhBzjzKFNzbHdWWKeuzN/ct1Bo/CgcMICTYDR00dRVcoHjTwZZ/GH4oGyY/ymtE2mM+zsLcf6UYQQQogTRoJGQtRWaDMoSgaHbz8XLhc4tLmTnGMznWkuT1xeo6Ln7JgDwJKEJe73LzF9KIU0qV2dhRDidJe9CSI7V9nnnGdUyvWpJiC0fe+XENmpLEDgpbA5bQCUujNKy/dVV5XNR8zgBWtT1nqn/ZH8h/fxjvQdEBAJRUmV3iv8LzU/lSJ7EWCSz5T6kzd4hDWH/N2+mcRAfrlMo/BAE4TMKMqotpjywUNPAOnHPT8CsDJpJQBzd82FwPqQswkcRcdYQSGEEOLEkKCROLliY80ZXMW/E7m82FqOYBMe5840cjc1cKew76qiJdrOjJ3HXi+l2Dn7HQDvRYvTWWLuUCsZ+FAIIY4qdxvU60BVI1I53ZmhpU4TELDn74OIdmaY9XIc1sppKQm5CdUu0uaweR//tPcn7+M1h9Z4H29I3QBhLSB/T6WmT8K/tNY0fbUpff7TBwCrFUpL/+RNHsHRkLcXKqwDBZ5Mo8CyTKOs4qxqi1mVtMr72BNIrDgKX3JeMgQ3huyN5saQEEIIcQqRoJE4udLS/nyeul5ebesQ1twEjTwXG+4U9o22yrPuy9537PUCDoT5njzaNWjt8m0KJx2oCvH3VV3gvbbB8L+Arm93ZUXiiupnKM0xTYwsvhf95Tsm9sgvzjB9GCnf/WhVgf6jDWrgyWCyKivLD5rMUs9oax0adgDcgYN67aAwsVLTJ+Ffe7P2AmV9SoWGwqHKfVtXLbgx2LPBUegzuahc87TwIJNpVL7/qvK01hzIOUC9oHoArD1kgkYlDt+MttySXKjfBbI3mCbvYDpwF0IIIU4BEjQSJ1fMCb67WtXyjlKHXbvggQfg8svhuecgPb2KmUJbQMHeshM9tzT3+Z5FWQiwmMygjMJqUtirqcOReibrKjQgFIXCFGmB0syymaQDVSH+vqoLep/ogPwJtidzD9sztvPCyheqn0k73ZmZ7ufuAPuWr9oDZt/saV6UY8uvMhhf9MOZAESFRDG87XAAQgKq7xTH01dN1+iuAGQWZXozjvZn7wdga/pWiGhr+q+RrJI65emUXKOxOWy0bAk7dvzJmzzqtTcB2MO/+HRaXuROXCvfPK1i5pCHpzlafqkZFS0xNxGH0+Edbc3TkXapqxTqdzPt5w7NN+3bndJMTQghxKlBgkZ/Z3XRVKumUlPNSZKH1r7PT8TyUqu+w/v66zBwIBQWmv8bNkDDrlV8Z50HQEEWZK3zeX+w+0Llrj53MfuK2QBEBEccvV4V6hYebUZWefr8p2kb1RaA0uBGkLerbL6/eLOG9HRYvBjWrjWdlAo/OhW2cVG3qgt6VzX9NMpKmr3N7FPn7ZlX/UyBEVCaBe4maJ4Au3KZNNBeTXvx7IXPAuCwhpnXXb7zHnHvkwa1GsTMy2cCvk3QKpq1dRYAdncwaMG+Bfx24DegrEkcQJorEPK2gzWociG1VdXvbLWeNr99TXy2+TPv41VJqzjjDNi4EUoqdl1VlchOpn+h7c+Z9cJZSqkGT/goNCDU2zwt35ZfZRE/7/250rRF+xcB0DCkIQsnLcSCBZd24arXDqzBsOVJwGmaVwr/K06D/Z/C7ncg44+6PecU4gTKt+XXeJRmUZnNYSPyuUh2Ze7685n/RiRo9HdWF021ThObN8Ozz8Lvv8PLL8P998OHH4I1vYrvx9OVwb4PwF42Gk6Ce7/dJqoN7Rq2A6puFnE0nruXd/S9gx6xPQDICYyF9FXg7ufIp1mDswRSF8G+/0LyD2Cvfhjgky0zE0aOhGHDYOZMeOUVaNECiuTm6tHVJBBUV9u4ywkp82HN7bDiKtj2PORX0/RS1K3qAu/VBMNrasjHQxj22TC/lOVP5TOMEnMSq54poj3k7y3rb84tyf20d7PejO82HoANRSWQt6csY9QdjD/kjvM0rdeUBiENAMgszkRXc6G5Isk0l/OMkvXRho/YmLoRME3WPKO1rcjJMFlGhxf6P9uoqm3cVU0m6ml8zLc77axJWUOj0EYAzN8znzPPhN9+871BUVxcTQEBYRDcCHK2wP5PIG87+S5z4hxkDUIpRXhQOArlzSSq6PeU3ytN+2H3DwDE1oulb/O+NA5vDEBGYCy4bJC7Fb5uBAsHHfdnF1XQLlh3H/xyDuTtAFsGbHsWmsb8LQOqpyy52XVcjhQeIfL5SMbNHnf0GU+jm0d15cttX5Jfms/LK18+7jKyirO8o2OeLiRodLopTIJV18KC/vDbRbBgAKycaPpOqKiGTbX+Tt56CyZNgmbNIMKdHFSvHlV/Pxo4HAAHPoWig94+Kva6rwOiw6OJDosGjt4XRkVF9iKK7EUEW4MJCQihZf2WABy0NoaDsytdCAEwrzNkroPASPObL+jvE8g6VWgNw4dDnz6wapUJGM2YYbK5wsJqWNi+/8LqG2DZWFh7J6Qt9l5E22xg/zvfdKmLbdyWBT/3hJQf4Iw7oMfzpi+OwMjalXsS7NkD994Ll1xi/u67z0yrE6fCidrRMjurqNeRwiMsTVzKov2LjtrR74m2P3s/+aX5dGzUEYDPNn1W9YxRPUy2RoVAUKJ7n9AisoU3oLAiPw9dsLcs0D42Fa7WJLnnbV6vOVaLlYigCFzaVeX3kWfLw+Hy3S+vP7wei/tUa3LPyQxqZQIBGcHNTPbKuntM0MhRXeTiOFS1jVuqOd2r4f7AZoOdOyE+HvbuPbWzQz/d9CkAOSVm9NK317xNt25w4AAcPlx9HM1Hw97mf/wd8NPZ5LlMa8cgd4ZYWGAYFmXxjs5WkctpFnJRu4vo17wfYNYTgCbhZhRUzzp4sNQBKtC80VGhuaSovb3vm4zwizfCmU9A18dg4BeclEuh3B1w4AvYOwMOfgUl1Y++d6rQWlcbLPc6FY5zJ0FGUQYhT4d4+7Q7GV5Z9QoA3+/+vtJxyMfftEl7Tdwx/w4APtjwgXewjJpq9GIj4l6PqzYL9a/IL3tKpdQIpdQupdRepdQjVbyulFJvul/frJTq6Y/l/mWU5kLyXHNxu/9TSP21LF3enwqTYOFAaHcTXPgrDPoSLlwI5/zXjPBVUQ2aav3d7NoFfftWEcCophkZlzxhRjRbNARWXg3AAfc+OzosmsZh5k5iri336DvzcpJyzXDMnrvbzes1B2CNI8z81mlLzIWGZ10KawUj4qHTPdDqcuhwK4xYY5ponGLWrDEZRVOnmu84MtL8RUfXoBBPIFQp6PM2nPs1nPk4B3J7c80kxZVXwvTp8K9/wYgRkH+67Ldrst3WxTa+cSo0uxh6vgINzoSINuZ5SE1+PCOnOIec4pza1ec4vfsu3Hgj3HILzJ1r/iZPhoYNT0p1TknPLH/G+/iFFUfpO+gEu+ene4CyDKOnlz9d9Yz1O4M9FxL+ZzIzx6bC+FJ2uwNBMeEx3kBQqkOjrSGw4+Wyjo+dNvZ7gv/uwL+nD5pD+ZV7U96ZbjrNbhrelH8M+AdgmqkdyD0AwIMDHuTKrlcCsDVjJzTsCYUJ8OsFED/l+L+Qiqra7p3Oys1warA/cDrh0UdNduiKFZCSAvPnQ05NN98TOFrqf9b/ByhrFljiLKHZmbsoKYGrrjJN1IqK4LHHjlJI7IU+Hal7gkaefq3CA8OPGjTan2P6sZo2ZBpT+prf2NO5uueY7gkeJeUlQ4NuFUpQf/km6MCpEUzY/hL0eM7c4LCGgMUKARHHna15XK3aSnNh0YWw+21zsyXmAghqBK27nvzv5yi/0YHsA1iesnDhpxfWfT3q6tqkDjOYrv/uemxOG2Nmjan5m7WGzLWw8Z8Qf6/52/wk5FTRPHXatCp/o8Jpj/Liqhe9Nyi+2PxF9cv7mzZpP1aL9i+i0F5I2wamS5AP139Y4zJWHlzpffzs8mf9VreTrdbjdiulrMDbwDAgGVirlJqrtd5ebraRQAf3Xz/gXff/05vWsPEhKEmHrlPNELvaZe58OgrAevxXJ5s2mT53YmKgvenTkw4Fb3DuoCuwNO5XaYjYY+V0wvLlsH697124jh2hf3+z37bZIDDQZOHU6CK/piqeTD7xBEyb5u1A0qLq7u5Qly6werXJPggPP4Y3tBgN258HWzokfwvAYYepY3R4NIHWQEIDQrE5baQWpNIissWfFpmUl4RC0SjM3IX0nFjOzy/hziANK8ZB3/9AoBmVhabDzO/u+e0tgebvFLBvn7nQKCkxm8XWrVC/PjgqxM+sNRkAbt29wLcQN977mfNKY+h/rukjqUUL89u5XGadjaiD2JnLBe+9B+vWQbt20KAB5OaaO/A9e8Ltt1d/g/9UorXJHFi1yvwmnvO1Vq1MwC2yfBJR2m/Q/0MIcG8Y38S6+3+xwNXHfmc8KTeJVq+3AmDf3fu8fXadCIWFJqsoNdX8Zh5du2ICsWl/QFGSezh0ZUZIbNy/7DMfD89Jr2e/djxXHNOmwZNP+k5z7xdrpYq67UjfwZvvdPHO8uKqF7ml1y3eprZ1ISk3ifM/OZ9XLnqFSzteWu18nlHJXO7O/21OG4k5icQ1iBv2HycAACAASURBVGNZwjLiD8dzX//7UJZAE9Dc8A9o3Bci2kFJGvvtoFDefWpUSBRF9iKORI8gdvfb0KgftLwMcneQ4DBBAk/gv2FoQw7nHyYlP4UzY870qVf8YdMJ9sgOI3lx2Iu8F/8e+aX53oBCy8iWxNU3N3DWH14PA682Q6xn/mH+TmHPPWdWkx9+gJAQs6+22825gF9Uc7yvDU9g77JOl7EpdRP7c/azq2ANfft2ZMUK6NHDnMOsWgWvvlpNIU1HwqayqFKe+7zIEzQKCwxDKUWpsxSXdlU6L9mbbUZvi6sf5+1r5ECOCSJ6zgOa1msKmGM+ba+H7M3gdAcuLcF1OrKe3W6aipeWQnAwNG5cw+NwXaq4TsTE1C544CoBa2jZ8z87dlWxv507fiaz1ATOPNMcH20200fW9OnmnOZPrbsXYs+HTveVHU/qtaest/5Tj1256Pm+ude/OGExP+/9mRHtR1Q9sz+Oc38xs7fNZv6e+dQPrs++7H28+ceb3N3v7mN7s9aw4kqo3xW6TXVPVCYLtaqA+rRpZfvFct/x9bPHwY6yY+LkHyYzqfskLFWdgNbVb1TV+QnUbF8eG1s546m2230NXfftdUBZwP/+X+7n9j63H/P7XS4Xo74YBZhrwOdXPs+EbhPoHtvd/5U9wWodNAL6Anu11vsBlFKzgEuB8kGjS4FPtclr/F0p1UAp1VRrfdgPy69zWmvSCtOICY9B1eSuWN5Ok110RYW008b9a1WfggLTrCcryxzcQ93HwNItLVF5a8qaLR3HxVzPnmb7vusuc2EFJpX7nntMVkjfvmZ5drvJxgkIgKioWn2c6mnts1NzuVy8sfo17v/lfgBmXT6Lq7pdVSeLnjIFBg+GW281wYeICPN9VBt4aNAdIjtA9iZAmxsHTrBarN471PVD6pNemE5yXvKxBY3cmUYx4Sb63yS8CRZl4UBOMgy8A3a/CauvKXtD1vqyx5unwVaz887QoVxh78v6w+v5z+j/MK7LuKoPJHXkttvMOvLkk+YEy+UywckOHWD3bujcuSyjq7DwGIN0YDK7oOyA900syXsbYmUdHTuGek98rVY/XthU8OyzkJhoAkdKme3B4Sjrc7ZWqjp4Qp0cQK+80mzb991n9i9gPktoaBUXELHDIGUeRPWskMVWTVuPKk4kdj1xJ53U297n7d5sx8ZbN3JW7FlVFmF32vlk0yfklORwR587vJ3PHi+LxfzZ7WZd9HxGZ/JPWHc8C4NmQ/QA02xIBZo70uoUuJLynDCegBPyp5dVzt55ZvkzfHTpR3WyvJlbZjLxm4kAjJk1hnv63cPrI16vNF9yXjK5tlxCA0I5eO9B7vrpLmZtm8X3u75nV8Yu3ol/BzCp+mtuXkPzbo/D4YHwc2+I7Az5uzlULqAP0CisESn5KWyIOp+RaXNh5ZUQFAWlOWZeyoJGnv15VZlGyxKXAXjX4zYN2rD5yGa01tQPrk9wQDBxDeKwKAu7M3dD6wmwaapvISExrD+8ntEzR9MwtCFzJ8ylTVSb2n/BtbR1K/TqZfalnu3luPar5ZtDep4rKh3vayurOIukvCSsyspX477ig/UfcNv825i3ex4PPTSJ9etNU9Q9e0wQrFr1O5lRzbLWApCnA8GiCQsw+6DwoHCcLieB1kAKSgu8mWhgmqwU2YsIsAQQExGDw+XAoizevgqbRphgUatIEzxPyEmAs/8F8eUuOJtdVOvvoiorVpj+Gm+6Cc46ywSMiopM8Cg09M/fX2Plj1l1sP/SWlNsLyYs6CjHhrY3wvYXof9Hpr8qr6Mcu8rtb//4XfPgJHPeUj5gWlLyJ+tQebZ0aNyv7PzFc57+qgWu1r4nDic64FLNb3TBR+eS4+6rDWDkFyPJ+EeG94bmX0YdBEscLgfXfGPOw3NtuQDc8/M9TO45+djOU4pTTEuUc78qm1bDazeHy8GPe34EzI2JI4VHsDltLNy/kIva13L/cZTvzOFykF2c7T2Onsjzk7qSVpDGoQJzbB/RbgRLEpdQ4ihhw+ENnN307GMq46MNH5FbatYFT5LDnT/eyfIblkJpjkka8YzsGlgPAhvUacatP/kjaNQcSCr3PJnKWURVzdMcqHHQaM1Ll9DjyruwutN6Afb//BYdOlhNE5Vy+j0Vwxp9xPs8QFl5tdv53BQMa3mX5JRgSu2KyHoulieMYdh5IxjR3TQtmndgKYtWreStrP9VqsN8yzgGX3YxIc16e6ft3JhK2to5DJgwvuzHdzlISWtN690fYmk3EeWyw7bn+GPxJ8x3hXLzuBk0i2hCQWkRM3fP4zL7ZhpGdmafvoG168OwWjSd4lJ45NFAXvqgB0qVZZl3aZPGTz/F8H//ZyE3V6E12BrfTtKP39PTci+q2yMo9wb71oLbCEley8ghhwmwukApiouc5Kx4jm43vuddCZxZW7HlxRAc1BCtLXjufGzfrtFaMXKkOTg6HOZguWcPzP06i8lj/iBQZwMuXC5omXQtjMsty4ABvp3jYMfiBUya6CAoyHxFTqdiz0/v0feaOwkpV4d1C9cB1+HM2ornMq0kfQOh7/i2ahw/ZzwPzviacxNf4KmHDxLsTEHpUlyWetz65AguGRPB8H5bCS2Kx2UJY1diE+JK3qLdZdO85TqztvLEu3fSt18vRvW8EYClKWvJydjAU1dGc845jzFmDLRtayF+rZP7L3yUXue1Jqz1ud4y9m3cxeRbw3j/tXdon3MhSheTQTgOilAuB1G2NJxZ2TQMCseZ4SBs9l04r/+vTx2WfTabHj2DiOw6xjt9V8IqNJpmQWE4s7bSyJGHAhJ+uZh/7buZqectJqRkI0o7KbHG8dOyvlwaMBrLWdNR7SejW45hwuuj+NJyCFjq/c7GzxnPlICWTBz1GH1aDcThcjB7z880PpRMQFJzHHE3oCxWtFaAi+yl0xh180UE1yuLDn44bw6JrOCOi58nOrQh27P28cWuefzLsZct9mlkObriIgClNDvXl3Lp+GYEBlopKjLrVEAAfPn484wc8QD33WflnAEW8vI0H305g31nTkWHNyIyKIIcWx6hASG8kNOZgWP+j+Cmfbx12Oa4z2xmez/E0tZcbHZuvoNLun7K7bdNZvrTFho1UigFC787wJNPhzDzmxjvdqQUPD1dERNj5/qxuwktWodWAWzJbMSCnXcw5aq3aVu/JfmlhXy+8wcSfhhC3+a5nDc4BGsAaBRtIsL5ZUc/8vKCCQpS3gDEBx+Y4MuVow4SVrgMhSbJ1YWLlvQlv8IJ6osBD9OAkbTv28vnWDuoMIuK12QrBg3gjId706jctuHI3MKEd4YzbMAkhrYbSqG9iDl7F9JsZwij2xXSZNAUn3Ut8+cpbORJii1noLGilCbtgI3ggc0Aq3e71xqsq8eTGTmJFVu7kZ1jJThIU5Q3hQuCryKuJAPVcQpq2HL44QwS329J3ETfA9+2tp0Je6w9rTK3YG1ksjJKjqyn0zuVWyj3mT6B29Nf4B8PKoKClPc68qK5t7CRsgv0fyz8B70d3fisaSM6jH/Lp4xpz0ZRvz6MHb6PwNKDgJVtGYqbNl/PYUqxWqw4XQ6igusz7Z6HGXrBA7zx70D69DH70H1/pNAtqj7W0Kbm4L7tedjxAv9e+AC5rZ9m4vDlBDpSAU16aQjf/v4wV1/5Ch0anYFLu5iz9xd2Ll1HixYFXHfRM1iUhf25SSxOXkOfVT/SbdLL3t/UmbWVRV9vY/3uNgwY1d3nPvOUKYqXnz5MpybrsDjz0CqEbRtz6dJsM83Pv8Pn91zz/oP0vPJOgstN+2VxBDNnWnn4sTAii5dgceZTEtKdAz++wsAJlxFWbt7NK7YTlfcVLS9+wltu+qGVzHaPApZ4wyLsLgftPxnBFwu2kfbmQZ59OZbIkuUE2pMpCutP8fZPOFB4LtZGZ7uDa5qUFIAm7Fv9G8GuNJRy4nIFMO2dIbRs34jrLl5BoD0ZjZV5CQe5Y79v8OSNP97AsXo95/fuwJiBZlvfkrGbp5fOAODcZmcTZUtldIuezNo2i5fmP0Gytayt1KGCQ7R4oQNnfbuLea89SrOsZ7HkbMJBKOlOC0ppGtmzcWZtJSYoHJd2ceu481n0+uu0z70XS2k2LhVGmr0ElCbKO28IGk2nn97DHt3W5/dctnMRCmgfFIwzaytdG7Rg85HNgCY2uB7OrK20cBWigIyN/bj+2kKeuXU6TdMeA22nOKAZUVsOYt/Sy/sZ2r7ZltGugQxp5uC2se8QbA0i15bP13t/4cq8nyF2Mqv2XUh6ZgDBQZpI13q6hHxCy1FP+awny99/gT6jL6R8TN6ZOAfn5mdR/T5k8YoGHEoN4OwzSzhLPYazXneWJ11NckoAAQEw+dKD3PFIJ1q1imLMGAuBgVBYqHnz/fF06hzFmHNM06t1R7bx66Y/sCd+z+SrPyQmrDF2p53Ze34GppKz8jnqdR7trVvWnt+B/j7He2fWVpKuuYvWPy3xWScOR1h5/+FYJk14l9ZRbdBa882+hYwe+i9C832bh/3aBbgSOkfFQc4Ozo4wKYX1D89leLerGD/2HWZ+HUVpqaJFs1Iue7otvc4awYXtLqTAXsT8hGWUbBmFa+cApt72OHHZVwFO0gK74nStJ1Q7cGZtJUBrXNrFRVk9yZ07hfALH/J+jq375qO1i0bBkejs7cS4nKZpmyOIImsJjXQJzqytNLGYc7Wvpg+h+0HNpc2von7ul4CFQ3o0LZZfQV7cU/y6LJycXCsd2pby6/qb6N2/FyPOvh6AFYfWk5u5gbMTNrEl9D8Ul4ahsWDBSfyem+ndP45L+5l+On5P3cRL7zSlZYsLGD3aBIqcTtM094U3J9ClYz0uHWACV5szdrFg02ps++dw3fj/0LJeLKXu3zNyxRGGnNOIyK5lTXIKCiwMHdmADz+008C5DoszF5c1ks0r99G3ZxGNel7h/X7s6ZuhbS8CC3xTjpefNxBYgbPcccOZuYVhb51H6Efn0Lvp2WTb8tiVfYDGh4OZaV/s8/4gFcjFP8/l5qmDiW0W6D3er1z6MEO4hC4lY7CccTOq/yewZASr9/Sj5/4ffPah63/dQKzrZ5oNm+qtb4vInTiLo1m/PoouXRSFheb8IiR/JVmb/0t8yT/JyQvC6VJYLU4GhNxLsrqCw45zcWFFKchJ+ReXJV5NfWsEllaXeeu8dMcgem/6wGf7PLh2ER+9lcJ5Ey933+gz60n28qe4YFRzItpf4J03OSWAa26I4L13XUSUrsfqzMFpbciHi2fRuVsIV553v/f3XLpnH188fDUffNaECPsmgku2YQvpwvalK+nfu4CGZ13m/cxL1n3i7dz/qf538WvSapamxDP7m4Hc2HIA8SWPkZAYhMulaNbUTpPd4+g86U2f64pbb3bQvFsPn3tHDgc8MO5LLrxmJPWjykaQTFv/PQPaL6Ppebf77A/GjgvhwdsTaNsiF6tFo1F8u2o12aGrufPSV6kXFE5Sfipf71lA1uqFDL/wKs7tNBqAnxKWk7X+CIPDd9Dion/6lHvDLZEMHVGPPr1dROQvwBnQmNUHhvHmvxUz/p1OfdsyLM5c7EFtuefZcxlynpOxA5cQ4EhFqyBe2rQQu8tOt4bteWPIozz1xzssTYnnH08P4fz+vbnMvc2tOLSeZVuzWPXWKP79QhIh6ggW5cLltJB6aAQ91v8T65kPo5QVtGZ3dkNezA3g7j3f0bVRe7JKcvlkx3e0iS/mgoFNiexyqfdzfPLb8xQ5iujSsB2bJ37Hh9vmcOtv0wi+/m5Yudtn23BYLOyc3o1Okz/w+Y2ytvzIps0WbM0moiwBZlXTLmJ2X0b3617wOc49+NmTvJ7ztU+5AcrKysAB9Jj4L4LKzfvRN5+Trpdzx2jzG+3NOchXexZwX8lydlqeYV9mNxxOcx6qjixn4JvDaDb0Ye9278jYzL/evZahK6czpLPZXhYkrmTj75uxOVcyZezbNAypT1pRBrN2/8Tv79zExcMbM6BXJmGFq3BZwlmTfDEvvhrGjPftNCheSIDjCCWhZ/HQc2fTv28p4wYvJdBxGE0gT2yaC8AV7Ycza+RLPL763zwbPwPXVeNhue93mdKoKfmPtaHDde97p7m0i6nzzfnKzIteoleTLnT8bBTRhzeaZuhDl0BwWSujJe+9wlndbER2+b+yMuzFbJv5KIdbvI/LEoFGodBkbZrDkP5pxPYc6VOPnZ/dQedJb6OCym7irpqzkI4tk2jU90afeYsPriL+t50Mub+61NqjU3/aqdmfFaDUOOAirfVk9/NJQF+t9V3l5pkPPKe1XuF+/ivwkNZ6XRXl3QLcAtCqVateiYkVOnC+XME3vpO+Ofsyzr/PStSAW0FZIOljSPkMVUWHptfsGknyga94/pVgzuppJSAA0tNLaTaj8m2CAQVnsCpiN52PwBmZsLMx7IqGgrWhhM/37bRyY9/u9HgqFC5yj5ThzvSYdtMUpsW9Bb1DoHUzcDh5NMzGczqVRoUwdQV83h02NoX4lc24eeEPtL2kC0OHWXA44Nfv97Nkcyeys33rtme0laR5g1nZ4GKcbTsAULwnmdD8I0zr/BScBdQH+oLdaiFw7E6o18H7/uKZrQglydzZiI01kc83C1n7mZXMn4eyqcUoVIf2aIsVnZTMxS1fZ/XGSyjuORAVWQ9Kimnb8j1GTe6ApdsjJkCkNXzbksO7rTS9fjbUb2um7XqVpFWzafl/r0DcleV+OHc0fbwdmrkzb365jaVfLWbI00tNkNpdN/1GIWdtgfM3wsMrwWaFf50PDUPO59WJdgL6vQ4NzwRLAHzTlJdvvooHH/g3dO8HTc4BexG/L95N/34lMHy1t9zSNwoJNtnjPLYUgp3w+AUwJBQWb2xEwv8i+JAbOUgcvVjH0Ffm0+XqGaafA3cZG+7vwG/PXcoDBU9CZ2AA2BfC7SPCabqnkOnu85nZXWFRp5bMGJcBVxX5fO8/7u7NxZPugHY3eKcvegI+3F/IXV/DgGQoCYAHhkP02rFMS/8GQoFLgCBwzrMwPfdfTGv1JPQCYoAcuKZDC3Y4c5g+u4BWuTCzG7zTF3KruJPY5J0dfPxxJ0aOrPDCTGXWE4/N0xjz9X/43lrhTntaN1r8sIUkd3jY6dBYAxSuXe+y8r4VrFnfHd31TFyBQej0DB6Km0Dmt434mitYzTnUJwfX2Jm83X1NpboVxIQSftXvENXdW4f5n63lkpfno/sraA+Em/U9ey4kf9+Nr7mC1JDWBDhtxMYe5CPr0xw44FvuG20mcM/tX0Lf8dBsGLgcfLTwE27KWlmxCugOwASn2ceUW38Pfd6MeT9fwuGOQ3DVb4DKzSEwdw6PTZgD53U3zWOU4vCuX2m2dw1BDmhYbH7PnFDo/Go8T/+3F2PHVvO9l1tPlu44j8GXDzD9MrinF79eSFgVA5e9lDmYB6/pDH3f9c77x91dueazPyp19qy3v8KKf2zm9zWdwf0bOVOPsD+/mICh13Hf/RZim1uwl2oe/6eLQYuf4uqQ6WY/EwH0hhJrMCFX7IT2/U2GVKNwVt/VjXPOscLwlT7b8qi1FvpscjFtiVn+s+dCm0EtuXrcBDj7BZ/vd1C8lZwSJ9dtNNvnF90hytqZn3OS4Uvfjqre7zyGW+/8BfrdA82Ggnay+MvJXJBfeQSLvfFQb140nzKJPZwBQFNSiG6ewZ19v4B+PUzv9/V+4YevuzH69ijo9Tw06AQoZn7UkompOfQ4DBveh1/awUWToJErmEyLjcUfw5AEGHgjrGrlXn8q/J4T3/6cM0dP5JHyPQE6bex46Gw6TxgFZ9wOIY3BaWPJsxMYMirONA0sVwYAVxVD89bm8S+38e9XMjg/eBvdLtgKrcaZ/XPmOsj6FS47DG16eOddMWchgwaHwQULveXa3yjk1tUWuqx38eBqM+sLA2Fx6SVMzD2DSde9avYxCrKKooi+J6tSh8g7f/yEzqOuQ+cfhLBm5s7a93F8/HQfrr/rd+j9KMQOAu1k7ifX8Hjmfl79UnNBAuyPgsmjYYk7wSbzBYgqgU5TICe8MefbMrjnK+ifAnnB8OAwKIwNQ2UW8c6PEGmDGT3h9R6RXPnRfUzjSegN9AC9E+4+IxprSjovL4QAFyxsAx/1hI5znjDzdgf6AHvgph6tCA2288qrhwl2wsqW8FZf+N/Ycr+n+7u88+vPsZfk8sobGdQrhfhmMP1ciIiFSxfBle4uKv55PixNeZD7gsMZu+VJGAzEgf4O2t8J5+yEe3+HokB45jzY3rIeyUH5fPYtXLMZnhwM04bAO9/fzMeO13n0iQA6d7NiK4FFH87ivktnwNClPuvJkbxGNBm/GDoN826fvFnIjpkDGTn/c4pCGxIdYyHxoIXvBg1mytqvufKuGAYNCcBu02xYuJqHjlzOt19fwCrOIT+gIQ1ch3j3samUWGH/69AqFxo+DIGqAZnBOdy4Hj6cC992grHjgWkafeALaD3RW7e0p8KIvfOIz/GeNwv5Zmc/xl4zCc640zv91cdtPJDlYNRumPc/2BALvW6FgpcDCSv0HfFgfxQ8dh1M/BEu2Q12Czw0DMadDQOyBlA6Yy0v8yDpNOYuy6u0ezyl0j6iybzH+cClGL3+SRgAtIbkBfDwNTB6EYx3/55PDoaouPO4++ZY05eku76ZrxVyXzwMWQ43bjDzPjcI1nVrT3h4Ki++V0BMIRxoAP+8ADp8N5VprucgELgC2Gc2m2ccL/BB2t1cfz00irawcWs2n7SKxakg9SUIcUCDqRC37EmGt3ucGSauSmmpBqudqCeDKbLC2vchtgBaPgBnBVh4bdFFbE+8AH1md3RIKLaiDB7qNRalIfNFaFACZ0yB7IgoMkKy6ZcEy/8Lb/eB+0bC7sVN6bDU995vpooicXIcPa9sBl0ehPCmsHAg/9vYkQnXjDPNstzfj/P1IqxTNOT6fu/LbjyXwR8t81knHG8UEri30k/ExYVx/BSWSKd089l2RENqPfe6VuHy5rnnoPOXTzDG/pTZH4Ri/ocBVxZAi3bebXnZV79x3rBGcN63Putl0ZchLJg7go2xI6BZM5TdxrZsTZNLLuONN604HOB0QUY6nNldkZGhCQpSaJdGWRTz58OhW//JzXHPQFu85y37C1rS9uovodtl3u1z3g2DeeyX+Wza5Ps5Nr7UkR4TX4dmI7112/ZQKwq2NqDfFSXQ+T4Ib45z+Rjqbcun2Ap734B22dDiPkihBc+8cy2P3v2sOWd1ARb47kBfxky6ATrc5i1369NOntlVwsT5cMkes7/9xzC4ILc7z2z6juunNmPYiAAsVli72sn1EcGVjnMfLL6JHfbpTL67vvvGmMJm0/Q4J6zSb7TkzccZ0j/d57yFNwshvDWM3mPO8R1FoAIYNL0FK1U6gU5oVOT+3QGlQStY+QGkRsDl4+HWzEG8NzYShsz3KXfaNY8xreUzMBWz3Sn45tsxdGufwBnDQqDD7eYiP2srX96xkqvu2gI9H4fo3uC08d7717I86wBTv7DR7QgkNDDXJp+7k6Yv3gX1SuHLM2Giow2fDGqP9dxPzHHd5YC5bZh23WimNf4A+lghrgm4XHwXDZfZKmeaL1A9GX7N3dD2Ou/nWPZEAO/uz+WW7+D8hLLf6MKz+nPlpAnQ8W7vvLZXSgkOtFf6jaJuzmLJqijOqpjsXcV56LU7WzHLcpDuh6BpPmyOhYMNKpzjuLejwXPeZpmlQmubrLZ0mvMHs+dH0amLuda1WmDZB/9maPflJuvKvbwjrxYS4z5v/2wOZIfC3RdDx5JYdoWkEuCEFnlwsD64LPD08w/w2J2vwNn1oMlgKMnih0UN0esa83+TPoaothDZBjLW8r+3BjPhro3Q+wmI7gOuUt5/fyJLMxP45+eldEmHQ/Vg6oXwwMAOdJ/4FjQd7q3brkea0XFNCnzle8PirhvCCE4u4sVFYNHwyVmwrG0zrg/vy7kXt4PwELAvB9syds9oyhkV9qEfB17LV8M+Yf58369t56NN6XTD42adhLIWJXOoFBdZet25DA4F3lvu+8LE5vB55VG8lVLrtNa9K71QcT4/BI3OAaZprS9yP58KoLV+rtw87wNLtNb/cz/fBQz5s+ZpvXv31vHx8bWqX0Vdu8Jrr5lhvstngyXkJND93e7eYVNjwmPYcvuWsrQ7P9Ja0/K1lqTkl52kKCx0/9bOlCkWxo8vawZVo+Y61dn7ARQlm05BgxubzrgTPgVrGFxVePzlzm0H53xq+n9wlcLWZ2D7s2ANh6sqjNiVPA8yVkFkJwiJhYTPIOHzauvgyQb5Uz/1MqNgNL/EXMx7m2Up6P6UOUFRAe4Lljam4Ar9A3y++XMmfTvJZ9prw1/j3nPurdn38ReyJnkN5318HjanDYAhcUP4avQidu20Ulxc1g+kUqaZXlBQ5TIOZB/gzvl38sehP7i99+1c324qd9wczpQppq+IiAhz9/LQISofiPzkmNeTqmgXzOsEPV4yQUBPU6s5MbyTVcydh8oCEhO6TeCLIQ+gCvYCyqxrf0w2neyi4OoK6e2rJpl1u9dr7n6lFHzbvMr1z192ZezitdWv0SaqDbf3vp3IkMqjmWVnw1NPmX7Q2rYt+41SUmD0aN++i3780fTTsHy5yQzzKN+cy69KjkDaUsDl/n5vrv77rYrTBt+1NIMARLQra34w072jv/o4VxSXA2YFwhXZEOTuAOmbWGxFaTTYByXA0LZD2XZkG4cLDnNJh0uYt2cew9sN5+puV3P999ejUOQ8kuPTdKVa+z8xo+mc921Zn2TedPVj/BwHPoddb/5/e3ceX1V17n/88yQBEmZkFgIJlEHFAUTFMFWmMgjodShq71XRXlTUSrUqyg9QARW8osWhpQpSqwilDiCKghRRFBQBkUEQgUKYwiCQMGRcvz/WdGTY3AAAGw9JREFUCUlIAgknIefA9/168co5+5zsvcNz9j5rP3utZ0GXT/3MYRHl4L2GwX/+XBbMucyfT6/4G1RtgXsvlne+von9zf9CTIw/VzgHrTMGc8FtL/vjMz0ZVj8Na572sb1mqy/+Ghm4t19IjFpMaMH6feuZ/z/z6di4I9Gjosl0meE5NCIIw+YPY/QXo48N2evxZg/mfr2d2I9WsHZ1FDExObXTDh8u+gyUKSm+Ftu11/qhSmb+XJCQAAsXQlxczrpSUgoenn3P7Ht4demrxFePp3p0dZbvXE5c1Tg2H9xMXPU4Nv1hE/d9dB8vfftSgRfyUPTz+JLEJbR7vR0NqzZk65CtTFkxhds+uI1uTbox97/nFu2PPoGDqQeZsXoGDas1pGt8VyIjyn5I6vTp8OKL8PHHfghU+fI+Fnd9+jve+uEtKkRWwMw4mnGUi3ePoumOxxkxwg+rL1cOjhyBV9c8wcjPR+ZZb69f9eKjWz7Kt71mE5qxYd8GFty6gITYBKJHR5PlsoiOiuZoxtE87/1+0Pf563Ssexl2LwwMAatU/HNXwIk+E0fTj1IuslxIxAf8sG4zXxcrJcXvd1qan2jh+uvhiit8vaOsLD/ap3XRRrkUTfaFzE+vQeL70OEdiAicEN427tgJk5Lh+vOu58K6FzJiwQhqxtQkKaEbEXuXwuUvQ6328H4jiCxfpO8H53xN09mzff3P7KF5JVrjLLeUjfDlAGg7wRcPj4yBH0aSuWo08Ztha66Oate19L2y/rnmn3lWMf4343mgXQFt+ozD8EEjPytszcvgyE4/C3Ljm/x3XHbdqX/VhswjcM02vywi0Cgq5Ltr0ZZFdJjcIc+y5Vf25ZJq9eCKib4g+uqnYe2zBV8zAbsP7ebhuQ8z5fspNK3RlKnXT6XtuSe9rj8lGzbAypWBHuaROdcAvXsXY+hlIbK/I7KNavERrz/Wi40b/QQ12TeccteXzO2BOQ/w4pIX8yyb2Gcizy95/tikAgAJsQksat7Qx7TDO77tZhH+s51+EBL+Dg2v9WUHZjb1deOu3RGIZ+CDG2x7sQSkpPj2d/b/S/a58JprSmnoMKc3aRQFrAe6AtuAb4GbnXOrc72nD3Av0Bs/dO3PzrnLT7bu0kgaLVzoZ1N65BF/Io+K8kUAmzTxyZxnFz1L1QpVueeye0p0u8dLy0yj8fjG7DzkT9Df3biHbu1rkpSU9wItpKXuhc3T4EhiznTbGYfh/IeDnrGryMmA/at8kdMGfaHur33RyF2fw+oxcPWqnKLQJ2m4jF44mmH/HgbAg+0e5LnfPBfU/ocD5xyTlk3ikvqXcOm5l5bgev0xdfSo/yxXq1aaJ7ogkkbJG+DTBLh2e04DINfn5MB/7eex+Y8x6NJBXFS3GAXsMlNhehW4bjeUr5ZvvWX5ZVQc27f7i8fZs6FxY9+d3MxftJRWPINyaAvMbgU3/JJTfyg7iVxIo6zIvrnLz7Jz4XCfhP4gHlKT6LsNPjxu0qSVg1Zy0V/zfl5a1mzJ2nvXFm1bKZvgs27Q+QM/M11WOsxqAalJFLk+3exW0OZ5f1cMSu7zt/MzWHw79FqR08W6sEZWVjoWWQ73/UifuLIIPynExslw3U6/DE4YoyGfDOGFxS8wvNNwOjfuTNc3uxJXLY5NDxzXZfAMN3/TfLr+vSuX1b+MJb9fQr3n6pG0vjHNFy5mxYqIPMdjWlrBSf6CTJ4MkybBnDk5N6dWroR+/XzdlqKs54ddP3DRX/J+3sd0GcPIBSNJy0qjVZ1WrN+73k9bHGTSKD0znZjRMWS6TI48foSH5z7MhG8m8HyP5xly5ZAi/MXhJyHB15T87XHlG9ftWUfLl1vmWfb1wK9pF9uOlBTYs8efs8uXh7r106g1riYp6TnH15YHthBbLTbf9u7/+H4mfDOBEZ1GcGXslfR8qydNqzflwYQHueeje6hSvgrJacl0iO3AFwO/yPf7rBrlz8WXjj8uaVS8iRKC+m4vA9u3+1lhDx3yySEzXyswO8l35Ii/GK9cuejHZ6EKqnc4GLh7DJz/qN944Lw690gFeiSm5nnr7c26MSnyK+i9AirF+/ZPMS6WnfPnix9/9MnJ01YiMz3ZzzaZedRf5JeviYtpwIB/3cT0NdOZet1UBrQaQEpaCrXG1jp2U7RlzZasvmd1wbU8f3wRfhgB7d+B2h3899T0StDpA2gYGDKU/R0VXQf6/yfnuuIk7YtlO5Zx6UTftp41YBZXN+8D+5bC7q8C9RLx/5nNBx9XY+vMsz15O7PWzeL21rdTPrI8O3bA3Ln+PJU9IVtkpK8je/zxkZWVxaUTL2XFrhUAXHfedcy40Q+Py74hMa77OB5q/TuY1SxwUypXBupt871bL/+Lb8dlLytfwyeNsm9elVR7MQydtqRRYGO9gRfwBTEmOedGm9ldAM65v5ivHv0S0BM4DNzunDtpNqg0kkZ+n2DtWl/ANi3N313v3Pn0z3J04OgBur/Znb/1/RtxMRdTv76/C5H7bn+p3dUPccVuMKQdgCM7ICsVDqyCteOh+4KcE8RJGi7OOVr/tTXJqclsuH9D8QqeS5kJqmGZngLv1Ye+66BCncDQxlNr4OZxwqRREOstA3v2+AvLVatyZqJLT4dXXvGFU0OKczC3IzT+LTS9IzDzGT6BFFUCWa4DP8K22ZBxwK87qgoHm9xJtbG1AiPOHUPbD2VMtzE0n9Ccn/b9RI3oGvxy9BfevfFdrj3v2pNvI1vqPvjPVD+zVkQ5/7dFVYFLRhdtRsSZTaHdFKgTuNNZUp+/bwb5pFnrcUXqyVXg8bl4oP8bWo/jWK+99GSIyT+F78SlExk0exCRFklkRCRpmWm0b9ieL+/4Mt97z2SH0w9TaUzeLsdRFsUfD6WxZo0xejTEx/v2zCefwM03F229PXv6BNGgQTntjLQ03xNxyhQ/4UZRej3f8q9beHvV24AvFL7roV00n9D82Mxh4GercyOzgkoaAdT/v/rsTNlJdFQ0aRlpZJHFwtsW0rFxx6KtIMz06eNjNHBg/l4cI/49gicXPgnA4MsG81LvlwpYg7d8x3LaTPS15KZdP40bL7ixwPe98u0rDP5oMJEWSVREFKmZqXRq1InPb/+cq6ZcxYLNCwA48OiBgntOZhyGz7r6hHWzu/yFWfpBf8FdDOGWNDqtCkoaXQg8dSH0WujPr5ExPhblKlN3XF2SDicRExXDkYwjJPUbSe0D30D7qf6G7yncVJgxww/3e+klaNvWx2v9et/zqCxkZWXlSQqt2LmC1n/1Xbp2PbTr2EyZ+Xx4AdTrBpeMyelV9Lb5WXmveM3/P1qET1R990f/WW49FqLr+qTP3u/8zJyF+GrLV+w/up/ezXuX1J96Vjpw9ADVn/WJoNRhqZSPzMksZWRlEBURBTvnw/fDoMucnI4M2Z/tju9DbP+8ywAa/RbaPAfR9f2HeN8yqFk6vblC2WlNGpWW0koahaonn4TPPoO33/bd9CIiYPNmP7vU2SaoBkPGET8Uo+s8Pxwu+4Ix41BwU2ZLyAm6Ybl5GqwcBm1fgtpX+mE32z6G+CJedRWmoOFpWWln/N2kMpeeAiuH++ERNVr75M7eb6HPylLbZPbQIYCDjx6kSoUqzNs4j+5vdgegWoVq7H90/4lWUfLWjIXdi6D92znnvJI4/825HFo9Bg0DhW9PcrFR4PHpHOyYA+tfBReoQ1OuGiS8mS8htv3gdhqMb5Bn2dAOQxnTdUxwf0cYih4VfezOOfiZt7Y/uJ3ERJg5019DRkdDy5a+G3tR7nskJMBDD5GvntrPP8Ntt/kehgkJftbL2bNh3ryC17P1wFYaveBnAJs5YCZ9W/Rl8vLJDJw5kCY1mrDxl430a96PmTd/EHTSqNPkTnyxJW8Pl9THUykfFWz3jdD03Xd++OCsWb5HfGamvxNfsSKkpKVQ5WlfyKUoQzYvePkCNu3fxKHHDhV6Yyx3LLMN7zScJ656gh3JOzj3+XMZ1nEYT3V5qvANOefPP0kLfI/08uf4HuiRRb/ToKTRKfjPNN9bon4Pn6Q7nAiXv8r01dP57QzfVa1/i/68H18XYupAq5F+ZtC3c30WitETdc8e+Mc//EzKGRk+cf3II6Fzo3v4/OE0qt6IO9vcWfAbstJ9r6Kr10PluJzl2f8ftdrDrwb5XrUH1sD5f4J9y2HT3+HwNn+jsXorOP+R0Jhd9QyXmuG//ypEFXIeObAG5veAfhvyjzK5/K9+9sTjbw73WuZLAhxO9DfEqp0PrYaedfFU0ihMzZgBL7wASUn+CzMuDj78MATv6peyoBsM22b7YRSthkPdzv6Cad0EaP9Wie2jlL0SaVgmb/A1YJIW+C+N+j19IclgvjQyDsGim33DokEff6dqx6e+ILSUPucgIxmI8ImSUuw5uO/IPmqOrcnFdS9mxV2++3SWyyLySf/5mXj1RH5/6e9LbfsFykyDL2+A1D2+0Vu+BuxdAhePCm69n1zhhz/EBnpNnaQHU0kcn3XG1mH3kd3UjKnJ3iN72TZkG+dWPTe4lYahflP7MWv9LBpUbsC2lG08kvAIz3R/Jqh1Dh7sY/TsswX3Itq0CRITfQ+X+HioW7fwdVUeU5lD6YfIGp6FmZGWmUaFURWODWdaNHAR7RslBJ00mrR8EnfMvOPYeutVqseOh4o9EW9Y+fJLuPdeX5e/Vi1/kb5mjX/tqQVPcTDtION6jCux7dUeW5s9R/YcO+Z2PriTupVPEPxSoKTRKcrK9CUj0g74837FhqRlpVNhlL+IWHzHYq7YPtkn8i56wifqw7QndNB+WQH/7gP9N/l6TpD3Rsh1eyBpoe9dVDkeancMm6nRz1qzW0H8rX4SkajKPjG4cQr8/DfoOj/nxllWetF6bZ8llDSSsBYX54cPipxI48a+N17IOrTVNzrI8uPlK8eX9R5JKUhKSaJqdFWio3IqRnZ4vQOLEheRPDSZyuWDq/F2Spzz9RMS34fUX3yRzya35sz+dyq+vdf3xmv9HJQ7ea+lkrjw+9Onf+K5r32NuXNizmHvw3uDW2GYmrNhDr3e6kWbem1YtnMZ6+5dR/OazYNa57JlfojaN9/4hFBMTOEFr08muy2ZuwdL1793Zf6m+QBk/L8MoiIjg04aZQ/Vi68ez6b9m3jqqqcY1mlY8Xc4DP3yC+zfD/XrB1+c9kT++MkfGb94POAnhdn5UOlM3nAiShqVrOwh01nDs7CfX4ct06Dju35mzbPVjrmw6inoPCunlMAp9rqSEHFgLcztAHV+DbHX+AlWNk72Pf/LVYWLx/h2+M55EHdTWe9tyChq0ihcSi7LWSakEwEiRVUpFuJvKeu9kFJWp3L+egnzbp1HcmoZJYzAX3XVvMz/KymNboCvboaLnvLdvyMi/XDgkqgZVYhuTbodSxrd3CrIYaNhrH1sewB+SPoBgGbnNAt6nW3a+ALLHTrAnXf6WS/fe8/XMyqugoY7Dbp0EPM3zaftuW1LbKariuUqUqdiHTbt98XQOzfuXCLrDQc1avh/pa1H0x7HkkY3X3j2HnNnkvX3rc950qAvLL0PDq6D6hf6YYOZqcUaPnhGcBmBHuW5kkPRdXN6XUn4qXaeH5728yTY9KZPFF0yFup0gtWjYUFP3wuvSjOfVIoMxVldQpeOChERkRIWHRVN7Uq1y3o3SladTlCpMczr7OtGHd0FP79Wqpts36j9scc9mvYo1W2FsioVqhBBBOlZ6XSI7VBikzX8+c9+eNq0ab7YcmKiL4ZdEnr9qhcAfZv3LZkVBtx8UU4i47IGJZgUFQA6NMqZKvxsPubOWDF14Vd3wsL+sPlNSNkMm8/C0g1RlX3NrdzDlP5rp+9hdDYN0zvTlK8B5z0IXT6FjjOgQW8/o/clT8P1+3xs+/6ohNEpUE8jEREROTkz6DQTvrgWFvT1Q91cBrS4r9Q2mbun1pk6Q1ZR3XDBDUxbPY0BrQaU2DrN4JZb/L+SVqVCFdKGpZVYL6NsXeK68MLiFwDyDAmVkpH7mMvu4SZnmDbP+95FS++HiPJ+oo6mA8t6r06vaudD8rqcmVazZWX6XrQikod6GomIiEjRRNeC7l/42SnbTYKr15b6JiuX8xex1aOrl/q2Qln2UKzOceEzJKtcZDkigqmjVYDsnjCt6rQq0fVKjpjAkNMqFc7imjdnsohycMVE6LMGOvzT/zzbVKjpe6Vs+xCyMnKWZx0tu30SCWHqaSQiIiLFU6vdSd/SuHFJTTaTDICNLIl1hbO7gbu5cGRZ78epK+jz0Lhx8dZRI8YX9undrHcJ7JEUJHFIIslpyWW9G1LaKsflnW7+bFP/N7ByuJ/llsqQdQR2fe6HNIlIHpo9TURERERKlWZFlaIK+ZlR5cxw4EeY0wYqxsJFT/ri4KtGwU0lVNhNJAxo9jQRERERCQlKAohISKnWElr+EX4cD4sG+Dp9URqSKVIQJY1ERERERETk7HLxKKjSHH78P4iu52s9iUg+ShqJiIiIiIjI2afJ//h/IlIozZ4mIiIiIiIiIiL5KGkkIiIiIiIiIiL5KGkkIiIiIiIiIiL5KGkkIiIiIiIiIiL5BJU0MrNzzGyumf0U+FmjkPdNMrMkM1sVzPZEREREREREROT0CLan0aPAZ865ZsBngecFeQPoGeS2RERERERERETkNAk2adQfmBJ4PAW4pqA3OecWAvuC3JaIiIiIiIiIiJwmwSaN6jrndgAEftYJdofM7H/NbKmZLd29e3ewqxMRERERERERkVMQdbI3mNk8oF4BLz1e8rsDzrmJwESAtm3butLYhoiIiIiIiIiInNhJk0bOuW6FvWZmu8ysvnNuh5nVB5JKdO9ERERERERERKRMBDs8bSZwa+DxrcAHQa5PRERERERERERCQLBJo2eA7mb2E9A98BwzO9fMPsp+k5lNBb4GWphZopndEeR2RURERERERESkFJlzoVs2yMx2A/85bnEtYE8Z7I4ET7ELT4pb+FLswpPiFr4Uu/CkuIUvxS48KW7hS7ELT4XFrbFzrvbJfjmkk0YFMbOlzrm2Zb0fUnyKXXhS3MKXYheeFLfwpdiFJ8UtfCl24UlxC1+KXXgKNm7BDk8TEREREREREZEzkJJGIiIiIiIiIiKSTzgmjSaW9Q7IKVPswpPiFr4Uu/CkuIUvxS48KW7hS7ELT4pb+FLswlNQcQu7mkYiIiIiIiIiIlL6wrGnkYiIiIiIiIiIlLKwShqZWU8zW2dmG8zs0bLeHymYmcWa2b/NbK2ZrTazPwSWn2Nmc83sp8DPGmW9r5KfmUWa2XIz+zDwXHELA2ZW3cxmmNmPgWPvSsUu9JnZkMB5cpWZTTWzaMUtNJnZJDNLMrNVuZYVGiszGxpor6wzs9+UzV4LFBq7cYHz5Uoze8/Mqud6TbELAQXFLddrD5mZM7NauZYpbiGisNiZ2X2B+Kw2s7G5lit2IaCQc+UlZrbYzFaY2VIzuzzXa4pbCDiVa+/ixi5skkZmFgm8DPQCzgduMrPzy3avpBAZwIPOufOAdsDgQKweBT5zzjUDPgs8l9DzB2BtrueKW3h4EZjjnGsJXIyPoWIXwsysAXA/0NY51wqIBAaguIWqN4Cexy0rMFaB77wBwAWB33kl0I6RsvEG+WM3F2jlnLsIWA8MBcUuxLxB/rhhZrFAd2BLrmWKW2h5g+NiZ2ZXAf2Bi5xzFwDPBZYrdqHjDfIfc2OBJ5xzlwDDA88Vt9BSrGvvU4ld2CSNgMuBDc65jc65NOAd/IlHQoxzbodzblngcTL+4rUBPl5TAm+bAlxTNnsohTGzhkAf4LVcixW3EGdmVYFOwOsAzrk059x+FLtwEAXEmFkUUBHYjuIWkpxzC4F9xy0uLFb9gXecc6nOuU3ABnw7RspAQbFzzn3qnMsIPF0MNAw8VuxCRCHHHMB44GEgd2FWxS2EFBK7u4FnnHOpgfckBZYrdiGikLg5oGrgcTV8OwUUt5BxCtfexY5dOCWNGgBbcz1PDCyTEGZmcUBrYAlQ1zm3A/yHG6hTdnsmhXgB3xDLyrVMcQt9TYDdwOTA0MLXzKwSil1Ic85tw99p3QLsAA445z5FcQsnhcVKbZbwMhD4OPBYsQthZtYP2Oac+/64lxS30Ncc6GhmS8zsczO7LLBcsQttDwDjzGwrvs0yNLBccQtBRbz2LnbswilpZAUs09RvIczMKgP/Ah5wzh0s6/2REzOzq4Ek59x3Zb0vUmxRQBvgVedca+AQGtIU8gJjy/sD8cC5QCUz+13Z7pWUELVZwoSZPY7v2v9W9qIC3qbYhQAzqwg8jh8ik+/lApYpbqElCqiBHz7zJ2C6mRmKXai7GxjinIsFhhDo1Y7iFnKKce1d7NiFU9IoEYjN9bwhOd3jJMSYWTn8h/Yt59y7gcW7zKx+4PX6QFJhvy9loj3Qz8w244d/djGzf6C4hYNEINE5tyTwfAY+iaTYhbZuwCbn3G7nXDrwLpCA4hZOCouV2ixhwMxuBa4GbnHOZTeYFbvQ1RSfZP8+0FZpCCwzs3oobuEgEXjXed/ge7XXQrELdbfi2ycA/yRnGJPiFkKKee1d7NiFU9LoW6CZmcWbWXl88aaZZbxPUoDAXYPXgbXOuedzvTQTf+Ih8POD071vUjjn3FDnXEPnXBz++JrvnPsdilvIc87tBLaaWYvAoq7AGhS7ULcFaGdmFQPnza74ceiKW/goLFYzgQFmVsHM4oFmwDdlsH9SCDPrCTwC9HPOHc71kmIXopxzPzjn6jjn4gJtlUSgTeA7UHELfe8DXQDMrDlQHtiDYhfqtgOdA4+7AD8FHituIeIUrr2LHbuokt3l0uOcyzCze4FP8DPMTHLOrS7j3ZKCtQf+G/jBzFYElj0GPIPvinoH/mLphjLaPykexS083Ae8FUiqbwRux98YUOxClHNuiZnNAJbhh8csByYClVHcQo6ZTQV+DdQys0RgBIWcH51zq81sOj55mwEMds5llsmOS2GxGwpUAOb69jaLnXN3KXaho6C4OedeL+i9iltoKeSYmwRMMj+dexpwa6CHn2IXIgqJ2++BFwMTdhwF/hd0zIWYYl17n0rsLKc3roiIiIiIiIiIiBdOw9NEREREREREROQ0UdJIRERERERERETyUdJIRERERERERETyUdJIRERERERERETyUdJIRERERERERETyUdJIRERERERERETyUdJIRERERERERETyUdJIRERERERERETy+f/rw9gqBUcgeAAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -1850,7 +1972,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1862,19 +1984,7 @@ }, { "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1888,13 +1998,17 @@ "name": "stdout", "output_type": "stream", "text": [ - "tal hits: [MotifHitAndCoord(motif_idx=0, motif_score=0.7396519082923678, precision_at_motif_score=0.6466523942825104, example_idx=3, start=8, end=33, is_revcomp=True), MotifHitAndCoord(motif_idx=0, motif_score=0.9925835180934502, precision_at_motif_score=1.0, example_idx=3, start=17, end=42, is_revcomp=False), MotifHitAndCoord(motif_idx=0, motif_score=0.7552320976497837, precision_at_motif_score=0.6949197693348133, example_idx=3, start=44, end=69, is_revcomp=True), MotifHitAndCoord(motif_idx=0, motif_score=0.9989573753258589, precision_at_motif_score=1.0, example_idx=3, start=53, end=78, is_revcomp=False), MotifHitAndCoord(motif_idx=0, motif_score=0.5618840852404383, precision_at_motif_score=0.09592826695380294, example_idx=3, start=75, end=100, is_revcomp=True), MotifHitAndCoord(motif_idx=0, motif_score=0.997376173301304, precision_at_motif_score=1.0, example_idx=3, start=84, end=109, is_revcomp=False)]\n", - "gata hits: [MotifHitAndCoord(motif_idx=1, motif_score=0.9998595508158103, precision_at_motif_score=1.0, example_idx=3, start=117, end=142, is_revcomp=False), MotifHitAndCoord(motif_idx=1, motif_score=0.9276210105708627, precision_at_motif_score=1.0, example_idx=3, start=161, end=186, is_revcomp=False)]\n" + "tal hits:\n", + "\n", + "gata hits:\n", + "MotifHitAndCoord(motif_idx=1, motif_score=0.9994427100002803, precision_at_motif_score=1.0, example_idx=3, start=62, end=87, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=1, motif_score=0.998124872090949, precision_at_motif_score=1.0, example_idx=3, start=86, end=111, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=1, motif_score=0.9933627532372303, precision_at_motif_score=1.0, example_idx=3, start=153, end=178, is_revcomp=False)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1913,19 +2027,7 @@ }, { "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1937,7 +2039,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1951,13 +2053,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "tal hits: []\n", - "gata hits: []\n" + "tal hits:\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.704276474569764, precision_at_motif_score=0.44302641367625195, example_idx=4, start=1, end=26, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.9952651939732524, precision_at_motif_score=1.0, example_idx=4, start=10, end=35, is_revcomp=True)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.635539514810006, precision_at_motif_score=0.28118745516214005, example_idx=4, start=58, end=83, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.9995073050902686, precision_at_motif_score=1.0, example_idx=4, start=67, end=92, is_revcomp=True)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.8856687419902738, precision_at_motif_score=0.8314828431175738, example_idx=4, start=140, end=165, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.999818566464115, precision_at_motif_score=1.0, example_idx=4, start=149, end=174, is_revcomp=True)\n", + "gata hits:\n", + "\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1976,7 +2085,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1988,19 +2097,7 @@ }, { "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2014,13 +2111,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "tal hits: []\n", - "gata hits: []\n" + "tal hits:\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.999818566464115, precision_at_motif_score=1.0, example_idx=5, start=26, end=51, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.8856687419902738, precision_at_motif_score=0.8314828431175738, example_idx=5, start=35, end=60, is_revcomp=True)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.9995073050902686, precision_at_motif_score=1.0, example_idx=5, start=108, end=133, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.635539514810006, precision_at_motif_score=0.28118745516214005, example_idx=5, start=117, end=142, is_revcomp=True)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.9952651939732524, precision_at_motif_score=1.0, example_idx=5, start=165, end=190, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.704276474569764, precision_at_motif_score=0.44302641367625195, example_idx=5, start=174, end=199, is_revcomp=True)\n", + "gata hits:\n", + "\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2039,19 +2143,7 @@ }, { "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2063,7 +2155,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2077,13 +2169,21 @@ "name": "stdout", "output_type": "stream", "text": [ - "tal hits: []\n", - "gata hits: [MotifHitAndCoord(motif_idx=1, motif_score=0.8735744116604658, precision_at_motif_score=1.0, example_idx=6, start=171, end=196, is_revcomp=False)]\n" + "tal hits:\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.8114523781844735, precision_at_motif_score=0.6617643108541413, example_idx=6, start=8, end=33, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.9988489961840756, precision_at_motif_score=1.0, example_idx=6, start=17, end=42, is_revcomp=True)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.8389726480891654, precision_at_motif_score=0.7246978685792207, example_idx=6, start=44, end=69, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.9998068744229901, precision_at_motif_score=1.0, example_idx=6, start=53, end=78, is_revcomp=True)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.6694922206103467, precision_at_motif_score=0.3611280077363049, example_idx=6, start=75, end=100, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.9995233787592409, precision_at_motif_score=1.0, example_idx=6, start=84, end=109, is_revcomp=True)\n", + "gata hits:\n", + "MotifHitAndCoord(motif_idx=1, motif_score=0.9998292111100581, precision_at_motif_score=1.0, example_idx=6, start=112, end=137, is_revcomp=True)\n", + "MotifHitAndCoord(motif_idx=1, motif_score=0.8404588409236708, precision_at_motif_score=0.7594466445239779, example_idx=6, start=156, end=181, is_revcomp=True)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2102,7 +2202,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2114,19 +2214,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABJYAAACMCAYAAAAulSOdAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAASPklEQVR4nO3dbbCcdXnH8e+vidiKdoAhYExCE51j2+BYpFuKdXR8oibUIfiCNkzVFJmJdMRqx7YGmWl9yfhYnVJohJQ4pcYMgmQcFGJq9U1BThCRgJFjpHAgJbG2yEgHCF59sXfa9bAnCfduOIfd72dmZ/f+P+xeZ67kZPM7e98nVYUkSZIkSZL0bP3SXBcgSZIkSZKk5yeDJUmSJEmSJLVisCRJkiRJkqRWDJYkSZIkSZLUisGSJEmSJEmSWjFYkiRJkiRJUisL57qAYTrxxBNr+fLlc12GJEmSJEnSyNi5c+ePq2pRv7mhBEtJVgGfARYAV1XVZTPm08yfDTwO/ElV3dHM3Q88BjwNHKiqTjN+AvBFYDlwP/CHVfVfh6pj+fLlTE5ODuNLkiRJkiRJEpDk32ebG/hUuCQLgMuB1cBK4PwkK2csWw1MNLf1wBUz5t9UVacdDJUaG4AdVTUB7GiOJUmSJEmSNE8M4xpLZwBTVbWnqp4EtgBrZqxZA3y+um4Fjkuy+DDPuwbY3DzeDJw7hFolSZIkSZI0JMMIlpYAD/YcTzdjR7qmgFuS7EyyvmfNyVW1F6C5P2kItUqSJEmSJGlIhnGNpfQZq2ex5nVV9XCSk4DtSb5fVd864hfvhlHrAU455ZQj3SZJkiRJkqQBDeMTS9PAsp7jpcDDR7qmqg7e7wNuoHtqHcAjB0+Xa+739XvxqtpYVZ2q6ixa1PcC5ZIkSZIkSToKhhEs3Q5MJFmR5BhgLbBtxpptwLvTdSbwaFXtTXJskpcAJDkW+H3g7p4965rH64Abh1CrJEmSJEmShmTgU+Gq6kCSi4GbgQXApqraleSiZv5K4CbgbGAKeBy4oNl+MnBDkoO1/HNVfa2ZuwzYmuRC4AHgvEFrlSRJkiRJ0vCkaublkJ6/Op1OTU5OznUZkiRJkiRJIyPJzqrq9JsbxqlwkiRJkiRJGkMGS5IkSZIkSWrFYEmSJEmSJEmtGCxJkiRJkiSpFYMlSZIkSZIktWKwJEmSJEmSpFYMliRJkiRJktSKwZIkSZIkSZJaMViSJEmSJElSKwZLkiRJkiRJasVgSZIkSZIkSa0YLEmSJEmSJKkVgyVJkiRJkiS1YrAkSZIkSZKkVgyWJEmSJEmS1IrBkiRJkiRJkloZSrCUZFWS3UmmkmzoM58kn23m70pyejO+LMk3ktybZFeSD/Ts+WiSh5Lc2dzOHkatkiRJkiRJGo6Fgz5BkgXA5cBZwDRwe5JtVXVPz7LVwERz+13giub+APChqrojyUuAnUm29+z9dFV9YtAaJUmSJEmSNHzD+MTSGcBUVe2pqieBLcCaGWvWAJ+vrluB45Isrqq9VXUHQFU9BtwLLBlCTZIkSZIkSTrKhhEsLQEe7Dme5pnh0GHXJFkOvAa4rWf44ubUuU1Jjh9CrZIkSZIkSRqSYQRL6TNWz2ZNkhcDXwI+WFU/bYavAF4BnAbsBT7Z98WT9Ukmk0zu37//2dYuSZIkSZKkloYRLE0Dy3qOlwIPH+maJC+gGypdW1XXH1xQVY9U1dNV9XPgc3RPuXuGqtpYVZ2q6ixatGjgL0aSJEmSJElHZhjB0u3ARJIVSY4B1gLbZqzZBry7+e1wZwKPVtXeJAGuBu6tqk/1bkiyuOfwHcDdQ6hVkiRJkiRJQzLwb4WrqgNJLgZuBhYAm6pqV5KLmvkrgZuAs4Ep4HHggmb764B3Ad9Lcmcz9pGqugn4WJLT6J4ydz/w3kFrlSRJkiRJ0vCkaublkJ6/Op1OTU5OznUZkiRJkiRJIyPJzqrq9JsbxqlwkiRJkiRJGkMGS5IkSZIkSWrFYEmSJEmSJEmtGCxJkiRJkiSpFYMlSZIkSZIktWKwJEmSJEmSpFYMliRJkiRJktSKwZIkSZIkSZJaMViSJEmSJElSKwZLkiRJkiRJasVgSZIkSZIkSa0YLEmSJEmSJKkVgyVJkiRJkiS1YrAkSZIkSZKkVgyWJEmSJEmS1IrBkiRJkiRJkloZSrCUZFWS3UmmkmzoM58kn23m70py+uH2JjkhyfYk9zX3xw+jVkmSJEmSJA3HwMFSkgXA5cBqYCVwfpKVM5atBiaa23rgiiPYuwHYUVUTwI7mWJIkSZIkSfPEwiE8xxnAVFXtAUiyBVgD3NOzZg3w+aoq4NYkxyVZDCw/xN41wBub/ZuBfwU+fKhC9uz/GX/0D/82hC9JkiRJkiRJhzOMU+GWAA/2HE83Y0ey5lB7T66qvQDN/Un9XjzJ+iSTSSafeuqp1l+EJEmSJEmSnp1hfGIpfcbqCNccyd5DqqqNwEaATqdTX3zva5/NdkmSJEmSJB3C1otmnxvGJ5amgWU9x0uBh49wzaH2PtKcLkdzv28ItUqSJEmSJGlIhhEs3Q5MJFmR5BhgLbBtxpptwLub3w53JvBoc3rbofZuA9Y1j9cBNw6hVkmSJEmSJA3JwKfCVdWBJBcDNwMLgE1VtSvJRc38lcBNwNnAFPA4cMGh9jZPfRmwNcmFwAPAeYPWKkmSJEmSpOFJ9xe1jYZOp1OTk5NzXYYkSZIkSdLISLKzqjr95oZxKpwkSZIkSZLGkMGSJEmSJEmSWjFYkiRJkiRJUisGS5IkSZIkSWrFYEmSJEmSJEmtGCxJkiRJkiSpFYMlSZIkSZIktWKwJEmSJEmSpFYMliRJkiRJktSKwZIkSZIkSZJaMViSJEmSJElSKwZLkiRJkiRJasVgSZIkSZIkSa0YLEmSJEmSJKkVgyVJkiRJkiS1MlCwlOSEJNuT3NfcHz/LulVJdieZSrKhZ/zjSb6f5K4kNyQ5rhlfnuR/ktzZ3K4cpE5JkiRJkiQN36CfWNoA7KiqCWBHc/wLkiwALgdWAyuB85OsbKa3A6+qqlcDPwAu6dn6w6o6rbldNGCdkiRJkiRJGrJBg6U1wObm8Wbg3D5rzgCmqmpPVT0JbGn2UVW3VNWBZt2twNIB65EkSZIkSdJzZNBg6eSq2gvQ3J/UZ80S4MGe4+lmbKb3AF/tOV6R5DtJvpnk9QPWKUmSJEmSpCFbeLgFSb4OvLTP1KVH+BrpM1YzXuNS4ABwbTO0Fzilqv4zyW8DX05yalX9tE9964H1AKeccsoRliRJkiRJkqRBHTZYqqq3zjaX5JEki6tqb5LFwL4+y6aBZT3HS4GHe55jHfB24C1VVc1rPgE80TzemeSHwCuByT71bQQ2AnQ6nZo5L0mSJEmSpKNj0FPhtgHrmsfrgBv7rLkdmEiyIskxwNpmH0lWAR8Gzqmqxw9uSLKoueg3SV4OTAB7BqxVkiRJkiRJQzRosHQZcFaS+4CzmmOSvCzJTQDNxbkvBm4G7gW2VtWuZv/fAS8Btie5M8mVzfgbgLuSfBe4Drioqn4yYK2SJEmSJEkaojRnn42ETqdTk5PPOFtOkiRJkiRJLSXZWVWdfnODfmJJkiRJkiRJY8pgSZIkSZIkSa0YLEmSJEmSJKkVgyVJkiRJkiS1YrAkSZIkSZKkVgyWJEmSJEmS1IrBkiRJkiRJkloxWJIkSZIkSVIrBkuSJEmSJElqxWBJkiRJkiRJrRgsSZIkSZIkqRWDJUmSJEmSJLVisCRJkiRJkqRWDJYkSZIkSZLUisGSJEmSJEmSWjFYkiRJkiRJUisDBUtJTkiyPcl9zf3xs6xblWR3kqkkG3rGP5rkoSR3Nreze+YuadbvTvK2QeqUJEmSJEnS8A36iaUNwI6qmgB2NMe/IMkC4HJgNbASOD/Jyp4ln66q05rbTc2elcBa4FRgFfD3zfNIkiRJkiRpnhg0WFoDbG4ebwbO7bPmDGCqqvZU1ZPAlmbf4Z53S1U9UVU/Aqaa55EkSZIkSdI8MWiwdHJV7QVo7k/qs2YJ8GDP8XQzdtDFSe5KsqnnVLrD7ZEkSZIkSdIcO2ywlOTrSe7uczvcp47+7yn6jFVzfwXwCuA0YC/wySPYM7O+9Ukmk0zu37//CEuSJEmSJEnSoBYebkFVvXW2uSSPJFlcVXuTLAb29Vk2DSzrOV4KPNw89yM9z/U54CuH29Onvo3ARoBOp9M3fJIkSZIkSdLwDXoq3DZgXfN4HXBjnzW3AxNJViQ5hu5FubcBNGHUQe8A7u553rVJXphkBTABfHvAWiVJkiRJkjREh/3E0mFcBmxNciHwAHAeQJKXAVdV1dlVdSDJxcDNwAJgU1XtavZ/LMlpdE9zux94L0BV7UqyFbgHOAC8r6qeHrBWSZIkSZIkDVGqRufssU6nU5OTk3NdhiRJkiRJ0shIsrOqOn3nRilYSvIYsHuu69CcORH48VwXoTlh78eb/R9f9n682f/xZv/Hl70fb/Z/7vxaVS3qNzHoqXDzze7ZEjSNviST9n882fvxZv/Hl70fb/Z/vNn/8WXvx5v9n58GvXi3JEmSJEmSxpTBkiRJkiRJkloZtWBp41wXoDll/8eXvR9v9n982fvxZv/Hm/0fX/Z+vNn/eWikLt4tSZIkSZKk586ofWJJkiRJkiRJz5GRCZaSrEqyO8lUkg1zXY+OniTLknwjyb1JdiX5QDN+QpLtSe5r7o+f61p1dCRZkOQ7Sb7SHNv7MZHkuCTXJfl+8z3gtfZ/fCT58+b7/t1JvpDkl+3/6EqyKcm+JHf3jM3a7ySXNO8Ddyd529xUrWGYpfcfb77335XkhiTH9czZ+xHSr/89c3+RpJKc2DNm/0fEbL1P8v6mv7uSfKxn3N7PEyMRLCVZAFwOrAZWAucnWTm3VekoOgB8qKp+EzgTeF/T7w3AjqqaAHY0xxpNHwDu7Tm29+PjM8DXquo3gN+i++fA/o+BJEuAPwM6VfUqYAGwFvs/yq4BVs0Y69vv5n3AWuDUZs/fN+8P9fx0Dc/s/XbgVVX1auAHwCVg70fUNTyz/yRZBpwFPNAzZv9HyzXM6H2SNwFrgFdX1anAJ5pxez+PjESwBJwBTFXVnqp6EthC9w+fRlBV7a2qO5rHj9H9j+USuj3f3CzbDJw7NxXqaEqyFPgD4KqeYXs/BpL8KvAG4GqAqnqyqv4b+z9OFgK/kmQh8CLgYez/yKqqbwE/mTE8W7/XAFuq6omq+hEwRff9oZ6H+vW+qm6pqgPN4a3A0uaxvR8xs/zdB/g08FdA70WC7f8ImaX3fwpcVlVPNGv2NeP2fh4ZlWBpCfBgz/F0M6YRl2Q58BrgNuDkqtoL3fAJOGnuKtNR9Ld031T8vGfM3o+HlwP7gX9sToW8Ksmx2P+xUFUP0f0p5QPAXuDRqroF+z9uZuu37wXHy3uArzaP7f0YSHIO8FBVfXfGlP0ffa8EXp/ktiTfTPI7zbi9n0dGJVhKnzF/3d2IS/Ji4EvAB6vqp3Ndj46+JG8H9lXVzrmuRXNiIXA6cEVVvQb4GZ72NDaaa+msAVYALwOOTfLOua1K84jvBcdEkkvpXhbh2oNDfZbZ+xGS5EXApcBf95vuM2b/R8tC4Hi6l0D5S2BrkmDv55VRCZamgWU9x0vpfjxeIyrJC+iGStdW1fXN8CNJFjfzi4F9s+3X89brgHOS3E/3lNc3J/kn7P24mAamq+q25vg6ukGT/R8PbwV+VFX7q+op4Hrg97D/42a2fvtecAwkWQe8Hfjjqjr4H0h7P/peQfeHCt9t3gMuBe5I8lLs/ziYBq6vrm/TPWvhROz9vDIqwdLtwESSFUmOoXsRr21zXJOOkiahvhq4t6o+1TO1DVjXPF4H3Phc16ajq6ouqaqlVbWc7t/zf6mqd2Lvx0JV/QfwYJJfb4beAtyD/R8XDwBnJnlR8+/AW+heY8/+j5fZ+r0NWJvkhUlWABPAt+egPh0lSVYBHwbOqarHe6bs/Yirqu9V1UlVtbx5DzgNnN68L7D/o+/LwJsBkrwSOAb4MfZ+Xlk41wUMQ1UdSHIxcDPd3xKzqap2zXFZOnpeB7wL+F6SO5uxjwCX0f1o5IV0/wNy3hzVp+eevR8f7weubX6IsAe4gO4PSez/iKuq25JcB9xB9zSY7wAbgRdj/0dSki8AbwROTDIN/A2zfL+vql1JttINmw8A76uqp+ekcA1slt5fArwQ2N7Nlrm1qi6y96OnX/+r6up+a+3/aJnl7/4mYFOSu4EngXXNJxbt/TyS//8UqSRJkiRJknTkRuVUOEmSJEmSJD3HDJYkSZIkSZLUisGSJEmSJEmSWjFYkiRJkiRJUisGS5IkSZIkSWrFYEmSJEmSJEmtGCxJkiRJkiSpFYMlSZIkSZIktfK/NfOgUMz+pAMAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2140,13 +2228,21 @@ "name": "stdout", "output_type": "stream", "text": [ - "tal hits: []\n", - "gata hits: []\n" + "tal hits:\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.9995233787592409, precision_at_motif_score=1.0, example_idx=7, start=91, end=116, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.6694922206103467, precision_at_motif_score=0.3611280077363049, example_idx=7, start=100, end=125, is_revcomp=True)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.9998068744229901, precision_at_motif_score=1.0, example_idx=7, start=122, end=147, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.8389726480891654, precision_at_motif_score=0.7246978685792207, example_idx=7, start=131, end=156, is_revcomp=True)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.9988489961840756, precision_at_motif_score=1.0, example_idx=7, start=158, end=183, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.8114523781844735, precision_at_motif_score=0.6617643108541413, example_idx=7, start=167, end=192, is_revcomp=True)\n", + "gata hits:\n", + "MotifHitAndCoord(motif_idx=1, motif_score=0.8404588409236708, precision_at_motif_score=0.7594466445239779, example_idx=7, start=19, end=44, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=1, motif_score=0.9998292111100581, precision_at_motif_score=1.0, example_idx=7, start=63, end=88, is_revcomp=False)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2165,19 +2261,7 @@ }, { "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2189,7 +2273,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2203,13 +2287,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "tal hits: []\n", - "gata hits: [MotifHitAndCoord(motif_idx=1, motif_score=0.9981759716448624, precision_at_motif_score=1.0, example_idx=8, start=50, end=75, is_revcomp=False), MotifHitAndCoord(motif_idx=1, motif_score=0.999767182191173, precision_at_motif_score=1.0, example_idx=8, start=96, end=121, is_revcomp=False), MotifHitAndCoord(motif_idx=1, motif_score=0.9994275624967489, precision_at_motif_score=1.0, example_idx=8, start=158, end=183, is_revcomp=False)]\n" + "tal hits:\n", + "\n", + "gata hits:\n", + "\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABI0AAACMCAYAAADx21mCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3gVxfrA8e+elt4oSQih995BBCmiCCiCCIIgCnbF7k+9XgtBr4oXQeEqIogVUIqCNBVFQJSO9B4IhFDSe3JyTs6Z3x+TdkhoEgiX+36eJ09yNnN2Z9vs7LuzM4ZSCiGEEEIIIYQQQgghSjJVdAaEEEIIIYQQQgghxNVHgkZCCCGEEEIIIYQQohQJGgkhhBBCCCGEEEKIUiRoJIQQQgghhBBCCCFKkaCREEIIIYQQQgghhChFgkZCCCGEEEIIIYQQohRLRWfgXKpUqaJq165d0dkQQgghhBBCCCGEuGZs3bo1SSlV9XzpruqgUe3atdmyZUtFZ0MIIYQQQgghhBDimmEYxrELSSevpwkhhBBCCCGEEEKIUiRoJIQQQgghhBBCCCFKkaCREEIIIYQQQgghhChFgkZCCCGEEEIIIYQQohQJGgkhhBBCCCGEEEKIUiRoJIQQQgghhBBCCCFKkaCREEIIIYQQQgghhCilXIJGhmH0MQzjgGEY0YZh/KOM/48wDGNnwc86wzBalcdyhRBCCCHElWMeZ2Zvwt6KzoYQQgghrpBLDhoZhmEGPgL6Ak2Buw3DaHpGshigu1KqJfAmMP1SlyuEEEIIIa4cpRRu3BxIPlDRWRFCCCHEFVIeLY06AtFKqSNKKQfwLTCgZAKl1DqlVGrBxw1AZDksVwghhBBCXCHZzmyP30IIIYS49pVH0Kg6cLzE57iCaWfzAPBjOSxXCCGEEEJcIam5+vlfuj29gnMihBBCiCvFUg7zMMqYpspMaBg90UGjrmedmWE8DDwMULNmzXLInhBCCCGEuFRp9jQA0vMkaCSEEEL8ryiPlkZxQI0SnyOBk2cmMgyjJfApMEAplXy2mSmlpiul2iul2letWrUcsieEEEIIIS5Vql1aGgkhhBD/a8ojaLQZaGAYRh3DMGzAMGBxyQSGYdQEvgdGKqUOlsMyhRBCCCHEFVTY0igtL62CcyKEEEKIK+WSX09TSuUbhvEE8DNgBj5TSu0xDOPRgv9PA14HKgNTDcMAyFdKtb/UZQshhBBCiCujsE+jlJyUCs6JEEIIIa6U8ujTCKXUcmD5GdOmlfj7QeDB8liWEEIIIYS48gpfT0vOPWsvA0IIIYS4xpTH62lCCCGEEOIaV9jSKDEnsYJzIoQQQogrRYJGQgghhBDivOKz4wFIyE6o4JwIIYQQ4kqRoJEQQgghhDiv4+nHAQkaCSGEEP9LJGgkhBBCCCHO63jG8YrOghBCCCGuMAkaCSGEEEKI8zqVdaqisyCEEEKIK0yCRkIIIYQQ4ryScpKK/lZKVWBOhBBCCHGlSNBICCGEEEJcEJvZBkCmI7OCcyKEEEKIK0GCRkIIIYQQ4oL4W/0BSLOnVXBOhBBCCHElSNBICCGEEEKck9PlBCDQKxCA1NzUisyOEEIIIa4QCRoJIYQQQohzKmxZ5O8lLY2EEEKUv1UxqzDGGdJn3lVIgkZCCCGEEOKcUu26ZVGALcDjsxBCCFEejqUfAyAjL6OCcyLOJEEjIYQQQghxToUti4K9gwF5PU0IIUT5OpV5CoC4jLgKzok4kwSNhBBCCCHEORUGiQqDRvJ6mhBCiPJ0MvMkAMczjldwTsSZJGgkhBBCCCHO6cyWRim5KRWZHSGEENeY2PRYQFoaXY0kaCSEEEIIIc4pJi0GgN0JuwHYm7i3IrMjhBDiGnM45TBQHDwSVw8JGgkhhBBCiHNafXQ1AGtj1wKwPm59BeZGCCHEtWZ/8n6g+OGEuHpI0EgIIYQQQpxTYk6ix+dsR3YF5UQIIcS1yKVcAGw/vb2CcyLOJEEjIYQQQghxTik5nn0Y5bnyKignQgghrjVOl7Po78LXocXVQ4JGQgghhBDinDIdmR6f8935FZQTIYQQ15rTWacBCPIKquCciLJI0EgIIYQQQpxTbn6ux+fC1wiEEEKIS3U84zgAYf5hAGTkZVRkdsQZJGgkhBBCCCHOqeSrA0IIIUR5isuIAyDML8zjs7g6SNBICCGEEEKck2EYAPhb/Yum2Z32isqOEEKIa0hhkKh6QHWPz+LqIEEjIYQQ4hIopVBKVXQ2hLiszIYZgIyXM4gMjAQgPS+9IrMkhBDiGrEudh0Ah1MPA7D9lIygdjWRoJEQQghxCUxvmOg7u29FZ0OIy0YpRW5+LhaTBcMwilobpdpTKzhnQgghrgWrj60GYPPJzQAsi15WgbkRZ5KgkRBCiGtbeDgYhudPePilpwWOph0FYGf8zsuQcSGuDlmOLAD8rH76t03/TrOnXd4FZ8fC3ndhz9uQcejyLksIIUSFOXOEzmNpxyooJ6IsEjQSQlyQXGcuDpejorMhrqSyAijnCaJcleLjL2zaxaYF1hxdA8CprFN/J2dC/FcobFHkY/UBINArUE/PvYwtjQ58CEsbw96JsH8y/NgSnFmXb3lCCCEqzJn3GMk5yRWUE1EWCRoJIS6I79u+REyMqOhs/H0X2YJEcHGBlatZWNiFTbvYtMAPB34o+vtExomLzdlVbd066NoVLBbw94fHHoOkpLLTpqXBhAnQpQvcfDPMmwf5+Vc2v+LyKWxRVNjSKMgrCIAene++PIHlxPWw4x/Q7gO4IxYGxsJ1X0CJTriFEOdxrTz4Ede8kqNzFj6UsLtkoIWriQSNhBDntTdxLwDJucn/vR3+XmQLEsHZgyUm039XJfT0aSh53Cqlp11qWmDh/oVFf685tuZSc3rV+PVX6NcPevaE/fv156NHPTdNodhYaNQIfvkFRo+G3r3hzTchXfpIviwqoggubFFU+FpasHdwQV7cl2eBe8dD/Ueg1ggwe4PZC6r3vzzLEkIIUaHis3V9PMwvjGXDC/oy+i+93bhWSdBIiHKkFDgcFVOpv5zm7JpT9PfWU1srMCeX4CJbkAjKDqAoBe4ybhT/BwNwhf0ZNa3SFIAFexdUYG7Kj1I6+PPhh/Dyy1C/Plx3HSxYAFWrAhkH4cB/YNebEDObkSOc3H03LFwI998PTz8N69dD5coVvSZcMy0M9++HgQOhWjWoXRsaNICscnpTSynFz9E/ezzpPVPh62mBNv0EOMQnBIAPFv2juFwonuE5A61nlR0LSRshKwZOrYCGY6CgZRMAFt+Ln+flcLGtN5SCtF1wbB6cWA4OiaaKK6TwGl4e56cQl1FcRhwAkYGRdK3ZlUCvQPJVPpl5mef5prhSJGh0NZFmpP+1du6EPn2gRw8YPFi/opF2mfsHvVKUUkxYN6Ho89c7vy6fGZfH8a4UnPpFd5K67SXYNxEyDpSd9iJbkPzPuZibawnAATD+j/FA8fCwi/YvqsjsXDhXHuSeBkcqlNFSZNcu3Zhs8GDwLXGf7ufjhD9HwKaHwCcCQm/gZFw+23ZY+Ne/wM9Pf89m06+zXVFnK08SE69wRsrfnj3QrRvcdx8cOwZ798LmzeW3jX848AN9Zvdh6uapZ01T+Hpa4WsDhS2NErITLj0Dp3+FJY1gVxScXAY7x4LKB98alz7vipayFZY0gENTdbAofR/82h2cGRWdM1GerpHgtBAV5Xj6cQDC/fV5U3iNKQwmiYpnKY+ZGIbRB5gMmIFPlVLjz/i/UfD/fkAOMEop9Vd5LPuqEh5e+ml7WJjcmF7jdu+GO+6ARYv0E2CXq7gPkGvB4gOLcbgcmAwTbuVmysYpvN/7fUymCo4525Pgt15QYxDUGaX7usiJA+/Qis3XxSqr3ICru+wozJdh6N/XWtO6C7Ti8Iqivw0MFIq9CXtpGtq0AnN1DinbYPs/wLc6BDaG/GxIWAPdl4A1oChZUhJERupWk97eJb5/4D/gzoMey8HsA4aJuCMO6tQxrvy6XKiqVfXx+l98rL74Irzxhn4wYbPpn/Licru4Y+4dADzz8zM82v5RvCxepdIVvp4W5K37Mgqw6eOl8JWCvy1tF2x6FHqtAluwfhUtPxuOfaODmoXl+ffhYI8HTDDcdWnLvFQXWv45M2BVP+j5IwQ01Nco5YKGj109rabEZZWZCWvXQkoKWK1QsyZ06qSD63/bf2OdQYjzKAwOVQ+oDkAVnyrEpscSlxFHk6pNKjJrosAlB40MwzADHwE3A3HAZsMwFiul9pZI1hdoUPDTCfi44LcoqWRh/19cwf1f88478MAD0KSJDhZdaz7Y8AEAVpMVp9uJW7n5bv93DGk65NJmfGbFGy7ueP/rGah1NzR6qrgC7nU1vA9TztxO3TLEZAOT1XN7lScJBF209Dz9mslbN77F3D1z2XxyMzsTdl500OjJ5U/y4eYP2T9mP42qNLocWdUB1TW3wS2bwBqog0TufHC/CBY/j6T16+vWLGaz5yzUsbkYTV/wSF+jto2YmLMfLqdPw/Hj4HTqAFS9ehAUVD6rpJTubNtiAeMavn7u2wf//Cf4+JT/vF/97VUAQn1DSchJ4PFljzNzwMxS6VJyU4Dip7/+Nn8MjEsf3Sb6U4gcqIND5oJglS0YKneAo99Ag4d1gLLIZepD6XKIXw1BTSGgQXEH3oZZAkbXojOun8qtePFFOPUYvPQSXH+9Lqs2bYLU1Kvk1V0h/oaEBHjvPf16dO3aup5w6pQ+rh97DNq3/3vzPZJ6BIDqgTpoFOavW6//t7U0crl0oHj7dn3OG4beRh06QOfOlxgwrmDlcYvbEYhWSh0BMAzjW2AAUDJoNAD4SukedDcYhhFsGEY1pdS1NUax3HT9TwoP129A5OWdETRK3QHJm/WNmcmqpyknGFao2gWCGldIfi+GUoq9SfpU/rDfh2yI28DMbTNZHbOaITc+eeVa1kVFwbhxntNeAB6aBkbBRr+ankRfjLJudrNP6BYh+6dAlU76Jt9lh9TtUOMOfVN1IaT142UTlxFHSm4KflY/nuv8HFazlc0nN/NT9E8Mu+mZC97uwxYMY+6euQA0/qgxS+9eyq0Nby3/DKftBr+aYAspvmldFFnmOVOzpg6Cv/QSvPuuDvY4HGD4d8Q7aRNE9NWBo51RVNs9jraRv/PPf97A+PE6sJGfD0uXwowZ8Oqr0Ly5fsqekwPe9p2QtEW3uDAKolLKrYOioTeAf51zrsbBg/DWW9CxI7Rpo1t0ZmVBq1b69bhr0a23wvz50Lp18To6nXqbXgqHy8G/1/0bgIQc/ZrZZ9s/Y3LfyfjbPJvKFr6GFuKt+zIK8ArAMAyScy8xaBTQABL/0NdGvGBnFOweByYvyDwCYT31MdH/IMwvn2hjrjOXexfey4ojK5g/ZD696/Uul/kCZORlsOXkFrrW7IotoL7un4kSgf7C9TP7wdBy6pRKeMjNhY8/1uVNRIQOUjsccPKkvrG95x5ofJmrX5s36z7eoqM9p/fpA26Vzz9Xvs47f7zD4+0f5/1b3sdmuYjmg9dwgFxc/bp0gZkzoV07/fq6YUB2dvHff1d0SjQGBmF+OlhUGDw6nnG8PLJ9RTidelCQmTN1AM1u16emr6/uCrQ8AkaJ2YnEpMXQIaIDxuV6iHwW5RE0qg6U3KNxlG5FVFaa6sBFB41W/+cNmndrg82vuCn9wvWr+fzkHDJ8TXibbdhdDhoF1WLosSa069mJwNBqRWmP7DlJs/sewpaZ4zHfIY/VYEFYcRZNmHgt9CHuX7yNmj9t8kjriGpHercBxBt9SEqxYrW68eEkztgfadJ7EIEF6TKiV/PlwtnUbxBOl+a9ADiceYKUjGjapmzF1uxBTqWEcfyEF43q5xCzcQ2RdfwIqdOyaB5HN//B+IkBDBxaiap+pzCrLFxGACu3/UKtSDt9O94IBpzMSWRT3H7iNq3hnsFPEeyt57AxcTcr1q9ljv0XEvIzsBhmTIaJPtW6EvLzRPrfGUFo5Rx8XNHkmWuQtH89LescIaxd/4KTXwEGD0y7n4D6dWlWpSEZzmzishMIix+E41Bjut3aiEqmXZhULpmWtixf/RCDet9M42r1ANictJf9O2Owuk5x142jMZnNZDpz2JS0B9uaGNrd3APfysWvFG3f48/SpRZuGlibytYDmFU2OZbG/Dx3F407NSM8svgpXXTMWjKy5jO6/ygsZgtOdz5r47fTKXs7Nt9mxNOLhCQbXl5ufFzHCJ0+nohlnvszpl0L6mzd5THtOJFM6fQRPV/uTlXfWKzuRHLN9fDPXoXZYqJa/brs2OOPxaL4v7tP0u2OtoRWDWXME2b8/SE5MY+qK1vD8DMu5I402P0vCKjHob3pHD/pRa1IO3/u+I7gECc92gwADE7nJrPpxF6ObVzD0AGPEupfBaUU6xN3kbcjk/qVTUS2ua6owHC73Gz69iva3XkXVu/i7bNs9RryiGXgDSMwmU0k2lP5K2k/E9Z8xGaKhwf3Ntn4ps1guigrOeH3cSI+CIfDRLL3ThKyEwiy+jEkoB4Nw93MZCZ712zAmZvFmfcs7h5pHP5pBgnOduTazVjMihqBu6ljW46p/kj2Ha5MQpKVti2z2Lp4MU06t6RkTzhZu74i78gSsqo9zImEytjzTAQH5pMR7KTR2plUu+GBorT7b/qWmltexNs7AlP1PkXTp+1vTqMV/6Zd3Y56/2ae5GBMHFUPx9D69sEUhlsyolez+cd11KofSGiD5kXfT06x8u4kf/oPq0UV/3i8XCewm+vgn7cZlyMTa5UWJCbpNTfbTvLGX08R45eH2bDgcDup6RfOe/VaU9PpTaVWgzhyzJ/8fIP6tTJY983XtBk4HKPE6x871+4l2CeNGu06U3hLlLtjMj6OZGj8lL65Xlgd7PEsimlMdvhP3NbtUQzDICUvnW0pB/llxs107xlMverJWFQ6bsOHY9EZ3Jqbw5lV0aFDvPh9fCVchn41pYp3ME95D6Wj1UTDbr2L8pARvZr183+gefcOVC8xLWbvKXJPbKFJr1s90k6aN5lOrdrQpVE3lFL8lXKAHfuiIfkw9/R7DJvVhtOdzx/xO+hg34WXrS6WiJ5s2xWAj48Lm/dO1m7/nmF9H8fb4kO+28UfCdvZt24HjetH0LOl3scH02OJjj1B2MEY2gwciqlEc5ivl8wjvLoPN7fVoywdzjzBgROxVN5+iA5DRnjs+7k/LaFKZUWv9v3BMIjPTWH7qUMErttDp2H3eqTdsXoXlYKyiWzdqeicWx6tX01r6F+dzMNrqJ/vxgAy1x3Gac8udW68mPYS7b+KJ7RGFYIc68mytuS9LY+wOHeuR7rbvrmNew+to0/PSOrXTMPqTsJl+GF2Z2CkbqfR9e1JTPbiZLyNdq3SmPz1f7i5Sx9qh+u7oP3pR9m8bS/m3OMM6/0gJrMZh8vJH/HbaROTReSBjzE3eqygLyPF2pM12WNuwNCDKzGbzEVl6ORHj9Pv6bfZtcubAQPMJCTAkgVj+f3VzgQrA3OTp6HJ87B7HF8/NpwObxxk/z4bg4eYSUuDKRMzeegxP7p0MWEvGDXX3ysDryWtSpWLifH5fDU1mt43JmOzFN8QeaWtIjMvCEdAJzIyLBgGzFsUhLdPHcaM0U/0Cm1euJCqgYlUrduw6PqZuOsX/vp+Fh3vGkFIif0Z/+d0GrSqDa3f9sjH6vH30fLWQVh8ioMTy9aswaniGNBtOIbJIDUvk83JezmwahUDbh5KzVAd5Por+QB7th3ChyTuvPE+DJNBljOXDYm72L16Nbf0uI0mEboF2tbk/RzYG8rRDbW47TYTfrYMDPJxG3689+frxFY+TaCvP27lBgyG3dCRt597keyscJ573kxAAGzbpujf4APwiSTVXo0de/zx93PhVFvYeHAZQ29+GD+rP5nOHNbGb+Po+t1c37IlrRt1BnS5OGXTPNzKTZuQhszo+govbJ7CqtNbmfH2GAZc35kqdYvvrGNidwJgy0wkI3o1pqQYDKDToUocWjaFsEbF9ZZda+eyfPXnjBz0JP5efkXXrvXrN0GQnZta9Mbb4sWO5IMkZuQw9PQeallfxNzyNWj+Cuwex+LNN9O4RTD1fuqCObQjmKxkOE18crglQ3YupJKv3qObk/biEx9P3skAvOr0xWy2ogCn287qdS8zrP8IwoIjANiWfIBv1v/IJ+k/FK3XLbNuwWyYWMgoOt16G95BIUX/M2fuIff4BuzVR3P8dDB5eSaqheVxct0smt94A1VLHFOz/vyRJ49OwF1iuJ8QawDfmAbSy6sv5uv+gxHYCBo/zZ6f5vPD/me4PlThn78dizuVbEtzvvg2lLp1oWunDAKcf5FvBLA/vi0LFxmMHg2VvWPxdh0jy9qG4LTZ2PwCUH71iU+0YrEobDY3S5ZauPH2uvhyEpv7JDmWxgRkrcBkNmEJacTpBBtmM/j55jP/Oxu3DvTDh3hM2HEbvkT/tZ/GjRW1m9ctWo+0DAtvjffn9rtrERKYi2/+QXIsjVm7dRa1qmXQ7zpdD03ITWFPyn5uSFmFrfFjZOWHs/+QLw3q5lDdugayj6FqDGHb7iCc+QZNGifwyTeTGNzvQSoXtCrYmryfXVv2U8k7h/433I1hMkhzZLE1eR8/TruZXr3Diajhh79zO7mWumzeswrDso57brwTi8VMoj2VTxY7WbvkLtav1/kvjKfs+X0j7tNribC0J6NEMGf8pMo0aBZEw8a++OXvIt8UAkphSfoZr5o9SEr2wplvEODn4o+dE7iuXTua1eoAwL60GE4cSiY8+QTNevcvuiZGWNdCXhNW/RbCdZ3N5OXp6T9vnc+wP+4qWvbULVOZumUqX1ufpEuHZlSuU9zS9FDMCX7ZOpvhtz1KsHcgDpeTtQnbsWzJpEnjUEIbNC865zL3/UD+vk+wNHmEI6ciSEqxEhHmIPXg70REmKjUoG1R2pNbf2bX0m/oNGykx/XTkvoHWYmnCGh6J9t2B+N2G3RomYzXkQlQ70FikyKJPupDzep5bN63GJtXKjd3GAKGQUpeBpuS9nBo9W8M7jeaaiERRftz95aDBHllMKDbCAyTQbojiy3J+/BedZB2t/XDO7D4nNu/NQZL7mHqXX8jRok77PVzF9Dq5u74VqpaNG3V5q2cTtnK0JsewGQ2Y3c5+DNhB39+25MmjavSoHkoAY6tOMzhnDyeS2DmEtr1ud7jxn3G/E9o16YVbetfV7Q/9x22sn15c24ZXJ8QnyS8XMfJsrYm7s/ZtL8ukLA6EUXf3xt9lLU7FjD8tkcJ8PInz+Xgj4QddHQewpkTQYK5P1k5ZgzArRSrV+Zx++0uvGwuTLhxKzPe2RtwUAmCW5CUbMNkUkRUTqKuYyJxfs9yLD6UPIcJby83ew74YiaPZm0C8HbpOnyGI5SE9dPpde9tHg+u1/6WSV5OFs0718dUEFtwuU2MfacaQ4b5UKtyDBaVhssI4PfdG/ENiGZo9wGYTLo+tCPlIL980o9+fUzUCEvHhB2FldCA+hzYH0aHDibS0/WMzWYYO1a/ehnkk4K/cyd55gjiDqcQyh+07Nkeo8R2f2diZZq3tNK4XjpmlYXCyp5j+gG1b3o8GdGrqerM159/3k6ceRaB4ZHFx8khX76dZ6P3nQ0I8MnCN/8Q6bbOVE6eik+lUEJrRvDXzgD8/VwEBzmZ/Y0Xt/Sz4kUqBg7chi9LN8yndYuq9Gihr4kH02PZE+tg04L23DqkDlX9jmJ1J2E31+HoprW0bGkQ2bhmUR6Skq1MeN+P24bVoaqfLm/TXfU4eSKSJk3MOBxG0bGWmpDB/gVv0uY2zweClpS1nI5NI8F3KLl2XVv3Mtuxnvwao+59uMzBoAxA8dVf7zDV/oXH9xsH1uL9jO50GDQUq0/xvd/u9QfwM8VTu8MNGKbiwFLG6ThiovO4YdQD/B3GpQ6fbRjGEOAWpdSDBZ9HAh2VUk+WSLMMeEcp9UfB55XAi0qpUsMwGYbxMPAwQM2aNdsdO3bMM8GdBnzvOWnoU5HMq1S6+ZpqgGfldGcUq+etpsfHGyHF7rncqNLr9mjqDXw8MAB6LNNP7POzYEo28yYP4YO0qTz8QiAtWppwOGDd3AU8f9sHcMuGorSOydkEH4RcE/z1MQTnQf2noLsvLNhYl7sXTmUtN2DDQR5eJHwaSsDgjbo5c8E8djxXFyPORMshDaD+A+BdFXfOCYJmDiDLDEc+gDpp0PBJSAjwJ92axf3bYOZi2FgdrnsQ2mSZ2RZwRssLhy/jp4zhpScmQFMv8K0POcfYvb0yzR96Gho/W7TNXLvGYYkuvX0Cv/6WdV2W0qzjLAjwB5M3J3KSiCwIBfo4Id8ETjPUdQVwxJzJvHkwZC8MGwxzm5fYR4UdBq54lFdfNzMyciWNuh2BmnfqJ9oZOzF6LS71MKXN2/XZ7jjMN9/BsN3w/nXw3C2wcmUPXtj3OYPGVKNNWxP2XMWeH7/mtXvnQK+VHvsTgLuyILKebh1Q2Y/F992IsSmI/nfPgbo3gi0Usg+Q/EkMI5d9TWanm+jWxUV+PpzYtYGZle/i2wX9WMhA4gmnDjH0bb2Qkbcehuu6Q2AVSF8Jmas48FUzhvw8B1W/AXVruTgUYyJuuD+ZFkX0ZKiXCs0fh+PB/mTYsmiUCEu+gYWN4aXesN7WjOtGjIWaQ4rWw/VBDuaFqtS54TvWRK7h5omN0OsIPDAAUkq0jDcKtqcyYJY7nNlf/kBE99YMHAhe3gYrNh3hj+zG3PkH/N96cBkwdAjcFtaNUaPaQ9uJRXmIfb0Sd0xYxQez69CunYGvn4HLpcje+CamaT/ywNfPsIT+WHFixkXK7MrF+75gu59+w59RE36g1aC2DLrTwM/P4FiMm1tzbKXSfjOsP64Vtbin8bvQzAqBfmSGpxF8DFCQ+i74OqHyi9DJ3pYVvXLgtn0e+97u8MJ70E4IbFg0feuzjdj5RSdGP/wx1GsEXpGQe4Q5E1owPXsGj/4jhDZtTSgFC5et4p+5N5c6N07/BWGL4VuGcj+fATDR51ke+3R68XoU5GH1kVb0GPE81BnpMf3bSUMZ1u8AtOsIObNA5exTt2MAACAASURBVND8kB97yC46jzo9CJsiYc3uG+j2gDc0eRL8a4Izk99n/JtuA1pByzc95mscKn0uT0zvznPDm0P7D0ufG2ecn6vnraJH3wjo8s1551s3rypHvBKZ9BM8uwEmXA8v9ob8HSaeXziRL70foWlDJ7m5JvI63s3eBksZswk+XA5vd4VXbio9T4Bu6S1ZczIW5nr2Nl9Yjvs5wOKGdG9ollmP3Z0SYUh6UX6dk7PxOwguIP49qJKjt2VcpTBOtIovtY82xTal4/A3dHlUMH3Nv+y8EOPimeUwfDdkW+GuIfBCvbb0uPcxqP+gxzyiRowlinHwHNACSIeBp8LYa81g+dRc6qfAjLbwRD/4fNlQho9ZCa0egeAmkJcMe/8Fvzbgp+n+3FlwordqHMXGoe/R/gRs/FSvu/erEGD4kGLK5Zev4MYY+E9HeLovjH3jNca2exO6e0NkNcjJpV2enb+MNL5eCPfshCkFadUuSP8+kE94hMX0J5g0GnOAFnXSuC/yLegABAC1gKU67ac8wCLuwI8sXmz5LokBDTlgvxXv1o0x+9hwpOdSa/c4hg88Bu27QEAVSPuFI9Ex1G3XBroVFGDfh6Ny4xnx8hfUGT6Chx8xCA03gYLjew+xZcybHLMOxbtVI6x+NpzZDm6p14emd0+FarcUbffUty2E+KeX2p/rVzah85MDi4NGha0/Sh7vBWmrH/LiJHn8OROuPw7974alBfd1jZJg/4ewKxRaPg5V3V4kGTpt5zi9Lz/qQFFDkxbxkGmFo5Xg/xJuZfzgAMxtXtctaQwTLIrE2F264+6Xg2HstrbM/bIZcxlKKiF0YBPvDXyBpxZN5ivTaFo2zScp2SC47wC21Pyt1DxMCsKy4ORE/bnGsxBhqodhiWXyLCedTsDuUHjkNvizF3DHafAJK9oWY5+uxE/ZJ/n4KxdtT8HJABh+Jyzp6l+q3jL6WStfONN4+Q94eyX8Xgt6jIIAF2Sc+agyrQZRk0cxtsOb+nFjZX1MRT3xMFHZ06E1cAtghun7rTzS0knvaPh5FmyqDp0eAt83M9mwzZ8WLYpn++X2Lxm1aBR9ouHH2RAXCLWege6qKn+akpjwo6Jxkj7nFpylLpK5eSJj3p1PQmRPhgwGXz/dgmTS9d6l0t6/4Es+Nx+lSQLUTYUd4RAXBGOjxhJVfxx0AWoDdph05FnaZKbQs9+XENEIrJUg+wBRw58gauAbcDtg+IHK44sVIzA21Oa+0HHwKLrQyoVV87rzwv4vuPPJanToaMKRB1M+hJEn/o8R90yBSB+whUHecdbMvJ4X9n/JXc9Wp2MnQ7cEnHuIf7YZRpVbnoZqvcHiA0ubkJTspsqQX6FSm6L9ue+lGix8ZSj/7DYORug8OAzwPQ6GG5L+DUF5cON9sKcexG+Hj79/hP9jIlacOLBxsL8flZb4MIJZrKA3JhShnV4lps8U7tyrW9IdC4K6T4OvYSYbF/s+hEbJcO9A+LoVjB03lqgq4yAK8NLHRP0jvhy2eD4Exm1i3k+DOGoZjnf75tgCvHA7XVTOeYu7Rgd51FuYks0b977K6/f9C24wwLs2OJNZta0Nb/+xgGdeDaZ9BxNWK+yPO02XRdUxKTj6AWTYoPkT8GTKDUwZFALdf/CYb85cH+YvHsLayGF41akOTicZEeOZ1XIBr62GvtGwqra+zqmdlKq/vTAwkvdax+Hj0Gn/rAHxAZBbq3S9hSnZzJj0GP+OG8/QkTYiI+FIjMHTDWtR/a5FUOW6EnW1EGpWPQ13Oz2+Hz8X1i4exKN8gsXXhmEobO40dvRqxfClc1hr6UndSCfHTplxvRBAjkkRPUXfg9x5F3zfRJd1XY/B2s91edLicQhWVtJxsn0atIyH0QPgi9agGpY+535fsJJug3uUqrd4lM0Faet9/x4xZLN8NvSJhnHdIapHwXFSaRy8AgTp42T1793o8YBnvSXt/WxCjhTM7kuwW+D2EcBf9/PV7hqMrDcOhgP5gAMIBobmQvXaRfXQB58MYiYnaZAEL/4Jn7aFjdVs9PzkJ+4d343bBxgEBRkoBbu/e5/WkRuha4kHRd+H8/lbvZhj/pAnXw6geQsDtxvmfx7Dil9CmDA1mKbNTXjZwJ4HMxqN5pkHZkGvYRCmGyOc2rWGat98Wer4cXxmwXbHNggueCi6Mwr7X+P5fcEN9H4gEZo8AQG1IDcB/9n3ko2bLsf0PprWARraYF3lJlTqP1m3eLf4gttJ/tzKLJn1Amt2N8e7VWOwWMg9Gk/IjtVE9SrYZm693dfs7kb3ezpBm3977M/oPY2pP/xBqDkYvELA7eSet9tx3JnEnI+yqZ4JWyJgTD/Y2LP0vp/8Xirhm0MY6hoH/yhY4ThQ2yFqYRQTeIHwKvlk5Rjc1OgHPnvlE7y7vAWVWoHJintRLcx7kgDoGQNWF6yoDxzsx0+JftwydCnUHwS2KpB9GNdHyzEv8nw1egOdONSkFSMfnA7124J3JOREEzM9gR9XDCPu+rvwrR0GSuGI28kbj4yEYfai7aAmZ9P5qd8ZM+l6hgw14VXwLPn3lRk8+FgQh86oU/d62offKtlpfQqq5uh7/AzvssuOjc92pJOzMnz4o+c/7qkBX8dyJsMwtiqlzv9ioVLqkn6AzsDPJT6/DLx8RppPgLtLfD4AVDvfvNu1a6euNgcPKlWtmlI5OUo5ncXTc3LKTv/PX/+piMLjZ8DsQap9e6W6dlVq3z49n7Vrz7LAbf9QatOTSjmz9efvwpSajXpoop5X7696q2d/elYRhfJ/y18RhWr0n0ZKKaWmbJiiiELdOffO0vN1u5Va1lKpP+9RypGhlCNdL2PH2HOuv9PlVG63W39I2aHU3AClDs1QKt+uf+ZXUl9/GuixvrY3bWr6lumKKFTohFB194K7i/6XH1q1cDDQ4p9+KLXiFqWcWUrl5yrldim1IFSv+xle+uUlRRTquZ+eU0opNWjuIMWz1VWlKg6VkKBUbm5x2szMc66ap9Tdenkp2/S2caQr9/xQ1bH+VjVpklJZWUrl5en5Z2df+GzT0pQKCVHq44/191JT9e/Ri0YrolAjvhuhpm2epohCeb/prUInhJY6fv46+VfxDAu32VkcTDpY6vvNPmpWvA9LuO46pebN89xOJbff+WzfrlTNmvpvh0OvW0aG/jx4sFL+/ko9+6xSn3yiVKtWZc/jppuU+vzzs59PF6L3V70VUah+s/qpu+bdpYhCNf2o6fm/WLgt7clKzQtW6vDn+pzIS1VpX9ZTVrNT5eYqlZ9f/JWSf58pM1OpoKDi2fr5lbGsi7QqZlWp/XnfZB/lXnmzUvklNlpBOaFmmy56GX+Xy+VS0zZPU9UnVle13q+lvtj2hVq4d2HRMbcrfpdq/J/GiijU7fceVtdfr1RCgj4nsrKUWvhrXNE6mcaZiv7+9fCvyutNL4913hi3scw8HE09qowowyPt93u/LzNt0w+bKqJQP0f/rFxuV9EyjqcfP/eK/s19p5RS6vRqpb710/vmG++yy9vUXUr9UE8fh86CE9Cly8C0r+qrkJDiLHg3XaEsb1hU7Q9qK6WUynXmKvM4syIKZR5nVvP3zFdKKfX6b68rolCjFo4qtbhXVr6iiEI9sfwJpZRSQ+YNUUSh3l///t9bx78jP09fTxLXKxW/Vqn5lVTmTD8F+vpY8lpb8u9yFxZW6nr0fzfr4+jRJY+qQ8mHirZvyDshiihU5087q8hJkYooVIMpDRRRqGmbpymllGr/Sfui75553uYuaaHU8SUFK5Wj1LZX9HHxrd85MujpoYeUuuEGpU6f1mVtTo5S332n1FPLn/JY1sOLH1a2N2zK9qat6Lve//JWtjds6lDyoXMv5G8c7zO2ztD1k697K6VU0TWt3+x+yuV2qZ2nd6pVMatUrvMiLjBKqfis+OIy4PhGNWrhKEUU6umlL6gTJ3T97MABXa/6bv1mRRQq/L1wpZRSyw4uU0Shmn/U/ILX9667lHr7bc9rYlbWRWW5bGl7lZpXSam4pbqek5eq6zjf+iu1qI5S8WuUcjn09Weun1LzQ5T61qegTEedmlpNVaqkStdxUtL1fLY+r7/rzFJJnzdUQX5ZKilJKbu9OK1zzQildv1L16+UKnHNKLGvS+772IVKfeur1JImSm16TKk5ZlX5TUOZx5nVtlPblFJKRU6KVKZxJvXOjL3K11epDh2Uev11fYwqpdSwYUp5eSkVEaFU7dpKmZstUqZxJtV8qt4nK4+sVKZxJmV9w6qMKEMt3r9YKaVU62mtlRFlqIW75yr1fXWl5piK8ur4xkfVm1zP43h//bfXz78PSq7b+tFK/dxZqazYgnpnjmpSfZ/65RddVS7pjm/uKHUuP//z8xe02y+W2+1WrT5u5bGsoHeCVF5+Xqm0S5cq1bmzUunpxfv5gupRJbbD6tW6zjJrlq7f5uUptWCBUu3bK3XHHUolJ+vjPyNDqaYfNVVGlKGWH1yulFJFZV/hz674Xer5n55XRKHCJoQpolBzds5RSinVcmpLj/171jKmrOklphXeS7z353tKKaX6zuqriEJN3zxVqUW1lZpjLj6mv/Uts3wfc6dPqf05bvU4pY59p78zx6LUgqp6HoX3ICW+78h3qKB3gjy+b/5HqLLZ9PZzOvU+SU9XSp1epdSfI5Q69au+3m16XJ2eGqps1nzlcnmuZlSUUqMKLtdZWboMysp0KfVDfaVOrlDKUaJQOsv9URG3SymXU5cpR+cq9WsvfZy7iiuwp7+pXGo7TPy2s1IruuoEzmyltr1cYnuWcZ2K/V5P3/CQUokblDr4sa6Dnrnd4pYq9VMnz+/uGHv+69+Zx4Mj07Pc+tZXvfWWUg0aKLVliz4PcnOVOvxZf6UOTiu1rFUzvUut88qNbyi1uKFS2Sf0vXG+/ezbN+ekUvOClDq+SOelsBw/174osR5ut1J16ij16696cnZ28f2k3a5UYqJScXFKxcbq32ceI+UJ2KIuIOZTHt0xbQYaGIZRxzAMGzAMWHxGmsXAvYZ2HZCu/kv7M7JY9N52u/VPobM12BrXcxxhvsUv4JgNM6NDviQ1FZYv1+9VWyy6c6wymb3BbS81+cGCNrArjqzg/Q3vAxS9l38g+QAxqTGsOKJfn7i90e2l5xv/m+5gt+MnukNUa6COIhc+bT3b+pssxe9Q7n4DGo6B2nfrDizNXuBI4R6fDBL+L4E6wXUY2mwoua/kMrr1aED3i/DN7m8AaFipIWajjEPwFqDNON3CyOwNCyMgL6Gg7w1PN9a5EYB1cesA2HZqG6TVoVq4CX9/z5F/Lmo0sz1vQ6NnILCJ3jZLGhIdG0hMSiPGjNH9Sthsev4lh6Q+n5kzoWdP/U69ry8EB+vfo1qPAmD2rtk8uuxRADpFduLXkb96fP+JDk/QplqbC15eg8oNWDS0eBjwUN9QNj+0ucz3YKOjoWlTz+3kMXLSebRqBTt2wA8/wKxZ8P338N138Oab+lj/6Sf994MPwrp1Zc+jenWIi/M8v3JzLzwPAPe3vR+A5dHLmbd3HgDDmg278Bkcmqr7bKkxWJ8TtmB8OUatKjGsX6/zk5mpf+ylT80iH3+s+1EolJ9/cetRlh61e9Chmm4W723RO2dUpxcxHKm6EHKdI0OXmclk4pH2jxD3XBxHnznKfa3v47ZGt2FgsCdxD62ntWZ/8n4MezC/LqjD/Pl6YKugIH0+9e1aveh8dhcMA9+0SlN61e1F7iu5jO0+lsfaP4bzNScdq3csMw+1gmuR92oeXWp0IdwvnMQXErmjyR1lph3YeCAASw4sYdnBZeS58ojwjyAyMLLM9OVi52vgKnhq6rbD/kml0ySth2D9NIyCfczuNyAvgU9XDPY4H+zJ+rXezLxMQA+LbiooU93KTUaeHta7sN+ZiIDiZvWFCrf5huMbANh6SjcA7lG7x99fz4tltkFIS/00PLQrDE7G//4sNm+Gl1/WfRhNnQoffaTLkMzMK5e1Udv172lbp9H0o6a4lItq/tW4p9U9AKyPW1/UUee9re4FirfhgeQDAIztMZZ9Y/YB4Gf1I/PlTLx7/w65p/Tw8gc/BK8gaPEGDLqw/sYSE2HOHF3GhoVBQIDuT6pPH5jcdzIZ/8jgiwFfkPVyFlP6TiFf5ZPvzifXmYvT5SQvPw+XcpV5TFyqttXaAnAoWT8q3ZO4B4BuNbthMky0CGtBj9o9isqwCxXqF0rtoNoAdP6sM1/s+AKAB9vfS0QENGgADRvqelX/Dq2wmCyczjpNrjOXXfH6FfSb65VuGXo2K1fqkVFLXhPLpd+s3f/SHXyH9dT1HFuwruO4sqDLHKjSueD899UjyTlSQbng+jkwMI7k7HD8vHMJDPS8RvsmfA0hraDlOP1dix+5mdkYJjN+fhQ9yQYwWrwGp3+Bo3P0cVhUiS2jTqbcsGWMbsXXZwu0mQjKRWOrwqVcHE07ilKK+Kx43G43H7zWiDvvhNWr9SsrP/0E+/frusHDD+u6xt698NyI5riVmxMZ+jWbo2lHcSs31QKqoVAcTj0MQGx6LArF9a6j4EyDiFuh7zZo+SZWdy7RkVnMumMW10dez8nnTjKu57nrsR5y4+HYPOj2A/jVKKh3+jBt9MO8G3WCxYt1X0iJiTrPn97+KUaJPqqCvYJ5+8a3z7GAv88wDLY/up2o7lGALqtTXkrBZi7d/9FXX0H//rocKNzP5+w4PyrKswMaw+Cf98QSFaWP+cJRGoOCdD9Qs2ZBpUr6+A8IgC41uqBQHEw+iFKK2HTdeqF+SH0A2nzShkkb9PWtb/2+AOxK0Ofg4dTDKBSdIi9tPKTCa9Rfp/Rg3PsSdRnb25wCeUnQ+DkY5tAtzF12yCvdinPKH/40qVI8Mlfn6p15tesr8Nez+ngYcAzu0OV7WfcgVrOVk8+dLOrrDSDh9X0cPw5z58LkyfDZZ/D55zBpdg/sbWdBeC99vevwEZUejKdhIzPLl+u6ZVqa/nnhBbj3Xvj3v/W1b9o0+PTjdFR2DIT1KO5Yf2eULjuc5+gfzTCByaLLlOxj4FtDTzeZ9ffnGIS5k0luUHwzM7nPZJ67609oMwH2ToADk8GrErT+N7R6GwYneS5DKdj8ODR7Gdq9r1sm1R0NuGF2vOexVus2OOANmx6D2PmQuA5Cu+nWZRfTz9vROeAsrgzk2fN5580s5s/X9yNeXrp8DLt9BuScgG0vwKFPdMveNpPoMTKeI08dKfr+rsd2cWPuFmj4hG5law2AH2qd9f6TA1Ogzr0QfpPeH0sbnz0tlDrnDJPB4ZFR1K0Ly5bBzz/rsnLpUv26X5Uq+p6oRg39+2roQPvMhsIXTSmVbxjGE8DPgBn4TCm1xzCMRwv+Pw1YDvQDooEcYPSlLrei1Kmjb/xvuQWGDNEHZl6evimePLl0eovJwqaHN1Hrg1oAbHpoE1Nf8+eOOzw7TT5zlJoizV6B7S/DH0Oh9nBdacg5Qce6I+n4aSc2nSjun2d6/+msOrqKVHsqTac2JS9fv0TdtUbX0vONX6UrLIWKOhG+CKdW6CaHhSPpfB9e9K+qflU58nTxyWgym5jabyqPL3+cQFsgGY4MVoxcAU/WKj3fX7pBZrSu/JhLVipLnzGdI3W0bUPcBiImRnAq6xTUOEbVoybeew+ef173e2E26x7/a9e+wHWznwbvXsWjuQCBPhnY7SaPfjTg4jo3275ddx53ZgCrW61uVPOvxqmsU/hafclx5vBBnw9oEdaCZcOXceucWwmwBTCl75SyOzc2jLN2tDug8QBe6vISk9ZPYt8T+/Cxll2TmDEDRo3Sv1u00OuVlqZv7C9UcDAMGOA5bexYfb60bFlc4T5boO2TT+Dtt+Huu/W70YGBcOQIvP/+hedhaLOhvP7b6xxMOQjom7RXbnjlwmeQuh2q3uBxUbZa8tnyTnembznJp5/qwhz0MfXpp2XfSMye7RnwKuzT4FL9et+vBI0Pwp5vZ0yHMfToFAVx7WDtnRDUAvxr6/dVE9dDz6Xls9C/yWKy0KNWD1YdW4XVbMWV76Kd5V7yGxoEBnqm9fKCZcOX4fNW8fH5x/1/ALryHNUj6oKWaTVbi753Li1C9bssH2/5mJnb9GhRhUO9XhbOLEje4DktP0uXmyUDBdX7w643IPMwBNQDTNDkOWjyHJ+/HYjdDg89pM+nV9+tSpZSZDt1ICrNnoZLubCZbThcDtLtenS3pBxdwavqV/pkvi5S9+Ww5dQWQt4NIc2ehoFRtH0qUvv2f38klr+ljPKzGeD/TgBZjixcShf+D7R9gHE9xjF963TyXPrEfr376/Sp34fXVr3GvD3zOJFxgkxHJgG2AML9wwn3D0eNPePpUoOH/nZWt27V15KSgQAoLlsDvAK4r/V9xdOtvmQ7sknOTcZi0pUPm9mGr7X8R/JqVrUZADFpMThdTraf1pG3dhHtLnnez173LE///DQ2sw17vp0Q7xCahzUvlc5qtlIzqCZHUo/Q/YvuxKTGAMXH+4UYPRomTtR1O6X0dT4/X980X5KUzdDw8eIO6QvrTr41igPGJacDdJoJkQPA4kuziG0MaDaD++9/inff1Z09KwVZexcR1GJY8Whz34cTWTmetwc/wy23TOOtt3QH9243rF/fiNtvXw05JyHzEHT+SuenapfS+U3bDW4HXPeZx8hvHb3hTzvEpMaQkJ2A0+0kMKMzrnwTH31UfCz6+uqgRoMGFHWWD/Dak3WYNMlMqj0Vh8vB4RQdJGoT3obY9Fj2Ju4lLz+PlNwUbCYbVeNmQ0hr/YqRxU93or7zNbDHM6LlCEa0HHH+bX9m/alHOLx+gw5cF/o+nG5N4vmlSSTH2yqOHdMPgAICIMSnEhse3ECnT3XAY/PDmy+uE+u/YWyPsTx//fP4Wf3O2vHtTTfpm83c3OLtXlj3LVNUlP4p4HDARl9YPtqzfrZ6NdxcRpy1c2RnZvw1gw1xG+hZuyd5rjwq+1Tm6eue5skfn9QtE1B4mb0Y2nwoX+z4gh/2/0BV36pkO7MJ9g4m1C+09IwvQuHDo9+P/c7snbM5mn4UgBqnF+rASovX9bnkXx9w63G+z+hPzwSss6cR8q4O+vx636+YUrfqQG2vleATDmU93C7B1+bL0WeO8siSR3iv93tU8qkEPjBy5PnXwWqFLVt08P/JJ4vPDYdDlzs9e5ZMHQK/9YJ9k/SowSpf9yvY9CX9eumFaPi4vsc6NA3qPwQtxurvH19ApTojycjL5ETmCRpXKejPrsp1+ud8MvbpwHaT54vv2wrvn+4EvjtLywq3E/Jz9H4K61l2mqgoz4FwCs+BmdXAOwfa/wfCb2HLxFHUqe2mQQPP+2u/ymFQ+Y0yZ10nJJDcV3RF3dviDQd9wJWLx0AdQJnB9IyDury0nHkDcJbj5YxzDvSb63XQsYX/BpccNAJQSi1HB4ZKTptW4m8FjCmPZV0N+vWDvn0hNlY/fahUSd8Yn03NoJpM6TOF+Ox42lZry/Hj0LXrBQ6fa7JA2wngcugIcX6WHgFHKabdOo220/UTvX90+QeVfSvTOrw1q46uIi8/D4XChIm6leqWnq/ZF/Lj9InhMf0iHqMplx7xpnSmy0z+cLuHeXz542Q4Mriv1X3UCi4jYATQ4WP47WZdMNQcAnec1MNF+9UslTTAK6BoKPhTWbrxWqCPP7/+YrBoEQwfritISkG1ajpib7mQo77OfRDzFdQaqguEQacJczt58JCVwYPhyy91Zd1s1i1jGja8gHmig4zr1unRfs4MHH1868cMnDuQHGcON9a+kdbhrQHo16Afq+5dRcvwln+7p/zxN41n/E3jz5lm4EAdqPnsMz2cZn6+jkO9996ljdKzdCk888yFVbS9vIqvDU6nDrT8nSe70/tPp8eXPQCY0X8GposJ0Ye0haQN4HxAB45aRkHLKILQA7ZdiOxs/VTS1xdWrdLr1b37Ra7EWQR6BTKp9yReXvkyE26eoCdG9tc/yq3LCLNP8Y1HBZs5YCZ1p9Ql0CsQe76dfw94kbtnlF2Z9bZ48/1d3zNo3iDe7PEmIT4hpROVk8IWmC7lIt+tm4HdXP/CWyFctKT1er+4neBfF7JjdaXvzGC9TzjctAq2vVhQ3tcGZwZpp05x6NAa+vWDDz7Q52TNOlUYuMWNPd+OW7lJs6fhVm58LD46aJSng0ap9lQAKvuUHufZ1+qLl9mLvP9v787jo6rv/Y+/vpPJDllISAghsm+yiBRBcEPcqa0brUprtWpdqlVpq621rd6299Zrt1+1vfVq9dp7r1frXm3FpWq1WkWtO4sLLigIKHuAEEK+vz8+cyaTzEzWCTND3s/HgweTk5OZL3wnZ875nM/n8921g40N1iOqJL+EnFCyq42+57dzf8vp951OyIVo9s384OAfEHIhbp93Oyf80TLZvnPAd6JZXpt2bOLBd+yUqO0qZKnSrx+sW9f5Y/PAooHUN9bz6bZPCYfCeDyVRZW9Mrb8cH705kf+T/LxkebQk6sm9/i5L5xxIRc/fDENTZZVef2x1yfdt7q4mnc3vMsLq16Ibtunep9Ov9bVV8N119nn4qxZds722mvweHzLqK4pHgbrX4YB+7UOVuSVY6vItTk5LBhkvT9ibqJdd8bFLN7nIv7zP+0cJDcXvjfTUcouIuuXRJ1/+I3M/9X1PPig9WQKh2HoUDsvckWDoaiDbLO1T0LFjNZPCkyODP3eZfdGV9frv+pzTJnROhMfLGvr/PMteyXQv1+I2pJaVmxawW+e/w0PL38YgOmDp/OnN//EbW/cxqKViwCoKarAbVoChz3RcpEWd7HWDc3YCrckOrcKUVdnd/pjTa+dzumTT6eqXxWjBozq+Rg6oaPjyFlnwUsv2Q26Sy+1c7cVK+zmdmfs3Gmn3ImuSxKddg4rHwbAHxf/kXuX3QtAYW4hX9/vBULmZAAAIABJREFU63xj4TeiAfZfHPkL9h5oCwAs+XQJlz92OQD5OfnxT9pFe1fa83605SPO/fO5ABSFCwhtegNm3ADhyP9ZqP2T/rKCMuovr8c5Z0H0dc9ZoKSgusOAUaAkv4Tb5t3WrX9Hfr5dq8yf34mdD74Pll4Dfz0ISiYAHjYvsQzAzggXw9EvwOq/2s2phk8hv8yCH97TP78/4/K7sbTgp4ssQ3LXjpbjVGzQO5lQLuR1sCpmgmALO7fA3ZUw/GzLaAoX09QcJr8g/tjTkVYZrxN/AE8cZdlD/UfDscsiWZ8JjjXVc2DNYzD63Oh14p4uJUGjvsg5+9AdmiTu0dY3ZkT7glNXB4sX23KgnS5tysmDktGtNsWWKX1z5jcBO3F94v0nGD9wPEs+WcLRo44mob1OgkcPguZf2G9Yd97slftbWu+Yr9tBooPnyAnl8M39v8kvn/sl/zrnX5PvWDYBjnnJIuEP729R39KJMOt/WmX+BKbXTueZD5+hMFzI9qbtzB01l5wcOOkk+9Mtw74EH90LT8y11VwKBsGmN/jFL+bzv/8Lxx5rJRK7dtl8/vnP8Xd8Ezn7bCu1uPVWuwvR2GgnUUVFcOyYY6P7tU2vnj18dssXvbhcek0NXNGFpJzO+PRTW3K7q3Jzux+sOnjowdHHX5jQybOmwOjz4P5R8MFt9j5obrTgaLjzd+RffNFOvq64wv7toZAtXZ4qC2YuYMHMBfHfcCErp8wgw8uHU1dSx4ebP2RE+QgOnVZLdTVcey1ceKEFBZub7Q5pcbGVjS06exGfqel5VkJ7ivKKmFw9mdfWvEZFUQWr61fz7Znf7r0X/OQfVmoy/lKYcrWdbDyeZKnv/qOsKbT3dvzLKeCZB0MUFMBvftPyuTHnkDwKXilge9N2NjVsYsN2Cw6VFpSyaccm1m2zsrQgGFRRFB80Ajh02KE8tPwhygrK2NiwkePHHp/af3uWm7f3PE6/73Samps47zPnRctDjhtraZUnjT8pmrFTnFvM1p1bo4G4Q4cnuXvaQzNnWqbj44/DnDktF3tbtyYOtA/uP5j3Nr4XDRoB1PSvid8xRSoKK9i2c1s0YARQ1a9nmQUAIRfiR7N/xA//9kOgZQ4SOWHcCTz70bOEQ2GampsIuRBjK8cm3b+tnBy74XHxxfb/2tAA5amIY+/9XVh0tmUO5ZdbCcy2j2DhlNb7nbgaXroMGj62z6FWmdcwYYKVa0a9PQ/e/6N9boVaX8SUYhm8HUqUyfzzi+DCK+KyygsiwYRnPnwmGtxp/KSO8VPjgw+vv27v07Y37XykLO77j38/mrU3scpOGOob63ltja3aN6EgbEG1yp6VNMWdP+1YD/cNgZ2bIaeffVifuNoC9uHkgZpbTrilZ+NIsVDISuJXrbJjwvLlloHW2Uz4oiILND39NMye3fIzRx8Np59uNw9jBVn+Hh+dt3EV4wi5EFcdchVXPXkVAF+a/CXKCspwuFb7zqhtZx7bvgedswHFRgOcIw/I/z7sCBPNtp1TWQfhdS3NnzupOC/moBkESbsS/NhdwoWWHTTpSrsBheswKBbHhaz5fU2S84/uaN7Rzu9LL9RVrf+n3YSbdGX0uDRl6CssXpLL5s2tb8pv397JJA2w68+D7oZF59jzFlbD5rdh7svx+448E978lZW97fszCOVD0xY7Tu2hMqBCru859VS4997WywW3LXnqrPtOvo9LZ10aLTs4bIR101+1eRVgafQJlYyFuhPhr4fC6odsdZ61HZd0tDLxB7DkavvlbdpqH7rb2y9x+/mRP6fpB03UlnRQBlI4yDI8jvknHLsEDrojYcAI4NJZlv+xX631erlk/0u69u9IJJQDB91j6a0f3G53/de/jPM7Oe00eO45C/wtWwaPPtq5gBFYffizz1pvjv33tw/j6ZH2LDmhHA7a6yDA6sX3FDk5Xe9L1FPOOV477zWeP/v56AVSp+UPgCOfgTevg4dnwD++DAs730cK7G7url2WblxUZHXVZ5zRtWHsSYKMqODvO++En/0Mzj3XeiVcfz0cZocunHNMr52+WzJdgl5rq+tXU1dS16uZTXzytGV4TvyBnbRVzur4Z5yzYKULsXy51bVXt7TIo6DAAkRggaFocCiSURT0Mgp6GyXKNIKWY2Zw5/aC6XtMYnBKFOUWMaLcMnZjbwA55/BXeu764l3RbV+baiVnQV+fy2Zd1itjysmxjNfTTrOMmMWL7WLxxBMT7z+sbBhgpYpBueLQ0k7e9eqGQ4ZaamVuJOOxsjB1WU1nTz0bsL6I+eHkH77nfOYcAIaXWe7/ieOS/OeAXai26fGCczBoEM7ZRUhlZTvlPl0xaI71g1y4L7z0LXj1e/DCBVCxn/3dtM2yX5q2wqf/gIppLRdk7V3ADpsPW96El79t52O7GmDbhz0fby7W36PNZ+nhkeB1s2+mcZc18KssqiIUav1f2dRkAbchCdrFBaWM25u2R3vZzR0zt1XfIIC5A4dAyTj7vwH7f/i/7mVet5I/AEadC387Fja9bhfiO+vhjXZubGawwYOtZ+aCBXDyyZ1vneCc/cyCBdbDaMsWy4ifMMHe9/PnW2bj1q2webNlZxS2KYn63NjPAS2/n/3z+lNWUAbAfoPt/Hz0gNEt+yT7nfskvvdQMod9aMeXkeUjAfjqyAOtF2lsf8euBn3q34eK6S3Z2kE28NeJT7uKHCPSIpTb9YBRbymotv+32JKuE1dbT6n53bzAbU/9u5axGROgKS3azKkz/49TTrH38KZN9h7+Z9w67R2onAHHvGirIU75d7seSCRcCEf/E1wY7h0Cd5ZYX6M9mIJGaXDooVbSNncuLF1qaaHJGgN35Lhxx3HNEddEvw6HwkytmcrGHXbx0G4z0/1+ZycuL1wA91TD0/Pab6bWVvVsmPwTKyV7bA48dQI8MLLdH3HOpfxi8MC9rGfTyx9bJDg4We8x56xh3f43w5yHrEwwBSU/Y8daivtdd8FFF1lzyMBTX30Kf6XvdhlaJpo40QJrsU2hd4dJ1ZOigcQuKx0Pn30NDr7XMkPmPNqlH3/rLZg6tfW/ub2m2Xu648cdz9GjjuZzY+ykcswYuxM6fboFjR5/3LKyki0o0FuCxQOgpYlxQsHJbdsT3K6cLG563TILAjmdvfVl3n7bAs2xN1vD4ZZAUGzQKGhuHGQe1TfacT1ZptGsOgtgvbLGes90pdl+X/Hvh/07w8uGR0stkgneU8s+XQa0ZE30hmOOsfLXJUusp8m559r5RaL0/CBAtPDthfzlrb8AVjrfW86fdj5gWWwA5007L2XPXdO/hisPuZI7v3hnu/uVFpRSGC7k7fXWkHvu6LkpG0OPjf8WfHax9ejJr4BxF8P+/wOrH4NHDoTXr4KXvgnrFkH/MS1lMu31nsztB0c+az2I7q2Fv0yE+ztZOx9YvbrN+lIezrwQtq+CpsjdnxNXw3xP5VesBQIQDfLsO2Yg775rmfSB5uaWZJG2gqzg2D5b4VA4WsoYlH8dWjMRiocSLSPrag/O9kz9hfWSe/RAuG8Y3DvIFovpYy65BEaMsAVRzj8fLrjAHj/yiM3h0KH2mb1X5LBx6iRLXZs22BrPzZ9k9VW1JbVMr53OdcdcF33uL0+2hQN2NVsA4fARhycfyMCB8e/BXbvit3nPad/+bwDrIwQcMHgq5JZaqX6gq++V5sbW5UgF1cn3FVN9KGx40XpBxWrupRP/Le9A2aTW8wz89owL6NcPRo2yBI0jj0zck6tT8sqsaXZ7VQZ5pTDtWvjCBvjiVjgxhcelDJQhIcq+JRSyLunz51sjy7w8692SqmyMr0z+SnQ1geBAmpBzVos5+tzuv9joc2DoF2HlA1ZGMf0/u/9c3RRcCG1p3EJdSR25OZnRy6UjY8Z0vhdSNjvhBGtkfemlLf0MduzofHZWr+qoqXj/Ufani957z3pgdHv1vj1MfjifhV9a2GpbaakFTS+6KE2DglarpgQrvCTU9j3S0fa2vLcyiJqj7I49dLpXQmDZMgsMtH0fVRVXsfiTxa2CRkP62y394OutjZa6nyzTKOgNt23nNkaWj+x6dl4fMG/CPOZNmNfhfjPrrGxjQ8MGRg8Y3esZc/vsY5l7HVm1xbKPb3/j9ui21fW9V+q8zyDrHfTO+neArjWg7ozONsY/ecLJ0VXWDtirnQzeXiz7TqqwGkaf33rb596Cd26AlfdD3gALlMTevS+ojlwEJzl+FNfBEX+3nmnbP+7W51ecylm2qqiPXwL0oKEH8eQHTzKxaiKvr32dr504lq+c2rp3UW6unfeuX2+ZMLFOnXQq33v8e8wYPINnPnom2lLh+PHH8+raV6O9b0aU7gXb3u/ycbNTXAj2+bGt/FS/3LIXinpxFc0MlZNjq94+/bS1UGhutps6JSVw//2wcqWtfBcEjWYNmcXNL98cvd6I7ZG26OxFrZ47WCnt3Y3vUpxbbAuypOB3LmiGHazQWNWvBta0iZp39DvTVk5B6+BHUObZmZ5DfVVemfX4efqLcOhDkZtsYVj6cyshS7VNb1jAPaf1YgIFeTt48EFbdOhvf7PzpWTZtym3B93sT0aZRmlSXg4LF1qd93332QpRqRKUqLVbM5xKeWUw/DQYdU5qTlC64YSx1ow0KDeRzHHCCfD++3YXfOtW+/Pqq+keVURPgwFJrFwZv7JRSsoaJKWcc9EASXDymVB1kjuNyba31VQP+M6tQpLE++/bXd+2grKf+9+8n7+v+DtAtPw3aIQdZBoFpWyJfGmSrTykY2jPBOUYYAGLTBGUpzU2N9IYufubdDGKFAh6hLy70U5uUpYB3EWxGQ1BaUxGy+1nqyUe/jfra5ZfacuHByJZPh2WfBTvZWUW+YkDxV1SdTCse8EWYwnS2CIZI0Fvm2A59QNnFLFpk5VMbrVYNdu2wciRVprfVpDt9vYGywabNcSyHvcdZNmOQTCgIK8f+EasczVtsj9SdCkTLrLshT4YMAo4BwcdZCXjN9xgZePBtXBtrS3oEaz0FKyG2OybO2ypENuA/sTxqbuKD0pPt+3cxtiKsbj8CnufhmJOvjr7OxMonWDl5Lv6cHp4d8y4yVZifGA0PPsVeOgzsCSFzTxjbV1hvW6DmzJtssmmTLHMubPPtsoeSQ0FjdJs5EhrOleTwn6UQY34nOFzUvekGe6IkZZ/2Jf+zdmirAxuvNGWFB0yxMq2Zs9O96giehoMSGLt2s43yZf0OmOfMyjNL20/QzFRyYb3nb9T2rDWytGKu/+m2LwZhg2L376q3jJIrn/xeh5918oogx5Gmxo2sWrLKnY276QwXBhd3SuR4OK6txo39yWTqiYBrRvyp9v4gePjt1XEb0ulo0YeFX3cm0232xNkF4VD4ews+y7d20rUmnZzY8BYRbXW4+WpE2Dru3YxXW9BnsnVLSvi7Td4P8Jh+OlPrXHyuefCAw9Yn5zZs+Gmm6zHSKC+3hqbDygcEF19LSjnDDLVINLjMb8S6j9oqWEOAgG91TNFOhRca0Dr3/VEYnuPpfI83TkXLceet/c8KN8H6t+JL4tq2tr5J6062FY7bbu6tLSvaDAcuxQGf9Z63eaWwWG9VObZvMN638pupaDRHihozvlvh/1buoey2wQfQu1mC0janHyy9d4YNcp6+5x33u7vX5NQT4MBCXgPGzemrzeidM2Nn7+Rjd/d2Lsv0rDG7vj34CS0qSnxaptVxbYiVcOuBpqarXwkaAq6qn4Vo6617M/ge8kEx9CgP4V0X7DyX1CSkQkSLTU/edDkBHumTtDfqbo4fT1Bgl5OQSPzrFO5P6x/JWFp2G414/fQsBr+PN5WF33QAqOxPbuCIOn559vCD/fcY5/9t94K8+bBU09Z/7r6estCWmZtv5gzrCWIEDxfbJP2OcPnWAbQ5mXx/UWatiHpEXujpTP9I4OFFlJdBRG872bVzbLSwtxyW8BmV2zgqAuXu5WzYONrFviIrPbWpaBTX1YwEGb+Fxz/IRz1bI+yq9vld1n5m+xWChrJHmFs5Vj8ld7qpCUjzZhhq4p98AH88pd7bvlv0Py6IgVVAbKHaFgDeZUtdz+7sfJPsqWTa/vHr0QZ26x5eyRDoaMsi5r+NfgrfXQ5eem+s/Y9i7EVYynJL0n3UKKC0qyCcAFFuXbh3VFT754KStLSGYh0znH5gZdz8+dvTtsYeqR8X9jwUuvyi3RkHZWMsZWCyiZbuVz5VGhuYkxFS2PGKYOmAPbZ/tvfwpNP2mf9I49YmdPIkVau/rWvWS+7WZEFJGODq0G5WuzxamrNVFsRq3E9rHux9bhSsDiJdF/w+dOZ8tPRFXYMGls5NqVjCEoZgxXaGPxZeP3HsHNTyyqES3/W+ScsHWcZfk8eB2uftH6Er/9LSscsPRVq3QQ7Wq6qsEZvUphORCSFmprspDlP194SaFhrSzsHJzndWPknJ8cWkGmrrrQubtuYyjE4HJ6WdL62yyNL7zlw6IEsu3BZuofRSigUIsfl0NDU0qejtxueB0GEiQN7bwW5zsjqrOsBn7HS1qe/CIc9YT08Nr7Re3fw21MyBo5pvX51fsx7KLZcCWC//exP4K67bHW/e+6xIHj/yJoAsdlKscGikeUjWb5huZXA5eRByTh49XKY/Rdb3appK7z5a5jwvRT+I6UrhpQMYeWWldGM1/b86qhfccjQQ9otk+6OeePncfsbtzOweKBt2PsyWHEbLJwCo79uK5euuAsm/bDzTzrtP+CxQ+GJSNldKA/2vab9n5HdJ5SbuFm59CqF5EREUqipyTJCEmWFSB+1q8HK03pwspybCxs2xG8PGhzHqiqqigsI9Mvrw8v3CdCyfDm0Lv/pLWUFZZQXlHPcuON6/bX2WC5kQZHNb8Kfx8ATx8BfM6dXFoDDAj3jKse1u9/o0fDGG/DjH8NVV9ljaAk2DSwa2Gr/4NgWPcaNvdgyjZ49AzYthbd/B692IRAgKfffx/83Nx57Y6f2HV4+nAUzF6R8DCMGjOClc19q2VA6DsYugMaN8Nr3LWCU18VuyJXT4dCHrS+PC1tPL8kcBYNg0+LW2UbS65RpJCKSQs61tEYSAawfSU4h0P2azIoKWL689Z17gOmD7WR2YNFAPtn2CQ5HKBQiPyefnc07o/vFLocsfdOI8hG8ue5NoHUAqTet/8763fI6e7TRX4dVf4FPnrFVnXIyK2uwqriKNVvXdKo9QFkZXHZZ621DSmy1srqS1lmTZ089m+Ublrdkpgw/zYIAH94NH95l23ISNHqT3WZM5RjGVI7peMfdbcq/QVEdvHWd/T3zlq4/R9WBMG+d9c3K1U2XjFI2wRqeN22H3OJ0j6bP0L1wEZEUys21gFGzboBIwO8Cl0NPgkYjR8LSpfElarUl1lMiaDYc9AQJljwPpLMZsWSG2GbQWdsYui/KyYPZC2H8ZTDkRDjg9nSPqJWvTvlqNPDTHUFJWttVtU6ZeArvXfxey4acfDjyH1BQBbklFjDKsP8LySBjzodjl8Cch6Gwm6s3upACRpmoZCxsfgvQCne7kzKNRERSKBy2C/stWxI0wx40CNbE9LNxDqqre7Ram2SDSNpZ0K+joDqmr1Hn7t2MH2/lHPX1UFrasj1YwWbVllUA0eWHD6w7kLuX3c2Bex3I0yueTukyx5KdhpcNjz5W0CjLhMIw+ap0jyKhnx7+U356+E979Bz+yk6m5vYbYct6r3sR+o+CfsM7/hkR2bMUD7febrF2NVqAXXqNMo1ERFIoNxcKCmDt2gTfXJOgAXKibbJncTmWbRTULJ64Gub7yJ/O3SkbMQKef97eW4HtkUWUwqEw6xusDKimv91RnVhtzWWDZY53VzmSZK4goAiJV90TyQp55VBzhAJGIn1V+RTYtQ3eucHKB8HaAEivUtBIRCTFKipg5cp0j0IyhguD3wl0v2Zx771h82YLHAUlakEMakj/ltKQ4HHQw2j9dgsmVRS1TXuTviYoZWz7WEREJGsUDoKiWnj1Ctjytp0M/TP1TdalNQWNRERSbNAgeOeddI9CMkYoD3as79FKH9Onw44dcOaZ0NAA27bBNZEVgIeXt9xxD4IBFYUWJFq3fV2rr6Xvis0uUqaRiIhkreFnAA4WToE7imH5Deke0R5PQSMRkRQbOhSeecb6GgW2bUvfeCTN8istaNS2EXbT9k4/RV4eHHCABSOnTYOTToIf/ci+F5s1EixbHWQWbdi+odXX0ne1Kk9TppGIiGSrkWdaFjfAru12c056lYJGIiIpNmIEPPWUNcUONDdjTa/bSrRN9iwFVbDjUwjltt7ud3bpac45B4qLYdkyeOihlvK02KWqBxZHgkaRzKLNjZtbfS19V+yS6P3ytCKQiIhkqaJa+My1toqiy4Vw/3SPaI+noJGISIpNngzr18MHH7Rs27gRWyXN+9Z/tHLanq+gGnZ8YktGx+piudoXvgCjRrUswlYYiQEM6jcouk9VcRXQklm0sWEjAPnhNq8tIiIikq1GnQmH/An2+Ql8dnG6R7PHU9BIRCTFZsywzKJzzrEVrrZvt8fSRxVUWfp0Q5sl9XIKEu+fRCgE99wDo0dDfj5ce61tD0rSYh8HmUX1jfXdH7eIiIhIphp0OOx9GRQqa7+3hTveRUREumLUKMjNhb//HY4/3i7wFy5M96gkbfLKbTnY9S9DbU3L9l0NXQ4cjRgBb77ZeluQXRT7OCg/atzVSDikj3oRERER6R5lGomIpJhzcOSR9viRR+CBB9I7HkkzF4JwCXy8sHXz60+fS8nTB32MAIrziu0lXUvT7dgGyNK3jasYx4jyEekehoiIiGQRBY1ERHrBhRdCUVHL18XF6RuLZICSMbDyASDSvXrnFnjvlpQ8dWx5WiJ7le6VkteR7Lf0wqUsv2h5uochIiIiWURBIxGRXnDwwdbbKByGnBwYNy7dI5K0qpwJW1fAijuhudFWU/vgjtQ8dVFlwu3982w1kZHlI1PyOiIiIiLS9yhoJCLSS+64A444AmbPhvvvT/doJK0GzoJwP3jxG/DCBfD44USzjnooNyc34fba/rUADCkZkpLXEREREZG+R90xRUR6SWUlPPhgukchGWHgQZZh1LwDlv/etoVLevUla/rXsGzdsg7L10REREREklGmkYiISG8rHASFta23+caUvkRuqHXGUbCSWkVRRUpfR0RERET6DgWNREREdodJP7QSNQByYMhJKX36tmVqQa+jikIFjURERESke1SeJiIisjsMmw+vXQm7tkNOAUy6MmVPfdaUs9i3Zt9W28oLygFlGomIiIhI9yloJCIisjuEcuGoRfDO9VD7OSgZnbKn/v1xv4/bNqBwAKBMIxERERHpPgWNREREdpfC6pRmGLWnrKAMaAkeiYiIiIh0VY96GjnnBjjnHnXOvR35uzzBPnXOuSecc0udc4udcxf35DVFRESkYyX5tjpbaUFpmkciIiIiItmqp42wvws85r0fDTwW+bqtJuBb3vvxwP7ABc65vXv4uiIiItKOcZXjCLkQIac1L0RERESke3p6Jnkc8IfI4z8Ax7fdwXv/sff+pcjjLcBSoLbtfiIiIpI6E6omsOuHu9I9DMk2gwaBc/Yn4JxtFxERkT6np0Gjau/9x2DBIaCqvZ2dc8OAfYFFPXxdEREREUm1NWu6tl1ERET2aB02wnbO/RVIdHvpiq68kHOuH3A3cIn3fnM7+50DnAOw1157deUlREREREREREQkRToMGnnvD0/2PefcGudcjff+Y+dcDbA2yX65WMDoVu/9PR283g3ADQDTpk3zHY1PRERERERERERSr6flafcDp0cenw78qe0OzjkH3AQs9d7/soevJyIiIiIiIiIiu0FPg0ZXA0c4594Gjoh8jXNusHPuwcg+BwCnAXOcc69E/szt4euKiIiIiIiIiEgv6rA8rT3e+3XAYQm2rwLmRh4/Dbi2+4iIiIiIiIiISObqaaaRiIiIiIiIiIjsgRQ0EhERERERERGROAoaiYiIiIipru7adhEREdmj9ainkYiIiIjsQVavTvcIREREJIMo00hEREREREREROIoaCQiIiIiIiIiInEUNBIRERERERERkTgKGomIiIiIiIiISBwFjUREREREREREJI6CRiIiIiIiIiIiEkdBIxERERERERERiaOgkYiIiIiIiIiIxHHe+3SPISnn3CfAB202VwKfpmE40nOau+ykectemrvspHnLXpq77KR5y16au+ykectemrvslGzehnrvB3b0wxkdNErEOfei935auschXae5y06at+yluctOmrfspbnLTpq37KW5y06at+yluctOPZ03laeJiIiIiIiIiEgcBY1ERERERERERCRONgaNbkj3AKTbNHfZSfOWvTR32Unzlr00d9lJ85a9NHfZSfOWvTR32alH85Z1PY1ERERERERERKT3ZWOmkYiIiIiIiIiI9LKsCho55452zr3pnHvHOffddI9HEnPO1TnnnnDOLXXOLXbOXRzZPsA596hz7u3I3+XpHqvEc87lOOdeds79OfK15i0LOOfKnHN3OeeWRX73ZmruMp9zbkHkOPmGc+4251yB5i0zOeduds6tdc69EbMt6Vw55y6PnK+86Zw7Kj2jFkg6dz+LHC9fc87d65wri/me5i4DJJq3mO992znnnXOVMds0bxki2dw5574RmZ/FzrlrYrZr7jJAkmPlFOfcc865V5xzLzrnpsd8T/OWAbpz7d3VucuaoJFzLgf4LXAMsDdwqnNu7/SOSpJoAr7lvR8P7A9cEJmr7wKPee9HA49FvpbMczGwNOZrzVt2+DXwkPd+HLAPNoeauwzmnKsFLgKmee8nAjnAKWjeMtUtwNFttiWcq8hn3inAhMjP/EfkPEbS4xbi5+5RYKL3fjLwFnA5aO4yzC3EzxvOuTrgCGBFzDbNW2a5hTZv/EoaAAAEpUlEQVRz55w7FDgOmOy9nwD8PLJdc5c5biH+d+4a4F+891OAH0a+1rxlli5de3dn7rImaARMB97x3r/rvW8EbscOPJJhvPcfe+9fijzegl281mLz9YfIbn8Ajk/PCCUZ59wQ4LPA72M2a94ynHOuBDgYuAnAe9/ovd+I5i4bhIFC51wYKAJWoXnLSN77p4D1bTYnm6vjgNu99zu89+8B72DnMZIGiebOe/+I974p8uVzwJDIY81dhkjyOwfwK+AyILYxq+YtgySZu/OBq733OyL7rI1s19xliCTz5oGSyONS7DwFNG8ZoxvX3l2eu2wKGtUCH8Z8/VFkm2Qw59wwYF9gEVDtvf8Y7M0NVKVvZJLE/8NOxJpjtmneMt8I4BPgvyKlhb93zhWjucto3vuV2J3WFcDHwCbv/SNo3rJJsrnSOUt2ORNYGHmsuctgzrnPAyu996+2+ZbmLfONAQ5yzi1yzj3pnNsvsl1zl9kuAX7mnPsQO2e5PLJd85aBOnnt3eW5y6agkUuwTUu/ZTDnXD/gbuAS7/3mdI9H2uecOxZY673/Z7rHIl0WBqYCv/Pe7wtsRSVNGS9SW34cMBwYDBQ7576c3lFJiuicJUs4567AUvtvDTYl2E1zlwGcc0XAFViJTNy3E2zTvGWWMFCOlc9cCtzhnHNo7jLd+cAC730dsIBIVjuat4zThWvvLs9dNgWNPgLqYr4eQkt6nGQY51wu9qa91Xt/T2TzGudcTeT7NcDaZD8vaXEA8Hnn3PtY+ecc59z/onnLBh8BH3nvF0W+vgsLImnuMtvhwHve+0+89zuBe4BZaN6ySbK50jlLFnDOnQ4cC3zJex+cMGvuMtdILMj+auRcZQjwknNuEJq3bPARcI83z2NZ7ZVo7jLd6dj5CcCdtJQxad4ySBevvbs8d9kUNHoBGO2cG+6cy8OaN92f5jFJApG7BjcBS733v4z51v3YgYfI33/a3WOT5Lz3l3vvh3jvh2G/X49777+M5i3jee9XAx8658ZGNh0GLEFzl+lWAPs754oix83DsDp0zVv2SDZX9wOnOOfynXPDgdHA82kYnyThnDsa+A7wee/9tphvae4ylPf+de99lfd+WORc5SNgauQzUPOW+e4D5gA458YAecCnaO4y3SrgkMjjOcDbkceatwzRjWvvLs9dOLVD7j3e+ybn3IXAw9gKMzd77xeneViS2AHAacDrzrlXItu+B1yNpaKehV0sfSFN45Ou0bxlh28At0aC6u8CX8VuDGjuMpT3fpFz7i7gJaw85mXgBqAfmreM45y7DZgNVDrnPgKuJMnx0Xu/2Dl3Bxa8bQIu8N7vSsvAJdncXQ7kA4/a+TbPee/P09xljkTz5r2/KdG+mrfMkuR37mbgZmfLuTcCp0cy/DR3GSLJvH0N+HVkwY4G4BzQ71yG6dK1d3fmzrVk44qIiIiIiIiIiJhsKk8TEREREREREZHdREEjERERERERERGJo6CRiIiIiIiIiIjEUdBIRERERERERETiKGgkIiIiIiIiIiJxFDQSEREREREREZE4ChqJiIiIiIiIiEgcBY1ERERERERERCTO/wdSsLyfXbihNAAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -2228,7 +2314,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2240,19 +2326,7 @@ }, { "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABIcAAACMCAYAAADm+clLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAZoklEQVR4nO3dfYxc13nf8e+zO0vuSuJSdkX5hZRCpaDbyq7VGIyiVGltJ3VKJbLZAgkqIS+O64BQYKVp0KaVG9T+r3Djom3ayFYEm1GCOhYCR0qIQLYkuG7c1pBCSn6TbCthZddaU42k2Nkhw9nlzO7TP+bO7nA5u3tpLffemfl+AIJ7z72XPItHvJrz23POjcxEkiRJkiRJ42mi6g5IkiRJkiSpOoZDkiRJkiRJY8xwSJIkSZIkaYwZDkmSJEmSJI0xwyFJkiRJkqQxZjgkSZIkSZI0xhpVd2CQq666Kvfv3191NyRJkiRJkkbGE0888VJm7lnbvmk4FBFHgVuBFzLzDQPOB/DrwI8BZ4Gfy8wni3OHinOTwEcy8wNlOrt//35OnDhR5lJJkiRJkiSVEBH/d1B7mWVl9wGHNjh/C3Cg+HUE+HDxF04Cdxfnrwduj4jry3dZkiRJkiRJl9qm4VBmfhb49gaXHAZ+J7seA66MiNcANwInM/PZzDwH3F9cK0mSJEmSpJrYig2p9wLP9R3PFW3rtUsDfeaZF/jo//p61d2QJEmSJG3icydf4sP/4/9U3Q1tka0Ih2JAW27QPvgPiTgSESci4sSLL764Bd3SsPnEiTl+8499uEiSJElS3T3w+W/xoc+crLob2iJbEQ7NAdf0He8DTm3QPlBm3puZBzPz4J49F2ycrTEw32oz32pX3Q1JkiRJ0ibmW21OL3ZYWl53DoiGyFaEQ8eAn42um4D5zHweOA4ciIjrImIHcFtxrTTQfKvNYmeZhfZS1V2RJEmSJG2g94P9pj/gHwllXmX/ceAtwFURMQe8H5gCyMx7gIfovsb+JN1X2b+rONeJiDuBh+m+yv5oZj59Cb4HjYjmQnvl9+mpyYp7I0mSJElaTy8Uai60ecXlOyrujV6uTcOhzLx9k/MJvGedcw/RDY+kTfUnz1fvmq64N5IkSZKk9fTCIbcGGQ1bsaxMetkys+/h0qm4N5IkSZKkjTQXuuO2puO3kWA4pFo4s9iht4+Za1YlSZIkqb46S8ucWeyGQs4cGg2GQ6qFXurc/dqHiyRJkiTV1WnHbyPHcEi1MH929YFi8ixJkiRJ9dU/ZnP8NhoMh1QL/Wmzy8okSZIkqb4cv40ewyHVgsmzJEmSJA0Hx2+jx3BItdCfNrvbvSRJkiTVV/+YrX//WA0vwyHVQi9tfvXstMmzJEmSJNWY47fRYzikWmgudIiA11457W73kiRJklRjvTHbNa+ccc+hEWE4pFpottrs2tngyst2mDxLkiRJUo3Nt9o0JoJXzU4bDo0IwyHVQrPVZvdlU+yemXLmkCRJkiTVWLPVZveM47dRYjikWphvtZmdnmJ2usH8WR8ukiRJklRX8602szNTzM5MMd9qk5lVd0kvk+GQaqG5sJo8n17ssLzsw0WSJEmS6qi50GG2GL+1l5KF9nLVXdLLZDikWliZOTQzRSacXvR1iJIkSZJUR93xW4PZ6amVYw03wyHVQrPVYXcxLbF77MNFkiRJkurodN+eQ4D7Do0AwyHVQnfNqsmzJEmSJNXd6p5DjZVjDbdS4VBEHIqIZyLiZETcNeD8r0TEF4pfT0XEUkS8sjj3jYj4cnHuxFZ/Axp+5zrLtNpLJs+SJEmSVHOZed6eseDKj1HQ2OyCiJgE7gbeBswBxyPiWGZ+pXdNZn4Q+GBx/duBX87Mb/f9MW/NzJe2tOcaGb0gqD959uEiSZIkSfXTai/RXsribdOu/BgVZWYO3QiczMxnM/MccD9weIPrbwc+vhWd03joBUHnJ89uSC1JkiRJddMbqzlzaLSUCYf2As/1Hc8VbReIiMuAQ8Dv9zUn8EhEPBERR77bjmp09VLm3tvK+tskSZIkSfWxMn6babBrurfnkD/cH3abLisDYkBbrnPt24H/vWZJ2c2ZeSoirgYejYivZeZnL/hLusHREYBrr722RLc0KpoL3QfJ7MwUV+xoMBHuOSRJkiRJddQbq+2emaIxOcEVOxuO30ZAmZlDc8A1fcf7gFPrXHsba5aUZeap4vcXgAfpLlO7QGbem5kHM/Pgnj17SnRLo2J+ZVlZg4mJYNf0lDOHJEmSJKmG5s+urvzo/t5w/DYCyoRDx4EDEXFdROygGwAdW3tRROwG3gz8YV/b5RGxq/c18KPAU1vRcY2OZmt1Q2roJtCuWZUkSZKk+umfOQTdcZzjt+G36bKyzOxExJ3Aw8AkcDQzn46IO4rz9xSX/mPgkcz8q77bXwU8GBG9v+t3M/NTW/kNaPj17zkE3bWrJs+SJEmSVD/za364Pzvjyo9RUGbPITLzIeChNW33rDm+D7hvTduzwA0vq4caec2FNjsbE0xPTQLFzKEFNzSTJEmSpLrpva1sttiMevfMFHPfaVXZJW2BMsvKpEuq2WqvpM7QnUFk8ixJkiRJ9TPfanP5jkkak904YXbaZWWjwHBIlZtvtVfWq0I3eTYckiRJkqT6cfw2mgyHVLlmq7MyJRHc0EySJEmS6qq5sGblx0yDM4sdOkvLFfZKL5fhkCo3KHle7Cyz0F6qsFeSJEmSpLXm12wL0hvLnXbf2KFmOKTKXZA8F7OIeq9IlCRJkiTVQ7PVXnnTNKy+ddrx23AzHFLl1s4c6gVFLi2TJEmSpHppDlj5Abjv0JAzHFKlMvPC5Hnl4eK0REmSJEmqk+ZCh9mZ8/eMhdVX3Gs4GQ6pUmcWOywnA5NnZw5JkiRJUn10lpY5s9hx5tAIMhxSpZrFpmXnJc+uWZUkSZKk2ultOn3+yg/3jB0FhkOq1PzZ7gPE5FmSJEmS6q03RnP8NnoMh1SpXro8MHn24SJJkiRJtbEyfusLh2amJmlMhOO3IWc4pEr10uX+h8vOxiTTUxMmz5IkSZJUI4NmDkUEu2emHL8NOcMhVao54OHSO3a3e0mSJEmqj94YbeD4bcHx2zAzHFKlBs0cgu4yM5NnSZIkSaqP1fFb47z2Xc4cGnqGQ6pUc6FDBOzaef7DpZs8+3CRJEmSpLrojdEGr/xw/DbMDIdUqWarza6dDSYm4rz2WZNnSZIkSaqV+VabxkQwMzV5XvvsdMNwaMiVCoci4lBEPBMRJyPirgHn3xIR8xHxheLX+8req/HWbLXZfdnUBe3OHJIkSZKkemm22uyemSLi/B/uO34bfo3NLoiISeBu4G3AHHA8Io5l5lfWXPo/M/PW7/Jejan5Vvu819j3zE43mD/rw0WSJEmS6mK+1b5gv1hYXfmRmRcERxoOZWYO3QiczMxnM/MccD9wuOSf/3Lu1RhoLrQvWK8K3eT59GKH5eWsoFeSJEmSpLWaC52B4dDumSnaS8lCe7mCXmkrlAmH9gLP9R3PFW1r/WBEfDEiPhkRr7/Ie4mIIxFxIiJOvPjiiyW6pVGw7syhmSky4fSir0OUJEmSpDrojt8uXIDUG9O5b+zwKhMODZoTtnY6x5PA92TmDcB/Bf7gIu7tNmbem5kHM/Pgnj17SnRLo6DZ6gycOdRLo93UTJIkSZLq4XRr/ZUfgPsODbEy4dAccE3f8T7gVP8FmdnMzDPF1w8BUxFxVZl7Nd66a1ZNniVJkiSp7tbfc6ixcl7DqUw4dBw4EBHXRcQO4DbgWP8FEfHqKHadiogbiz/3L8rcq/F1rrNMq71k8ixJkiRJNZeZG+4ZC678GGabvq0sMzsRcSfwMDAJHM3MpyPijuL8PcBPAL8QER2gBdyWmQkMvPcSfS8aMr3gZ6Pk2YeLJEmSJFWv1V6ivZTrvG3alR/DbtNwCFaWij20pu2evq9/A/iNsvdKsBr8bJw8uyG1JEmSJFWtNzZz5tBoKrOsTLokeqnyem8r679GkiRJklSdlfHbgD1jd0339hzyh/vDynBIlWkudB8cg5aVXbGjwUS455AkSZIk1UFvbDZo5lBjcoIrdjYcvw0xwyFVZn5lWdmFyfPERLBresqZQ5IkSZJUA/Nn11/50W1vOH4bYoZDqszqtMTBD5fdM4ZDkiRJklQH8xvsGQvdcZ3jt+FlOKTKNDfYcwi6a1nd0EySJEmSqrfR26Z77Y7fhpfhkCrTbLXZ2Zhgempy4HlnDkmSJElSPay+UGjwS88dvw03wyFVprnQXjd1hu6Mot6m1ZIkSZKk6jRbHS7fMUljcnCMMDs9xWnHb0PLcEiVmW+1112vCibPkiRJklQXjt9Gm+GQKtNsddadkgiuWZUkSZKkuth05cdMgzOLHTpLy9vYK20VwyFVpkzyvNhZZqG9tI29kiRJkiStNd/aOBzqje1cWjacDIdUmc33HGqsXCdJkiRJqk6z1V73TdOw+hZqx2/DyXBIldls5lAvOHJpmSRJkiRVq1li5QfgvkNDynBIlcjMzZPnlYeL0xIlSZIkqUrNhQ6zMxvvGQvdvWU1fAyHVIkzix2Wk1LJszOHJEmSJKk6naVlzix2nDk0wgyHVIlmsUlZqXDINauSJEmSVJnTjt9GXqlwKCIORcQzEXEyIu4acP6nIuJLxa/PRcQNfee+ERFfjogvRMSJrey8htf82e4DY8NpidMmz5IkSZJUtd6YbONtQRrnXavhsv7IvBARk8DdwNuAOeB4RBzLzK/0XfZ14M2Z+Z2IuAW4F/iBvvNvzcyXtrDfGnK9NHnDt5UVDxeXlUmSJElSdXrjt41mDs1MTTI1GY7fhlSZmUM3Aicz89nMPAfcDxzuvyAzP5eZ3ykOHwP2bW03NWrKJM87G5NMT02YPEuSJElShVbGbxuEQxHB7PSU47chVSYc2gs813c8V7St593AJ/uOE3gkIp6IiCMX30WNol6avFHy3DvvbveSJEmSVJ3emKzU+G3B8dsw2nRZGRAD2nLghRFvpRsO/VBf882ZeSoirgYejYivZeZnB9x7BDgCcO2115boloZZmeQZMHmWJEmSpIqtjt82jhB2zTh+G1ZlZg7NAdf0He8DTq29KCLeCHwEOJyZf9Frz8xTxe8vAA/SXaZ2gcy8NzMPZubBPXv2lP8ONJSaCx0iYNfOjR8u3eTZh4skSZIkVaXMnkO98+45NJzKhEPHgQMRcV1E7ABuA471XxAR1wIPAD+TmX/a1355ROzqfQ38KPDUVnVew6vZarNrZ4OJiUET01bNmjxLkiRJUqXmW20aE8HM1OSG181ONwyHhtSmy8oysxMRdwIPA5PA0cx8OiLuKM7fA7wP+GvAhyICoJOZB4FXAQ8WbQ3gdzPzU5fkO9FQabba7L5s49QZusnzn71weht6JEmSJEkapNlqs3tmimJsvy5XfgyvMnsOkZkPAQ+tabun7+ufB35+wH3PAje8zD5qBM232hu+qaxndrrB/FkfLpIkSZJUlflWe9P9YmF15UdmbhokqV7KLCuTtlxzob3pelXoJs+nFzssLw/cA12SJEmSdIk1FzqlwqHdM1O0l5KF9vI29EpbyXBIlSg9c2hmikw4vejrECVJkiSpCt3x2+YLj3pjPPeNHT6GQ6pEs9UpNXOol067qZkkSZIkVeN0q/zKD8B9h4aQ4ZAq0V2zavIsSZIkSXVXfs+hxsr1Gi6GQ9p25zrLtNpLJs+SJEmSVHOZeVF7xoIrP4aR4ZC2XS/ouZjk2YeLJEmSJG2/VnuJ9lKWfNu0Kz+GleGQtl0v6Lm45NkNqSVJkiRpu/XGYs4cGm2GQ9p2vRS57NvK+u+RJEmSJG2flfFbiT1jd0339hzyh/vDxnBI22714bJ5OHTFjgYTYTgkSZIkSVWYv4iVH43JCa7Y2XD8NoQMh7Ttmgu9aYmbJ88TE8Gu6Sk3pJYkSZKkCjQvYuVH97qG47chZDikbXcxM4egm1CbPEuSJEnS9ruYmUPQHec5fhs+hkPadhedPM803NBMkiRJkipwMW+b7l3n+G34GA5p2zVbbXY2Jpiemix1vTOHJEmSJKkaqy8U2nxbEHD8NqwMh7Ttmgvt0qkzdGcY9fYpkiRJkiRtn2arw+U7JmlMlosPZqenOO34begYDmnbzbfapdergsmzJEmSJFXF8dt4MBzStmu2OqWnJIJrViVJkiSpKhe98mOmwZnFDp2l5UvYK221UuFQRByKiGci4mRE3DXgfETEfynOfyki3lT2Xo2f7yZ5Xuwss9BeuoS9kiRJkiStNd+6uHCoN9Zzadlw2TQciohJ4G7gFuB64PaIuH7NZbcAB4pfR4APX8S9GjMXv+dQY+U+SZIkSdL2abbapd80DatvpXb8NlzKzBy6ETiZmc9m5jngfuDwmmsOA7+TXY8BV0bEa0reqzFzsTOHekGSS8skSZIkaXs1v4uVH4D7Dg2ZMhu/7AWe6zueA36gxDV7S957ga89f5qb/t2nS3RNw+gvz353D5d/8puPMVVyh3xJkiRJ0sv356cXLm78dln32p/7rePscPw2NMqEQzGgLUteU+be7h8QcYTukjR2v/Z7efPr9pTomobRxERw+O/sLX399+9/Je+6eT9nF91zSJIkSZK208QE/OTBfaWv/9t7d/PuH7qOM+45VEuPr9NeJhyaA67pO94HnCp5zY4S9wKQmfcC9wIcPHgw//1PvLFE1zQOLt/Z4P1vf33V3ZAkSZIkbWJ6apJ/e6tbDdfVr63TXmaO13HgQERcFxE7gNuAY2uuOQb8bPHWspuA+cx8vuS9kiRJkiRJqsimM4cysxMRdwIPA5PA0cx8OiLuKM7fAzwE/BhwEjgLvGujey/JdyJJkiRJkqSLFpkDtwCq1MGDB/PEiRNVd0OSJEmSJGlkRMQTmXnwgvY6hkMRcRp4pup+qBJXAS9V3QlVxvqPL2s/3qz/+LL24836jy9rP96sf7W+JzMveANYmQ2pq/DMoCRLoy8iTlj78WX9x5e1H2/Wf3xZ+/Fm/ceXtR9v1r+eymxILUmSJEmSpBFlOCRJkiRJkjTG6hoO3Vt1B1QZaz/erP/4svbjzfqPL2s/3qz/+LL2483611AtN6SWJEmSJEnS9qjrzCFJkiRJkiRtg1qFQxFxKCKeiYiTEXFX1f3RpRMR10TEZyLiqxHxdET8UtH+yoh4NCL+rPj9FVX3VZdORExGxOcj4o+KY+s/JiLiyoj4RER8rXgO/KD1Hw8R8cvFc/+piPh4RExb+9EVEUcj4oWIeKqvbd16R8R7i8+Bz0TEP6ym19oK69T+g8Vz/0sR8WBEXNl3ztqPkEH17zv3LyMiI+KqvjbrPyLWq31E/GJR36cj4tf62q19TdQmHIqISeBu4BbgeuD2iLi+2l7pEuoA/yIz/xZwE/Ceot53AZ/OzAPAp4tjja5fAr7ad2z9x8evA5/KzL8J3ED3vwPrP+IiYi/wz4CDmfkGYBK4DWs/yu4DDq1pG1jv4nPAbcDri3s+VHw+1HC6jwtr/yjwhsx8I/CnwHvB2o+o+7iw/kTENcDbgG/2tVn/0XIfa2ofEW8FDgNvzMzXA/+haLf2NVKbcAi4ETiZmc9m5jngfrr/AWkEZebzmflk8fVpugPDvXRr/tvFZb8N/KNqeqhLLSL2AT8OfKSv2fqPgYiYBf4+8FGAzDyXmX+J9R8XDWAmIhrAZcAprP3IyszPAt9e07xevQ8D92fmYmZ+HThJ9/OhhtCg2mfmI5nZKQ4fA/YVX1v7EbPOv32A/wT8K6B/41vrP0LWqf0vAB/IzMXimheKdmtfI3UKh/YCz/UdzxVtGnERsR/4PuBx4FWZ+Tx0AyTg6up6pkvsP9P9cLDc12b9x8P3Ai8Cv1UsK/xIRFyO9R95mfktuj8t/CbwPDCfmY9g7cfNevX2s+B4+afAJ4uvrf0YiIh3AN/KzC+uOWX9R9/rgL8XEY9HxB9HxPcX7da+RuoUDsWANl+lNuIi4grg94F/npnNqvuj7RERtwIvZOYTVfdFlWgAbwI+nJnfB/wVLiMaC8XeMoeB64DXApdHxE9X2yvViJ8Fx0RE/CrdLQY+1msacJm1HyERcRnwq8D7Bp0e0Gb9R0sDeAXd7UR+Bfi9iAisfa3UKRyaA67pO95Hd6q5RlRETNENhj6WmQ8UzX8eEa8pzr8GeGG9+zXUbgbeERHfoLuE9Icj4r9h/cfFHDCXmY8Xx5+gGxZZ/9H3D4CvZ+aLmdkGHgD+LtZ+3KxXbz8LjoGIeCdwK/BTmdkbBFr70ffX6f5g4IvF5799wJMR8Wqs/ziYAx7Irj+hu3LgKqx9rdQpHDoOHIiI6yJiB92NqY5V3CddIkVS/FHgq5n5H/tOHQPeWXz9TuAPt7tvuvQy872ZuS8z99P9t/7fM/Onsf5jITP/H/BcRPyNoulHgK9g/cfBN4GbIuKy4v8DP0J3zzlrP17Wq/cx4LaI2BkR1wEHgD+poH+6RCLiEPCvgXdk5tm+U9Z+xGXmlzPz6szcX3z+mwPeVHwmsP6j7w+AHwaIiNcBO4CXsPa10qi6Az2Z2YmIO4GH6b695GhmPl1xt3Tp3Az8DPDliPhC0fZvgA/QnWb4brqDiJ+sqH+qhvUfH78IfKz4YcCzwLvo/sDC+o+wzHw8Ij4BPEl3ScnngXuBK7D2IykiPg68BbgqIuaA97POsz4zn46I36MbFneA92TmUiUd18u2Tu3fC+wEHu3mwzyWmXdY+9EzqP6Z+dFB11r/0bLOv/2jwNHi9fbngHcWMwetfY3E6mxOSZIkSZIkjZs6LSuTJEmSJEnSNjMckiRJkiRJGmOGQ5IkSZIkSWPMcEiSJEmSJGmMGQ5JkiRJkiSNMcMhSZIkSZKkMWY4JEmSJEmSNMYMhyRJkiRJksbY/wcrdSTa3j0bMQAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2266,13 +2340,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "tal hits: [MotifHitAndCoord(motif_idx=0, motif_score=0.6470172153354097, precision_at_motif_score=0.3596704221616013, example_idx=9, start=91, end=116, is_revcomp=True), MotifHitAndCoord(motif_idx=0, motif_score=0.9985564582348262, precision_at_motif_score=1.0, example_idx=9, start=100, end=125, is_revcomp=False)]\n", - "gata hits: [MotifHitAndCoord(motif_idx=1, motif_score=0.9969703204925457, precision_at_motif_score=1.0, example_idx=9, start=20, end=45, is_revcomp=False), MotifHitAndCoord(motif_idx=1, motif_score=0.9975591077917395, precision_at_motif_score=1.0, example_idx=9, start=158, end=183, is_revcomp=False)]\n" + "tal hits:\n", + "\n", + "gata hits:\n", + "\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABHsAAACMCAYAAADsiaVcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3dd5xU1d3H8c+Z2V5YFhZY6lKlg1JUQMQSW2LFLvFRgxoLxhQTY9QIJkbzkJg8amKiUbF3IvZeQAHpRToCS98CbK8zc54/zmwZdhd2gd2dXb7v1wt27plbzsyZuXPu755irLWIiIiIiIiIiEjr4GnuDIiIiIiIiIiIyJGjYI+IiIiIiIiISCuiYI+IiIiIiIiISCuiYI+IiIiIiIiISCuiYI+IiIiIiIiISCuiYI+IiIiIiIiISCsS0Rg7TUlJsT179myMXYuIiIiIiIiIHJUWL16cba3tcLD1GiXY07NnTxYtWtQYuxYREREREREROSoZY9Lrs566cYmIiIiIiIiItCIK9oiIiIiIiIiItCIK9oiIiIiIiIiItCIK9oiIiIiIiIiItCIHDfYYY7obY74wxqwxxqwyxtzeFBkTEREREREREZGGq89sXD7gV9baJcaYRGCxMeYTa+3qRs6biIiIiIiIiIg00EFb9lhrd1lrlwQf5wNrgK6NnTEREREREREREWm4Bo3ZY4zpCRwHfNsYmRERERERERERkcNT72CPMSYBeBP4ubU2r5bnbzTGLDLGLMrKyjqSeRQRERERERERkXqqV7DHGBOJC/S8aK2dWds61tonrLWjrLWjOnTocCTzKCIiIiIiIiIi9VSf2bgM8BSwxlr7cONnSUREREREREREDlV9WvaMA64GTjPGLAv++2Ej50tERERERERERA7BQadet9Z+DZgmyIuIiIiINIac72D9P2DYNIjp2Ny5ERERkUZ20GCPiIiISK169oT09ObOhTTIv5o7Ay1XWhps2dLcuRAREakXBXtERETk0KSng7XNnYvDZ0zreB11yV0LH44EfxF4ouGKkqY9fmt5f40auouISMtR76nXRURERKQFyp5LZY98T1SzZkVERESahoI9IiIiIq1Z5lfgL3SPra958yIiIiJNQsEeERERkXBXng+B8kPbNuvrqsf+4iOTHxEREQlrCvaIiIiIhLPCdHgjGT4e1/Cxb3xFULitcfIlIiIiYUvBHhEREZFwtvxewEDeGtj9ScO2LdwC3pjGyJWIiIiEMQV7RERERMLZzvfcWDu+Qtg+q2HbFm0Ho+qeiIjI0Ua//iIiIiLhqnBrtXF2bMNb9hRtg4AGZRYRETnaKNgjIiIiEq6yvgYTUbVcsKVh2xduA3/REc2SiIiIhD8Fe0RERETCVcYX4MuvWo6Ibdj2+esBCzGpMOhOjd8jIiJylIg4+CoiIiIi0iz2LgldDpQ1bPui7e7viL9Cz6savr2IiIi0SGrZIyIiIhKuineELvtLGrZ9Sab72+0C97fXNYefJxEREQl7CvaIiIiIhCMbgNI9h7ePsj2Q2A+wbrnNgMPOloiIiIQ/BXtEREREwlFJBngiD28f5XnQ/ngXOAIIlB5+vkRERCTsKdgjIiIiEo4Kt7pgj/HC6V/AoN82bHtfIVg/tB0OEQmNk0cREREJSwr2iIiIiISjkt3ub49LIOVEGPJ7iEyq//Zl+8ATDW36gQlW+bwNnM1LREREWiQFe0RERETCUUkGBHzQ9Tw3ZXqgDFLG1H97X5EL8sT3rEo73G5hIiIi0iIo2CMiIiISjop3gb8YOk5wyxHx0PHk+m/vDwZ7Yjs3Tv5EREQkbCnYIyIiIhKOCtMhMhGiO7plTwSk/qD+2/sKAQORbRsleyIiIhK+FOwRERERCUdFOyC+l2vdUyG+R/239xW5MXqM98jnTURERMKagj0iIiIi4ag8PxjcsVVpUe3rv72/CKLbQ6DkiGdNREREwpuCPSIiIiLhyFcA8WluRq0KgbIGbF8IkckQ8B/5vImIiEhYU7BHREREJBz5CyG2K3gPNdhT5Gbxqt4ySERERI4KCvaIiIiIhCNfsZs23Rxidc1fEewRERGRo42CPSIiIiLNYMMGyMs7wAr+EojrFppmIup/AF9RsAuYOZTsiYiISAumYI+IiIhIE5s1CwYNgmHDoKCgjpUCJW6A5eo8UfU/iK8AImIOvWWQiIiItFj69RcRERFpQtbCTTeBzweZmfDEE3WsGCiDiLjQNE9k/Q9UngveOAV7REREjkL69RcRERFpQkuXQn6+e1xcDE8/XctKgXKwAResqc7U0SUrNdU9V/3ffx6DiPiGdf0SERGRVkHBHhEREZEm9OKLUFpatbxxYy0r+QpdK576DrCckVEzLRrXMsijYI+IiMjR5qDBHmPM08aYTGPMd02RIREREZHW7L33XBeuCpG19czyFboWOZ7oWp6sJy8QkQDGe+j7EBERkRapPi17ZgBnN3I+RERERFq9QAA2bw5NKyysZUVfoQvSHE6rHANEtjn07UVERKTFOmiwx1o7G9jbBHkRERERadW2bIGIYPwmLs4NrWNtLSv6Ct14O9Z/6Afz0LDZu0RERKTV0Jg9IiIiIk1kzRrXbWvAAMjJgfffr2PFQLkL9gR8daxQT+rCJSIiclQ6YsEeY8yNxphFxphFWVlZR2q3IiIiIq3Gpk1ucOa77waPB046CYYNq23NAHiPQMseTbsuIiJyVDpiNQBr7RPW2lHW2lEdOnQ4UrsVERERaTXWrXODM194IXi9EBUFV11Vy4rWBsfrCRz6wUzlfyIiInKU0e0eERERkSayejUMGeIGagYX7PnhD2tbM3D4rXIM6sYlIiJylKrP1OsvA/OA/saY7caYyY2fLREREZHWJzPTBXtMtQY3ffrUsqIN0KB7cp061fFEtdGfZ6bCSwZeUgBIRESktTvofJ7W2iubIiMiIiIirV1engv2xMdXpZnaelrZwAGm6qrF7t01d3jGmcGgUVBJRvDBYXQNExERkRZB3bhEREREmkh+vgv2eKrVwEpLa1vTctjVNOMJDfaIiIjIUeOgLXtERERE5MgoKqrZbctTa0zHENIFC1w3rJIMwANX1WOWLuMBDmM2LxEREWmx1LJHREREpAmUl7t/ycmh6VFR7q+1lqKyIrdQW6ucBnfD8kBAwR4REZGjkYI9IiIiIk0gNxeioyEhITQ9Otr93V2wm/gH4ynxlQRb5QTqGNCnnowHAiWHvr2IiIi0WAr2iIiIiDSBnByIjISYmND0inhOVlEWAJmFmYA5/PF2jAfK8g5vHyIiItIiKdgjIiIi0gRyciApCfx19KzKKqwW7DEesD7c2D2HyBMF/kIIlB/6PkRERKRFUrBHREREpAnk57tgT1lZ7c+7Fj0Vfz3gKwbjPfQDRiSCrzAYNBIREZGjiYI9IiIiIk3A5ztwy56Mgoyqv54I1yrHcxgTp0a2AV+RBmkWERE5CinYIyIiItIEAgE3Zo+1tT+fUeiCPZmFmeCNc61yTOShHzAqCfxFhz/2j4jIwdgArH8cFv8CSrKaOzciAhzG7SIRERERqS+/HzwHuM2WnpMOwLa8bRAR78basb5DD/h448BfQuVU7TGdqk3fLiICPXtCevqR2JMHuPlI7EjCUFoabNnS3LmQhlKwR0RERKQJBAIHDvas27MOgLXZa12wx/rBXwqeQwz2RMS57StM3A0vHcaAzyLS6qSn193asN4KNsF7Q8Bf7Ja9cXB54WHnTcKH0U9Hi6RuXCIiIiJNwNoDV5g35WwCYMOeDVUteyounsC1zGmIiHgIlB58PRGRw7HxCQhUGwjeX9R8eRGRSgr2iIiIiDQBr7fuwZkBckpyANiat9VNmw7BblhBE3c38IDBcX8OZ/p2EZGDSX8FbDkMuRdOeh2iOzR3jkQEBXukmeWV5DH6idHNnQ0REZFG5/W6rlwHElEx+5YxLuBzOHfII+KgdG9V4EhE5EgryYLiXdB9Igy6E7qdD2Oebe5ciQgas0fq4cgN3FabNsBCzE8ba//SVDRwm4jIgXk8UF5ee1euMn8ZAIlRiewr2UfABvB4o6Fs36Ef0BsHZXvAq2CPiDSS7HngjYERf3VdRwE6nlz3+qmpkLHfQPGdOsHuBrZcFJGDUsseOaiKgdsa49/zy1+AqYbFO5c02jH0r2n+NV5AUESkdfB6IS/P/d1fdlE2AEnRSUCwS5c3Bop2HPoBKwZ59hUffF0RkUNRsAliUiG6Y1WaOUB7gv0DPXWlichhU7BHmlXFNLOb921u5pyIiIg0roQEyM2FyFom18oocBc77WLbVS1746Bwy6EfMCLORePL9h76PkREDiR/I6Sc6ALLFbzRzZcfEamkYI80q/V71gOwad+mZs6JiIhI42rbFnJyag/2ZBZmApASl1K1HBEHxTtCp09vCG8cEICi7YeYYxGRg8jfAIn9wRvf3DkRkf0o2CPNaumupQAsz1juElJT3WAG+/9LTW3GXIqIiBy+5GQ3Zk9JSWh6IFAV7Gkf1x6oCPYkQOHW0Bm5GiIiAawPCtV6VkQaSeFWSOrvBiWrj06d6pcmIodNwR5pViuzVgIwb/s8l1BXn1315RURkRYuKQnKyqCgIDS9vLyqG1dKrGvZk1GQARGJUJgO2EM7YHQ71yoody0Eyg8j5yIidSjLhvhedT590zs38czSZ6oSdu923UsrWKvBmUUaiYI90mxs8ERvMOrGJSIirV5UlBucOScnNL2sDGatnwXAowsfBeDdDe9CbCc3Zo835tAO6IkEbyzsWwy+wsPIuYhIHQI+iEqu8+l/L/k3U96f0oQZEpEKCvZIs9lX4qaTTY51PxABG6i7GWdDm3cW74YvfwSzesHCKYc+3oGIiMgRFB8Pm/a7v+H31xy7bsOeDRDfE0qzwRdsChTw02BRbWHPAhf0ERE50qy/ztm3/MFzVpGvqClzJCJBCvZIs6mYgatLQhcAdubvrNm0Eyqbd1prWZ+9nkAgcOAdF26F9wbBro/dHdFNT4MvvxFegYiISMMkJMB337lxeipERUFeaV7IevtK9kFsF9eqJ2uuS/Tt1/+rPqJToHSPZuQSkUZiCOlqOjMVXjLwkpfv933fbLkSEQV7pKlVC+RU3MXsntQ9ZLkuW3K20P8f/Q/+w7HwZnecMc/ChdthwC9dZVdERKSZtWnjgj2F1XpVeTxQ6gttgVpUXgQxncATBTvfA1/RoU1nHBNsGbv24dB0a2HrG/DRifDJBMj4suH7FhHxeEPHBCupGGczwPLdyyuT9xYfPOC8NWcrWYVZRziDIkcvBXukaeR/D5+dDi9HwOtJsO5R1mWvAyAuMg4INlk/gK+3fh3yt1aF22D35zDuFeg+EeK6wuC7jsxrEBEROUwpKTVb9mzaBL6AL2S98kA5xKYCBra8CIFSSH+14QdMCA6cuuav8HafqvQFN8G8ayFvDexd5Lo+p3aqczbML76Aiy6CiRNhzpyGZ0NEWilPNJTUPsDy4l2LKx9XD/zUJe3/0uj4l45HLGsiRzsFe6TxFe2AD0dC/nrofxt0OhWW/ZbnVjwHwHvr3wPg+eXPH3A3s9a5wSvfXvd2SPqwx4eR9vc0t5A1B9oOgY4nVQ1oGRF/BF+MiIjIoRs4EFauhIjgEBfl5fDRRxYb7AYxpOMQIDiOXVx3d8fcVwhvtIP51zb8gAl9guNpWCio1oJ2ywsw/I8wMQsuyYZ+N0NGZs3tMzL42c/g3HNhyRJYtAjOPhvy8mquKiJHodhUKKi91f1XW76qfLw848DBnv1bN4rI4VOwRxrfoimQNBh+tBqGPwhjnofxb7gxeoASfwkA6/esP+Bu3lzzJgBvrXsrJH1l5kq25m51s3tlfAEpJ+L6D4uIiISXgQNdg5kPPnCte0pK4LnXXOQkJS6FlTevpE10GwBKItu5Fj2HI6577YMz95wEfa8Hb5R7fti0WidD+LDtFTz7LDz7LKxdC+vWwZNPuu5oItK6WQsbNrgAdXl5HSvF94K8dW5WLqjqOgrM3zG/8vHcbXMPeKxvd3xb+TizsJbAc3XlebD6z/DJSfDVebDrk5pjfoqIgj3SyPwlsPMDOPFpiEyEiFj3t8NJbjyCavaW1N2Xt6Kfb2q8a06eXZQNwPa87ZXrrMle4+4stD8eIuKO9CsRERGp2/Z34P3hrrvya21g0W1QWvN3rXdviI6GBx5wy6tWwbL17sKmIsiTGJUIQFbxPohse3j5iusGppbq3sBfQURC1XJEfM1JEqxl+oiXmTIFzjkHYmPdvwsuOLwsiUj4++Yb6N8fjj8ezjzTxYKLglX3/o/2Z+oXU91Cm2MgZ6VrgQgw0XXpygjGfiomYvls82cHPN6nmz6tfPzlli8rH2/N3Uq7P7ejzF/mEoq2wzvHuDHHOp0Osd1g3tUuAFSWC5uegzUPw+5PwR5kUheRVk7BHmlc2d+6JuRxPUKS/d64yibrXuMFao5XUN03W78B4NjUY0OW313/buU676x7x91V8FQbwLLajAAiIiIAE1+dyPMrDtx1uEE2/BsW3uImBJi4G86cB0U73ZTE+xkwwE21vmwZdOkCEyYACW5A07YxLrCTFJMEQEZhBsR1Oby8xXWruuNewRsDCb0PumlZmbvgu+kmN2V8hXj1jhZp1VaudN01f/Yz2LULtm6F11+HuDjIKMhg/d71TJs9za0c3wv2LKwxgPzLwYlwdxa4lvx7i/dSVFb3FOyvrqoak+yDDR9UPn584ePsK9lXVef/ZhJ0OQd+8BUMuRdG/AXOWQLbZsKsNBfkKUyHVQ+5mQhFjmIK9sgR9+n3n2KmGXJLcqE0G+LTajRD35G/A4C0pDR8v/cRHxmP3/opLi+udZ8Pff0QAB9+/2HI8osrX6xc55llz0BUW3eCDwQr2NVmBBAREdmau5X/rv0v//Pf/zkyO/QVw9JfwYS3Ie0KN/tj28Ew9jmI6VBj9d69XRAFICMj+DjetexpF9MOgOSYZCDYlSFp8H57MCHdJA4qrkfNoJMnNvSOdx03RvbtA68Xunat/+FEpOWbOhVuuw2uuw5iYiAyEsaPd889t/y5yvV25O2ApIHgL4Y9C6rq38BXtcR1Pvr+o1qPl1Ocw/o964mPdJHkl1a+BIC1loe+cXX+e7+4140Dum8JjHzEteL3RLhWifmbYPndcNZ8GP0POPZBmDCr1nOwyNFEwR454q5/53oAHpjzgDsRl+0DU60COTOVTa+7AZVTE1y3rA7x7mS8JWdLrfusPpo/wNLdS9lbtLdyZi6DYd2edexJGAzZ88BX4FasXiHOWwcrfg9zr4H5k2H1dCiuffYAERFp2ax1gwm//jq8/DJ8/rkLrDw458HKdVZkrDj8A2V8DknDIbFf6J3tOiYH8HqhR2hjV6KSXbAnJT4FgPZx7YFgsKfT6eCtti9PZGU3iXrxeF3wqTp/Edjap0quLjISfD7XEklEjh4ffQQ33hjaii8qygVf7v3i3sq0Z5Y944ZP8BfDghvdzV2fi/JkB88b3RK70TbatVqsPvxCdU8ueRKAwnLXFawsUMbinYtZsmsJAF0Tu7I6azXZu76C5BE1u2et+zsccyvE9wwOGxGnCVoawZtvwmWXua68F14Iv/sd7NzZ3LmSA6lXsMcYc7YxZp0xZqMx5reNnSlpueZum0t6bjpRniimz53OnpjesG9pjbuKm4N1zG5tugHQOaGzS8/ZXGOfJb4SSv2uZdCwjsMAKPWX8siCRyrXqegS9vzO7yHr66rjVa8QL7sLel8HY56BE56A1NNdpVlERFqVJUtg5EhYsACGDXNjTuTlwYbdO/nX4n8R5YkC4Jb3bqnc5vHH3Tg606bB9Okwf349x/v0F7uLi+q/cwfpQnz22S7oUyEQ64ItneLdDYqO8W7q4czCTOhwUuicAw1p1VOh02lUVvkiEt3sObs+rXVA1eqSkyEpyb2PInL0CARcsHd/zy9/nlJ/KZ7gOGD3fXEfARMFbYe7m6qfngzzrgFgVzAe88GPP2DqKVOB2uv5ALPTZwNuaIeKfX+w4QOufetaINilFfjf+Y+5m8jV6+8zU2Hbmy7oVDETr4ZxOKIqBuf+/nuYMQNeeglefRUuvtgFAWsoyYLV/wvzroWFt7luzvMnu3FcNZB2kzposMcY4wX+AZwDDAKuNMYMauyMSSNLTXXTgVT/l5pa/+3z1sH6f8Kq/4U1f3X/Vk/ntBmnAC4iDzD+5YugzQBYdmfVwG0XbGVD8KTRK7kXAN3bdAdg075N7G/RzkWAC/Qsv3k5x3Zy4/bM2z7P7a7/BVw2+DIAPs8PdhCeexWUF7jB2gC8cTDuZUjo5QaqNF5IPhai29f/NYuISIvwox/B00/D5MlugNE+feC88+A3X98AVP1GfbPtG277rbspcNll8Mtfwh13uO4Lw4e7n8Ya9v/9PPZS2PEFtXcXrr0L8aRJbqDjCrGdtwJuNi6AjnEu2LM9bzu06R+6ccdTAJiTPoeEPyXw3zX/Pfgb0mEcRAYHY7Z+6HEpLP+da+ET8MEF6bVuZoyrzN9zDxQWVqVXfywirc9JJ8ELL1QNyAyulV/FjVaP8WAwBAgwa90s6H2Nq2vvXQzb3sBnIT1Y1++d3Ju+7foCVXX3/X2/z03d/snVn/DYOY8Bbqr277K+A1wLfoDHNi3AFm6G3NUQ2G96sJ3vVV1rVGr6YRysheJiyM93sy22htjGO++4v7fc4sZtio93Ew0ceyykpMC8bfM447kz2Ja7zY1X9+Eo6HoejHoUhv8Bhv/Jda/rMK6OH1ZpLBH1WOd4YKO1dhOAMeYV4AJgdWNmTA4sYAOk56TTIb4DCVEJB9/gSMr6Br6dDOeudU01Az4w8OWOJZQGyon2RjOi8wjmbZ/Hmuw1ZP/ov6R8e5UbJG3AL6FgI6uC4xVUBHkqgj7r9qyrcbiKaP+oLqMAGN11NMsyllV24frjaX8kKTqJ11a9xudb5hC4/J94Ft0M7w2C5OFuJ4FSdycgsi1ExMCKqfDdNNc0/vKCWl9mwAbwB/xEeoN3D1JT3QAL1XXq5GYv2V9t6w5Igc9fDt79rXbmN143rlGbYw6+j7qOJ2HFWsve4r0kRCUQHRF98A1aEH/Az5JdSwjYACO7jCTCU5+fEWlp9hTt4Ztt3zCy80i6tmm8AVtmzoQdO9w03rGxrg6Ymem6Xw0aBN26gcfj7jJbC6Wlblaog92biI52le1AtXp+SXkZc9LnAHDHmDtYtHMRX6Z/yX8eT+BRXCsWz6F0bt8HLDfQ5RI46VXwRMEFm+HVumeFPOEEl8eCAjceRqd+2ymwhnaxbsyeim5c23K3uTel4wR3RzQiHtvlh5z74o94f+P7AEx8bSIndjuRuT+Zi6mrEp0yDoIBLiLiYdBdsPEpeH8YDP5dZbeL2tx7rxtU+txz4cEH3Xt6220weDBcdJEbzyc62nWR274d3noLfv5zOO64hr+Vddr6OuSshqT+EJUMeKA8H4q3u7+D7nRjdwSVlrr31hdsuOTxuM9XfHwt1xkBf7BbW8Ug1h7XOsDbus7d1QUC7iK0onue1+s+h4f0+ZcWJWADfJf5HVtytnBqz1NJjE6sdb1p0+CHP3TB8rPPdp+Ztd8XsXz3cgC+vf5b3l3/Lvd9eR+vrHqFiy54ClZOdd8lYH2ZC7MkRScRFxlHn3Z98Bova7LW1DhWQVlBZf3/xG4nVp4HP9zoxukc020Mz174LGc8fwbpuels7nIFvb+5AsY+D8kj4fxN8Fo8bHgcUs+ATqfAuWsperELk/8zgzNLXfA+MdH9juzb57r3duoEv/51tYzUVu+Gete9Z8+Gv/3N7bNLF3deLClx58haW780BmuhaJubCbLinI9x3Xkj27jrjYpWUYFy2P2ZmzkZqk6O1gIWUsa4VqC4GybgPgdlZVWvp6jIcsHM0/liyxcA9Ph7Dx4bMZFbo5LddU3FMB4zU6Ekg/IAfHz8u3y66VPOPeZcJvScQMT9f3QfuP1NvRvu/JnLp7Uuf95Y9zqq1z2Ld0PmV8FZJz1UXmNVbNPlh/Wapdlay5qsNeSW5jKyy0iivFWFVuYrI9IbWfdvbBirTy29K7Ct2vJ24IQGH+klA1eFhjYnPTSGl0rn12vzO/NO46GJnWDcSwfd79czHueknu/CKe+FpJtpNQvospxRvHpOJJw5tzItEIA/XXEPXc+6l9Qu0ZWf/XmrHuH+gttr7GP8a19yy70TuOKKqrR13y6n/19PhNdLQtbdd2YyyR/vC0nb2S6VLqfshpmh+/34jvM58ycTYOAvK9O2Z2yn+7+618jDx54xnHHltdD3xqrE4gweu/0RptxznKt8Gg9YyzfPP8O4z3/hKkfBF1fuKyPqj1EM+sdgJg2bxJ6iPTyx+AlGl7QD0kPeu+4R8FnSaPrt+gQ6jIWoNrD89/x25j/AA387+2/cPOpmrnvrOmYsn0GHXhdiNz0JC2+G3Z9AwMe6gkSMya/sxpWWlIbB8Oi+x8D+X8hre2/+6wAc3/X4yr9PLnmSovIi4iJiGdRhEAZXSd67/ESOm3g1y1/a5YI5mXMAw+kPfMQH8T8kqs9l7uTVcTwrtx/H0GOyaryXSfd7yNsvDN+/oCdrS2r+AEwfeQ2eP+cz9uTEykpSflYmP6hl3cDde/C06edOtAAzU/EXZeL1GrgytJvb/OkXcaK/lsr3wzX3+8b9D3LJmRvc9PbV1PZ5P9WXxhcRNe/g2n7U+B49+r87SSl9mysvKQyeJI374TjhdsgN3f6Oq/oCG2oec6rF7w+tQM595TXGvvcreGG/ftsTqfEdWNL7OP45/Emu+cXIygtBgMHTYoh5J3TQ7zdHpHHJ+TVf20BvJGv85UR63Em6zF9Gt6JObI/LoEtiF07oegLbcrexaNciRnjiWRIorGxGXB4op01ZIrlr82vkbfG0cYyc9BPo85PKtFJfKTEPxNTIw5uBCUzMjoJ/fhL6xIvUeN+fufc5Fu46j9t/nVz5vlnrKlz73x26+qFxvFA6l/q4t/Bk7r+wO4x9IfSJWs6h0+9ayLx1o5m532uu7TN1/r7RzHp2KeSEzvZTOiOK6ImrIbFPZeVVsFwAABufSURBVNryT+cw/D/nwauhH6Cxfebz6+kncNFFVWkffvk253xVc37nrLntSPk4dDrr3W07knpaZo0yWvHAKIZN+pUbNDdoX3YJHVJjKi8CK0y79kXyki/jnt9HYox7r/3WR4dHIzEY2se2p9RfSn5ZPuMDqczx1Kz41fY9+nD6VM4+eafrOlpNbe/lTflnkWam0WvUCURFuc97aSlcsdatmxCVgLWWwvJCTisZwOcxa2vsIwLAE8HIziMBN97ZmPy+zImvua7tB1y0G2KruvBMf+5efrP5jzXWze2WSJtL5kNSVcPeOe+sZnyNNeG0oXO54XdjufLKqrT0FWtot/piEi/4PNii0r1PF18cRXp66Bg2r75YwLZtCTzzTOh+j/tDW5YFcuHfVWldvPB5m+Ppf/W/3fS7xu36w/vvZvJtf+CMczty1lmuO8IL874gvyyfgSkDmX7mdFZnrWbwPwfzs8kXw9/g7bdh9GiIiIDN6eWM+SCKCwdcyD3j72Fv8V5u//B2bt7Rm9veudjdoaxWMY6OLKV04mR4q6e7yVCyGzAUdLiGx6fD11+74EP37jDjTIPnKstf/+rGxGjTBiIjNkK5rWzZ0yGuAwbDW1f+l4JzIWHYH12wJyqZKe+/y/tZLtAT7Y2m1F/K/O3zsS96MRdtrvqNAb78Em64ATZsSIG0q2DT0zD0Pjp0a8ecWZ8yIGsiLLkDsKzbNYD+aZk1yrPL4v589NKLXHbzKM4806V1bLuH3bvbh3xnAWLnnMizf7gDelxSmbZ2+1oGAP9Y8A9uPf5Wtudt58JXLqTtrq18H+fn3xNfpmdSTx5b+BiPLniU8THwP2c8yfUjrqewrJBJMyfxUNYqBlzwYNV+V0xlz7xHuf/tP3PK9T8jObuqXn/nLRu58Vd9mTy5WsYC5Vxzyss8+2SOu1gwEYDlu/deYsipE2DovdVfRq3fz2uyzmVGjVTY/lg3ul31DrSrim49ct8CPlp0PO+FVkNr3e+Eoj6cX3g3CcOuIy7Off7KyuD9x1/lB5Mv5fzzPZUftQ3z5jE2cDlcuDVkH8MfiCI7Kom7Tr6PpJgkHl3wKNkbdrI5fkfNDE+17NwJnTtXJW1em83f7vyMs396ecgYLQ//9gtOu+JUbq9W9fWX+/FeEVHjfHvG79rxaZQ7NxtMZff62s6Ls6dfz8lnd4OhUw/6/pzh68UnEbV3/dnfrdnn8tglHjcwb3W1/M7NfvrfnNz7HTilalZXAuU8eNXv+c2fBuONq3iDDPe9/iT3732lxvESHspj0bJE+ldrfLfw/TmMLr8GLghtqR4zzVC63/bH5fVnybZt8Hpofe/UAbO54d7xXHVVVdq2NZvpfk8fmBn6OkZOi2eJDW3NUle9ZfDUBFZT2w1Oi5lmQsrty76pzPjDP5l8/UUkJ7tA6RrfV/gu9TG041BGdB5Bckwy9315HzP/8gPuWpzAg7c9D3MmAh42Jo/Cbv2K3slu1r9ebXthjOHX2cfCgpvh+Mcrj74iYwUBG6Bn257ERrp6fZQ3ipSiKAoi4dpjr6Vf+35MGjqJP339J/qMfwK79B747HSI7gC+QmZ8dR3LC67lb9FXuhkIoztSWJrIW0su44lLXKCnwvrZn9KldBeJba/mxRddsLO8HH5cnMH+n8C5sScy6+Sf8uc1fwFPjAteWB+B42/HkxdaFhvbXkvZ2GcYOzZ0H7++9CV+8/O9dOiSXNnNbFd6Lr3O+AkloZeJnHbsYq771UiuvroqLXtfNh0eqTnQ9IdmHGddOQn63VyVuGchfHNFjc/f6kdPZ9A5V0HfaifGvUth0a1w/vdVaTNT+WppfyZklsETVdfo7ta5ZcIEuP56GDjQtVy6f95QlsSuCjnWlCUz2bPyXn6feAX0vx3i3SQBN6ztyX+8W+D7cwH4+7d/d3s9BvCXQbXgyvIXH2B42kqI6Riy79rOEVPpzX0/PAtG/7PyNVCSQV5xsN5SLdCzavYCBl8wBnJCW3wlTjUUEFqe3QpT2R5fs66XntKVHpe+6G7CVLyVu3Po2K1tjbrl6D8ksyiQU2MftZ0X502/lDHnjYMBPw9duXAbzOpRY/36qk+wp7YQVo2jGWNuBG4E6LH/yIPA14+lcdKk0F2dc2IvdoxJJLM0nxgflETAoCxIjUxidptcIgMQMBDth+7f72D9mmyO+SB0H5+dmMbp++23U+c+LL+uM8MLpruEko+h7FPu/D6FN5KzKQ0GGSP9MHRFJgvozPG597tE/xcEyudw7+s+9j0BbdtW7bddl+N5+7l4VsQX4rHg80D/bIjJXU/m5pFkZcRWXoyZ6FSeHnASF274DW3HXI7xF2MeK+G2BQP51W3nkDbghMr0NtPz+Ne68Vy24d6QdaNmfwOZadBtqyuGdQ/TftUj/HRLEr3X5zJ8N+yNgxWdIKsgHX7/U+CnVRnuC1P+NgB6POCWg61ZYgLH8dWSNIZGfULblGSMvxjfy1H0KIpgdfZq7v787spd9N7YiS+AcVshphwKo6DPXnhxUSJT7zkTugBRgB/uu6QveRvaccnxt4C9hUei4OKesChtAvSeDXFAHyAfHovvSeZxPbhw8MVgYbIXevSGO8+dwA09nqR3SjKe7H3Y5Bj+7M1my9o0Lr//JgjcxDUe6NIH9vbszHHLduG5xxXovPbwbdwqdnkvgiGzoCPQsRjSYXzqnURdsBS6LYW2QAA6Faew4rIUhqU85V5szizIe4cHVnXmu6Jd9NsDseWwvBN0L9jLk7eeysXX3RVSRn+/4Tpm/DyRMWOq3vbigkT+9dPxXHb93bQde2Xlun+e3pe7/tAfeneDNglw1h5MlOX9mQP54Z6bITIGouZB9Ld4S0by9SM3Mmj0WSHH+/YfPThhv8/7cef1gjNPqUoIlvNZmXF81KGo8hscWwbD13qJ6NGG3II8YnxQHAF99sFXH6YxYb/9Xvf7eBImPws9bnK16P92hpIM8ssjSSS06eyE70r4K9CxAKL8UOaFoRnQf8AUXp18Hl2GVnWXy8mN5/VhJ3D6hqdDvxsLx3PLZxfT//JplWW/9uz+bNs4snIGiAo39B7Nzz46n669j63cx6DJuZy9Op7vTaE7n0RC91wYXZjA+sH7KK+W58E78inuYdjJTv67tqoLxDlLolk5pJDyCD/+4Pgbx28t5l99x3PJurtoN25SZX7XP7KZkfdNBqp+OKOAm37chvY78jhuF+yLhdUdoKQ0n9k3nMyQX/w65DV/9kE/Ti+5HRKSAQP+L1i28CLihyaHVB4BftD5Jd7713hSe8dWXtQcG3M5WzNXk1mWQ0y5e82DsqBDZBs+6JCHNe4cmlAGScszWeqN4LhtU90OA1+C/YpPH03jB/uV/aROnYkYfBnfTOpXce0MwEOBY4jevJ6x28BYmNcDIiN2UezzEkvoL9ynj6fyo2v7hqR1atuR5345lnM3/CLkfUi9+0vSF6SxoV9b99qAiPJenLQ3keVx+XgtlHvduef2gf351ZRz6DnwxMp9JP4l351D199D27FXVO53zSO7GHb3lUBV1CGaWEZ3eIu574wgNqGqL/+G7OPp3SOS5OSq/Jb5AxyXG8/SpEKyi7MB8ATg2DUJeLslkV+Q675HkTAwC+Z+1IOx+72XPUYOYG/3frTrGqw0bfkPbH2Ka7cl8V67XAIG/AbalsDaNy+j609P4PLLQ8v+tVs7MrNjJgVlwUq6hb4bC8lNi2V9VDFRPvf+HLsbkr3xzOpeyLc7vq3cvuu2XAZ0i2ZtfCkeCwEPDMyEDz7owTmTQpvInNajEz8/tT2nzt9Dn72wKwHmd4Ovytpy3vWhg/wOSXQ/kLNve919RoJRsqSCTexY3o/NI5MqPzyleaXERxW4ViWeyMrz1CuneylO68Oc9gMJJLXDGkPXwizuGLyAhfH9KUrtDVHRmPJSfjZuMO8XzyXSDzE+yIqHY33Q//JNkNgXIhIq9zsgAp7q+wFR0yJIn5ZGPpH82LOboRf35ayP1sAUwyBgbjdo1/NjAAZcNIC1dKWcSGIis0n6jZe31r7FW2vfqnzNmzZ6+GhZF0YnV/1+mpcMd3U5BcZ9CUlA2lwohPWl/Til4K/8aXo5L78cSXS0m774s1vg9EmGa4CBjKZH5lbWPhfFjtEDuXjo5WAv50oPtO8DC3qPISEx+NnpDuRt4ydtv2D4+H5c/voGkkpLKYyEj/vAbWefxK2dZ5KaNqQyb/2+68rk8lFg3oZIoBewYQq39nuKAeOWghfoD/ggZWcGT/9iJBceG/raZj4LEz8ezfdEMpexGCzjyr5m3sAYlppj2Ne+LzYmFlNawuOTDL9evJy+ZUmV30/vdHd3ecoHU5jywZTK93LS+jZ8dkweZ71wVsjnak4JzHvrBsaedQNvHwOzzoS1809n6uszuKLgGuiUAsaQcUIqbyy7nv/bL+D031ey+fr305j/RDKByGgwHtp02sSzd66B/t9VrbhiKmX5e3j3/gWcGzsOIjzQZyv02srV25J4pUsuPo/7CMeXw0kZK912vkLAwHd/hNUPUpTVFjJWQFTwYmztw1zc4VWKCn/M7MkDMdWqzL8r68MHcd8TMO48FzDg/fAWdl1yHdOr3asDmDalH9d09dCx2rWOHd6L5ddEMfyi0PPMsKsTeaFPNrd9eFtl2oCiBAb5IlmdVPXb164I7h0zkC0njWBrt64EMGA8LMntxtfmVh75YWgeZuybyd7Faaxe2ImKL3PAb/m673guXv0b2p/8P5Xn21M3JjHPl0OhN1AZMDhhG6wsSGVozycgPgUyX4Ws10gsH86W2Xvpuc8Nykvu25D/LhftiufDlEL8wd+u9sUwYLNl9TGR7Igux1iXi1E7YURRGz5vl+fOaQbiyuGEnaspzulFbMEOdz5a+1dY9zCfP5rGafudmzt368PaIbEMOLVaejTc9TTQy1fVImHFVH5QPpvNu5NJSt9HjxzYkQTFXijp/iBfP3Ypeyd0AGsxxlCwx5Ll99Jh91L3nm36N2x5gj+t7cyisl10KoDIAGxpC8Ozs3h6/Nga1wop93zFjsV92TAsufK6oigvnvePGc+lG+4JWffK9xLZ3K2QfXHud9lYmPB97fWWe97uws6t6zlpK7QphWWpsDoFKsL7FeUWVwalb+ymf9TP2L3nUubtGUMxsYzwzGfWqr6c9fBKuMXQC5jfFZaVvIAp+gQeeh06AMnwow1f8eSlAzjjb0vhJkM0sCAV0rtn8eEx/Ti+XdV5ZszscTyzvAsnf7kFfm6IBBZ2gvn9kkjoksRl9/8UAj/lnggY2wsW9hoPx30D8UDvrVAMJ2ycx96+++ClndB7JyRCh+3w5skeMtr0ZnFsP/xJ7TABP08WnE/3W6/mlzeEft5vWTyeKeddSGra0Mr3eNhfVjB25AYY+EBoXdgXSdJ+deGflM+gf+A1lpl+7E3qhT86Dk9xIdP/NQuO3VIViF8xlYT1f+XEdh2Z++YIvJFVd0SH+P9C5ms38o3pGfzOuZuUk7a3hz17SMuBgmjIiYE9eaVsXfECPd6sGnsOA48NH8+UR3pCh3YwKAP67iR37wl8+8/3OaHDHLfbtsug7XL+8oeTueO+NtA91TVFOieb5PiOfHrCWEb8+v6QzxqTYOGyCJZNOZY9tCeZYu4cFkHJcYO49MXVxPpgTyx83gtWFX0Jp82BtDdcOfng0svj6Lm5MxPf3UWnQtiRCJ/1gt/knMyN3Z8KufaL3/0Urz7Xl8uTRkJsDPTdBr238cf1nZhnM0gqdZ/1PXFQvqacf81az02R7aBzRzg/G2Lgqydr1ls6tkmh2B9BLGUh6X/5oh155Xs4cTvE+uDbLrA3roBNvRNpvyOfgVmwOxF2JsBsj5cf77wXBp0cvOnzFbFlCxnf4WW+eW00EVEVrYsMk9cPIsE7l9xod31UGgHDMmDRxz0Ytd85KXLYCNLnbydt5i9C0gNXpuJ56dD7Ahp7kI6ExpgxwFRr7VnB5bsArLUP1rXNqFGj7KJFiw45U+HC73dN/crKXMuE6GgX/GlRLbisdTNTleW4JsrG6yrEUcm1vpB9xfv4w+w/0D+lP9cfdz1ej5eePSG99u78IpXS0mDLlubORcP4Aj7mbZvHkI5DSI5NPvgGIo2sqAh27arqguT1ui401QfzrY/dBe5uVMWMh42mohlUS1fH63h11atc8YZrGbbiphUM7TS03rs87TQ3bfGll7ouMked6l0CjMFMrXrqx8N+zPMXPc+yXcs47gnXIuaXJ/6SP5/xZ4Y9Pow12aFdPT7/n885tdeptR7GWjeGUEUr0oppomuslDXHTc9MABdq8bjHPa+sGtS1Pq/pCH/e/X5Yswa2bSPkrvCZZ7p6Z30VlBVw07s3sTV3Ky9MfIEeSTVvvB5MIODOPX6/O+fExbWwOu+RUlF3DpS5VvGeGIiIPfh2LZTq+VIfLbGe35oZYxZba0cddL16BHsigPXA6cAOYCFwlbV2VV3btJZgj4iIiBxAKw/2HI4hQ+Dhh+EHPzhKx0LZL9iTVZDJ0MeHcuOIG7n/tPsrVwvYAIFAgAiva2w+O302E2ZMIDYilmJfMb3a9mLT7TUnb2gWreXzLiIiLVp9gz0HrX5Ya33AFOAjYA3w2oECPSIiIiJHuz//GX77W9diIz8fcnJcq4lWrfpMZRWCjzvEd2D3HbtDAj3gZvWpCPQAnJx2MpOGTqLY596sd696FxEREWm4g7bsORRq2SMiInIUUPt/qQ+Pp2rqp3rYlb+LLg93ISk6iZzf1hzcstmoZY+IiISB+rbs0Zy5IiIicmhaSwd+Ba0aVyDQoMFfOlMxHHAu3BVGg8akpR18HRERkTChYI+IiIgc3VpL0EpEREQk6GgcMlBEREREREREpNVSsEdEREREREREpBVRsEdEREREREREpBVRsEdEREREREREpBVRsEdEREREREREpBVRsEdEREREREREpBVRsEdEREREREREpBVRsEdEREREREREpBVRsEdEREREREREpBVRsEdEREREREREpBVRsEdEREREREREpBVRsEdEREREREREpBVRsEdEREREREREpBUx1tojv1NjsoD0/ZJTgOwjfjBpCiq7lknl1nKp7FomlVvLpbJrmVRuLZfKrmVSubVcKruWqa5yS7PWdjjYxo0S7Kn1QMYsstaOapKDyRGlsmuZVG4tl8quZVK5tVwqu5ZJ5dZyqexaJpVby6Wya5kOt9zUjUtEREREREREpBVRsEdEREREREREpBVpymDPE014LDmyVHYtk8qt5VLZtUwqt5ZLZdcyqdxaLpVdy6Rya7lUdi3TYZVbk43ZIyIiIiIiIiIijU/duEREREREREREWpEmCfYYY842xqwzxmw0xvy2KY4pDWeM6W6M+cIYs8YYs8oYc3swvZ0x5hNjzIbg3+TmzqvUZIzxGmOWGmPeDS6r3FoAY0xbY8wbxpi1we/eGJVd+DPG/CJ4nvzOGPOyMSZG5RaejDFPG2MyjTHfVUurs6yMMXcF6yvrjDFnNU+uBeosu+nB8+UKY8x/jTFtqz2nsgsDtZVbtefuMMZYY0xKtTSVW5ioq+yMMbcFy2eVMeZ/q6Wr7MJAHefKY40x840xy4wxi4wxx1d7TuUWBg7l2ruhZdfowR5jjBf4B3AOMAi40hgzqLGPK4fEB/zKWjsQOBG4NVhWvwU+s9b2Az4LLkv4uR1YU21Z5dYy/B/wobV2ADAcV4YquzBmjOkK/AwYZa0dAniBK1C5hasZwNn7pdVaVsHfvCuAwcFt/hmsx0jzmEHNsvsEGGKtHQasB+4ClV2YmUHNcsMY0x04A9haLU3lFl5msF/ZGWNOBS4AhllrBwN/Caar7MLHDGp+5/4XmGatPRb4fXBZ5RZeGnTtfShl1xQte44HNlprN1lry4BXcCcMCTPW2l3W2iXBx/m4i86uuPJ6Nrjas8CFzZNDqYsxphvwI+A/1ZJVbmHOGNMGOBl4CsBaW2atzUFl1xJEALHGmAggDtiJyi0sWWtnA3v3S66rrC4AXrHWllprNwMbcfUYaQa1lZ219mNrrS+4OB/oFnyssgsTdXznAP4G/AaoPmCoyi2M1FF2NwMPWWtLg+tkBtNVdmGijnKzQJvg4yRcPQVUbmHjEK69G1x2TRHs6Qpsq7a8PZgmYcwY0xM4DvgW6GSt3QXuQwl0bL6cSR3+jqtABaqlqdzCX28gC3gm2AXvP8aYeFR2Yc1auwN3Z3MrsAvItdZ+jMqtJamrrFRnaVl+AnwQfKyyC2PGmPOBHdba5fs9pXILf8cA440x3xpjvjLGjA6mq+zC28+B6caYbbg6y13BdJVbGKrntXeDy64pgj2mljRNARbGjDEJwJvAz621ec2dHzkwY8y5QKa1dnFz50UaLAIYATxurT0OKERdf8JesO/0BUAvoAsQb4z5cfPmSo4Q1VlaCGPM3bgm8C9WJNWymsouDBhj4oC7cV1JajxdS5rKLbxEAMm4bia/Bl4zxhhUduHuZuAX1truwC8ItiJH5RZ2GnDt3eCya4pgz3age7XlblQ1I5MwY4yJxH3YXrTWzgwmZxhjOgef7wxk1rW9NItxwPnGmC24bpKnGWNeQOXWEmwHtltrvw0uv4EL/qjswtsPgM3W2ixrbTkwExiLyq0lqausVGdpAYwx1wDnApOstRUVXZVd+OqDC44vD9ZVugFLjDGpqNxagu3ATOsswLUiT0FlF+6uwdVPAF6nqruPyi2MNPDau8Fl1xTBnoVAP2NML2NMFG5Qobeb4LjSQMEo/VPAGmvtw9Weeht3wiD4d1ZT503qZq29y1rbzVrbE/f9+txa+2NUbmHPWrsb2GaM6R9MOh1Yjcou3G0FTjTGxAXPm6fj+lmr3FqOusrqbeAKY0y0MaYX0A9Y0Az5kzoYY84G7gTOt9YWVXtKZRemrLUrrbUdrbU9g3WV7cCI4G+gyi38vQWcBmCMOQaIArJR2YW7ncCE4OPTgA3Bxyq3MHEI194NLruII5vlmqy1PmPMFOAj3IwlT1trVzX2ceWQjAOuBlYaY5YF034HPIRrsjkZd5FzaTPlTxpG5dYy3Aa8GAyGbwKuwwXiVXZhylr7rTHmDWAJrhvJUuAJIAGVW9gxxrwMnAKkGGO2A/dRx/nRWrvKGPMaLujqA2611vqbJeNSV9ndBUQDn7h6MvOttTep7MJHbeVmrX2qtnVVbuGlju/c08DTxk3rXQZcE2xRp7ILE3WU2w3A/wUnkigBbgR958JMg669D6XsTFXrVxERERERERERaemaohuXiIiIiIiIiIg0EQV7RERERERERERaEQV7RERERERERERaEQV7RERERERERERaEQV7RERERERERERaEQV7RERERERERERaEQV7RERERERERERaEQV7RERERERERERakf8Hq33lwtgHYaMAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2291,19 +2367,7 @@ }, { "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2315,7 +2379,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2329,13 +2393,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "tal hits: []\n", - "gata hits: [MotifHitAndCoord(motif_idx=1, motif_score=0.998810229513942, precision_at_motif_score=1.0, example_idx=10, start=134, end=159, is_revcomp=False)]\n" + "tal hits:\n", + "\n", + "gata hits:\n", + "\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2354,7 +2420,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2366,19 +2432,7 @@ }, { "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2392,13 +2446,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "tal hits: [MotifHitAndCoord(motif_idx=0, motif_score=0.5891716112073493, precision_at_motif_score=0.18046493206611938, example_idx=11, start=125, end=150, is_revcomp=True), MotifHitAndCoord(motif_idx=0, motif_score=0.9986918443818005, precision_at_motif_score=1.0, example_idx=11, start=134, end=159, is_revcomp=False)]\n", - "gata hits: [MotifHitAndCoord(motif_idx=1, motif_score=0.9971011527533985, precision_at_motif_score=1.0, example_idx=11, start=87, end=112, is_revcomp=False)]\n" + "tal hits:\n", + "\n", + "gata hits:\n", + "\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABI0AAACMCAYAAADx21mCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOydZ3hURReA37ub3guB0EPvvTdBEJAiKCggNlBRPkUEu6ISBBvYQBQEURDp0qV36b0HQkKAhEASQkJIz5b5fkx2k5ANJCSQoPPy7MPdm9m5c++des6ZczQhBAqFQqFQKBQKhUKhUCgUCkV2dMVdAIVCoVAoFAqFQqFQKBQKRclDCY0UCoVCoVAoFAqFQqFQKBS5UEIjhUKhUCgUCoVCoVAoFApFLpTQSKFQKBQKhUKhUCgUCoVCkQslNFIoFAqFQqFQKBQKhUKhUORCCY0UCoVCoVAoFAqFQqFQKBS5sCvuAtyOUqVKiYCAgOIuhkKhUCgUCoVCoVAoFArFv4bDhw/HCiH87pSuRAuNAgICOHToUHEXQ6FQKBQKhUKhUCgUCoXiX4OmaZfyk05tT1MoFAqFQqFQKBQKhUKhUORCCY0UCoVCoVAoFAqFQqFQKBS5UEIjhUKhUCgUCoVCoVAoFApFLpTQSKFQKBQKhUKhUCgUCoVCkQslNFIoFAqFQqFQKBQKhUKhUORCCY0UCoVCoVAoFAqFQqFQKBS5UEIjhUKhUCgUCoVCoVAoFApFLpTQSKFQKBQKhUKhUCgUCoVCkQslNFIoFAqFQqFQKBQKhUKhUORCCY0UCoVCoVAoFAqFQqFQKBS5UEIjhUKhUCgUCoVCoVAoFApFLpTQSPHg4+8Pmpbz4+9f3KVSKBQKhUKhUCgUCoXigcauuAugUBSa6Oj8nVOUSIQQAGiaVswlUSgUCoVCUZI5eBDWrIEGDaB//+IujUKhUPw3UEIjhUJRrOg+06HX9Bg/NRZ3URQKhUKhUJRQ/v4bBg6E1FRwcYF9+2DiRGlgrlAoFIp7h9qeplAoih2TMBV3ERQKhUKhUJRQYmKkwCglBdzc5P/TpimBkaLw6Mfpcf3CtbiLoVCUaJTQSPHgU6ZM/s4pShwmsxIWKRQKhUKhuD1TpoAQ8PvvEB8PJ0+Ck1Nxl0rxb8CMmRRDSnEXo9jZELqBLnO6FHcxFCUUJTR6ULHl/Pm/6gA6KkrOJCwIIc8pSjxh8WHW48T0xGIsiUKhUCgUipLKrFkwZAg89RTo9VCjBsydW9ylUjzoKOVlFl/s/IKtF7diFubiLoqiBKKERg8qeTl6Vg6gFSUAo8mYr4H4VMwp63HQtaAiLYPBAIcOQVDRZqtQKB50lNJFcZ+p9H0lpcEvBAkJcP06fPghuGbuInJwgE6dirVYin8B5+PPW49jkmOKsSTFT2h8KADn487fIaXiv4gSGikUiiLHfoI9Hl953DHdiegT1uPsAqS8eHX1qwxfPfyO6Y4cgdq1oXNnaNECuncHk1ImKf4F/HzwZ7RxGkazchx/1yili+I+E3Ezgq0XtxZ3MR5YTpyAypXBzy/neYOheMrzwGNLcP4fFZofjzpu8/i/yJXEKwAcunKomEuiKIkoodGDSl4+e5QvnwcCIQSO4x1ZfW51cRelyDGY5CwuP/vD90futx4fjTp6x/QzjszglyO/3DZNTIwUFhmNMG4cjB4N+/dLc3aF4kFn28VtAByLOlbMJXmwcPnchV8OZ/YdxTR+auM0mkxvck+voSh5xKXGWY9F9q309xnLzv24uDunLWmcOSMVQWlpOc+7FoXv4gfU8vC7Pd8xZMWQfKWt/3N9tHHZPIbbEpD/R4Xmh68eth4fj/7vCo2yz9l3R+wuxpIoSipKaPSgYvHjo3z53HOSkyEiAjIyii7PkLgQMswZzDk2p+gyLSEcuXrEenwnwVH2gWnf5X23TZtqSLUepxnT8kw3dqzUSJ46BSNGwEcfScsjheLfwNYwaa2w7cK2Yi7Jg0NUUhSpxlRmHJqReeL+j5+W/utYdNEL+6KiYOVK2Lbtv2FRmZwMU6fC0KHw1VclXwiyJ2KP9Tj4enCxlOHAAWjYEAICoGxZ6NbtPteVQgpmkpKkldGtyp8iUQY9oJaHb296mznH8zeHPH3tNABJGUnyhAogY2V3eNY89N8oLBFC5EtYnd3KalXwqntZJMUDihIaKRR5cPOmnJSWKiU1XH5+cuJSFKwNWQvAhvMbiibDEsTWC1km+Hsj9uaZLtWQys30m3g4ym1s2bU9tsg+8c5+nB0hYOlS+PZbcHEBe3v5fwlXGCoU+cJgMhCXJlfIf5z4o5hL8+CwIVT2s0eiik96/M+lf6zH2QXghcFshlGjoEoVePttePppqFSpaBUc94J3N75LjR9r3NVvz56V9/jjj3I8XrDgNluUSogFSXYB767wXUWa9yN/PEKLmS1um+bMGWl9W7cu7N4NGzdKi537an1bSMGM2Sxf3T3hAbTcz749OeR6yG3TZu9vtl/cLg8KEkDmX76VbVdEVpv856Lsp4WA1atlu6lXD156Cc6dK64SFo5WM1uh+0x3R8HRwSsHAfBz8SPiZoRyEK7IhRIaKUoER64c4UL8heIuhhWjUQ4Wly5JDV1MDCxaBG5uRZP/jMNS452UkZSl+fmXsOzsMuvxlgtb8ky38fxGAG6m37Seszjf23d5H9o4jdC4UOvf1p9fbz22LAJvJTxcLpg6dMg5IXZxkf9fuwYzZsD48bBwodRYK0o+ZjNs3w4TJsDEiTLU8n8Ri58BL0cvTsWcUn6N8sncE1khlqKTisd6IPtW5J3hO4skz88+g3XrYM8eaVl54QK89pp0EFyS+WbvN4TGhXIj7UaBfmc2w6OPwsCBcOyYjKa1d2+JXtsDsOLsCutxUSqKhBBsubCFQ1cO3XaBN3KkFCjOmgXNmkHHjrLe3FcKKZhxdpbOsO+JdZQtAUoJt9zffzlra79FCZkX2fsbZUGSk4vxF3N8j0uLIyH1JsOGSYF8t27w+efyb56e9798RcHBq1IYZBEK5cXqYDlGlXcvD+TPz2hJwGiUCoRi3Pn7n0EJjRTFjsFkoNnMZlSdUrW4i2JlzRopfFi9Gho0kPvmH3mkaPJONaRyJvYMpV1LAzktcx50jGYjh64cwtVeOhpYdGpRnmlt3fe6UDmT/XbPtwD8uP9H69+y57XotO18Y2OhYkXbmueffoL69eH8eTkB3bmz6CzHEtMT0cZpfLTlo6LJUGHl6lWp6Zs0SS6GMzKkBWB8PBB3BE6MhX0vQ9BEuHl7jWt+MZgMaOM0az0sKaw5twaA2n61ATh85fbWeQoZTnnLhS242UuJv0VYfb/5/djv1mPL5LwwpKfDN9/A4sVyjHJykv3am28WOuuiJf06JJyFjHggp9BuadDSAmX1zz/g6Cjv29kZPDyyFAI2KaAwQAiBNk6j7ay2BSrX7UhMTyTsRph1TFxxZsUdfpF/si8CLb7ObiUpSY51EybkVHoViS+gglDILaHVqkFICNjZ5TxvGcO/2vkV2jgtX1Z8JrOJ+NT4/Ja8RLIyeKX1+E5b1LL3N9n7oXxTEKukB4zsz9HCpD+PsHWr9IU5ahQ8/jhMnlzyhdO2uHTjkvX4j+O3t062OOoPipUhh386+NO9K1gRcOoUdO0KVatCmzbSLUVi4r29pseXHjl9g/3HUEKjB4R0Yzplvyn7r/Rj8VfQX9bj7B1ccfLHHzB4sNzeZOHWycrdMu/kPAAc9Y4AJW5hWhgWnloIQLopHQ2NsBthxKXYdjgRnSwXD052TtZnEZkYSaohlb/O/IWGxpQDUzCajYQnhBNxM8L620sJl4hIiMiVp50dpKTkflf798N338HRoxAYCO+8A19/XXSTgOmHpwPw5a4vi9XR6b+Rp56CAQPk4vidd2TI5R3bTXiffhqOvAN+7aH2SHCvCY7eRXLN+SfnA/DupneLJL+iYvKByUCWE+zx/4wvzuI8EFgWBZZtsN/s+ea+l+HY1WOkGFKsgoOZR2YWOs99+6BGDahePWd/V1TWsIUmejusaQgHhkPodNj3IqTHsuDUAmuSibsnFijL7dtliHWzuUhLamVT2CYA9l7ee1u/eQXBYuWWbJBmrUZhzBE1tDDMOjLLejz90HSbaS5dgnLlHkAriVu2RDXqUZaQk2l5Whp9tFUqbH47+tsdsx61fhQ+E30IuhZUlCW+r1jet6u9K0ejjuY5z4Ks/sbF3gWj2cjByNtbnPybMZqN7L+83zpPOxB5AAAnfdY8dMFvPgwbBu7uUhgPJahfLSCWOTlIIZBZ2O48r9y8Yv1bhknuby4qi9h7gWXL7ciRctvg7t0QFCTf2b0iOimaxAwplcruB+u/RJEIjTRNe1TTtGBN00I1TfvAxt81TdOmZP79hKZpTYviuv8lvtj5BVHJUTy24LFiW5QKIeg5ryd/nvizSPN9a+Nb1uOvd30tD4p5D3VsrHQYeS/M/L/b+x2AVQiyM3wn5ns1C77PLDm9BAANDS3TAcH8U/Ntpo1NiQVgxcAVTOs1DYBrydes2o2avjUB+P3o79btfNmxda5GDbh8OdMKJRvffw8vvyz9Ujk7y3N3Owko9205tHGadVuhwWTgvU3vWf+e3XeJonBcugSnT8OYMVIzrtPJbYeu0XPAkAidVkPZruDVEMr3BsdShb6mWZgZsnIIAAKRp/+s+026Md1a5yzb0oraP8q/EYuQ6EqSDCV8IuYEGcb76/THIuyzCA7STemFDmmckiIFAcaSuEMx7ijsHybbZ+tZ0OgLaDMHHEvx6bZPAbnYPRd3jiNX8u9nymSSihzdPVJ3jlw30npcVEEqNp/fDEjliL1OaqGyb1ezxbSD05h1dNZt06QZ05hxRI6BGhpLzyzlesr1XOkcHWVduVfP7H7hTxR2GJgxI2cEtUuX5AJOIOfFI9aNsPaPQggenv0wn//zuTV9iiGFqQenAvDssmfv3w0UIYeuHLIuXi19yg/7f8gzbbopHcgKTDJ5/+T7UMp8kHEDzk6GnQNhz/Ow+1k4PBpu3jtn8W9teIvWs1pbFUMGszRL/6jDR4xsJdt/QpQPzZvLtnMviE2JxeNLD2tQi3tJ4PZAAGvf88cx29ZGFkfpno6etCgnfaRldx1RKIwpELEMznwLp7+E0BmQVDh3JB99BB9/LHeAODlJq9N7Ldj7ft/31uP3N79/by9WQin0MKJpmh74CegB1AWe1jSt7i3JegA1Mj+vANMKe91/BWYjpF2DlEhpwp2HMOhUzCk+++czHHQOJBuSmXpg6n0uqGTCPxNYF7qO55Y/x+Wbl4skz1lHZxGVlGXmOu3wtBzf7wXpxnTmnZx3W01ikyZSq1lU25eyE54QDkBZt7LYaXYIBGdizxT9hYqBa8nXAHi9xev0qdkHIM/3aRmkqnhXoYp3FUBut7EsKixRZt7b9J71mbWr2I52FdsB2KyDLi4yQszkyTn9Fd24ITUQ2S3H7oalQUu5mnQVwBrq9q0NUuip02R32m9xv8Jd5AFhS9gWvL7y4mzs2QL/1miEHTukM9spU2QkpBkzpPZICMGxqGOYzCaSk/PYfhKxHMp1A7tseyx0RWMK+NmOz4AsS8B+i0rG+7REJazgUYEvOn8BSJ9oyq/R7bE4ifV39bdOnPdH7r/dT4qc09Gyr6vsWRlvJ2kNdztNpVmYGbBkAB9szqWDs1K/vowKeasz4xLhBDt4ClR5FpzLg70H2LmAvQdbwrZYF7uWBewn2z6xnYcNxVGLCX3Yu7loBuWhK4aijdOs/de8k/MIvh5s7cdfW/NakQgXr6XIMXHiIxMZ3Xo0AFGJec9xdofv5rW1r/Hyqpdvu/108r6shb9FYPLVrq9ypataVdaJI0dyWmilpxfoNu4/t2yJ0oSg3/PufPklhIbKudmNG9Ii/IlFTwBZC+MPNsl2M2X/FLZf2s7H2z62WhUNWzUMkM5+j0YdZcHJBTxoWHw6OuodcbGXA2Reyg1LMBJfZ1+qeksXEGevFXzMLnJSrsC6ZuDTHNrMhuZToOU0qPt+kSh/bHEi6gQ/HpAuD55d/ixXEq9wNOooAL1q9uLR6o8CYPIOZv/+nMLJosIszLSd1ZbEjES6zO1SdIIZGxyIPECaKS2HEjcv4aLF+nFok6HselEqo6KSovKcXxgMcPw4bNkiHevv3ZvH1rDINbC1CziXg1pvQN33oPxjJGb48tdf0uL/q6+k+4Eff5TWQpP3T0Ybp+Xw23UrwcHSsb9FCXyviUmK4evdX1u/747YzfrQ9bf5xb+TotA9tARChRBhQogMYCHQ95Y0fYE/hGQf4KVpWtkiuPaDSex++KcfhC+WknZhgrQoMNnei93ljy4AZJjlBGbk+pH33XnypN2T+HT7p9bvAT8EkJRe+DL8cvAXQG4dcLKTdqCzjsy6Z3uoT8WcwulzJ55d9izOnztzMtq2R91XXpHbYcLDswRHBd4ra0yB2ANwZR1EroXINZw/+xvJhmR8nLy58vYVhjYZChSfn42ixGQ2WcNJj3loDK82fxXI8lOUnVRDKjHJMWhoVPKsRIBXABoawdeDSTWm4qBzoE+tPug0HTfSb1j9H03pMYUpPaYAeftw+PBDmDZNOi7PyIDUVKmhXrIkpyApz4g7eRByPYQnlzxp/b70zFLGbRtn1UhbTHvjUuOs24ceJISQEQOjoqQfodjYvK0Yfj74M4/MfYSE9ATq/FSHZWeW2U5og/h4uaXGyUm2syFD4IUX5EfvFUn578rT5JcmOE5wRO8Xgl4PW7dKbbmFdI820p+RMfOFngiE+Rosyq1qEkL6sdq4Ef7+G1atkr7KNm2Cixdv7WYEU/bL+mXRzkYnR3PsavG/T0sb6Fe7H++2e5cAzwBMwkTMu6/ZjhAVGFi8BS4BXEu+RmxqLA56ByLfjuStNlLAa9mGdD8wmU2cjpVCo4PDDlr7r7zKkJSRRN2f6rIkaAlf7/6a/ov627RErVhRCo5Gj5b9mskk/7+e29jk/uNaGVKjwJwpmVjmD/M1Nq2WjgG7Vu3K6DZSgHIiJv9btR5lPRfOGfj1Vzkum0x358Ni4JKBzD4+G4A6P9Vhfeh6q5WzpR83Y2buybl5ZZEvzMJsjdg3oN4A+tSSipTNFzbbTH/4ymHa/97e+r35zOZ5bqGyCAmeafAMLzV5CYB9kftypdPpZOSn116TjqSTkuQzi4y8+/sqLt57T47nLVvCk0/KRWPwjRNWwZzFamTGkRn8duQ3Rm0YZf1tvZ/rERQTZLV8tvzmlb9feeC2lG+/tB2AuU/M5cRw2X6ORx+3eR+Wfub77t9z4GW5FSsoNqj4lQ2RK8GnKfg2AztncPCC1TVgeVlYWrrIL2cWZprOyLnJpf5P9a0uMap5V6OadzUA0pp+w6xZgoQEWd+g6BTIHX/vSEhclu/FgB8C7ln9swgXH6v5GD/3/BmQwWZsOc231Kn6fvVx0Dvg7+qPWZht9j8ffwwjRkhFbIcO8PDD0srfZjTG/cOg+U/g2wp0DqDpOXupLI2ae9Cypcxn+HA5Fxw2DKaHvcuo9bLdtp7VmtlHZ9u8t969ZaTk7HP6e2l1azHW0DL/gVwX/9coCtVseSC7c5HLQKt8pCkPXC3oxXb88gO1WtbE0TlL/XwhKJK0a+eo2f4h9Nlq7W/Lf6NVkxbUC2gAwJmEC5wLjiAlLpQnOj+Lk4MDqcZ0jsSd4ejaNpQv40jD+gK9ORmh2RETlU7VP7+g5qacC/pzY1tRccBwHMtlOUuMCT6OV/QkHLuuBl2WOcPs37+ivJ9Gi7rdQdNxKekqbhdmUK1me7SAwdLaaEUFSItm+cF+pLZYSkCZSBxNkQj0bI0+RUxyDC56J75uOpK5YWs4cP0030x8nX61m1KhXkN8Mq8VH7QeU/BMHGoMJtFYlkuXnahUPp3o4OO4O6fgV7MxZGrRUtPTmbNiGn27D6Kslz9CCI7GBVPBeBmPmzfwbtCXM6HeGAwavgFhvLdZbr8p5ehFsjGVVFM6I74YyGsBbanasg16fZb8cd/SVTTo3B5Xbx/ruWOn3dixQ0frbjUp5RiKTqRywehm9eof1HsRx+PP0Wvrm6xfv5ROQWnUat8Ji74h/ux2fvndG79ybtRoWB5XwwkMOj+irhpwiF1Pi24N8cuWdvYCL1zcnWnU2B4HcwxmHNgYfpgxka/keJcNpzfk4+s/Ub36w1SqXRaLezN701UGP3yBDu278dQAPfXra2zbZmbp90tBmAiPrczVGAfs9IJUcY63D33EYVMEGhpGYaKhVzWO+52HgWmgz7JxXb5NbpVo7FWd+LPbaWov73DaH2fJWHmU5l3q4YlcYNww1eLazu94eGA7HB2yHK+d3heMq30ilZo0RZdpcy7Mgn1Ll9KkZw+csnm4PHvoPHbmGKo0b4U+m336vr+W07BbZ1w8shwdhBy/hEiOoFqrtjnf57K/qd+pDW4+vtZzJ8+4sWWbjtbdauPjdBk7czxH0wVphlQ87F3Rh58iIDUFDY2MkJv88/MY6jzUGTs72T5PxIeAELjrnUkN3Yer2YRO03BMsSPVAQZX7s53jUfzcmoSy8K3EnkzEp2mUS5ObmnTaTrSo1KpPb4sweYoNEAA9T2rsbBWRzo1Hs3IN+rw1lt6MjIEpd2u0LBeCj17VGHcZ3aUKwdBQQKTSUNLj6FyqXDs9AaE0IiOT2TD6ZkM6TmA8u4+pBjT2BNznAl7pV+AZj61qeBShpWXd/DNtkkk6ZMJcC3Lkd7z+S5oHhNO/srwiXN53F7Q8pE6eIpTgCCBukT/8z0PP9kWR6es57th9y7gOl3bPIZOpyMhI4nTN87TIn4X8S5PkWCsRnqGDnt7QWp0EH6u4ZRv0NralgEmTfGmfjNfKlTxwdV4mjR9JaLCIvA2H6Jh+9rWwVwIwW/LZtKp9cNUKy9DXp+7Gc7E8XWp06g5EyZIM18L06ZB+XKCMq4h2JuvY9acWBS8jm+uj8nRjvov7s9cu5G0btUM3wqVsupJSBjHz21lQLfncbB3wCzMrDl9iYSEF2jaVCM1VUOvl4KbtQdW029rH+tvTcJE7Z9r8tPrn/DMoDF8MMaeXr10ZGTAL9NGMq5dO3y1d9A3/Fhqr06NY/bZyvit/pK2NdoAcCnpKlN/K0XKja7Mv2WX5JwFk0lKuoFH6kNomkZEchSLQjYTnxaPv6MPJx5bxNTgRXx28le+mv42vSrXo0ervuj1eiJTrnEq7gL753Wn/SP+lPM34Gi8hEFfhpT4GOKiYqlUpxo6vQ6EhqaZidn9M816d8PBJesBBx+9RPn5sym/anuOsk1oMZuAlztTubonrsYgMnT+zDkonb/XwY34s9tp4F6RiwkXWe6SSu9/FlL5oUEAxJ/ZxsUzUaREnabmqS3WNgcwe/kcWjZpQt2AhgBcSIrEmHKBSvGhuNd9koQUH65EOVK/djKH1m6ncr3KuJWubP19RKQj8xc70qFHddw97HA2hZBs15Dde76gfi0XHqrfxJrvqQsXuR52kkGPDsXJ0REhBAevB3Fm/2lqVyxDq4YdAYhOjeN45HUOLGtGp15V8PBxw9V4miS7hkQf+ZuqlRKpVr+8Ndx2YrKe7390o1svd0p73kAn0jBrTmw/UovL0e707iVwF8GAmeUxB0BAXfcqJAT/Q0NNOjwI3riLI1cmUrlJcyy92vUzW/l5yff07vIkAb6VEUJwOO4MSWeSaPX3BsqtzLmVYNOrA6k7dBAunl7Wc0dOurNrt0arR2rj6xiKXqRwICWNlIwUvB08sIs4Tc00MxqwZXcMn+w5TNtH6+DtdBV783XidDV4bHdZ0skyA1l2dhn9P3+EH/YaqLwu53bE39/oQ9s/FnDqpCOP9dFz9Srs3LmLEa8vpl/7J9A0DbMwcyD2NIb916jTIIBSlbMCTgSFXWTTieUM6PIspV19uGlIYl/sKVyPG6hVsyxlqteypg2LvMr2A8t4uudLODs6IYTg0PUz1Mg4h3OGM6UbdeN0sBsO9mbK+LTFdOgVvBz80Nd9G5BtfOYNO8DI21X60sK3LjMOTicyNpZRLy1kQJ/yePk4o2kghEbYmK8p5ZNBjabV8a3bGYDkoHXMXvYDg97/hFUrdbRpq+PkSTOjR+s4H2qifqUQ7EQcCIFJ58H5HStp37clFTLvIf7sdkZv/JbF8X/neI495vUAQIeOy0+uY2vUAZ7d9QnL/vqd5zq9icPNnGE2J7u8i9ek16leyxVn0zmMmieaMKGL20mtlvW4GO5KYrIeSp8m1ZCCq94Jh8tnqJCRhA4NLdzI9h8/pN7Dj1jbZ7opg9Z/yXLY6+xAgEEYefz7ngz1ac6gLs/j5exBoiGF7dGHWZvpFH9MlSdw0Tsy6+gsDp0+zxdvLqLroxVw88h0xiI0hrbZwZplz1G3jjeP9tCTnAyHdkURtmkOCQ5tOX/RmdQ0Ha4uZs6FOmIwmKlYtxquxtOAjuiMRvw224FnB6VQwfMcOpGCSXNl2+HaRMU48GT38zhpcmxOMpZiym/VGDBAo4JvFE6mMNL1lbgcFExZr3DqNK9ibXNxZ7YzYZI3bTv7UanMTexEPCbNnfCQaPycL1C3VfUcc8CyYTN4/Zn3mDa/ARs26HF2MlH65RFEAB83eIm36j5L47+fJjw5ipdWS0Gav5MvKaY0bhqS6fnTI6CDXuXaMbLOYJ7f/QnRaXH88dlwOj3cmcrZrqVLvUhqxD+kln6a2Bs+GIwaHm4m6jjPQe9RhQy35pw840opHwPXEk5z7Ox2Hu/0HHq9I0aziYPXT2Paf43aDapSqnIVa92Jjojn6sk91O/aHTv7rCXYohXeGIx2NGxXAzfDccyaMzEJvqQHz6V935ZYkmaYDOwIkwqz2mlmvKPDcdE7EXvdyIsv7KRf3/r4ed7AwXSVVH0FNp2TQqMaaQJd+En8HL1IScpg6bhXeLj/IEpnu2e7mwdJjI7Es14fgs55YhZQp+pNjqxaSoMevazvLf7sduwSj5F4NYwbngO5meyM2QxeHkai98+lftdu2DllOZfRJ50i+UoQ5opPEnXNA6NJo7xPBXwuH8Ap9iA63+ZSwBD6rB8AACAASURBVCwES8MDWGnnjvuCp3C1cyYu/Sbejp50DClFw4da417Kz5rv6WBXNm7W06Z7LXycLmNvjidR34Dk4GXoPatRqmyWj8NfT0/GJEyUcy7Fc1V7MTV4MfHp8ejQcNY5Yr54FFezCb2mp1zVDbS7sp4WzbvywhA7ateGdevM/Dl+Homp7oReqUByih6dTpCQFMqFqOU8+cgL2Ns5WfvbehkhOJi88G/UmTPnXHB3M7E/dgu7ImQfXs+zKqGJEcSnxfPmhCfoVK0unZp0RdM0wpOjCI2KxOXoBZr17Yt9NhP5jdu9uXRJ0LxLPTyEjG523dSImb/qGDwwjYpe59CLJEyaK1P3SVcPz/t3oLNLNT519uNK8nUGPbuNQb0a4O+vw9kUSrq+ArtC9qChUSYphfiz2wlw9iMqOYr5U99GdHuWSn6ydZyMD2XOb/1YstSLqlV1pKVJHZWbG+yb/S11WtXBIdv6PNHQlXLBM9C3+A7NnAGnvyJh9TYc7XdSoYI9iYka9vbSCnLi6kB+DMrpc3DoqqEcmO1P0yo1qNmoHK6Gkxh0vnRvB8Ne9yIj3Yv3P9Dj4QEnTgi6VZ8Ddh6kmktx4owr7q4m0kyn2H5iDf07PY+HoyeJhhT2xZ7k/D/tcLfzoWGbANyMJzBrTlxKaMiy5ToGPxlHGdcL6EQaGZojk/dKy871XaZS3b0C1Vb05XjwUf7+/HVa9Xkcu2zvaM1mb6KuQutOfjiLSAQ6gsL8+fw7fw4c1OfwL/fPovWk3oiiabvK2NnJSU5GmpHDK5fT7PHHcHB0sqYNOhCCsz6eyk2aW9d+ABMm+tDxYR3ly6RmzocciAiJxsc5mrqta5BtOUdCTDRXIgVtnx7E3aAVVsKpadpTQHchxMuZ358DWgoh3siWZg3wpRBiV+b3LcB7Qohctreapr2C3MJGpUqVml26dItj5P4a3KLU3vH8Q3R0MsCMvdZzN5zAO9Oyu89ZSHSAbVWhpsGXc/bX6XcaXj0CHz8M5yvBKfuqlB08Ccp0Ant3ECZ2fPYYHTs7Q8dV0lTamARTkklKcMVt0B7wlhNvTgSyffE2OrVPgUcPWs+Jk+PQZUYMf+EouBrg55bgerETK6970aXrDajZCOJ/BXMyP77zGm/871d4+Bnw6wDCxMxNC/nxylYCVwj6nYXz3vBMf1jVzJfSAzaAT7McZYueV5rBa+dzzKUtNasYCLloz67x9ag9aBqU7W5Nu3W8gS4xGejNMGovHC0LW6vCpcNwfHUvXmEmDj5uONgLotIvkDGyMZ9ugzE74bozdH8WPvNrSc8XnoOaI3KUAYDBIssH0cbhvDiyIh81WEz1lgehYg/Qu3A5ejd9Dp6h50GYsA1MGjwxEHr5duTVIfWh+dQc+QY+M5bAKuNgNOAM2MH2/R3p9Gw5aDc/R9rZE15gyIjV0Op/4NMEjKl8vOhnPjftZfZyeDQUNlaD5/sBgYL09Fv8F0Ushw9eY+/8ACbyLuFUpgUHeLXzDF7bP5sOw+rQtq20Vlm+7RcWVBjJrSzb2psnBgpo2A7cSkPMSqYfPcDPN6L5cin0CoEoN+g/ALr+OYpAvx9gJFhmSdciSuFXIzbrWWbe27HImjR+ehJU6GM9b/w+FTu9OVfaIxea0HTQCKj2Yt7vKPPcnnOtaTuwP9R5547v839vlWGQuEDHppPkplQzXEyF/hHQ6wB8tl0mHfAUdPDryBvpN2HWUeuzuewBTwyHTkdhUqbC/cW+EFm1CrFOV5g9K50GMXCwHLzYB9zcoVEQTJfzZP7XC8Kr1GBtqdzRssQJEMtgHoOZygg8SOTHRiOoWSeelQvb8SsvEUl5Gtkd59dfh2H3ZBi4Zgk65kyqx5CU3NqVx+N0JMeZWbkQnI3wUWfYVKsU6R6xfLwaBgTBVTd4cgB0nT+CwLZT4Wk9eNUAdCREX8XTOz7Xcy97SkeUo5kTP0ODGOj2HGxyakbL3Rv4Y6k3lQM0HB3AaILD3/Wm9WVgas4Qu4GMJdBnHIwFXAEd7DrWjvbDukP9T6zX2/11Mu0vQ41YODcVrrlAmXfh5SuP4R03gUcHlUNzsAM0NGHm6vjhDHpjHzQdAV71wZDEa3M/Z5Y4webfBR3CYXlt6DcIRI1s9SQ6GnxdafO6A/u0eGavgBeOw++N5XsO3VuVxbuHktjpMVzLeyNMJs4ZJjC36m98tw4eD4YdlWHoE/J9RiyrwC+8wnp64Eg6TThCLZ8Y3qg7AdoAXkA50Gz40a+VFMCzu9+mVMsu+NTwwcHZjrRkI0/H5faR5pvmTTkRz/tr4ZmTEO0q2+fhCpB2qxbN4MhPfwzltdemQ+NO4FIV0qPw6juPbbu9aNLklvTzNfl8QFpGnRrHvpBWtB44EGqPzt3XdRwHzyGloXbwVEg5LpPIsimJlE2CTVXh7W5wogO52uf2xdvp1KeONPfPzDdoUjL1wqFMIlz9FtLswOsDGFkKJh2rw+LZ9RjCHPQYKcdVgufVzvU+Z/d/Em1jAC9cGgeBQBUwLwR9S3nptpfA3gw7qkDZdG+iHOKZuhZeOwjrq0OPZ0APuGTAzS/lb1oMg0OmNny7pBtvJY6D/wHtgBWQ0N0Dzyf3gFc9631c/MQXN3svSvX4CMo8JLc+ra5B4DNPE5g+BZ4FpIyBlftc+cQ7mQ/XwNOn5Lyg7yD4tnYdmj89Hir1t+Yb8W0ylS7mrj/rRTO6P/sqVB92x35x8PCafFh9DQ1azgffsmDnQUh8MAPC4Mk9cvw0a/D4QDh+dDKzSkfzSJ0vZB02QVoyOMfDs8dg9kpIcoCeg6GXW0c+GlwFWv+eswxLIW6ZN5MZyRp6400cEaMHc87jOksWQ/8zMK8BPNcPzDVzt88PR5ThKy0s1z2LGsBTN+VcKPN6j450YKM5nsnr4I0DsLUKdH0OjCfBuNyOgSxiA90RaPRlOc3czvJO0wlSheilYSon6H1MhxZrZtUCsDPDl+0hskUppj5aE7plbtdb5g9p0ZyNrpJr3mK55wvLAviCDzlCM2pwjlEvjaf1sC5QZxS4lAM0WFkJ0q/l6m97hPhy2pTMlp/SqBEHP7aEkT2hcSo8uRvG7IJ0PfR5Gl4q3Y4Bc47B9ZxCo0keb/Pua99Cq9rg3gAMN+DqZtYsGskrG98joLEXXh5mjlyMovzAGjxyBL7KNC567gmoX7oj7z+Xc96SMTkZ/7PQIwj+XCbrycAn4WrlAPa45a6YHZKgaijMznSPNKIn+FVtwNgBNaHDXzn6GZZCxjJ7ZvEisxmCE2mMqvY9v4oPeOilFjzWR8PNTSMuzszq1mP45LmJ8GglOQ81mwg6HIEpPIkGAxtD1RfA0QfSrrH6xS957E07aPw+eEofhNHzuzDrjf589MqX0BTkgJTMsWu25i1pLJvajwHDt0P9oeBeFVKiOLJuNU0HvZZ73rIUWAY/8T/+4AWacZjr748nwi6Vv6YkUC4RFteFwI5w0Q/e2ANfb4Zke9n3eJatSIwWz4JpSVSNh79rwEddbPehx/5ewTsLVjBoRAU6dtJwdIQrkYLW39kTuawcXdlEBBUxYkf9EfU5VCqMH9fAiIPweQf4uIvtMXHX641o38EOHtmRu8+vNw5eAxwBHRw80YwWj6RCr9PWtGk/JNP7GHiFS+tpDfjkYVji2YKPQxry7IuzoPZD4FQOY0oYvbYcwiFazlt0Ar5uB1trVWTDI1fhaUOOMkQttOOL1d+wvuKrdH7YjKbBwX2JHPrUP1c7em/8h0TVH8NbHzhRuYqGpkFUlKD2UbtcaWMS/Hj1m5U4NWlK794aDg4yOInvzE/5sP3X0KUClC4HSYl0i73GJl2s7T7plnc0+n1P+hov0an9ZKgk+9DUDCdcXk/N5e1jxKSe7I3fxq+/p9EkCrZUgTd6gLsbtD0O30ujHF7pDTWawDsXq7F5bhUm8yZXKUszDnLQtwPfLqpDy1YaLi5SEN5v8qOsStzIhC2yf/+1CQzrK+ctLIPxjOFLPgIEr3fuyU/t/2HBIugbDCdLy/lelA3nzQ1uVudE62vw1I2c9WTIWwT6fyfXCpl6+cvnyxF5uTytni8HNV4G5zKIlBie+KYfSQkZrFoILgb4uQVMa+TIU7+/y6fPTYCOgAGwhx6XvEgz2LFqUizuGXLcGNsJzvuCVwpsmAcHy8KI3jDL1Y/kNeOJcWiMRy1/NL2e5Ks3GdunXq539Mqosrxaah/NyiyGJo3B3gH4h5Nz6rLs0BDSO/XAubQr5gwjx70GsdnzCJtnmWkZKdvywAEwNnAsgTXHyXt2RJq7REB6SEPmzW3GPAYThw9NOcKsfsOYs+w5RjEZMzqM2NFq8NNsq5k7Yum4zz7h06fHQ3c38KgL5jQ27ypNo8ox+HUdBuW6g50LhrUN6bU/DtfLsGyRbHPvdoXLFeqz4LF4eOJyjnf03aj/8dZL06HbE+D3EAgzJ3ad5LkffmD9NndKlQKLpjupryfe63Oay8a5eeHT7UYuWcehr3LPW5iSTLJoiGvPueBeHfROYDZy6Kv2NI8uAz/mVJDwbCWYm3uirGnaYSFE89w18RaEEIX6IKc7G7J9/xD48JY0vwBPZ/seDJS9U97NmjUThWHGoRmCQHJ8NoZuzHWuwVeOQiwtLX9kMgiRkSDE0Q+FmIcQC10LVQZb15t2YFruhMZUIZb6C3H9sBCGxKzzf5UWYmmZfF0rI0OIqlWFGDFCiORkIRIS5P85sAQ9FUL0X9g/V9mWr78mfHyEWL5ciLQ0IVJThThwIB8Xz5avzXPBU4XY1FGI9BtCZNwUwpBUoHsTQgiRclWIRe5CLPYUYu+LMr955M4jKVyIv/yFSL0mhCEl63xBr3cLCQlCeHsLceFCzueamJjnT/JP2nUhlvgKsaahEBErhYhYJcR8u6zy2nq+eZ2/H2nNZiE2tBHirzJCnJ2cWV77Qj3f+47JKMT+V4QI/kmIa3uFiDsuxP5XhZiHSJ7vJP449od4YuETYvz28SLyZmTB8j4/R4iVNYRIOCNERqKs83+Vsvk+h60aJghEvL/pfXEh7oJsi893Fo0bZ2WXlCTbd54Y04VYVl6I+XrZJuYhxEKXrL9nXi/dmC5cP3cVBCL+Dv5bjN02VhCI6PFnj9x5xp8QYkVV2VaN6Vnn79SOsgIri482fyQIRIxcO1IIIcT//v6fIBDxydZP7vAA746UjBTR8feO1v6s4ncVxbnYczbTms1mMWHHBGva/ov6i6jEKJtpTWaTGLl2pDVt/Z/rizMRu4RY4ifE1c3y/WYkCpGRIDIWlBFRs+qLsDAhzp8XIiREiLAwIYzGAtxI+Ao59uwdKkTMbiHO/ijEPN3dta/Md2Eym4Tv176CQMTOizvFgpMLBIGIRtMaiX/+EcLFJevV2dnl/n2O/uDyaiEWuWXWMyex48KOXGNJrz97CQIR72x4RwghxPSD0wWBCN04ndACNWE2m4UQQlT6vpKw+8xObAzdKETCOSEWOst8FzjavA9x9AMhDo7MOn98bNZYfXqirPe22kA+2BexT/hP8rfew/PLnhcmsylfz1cIIcS1/bIfv/y3EMYUOZb/5Zf3e9v9nBALnIT4p58Qh0cLMU8rdB/66NxHhRaoian7pwohhPhm9zeCQES/hf1yljezzDfTborfjvwmBi4eKH7a/5OIS4mzeX9vrH1DEIh4d+O7Qggh/jj2h9CN04nWv7YWQ4YI4eycla1LQR67ySDEjTNCxB4S4to+IZb4ZL4/Xf7z+KuUEHHH5LEhqcjmbzYxm4RYVVOIU1/Ka6XfECIjQeye0EOUK50sDhyQc4L4eNlv35G8xuBsHI48LHr82UN4fekluv/RXRyMPJh32VKihEgIFeLGWflcb5yVz/gWnnlGiPHjbfRLuwbLfseQnNmv3RRigbMQB1+XdVoIWUctbcyYlvXb7Oc3dxYi6aIQpoy820DMHiH+biCfoTFVnjNlFHquVhTUqSPEpk1CmG5p/hkZQgQECKHXC+HhIftKhwarBIGIqpOrimVBy4T/N7IP2XZhm/yRrT40+3khhIg/JfurHY8LEXtQiCsb8jcHtJB0UYglpYSI3infWXpCgZ/jq6/KepGUJOtwYqKNNUQmjo5CRETkfD45nlW28rZpI8S8eTnnyvlqG7bI/hwMSUIsryTEps5CxJ8UIu2aEIvcReKfVcSlS3LsDQ4W4tw5ORYXaAy+hZgYITw9hbhyJav8qalZa7zqU6qL0OuhovXM1oJAxNzjc0VQUM5+0dfXdt7XU66L0pNKW8cd3Tid2H1pt+17Tr0mxBJvIdY1FyJynRCRa+W4sfsZ2WaFyNYO8+hD9w4VYnUdIaK2y/Ybd9zm/N1sNosm05vkGtu3hm29/cPKR59WIJIuCrHIVYjlFYU4/rG8V1trPyHEypWyXU6cKERsrHz3PXsKERIbIl5e+bKo8kMVMWTZEHH22lkhDrwuxOYucv1lWZvOt5drGsu4n71Py889m4xCrKoh303G3a3l86RMmZx9CQjRCFkXhJDXtox9BRz/gEMiHzKfotiedhCooWlaFSASGAQMviXNKmCEpmkLkXqnBCFEgbemFZRhzYbRrFwzms1oBsDl0Zcp71GeQ8MO0XxmlkDt7+HnwNEFLv0FGZkOqd0CoMUvUHVIocrQtVpXTgw/QcPp0ipp2wvb6BTQKXfCtGjpA8erEegyVdonAiE9BvSuudPbYOVKGR3q66/zcB57C38N/IvJ+ydb949ef+86fbv5MHYsdO+eFTkgl8b8bjj9hbTYcsi0y1vmL++tIBwfA05lpEbS4gB3sZt8dtlJCQdHX7B3BX2ml7QCPktbXLsmzTDLl8/pULlIPPYHfQ2uAdB1R1aZhTH3vZUUrqyDpDDocUg6LdQ7gTCU3PLaQqeHlr/kPNdyOrScjgvSyOO5Rs8VPF8h4PhH0HYuuFXPctCcnlt7BvBCoxeYeWQmE3dPtEbWC2gSxu5psGePVFCazdI3haenDDmdKxLOhblS2x3wDDQYB9FbYf9Lsp31y/IF5qB3oG3FtmwK20TvBb2t5wfVs2GqmhYDDj5yG5w+0wyvgO2obUW5hffQVRkpyuLM2XK+qHG2d2b7kO0kZyRjNBvxdMo7zrSmaYx5aAxjHhqTZxoLOk3H5B6T+eHRHxBCSNPgoG+gfA+5V9/ezWohYQ+UcYqGKnfM1jZCwMHhUO9DqPWmzNunKRx+o1DtS6fp6FylM0uClvDwHw9bFDg8Xvtx3nlH+gOYMwdat4Z33rlDZmFzpJYLQLPnoYCHuDz6MhW+lxuBQt4IYeP5jawJXUPYDWnJEpkYmXl7Ar1OT7IhGTcHN6tDZG9nb4j8W94/SP8Htqj7nozCcvht8G4kLUlbz4ZyPWBVddlJt/wFNDvY/3KuNnA7WlVoxdV3rpKckYyjnSN2BXWufuJjqPc++HfO6sfTr9lOe+M0RPwl+4myj8p+4uz3he5DK3tVRiCs0SljkuU4G+AVYDO9u6M7Q5sMtfrXywvL7yNvyvcYmxKLWZjxMzZl4UKoUgXmz5e+PwYMKECBdXbgWTvr+5N34ZSpd7CsO1fXg2Yvx6RGX0nHq0XN1U2yX6z1RtY8ZJk/H8+fx0efutCwYdFHXWparilrn1l754SaDpzLyM8dGD4c3noL+vaF2rWlfyi9KQ77iKXSukGfuS1imT+YUyHhrGybhkQgmxnHvqHSebFrQFbbdfSFh1ZISzXIuw1EbYZSraVLB71TlmUUFGquVhS8+y788IP01VKunByDhYAFC6S/v0mTpD+WmzehW/eeHNN0hMWHWQNhOOgd6Fi5Y/4veOQtqPA4tJoh65UwF2wOeOZbuV7xyfQRVMA5dno6/PabnOe65uPRb98O48dL32q1ask5ycWLMkqt5y3D7okT0K5dzrlyfq5xR8L+ACd/6LQqqy0aE3HTEnGrdPufFhQ/P+kv7tQpaSVlMsmhxt6hC3pNT2hcKLV/qm31FdW/Tn8GD8jpcD67X8bs+Dj7EP1ONFvDthKREMHzjZ+3Oq7OxenPwb0WdNmcLRCIkMGU0MB8B2edKZchfAn0PgNOZeU82Luhzfm7pmlsfn4z/t/4W/2FjW49moerPHyHp1XEHHkH3GpmrY9MaXBxns22MWoUTJwIzz0n18G+vtIiz8WlOjP7zMxKmB4HYbOh7wVpOWlBGKQZvmc92TdZyacL6LRo+YzLdgXt7tbyBeI4MPwS7Nss1xheDaDtAtn3lnu0yC9XaKGREMKoadoIYAPS8vw3IcRpTdOGZ/59OrAW6AmEAinA7WcnRUjTsk3J+Fg6kLbXy5V+s3LNWDt4Lb0X9ObM62eo5JnZu1R+Mq9sCkWDMg24PPoy6aZ0a/SCXLhUAr+2Mhxh3bfBlA61R8kJsl0+JEBIZ7GdOxcsTPybrd6kZ/We+Lv54+bgzt69sGJFTo/0dkUSlEgnB0Fb5/ODEJkT7AVywna7yXyptuBeDU6Mhfofy8VH/THSpM+rwV2VHqBaNejXTzqU/Ppr+Yx0Ouk0OCDgrrOVXFokt5LonXP4qimxXFoIlZ+W70LvdOf0/yWMyXLg8GufVU+X5d4KZaFdpXY46B3IMGVYJxzDmg7DxQXa5le2Evy9vF6Ln+VEwmmQFBrZGFTHdhzLprBN2OvsMZgN6DU9gxveKucHynSWwop9w6DBp+BSHmq/CZ51oPLAfBWrVQXp3u5Y1DF+2PcDx6OPA9CyfMt83tjd4epwbxYcmpYVhQRhlJMCm5O7QrThhCAQJqjzdlbbKqI2NqrVKJYELcnhBLVnqdf5+oQUGPXpIydaC24XUMhsgCvZFrBGaVpd3qM85k9lH69pGqFxcm/25QQZ5fBC/AUgK8pgYnoibg5upBqkp1FvJ284uRjMaTnyzYWDNzSakPt8+BL5f+fN4N0Y0PJsA3firutP7H5oNTNLYHSbdk/EMijdUQqM7IsuVrBFuGOJWmmJ9ljRs2Kh8i3vXh6AK0lXcuR/Y09/PD1h9265WDSZpLD7vuLoA1Wfvz/Xyrgu6+AtzmSDr9SmQ4d7F6a7qGnfXi78t2yRH6MR3O2NvOKvR7M1B4neKgVEjqWgygtynGv0Odi5QfwxiN0LbebApcWZDm8z87hdG6jUH3b0gYw42Z/W+1D2e8KcpWAsJoYOhccflwETrlyR9drREWbNkoK2YcOk8tDXFzas1/PBnqHMOjqLsm5luZp0lTdavJH3wv9WjKkQswMeC8kSBBR0Hph+XY7N+lsrYMHyuXVbV160bi0/+eHzz+H116VQytlZXsPOLn/K7dtyYTbUHA66bALOe4heD40ayU8WOroldGNd6Dqrg+Qm/k2ww5mNG6WwsXJl6bA51rbe0Ernqp3vXIjwxdBmbs7IsSAF5v88AaXaQMMJMrhS/Y9z/z5iBZTpAnYeUmCUqezKCx9nH4JHBFN1SlX83fz5ttu3dy5jUWI2yfnGI9uzhNA62+NlSIh08v/CCzLQigWb9SzpPLhVzbm+ttSfxBAp+L6yDpp8I591+cfyV15nf/CoDRcXQoW+sj3WHwN13839zgpKEQSDKixFIg4QQqxFCoayn5ue7VgArxfFte4Gi7AoOz1q9MD0aW4P8veK8h7lb59A06Djajj/K2ztBg6+gJDR1Tqvz5qE3gZvb6klSEu7xfolMBDGjct9vbFjITCQGr7SIa4QUghSoKhSlr3a2fMtUyZ35a7/KRweDZ1Wy4XWYyHy/3wKxEgMAfTg3+XOC3FNk1qumO3ymoab8loeNcGzbpb09y6YOVNOjt99V0YisVgeffNNIYRrxmRIjZQLiPxMtEoCMdug3aKs91fSy3s/0TtLzWlKpLRYzIHtCdx33b5jxLoR1tDJ77V/L//XM6XDzWBo80fWoHSbdtWuUjua+je1RvX5ossXti0qNA1a/QJJF+WgnR4r782jtuws8jEhLuVSCh06UgwpvL/5fTJMGeg0HT7OPnf8bYmn6guwtjHUfB3ca0LfcOnMM+MGuBZigX59vxR8m9JzavuLgLaV2tKwTENreN3B9QcTctyPgAC5ELIoC26rBY47mrsPzbTmyb5IquIlTa2ikuVYEJ4QDoCTnROpxlQSMxIpS1nSjFJI5O3gDPFH7v7mrqwD35ZSQ1hcgmx7Vxk1zLXyLX+w0e4jV0P1V7MERkX0jsu6ycC0FqFOdHJ0jvN3SwUPaUV2LVlajVgsxyKP1mXIELmg1unkx+df0LzzxL8bHHpTao51DmDnBP2iaPyrkQ0bpGXK/QoDXVhcXOCxHGuh0rC1HZwaD3U/kIvxxy+DOeP2czXfbK4wrq6X459267zbRhvwrAtt/4SdA8G1grRWSr8GcYeh5/G7v7Eiwts7p9Wc0Qhvvy2F6tnn2I6O8G23b5l1dJa1vY3vPD7/F0o8By4VwCnLyXOB+4NqQ+HIe1BrJOhdpHWlKSPLSvgOODrKCFbDh0vhjilzeaTXF1648+abUgE2alTOKGSLF+dc3BeY5PDMqFyZ41ExWbrPfGwmFb6vgK+zL1HJUcx5fA4HDshn17kzrF0r11V16hTyQhkJkHYN/NplncteTzqvl0odQ6IU5toiLUr68LRZL2zPT6t4V8HwsSGn0ux+ceO4VE57Ncw6l0fbiIiQVm/p6fmoV66VIfliHpZZOql48m5c8PJqOui8Sa49w2ZBqXaAgOgd0G1nwfMrYRSJ0EhRROjsoMZw+bkLnn9eao/GjZPWRg4OsqOyDwzMV/hlTYOuXWXEpPfey1o4pKUVsmMHqP6yNPtb21haRNi5wPWD0DOfoaxvnpVb90zZopHdboDQNCjzsPwUMe3ayU+RYUqXizCbCx0bnfitgjrIW1h3rzCmgpOtsKgPgJXUvUanh2ovw6E3oP1C0DneceL9TMNnGLFuBADvtHmnYNtiEoLA0U86qr6V14Bnsg3ymfVkE0zNuAAAIABJREFU7I4Z9F3YF4AXm7x4+/zdAqDma/kvzy2UcSvD1aSrGE3SuqWwi9cSg3NZKZze0Q/KdADXKnJL3+VV0L8Qu6/NGZnCvyK2YMrkw/Yf8vTSpwEY0XIEi7+TE3pTfnUoCadzW43a6Isre0nBiWWblMXixcPRg2RDMonpiWSYMjAJExoanhkxsq2YM7IyKcDWMuIOQ+23C6/NKwzVXoGT46DDElmOflFSKWCrTCnhUCpboNkiWvD4u8kJtSWkuOX5W87fLRbFV1xqHABXEjMtji74MnBgzoVl9giM/zqcSkHLn2FTB6j3kbTGTI/j875/0/XjX6hXT4agNhiklYGX152zLFG0XwQ7n4RtPcH/EcAst/5ZgrzcCd/WcO5HOd/D4c7tt1Rr6L5bzoMy4sDeM//KxPvMmTPyfVarlvO8uzuAJ/3r9GfpmaWMaDkCZ/sCSA6FSQoghY1OOI8xPNdcr0wX6bh3fUtp1eBSCRJDoeb/8l2MH36ADz6Ahg2hY0d5qZ07ITg4/7diU5EMtChThvlFPT/VO0shisUozalMZj96f+eh5T3K06B0A07GnMRR70iDMg348jfZB/z5Z5ZAfebMO+d1W8wZctu1za3bmfess8+53epWnMvKMdyilLK0T2PKbdudnb6YxAUpl8GjFphS77j2c3ODmJh8Wns6lZZO+fcNgTZ/SkvHx4KlYM61AHsbb2c4YUzN3CKq2bb6egBRK7x/EbVqyT3W7dpJwc/BgzB9+p1/l52vvoLvv5e/T0mRnd6KFbf5QVTUrW65bAsuNE0uPPtelNGcavwPuu7KnS4vzAa5Tzv7Xnony779B7wa27sDAlKzLTT7RckoBINtTCJuFRjd6XxB8PfPaUGiaVmRELJj7/7/9u48uq663vv4+5uTkzlpkqZJ06bpRGmhpbTQQhHLXCkFofiA4pXBq9CLA4/TI4LoAy51iQNefa7okisKywGvV/ACCshghStXWqAyCIWCjIWOdEqnjL/nj99OcpKck5yTs9OzT/p5rdWVc3Z29vml3+Rk7+/+/r4/2PNm7/PBxnswmvdNP73mwRP9NMlnr4M/nZZy9+qSaj89B7h8QYZJ451/93dsOxImzA9xl3LZjGU9j+vK6gbZM3uXHnUp4KcFJz4fFcYdB8tfg8Ou9FUu0z/iV9LIRmkjtPyjb+Oq922EC1pD+f1aPmt5z+NFTYtYtQqOPTaD3mzb/wade4bcraSwhHhBnL3texn/nfE909XGlvqFm1vaWmhpbenZN7b7HwOr19JNpDjnq1HHLsxttebhn/d3cv98Frxxu7+7uCZFgyjn+k6zDunvWWOlT8q+s9f3BupO8nRvH64JlRMA2LF/BxAkpfbW0t4aY+bMrA6df5rPh6VP+ou4dT+AjQ8w79wPcdedjquugtmzfYXBjBm5HugwFNXAqQ/5XluVM/zflhPvSv/rJy2HXWt9v5COPf7CqX33kF9GrNi/90U0YQSwfr3v/5SqN82XFvsLwyvflUGlMPgKq92v9K166D6n6nlfGIIZzPuGn7Gwf4tfAbhz34BplIMpLPRV82vXwhVX+FYMzzyT2bdyQE18L7zys96frxyeh37tFD9l+rqTrgP8FN2FC3tvvsfjPpmclaJqoMsnUrpl+j03Lfd92dp39f3ZcB2pvyZqUvytPOoof/n57LN9b4LtTvX2c+xPfFXeH2bD6hXw6MVwbxhNfAOFpb6iqbx51LTxUKXRKHPttXDCCXDDDfDDH/o7IitWpD/P/ogjfG+kj38crrmmd/rVBUn65A6LWd+ml+mKV/mT8YKEkud070BHXUHcX3C+9gs49Irek6aOfUGirJ+GhuQJooY0Ty7C0LgUXr/NX6SF2I9j1CgshVNX+j4P6+/ylRlHfmPQaV3Xn3Y93/jLN5heOz3p51Nq2+lPthP/gHZfbP+Q3mXeE4cHrProKsaWj83stQaTogLu7Dm1fPU86Azuop4z85zwXjMKzHwjyZq5Q++bjoaT4S/vh32b/HrA3bo6UjeHzkBJYQnHTjyWKdVTMDO2b/cXQmnbFkwhm/ZhmH0N3J36yri7f1H3lA2AsWX+Z2532252t/mzuYqiCj/FsmPoZFRSnXv9BVfidNBcTFUoLIf3/A+8+gtY+x3fLLxxqT85L+g3pa+4zlcJVgX/+SH9Peuu5NvR6pM7u1p39dk+XEWxIkpifmrh1x75Gq/veB321zF2rIXU9zDPlE3w/XcSHFfvL7I3bfK9NZpDbsZ7QJU3Z3bHvVusBE66x7dZeO0236x+x/OwZGX4YzzA2tt9BX+qvj/zGufhrk2zKVCi4lqfnHvx//mfqZ6mznsyrx6vmgGzr8p8DAnicZg3jJk5wIHtuzLjX+C+hTBhGUw80yc+ujoHr7QZIctmLGPhhIU9N8Vee81fNyVWYO7fn2XPs4K471n0j5v79shJVc2aTNlEmPx+WPke3wOz7jg/k2P15XD6Y1kMjpRVZlnNgiib5M8NElu0vG+jP6fu1/ersNBPr7z4Yrj3Xj9NurDQFz5ceGGSY8dK4Phf+XOtd1b55+/+dWbji0CfoQPpYPxTP+qdfHJ2Ge0FC2D1ati+3f+RHDdu6K8ZcWMX+JLK/vNPhyipzBuHfhIe/6RvPtx9EdGyzq+E0d9IvkklO3ay6qNZwFVxv4JMxTT/Ztu5P7dTQ6LGzDe3H5deN+sVR69gxdErMn8d1+n/eCbGKI0y7WOaQm5GnaLSbe5aX+nwwpYXAL8wgAwiXgUTzoT/Pj/oZ1fs+4M88yU46ruhvMRjl/aeHHZ2ZtiPbc+rPnm14AdD9tqrLa3tmZYGUBwr7qlsa2ltoaXNVxpVFVfBjmf8z/KEM+HYm+F3GVQKdbX534GCCHQhjpX46diHDFFR13i6rwYYv6S3wWcIupNym3Zv4uzbzu6pNKooyj653xHcjb525bV00QVd44nH02+ee7BoaDiw93Aip24RLH8DXv532PEsNJ6W9CIv35SU+KqFAauXhmHu1+HR8/051KGf9ImANZ/2vQoluTGHw1H/Co9d4lcUKx0P256A/zVEx+kRUFhQyOrLVvc837jRr3Sb+Lc1lJWWZ30W/nqRn9pcfwJgsOnPPmmWrmN+DE9+Gv68LJgS3gqNZ2Q/tpGYBVE9109b3f43f3O9+z2kY2/SG9Zf/zo8/bSfYjlrll/d8PXXUySNupU2+KlqMiQljSSlmppcjyBBUY1vFLj2Br/CRneiKJ9KKgfT/H547Vfw4Ck+QWYGW1fDB9Io6x5pyd7wXwCebofSd/uGwOXN8PJN8N51B3x4B71YiW98mNgPIRdVeCkq4IrqGqgq2seutl3UltZmvoz5weiYm+DeI+H3s2DMHN+MvG1raEmjRMXFsGNHmjs75/s2NZ7uK58KB796ml4znQ27N1AcK6a1s5WxpWNpKPdX04nT06pLqv1qJgALf5TWkuF9BeNIvDDNUX+LtDWdDY8s99Va5VN8Q+UQboJ0V3c5HHevuxsAI5wGpmXxMna17vIJI4DCVlpajNjw15aQ0aqo2ldDjCLTp8Pzzw/s8dnVFUIiaeIZMPvL8MyX4ekv+T6X+lvZa7AqlnXPwIvf803Uj/pe2gt1jJSuLn/TvX+lYSjvk03vhUnn+ZtK5c2A860iMrlWKIjDwhvhiK/A7pf9tVVZU/ZjG4lZEAUxPw1x9eWw5BHfnN+1wcYH/VTYfuJxuO8+P2Pm7rt9D7JLR1FHhFyL6NmUSBKHXekbLL72K1+Cun8zrAwhOx4FZrD4DjjqO34ltT3rYf63o3ELN9Ub/n/W+4TRyz/2JzkhTJ0Z9dLtGZWJyumwa93A//+OFI0XRkqy/mZBj7MPzvGNlz90xIcO7JjyVUkdnPWiX12rowXGHg1n/G1EXmr6dFi1Ks1VM/dv8o04m5antST2Px3xTwCcOPlEAM6ffT4NFUHSKKHSaGzZWNj3tm8mXjyMKZOxUn8DoX1n77ao91mrP9E3+Lz/OPjHv/vV31a+J5RDxwv6rlxVlOYKSkPp3/+sqPoddu8+6Cr0wzESfwtkRE2b5iszn3yy7/Y9qWbV9o8xDB7n2V+AM5/3534Lvg/L30y+38FosCqWqhk+CfLu38DUC3OaMALfjDkeh7qRahe56Cf+ey1thNIJ/vFwlNT5qsAwEkYw6DlgVuZ/299U+v1hPqn62Efh0Q+m3N0MTj3VN3a/7jpoCunbE1UaST6Zfqlvevfkp+CJT/gpCUNMj8grBTE/R3vGv+R6JH0N9YZ/5Nd9KXW6DRsPZslOfLJtYF59JOx+yZcYk1Cl0H+Fqxw6eerJ/HjNjzlpykm5Hkr+iFf4xqbzvjGiL3P88fDII7Bvnz/RHdS+DT45mbjE9iAOH3c4AMWFftrYvPHzevoY7Wrd1VNpVF86zt8lnvbR4X0TsSK/guDO56F+8fCOcaCZweLb4U9L4KmrfdIrpOk7pfFS2lt7s4BhTE0DmDJmCq9sf4V4QZz2rnaqy8qpaPZNX887r7faorU1y94dB4OR+FsgI8oMjjkGrr4a/vAH3+S4vR3eeitFX7jhTNepmAIzPxnGcEeXKPTyTNOOHX6mxoj2epu4zP87GJRPglMe9Ks6vvQjvzLj1ItyPaqDkiqNJH8UxOC0R+DQT/gmojXz/fPRLB/uRsYr/VzyHN/dyQvJTnCyPekpGQeFFbDuRt88vdu+LFfxCtGipkV9PsoBkOZ7x/z5/qK/tbV32759A3bz2nf441Sk16x9as1UAN7Y8YZ/Xj21pzHzNx/9Jhf/18UAdLS+A5hPRg13etaY2bDx/r6/A52tqfePgrImWPaM7zEx75uw7NlQDltb0rcR7LiycBoTnjvrXABOmHwCAGfMOIOFC+Hf/q3vz0xXdPLVIqG68kp44gk/5WXDBnjsMb88vYywkapiGQHt7b5/UVrVu5KeumPh7JfhtIfhrBfg2JtyPaKDkpJGkl9iRTD/W3DuW3DGmrTveOetMO5G5kPi6WCR7MQnjJOeyRf41Zp2PO1XbGrb7lfgiojmMc20XtPas2y3HABpvne8+93Q1uYbRe7Z4xu9vvRSimO27YBYedrLx06snAjA27vfBnwSqb3Tn0m3drayt91PoSzq2uf7LFRn0SS97nh45da+2yJUbZdSQRymfghmfcpPNQ3B4mZfbXVIzSEAnDglnKvaQ+sOBXqnqc0bP4+LLoKnnoKf/9z//OzdC1/+cigvN7qNxA0EGXGnn+4Xi7nzTpgwwa9W3NKSYudU8VScR7WODl9lFIXuEqNKrBhq5/tl7CUnlDQSGe1UBj/6HfZ5Pz3twRP8Usd3z4CWf+R6VD3MjKJC9byKopIS+PjH4eGH/cXQhz8Mxx2XYuf2nVDe1LeaZxCxYJn5d/a+A/gkUmPlwKXfG0vKgZhvCD1ck98Pre/AEx+Hzn1+jGs+N/TXjULHTfIB7E4WHTvx2FCO21Tlm0O81fJWz/OlS32z0Y99DJYt81UXN9wQysuNbiN1A0FGlJlvtHvOOX46ZmUl3HFHip3zqDpGwhOL+d5XIqONkkYiUaa7kZKOiil+6VkrhK1/9RfMDSflelSSSxm8d3zxi77J66uvwu23D3LMth1QXA+kX8EzpXpKz2pbsYJYT+Ih0YSSSt/Pp6h2wOfSVj0HxhwGr9wC98yFe+fByz8a/vHyWHdibsueLX2eZ6u7cmzz7s09z2Mx+I//8P1dHnkE1qyB2izCKBJ1JSVw221+Su/OnbB0aa5HJFESj/ufjaxXS9MsAYkYJY0kfMne6PRmNzxh3I1MdqFYUKAYjTYzLofjfwPNH4A5X4IT7sr1iCSXMnjvGDPGr6B23nm+2ujGG1Mcs20HxMvJ5NRh0UTfx6qxwicumquaB+zTWFIOJfXQlWUTiEU/g8IqaHkZWtb5Xl8jJcJ/57r/rzft2dTnebaqiquA3mTUxCqfRHrXu+DRR+GMM3wFxpo1obycSKQVFg6zlaOSAaNaWRls3RpCI2zNEpCI0eppEr7hrBghIyfZhWKqMx3FKL81neX/iWSoshJ+8YshdmrdAvFqKAhOHe4Y+kLnyPFH8uvnfs3chrkATKmZMmCf8cVl0DnWr4hJFitiVh8BS/4bHr/c9zNamCr7FYII/50bX+HjsnXv1j7P0z/A+IHfhxnW0AAfgx2tO4C+yagjj4R77hn+mEUOGkoGjGqNjX5hgG3boL4+16MRCY8qjURGiwjf+RaRUaB1C8TH+ObNAPuHvtCZWu1XUDt0rG+inLj8e8x8/f744jIoLCeTaW8p1cyF9/wPnP4Y1B6d/fHyUHeSaPu+7QCMK89w9bRBEmJNVU04fIfXeCw+7DGKiIxGRUV+9bQNG3I9EpFwKWkkMlpE+M63iIwCrdugeGxv0igN02qmAb3Jo2SfayqtgsIyYDhzPaS/4sJiAHa27gSgwMI71ZtbPze0Y4mIjEYNDfD44323pVxlb7CDpLNN5ABR0kjCp2VGo08xEpFMde6H4syqVqbW+GRR85jeXkb15X1r9otdGxSW0nNKksa0Nxlap+uksCDcLgRz6ucAcEjtIaEeV0RktGhqgj/+EXbt6t2WcY8jrbAoEaOkkYRPy4xGn2IkIplyHVBUndGXjC0dC/QmGwAayn1yeste31C5oG2bb2BdECw3k8a0t5yLeOK9e4padzVXRgb53rqTf8M6roioguQgMG8e3H+/X0mt29tv5248ImFQ0khktIj4RYyI5DnXBZbZ7VIzw13rmFk3s2dbXVkdADv278AwaN0O8SqwPOqRE/HE+8yx/v97zrg5Q+yZxCDfW/eKaZPHTA5zuCIHD1WQjHonneQ/fvWrvin23r1w2WU5HZJI1rR6mshooZMOEQlLshW0nnwc5mZ/2jCurHeKW315va9gildBrCjrY4t3+LjDefj1h5lVNyvU4zZVNQEwoXJCqMcVERktFi+G/fvhW9/yU9Q2bYKVK3M9KpHsKGkkIiIifSVroG9ACE2V6yt6expNqJwArtMnjSQ0k6omAfRUBoVlYqU/Xvf0NxER6aumBo44Ap58Em680W+LxXI7JpFsaXqaiIiIDM3hp1J0K+me+prZqUR3TyOAhoqGYNqbzqjD1FjR2OdjWLqbmNeV1oV6XBGR0eSLX4Ty8t7nRSqklTynSiMREREZWhe+Kqjb+4Y3JbampKbncX1ZPbidoVQwSa/GysY+H8MSK4hxw3tu4PRDTg/1uCIio8m558LRR8Pq1VBQAFdckesRiWRHSSMREREZmqNv0miYakp7k0a+0mhbxg22ZXANFb6aaySmkX32uM+GfkwRkdHEDO67D77/fRg3Dj7ykVyPSCQ7OksTERGRoTmgc3/Wh6ktre15PK5sHLS/EBw8UNIA+zehGfTD192oWr2HRERyo7QUrroq16MQCYeSRiIiItJXQ8PAZtidQOuWrA+dOD2tprQGOgpCmfYmverL63HXuqF3FBERERmCbuOJiIhIXxs3+qbXif9OORNat/Zthj0MidPTakpqfBNs15XtiEVERERkBGSVNDKzWjN7wMxeCj7WpNjvp2a22cz+ns3riYiISI4Uj4W27dDVltVhBlQaWUEovZJEREREJHzZVhpdBTzknJsBPBQ8T+YWYGmWryUiIiK5UjwO2ndCV3tWh6kuqe553FNp1L4z29GJiIiIyAjINml0DnBr8PhWYHmynZxzjwDbsnwtERERyZXiOmjblXVVUDwW73lcU1oDBXFo3wWd2VUwiYiIiEj4sk0aNTjnNgAEH+uzH5KIiIhETtEY6Gihz0pnWaotrYWiGp80cv0qmMaP9+sWm/VuM/PbRUREROSAGHL1NDN7EEh2hnZN+MMBM1sBrABobm4eiZcQERGRTMWrYe9bvjIoJJVFlb5X0s7noatfBVP/1duG2i4iIiIioRsyaeScOy3V58xsk5k1Ouc2mFkjsDnbATnnbgJuAliwYIHWixUREYmC+BjYtwEKikM7pJlBvAo69wFaQU1EREQkarKdnnYXcEnw+BLgziyPJyIiIlFUVA10wf6ESp+uEBI98Sro2EeY095EREREJBzZJo2uB5aY2UvAkuA5ZjbBzO7p3snMbgP+Csw0s/Vm9tEsX1dEREQOpKJa3wR75/O92zr3ZH/ceBV07Cb7UxIRERERCduQ09MG45x7Bzg1yfa3gWUJzz+YzeuIiIhIjpVP8tPINq2E+sUQKwEbXqInZjE6u1dhK6yC1q0QKwpxsCIiIiISBt3WExERkaEVlkOsDN68HVwwLa1127AOFSuI9T6JB0kjy+o+loiIiIiMACWNREREJD2lE6FlHexaB10dsO4HwzrMZUddxuLmxf5JvNInoVrfCXGgIiIiIhIG3dYTERGR9FTNhJYX4M9nQOMSeO2XMP+bGR/mB8sSkk3xKt8rac+rUDq+d3tDA2zaNPCLGxqGMXARERERGQ5VGomIiEh6xh7jp5Ht3wiv/rx3mlo2iqqhqw22P9O7rbMNNm4E5wb+27gx+9cUERERkbQoaSQiIiLpqZ7j+xqFqbDSN9Te9ji07/bbOveF+xoiIiIiMixKGomIiEh6aub7qqAwmUFxHWz4I3Q3yI4Vh/saIiIiIjIsShqJiIhIesonQdnE3ucFReEct6wJ9q6HvW/7KWhb/xrOcUVEREQkK0oaiYiISPqmXtybLLKQ1tOomOY/rroUWl6EJ64I57giIiIikhUljURERCR9Uy8EC6aRlU8O55jVc30CavOf4feHwc7nwjmuiIiIiGRFSSMRERFJX8U0WPhDv5LaCb8L55hVM8NvsC0iIiIiWQuprlxEREQOGtM+7P+FpfJQwIV3PBEREREJhSqNREREJLcqDwl/VTYRERERyZqSRiIiIpJbsWI/3U1GxvjxYNZ3m5nfLiIiIjIIJY1EREQk9yZ/AGKl/nFhVW7HMtps2pTZdhEREZGAkkYiIiKSexPOpKevkWvP6VBERERExFPSSERERHKvYgpM+2f/+Iiv5HQoIiIiIuJp9TQRERGJhgU/gMO/AGXNuR6JiIiIiKCkkYiIiESFFUD55FyPQkREREQCmp4mIiIiIiIiIiIDKGkkIiIiIiIiIiIDKGkkIiIiIiIiIiIDKGkkIiIiIiIiIiIDKGkkIiIiIiIiIiIDKGkkIiIiIiIiIiIDKGkkIiIiIiIiIiIDZJU0MrNaM3vAzF4KPtYk2WeSma00s7Vm9pyZfSqb1xQRERGRDDQ0ZLZdREREJJBtpdFVwEPOuRnAQ8Hz/jqAzznnDgMWAZ8ws8OzfF0RERERScfGjeDcwH8bN+Z6ZCIiIhJx2SaNzgFuDR7fCizvv4NzboNzbk3wuAVYC0zM8nVFRERERERERGQEZZs0anDObQCfHALqB9vZzKYA84FVWb6uiIiIiIiIiIiMoMKhdjCzB4HxST51TSYvZGYVwO3Ap51zuwbZbwWwAqC5uTmTlxARERERERERkZAMmTRyzp2W6nNmtsnMGp1zG8ysEdicYr84PmH0S+fcHUO83k3ATQALFixwQ41PRERERERERETCl+30tLuAS4LHlwB39t/BzAy4GVjrnPtulq8nIiIiIiIiIiIHQLZJo+uBJWb2ErAkeI6ZTTCze4J9jgcuAk4xs6eCf8uyfF0RERERERERERlBQ05PG4xz7h3g1CTb3waWBY//Alg2ryMiIiIiIiIiIgdWtpVGIiIiIiIiIiIyCilpJCIiIiIiIiIiAyhpJCIiIiIiIiIiAyhpJCIiIiIiIiIiA5hzLtdjSMnMtgCv99tcB2zNwXAke4pdflLc8pdil58Ut/yl2OUnxS1/KXb5SXHLX4pdfkoVt8nOuXFDfXGkk0bJmNkTzrkFuR6HZE6xy0+KW/5S7PKT4pa/FLv8pLjlL8UuPylu+Uuxy0/Zxk3T00REREREREREZAAljUREREREREREZIB8TBrdlOsByLApdvlJcctfil1+Utzyl2KXnxS3/KXY5SfFLX8pdvkpq7jlXU8jEREREREREREZeflYaSQiIiIiIiIiIiMsr5JGZrbUzF40s5fN7Kpcj0eSM7NJZrbSzNaa2XNm9qlge62ZPWBmLwUfa3I9VhnIzGJm9jcz+33wXHHLA2ZWbWa/NbMXgt+94xS76DOzzwTvk383s9vMrERxiyYz+6mZbTazvydsSxkrM7s6OF950cxOz82oBVLG7tvB++UzZvY7M6tO+JxiFwHJ4pbwuf9jZs7M6hK2KW4RkSp2ZnZFEJ/nzOxbCdsVuwhI8V45z8weM7OnzOwJMzsm4XOKWwQM59o709jlTdLIzGLAjcAZwOHAB83s8NyOSlLoAD7nnDsMWAR8IojVVcBDzrkZwEPBc4meTwFrE54rbvnh+8B9zrlZwJH4GCp2EWZmE4H/DSxwzs0BYsAFKG5RdQuwtN+2pLEK/uZdAMwOvuaHwXmM5MYtDIzdA8Ac59xcYB1wNSh2EXMLA+OGmU0ClgBvJGxT3KLlFvrFzsxOBs4B5jrnZgPfCbYrdtFxCwN/574FfMU5Nw/4v8FzxS1aMrr2Hk7s8iZpBBwDvOyce8U51wb8Gv/GIxHjnNvgnFsTPG7BX7xOxMfr1mC3W4HluRmhpGJmTcCZwE8SNituEWdmVcAJwM0Azrk259wOFLt8UAiUmlkhUAa8jeIWSc65R4Bt/TanitU5wK+dc63OuVeBl/HnMZIDyWLnnLvfOdcRPH0MaAoeK3YRkeJ3DuBfgSuBxMasiluEpIjdx4DrnXOtwT6bg+2KXUSkiJsDqoLHY/DnKaC4RcYwrr0zjl0+JY0mAm8mPF8fbJMIM7MpwHxgFdDgnNsA/ocbqM/dyCSF7+FPxLoStilu0TcN2AL8LJha+BMzK0exizTn3Fv4O61vABuAnc65+1Hc8kmqWOmcJb98BLg3eKzYRZiZnQ285Zx7ut+nFLfoOxRYbGarzOyybg8/AAADN0lEQVRhM1sYbFfsou3TwLfN7E38OcvVwXbFLYLSvPbOOHb5lDSyJNu09FuEmVkFcDvwaefcrlyPRwZnZmcBm51zT+Z6LJKxQuAo4EfOufnAHjSlKfKCueXnAFOBCUC5mV2Y21FJSHTOkifM7Bp8af8vuzcl2U2xiwAzKwOuwU+RGfDpJNsUt2gpBGrw02c+D/zGzAzFLuo+BnzGOTcJ+AxBVTuKW+RkcO2dcezyKWm0HpiU8LyJ3vI4iRgzi+N/aH/pnLsj2LzJzBqDzzcCm1N9veTE8cDZZvYafvrnKWb2CxS3fLAeWO+cWxU8/y0+iaTYRdtpwKvOuS3OuXbgDuBdKG75JFWsdM6SB8zsEuAs4EPOue4TZsUuuqbjk+xPB+cqTcAaMxuP4pYP1gN3OG81vqq9DsUu6i7Bn58A/Ce905gUtwjJ8No749jlU9LocWCGmU01syJ886a7cjwmSSK4a3AzsNY5992ET92Ff+Mh+HjngR6bpOacu9o51+Scm4L//fqTc+5CFLfIc85tBN40s5nBplOB51Hsou4NYJGZlQXvm6fi56ErbvkjVazuAi4ws2IzmwrMAFbnYHySgpktBb4AnO2c25vwKcUuopxzzzrn6p1zU4JzlfXAUcHfQMUt+v4LOAXAzA4FioCtKHZR9zZwYvD4FOCl4LHiFhHDuPbOOHaF4Q555DjnOszsk8Af8SvM/NQ591yOhyXJHQ9cBDxrZk8F274IXI8vRf0o/mLp/ByNTzKjuOWHK4BfBkn1V4B/xt8YUOwiyjm3ysx+C6zBT4/5G3ATUIHiFjlmdhtwElBnZuuBa0nx/uice87MfoNP3nYAn3DOdeZk4JIqdlcDxcAD/nybx5xzlyt20ZEsbs65m5Ptq7hFS4rfuZ8CPzW/nHsbcElQ4afYRUSKuF0GfD9YsGM/sAL0OxcxGV17Dyd21luNKyIiIiIiIiIi4uXT9DQRERERERERETlAlDQSEREREREREZEBlDQSEREREREREZEBlDQSEREREREREZEBlDQSEREREREREZEBlDQSEREREREREZEBlDQSEREREREREZEBlDQSEREREREREZEB/j/VDW4yY5xE/AAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -2417,19 +2473,7 @@ }, { "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2441,7 +2485,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2455,13 +2499,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "tal hits: [MotifHitAndCoord(motif_idx=0, motif_score=0.8168112706641384, precision_at_motif_score=0.8856918434803535, example_idx=12, start=78, end=103, is_revcomp=True), MotifHitAndCoord(motif_idx=0, motif_score=0.9988549902881714, precision_at_motif_score=1.0, example_idx=12, start=87, end=112, is_revcomp=False)]\n", - "gata hits: [MotifHitAndCoord(motif_idx=1, motif_score=0.9991710670547282, precision_at_motif_score=1.0, example_idx=12, start=9, end=34, is_revcomp=False), MotifHitAndCoord(motif_idx=1, motif_score=0.9987750034461544, precision_at_motif_score=1.0, example_idx=12, start=54, end=79, is_revcomp=False)]\n" + "tal hits:\n", + "\n", + "gata hits:\n", + "MotifHitAndCoord(motif_idx=1, motif_score=0.7484393570283403, precision_at_motif_score=0.5937741511866684, example_idx=12, start=166, end=191, is_revcomp=True)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2480,7 +2526,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2492,19 +2538,7 @@ }, { "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2518,13 +2552,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "tal hits: [MotifHitAndCoord(motif_idx=0, motif_score=0.5458333821414315, precision_at_motif_score=0.04620324188764962, example_idx=13, start=166, end=191, is_revcomp=True)]\n", - "gata hits: [MotifHitAndCoord(motif_idx=1, motif_score=0.9967916625348455, precision_at_motif_score=1.0, example_idx=13, start=7, end=32, is_revcomp=False)]\n" + "tal hits:\n", + "\n", + "gata hits:\n", + "MotifHitAndCoord(motif_idx=1, motif_score=0.7484393570283403, precision_at_motif_score=0.5937741511866684, example_idx=13, start=9, end=34, is_revcomp=False)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABI0AAACMCAYAAADx21mCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3gUxRvA8e/eXS6dJEAILXQIvVfpSBdBFBSwYq+o6A9FVIoioqggIggqitJ7b1Kk9957LwklpCd3ufn9MWmXAgkEQvD9PM89udvs7c7u7c7OvjM7YyilEEIIIYQQQgghhBAiJVNOJ0AIIYQQQgghhBBC3H8kaCSEEEIIIYQQQggh0pCgkRBCCCGEEEIIIYRIQ4JGQgghhBBCCCGEECINCRoJIYQQQgghhBBCiDQkaCSEEEIIIYQQQggh0rDkdAJuJn/+/KpEiRI5nQwhhBBCCCGEEEKIB8b27duvKKX8bzXffR00KlGiBNu2bcvpZAghhBBCCCGEEEI8MAzDOJ2Z+eTxNCGEEEIIIYQQQgiRhgSNhBBCCCGEEEIIIUQaEjQSQgghhBBCCCGEEGlI0EgIIYQQQgghhBBCpCFBIyGEEEIIIYQQQgiRhgSNhBBCCCGEEEIIIUQaEjQSD7zISIiPz+lUCCGEEEIIIYQQuYslpxPwX1WiBJw+ndOpEPe74sXh1KmcToUQQgghhBBCiP+ibGlpZBhGW8MwDhuGccwwjI/T+f/ThmHsSXhtMAyjWnasNzc7fRqUkle2vAIKojCcXwEFUQrKltX728MDfvzxPkhrFl8SWBRCCCGEEEIIkVPuOGhkGIYZGAW0AyoC3Q3DqJhqtpNAU6VUVeALYOydrleIJJcvpzvt8GE4d05/jIqCcePubbKEEEIIIYQQQojcLDtaGtUFjimlTiil4oApQKeUMyilNiilrid83AQUzYb1CnFTkyY592V05EjOpUUIIYQQQgghhMhtsiNoVAQ4m+LzuYRpGXkJWJwN6xXipubMgbi45M8uLjmXFiGEEEIIIYQQIrfJjo6wjXSmqXRnNIzm6KBRowwXZhivAq8CFCtWLBuSJ/6LFHD0qPO0iIgcSYoQQgghhBBCCJErZUdLo3NAYIrPRYELqWcyDKMq8CvQSSl1NaOFKaXGKqVqK6Vq+/v7Z0PyxH/RuRRPQHp6gilbunwXQgghhBBCCCH+O7LjVnorUNYwjJKGYViBbsC8lDMYhlEMmAU8q5SSnmXEXXeQClitUK4cXLsGK1fmdIqEEEIIIYQQQojc5Y4fT1NK2Q3DeBtYCpiB35VS+w3DeD3h/2OAz4F8wM+GYQDYlVK173TdQmTkBKWIi4NPPgGzGWrWhLp1czpVQgghhBBCCCFE7pEdfRqhlFoELEo1bUyK9y8DL2fHuoTIjEMEYbPB44/roJGbGzz7bE6nSgghhBBCCCGEyD2kpxeR+wUEpJl0wFqDihVBJXTJ7uICrVvf43QJIYQQQgghhBC5mASNxP2pYEEwDOdXwYLpz3vpUnJ0CEApgis0o0oV/bVEJUrc1RQLIYQQQgghhBAPFAkaifvT5cuZm5aB0FCoXFmPnJYoLi4b0iWEEEIIIYQQQvxHSNBIPJAiIqBKFTClOMLt9pxLjxBCCCGEEEIIkdtI0Eg8kCIioFQp52kuLjmTFiGEEEIIIYQQIjeSoJF44Njt+lE0Pz/n6a6uOZMeIYQQQgghhBAiN5KgkXjghIWB1ercnxGAxZIz6RFCCCGEEEIIIXIjCRqJB8716/pRNA+PnE6JEEIIIYQQQgiRe0nQSNyfAgIyNy0doaHg7Q0ORzanSQghhBBCCCGE+A+RB3bE/enSJf3XMPRfpTL91chI3Z9RXJx0fi2EEEIIIYQQQtwuaWkkHjgOh25pZLfndEqEEEIIIYQQQojcS4JG4oETHy+dXgshhBBCCCGEEHdKgkbigRMfD2Zzlp5oE0IIIYQQQgghRCoSNBIPHIcjuSskIYQQQgghhBBC3B4JGokHjmFIKyMhhBBCCCGEEOJOSdBIPHDMZmltJIQQQgghhBBC3CkJGokHjsmkg0ZCCCGEEEIIIYS4fRI0Eg8csxmionTwSAghhBBCCCGEELdHbqtFrhNjjyHOHpfh/61WCA0FF5d7mCghhBBCCCGEEOIBI0Ejkeu4D3bHc4hnhv/38dFBI6v1HiZKCCGEEEIIIYR4wEjQSORKdoc9w//5+UFsLMRl3BhJCCGEEEIIIYQQtyBBI5GrONSte7j29dUBo8jIVN+VzrGFEEIIIYQQQohMk6CRyFXOh51Pep9RAMnNTf8ND3eeLi2PhBBCCCGEEEKIzJOgkchVDl89nPT+zI0z6c5jGODpCRcuOE+Pjb2bKRNCCCGEEEIIIR4sEjQSucrhK4fTfZ+alxfs338vUvTfERUFO3fCxYs5nRIhhBBCCCGEEPeCBI1ErrL78u6k9ylbHaWWJw/s2wfR0cnT3N3vZsoebKtXQ4kS0LQplC4Nn30GSuV0qoT4b4qKgitX5BzMVZSCs7Nh4wuwZyDYwm/5FSGEECJXKFhQP+qR+lWwYE6nTGQTCRrlJlHnIHgtRF/K6ZTkmK0Xtia933VpV4bz+fnB3r3Oj6TduHE3U/bgOnwYHnkErFZ44QWoWxe+/15fC4QQ905MDPzvfzp/K1IEatcGe8YDSf7nKAVTpkD16lCtGkyYcJ8E1pQD1j4OG56Fk3/Cga9hXim4ySigQghxOz5b9RmXIy7ndDLuyJJjS/AY7JHTyRBZcTmDYy6j6SLXkaBRbuCwwda3YH45+PdRXdj8j9ZSpgwU7by0M8P5SpeG3budWxftzHh2HZBb2xWmuMF0X9g7COJjsiHFud8770ClSnDwIAwdCgsXwqef5nSq7j+XLsHGjfqvEHfDCy/AmDHQrRv07q3LYhZLTqfq/tGzJ7z8MsTH66D2m2/eJ5UFR36Gy6uh2mDoGgat14FrfjDJjyeEyD7BkcF8ueZLhm8antNJuSN/7v6TaHs0p0NP53RShBAJJGiUG2zvDWdnQvWh0Go9VP4cXLxzOlX33I0YXfr3dfUFbt7SqHJlCAvTrY1Av58wIYOZY4JhcQ0I3QOVP4VSPeHISLBHZWfyc6XoaPj3Xxg/Xncu7u6u/777bk6n7P4RG6tvVEuWhHbt9N/74kZVPFA2btQB26VLYdQoGDhQB3KFtmQJzJ4NkyfDpk2wfj3MnAm+vjmcMKVg30Co0h/KvKKv3b7VoeW/OZwwIcSDZsWJFQCsPr06ZxNyh1afXA3AipMrcjYhIvMCArI2XeQ6Us11v4s6D8d/g1b/gm8VMLuBV6mcTlWmHDiggzYFCkCTJmA239nylhxbAkBobGjStAthFyicp3CaeUuVAg8P+PFHGDtWT5s3L4MFb38f8lSA5ovBZNUtuyp8AK557yzBD4BNm3QQpFQpMKUIMZsk3JykZ0/YtUsfX3Xrwtat4OOT06kSD5opU+Dxx6FqVd3RP0gro5R+/BFefRVatNCBbYBGjXI2TQCEHwNHPJR9XV+/AUxmMMujF/cjY6BBJf9K7HtzX04n5dbCj8G+wXBpGZhcofRLENTrP1mpKLQp+6YAsOncphxOye2zO+xcitRNtqfun8qLNV7M4RTdG5FxkcTFx+Hn7pfTSbk9ic3sE/uuuC+eDRfZSYqc97vzC6BAE8hTPrnAabm/e3S+fBk6dYLQUKhSBUJCdKfU58+Dq+vtL3fD2Q1ppq08uZJnqj2TZnrZsjq/+usv8PaGHTsgPL0n+hw2ODcH2m4DS8KdhsmFDBvhFSyY/vO5AQEP5HNJJ07oVluxsc6P+rm55Vya7ifHjukWDnv36kPDbIbmzXM6VbmHSihUGNJB1i0tXAg//ZQcMAIJ3iaKj9ed9Y8YkRwwAuf36YmNhe3b9ferV9fXimx3bSvkq6sfdzanyDhdvDL+zl104oQObLu7Q7NmetAIoR0IOQDA/pBbD70aGQkLFsCePZA3L3TsqMsd98y17fBPcyjRHRrPhLjrcOh7KPOqBI3+o5RSzDsyD7NhJl7Fc/zacUrnLZ3Tycqy7Re2A2A1W1l2fBlKqf9EGcFvqB82hw3H547/xPaK3EeKnPe7kHXg3xDM93egKJFS0LKlbnGxYweMG6cLVn//fWcBI4CT108C+kJiSegL4tDVQ+nOW6FC8shpP/+sW8yk68Z+cAsAr5LO0y0SFQF9M+XiIp1eZ2T6dGjTRt9sJraku9MWdTkmvZEv7vKoF6ZBJkyD5DKUGdeuQblyOZ2K+1N4uM6rSmWyEa7DAZ98om/yx42DP/+EWrXu0mOl9iiw+gIpMtFZBWGSAZOyJ7MIjQklLCbspvMEB0PDhrpfrJ07YeVK3Wot3cqU2xBliyI8Nnf3tfjnrj+T3u+9vDfD+davh+LFYcMGKFNGZ5UdO97jx5I3PKv7yKr5PeSvD4XbQZM54OZ/DxOh1RhTA2OgQbwj/p6v+79AKcWUvVOIjIu86XwHr+jnlWsVqgXA0uNLbzr/hQu664EhQ/TfCxeyJ713au7huQBULVAVgL3BGZ+LD4qIuAhsDhuQfgX5/WjWwVkUHFYQh3Lc9XWdOgXDhun+HF97DebMAZvtrq9WpCKl9fudw6ZrJxM7zMxkYXPnxZ1ExEbcgwQ6W7tWj+YzdKh+PMzXV9eMN25858tW6FYJox8ZTd9GfQEwSD+a4eqa9n7Xak1nxvgYcPHR+znRzfbxpUs6Mpay2aVScGQNrO0Cy5vCqkdg6UOw+VWIuk+uwrcpf344cyZtiwYZsUk7cQKCgrLQQiEHAjP3q/3BybX5iTWLImNWa/bd4D9oLBYdCMpsvjRwoK7U2L9ft076/nv9iKmPdzycnQMbnoN/O8L67nBsHNij7yBxXhB7xXlaTGJr1TsvbNsddvyG+uEz1Cep5V5qSkH79rrPtcWLYcAAGDxYt5DMrtZVnl95kufrPMTY7/4AEonb/MPGH7JtmUopvtnwTdLnP3f/me58UVE6QDRrFnz1lX48uVeve/xYcvgxiL0KZV5ObiENzu/vVVJiw9l1WfcvOefQnGxddlx8XFJflnfVfT5U+PzD8+k+qzsf//PxTecb+O9AALZf1NfTgasHpjufUtC3L3TooMvpTZvqv+mWkXPAiM0jgORg0YDVA3IwNffG5L2Tk95/t/G7HExJ5r0w5wUuR15m5oGZ2bbMsDD9qPmzz0KXLjpv7dsX2rbVlTzffAPvvQfr1umnWcS9lS1BI8Mw2hqGcdgwjGOGYaTJ1Qztx4T/7zEMo2Z2rPeeuJc3eemt67upELIFbAm1iJkobK46uYqaY2tSc+y938179+oa29QR4Fs9JpAZia2KaheuTfWC1QHYcXFHhvM3aOD8Od2WTh5FIeIEGCme1Mxqgf76HljVTndQ3mwhNJwIDy+H2iPBI21/S7lJo0bJj2+kFH0H91APEj8/XYMf9SD0mZ4YEE2k1F195LLPP32S3vde2jtbl30h7AKHrqTfCjG3qllTP6IWF5fqH/f5Dc+94Ompz8Vt2249r1K6xnLcOB0wyZNHvzxcY2BpXd36tM4oaDwLGvypK23sd1AB498Arm5JeOw5gVv2dQw6dvvYpPezDs5Kd569e+HqVfjwQ72v3Nz03+wKGK06uSrp/Xcb7v4Nzw+bfiA0JpTey3oTZcuezHfCbueRMr7b+B12R9oo5KJF+lysUSO5XGOxOD82mhlxcfDPP7rPxZEj9UAdx49n8suxV8C9EKgUF+Zsbr2WWSM2jUh6/9K8lzIMXN6OaqOr4TvU96atvh50doedTlM7AfDT1p+4Hn09wzx/6Y7pQHIFa3BUMLb4tM0x5s/XN91r1+ob84ce0n/z579325WRsNiwpHPaZOhb1NWnVudgiu6N/y3/H6CfpJh9aPYtR41TSt3RueZw6C5DjhyBs2eT79kcypGpFoObzm0iPE7XYj0548lsaWW4fbvOW0uXht9/h2nTdPDo9991q85HHoFixfSTJAMGgP+9b1T5n3fHQSPDMMzAKKAdUBHobhhGxVSztQPKJrxeBUbf6XpzjYiTsO9r2NlXd1i470vYkXCzFHf91t/fDpxZDPGx+vMtCpuXIy7TYkILAI5eO8q47ePuIPFZV6wYHD2atoPWOw0yKKU4e+MsAIF5AgnMEwgkN8dNz3PPOReK0+3/w6MouOWH05OSa5OzWqDf/5XuR8Cnou6nwuqra/zMN38e70bMjTTNOiPiIgiJDMna+u+iAgUgMBD69NF9OID+LQ89WPfjt61jRz2aVabd48DM/WrdmXUsOroo6fOaM2tYfHQxoB9zGblppC4c34YL4Rco8kMRKoyqwJrTa7IlvaALU9XGVMMYaHDk6pFsW25mde2qH6NKGTSKvPnTCvcvh123lri+C67vhsjTkJUm7gMGON0sGSaDR4vuYMgQ532S3v5RSvdllKYi49ivkKccBL2r+4QxWfTACMW6pv/Ij1K6wuHiMjg3H84v0tvjSF1jUlwv78DXYE9I0GNnM7+tN3Eu7BxvLXor6XPX6V3TfUwtJkYHiu5Gv6R2h532k9onff501adOrQiz265Lu+izvE/SDeUzs9L2aXg7ft72MwBuFjfMhg68zD00N2sLcdh0JdKlFfq4CF4HMWmv56tW6dYdbm7w/PPw5pv6hijTcV7vshB+RLeUTpuIrKU5tSwEoUNjQvls9WdJn2/E3uCrtV/d2foTjN85PqmisNqYanf30cf0rsv3ybX5ncXvAJDHVXc+1mlKp3TnizPDDavehkHNBlHYS1dYJrY6SmnhQt3632q9/x6r33xuMwDl8pVjeNvhgC4rpxf8uh1T9k7B+oWVLee3ZMvyssPcQ3O5Eatb1MXF6wv8zVqVxdpj8Rnig2mQKcuVYzEx8NZb+nXwoC7PnzoF/frBlWt2Sg4vieULyy3LTm3+auP0+b0l72UpHel56SXdyqhVK90thskEFy9CxYr6+Ex5X5kYpFdKcT7s/O0F0KTCLcuyo6VRXeCYUuqEUioOmAKkztU6AROUtgnwNQyjUDas++67k5u8mGBYVBUqvAeV+0L596D8+1BtkP6/a17nA/X119M++nTaAQHVYHV7CD8Kj52/6Sof+u0hp8+vLniVyxHpdNx8l7RrB6dP61qziAh9gxMRoSPad+JC+AXsDjuuZld83Xwp5lMMs2HmXNi5DJ+nbd06uYWM2Qzdu9kgdC9cXgUXl8OFZXDxHwh8Cnb2gYtLwREHHU9mLXHe5SDyBDgSAnt7Bugav6npVz2evXGWmr/UxHeoL+ZBZpYe01GHHzb+gPcQbwoMK0Cbv9rcm2bZmTBsGEycCK+8opvg//GH7scnN4q1x7Lp3CYi4m6j5UA6F5iHGptwOX2MZ5/VzWrDwu7+I0TRtmg+W/kZzcY3Y9PZ3DlCysjNIwEI8AygkJe+FIzaOoqZB2bi+ZUnvZb2Iu83ebMc9D4depoi3xdJ+tz0j6ZM3Tf1jtMba48lYFgAey7vASDopyCn5uT3Qrduus+Uli31yJTXr+vHY+7nG5404uNgdQc4/qvup8+7HHiX0QEjexYiYAMGpNnmj6fWZOVKeOcd3f9TaKhuWZOayQSPPQbffuscVIpx5AFbRHIHboktN6a6p229EboXltQGWzgENIci7aFwW3AtkH6rpOpD4dBw2DtQB8guJkeaL0dcZt7hebfsryQ9Hyz9wOmzQiU9opJSrVq6NeSSJfp6DLqmOUtBx8izehuOjILjf8LJSXB8PCPmdU3zSFrije7+4P28MPsFZhyYkW39XnSe0lmnP2F5sw/NTjovMy1V0NFuNth/bicAC7ovoHcD3fJx4dGFab7avr1+tHHHjuR9abdD7Nb+sPVtHWAMaA6FWkPemuCStqfxd9+Fzz7TfUy5uurySb58WWiR7ZoPinSETS/qPrNs4fDovQ9k/7bjNwC8rd4U8db57ujlS3jrLRg1SrekWr8eVqyAMWOSb1Rv5XzYeV6clzxilkLR5I8md2Ub7mdRtih+2fYLoFvgAKw9s5azh7emuVfYeGw1GBCUL4h+TfrxZKUnAZIqY1Jq1Qo2b9blc0fCaem4+93SZMriYzq9T1Z8kldrvUop31I4cLD1wtY7Xnb3md3pPqs7NoeNer/W46PlH93xMrND4mOdj5V/jA8a6Dx9w9kN6QZCwmLC8BvqR7hNFzQrjKrA7IOzM72ukSN1vv/TT7osUa2aDiAO/MJGuXEFOBN2BtBlp2EbhqW7jDWn1xAWp49HU0IY4fddv6fbMjPR/uD9jNoyiitRVzKcx8tL56kpn2yoV08PpBQRoQNeiSIiYP2Z9ZgGmSj6Q1H8hvqx69KuzO6GnJHquoNhwIABrD+zHusXVoyBBkPXDcVxv5yM6TDutCmpYRhdgLZKqZcTPj8L1FNKvZ1ingXA10qpdQmfVwAfKaVu2pi8du3aaluq9uanR5ahWI8pejSxBOsnT6dO4XlYm/7lNG/EX0Xw7rpN18okGPzb//j0XNoToZrJi92OCKc+ct62dGNolVO4tVuGYdVNVlRcOK2Glma/Syz+eYpiAJcjQ2hqq02U6zreeeQvqhSoxJGrR/l9+xi+Dd9O/g6TMPzrYThiUPuHcHzlNMp+cBxHXITTctf/8DoNOtTFVPbFpOknj0TQse0Vdn/fCiPmIhAP8dGc/qUEJdacctqGKVU86f5EJF4uXox75CemH5jFrCPzKLN9Kq9Ur0Gvbusx4nUpJ8bminnX+3j2OOE09O/qMd/RqM41LLUGO++gWQWg/V5uxATw518utGtjp5wxCkL3QZ2fWbDQzPkLBi88Z+fIL215eMgqGjayULacQWiownL6V4Z/vBKXRs43gSd+rkWpHn+Ab5WkaRumzaa2/1Sszack7YcVRxbQalIHCnvk5+x7J3EoB25f56XN9ZrMbOWFtdU8p33JP02g0if0HdmR4SNdMJthx+jXCKpeCKo6F6offVQxrFsvypl/SxjdxsGuoyV4bepS5i4poJep9Pl9+PceNO7SDFOpp5PWd3j3FYJnP0mj1sV0YNA1H8acQAbP/oQmj9emfn0TGCZAsWz/Hjps+4zUiihvzhupog0xeeDrG9w4exhr6L8YtlCUiw/rFx+maTML5uqfJ8+rHDDLn+iWx1m8Ih/HjpsoVFBRKOw7mtW7gKX20KRZo23RfDiqGF3bj6VZuc7YHXZ+3j6O2pHbeMjDzKkC41i4yEJ0NDSoH0/DqyX438o9/Dw+gJgY8HAHX19F/QYm/hh7FcuFGRj2cOLzNSbypY74Lw92PnTozLjmfzHrtw2Ywg+BIwZlzUftLs8w9Fsrzatuxnx1LcqSh6WHuzPkG09WTVmNKXy/ntfFj4C63diyw4ugoOTlrl+nGPbZfiaP2YvJiAcUKHhr2hfUr9uYns2HYxgG0w/OZuHqBUy4Pi3Nfq+/aR9PtytLz6fOYbk0D0wWjsZ1o1mb/Jw6FoXl0hyM6HM4PEtjqvUsrhGpmszlgZOflaTJ8GPYbAaFChtcvKh47jkDV1dF39f3YL6yElCEu9bDbUMbPHucwnD3TzpWPxj+FDb/C7zZ5lfyuedl2cmVTDs4k9WvzmbvbjsF4pdiijyGci3Ak/PGMD92c5rtKDY2mNUzdlA4zxkMQ6EwWLXkClXLnKNQk7dSzKkoVz2QGRPOE5R3LYYtFMxubFofSf0ym7A2m+h0HtWuFc/Q7zxoWGYtphvbURYf5u16ktG/erLo9xWYInRtt7L6UXnGuxzHef+0pSHLWO9U921gYALiUVzodQyr2YX8PxSnVFQRTnikjS5PcXsCl7wfYMpXO+l+/uSZFfwV3YlH6vSmXuE6HLt+jNmH5vHv2fUA5HPPi7vFnXPh5ykaVZCDlex4dncOBr/b24WC/jbe7/4PpqhTAFyNKcZbvdyZMikWk0FS38WBE57lMs7BAHO8iX55zTz22EKqF2mA3WHnlx2/s2FyC/LFV2DIELCcm4QRH0VI/vaMmVyJDo9MoF6ptjiUg7E7x7N5dn2Mi9UZOcKO5fxkDHs49kKd4Z+muLeZy3VbGf6a6ELDh+Kpk+9Ptq8+Rpu+w4iKTm49smdIZUp3H4sR0Cjpd+PsbDg5AZrMZvFiMydOmujyuJ1OnewM+sqLRjVOYbk0D+VagO17fKjl8S2ubZxvkFs+HM+bvTxp08qO5cx4lGcZlNkN8673sLb/l3/+MbP/gIlH2tm5Nv9J6nR5CqPY40nfP7RpD8UvvYj7Yymu4bYbGHOLo7qEYrh46SDN/q/gwBCw+kGnM2zZamLjJjMtW8RzdXkvGrYLwhT0RtIigs8E47mmJp7PnHPO83f3ZfLyhrzy5VPYbDrP9vGM4NT3hfB8+oxuNZTg6vofaPPG8wQGBfLEE7pWc/kyB23zPM0TXQyMyv1gRQuM2BBWH2xCw3YVsdT5Nnk7gv/F2N0P2u9C2SMxHDbU/q9x7P+W7ZF9OOLWH4UpMUvi44/s7Pr9A/zD/wRHNJg96HUggJ9MaSsoIqsUwVr3T1btfYhdu03kyaMo4z6PRgV/xdoy+fGzyxHBFP2xNPHA8Tf2Ehp7g1q/N6JtWF1mNTXj1m6Z03L3jX+d1p+O47HH3WjUWNcwj/oJHAo2zluPOWw32CNRLr7sX7uFk6YXwa82hmFgGFD82ofUqmOFGgn7YVZB7NGXyXvUTLgRzz89FhCUryyBI4MoGOXPJY+0LWy2VKtFjeId2XjjQ7ZsMWMYULnsZR66VhHPZ52DnKt/GkjjJlbMVfsmTVt8cBmPzH6CPFZvVjy9kJmH5vL1xu8I3PkznYu+yFefnsYSvAQcNuLzNSF/UG327jUoZFmP+fpGHB6l2LD8DI2r7cOl3vCk42fZ4bm0mdyJQK8ATvc6xv6Qg1QZVxfrrjfp7v4FoweuxhR1BpQN5ZKXtdOX0n3kJJ5+2ky16gbXryuqXe9Ai2faYyr/FiruBsb+IXBwKE2//JcfvomkUpngpPxr7hwHoxb24JdxVkqXhvh4A4dD0b49fPrOfhqW24DhiAZMzNxyhkWR4/m4yyLK5w/i8NUjfLtpBBfHfMbfzz9Pfs/LULA52CI5uGkPJUsauHVybkVxbEwLyvjoIGsAACAASURBVHbuB0WT63NP7D5MwP42eHTd5zTv2h/eoWH7ypiCXkvaP+dORvBQ/RgOr9+EKVrfVCqg0MzehBLDv88soWFgA/x/KEHU2qd4xHU0M1N1c7L6x89o1CA23XILjx5n/da8bNpsplxZBwMPVWGH7TiPB3WifZnWvL74XewOO7FB7ri028Gh04EsXW6hSmUHKw6+zHLHMhqVf4riPoFsOLeZ/VcOsifgClerLGfRuvKEhBh4eSnaBk2gpMsCbHUnMWWqhStXDTo9ase+qB5le4zGKKgDUyouHM7NheO/EVNvHlOnWbhyxeDh5vGM/Kc0bRr35Mn6n6CU4o89f+N6ZR1dbKdYafzD0aMmYmLAx0dR40Z7and/A6NIu6RN3rNqM+Ui/4dbh1QtOdZ0JjrgaRbs6ca58wYuLrAp/gMmRYyibalWLOo2iz4r+jFs84/MUq3o+FRHTGVeSPqN3pz0IqOP/E7Pqs/wW4fRTDswi25znqe7vRz1a5XnzXYTMJvMLD6+jLVH5hE+qi47I97gk0+gSBGDCxcUHoc/olFTV8xVkoMpUeFRqDml8Oxxymn0x9Wjv6FRvQgsNQc5bYaPn5V9O8MoEL8cI/oMypqP4TOf4NAJP3760ZZwTQzHVvgpAsv4s2YNlM67C3PIChyepSg79XXOxwczt+tUHi3bnh5zejLlwAyO+pak9NOTwadS0romTbYwbTpMGnsSy5WVYI/EkacS4W+8TIHlzvnJCz0K8me5tBUpQbNOMnJAPI3LrcawXQOTld27TVTJ8zdu7Vc4zfvI0HJc8nGlQYlWmAwTG85vpvj1xpTe3YzBgw0MI7EdhmLzpN9o0LUjppLdk75/8KDBI49a2L9+L6brWzHs4cSYPCkw513iiOfoG7sp6VuCvN8HEhach7x/HOX0KRPmS/MwRZ7A4VWO/JOeJIpUra6i/PAYeZHLp69hubIcI+YiyjWAsZOKUbZ4GC1bWZLKMvsOuPHc+7WZMNmHSpXAZjNwcVGU/7oQJ1XaBgZ5h99g14qdFLAeAGUHw0zNOV9xIP48Y9r9yKs1elJtXH32huznTL6iFO0xHyNfDb0X4sJ5fdRzjL2RNqhVasIV/hzvQ83iGzBf34yy5uP4GV86v96It9/35/EndPnm+HG4uKgP740fwkd9zdSsaRARofhq1uusLDA2zXIrzT/BwI8DaVd/N+Yrq1AWL/491Y0P+/qycW0UloszMGIv4/CpwY7JI2nw1BOYyjyf9P0dmyPp8YyJbVvisFycgxFzCYd3ebp/2IEWzR283Gk95tCtYFg4HNaKVl0qcmLfBcwhSzFiQ1DuRbn49neUXLHTKV3BPvnx+MGWptxS9ety7HNcdN6IWE8q/L2NLUv3YTXHJB5SrJuzgcbNPbDUGJA8ry2cXl0WMWREUVxdHUk3q+tmrqZRvTDncgugTk1ny5wF1P+fcwZtGMZ2pVTtNDs0FcutZsiE9HoiTh2Jysw8ekbDeBX9CBvFihVL8/+A5WcxetVxmuZo3gjX4iHQyvkB/dCBhfC+ehjMCdMPDkOdnYeLAqsd3G0QaQWbCaKiosAj+VlgAPuxo7jXNvQjRwEBYI/AmO7NiQgzl9zjuZSiJcjx63vZ7hfGglRNR0uNeJr+w5pAVR8oUgQjPp74gnq3G6mWGxJRF7O1idP6HAuq0uPcs5g6H4UGQCHgNKxpVZgSv7wD5XvrFhD2CIJes9DnAHSZE0Gdfi/QwQpVG0DHGr2p0ek5KPNRQqavUFPL4uYWCW4Fkr7Pj5FsPt2U5g1r6TSkmM5MUN3K0JwdHKAiAz+I5UzHgXj5l2dow0EMoj8KmPjWDlZ1Xs/Zq17MnduJPVSlMsEEtT6E1Zo3zXJ93PJiWP0gsIzeYcteRx3+B9ciPk77od7mDvQ+Z6XJmisYfbwxA+OqwfWSBq4u9jS/0eWpEDCvK19ipiBvU43dXHo3nkutYmhauQPk9wf33eC6k1prehK0YDwUB2pFQwxEHPIi1BxAoVTt4Xbbj2K2tndaX/ySxmz65kkaTxgI5f8Ad6Ad9Ov8FXRPcZjvGUDBYz/TKhw+ngnNT8F5b/i8OXh5m/C8BJ+uAU8bTKsIv1eCpUCeo59C1b7gHgCLqrE3uBIPWxul2ZcrRzfjiae96NoDSgRZ2LHVRoGrUbQ6sBUeSj43zueF0b1g9IznKH0NQt3gqgf09TSY8Os0VkSY6NzFwOpuYmC/eBYGhDBsdiEepwFLaU3xqDNER7lRx+UcXvPmQ9464OkPewZwo7MnTNsD5Vsl/Z4uE7Yxo0IF3GM+gTJd9GN788vR/fwWHtn4C1xxh8INIeIy3psn888rJ/S8ZZ/Sx+u80nTIr9g6vwP2G95JlWv5jr7H7B/8IWiILnw67Kg5gfzqCObXTUd5edPvSdtcPqIEhVyh3jGodQEO54d1gdBmy5e87T0F8gAeBcFuw/XMCH4qXg+vmZMg8BHwKQaXljOxVw2efrarDgym2O8lZ57i5HkrU3mKQ8FBlOcwZ6aH0PeZ5bCjDhR/DAwz9n2f4ukWqR+HTHGs7jrrxaqoCH4a65xfjy/+CsVXT4Iyz0L+ihC2i5JR12kX5827M8IpGgYLy8L2h+Cv4Y2wVvkH3Jvq1nKGmbyz2lC4UDXwrZh0/LFvIEt6lKS093NQ+g1dY+2IwzTrUVwreqY5j54OeYmWe36DqDpQsC7cuEHefbNZ8tpJXM3fQIUX9c34nKL4hsfh7gq+sTpzD3MFy5VLOFJ166VQfHDSkwq7Iik0QJ/3kyrDxiA3zhd3of9EG1Uvw3E/+KyJmW5zZ6R5rGbyksvs2BzHjnVfO03vddybwGPh9N50DZOCGRVgdTkzXjXD0pwvVTY34ZVXdkL0ZxCom87lmduM2d80hNLznfbZK0fzYVyI4JO14GaHJWXgi8YwyGxj4ZDWbBsLa0vCO8+D1+YvmWmZjtc3X0EpwAT7r8DgSPh7TFdODYf1xeHNnuC1/iPmuv2B18QxOt8wg+uO3tjnQ/TTDanKEa6SDxOws+UP1Cpq4eS1sYynJ9fwo1P0PPK4Xsaw+urfDTAODoN9A2FpaSa0fIM3GEM8Bj++d54ebj/R5vOR8LpeF/Fg2VsXt3aWNPun8Y7XeKLrLzAQCEzYwcsBowC/PNab3vyAHYMBH9qY9+U5TC6eOh+/fBnyeeLoUwyPoNg0y/3qwy58MiwP1Cuv0+xQUNKAOdFs6tqSh1mBHYUrdn7pdwCzSzWnZTgGeuGVLyrNsbp9IvRY9BNN+JC/eBaFQefYmXi5RepWvSnScORv2HqoP5sO1WfF3BbYsdCN9aynIV1nDIQqU8ATiAaqGri4mNJsx7A3P+DDKlaM2hUgjw9GbCwPTd/Ah1/X45muEBenUApcXQ1OvPw5BTqMgXJAZeBaFL4FXChXxoXWO22UuwobAmFNcTg82o3HnihD1RYOqta1cu60nU0HbDz8ebxTGvxHRNL7rBvVN8dQaoCudBlXA8IDHbi3VmnS67cQToVMZ9kvrdnyS108iKKP3wnafrERj/B3oXR3sHgSPrUatd88leac271jKDPeeI0uNapCiZJQOBSLGXof8yTf0TBaDOiAAcwJgpVlLCypAj02wMMn4Vhe+LUmXFwVRvd1z/LoKwZtO1lAweIZ0PrhyDTpPXCpMc2tLZymV/g6lj7B0HF+OLU/aUJlC3g2AMeZ6Xwe+CasKwHFOoHZBba/ykcxj1J6+BdQM+F4t4P5ZFOstcs5HT91Nnfiw8vQesJljA+9qQR8Xx8ceU/w7kuPYvEdAaU76sqfWQVpuDuEM9cWMH/ko+ylCn5cZ7tREfu6XbT198coW1ZHIkua+HdwN+hwQRfm7RFgmOhaqgitC33H4vKVmeMWhM3NG+/Ys0z4ZDqBlb+EUs+AYQbDzMF5FZkYf5WJv9Zz+j36b7biv3wzlAcqjoc4cJyriPvAmDT7MuxQabh8GHx0wIdD3+NYOx/P4lFp5r0UVh+ztbbT/rEuLs6JcWWxBEwF95b6Mbz5ZfjwkAfWMzE0GtgWk4JpJWFN+TF0vL6Vv4u0wFGhsq5lio7mWvU1NGuattzimGHwfPeVzOIJ4jBwJZ4uPcvSyS+aD5+bi4dtLhUCYW4QWPdEs6N7D5qymjgsWHDQ7LXdbCt0hW1bRzntn2/HfMAMFcTngyzUa2AmPMzB2nmxeJy4RuvmxzlOaWy48Nn/FEd/DsFwTZuH7pj0KG0XRhGFBw4XK5+pGGI+vcT4lUPotnJI0roahtTnuxVLGTbCwqtvWHBxgdDrcOr3i5is3k75oupdBvd95+Fx5/uVCfVaMuhYJz7sb9CipQt2G+z7uzZ9lJVXflyO8Zw3H3mAa30wNwrFbPVw+o06XFiId4iJl1/+G+Pa3zxihf4PweAmR5i8+wjv7vZNWldBM1z0msCJZcNY3KEd6ylMES5g6rOXZi4tnX+jbxx4uUXrckuK323b2SY0b1wvze85qX57iu3YDVX6QqE6EHkR297hPHXWhte3Q6Ckvia6rn2Hd0M/o8rHX0CX5PPz5dAKGPHQsvpTGDb4PD8Uqw75nryW5l7BvuEEo2ttxHNXUSj/GlhLwbquhHT0gSnboOIjSfPWnj0NU1g4/X+LpPgN2O8PXzWGPk1bU61QGyjxEbgXBGXHtLAV7tXtabZtV5TBxXjFzmvJld/PmoJ5738uUOo7pzJDoX8KYv50AQm3swA4PCqyoV84Hhe7QdBrYPXBOj+Ij4954X/4BmUGVANgUllY4O9HjTy98Zo4GnwLgX8VOPAdb5/MS54Tl+mzHlwc+ryYVBre6tASr/XXoPInkL8JrG7H62XCsT62K7lSfs8AalwfyNbyrqyq2ZyVXnVx+ObDHBFKyycLkd/LTL+RF/C0weoSML8RDPy+Ol6F/wT/l3QfaiYLXaeNwRQRzzONemHYevFnQZhSGfyfDsFwzed0HuW9tp8qdle6bIil9DV9jVtaGl65MoBGa36CEj5QqCGEnaVS2F4ONi7L4vfK8fd7lYnCnQCC6d7pZ3adHcfiN9sxn0p4EUGzVvvJ6+7Ol39EE3QVdgfApy2g3vHBPLHtN4hyh8KNIeoqLuumMThPUbxm/gV5yoJfKdj3FfGqmC63BAQknZ/2pc34plApvGZPh6KPgHdhOD+flkfG8vbDi+Hsi1CsLThsWJd3Y35bLzzXh0OlPpC3Lqx5jE31K1Fy1I8Q9E7S8RM/0IyX+4005ZaHj/vS6Ar8bz3kiYXpFeFqCxuf/vkeVFiScODYwWTBbW4/XD4+A6ToN7AkjBxeCsoedzr+jKtNcRkfCQ2d8xmjRyHqT7yDAZoSO9O63Rc6lLE0xee+QN9U8/wCdE/x+TBQ6FbLrlWrlspNImIj1OcrP1f5huZTvRb1Utejrmc4L9yjRNljlZpoUirmilLxdj1td3+lJqLUFM/kxKSXoFTTly9XystLT3J1Vap/f6VOnlTK3T15Vk/PTKQpvfVllIbczBapVOgBpUI2KxW8QamQjfp9vC1z3z84Qu8SW4T+PDNA/26Pk7y/El5XyKt8PWPVunVKhYfr2SMj9e+TnmEbhikGkPQyBhjqq28jVMOGSoWFKRUdrZTNplRERAZpC9mo1PR8SgWvVyouXKnYUKVmFNBpTG1RLaXOzlHKHuO8HRNRanlz/d3YUL2dkyxKnZykj9vU86Z2ZrZSa59S6uIKpSLOKLX9A6Umoq7+7a4Cvg1I2jbPwZ7qVOip9Lfj5ESlZvgrdWGJUvZo/ZrqpdNxaaVScWFK2aIy3raMrOuh1OZX9THgcOhpN1nGkStHVJ1f6iifIT5q7LaxKj4qWKlpfkqFbNL7V6mEdPinXcallUotrKbfx4YqFXtdqR0fOZ/jSds7SakVrZWKj0ueltE+djiUWlBZqV399G9ji9JpmWRW6vyi5PzkZr9RNrh8Wan165X65x+dBy1frtSKFUrFxSl1Puy8+n7j92p/8P7MLSzxnIm36X15fbf+zRMlbsfFFUqdX6LU+cUJx0ZMmkWFx4Yr0wCTYgBqyt4pqsPEDooBqEGrBym15W2lJrvqZU0yqfi/UfkG6eOx6fimquj3RRUDUMPWfqXUrKJKzSuj13N1h1KTrUrNDFAffuictwYGZm2/HT2qlIdH8vfd3JRSEaeUmuKu1MyCSu36RKm1T+o0Jh5TqfPh43/oYyhxv0z1Utu3O6fLKdtOd2I6y01HWJhSefMmz2oYqWa43WtE//5p8kvVv/9dWcbgwUq9+aZSO3cqFRys1JUrSh0/nvnVxMcrVbKkUiNG6HzcZtP5eHBwipkysx8yu82rOyl1aGSavHnLoNpq8mSlpkzRr2nTlJo8WamoqMxvS2oOh1Llyys1Z07yNUop5/dO25beNmS0Hbs/V2pFK50/2WN0/jajgD52p+dX6vAopaKD9fk80ZT5vHxGAaWu7U7+nNW8LuqiUkvqK3Vhqc6b4206P00vbw5er9Tc0qm2q79SE1GH/nRXlUdVVgxAVfipgjoYcvDW687K+XKrefcMUGrTK/q9LUqpXZ+lvw2ZlWJ9w4YplSePUp9+qtShQ0qNHq1Uvnzpfy0qSik/P+fDwd1d/y80OlRtO79N2eJtatMmpSpW1OWX+Pjk74eHK9W6tS6/vvOOUj/8oFSJEumvKyxMqfz5lercWZ/HdrtS8+YpdeLaCeX+pXtS+cL/G39VrbpNzZmTfKnPcHsz2MfXryvl66vU2bNKxaS41GRY/sqCyLhIFfh9oFN5b+OZjbf+Ylby8cTpV3coNS9IqdhrSsUnlOEc8cnnzGRXpaZ662vvRJSa7qevRwurKnVwuC7Ppbwe3Spd23opteXN5DKyUlk7Py+t1mUcR4qDJPU5ns4234i+oW5E39Af4uOUur5XL+viCqUuLlfq4j/JZdiUNr+u1K5PdbkwvXWllFje2/WJUvaom5exz85TaulDej8klssSlxsbqlT4SaVuHFXqxhGlwk84b+/NHP1FqX8fSz6wE+8d7+TcT/RPS6VWd9RpTiz/T/PNWjk7PRt7KrWsiS4Hx4bqa8I0X6UmGro8Y4u8+b4MO6rU9Lz6ni0uTM8/3V+Xe8/OTXusZbTf78T1vUr921mp09OVunFIqW3v6WUua5rxd+wxSsVc1de5mKvO9x6ZAGxTmYj5ZEdLo61AWcMwSgLngW5Aj1TzzAPeNgxjClAPuKGUStUeK/fztHoysPlABjZPf5jLHGG2QstVsOU1yP8Q+FWHgGa6hUHTwdAtRSMww9AR0Az6whg6NPkZ/thY3WFZZKTzSGm5tmPWu8HiAT4Vbv/7tgzGk3zCBDOdRyqY+CO036yfT07sIM7DAwpnMHjbBw0+oEL+CjwySdfEXPvoGpXLeDJ1qnPn4ak7NE9yYCgEvQ1+NcDirqfFBqc/r2s+PTywsgMpOgc3TNBoKlhTjFOs7LqDT2UDUo7/mk73a4GP6ZfDDvZwqNgHKn9GXpc8XER3zHc95jrjO43HbMqgl8d9X+j+Rgo0TW56bY+AEk/rFlQuXrpvk4y2LT3xsXBmOjwRrI8BuOUyyuYry5ZXUzxScPgnKNwmuXP1WQVTjOqXSkBzaDIHjo6BuFB0NV4+qD4Myr/jPG+BxrC7nx4hyrusrjFOalKQah9f2wbxUVCpX/JvPKugrm06MwMKNAP7Tb6fTQoU0K/0FHYpzPv138/6Qu0ReiCCPOWTH1vaM0D/NXtCwRa3XISX1Yuy+cpy+OpheszqkdTHSveg9vBvI8gTBA+vBIsnpqnutPGASRHw7+l/k5bxUl4PuGKCNlvAkgdMZnDEERdxjVGjnAcQuJ7FfsF/+kn3WeHiokcHu3oV2NMf3AtD2616KPj4ODgzLeNja+8giE+Rqdsj+OqtBcTEdOCtt/SQzZ9/nv5Xs2rqVH1d8faG6tV1/2nZYsAA/boHy/jkE/03PFz3P+Vw6H2f0GL8ltau1fn3K6+Ae8IpZ7FkMPJnNqQXj0CIOpcmb65Tegd1umVxnbcQEgInT+pjJmWnuxmOOpaV3+3wCGi9XueV4Jzf1v9N9/9jcYeCLQFHxsd7auV76w7Ma/+kW8hmNa9zLwhtNurHMCOO6cE2inaC0i+CZ0nnefM3gFIvwfqnoeRz4FUCinUB94IElX2dvYDD4cCU7oged1mlT3Sev+19cPXTeUeVAbqPzjtgt0P//rp/seef12WW4sWhcuX05584Uedpjz0GgwfDvHnJ55yPmw+1CtcCdJ9vZcvq8y/l7jp6VI8aNneuHhnWzQ1efDGdFQGTJ0OJEvD33zpdoPvJdHUtSVjfMHrM6IGvuy+/dPiF3/wMfvsNmjTRx7bDoc/ZxHP4Vk6d0qM/+vs7n+vZMeqwh4sHp987zZsL32TbhW2sfmE1ntZsWHB6Li7Ro0UaLvq6mrrc4v8QNJ2n/z/VTV+DCzTVow5bPMH+MpyZmvnz88wMaLpAfxf0+rLCr6ruSy9kI+StoVtpZ+Icz+OWop8ykwv4ZnDApmay6HWkedAmnXWdm6P7/Kv0ie7/z+yecRny0jKdfxguugyRsixj9XEuY2dFqRch6iJsflmXMws00WXNy6ug1vDbWyboAaKubdMDQlhSHIu2UFI/eZclcTfg1BToeEwPSJRyuYFP6FdimTyjfXn4RyjeXR8bFk99TMWF6DyvcLvkUVATj7Wij93+8ZcR38rQZJY+FuNjdF5b7Sunx0PTMLvecvCl7HDHQSOllN0wjLfRT9KYgd+VUvsNw3g94f9jgEVAe+AYEAX0vNP1iiwo0ES/HHZ9s6Qc4N8QGHzLryaKjYV//3WeZrfrC6vdDr16QZky0Ldv+t8Xt6F8wjDkR36Gsq9B54v6Bs6StpQdFqYLKKlvTKzWNLMmaV+2PSd7ncTP3Q8fNx9u3NAjpWVKyAaoNtg5mJCRh/6GDc/C1a1Q/CloMg9OT4VrW50zucRl7B0AV7dDscehzmgIOwyVMh5JApNF94eSggGMaDci/fkTxQTrzl2LP5WcGSemITFg5Lyimy8vidIvI73sNZPLcMQ49cFyy2V4lYCyr996uR5Fod12OPkXHBwOFld90TNZodb3zvNGngbv8gmFnFSl3xPjdYDKNb++sYm7DnXHZGLD7hNWX30juftzqNJfB8/Kvw8VP0o+pjPhk0af8Pzc5/Fw8SAiLoIAzwDKRO7R/cQ9vEIH7xKMLaCDRol6Vu+Jb8gKfQNpdteFvQSrDzTDxUXfNLz6qh5taePGzG+eUvoGy8NDD7deuDC8/bbS/XTU/wMsiaODuWS8kMjTEH1BHxulX4bwI0SdXs/C7Q/z4ou6EsHTUw/XnB1+/VWne/t2KFpU/82tvL1vbzj7kBC97XFxzjecZjM6gDIwRYWUYeg77jsJiNX8Fra/D+t7QIke0GCCHhEuM3lJFuXNCz4+sGePHjLZLSHLTeyb67YppTuCdi+S9n9uBXWQJjF/N2WxyFvpIwg7Csd+gZgreh+ZrFB10K2/m5KLl66wuxnD0AOmKKUDebZQfRNYPDl6lyMBI9D5RInu+pWNtm3Tw7z37Jl8DLi56aBxen7+GSpV0oEcT08dYLqRznghnTvrjsa3bYM6dXQQRyk9hHejRroD8sSATEaBmUmTdCArZRAn8b3FZGHak8l9JL78sl7ut98mB/ftdhgxIjngdDOVK+uy2ty5uqN1F5fkjqkzG3i6GcMwGN3hHgxanbc2nJ2TfoTc4q0DDqnLr/V+Tb7pttwkmJVe/vcRUGWHrqCxpNzRmTxPrH7QfrcuDx0brddftJO+R6oz6tbfz6pqQ2BNZ9j1sR5xuc0WHSDLVyftvBeXQqFWYEo46G5Wxi7UTo/MreLAYYaqA6DyZ05littiskDV/vq9w6Y73Te76bLTnbiyUd+DqhSV39kRcLm+C3wrOQ8+kLjc4t2dKxUycmMflH4p7bEYH6UDjCmDUQBXNujpTvNnUz5tGAnl0WzIBLJJdrQ0Qim1CB0YSjltTIr3Cngr9ffEPWayOB/wWRhdZ/duffFK2aooLg6uXNEX6CFDdME2w1pDkXWJGVyeINj5McRe0bV8tYbrm8wUHn0UunTRv4mbW3JNbmTkzWurSviVSHrfogWMH69HHEr8js2mCzBpmFzSHyUovczSzR9aLIGo83oEwLhrOshxdSPpd3dmgsbT9A2rPRry1ct8VX1WxF3XN/VGOmkOWacvHC5e8HgWR6Eyu+mRlA58ldBKx1Mvwx6RbsAvXYFPwKHvwRamb1IevwQO3Ql+2mBWFln9IKjXrefzqQzXtzsHFh6/BPYYsNzJXd59ouFkOPQdLK2XMLCC0gHKRzI/EtOz1Z7l+bnPJ43GN7LdSAhZklAj5Vzr42mGTxt/ypdrvwTgyxZfwtKqUPWLNEHLJbvbEhEBy5fr2uu+fXHqBP5WDh/Wo2WNG6dbaVks8P0XZ2GVXbdgy8zN86WVutBZ5Qso9xYoxfZBbXB1iWPIEPekPCI7bmqiomDnTvjySx00cXeHGjXufLm5TYMG+gbUnmoQmshI8MyOFlOpmd2g7mhd6I04pf8GtLgr+a3Fom/aH30UvvhCj+CkFCxdqrf5thkG5KutW3eWeEYXsh+/BAe+hdDdujWd2e3mrTVvJk9ZqHQPa8MMAzwDSe5ILIsKFtT9c6Rc3k1akOekDRugfv3kckui9Cq74uP1KErz5iXnOZ6e6VdU+vrCpk3Qpw98+qluMRQeDitX6tFgUwZyMhpq/uRJHRDP7FD05csnjGZ5GywWWLNGj/z4889Qt64ue61YoYOsuUahVnB2ph4hs/oQaLdLtzL/tyMUaqn76UrJI9A52Huzm/n08r+wo3rQG0cclHwGHjujr+EpBta5JRdvKPemfqV0N84jFy94eDncOKRb2tjDwcVHj7KYet9gSmj1lIlWSUXa60rYpQ/pii/PQF3ezs4gr8nl9lss6YGIvgAAHSBJREFUpVmWVbegSfcacwcBF5NFt/RPr0zviMvcunwq60rxxBZEieX//UNhVTtdCe4RqFtJXdmkK7k3vaz7kmq3C6LOph8EfEBkS9BIPPi2btUX9mrV9FCqI0eS9CjTyJHJF+FuN2vSnosKM/eVoh316yaqVYOOHaFpU10oKl8eLlyAfv10wSMzvv1W37R4eMBrr+mC24YNOpiURrEu+hGqOj8nB1YSOmvLkEcR/QKwNYRdfXTgxiWhSv7xS84Re69SmUv47XL1101UHbbkm/bHL0FMCMwvAxeX6WGTlUPfPN+sFiy1ur/Ciha6UBPYGTDB+QXQ8O/Mfd+rJFTsB0vrQ+V+uhAUdR72D4H2O2/9/ezgUx58q8Kml6DeOP0Ii2HRN2L+De9NGrLLzfKeSn31sQtZbolgGAaDWwym38p+AHQM6ghLB+km5S5pm5q8W/9dvlz7JV5WLwp7F9YtB91SFJQTbmqX7WtN06a6ljzx8aSvv06zuAzt2qXz5scfT74Zs0QdAJ8qzsf7zQrpF5eBiy+UfUsHqZWDgxcqUL2m1an2Pd2gchYdO6a3sWdP5xvC/5oiRXQApW1b+Osv/YhNXBx8/71uOXHXWDx1De1d1rTp/9u78/gq6yuP45+ThYQQVgNhlU1AQVDWumsF9yrqqMM4dbS2Wq1Ly+jUbaptZ6mtXV+zdXAZnRlri0u3qTLuuILiLiBVBCnKqihbCCT85o9zM7lrcm9uwn1u8n2/Xnl573O3H57kuc9znnN+P08OPvgg/HWskHbmzNQ2opxN/Sd4OpaoHTEHKPE259KqDFfbC1Sx05Ul74OBz675NjVXfDslSZQuabRypR+bHH984u9KSD6njhk61KuFoLlNd9AgrzLK5netvNwTTfvKgAF+TL1jh/9vKi/3as5ISPf9WVLSXA4Vv722Fpb9AT64H7atgMpBfsI+6KTUNp5+UxMrmXNN6vYaA6e9De/dAU+e6Bfm+k2FGfN8ao6o6n2g/7RkyKmw/Ic+7UJJeesXLyfe4t/V6x+Hj5dAZa1X8qQkoyKg9njvPtiz1S+kWknuF1bT6TcNdqyC7Suh13jf95+9HpbeCqvvhaGn+/u39P9y3NWwYIZPUdFnYnMCasJ10PcQePlr/nsdgJrPwXGPwKZn4b153rnQ8wB/XsZOgeKmpJFk5eWXvYz8n//Zv3QnTIAHHvB2pj5xxUuZvsCBlAOGjNukTX70I3j8cY/RO+/4Ccgll2R/0XjsWG8JueUWL/vevRumTvV4p8ypceA18PBE6DHcW8dKKrzkdMDR2Q22vKfP3/Ds2XDMr6G8r+/g18yHUfuoe7Win7dfrbzTS4WbypvLquC4BfDMGdDnUE90bX8fTnim5feL173Wy543PAkf/S/Q6Fd9crmCP+4Kv3K36j/ho4f96saMfVBiHu/oB+GFL8L/HOTtFbs/ha3L4ZzN+3YcHS3XtpU4Fx16ETc9eRPDew+noqzCf1f2i1sJLy4xU1NVw/xz5nPwgNgcCCXdoGEr4KuNUFkLuzbwwabhXP2t5sRJeTnMTlyYs0UrV3rCqb6+OWnUraTOy7bjS8JbOkj/7O1Ysjp2YmAlvPHBIRw4oXvmuc7aaOVK3//k1abUSdx2G9x1l1fkrFrlJ9BnnVXoUbWf/v3hssv8p93UzPD5w964EV66xBP9VftDr7HNCeGmE4XG+n0y90PB5HIRrsAX8qqoY9WWBvbsKUv4229sTK3wWbrU9xG7diUmlVpqwU9+TkND9pWRxx3nx7jTp2fXYtZeevSAUR18vazD9ZvqP01+dY/Pf9mk6XunrCqxKiT2/ZdTUrdiPz+hn3BdXkNOUeiL2UNOhyVX+z7tkO95cq2kPKkNL0llTSxpHnEV/byS/+nT/UJq9QF+UfKtv4PJeWRKSyvgoGvh2XPhqPmeVMT8d2zTC7DsBzD+Bv+sxl3eBZGs5wFw2H/AUyd5219FjXdIzHzMOwgGn5z6moEz/acLUNJIsvLaazB+PEyZ4vfLymDkSO/jjtfil2vTsobJ26TdzJrlP201YgTcc08WT+wxDGY9Ay9eACt+AiXdYW89nLc1+w+b+hNYdDH8fpyXhO7+xH/2VdIIfF6mF873k+mRF/gJ9fIfwcSbfQ6p9U94uemoi3Jv2Sgp80qlQSe2fXy9xsIhf9/21+ervCcc+1uvctryupdS1xxeuPG0VQceAA7uOZhzx5/LZVNjZ8F7672KrUlSYubcCec23+lziCcVx4z6/6tidXVQ91c+6Wr8FfFcKjHefturDRNOkEoqvC8/24P0unUw+AsJFXZL105gzp/lcBKV5Unpu+/6BYjktqyuyAy+/GX/6Yiu3E6r7yE+oW6T7avh4Umpz4tPmsq+k2YfPO0JuOeq1AU3duzwCeTjrV3rx5zJFyZzaY+tqvLd0QEHtP7cCy7wlv+5c71CqXv31tv9O618vz/DnrSVt9Rv9gRvk1ynAujMSitg1tPw5Ak+T1T1KK+ePGttoUfWPqb+DF67FhZM9+OQ3Vv8wmg+SSOAg2/2aRwe/ZxfONizHQj+//KZM2DlXV7dvW0FnJehlHDYbBi4zicjr1vnVV/6MgaUNJIsrV7tB7FNJy7V1X71ZuLEHL5E033xDByY+IfYdFtta9HXd5JX02x/38tMe7VSbpuspByO+C/Y/l2/CtCtNwzMI8HSFkNOhUl/D0uu8i+wph7yiTd70mfwSft2PFEV31ooKeaf2zwpqh9cZJmYGXqWlzWP/hKU+I507eqd9OhRxdChiU9N7gRoyYoV3uKUcBW+1zj49M3EuZaa5spKbuHZ2+gT8fZNPOneUd8jZVwtyrK6dPlyPyFMOQFM09LSldqau8wxakdUvFSP8In/F13s3zNW6leY3/05HHRN3kPuFAr8N3TkkfD++z5320kneUVzY6MPKzlpVF/vx53ZzjGUzvTpPofWtGmtr0h47LE+n9zhh3tV3JgxPln/00+3/fMjr8P2tyWJyaGm78TNi1NXhNqzLX2CqSvqNRZmr/JJsbe/79/hnSV5UVLqF44n3gyfLvXqo97j839fMzj0Vjjom/DxS/67tN9h/nlnvA8bn/XfvdYWJiiv9nmyJIEau6VVIcD27d5LHl9CvHWrf5FKF1c9ynfALS0H2eLrR8LIv4QhXyhMH/q4K30CxWn/6it5nPXRvh+DdB4lZX7g2+Ts9XB+gPPTVDiMuhB2rIZnz/G5tPbu5k/PP8jgwd4eGi+XZde3bPFWjgTVo/zAfdOziRmovXWpb7Brg7fOVdQ0b3toII17S3NrTUtXSZpm27Zt3hKb8m/M1L6stubOpaNa14/4L18GfMEUb/N4+jR48+b831faRWUlXH65rxD5m99AXZ3Po3hymg6QpvPkFqdAaMWJJ8L993tiqkldmt1fk1/8wlv8v/99uOgi+OSTtn92Ueio/W1ZlVdsNzl7PczZ4y1CGxc2t5BKKivxhTXGXgEDZ3WOhFG8bn1hwFHtkzCKV9HPW8n6H9l8UcxKoPZYGH6eJ+QkZ0oaSas++8zLhydNSt0+fHieb75+vR8FJP90gavIEiEV+3kv+P5/1nLPuEhrKgf6fEDZqOjnq3FsXAi/Hgi/rODD1xYyaFB+SaOGhjQVoGY+Gekr3/AJuMNen3h+fZqZ8us+hG77kXCIsGsD3crq2bEj+3Gk3b+n2bfv3p3h35epfVltzZ1LlsnFnPWbCjOf8N+7d37qlXYzbs//faXdfO97sP/+XsleVeUVR+naVLt396RNYx7dhWefDR98AFde6Ss27tgBL72U+fkVFb6i444dfpG0qFYyi5LeE7yaPL7aqKTMl7d/6au+Uu6erf599IKqO0SiSu1p0qrNm/3Lc/DgxO179iROgi0i0uX1nQwbnoL+x/jy360Zegac+ha8/V3Y/Sm7hn+dmk35XVDMuBrVpL/zqosFU3wy+8/egff+DebUJz6vsQ66D4S9uxKq/wb22cCbb/qk3O05GXZpaYb5jHTxoGvoyDjXHAanr/AJsEu6db4r9UWushIWLYI77/TWr4MP9nmEko0a5RPmJ6/WuH27t61lo39/X1H2H/8RFizwvOTSpakJ+mSlpft2MuyCSTfvaNP2fPQ/CtY84PNVlseC1VAHk2+DP4z3hTYGHAWfLYP6zl7OJVK8VGkkrdq0Cfr1Sz2o37u3fU8cRESKXv8j4YNfJW7bs73l1/QcDYffA8f+lj3VE+mW57ltWZnPAZKi94Ew+cc+sfnLl8PKf/cVEJPtbfC5j5J6QaaOXMLy5Q3s3Nn2saVTWenfM/lUEYi0qLRCCaOIKinxNrB774Ubbki/iuKECZ40SpZru9qNN8J3v+tVS8uX+zxHHSZ5zk7w+wMHpn9+oXVU5f/AWbDlVV9Mo6HO58xrrIMe+8PMp3whkk0vQv3HMPkH7fNvEZF2p6SRtGrzZk8aJV+NMcuvv1xEpNMZeibUrYfXr4eGndCwHdY+lPXL22Oeyx49YM2aDA+OvQxOeNaXpp30D3Bqup6LvYmTeQNU1jJh6DJeWbQzq2WuczF6tJ8Q5tT6JiJdxtChfqFy/nyvcm+yNYcFW8H3rddcAx9/7K1qzz3XvuNMoDnZXO3nobwPPHUirP5vWPcILJjmj+033ScoPuE5mL3G5+4RkUhS0khatXkz9O2bunpPaWnrZb0iIl1KrzGw3wz44z/BE8fBM2fDixdm/fLycq/qzCchP2oUvPVWCyuu9ZvqrQEH/XX6CeytLHVy0rPXc8iVD7Fucy8WLmyuPN3eShFVNsaNgw8/1EUIEUnPDI4+Gr7znebk8s6dPj9RW/To4V1XKj7bB6wEpv+L337pUlh4emxF0Ziy7r5SZ2VN+teLSCQoaSSt+uyz9HMXVVRoygkRkRSfmwfd+sDHS2D9Y1Ca/YQY5eW+z80ngTJhAqxYkUfljpVBw7bmVUdiRo+GAQN8JaGNG33loUcfbfs449932bLcJvsWka7lqqu8QuiII+DnP4c5c+APfyj0qFqgifybDT0DjrjXL1JYKYz5WqFHJCI5UtJIEjX1YMddfmmYey29qxsoLU196qpV+3h8IiJR12scnPQy1B4H/abBcQ9n/dL+/T0Zn7y/zWW+n7FjYfHixEljM1YdpVPRz+c9KkmdyHvuXG8JGTcOZsyAc87J4X0zGDPGE2WPPdY8TlWxiki8006DIUPg3Xfh8svh97+PeKJZqwMnGnYWnLcD/rwOptxW6NGISI6UNJJEaXqtGymltCy1jHf4cHjnnRxPRkREuoKeo2Hmk3Dyy1B7bNYvGzbMW7W6J+Vrcpl8+sADfWLpd95p2+upGuaVRg3bUh76yld8fpFdu+Dtt1PH2Rb9+/tFiOuv9+olaJ+2NxHpPEpKYOFCX8m3Z09vMXvkkUKPSnJiJVBS3vrzRCRylDSSVjVSSmlpSUrSaNw4eOUV2JZ6XiEiIm0wbBh8+mnqfjWX5Pz06V6pc/HFniyqq4PHH89hEOU9oaTMq43iNeykRw949lk46CC/yn/++e0zF9GcOV5BcNppcPvtMHNm/u8pIp1LbS0sXQoLFsB778FRRxV6RCIiXYOSRtJmo0bBokWJ5cG5rmQhIiLN+vb1JMyLLyZuT7cMdSbdusGsWfDaa3D88XD11Z7cyUnFANjwVGK2KniP3IAB8OabXm10++3tM5nsJZd4S97ChXDppfD66/m/p4h0PtXVPq9RVFeuFxHpjJQ0kkRpJugrpZHGxr0pV5MnTvSr2M8/37ySjoiItJ2Z74bnz09s0Xr55dze56qrvH1j8WK44w5P8OSkahh89HtoiBtEyGFipRyNHg1/+7dQFZszvCr7ucNFREREpAMpaSSJ0kzcV3rb92nYW5aSNDrsMD8RufhiqK/321/5SmGGLSLSWRx1FNx/f3PSaOdOuPnm3N7jxBNh9uzmCqWckzADjoENz0BDrHy0YQe8+/Mc3yQ3N97oE9yOHw+33NKhHyUiIiIiWVLSSFpVVuYr2ySv3tO9O0yZAmvW+Go906b5iY6IiLTdKaf4pK/nnOPz/Pz0p/DUU7m/z513wpln+n76gQdyfHHt56G0Gzz357B3N+z4AN76du6DyIEZ/PCHPmfJN7/ZoR8lIiIiIlkqK/QAJPr69PGJWZPV13uV0VtvwUcf+U+J0pAiInk55RSfyPr55z0hD21r16qshPvua+MgBhwNjbth8wvwq6oObU0TERERkejSKb60qqYGtmzxSUrj7d4NF17ojzeJnxRbRERy17+/T/Ra0CR8aSUMPgmstDlhVNajgAMSERERkUJQ0khaVVMDn3ziK/LEa2z0bQ8+6Cv+dOvmrQUiIpKfefOak/BVVfCtbxVgEFN+AiVNO/4S6DOpAIMQERERkUJS0kha1VRplHzVu2mZ5alTff7szZvha1/b9+MTEelsxozxeYgmTvT96rXXFmAQ1SNh+r974qh6BBzxiwIMQkREREQKyULyklgRMm3atLBkyZJCD6NDmJGyGllUffqpLwG9YgWMGNG8fc8eKC8v2LC6hGL6PRGRItd0JSB5pxP2Atb8eGuvT/ceIiIiIhIpZvZKCGFaa89TpZG0qndvb0V7443E7Vu2FGY8IiKyD1lJ6wkjEREREemUlDSSVplBdTU8+STU1TVvX7y4cGMSERERERERkY6lpJFkZeRIWLCgueNg2zafb0NEREREREREOicljSQrkyfDH//YXF20Zw/cd19hxyQiIiIiIiIiHUdJI8nK9OnQvTtceaVXHH3pS544EhGRIjdwYOKcRWa+TURERES6vLJCD0CKw/TpUFYGy5bBKaf4tsrKwo5JRETawYYN2W0TERERkS5HlUaSlUmTYNeuxG3l5YUZi4iIiIiIiIh0PCWNJCvdusGsWYnbKioKMxYREYmQ5PY2UIubiIiISCehpJFk7brroEcPv11ZCXPnFnY8IiISAZla2dTiJiIiIlL0lDSSrB1zDEyc6BVG1dXw1a8WekQiIiIiIiIi0lHymgjbzPoBvwJGAKuB80IIW5KeMwz4T2AgsBeYF0L4WT6f2xkMH55azV9M6uuhpqbQo+j8hg8v9AhERERERESkq8p39bTrgSdCCLea2fWx+9clPacBuCaE8KqZ9QReMbPHQgjL8vzsorZ6daFHICIiIiIiIiKSWb7tabOBe2K37wHOTH5CCGFdCOHV2O1twHJgSJ6fKyIiIu2htja7bSIiIiLS5eRbaVQbQlgHnhwyswEtPdnMRgCTgcV5fq6IiIi0h/XrCz0CEREREYmoVpNGZvY4Ph9Rspty+SAzqwYeBL4RQtjawvMuBS4F2H///XP5CBERERERERERaSetJo1CCLMyPWZmG8xsUKzKaBCwMcPzyvGE0b0hhIda+bx5wDyAadOmhdbGJyIiIgVUWwsbNqTfLiIiIiJFLd85jX4HXBi7fSHw2+QnmJkBdwLLQwg/zvPzREREJErWr4cQUn/U9iYiIiJS9PJNGt0KnGBm7wInxO5jZoPN7OHYc44ELgCON7PXYz+n5vm5IiIiIiIiIiLSgfKaCDuE8DEwM832j4BTY7efAyyfzxERERERERERkX0r30ojERERERERERHphJQ0EhERERERERGRFEoaiYiIiIiIiIhICiWNREREREREREQkhZJGIiIiIiIiIiKSQkkjERERERERERFJYSGEQo8hIzPbBHyQtLkG2FyA4Uj+FLvipLgVL8WuOCluxUuxK06KW/FS7IqT4la8FLvilCluw0MI/Vt7caSTRumY2ZIQwrRCj0Nyp9gVJ8WteCl2xUlxK16KXXFS3IqXYlecFLfipdgVp3zjpvY0ERERERERERFJoaSRiIiIiIiIiIikKMak0bxCD0DaTLErTopb8VLsipPiVrwUu+KkuBUvxa44KW7FS7ErTnnFrejmNBIRERERERERkY5XjJVGIiIiIiIiIiLSwYoqaWRmJ5vZCjN7z8yuL/R4JD0zG2ZmT5nZcjNbamZfj23vZ2aPmdm7sf/2LfRYJZWZlZrZa2b2P7H7ilsRMLM+ZvaAmb0T+9s7XLGLPjObG9tPvm1m95lZpeIWTWZ2l5ltNLO347ZljJWZ3RA7XllhZicVZtQCGWN3W2x/+aaZ/drM+sQ9pthFQLq4xT12rZkFM6uJ26a4RUSm2JnZVbH4LDWzH8RtV+wiIMO+8lAzW2Rmr5vZEjObEfeY4hYBbTn3zjV2RZM0MrNS4F+AU4DxwF+Y2fjCjkoyaACuCSEcBBwGXBGL1fXAEyGEMcATsfsSPV8HlsfdV9yKw8+ABSGEA4FD8BgqdhFmZkOAq4FpIYSDgVJgDopbVN0NnJy0LW2sYt95c4AJsdf8a+w4RgrjblJj9xhwcAhhEvBH4AZQ7CLmblLjhpkNA04A1sRtU9yi5W6SYmdmnwdmA5NCCBOAH8a2K3bRcTepf3M/AL4TQjgUuDl2X3GLlpzOvdsSu6JJGgEzgPdCCO+HEHYDv8R3PBIxIYR1IYRXY7e34SevQ/B43RN72j3AmYUZoWRiZkOB04A74jYrbhFnZr2AY4A7AUIIu0MIn6LYFYMyoLuZlQFVwEcobpEUQngG+CRpc6ZYzQZ+GUKoDyGsAt7Dj2OkANLFLoTwaAihIXZ3ETA0dluxi4gMf3MAPwG+CcRPzKq4RUiG2F0O3BpCqI89Z2Nsu2IXERniFoBesdu98eMUUNwiow3n3jnHrpiSRkOAP8XdXxvbJhFmZiOAycBioDaEsA78lxsYULiRSQY/xQ/E9sZtU9yibxSwCfiPWGvhHWbWA8Uu0kIIH+JXWtcA64DPQgiPorgVk0yx0jFLcbkYeCR2W7GLMDM7A/gwhPBG0kOKW/SNBY42s8VmttDMpse2K3bR9g3gNjP7E37MckNsu+IWQVmee+ccu2JKGlmabVr6LcLMrBp4EPhGCGFroccjLTOzLwAbQwivFHoskrMyYArwbyGEycAO1NIUebHe8tnASGAw0MPMvljYUUk70TFLkTCzm/DS/nubNqV5mmIXAWZWBdyEt8ikPJxmm+IWLWVAX7x95m+A+WZmKHZRdzkwN4QwDJhLrKodxS1ycjj3zjl2xZQ0WgsMi7s/lObyOIkYMyvHf2nvDSE8FNu8wcwGxR4fBGzM9HopiCOBM8xsNd7+ebyZ/TeKWzFYC6wNISyO3X8ATyIpdtE2C1gVQtgUQtgDPAQcgeJWTDLFSscsRcDMLgS+APxlCKHpgFmxi67ReJL9jdixylDgVTMbiOJWDNYCDwX3El7VXoNiF3UX4scnAPfT3MakuEVIjufeOceumJJGLwNjzGykmXXDJ2/6XYHHJGnErhrcCSwPIfw47qHf4TseYv/97b4em2QWQrghhDA0hDAC//t6MoTwRRS3yAshrAf+ZGbjYptmAstQ7KJuDXCYmVXF9psz8T50xa14ZIrV74A5ZlZhZiOBMcBLBRifZGBmJwPXAWeEEHbGPaTYRVQI4a0QwoAQwojYscpaYErsO1Bxi77fAMcDmNlYoBuwGcUu6j4Cjo3dPh54N3ZbcYuINpx75xy7svYdcscJITSY2ZXA/+IrzNwVQlha4GFJekcCFwBvmdnrsW03Arfipahfxk+Wzi3Q+CQ3iltxuAq4N5ZUfx/4En5hQLGLqBDCYjN7AHgVb495DZgHVKO4RY6Z3QccB9SY2VrgFjLsH0MIS81sPp68bQCuCCE0FmTgkil2NwAVwGN+vM2iEMJlil10pItbCOHOdM9V3KIlw9/cXcBd5su57wYujFX4KXYRkSFulwA/iy3YsQu4FPQ3FzE5nXu3JXbWXI0rIiIiIiIiIiLiiqk9TURERERERERE9hEljUREREREREREJIWSRiIiIiIiIiIikkJJIxERERERERERSaGkkYiIiIiIiIiIpFDSSEREREREREREUihpJCIiIiIiIiIiKZQ0EhERERERERGRFP8H5nKB+9Y4t2oAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -2543,7 +2579,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2555,19 +2591,7 @@ }, { "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2581,13 +2605,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "tal hits: []\n", - "gata hits: [MotifHitAndCoord(motif_idx=1, motif_score=0.9754941959328381, precision_at_motif_score=1.0, example_idx=14, start=48, end=73, is_revcomp=False)]\n" + "tal hits:\n", + "\n", + "gata hits:\n", + "\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABJQAAACMCAYAAAAqYPOgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3gU1RrA4d9k00OoCYTee0eaUkVFEHtFxI4du167BqzYkYt6UYooIE2kN6UFkN47obf0Qnrb7/5x0jYkkJCO38uTJ9nhzOzZ2ZkzZ745xRIRlFJKKaWUUkoppZTKL6fSzoBSSimllFJKKaWUKl80oKSUUkoppZRSSimlCkQDSkoppZRSSimllFKqQDSgpJRSSimllFJKKaUKRANKSimllFJKKaWUUqpANKCklFJKKaWUUkoppQrEubQzcDl8fHykQYMGpZ0NpZRSSimllFJKqSvG1q1bw0TENz9py2VAqUGDBmzZsqW0s6GUUkoppZRSSil1xbAs60R+02qXN6WUUkoppZRSSilVIBpQUkoppZRSSimllFIFogElpZRSSimllFJKKVUgGlBSSimllFJKKaWUUgWiASWllFJKKaWUUkopVSAaUFJKKaWUUkoppZRSBaIBJaWUUkoppZRSSilVIBpQUkoppZRSSimllFIFogElpZRSSimllFIqu8QQiNpd2rlQqkwrkoCSZVkDLMs6aFlWoGVZb+by/y0sy/rHsqwky7JeK8i6SimllFJKKaVUiUmNh0UdYHEnCF5V2rlRqswqdEDJsiwbMBYYCLQC7rcsq1WOZBHAC8CXl7GuUkoppZRSSilVMo6Mh5RokFTY8kJp50apMqsoWih1BQJF5KiIJAO/A7dlTyAiISKyGUgp6LpKKaWUUkoppVSJOTkd0uLN3zEHSzcvSpVhRRFQqg2cyvb6dPqy4l5XKaWUUkoppZQqOqkJEL4l67WTW+nlRakyrigCSlYuy6So17Us60nLsrZYlrUlNDQ035lTSimllFJKKaXyJTQAbNmCSKkxpZcXpcq4oggonQbqZntdBzhb1OuKyDgR6SwinX19fS8ro0oppZRSSimlVJ6idkNaYmnnQqlyoSgCSpuBppZlNbQsyxUYDMwrgXWVUkoppZRSSqmiE7UL7MmlnQulygXnwm5ARFItyxoOLAVswAQR2WtZ1tPp//+jZVl+wBagImC3LOsloJWInM9t3cLmSSmllFJKKaWUKrCoPaWdA6XKjUIHlABEZBGwKMeyH7P9HYTpzpavdZVSSimllFJKqRIXd9z87vgl1BoIS7uVanaUKsuKJKCklFJKKaWUUkqVa/ZUSIkGzzrQ7FnAgiZPl3aulCqzimIMJaWUUkoppZRSqnxLDAInN6g5EOxpYHOH+veVdq6UKrM0oKSUUkoppZRSSsWdAicXqHsnuFQwyyq3Ld08KVWGaUBJKaWUUkoppZRKOAMIVG6XtSwtsdSyo1RZpwElpZRSSimllFIqJRpEwN03a5lllV5+lCrjNKCklFJKKaWUUkqlnAePmmBPylpm8yy9/ChVxmlASSmllFJKKaWUSjkPHn5mtrcMTheZGN3Pz7Rgyv7j51f8+VSqjNCAklJKKaWUUkoplRQBnnXAyudtcnBw/pYpdYXSgJJSSimllFJKKZUcDu5+4ORW2jlRqlzQgJJSSimllFJKKZUcCS4Vwcm1tHOiVLmgASWllFJKKaWUUio5Gtx8dGY3pfJJA0pKKaWUUkoppVRKNLhWKe1cKFVuaEBJKaWUUkoppZRKjdWAklIFoAElpZRSSimllFIqNR5cKpV2LpQqNzSgpJRSSimllFJKSZoZlDu/atTI3zKlrlAaUFJKKVU0/PzMIJY5f/z8SjtnqrTkdkzo8aCUUqrMsoPNM//Jg4JAJOu1iFmm1L+EBpSUUkoVjeDggi1XV77cvns9HpRSSpVVYgdLb5GVyq8iOVssyxpgWdZBy7ICLct6M5f/tyzL+i79/3dZltUp2/8dtyxrt2VZOyzL2lIU+VFKKaVUMbKnwPbXYUV/iAks7dwopZRSRUNEA0pKFUChzxbLsmzAWGAg0Aq437KsVjmSDQSapv88CfyQ4/+vFZEOItK5sPlRSimlVDHbPRIOjYWgv2F5b8fm/koppVQZFBwMPXpAw4awcWNeqbSFklIFURRnS1cgUESOikgy8DtwW440twGTxdgAVLYsq2YRvLdSSimlSlJCMBz4CtISADuknDdjIyml8k/HF1OqxD3yCGzaBMePw6BB+XwW8ocfTLVgqq2Yc6dU+VQUAaXawKlsr0+nL8tvGgGWWZa11bKsJ4sgP0oppZQqLiemYS7d6dLiSi0rSpVbOr6YUiXqn39gzRpITTWvExLyehbiZMZRypCYcV7ac0us1L9eUQSUcjsVc8Z7L5amh4h0wnSLe86yrN65vollPWlZ1hbLsraEhoZefm6VUkqVjqRwHW/nSnByJqQlgnczqHkjuV/i0+l0ykoppcqACRNMEClDfHweCS3LMaCklLqooggonQbqZntdBzib3zQikvE7BJiD6UJ3AREZJyKdRaSzr69vEWRbKaVUkcorUFCjBgSvhrn1YVFb2PJiyeZLFR17GkRsBffqMGAr9JoDTZ/JO71Op6yUUqoMmDfPXIJeeQX++1/w9MwrpRPaGkmp/HMugm1sBppaltUQOAMMBobkSDMPGG5Z1u9ANyBaRM5ZluUFOIlITPrf/YGRRZAnpZRSJS0jUJDRhjwjkJASC/MaQ2p616gjP0Pn0SWfP1V45/eBkwt0GGV+29ygw2elnSullFIqT+fOQXQ0DBgAH34ITk6OrZUcWE6mFa5SKl8KHVASkVTLsoYDSwEbMEFE9lqW9XT6//8ILAJuAgKBeODR9NVrAHMsc/PhDEwVkSWFzZNSSqky5OgESI3Nep2WVztzVeZF7QHLBnXvMsEk0K4BSimlyrQNG8DNDUaPzmqZNHx4HoktJ0iJKbG8KVXeFUULJURkESZolH3Zj9n+FuC5XNY7CrQvijwopZQqo45MMEGkmgPAuykEjivtHKnLlXAWvBo5LnPxLp28KFWe1ahx4SDcOr6YUsUiMBAqV4Z69bKWJSeDu3suiW0ekBJdYnlTqrwrkoCSUkoplauUGNNNyuca6DXbdIer2LK0c6UuV9xxqNoBh4G4raIYjlGpf5m8uggXo0Nhh/Bw8aBupbqXTqzUFeT4cejWDZKSsoJIFSrkkdilAiRHllTWlCr3tBaolFLqskQmRBJwPODiiULXmad93X4CZ0/zd6OHSyaDqujFHgOvBua7VEqVK83HNqfB6AalnQ2lStyRI9C+PXhna1DrlNddsHNFx4CSu7YcVOpiNKCkSkdasg54p1Q59+SCJ+n9S++LJ4o5BG6+UKFh1jJt0VJ+xZ8C78b6HV7p/PxMy5mcP35+pZ0zVUh2HfNM/QudOgVNmlwkiJSdayVICst6fafOTKrUxWiNUJW8o5NhZgWYUREOflfauVFKXabziecBiE+5yCDbMYfB52qwp2Qts+U2aIEqF5LCwLN+aefiylYWgjk5x/a51HJ15cvtuNQAoyonQkKgfn4vXa5VzBhKacnFmielrhQaUFIl68wC2Py0ubmUFNjxZmnnqER4fuxJ1VFVSzsbShWpE9EnADgScSTvROcPQKXW4JzXYAWqXLGngLtvaefiyqbBnH+vYgwmRiREFG4DuR1/ekyqciI+HmrWzGdi12qQGAr2pGLNk1JXCg0oqZIjApuHQ1oC1L0bGjxwZXV7u8jTu4TUBCITdYA/dWU5EWUCSofCD+WdKPY4VGqhXaSuFJIGlktp56Js0BYbqqgVYzAxe+A/MkHrI+rfJS0NPDzymditquneLWnFmielrhRawy9v4k5B2EZIjSvtnBRc2AZIDoeOX8DVk6Dr/6D7+NLOVdEprqd35fWmJTUBovZCsk69eqVKTA8IH444nHei5MgLp5lX5ZfYHYODf/jBVAum2kovT6WlIGV+eSvH85q+Xqe1L7cCIwIz/z4SeZFWpUqVBcnRZliMA99AUnihN2e3gy2/lymXSpAQBNa/8Lqm1GXQgFJ5IQIHvoUFzWFFf5jfzHFMkvLgzDxwrwlNnwNnL/NT797SzlWxy97MPCEloeAbKI/NzCO2wtz6sOxq+LOO6eqoikZZGF8FSEzNal247dy2vBNKKrhULIEcFbOS3u9lNQBh2Ryf2iZmlEU60O9FFaQcLwvBnKAgx2nsRcxPkA5OW6zy+o6dnApdHmQP/F+0m3JB8qYBRlUcYgJhUVvY8QbseAsWtgZ7aqE3m71IuyiXipBw1sxKq5S6JA0olRfHp8DOd8ByBs9aJnLudJFuB0kRsGEYLOsB+z4Hexlothm2ERo96Ph028mt9PJT1PKobO0P3Z/58mD4wRLMUCmJOwXL+5jBe92qmj7oa6/8wGGJKSPjq2S/IVl3al3eCSUNnJxLIEfFrKT3e1kNJFs2021ZFd8NtgZz/r3y+u7tuQRsC1ge7A7enfn3RVuVFiRvekyqoiYCAXdC/Gnw6w+1B0FiSKHrETYbpOY3JuVS0dRdkrVrqFL5oQGl8sCeCttegSrt4faTMGArXL8y7/Sxx0wLpuO/Qth62D0SUqJKLr95Ob8Pql8LtmxBpCvhRjNDHpWtvaF7MxftDdmby4qXUN6eCu5827Q+u3Ej3LwfbgkEz9qlnStVxDJuSDycPTgbczbvhJaTY4uWf3MXqSuBzR0SzpV2LsqGgtxgl7dyXBVcGWk9mpftQdsz/94dsvsiKUtYWW2NqUpH0HJzH9NzBlwzBbr/An0XFXqzzs4Qkd9x6T1qmbrL+QOFfl+l/g00oFQSLqeSYU8zBWpiGISsMeNW9J4LrpXB2ROqdsl73X8eAZsr9JkHd4VBm/fArVqRf6wCsaeZGRMqNi/dfJSC7eeyKnG7gncVfAPl6amgPQVOzoSrvoXK7UxzYY/a0OuP0s7ZlaMsdIcBDoaZ1nZNqjYB4HzS+dwTWs6QGp/1+lJdpMrqzUVJ7/eyGoDw8IO4Y6Wdi+JTXMdfKZTjiYkwdSqMGwcnThTrW5WsslpGFGcrxiIoD45EHsHZMg/xLuvhVnEpq60xVek48TtU7wU1B4BLBfPj27PQm61aFc6cyWdizzrmYf6pPxzrL0qpXGlAqSQUtJIRvBLmNYaFbcz4M1tfhho5WvY459GvN3qfGb+m72LTGsitGjQfnnfeSqpiZk8y0X7XSkW/7TJuw5kNmX9vPru5FHNSAqJ2gZsP1L0z63h1soFXw9LN15Uk48a0lIOMGeMm1fY2rc+yD/jqwLkCxJ3M/4bL6s1FSe/3shpI9qwPsUezxvBzLwNBrqJUVo+/Atq8GerXh6eegpdegpYtIa4czuWRqyvkOyqQQpYHUQmmlXpFNzOeXfaW06WuGIPnIoI1wuKjNR8VyfayC40LJT5Zgw1FLiQAGj9pAkkZsv99mWrVgqNH85nYozbYE+DcYkAgLbnQ76/UlUwDSmVNxDZYdTNUaQd95kKX/0LMIfDtATavS68fvBKq94QKjUwrJTDdj/JMX0IVM8lojWBlLSuhri/D5g1jxp4ZxfoeF7MjaEfm3/+c+qfU8lEiwjeZrpk5x1jRKeOvOAsPLwTg72N/AzB9z/TcE3rVc2w2fqkARFltmaMM70YQczjrqe2dZSDIVZSugOMvKgoGDICOHWH3bjh3Dt55B7zyUYUoFwr7HRVX17Qy0no0NxnldERiVp+f8PjCz5xVJIoxeJ7RNXvmvpmXt4E8HrqKCNW/rE7bH9oWST7LvBJ7+JwKccfB5+oi33S9enDggGm5eUk2V/Mw7PxBc19FGRiHVqkyTO/ySkJBKhmbnoIGD0CPqeB3PTR4CCo0hMptTUuPSzm3DHx7mXEuLjdvxVH5cXI146ikJWUtK4HZgZLTkhm/fTwP/vlgsb3HxZyINv0MrPR/iWmJRCXmMZ5VGR9/IV8SQ8Grvvm+s3P2LJ38qGITl2KaO6Skt1TJs/WddzMTUEpNbx5xqQBEWW2ZowzPuhCx88Jz/EpxBRx/EyZA48YwezY0aACVKplWSleMsvodlZHWo7nJrXwOOBFQCjkpWQsPmQcflzXcAOT50DVje0ej8tvkpZwrqYfPafGm3lsMw3Q0aQKbNkFSttuQ7H9fwLOe+b36VphZucjzo9SVRANKJSGvWTvAMXBQ0YKQrdDxcxMZh/RWRhb5btmTGAqVW198BrhL5a04Kj82V9NSqoTH3lh+ZDlgAkvJpdBkdcnhJQBI+r/sebpAGZm9q1DEnt4aKf14zTxWdRDmci18C2x8ApZeAwH3EHx4ygVJMsZUukDF5hC2oQDz9RafNHsaK4+tRMpAXsotz7qQHArJOVo3PEv5D4hfIaZMgWefBY9sPeMdWielJZppuRNDSzxvZUIZDvwUlz0hewCwWTac0lsMX/Fd8IEft/6Y+ffRyMsI/uTx0HX2/tmZL8/F/AsmKSixlpsW5Lw8F1Fvhnr1YO9ecM32LOSiAaVKrdL/ELBrlzdlfLX+K37b9VtpZ6PM0YBSacoZKKgPeLY20zJn51rZjFmR4WIte5xsjn19y9KMSt5NIWJLVve3Ehh746dtP2X+/dfRvzL/DguDDRtg1So4dKj47nX/OW26uNksG7b07zXgZEDurZGc8jgdy0Bz+XxzqQgJwVkX38Tsx3gux+uV0CqrPEgKh6C/4Nzygt9E7vkY1g2Bmv2h+3ho+hQndn8BgKeLJ22qtwEgTfJoEl6hsSm/Ukt/AJf5B+fTb3I/FgcuLu2slF9VO5lrzP6vICU2a3l0HukLGBDfG7IXa4RFaFwRBjvK6iDORSGXzxa4LZq+fXO5pCSGQcA9sKgjbH8DAu6GBa0dWw6XISIwYwb06GFaFzRqBLfeChs3lnbOyh8vFxNRHNpuKAMaDwCyxlO6UsUmx3Io/BB1vOsAsPjwZZT7eTx0/W7jd5mL5h2cV9isln0l9vDZExBIDMlalo/eDKFxoWw8ffGCoUMHk+3ff8/q9nbRWd8qtzeTiuTi8bmPM27ruIu+n7ryJKUm8dry13hwzoP6YDIHDSiVppyBAhvg4pFtvCFMQChsPYSshpQYs+xigRjvpiZ9avoYNiXQrSzfqnSC49Py3/WlkBJSEph7cC4eNvOYdsymMSQmmie3t9wCa9fCvn0walQBphItoIwZVe5rfR93tLgDAFdbHl1FfH0vjGyVt6emVTtB1M6sAbmvtAF7y5vEUFhxI2x4FM4fMq0SNj9jAkz5cf4gBP4E/ddBnduhUkuo0Y8TTV8FYGCTgWwcZipxscmxuW/D9xozKP+ON825nzGYcyl4ZO4j5vefj5RaHso9zzpmUohDYyAu2+Dcec23UMCA+AuLXwDg3RXvFiKT6gL2NFh+DVTrAgO3muBw3/nQc7rjhB9lyNtvw48/wsyZsGsX7N8P779vAkvl0Yw9M/JuyVnMjkWZ1uHDOg3j7lZ3A3Ao/FCp5KWkfL/5ewDC4sMAGLlmZJFsd3fwbqKTovH19AXg83WfF8l2FeaheIXGELauQA+fW41tRffx3S/aCq1jRxNIeu018zs5GR566CIbrdw6PcCVjXsNjkYeZcKOCTy14CnS7GVnbKW0NFi4EPz94ZVX4NNPYfv2S66mCmDK7qzW+auOryq9jJRBRRJQsixrgGVZBy3LCrQs681c/t+yLOu79P/fZVlWp/yue0XLGfFfcxBSjjhW7jICQmfmm6ePcPFAjF9/CFlDZpvRsnRD73c9hG2EuBPmCbc9tVjf7uOAjwFIFfM+SwKX8NzzSbi5wd9/w8svm+DS6NFQrei7awOwJ9Q0Mx/WaRgPd3gYSB+ku6yOAVFYVTtD7HGI3AV2uzlWh1wkip9Xd9ByuC/sYmfNiTWkFvNxXSBrboN698A1U6HZs9DsGeg+Kf/jE5yeCzX6mjHZMrrRWk4cijSztjWt2hRPF088XTyJS4kjMiHywm141DTl0LFJcPA7OLe0KD5ZgS0LXEZ0UjR1vOsQGh/KiqMrSiUfV4Qa15kx8Ra1h+np/aq+p9Dn8uHww6w4vgI3mxvjto0jKCbI1I5za8Xo75///F6p5S3k+tmadKrEqlWmCM50diG414Rmz5kx7Vwrmxal3s0g/iwc/hF2fgA73jGtEkMCHB9ulbDgYPj+e5g3z8zO5OkJbm6mlYGvb6ll67IFnAjgvtn30WJsi+K/RuTSau144BbAzMpZu6KZmbNMzfRWDDJakCSmmeYoIXEhuV+jCmjEqhEAhMabVpRHo45y9vzZQm9XpavRBw79kOvED9HR8M8/8NdfsG6d6W2wI2gHYQkmaPjo3Efz3Kyrqyk/IiJM97f69SHgYsOIVe8L9mwjeDt7wZ1BmQ89ACbvnHw5n7DInT0LbdvC8ePw/PPw8ccwZIgZS08VDbvdzvOLn898PXzxRWZQ/xcqdEDJsiwbMBYYCLQC7rcsq1WOZAOBpuk/TwI/FGDdMi0uOY7E1PxMGZAPFZuBzQOOT81qYZQREEqJhk3PmAI2o6VSbvz6wfn9cOxXSI0tWzPw1LkVJBX+7gshqyB0XbG+3fxD8wHHrjjTZwpPPWUqp7b0XoAVCj8baZ4yngA2qNyABpUbALA/bH/xvWFpc6kAPt1h46OQEmW6xFxOV6ey2kUljy564leDW6fdSp9Jfeg1sRf2UrwRy5QaZwK4DYde/vS7Lt6OM/ald6Hdudm0HqlfuT4A1T2rA1kz6lyg4VAziPPOt2H1LQX6GJcSlRDF+G3jL1kOD549GIDTMacBuHfWvUWaj1JV0l1H692dNc5fRvlaBA8vek/sDUBSehesfpP7mcBRbi03CxJQ+pd54AETjEnIduomxUabAFL2rql/+MF0N9j4ONS+Fdq8bX5avmoeDuQ2O2cJlc0hIVC5MrjkGA7SOfceKGVacGwwvSf1znz99IKnS/T9U5wg3N2cQzW9a1LLuxYAx6OOl2g+SpKIEBxrHsg+3P5hanubINqG0xsKve0dwWbm3kZVGmV2G1x+NI+xMYtCWa0PFZcGD0DEpvR7oVhIiSUitgq3fPMX339vAsrt2plAs5ubnWsnXQuAq5Mra06s4edtP+e56cGDzdhyMTH5eKbgWgkqtsx6bU9l9r7ZmTPcAjw27zGiE/Pq711yXnwRnnwSHn/cPCD38DABs4pXdq/WEvXZus+IT4nPfL0vdF/moP/5kZoKS5bARx+Z1mOffQYffghffw179hRNHsPjw0vt/qMoWih1BQJF5KiIJAO/A7flSHMbMFmMDUBly7Jq5nPdMikyIZL+v/anwqcV8PjYg3dXvIvdXgRfYvuPYft/TEFqT4GB2dornvoDlnaDTU/mvb57dWjyFGx7GTY/D4F5F6y5EoET02H/12bdE9Ph+O+m28u+L+BsIVoXOHuap6Op8bDyRhNYgmJpRZWQksD+UBO4CXs9jHE3mydV3k12sngxxGbrnZOvKUQvQ3RiNNFJ0ThZTtSpWIf6lerjZDkRHBtMUmrZHLOCU3/A3lFwZDycmAknZ0HgeNg3Ck7OvvT6AB2/NK2UFrYy3asWdyjWLJc2AVoMDs+sZGw4vYH639Qv/f7VNk/wbgLBq7KCerv8zZhq0/MZVKp/v5k5MnyzQyB7X7K5eNSpaMamqF2xNhYWh8PzCCg1fQasHHeGRXDef7b2M6p8XoVh84fh8bEHk7ZPyjXd3pC9RCZG4uzkzKCmg7BZNsITwkut+0m5V/dOE5zIYPMq9MOLQ+GHCIoLwsKiURXTp2l/2P4yM+DtjqAdtP+xPXW/qcvsfbOL5npfTB57DI4cgbvvhhMn4Px5GPvnzWZw/JgjjmNfAbQbAZ61TOvoeY1Nq7MZxfikJQ9HIo7w5fov2R+6n1atTPBoyRLH63Vc6Q/FVmA3Tb3J4fX47ePZcKrwgY085Wi1diL0ME7Ozni5eOHu7E5t79rYLBth8WGkpJVeF+TitC90H7Epsfh6+jLp9kkM72paE/x58M9CbTcqMYojkUfMezy7j6/6fwXAnANzCpfhgoqNLXzLzbLKtxdUagObn4WVN8GaWxmz9HlqderDf/5jxlOrXh0aNoS/T88jKsnMnJycPnbnuyvezbP+9dhjjkHq7BMX5KrePeCU3mvEoyYjVpvWaTbLhpU++cy3G7+9/M9aRLy9TZAsraR64BWy5XBcHEybBpMnw2+/mYkkfvsNfv3VLAstg/NFzNo3C4B+DfrRtXZXoGAt1J54AjZvhnffNb1jnn0WXnjBdE9s06Zwedtydgs1v6yJzxc+2EbamLZ7WuE2eBmK4llPbeBUttengW75SFM7n+vmy5ovn6b3gNrQ5j2H5am/OrOiRirr15vy18MDDls92VRhN3d1eJI6Feuw7MgyAk4GEF0vhnX10vh7hRPh4ablyv3tPqJW1TBmH/+WwEATYfT2Oc/IlKoO7/NxwMdsXTKH5i1S8B+yicruldkXuo/RG0fzbdhkPO454JB+7eRJ9Kw7Ha51HCSwRvcH2P3bfqpvHQ5bnwfLxpzNd/LN5mmsGfUInJkHseZihmUj/MAGFmzszpYtptVNtWowfepnbB19FE7OhJPTAXht2te8UHca9erZMp867tsaTCtrFNx+MisD9mRYN9ixm9IffgQFwdLDD+Nx9Y2ZPe8AXPa+SWzVwdh8O2QOAJoaG4LLntdI7TIZETMwqIgZC+G2Wz7m1c67IGStSVy5DYSbMVj++gsWL4bu3eGehs+TYPdh2bkPCAgwfZ27dYMHLAuGCBs2mCmRu3eHNYE34l4rjJH3r8fN2Y1tZ7fxzsp3SLGn0KRKY6p4VOHahuYJxuC7b2POL6vZtas5Q4aY42HzZnNCBwelUT3xDwgNAHc/1qz3oHeLAOj9h8N3VLFiGrvWHaOB02xIPAc2L9ZtdKVHkzVw3d+Z6Q6GH0TETlX3SrjYXHCxueDp7Emf0Ja4/dUTBjjOsBI4ujVNBv/XYdnOvwJonzAMbnG88b35Y18aNe3K2wPH4+bsxnebvmPf+m1Mb77xghu7AQNM09eH7jplujU4uXDS6T7G+G/ki6/Sp/6xMJGRdffC3RHgWiXzuw8MiaVp8LYTms0AACAASURBVIW1+Fncwl13dYM272QuS00FF9+uyKGvYNsrcGq22bjlDC1eITkZxo6FqCh47jmo/pd1QZe4VWNG0HfeHdD1h6xuniImEJISY1rNZDjwDYRv5qDPVKZMMdu99lq4PdEF67ZjbDtQh6lTzdTZETzLwqSpvHfzb7Su3pqAEwF8uOZDNrhHUu3e1aa/fIaTs+Dgd9ivW8O4cXD4MNx3H9R414v6g9ebcYHSPTfuYQ6d/QU3mxvd63Rn89nNnI45zdkZ1and+zd2h93I5MmmPKnRbBw7wl/l1fu30bRaU0LjQhm5ZiTvp6zAt/0HBKbcy88/g7s73Np3P53CesLdjuMdbfziVrrdcSs0GZa57NzRM9TcWB/uz9aVwrJ4df583o26jSptboZag6DGtcRu+RLvx2OR+4AzCyBohWmNEBoA7tU5UWkEP/1kZj8ZOrQyz7yzkPWf3Aa1boImT0NyOMcP/QCWPfOpb6MqjVh3ah0P7BkKbRxb/nzyCRw5Uofxb3wB218zx0PlthC+wQwS7O6TmXb1z2Pp03wl9JqVuex80nle/29V+vX5hvs6m+bG3274lnnLf2WlfZvDez0671HuPfQinv1XExjegfHjzVPMpfYXAXil+yuMumEUry59la83fM2XP3WnbZcHeeF6M8DqD5t/IHj9QfwbL4WbHVsS7v26K63vew9qZ2thFbEdVt9M6i1nGD/ejPHSowc0On4DV93ziHnSmu7P1bNYsuN+Xhiyk1a+rYhLjuP9Ve+zfcNUVkswnq5eODs5E5MUQ9WEKoS0Dbvg3Aj44lF63dQcWmf1Dk9OTMb162CTNvv5svUlsHmyZ4+prCUlQf/+ELPkflK6Tsus/wG0sb9P84aR/BU1hpUrTcuWzp3hYRcL7o1l2y4vpk0zT4WDgmDXLhd+/ex/sPY+s4HqvUj7zYbtzlMO+V0z8Sd6N1oAfeZmLktMTeTFbyvRo+dIHur+BgBf//M1U/42Eyi80eMNPr3+Ux6f9zgTtk8g5ZeucL9jMHv0rx9yKPY73n5gB7Ur1iYoNogPV3/IuZ1T6NrxLt4Y8DOWZTFm0xgOrd7KmOZr4dZAh2306mW6Pd953QE4OgFs7hyOuYGmQXfCXY612Roj3QmRrIcAd8+8mzrxfpzqGAGDHR8OnLqhDXX/cuxKFO3hTaWfYy7s/rvpafCsTZDPe3z/vfmOHn8cmm25sFx8/XXztX75STQcHAOpMdDkCZjfFO53vIuofPojlnxpcfOb79CmTcZNRhXm1PuD1R/dhFODe8052OIV5k9Yyw3er+Le/XOo2jFzGwnJrnjEnXDY7trJk+g5raOpt2Q71mwjLOwjLIe0fRLb0aZ+MO8/uIvqXtU5F3OOD1Z9QOre6fS4+hke7/MZABO3T2TRspnMSsyqC72+/HUA/nmpD0NfXEjf673o08fUAwLmbmbSY3c51lsA/u7HuYovMGP97Zw8aeod3t7w1VcQfeaYqQ/FnQTvJmyc9zfd7rgZmj6VuXpwMNSsmd5N8PQ8E4iv3ouXf/0M98ZejLh7Ca42V+YemMu8PcuZ9sDnxAcuhcjdICng5MzqBYfpM6ghtPswc7sbTm9g27ltuNvcWfTAIladWMXI1SP5Z+xIut/dBDp/5/g5plpwn+NTrlXff07fjvvg6kmZy86fh0qVLmy8t2b8j/Ruusyh3nI08ihp9lR8KpggfmX3yjhZTtwT3gWXVQMc6i0A7iMscj7yuju2NzOvi8+73lLj2sxl0/8czxv7nuaNG76jZ72e7AzeyadrPyWgdipVO41ia8jtTJtmrnM3dttJr5QbLwxIrxyAvd4QVh5/iEWLzPc5+ObjXBXUCu6LZ/58WL0arrsOBnrfC9V7E1V9OGPGmH2S2tGUORk3ft3rdAeg5e51TDmwjFTf/pl105QU4efPNvDPkgMOLfhWzQyg7wA/6Dgqc1nG5C7tarTDzdmNnvV6AtBpSww0esbUW7KbasE953Ott9BjKjNmmPHB/vMfqLjQBW47xr7jdfjlF2jWDJraJtD7987Qd4HDORc+zodq926EKtnuRE/MNN3K8WfOHFi/Hh5/Op4vZtWkx9XDeay3GQZiwvYJJJ9ewNO2I8jAnUycaGY/u+MO6Bp+FSvixrHn7FVI+iXFFrWRl7vcB7cdd/hoz33SgFptuvP2LdOwLItfdvzC0g0nWfrOe4SHpsGxXyBqF/hczcYZUy6otxB/BuaaesvSpeYe4PrrYfJkiz5dZvFkkxsgchsIDO15knvHPc7SpfW47joTFEpLgxdmPgLAnPvmcFvz22g4uiEnok/g5GQhaalm3NaIzVChEcSfpJII3377DcOHm8923W1BPP1NTW4bNJ+BzW7GLnY+XP0h66b2oW5aX8aPfRL2mzGydtV9it073sLT2YOoN6PZG7qXjv/rSOS8NeB0t0O9xZwInqTeuJc//2rI6tWmZVUV73hC9qzkw7fOkTE0SXxKEi/Mf4NePd7k4R7mHvaHzT8Q+s8B7HtvpM/gmzLP8xRJYsammnTr/hhPXvslAJN2TKL5DX+z6JMXCQ/vzLBhpuw7djKZyQH16dT5Vob3/x8Av+/5nTkrj7P2szc5cwbTaCB8M9S6ia2/fnpBvSUw0Iw9FRODqReHrge/fmzw2k33g2PNUAoZx2VCCPxRHfBn9mzTnbBbN5h3tA1BleN57YYxVPeqzm+7f+P336BD6GiW5mijsPrrl+jTzxN8P3FYblnpZd255XB2MVRqxb6/FtGqby9o8XJmupikGP7zfUWuv/437mr7AGn2NEasHsG22f3wjbmaif6zIHqPaXnvUZu0bW+aeotnrcxt5FZvCYwIZHvQdtxsLiweupiIhAhqflWTWTNt9B0Lq1YKHJkAMQehwVDqtmvH7NnQtdkecx64+tC27kA272lJZKQLHh7m+HV1NfWqr79M5vqWiyB4JTh7sP7sgzzyYgsOrVpiHgSlRIFbdXat2cVO+wekebfBycnsl62nfmJ0imNDkyF/DMFv3vdcO/gxaJzVDfRs4ClqbWlyQb0FgKlOhPQ4S/X6l9f6sSgCSlYuy3KGhvNKk591zQYs60lMdznq1at3wf8nzloMr58E3s9cFoIv/aof4v2vk3nrLRfAwskJ7vvUi2MJ5/nyny+zNpDsQdeXNnH/a6m8/LILFSpYpKXBt29ezdx1Pfj+xzSGDbMhAhHhFQh914vbV8TR/4hpTjyxI4y69iRLTsXS7poqPLYdRt4F09vCfU4d6B2+D1v19BunrS/jdiKAEO86+MadhOo+kBqPNdXimbTBVL/xd6gBtAHioNrmUAbXfAN6ToO2gC+wB8bWu5HPj7Xh/Y+SeeopVxITha9HJfFQ0FtmsM02mO0chC9HvQK9su3aXf64n/iFUxV9qJM9D9Pd+XzEtfznGw9o3xyqVoHWEczZ8hjLIkcx55sc38u9n5GYaMY2yDD2Wy9Wn5nMjBxpD73Tm1f/E2AGH++COfq2biSyP8x84AleYjQJeOJJHBE9/ubTLX/zzNuJPP64G87OFutWJRO+EI490JnrWE08XngSh7yziuQjydxbz52rzsHo22FJe/jwmCc3LT8CL1o0Bqa1gYYtgxnZbhAHJlVh76TWJOJOY84yqmYFqv86DWpUhvp94FwAbmdcCPNrQLW4k9DoKrN/xsSz+O4WNDhbB7p8Cd6NwJ6E++JbCY6qSvVs+7LTqm58fKgKV6+PhDfNoT6nERxqkMC5rj745fjuNwRfQ93I47hW98EKCUOqeuKx8zHO+FSjVo6022KdWLh/EWP218zcv41j63Eyojp1c+S3+94beOjj5ZAMuJkzrGL0N3wxvAfUX5R5PLBnBJ+N6MGbn9eAjs1MdLJtBJ5OrjRIsIiwBK9kSHIG1zTYZD9P/+gYKmR/v9GJfOA2HJp9B3WBZpiQcX2Iq72YFyY1YypDSMGZuSP3MvWrRrQI3YyV7bPZQnsQGd2Syjk+8+ZTLekUvgOn9neaPC8aCge+5cWPx/H7qXhuu8eVKj7OfPJuLB0bp7JzyLMMYRrxeOFBHF1vD2VTh2hu+d2xy9UG6Uz/yMM4N++bud+tMfGE/VmbR/rPZyX9iMeLH7+OY+I71akZeRSXbN/RLeFr8TlXiaenRlMrZjWhnjDuKgjZHMb0wUt4l14k4IELKVS9Yy3B7WNJfbQZP8+H37rDfwfAg5tg7aKpDOUmEvDARhqzxqaw4MMa1M/xfa4K7kObqDA8s+0f17/acjSpDg1zpPVe1psqPx+A+gegsSnvbLe584Hbi/DAd3B9+jGRCEtnQNDSB3mGeHOVszkx9stE/uP+OwwOg1aTwQ+Ihvfrt6aKbzzta3cCgRGV4armsNOrGW3CtuKUrayreyqMBhtrQPOvoEV6+bV+A+s/bEO3iF04dbwv8/t0O7uesBoNzTmX/tn2/FaJn2JgzowXuK/LC8S5wKtvQdfYFrydWJXnJ0fgFwtHq8D/roKTW87jMfg2urOVCKriTgJ3d23HFx128Pitn0Pi57zjAX4d4IProkhYN4YGz43BNQ2efRC6RDbjiarp51y2fbk+pCeNo87gVjnbcbmkE0em1eGmOw9ymtrEU4GfR8fy0WvJtIwMxsM3axtzXxcmJaXiObQ1Xy+DjQ3h2wfhrpPe2BuIw6DmFeOTORpWl4axJxzOgcXn+tAxuhZe2fP2TRJHo+rSIGq/w3lk9+3D088/xYxj8Vw/yA13TxsP3JVA49bT2JTjgerx1a1pMaAHg59IZOhDbri5WWxal8zZPyD4gZ70Zg1xeONJHINYyK0tN0Kdr6EJ5pj4ZwnrRrTjmoi9jte5U+sIq1rX4fsMmuLBuDj4efGb3NPrTUK94NWXoVt0M76K8+GxWz6DxM/4zBPat4VNN9TGL/KIwzk3+/jnBKTF0vTGOry0AeZ0hu8HARbM2TSBtzZNyPxsbWKacNq3CrVzlCfXHbmJO8csMrPTuQB2cA+ewMlKNUwZmi3t04d88DiexNBd4JEKC5vCxvopHK2bfs5lSzu+XR9e+8gfrzaPZn5Hti/SzPd5/ohD2mWTwXlpX27nRRJwJw0bYz5PYs/oujSI3O3wfTYMe4aGx5Phf+OhIuY6uv1zdkc0oVWOc846+C0tVzXjRMiH/MGdnKciA1nMxLM34DQ4CFp+BzWBeEjaehczF3XiQedrwCf9unwP/BPUIt/1ltuDPdlvxdMkAuwWHK8MhyscZk1QAp171uCRHfBnZ/hpkGnZOHPpKB7va27SX3oT6iQ3ZIDdnVvWJtIuGA76wPxm4BqzmkMnvNkyvjNbxnfGlWQer3mAU7fnqLdMtXjlo+FsrzyQr8fYadnaCbsdFi1IY+6AnrDwBLR9A2reCOuHsCLkKtpERziUoS5zq/K+64Nw33cwIL1c3PUNKyO82ZkSw7H73OhyBl4bAC2dXAifsBjcp0HrQSDJYLkwZ0J/OkbVwDvbdtuuuppPjnlw47IEOr3Xjz4WNGwP7vViiIpOoVKOz7H9THPa5fg+XUI2EhHVlCrZ0nrOdWZkm6dY9MR1ePh4YaVXnUNi4wnzdXY45/r8cyMfHa7EtavPwCumXcXcJnCyUQLBvaqYeku2su62c17st+JoFmGmcwmsCk2CIzjX6SL1lna+medn4n8qcyIllWcXPetQzhxZAP6LT/Iz8XhX9yAtOZU/frax5KPqF5xzyyd68/ZfH+LcLo7rbvEiLdXOGy+nMbN+EhMHv8J7fEg8Xnz/VTyLB8zkqiWL6E1vDtAcsGjp055Pb/bgntEL4QGLnk4wvj08sX0HJ087U7t2Vr7shyfxeOOZ0Di9PvSHHyQGY8X3Ijq6ChWz5a3/1nv45JgHN/2wC56xaA5MaQv2hklERqeaeku2fZlbvcU6+C0xixsyv+f9PMHPpOLMko93MeuWVOxDetODrURRCU8SeK/DAVp+4IZPzv1+Nr3ekq1ctNbew/n51ZnZ/3Fe4DsSceN/v20m7qnzzFzyCY/1MTfpL74Frbzhnm0+PDtoOgu42ezLr+Px9lzCsjVV6HunkJhoYVlw7kAFTu/zcShD7VMs5sTYOLd9Oqd+mk7NGPC/FlzC6vOp8xn47H/m2uAO7BxNypz68J/5wBNZO74CRF4Py4bcy6NMIgFPxn4Zz3/qD+TJqWtMudzNlOuNtx9hWb8GHB/UkSm0J8FWAfe0OEbe1xA5uINbRtyBJTC/OqxoCKl+j8GYiVDVG2peBYGzIPEcsata8egvFg3oyzlq4rnld+5oCn//9xYOjzFlj/9wcA0aysSjC8DjK6hnrnMtt7zFR0Mrce3KaFzedaUD8HtrSKgTS1hfX4dzzppqsX5iLYYMhspNYuk1oAL7dqXweNPbeP6dIdBoWOaxdig6mAnxMHPB+zzc833SLHjxXaiz7QW6ed+Ef1aslsPhJ5kUEMmUFV/xRL+vsIDn34JmFWBFy/mcGl2HraOvIpYKpFU6zS8vBTF53TieHTAOJ4FXX4FzSU35LD4I7h1tBpxxA3Z+RUBI7wvqLR4jKvMmd8HDY6BvVrn4V1Af2uYoQ60/qhMxHV56YDKzuZN4KuBJLDc8F8qq1BBWTbs583PYGlu8fXoNCxpcQ2r9JuDuhpWSTELVGM5fhSlDs51HH3g8B4PHwo1k1lmPbxqIZ9wOGgSaWYdJXEZQ7F/8GA0//jGUCQ8NZVcN+PZquC5sEz8M2gWpn0LL182YoHMbsu5EG1Nvadg+8/x0qLek56Hhd/F8cqgSV6+PxvU9N/yAec1gXWoQDVJfgaHfmPq0K7DtCx5PvIeuz82EZ9OXpcArPm9yYncD1ldtRVi15qS5e2GLCuexuoFcf2A5cBPUHwipcVTZcy+bXgqHiNegxUvg7EXMtJa0H37sgocIrba1J/lnD56blUDrUAj1hO+7gGvySXj3MeCxzLQuFasR2cOTKvc7hl9kaF2sX+1UpxBEpFA/wNXA0myv3wLeypHmf8D92V4fxFRnLrlubj9XXXWV5Mdnn4k8/LBIYqLj8rQ083tX0C6ZuH2ixCTFyI8/itx1l0h8vGPaatVE9u3L19vJz1t/FvyRQVMGSVhcmFQbVU3wRw6EHsjfBgogIkKkShWREyccP19sbB4rpKWKxJ0WidgtErFDJGKnSOReEXtagd5zzx6RTZtENm40v8PCzN/Ll4ssW2Z+liwRWbtWZN48kTlzRP780/xOSMh9uwcPinh4mBFca9USsdlEWrcWWbBAJC4uK11iokhSkvlOskZ8FbGGtxCnEU6y8NBCERG57pfrxPK35OetP+f7s8lf/URW3iySEiuSFG1+z6gsMruG+f+MNwv9R2R+K5GUbBmbXUNkCuanBE3eMVnwR/BHPlr9kaSlpYl88IHjzgER/7dFZlYTme4lsuMdkW2vmrzO8hWJPiASvl0kbKv5nZZyeZnJeK+LmD1bxNMzK6mHx+W9Vfb3mjVLpFkzkaAgkZgYc3zExYmEhJj3cnYW6dNHpG5d837hceFyz/R7xO1DN3nv7/ckMSXxwu2mb/uLL8w6NWqIXHON2VZBbNli1h8yxJyn27eLtOq7W/BHqo2qJptOb5IOP3QQ/JEJaxaKl5dI48YiM2aITJgg4uOT+2cuyP7J05nFIr97isxtLLLlRZGF7WT/n2PEw0PkzTdNOZiUJPLjjwX7zJflEvlNTEkU55HOgj8SkxQjm89sFvyROl/XyXOddu1EnJyyNu3llXu6N/96M/Mcyvh5bsFz+c6biMiAASL164ssXSoSFSXyyy+5f75v/vlG8EfunH6niIhM3TVVLH9Luv3U7aLbd5Db+Q1meQ6TJ5vj6fRpkehokfPnze/AQJEVK0QWLxZZtMj8bttWZOJEx+tHUpJIcrKIr6/jW3l65j+7een+U3fBH+kyrou0Htta8Ece+uOhfK//0eqPBH/kyflPiojI84ueF/yRZxY8I5a/5fB9bju7LfeNRO0X+d1DZOWg9HJwi8hU56wyvwRER4tUrmz2/9q1Itu2mfIqV3a7yOIuIlOcRP55TGTbayJTrBLNb0EMnjVY8Ec+X/u5iIj4r/QX/BHL3xLL35K45DhJTEkUy98S2wibxCblVXm5tOBgkQoVLqy/pQUFmOt1UoRIWrJZeLFr9bm/Tbk4q5rIqptFplhyYEq1C8qIX6c0F9kwLOt6ufMDs81lfS77M5S6glxjLrZ++jbS0tJk6q6p0mJMC/l6/deSnJosU6eKVK0qMneuqc8lJJjrbG6GDBEZPNhcz1NSTFkUG2uuoxn1RVfXrCw/+qiIm1tWFlxdc9/u1q3mujZunCnzJk4U+fWnc5K88WWRfV+LnJ4vMrNK1nEyxbr8fXGRZcnJItWrO16j7HaRFi0cr10FLW8zzoWM9V28YsQ2wiaWvyWJKYmSkJKQec6N/m+ieHqaMr5nTxEXF5GKFU1dKuOacf583nX3pYFLLzg33lj+hsj6h0Rm+ogcmSgSd0pkunee5dSpU1nfZ2EPQQeLrxJZdYtI8nmRpCiRlHiR370uyEdsUqw4jXAS/JH45HiZsG2C4I/cMvWWQmehSxeRZ54xx3B8vNmXp7csF9n4tMiRSSLBASIzq0ryb4hL+v6LiI+QoxFHBX/E+xNvsdvtDttMs6eJ24dugj9yLuacRCZECv6Iy0gXSU5NviCty0gXsY2wSXBssNjtdnH90FVsI2wScmS6KeumIDKjovmdfd9k/zJO/pm171bfdtHrzsSJ5lju3VtkzBiR664zy+OS4+TlJS9L34l9ZW/I3vztwOx5OPeXye/C9iL7vhJZdeuFeU53+7TbLzguY/+oL3JuuUhqkkmU874tr4MvPwfl6YVm/2SWGYjM8jHLZlYx1+qAe/PMryzqJLL7E3PfKWLuy6cgsudTkdQEh/yufKeP/PCDyE8/mX09aZLI//7neK9clIAtkt94UH4T5rkB8zzrKNAwPQ63E2idI80gYDGmRVJ3YFN+183tJ78Bpf37zc3mnj3mQhQZaU7os2cvTLttmynIw8JMQZqYaNa5/35TV4+PdyxgcxMaG5p58Gac8B4fXe5d88UFBIh06HCRAFI58tBD5qL599/mJmbXLnNBDQ+/MO3vv5uLZZs2IuPHiwwaJGINHSD4IxO3TxQRkdZjW4vlb8mywGX5y0DsCXPBS452XJ5bYRO8RmRBuzwCSk4F//CFlGZPk7RLBQUP/Ndc3M8fNoVTSnzRB8DyUeh27mySNGsm0rVrISoO2d6rSxdzA5+SIw727rsilSqZ8yQmxvxkXNguuV2Q5GRzo3f11eZ8j4kx2yqIgQNFbrnF8RyNiZHMssHrY6/M8uKlV1KkSRNTxqSmmvPgzJncP3OeatS4MNBQI4+bzYXtRJZ0NZWt1ESRlDh5st+Pctddjvkt1vIlt/zmkec237cR/JENpzZkVviGzh6a62Y3bzblScuWImvWiHz/vSlPcpOUkiReH2V9Dy4jXSQuKS73wE0uQZtDh0zlad++rGPwgsp3+vqz980W/JHuP3UXEckMMD0w+4F87rCCadVKZPr0C8+N3Hh6mqBnTrNmmfK2e3eR1atNsLEoKvyj1o66oMK35PCSfK8//+B8wR/pMb6HiJiHCPgjs/bOktC4rOvwqehTeW9k7WCR5X2zKnEiJf5g4IsvRJo0MWVMxoOuPM+54ADzUOD0fJPn1IRSeZCRX++veF/wR15e8rKIiAybO8yh3DsYdlCORBwR/JGqo6oW6r2iokS8vc2DhORs91QpAQ+bYE9G4OdSD3+WdBWZ11QkIcSUjelpf9j0Q+YxVfPLmpISH2YeQO0aIRJ9yKSPOVqoz1DqijiglJs2bUT++1/HwF9MzIXpYmJMkCE09ML/u+MOEzhatMi8njPHfP/u7ubSERBggrN+fpf/US7bxa4bOfbNzJmOgR8Q+ecfcz2pV8/cMD78cMG/kq++ujBAU+WzKoI/ciTiiASGBwr+SJVPq4mfn0inTubeKCbG3AedPi3yzTcib70lMmKEyMiRIm+8cWGwNsM7f7+TeW70mdhHJD5IZJqbCc5m3Axf5Jx7/XUT/HvySXOv9tRTBfu8uYrcIzKrukhyjoMrj3y0GNNC8Efaft9WfD/3FfyRcVvGFSoL+/aZ4zHnfsvZwCFDm7GmjrP+5HpZdGiR4I/0nNAz17Ttf2gv+COrj6+WTac3Cf5IszHNck1b75t6gj+y9exWiUqIEvwR1w9dxb6sp7nvCdssYk+9cN9kP14XtBZZ0EYkKdyhXMzJbhepWVPk3nuzrmOXFejIrW44yllkee+s63VKbJ75SExJdKhfD5s7zJTrQSuzHizkvG/LWXblsw4oIiJLrzZBtgPfmcYaGfmaXVMk7kx6HTuP/EYfEpntl3WuZM/bjney7jVL6T6zIAGlQnd5E5FUy7KGA0sxjbAniMhey7KeTv//H4FFwE1AIBAPPHqxdQubpwwtWsDatWaAr927zQCPImZyhBEjHGcL6djRDAb2zDOmX7evL8THm5lGrr0W7r3X9K+32cyySZNMH9XsfLx88Hb1JiY5a/DabrUva0ioS2rTxgy2GRpq8uTubpbHxhbvrGVFzW6HmTPh/ffh6qtNT5vmzWHgQPjpJxg+HLzSh/mJjYWffzazFqxeDVWrmhkbmr3QnDMsyZzRIyw+DEGoV+nCrpG5Cl0Hvj3NwZHhjzz6kPr2hGqdYcNj0OFT8KwLtx6Fs0ug3p2F2BOXxym3WXhyOjkDmjxupm+3uRd/pnIRFmbGCejeHVasMLv6tdcKv92jR81xk3Pmn19+MQPedepkxhYDmDEj/9tdv978nj076zy/6qr8r5+WZo7RzZuzjl8wXUP7N+7P/EPzSUgxUzA1qdKEhVOcef99M6aXzWZ+KlfO//sVSFI4nD8AA7c5jOvw55bbmbPYMb/Z/y5NDSo3YE/IHq4efzWS3rWjZ1/ozwAAIABJREFUWbVmuab95RdTHq5ZY8qITp0cT+3sXJ1dWfbQMnpM6AHAkqFL8HT1NANL5mNwyaVLoU8fqF076xh0z+MUq1+pPgDBcaacOhNzBoAWPi0u+T6X48ABuOGG/M2KNWCAGRDzhReyrh9xcaYM9vWFZcvMeXDVVWbslsJ67erX+GDlB5nTebfyacWNTW7M9/rtarQDsmapOhJxJHO5j6cPKe+ZgYadnfL48CJmsPm+C8xU0KVkzhyzz93cyByDMM9z7vRc8LnGTGVdinnOr7qV6gJw+vxpIOt4r+Vdi8MRhzkZfTLz+2lcpXBzW1eqZMrqfv3MbEfdupm6hX2/Fx07J2LGxcl+LORy3UyKgMjt0O8vcK2W9YUAT3d5mvdXvU9ofCgbh23E2aOaGVYgKQKidkPMITPpiFc9sGyF+izljp+fGYAqO8uCGjUcptEKCzMDxT/0kONAyLnVV8PDzXmQ8xqYmAiLFpkp0fv2Ncv69zfXdhcXc81tZMbzZ82awn+0AsvndQPMuZ99sHkw1y5nZzP2TO3acP/9BR9kefJkMwbeb7+ZfTN0KIRXacTWc1s5ff50xkN+asQM4HSsqX9n7OeWLc3166WX8v9+I68dyccBZmymeffPg3MLzZiMPt0uWd8UMZ+5f38z05WXlxnzrNCClkONfpgOm2R2YcxLC58WHAg/wO6Q3ZnLetXvVags7N1r6h5JSY7He/bhQbLr4NeBPaF7eGHxCySnmcHFO9fsnGva7rW7szN4J9P3TMfV5gpAl1pdck3btGpTTkaf5PT507jZzJu3qlgDK3wzdJ9oxtK7WJkVf8ZM5NB/HbhWzTsdZryluDgzw2jGdSyj/l0oHoBfKnQdl3Xtu8g10M3ZjQ3DNtD2h7YAfD/oe1O2rx9iJg2qeYMZgy/2GFRsnvtG8nsuJwRDxDZo/wk0fswxX63fAreqZrIL8vjiU8+DSyXIbbSffZ9CWqIZd2zANkg4a+4/y6iiGEMJEVn0//buPD7K6lzg+O/MZE8IkAVISICwE3ZZLiC4ICDigmgVrmtt1boUd62WXqmtty4VlyrtrVVre7Va22pdKleRalelshYRFBRlV0CWAFlIcu4fz0xmJpk3mUkmM+/A8/188snkzTuTk5zM+57znHOegwSNgo/9T9BjC1wb6XNjqbAQbr45snNHj3budF5xRfjjjf3olB8xd9Fc+ub1Ze2utSw8fWFkT4xSp06SaPWEE2DePBg7Vi5czzwDjz3W8vPd4tNPpSFwzTWBi25amgT3Lr5Ygg+zZslN9u234R//gPvuCzRCsrLgwhl9uH9NYDvwfVWy44O/QdsiW9/MBbVRw9MYGPck7F0NGx+Hw1tk++zOvl6rMeFfJlGslaSGYxYmtBOyeLHU6+9+F6jnBx5o/jmRKC2FFSukEen1VeGhQ7Bjh3TUgm9m0Ww3vWwZTJgQ2rlrcTeQIBs2SOCzb9/Q46mp8JPTfsKrH79Kn7w+bPhqAw+d/AvOuUWCqMG7j0R9I25xD1yfPe9DhwGQXdZwqL4evjzQhaFDo/yZbRFpeYERXUfw2sevNQSTAI7vcXzYc998UxIbZ2VJnzA7Gy67LOypAEwonUCXrC5U1VUxuWxyxGUCeOcduQZHEnjr2UkCSnsqJcn65/sk4XGvTr2i+pmRSkuTRJqdO7d87i9+AeecA8uXSycmI0OCqv/8J9x/fyBIlp0t29y2lcfj4cFTH2zIsbLg1Oh6EaW5cm3fVrGNzP/OpKpWAlP+3eEcA0l+ldvA1sp1289pEKEdLV8u9+y0tAhO/mIJDLgeUpNjxMi/A6R/lz5/ILW8oJwNX23gH5v/gdcjF21/gLAtpk6FVaukjbB2rbz3Bw66DrvpZEyfyyCzO5y9RRroqR2avsDeFZDdG/LHhAST/LbdtI16W096SlDHID0Pup7Y5rIfC3bulA0SvBHE24qKpD27caMMDPt98IEEtq+6KnA/zsqCJUtkM4SiosA9tGvsNw+OqSW+POivvSZ9jylTZFOaSy+V9JVer1xvH3ww8tc8dAg+/BAuvxxmzpR28m9/Cze8M4TlO5azed/mhnto3r4pdBstfSQ/p8GQ5niMJzSA/8WfoWB8oE3dzHV1504ZoPjRjwL30JgMYtUdlk562HZ90/f2rcffyh8/+iO5abkcqDlAx/SObR7oKSiArVubXtvr68NeXuiUIVG9ZTuWNRzLywwfwPEHkZ5Y+USTY40N7zqcJZuWsPXA1oZzpuV1gQwPlM7yBTua8dUy6DgQclv+e/zznzLoFE1bO6zGbcOdb8Gy6yArwkkCwJAuQ3hlziuUdSoj1ZsKBWPhtFXw2TOyk3rtYRkAmPbz0IC4vw/XKCDuaM9SSO0EA66TQYVgvS5oeRC/41Co3iV9ys4jpT7O2Sk7M6dkS7Dqi79A7UHZLKnzSPC4c9AiJgElFTBnyBzmLprL2l1rMRjKC8vb7WeddprM+nj9dWmUZmVJp8CNcQ0nq1eHNhj8OneWG+2uXbB0qewedsMN8OKLsmNZ8EV6VN8esAa27N9CVW0V1XXVZKdmk5UaYY+8YBwsmwvBnRD/G7qkD1wY9McMHnnrPLx1v3Q8VX0pAbPcoNkcseo4RTgyCfJ/Wl4uI8mxdMstcPfdMsKVkSGjP0uXQklJ0450NDP3/v53aeRFE0QKVlEhDbWamqYNil6depGXmceGrzYA0C99EoWFEoCKi70rZUe7et+OcC92w1R+gcfUUlfnzhvVZSMu4+6/3U2aN61h9O6knic1Oc9ambn59a+HBuRqa5ucGuKLW51HL5tz6JDUc5NOUpj3Rn52Id47Zde6elvPtgMyY8M/cynWTj8dHn1UBtn8jfSqqvCdhrw8CY5t2CD/+7t3S6BswQLZ3TA40NnmxqLPJcMvaQgoTeszLarnGmPI8GZQVVfVEExK9aQ2BChadOQApBXItdGvmRHs9lBbK9eHbpFejg98BIVBQdQEBMCi4Q8o7TosO+btPrwbgIwU+Qe85+/3NJxbVx+bva69Xvm/DRgAW34Gb06UzlNmN9npLWi3tAZ7lstW5XU14M1s8vdN9aY2fY6KeGAgM1OCB5FcP9LSZCD461+HV18N3EP/+leZnd/4er56tbQFgu+hcbuftsJXX8HevXDuuTLDNStLdkE+6SQZvG48qzlSK1fK3/m73w20d1JTA8GGi/94ccO5u9f357Thodf21goJ4FfvgU7DAx3pZq6r69bJoGC/fm0vQ4gO/WDbn2iY9eHfQfDIwbAB+QmlEzAYDtTI9NsbxkUxRcvBpEmwfbsMpk6dKnVcXy+zx8IFzWYNmsVj7z+G13ixWOptPbOHzA772pPLJvPo+482tIUATuwVPrCdkya/701v3NSwomGgt0b6L3VVLQc89rwv18Wg9qKTNWtg8OAIB0iisf9DmUlVXwNktjjjzO/MAaEb8JCaA/2uanTWz9tetoJxUH8k9HhGt9BBfKe/mzcNxv4P/O1cGPWIzKyrr4GNP4eh8yHvOPlIAhGsl1HRKMgqoCBLdueYN2leC2e3XadOEmBZsEBGjidPTp5gEsiyjOZuJoWFcMYZcPbZsgSxtLTpzI2uGTJavWz7Mub9Wf7m/mh/RDr0kYDL0iuhtlICSUcq4Kvl0f467lNXCSmNRmNj1XFqHExq5viaNXDqqaGd2VhMhb3gAhgzBkaMgO99T2ZTXH+9LJusrAw9N9yokJNPPpFlE61tbGVlSYPR6fl3nXQXAGcNOAusl9RU33bV8VDzFWQWhzT4jIGywk387W9xKkOUeuf1JjMls6EBNaVsCp5wswi2SaeyT6MVNI2XJ8dKfr7MsqypaflcA2T7zpv41ERW7FgBQPfc7s5PaoO77pJOyqOPyrXzyBF4+eXmn9Ovn8zmuuoq6ZAVFzd9n8YqoJSdls3ZA87m+v+4PrKlu434lzT7O0vFHYqbOz2UJ12u8cEBqAz/lIb4NIv8QchI/ncAaWSmB41YxzkAFi1/QGnP4T3U1teyt3IvAKOKZe1wdV011XWydfGgwkHtV5DSmTBrG/T4mmwd3vvS8GtgK7dCbt/AKLPL/77JpndvCQStWBF6vDrM7tUA//Vfspy9vFzu87NnS6Ckb9/Qa5C1cr+OZkl6oq1YIW2h739fAj8ejwy2ZWRI2yVYNJ3zzz6TAHVwkDo7G4pzml4bK78sYdy41s1KapY3S9oY/gBEM9fVDz+Ue05VVYzLUDxDZhzueV/a9CAd/iP7HZ9y5ajAtutn9j/T8bxIeb2y0uLSS6Wely+X++/UqeHPP7mXbOVmMNTbelI8KY7L+qf3mw7I7LAUI2+GmQNmhj3X3x+trqum0ve3GOg5DB3LAwGP5gYnDm2W2Un+QFwz18WDB6VPGk0QNCJ1VZCaG5hxFstr886d4TJ5Rjfjv9PgwH3D/7fM6Ap1QRe35src4zyY9AfY9Gt4tS8sGglVu3xLtZOHBpTawQVDLpDPQy9IcEncr6JCpoZGcgH6+GMoK2vaACnw9Ra3VWzjwXdlfvChI4eiK8ikP8CX78CiETK18m/nwtunhr/YRLFUJ+E8qVBfRchbPVYdJ6c55WGOb9ggecpiMRoWzBh46in4/e+lUbJmjTRCo5pZ1K1bkyhs9Zr1bRrh7N9fZnls3Rp63J8PYfZgGXm6bMRldO4sednC5vlpXDZjopjS4MSDjNz5fqDv/2HOhD9wzz0y68bvUJRvo/Y0a+CshsfT+04Pe86nn8o1oqUZSbFy6qmSt6NJUMChkVKfK42yd7e+25A/KKpASBQGD5blf08/LdfY/HxZBhqpjRulsd84MBuTnAg+L815iYenP9yq515+3OUATCiZAMA3R34z8idn94S6Cjj0eeDYOTvhAgsXxKcRZ4wE7Bp3sJ2f4IHgmTxxDoBFq2O6TEfdXbmbtB+mUVFTgcEwtXfTHtWJPdt52Zg3DYqmQe+vQ9eTw4+61VVJoNHju0m5/O8bM+1yj2nKGAkMzZ0r7b6aGgl079kT/nyPBx56CD76CK68UvJpnnsu9OwZOsPj0CF5rbKy8K/jRps3SyAneDB10yb5HRrfS6IJ+GzaBMOHN32NcMvDM+jUPgMtBeNkGVDdYfm6mevqhg0y+BPzoFZKtuTK+dv5sP4B2Ptv2PS/sPgEx6ecMyiQA3Vk0ciYFOO00yRVx0cfyeNbb4Xzzgvf1jPGMLp4NLVWGi+n9nHOKZiRkkHPjj2pt/XU2lryM/MdB9HDzVwqzsiU4Lr/WtdcsKPeN2PTP+jTzHUxM1OCSkeONPlW23hS5frsz4mVEdzHSPD1+eBGyRnW+G9pa0Ovqy3dTwrGwYmvwNe+gnN2wJjHki4fny55awc3jLuBz/Z/1r6jbkeRSGdU7d8ffg3+oK5NE3oW5RRFV4is7nDWJ/DJ05KrIncQjPlpdK/hRhldZJZS5XZZLwyB6b9tFUVgbft2CbK0lzFj5AMkT9NTT0Xx5DAzqtI40qQjHY3UVElA/oMfhCYorKqSx4XZhdj5gVZFTo7kbZoUlAeytradLtDp+bBnmW+6c3rD/8MN02BhPzjrLGnIZ2dLsvxnn22PQkRvap+p/OaD3wDOCTMrKyVwEq+A0rRp0tn5y19k84asLOngOOWB6JLdhYM1oZlY/UuA2sP48bKsYNMmCcRH8x6srJRAlFtnvE7sMRGgoQEeVRJVTwrkj4d1C+C4BYGRWn/egjiZNk1mkY0ZE5oMPez/T1qeJNPP8CU9idV1vJ0YY/AYD/W2viFvi9fjbciXlOZJw2M8VNVVMbrYBYlGvZmSp6KuOuS6eNQLN9PYafZxG/33f8uStaFD4cILJbD03HOS2sBJXp7kAwI5t/GMnerq0I1pksH27RLwr6wMDKZWVspS/bZ0xtevhx49mg6o+a+V/qVptfW15OVkt6mN46jbFFg9D2r2y6wSkEB4mOXIBw/KqoN2qbv+18rs/FW3wZofSlB50K2Op/uD2hkpGa2aMetk5MiWZwb7Tes9jWXbJYeSf8aSk8llk/nlql82PHYypHBIw2MPHuqppyAjLzRYkdHVFwgJ83unBM0486Q0e10sL5f2d1VVjGcp5fSGz54NlK9hCeMhSE3wBhV1VZBe2PT4wU/lnuJ3DNxPjvKhl8Qo61zGy3MivIIc47KzZYQqkmn/NTWhu+H4eTyeJjcAf3LWqHgzoP9VMOl3MPoR6NC35ee4nSdVEjBvX+Rbf+xT2x4tCWfV1fFLkllcLLPZGjeqHJeUhSlYETtYtSr6HVaCzZ8vM6fuuiuQKPwch40ATzwxcJ5fdTXtM0MubzTs+7c0sIIUFMiMlo8+gokTpSH0pz+17UfF0vGlgVHWkd3CjyDW1UnnwmlXt1jr2lVyXlx4Idx7rwSWmtshp2/n0GtKeksJMWPAGFluMmhQZAlx/Wpr5Xy3BpSGdJGG8sY9GwEY2iXKjPLlt8GmZ+CTX0oQoa4SVt0R62I26xvfkFyBL78s7/2KimZmLBWMg+2vx/3a3RaNg6VZqVl4PB5Kc0upqa+hqq6KrtldI8991Z469JOAXV3y/H1jItyNuZ1u1h07yv/35Mnwk59I7s9vfzvy63VGhuRhCr4v+58bzZL2RNu0STrfwZ1uf/u2LT75RJbMNQ66ZaZmkpmSSW19LbX1tWSnZtOj1MuKFe0wmyR3gKSQeGeGLJeqq4aK9WFPtbad6633JTBrB3xtN3xtv+SkcZCekk5pbik3/Efb8ye11vjS8Q2P/6Ok+R3CJ5ROaHjsDxiG4/F46N5BltXnZkiALyszT3Jd+XMINjc7N7dc8gTVtjxdffx4yeMV8zotGA/7PgjMevOLYeCvTcLNRKqrhIqNoefVNir/UcYltaGOVQMGyNKKSBoUXq80JMKd2yFN5u76A0sjuo2IZTGTW/EMWPfjQECpvt63DC5+6upiv9zNyfDhMqV8f6Pl8o236G0QJmgz8a5pvP9+25Z8nXSS7F64cKHMPigpwTFH0W23yQ4Zt9wiI5X79sH557f+Zzcrf7SMnuxdFZqUGJkp8emn8Pzzsv3w5s3tVIZW6JsXCMY4JchNS5PRsXgGQR54QBJgL1gAZ57Z/Iyuk8tk1LFrtjQ6BuQ7bFnrAmlp0smJV3AuWh3S5Zq/85AEWPOz8qN7geLpUHImrLpd8h78oRA+eTLWxWzWxInyv3PFFTLD7YwznHNs0G0qfPYbmUrvF0EjP5E6Z4TujFCYJSO5wTOSXDE7CSTQvndNy0lqjzZxXtZfWCgziCsqJDn1/PmRX6/LymSwKPhenp4u7YuY5+FpR1u2yMyc4EEvr7fteRQPH4ZevcJ/b1TRqJDHEydKMvOYz1IyBiY8K8GkV/vDy71gUfgEVxkZ8n8Q86BW4/Kk5ka0M9bmGzdzz5R7WjyvvYwpHtPw2GnQzO+4okCi5uC6DWd4N9lAaF/VPopyijC55TKoGMn9I3+0tBUddpELVl4u78V58wJt55ikTcjoIkmuV9wcKHPtIdjy+xi8eBt5UmWTDz9/cC5/LKy9WxLB+yVZTqRoaUBJJdTw4bIkI5KR8/R06Wg3njVSXw+n9pX1xrMGSJ6VM/qfEeuiJq8Bc2XJ2+ITZAvKPUvhjeZHP2LNmPglnc7JkQHWn/5UGlh+0fz80aNlR5lgTslDm/PjH8suNeeeK8kZ16wJf96YMXDRRRLEycqSHereeSf6nxeR1FzZGvu9b0DNXklOHHRDTEuDGTMkEb6bdsoxvl6Hf9eScAoKJCAWyzw/LUlLkyDS3/8OTzwhOxo6mdRDlmWd0FNyOczoNyMeRWyVTp2k49O4sxe35PER8C+fKuvUygQqE34Dxz0ko4o5fWFi/BuozzwjGwmsXClb3jsGknv9J1TvlpH/6q9kgGCF8xIONxhXMg6ALlldAJhYKiPp0XSG4qbzcKj+Ajb/LpBMtS7SjOkqHkaMkIBS8OBUTo4k6f78c+fnJVSYHFXbFq9tkvMpM1M28mjLYEhNjfPyseD33MiikRx3HLz7bujqgJgFdnL7wxnrZDAzJQt6nN9k8AokH9Ynn4S2045lXXMCMwOz05pfyjW4cHDDY3/AyMnwroHvjy4eDXkjYf+6yGb45B0Hldtgy0tB18XwUUiPR5LpP/kkfOtb8MYbkjMtJoZ9X8qw9ArY8y/46BH417di9OJtkNk97OAs/a+Hra/IIFV9jbSx/3JWYsoYJxpQUgnVt6+MLD3xRGCEyemm1qOHNBoa33APH4bygnIAth/cLuf6dgBSSH6ooT+U6fz/NwoWT4DDW1t+XgylpMR3BPHCC2VK/bp1MgJ26JAci9QJJ8jU+muvlf+vykpJst0akyfL0rennmq6+1iwn/9cAlAlJXLec8+17udFZOQDMoL42kB47zL40+CWn+MCdr6l4o4Kx+/37y9LaBvPTmvXEVCfkSMlGNC3mZWyPTv1BODzfdL7adXS3DgZOFBmjzYOzrkpUfsZ/WTgoNWBOWOg3xVw5nqYsQq6nxbD0kUmLQ3uuUeuMYcPS1A5/ImdYej3ZVDgD/nwfAZsejqOJY2ePwH36f1PB2Byb8n1MbBgYMM5rsk1mZIFxafDsuth70rZFWpfM9FhFXdDh0pAadu2wDFjZObSypWJK1ezwuSj2kcnSkpCj/XoIUmqG19v27LsPtjgLoF7/ODCwYwdK6/9jW/Idae5BOmtklUMJ7wouUkn/Dps8KK8XJb/xWrn0GNJekpgfWRzg2wAgwoC19iR3UZCp2FwYF3ophT1tYHgZ3AnK60jrAH+dQ3sfk+OffG248+aO1cGSF96CaZPh9/+Nqpfy1nZJVA4Aba+LAPia34AaVHOSm4P+WNkOV7j2V49Z0NWKay81TcDuosEwo5iGlBSCeX1SsLFO++U2RuVlTIqHs6AATL7oPEITF1doKO29YAESrrlxH6XkqRWfjOMf0byKXUcDCe+Ftcf36FDfEcQb7xRAlgTJsCcOTKy+ec/R/78nBy4/HJJMDhtmixJG9HOqyiNkSVyW7ZIR/6s9hzMKBwPw38kN8Ftr8mMh6NAVpbMrGk8u8styyH8mwX4A9/+65Yb9esnI+abNoUejyYPU3vzj7q7ZpZLG6SkRLBF+KBbYMR94EmTDlqP2XEpW2uV5EqveUfFjpCvgwNKwY8TbviPZDn4mxPgpWJ4Y2yiS6SC9Oghs2bnzg3Majl8GIYNk47rgaCVJ8GPEypMPqpaUsjLCz3m3xm28WBINAH81FTnmdTBW9APKBhAWhrcdBMsXgzHHy9tpmHDIv9ZsVBeLkG0CucxomPO6qtWs+7adTF9zX75ge0EBxQMkHxxaR1h6eXSBqyrgiP7nZPxP10DtgaWnATPp8M7pzv+rJQUaWv/4Acy033evBgtmzceOPn/YPA8yBsDvS6CM9bG4IXbqOMQ2P1uYJc3P48XpvxVlgz6dvRlyPfiX7440oCSSrh582QGwfjxMGqU3GTC6dtXlrwtWxZ63OsNzEjaXiEdtVju0nDU6HGOjMSf/gF0c94Voj307AkfftjGFwm3vbHDFsfdusmMIK8XXn9dRjRHRdnnvOsuyXOwbBk89thROC174PVywxt5P5y8KNGliZnBg6W+ghvi+/YlrjzB/MmHd1ZIjpKeHd0bUMrIkHwnjZeObtzo/Jx48y95G9o1yoTcycoYGPBtOP8gnFcB43+Z6BI1qyGgdDA0oBScD61fXr+mT0yUjgNhwnOyO09dTeguPSrhjJEk3n/9q2y//sILMiB58smwZIkEY+rq5MM1QYowOarq8rs2mZWTkyMDb6++GjorqcUgc5DMTOe8h8EBJf/jW26RzRrWr4fHH4//7NNeveRPsmBBjHPuJLFhXYdFHGRf9a1VLLtiWYvnNal7Y2DgzbB3NbwxDlbeBouaydm0HZj0IqTkyDUxtflcCB4P3HyzbOry3e/GMKel8cCQ78L0f8G4J1osR1zkHQdVO2HHG4HAkX+2UkYBTP07zFgDZ2+BwfHd9CPetNetEm7oUOm8p6c3n08pPV2WAz3wQCAp4+HDslzOH1Cqs3WU5pbGqeQqUoMGyXp9x8TYkXAaPXE4PmcOvPWWbOt+553wtvMs3bA6d4bly2UZ09ixsoTuqJM/GgZcB11OSHRJYuaiiyQI+OtfS+P04EHJYeUW3Tt0b9jq3u1Lc2fOlI7Ghg1yrT14EC67LNGlCujduTdFOUUh+SSOCZ5USHF/sMMfQNp1SPaF9+82FLz7W0u5QuKudKYMuoz/JczQJW9uc911sjvwokUwe7bc1889V3IBnXiiBLw/+UQeu1V9ffidsIYNk3aGf0ZtdXV0O62WlckureGWePtnx0JgU4jsbNkM5PLLYdIkeOSRaH6LtvN6JVfjQw/JwB9IvarIDO82nFHFLY+U5mUGpsM1BPD7XQ1ZJVDxMXz8qOTnc9rdsWtX2cTizI/hhJfgzA2xKP7RIbe/JAx/9xKo2CC5lP4dtJug8UCHPpBRmLgyxokGlJQr3Hor/OpXcMkl8PDDzlMkZ8+WbZb/93/lpvzBB3D77YGGK7S8O4KKvyFDJEFf8KhcPKakT5gguYluv711u8zl5kpgYulS+OY3Y18+FXvnnSfXhmuugSlTZMaj41bsCRCcHDUz1d1BgSuvlM8nnABXXw3jxsk11y28Hi/bb97u+r/jscrfkdlTKclZXBc8cpJTBqXnSEdAuUpurtyPu3SRgEi3brIZw8yZsHWr5H4bMMDFSbqRQEptbdPjl1wiwfvvfEfuYZs2SY6jSA0aJL93uJ3bTNA0keDHGRnw6KMy6+vyy6P5LWLjpptkFtb558vn886LfxmOJR0zOsqDlCw4dSkUjJeZPiVnw44dTXd8DN71MbMIup4su66pgPJbJQfV68NkSeD6BYkuUUJoQEm5xte+JkGlK65wniJ55ZVyM77mGsjPlw5OSkroiGd5ocOaOZUw48avbkqwAAANgUlEQVTJdPRFi2T0rb5e8rMoFWsdO8L3vif5lN57T3JSZbuoH+tfppUMRo6UpcjV1RJYXbvWeRchpRrzd1yr65omdtFl6aq1eveWwMmaNZJXE2Rpbvfu0j70euWxW3m9obur+fkHQxYulPvXoEHhz3NSViYB/2RKcj1qlASysrJkZlU8d2g95qV1ginvwHn74fjfxHBt2jGm9zeh8wjwpIOtPWaXSusdXSWVPn1kFCcrS/KipKRI8thgZZ1buYW0ajcTJsiI3CWXwOrV0hicNi3KF2luOq5SQe64Q2aUeb2Sl2LJkkSXKMC/xX2vjr0SW5AI/fGPkjA2J0cCc4sXJ7pEKpkUZslU/76dQ7c/rLuzDjs/Ftla1bEoPV0CKP4cQ/n5sqz+iivk2v/uu4ktX3PS02UySGMdOsC990r7trpa7l/FxZG/bq9eMoASPFgXPFvplLJTOKXXKa0ud3t55BHZUXfQIBksjkkSZxUiP9MFO6IdrbxpMPlNKDlLknSPXpjoEiVEEsWxlRI//anMwHz1VRmpeustOd4lqwtfHv7S9XlJjkWpqTID7ZlnZLZSq/in3SrVAmMkF8V990njPVy+ikTx7+yWLNepnBzJSbV2rSSpLyhIdIlUMhlSOIS3P3+bkUW6FF21r27d4Gc/S3QpWtali3Py7Ouuk01EHn5YrreNdyxtzogRMgP8oYckL2l2dmiC77cueatN5W4vxsD998uHah+7b9ud6CIc3VKyYeILiS5FQrmoma1UZLxeePllmQq8fr2MTAEUd5ChnGTpqB1r5s8Pnc6ceWzOClVxlJnprmASBHZ2S6brVFqaLH/TYJKK1rBussTzmEucrpSDkhL47LPQYE+w++6TGUobN8q5kerYUWbxP/igJNuurdXcj0qp+HBZU1upyDVeJ+4PKOkub+7Uuzf89rcyYyQ9XRJPKnWsKe0o16eiDkUtnKlU8kvGAKpS7alXLwkoHT4c+9e++GJpX02bJjPDXzi2J00opeKkTQElY0yeMWaxMWaD73Nnh/OmG2M+MsZsNMbcHnT8+8aYbcaYVb6PGW0pjzq25WbkAtAhvUOCS6KczJgB27fLyNv8+S2fr9TRxr+BgD8ArtTRzL8Da/BOrEody3r0kITi7eHii0Nn5SZTgm6lVPJq6wyl24El1tp+wBLf1yGMMV5gIXAaUA78pzEmeBuuh6y1I3wfr7exPOoYNr3PdFI9rdgbXsVVXl5007iVOtrY+ZYbxt2Q6GIo1e6658p2WxpQUkoUFcnudMGbah04EJvXLimR/En+9AK6K6dSKh7aGlCaCfzK9/hXwNlhzhkLbLTWfmqtrQGe9z1PqZi6dMSl1PxXFHusKqWUUqrddO+gASWlgg0cKJ9ffx2OHJHHsZxJdPPN8MADMGeO5FJSSqn21taAUldr7Q4A3+cuYc7pDmwJ+nqr75jft40x/zbGPOW0ZE4ppZRSSiWXktwSnj/neV2KrpTP4MGyG9t3viOJs6urZVe3WDEGrr4annsOhg6N3esqpZSTFgNKxpi3jDEfhPmIdJaRCXPM+j7/DOgDjAB2AAuaKceVxphlxphlu3btivBHK6WUUkqpRPB6vMweOjvRxVDKNVJTZZbSZ5/BrFmST/KHP0x0qZRSqvVanGRprZ3i9D1jzBfGmCJr7Q5jTBHwZZjTtgLB226VANt9r/1F0Gv9AnitmXI8DjwOMHr0aOt0nlJKKaWUUkq50cyZsG4dvPGGfCilVDJr65K3V4BLfY8vBV4Oc877QD9jTJkxJg2Y43seviCU3yzggzaWRymllFJKKaVc6bzzZKaSX6ruJ6OUSmJtDSjdC0w1xmwApvq+xhhTbIx5HcBaWwt8G3gDWAe8YK1d63v+/caYNcaYfwMnAze2sTxKKaWUUkop5UrDhsGJJ4LH1wuLZVJupZSKtzZdwqy1e4BTwhzfDswI+vp14PUw513clp+vlFJKKaWUUslk4UIYNw727YO77050aZRSqvU0Jq6UUkoppZRScdK7tyTm3r8fiopaPF0ppVxLA0pKKaWUUkopFUdZWfKhlFLJrK05lJRSSimllFJKKaXUMUYDSkoppZRSSimllFIqKhpQUkoppZRSSimllFJR0YCSUkoppZRSSimllIqKBpSUUkoppZRSSimlVFQ0oKSUUkoppZRSSimloqIBJaWUUkoppZRSSikVFQ0oKaWUUkoppZRSSqmoaEBJKaWUUkoppZRSSkXFWGsTXYaoGWN2AZ83OlwA7E5AcVTbad0lJ6235KV1l5y03pKX1l1y0npLXlp3yUnrLXlp3SUnp3rraa0tjOQFkjKgFI4xZpm1dnSiy6Gip3WXnLTekpfWXXLSekteWnfJSesteWndJSett+SldZecYlFvuuRNKaWUUkoppZRSSkVFA0pKKaWUUkoppZRSKipHU0Dp8UQXQLWa1l1y0npLXlp3yUnrLXlp3SUnrbfkpXWXnLTekpfWXXJqc70dNTmUlFJKKaWUUkoppVR8HE0zlJRSSimllFJKKaVUHBwVASVjzHRjzEfGmI3GmNsTXR4VnjGm1BjztjFmnTFmrTHmet/xPGPMYmPMBt/nzokuqwrPGOM1xqw0xrzm+1rrzuWMMZ2MMb83xqz3vffGa70lB2PMjb5r5QfGmOeMMRlad+5kjHnKGPOlMeaDoGOOdWWMucPXZvnIGHNqYkqtHOrtx77r5b+NMS8ZYzoFfU/rzSXC1V3Q924xxlhjTEHQMa07F3CqN2PMXF/drDXG3B90XOvNBRyulSOMMe8ZY1YZY5YZY8YGfU/rzSVa0/+Otv6SPqBkjPECC4HTgHLgP40x5YktlXJQC9xsrR0EjAOu9dXV7cASa20/YInva+VO1wPrgr7WunO/R4D/s9YOBIYj9af15nLGmO7AdcBoa+0QwAvMQevOrZ4Gpjc6FraufPe9OcBg33N+6mvLqPh7mqb1thgYYq0dBnwM3AFaby70NE3rDmNMKTAV2Bx0TOvOPZ6mUb0ZY04GZgLDrLWDgQd8x7Xe3ONpmr7f7gfustaOAO70fa315j5R9b9bU39JH1ACxgIbrbWfWmtrgOeRi5JyGWvtDmvtCt/jCqRj2x2pr1/5TvsVcHZiSqiaY4wpAU4Hngg6rHXnYsaYXOAE4EkAa22NtXYfWm/JIgXINMakAFnAdrTuXMla+1fgq0aHnepqJvC8tbbaWrsJ2Ii0ZVSchas3a+2b1tpa35fvASW+x1pvLuLwngN4CLgNCE4Sq3XnEg71djVwr7W22nfOl77jWm8u4VBvFsj1Pe6ItFFA681VWtH/jrr+joaAUndgS9DXW33HlIsZY3oBI4GlQFdr7Q6Qf3qgS+JKpprxMNJIqw86pnXnbr2BXcAvfUsVnzDGZKP15nrW2m3IKO1mYAew31r7Jlp3ycSprrTdkjy+ASzyPdZ6czljzFnANmvt6kbf0rpzt/7AJGPMUmPMX4wxY3zHtd7c7Qbgx8aYLUh75Q7fca03l4qw/x11/R0NASUT5phuXedixpgc4A/ADdbaA4kuj2qZMeYM4Etr7fJEl0VFJQU4DviZtXYkcAhdIpUUfGvZZwJlQDGQbYy5KLGlUjGi7ZYkYIyZhywVeNZ/KMxpWm8uYYzJAuYhS2+afDvMMa0790gBOiPLcW4FXjDGGLTe3O5q4EZrbSlwI77Z8Gi9uVIU/e+o6+9oCChtBUqDvi4hMOVOuYwxJhX5Z37WWvui7/AXxpgi3/eLgC+dnq8S5njgLGPMZ8iy0snGmGfQunO7rcBWa+1S39e/RwJMWm/uNwXYZK3dZa09ArwITEDrLpk41ZW2W1zOGHMpcAZwobXW35DWenO3PkgAfrWvrVICrDDGdEPrzu22Ai9a8S9kJnwBWm9udynSNgH4HYFlUVpvLhNl/zvq+jsaAkrvA/2MMWXGmDQkidQrCS6TCsM32vAksM5a+2DQt15BLkr4Pr8c77Kp5llr77DWllhreyHvsT9bay9C687VrLU7gS3GmAG+Q6cAH6L1lgw2A+OMMVm+a+cpyLp3rbvk4VRXrwBzjDHpxpgyoB/wrwSUT4VhjJkOfAc4y1p7OOhbWm8uZq1dY63tYq3t5WurbAWO890Hte7c7Y/AZABjTH8gDdiN1pvbbQdO9D2eDGzwPdZ6c5FW9L+jrr+U2BY5/qy1tcaYbwNvILvgPGWtXZvgYqnwjgcuBtYYY1b5jn0XuBeZ3vpNpBN1XoLKp6Knded+c4FnfQH3T4HLkMEErTcXs9YuNcb8HliBLLtZCTwO5KB15zrGmOeAk4ACY8xWYD4O10dr7VpjzAtIcLcWuNZaW5eQgh/jHOrtDiAdWCztcN6z1l6l9eYu4erOWvtkuHO17tzD4T33FPCUkS3pa4BLfTMDtd5cwqHergAe8W0cUgVcCfp+c6Go+t+tqT8TmMmrlFJKKaWUUkoppVTLjoYlb0oppZRSSimllFIqjjSgpJRSSimllFJKKaWiogElpZRSSimllFJKKRUVDSgppZRSSimllFJKqahoQEkppZRSSimllFJKRUUDSkoppZRSSimllFIqKhpQUkoppZRSSimllFJR0YCSUkoppZRSSimllIrK/wPqWjNWN9GbMQAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -2606,19 +2632,7 @@ }, { "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2630,7 +2644,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2644,13 +2658,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "tal hits: [MotifHitAndCoord(motif_idx=0, motif_score=0.7170648136313933, precision_at_motif_score=0.5766776497955829, example_idx=15, start=5, end=30, is_revcomp=True), MotifHitAndCoord(motif_idx=0, motif_score=0.9977790829683072, precision_at_motif_score=1.0, example_idx=15, start=14, end=39, is_revcomp=False)]\n", - "gata hits: [MotifHitAndCoord(motif_idx=1, motif_score=0.9987429074356223, precision_at_motif_score=1.0, example_idx=15, start=71, end=96, is_revcomp=False)]\n" + "tal hits:\n", + "\n", + "gata hits:\n", + "\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2669,7 +2685,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABIcAAACMCAYAAADm+clLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXxbZ533/c8leV/j3Vnt2HGapmnSJm6WAqW0paSlUHa6UApdQoHyDPA8M1BmbmBm7vtmG+CeoYVudNpSus1dCh3oCgVamqXZtzaL7WyO4z225UWSJV3PH5JdJ5Fj2XF8JPv7fr38inV0jv2zfXIkfXVdv8tYaxERERERERERkanJ5XQBIiIiIiIiIiLiHIVDIiIiIiIiIiJTmMIhEREREREREZEpTOGQiIiIiIiIiMgUpnBIRERERERERGQKUzgkIiIiIiIiIjKFJTldQDSFhYW2vLzc6TJERERERERERCaNzZs3t1pri07ePmI4ZIx5CLgGaLbWLopyvwH+Hbga6AU+Z63dErlvdeQ+N/Cgtfb7sRRbXl7Opk2bYtlVRERERERERERiYIw5FG17LNPKHgZWn+b+q4CqyMca4BeRb+gG7oncvxC43hizMPaSRURERERERETkbBsxHLLWvga0n2aXa4FHbdh6YJoxZjqwHKix1tZZa/3Ak5F9RUREREREREQkToxHz6GZwJEht+sj26JtXzEO309EREQmqVDI8vJbjfzfzfX4AiGny4kbcwszubiygBVzC8jLTHG6HJGEY63lcHsv62rbWF/XRluP3+mSJpzbZbhqUSkfuXAmqUnus/Z9rLW8vr+VJzcexuMNnHJ/fmYKn11VxrKy/GG/RiAY4vc7jvHc9gb6g6c+FqyqLOBLl84b17pFprrxCIdMlG32NNujfxFj1hCelsacOXPGoSwRERFJFKGQ5YVdjfzs1f3safQwc1o6JTmpTpcVF4IW/mtTPY+uO4QxcG5pDhdXFrCqsoDlc/PJTkt2ukSRuHSss4+1NW2sq2tjXW0bRzv6ACjKTmV2XrrD1U28jt5+vvHMTn7yyj5uffdcrl8+Z1yvH4FgiBd2NXLvX2vZ3dA17O9559FOfretgeXl+dxxaQXvO6eYcBtb6PMHeXrTER54vY76433Myc+gMOvEQLy128+62jY+VT2bwiw9ToiMF2PtsHnNOzsZUw78fpiG1PcBf7HWPhG5vRe4FCgHvmut/UBk+10A1trvjfT9qqurrRpSi4iITH7BkOX3Oxq4+9Ua9jd3U1mUyVcuq+KaxdNJcsfSGnFq8AdC7KjvYF1tG2tr29h8+Dj+QAi3y3D+zFxWVRZwcWUB1WX5pKecvREBIvGsxeNjfV34/8j6ujYOtPYAMC0jmVUVBYOhamVR1mAYMZVYa/lbTSv3/rWWN2rayE5L4qaVZVx30RzyMpPJSEnC7Yr+e/EHQvT6A/T1B0+5L2Thz3uauf+1Og6391JRlMkdl1Ry7YUzoo5Q6vUHePLNIzz4eh0NnV7OKcnm9ksqaOjo4+G1B2nv8bOsLI8vvreSyxYU4zqppv1NHt7/09f4pw+ey23vqRifX47IFGKM2WytrT5l+ziEQx8E7iS8WtkK4D+stcuNMUnAPuBy4CiwEbjBWrt7pO+ncEhERGRyWVvbyj/9dhe+/hD+YIhAMEQgaPEFwrfPKcnmzsvmcfX504d9cSLv8PYH2XL4OOtqwyMith3pIBCyJLsNt767gm9etcDpEkUmTK8/wOce2sibB8NtUrNTk1hRkc/KigIurixkQWn2KQHDVLf9SAf3vVbLC7saGfpyMDXJRWZqEunJboIhS68/QK8/SCA08mvGJbOn8cX3VnLlwpKYft/9wRDPbWvgvtdq2dfUDcBlC4r54qWVXFQ+/JQzgI/+/A26vQFe/tolUzLoEzkTw4VDsSxl/wThkUCFxph64DtAMoC19l7gecLBUA3hpew/H7kvYIy5E3iJ8FL2D8USDImIiMjk86e3m6k/3seHl8wg2W1IcrlIdrtIdhsunJMX84sJCUtLdnNxZSEXVxYC0OMLsOnQcX7yyj7+e3uDwiGZUh547QBvHmznq1dU8b5zijlvRo5GHo5gyexp/PzGZdS1dLOuro1eX5Aef4A+f/jfXn+QJJchIyWJjBT3YGCUluwm2qW6oiiLi8rzRhXUJLtdfHzZLD564UzWH2ijMCuV+SXZMR37qerZ3PWbnWyv7+SC2dNi/p4iMrwRwyFr7fUj3G+BLw9z3/OEwyMRERGZwmpbuqkqzuLfPrnE6VImpczUJN47v4gdRzr48Sv76PUHyEgZj9aSIvGt2ePlvtdquWpRKV+9Yr7T5SSciqIsKoqyHK3B5TKDQXesrlk8nX/+7908vemIwiGRcaJIXURERM662pZuKh1+ATIVVBaHf8d1LT0OVyIyMX76yn78gRDfWK3RclNJdloyV58/nf/e1kCf/9Q+SCIyegqHRERE5Kzy9gepP96ncGgCDPyOa1u6Ha5E5Ozb3+ThqY2H+czKMsoLM50uRybYp6pn4/EFeHH3MadLEZkUFA6JiIjIWXWgtQdrobJYL97OtrKCDFwGajVySKaA77+wh8yUJP6fy6ucLkUcsGJuPmUFGTy9sd7pUkQmhZhWK5to1eW5dtN33u10GSIiIjIO2np87G/u5vyZuWSqD85Zt/XIcTJTk5hfHFtjV5FE1Ont5+1jXczJz2BGbrrT5YhDjnb0cuR4HxfMnkZaktvpckQSgrnl+airlWnkkIiIiJxVA/0g0pP1xH0ipCe78aoHh0xiFsvhth5S3C5Kc9KcLkccVJidCkCLx+dwJSKJLz7fviusgs//wekqREREZBz88ImtbA0c5/VbLnO6lCnhmT+8xaPrDvHWzatxR1tzWiTB/W7rUb66dxs//fQSll44y+lyxEGpwC8eepP9TR5ev/kyXfNEYnFL9P8nGjkkIiIiZ5VWKptYlUVZ+AIhGjr6nC5FZNx5+4P86KW9LJqZw7VLZjpdjsSBT1XPpqHTyxs1rU6XIpLQFA6JiIjIWRMKWepaehQOTaCB5exrtGKZTEK/WneIox19fOuqc3FplIgAVywsZlpGMk9vOuJ0KSIJTeGQiIiInDXHurz09QcVDk2gweXsmxUOyeSztraVc0qyuXheodOlSJxITXLzkQtm8vLuJjp6/U6XI5KwFA6JiIjIWVMTCSgqi7SM/UTJz0whLyNZy9nLpNTS7WPGNDWhlhN9snoW/mCIP+w85nQpIglL4ZCIiIicNQOjVwamOsnEqCzKolbTymQSau7yUZytcEhOtHB6DtNz01hb2+Z0KSIJS+GQiIiInDW1Ld3kpidTkJnidClTSmVRFnUKh2SSCYYsrd0+inNSnS5F4owxhhVz89lQ14611ulyRBKSwiERERE5a8IrlWVijBrHTqTK4kxau/3qvyGTSnuPn5CFomyFQ3KqFRUFtHb7qGvVlFqRsVA4JCIiImdNrVYqc8RgU2r1HZJJpNnjBaBY4ZBEsWJuPgAb6todrkQkMcUUDhljVhtj9hpjaowx34xy/98bY7ZFPnYZY4LGmPzIfQeNMTsj920a7x9ARERE4lNnXz8tHp/6DTngnXBIU8tk8mjx+ACNHJLo5hZmUpiVyoYD6jskMhZJI+1gjHED9wDvB+qBjcaY56y1bw3sY639EfCjyP4fAr5mrR0a2b7PWts6rpWLiIhIXBvoeaORQxNvVl46KW6XwiGZVJoj4ZAaUks0xhhWVLzTd0jTmUVGJ5aRQ8uBGmttnbXWDzwJXHua/a8HnhiP4kRERCRxDUxp0jL2Ey/J7aK8MIPaZk0rk8lDI4dkJCvn5tPY5eVIe5/TpYgknFjCoZnAkSG36yPbTmGMyQBWA88M2WyBl40xm40xa8ZaqIiIiCSW2pZukt2G2fkZTpcyJWnFMplsWjw+stOSSEt2O12KxKkVFQUArNfUMpFRiyUcijYeb7j1AT8EvHHSlLJ3WWuXAlcBXzbGXBL1mxizxhizyRizqaWlJYayREREJJ7VNndTVpBJslvrXzihsiiLQ+29+AMhp0sRGRfNHq+aUctpVRVnkZ+ZoqbUImMQy7O1emD2kNuzgIZh9r2Ok6aUWWsbIv82A88SnqZ2Cmvt/dbaamttdVFRUQxliYiISDwbWMZenFFZnEkwZDncrqllMjk0d/nUb0hOyxjD8vJ8NaUWGYNYwqGNQJUxZq4xJoVwAPTcyTsZY3KB9wK/G7It0xiTPfA5cCWwazwKFxERkfjVHwxxqK1XzagdNPC7r1HfIZkkWrp96jckI1pRkU/98T6OdqjvkMhojBgOWWsDwJ3AS8DbwNPW2t3GmDuMMXcM2fWjwMvW2qHPQEqAvxljtgNvAn+w1r44fuWLiIhIPDrc3ksgZBUOOahCy9nLJGKtjYwcUjgkp7dibrjv0IY6jR4SGY0Rl7IHsNY+Dzx/0rZ7T7r9MPDwSdvqgCVnVKGIiIgknNrmyDL2xQqHnJKVmkRpTprCIZkUun0B+vqDFOcoHJLTW1CaTW56Mhvq2vnY0llOlyOSMNQhUkRERMbdwDL2Feo55KjK4szBv4VIItMy9hIrl8twkfoOiYyawiEREREZd7Ut3RRnp5KTlux0KVNaZVEWdc3dWDvcQrMiiaE5Eg6pIbXEYmVFPgfbemnq8jpdikjCUDgkIiIi4y68UpmmlDmtsigLjy8wOOpCJFG9Ew5p5JCMbPncfAA2HNCS9iKxUjgkIiIi48paS21zN5XFmlLmtMEVy9R3SBKcppXJaCycnkNWapKaUouMgsIhERERGVet3X66vAGNHIoDAwGd+g5Jomv2eElJcpGbrqmqMrIkt4vq8jyNHBIZBYVDIiIiMq4GVsdSOOS80pw0MlLcg6vHiSSqli4fRVmpGGOcLkUSxIq5BdQ0d9ParWm1IrFQOCQiIiLjajAc0jL2jjPGUFmUpeXsJeG1dPs0pUxGZUVFuO/Qmxo9JBIThUMiIiIyrmqbe0hPdjM9R6sKxYPKokzqNK1MElxzl0/NqGVUzp+ZS0aKW32HRGKkcEhERETGVW1LNxVFmbhcmv4RDyqLsjja0UevP+B0KSJj1uzxUpyjcEhil+x2saxMfYdEYqVwSERERMaVlrGPLwPT+zR6SBKVPxDieG8/RVkajSijs7w8nz2NHjzefqdLEYl7CodERERk3Hj7gxzt6KOiSMvYx4uBoE59hyRRDTQU1sghGa0F03MAqFFTfpERKRwSERGRcdPY6cVamJ2X4XQpEjEzLx2AY51ehysRGZtmTyQcUs8hGaWqyMjJ/QqHREakcEhERETGTWNXOIAoUTPquJGVmkRWahKNCockQbVEwiGtViajNTs/g9Qkl0YOicRA4ZCIiIiMm6ZIOFSaqxdx8aQkJ5Vmj8IhSUwD525xtkJnGR23y1BZlMX+Jo/TpYjEPYVDIiIiMm4GwqFijRyKKyU5aRo5JAmrucuHMVCQleJ0KZKAqkqyNK1MJAYxhUPGmNXGmL3GmBpjzDej3H+pMabTGLMt8vHtWI8VERGRyaOpy0dGipvs1CSnS5EhSnPSaOryOV2GyJi0dPvIz0gh2a33tWX0qoqzqD/eR48v4HQpInFtxGduxhg3cA/wfqAe2GiMec5a+9ZJu75urb1mjMeKiIjIJNDY5aUkJw1jjNOlyBDFOWk0e7yEQhaXS38bSSzNXT71G5Ixm1ecDYRXbFw8a5rD1YjEr1ji9+VAjbW2zlrrB54Ero3x65/JsSIiIpJgmru8lGi56bhTmpNKf9ByvNfvdCkio9bi8SockjGrKomsWNakqWUipxNLODQTODLkdn1k28lWGWO2G2NeMMacN8pjMcasMcZsMsZsamlpiaEsERERiTcDI4ckvgz8TQZWkxNJJC0en5pRy5iV5WeQ7DbqOyQygljCoWhjj+1Jt7cAZdbaJcDPgN+O4tjwRmvvt9ZWW2uri4qKYihLRERE4om1lqYuH6UKh+JOSW74b9KsvkOSYKy1tHT7KNaIRBmjJLeLisIsapq1YpnI6cQSDtUDs4fcngU0DN3BWttlre2OfP48kGyMKYzlWBEREZkcOnr78QdCWqksDmnkkCSqjt5++oOWoiyFQzJ287RimciIYgmHNgJVxpi5xpgU4DrguaE7GGNKTaTzpDFmeeTrtsVyrIiIiEwOTZ5w8KCRQ/GnONKvpUnhkCSYZk94tJtGDsmZqCrO4nB7L97+oNOliMStEVcrs9YGjDF3Ai8BbuAha+1uY8wdkfvvBT4BfNEYEwD6gOustRaIeuxZ+llERETEQY2d4eBBDanjT7LbRWFWisIhSTjNkdBZPYfkTFQVZ2NteMWy82bkOl2OSFwaMRyCwaliz5+07d4hn98N3B3rsSIiIjL5DPSzUUPq+FSSk0aTeg5JgmmJjBzSamVyJgZWLKtpVjgkMpxYppWJiIiIjGign42mf8Snkpy0wdFdIolicFqZwiE5A+UFmbhdhn1NakotMhyFQyIiIjIumrq85GemkJrkdroUiaIkJ21wio5Iomju8pGZ4iYzNaYJDyJRpSS5KC/IYH+TmlKLDEfhkIiIiIyLpi6v3t2PYyU5qbR2+/EHQk6XIhKzlm6fppTJuKgqzqZGK5aJDEvhkIiIiIyLpi4fpbnqNxSvBlaRa+lW3yFJHM1dXjWjlnExvySLg209+AJasUwkGoVDIiIiMi4au7yU6EVc3BpoFK6+Q5JIWjw+itTHTMbBvJJsQhYOtPY4XYpIXFI4JCIiImcsEAzR2u2jRCOH4tZAONSs5ewlgbR4fBRlKRySM1dVHF6xTH2HRKJTOCQiIiJnrKXbh7XhvjYSnwb+No0KhyRB9PmDeHwBrYAo42JuYSYuA/vVd0gkKoVDIiIicsaausJ9bAb62kj8yc9MIdltBv9WIvFuYHU99RyS8ZCW7KasIJOaZi1nLxKNwiERERE5YwN9bEoUDsUtYwzF2Wk0aeSQJIgWTzjI1GplMl7mFWdpWpnIMBQOiYiIyBkbeIdf4VB8K81VOCSJozkSDhUrHJJxUlWcxYHWHvqDIadLEYk7CodERETkjDV2eklyGQoyU5wuRU6jJCdVPYckYQw0T9fIIRkvVSVZBEKWg1qxTOQUCodERETkjDV1+SjOTsXlMk6XIqdRkpNGs3oOSYJo6faR5DLkZyh0lvFRVZwNqCm1SDQKh0REROSMNXV5KdaUsrhXkpNGty9Aty/gdCkiI2ru8lGYpdBZxk9lURbGaDl7kWgUDomIiMgZa+ryaqWyBDDwN1LfIUkEzR6fppTJuEpPcTMrL539WrFM5BQxhUPGmNXGmL3GmBpjzDej3H+jMWZH5GOtMWbJkPsOGmN2GmO2GWM2jWfxIiIiEh8au7yU5OhFXLwrjvyNmjoVDkn8a/H41Ixaxl1VcTY1mlYmcooRwyFjjBu4B7gKWAhcb4xZeNJuB4D3WmsXA/8K3H/S/e+z1l5gra0eh5pFREQkjvT6A3i8AUpyNXIo3g2OHPIoHJL41+zxDQaaIuOlqjiLupYeAlqxTOQEsYwcWg7UWGvrrLV+4Eng2qE7WGvXWmuPR26uB2aNb5kiIiISr5oiDY5LshUOxbuSSDjU2Kmm1BLfAsEQbT0+irIUDsn4qirJxh8Mcbi91+lSROJKLOHQTODIkNv1kW3DuRV4YchtC7xsjNlsjFkz+hJFREQkng30rynVyKG4l5maRHZqknoOSdxr7/FjLRSpl5mMs6riLEArlomcLCmGfaItD2Cj7mjM+wiHQ+8esvld1toGY0wx8IoxZo+19rUox64B1gDMmTMnhrJEREQkHgwEDeo5lBiKc1IVDknca/aER7ep55CMt8pIOLT50HHOKck+4b70FPfgCEuRqSaWcKgemD3k9iyg4eSdjDGLgQeBq6y1bQPbrbUNkX+bjTHPEp6mdko4ZK29n0ivourq6qjhk4iIiMSfd8IhPaFOBKW5aQqHJO4NTPmZkZvucCUy2WSlJjE7P537X6vj/tfqTrn/N1+6mKVz8hyoTMRZsYRDG4EqY8xc4ChwHXDD0B2MMXOA3wA3WWv3DdmeCbistZ7I51cC/zJexYuIiIjzGjt9ZKS4yUqN5WmFOK0kO40NB9qdLkPktHbUd5LsNswvzXK6FJmEHvhsNW8f6zphW3/Q8g//dwdv7G9VOCRT0ojP4qy1AWPMncBLgBt4yFq72xhzR+T+e4FvAwXAz40xAIHIymQlwLORbUnA49baF8/KTyIiIiKOaPJ4Kc1JI/J4L3GuJDeNZo+XUMjiculvJvFp59EOFpTmkJrkdroUmYQWlOawoDTnlO0Pvl7HpkPHoxwhMvnF9BaftfZ54PmTtt075PPbgNuiHFcHLDnDGkVERCSONXV6tdx0AinJTqU/aGnv9VOolaAkDoVClh31nXx4yQynS5EpZllZPr/f0aDwXKakWFYrExERERnWwMghSQwDq8qp75DEq0PtvXi8ARbPynW6FJliqsvy8HgD7Gv2OF2KyIRTOCQiIiJjZq2lqcunZtQJpDhH4ZDEtx31HQAsnjXN4UpkqqkuD/ca2nRQU8tk6lE4JCIiImPW0duPPxBSOJRASgfDIZ/DlYhEt6O+k7RkF1XFakYtE2tOfgaFWSlsUd8hmYIUDomIiMiYNWoZ+4RTlJ2KMdDYqZFDEp921Hdw3oxcktx6qSITyxjDsrI8NaWWKUlXXBERERmzgalJpblqbJwokt0uCjJTafYoHJL4EwiG2HW0i/Nnqt+QOKO6LJ/D7b26RsqUo3BIRERExmwgHCrO1sihRFKSk6qRQxKXalt66OsPsmS2wiFxxrJI36HN6jskU4zCIRERERmzgb41Wso+sZTmpNGonkMSh7arGbU4bNGMXFKTXJpaJlOOwiEREREZs8YuL/mZKaQmuZ0uRUahOCeNZq1WJnFoZ30n2alJzC3IdLoUmaJSklwsmTVN4ZBMOQqHREREZMyau7xqRp2ASnPSaOvx4wsEnS5F5AQ76jtYNDMXl8s4XYpMYUvL8th9tBNvv66RMnUoHBIREZExa+zyUqIpZQln4G/W4tHUMokf/kCIt495WDxL/YbEWdVleQRClu1HOpwuRWTCKBwSERGRMWvq8lGqkUMJpyQ3/Ddr0tQyiSN7Gz34gyH1GxLHLSsLN6XW1DKZShQOiYiIyJj0B0O0dvsoVjiUcEqyB8IhjRyS+LHj6EAzao0cEmflZaZQWZTJZoVDMoUoHBIREZExae32YS0aOZSASiMjh7ScvcSTHUc6yctIZlZeutOliFBdls/mQ8cJhazTpYhMCIVDIiIiMiYDwYJ6DiWevIxkUtwumjwKhyR+bK/vYPGsaRijZtTivGXleXT29VPb0u10KSITIqZwyBiz2hiz1xhTY4z5ZpT7jTHmPyL37zDGLI31WBEREUlMA1OStFpZ4jHGUJyTSpNGDkmc6PMH2d/crSllEjcG+g5paplMFSOGQ8YYN3APcBWwELjeGLPwpN2uAqoiH2uAX4ziWBEREUlAA82MFQ4lppKcNPUckrjx1rFOgiGrZtQSNyoKM8nPTFFTapkyYhk5tByosdbWWWv9wJPAtSftcy3wqA1bD0wzxkyP8VgRERFJQE1dXpJchoLMFKdLkTEozUnTamUSN3bUdwJqRi3xwxjD0jl5GjkkU0ZSDPvMBI4MuV0PrIhhn5kxHnuK/c3dXP3vr5+wbca0NP7u8vmcH2cPGH96u4m7/1yDrz/kdCnMLcrka1fMZ15x1rD79PmDPPTGAV7c1UjwDJurnTcjh3/9yCLSkt1n9HVEppL6471897nd3HxxOe+pKjrtvn3+IN96did7Gz2n3JeR4ubmi8u5ZvF0R3oz9AdD/PSVffxlb0vMx5TmpvH9j59Pcfb4jTLp6PVz1292srKigM+uKlOfihj1+ALc/1odexq7+MHHFzMt4/ThzvYjHfzr79+i1x88Yfuxzj6Ks1NxufR7T0TFOam8usdLZ28/uRnJp913y+Hj/O8/vH3KOTAct8vwwcXT+dzF5eP2PKHF4+PuV/ez8aBeqA3ISk3ilnfP5QPnlYzb9W/X0U5+9up+Lq4s5OaLy8fla8ZiR30nJTmpGokocaW6PI8/vt1Ea7ePwqyR++s9s7meF3Yd43999PwRz+X9TR7+9/Nvc+dlVYNT2IbT2dfPN5/ZwaG23phrXzQzh7+7Yj4zp42+wfv2Ix3c/eca3ndOMTesmDPq4yU2exs9fPt3u/B4A06XAsQWDkV7pDk5VRhun1iODX8BY9YQnpJG9owKZpxwElu2HO7gQ3f/jWsvmMH/d+U5zM7PiKH0s6c/GOLfXtrLfa/VUVGUSUXh8IHMxLD8dW8LL+5q5NMXzearl1edsLRwMGR5ZnM9P35lL01dPi4qzyM3fezv9AZCIf5rcz3NHh/33bRMAZFIDI529HHd/eupP97Ha/tbefCz1VwyP3pA1OcPcusjG1lf18al5xTjOulJ/8G2Hr7yxFYefL2Ou64+l5UVBRPxIwDhn+POx7ew9XAHF1cWkJESy0MJrK1t5YYHNvDE7Sspyj7zBsadvf3c+OAGdjd08cKuRtbXtfGDTywmJ+30L3Knsv5giKc2HuH//HE/rd0+klyGGx/cwOO3rRw2HNhR38FnfrmBzJQkFs088Q2aGdPSeU9V4USULmfBB8+fzq/XH+azD23g0VtXkJse/RzYdqSDm3/5JtlpSSycEdubdB29fr7/wh4eXXuQr195Dh+9cCbuMYaIPb4AD75+gPtfq8UXCHHxvEJS3FpTBaC2pZs7HtvMsrI8vnX1ApaV5Y/5a9Uf7+XHL+/j2a1HSXIZXtrdRH8wxG3vqRjHioe3o76D82dqSpnEl+ohfYc+cF7psPv1+YN857ldPL2pHoC6lvU8uWblCa/Hhqpp7ub6BzbQ2u1j48HjPHrrcpbOiR4Qdfb1c9MvN/D2sS7eO7+I6C+xTxQMhfjttgZ+u62Bz19czpcunTfimwAAh9p6+NFLe/n9jmMkuQyvvNVEIBTis6vKRzxWRmdfk4cbHliPMYYLZsfHtc9Ye/rRI8aYVcB3rbUfiNy+C8Ba+70h+9wH/DyTqPQAABQpSURBVMVa+0Tk9l7gUqB8pGOjqa6utps2bTphm8fbz31/rePBv9URCsFNq8q4833zyHNgKPuxzj6+8vhWNh06zo0r5vA/rlkYF+FIW7ePn71aw2PrD5HsdnH7JRWsuaSCjQfa+f4Le9jb5OHCOdP41tXnclH52J88DHhq42G+8cxO3ndOEffetIzUJOd/ByLxqiESDB3v9XP3DUv5/gt7qGvp5sGbq08ZQdTnD3LboxtZV9vGjz+1hI9eOOuUrxcMWZ7depSfvLyXhk4vly8o5htXLWB+SfZZ/Tn+vKeZrz29jUDQ8oOPL+aDi6fHfOyGujY+958bmZmXfsYBUWdfP595cAN7Gz3ce9NSapq7+cGLe5k5LZ2f37j0lBBjqrPW8tLuJn744h7qWntYXp7PXVcvoKO3ny/8ajPnlGbz2G2nhgO7jnZywwPryUlP5qkvrBrTu48S3/70dhN3PLaZhTNy+dWty08JV3fUd3DjgxvIy0jhqS+sZHpu7OfAuto2vvfC2+yo72RBaTZ3XX0ul1QVxjzCJRAM8fSmen76x320eHxctaiUv//AOVQUOf2GXPwIBMNv1v3klfDvaPV5pfzD6tH9jjp6/dzz5xoeWXsIY+DWd8/l9vdU8I+/3cnzOxv59jULueXdc8/iTxF+nr/4n1/m61fM5yuXV53V7yUyGt7+IIu/+zKfe1c537r63Kj71LZ086XHtrCv2cOd75vHu+YVcsvDG5mem8YTa1aeMmK6tqWb6+5fj7Xw79ddwD8+u5O2bj+P3rqcC08KiLq8/dz04AbeOtbFvZ9ZxuXnlsRc+9GOPn7y8j5+s7WenLRkvnLZPG5aVRb1NVt7j5+fvbqfx9YfIsnl4vb3zOXz75rLPzyzg1feauJ/fmQRn1lZFvP3ltOrafZw3f3hYOipNSsn/HHNGLPZWlt9yvYYwqEkYB9wOXAU2AjcYK3dPWSfDwJ3AlcTnjb2H9ba5bEcG020cGhAY6eXn76yj//afITM1CQWRXkHKyXJxbnTc1gyK5cls6cxPTdt8ImItZbGLi/bj3Swvb6TvY0eZuWls2TWNJbMnkZFYeZph8f/ZW8zX396O97+IN/72Plce8HM0/0ojjjY2sOPXt7LH3YcIy3Zhbc/RHlBBt9YvYDVi0rHddrFk28e5pu/UUA0WQWCIX6/4xjP7zzG7PwMlsyexpJZuczJz9D0nVFo7PTy6fvX0d7t51e3reCC2dNo7/FzwwPrOdDawy9vvoh3R0ZfePuD3PbIJt6obeUnwwRDQ3n7gzy89iD3/LmGHl+AZWV5JLlie0c9I8XNeTNzWTIrl8Wzpp02rAkEQ/z4lX384i+1nDs9h5/fuJS5hZmx/xIi1te18fn/3MisvHQeH2NANNwTpU0H27nz8a209/j59ocWcuOKOZPqPA2FLAfbethR38m2Ix3UNHfHPD24vcfP3iYP84qz+ObqBVx+bvHg72YwHJiew69uWzEYDuxu6OSGBzaQlZrEk2tWOj5iV86el3c38qVfb+H8Wbk8estysiPnwHiEg6GQ5Q87j/HDl/ZwpL2P82bkxDy672hHH4fbe6kuy+Ouq88dcdrFVNbrD4+uuu+vtXgDIZaV5eGO8fq3u6ETjy/AJ5bO4utXzh8MAPuDIb7y+FZe3N3IP3/4vLM6xWxdbRvXP7CeR25ZHhkZIRI/PvbzN2js9HLjyjIumD2N82flDl7HfrftKN/6zU5Sk9389NMXDJ6/A2+IzcpL54k1KwenpB1o7eHT960jGLI8uWYlVSXZHOsMv4HYflJA1OXt56ZfvslbDZ384sZlXLEw9mBoqLcauvj+i3t4bV8LM3LTKCs49fnbrqOd9PgD4RkoV8wfnBLnD4T44mOb+dOeZr73sfO5frmmmJ2poeHgk2tWnrYlzNky5nAocvDVwP8B3MBD1tr/ZYy5A8Bae68JP8O8G1gN9AKft9ZuGu7Ykb7f6cKhAfuaPPzs1ZqoS7B2+wLsb/bQHwz/bEXZqSyZlQsYttd30OIJr8yR7DbMLczk6PE+eiJz6LNTw8Pm5xVnnTL8uaPXz++2NzC/OJt7blzqyB9yNLYePs6j6w5xwexp3LBiDslnaQj24xsO861nd3LZgmJ+8ZmlCojimLWWA609rK9r51hnH0vL8rioPJ+s1BOnBfX5gzy18TAPvH6Aox19TM9No73Hjy8Q7q01LSOZxbOmsXTONFZVFHDBnGlx/XcPBEPsONrJ+ro2XMawqqKARTNzRzXFoc8fZPOh42w82E5BVgor5hZQVZw1Yq+Vpi4v192/nhaP75Qhw0MDooc+dxHLyvK4/dFN/K2mlX/7xBI+vuz0wdBQx3v8/OKvtWw73BHzMR19fmqauxnIF2ZOS2fJ7NyoPYG213ew9XAH1y+fw3c+dGajJdfVtnHLwxuZnR8OiGKZwz/A4+3nsw+9yc76Tn5+41KuPGmId1u3j689vZ3X9rVw6TlFlEd5AjQeKosyWVVZSGVR5lkLoLz9QbYcOs66uja2Hu5gR30HXZE56enJbuaXZpMa43Xd7TJ8aMkMPlU9i6Qox5wcDtQf7+OGB9aTnuzmqS+sUjA0Bby46xhffnwrF8yexiO3LOdgaw83Pjh+4aA/EOKx9Yd4aXcjMTz1BCA12cVnVpZx5cLx66cz2bV4fNzz5xreauiK+ZjinFTuvGweC0pzTrnPHwjx5ce38MpbTfzrRxZx01kaOXDfX2v53gt72PI/3k++GtxLnHluewM/fWUfB1p7BrdVFGUyPTeNN2raqC7L42c3XHjKyMp1tW18/uE3mZOfwRO3r8TjDXDd/evxB0M8cftKzil9Z7T34AjznvAbiRVFmXz2l2+yu6GTn9+4jPePMRga6m/7W/nl3+ro8Z3aO640N42vXDaPqigj0H2BIHf8ajN/3tvCDz++mE9dNPuMa5mqBsLBkLU8cfvKqL/viXBG4dBEiyUcGom3P8ieRk9khFAH2490YIELIiOEFs/K5dzpOaQluwmGLLUt3YP77qjvjNrsyxi4alEp377mPNJT4veFsBN+veEQ//jsLi5fUMzfrz4Hc9JcWJeBjNQkslKSyEh1n7WgajKw1uILhOj1B+n1BwiG7OATaRu5f+Dz8P7v3Dpxv/Dn/cEQ2+s7WF/Xzoa6Npoj4agx4X3cLsOSWbmsqixgxdwCth7u4OG1Bzje2091WR53vLeSyxYUE7SWvY0edtR3Dv5f2dvkwVpIS3ZRXZbPqsoCVlYUUDSKF/tnS0efnw117aytbWXjweN0+05s9JadlsSKufmsqixkxdz8qO9kH+vsY11dG+tqwy/O/cHQ4O8NID8zhRVz81kxN58L5+SRnuLGZcKrWxjA2x/izie20NTp5dFbl0ftBTEQEB1s6+Hc6TlsO9LBjz6xhE+MIhg6Ez2+ALsbuk64/nX29Z+yX0aKm39Yfc6II5liNfCEqSw/kx99cjGpSW6MCc+iD78GDF9D3tlmCIYs33hmR7hJ4g1LWb0o+tz/UMjyi7/W8p9vHBh8k2A8BUN28Hwqyk7l4soCVlUUsLQsj7QzDEmbPF7W1baxtraVLYc78AdCuF2GBaXZgyP3lsyexryirKghz5l4cVcjdz6+hfNm5HDkeB+pSS6eXLMy6juMMjk9v/MYX3liK4tm5nKorYcMhYNCOCD60q8388e3m/nuhxZy2YIzf5F6sn/5/W72Nnl4/R8uG/evLTJeOnr97KjvZEd9B9uOdLKvycPV50/n/71y/rCvbdbWtPL5hzdSXpBJl7cfb3+Qx29fybnTTw1jh7YgKCvIYM8xT9Q3wpzg7Q+y5lebeX1/C//zI4t4z7xTR/i53YaMZDfpKW5Sk1wK9TnxdV1DRx+3PbIpajg40aZcOCQT77H1h/in3+6Kad+UJBdZqUlqKDlEIGTp8wfo6w9yhgvJRVWSk8rKioLBj9KcNDYfOs66ulbW1raxo75zcIrKFecWc8d7K6keoTdVZ28/Gw60sba2jfV1beyJsqqW0yqKMllVUcDFlYWsrMgnaC3rIvWurW0bcdUHY2DRjHB4tqqygIvK8zne42d9XVs4cDvQRv3xvmGPz0hx88gty0/b56ut28eND25gb5OHH358MZ+snhrvyKytbeWWhzfiHcVqj26X4e7rL+Sq82PvdTTerLUcbu+NhDjhj9Zu37h9fWNg4fSccOgUOeeyJ6jJ9gs7j3HnE1spzErhqTWrKB/D1EFJbP+9vYG/e3IrJTlpCgdlkC8Q5IuPbeHVPc1n7Xtcs3g6d9+w9Kx9fRGn/G1/K7c+spH0FDe/vm0F552msX948ZJ1HOvwcs+NS0/bBHuiefuD3P7oJl7f3zrivm6XIT0SFMU6xXUyCVpLX+SN/qGv6/IyknlizcqoIzUnksIhmRDbjnTQ0HHqC+VgyNLrD9DtC9LjC9DjC9DtCxA4C+/qJyqXy5CR4iYjJXwhzUh2k5GSRJL7nREUAAbDydfYgZEqJ+8H4VFbC6bnUF5w+j5B3b4Amw8dZ+a0NOYVjy3Jbu32sengcXp8zi/HmJbsZllZHqW5p19GtKGjjy2Hj+OLElDkpidzUXn+iKs7HGnvZXdDF4FQCGshZO3gv4tnTYtpCmqXt58j7b2nfcIwGdW1dLOnMTwCzWIj/w4ZIRfZPvB5VXE258+Kr9+RteHRp7uOdsXcA2g4OenJXFSeN+LS8mfTrqOdFGVrOempbGdkSfHhVtmRqckXCPKnt5vp8586JWU8vGte4YiP2SKJal+Th/Rkd0wjMdt7/LR2+876IiNj4e0PXwe8/adeBwKhgZkP4VCk1x/E2x8kFPt7gJOGywXpyUnh13ap77yuW1VZEBejcRUOiYiIiIiIiIhMYcOFQ5rTIyIiIiIiIiIyhSkcEhERERERERGZwhQOiYiIiIiIiIhMYXHZc8gY4wH2Ol2HJIxCYOS2+SJhOl9kNHS+yGjofJHR0jkjo6HzRUZD54sMp8xaW3TyxiQnKonB3mgNkkSiMcZs0vkisdL5IqOh80VGQ+eLjJbOGRkNnS8yGjpfZLQ0rUxEREREREREZApTOCQiIiIiIiIiMoXFazh0v9MFSELR+SKjofNFRkPni4yGzhcZLZ0zMho6X2Q0dL7IqMRlQ2oREREREREREZkY8TpySEREREREREREJkBchUPGmNXGmL3GmBpjzDedrkfiizFmtjHmz8aYt40xu40xfxfZ/l1jzFFjzLbIx9VO1yrxwRhz0BizM3JebIpsyzfGvGKM2R/5N8/pOiU+GGPOGXId2WaM6TLGfFXXGBlgjHnIGNNsjNk1ZNuw1xRjzF2R5zR7jTEfcKZqccow58uPjDF7jDE7jDHPGmOmRbaXG2P6hlxn7nWucnHCMOfLsI8/ur7IMOfMU0POl4PGmG2R7brGyIjiZlqZMcYN7APeD9QDG4HrrbVvOVqYxA1jzHRgurV2izEmG9gMfAT4FNBtrf03RwuUuGOMOQhUW2tbh2z7IdBurf1+JITOs9Z+w6kaJT5FHpOOAiuAz6NrjADGmEuAbuBRa+2iyLao1xRjzELgCWA5MAP4IzDfWht0qHyZYMOcL1cCr1prA8aYHwBEzpdy4PcD+8nUM8z58l2iPP7o+iIQ/Zw56f4fA53W2n/RNUZiEU8jh5YDNdbaOmutH3gSuNbhmiSOWGuPWWu3RD73AG8DM52tShLQtcAjkc8fIRwwipzscqDWWnvI6UIkflhrXwPaT9o83DXlWuBJa63PWnsAqCH8XEemiGjni7X2ZWttIHJzPTBrwguTuDTM9WU4ur7Iac8ZY4wh/Ab6ExNalCS0eAqHZgJHhtyuRy/8ZRiR9PtCYENk052RIdoPaZqQDGGBl40xm40xayLbSqy1xyAcOALFjlUn8ew6TnxCpWuMDGe4a4qe18hIbgFeGHJ7rjFmqzHmr8aY9zhVlMSdaI8/ur7ISN4DNFlr9w/ZpmuMnFY8hUMmyrb4mPMmccUYkwU8A3zVWtsF/AKoBC4AjgE/drA8iS/vstYuBa4CvhwZfityWsaYFODDwH9FNukaI2Oh5zUyLGPMPwIB4NeRTceAOdbaC4GvA48bY3Kcqk/ixnCPP7q+yEiu58Q3uXSNkRHFUzhUD8wecnsW0OBQLRKnjDHJhIOhX1trfwNgrW2y1gattSHgATSsViKstQ2Rf5uBZwmfG02R/lUDfayanatQ4tRVwBZrbRPoGiMjGu6aouc1EpUx5mbgGuBGG2n+GZke1Bb5fDNQC8x3rkqJB6d5/NH1RYZljEkCPgY8NbBN1xiJRTyFQxuBKmPM3Mi7ttcBzzlck8SRyNzZXwJvW2t/MmT79CG7fRTYdfKxMvUYYzIjjcsxxmQCVxI+N54Dbo7sdjPwO2cqlDh2wrttusbICIa7pjwHXGeMSTXGzAWqgDcdqE/iiDFmNfAN4MPW2t4h24sijfAxxlQQPl/qnKlS4sVpHn90fZHTuQLYY62tH9iga4zEIsnpAgZEVm24E3gJcAMPWWt3O1yWxJd3ATcBOweWZQS+BVxvjLmA8HDag8AXnClP4kwJ8Gw4UyQJeNxa+6IxZiPwtDHmVuAw8EkHa5Q4Y4zJILxq5tDryA91jREAY8wTwKVAoTGmHvgO8H2iXFOstbuNMU8DbxGePvRlrSQ0tQxzvtwFpAKvRB6f1ltr7wAuAf7FGBMAgsAd1tpYmxPLJDDM+XJptMcfXV8Eop8z1tpfcmrfRNA1RmIQN0vZi4iIiIiIiIjIxIunaWUiIiIiIiIiIjLBFA6JiIiIiIiIiExhCodERERERERERKYwhUMiIiIiIiIiIlOYwiERERERERERkSlM4ZCIiIiIiIiIyBSmcEhEREREREREZApTOCQiIiIiIiIiMoX9/xq3qKf4TRIBAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2681,19 +2697,7 @@ }, { "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2707,13 +2711,17 @@ "name": "stdout", "output_type": "stream", "text": [ - "tal hits: [MotifHitAndCoord(motif_idx=0, motif_score=0.6887544010946807, precision_at_motif_score=0.4889720854762052, example_idx=16, start=151, end=176, is_revcomp=False)]\n", - "gata hits: [MotifHitAndCoord(motif_idx=1, motif_score=0.9987333675412913, precision_at_motif_score=1.0, example_idx=16, start=93, end=118, is_revcomp=False), MotifHitAndCoord(motif_idx=1, motif_score=0.9939796094680625, precision_at_motif_score=1.0, example_idx=16, start=141, end=166, is_revcomp=False)]\n" + "tal hits:\n", + "\n", + "gata hits:\n", + "MotifHitAndCoord(motif_idx=1, motif_score=0.9971336414418648, precision_at_motif_score=1.0, example_idx=16, start=45, end=70, is_revcomp=True)\n", + "MotifHitAndCoord(motif_idx=1, motif_score=0.9997176352865069, precision_at_motif_score=1.0, example_idx=16, start=91, end=116, is_revcomp=True)\n", + "MotifHitAndCoord(motif_idx=1, motif_score=0.9992547815607424, precision_at_motif_score=1.0, example_idx=16, start=153, end=178, is_revcomp=True)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2732,19 +2740,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABIkAAACMCAYAAAD4MPn4AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXxcd3nv8e8zizSSZmRLlmzLktfYcexshLgOEJZQEogDNFCWm0DbFLg1oYFeersBXeCWvlqgpYW2QJrSQKCQhLSkpIlJIIQESLPZIZtjOXFsx9bmXZ6RNCPN8rt/zIwsyTPaZqwzkj7v10svzZz5zTlPnKMzM888v+dnzjkBAAAAAABgfvN5HQAAAAAAAAC8R5IIAAAAAAAAJIkAAAAAAABAkggAAAAAAAAiSQQAAAAAAACRJAIAAAAAAICkgNcBjKepqcmtWrXK6zAAAAAAAADmjB07dhx1zjWP3V6WJJGZ3SzpbZIOO+fOK/C4SfqypKskDUj6befckxPtd9WqVdq+fXs5QgQAAAAAAIAkM3u50PZyTTf7pqQrx3l8i6R1uZ+tkr5WpuMCAAAAAACgDMqSJHLO/UzS8XGGXC3pWy7rUUkLzaylHMcGAAAAAABA6WaqJ1GrpIMj7nfktnXP0PHhocFUWjtePqGfv3hUO7uics55HdIZ4/eZli2s0crGWq1cVKsVjXVauahWddUV3f4LFeT+5w/pW4++PKf/TmZac6RaX3jXBQr4WasBAAAAGM9MfXK1AtsKfgIys63KTknTihUrzmRMOIMOHh/Qj54/pJ+/eESP7T2ueDKtgM90TktEVXP4g9pQOqOnDvaqdyA5antTuEorGmu1clFd7netVjfV6cK2hfL5Cv15YD66b2ePbvjOk1pSH9KS+mqvw5kTjvcP6ecvHtXvX362ljfWeh0OAAAAUNFmKknUIWn5iPttkroKDXTO3STpJknatGkTX6XPQgePD+iKf3hIiWRGa5rr9N5NbXrduma96qxFCs+TipqT8aQOHBvQy8f79fKxgeHbj+87rv96qlP5IpG3X7hMf//eCxWcw4kzTM5Pdh3SR7/7pM5rXaBvf2izIqGg1yHNCfc+16Pr/32HoonkxIMBAACAeW6mPrHfJemjZnabpEsknXTOMdVsjvqbH+6SyfTj33+91i2JeB2OJxbUBHV+2wKd37bgtMcGU2l1nIjrv5/u0pfuf1FDqbT+8dqLVB3wexApKsFDLxzRR/79SZ2ztF63fJAEUTlFQtmXub5EyuNIAAAAgMpXlvIFM7tV0iOS1ptZh5l9yMyuN7Prc0O2SdoraY+kf5X0u+U4LirPY3uPaduzPfrIZWfN2wTRRKoDfp3VHNbHLz9bn3n7Rt2385A+/O0dSiTTXocGDzy856i2fmu71i4O69sf2qwFNSSIyimfJIqRJAIAAAAmZJXcHHXTqgVu+6df63UYmCQnp2c7TyqVdrpw+UL5jV47k3EoltC+o/2qDwW1fmmEf7d5JJpIqr0nquqAXxuX1SvoY9phucWTaT3d0au1zWE1henzBAAAAEiSfXDbDufcprHb+USCsjkSG9TAUForGmtJdEzBkkhIZzWHswmD7qhSmYzXIWEGDKUzau+JZRNELSSIzhR/rjF8KlP+L0R2dp/Ukb7Bsu8XAAAA8EpldxFuWid94B6vo8Ak9A2m9Na/e1BtS2v0/Y+8RiJJNCXNkp54tlu/cesv9Yqhhbrj+lfL+Dec025+6CV9bk+77r/h9QouZmrmmZJJpnXNn9+rP7pgvW5449qy7TeVzuitf/pD/ebGlfrsO84r234BAACAGfHBwp83+eoaZfG1B/foSGxQf/G2jSQ3pumq81v0+1ecre0vn9Cx/iGvw8EZ5JzTHdsP6uKVDVpLguiMqg74FPSb+gbL25Mov78Yq6YBAABgDiFJhJIdPD6gf/35Pr3zolZdtKLB63BmtXOX1UuS9h3t9zgSnElPHezVS0f69Z6L27wOZc4zM0VCwbInc6LxbJIoSkNsAAAAzCEkiVCyz9/bLp9Jf3zleq9DmfXWNIUlSfuOkCSay/5jR4dCQZ/eekGL16HMC+HqgPrKnMyJ5pJOVBIBAABgLiFJhJJs339cdz/TrevfcJZaFtR4Hc6s19pQoyq/Ty8d7fM6FJwhiWRadz3dpS3ntSgSYrn7mRAJBRQ7Q0mifEURAAAAMBeQJMK0pTNOn75rp5bWh7T19Wu8DmdO8PtMKxfVUkk0h/3o+UOKJVJ6N1PNZky4OqBYmXsS5ZNOVBIBAABgLiFJhGn790df1s6uqP78bRtVW1XZC+XNJqub6uhJNIfdsf2gWhfW6NVrFnkdyryR7UlU5kqieK6SiJ5EAAAAmENIEmFaDscS+rv7dut165p01flLvQ5nTlndXKeXjw0onXFeh4Iy6z4Z1y/2HNW7Xtkqn49VAGdKJBRQ32B5K37ySae+wRR/qwAAAJgzSBJhWv5mW7sGUxn9v187lyXvy2xNU52G0hl1noh7HQrK7PtPdso56V1MNZtRZ6In0cj99ZV5KhsAAADgFZJEmLJH9x7Tnb/s1IffsEZrmsNehzPn5P9N99K8ek5xzuk/dnRo8+pGrVxU53U480p+dTPnylfxEx3Riyg/9QwAAACY7UgSYUqS6Yz+/L+eU1tDjX73srVehzMnrW7KJhD20rx6TnnywAntO9qv91BFNOMioaBSGadEMlO2fY5sWF3uKiUAAADAKySJMCU3/2KfXjzcp8+8/VzVVPm9DmdOWlRXpUgoQPPqOeaO7R2qrfLrqvNbvA5l3gmHso31Y2XsSxSNn0oMRVnhDAAAAHMESSJMWvfJuL78kxd1+YYlunzjEq/DmbPMTGtY4WxOiQ+ldfcz3dpyXovqqlkJcKbV55NEZaz4iQ0mVRXwlX2/AAAAgJdIEmHSPnv388o4p0+/faPXocx5a5rDJInmkPt29qhvMKX3bGKqmRfCucRcXzmTRImU2hbW5G5TSQQAAIC5gSQRJmVn10lte7ZHN1y2Vssba70OZ85b3VSnzt644kNpr0NBGdz1dJfaGmq0eVWj16HMS5FQUFJ5K36i8aRaG2qGbwMAAABzQVmSRGZ2pZntNrM9ZvaJAo9fZmYnzeyp3M9flOO4mDlPHeyVJL3jolaPI5kf8s2r9x+jmmgueKbjpF61ZpF8PvM6lHlpuJKojD2JYomUli2oGb4NAAAAzAUlN8cwM7+kr0i6QlKHpCfM7C7n3PNjhv7cOfe2Uo8Hb7R3xxSuDqgt9805zqw1zdkk0b6j/drQUu9xNCjFkdigjvYN6pylEa9DmbciuZ5E0TIlc5xziiaSagxXKRT00bgaAAAAc0Y5Kok2S9rjnNvrnBuSdJukq8uwX1SQ9p6ozlkakRmVEDNh1aJskmjvkT6PI0GpdvfEJIlkn4ciZW5cPZjKKJl2qg8FVR8KUkkEAACAOaMcSaJWSQdH3O/IbRvr1Wb2tJn90MzOLcNxMUOcc2rvjvEhdwbVVQe0tD6kvTSvnvXae6KSRCWRh8rduDrfgygSCigSClBJBAAAgDmjHGsxFyotcWPuPylppXOuz8yukvRfktYV3JnZVklbJWnFihVlCA+l6jgRV2wwpXNa+JA7k1Y31bHC2RywqzumxZFqLQpXex3KvBXw+1Rb5S/bKmT5aWvZJBGVRAAAAJg7ylFJ1CFp+Yj7bZK6Rg5wzkWdc32529skBc2sqdDOnHM3Oec2Oec2NTc3lyE8lKo9N13mnKVUEs2kNc112nukX86NzbliNtnVHdU5VOF5LlwdUN9geZI5+WRTfU1Q9TXBsvU6AgAAALxWjiTRE5LWmdlqM6uSdI2ku0YOMLOllmtmY2abc8c9VoZjYwa0d2eny6xnusyMWt1Up5PxpE4MMJVltkqmM9pzuE8b+NvxXCQUKFvFTz4pVJ+bbhaL8zcKAACAuaHk6WbOuZSZfVTSfZL8km52zu00s+tzj98o6d2SPmJmKUlxSdc4yiNmjfaemFYuqh3u64GZcWqFsz411jV6HA2mY9/Rfg2lM0zVrADhUFCxclcS5RpXU0kEAACAuaIsn/pzU8i2jdl244jb/yzpn8txLMy8XbmVzTCz1jSFJUkvHenXxStJEs1Gu3JVeDR99159KFC+nkTxfE+ioOppXA0AAIA5pBzTzTCHxYfS2n+0n35EHmhrqFHAZzSvnsXae2IK+m044QfvhKsDZVvdLJ9syq9uNpTKKJFMl2XfAAAAgJdIEmFcLxyKKeOkDUyXmXEBv08rFtVq3xGSRLPVru6ozmoOqyrApdZr5e1JlJTfZ6qt8qu+JihJrHAGAACAOYFPLhhXew/TZby0pqmOSqJZrL07xt9OhQhXB8u4ullKkVBAZqZIKJDbxpQzAAAAzH4kiTCuXd0x1Vb5tbyh1utQ5qU1zWHtO9avdIY+77PNif4h9UQT9POqEJFQQH2DqbL8LcUSKdWHshVE+d9UEgEAAGAuIEmEce3qjmr90oh8PvM6lHlpdVOdhlIZdfXGvQ4FU9TeE5NEFV6lyFf89A+VnsyJxpPD+4vkkkQ0rwYAAMBcQJIIRTnn1N4To2m1h1Y31UkSU85mofxUzXPo51URTk0LKz1JNKqSqKZ8+wUAAAC8RpIIRfVEEzoZT2ojH3I9s6Y5myTae6TP40gwVbu6o1pUV6XmcLXXoUDZnkSSyrLCWTRRoJIoTiURAAAAZj+SRCiqvTs7XeYcpst4pjlcrXB1gEqiWai9J6ZzWiIyY6pmJShng+ls4+rgmP1SSQQAAIDZjyQRitqVmy6znsa7njEzrW6q016SRLNKOuO0m6maFSVcxmRONJ4cnmYWrgrIjNXNAAAAMDeQJEJRu7pjal1YM9x7A95Y3VSnvUdIEs0m+4/1azCVoWl1BanPJ4kGS0sSZTJOfUOnKol8PlO4OqAolUQAAACYA0gSoaj27igfcivAmuY6dZ2MK5FMex0KJml4qiZVeBUjMrxUfWkVP31DKTl3KukkSfWhIKubAQAAYE4gSYSCEsm09h7t1waaVntudVOdnJNePjbgdSiYpF3dUfl9prWLw16HgpxwdTapU2rj6nyD6pEVlpFQQNE4lUQAAACY/UgSoaA9h/uUzjh6qlSANU3ZRAMrnM0e7T1RrWmqUyjo9zoU5NRW+eWz0nsS5Z+f70mUvR2kJxEAAADmhMDEQzAftffkVzajkshrq5vrJEkPtB9WVWB0Xre+JqhNKxtYQavC7OqO6eKVDV6HgRHMsr2D+krsSZSvJIqMqCSqDwXU2Zsoab8AAABAJSBJhIJ2dUcVCvq0alGd16HMe+HqgFY01uqOHR26Y0fHaY//wRVn62NvWudBZCgkmkiqszeu979qhdehYIxIGXoH5SuJIiN6EkVCQcUSsZL2CwAAAFQCkkQoqL0nqvVLIvL7qFCpBN//3deoqzd+2vabf7FPX/zxC1rdXKe3XbDMg8gw1u5cFd4GpmpWnEgoUHJPotjg6T2J6kOBkqexAQAAAJWgLEkiM7tS0pcl+SV93Tn3uTGPW+7xqyQNSPpt59yT5Tg2ys85p13dMV2xYYnXoSCnKVytpnD1ads//+4L1Nkb1x9872m1LqzRRSuY4uS1Xd1RSUzVrESRMiRz8g2qT68kSso5x9RPAAAAzGolN642M7+kr0jaImmjpGvNbOOYYVskrcv9bJX0tVKPizPnSN+gjvcP8SF3FqgO+PUvv7lJS+pD+p1vbVfHCVZA89qu7pgW1AS1tD7kdSgYoxw9ifINqkf1JKoJKOOk/qF0SfsGAAAAvFaOSqLNkvY45/ZKkpndJulqSc+PGHO1pG8555ykR81soZm1OOe6x9txNJ7Uj3b2lCFE+Mz0ypUNaqyrmnDsru5c02qmy8wKjXVVuvm3f0Xv/OrD+tA3t+s/PvLqUR9gzyTnnPYc7tO+o/0zcrxyOmtxWGc1T7xEfc/JhDp7B3R+68LTGocX0t4T1YaWCBUlFSgSCpZ8rkYTKYWCvlHnQv7vLRpPKlw9s7O4E8m0Htl7TMlUZkaPW6nMTBetWFiw8hIAUPme74rypec01VUHtHl1o4J+FjA/U7pPxvVsx0mvwzjjyvFutlXSwRH3OyRdMokxrZJOSxKZ2VZlq41UtXSttn57RxlChCRV+X3acv5SvW/zCm1e3Vj0Q2x7brrMBiqJZo21i8P62vsv1nXfeFwfu/WX+vpvbVLgDL1AxIfSemTvUT3Qflg/bT+izgK9kmaLzasa9b5LVujK85aOWq4+nXH62QtH9J3HDuiB9kPKuGwVyuvWNemN6xfrsvXNWlygUiiTcdrdE9N7Ny2fyf8MTFI4VJ5KorFJ2PzUs5nsS5RKZ/T9Jzv1D/e/oO6TrKw2UtBvevO5S/X+zSv06rMWkbAFgFng4PEBfe7edt3zzLg1BJjA4ki13rtpua7ZvFxtDbVehzNnHO8f0ld+ukfffuRlDaXn/hdz5UgSFXr35aYxJrvRuZsk3SRJ5154kbv9Y68tLTpIkuLJtO5+ukvf/2WnfvBUl9YuDuvazSv09gtaVFPlHzX2ua6oWhaEtLB24qojVI7XrmvSZ68+T5+681ld943HdUHbQi1bENLSBTVqWRDS4vpqxRIpdfcm1H0yru6T2d/H+4cmfYy+wZS27z+hwVRGtVV+Xbq2STe8ca3Ob12g2fQ5zDnp4ZeO6tbHD+jjtz+lhv8O6l2vbNNVF7To4ReP6rYnDqqzN66mcJU+/IazdN6yBfrFniP6afsR/fC5bHXjea31OrdlgZYuCGnZwuy/syQNDKVJsFaoSCigaBl6EtWHRr905ptYl7py2mQ45/Sj5w/pb+/brT2H+3Th8oX6q3ecpyVMb5QkDabSuueZHv3nkx2655lurW6q07Wbl2vLeS06GU+q+2RCPSfj6jqZUM/JhAaGTj8fAj6fzm2t1yWrF+mCtgV8IwsAZ1A0kdRXHtijbzy8Xz6f9HtvWqc3b6Qv6nR09sZ1+xMH9dUH9+grD+7RG85u1vs2r9Crzlp02odxn5nqZrj6eTYaGErpGw/v140PvqT+oZTe9co2ve+SFXPmvcH5ny+8vRxnRoekkV+bt0nqmsaY09QE/TqvdUHJASLrV1Y16hNbNujuZ7r03ccP6LN3P6/P3v18wbG/es7iGY4O5fC+S1boxMCQbn38gB7fd1zJdMFc7LCmcJUa66rkm2SGJ+j36f2XrNQbz2nW5tWNqg74J35ShTq/bYG2vm6NHtl7TN997IC++T/79fVf7JMkXbp2kT511QZdsXHJ8LSit17QIuec2ntieqD9sB564Yge2H1YR2KDp+17QwtTNStRpDqgoVRGg6n0tM/d6LiVROVJEsUSST2697gybvTfbyKZ1i3/s19PHujVmuY6fe39r9SV5y2lUmaMi1c26o+vXK9tz3bru48d0F9va9dfb2sfNSbgMy2pD41qQJ4XT6Z1z7PZb7Jrgn5dvLJBl6xu1Dkt9Sr0ntDv8ynoNwX9vtyPKeDzKZnO5H6ckumMhtIZOTf+NXkkkw3vLxjwqcrvU8Bv8lfA/++aKn9J31CnM077jvZP6d8DOBOcsudj/u91KJW9ncqcuUoBn42+XuRvz8cFhR/Ze0xfuv9FnRgY0q9f1KY/fMvZasl96YapO691gd5y7tLhZNHtTxwYd1ZOQ21QZzWHtXZx9ues5rCWLayZdedi2jklU05Dw6+72Z9SHTg2oK8++JIOxwZ1+YYl+uMr1+vsJfPji2Ar9QXazAKSXpD0Jkmdkp6Q9D7n3M4RY94q6aPKrm52iaR/dM5tnmjfmzZtctu3by8pPhT3fFdUj+w9VvBN2mXrF2vt4on7taByZTJOR/sHc5VDCR2OJRQJBdSSqyxaUh8aNcVqvjsSG9RDLxzRppUNWtVUN+nnDaUyOhRNDFdmpTNO77yolQ/uFeiW/9mvT9+1Uzv+7HItmmbPmnd85WHV1wT1rQ+eegl76Uif3vTFh/Tla16hq1/RWvB5J3IVew2T6Av3hXvb9dUHXyr42NL6kD5++Tq9++K2MzaldK554VBMj+07ruZw1fD1rylcLd8474KP9Q3q8X3H9di+43p07zG198RmMOLZ4fatr9IlaxZN67lfuv8Ffen+F8scEYDZ6FVrGvVnb91IYcAZkEpn9ODuI9p/7PR+jMm004HjA3rpcJ/2HOmb0syC+WTTygZ9Yss52rSq0etQzggz2+Gc2zR2e8mVRM65lJl9VNJ9kvySbnbO7TSz63OP3yhpm7IJoj2SBiR9oNTjonQbl9Vr4zIqHuYqn8+0OBLS4khIF9IiZ0LNkWq9++K2KT+vKuDT8sZaLW9k3nelyzeVjiVS004SRRNJtTaM/pYzX40SjRevJPr47U9Jkm754ITfj2jf0X4tb6zRjb9x8ajtJtOa5jqSu1N09pLIlL/5WxSu1pbzW7Tl/BZJ2STfgeOnN1IdW4WQrxxKpd2oCqDgNKqAMs4plXFKpjK5b0ezxxlbYTbTnJM+e/fz+vJPXtR3p5EkOhlP6t9+vk+vW9ek//UrvDjBewHfqWqegN9yVXu+gr0yyiFb9ZD7m85khm+7wp045rSmcLUuGadPKkoT8Pt0+SSn7h3vH9JLR/p0KDr7+hz6LPt3Gwxkq/Oq/D75fTbpmRLFhIJ+nb0kPC/Pz7JMRHTObVM2ETRy240jbjtJN5TjWAAATEc+mVNK8+pYIjXcgyjvVE+i4vt98dDkK1E6e+NatahO5y7jW9VK0VBXNakqsPniUDShv7pnl7bvPz7lb1e/+fB+xQZT+uSWDXxRBQAVorGuSo11c7NaBlNHrToAYF6IlKHBdDSePK1xdSjoV5XfV3S/yXRGPdGEeqKJSc2R7+qNq62BngyoXO+/ZKUW1VXpHx/YM6XnxRJJ3fzwPl2+YQkJIgAAKhRJIgDAvDBcSTTNFc4GU2kNpjIFmx1HQgHFiuy352RCGSdlXPb2eBLJtI72DWkZjTtRwWqq/Pqd16/Rz144oqcO9k76ed9+9GWdjCf1e29aewajAwAApSBJBACYF06tQja9JFH+efU1wdMeq68JFt3vwRMDBW8X0tkbl6TT+h4BleY3XrVSC2uD+qefTK4B9cBQSl//+T5dtr5ZF7QtPMPRAQCA6SJJBACYF/KNq6fbkyifBCpWSVSscXXniXjB2+ONbV1IkgiVLVwd0IcuXa2ftB/Wc50nJxz/nUcP6Hj/kD72q+tmIDoAADBdJIkAAPNCeLiSaHo9ifLPG9u4Or+t2H47TsRlJpllb4+HSiLMJtddukqRUED/PEFvokQyrX/52V5dunaRLl7ZMEPRAQCA6SBJBACYF6oDflUFfIpNs5IoGs9XEp2eJIqEAkVXN+vsjWtJJKSl9aGJk0Qn4vL7TEvrQ9OKEZhJ9aGgPnDpat27s0e7e4qv4Hfb4wd0tG9Qv0cVEQAAFY8kEQBg3qgfp8H0RPKVQsUbVxerJBpQa0ONWhfWqLN34p5ES+tDCvh5ecbs8MFLV6muyq9/eqBwb6LBVFo3PrRXm1c36pI1i2Y4OgAAMFW8CwUAzBvh6sC0VzfLL3FfsHF1KDhcaTRWx4nskvZtDTWTqiSiHxFmk4W1Vfqt16zSPc92a8/hvtMev2N7h3qiCaqIAACYJU7/OhQAgDkqMk7voImM37g6qHgyrWQ6o+CIKqBUOqOekwm1NdTIZLr7mW6l0pmilUKdvXFtXt04rfgAr/zv167WNx/er63f3q5Vi+pGPfbUwV69csVCXbqWKiIAAGYDKokAAPNGuDow7dXNoomUzKRw1elJovqa3MppY6qUDsUGlco4tS6sVWtDjVIZp0OxwYL7T6Uz6okmqCTCrLMoXK1PbDlHdVUBHYkNjvpZ0VirT121QWbmdZgAAGASqCQCAMwbkVBAB46P3xeomGg8qXB1QD7f6R92882so4mkGuqqhrd35I7V1lCj/GfkjuMDBRNBPdGE0hnHymaYla57zSpd95pVXocBAABKRJIIADBvhEtqXJ1SfYGVzaRsQ+z8mJHyS9pnk0Q2attYnbl+RVQSAQAAwCskiQAA80Z9CT2JoolkwX5E0ohKovjofecbVS8bkfgp1ry662QuSUQlEQAAADxCkggAMG/kexI556bcIyWWSBatJMonj6JjKok6TgyoOVKtUNAvSVocqVbHicLT3agkAgAAgNdoXA0AmDcioYAyThoYSk/5udF4arhB9VgLarLJo7FVSp29cbWNqAxqa6gpPt2sN65FdVXDCSUAAABgppWUJDKzRjP7sZm9mPvdUGTcfjN71syeMrPtpRwTAIDpChfpHTQZscHk8LSysYpXEsVHVQa1NtQWnW7WcSLOVDMAAAB4qtRKok9I+olzbp2kn+TuF/NG59wrnHObSjwmAADTkk/y9A1OvS9RtnF14UqicHU++XRqv5mMU1dvXG0NtcPb2hpq1NUbVybjTttHZ2+cqWYAAADwVKlJoqsl3ZK7fYukd5S4PwAAzphiFT8Tcc4plkgVrSQK+H2qq/IrGj+138OxQSXTbtR0s9aFNUqmnQ7HBk/bfxdJIgAAAHis1CTREudctyTlfi8uMs5J+pGZ7TCzrSUeEwCAaYnkKn76ppgkGhhKK51xRXsSSVJ9zeiV0/INqlvH9CQa+Vjesf4hJZIZppsBAADAUxOubmZm90taWuChP53CcS51znWZ2WJJPzazdufcz4ocb6ukrZK0YsWKKRwCAIDx5SuBptqTKJpL/hSrJMo+FhgeJ2m4QfXyUUmi7NSzjhNxbVp16rmsbAYAAIBKMGGSyDl3ebHHzOyQmbU457rNrEXS4SL76Mr9Pmxmd0raLKlgksg5d5OkmyRp06ZNpzdtAABgmvKNq6fakyifVIoU6UmUfSw4KvnUMZz4OdWTKJ8EGrvCWf4+lUQAAADwUqnTze6SdF3u9nWSfjB2gJnVmVkkf1vSmyU9V+JxAQCYssg0VzeLxrNJpfpxKonqQ4ExSaIBLaqrUk3VqSXta6r8agpXnTbdLF9J1DYioQQAAADMtFKTRJ+TdIWZvSjpitx9mdkyM9uWG7NE0i/M7GlJj0u6xzl3b4nHBQBgyuqqppckmu+IxakAAAsZSURBVGwlUXRUT6L4qKbVea0NtcNVRnmdvXGFqwPj9jwCAAAAzrSS3o06545JelOB7V2Srsrd3ivpwlKOAwBAOfh9pnB1YNo9ieprxqkkqhm9384TcW1oqT9tXNvCGu3qjo7a1nEiu7KZmU0pLgAAAKCcSq0kAgBgVglXB6bckyg62UqieFLOOWUyTh298YI9htoaatTRG1cmc6rtXmeRsQAAAMBMIkkEAJhXIqGpVxLll7YfrydRJBRQKuOUSGZ0tH9QQ6lMwelmbQ01Gkplx+R19cZZ2QwAAACeI0kEAJhXwqGA+gan2rg6pSq/T9WB4i+b+QRSNJEc7jlUuCdRdlt+TN9gSifjSS0jSQQAAACPkSQCAMwr2QbTU68kioQC4/YMOrVy2qkkUWuB1craGrLb8mPyK5sx3QwAAABeI0kEAJhXItUB9SWm1pMolkiN27RaOtXUOppIjZv4yU8ry4/p7B0YtR0AAADwCkkiAMC8Mp2eRNFcJdF46nOPR+NJdZwYUENtUOHq059TVx1QQ21QHSeyyaHOcaamAQAAADOJJBEAYF4JV0+ncXVq3KbV0qmeRLFEasLVytoaaoenm3X0xlXl96k5XD2lmAAAAIByI0kEAJhXIqGg4sm0UunMpJ8TjU9cSRQZ07i6rUA/orzWhTXq7D3Vk6hlYUg+X/F+RwAAAMBMIEkEAJhX8smeqaxwFkukJpEkCgyP7TgxMO70sbaGGnWcGJBzLlt1RD8iAAAAVACSRACAeSU8IpkzWdFEcsLpZrVVfvl9ppeP9SuRzEww3axGiWRGx/qH1HmCJBEAAAAqA0kiAMC8Uj/FJFEqndHAUHp4OlkxZqZIKKDnu6KSTi11X0hr7rF9R/t1ODY4bkIJAAAAmCkkiQAA80q4Opvsmex0s/y4+prxp5tJ2ebVuw/FJI2/Wln+sSf2H5ckKokAAABQEUgSAQDmlVO9g5KTGh+Np3LPG7+SKL/vRDLbEHu86qD8Y4/tPT7hWAAAAGCmkCQCAMwr4Sk2ro7mkkkTNa4eOaY+FBi3h1F9KKj6UEA7Xj4hSeOuhAYAAADMFJJEAIB5JZ/IiU6yJ1E+STRR4+qRY8brR5TX1lCrvsGUzKSlC0KTigUAAAA4k0gSAQDmlUi+J9Ekk0T5BteTqyTK7nsy08fyfYkWR6pVFeDlGAAAAN4r6V2pmb3HzHaaWcbMNo0z7koz221me8zsE6UcEwCAUoSCPgV8NoWeRNlxC2omUUmUa249XtPqvHwiiabVAAAAqBSlfnX5nKRfl/SzYgPMzC/pK5K2SNoo6Voz21jicQEAmBYzUzgUmHRPoulUEk12upkktU5iLAAAADATJn7HOw7n3C4p+4Z7HJsl7XHO7c2NvU3S1ZKeL+XYAABMVyQUGE7+TCQ/Llw98UtmfS6RNJnqoPwYKokAAABQKUpKEk1Sq6SDI+53SLpkBo4LAEBBkeqgtj3brUdeOjbh2FgiqboqvwL+iYtv62vylUST70k0mf5FAAAAwEyYMElkZvdLWlrgoT91zv1gEscoVGbkxjneVklbJWnFihWT2D0AAFPzsV9dqwd3H5n0+PPbFkxq3Js3LtHRK9drY0v9hGM3ttTrj96yXm89v2XScQAAAABnkjlXNF8z+Z2YPSjpD51z2ws89mpJn3HOvSV3/5OS5Jz7m4n2u2nTJrd9+2m7BAAAAAAAwDSZ2Q7n3GkLkM3EmrtPSFpnZqvNrErSNZLumoHjAgAAAAAAYJJKShKZ2TvNrEPSqyXdY2b35bYvM7NtkuScS0n6qKT7JO2S9D3n3M7SwgYAAAAAAEA5lbq62Z2S7iywvUvSVSPub5O0rZRjAQAAAAAA4MwpS0+iM8XMYpJ2ex0HZo0mSUe9DgKzBucLpoLzBVPB+YKp4pzBVHC+YCo4X1DMSudc89iNJVUSzYDdhRopAYWY2XbOF0wW5wumgvMFU8H5gqninMFUcL5gKjhfMFUz0bgaAAAAAAAAFY4kEQAAAAAAACo+SXST1wFgVuF8wVRwvmAqOF8wFZwvmCrOGUwF5wumgvMFU1LRjasBAAAAAAAwMyq9kggAAAAAAAAzoCKTRGZ2pZntNrM9ZvYJr+NBZTGz5Wb2UzPbZWY7zez/5LZ/xsw6zeyp3M9VXseKymBm+83s2dx5sT23rdHMfmxmL+Z+N3gdJyqDma0fcR15ysyiZvZxrjHIM7ObzeywmT03YlvRa4qZfTL3nma3mb3Fm6jhlSLny9+aWbuZPWNmd5rZwtz2VWYWH3GdudG7yOGFIudL0dcfri8ocs7cPuJ82W9mT+W2c43BhCpuupmZ+SW9IOkKSR2SnpB0rXPueU8DQ8UwsxZJLc65J80sImmHpHdIeq+kPufc33kaICqOme2XtMk5d3TEti9IOu6c+1wuGd3gnPsTr2JEZcq9JnVKukTSB8Q1BpLM7PWS+iR9yzl3Xm5bwWuKmW2UdKukzZKWSbpf0tnOubRH4WOGFTlf3izpAedcysw+L0m582WVpLvz4zD/FDlfPqMCrz9cXyAVPmfGPP5FSSedc3/JNQaTUYmVRJsl7XHO7XXODUm6TdLVHseECuKc63bOPZm7HZO0S1Krt1FhFrpa0i2527com2gExnqTpJeccy97HQgqh3PuZ5KOj9lc7JpytaTbnHODzrl9kvYo+14H80Sh88U59yPnXCp391FJbTMeGCpSketLMVxfMO45Y2am7Bfpt85oUJjVKjFJ1Crp4Ij7HSIBgCJy2fCLJD2W2/TRXOn2zUwfwghO0o/MbIeZbc1tW+Kc65ayiUdJiz2LDpXsGo1+Y8U1BsUUu6bwvgYT+aCkH464v9rMfmlmD5nZ67wKChWn0OsP1xdM5HWSDjnnXhyxjWsMxlWJSSIrsK2y5sShIphZWNJ/Svq4cy4q6WuSzpL0Ckndkr7oYXioLJc6514paYukG3JlucC4zKxK0q9JuiO3iWsMpoP3NSjKzP5UUkrSd3KbuiWtcM5dJOn/SvqumdV7FR8qRrHXH64vmMi1Gv1lF9cYTKgSk0QdkpaPuN8mqcujWFChzCyobILoO86570uSc+6Qcy7tnMtI+ldRbosc51xX7vdhSXcqe24cyvW3yve5OuxdhKhQWyQ96Zw7JHGNwYSKXVN4X4OCzOw6SW+T9H6XaxKamzZ0LHd7h6SXJJ3tXZSoBOO8/nB9QVFmFpD065Juz2/jGoPJqMQk0ROS1pnZ6ty3uNdIusvjmFBBcnNr/03SLufc34/Y3jJi2DslPTf2uZh/zKwu1+BcZlYn6c3Knht3SbouN+w6ST/wJkJUsFHfvnGNwQSKXVPuknSNmVWb2WpJ6yQ97kF8qCBmdqWkP5H0a865gRHbm3MN82Vma5Q9X/Z6EyUqxTivP1xfMJ7LJbU75zryG7jGYDICXgcwVm6Vh49Kuk+SX9LNzrmdHoeFynKppN+U9Gx+OUdJn5J0rZm9Qtky2/2SPuxNeKgwSyTdmc0tKiDpu865e83sCUnfM7MPSTog6T0exogKY2a1yq6yOfI68gWuMZAkM7tV0mWSmsysQ9KnJX1OBa4pzrmdZvY9Sc8rO63oBlYeml+KnC+flFQt6ce516dHnXPXS3q9pL80s5SktKTrnXOTbWKMOaDI+XJZodcfri+QCp8zzrl/0+l9FSWuMZgEy1W3AgAAAAAAYB6rxOlmAAAAAAAAmGEkiQAAAAAAAECSCAAAAAAAACSJAAAAAAAAIJJEAAAAAAAAEEkiAAAAAAAAiCQRAAAAAAAARJIIAAAAAAAAkv4/GuJVHonWGNUAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2756,7 +2752,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2770,13 +2766,17 @@ "name": "stdout", "output_type": "stream", "text": [ - "tal hits: [MotifHitAndCoord(motif_idx=0, motif_score=0.6991793707241977, precision_at_motif_score=0.5212686068774202, example_idx=17, start=51, end=76, is_revcomp=True), MotifHitAndCoord(motif_idx=0, motif_score=0.9890048345603109, precision_at_motif_score=1.0, example_idx=17, start=60, end=85, is_revcomp=False)]\n", - "gata hits: [MotifHitAndCoord(motif_idx=1, motif_score=0.9809579313367828, precision_at_motif_score=1.0, example_idx=17, start=22, end=47, is_revcomp=False)]\n" + "tal hits:\n", + "\n", + "gata hits:\n", + "MotifHitAndCoord(motif_idx=1, motif_score=0.9992547815607424, precision_at_motif_score=1.0, example_idx=17, start=22, end=47, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=1, motif_score=0.9997176352865069, precision_at_motif_score=1.0, example_idx=17, start=84, end=109, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=1, motif_score=0.9971336414418648, precision_at_motif_score=1.0, example_idx=17, start=130, end=155, is_revcomp=False)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2795,7 +2795,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2807,19 +2807,7 @@ }, { "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABIcAAACMCAYAAADm+clLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAVvElEQVR4nO3df4xd51ng8e/juePMOGSmATttsZM6IJclrRq1OxvCZtm2QMGBtgYJJEf8KF2QFdSwLFp+pCC1/626FC0/Qy2rNQFRGkFpwEJuk6iwlB9KsBP6I25j1rilGRw2CS1z0+RO5s7Mwx/33OnN+M7McXvvnOt7vh9p5Hve857xO3rs8fUzz/u8kZlIkiRJkiSpnnZUvQBJkiRJkiRVx+SQJEmSJElSjZkckiRJkiRJqjGTQ5IkSZIkSTVmckiSJEmSJKnGTA5JkiRJkiTVWKPqBfSze/fu3L9/f9XLkCRJkiRJGhsPP/zw05m5Z/34lsmhiDgOvBF4MjNf2ed+AL8OfA/wHPBjmflIce9gcW8CeG9mvqvMYvfv38/p06fLTJUkSZIkSVIJEfFP/cbLbCu7Gzi4yf1bgQPFxxHgPcVvOAHcVdy/AbgtIm4ov2RJkiRJkiQN25bJocz8GPCFTaYcAn4vOx4EXhQRLwVuAs5l5vnMXALuKeZKkiRJkiRpRAyiIfVe4PGe6/libKNxSZKkTf3fs0/yvr/+bNXLkCRJqoVBJIeiz1huMt7/k0QciYjTEXH6qaeeGsCyJEnS5eqPHp7n6F/+Y9XLkCRJqoVBJIfmgWt7rvcBFzYZ7yszj2XmXGbO7dlzUeNsSZJUI81Wm4VWu+plSJIk1cIgkkMngB+NjpuBhcx8AjgFHIiI6yNiJ3C4mCtJkrSphVabpeVVFtsrVS9FkiRp7JU5yv4DwOuA3RExD7wTmATIzKPASTrH2J+jc5T9W4t7yxFxB3AfnaPsj2fmmSF8DZIkacw0i6qhZqvN1ORExauRJEkab1smhzLzti3uJ/C2De6dpJM8kiRJKq27pWyh1eaamamKVyNJkjTeBrGtTJIkaWAyk+biMgDNRfsOSZIkDZvJIUmSNFKeXVphZbVzwKlNqSVJkobP5JAkSRopzZ6EULO1XOFKJEmS6sHkkCRJGim91UJWDkmSJA2fySFJkjRSXlg5ZHJIkiRp2EwOSZKkkWLlkCRJ0vYyOSRJkkZK96SyzmuTQ5IkScNmckiSJI2UbrXQS2amrBySJEnaBiaHJEnSSOn2Gdp79bSnlUmSJG0Dk0OSJGmkLLTaXHVFg6t3TVo5JEmStA1MDkmSpJHSXGwzMz3JzPSkPYckSZK2gckhSZI0UpqtIjk0ZeWQJEnSdjA5JEmSRkqztczsdIPZ6Um+9Pwyq6tZ9ZIkSZLGmskhSZI0UhZabWamOtvKMuGZRZtSS5IkDZPJIUmSNFKai21mpyeZnZ5cu5YkSdLwmBySJEkjZWGt51Bj7VqSJEnDUyo5FBEHI+JsRJyLiDv73P+5iPh48fFoRKxExNcW9z4XEZ8q7p0e9BcgSZLGR3tlleeWVl5YOWRySJIkaagaW02IiAngLuANwDxwKiJOZOanu3My893Au4v5bwJ+JjO/0PNpXp+ZTw905ZIkaex0E0EzUw1miuSQlUOSJEnDVaZy6CbgXGaez8wl4B7g0CbzbwM+MIjFSZKkemkWzadnd9lzSJIkabuUSQ7tBR7vuZ4vxi4SEbuAg8Af9wwncH9EPBwRR77ShUqSpPG3sFY5NGnlkCRJ0jbZclsZEH3GcoO5bwL+Zt2Wslsy80JEXAM8EBGPZebHLvpNOomjIwDXXXddiWVJkqRx091WNjs9yZU7J5jYETRbHmUvSZI0TGUqh+aBa3uu9wEXNph7mHVbyjLzQvHrk8C9dLapXSQzj2XmXGbO7dmzp8SyJEnSuFmrHJqeJCKYmWpYOSRJkjRkZZJDp4ADEXF9ROykkwA6sX5SRMwCrwX+tGfsyoi4qvsa+C7g0UEsXJIkjZ9uf6Fuv6HZ6Ul7DkmSJA3ZltvKMnM5Iu4A7gMmgOOZeSYibi/uHy2mfj9wf2Y+2/P4i4F7I6L7e/1BZn5kkF+AJEkaH709h6BTQWTlkCRJ0nCV6TlEZp4ETq4bO7ru+m7g7nVj54Ebv6oVSpKk2mi2ltk5sYOpyU5x8+z05FofIkmSJA1HmW1lkiRJ22Kh1WZmukFRdczMlJVDkiRJw2ZySJIkjYxmq712hD10t5V5WpkkSdIwmRySJEkjo7nYXus3BDAz3bAhtSRJ0pCZHJIkSSNjodVeO6kMOj2HlpZXWWyvVLgqSZKk8WZySJIkjYyLtpUVVUQ2pZYkSRoek0OSJGlkdCqHvnyYareKyKbUkiRJw2NySJIkjYTMpLm4vK7nUFE5ZN8hSZKkoTE5JEmSRsKzSyusrOZFPYfAyiFJkqRhMjkkSZJGQrev0At7DjWKex5nL0mSNCwmhyRJ0kjoVgdZOSRJkrS9TA5JkqSRsFY51K/nkMkhSZKkoTE5JEmSRkK/yqHJiR3s2jlh5ZAkSdIQmRySJEkjobnY6SvUmxzqXntamSRJ0vCYHJIkSSNhYa0hdeMF4zNTk1YOSZIkDZHJIUmSNBK6fYWumupTOeRpZZIkSUNjckiSJI2EhVabq65oMLEjXjA+M92wckiSJGmISiWHIuJgRJyNiHMRcWef+6+LiIWI+Hjx8Y6yz0qSJAE0F9trp5P1mrHnkCRJ0lA1tpoQERPAXcAbgHngVEScyMxPr5v6V5n5xq/wWUmSVHPN1gbJIXsOSZIkDVWZyqGbgHOZeT4zl4B7gEMlP/9X86wkSaqRZmuZ2emLf241Oz3Jl55fZnU1K1iVJEnS+CuTHNoLPN5zPV+MrfetEfGJiPhwRLziEp8lIo5ExOmIOP3UU0+VWJYkSRonC602M1P9t5VlwjOLNqWWJEkahjLJoegztv5Hd48AL8vMG4HfBP7kEp7tDGYey8y5zJzbs2dPiWVJkqRx0lxsM9tnW1l3zL5DkiRJw1EmOTQPXNtzvQ+40DshM5uZ+aXi9UlgMiJ2l3lWkiQJisqhvj2HGmv3JUmSNHhlkkOngAMRcX1E7AQOAyd6J0TESyIiitc3FZ/3X8s8K0mS1F5Z5bmllc0rh0wOSZIkDcWWp5Vl5nJE3AHcB0wAxzPzTETcXtw/CvwA8JMRsQy0gMOZmUDfZ4f0tUiSpMtUN/HTrRLq1a0msnJIkiRpOLZMDsHaVrGT68aO9rz+LeC3yj4rSZLUq1k0m57dZc8hSZKk7VZmW5kkSdJQLaxVDvU/rax3jiRJkgbL5JAkSapcd1tZv55DV+6cYGJH0Gx5lL0kSdIwmBySJEmVW6sc6pMcighmphpWDkmSJA2JySFJklS5hU0qh7rjJockSZKGw+SQJEmqXLfZdL+eQ9CpKLIhtSRJ0nCYHJIkSZVbaLXZObGDqcn+b02sHJIkSRoek0OSJKlyzdYyM9MNIqLv/ZmpybWm1ZIkSRosk0OSJKlyzVa7bzPqrpnpSRY8rUySJGkoTA5JkqTKNRfbG/YbApiZbthzSJIkaUhMDkmSpMottNobnlQGnZ5DS8urLLZXtnFVkiRJ9WBySJIkVW7LbWVFVZF9hyRJkgbP5JAkSapcp3KoseH9blWRJ5ZJkiQNnskhSZJUqcykubi8Rc+honLIvkOSJEkDZ3JIkiRV6tmlFVZWc8ueQ2DlkCRJ0jCYHJIkSZXq9hEqkxxqepy9JEnSwJVKDkXEwYg4GxHnIuLOPvd/KCI+WXz8bUTc2HPvcxHxqYj4eEScHuTiJUnS5a9bDbR5Q+rGC+ZKkiRpcDbu/FiIiAngLuANwDxwKiJOZOane6Z9FnhtZn4xIm4FjgHf0nP/9Zn59ADXLUmSxkSZyqG1nkMmhyRJkgauTOXQTcC5zDyfmUvAPcCh3gmZ+beZ+cXi8kFg32CXKUmSxtVa5dAmDaknJ3awa+eElUOSJElDUCY5tBd4vOd6vhjbyI8DH+65TuD+iHg4Io5c+hIlSdI4ay52+ghtVjnUve9pZZIkSYO35bYyIPqMZd+JEa+nkxz6Lz3Dt2TmhYi4BnggIh7LzI/1efYIcATguuuuK7EsSZI0Dr7cc2jztyUzU5NWDkmSJA1BmcqheeDanut9wIX1kyLiVcB7gUOZ+a/d8cy8UPz6JHAvnW1qF8nMY5k5l5lze/bsKf8VSJKky1q3j9BVm2wrg6JyyNPKJEmSBq5McugUcCAiro+IncBh4ETvhIi4DvgQ8COZ+Q8941dGxFXd18B3AY8OavGSJOnyt9Bqc9UVDSZ29CtW/rKZ6YaVQ5IkSUOw5bayzFyOiDuA+4AJ4HhmnomI24v7R4F3AF8H/HZEACxn5hzwYuDeYqwB/EFmfmQoX4kkSbosNRfbmx5j3zUzPclj//LMNqxIkiSpXsr0HCIzTwIn140d7Xn9E8BP9HnuPHDjV7lGSZI0xpqtkskhew5JkiQNRZltZZIkSUPTbC0zu0Uzauj0HPrS88usrvY9F0OSJElfIZNDkiSpUgutNjNbNKOGzrayTHhm0abUkiRJg2RySJIkVaq52Ga2xLay7pzmolvLJEmSBsnkkCRJqtRC6Z5DjbX5kiRJGhyTQ5IkqTLtlVWeW1q5tMohk0OSJEkDZXJIkiRVppvo6VYFbaZbXWTlkCRJ0mCZHJIkSZVpFs2lZ3fZc0iSJKkqJockSVJlFtYqh8qdVtb7jCRJkgbD5JAkSapMN9FTpufQlTsnmNgRJockSZIGzOSQJEmqzFrPoRLJoYhgZqpBs7U87GVJkiTViskhSZJUmUupHOrOs3JIkiRpsEwOSZKkynSbS5fpOQSdCiMbUkuSJA2WySFJklSZhVabnRM7mJos95bEyiFJkqTBMzkkSZIq02wtMzPdICJKzZ+ZmlzrUyRJkqTBMDkkSZIq02y1SzWj7pqZnmTBhtSSJEkDZXJIkiRVprnYLt1vCGBmumHPIUmSpAErlRyKiIMRcTYizkXEnX3uR0T8RnH/kxHxmrLPSpKk+lpotUufVAadnkNLy6sstleGuCpJkqR62TI5FBETwF3ArcANwG0RccO6abcCB4qPI8B7LuFZSZJUU5e8rayoMrLvkCRJ0uCUqRy6CTiXmeczcwm4Bzi0bs4h4Pey40HgRRHx0pLPSpKkmupUDjVKz+9WGXlimSRJ0uCUeTe2F3i853oe+JYSc/aWfPYijz3xDDf/r4+WWJokSbqcffG5S99WBnD42INMTtg6UZIkaRDKJIf6nS2bJeeUebbzCSKO0NmSxuzXfwOvffmeEkuTJEmXsx07gu9/9d7S8//jy67mrbfs57nn7TkkSZJ0qR7aYLxMcmgeuLbneh9woeScnSWeBSAzjwHHAObm5vJ//8CrSixNkiTVyZVXNHjnm15R9TIkSZIuS7+8wXiZeuxTwIGIuD4idgKHgRPr5pwAfrQ4texmYCEznyj5rCRJkiRJkiqyZeVQZi5HxB3AfcAEcDwzz0TE7cX9o8BJ4HuAc8BzwFs3e3YoX4kkSZIkSZIuWWT2bQFUqbm5uTx9+nTVy5AkSZIkSRobEfFwZs5dND6KyaGIeAY4W/U6VIndwNNVL0KVMf71ZezrzfjXl7GvN+NfX8a+3ox/tV6WmRedAFamIXUVzvbLZGn8RcRpY19fxr++jH29Gf/6Mvb1Zvzry9jXm/EfTWUaUkuSJEmSJGlMmRySJEmSJEmqsVFNDh2regGqjLGvN+NfX8a+3ox/fRn7ejP+9WXs6834j6CRbEgtSZIkSZKk7TGqlUOSJEmSJEnaBiOVHIqIgxFxNiLORcSdVa9HwxMR10bEX0TEZyLiTET8dDH+tRHxQET8v+LXq6teq4YnIiYi4u8j4s+Ka+NfExHxooj4YEQ8Vnwf+FbjXw8R8TPF9/1HI+IDETFl7MdXRByPiCcj4tGesQ3jHRFvL94Hno2I765m1RqEDWL/7uL7/icj4t6IeFHPPWM/RvrFv+fez0ZERsTunjHjPyY2in1E/FQR3zMR8cs948Z+RIxMcigiJoC7gFuBG4DbIuKGalelIVoG/mdmfjNwM/C2It53Ah/NzAPAR4trja+fBj7Tc2386+PXgY9k5n8AbqTz58D4j7mI2Av8d2AuM18JTACHMfbj7G7g4LqxvvEu3gccBl5RPPPbxftDXZ7u5uLYPwC8MjNfBfwD8HYw9mPqbi6OPxFxLfAG4PM9Y8Z/vNzNuthHxOuBQ8CrMvMVwK8U48Z+hIxMcgi4CTiXmeczcwm4h84fII2hzHwiMx8pXj9D5z+Ge+nE/HeLab8LfF81K9SwRcQ+4HuB9/YMG/8aiIgZ4L8C7wPIzKXM/DeMf100gOmIaAC7gAsY+7GVmR8DvrBueKN4HwLuycznM/OzwDk67w91GeoX+8y8PzOXi8sHgX3Fa2M/Zjb4uw/wq8DPA72Nb43/GNkg9j8JvCszny/mPFmMG/sRMkrJob3A4z3X88WYxlxE7AdeDTwEvDgzn4BOAgm4prqVach+jc6bg9WeMeNfD98APAX8TrGt8L0RcSXGf+xl5j/T+Wnh54EngIXMvB9jXzcbxdv3gvXy34APF6+NfQ1ExJuBf87MT6y7ZfzH38uBb4uIhyLiLyPiPxXjxn6EjFJyKPqMeZTamIuIrwH+GPgfmdmsej3aHhHxRuDJzHy46rWoEg3gNcB7MvPVwLO4jagWit4yh4Drga8HroyIH652VRohvhesiYj4JTotBt7fHeozzdiPkYjYBfwS8I5+t/uMGf/x0gCuptNO5OeAP4yIwNiPlFFKDs0D1/Zc76NTaq4xFRGTdBJD78/MDxXD/z8iXlrcfynw5EbP67J2C/DmiPgcnS2k3x4Rv4/xr4t5YD4zHyquP0gnWWT8x993Ap/NzKcysw18CPjPGPu62SjevhesgYh4C/BG4Icys/ufQGM//r6Rzg8GPlG8/9sHPBIRL8H418E88KHs+Ds6Owd2Y+xHyiglh04BByLi+ojYSacx1YmK16QhKTLF7wM+k5n/p+fWCeAtxeu3AH+63WvT8GXm2zNzX2bup/N3/c8z84cx/rWQmf8CPB4R31QMfQfwaYx/HXweuDkidhX/DnwHnZ5zxr5eNor3CeBwRFwREdcDB4C/q2B9GpKIOAj8AvDmzHyu55axH3OZ+anMvCYz9xfv/+aB1xTvCYz/+PsT4NsBIuLlwE7gaYz9SGlUvYCuzFyOiDuA++icXnI8M89UvCwNzy3AjwCfioiPF2O/CLyLTpnhj9P5T8QPVrQ+VcP418dPAe8vfhhwHngrnR9YGP8xlpkPRcQHgUfobCn5e+AY8DUY+7EUER8AXgfsjoh54J1s8L0+M89ExB/SSRYvA2/LzJVKFq6v2gaxfztwBfBAJz/Mg5l5u7EfP/3in5nv6zfX+I+XDf7uHweOF8fbLwFvKSoHjf0IiS9Xc0qSJEmSJKluRmlbmSRJkiRJkraZySFJkiRJkqQaMzkkSZIkSZJUYyaHJEmSJEmSaszkkCRJkiRJUo2ZHJIkSZIkSaoxk0OSJEmSJEk1ZnJIkiRJkiSpxv4d0t2XM5E7I64AAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2833,13 +2821,18 @@ "name": "stdout", "output_type": "stream", "text": [ - "tal hits: [MotifHitAndCoord(motif_idx=0, motif_score=0.7118732661068118, precision_at_motif_score=0.5605942527506326, example_idx=18, start=55, end=80, is_revcomp=True), MotifHitAndCoord(motif_idx=0, motif_score=0.9945691767749727, precision_at_motif_score=1.0, example_idx=18, start=64, end=89, is_revcomp=False)]\n", - "gata hits: [MotifHitAndCoord(motif_idx=1, motif_score=0.9987356972101512, precision_at_motif_score=1.0, example_idx=18, start=81, end=106, is_revcomp=False)]\n" + "tal hits:\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.6763298538561408, precision_at_motif_score=0.3772269950506758, example_idx=18, start=91, end=116, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.999585467994209, precision_at_motif_score=1.0, example_idx=18, start=100, end=125, is_revcomp=True)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.7407143227403524, precision_at_motif_score=0.5, example_idx=18, start=154, end=179, is_revcomp=True)\n", + "gata hits:\n", + "MotifHitAndCoord(motif_idx=1, motif_score=0.9927436977742843, precision_at_motif_score=1.0, example_idx=18, start=15, end=40, is_revcomp=True)\n", + "MotifHitAndCoord(motif_idx=1, motif_score=0.9955978570801688, precision_at_motif_score=1.0, example_idx=18, start=153, end=178, is_revcomp=True)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2858,7 +2851,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2870,19 +2863,7 @@ }, { "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIcAAACMCAYAAADm+clLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3dfXBkZ3Xn8d9pdUvdGqkljWcsmxkZG++Mdw0FCTvrYNhdIFkSOwGcfauyKy+ETcplCmfZrd1k7bBF+G+pZXcTFgxeB7wOtYArRSCZSgyGkBcvSwyecXixgXmpwbbEeN6sUbdm1C11q8/+ce9ttaRu6WqsVt/u/n6qptT93HvHj+qx23qOzjmPubsAAAAAAADQn1KdngAAAAAAAAA6h+AQAAAAAABAHyM4BAAAAAAA0McIDgEAAAAAAPQxgkMAAAAAAAB9jOAQAAAAAABAH0t3egLN7Nmzx6+//vpOTwMAAAAAAKBnHD169IK77107vmlwyMwelvR2Sefc/TVNrpukj0j6eUkLkn7N3Z8Or90WXhuQ9El3/1CcyV5//fU6cuRInFsBAAAAAAAQg5k932w8TlnZI5Ju2+D67ZIOhH/ulvSJ8B84IOmB8PrNku4ys5vjTxkAAAAAAADttmlwyN2fkDS7wS13SPq0B56UNG5m10q6RdJJdz/l7kuSHg3vBQAAAAAAQEJsR0PqfZKmG97PhGOtxoHt87cPSCf+otOzAICu9QdPnNITx893ehoAAKAffOsPpB/+eadngSa2IzhkTcZ8g/Hmf4nZ3WZ2xMyOnD/PD6mI6eu/J33ns52eBQB0rY//9Ul94emZTk8DAAD0g298VHr6052eBZrYjuDQjKSphvf7JZ3eYLwpd3/I3Q+5+6G9e9c1zgbWc5dKc8EfAMCWubuK5aoKpUqnpwIAAPpBmf1bUm1HcOiwpF+1wBskFdz9RUlPSTpgZjeY2aCkO8N7ge1RWZBqleADBgCwZZcWq1quOcEhAADQfrWaVC6yf0uoOEfZf07SWyTtMbMZSb8rKSNJ7v6gpMcUHGN/UsFR9u8Or1XN7F5Jjys4yv5hd3+2Dd8D+lW5sPorAGBLiuXqqq8AAABts1iU5OzfEmrT4JC737XJdZf03hbXHlMQPAK2X5SOSFoiAFyRwkKQMUTmEAAAaLsy+7ck246yMqAzGjOHvGWvcwBAC8VyEBQqEhwCAADtFu3fqiWputjZuWAdgkPoXlHkuVYJ+g8BALYkyhharNZUrix3eDYAAKCnNWYMUVqWOASH0L0aP1D4cAGALWvMGIqyiAAAANqC/VuiERxC92qMPFO3CgBb1thriNIyAADQVmX2b0lGcAjdi8gzALwsjaeUFUqcWAYAANqI/VuiERxC92qMPJeJPAPAVhXJHAIAADulxP4tyQgOoXsReQaAl4WeQwAAYMes2r8RHEoagkPoXqU5afQVK68BAFtSKFV0TT5bfw0AANA2ZfZvSUZwCN2rXJDGr1t5DQDYkmK5ov0TueA1wSEAANBO5YI0crWUzrJ/SyCCQ+he5Tlp+CppcIS0RAC4AoVSRXtGhpTNpMgcAgAA7VWak7JjwR/2b4lDcAjdq1yQcuNSdpzIMwBcgWKpqrFcRmO5jIqcVgYAANqJ/VuiERxC92qMPFOzCgBbVihVlM+llc9myBwCAADtVWb/lmQEh9CdlqvS0nwQdc4ReQaArVqq1lSqLK9kDnFaGQAAaKdygf1bghEcQndaLAZfqVkFgCsSBYPyuYzyOTKHAABAG1XKUrXM/i3BCA6hO0UfJtSsAsAViU4nI3MIAAC0XbRfY/+WWASH0J2iGlVqVgHgikSZQvlsRvlsWoUFgkMAAKBNol/uZ8fDzKGCVKt1dk5YJVZwyMxuM7NjZnbSzO5rcv23zOzb4Z9nzGzZzHaH154zs++F145s9zeAPhVFmqOa1aX5oA8RACCWYjn4zMyHmUPzi1XVat7hWQEAgJ60dv/mNWnpUmfnhFU2DQ6Z2YCkByTdLulmSXeZ2c2N97j7h939J9z9JyTdL+lv3H224Za3htcPbePc0c/KazKHpJU+RACATRXqZWVp5XMZuUvziwTZAQBAG6yt/JDoO5QwcTKHbpF00t1PufuSpEcl3bHB/XdJ+tx2TA5oaW3NqsSHCwBsQdRzKGpI3TgGAACwrZru3+g7lCRxgkP7JE03vJ8Jx9Yxs2FJt0n644Zhl/QVMztqZndf6USBVZpFnuk7BACxre45lFk1BgAAsK2aVX6wf0uUdIx7rMlYq6YE75D0/9aUlL3J3U+b2dWSvmpmP3T3J9b9Q4LA0d2SdN1118WYFvpauSClMlJmOIg+R2MAgFiK5YqG0illMwMaizKHOLEMAAC0Q2NwiP1bIsXJHJqRNNXwfr+k0y3uvVNrSsrc/XT49ZykLyooU1vH3R9y90Pufmjv3r0xpoW+Vp4LPljMqFkFgCtQLFXq5WT5XLo+BgAAsO1Kc1I6J6WH2L8lVJzg0FOSDpjZDWY2qCAAdHjtTWY2JunNkv60YWyXmY1GryX9rKRntmPi6HPlwkrEmZpVANiyYqlazxiqZw6VaEgNAADagP1b4m1aVubuVTO7V9LjkgYkPezuz5rZPeH1B8Nb/7mkr7j75YbHJyV90cyif9Zn3f3L2/kNoE+V5lYiztSsAsCWFUoV5bPBjwFRBhE9hwAAQFuUG/ZvQ3lJxv4tYeL0HJK7PybpsTVjD655/4ikR9aMnZL0upc1Q6CZcmEl4jy4S0qliTwDwBYUyxVdtWtQkjQymFbK6DkEAADapHH/lkpJ2Tz7t4SJU1YGJE9j5DnqO0TNKgDEVmjoOZRKmUazGTKHAABAezRWfkjs3xKI4BC6U2lupWZVCqLQpCUCQGyFUqXea0gK+g4RHAIAAG1RZv+WdASH0H3cw7TEtZFn0hIBIA53D04ry64Eh/K5NKeVAQCA9mD/lngEh9B9KgtSrbJSsyoFUWjSEgEglkuLVdVcZA4BAID2q9WkcpH9W8IRHEL3iSLMRJ4B4IoUy8GR9fncyrkU+WymPg4AALBtFouSnP1bwhEcQveJalOpWQWAK1JYCDKEyBwCAABtV2b/1g0IDqH7bJQ55N6ZOQFAF4mOrF/dcyhDzyEAALD9mu7fxqVqSaoudmZOWIfgELpPFHleW7NaqwT9iAAAG4oyhPJrMocWqzWVK8udmhYAAOhFpRb7N4nSsgQhOITu0ypzqPEaAKClKEOosawsnw36D0VZRQAAANuC/VtXIDiE7lPvOTSxMhZFoalbBYBNNcscil5TWgYAALZVq55DEvu3BCE4hO4TRZeH8itjRJ4BILZiuSozaXSo4bSyMDhUKHFiGQAA2EZkDnUFgkPoPuU5aXBUGljZ1KzUrBJ5BoDNFEsVjQ6llUpZfWyMzCEAANAOpTnJUsEeLsL+LXEIDqH7lAurUxKllbREIs8AsKliqaKx4cyqsXpwiJ5DAABgO5ULQaZQqiH8kCU4lDQEh9B9SnOrUxIlalYBYAsKpcqqY+yllWPtC2QOAQCA7VRutn8L37N/SwyCQ+g+5cLqYxAlalYBYAuK5cqqk8okKZ8LTysjOAQAALZTs/1bJiuls+zfEoTgELpPs8jzQFoaHCEtEQBiaJY5NJQeUDaTInMIAABsr2aVH1Iwxv4tMWIFh8zsNjM7ZmYnzey+JtffYmYFM/t2+OcDcZ8FtqxZzyEpiEYTeQaATRVL1XWZQ1LQd6jIaWUAAGA7sX/rCunNbjCzAUkPSHqbpBlJT5nZYXf//ppb/6+7v/0KnwXi2yjyTM0qAGyqUKrUy8ga5bMZMocAAMD2alb5IbF/S5g4mUO3SDrp7qfcfUnSo5LuiPn3v5xnAUmSu+uZH4cR5eWqtDS/vmZVCqLRRJ4BYENL1ZpKleXWmUOcVgYAALZTs55DEvu3hIkTHNonabrh/Uw4ttatZvYdM/uSmb16i8/KzO42syNmduT8+fMxpoV+8dRzF/X2j35dR5+flRaLwSA1qwBwRaLgT75JcCifI3MIAABso0pZqpbZv3WBOMEhazLma94/LemV7v46SR+V9CdbeDYYdH/I3Q+5+6G9e/fGmBb6xYlz85Kkk+curXx4ULMKAFckOo2MzCEAANB20f6M/VvixQkOzUiaani/X9Lpxhvcvejul8LXj0nKmNmeOM8Cm5meLa18jWpSqVkFgCsSZQatPa0sGEursEBwCAAAbJPol/vNysqyY0FwqFbb2TmhqTjBoackHTCzG8xsUNKdkg433mBm15iZha9vCf/el+I8C2xm+uLCytcostyqZnVpPuhLBABoqlgOPiOblZWN5TKaX6yqVmua5AsAALA1m+3fvCYtXdrZOaGpTU8rc/eqmd0r6XFJA5Iedvdnzeye8PqDkv6VpPeYWVVSSdKd7u6Smj7bpu8FPWpmNgwOzS40RJ5bZA5JQV+i4d07NDsA6C6FellZk9PKchm5S/OLzY+6BwAA2JLNKj+k8DSz/M7NCU1tGhyS6qVij60Ze7Dh9cckfSzus8BWTF8srXzdrGZVCj5cCA4BQFNRz6FWDamjewgOAQCAly3W/o2+Q0kQp6wM6JjLi1XNXl7SaDat8/OLqly+GFzYKPJM3yEAaGnjnkOZVfcAAAC8LHEqP9i/JQLBISRa1G/oDa+6SpI0P3dBSmWkzPD6m3NEngFgM8VyRUPplLKZgXXXomwhTiwDAADbYqPgEPu3RCE4hESLTip7441BcKhUfCn4YAn6n6/WWLMKAGiqWKo0LSmTpHzYh6hI5hAAANgOpTkpnZPSQ+uvsX9LFIJDSLTpsBn1G2/cI0laujTbvF5VWqlZJS0RAFoqbNBPKBqnrAwAAGyL8hz7ty5BcAiJNn1xQcODAzo4OaJsJqXawlzzlESpIfJMWiIAtFIsVZXPNj+PYqUhdXUnpwQAAHpVudB6/zaUl2Ts3xKC4BASbXp2QVMTwzIz7Z8YVmqxsBJhXmtwl5RKk5YIABvYKHNoZDCtlPVe5tByzXvuewIAoCuU5lrv31Kp4Ah79m+JQHAIiTY9W9LU7pwkaWoip0xlvnXk2Sy4RuQZAFoqllv3HEqlTKPZTM81pH7kG8/pzR/+Ky1Wlzs9FQAA+stGmUMS+7cEITiExHJ3TV9c0P6J4GSyqd3DytXmW9esSkFUmppVAGhpo8whKeg71GtZNkefn9XcQkU/unC501MBAKC/bNRzSGL/liAEh5BYs5eXtLC0rKndYXBoPKdRv6zywGjrh4g8A0BL7h6cVpZtHRzK59I9d1rZ8bOXVn0FAAA7hMyhrkFwCIk1fTE4xn5qIigru35MGrRlzflw64dy49SsAkALlxarqrn6KnNosbpczxg6fma+w7MBAKCP1GpSudi655DE/i1BCA4hsaJj7OuZQ8PB6TkXKtnWDxF5BoCWiuXgczSfa35amSTls5n6fb3g1PnLWq65JOnYWYJDAADsmMWiJCdzqEsQHEJiTV9cHRzal12UJL24YXCImlUAaKWwEGQE9VPm0PEwIHTj3l311wAAYAdEGUH0HOoKBIeQWNOzJU0MZzQyFPyGe9SDsoAflwZbPxRFnt13YooA0FWiU8g27jmU6ameQ8fOzCudMt32mmv0wuyCSkucWAYAwI6IMoI2zBwal6olqbq4M3NCSwSHkFgzFxfqWUOS6pHn5y633tQoNy7VKlJloc2zA4DuE2UEtTrKXgoyhxarNZUrvRFEOX72kl61d5de84oxuUsnz9GUGgCAHRFlBG3Wc0iitCwBCA4hsaZnFzQ10RgcCj4wTs637pVR/+DhwwUA1okygjYqK4sCR1GWUbc7fnZeBydHdfCa4KRL+g4BALBDoj3ZZmVljfeiY2IFh8zsNjM7ZmYnzey+Jtd/ycy+G/75hpm9ruHac2b2PTP7tpkd2c7Jo3ct11w/nitp/+7cymAYeT5RGJC3KhuLUhapWwWAdeJkDuWzQQC+F0rLFpaqemF2QQcnR/XK3cMaTKfoOwQAwE6Jeg5t1pBaYv+WABukYATMbEDSA5LeJmlG0lNmdtjdv99w248kvdndL5rZ7ZIekvRTDdff6u4XtnHe6HFni2VVlr1p5tCFalbn5xd1db5JY2rSEgGgpWK5KjNpdKj1//6jrKJCqftPLDtxNighOzg5qvRASjfuHdExjrMHAGBn1HsOUVbWDeJkDt0i6aS7n3L3JUmPSrqj8QZ3/4a7XwzfPilp//ZOE/1m7TH2kqTynKrpXVrWQP0ks3WiyHOZyDMArFUsVTQ6lFYqZS3vqZeV9UDmUJQldFNYUnbT5IhOkDkEAMDOKM1JlpIGR1rfw/4tMeIEh/ZJmm54PxOOtfLrkr7U8N4lfcXMjprZ3VufIvrR9MWSJGlqoqGsrFyQh1Hn6dlS8wepWQWAloqlisaGN2jqr5XMoV7oOXT87LyG0ildF/6i4eA1ozpdKPfE9wYAQOKVC0HwJ7VB2KG+fyM41GmblpVJavbrxaYNX8zsrQqCQ/+4YfhN7n7azK6W9FUz+6G7P9Hk2bsl3S1J1113XYxpoZdNzy7ITNo3sbrn0MDweP16U9GHCzWrALBOoVTZ8Bh7aeWY+0IPZA4dO3tJf+/qEQ2EmVI3TQYZRCfOzusfvnJ3J6cGAEDvK89t3G9IoudQgsTJHJqRNNXwfr+k02tvMrPXSvqkpDvc/aVo3N1Ph1/PSfqigjK1ddz9IXc/5O6H9u7dG/87QE+avrigydGshtIDK4PlglK5Ce0dHYpRVkbmEACsVSxXNjypTJLyud5pSH38zHw9ICQFvYck6dgZjrMHAKDtyoWN+w1JUiYrpbPs3xIgTnDoKUkHzOwGMxuUdKekw403mNl1kr4g6Vfc/XjD+C4zG41eS/pZSc9s1+TRu2ZmS5pqPKlMqkeepyZyrcvKBtJBTStpiQCwTpzMoaH0gLKZVNdnDhVKFZ0plutH2EvSvvGchgcHOLEMAICdUIqROSQF97B/67hNy8rcvWpm90p6XNKApIfd/Vkzuye8/qCkD0i6StLHzUySqu5+SNKkpC+GY2lJn3X3L7flO0FPmb64oFtfddXqwXJByo1ryoZ19PmLzR+Ugug0kWcAWKdYqm6aOSQFfYeKXX5aWdR4ujFzKJUyHZgcJTgEAMBOKBek/LWb38f+LRHi9BySuz8m6bE1Yw82vP4NSb/R5LlTkl73MueIPrNYXdaZYln7G08qk+qR56ncsP7suy+qulxTeqBJ8lt2jJpVAGiiUKrUy8Y2ks9muj5z6FgYAGrMHJKCE8v+8ofnOjElAAD6S5yeQxL7t4SIU1YG7KjTc2W5rzmpbLkqLc1L2XFN7c5pueZ6sVBu/hfkiDwDwFpL1ZpKleX4mUNdfqLX8TPzGhlK6xVj2VXjBydHdeHSki5cWuzQzAAA6BNxeg5J7N8SguAQEic6iWyqMXNosRh8zY5pamJ41X3rULMKAOtEwZ58jOBQPtcbmUMHJkcUlrbX3RRmElFaBgBAG1XKUrVMz6EuQnAIiROdRLYqOBR9WOTG6+OtTywj8gwAa0Wnj/VL5tCJs5dW9RuKHKwfZ8+JZQAAtE20H8vFyBxi/5YIBIeQONOzJWUGTNfkG0oBohrU7JiuHctqIGWtTyyjZhUA1okygTY7rSy4J63CQvcGhy5cWtRLl5fqgaBGV48OaSyXqfckAgAAbRD9cj9OWVl2LAgO1WrtnRM2RHAIiTN9cUH7xnMaSDWUAkSR5Oy40gMpvWI82zpzKDce9Cda7u6TdgBgOxXLwWdinLKysVxG84tV1Wre7mm1xfEzYTPqJsEhM9NNk6P1ewAAQBs07N82lRuXvCYtkdXbSQSHkDgzswurS8qkhshzULM6NTG8cc8haaVPEQCgnjk0Fue0slxG7tL8YncG2VdOKhtpev3gNSM6dnZe7t0Z/AIAIPFKq/dvG4ruoe9QRxEcQuJMXyxp/8Ta4NDqmtWpiWFNX2xVVhZGp/lwAYC6qOdQ3IbUjc90m+Nn5zUxnNHekaGm12+aHNV8uaozxRanXgIAgJdnqz2HGp9BRxAcQqJcXqxq9vKSpnbnVl9YE3me2p3T+flFlSvL6/+SKPJM3yEAqNtaz6HMqme6zfGzl3RwcnTdSWWRA5Oj9fsAAEAblK8gc4j9W0cRHEKi1E8qW5c5NCelMlImGI/Kzmaa9R3KkTkEAGsVSxUNpVPKZgY2vXesizOH3F3Hz8zXj6xvJupFRN8hAADaZCtlZezfEoHgEBLlhZeaHGMvBSmG2TEp/C1wVHb2QrO+Q/WaVdISASBSLFdilZRJUj7sS9SNx9m/WChrfrFazw5qZveuQe0dHeLEMgAA2qU8J6VzUrp5ifcq7N8SgeAQEiXqIzQ10aSsrKFeNSo7a3qcfVSzSloiANQVSpV6RtBmovu6sawsCvjctEFwKLp+nOAQAADtUZ6L129IYv+WEASHkCjTswsaHhzQ7l2Dqy9EmUOhvSNDymZSzU8sI/IMAOsUS1Xls5ufVCY1NqTuvtPKTkQnlU02P6kscnByVCfOXlKtxollAABsuzX7tw0N5SUZ+7cOIziERJm5uKCpieH1TUTLcysRZUlmpv0Tw/UeRasM7pJSaWpWAaDBVjKHRgbTSlmXZg6duaTJ/JDGhwc3vO+ma0ZUqixrptXJlwAA4MqVVu/fNpRKSdk8+7cOIziERJmeLa0/qUxqGnmemsg1LyszC+4l8gwAdVvpOZRKmUazma7sOXT87Hy94fRGop5E9B0CAKANtpI5JLF/SwCCQ0gMd9f0xYV6s+lVSutrVqd2t8gckoIoNTWrAFC3lcwhKeg71G2ZQ8s114lzMYNDVwdlZ/QdAgCgDbbSc0hi/5YABIeQGLOXl7SwtLz+pDL3FplDw5ovV1VYaLJ5IfIMAHXurmKponw2fnAon0t33VH207MLKldqmzajlqTRbEb7xnM6xnH2AABsPzKHuk6s4JCZ3WZmx8zspJnd1+S6mdn/DK9/18xeH/dZINLypLLKglSrrKtZrZ9Y1ix7KDdOzSoAhC4tVlVz9XzmUJQFdPCazYNDknTTNZxYBgDAtqvVpHIxfs8hif1bAmwaHDKzAUkPSLpd0s2S7jKzm9fcdrukA+GfuyV9YgvPApJUP3lsXeZQFEFeE3mOys9anlhG5BkAJEnFcnDqWD4X77QyScpnM/XnukUU6IlKxjZzcHJUp85fVmW51s5pAQDQXxaLkpzMoS4TJ3PoFkkn3f2Uuy9JelTSHWvuuUPSpz3wpKRxM7s25rOApJUMoHXBoaj2tEnPocbnVqFmFQDqovLbXs8cOnb2kvZP5LRrKF4Q7ODkiJaWa3r+pcttnhkAAH2k3Hz/tiH2bx0X56enfZKmG97PSPqpGPfsi/nsOtXT39O5D94QY2roJf/CpX+ZlUY+ll19YXkp+LomLXEsl1E+m9ZH/uKEHv76c6uuvada0LtqF/j3CAAkXSXpb4ek3Y8NSo/Hazf4O+WK3re0rHMfbOvUttX7XRpMp6T/vvEx9pF31Gq6dWhJqY9L59o8NwAA+kVay9ot6bf//AU98aWvxXrm15Zndc9yif1bB8UJDlmTMY95T5xng7/A7G4FJWk6cG1ez03cGmNq6DV7RoakPbvWXxgalaZuWTf8n3/hZh19/uK68QvlX9Q3X6rKtNyOaQJA10mnUtq7f0xKNftf83peqmjm7Hzz/2kn2A17dkkjQ7HuHZB0fqagcpX/VwAAsJ0qllVu8s1680C8PoDFxXfoyQuXlVJ3lbR3p+eajpr7xj/2mdmtkj7o7j8Xvr9fktz9vzTc878k/bW7fy58f0zSWyRdv9mzzRw6dMiPHDmy+fcEAAAAAACAWMzsqLsfWjseJ7f8KUkHzOwGMxuUdKekw2vuOSzpV8NTy94gqeDuL8Z8FgAAAAAAAB2yaVmZu1fN7F5JjyvIwH7Y3Z81s3vC6w9KekzSz0s6KWlB0rs3erYt3wkAAAAAAAC2bNOysk6grAwAAAAAAGB7tSorS2RwyMzmJR3r9DzQEXskXej0JNAxrH//Yu37G+vfv1j7/sb69y/Wvr+x/p31Snffu3YwzmllnXCsWSQLvc/MjrD2/Yv171+sfX9j/fsXa9/fWP/+xdr3N9Y/meI0pAYAAAAAAECPIjgEAAAAAADQx5IaHHqo0xNAx7D2/Y3171+sfX9j/fsXa9/fWP/+xdr3N9Y/gRLZkBoAAAAAAAA7I6mZQwAAAAAAANgBiQoOmdltZnbMzE6a2X2dng/ax8ymzOyvzOwHZvasmb0vHN9tZl81sxPh14lOzxXtY2YDZvZ3ZvZn4XvWv0+Y2biZfd7Mfhh+DtzK+vcHM/v34ef+M2b2OTPLsva9y8weNrNzZvZMw1jL9Taz+8OfA4+Z2c91ZtbYDi3W/sPh5/53zeyLZjbecI217yHN1r/h2n80MzezPQ1jrH+PaLX2Zvab4fo+a2b/tWGctU+IxASHzGxA0gOSbpd0s6S7zOzmzs4KbVSV9B/c/R9IeoOk94brfZ+kr7n7AUlfC9+jd71P0g8a3rP+/eMjkr7s7n9f0usU/HvA+vc4M9sn6d9KOuTur5E0IOlOsfa97BFJt60Za7re4c8Bd0p6dfjMx8OfD9GdHtH6tf+qpNe4+2slHZd0v8Ta96hHtH79ZWZTkt4m6YWGMda/tzyiNWtvZm+VdIek17r7qyX9t3CctU+QxASHJN0i6aS7n3L3JUmPKvgXCD3I3V9096fD1/MKNob7FKz5H4a3/aGkX+zMDNFuZrZf0i9I+mTDMOvfB8wsL+mfSvqUJLn7krvPifXvF2lJOTNLSxqWdFqsfc9y9yckza4ZbrXed0h61N0X3f1Hkk4q+PkQXajZ2rv7V9y9Gr59UtL+8DVr32Na/LcvSb8n6bclNTa+Zf17SIu1f4+kD7n7YnjPuXCctU+QJAWH9kmabng/E46hx5nZ9ZJ+UtI3JU26+4tSEECSdHXnZoY2+30FPxzUGsZY//7wKknnJf3vsKzwk2a2S6x/z3P3Hyv4beELkl6UVHD3r4i17zet1pufBfvLv5H0pfA1a98HzOydkn7s7t9Zc4n1730HJf0TM/ummf2NmbU/QMAAAALZSURBVP2jcJy1T5AkBYesyRhHqfU4MxuR9MeS/p27Fzs9H+wMM3u7pHPufrTTc0FHpCW9XtIn3P0nJV0WZUR9Iewtc4ekGyS9QtIuM/vlzs4KCcLPgn3CzN6voMXAZ6KhJrex9j3EzIYlvV/SB5pdbjLG+veWtKQJBe1EfkvSH5mZibVPlCQFh2YkTTW8368g1Rw9yswyCgJDn3H3L4TDZ83s2vD6tZLOtXoeXe1Nkt5pZs8pKCH9aTP7P2L9+8WMpBl3/2b4/vMKgkWsf+/7Z5J+5O7n3b0i6QuS3ijWvt+0Wm9+FuwDZvYuSW+X9EvuHm0CWfved6OCXwx8J/z5b7+kp83sGrH+/WBG0hc88C0FlQN7xNonSpKCQ09JOmBmN5jZoILGVIc7PCe0SRgp/pSkH7j7/2i4dFjSu8LX75L0pzs9N7Sfu9/v7vvd/XoF/63/pbv/slj/vuDuZyRNm9lN4dDPSPq+WP9+8IKkN5jZcPj/gZ9R0HOOte8vrdb7sKQ7zWzIzG6QdEDStzowP7SJmd0m6T9Jeqe7LzRcYu17nLt/z92vdvfrw5//ZiS9PvyZgPXvfX8i6aclycwOShqUdEGsfaKkOz2BiLtXzexeSY8rOL3kYXd/tsPTQvu8SdKvSPqemX07HPsdSR9SkGb46wo2Ef+6Q/NDZ7D+/eM3JX0m/GXAKUnvVvALC9a/h7n7N83s85KeVlBS8neSHpI0Ita+J5nZ5yS9RdIeM5uR9Ltq8Vnv7s+a2R8pCBZXJb3X3Zc7MnG8bC3W/n5JQ5K+GsSH9aS738Pa955m6+/un2p2L+vfW1r8t/+wpIfD4+2XJL0rzBxk7RPEVrI5AQAAAAAA0G+SVFYGAAAAAACAHUZwCAAAAAAAoI8RHAIAAAAAAOhjBIcAAAAAAAD6GMEhAAAAAACAPkZwCAAAAAAAoI8RHAIAAAAAAOhjBIcAAAAAAAD62P8HlPyiCSyXPkYAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -2896,13 +2877,18 @@ "name": "stdout", "output_type": "stream", "text": [ - "tal hits: [MotifHitAndCoord(motif_idx=0, motif_score=0.8537087137453788, precision_at_motif_score=1.0, example_idx=19, start=37, end=62, is_revcomp=False)]\n", - "gata hits: [MotifHitAndCoord(motif_idx=1, motif_score=0.9060133574960566, precision_at_motif_score=1.0, example_idx=19, start=50, end=75, is_revcomp=False), MotifHitAndCoord(motif_idx=1, motif_score=0.999371099425408, precision_at_motif_score=1.0, example_idx=19, start=162, end=187, is_revcomp=False)]\n" + "tal hits:\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.7407143227403524, precision_at_motif_score=0.5, example_idx=19, start=21, end=46, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.999585467994209, precision_at_motif_score=1.0, example_idx=19, start=75, end=100, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.6763298538561408, precision_at_motif_score=0.3772269950506758, example_idx=19, start=84, end=109, is_revcomp=True)\n", + "gata hits:\n", + "MotifHitAndCoord(motif_idx=1, motif_score=0.9955978570801688, precision_at_motif_score=1.0, example_idx=19, start=22, end=47, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=1, motif_score=0.9927436977742843, precision_at_motif_score=1.0, example_idx=19, start=160, end=185, is_revcomp=False)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2916,16 +2902,20 @@ "source": [ "reload(modisco.visualization.viz_sequence)\n", "reload(modisco.visualization)\n", + "from matplotlib import pyplot as plt\n", "\n", "def visualize_idx(idx_to_viz):\n", " viz_sequence.plot_score_track(task0_transformed_scoretrack[idx_to_viz],\n", " threshold=CUTOFF_VALUE)\n", " \n", - " viz_sequence.plot_score_track(motif_precisions[idx_to_viz][:,0])\n", - " viz_sequence.plot_score_track(motif_precisions[idx_to_viz][:,1])\n", + " fig = plt.figure(figsize=(20,2))\n", + " ax = fig.add_subplot(111)\n", + " viz_sequence.plot_score_track_given_ax(arr=motif_precisions[idx_to_viz][:,0], ax=ax) #tal score plot (start idx)\n", + " viz_sequence.plot_score_track_given_ax(arr=motif_precisions[idx_to_viz][:,1], ax=ax) #gata score plot (start idx)\n", + " plt.show()\n", " \n", - " print(\"tal hits:\", motifmatch_to_coordinatesbyregionidx[0][idx_to_viz])\n", - " print(\"gata hits:\", motifmatch_to_coordinatesbyregionidx[1][idx_to_viz])\n", + " print(\"tal hits:\\n\"+\"\\n\".join([str(x) for x in motifmatch_to_coordinatesbyregionidx[0][idx_to_viz]]))\n", + " print(\"gata hits:\\n\"+\"\\n\".join([str(x) for x in motifmatch_to_coordinatesbyregionidx[1][idx_to_viz]]))\n", " viz_sequence.plot_weights(task_to_scores[\"task0\"][idx_to_viz],\n", " highlight={\n", " 'red': [(x.start, x.end) for x in\n", From d16ab0cdd1123de07257efca02236f03b4bb82be Mon Sep 17 00:00:00 2001 From: Avanti Shrikumar Date: Mon, 28 Dec 2020 03:58:54 -0800 Subject: [PATCH 26/30] added agkm and var seq len test --- test/test_tfmodisco_workflow.py | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) diff --git a/test/test_tfmodisco_workflow.py b/test/test_tfmodisco_workflow.py index 465da0c..581a491 100644 --- a/test/test_tfmodisco_workflow.py +++ b/test/test_tfmodisco_workflow.py @@ -128,6 +128,37 @@ def test_base_workflow(self): null_per_pos_scores = null_per_pos_scores, plot_save_dir="plot_save_directory")) + def test_varseqlen_agkm_workflow(self): + + onehot_data = self.onehot_data + task_to_scores = self.task_to_scores + task_to_hyp_scores = self.task_to_hyp_scores + + import modisco + null_per_pos_scores = (modisco.coordproducers + .LaplaceNullDist(num_to_samp=5000)) + tfmodisco_results = (modisco.tfmodisco_workflow + .workflow.TfModiscoWorkflow( + #Slight modifications from the default settings + sliding_window_size=[5,9,13,17], + flank_size=5, + target_seqlet_fdr=0.15, + seqlets_to_patterns_factory= + modisco.tfmodisco_workflow + .seqlets_to_patterns.TfModiscoSeqletsToPatternsFactory( + trim_to_window_size=15, + initial_flank_to_add=5, + embedder_factory=(modisco.seqlet_embedding + .advanced_gapped_kmer.AdvancedGappedKmerEmbedderFactory()), + final_min_cluster_size=60) + )( + task_names=["task0", "task1", "task2"], + contrib_scores=task_to_scores, + hypothetical_contribs=task_to_hyp_scores, + one_hot=onehot_data, + null_per_pos_scores = null_per_pos_scores, + plot_save_dir="plot_save_directory")) + #@skip def test_memeinit_workflow(self): From e6da2fb893ef9f72f38c6bfec14fe79573773a2a Mon Sep 17 00:00:00 2001 From: Avanti Shrikumar Date: Mon, 28 Dec 2020 04:16:25 -0800 Subject: [PATCH 27/30] small fixes --- modisco/coordproducers.py | 2 +- modisco/util.py | 2 +- test/test_tfmodisco_workflow.py | 63 +++++++++++++++++---------------- 3 files changed, 34 insertions(+), 33 deletions(-) diff --git a/modisco/coordproducers.py b/modisco/coordproducers.py index 1829ed2..fdcb165 100644 --- a/modisco/coordproducers.py +++ b/modisco/coordproducers.py @@ -427,7 +427,7 @@ def __init__(self, origvals, nullvals, increasing, min_frac_neg=0.95): #See derivation in irval_to_probpos function min_prec_x = self.ir.X_min_ if self.increasing else self.ir.X_max_ min_precision = self.ir.transform([min_prec_x])[0] - implied_frac_neg = -1/(1-(1/min_precision)) + implied_frac_neg = -1/(1-(1/max(min_precision,1e-7))) print("For increasing =",increasing,", the minimum IR precision was", min_precision,"occurring at",min_prec_x, "implying a frac_neg", diff --git a/modisco/util.py b/modisco/util.py index 16bdf77..86615d2 100644 --- a/modisco/util.py +++ b/modisco/util.py @@ -5,7 +5,6 @@ import numpy as np import h5py import traceback -from sklearn.neighbors.kde import KernelDensity def load_patterns(grp, track_set): @@ -75,6 +74,7 @@ def factorial(val): def first_curvature_max(values, bins, bandwidth): + from sklearn.neighbors.kde import KernelDensity kde = KernelDensity(kernel="gaussian", bandwidth=bandwidth).fit( [[x,0] for x in values]) midpoints = np.min(values)+((np.arange(bins)+0.5) diff --git a/test/test_tfmodisco_workflow.py b/test/test_tfmodisco_workflow.py index 581a491..f8b197f 100644 --- a/test/test_tfmodisco_workflow.py +++ b/test/test_tfmodisco_workflow.py @@ -97,6 +97,7 @@ def setUp(self): self.task_to_scores = task_to_scores self.task_to_hyp_scores = task_to_hyp_scores + #@skip def test_base_workflow(self): onehot_data = self.onehot_data @@ -128,37 +129,6 @@ def test_base_workflow(self): null_per_pos_scores = null_per_pos_scores, plot_save_dir="plot_save_directory")) - def test_varseqlen_agkm_workflow(self): - - onehot_data = self.onehot_data - task_to_scores = self.task_to_scores - task_to_hyp_scores = self.task_to_hyp_scores - - import modisco - null_per_pos_scores = (modisco.coordproducers - .LaplaceNullDist(num_to_samp=5000)) - tfmodisco_results = (modisco.tfmodisco_workflow - .workflow.TfModiscoWorkflow( - #Slight modifications from the default settings - sliding_window_size=[5,9,13,17], - flank_size=5, - target_seqlet_fdr=0.15, - seqlets_to_patterns_factory= - modisco.tfmodisco_workflow - .seqlets_to_patterns.TfModiscoSeqletsToPatternsFactory( - trim_to_window_size=15, - initial_flank_to_add=5, - embedder_factory=(modisco.seqlet_embedding - .advanced_gapped_kmer.AdvancedGappedKmerEmbedderFactory()), - final_min_cluster_size=60) - )( - task_names=["task0", "task1", "task2"], - contrib_scores=task_to_scores, - hypothetical_contribs=task_to_hyp_scores, - one_hot=onehot_data, - null_per_pos_scores = null_per_pos_scores, - plot_save_dir="plot_save_directory")) - #@skip def test_memeinit_workflow(self): @@ -233,3 +203,34 @@ def test_norevcomp_memeinit_workflow(self): null_per_pos_scores = null_per_pos_scores, plot_save_dir="plot_save_directory", revcomp=False)) + + def test_varseqlen_agkm_workflow(self): + + onehot_data = self.onehot_data + task_to_scores = self.task_to_scores + task_to_hyp_scores = self.task_to_hyp_scores + + import modisco + null_per_pos_scores = (modisco.coordproducers + .LaplaceNullDist(num_to_samp=5000)) + tfmodisco_results = (modisco.tfmodisco_workflow + .workflow.TfModiscoWorkflow( + #Slight modifications from the default settings + sliding_window_size=[5,9,13,17], + flank_size=5, + target_seqlet_fdr=0.15, + seqlets_to_patterns_factory= + modisco.tfmodisco_workflow + .seqlets_to_patterns.TfModiscoSeqletsToPatternsFactory( + trim_to_window_size=15, + initial_flank_to_add=5, + embedder_factory=(modisco.seqlet_embedding + .advanced_gapped_kmer.AdvancedGappedKmerEmbedderFactory()), + final_min_cluster_size=60) + )( + task_names=["task0", "task1", "task2"], + contrib_scores=task_to_scores, + hypothetical_contribs=task_to_hyp_scores, + one_hot=onehot_data, + null_per_pos_scores = null_per_pos_scores, + plot_save_dir="plot_save_directory")) From aca8a83d12b332418a86ffad7e8b4b1807bdf53f Mon Sep 17 00:00:00 2001 From: Avanti Shrikumar Date: Mon, 28 Dec 2020 05:19:15 -0800 Subject: [PATCH 28/30] switching default embedder, avoiding default tensorflow import --- .../TF_MoDISco_TAL_GATA_hitscoring.ipynb | 1018 ++++++++--------- modisco.egg-info/SOURCES.txt | 1 + modisco/affinitymat/core.py | 2 +- modisco/coordproducers.py | 1 - modisco/seqlet_embedding/__init__.py | 2 +- .../seqlet_embedding/advanced_gapped_kmer.py | 1 - .../tfmodisco_workflow/seqlets_to_patterns.py | 11 +- test/test_tfmodisco_workflow.py | 7 +- 8 files changed, 460 insertions(+), 583 deletions(-) diff --git a/examples/simulated_TAL_GATA_deeplearning/TF_MoDISco_TAL_GATA_hitscoring.ipynb b/examples/simulated_TAL_GATA_deeplearning/TF_MoDISco_TAL_GATA_hitscoring.ipynb index 45dc15b..96bf3d0 100644 --- a/examples/simulated_TAL_GATA_deeplearning/TF_MoDISco_TAL_GATA_hitscoring.ipynb +++ b/examples/simulated_TAL_GATA_deeplearning/TF_MoDISco_TAL_GATA_hitscoring.ipynb @@ -54,10 +54,10 @@ "Requirement already satisfied: scipy>=0.19.1 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from scikit-learn>=0.19->modisco) (1.4.1)\n", "Requirement already satisfied: six in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from h5py>=2.5->modisco) (1.15.0)\n", "Requirement already satisfied: python-igraph>=0.8.0 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from leidenalg>=0.7.0->modisco) (0.8.2)\n", - "Requirement already satisfied: kiwisolver>=1.0.1 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from matplotlib>=2.2.5->modisco) (1.2.0)\n", + "Requirement already satisfied: python-dateutil>=2.1 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from matplotlib>=2.2.5->modisco) (2.8.1)\n", "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from matplotlib>=2.2.5->modisco) (2.4.7)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from matplotlib>=2.2.5->modisco) (1.2.0)\n", "Requirement already satisfied: cycler>=0.10 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from matplotlib>=2.2.5->modisco) (0.10.0)\n", - "Requirement already satisfied: python-dateutil>=2.1 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from matplotlib>=2.2.5->modisco) (2.8.1)\n", "Requirement already satisfied: texttable>=1.6.2 in /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages (from python-igraph>=0.8.0->leidenalg>=0.7.0->modisco) (1.6.3)\n" ] } @@ -68,7 +68,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 3, "metadata": { "colab": {}, "colab_type": "code", @@ -90,7 +90,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 4, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -100,34 +100,7 @@ "id": "uVOSJpXV8aIG", "outputId": "3fa7a2eb-987f-49d6-8e8c-307a93d580b8" }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "TF-MoDISco is using the TensorFlow backend.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "WARNING:tensorflow:From /Users/avantishrikumar/anaconda3/lib/python3.8/site-packages/tensorflow/python/compat/v2_compat.py:96: disable_resource_variables (from tensorflow.python.ops.variable_scope) is deprecated and will be removed in a future version.\n", - "Instructions for updating:\n", - "non-resource variables are not supported in the long term\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/avantishrikumar/anaconda3/lib/python3.8/site-packages/sklearn/utils/deprecation.py:143: FutureWarning: The sklearn.neighbors.kde module is deprecated in version 0.22 and will be removed in version 0.24. The corresponding classes / functions should instead be imported from sklearn.neighbors. Anything that cannot be imported from sklearn.neighbors is now part of the private API.\n", - " warnings.warn(message, FutureWarning)\n", - "/Users/avantishrikumar/Research/tfmodisco/modisco/seqlet_embedding/advanced_gapped_kmer.py:190: SyntaxWarning: 'tuple' object is not callable; perhaps you missed a comma?\n", - " ('max_len', self.max_len)\n" - ] - } - ], + "outputs": [], "source": [ "import numpy as np\n", "import modisco\n", @@ -178,7 +151,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "metadata": { "colab": {}, "colab_type": "code", @@ -248,7 +221,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "metadata": { "colab": {}, "colab_type": "code", @@ -270,13 +243,13 @@ " #in this example they all have the same length (200bp) but that is\n", " #not necessary.\n", " task_to_scores[task] = [np.array(x)[::rc,::rc] for x in\n", - " f['contrib_scores'][task][:n] for rc in [1,-1]]\n", + " f['contrib_scores'][task][:n] for rc in [1]]\n", " task_to_hyp_scores[task] = [np.array(x)[::rc, ::rc] for x in\n", - " f['hyp_contrib_scores'][task][:n] for rc in [1,-1]]\n", + " f['hyp_contrib_scores'][task][:n] for rc in [1]]\n", "\n", "onehot_data = [one_hot_encode_along_channel_axis(seq)[::rc, ::rc]\n", " for seq in fasta_sequences[:n]\n", - " for rc in [1,-1]]" + " for rc in [1]]" ] }, { @@ -369,7 +342,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 5, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -385,10 +358,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "MEMORY 0.651464704\n", + "MEMORY 0.130899968\n", "On task task0\n", "Fitting - on window size 5\n", - "peak(mu)= 0.004865888827480376\n", + "peak(mu)= 0.00486588878557086\n", "Computing window sums\n", "Done computing window sums\n", "For increasing = True , the minimum IR precision was 0.2954850349262155 occurring at 5.7220458984375e-06 implying a frac_neg of 0.41941626448668695\n", @@ -399,7 +372,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -425,7 +398,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -451,7 +424,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -466,18 +439,18 @@ "output_type": "stream", "text": [ "Fitting - on window size 17\n", - "peak(mu)= -0.03414142362773419\n", + "peak(mu)= -0.03528579294681549\n", "Computing window sums\n", "Done computing window sums\n", - "For increasing = True , the minimum IR precision was 0.40074974232407007 occurring at 6.67572021484375e-06 implying a frac_neg of 0.6687518898670086\n", + "For increasing = True , the minimum IR precision was 0.4006572406407763 occurring at 7.033348083496094e-06 implying a frac_neg of 0.6684943371454617\n", "To be conservative, adjusted frac neg is 0.95\n", - "For increasing = False , the minimum IR precision was 0.2519079426947738 occurring at -3.814697265625e-06 implying a frac_neg of 0.3367338821938512\n", + "For increasing = False , the minimum IR precision was 0.41327328308403144 occurring at -4.0531158447265625e-06 implying a frac_neg of 0.7043709978920574\n", "To be conservative, adjusted frac neg is 0.95\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbIAAAEGCAYAAAAAKBB/AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deZhcZZn+8e/d3QmEQEAWkX0NICC7EEDZFAWGRRQVFRQcZUAcUNRRmfmJMipuqCACRhbBBccRkKioIAYBhwiEfZFFwBBAAmFJIIGku+/fH++pTqWo5XSnqutU9fO5rrqq6qxvBT1Pv9vzyjYhhBBCp+ppdwFCCCGEZRGBLIQQQkeLQBZCCKGjRSALIYTQ0SKQhRBC6Gh97S5Aq/X09HjChAntLkYIIXSUBQsW2HZHVHa6PpBNmDCBl156qd3FCCGEjiJpYYP9FwAHAnNsb11lv4AzgAOABcBRtm9tRVk7ItqGEEIonB8B+9XZvz8wOXsdA5zTqoJ0fY1spObMf5lXFg8utU2CtVeeQE+P2lSqzrJgUT9zX1zU7mKEMGa9buXlGdfbmvqK7eskbVjnkEOAi52ybsyQtIqktWw/2eyyRCCr4aT/uYMbHnrmVdtP2GdTTnrb5m0oUec56Hs38Peno1k3hHa57jN7s/5qK7Tr9usAj5V9n51ti0A2Wj66x8Ycst3aS2378m/v45/zXm5TiTrPU/Ne4c2TV+fgbddufHAIoelWXXH8spzeJ+mWsu9TbU8dxvnVmq5akhMxAlkNe262xqu2nfmnB+kfiNyUeS0eGGTLtSfx7p3Wa3dRQgjD1297p2U4fzZQ/n/+dYEnlq1I1cVgj2EY19PDooHBxgcGIAWycT3xP7EQxqhpwAeVTAFeaEX/GESNbFjG9fZEjSyngUEzaFrW0RxCaC9JlwB7AatLmg2cAowDsH0ucCVp6P1DpOH3R7eqLBHIhqGvVyyOGlkupX+ncX0xwjOEbmT7fQ32Gzh+NMoSgWwYxvX2sHhw7NXIbHPJTY/x3IL6Q+mfeH4hf7zvKXokBrN17sZHjSyE0GIRyIZhXK9Y3D+KNbLpp8Henx+9+9Xwj7kLOPnyu3Iff+A2a7HC+F76ent425ava2HJQgghAtmwjOvtYdFoBrKCKDUTfve923HAG9aqe2xvj+iNCeMhhFEUgWwY+np7eGnRQLuLMeoGSs2EfT2M74umwhBCscRTaRjGj3bTYkEMZP2CPYqaVgiheCKQDUNfTw/9g2MvkJV+cjQZhhCKKALZMIzr62HxGJxHVmpajAGIIYQiikfTMIwbo/PIomkxhFBkEciGYVxPz+gFsumnjc59chgcqpFFIAshFE8EsmEY16cxmaIqamQhhCKLQDYMfWM0aXCpRhaBLIRQRBHIhmF83yg2LRbEY88u4O7HXwCiaTGEUEyFmRAtaT3gYuB1wCBpEbczKo7ZC7gCeCTbdJntU0erjH09Y69p8b0/uJEnXkiLiU6aUJj/uYQQwpAiPZn6gU/ZvlXSSsBMSVfbvrfiuOttH9iG8qVlXAaNbTRGmtnmv9zPAW94HcfvvSmbr7lSu4sTQgivUpimRdtP2r41+zwfuA9Yp72lWtq43hS8xtJcsv5Bs84qE9hq7ZXHTPAOIXSWwgSycpI2BLYH/lpl966S7pD0O0lb1Tj/GEm3SLqlv7+/aeUqLRI5lvrJBmx6om8shFBgRWpaBEDSisClwCdsz6vYfSuwge0XJR0A/AqYXHkN21OBqQATJ05sWvWpFMjGUj/ZwKDpi0AWQiiwQtXIJI0jBbGf2r6scr/tebZfzD5fCYyTtPpola/UtDhWhuDbZmDQ9EaTYgihwApTI1PqgDkfuM/2t2sc8zrgKduWtDMpEM8drTIO1ci6PHHwU/Ne5oIbHhkK2L09hfp7J4QQllKYQAbsDhwJ3CXp9mzbycD6ALbPBQ4DjpPUDywEDrc9au18faU+sv7ublq86p5/8oPrHmbi+F5WnjCOLdee1O4ihRBCTS0JZJJeA6xNCjaP2m5YhbF9A1C3Dcv2WcBZTSnkCAyNWuzyGtkr2ZprM05+CystP67NpQkhhPqaFsgkrQwcD7wPGA88DSwPrClpBnC27enNul87jJVRi6UmxXGxbksIoQM0s0b2S1Jmjjfbfr58h6QdgSMlbWz7/Cbec1SNGyNNi6XfF4EshNAJmhbIbO9bZ99MYGaz7tUufV3etNg/MMhDT7/IP+ctpEeRWzGEMHok7Q58EdiAFJsE2PbGjc5tZtPiDvX2l7J2dLLxQzWy7gxk3/3jg5w1/SEAJi1fpHFAIYQx4Hzgk6RKz8BwTmzm0+r0OvsM7NPEe7VFqantnifmDWW72OJ1K3XNgIjnFixipeX6+Oa7t2G9VVdod3FCCGPLC7Z/N5ITm9m0uHezrlVUK09IAevU3yzJY/zOHdbh2+/Zrl1FaqpBw3Ljetlv67XaXZQQwtgzXdI3gcuAV0ob87TmNbNp8Z319lfL1NFpNltzRX51/O68+HLK33jy5Xcx/+Xm5XJsPxPdYiGENtkle9+pbFuu1rxmNi0eVGefSVG2o0liu/VWGfq+4nJ9jN507NYbHITIRhVCaIdladVrZtPi0c26VqeQUj7CbjFo0xORLITQBtlc5FOAPbJNfwZOtf1Co3ObPjRN0heqbR/NlZxHi5Sqmt3CEIEshNAuFwB3A+/Jvh8JXAjU7baC1qSoeqns8/LAgaRFMruOUNfVyEIIoU02sf2usu9fKsu7W1fTA5ntpYbhS/oWMK3Z9ymCnm6rkRki0X0IoU0WSnpTlne3NEF6YZ4TR2PW6wpAw5nZHUlisIsimaOPLITQPscBF2V9ZQKeBY7Kc2Ir+sjuYklFpRdYA+i6/jEYyp/S7mI0zaAbLD8QQggZSfsBZ5Ce8+fZ/lrF/pWBn5CW4uoDvmX7wlrXs307sK2kSdn3eXnL0ooa2YFln/tJC2F202SrId1WeYnBHiGEPCT1At8H9gVmAzdLmmb73rLDjgfutX2QpDWA+yX91PaiimsdYfsnkk6q2A5ArYWWy7Wij+wf2Y9cM7v+2pKwPavZ92q3Hqm75pHZXRecQwgtsTPwkO2HAST9HDgEKA9kBlZSikgrkpoKq1VqJmbvK420MK1oWvx30lyAp4BSdl0D2zT7Xu0mumukn+2hv4JCCGNen6Rbyr5PtT01+7wO8FjZvtksycxRchZpoN8TpCD13mqLLNv+Qfb+pZEWtBVj1E4ENre9le03ZK+uC2JQmhDd4ptMP63FN1jCJlJUhRBK+m3vVPaaWrav2pOi8mn4duB2YG1gO+CsUv9XNZK+IWmSpHGSrpH0jKQj8hS0FYHsMaDhTOxuIIRbMAD/O1c/wI0Pz+XGh+c2/dr1DNoohnuEEBqbDaxX9n1dUs2r3NHAZU4eAh4BtqhzzbdlAzwOzK6/GfCZPIVpxWCPh4FrJf2WpTMYN+yw6zSjUiMbRXb3DWAJIbTEzcBkSRsBjwOHA++vOGYW8BbgeklrApuT4kMtpfWwDgAusf1s3q6OVgSyWdlrfPbqWlJKtNstBh2jFkMIjdnul/Rx4A+k4fcX2L5H0rHZ/nOB/wZ+lE3JEvBZ28/UueyvJf2NNAn6Y9lIx5fzlKcVoxZH3GHXaVLTYvdEMseoxRBCTravBK6s2HZu2ecngLcN43qfk/R1YJ7tAUkvkUZCNtSShESS/qP8vVv19HRP0+LLiwe45m9zGOimVCUhhMKTtE/2/k5gb+CQ7PN+wG55rtGqzHqHV7x3pVQj6w7zFi4GYPPXjXgqRwghjMSe2ftBVV4H1jqpXKtzLXZ1Q5XUPfPISr9i541WbWs5Qghji+1TsvcRr2kZuc6XUZfEsaHfEcPvQwjtIOmrklYp+/4aSV/Oc24EsmXQo+5pWizNh4vBHiGENtnf9vOlL7afIw3FbygC2TJQSn/f7mI0xZIaWQghtEWvpOVKXyRNAJarc/yQVvWRXZu9T2/R9Qsh5VpsdymaK2pkIYQ2+QlwjaQLSd32HwYuynNiSwKZ7ZPK37uV1JoUVe3QHb8ihNCpbH9D0p3AW0n1hP+2/Yc85za9aVHSCpL+n6QfZt8nS2o4hFLSepKmS7pP0j2STqxyjCSdKekhSXdK2qHZ5R+Oni5KUVVaIDQGe4QQ2ug+4Pe2P0VKbZVrPlAr+sguJOVY3DX7PhvIM/KkH/iU7dcDU4DjJW1Zccz+wOTsdQxwTlNKPGLqmqbFoYAccSyE0AaSPgr8EvhBtmkd4Fd5zm1FINvE9jeAxQC2F5Lj8Wj7Sdu3Zp/nkyLzOhWHHQJcnGVTngGsImmtppZ+GFLS4C6JZJmIYyGENjke2B2YB2D7QeC1eU5sGMgkbT3MwizKRps4O38TyrLg5yFpQ2B74K8Vu6ot5lYZ7JB0jKRbJN3S319tQdLm6MaHfiysGUJok1dsLyp9kdRHzu77PDWycyXdJOlj5ZPV6jgF+D2wnqSfAtcAuXMuSloRuBT4RLY2zVK7q5zyqh9qe2ppMbi+vtYlL+mRuqiPrN0lCCGMcX+WdDIwQdK+wP8Cv85zYsOnvO03SZpMGgp5i6SbgAttX13j+Ksl3Urq5xJwYoPU/UMkjSMFsZ/avqzKIXkWcxs13ZWiqjTYI4QQ2uKzwEeAu4B/I2XWPy/Pibn6yLK2yv/KbrQncKakv2UZipeSjSTcAHiSFGTWl7RJVk2sSalN63zgvjqLcE4DPpiNXpwCvGD7yTy/oRWkURq2Pv20lt9iaEJ0RLIQwiiT1APcZfuHtt9t+7Dsc65HbMMamaRtSEtW/wtwNXCQ7VslrQ3cCFTWnM4GdgDuJP2Bv3X2eTVJx9q+qsatdgeOBO6SdHu27WRgfRha5+ZKUsqSh4AFWbnaRqglgz2mzJra9Gs2MjRoMQJZCGGU2R6UdIek9W3PGu75eTqQzgJ+CJycjUAs3fgJSf9V5fhHgX+1fQ9ANoT+M6TVQi8DqgYy2zfQoGUri87H5yjzqBi1GlkIIXS/tYB7su6rl0obbR/c6MQ8gewy2z8u3yDpRNtnVG7PbFEKYlkh7pW0ve2Hu21EnLpqsEdMiA4htNWXRnpinj6yD1bZdlSd4++XdI6kPbPX2cADWTLIxSMpZFGlnMHdEcmiaTGE0E62/wzcD6wMTALuz7Y1VLNGJul9wPuBjSRNK9u1EjC3zjWPAj4GfIL0rL8B+DQpiO2dp1CdQoKn5r3CcT+ZObRt7y1ey3t2Wq/OWcXUJfE4hNChJH0E+ALwJ1Ls+J6kU21f0Ojcek2L/0caebg6cHrZ9vmkwRtVZf1op1ecU/JiowJ1kj0mr8F9T87j70+nn/X4cwt5dO6CjgxkDK1HFlWyEEJbfAbY3vZcAEmrkeLQyAOZ7X8A/2BJzsRcJO0OfJE0BH/o+rY3Hs51OsG7dlyXd+247tD3j158C489u6CNJQohhI41m1RRKpnP0pmcaqrXtHhDNhl6PksPzsu6hjypxqnnA58EZgIDeQrRLTq5LhMLa4YQ2uxx4K+SriDFnEOAmySVlgWrNb+4bo3sTdl7rjT6ZV6w/bthntMV1MHLusRgjxBCm/09e5Vckb03jEF5JkRvAsy2/YqkvYBtSBnon69xynRJ3yTNGRtKFlzKbN/NROcutLmkRhaRLIQw+myPePh9nnlklwI7SdqU1Gw4DfgZKcNGNbtk7zuVlxHYZ6SF7BSdXSMrDfZoc0FCCGGY8gSyQdv9kg4Fvmv7e5Juq3Ww7a4aYj8ckekjhBBGX55AtjibU/Yh4KBs27h6J0j6F2ArYPnSNtunjrSQnSJl+ujMUBaDPUIInSpPIDsaOBb4iu1HJG0E/KTWwZLOBVYgTX4+DzgMuKkJZS28NJyz3aUYmch+H0JoB0nfo05jlu0TGl2jYYoq2/faPsH2Jdn3R2x/rc4pu9n+IPBc1nm3K0uvIda1JHVs0+KSQSoRyUIIo+oW0nSt5UkrpzyYvbYj5xSuPKMWKyc4l+aR1Zrg/HL2viBb6mUusFGewnS6Ts692KHFDiF0ONsXAUg6Ctjb9uLs+7nUWC2lUp6mxeFOcP61pFWAbwK3kqqMP8xTmE7XDYM9omkxhNAma5PmjD2bfV8x29ZQnkCWe4JztsrnNdkcs0sl/QZY3vYLec7vdJ3cR1YScSyE0CZfA26TND37viepNbChPIEs9wTnbJXP08nyM9p+pfycbpf6yDozki0Z7BGhLIQw+mxfKOl3LJmL/Dnb/8xzbp5ANtwJzldJehdpQc7OfKqPUCfXyIYmRLe5HCGEziBpP+AMoBc4r9ogwCwb1HdJU7aesb1ng8v2Ak+TYtNmkjazfV2jsjQMZCOY4HwSMBEYkLSQxkmGu0YnrxjdqeUOIYw+Sb3A94F9SVnrb5Y0zfa9ZcesApwN7Gd7lqTXNrjm14H3AvcAg9lmA8seyCStCXwVWNv2/pK2BHa1fX6140eQZLhrpBRVnR0RomUxhJDDzsBDth8GkPRzUrb6e8uOeT+pZW4WgO05Da75DmDzrEtqWBrOIwN+BPyBJaNHHiCt/lyTpIMlfSt7HTjcQnUq0bmjFiP7fQihQp+kW8pex5TtW4el1wqbnW0rtxnwGknXSpop6YMN7vcwDbJG1SxojmNWt/0LSZ8HyPIu1hyGL+lrwBuBn2abTpT0JtufG0kBO0krkgbf+PBcAGb0PwDAJ/fdrLk3yJRqkpH9PoSQ6be9U4191R4UlU+/PmBH4C3ABOBGSTNsP1DjmguA2yVdw9IDCxtm9sgTyF7Klpw2gKQpQL3h9AcA29kezI6/CLgN6P5A1snLuLS7ACGETjKbpTM2rQs8UeWYZ2y/RIoj1wHbklr1qpmWvYYtTyA7Kbv4JpL+AqxByp9YzyosmdS28kgK1ok6bRmXBYv6eezZhQDMmrsgbYwKWQihsZuByVnu3ceBw0l9YuWuAM6S1AeMJ42A/06tC5YyfIxEnlGLt0raE9ic9Ji7v5RCpIbTWDKpTcAewOdHWsBOIsFgBwWyf/vxTK5/8Jmltk0Y19um0oQQOkXWxfRx0viJXuAC2/dIOjbbf67t+yT9HriTNArxPNt317qmpEeo0jhUJx3ikJqBTNI7a+zaLFuu5LJqO21fIulaUj+ZgM/mndTW+TpruMfzCxaz1dqTOH7vTQGYML6XN264aptLFULoBLavBK6s2HZuxfdvktIV5lHeH7c88G4g1wOpXo2stPbYa4HdgD9l3/cGriVl+qjK9pOMsK2zk/V0WNOiMWtOWp4D3rBWu4sSQhjjbM+t2PRdSTcAX2h0bs1AZvtogCxf4pZZcELSWqSJcKFCNyQNDiGEdpC0Q9nXHlINLde85DyDPTYsBbHMU6T5AaGC6KwVou0Y2xFCKIzTyz73A48C78lzYp5Adq2kPwCXkCochwPT658yfJIuAA4E5tjeusr+vUijYB7JNl1m+9Rml2NZtLJGNmXWVGasf0zjA0MIoQONIB3ikDyjFj8u6VDS6EOAqbYvz3sDSfdlH79v+6w6h/4IOAu4uM4x19subKaQTksabEcmjxBCMUhaGTiFJbHmz8CpeZYBy1MjIwtcuYNXxbmvl7Q6S7Lo1zruOkkbjuQeRSGJwU6KZCGEUBwXAHezpDnxSOBCoNYI+iG5Atmysv0M8NsmXGpXSXeQZpB/2vY91Q7KcoIdAzB+/Pgm3HYYOiiOxcItIYQC2cT2u8q+f0nS7XlObFogkzSfOo/xJizjciuwge0XJR0A/AqYXONeU4GpABMnThy10BKjFkMIYcQWZnl5bwCQtDuwMM+JeZZxORC4spQ7sZbS8i2STgX+CfyY9Of+B8g5hLLB9eeVfb5S0tmSVs9qe4XQo04btejoIwshFMWxwMVZXxnAc8CH8pyYZxmXw4EHJX1D0utzHP9222fbnm97nu1zgHc1PKsBSa+T0mNX0s6ksldOoGurpuT1mH5aE0oSQgidI1uo8wjb2wLbANvY3t72nXnOzzNq8QhJk4D3ARdKMqkD7hLb86ucMiDpA8DPSc/19wE1l30p+yGXAHsBq0uaTRq9Mi4rw7mkRMXHSeonVTcPd8GqP52WNBiihyyE0H62ByTtmH2e1+j4SnlHLc6TdClpTZlPAIcCn5F0pu3vVRz+fuCM7GXgL7w6K3K1e7yvwf6zSMPzC0vq3GVcQgihzW6TNA34X+Cl0sZaeX3L5ekjOxg4GtiE1O+1s+05klYA7gOWCmS2HyUteT3miM7Kfh/zyEIIBbIqqbton7Jtpk5e35I8NbLDgO/Yvq58o+0Fkj5cebCkNYCPAhuWX9/2q47tOp2V/D6EEAqjlN93JPIEsicrg5ikr9v+rO1rqhx/BXA98Edy9I11k05bIdoYRS9ZCKEAJJ1ZZfMLwC22r6h3bp5Ri/tW2bZ/neNXyILcL2xfWnrluE/H68TBHiGEUBDLA9sBD2avbUjNjf8q6bv1Tqy3sOZxwMeATSSVD4FciTSAo5bfSDogW3RtTOnpsAnR0UcWQiiQTYF9bPcDSDoHuIpUmbqr3on1mhZ/BvwOOA34XNn2+bafrXPeicDJkl4BFlPKpbvsmT0Kr9OWcQkhhAJZB5hIak4k+7x2NjT/lXon1gtktv2opOMrd0hatVYwK2X4GIuWOUXVKE+GNlEjCyEUxjeA2yVdS6oA7QF8VdJE0piLmhrVyA4EZpI988r2Gdi42kmS9qi2vXLASDfqtGVcQgihKGyfL+lKYGfS4/Rk209kuz9T79yagay07pftjYZZnvIbLp8VaiZLzw3oTln1JuUwLH5Vx45RiyGEYshSEL4F2Nj2qZLWl7Sz7ZsanVtvsMcO9U60fWuN7QdVXGc9UpWx65VCQgyiCCGEYTsbGCRVek4F5gOXAm9sdGK9psXT6+wz+WtYs4Gtcx7b0UrBq6NaFyPghhCKYRfbO0i6DcD2c5JyLShZr2lx75GURNL3WPIs7yHNC7hjJNfqNKVmuqMuXFITnrLxahy/96YNz/3O1Q8wZdboJvPvqIAbQuh2i7Ms+IahLFF1lw8rqde0uI/tP0mqusx0nUSOt5R97idlya8376xrvGnyalz/4Gt48ZV+AGbNXcDf57yYK5C1S1TIQggFcSZwOfBaSV8hpUf8rzwn1mta3BP4E3BQlX01EznaviirDm6Wbbo/T0G6wY4brMovj9tt6PvnLr2T6ffPaWOJGogqWQihACT1AI8A/0Ea8CHgHbbvy3N+vabFU7L3YSVylLQXcBHwaFaY9SR9aCwMv6/U2yP6B5ocLaafBnt/vmmX64TRlSGE7mZ7UNLptncF/jbc8xvmWpS0mqQzJd0qaaakMyStVueU04G32d7T9h7A24HvDLdg3aCvR/QXeF2X4pYshDAGXSXpXRrBX9d5kgb/HHgaeBepzfJp4H/qHD/O9lBzou0HyFZ6Hmt6e3oYKHAgg+gjCyEUxkmkRTUXSZqfvXKtFp1nGZdVbf932fcvS3pHneNnSjqftAgnwAdIE6LHnL5e0T+Ya9BNW0ReyBBCUSxLesM8gWy6pMOBX2TfDwN+W+f4Y4HjgRNIf/BfR5roNub09aj4NbKokoUQCkLSwaQciwDX2v5NnvPqDb+fz5IciycBP8l29QAvAqdUOacHmGl7a+DbuUvfpaKPLIQQ8pH0NVIWj59mm06U9Cbbn6tzGlB/1OKwq3nZyJM7JK1ve9Zwz+82vT092DA4aHp6iln1KWapQghj0AHAdrYHASRdBNzG0suIVZWnaRFJrwEmk5IAA3Wz2a8F3CPpJuClsuMPznOvbtLXm8JE/6AZX8BAFl1kIYSRkrQfcAbQC5xn+2s1jnsjMAN4r+1fNrjsKkBpibCV85alYSCT9BHSYpnrArcDU4AbqZ1r8Ut5b97terPgVeR+sphHFkIYriyV1PdJqzfPBm6WNM32vVWO+zrwhxyXPQ24TdJ0lqxHlmvSbJ4a2YmkdssZtveWtAV1gpXtP+e58VjQlwWyOfNfZoPVJra5NK/m6CULIYzMzsBDth8GkPRz4BDg3orj/p0GGewl7Z6lMbwMuDY7VsBnbf8zT2HyzCN72fbL2Q2Xs/03YPM6hZovaV7F6zFJl0uquhhnt1ptxZS4+a+PVF1Me9imzJqaPjRxJemoj4UQRmAd4LGy77OzbUMkrQMcCpzb4FpnZu832n7S9jTbV+QNYpCvRjZb0irAr4CrJT0HPFHn+G9n+39Gek4eDryOlHPxAmCvvIXrdDtvlCVAKWjFJ/rIQgh19EkqTwI/1Xb213TVv4ErnyjfJdWqBhp0YSyWdCGwjqQzK3faPqFhQRsdYPvQ7OMXs7bLlYHf1zllP9u7lH2fKmlGtuLnyY3u101K4zsGixwxokoWQqiu3/ZONfbNBtYr+74ur67g7AT8PAtiqwMHSOq3/auK4w4E3koadzGi5Bl5Ry3uALyJFHH/YntRncMHJb0HKI1OOaxsX4Gf6M3Xk/0VUtSxHkWOryGEQrsZmCxpI+BxUsvb+8sPsL1R6bOkHwG/qRLEsP0MKeDdZ3tEa1fmSRr8BVI2+9VIUfVCSfXWiPkAcCQwB3gq+3yEpAnAx0dSyE5VquwUuUamqJKFEIbJdj/pef4H4D7gF7bvkXSspGNHeM0RL8Ccp0b2PmD7sgEfXwNuBb5cozAPU30NM4AbRlLITlVqFy5uGAshhJGxfSVwZcW2qgM7bB/VyrLkGbX4KGUToYHlgL/XOljSZpKukXR39n2bBjW40nkXSJpTOq/KfmXLyTwk6c6subPQSn1kRU7OG9PIQgidrl6uxe+RKhOvkDJ1XJ1935f6NasfAp8BfgBg+05JP6NGDa7Mj4CzgItr7N+flF1kMrALcE72XlhDfWQF7SQrcoANIYwNkk6qt992w7y99ZoWS8MuZwKXl22/tsE1V7B9U8Vwy/5GBbF9naQN6xxyCHCx09N3hqRVJK1l+8lG126Xog/2gBi0GEJou1Je381Jk6GnZd8PIq2e0lC9pMEXlT5LGg9sln293/biOtd8RtImZF1Dkg4DmhFsak3Ae9W1JR0DHAMwfvz4Jtx6ZJQ13BZ1sEcxSxVCGEtsfwlA0lXADrbnZ9+/SFpos6E8uRb3Io1afLgCj1MAABdbSURBVJT0B/x6kj5UJ2nw8cBUYAtJjwOPkEYyLqs8E/DSxjRpbyrAxIkT2/a8LhW4oHEMiD6yEEJhrA+UT+1aBGyY58Q8oxZPB95m+35IgzmAS4AdKw/MEkQeZ/utkiYCPaXo2gR5JuAVSs/QqMViRrIiB9gQwpjzY+AmSZeTKimHUnvMxFLyjFocVwpiALYfAMZVO9D2AFmAs/1SE4MYpHbTD2ajF6cALxS5fww6pY8sqmQhhPaz/RXgaOA54HngaNtfzXNunhrZTEnnk6IlpGbCemlEbpM0jdS2Wb4e2WX1biLpElIextUlzSatQD0uO/dc0nyFA4CHgAWkH1xoKniKqqLWFEMIY9YKwDzbF0paQ9JGth9pdFKeQHYsqd/rBFK3z3XA2XWOXxWYy9LrlZmUor8m2+9rsN9ZOTrGUNNigeNF9JGFEIpA0imk/IybAxeSKjI/AXZvdG7dQCapB5hpe2tSVvuGbBe+pjRahpIGF7RtscgBNoQw5hwKbE/KHIXtJyStVP+UpG4fme1B4A5J6+ctiaR1s7XH5kh6StKlktbNe343USf0kUWNLIRQDIuylrfS1K3cqxHnaVpci5TZ4yaW7vM6uMbxF5LWInt39v2IbNu+eQvVLYZSVBW0L6qYpQohjFG/kPQDYBVJHwU+DJyX58Q8gexLwyzMGrYvLPv+I0mfGOY1ukIn1Mgit0cIoQhsf0vSvsA8Uj/ZF2xfnefcerkWlycN9NgUuAs4P0vd38gzko4gzTWDlD1/bp7CdKMeFTenYUGLFUIYgyR93fZngaurbKurXh/ZRaQRJHeREvaenrM8HwbeA/yTlD7qsGzbmNQjFXb4PUQfWQihMKp1P+2f58R6TYtb2n4DQDaP7KZ6FyqLnLvU6T8bc1Iga3cpailswUIIY4Sk44CPARtLurNs10rAX/Jco16NbCgxcM4mxQMkjQM+n+fGY0X/4CDnXPt3BgoazaJCFkJos5+RMt1Py95Lrx1tH5HnAvVqZNtKmpd9FjAh+y7S/ORJFcf/HngGmFh+XJ3jx4S1Vp7A488v5IWFi1l1Yu1M/FNmTR3FUiUFbvEMIYwRtl8AXiCNp0DSa0mLOa8oaUXbsxpdo2aNzHav7UnZayXbfWWfXxWUbH/G9srAb8uPq3X8WHHMHhsDxR3wEX1kIYQikHSQpAdJK6b8mbTiyu/ynJsnafCw2D6k2dfsZBqaS1Y8RSxTCGHM+jIwBXjA9kbAW2hCH9mISfpF+ftYVvQ1ySL7fQihIBbbngv0SOqxPR3YLs+JeSZEj8Sm2fvkFl2/cxR4TbKiNneGEMak5yWtSEpM/1NJc4A8Aw1bUyMLSwzVdwoaM6KPLIRQEIcAC4FPkgYP/p00erGhVtXIQib6yEIIoTHbLwFImgT8ejjnRiBrsVIfVN1WvOmnjU5hKvQPmN6eqJKFENpP0r8Bp5JqZYMsmcK1caNzWxXI4umYUQEz4N866zlmP7eQlxcPML4vWpdDCIXwaWAr288M98RWBbJvVryPWUUbtTgwaA7/wQwWDQwC8NqVlm9ziUIIAUh9YgtGcmJLApntn5W/j2VF6yMbtFk0MMhRu23Ih3bbkA1WXaHdRQohBEjpDf9P0l+BV0obbZ/Q6MSmBzJJmwHnAGva3lrSNsDBtr/c7Ht1giV9ZMUIZaVirLHScmy0eu4FWEMIodV+APyJtOLK4HBObEUHyQ9JkXUxgO07gcNbcJ/OUKqRNTuOjXCASJH66kIIoUy/7ZNsX2j7otIrz4mtCGQr2K5c8iXXpLZuVLRRL6WAGvPHQggFM13SMZLWkrRq6ZXnxFYEsmckbULWLSTpMNICm6FVhlE7GwpkhQuxIYQx7v1k/WTAzOx1S54TWzHY43hgKrCFpMdJmYxzrSnTjaQc88hGUalpMWpkIYQiyRIFj0jTA5nth4G3SpoI9Nie3+x7dJKh4fcF6ZtaUiMLIYT2k7SP7T9Jeme1/bYva3SNVoxa/ELF91JhTm32vTqBWjXYY4RKxYgaWQhhWUjaDzgD6AXOs/21iv0fAD6bfX0ROM72HVUutSdptGK1vIoGRj+QAS+VfV4eOBC4rwX36QgtnUc2/TTY+/PDOqU0DSD6yEIIIyWpF/g+sC8wG7hZ0jTb95Yd9giwp+3nJO1P6nLapfJatk/JPp5q+5GK++RqbmxF0+LpFQX5FjCt2ffpFIWbR5a9R40shLAMdgYeyrqSkPRzUvb6oUBm+//Kjp8BrNvgmpcCO1Rs+yWwY6PCjEbS4BXIkfSxWxUts0dB4mkIofj6JJWPGpxqe2r2eR3gsbJ9s6lS2yrzr8Dvqu2QtAWwFbByRT/ZJFKrXuOC5jloOCTdxZLndi+wBimjcaPzGrW37gVcQaquAlzWSf1uNQPIaGe+H5pHFlWyEEJd/bZ3qrGv2gOk6lNO0t6kQPamGtfanNQFtQpL95PNBz6ap6CtqJEdWPa5H3jKdt0J0TnbWwGut33gqy5QYEsCxqv/G3/n6geYMmvuqJZnaPj9qN41hNBlZgPrlX1fF3ii8qAsReF5wP62qz7sbF8BXCFpV9s3jqQwTZsQXTYLe37ZayEwKcfs7KH2VtuLgFJ7a8crWvb7UjliGbIQwjK4GZgsaSNJ40lpCJcaCyFpfdKIwyNtP5DjmodKmiRpnKRrJD0jKdcc5GbWyGaSqh21qpz1+snytrfuKukOUuT/tO17ql1M0jHAMQDjx49vXPIWKlwfWfYeTYshhJGy3S/p48AfSN1BF9i+R9Kx2f5zgS8AqwFnZ8+bek2VAG+z/R+SDiXFgHcD04GfNCpP0wLZsszKJl97663ABrZflHQA8Ctgco2yTCUN9WTixIltjSG5VogehhsfXlI733Xj1YZ9/tDw+4hjIYRlYPtK4MqKbeeWff4I8JFhXHJc9n4AcIntZ/P+wd2SUYvZyJM3kYLR9bZ/1eCUhu2ttueVfb5S0tmSVh/JaqKjqeUrRA9zsMhgZPYIIRTTryX9jdQl9TFJawAv5zmx6UmDJZ0NHEtaU+Zu4FhJ329wWp721tcpC8+Sds7KProjJUagaAHDS4YttrcgIYRQxvbngF2BnWwvJq0WnWusRCuy3+8JvD1bU+ZCUjVxr3onZKMaS+2t9wG/KLW3ltpcgcOAu7M+sjOBw12UWcY5FKakUSMLIRSIpP8o+/pW2wMAtl8CGq4ODa0JZPcD65d9Xw+4s9FJtq+0vZntTWx/Jdt2bqnN1fZZtreyva3tKRWzxgsrci2GEEJd5QsvV+bc2y/PBZrWRybp16Tn5MrAfZJuyr7vQlpfZozKBnsUZNxirEcWQigY1fhc7XtVzRzs8a0mXqtrFK9GFqMWQwiF4hqfq32vqpmB7LpGfVaS1En9Ws1QL15MmTW1zt5hypkJP9YjCyEUzLaS5pEeSxOyz2Tfc+VabGYf2XRJ/57N5h4iabykfSRdBHyoiffrCMVbITqJGlkIoQhs99qeZHsl233Z59L3cY2v0Nwa2X7Ah4FLsjVknidF017gKuA7tm9v4v06QvFWiC41LUYkCyF0h2Zm9ngZOJuUjmQcsDqw0PbzzbpHJypcH1k0LYYQukxLMntkk9mebMW1O03Rci2WRI0shNAtWjGPLJQp2grRg6WmxTaXI4QQmiUCWasVrEbmyFAVQugyEcharK3rkVVJKByjFkMI3SYCWYuNel9Ug2z4Q6MWo3ExhNAlIpCNmrIq2TCXXmlFKaJGFkLoFhHIWqwUL37w54cLMeCjAEUIIYSmikDWYhuuNhGAq+59in/MXcDLiwd4eUC8vHiARYM9zQ0suWp6MSE6hNBdWjKPLCyx/morcOFRb+ToH93MXt+6Ntv6Bvjj74E92Wni03xq7btbWgbb/L8r7uYfcxfw0iv9QAy/DyF0jwhko2C3TVfjiwdtyYLFA9zw4DOs//xNzFplZ2Y/9g+eWLRC829YkUD4lf5BfjJjFuusMoE1Jy3HbpusxrbrrtL8+4YQQhtEIBsFy/X1ctTuGwHwyuJBpsyaxYz196Nvzt3cu3DkAeXGh+cOfd5149VqHleaBH3krhtw7J6bjPh+IYRQRBHI2mTKrKncrc14ebCPR19Zcal9a41bwHI9g8t2g7L+ssivGELoZhHI2mhibz8vDo7j87PeuNT2XVacwyfWuqdp94kh9yGEbhaBrI0Oec0/mLz8vKXSV/3P3I2ZP5BrCZ7cYhJ0CKGbxfD7Nlqhd4CdVnyGN5a9VuldxICbGHCmnxY1shBCV4tANlqyPqsps6bWPaxXZqDJNSdn3W0xdyyE0I2iabFgevCIamT1RjD6+u8AW0XDYgihK0UgG005Mm/0aZDBZWxarAxq0bQYQuhm0bRYMD0yTy5egS8+tj3Tnl2/KdccCmSlDW1MWhxCCM0WNbKC2W3FOSwY6GPWohW5fn4fB686a5mvWQpkPT3NqZJ95+oHhj5/ct/NmnLNEEIYqQhko+A7Vz/AlFlzGx8I7LLS0+yy0tOc8eSWzKqYKD0SNz48lxf603D+P/1tDnNfXMSUWXOZ0f9A1eOHG5giqIUQ2i0CWUH1ygw2aXiGs+uIpUdNTpk1lRnrH7PUseWBKYQQOkEEsha58fxPM2P9Y5gyaypTRnB+DzRtPtloLUFWq3YWtbYQQitFICuonqbWyJLyzB6N5rMtq1o1u+EGtQiCIYRGChPIJO0HnAH0AufZ/lrFfmX7DwAWAEfZvnXUC1pH+UN3CssWLHpHOJ+srjqXq9bM2GrDbcZc1mbP6P8LoXmK9MwuRCCT1At8H9gXmA3cLGma7XvLDtsfmJy9dgHOyd7bqvLh2qyaTlNrZFlA3OTZ62DlV+8vlbkdwWw0LUsgXJZzIwiGblO0Z3YhAhmwM/CQ7YcBJP0cOAQo/0c5BLjYKQPuDEmrSFrL9pOtKlS1h1flw75VTXR9GmTewHiOfujNy3yt0mCPniq9ZZXlL30v/cbS7632uyu31zp3rCviAJpawbWIZW2W+IOiqQr1zC5KIFsHeKzs+2xeHbmrHbMO8Kp/FEnHAKUnqCUtbF5RAU5v7uXq6wP6m3Ghk4d19OlVPlf+7kbbq+1bStN+W8EU/nedNPJTC//basnxmzv2tzUw0t81QdItZd+n2i795dvUZ/ayKkogq9aGVll9yHNM2pj+sVs7mmGUSLrF9k7tLkcrdOtv69bfBfHbOlGLfldTn9nLqigpqmYD65V9Xxd4YgTHhBBCaL1CPbOLEshuBiZL2kjSeOBwYFrFMdOADyqZArzQyv6xEEIINRXqmV2IpkXb/ZI+DvyBNJTzAtv3SDo2238ucCVpGOdDpKGcR7ervKOsK5pIa+jW39atvwvit3Wipv+uoj2zlQaUhBBCCJ2pKE2LIYQQwohEIAshhNDRIpAVlKT9JN0v6SFJn2t3eZpF0nqSpku6T9I9kk5sd5maTVKvpNsk/abdZWmWbDLrLyX9Lftvt2u7y9Qskj6Z/W/xbkmXSFq+3WUaKUkXSJoj6e6ybatKulrSg9n7a9pZxlaIQFZAZelf9ge2BN4nacv2lqpp+oFP2X49KSXl8V3020pOBO5rdyGa7Azg97a3ALalS36fpHWAE4CdbG9NGrhweHtLtUx+BOxXse1zwDW2JwPXZN+7SgSyYhpK/2J7EVBK/9LxbD9ZShxqez7pgbhOe0vVPJLWBf4FOK/dZWkWSZOAPYDzAWwvsv18e0vVVH2kLBZ9wAp08PxU29cBz1ZsPgS4KPt8EfCOUS3UKIhAVky1Urt0FUkbAtsDf21vSZrqu8B/AIPtLkgTbQw8DVyYNZmeJ2liuwvVDLYfB74FzCKlTnrB9lXtLVXTrVmav5W9v7bN5Wm6CGTFNGqpXdpF0orApcAnbM9rd3maQdKBwBzbM9tdlibrA3YAzrG9PfASXdI8lfUXHQJsBKwNTJR0RHtLFYYrAlkxdXU6LknjSEHsp7Yva3d5mmh34GBJj5Kag/eR9JP2FqkpZgOzbZdqzr8kBbZu8FbgEdtP214MXAbs1uYyNdtTktYCyN7ntLk8TReBrJjypH/pSNlie+cD99n+drvL00y2P297Xdsbkv6b/cl2x/91b/ufwGOSNs82vYWll+voZLOAKZJWyP63+Ra6ZCBLmWnAh7LPHwKuaGNZWqIQKarC0mqlf2lzsZpld+BI4C5Jt2fbTrZ9ZRvLFBr7d+Cn2R9WD9MlKeJs/1XSL4FbSSNqb6ODU1VJugTYC1hd0mzgFOBrwC8k/SspcL+7fSVsjUhRFUIIoaNF02IIIYSOFoEshBBCR4tAFkIIoaNFIAshhNDRIpCFEELoaBHIwqiRtJqk27PXPyU9XvZ9fMWxn5C0Qo5rXitppyrbzxvtZMSSTh7N+1Xcu6m/V9JOks4c5jlflPTpZpUhhLxi+H1oC0lfBF60/a0a+x8lZSR/psF1rgU+bfuWZpcxr2wirYB5tldsVznardF/0xBaJWpkoa0kvSVLRHtXtpbScpJOIOW9my5penbcOZJuydaN+lKO6w7V1CS9KOnrkmZK+qOknbP9D0s6ODvmKElXSPp9tg7cKWXXOilbq+puSZ/Itm2Yrct1Nmky7fmkDOq3S/ppdsyvsnveI+mYsuu9KOkrku6QNEPSmtn2NSVdnm2/Q9Ju2fYjJN2UXfsH2TI/jX7vq65fcfxdSmuMSdJcSR/Mtv9Y0lsl7aVsPbWspnVB2b/ZCWXX+c/s3+uPwOZl27fL7n1n9pteI+m1kmZm+7eVZEnrZ9//nqcGHkI1EchCOy1PWj/pvbbfQMo0c5ztM0m5Jfe2vXd27H/a3gnYBthT0jbDuM9E4FrbOwLzgS8D+wKHAqeWHbcz8AFgO+DdWfPajqQsFruQ1k/7qKTts+M3By62vb3to4GFtrez/YFs/4eze+4EnCBptbLyzLC9LXAd8NFs+5nAn7PtOwD3SHo98F5gd9vbAQNZGRv93mrXL/cXUpaVrUiZOt6cbZ8CzKhy/BbA27N/o1Mkjcv+bQ4nrWDwTuCNZcdfDHzW9jbAXcAptucAyystC/Nm4BbgzZI2ICVbXtDgd4VQVQSy0E69pIStD2TfLyKte1XNeyTdSkohtBVpwdG8FgG/zz7fRQoWi7PPG5Ydd7XtubYXkpLHvil7XW77JdsvZttLD/1/2K720C85QdIdpMCwHjC5rDyl1aNnlpVhH+AcANsDtl8g5f7bEbhZKaXXW0jLqjT6vdWuX+560r/1Htk936C0yOSz2e+s9Fvbr2RNvXOANUn/DpfbXpCtYDANQNLKwCq2/5ydW/7f9f9IAXQP4KvZ+5uz8oQwIpFrMbTTS3kOkrQR8Gngjbafk/QjUm0ur8Ve0hk8CLwCYHtQaTHFksoOY1N9SZ2SmuWXtBcps/quthdkfXmlMpeXZ4D6/z8UcJHtz9c5plKe618HHA+sD/wnqXZ6GLUDyitln8uvOdxO9utJgWsDUvLaz2bX+E29k0KoJ2pkoZ2WBzaUtGn2/Uig9Ff8fGCl7PMkUtB4Ievv2b9F5dlX0qqSJpBW0f0L6YH/DqXs6BNJD/xaD/vFSkvUAKwMPJcFsS1ITXaNXAMcByCpN2uCuwY4TNJrs+2rZk1xy8T2Y8DqwGTbDwM3kP5YGE7N6DrgUEkTJK0EHJRd+wXgOUmlmmv5f9frgCOAB20PklYzPoD0bx3CiESNLLTTy6T+p//NakY3A+dm+6YCv5P0pO29Jd0G3EPqz2nVQ+8G4MfApsDPSiMhsxrgTdkx59m+TWl160pTgTuzJtAPA8dKuhO4n+r9TpVOBKYqZSkfIPUX3ijpv4CrJPUAi0k1qX+M7Ccu5a+k5l1IAew00r9BLrZvlfQ/wO1ZecqD4IeAc7MBHEPZ8m0/KglSQCO737q2n1uG3xHGuBh+HwJp1CJpuP/H212WEMLwRNNiCCGEjhY1shBCCB0tamQhhBA6WgSyEEIIHS0CWQghhI4WgSyEEEJHi0AWQgiho/1/rhoLVry0nGEAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -489,7 +462,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -503,24 +476,24 @@ "name": "stdout", "output_type": "stream", "text": [ - "Thresholds from null dist were -0.85 and 0.85 with frac passing 0.17135\n", - "Got 639 coords\n", - "After resolving overlaps, got 639 seqlets\n", + "Thresholds from null dist were -0.85 and 0.85 with frac passing 0.17035\n", + "Got 318 coords\n", + "After resolving overlaps, got 318 seqlets\n", "Across all tasks, the weakest transformed threshold used was: 0.8499\n", - "MEMORY 0.652726272\n", - "639 identified in total\n", + "MEMORY 0.158728192\n", + "318 identified in total\n", "1 activity patterns with support >= 100 out of 2 possible patterns\n", - "Metacluster sizes: [597]\n", + "Metacluster sizes: [298]\n", "Idx to activities: {0: '1'}\n", - "MEMORY 0.652726272\n", + "MEMORY 0.158765056\n", "On metacluster 0\n", - "Metacluster size 597\n", + "Metacluster size 298\n", "Relevant tasks: ('task0',)\n", "Relevant signs: (1,)\n", "TfModiscoSeqletsToPatternsFactory: seed=1234\n", - "(Round 1) num seqlets: 597\n", + "(Round 1) num seqlets: 298\n", "(Round 1) Computing coarse affmat\n", - "MEMORY 0.652726272\n", + "MEMORY 0.15878144\n", "Beginning embedding computation\n" ] }, @@ -529,17 +502,15 @@ "output_type": "stream", "text": [ "[Parallel(n_jobs=10)]: Using backend LokyBackend with 10 concurrent workers.\n", - "[Parallel(n_jobs=10)]: Done 30 tasks | elapsed: 4.5s\n", - "[Parallel(n_jobs=10)]: Done 181 tasks | elapsed: 6.5s\n", - "[Parallel(n_jobs=10)]: Done 578 out of 597 | elapsed: 13.1s remaining: 0.4s\n", - "[Parallel(n_jobs=10)]: Done 597 out of 597 | elapsed: 13.5s finished\n", + "[Parallel(n_jobs=10)]: Done 30 tasks | elapsed: 1.6s\n", + "[Parallel(n_jobs=10)]: Done 250 tasks | elapsed: 4.2s\n", + "[Parallel(n_jobs=10)]: Done 279 out of 298 | elapsed: 4.6s remaining: 0.3s\n", + "[Parallel(n_jobs=10)]: Done 298 out of 298 | elapsed: 4.8s finished\n", "[Parallel(n_jobs=10)]: Using backend LokyBackend with 10 concurrent workers.\n", - "[Parallel(n_jobs=10)]: Done 40 tasks | elapsed: 0.7s\n", - "[Parallel(n_jobs=10)]: Done 340 tasks | elapsed: 4.9s\n", - "[Parallel(n_jobs=10)]: Done 578 out of 597 | elapsed: 9.2s remaining: 0.3s\n", - "[Parallel(n_jobs=10)]: Done 597 out of 597 | elapsed: 9.4s finished\n", + "[Parallel(n_jobs=10)]: Done 40 tasks | elapsed: 0.5s\n", + "[Parallel(n_jobs=10)]: Done 298 out of 298 | elapsed: 3.5s finished\n", "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n", - "[Parallel(n_jobs=1)]: Done 597 out of 597 | elapsed: 1.4s finished\n", + "[Parallel(n_jobs=1)]: Done 298 out of 298 | elapsed: 0.7s finished\n", "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n" ] }, @@ -548,23 +519,10 @@ "output_type": "stream", "text": [ "Constructing csr matrix...\n", - "csr matrix made in 0.14378023147583008 s\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Parallel(n_jobs=1)]: Done 597 out of 597 | elapsed: 1.4s finished\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "csr matrix made in 0.06719017028808594 s\n", "Constructing csr matrix...\n", - "csr matrix made in 0.1436150074005127 s\n", - "Finished embedding computation in 26.21 s\n", + "csr matrix made in 0.06815409660339355 s\n", + "Finished embedding computation in 10.03 s\n", "Starting affinity matrix computations\n", "Batching in slices of size 500\n" ] @@ -573,7 +531,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 2/2 [00:01<00:00, 1.11it/s]" + "[Parallel(n_jobs=1)]: Done 298 out of 298 | elapsed: 0.7s finished\n", + "100%|██████████| 1/1 [00:00<00:00, 1.14it/s]" ] }, { @@ -588,22 +547,22 @@ "output_type": "stream", "text": [ "\n", - "100%|██████████| 2/2 [00:01<00:00, 1.15it/s]" + "100%|██████████| 1/1 [00:00<00:00, 1.18it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Finished affinity matrix computations in 3.55 s\n", + "Finished affinity matrix computations in 1.73 s\n", "(Round 1) Compute nearest neighbors from coarse affmat\n", - "MEMORY 0.691224576\n", - "Computed nearest neighbors in 0.03 s\n", - "MEMORY 0.6969344\n", + "MEMORY 0.2899968\n", + "Computed nearest neighbors in 0.02 s\n", + "MEMORY 0.2899968\n", "(Round 1) Computing affinity matrix on nearest neighbors\n", - "MEMORY 0.6969344\n", + "MEMORY 0.2899968\n", "Launching nearest neighbors affmat calculation job\n", - "MEMORY 0.696938496\n" + "MEMORY 0.292048896\n" ] }, { @@ -618,29 +577,29 @@ "output_type": "stream", "text": [ "Parallel runs completed\n", - "MEMORY 0.697053184\n", - "Job completed in: 1.17 s\n", - "MEMORY 0.697053184\n", + "MEMORY 0.309334016\n", + "Job completed in: 1.19 s\n", + "MEMORY 0.309338112\n", "Launching nearest neighbors affmat calculation job\n", - "MEMORY 0.697053184\n", + "MEMORY 0.309338112\n", "Parallel runs completed\n", - "MEMORY 0.697061376\n", - "Job completed in: 1.17 s\n", - "MEMORY 0.697061376\n", - "(Round 1) Computed affinity matrix on nearest neighbors in 2.45 s\n", - "MEMORY 0.697069568\n", - "Filtered down to 422 of 597\n", - "(Round 1) Retained 422 rows out of 597 after filtering\n", - "MEMORY 0.697069568\n", + "MEMORY 0.315056128\n", + "Job completed in: 1.21 s\n", + "MEMORY 0.315056128\n", + "(Round 1) Computed affinity matrix on nearest neighbors in 2.47 s\n", + "MEMORY 0.315056128\n", + "Filtered down to 291 of 298\n", + "(Round 1) Retained 291 rows out of 298 after filtering\n", + "MEMORY 0.315256832\n", "(Round 1) Computing density adapted affmat\n", - "MEMORY 0.697069568\n", + "MEMORY 0.315256832\n", "[t-SNE] Computing 31 nearest neighbors...\n", - "[t-SNE] Indexed 422 samples in 0.000s...\n", - "[t-SNE] Computed neighbors for 422 samples in 0.002s...\n", - "[t-SNE] Computed conditional probabilities for sample 422 / 422\n", - "[t-SNE] Mean sigma: 0.377335\n", + "[t-SNE] Indexed 291 samples in 0.001s...\n", + "[t-SNE] Computed neighbors for 291 samples in 0.002s...\n", + "[t-SNE] Computed conditional probabilities for sample 291 / 291\n", + "[t-SNE] Mean sigma: 0.232271\n", "(Round 1) Computing clustering\n", - "MEMORY 0.69709824\n", + "MEMORY 0.315293696\n", "Beginning preprocessing + Leiden\n" ] }, @@ -656,28 +615,44 @@ "name": "stdout", "output_type": "stream", "text": [ - "Quality: 0.688869450647686\n" + "Quality: 0.6632175729969298\n", + "Quality: 0.6635930382169241\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 50/50 [00:03<00:00, 14.47it/s]" + "\r", + " 6%|▌ | 3/50 [00:00<00:01, 23.65it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Got 11 clusters after round 1\n", + "Quality: 0.6638219820788932\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 50/50 [00:01<00:00, 27.73it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Got 5 clusters after round 1\n", "Counts:\n", - "{7: 7, 4: 53, 3: 65, 1: 72, 5: 37, 0: 80, 2: 66, 9: 3, 8: 5, 6: 32, 10: 2}\n", - "MEMORY 0.697397248\n", + "{4: 17, 0: 79, 2: 67, 1: 79, 3: 49}\n", + "MEMORY 0.31578112\n", "(Round 1) Aggregating seqlets in each cluster\n", - "MEMORY 0.697397248\n", - "Aggregating for cluster 0 with 80 seqlets\n", - "MEMORY 0.697397248\n" + "MEMORY 0.31578112\n", + "Aggregating for cluster 0 with 79 seqlets\n", + "MEMORY 0.31578112\n" ] }, { @@ -691,50 +666,29 @@ "name": "stdout", "output_type": "stream", "text": [ - "Trimming eliminated 0 seqlets out of 80\n", - "Skipped 5 seqlets\n", - "Skipped 1 seqlets\n", - "Aggregating for cluster 1 with 72 seqlets\n", - "MEMORY 0.697397248\n", - "Trimming eliminated 0 seqlets out of 72\n", - "Skipped 10 seqlets\n", - "Removed 3 duplicate seqlets\n", - "Aggregating for cluster 2 with 66 seqlets\n", - "MEMORY 0.697397248\n", - "Trimming eliminated 0 seqlets out of 66\n", - "Skipped 3 seqlets\n", - "Aggregating for cluster 3 with 65 seqlets\n", - "MEMORY 0.697397248\n", - "Trimming eliminated 0 seqlets out of 65\n", - "Skipped 11 seqlets\n", - "Aggregating for cluster 4 with 53 seqlets\n", - "MEMORY 0.697397248\n", - "Trimming eliminated 0 seqlets out of 53\n", + "Trimming eliminated 0 seqlets out of 79\n", + "Skipped 16 seqlets\n", + "Aggregating for cluster 1 with 79 seqlets\n", + "MEMORY 0.31578112\n", + "Trimming eliminated 0 seqlets out of 79\n", + "Skipped 7 seqlets\n", + "Aggregating for cluster 2 with 67 seqlets\n", + "MEMORY 0.315789312\n", + "Trimming eliminated 0 seqlets out of 67\n", "Skipped 8 seqlets\n", - "Removed 4 duplicate seqlets\n", - "Aggregating for cluster 5 with 37 seqlets\n", - "MEMORY 0.697397248\n", - "Trimming eliminated 0 seqlets out of 37\n", + "Removed 1 duplicate seqlets\n", + "Aggregating for cluster 3 with 49 seqlets\n", + "MEMORY 0.315789312\n", + "Trimming eliminated 0 seqlets out of 49\n", + "Skipped 3 seqlets\n", + "Removed 1 duplicate seqlets\n", + "Aggregating for cluster 4 with 17 seqlets\n", + "MEMORY 0.315789312\n", + "Trimming eliminated 0 seqlets out of 17\n", "Skipped 1 seqlets\n", - "Aggregating for cluster 6 with 32 seqlets\n", - "MEMORY 0.697397248\n", - "Trimming eliminated 0 seqlets out of 32\n", - "Skipped 5 seqlets\n", - "Aggregating for cluster 7 with 7 seqlets\n", - "MEMORY 0.697397248\n", - "Trimming eliminated 0 seqlets out of 7\n", - "Aggregating for cluster 8 with 5 seqlets\n", - "MEMORY 0.697397248\n", - "Trimming eliminated 0 seqlets out of 5\n", - "Aggregating for cluster 9 with 3 seqlets\n", - "MEMORY 0.697397248\n", - "Trimming eliminated 0 seqlets out of 3\n", - "Aggregating for cluster 10 with 2 seqlets\n", - "MEMORY 0.697397248\n", - "Trimming eliminated 0 seqlets out of 2\n", - "(Round 2) num seqlets: 312\n", + "(Round 2) num seqlets: 223\n", "(Round 2) Computing coarse affmat\n", - "MEMORY 0.697397248\n", + "MEMORY 0.315789312\n", "Beginning embedding computation\n" ] }, @@ -743,15 +697,15 @@ "output_type": "stream", "text": [ "[Parallel(n_jobs=10)]: Using backend LokyBackend with 10 concurrent workers.\n", - "[Parallel(n_jobs=10)]: Done 40 tasks | elapsed: 1.1s\n", - "[Parallel(n_jobs=10)]: Done 293 out of 312 | elapsed: 7.0s remaining: 0.5s\n", - "[Parallel(n_jobs=10)]: Done 312 out of 312 | elapsed: 7.3s finished\n", + "[Parallel(n_jobs=10)]: Done 40 tasks | elapsed: 1.0s\n", + "[Parallel(n_jobs=10)]: Done 204 out of 223 | elapsed: 4.4s remaining: 0.4s\n", + "[Parallel(n_jobs=10)]: Done 223 out of 223 | elapsed: 4.6s finished\n", "[Parallel(n_jobs=10)]: Using backend LokyBackend with 10 concurrent workers.\n", - "[Parallel(n_jobs=10)]: Done 40 tasks | elapsed: 1.2s\n", - "[Parallel(n_jobs=10)]: Done 293 out of 312 | elapsed: 6.9s remaining: 0.4s\n", - "[Parallel(n_jobs=10)]: Done 312 out of 312 | elapsed: 7.3s finished\n", + "[Parallel(n_jobs=10)]: Done 40 tasks | elapsed: 0.8s\n", + "[Parallel(n_jobs=10)]: Done 204 out of 223 | elapsed: 4.0s remaining: 0.4s\n", + "[Parallel(n_jobs=10)]: Done 223 out of 223 | elapsed: 4.3s finished\n", "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n", - "[Parallel(n_jobs=1)]: Done 312 out of 312 | elapsed: 0.8s finished\n", + "[Parallel(n_jobs=1)]: Done 223 out of 223 | elapsed: 0.6s finished\n", "[Parallel(n_jobs=1)]: Using backend SequentialBackend with 1 concurrent workers.\n" ] }, @@ -760,10 +714,10 @@ "output_type": "stream", "text": [ "Constructing csr matrix...\n", - "csr matrix made in 0.06708884239196777 s\n", + "csr matrix made in 0.05225801467895508 s\n", "Constructing csr matrix...\n", - "csr matrix made in 0.06825685501098633 s\n", - "Finished embedding computation in 16.3 s\n", + "csr matrix made in 0.04984688758850098 s\n", + "Finished embedding computation in 10.23 s\n", "Starting affinity matrix computations\n", "Batching in slices of size 500\n" ] @@ -772,8 +726,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "[Parallel(n_jobs=1)]: Done 312 out of 312 | elapsed: 0.8s finished\n", - "100%|██████████| 1/1 [00:00<00:00, 1.11it/s]" + "[Parallel(n_jobs=1)]: Done 223 out of 223 | elapsed: 0.6s finished\n", + "100%|██████████| 1/1 [00:00<00:00, 1.15it/s]" ] }, { @@ -795,15 +749,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "Finished affinity matrix computations in 1.78 s\n", + "Finished affinity matrix computations in 1.74 s\n", "(Round 2) Compute nearest neighbors from coarse affmat\n", - "MEMORY 0.697454592\n", - "Computed nearest neighbors in 0.01 s\n", - "MEMORY 0.697454592\n", + "MEMORY 0.319156224\n", + "Computed nearest neighbors in 0.02 s\n", + "MEMORY 0.319156224\n", "(Round 2) Computing affinity matrix on nearest neighbors\n", - "MEMORY 0.697454592\n", + "MEMORY 0.319156224\n", "Launching nearest neighbors affmat calculation job\n", - "MEMORY 0.697909248\n" + "MEMORY 0.319156224\n" ] }, { @@ -818,28 +772,28 @@ "output_type": "stream", "text": [ "Parallel runs completed\n", - "MEMORY 0.697909248\n", - "Job completed in: 0.74 s\n", - "MEMORY 0.697909248\n", + "MEMORY 0.31922176\n", + "Job completed in: 0.72 s\n", + "MEMORY 0.31922176\n", "Launching nearest neighbors affmat calculation job\n", - "MEMORY 0.697909248\n", + "MEMORY 0.31922176\n", "Parallel runs completed\n", - "MEMORY 0.697909248\n", - "Job completed in: 0.6 s\n", - "MEMORY 0.697909248\n", - "(Round 2) Computed affinity matrix on nearest neighbors in 1.4 s\n", - "MEMORY 0.697909248\n", + "MEMORY 0.319250432\n", + "Job completed in: 0.63 s\n", + "MEMORY 0.319250432\n", + "(Round 2) Computed affinity matrix on nearest neighbors in 1.41 s\n", + "MEMORY 0.319250432\n", "Not applying filtering for rounds above first round\n", - "MEMORY 0.697909248\n", + "MEMORY 0.319250432\n", "(Round 2) Computing density adapted affmat\n", - "MEMORY 0.697909248\n", + "MEMORY 0.319250432\n", "[t-SNE] Computing 31 nearest neighbors...\n", - "[t-SNE] Indexed 312 samples in 0.000s...\n", - "[t-SNE] Computed neighbors for 312 samples in 0.003s...\n", - "[t-SNE] Computed conditional probabilities for sample 312 / 312\n", - "[t-SNE] Mean sigma: 0.419007\n", + "[t-SNE] Indexed 223 samples in 0.000s...\n", + "[t-SNE] Computed neighbors for 223 samples in 0.002s...\n", + "[t-SNE] Computed conditional probabilities for sample 223 / 223\n", + "[t-SNE] Mean sigma: 0.279836\n", "(Round 2) Computing clustering\n", - "MEMORY 0.697909248\n", + "MEMORY 0.319250432\n", "Beginning preprocessing + Leiden\n" ] }, @@ -855,28 +809,29 @@ "name": "stdout", "output_type": "stream", "text": [ - "Quality: 0.6519505308172979\n" + "Quality: 0.599614126588206\n", + "Quality: 0.5999271629421645\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 50/50 [00:02<00:00, 21.77it/s]" + "100%|██████████| 50/50 [00:01<00:00, 27.62it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Got 15 clusters after round 2\n", + "Got 10 clusters after round 2\n", "Counts:\n", - "{0: 82, 8: 9, 5: 27, 14: 2, 13: 2, 1: 34, 2: 32, 7: 20, 6: 21, 9: 7, 11: 6, 4: 27, 10: 7, 3: 31, 12: 5}\n", - "MEMORY 0.697909248\n", + "{2: 27, 1: 28, 4: 26, 6: 9, 3: 27, 5: 17, 9: 2, 7: 5, 0: 79, 8: 3}\n", + "MEMORY 0.31950848\n", "(Round 2) Aggregating seqlets in each cluster\n", - "MEMORY 0.697909248\n", - "Aggregating for cluster 0 with 82 seqlets\n", - "MEMORY 0.697909248\n" + "MEMORY 0.31950848\n", + "Aggregating for cluster 0 with 79 seqlets\n", + "MEMORY 0.31950848\n" ] }, { @@ -890,196 +845,140 @@ "name": "stdout", "output_type": "stream", "text": [ - "Trimming eliminated 0 seqlets out of 82\n", - "Skipped 1 seqlets\n", - "Aggregating for cluster 1 with 34 seqlets\n", - "MEMORY 0.697909248\n", - "Trimming eliminated 0 seqlets out of 34\n", - "Removed 5 duplicate seqlets\n", - "Aggregating for cluster 2 with 32 seqlets\n", - "MEMORY 0.697909248\n", - "Trimming eliminated 0 seqlets out of 32\n", - "Removed 10 duplicate seqlets\n", - "Aggregating for cluster 3 with 31 seqlets\n", - "MEMORY 0.697909248\n", - "Trimming eliminated 0 seqlets out of 31\n", - "Skipped 1 seqlets\n", - "Aggregating for cluster 4 with 27 seqlets\n", - "MEMORY 0.697909248\n", + "Trimming eliminated 0 seqlets out of 79\n", + "Aggregating for cluster 1 with 28 seqlets\n", + "MEMORY 0.31950848\n", + "Trimming eliminated 0 seqlets out of 28\n", + "Removed 7 duplicate seqlets\n", + "Aggregating for cluster 2 with 27 seqlets\n", + "MEMORY 0.31950848\n", "Trimming eliminated 0 seqlets out of 27\n", - "Aggregating for cluster 5 with 27 seqlets\n", - "MEMORY 0.697909248\n", + "Removed 8 duplicate seqlets\n", + "Aggregating for cluster 3 with 27 seqlets\n", + "MEMORY 0.31950848\n", "Trimming eliminated 0 seqlets out of 27\n", - "Aggregating for cluster 6 with 21 seqlets\n", - "MEMORY 0.697909248\n", - "Trimming eliminated 0 seqlets out of 21\n", - "Removed 5 duplicate seqlets\n", - "Aggregating for cluster 7 with 20 seqlets\n", - "MEMORY 0.697909248\n", - "Trimming eliminated 0 seqlets out of 20\n", - "Removed 5 duplicate seqlets\n", - "Aggregating for cluster 8 with 9 seqlets\n", - "MEMORY 0.697909248\n", + "Removed 10 duplicate seqlets\n", + "Aggregating for cluster 4 with 26 seqlets\n", + "MEMORY 0.31950848\n", + "Trimming eliminated 0 seqlets out of 26\n", + "Removed 11 duplicate seqlets\n", + "Aggregating for cluster 5 with 17 seqlets\n", + "MEMORY 0.31950848\n", + "Trimming eliminated 0 seqlets out of 17\n", + "Removed 6 duplicate seqlets\n", + "Aggregating for cluster 6 with 9 seqlets\n", + "MEMORY 0.31950848\n", "Trimming eliminated 0 seqlets out of 9\n", - "Aggregating for cluster 9 with 7 seqlets\n", - "MEMORY 0.697909248\n", - "Trimming eliminated 0 seqlets out of 7\n", - "Removed 2 duplicate seqlets\n", - "Aggregating for cluster 10 with 7 seqlets\n", - "MEMORY 0.697909248\n", - "Trimming eliminated 0 seqlets out of 7\n", - "Removed 1 duplicate seqlets\n", - "Aggregating for cluster 11 with 6 seqlets\n", - "MEMORY 0.697909248\n", - "Trimming eliminated 0 seqlets out of 6\n", - "Removed 1 duplicate seqlets\n", - "Aggregating for cluster 12 with 5 seqlets\n", - "MEMORY 0.697909248\n", + "Removed 4 duplicate seqlets\n", + "Aggregating for cluster 7 with 5 seqlets\n", + "MEMORY 0.31950848\n", "Trimming eliminated 0 seqlets out of 5\n", - "Aggregating for cluster 13 with 2 seqlets\n", - "MEMORY 0.697909248\n", - "Trimming eliminated 0 seqlets out of 2\n", - "Aggregating for cluster 14 with 2 seqlets\n", - "MEMORY 0.697909248\n", + "Removed 1 duplicate seqlets\n", + "Aggregating for cluster 8 with 3 seqlets\n", + "MEMORY 0.31950848\n", + "Trimming eliminated 0 seqlets out of 3\n", + "Aggregating for cluster 9 with 2 seqlets\n", + "MEMORY 0.31950848\n", "Trimming eliminated 0 seqlets out of 2\n", - "Dropping cluster 14 with 2 seqlets due to sign disagreement\n", - "Got 14 clusters\n", + "Removed 1 duplicate seqlets\n", + "Got 10 clusters\n", "Splitting into subclusters...\n", - "MEMORY 0.697909248\n", + "MEMORY 0.31950848\n", "Inspecting for spurious merging\n", - "Wrote graph to binary file in 0.011699914932250977 seconds\n", + "Wrote graph to binary file in 0.008906364440917969 seconds\n", "Running Louvain modularity optimization\n", - "After 1 runs, maximum modularity is Q = 0.00527286\n", - "Louvain completed 21 runs in 0.23298096656799316 seconds\n", - "Similarity is 0.9545029; is_dissimilar is False\n", - "Merging on 14 clusters\n", - "MEMORY 0.697991168\n", + "After 1 runs, maximum modularity is Q = 0.00251289\n", + "After 6 runs, maximum modularity is Q = 0.00269466\n", + "After 9 runs, maximum modularity is Q = 0.00275705\n", + "Louvain completed 29 runs in 0.24180197715759277 seconds\n", + "Similarity is 0.95880765; is_dissimilar is False\n", + "Merging on 10 clusters\n", + "MEMORY 0.3195904\n", "On merging iteration 1\n", - "Numbers for each pattern pre-subsample: [81, 29, 22, 30, 27, 27, 16, 15, 9, 5, 6, 5, 5, 2]\n", - "Numbers after subsampling: [81, 29, 22, 30, 27, 27, 16, 15, 9, 5, 6, 5, 5, 2]\n", - "Applying left/right pad of 2 and 0 for (67, -2, 23) with total sequence length 200\n", - "Applying left/right pad of 2 and 0 for (67, -2, 23) with total sequence length 200\n", - "Applying left/right pad of 0 and 2 for (66, 177, 202) with total sequence length 200\n", - "Applying left/right pad of 0 and 2 for (66, 177, 202) with total sequence length 200\n", - "Applying left/right pad of 0 and 2 for (26, 177, 202) with total sequence length 200\n", - "Applying left/right pad of 0 and 2 for (26, 177, 202) with total sequence length 200\n", - "Applying left/right pad of 1 and 0 for (190, -1, 24) with total sequence length 200\n", - "Applying left/right pad of 1 and 0 for (190, -1, 24) with total sequence length 200\n", - "Applying left/right pad of 0 and 1 for (191, 176, 201) with total sequence length 200\n", - "Applying left/right pad of 0 and 1 for (191, 176, 201) with total sequence length 200\n", - "Applying left/right pad of 0 and 4 for (26, 179, 204) with total sequence length 200\n", - "Applying left/right pad of 0 and 4 for (26, 179, 204) with total sequence length 200\n", + "Numbers for each pattern pre-subsample: [79, 21, 19, 17, 15, 11, 5, 4, 3, 1]\n", + "Numbers after subsampling: [79, 21, 19, 17, 15, 11, 5, 4, 3, 1]\n", + "Applying left/right pad of 3 and 0 for (95, -3, 22) with total sequence length 200\n", + "Applying left/right pad of 3 and 0 for (95, -3, 22) with total sequence length 200\n", + "Applying left/right pad of 2 and 0 for (95, -2, 23) with total sequence length 200\n", + "Applying left/right pad of 2 and 0 for (95, -2, 23) with total sequence length 200\n", "Cluster sizes\n", - "[81 29 22 30 27 27 16 15 9 5 6 5 5 2]\n", + "[79 21 19 17 15 11 5 4 3 1]\n", "Cross-contamination matrix:\n", - "[[1. 0.01 0.02 0.03 0.02 0.59 0.02 0.01 0.38 0.08 0.01 0.01 0.36 0. ]\n", - " [0. 1. 0.76 0.57 0.83 0. 0.72 0.77 0. 0.38 0.46 0.31 0. 0. ]\n", - " [0. 0.67 1. 0.52 0.79 0. 0.71 0.65 0. 0.3 0.3 0.28 0. 0. ]\n", - " [0.01 0.59 0.66 1. 0.9 0.01 0.67 0.46 0. 0.29 0.43 0.14 0. 0. ]\n", - " [0. 0.6 0.68 0.58 1. 0. 0.49 0.56 0. 0.15 0.31 0.27 0. 0. ]\n", - " [0.92 0.1 0.15 0.2 0.17 1. 0.13 0.07 0.56 0.29 0.08 0.04 0.55 0.01]\n", - " [0.01 0.75 0.78 0.68 0.77 0.01 1. 0.61 0. 0.46 0.51 0.24 0. 0. ]\n", - " [0. 0.81 0.8 0.42 0.82 0. 0.63 1. 0. 0.4 0.36 0.39 0. 0. ]\n", - " [0.83 0. 0. 0. 0. 0.68 0.01 0. 1. 0.18 0. 0. 0.54 0. ]\n", - " [0. 0.28 0.24 0.18 0.19 0. 0.23 0.3 0. 1. 0.25 0.03 0. 0. ]\n", - " [0.1 0.8 0.71 0.71 0.87 0.09 0.76 0.63 0. 0.69 1. 0.53 0. 0. ]\n", - " [0.1 0.54 0.57 0.51 0.65 0.04 0.51 0.56 0.1 0.51 0.55 1. 0. 0. ]\n", - " [0.38 0. 0. 0. 0. 0.15 0. 0. 0.31 0. 0. 0. 1. 0. ]\n", - " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1. ]]\n", + "[[1. 0.05 0.07 0.1 0.04 0.03 0.42 0.06 0.21 0. ]\n", + " [0.04 1. 0.81 0.71 0.91 0.86 0.3 0.78 0.01 0. ]\n", + " [0.07 0.81 1. 0.76 0.86 0.78 0.35 0.74 0.01 0. ]\n", + " [0.15 0.66 0.68 1. 0.64 0.46 0.28 0.71 0.12 0.05]\n", + " [0. 0.68 0.63 0.5 1. 0.62 0.25 0.53 0.03 0. ]\n", + " [0. 0.66 0.57 0.31 0.66 1. 0.15 0.4 0. 0. ]\n", + " [0.81 0.73 0.73 0.71 0.75 0.73 1. 0.76 0.76 0. ]\n", + " [0. 0.46 0.38 0.42 0.4 0.31 0.07 1. 0. 0. ]\n", + " [0.01 0. 0. 0. 0. 0. 0. 0. 1. 0. ]\n", + " [0. 0. 0. 0. 0. 0. 0. 0. 0. 1. ]]\n", "Pattern-to-pattern sim matrix:\n", - "[[1. 0.41 0.5 0.53 0.52 0.97 0.48 0.43 0.76 0.64 0.39 0.32 0.86 0.43]\n", - " [0.41 1. 0.96 0.92 0.94 0.45 0.95 0.96 0.27 0.79 0.89 0.79 0.36 0.53]\n", - " [0.5 0.96 1. 0.93 0.98 0.55 0.96 0.96 0.35 0.82 0.88 0.81 0.47 0.48]\n", - " [0.53 0.92 0.93 1. 0.95 0.57 0.94 0.92 0.32 0.81 0.89 0.77 0.36 0.44]\n", - " [0.52 0.94 0.98 0.95 1. 0.57 0.95 0.95 0.36 0.82 0.89 0.82 0.49 0.35]\n", - " [0.97 0.45 0.55 0.57 0.57 1. 0.53 0.46 0.73 0.64 0.45 0.34 0.87 0.37]\n", - " [0.48 0.95 0.96 0.94 0.95 0.53 1. 0.96 0.31 0.83 0.88 0.8 0.46 0.41]\n", - " [0.43 0.96 0.96 0.92 0.95 0.46 0.96 1. 0.31 0.83 0.82 0.79 0.38 0.37]\n", - " [0.76 0.31 0.4 0.38 0.43 0.75 0.37 0.38 1. 0.62 0.31 0.28 0.82 0.36]\n", - " [0.65 0.79 0.82 0.81 0.82 0.64 0.83 0.83 0.52 1. 0.74 0.65 0.64 0.25]\n", - " [0.39 0.89 0.88 0.89 0.89 0.45 0.88 0.82 0.25 0.74 1. 0.74 0.39 0.34]\n", - " [0.33 0.81 0.83 0.81 0.86 0.34 0.8 0.83 0.24 0.68 0.76 1. 0.3 0.38]\n", - " [0.87 0.36 0.47 0.37 0.49 0.87 0.47 0.38 0.67 0.64 0.39 0.3 1. 0.26]\n", - " [0.43 0.52 0.47 0.43 0.34 0.36 0.41 0.36 0.36 0.25 0.34 0.37 0.21 1. ]]\n", - "Collapsing 2 & 4 with crosscontam 0.7327535788605521 and sim 0.9806707889498065\n", - "Collapsing 0 & 5 with crosscontam 0.754703337334335 and sim 0.972143568744242\n", - "Collapsing 2 & 6 with crosscontam 0.7445393941350488 and sim 0.9629436064663591\n", - "Collapsing 2 & 7 with crosscontam 0.7248288950107131 and sim 0.9620860103578344\n", - "Collapsing 1 & 2 with crosscontam 0.7177318856935632 and sim 0.9604115788663822\n", - "Collapsing 1 & 7 with crosscontam 0.7890357128213539 and sim 0.9601625874139877\n", - "Collapsing 6 & 7 with crosscontam 0.6165626446759259 and sim 0.9554056919477923\n", - "Collapsing 4 & 7 with crosscontam 0.6914431065725077 and sim 0.9531991480992275\n", - "Collapsing 1 & 6 with crosscontam 0.7352907400621183 and sim 0.9512422992114119\n", - "Collapsing 4 & 6 with crosscontam 0.6306834915440991 and sim 0.9508054157058776\n", - "Collapsing 3 & 4 with crosscontam 0.7388049585937103 and sim 0.9486001776329169\n", - "Collapsing 3 & 6 with crosscontam 0.6760044849537039 and sim 0.942734559632384\n", - "Collapsing 1 & 4 with crosscontam 0.7135372958534933 and sim 0.9385523627154476\n", - "Collapsing 2 & 3 with crosscontam 0.5912197178395526 and sim 0.9345569563677238\n", - "Collapsing 1 & 3 with crosscontam 0.5785619291028288 and sim 0.9221598249497504\n", - "Collapsing 3 & 7 with crosscontam 0.43757530864197536 and sim 0.9155317791319294\n", - "Collapsing 1 & 10 with crosscontam 0.6294629637222608 and sim 0.8939540821579719\n", - "Collapsing 3 & 10 with crosscontam 0.5703703703703704 and sim 0.891171883366082\n", - "Collapsing 4 & 10 with crosscontam 0.5890743281003912 and sim 0.8868214772937173\n", - "Collapsing 6 & 10 with crosscontam 0.6363841869212963 and sim 0.8844289295342134\n", - "Collapsing 2 & 10 with crosscontam 0.5080627208726383 and sim 0.8823080558455356\n", - "Trimming eliminated 0 seqlets out of 49\n", - "Skipped 2 seqlets\n", - "Trimming eliminated 0 seqlets out of 108\n", - "Trimming eliminated 0 seqlets out of 63\n", - "Skipped 1 seqlets\n", - "Trimming eliminated 0 seqlets out of 77\n", - "Trimming eliminated 0 seqlets out of 106\n", - "Trimming eliminated 0 seqlets out of 136\n", - "Trimming eliminated 0 seqlets out of 142\n", - "Unmerged patterns remapping: OrderedDict([(8, 2), (9, 3), (11, 4), (12, 5), (13, 6)])\n", - "Time spent on merging iteration: 9.631079196929932\n", + "[[1. 0.52 0.52 0.55 0.43 0.4 0.76 0.52 0.55 0.38]\n", + " [0.52 1. 0.98 0.94 0.96 0.95 0.73 0.93 0.27 0.22]\n", + " [0.52 0.98 1. 0.96 0.97 0.94 0.72 0.93 0.23 0.08]\n", + " [0.55 0.94 0.96 1. 0.94 0.88 0.75 0.92 0.4 0.33]\n", + " [0.43 0.96 0.97 0.94 1. 0.95 0.7 0.88 0.47 0.36]\n", + " [0.41 0.95 0.94 0.88 0.95 1. 0.72 0.89 0.21 0.12]\n", + " [0.76 0.73 0.72 0.75 0.7 0.73 1. 0.75 0.48 0.17]\n", + " [0.52 0.93 0.92 0.92 0.88 0.88 0.75 1. 0.24 0.02]\n", + " [0.56 0.41 0.34 0.38 0.44 0.34 0.63 0.35 1. 0.37]\n", + " [0.38 0.22 0.08 0.33 0.35 0.12 0.17 0.1 0.34 1. ]]\n", + "Collapsing 1 & 2 with crosscontam 0.8067035069662333 and sim 0.9757491842728849\n", + "Collapsing 2 & 4 with crosscontam 0.7408654970760233 and sim 0.9724332025550532\n", + "Collapsing 2 & 3 with crosscontam 0.717632808832573 and sim 0.9632570615993168\n", + "Collapsing 1 & 4 with crosscontam 0.7936202713889788 and sim 0.9597049218621097\n", + "Collapsing 1 & 5 with crosscontam 0.7625065601115525 and sim 0.9517267756916664\n", + "Collapsing 4 & 5 with crosscontam 0.637462225561399 and sim 0.9471994580389731\n", + "Collapsing 2 & 5 with crosscontam 0.6766716370940297 and sim 0.9447518005681776\n", + "Collapsing 3 & 4 with crosscontam 0.5724439619754091 and sim 0.9405814815511968\n", + "Collapsing 1 & 3 with crosscontam 0.6883880591287429 and sim 0.9405349531105659\n", + "Collapsing 1 & 7 with crosscontam 0.6237852283770652 and sim 0.9277588858228016\n", + "Collapsing 2 & 7 with crosscontam 0.5620216139378916 and sim 0.9251655433878759\n", + "Collapsing 3 & 7 with crosscontam 0.5660619784245877 and sim 0.9203135085395104\n", + "Trimming eliminated 0 seqlets out of 40\n", + "Trimming eliminated 0 seqlets out of 55\n", + "Trimming eliminated 0 seqlets out of 72\n", + "Trimming eliminated 0 seqlets out of 83\n", + "Trimming eliminated 0 seqlets out of 87\n", + "Unmerged patterns remapping: OrderedDict([(0, 1), (6, 2), (8, 3), (9, 4)])\n", + "Time spent on merging iteration: 3.8640291690826416\n", "On merging iteration 2\n", - "Numbers for each pattern pre-subsample: [142, 108, 9, 5, 5, 5, 2]\n", - "Numbers after subsampling: [142, 108, 9, 5, 5, 5, 2]\n", - "Applying left/right pad of 1 and 0 for (190, -1, 24) with total sequence length 200\n", - "Applying left/right pad of 1 and 0 for (190, -1, 24) with total sequence length 200\n", - "Applying left/right pad of 0 and 1 for (191, 176, 201) with total sequence length 200\n", - "Applying left/right pad of 0 and 1 for (191, 176, 201) with total sequence length 200\n", + "Numbers for each pattern pre-subsample: [87, 79, 5, 3, 1]\n", + "Numbers after subsampling: [87, 79, 5, 3, 1]\n", "Cluster sizes\n", - "[142 108 9 5 5 5 2]\n", + "[87 79 5 3 1]\n", "Cross-contamination matrix:\n", - "[[1. 0.02 0. 0.52 0.45 0.01 0. ]\n", - " [0.05 1. 0.47 0.15 0.02 0.47 0.01]\n", - " [0. 0.8 1. 0.18 0. 0.54 0. ]\n", - " [0.23 0. 0. 1. 0.03 0. 0. ]\n", - " [0.56 0.09 0.1 0.51 1. 0. 0. ]\n", - " [0. 0.32 0.31 0. 0. 1. 0. ]\n", - " [0. 0. 0. 0. 0. 0. 1. ]]\n", + "[[1. 0.07 0.39 0.01 0. ]\n", + " [0.06 1. 0.42 0.21 0. ]\n", + " [0.73 0.81 1. 0.76 0. ]\n", + " [0. 0.01 0. 1. 0. ]\n", + " [0. 0. 0. 0. 1. ]]\n", "Pattern-to-pattern sim matrix:\n", - "[[1. 0.49 0.31 0.83 0.81 0.44 0.4 ]\n", - " [0.49 1. 0.76 0.65 0.32 0.87 0.42]\n", - " [0.37 0.76 1. 0.62 0.28 0.82 0.36]\n", - " [0.83 0.65 0.52 1. 0.65 0.64 0.25]\n", - " [0.83 0.34 0.24 0.68 1. 0.3 0.38]\n", - " [0.45 0.87 0.67 0.64 0.3 1. 0.26]\n", - " [0.39 0.42 0.36 0.25 0.37 0.21 1. ]]\n", - "Got 7 patterns after merging\n", - "MEMORY 0.699150336\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "[[1. 0.5 0.74 0.23 0.05]\n", + " [0.5 1. 0.76 0.55 0.38]\n", + " [0.74 0.76 1. 0.48 0.17]\n", + " [0.34 0.56 0.63 1. 0.37]\n", + " [0.07 0.38 0.17 0.34 1. ]]\n", + "Got 5 patterns after merging\n", + "MEMORY 0.319868928\n", "Performing seqlet reassignment\n", - "MEMORY 0.699150336\n", + "MEMORY 0.319868928\n", "Cross contin jaccard time taken: 0.01 s\n", "Cross contin jaccard time taken: 0.01 s\n", - "Discarded 7 seqlets\n", - "Skipped 4 seqlets\n", - "Skipped 9 seqlets\n", - "Skipped 3 seqlets\n", - "Skipped 9 seqlets\n", + "Discarded 1 seqlets\n", + "Skipped 1 seqlets\n", + "Skipped 1 seqlets\n", + "Removed 1 duplicate seqlets\n", + "Skipped 6 seqlets\n", + "Skipped 1 seqlets\n", + "Skipped 7 seqlets\n", "Skipped 2 seqlets\n", "Got 2 patterns after reassignment\n", - "MEMORY 0.699334656\n", - "Total time taken is 71.67s\n", - "MEMORY 0.699334656\n" + "MEMORY 0.319868928\n", + "Total time taken is 37.6s\n", + "MEMORY 0.319868928\n" ] } ], @@ -1111,10 +1010,8 @@ " # max_num_seqlets_to_use=10000, nmotifs=10, n_jobs=1),\n", " \n", " embedder_factory=(modisco.seqlet_embedding\n", - " .advanced_gapped_kmer.AdvancedGappedKmerEmbedderFactory()),\n", + " .advanced_gapped_kmer.AdvancedGappedKmerEmbedderFactory(max_entries=500)),\n", " \n", - " nearest_neighbors_to_compute=50,\n", - " \n", " trim_to_window_size=15,\n", " initial_flank_to_add=5,\n", " #kmer_len=5, num_gaps=1,\n", @@ -1140,7 +1037,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 6, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -1173,7 +1070,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 7, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -1194,7 +1091,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXUAAAD8CAYAAACINTRsAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3de7wdVX338c/3nIRbKkXlflGwRCpgjIhBXyj3YKBKRAVBS6O2Riz0UVuVUB652PJ6KKgUK+UiRlERRDGVBwIh0geoWiSABHPhEihKSAQBQQNCknN+zx+zNk5O9j5n9p7Z5+y9z/fta17ZM7NmZm1evn57nTVr/ZYiAjMz6w19Y10BMzOrjoO6mVkPcVA3M+shDupmZj3EQd3MrIc4qJuZ9ZC2BXVJMyTdL2mFpDnteo6Z2ViSNFfSE5KWNDgvSV9OsfBeSfvkzlUeJ9sS1CX1AxcCRwB7AsdL2rMdzzIzG2PfAGYMc/4IYHLaZgMXQfviZLta6tOAFRHxcESsBa4CZrbpWWZmYyYibgOeHqbITOCbkbkd2ErSDrQpTk4oe4MGdgIeze2vBPZrVPg/f73C01rNrJBDtt9dpW+y9JrCMUd7v+9jZC3smksj4tImnlYvHu7U4HjDOFlUu1rq9f6jb/AfUdJsSXdKuvO6b13VpmqYmZUTEZdGxL65rZmADo3j4YhxshXtaqmvBHbJ7e8MrMoXSP9hLgW31M1sdMXAQOGy5f8saBgPN2lwvJR2BfVFwGRJuwGPAccBH2jTs8zMmhLrXihctoKgfi1wsqSryLpXno2I1ZJ+QxviZFuCekSsl3QysADoB+ZGxNJ2PMvMrGlNtNRHIulK4CBga0krgTOAiQARcTEwHzgSWAE8D3w4nWtLnGxXS52ImE/2ZczMOkoMrK/uXhHHj3A+gJManKs8TrYtqJuZdawKg3qncVA3s3EnBns3qLc8pFHSZpLukLRY0lJJZ6Xjx6T9QUn7VldVM7OKDAwU37pMmZb6i8AhEbFG0kTgx5JuAJYA7wEuqaKCZmZVi7XFR790m5aDeur8X5N2J6YtImI5gFTBQCAzszaIwe5rgRdVakappH5J9wBPAAsj4mdNXOsZpWY2JmJgfeGt25R6URoRA8BUSVsB8yTtHRF100/WudYzSs1sbHRhsC6qktEvEfGMpFvI0k8WCupmZmOll7tfWg7qkrYB1qWAvjlwGPAvrdzrkKcWt1oNMxtvtt+99C38orS+HYDLU6L3PuDqiLhO0tHAvwHbANdLuici3lFBXc3MquHul41FxL3AG+scnwfMK1MpM7N2cveLmVkvcUu9vjTq5TJgb7Lk7h8hm3j0LmAt8BDw4Yh4pmQ9zcwq00w+9W5TduWjC4AbI+LPgTcAy4GFwN4RMQV4ADi15DPMzCrlcep1SNoSOAD4EEBaOHUtcFOu2O3A+0rUz8yscrHuxbGuQtuUaam/BvgN8HVJP5d0maRJQ8p8BLihxDPMzKrXwwm9ygT1CcA+wEUR8UbgOWBO7aSk04D1wBX1Ls6nCbj0ewtLVMPMrDnufqlvJbAyl+/l+6SgLmkW8E7g0JT4ayP5NAEsvcZpAsxs9HRhC7yollvqEfFr4FFJe6RDhwLLJM0ATgGOiojnK6ijmVmlYmCg8DYSSTMk3S9phaQ5dc5/RtI9aVsiaUDSK9K5RyT9Ip27s4rvVnac+t8BV0jaBHiYbEHVRcCmwMKUfvf2iDix5HPMzCoT69ZWcp80o/5CYDpZ78UiSddGxLKXnhVxHnBeKv8u4FMR8XTuNgdHxJOVVIjyWRrvAYaublQ+MYOZWRtVOE59GrAiIh4GkHQVMBNY1qD88cCVVT28nrLj1M3Muk4MDBbeRrAT8Ghuf2U6thFJW5Blsr0mXxXgJkl3SZpd4iu9xGkCzGz8GTlYvyQF23zAvTQN9ACot8Rbo4Ef7wJ+MqTrZf+IWCVpW7Iu6/si4rbClaujbJqATwAfJftiX42If5X0T2R/fgySrYj0oYhYVeY5ZmZVaqb7ZYORehtbCeyS298ZaBTvjmNI10stNkbEE5LmkXXnlArqLXe/SNqbLKBPI0sR8E5Jk4HzImJKREwFrgNOL1NBM7OqxUAU3kawCJgsabc0YOQ44NqhhST9KXAg8MPcsUmSXlb7DBxOBYsMlWmpv45sZMvzqVK3AkdHxLm5MpNo/KeImdmYGFxbzaSiiFgv6WRgAdAPzI2IpZJOTOcvTkWPBm6KiOdyl29HtgwoZLH4OxFxY9k6lQnqS4CzJb0S+ANwJHAngKSzgb8CngUOrndxvp/qkjM+xuxjppeoiplZcTFYXVszIuYD84ccu3jI/jeAbww59jBZL0elykw+Wk62fN1C4EZgMVlaACLitIjYhSxFwMkNrr80IvaNiH0d0M1sNFXY/dJxSg1pjIivRcQ+EXEA8DTw4JAi3wHeW+YZZmZVi4HiW7cpO/pl2/TW9lVki2O8VdLkiKgF96OA+8pW0sysSt3YAi+q7Dj1a1Kf+jrgpIj4bUrBuwfZkMZfAk4RYGYdZbD4MPWuUzZNwNvrHHN3i5l1tMFqUr90JM8oNbNxxy11M7Me0o0vQIsacfSLpLmSnpC0JHfsPEn3SbpX0jxJWw255lWS1kj6dDsqbWZWxuCgCm/dpsiQxm+QZRbLWwjsHRFTgAeAU4ecPx+vTWpmHWpwsPjWbUbsfomI2yTtOuTYTbnd24H31XYkvZtswYz8dFgzs44xsK77WuBFVZFP/SOkVnlKSnMKcNZIF3nhaTMbK4MDxbduU3by0WlkqQGuSIfOAs6PiDUpSU1DXnjazMZKN/aVF9VyUJc0C3gncGhE1ILyfsD7JJ0LbAUMSnohIr5SvqpmZtUIB/UNSZpB1s1yYC31Lmw4GUnSmcAaB3Qz6zTd+AK0qBGDuqQrgYOArSWtBM4gG+2yKdnyS5DlVXc6ADPrCuO6+yUijq9z+GsFrjuzlQqZmbXbuvVVjBHpTJ5RambjTi+31FudUXqmpMck3ZO2I9PxXSX9IXf84sZ3NjMbG4Ohwlu3KdJS/wbwFeCbQ46fHxFfqFP+obTotJlZR+rlF6UjttQj4jayVY3MzHrCQKjwNhJJMyTdL2mFpDl1zh8k6dlcD8bpRa9tRZm3BSenhF5zJb08d3w3ST+XdKukjfKt13hGqZmNlaoSeknqBy4EjgD2BI6XtGedov8VEVPT9vkmr21Kq0H9IuDPgKnAauCL6fhq4FUR8Ubg74HvSNqy3g288LSZjZV1g32FtxFMA1ZExMMRsRa4CphZsBplrm2opaAeEY9HxEBEDAJfTZUjIl6MiKfS57uAh4DXlq2kmVmVmul+yfcqpG127lY7AY/m9lemY0O9VdJiSTdI2qvJa5vS6ozSHSJiddo9GliSjm8DPB0RA5JeA0wmy9hoZtYxmll3eoM8VRur1z8z9O53A69OObGOBP6DLDYWubZprc4oPUjS1FSBR4CPpeIHAJ+XtB4YAE6MCL9kNbOOUuFQxZXALrn9nYFV+QIR8bvc5/mS/l3S1kWubUWlM0oj4hrgmrKVMjNrpyKjWgpaBEyWtBvwGHAc8IF8AUnbA49HREiaRtbt/RTwzEjXtsIzSs1s3FlbUVCPiPWSTgYWAP3A3IhYKunEdP5iskWEPp56MP4AHJcy29a9tmydHNTNbNxppk99JBExH5g/5NjFuc9fIZvAWejaslpNEzBV0u1pIP2d6U+K2rkpkv5b0lJJv5C0WZUVNjMra6CJrdu0uvD0ucBZKR3A6WkfSROAb5O9IN2L7AXruqoqa2ZWhV4O6i0tPE026qU2qehP+eMb28OBeyNicbr2qWqqaWZWnYG6owl7Q6szSj8JnCfpUeALZItmQDbRKCQtkHS3pM82uoHTBJjZWBmIKLx1m1ZflH4c+FREXCPpWLIhjoel+70NeDPwPHCzpLsi4uahN/DC02Y2VtaOdQXaqNWW+izgB+nz90hpAsgG098aEU+mtUvnA/uUq6KZWbV6uU+91aC+CjgwfT4EeDB9XgBMkbRFeml6ILCsXBXNzKo1QBTeuk2raQI+ClyQAvcLwGyAiPitpC+RzbIKYH5EXN+mupuZtaQbW+BFtZomAOBNDcp/m2xYo5lZR+rGF6BFdcSM0sHnfjdyITMzyq3sUzOuW+qSdiFbn3R7YBC4NCIukHQMcCbwOmBaRNyZyn8Q+EzuFlOAfSLinkbP6JtUdx0NM7O2WEvvLlJapKW+HviHiLhb0suAuyQtJMuh/h7gknzhiLgCuAJA0uuBHw4X0M3MRtu4bqmnxTBWp8+/l7Qc2CkiFgJIw87MOh64soJ6mplVppf71JvqnkrpAt4I/KzgJe+nQVD3jFIzGyvjekhjjaQ/IVsA45P5lTyGKb8f8HxELKl33jNKzWysdGOwLqpQUJc0kSygXxERPxipfHIc7noxsw60Lsbxi1JlneZfA5ZHxJeK3FRSH3AM2ZqlZmYdZby31PcHTgB+Iak2iuUfgU2BfwO2Aa6XdE9EvCOdPwBYGREPV11hM7OyevlFaZHRLz+GhsmH5zW45hbgLa1Xy8ysfapsqUuaAVxAts7oZRFxzpDzHwROSbtrgI/X1pyQ9Ajwe7JRlusjYt+y9emIGaVmZqNpsKKWuqR+4EJgOlmW2kWSro2IfCLD/wEOTLmxjiAbILJf7vzBEfFkJRXCQd3MxqEKW+rTgBW1rmZJVwEzyWWnjYif5srfDuxc1cPrKbLw9C6S/p+k5Wkx6U8MOf9pSSFp67Q/UdLladHp5ZJOrX9nM7OxsS4GC2/5OTVpm5271U7Ao7n9lelYI38N3JDbD+AmSXcNuW/LWk4TEBHLUl6Y6cCvcuWPATaNiNdL2gJYJunKiHikigqbmZXVTEt9gzk1G6v3vrHuzSUdTBbU35Y7vH9ErJK0LbBQ0n0RcVvhytUxYks9IlZHxN3p8++B5fzxl+h84LNs+CUCmJRyrW9OtnKU0zCaWceocI3SlcAuuf2dyRYR2oCkKcBlwMyIeKp2PCJWpX+fIBt4Mm3otc1qOU2ApKOAx2pvcXO+DzxHli/mV8AXIuLpOvdymgAzGxODROFtBIuAyZJ2k7QJ2aTLa/MFJL2KbPnPEyLigdzxSan3A0mTgMPJEiWW0lKaALIumdNSJYaaRjY8Z0fg5cB/SfrR0DHrThNgZmOlqnHqEbFe0slkS3n2A3MjYqmkE9P5i4HTgVcC/54SINaGLm4HzEvHJgDfiYgby9appTQBKaXubsDiVKGdgbslTQM+ANwYEeuAJyT9BNgX8EQkM+sIVaYJiIj5wPwhxy7Off4b4G/qXPcw8IbKKpIUGf2yUZqAiPhFRGwbEbtGxK5k/Ur7RMSvybpcDlFmEtkkpPuqrriZWasGY7Dw1m2K9KnX0gQcIumetB05TPkLgT8h6xtaBHw9Iu4tX1Uzs2pU2KfeccqmCaiV2TX3eQ3ZsEYzs440rnO/mJn1mm5sgRfV8oxSSd/Ndcc8UsvgKGkTSV9PM0oXSzqozd/BzKwpgxGFt25TZkbp+2sFJH0ReDbtfhQgzSjdFrhB0psjuvCNg5n1pPVdGKyLKjujtDY65lj+uMrRnsDNqfwTwDNkQxrNzDpCL78orWLh6bcDj0fEg2l/MTBT0gRJuwFvYsNptLV7eUapmY2J8d79Agy78PTxbLgW6VzgdcCdwC+Bn5J14WzAM0rNbKx0Ywu8qFILT6ekXe8ha40D2bRZ4FO5Mj8FHmQYf1h8a3O1NrNxa/O93lv6HuM6qI+w8PRhwH0RsTJXfgtAEfGcpOlkeQ6WMYxNd39j8zU3M2vRYO/G9NYXnk75Do5jw64XgG2BBZIGgcfStcPqm7Rl8RqbmZW0nt4djFdqRmlEfKjOsUeAPcpWzMysXbrw/WdhnlFqZuPOuO5THw2DLzw31lUwsy7R1DjsBno3pBd7UboZcBuwaSr//Yg4Q9IxwJlkwxenRcSduWtOJVuLbwD4XxGxYLhn9G02qeUvYGbWrPHeUn8ROCQi1qShjT+WdANZat33AJfkC0vak+wF6l5kqx/9SNJrI2Kg2qqbmbWmd1+TFntRGsCatDsxbRERywHSykd5M4GrIuJF4H8krSBb4u6/q6q0mVkZvdxSL9Q9Jak/DWd8AlgYET8bpvhOwKO5/ZXkcsXk7uk0AWY2JqKJbSSSZki6X9IKSXPqnJekL6fz90rap+i1rSj0ojR1nUyVtBXZQql7R0SjVa/rDX/c6L+N0wSY2VipKuBI6idb7W06WQN2kaRrh0y4PAKYnLb9gIuA/Qpe27SmXiRHxDPALcCMYYqtZMMEXjsDq5qumZlZm1TYUp8GrIiIhyNiLXAVWRd03kzgm5G5HdhK0g4Fr21akUUytkktdCRtTkoNMMwl1wLHSdo0ZWmcDNxRtqJmZlVpJqjnu4rTNjt3qyLdzY3KFOqqblaR7pcdgMvTnwp9wNURcZ2ko4F/A7YBrpd0T0S8IyKWSroaWEaWnfEkj3wxs84y7LLLG9igq7jYjYY28BuVKdRV3awio1/uJcuhPvT4PGBeg2vOBs4uWzkzs/YoHtRHUKS7uVGZTQpc27QqJmeZmXUZNbENaxEwWdJukjYhm6Nz7ZAy1wJ/lUbBvAV4NiJWF7y2aUX61DeTdEdaRHqppLOGnP+0pJC0ddp/ZVqoeo2kr5StoJlZ5SqK6Wn9iJOBBWRLfV6duqBPlHRiKjYfeBhYAXwV+Nvhri371VqeURoRt0vahWw4zq9y5V8APgfsnTYzsw5TXSdFSkM+f8ixi3OfAzip6LVlFVl4OiJioxmlaf984LO5fSLiuZSu94UqK2pmVhU18b9u0/KMUklHAY9FxOK21tDMrGJSX+Gt2xSqcUQMRMRUsrez0yRNAU4DTm/1wU4TYGZjp6+Jrbs0lU89Ip6RdAvZrKfdgMUpodfOwN2SpkXErwvey2kCzGxM1ElE2DOK5FPfBliXAnptRum/RMS2uTKPAPtGxJNtq6mZWVW6sFulqJZnlA53QQryWwKbSHo3cHjZJDVmZlVRF3arFNXyjNIhZXYdbt/MrJOor3+sq9A2HbFGqZnZaOrGUS1FOaib2bgzrrtfhll4+rvAHqnYVsAzETFV0nTgHLJkNWuBz0TEf7al9mZmLRjvLfVGaQLeXysg6YvAs2n3SeBdEbFK0t5keQ1K5wg2M6tKNu6jN7W88HTtvLIBn8cCh6TyP89dvhTYTNKmaSFqM7Mx18st9SoWnn478HhEPFjn0vcCP68X0D2j1MzGSl/fxMJbt6li4enjgSuHXiNpL+BfgMMb3NMzSs1sTPRyS73VNAEzgCWSJgDvAd6ULydpZ7JVkf4qIh6qqK5mZpXo5T71sgtPHwbcFxErc+W3Aq4HTo2In1RfZTOzcqT+wlu3KZsm4Dg27no5Gdgd+Jykz6Vjh0fEE1VU2MysrL7x3P0yXJqAiPhQnWP/DPxz6ZqZmbVJN7bAi+rdnyszswb6+jYpvJUh6RWSFkp6MP378jpldknrOi9P60B/InfuTEmPSbonbUeO+N1K1djMrAupr7/wVtIc4OaImAzcnPaHWg/8Q0S8DngLcJKkPXPnz4+IqWkbcT3TwkE9jVX/uaTr0n7dXyBJ03K/KoslHV30GWZmo6FP/YW3kmYCl6fPlwPvHlogIlZHxN3p8++B5ZSYhd9MS/0T6WE1jX6BlpAtmDGVbOjjJWnoo5lZR2hm9Et+omTaZjfxqO0iYjVkwRvYdrjCknYle4eZn+B5sqR7Jc2t130zVNEZpTsDfwFcljtc9xcoIp6PiPXp+GbkUgqYmXWCZoJ6RFwaEfvmtks3vJd+JGlJnW1mc3XSnwDXAJ+MiN+lwxcBfwZMBVYDXxzpPkVb0P8KfBZ4We7YBr9AkvLL2+0HzAVeDZyQC/L5LzAbmA1wyRkfY/Yx0wtWxcysnP6+TSu7V0Qc1uicpMcl7ZBi5A5kqVbqlZtIFtCviIgf5O79eK7MV4FhV52DYpOP3gk8ERF3jVQ2V5GfRcRewJuBU1P63qFlXvr1c0A3s9E0ii9KrwVmpc+zgB9uVJcsKeLXgOUR8aUh53bI7R5N1r09rCLdL/sDR6V1R68CDpH0beDx2gMb/QJFxHLgOWDvAs8xMxsV0oTCW0nnANMlPQjU1ppA0o6SaiNZ9gdOIIutQ4cunivpF5LuBQ4GPjXSA4tMPjoVODVV5CDg0xHxl5LOI/vlOYfcL5Ck3YBHI2K9pFeTLaTxSJFvb2Y2GkZr8lFEPAUcWuf4KuDI9PnHgBpcf0KzzyzzM3QOcLWkvwZ+BRyTjr8NmCNpHTAI/G1EPFniOWZmlerlAXnNZmm8BbglfW70C/Qt4FsV1M3MrC0qGH/esXr358rMrIG+/o3GbvSMMjNK/ykNiL9H0k2SdhxS/lWS1kj6dNWVNjMro5dT75aZUXpeRExJM0evA04fUv584IaS9TMzq9wojn4ZdS3PKM3NeAKYxIaLUb8beJhs4Wkzs46ivgmFt25TtKVem1E6mD8o6WxJjwIfJLXUJU0CTgHOGu6GXnjazMZKL7fUR6xxfkZpGqf+kog4DThN0qlkKx6dQRbMz4+INdlEqfryC08P3vXNGHzhuZa/hJmNH1XkC1cPvygt8jNUm1F6JFmCri0lfTsi/jJX5jtk65KeAewHvE/SucBWwKCkFyLiK40e0LfZpJa/gJlZs7qxBV5UmRmlkyPiwVTsKNJi1BHx9tq1ks4E1gwX0M3MRl0X9pUXVWpGqaQ9yPrZfwmcWE2VzMzarAuHKhZVZkbpewuUP7OVSpmZtVM3jmopqne/mZlZI+O5T93MrNfEhOoWyeg0LacJSMf+TtL9kpam0S5I2lXSH3J5gS9uR8XNzFrW11986zLNtNRraQK2BJB0MNk6pVMi4sX8cnbAQyl9gJlZx4kuDNZFlVl4+uPAORHxIkBE1F17z8ys00Rff+Gt25RJE/Ba4O2SfibpVklvzp3bLXXV3Crp7dThNAFmNmbGc/fLMGkCJgAvB95CtsD01ZJeA6wGXhURT0l6E/AfkvYakgBsgzQBLL0mMDMbJdFXRbKBkUl6BfBdYFeyZT2PjYjf1in3CPB7YABYHxH7NnN9XpmFp1cCP4jMHWSt+K0j4sW0KhIRcRfwEFmr3sysIwxMnFh4K2kOcHNETAZuTvuNHBwRU2sBvYXrgQJBPSJOjYidI2JX4DjgP1Pel/8ADgGQ9FpgE+BJSdsoZZZPLffJZGl4zcw6QvT1Fd5Kmglcnj5fDry73deXGac+F5graQmwFpgVESHpAODzktaT/SlxYkQ8XeI5ZmaVaiZYS5oNzM4dujR1HxexXUSsBoiI1UNGCW5QJeAmSQFckrt/0etfUiZNwFrgL+uUuQa4ppn7mpmNpsEmgvoG7//qkPQjYPs6p05rokr7R8SqFLQXSrovIm5r4vqXeEapmY070V/di9KIOKzROUmPS9ohtbJ3AOoO/Y6IVenfJyTNA6YBtwGFrs8rs/D0GyT9t6RfSPq/krbMlZ2Szi1N53s3I72ZdZ2BiX2Ft5KuBWalz7OAHw4tIGmSpJfVPgOHA0uKXj9UmYWnLwPmRMTrgXnAZ1KlJgDfJutL3ws4CFjXxHPMzNoq+lR4K+kcYLqkB4HpaR9JO0qan8psB/xY0mLgDuD6iLhxuOuHU6j7JTej9Gzg79PhPcj+PABYCCwAPkf2K3NvRCwGqA1vNDPrFBUE62LPyeLfoXWOrwKOTJ8fBt7QzPXDKTOjdAnZikcAxwC7pM+vBULSAkl3S/psvRt6RqmZjZXoL751mzIzSj8CfFnS6WT9Pmtz93wb2SzT54GbJd0VETfn7+uFp82sFVW84hytlvpYKLvw9OHw0uSjv0jlVwK3RsST6dx8YB+y2VB1eeFpMxtVo5MlYEy0PKO0NgheUh/wv4Fa3vQFwBRJW6SXpgcCy9pSezOzVkxsYusyZX6vjpf0AHAfsAr4OkBKNvMlYBFwD3B3RFxftqJmZpXpa2LrMmVmlF4AXNCg3LfJhjWamXUcdWGwLsozSs1s3FFf72b77oig7pEvZlZUFY3scd9Sr5fAXdJ5wLvIhjI+BHw4Ip6R9EHS7NJkCrBPRNzT6P4e/WJmo6kLFzQqrJnfq6EJ3BcCe0fEFOAB4FSAiLgilZsKnAA8MlxANzMbbf0TovDWbVr+IyQiboqI9Wn3dmDnOsWOB65s9RlmZu3Q11d86zZFq1xL4H5XShg/1EeAG+ocfz8NgrrTBJjZWOnloF70RWnDBO6STgPWA1fkL5C0H/B8RCzZ+HZeeNrMxk43BuuiCn21fAJ3sjS70wAkzQLeCXwwIoYG5uNw14uZdaBx3VJPSdv7IuL3uQTun5c0AzgFODAinh9yTR9Z5sYD2lBnM7NSJnbhC9CiinS/bAfMk1Qr/52IuFHSCmBTsu4YgNsj4sR0zQHAypQneEQDvx1xhSYzMwCqGI3YjS3wokYM6o0SuEfE7sNccwvwllI1MzNrk3Ed1EfD4HPPjnUVzKxLVNFSr3Dd6Y5TZkbpmcBHgd+kYv8YEfMlTSRbv3SfdP9vRsT/Ge7+/Vvv2FrtzcxaMFprZEh6BfBdYFfgEeDYlMk2X2aPVKbmNcDpEfGvjeLscM9spqV+cG3hi5zzI+ILQ44dA2waEa+XtAWwTNKVEfFIoxs7TYCZjaZRbKnPAW6OiHMkzUn7p+QLRMT9wFQASf3AY2SjDGvqxdmG2tH9EsCktEDG5mS5YX7XhueYmbVk4uh1PM8EDkqfLydLXX5Ko8Jki0w/FBG/bPWBZWeUnizpXklzJb08Hfs+8BywGvgV8IWIeHroDT2j1MzGSn9f8a2k7SJiNUD6d9sRyteb31MvzjZUtMr7R8Q+wBHASZIOAC4C/ozsz4bVwBdT2Wlkfe87ArsB/yDpNUNvGBGXRsS+EbHv7GOmF6yGmVl5zQT1fAM0bRukSpH0I0lL6mwzm6mTpE2Ao4Dv5Q43irMNFfojJD+jVNI8YFotTUCqzFeB69LuB4AbI2Id8ISknwD7AoXGrJuZtVszQxo3SGlS//xhjc5JelzSDhGxWtIOwHCTco4gW/7z8dy9X/o8JM42NOJXk2g+Vj0AAAWVSURBVDRJ0stqn8lmlC5JFaw5GqjlePkVcIgyk8jGq9830nPMzEZLv4pvJV0LzEqfZwE/HKbsRllth4mzDZWZUfotSVPJ+tsfAT6Wyl9Itgj1EkDA1yPi3gLPMTMbFaM4+uUc4GpJf03W4D0GQNKOwGURcWTa3wKYzh/jaM25DeJsQ2VmlJ7QoPyaWsXNzDrRphNGZ6B6RDxFNqJl6PFVwJG5/eeBV9YpVzfODqczZpR6jVIzK6iKRva4n1Habp58ZGajqYK+8o5VJk3AVOBiYDOyRTL+NiLuSMNyLiEb8TIIfCIl+DIz6whuqWeGpgk4FzgrIm6QdGTaP4gsTwEpTcC2wA2S3hwRg1VV2sysDAf1+gLYMn3+U2BV+rwncDO8NK79GbJW+x0lnmVmVplNRulF6Vgokybgk8B5kh4FvgCcmo4vBmZKmiBpN+BNwC5Db+g0AWY2VkZxnPqoa3nhaeB9wKci4hpJxwJfAw4D5gKvA+4Efgn8lKzPfQNeeNrMxkr/aOXeHQMtpwkgmx31iVTke2Q51ImI9cCnatdK+inwYIV1NjMrpZf71FtOE0DWh35gKnYIKXBL2iKVQ9J0stEyy9pQdzOzlvT3qfDWbcqkCVgDXJDypr8A1PratwUWSBokS/be9IwoM7N26uWWepk0AT8mewk69PgjwB5VVM7MrB0mduMb0II6Ykapmdlo6sZulaIK/REiaStJ35d0n6Tlkt4q6by0f6+keZK2ypU/VdIKSfdLekf7qm9m1rxRXPlo1BWt8gVkC1/8OVlXzHJgIbB3REwBHiCNU5e0J9mSTHsBM4B/T4upmpl1hF5+UVpk9MuWwAFk49CJiLUR8UxE3JSGLwLcDuycPs8EroqIFyPif4AVZEMgzcw6wrgO6sBrgN8AX5f0c0mX1YYs5nwEuCF93gl4NHduZTpmZtYRxnv3ywRgH+CiiHgj8Bwwp3ZS0mlkM0avqB2qc4+NZow6TYCZjZWJE/oKb92myOiXlcDKiPhZ2v8+KahLmgW8Ezg0IiJXPp/rZWf+mOzrJU4TYGZjpRtb4EWN+NUi4tfAo5JqY88PBZZJmgGcAhyVlmKquRY4TtKmKaHXZJyh0cw6SC/3qRcdp/53wBVpAYyHgQ8Di4BNyRJ8AdweESdGxFJJVwPLyLplToqIgeFu7uXszKyoKhrZfaMUrCUdA5xJluRwWkTc2aDcDLJRhv1kC1Kfk46/AvgusCvZwtPHRsRvh3tm0YRe95DlRM/bfZjyZwNnF7k3eDk7Mxtdo9j9sgR4D9lqcHWlId8XAtPJuq8XSbo25cyaA9wcEedImpP2TxnugR0xo/QPi28d6yqYWZfYfK/3lr7HJqP0AjQilgOk3oxGpgErUkoWJF1FNjR8Wfr3oFTucuAWuiGob/6BL3dfx5W1naTZ6YW6WaUO2X73wjEnLQw0O3fo0or/f1lvGPh+6fN2EbEaICJWpzUthtURQd2sgdnURkiZjZENRurVIelHwPZ1Tp0WET8s8IhCw8CLclA3MyshIg4reYvhhoE/LmmH1ErfAXhipJv18GhNM7OusAiYLGm3NMLwOLKh4aR/Z6XPs4ARW/4O6tbJ3PViXU3S0ZJWAm8Frpe0IB3fUdJ8eGkJ0JOBBWTJEq+OiKXpFucA0yU9SDY65pwRn/nHiaBmZtbt3FI3M+shDupmZj3EQd06kqQZaeWsFWkmnZkV4D516zhp2vQD5KZNA8enadNmNgy31K0TvTRtOiLWArVp02Y2Agd160RePcusRQ7q1okqnTZtNp44qFsnKrR6lpltzEHdOtFw06bNbBhO6GUdJyLWS6pNm+4H5uamTZvZMDyk0cysh7j7xcyshziom5n1EAd1M7Me4qBuZtZDHNTNzHqIg7qZWQ9xUDcz6yH/HyYtWXHSwy1hAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1211,13 +1108,13 @@ "metacluster_0\n", "activity pattern: [1]\n", "metacluster_0 pattern_0\n", - "total seqlets: 142\n", + "total seqlets: 83\n", "Task 0 hypothetical scores:\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABIkAAACMCAYAAAD4MPn4AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOydd5wU5f3H3zPbrxeuAEcvooiIQREExQbW2HtM1JioscXEn4ma2P0Zjd3En703VOyCKFixg/QOHuUo1/vubZvn98eze7t7dTnuBOX75jXs7ezMM8/OPDvzPJ/nWwylFIIgCIIgCIIgCIIgCMLujbmzKyAIgiAIgiAIgiAIgiDsfEQkEgRBEARBEARBEARBEEQkEgRBEARBEARBEARBEEQkEgRBEARBEARBEARBEBCRSBAEQRAEQRAEQRAEQUBEIkEQBEEQBEEQBEEQBAGw7+wKdESvXr3UwIEDd3Y1BEEQBEEQBEEQBEEQfjHMnz+/QimV13L9Li0SDRw4kHnz5u3sagiCIAiCIAiCIAiCIPxiMAxjQ1vrxd1MEARBEARBEARBEARBEJFIEARBEARBEARBEARBEJFIEARBEARBEARBEARBQEQiQRAEQRAEQRAEQRAEARGJBEEQBEEQBEEQBEEQBEQkEgRBEARBEARBEARBEAD7zq6AIAiCIAjdR2MjfPstVFRAOAzp6bDfftCnz86umSAIgiAIgrCrIyKRIAiCIPzMqauDhx6CadNg5UrweEAp/ZlpQlMT9OoFRx0FV18NI0Zs/zGWlC7h1s9v5dXTXu3eyguCIAiCIAi7DOJuJgiCIAg/U/x+uPdeKCqC22+HJUsgGNSiUX29Xmpr9XabN8Mzz8CYMfDb3+r328OTC57kteWvsaZyTY98F0EQBEEQBGHn0y0ikWEYRxmGscowjLWGYfy9jc8nG4ZRaxjGwshyQ3ccVxAEQRB2V0pKYO+94YYbtBjk83W+TzisrYqmTYM99ti+472z6h0Apq+Y3oXaCoIgCIIgCD8HdlgkMgzDBvwXOBrYCzjLMIy92tj0C6XUvpHllh09riAIgiDsrixcCKNHQ3GxjkG0vQQC27ff5rrNFNcUA/D84ue3/4CCIAiCIAjCz4LusCQ6AFirlPpRKRUAXgFO6IZyBUEQBEFowfz5MHEiVFVpy6CfgjdXvondsGNgsK5qHVvqt/w0BxYEQRAEQRB+UrpDJOoLbIp7XxJZ15LxhmEsMgxjpmEYI7vhuIIgCIKwW7FtG0yd2rkV0F57wcknw2mnaUHJ6dyx4z636DlCKgSAzbTx9sq3d6xAQRAEQRAEYZekO0Qio411qsX7H4ABSqnRwEPAW+0WZhh/NAxjnmEY88rLy7uheoIgCILw88eytOhTV9f257m5OsNZTQ18+y089RQ8/ji8957eZ84cHbR6e6nyVbG4dHHze2/Qy7OLnu3itxAEQRAEQRB2ZezdUEYJ0C/ufRGQYIeulKqL+3uGYRgPG4bRSylV0bIwpdRjwGMAY8eObSk2CYIgCMJuydNPw4IFOntZSy68EO6/H2w2cLvb3n/yZJg7F95+G84/X2c8S4b3Vr+Hw3TgD8d2WLBtAdW+arI92dv/RXYSNTX6+3/8Maxdq79/aqqO7TR5Mowb1/65EwRBEARB2F3oDpHoe2CYYRiDgM3AmcDZ8RsYhlEIlCqllGEYB6AtmCq74diCIAiC8IvH74drr23tZmYYcNddcMklWvDoCNOElBQ44QT4+ms48sjkjv3coudoCDYkrHPanLy3+j3OHX3udnyLncOnn8L//A8sWgQeDzQ0aKusKO+9B/feq7O+HXMM/Otf25/5TRAEQRAE4ZfCDrubKaVCwGXALGAF8KpSaplhGBcbhnFxZLNTgaWGYSwCHgTOVEqJlZAgCIIgJMETT4DX23r9bbfBxRd3LhDFk5KiYxZ99lnn2zYGGpm7cS4AJiYpjhQAGgINu3yWsyVLYP/94bjjYN48bYFVV5coEEFsfSAA774L++4Lp54K4vEuCIIgCMLuiLErazVjx45V8+bN29nVEARBEISdRigE+flQXZ24fupUmD59+wSieLxeLRh1xBsr3uC8t86jPlBPhiuDMYVj+GyDVpdcNhdVf6tqFo52JV57Dc47r21hLRkcDsjKgrKybq2WIAiCIAjCLoNhGPOVUmNbru8OdzNBEARBEDpBKZ22vrgY1q+H2lqdwt5u10GnBw3SS3p64n5ffKGFongcDnj22a4LRNC5QATwwuIXqA/UA+AL+jhj5BnM3zqfhkADTpuTD9d9yIkjTux6JboZpeD66+GBB7ouEIG2LhJLIkEQBEEQdkdEJBIEQRCEHqKyUrswvf02fPIJ+Hyx4MjhsBY1DEMHnFZKf56bC0cdpd2kjj0WXn65dSyi3/8+OZFnRwiGg8xaN6v5fVFGEVOHTuXqj64GoD5Qz4uLX9ylRKI77khOIDIMLc61FQRcEARBEARhd0ZEIkEQBEHoZhYtgjvvhDff1GJEQ1zc50Cg431LS7WV0Btv6Pg5TmdiHB3DgJtvbm1x1N18uv5TbIat+f0Rg49gUNYgnDYn3qBWYWasnUEwHMRhc/RsZZJgxgwdo8nna/vzvffWAb6nToWBA/U6y4Jly7SQ9/DDsG3bT1bd7SPsh5olUDUPqhdAsA4MG7h6Qc5YvWQMB2OHQ00KgiAIgrCbIyKRIAiCIHQTNTVw6aVaHAoEtLVQPIahxYoxYyAtDVwuLWrU1emMY8XFsW3r69s+xtixP02q9peXvkxDQKtb6c50jhh8BIZhMKFoAjPWzgDAbtj5fMPnHD748J6vUAeUlcGZZ7YtEPXuDY89Bocdps+3LaZ7YbPpQNV77gl//asOEP63v+lMZ7sEFd/Birtg87tgukCFINziS9rTAQswYOgfYY8rIHXAzqitIAiCIAi/AEQkEgRBEIRuYMkSLUTU1+uU9VHcbjjrLDjxRJg8WQtFoC2MTFMLSaGQfl9fDx9+qEWmt9/Wli7xogbAGWfoVO49iaUs3ljxBgqd3CIQDjCx/0QAjh52NJ+s/wRfyEdDsIGXl76800Wi665r20Jr3DhtYZSeruM4tYfLpV8vvBCOOAKmTIHNm3umrklRsxS+Ogfq10K4CbDAascELRSnJq7+D6x+GPocAwdP/0mqKgiCIAjCLwsRiQRBEARhB5k3Dw4/XFsExXP66fDf/2oRIhn3sJQUOOccLSiVlmrBoqVYMWVKx4JHd/Dd5u8Iq5gZVKY7kz7pfQCY1H8SNlMrV5aymL5iOo8d/xjmTnJ1Wr0aXnopUZgDmDBBC27bE9w7JQWGDYP587WFEYWF+kL0BAUFrf3brDAsvxOW3RYRh7YzA21USNryXrdUURAEQRCE3Q8RiQRBEARhB6iu1sJNvEDkdMKLL+oA1Glp21eeaWpBKT1du6Vt2JD4eTSeTk8ybdk0fMGYW9PBAw5u/nvv/L0JWzEBKWSF+H7z94wrGtelY/n98OWX8N13sHQprFqlM4sFg9qKKiMDhg7Vbnr77KPFuNzc2P5XX93aiqhPH3j//a5lf3M4IDsbZs0CRveQQAStxaewHz47Hsq/bO1Str20Z3UkCIIgCILQCSISCYIgCMIOcPnlrbNp3X03HHPMjmcg27Qp8X12thagehKlFK8sfaXZkijVkcpRQ45q/txm2vhV718xd9NcAJqCTby6/NXtEonCYXjnHbjvPi0OuVz6HIZCbW+/bJnePi1Ni0qDBukMbxdeqK2FWsZ+euKJrglEUZxOGDKk6/tvN1YIPj0WKr5qWyAyXdDvZOg9BXpNAGc2oMC7Gco+15ZD22b/hBUWBEEQBOGXiohEgiAIgtBFqqvhtdcSLVkOPhguuKB7UtS3dKHKzNTHisbQ6QmWlS+jzh8zi1IoJg2YlLDN0cOO5rst3xEIBwipEK8sfYW7j7wbIxpwqR0sCx5/HG68ERobY1nfWn7PtlAqFsx71Sq46SbtseVwJO4/fry+BjvqkrcjItN28/2lUPF1a4HIdMDI62HEVfq9IyPxc3c+ZI2GIRdAsBYWXA0bpv00dRYEQRAE4ReJiESCIAiC0EVmztSCTbxI9Je/dJ/AYFmJ782fIOzP0wueJhCOfSGlFOur17OhJub35rF7sJv25u0qvZUsKl3EvoX7tlvuunVwyimwdq0WiFoydKh22zv6aOjVS4tsgYAWhr74Qp/r77+PWQ15vdpiKCo0Rbnjjp4P7N2tlH4G61+AcAtztIwRcMg74OkD9g4alGmCmQ6OdDjgCRh4rg56LQiCIAiC0AVEJBIEQRCELrJyZetU9ePHd1/5LV3LmppaZzvrbh767iFCVszvKxgOcvrrp7fazhuMiRr+sJ+rZl3FJ7/7pM0yf/gBDj1UCzrxwldBgbYIOumkWOymtgS2gw6CK6/UGeA+/1zv89138O23idvl5OiMZj+FmNYthHzw1dmtBaKsUXDEFzq9/fZ8GUcaFB4OU7/tfFtBEARBEIQ2EJFIEARBELqI3a5T2qu4JFTtxdXpCvEBmkEnw+rJzGZzN84laAUT1oVUiFp/baf7frnxyzbXL1wIkye3FtMuuQT+/W99Djtzn3M6Y4LZ1KlwyCHw6KPwj38kWnH9+tc64LXb3Wl1k6OgoGezm/34NARqEte7esHhn2jLoK5kjLO5IXVA99RREARBEITdjp/LXJsgCIIg9Dh//uDPHPHcESiVXOrxffdtndp+9uzWgZS7ypgxWoSKYlmweXP3lN0W//7q313eN2gF+WrjVwnrAgE48cREgcgwdBynu+7SVkPbG1/JNLUr2oABWmCKZ9Kk1tdjh9i2TSuAHS3t0dl+W7fCin+3tiI64FHtXtYVgSiKrbtUMkEQBEEQdjdEJBIEQRAEYM6Pc3jg2weYUzyHO7+8M6l9jjyydfr1u+5KLhBzMowc2ToA9g8/dE/ZbfHRuo92aP+7vror4f3dd+t09vFceikcdVTMvayr/Pijdr+LZ8yYHSvzJ6XiG/C3ODm9DoTeU0XkEQRBEARhpyEikSAIgrDbs6V+C6e8egoApmFyy2e3MHfj3E7383jgiisShZxly+Cf/2wdULkrjBjROgbRSy9BXV3b2+8IK8pX4Au1kX59O/hw3YcJ7//7Xx1gOkrfvvCvf+24QARQVdVaoOvXb8fL/cnY8r6OSRTPiL+CKQKRIAiCIAg7DxGJBEEQhN2akBXi1y//msagTrllYOAL+TjhlRMoayzrdP9bboH8/EQx5777tEWR19s6Q1myBIMwaFBrq6QPPmgd0Lo7uP/b+1utc9qcpDvT210MElPe+0K+5ixoa9dCdXVieaeemug+tyO0tCKCno3X1O2UfQ7ENQ7TAX2PB7OHI5MLgiAIgiB0gASuFgRBEHZrrvnoGlaUryBkhXDb3BiGFonq/fWc+MqJfHH+F9g6GLi7XDrj1vjxUFamxR2l4NZbYcYMePxxnd7d5UpO3PH5tLD0ySdw+eU6s9fHH8c+b2yEV16Bs87a/ng+HbG0dGnCe4/dw9Xjr2bPvD3b3eeJBU/wcXGsci6biznFc7hgzAUUF+vv64szljnkkNbuc12lLUGou2JB/STULEl8nzkSrCawdeNFFQRBEARB2E5EJBIEQRB2W95d9S6PzHsEX8iH3bRz9LCjmTRgEv/8+J80BhtZVLqIGz+9kdsOu63Dcvr1g3nzdIyi4mIt5ADMnw/77QcHHqizcp14Iuy1lxZO4mMeG4YWfL7/Ht58E2bNguXL9WfRdO/x7mv//CeccUb3nYd6fz3zts5LWBeyQlw76Vo8Dk+7+9lNO99v/p76gI5M7Q/7eW7Rc1ww5oI2M7e3dA/bETIydBDreEutigrIyem+Y/QYVgiCLTLGZY1CDLwFQRAEQdjZSG9EEARB2C1ZX7Oec944pzkOj8N08MBRD3DZ/peR7ckGwBv0cu/X9yYV0LmwEBYs0AJOSoqOVxTlm2/g5pt1YOXsbJgyBU45Bc45B046CQ49VIseBx+sXdWiAhHA8cdr66R4Skp0vJ+oGNUV4q1uZqyZgauFBcuw3GEdCkQAE/tPJBBOVH6+KfmGen89I0e2dgn74IPuidUEMGyYzo4Wz+LF3VN2jxNuAqOFdZo9vfU6QRAEQRCEnxgRiQRBEITdjkA4wLEvHdsch8hj93DVgVfRL7MfDpuDR497lFSHViB8IR+nvXYam+s6zz1vt8Pf/gabNmkLoLw8nZI93jXK69WWQR9/rN3RPv1Ui0vxQpDbrYWmoUO1Zczpp7d2r7ruOh33p6vWOfFuYC8sfqHZGgh08O6pQ6Z2Wkbv9N5kubMS1jltTj5Y+wGFhTqmUjxvvtl91kR77dV63ddftx2raJfDdAAqcZ0VaL2uPd4ohJeMThYRnARBEARB2H5EJBIEQRB2O0585UTWVK7BUtpXyTRMBmUN4vlFz/P8ouep8FbQN71vc2Dm+kA9E5+eiDfg7ajYZnJy4JprYOtW+PBDbV20334Kh6cJ02aRng6ZmbElLU0Hvs7K0tZEd9yhhaTVq3V5t93WOstZMKhd2EpKtl8YaWzUQaQB/CE/s4tnJ3ye5kzjsEGHJVXWIQMPSXhfH6jn+cXPA/CPfyRa+9TWwm9+s2MWUFGGDUvMnAbwzjtdDxT+k2I6wWjh8V+/Fqxg29u3pKk0iY1+DidCEARBEIRdDYlJJAiCIOxWXPnBlcxcOzNhXcgKcdWHVyWss5SFilh2WMpifc16Jjw1gYUXL0z6WDabjkd04IHAwbfxw6c3YAYyePSwuQzwjCIU0hZCubkwYED7gaj794ff/haeeSbREqe0VMc8mjED9tmn89TyPp9epkzR8ZIA5hTPwWE6aCKmNDWFmjio30FJfcepQ6by/ur3m62yAGb/OBt/yM/ZZ7t4+GEteIVC+rOZM7WV1c0371gQ62AQhgyJCWmgLas2b9YC0i6NYUD6cKiNC15dvQBs3RTVezchGIQNG/R1Ly/Xv41AQMf7cjr1byszU1vkDR7cfUHTBUEQBOGXjIhEgiAIwm7DrLWzePDbB1ut94f9+MP+NvZIZFHpIq6fcz23H377dh33pSUvccfcOzANE8tZx5++P5gfLvqBQdmDOt85wm23wauvtnbXqq3V1ke//S38+9/a5S01Vb9GqavT7598Ugs0VVWJdYt3NQPonda7OS5TZ0zqP6lZTIviMB18XPwxRw87munTYdw42LIlJhTdfTd8+SW8+CL06qVd8pKlqUmX8/e/wwUX6O8Tb0l16606XtP2lLlTyJuQKBIFa6FuOWTvu/PqtAvT2Ahz5sD778OiRTpAfGWlds2023WMLcuKBYQ3DB3Y3DT1Op9Pi6gDBmgXz6ysDg8nCIIgCLsthlJJ+r/vBMaOHavmzZvX+YaCIAiC0Am+oI9+9/Wj0leZsN7AwDCMdveLuqRFsRk21ly+JmmBZ+7GuUx9firekBebYWsWVIoyilh40cKkxRjQrmsnnpgYTygelwsmTdJuaGPG6MHzxo3aemf2bG1tEU8oHCb7zuxWItEF+17Akyc8mVSdlFJk3ZlFnb+ueZ2BwTn7nMPzJ2m3s23bYMIE/Rpfd5tNB+8+6ywtdAWDOuC30xnbxrKgvl6LAcuWwRtvwKOP6kxm69fDiBGJIpFpwsqVO25N5Pe3b9mVQHttp7P+1YZX4dvfQygukvfAc2D//wNHJwrXG4XJuZydvfP7eE1NUFamhclgUAt8lqWvvd2uz3FenhYL7S2mLi1Lt/mHHtICkcul24JS2rrugAO0ldDo0bod5OToMkxTH6uhQVuaLV6sXxctgiVLOr80giAIgrA7YBjGfKXU2FbrRSQSBEEQdgfOnn42b658k6aQVhTshp1jhx/LW2e+1eF+93x9Dzd+cmOzO5VpmAzPHc6Cixbgtrs73HdN5RrGPj6WOn8dBgbDcoexqXYTvpAPp83J6ILRzL1gLk6bs8Ny4vnf/4Xbb28dj6crfL7+C4596dgEkSjdmc6jxz3KWaPOSrqcqS9M5cN1HyasS3emU/23amymDqbU2AhXXAEvv6yFg5bdD5sN9t9fi1w5OTrbW1MT1NTowN6ffto6M5pSWiBomdVswgT46KMdcy+qrtaZ6DqlqyJR2A/TeyWKRKYDjlsFaclbmDXzUhv1+IlEoupqncHvhx/gq6+0C1hFhbZyCwZ15r/CQn0+oyJOOKyt4iortZVZVZW+XllZWjCaNg3OP19f2+h1z8qCP/4RLr5YlxcI6H1aBnVvSTgc+70EAtq9UxAEQRB2d0QkEgRBEFBKux7V1sZm9C1LD9qiM/tZWdotowPjmp8dTy14istnXo43GFNWPHYPKy9bSf/M/h3uGwgHGPzAYDbXx7Kbeewezhp1Fk/+un1rm/LGcvZ9ZF+2NmxFofDYPcz74zxmrpnJjZ9q0clj93Ds8GN59dRXO7RmikcpHQj73nvbtyhKlj+9dymPzH8kwVrKbXez5vI1FGUUJV3OA988wN/n/L1ZgAMtEs04ZwYT+09M2Pa77+CGG+Czz/TgPZhkrOZ4DEOLAw0NWgw66aTWwbCvuEILavGBs5OlsVFbY82dm2Rl2iKZ/tX8P8Pqh0HFnYTcA+DwT8C+nQrXjohESkGgGsJNoEJ6MWw6uLbpBGcOmImR05ua4Nlntevghg36evj9cNhhepk0SVv5ZGTo6+z3tx1U3GbTVmJKaaFo2TKYPh1eeUVf32j72HtvbVWUmSmxhQRBEAShO2hPJJKYRIIgCL8g6uv1zPuiRXqwtWSJDm5cW6sHVoWF0KePdulxOLRbj82mBaNgUA/kfD6dMausTM+6Z2bq+DE5OTvhC4X92q3Gtw3CjTr7kxUZxFpB/YoBpj0yoHVEXu3gyAR3IUtqS9sUiK4Yd0WnAhHolO6PHPcIZ75+ZrM1kS/k45Wlr3DEoCPatLjxBX0c8fwRlHvLUShSHClcPf5q9srbiz1y9+DZRc+ytGwpvpCPGWtm8I+P/5F0nCPD0PGJhg6FP/2p60KRJ0Xx2vLXWrnTpTnTEgQin09naduyRb82Nur2EgrputjtUBOehBVOFCkaAg1MWzqtlUh0wAHwwQfw44/wxBPw5pv6b49Ht7e2vo/TqYWEUEiLPsceC7/7nf7syCO1NdHXXyfqMg8+qN2TbropeVEhanFy2mm6zfc4I66CtY9BOE4kqvwOFlwDY+4EexcUrvZQFtSthPKvoGYxNKyDxk3QtE0LRIaphSEM/TdKn1BlgQqAPQPc+ZBSRHHdAYy/+HYaGs1mce6QQ7QboMfTOiZW1K2sM6IWR/feq8XscFivT0vTFkqpqVrQFgRBEASh5xBLIkEQhF8Ab7+tB1bffKMH05YFhx4K550HY8dC7956gO2PxGY2jMRFqcTFMPSgzjBg0yYtSPQoTWWwZSaUfwk1S8BXAtghcw+dBcrTG1IHgKePzgDVLArZI5WOCkch7b7jLYHGjXgb1rPH1x9QUr8l4XDZ7mw2XVlMKn5oKodApRakVDhSVjgiRoXBMFHYmPj+dXxdtiohSLPTdLD0ovkMyx/VvC5khZj8zGS+3/I9gbCOMt03vS8vn/IydlOPnItrijn/7fObP3fZXNw0+Sb+PvHv23XavvoKfv97fY2STSsfFQhvvx0a9v0XKypWAFoLqKiArIqjqf7iTJYs0a5A0ThBWVk6dkxBgX5vs+lTHw5DfUOYxXnXU6+2EgzqdXY71H/yLu7K6k7rVEkO8/kVxQxiNcPZQH8COHEQIodK9mIFgyhmFEsYwo+xHUtLIT+fRYtg/Pi2BaYpU7SLm9PZcfa3+nothB1/PKxZo9cl1UXaEUsigOX/hiU3axE0nqGXwH53g+lOThlpy5LoLAtK3oLiZ2HbbCDyY0dBrwMhdxxkjoDUQeDpC67cyG/LFhGHwjqgtm8LNG6AujVQNY9r7j2Me969LMEyqKxMt4/uYPjw2DUAncVu8WKxIBIEQRCE7kTczQRBEH6hvPAC/OEPicF7P/lEZ5TyeH66eiilrTCqq7WbSDisF6W0oGCzaeEpO1tbJzWPez85BkrnaLeWUAOkDYZDZ0FKkXZ/MR1g80SsG7YDK0Q42Mg5b51HTX0x+CshWA/hJq7Ky2TqoEmQMQJSB2rxyZ0PziwtPhm2yBK1qAizpmotf/3kVgKhJrACYPkxwn6eOv0deufs0XzYMY+MYWHpwoSqpDnSmmPzRGkKNbXKqHbn4XdyzcRrtutrKgWvvw5XX60oLVPYbQaNjYmCgculRZJwGP78Z50ZLJr9a9MmuP56XYbdroXE9HQ45hi9jB+vRUbQn0WtO1pit2uBMhDQwbI/+wwuuvgn8FmM9GNuuAHuuaftWE1ut45jc+WV+rvEi0kpKbBiBdx8M7z1VqK285OIRFYYZu4LdSu0KBNP5t4w6TUt4NhT2/8NWEF4pY24Vpl7Q+P6WNyjzL1g7H+g1wT927Kn6N9XsigLgvUsX+VmwiRXguXX+efDfffp3/WOZpa75x59PaPX0jB0VrNJkzoW+rqbKl8Vs9bOYt6WeZw28jTG9hnbLPQKgiAIws8dEYkEQRB+ocydC0cdpa2HogO2O+/UMVlCoR0fVEVjFoF2Q1u4UM/qL1wIq1ZpaxO/XweDHThQWxNE01K7XHrfQCDmzlZfr7NSbd2qBYfNj+6B3b8pYrkThKxRcMxiLegYto5jsySb5cl0amEHYM//gTF36UEyJmxH0OhWqHDERUdz+mun89ry17peHvDWGW9xwogTkt7eG/TyzMJnuGPuHZRsNHFvOpbBFX8iMzQcEycZGdoV6PDDdcYzW5xW9cwz2mUt6m5os2kB6dpr9XXfkcG+ZYHZp1Bb+/QUBQU6ZVrkeEcfDZ9/niiYtiQ3F/bZR7fR2lodFLs9l72fRCQCaNwIH+wH/iqgjf0KDoc9r4a8CVrEtAKAATY3BGpgy/s6U1pHDDwbDngcTFer+EJdoboa/vMfuP9+fb6jqeZPPVXHczrgAJ2BzLL07z8qLkZPV/zpiRcY167VIveaNfD004lC0c03w9VX6/ba1bbp87UvngfCAb4p+YaZa2YyfcV01lStabXNkYOP5JQ9T2HKkClJZTgMBotuq4UAACAASURBVPVPoKJCx1yqrNSv1dX6e9jtMUE9GiPOMGLCetQd2DS1uJ6To9tw9LV3b33uBEEQBGF7EZFIEIRfPkpF3IUstPVH/CuR0YmZ+NpsLbLrUNtUizfopTCtMOlgxlu3wosv6kHVmjVanOnVS8drGTsWRo6EAQMgP19vH7XwsayYe5lpxgJYh8N67L1hA8yfr/d5+GHYvFlbpNjtcPrpOnX5yJF68OLz6f2iLmymGfs7epzoMQ1DD9RCIUjxWFA1Hza9CWWf61gpgSrtCpPzK0gbAqn9UJ4+4MrTok7E2sd4by/wl3V+gpw5EPZpsShzpBaK8ieCIwusJi1QAToei0FzXJalt8PyOzou25YKZzTw/ur3OeGVEwjHWYOYhknvtN7tXsdAOEB5Y3mCC1uGM4NVl6+iMK2ww8OW1JVw3zf38di8xwhYAUJWCLtpJ2SFMA0Tu2nn5D1P5u8H/Z1RBaNa7R8O63YSbxl08snw/PM7wa2nrfPThf6J1wuTJ+t4XN2R/e0nE4kA6lbBhwdBsDp2z2qLlCL9O1AWeDfp30oyHPQy9D89uftdUuKrCWeHUQqKi7VY/d138O232m2vulqLwgUFOs5Qfr62IrTZYveEYFCLJ2Vlep/aWh13KDtb33vefVeLmDU1+npalg6Efcop+t6z//5aBPd6YxaLUUE76gqpVCze1apVOiD2v/8d3UaxaNsizn3rXJaXL28VnysZ0p3pnD3qbO484k4y3ZkEg/DYYzBjhj4fVVXaXe7UU+Hgg7WQnpOj6+1263MQf3+M3o/j76MOh65/Y6M+F/366fuwIAiCIOwIPSoSGYZxFPAAYAOeUEr9q8XnRuTzYwAvcJ5S6ofOyv2liUTRWX6vVy/RAVV00BRdWg7YogMtm013dFJS9OLx9HwAR6V0p62yUr/W1uoOSm2t7vzFzwhG6w6JA8To5263HkhGl6wsPQuWkfHLyqK0K7NihXYBqajQg/1t26CoSHdWU1L0NUpN1e/T02OpiqPXs2Vb9fm0VUh9vW4PjY16RnnjRj347NtXDxAGD9ZuKw4HWMqi0ltJSV0JHruHwvRCMl2ZnYshVfPhy3MiAXTCEA7AHpdD76Mig55or9oEw6HjamDE1gNaMAKw9ADLCiQKSenDIvv1PBtqNzB341yKq4rZULuBr0q+Ynn58ja37ZPeh8kDJjM4ezD9M/uzf5/92adgH8zoDSBQC/Ov0MGd/RWEmupZ2zCFNYEzWLM+k60VmWytSKW8yk1llYNg2Ibfb2CzG9jiRKFwWEWEAwuXI0xuTpCC3Ca+/cHD+k2pNDXp8+jxxGbBu5I5KimUorFxCwuKZ7JowyxWlXxGo68ch6EzLtgNcACDM4vYM28kQ3L3oG/mAEybCxZeB6G6WFGuAlaP3Mqir9dTV7KGQPUGzGAZfbNL6J1TRl6vEBnp4EzNwObOwDRN3R5NE8PQDV8pCxV5dW58EsNqiis/n4UTPmDi0xMTgmOnOFKYec5MDh5wcIdf9aoPruLR+Y/iC2lzFofpYEjOEOb9YR6pztYn+JmFz3DfN/exvHw5SiksZWE37Rw5+EimDJnC/K3zeW35awTDwebP+mb05fzR53Pdwdc1u8tE08evXBnLIDVihB7Y2u0/ratid4lEoAfTF1+sU6jviFDk8SS5f3eJRAAN6+GLk3Tsn5YxirqCPRVCkXLSh8GkN3RsL0cnZjhtxTdqyZ+A2o43CeCgjHzKyKeSXELYCWHHwsRGGDshnAQiW5SRSyU2IkJNJN6UUjrW2jPPaHfAhgb9LPH79fPG49HPmGHDtPjicMSsF+vrdVD0dev0Pcvh0Nu/sWAOTy14ilnrZlHpq2yn9gZtnQUV93/LrQel7cW+gct447qLEz77z3/g0ksTrTJ3BK9XP7+rqmJWSV6vvicrpV+jccGiz+7oAokiFMSsmKLnzjT1vmlp+pxGlz59Ei0Ruw2ltGVnqCGyRJIURJ/V0ckfZcVN8sQvNm0hZ08DR5p+3R43yt2EYFD3A6PWbFVVuh9nmrFsp+GwvsYOR2LMwraICr0QE2ijbSpq9ZaZHcaWtYVQWjHF1cV8VfIV7656l60NWwHondabX+/xa8YXjWdQ9iAGZQ2iT3qfVu7ZLVFK//5bLoFA6zFJNHZafJuPH1u5XLr/G12icfvi8Yf8bGvYxpb6LaysWMmy8mWMyh/FHr32oE96HwrTCnHuiFVyD6MUzfEC48ebLcedLcefTqeM0bqCZelnVHQJBBLPe8t7cvykavy5d7liS0+N+XtMJDIMwwasBo4ESoDvgbOUUsvjtjkGuBwtEo0DHlBKjeus7J0lEnmDXjbXbaakroSVFSv56MeP8AV9jCsax9g+Y+mX0Y+ijCJyPDltDmwbGvRMZnV1rJMyYQI88EDshhQ1rXY6Yw/l+JsXJM66B4O6rKYmfSPv1y8xc0h3Mm2atkhYsEB3Qux2uPVW7abQp48WdlJTYylro0JXex2QaGOPCmTZ2fq7REWn2lotLvh8sYw50aw50cCo0fMRT0sLheixvvkm9lAzTX28IUNaWzPEP8w6It7yIf76bSqx2BBYwFbje2qN9fioIJC5mmVlS6luah2o1W7a2avXXuydvzeFaYUUphUyMn8khw86HJddp32xLN0v9noTH3jxwkxHJvstz0/8ZzabbpfxHHOMjvPQHSilmLl2JtsatrGtYRtzfpzDJ+s/SbCQ2B5sho0ThpzFyNx96J1RyLCKCo5o+EviRlO+1sFXk2HxTbD05nY/Xrplf75M/665TUZnfx0Ofb2jHSCnMybQtvzNQqx9hcO6TUc7LPdVHsHq0JztOwlJMszhZPXAQGI9fvUQxh6Xtbm9soI0Zy4CWHorxrL2M2v971vXcvvb/8AfTmnuQH7+uRYYks1alAyBcIAvN37J6a+fToW3osvlHNTvIB47/jH27LUnZWUGffroejoc+l7z29/q1N3R31i0k7g9M/PRIOChENQbJYx+ZDRVvphFh9vm5qxRZ/HUCU91WpYv6GPoQ0PZEhdc2213c1C/g5j1m1nYTBshK8SbK97k9NdP365z0Rb3TbmPP/zqD6Q6Uykvh7/8RaccD4d1e83J0ff8s86KCLuWFpGTfeZE49REfytJ0Y0iUZRHHoG//lXXvyP3s5akpurv+/rr2vKjU7pTJAIdo2jFXbD01kgA9UDn+7SFKx9GXguLb9B1DNbr1/6nw8DfQP4kPbi2gmi3S3fM9TIZS6IkRKIukwUckAl3/0XHamoqA0c2KnUgxWX9WF3Sn7UlvVlR3Islq3NYtz6Vmjo7YcsgHDJQCux2hc2mSPGEGdivib2G1jBqWBlDi0p5rHYxX1e9r/sdkUHur4b156T+FzJl+GRyss3mfk60cx7fp1EKKr1VvLrsVV5b/ipNoYCed7DAUDau6v0gJQvTmf1pKuvWe6iuczFybwfjxsHw4YqiftAr1yA7B9LSjObnS9SSM/55b0Uy7lXXKKoq4csvFTfeFBtAmybMmdP6+Q6xgT8k9qWiTTb6GhWTkiF6n4gONtsa8LRMjBDtOzmdYPvx/zA2vqotQP3Vuo2PuhE8heAuBGe2FjdtHt0mDZOYBbCBFuiiB1PaCjTs00uoge/qain1VVPrr2XRtsW8u/pd6vx1+II+fCFvqzhwLXGaLtx2Dx57CmmOdA7vdwx79xpDpjuTgrQ8Diwa39wncDrbPm+BcIBtDdvYULOBHE8OvdN7k+3O7nQyTClFQ6CBKl8Vlb5Knl74NKsrVlPuLaemqYYqXxW1/tiPzsBItEJ1ZZDjySHbnU1eSh7DcodxwZgLyPHkkOvJJcOdKA4PH66t61rXI1FkaY9om41yxcwrWLB1AWur17EtIgLtKDnO3hR5htC78Whm/eO6hM9eeAHOOadbDsOibYuYtmwaW+q3sLluM7OLZ+9giQbj8o6g0NOX3ml9mJR5Lg3rR9DQoH/PVVV6MjZqmR39DUaFgXjRLV7ojV6XQCDWBwkGdfKS6urYpO2wYXqyxG7X46DoZHBKSuye1rIfGz/WCAR0PRsb9XLIIZ0/z6PtfmPtRnI9ufRO753cJHAP88QTOkSCYcTGUMcfH7vHRu9lLceFLcfk8X9H34dCOhtqPGecoS1Wfy70pEg0HrhJKTU18v5aAKXUHXHbPAp8qpR6OfJ+FTBZKdXhHaQnRaKb3nyOLzd/RkVgEyVNq6gIbtyh8pymmxHpo8n39CMrPJzXL00ccF10SYhHHm67hx0MqiRMjWMtdfGGjVzxxk14w7V4rVrW+3+g0eo8e0xHjM6cQLojk1RbJgvvfIjS9b2w2bXVhdtt0BCJeamUvvnoDlhrpb09gsGY8NPyJrP33jpNd3fQ0NA6TsE99+hBUHfw0EdvccVXJ3VPYW1gv6+UUG1+wrru9Aj9bN5mPpjTQElpE+s2elm4toL9hvWmIDuDvMxUstM9pHmcZGXayEw3sNsNTFN3YG2mEXl4KMKR1yafQX29iderqKmxuNPVfmAEm2HDZtgwTRPTMDExUZF/lrIIW2HCKty+uf+yk+G16c1vHbYASxc2MHxwk3YXCkeXuA6gssCI60xGO5rKgM+PT3DTGHjVj2woS4wv0Z3n3vjDOOi1CqoHQ/VAeqXl8qff9GFM4Rj2KdiH/LT8Dvev99eztGwpi0sXs7pqNfVN9Wyo3cC66nWUNpYy/8Lv2VqzmvLqVXy25i02li8mxYRU0yTPk0WWM40MRwouRwoOuxsTQ18H08RmmISVhWVZ+looi9+HF+BSemTdZMFnJYcybd1M3nvbQU2NgdsDewyHww4zGD9eZz+LWqW1NZMXfz+Lir9bt+rYRJ+Vv8FTK+5hC/MIkzggthkO0myZpNozsBvO5u6wHiooAlYTjaFaGsN1KBLbTqotk72dx1L6xBOUFHtwOHRn4OCDdaruoiJ9b4rOhEbdOtoaEMbfo6Oz9EpBY6iOQ17aj+Ka4oS22yulF+uuWEeGK6P1xVSWHphbQT1AMu18vvEbjn75eLyhWHAcj93D6SNPZ89ee3L313fTGGhstjZy2pxkOjO5YL8LGNFrRJvHsKkgZfVbeWLxi/xYu7E5k5rH7sEwDC761UVcdeBV9Mvsx9q1eoJg+nTtquVy6e9XVKQnCAYPhkGDtMtinz7gcQVwmH4sZRBSbhoa7ZSU6Ou5YYMeeCxcCEtXNxC2EoMxZ7gyWncakxCJ6v31CedYKdWqHJtpI80ZC8JVVQV33QUPPRTJtlbf9u/aZlOkpIDDofjHTX5+87sAKW57m5ZcrWinA1xbo5rbe3QgsF00bsRa+SDGuscAA0INGLR9f1SGQw+o7RmoPa/BHHoeOCJtL+SD0k90lrPSOdC4CWWLPIgjA3MjpY8Ojp3aXw/OTQeokLbY9G0G72adIS2CpaDeAk6raV5nGibprhYP4CQEtLAVpiHQkPCx++vf4Nr6XuI+Z7e4cPFqR0s6Ebl6X7qFbTU6GrvHHaKoSLF6TWKHJjoAi8/g1takQHR91PrG6aSVJZYafAGMe5LGxkQrjujMfjgM4ZC25AyF4uIR2Y3mv+12bYEdtoI89GgNmzYrKsoNtpYHOGC/FA6b5CY3x05hvo30dIPUNEVqKricRsTIVrdH04CwBUrpZ7qKs3Kvr4eXnmvgqecSr+PWrdplsDvwv5yHS+lJgJByEE4ZhOukFkpFND6dilO4DCMp91+jdRip7iNs8MEJX1Hq20qZdxtvF7/Kt2VfEeyikJtqT+XSUX9mcOZQCjwF/PndO9hg/6KbKx1jRP0ljAtcz+bNFrNnW7iyajnz+Dzyst3k5TjIy3WQkWbX7SdFhy6zmWCaRsKzMGypZsuUhgZobIC6OriwJM76xzJwqEzGDtiTUfmjGJg9kIGZA9sUy5RSVDdVs752PRtqNrC4dDEryldQ44/dX6gtYvD7awhbYYLhMHU+L+ed4+HC36ViGgY2m27npmFgmGC3ARhxFjIKyzIiz3GVMMkNcOITl7Ay7dFW5yzNmUZ+aj65nlzSnGmkOdNw22N93aZQEw2BBuoD9VR6Kyn3lre6nwFwU+L9a599YNGi7b2CbdPW2Oeiiy0e+b+2lV8rcv3aG3fqcxa7Ro1NAb5YuYwy31bKvFt5fc1zzC//mpAV3O66GhikOlL5877X0i99APkpvZn1/FAeeaB/wnbr1ul+R3fgdAUJBmL397hQhjtMIACjxvipqtTW+P5wgAkTFM88loayjIiIasSd2/i2r+Im9GPro+0z2jb79OlZka0nRaJTgaOUUhdG3p8LjFNKXRa3zXvAv5RScyPv5wB/U0q1UoAMw/gj8EeA/v37/2rDhg07VL92631z6xPutrvpn9mffhn9yPHkkOXOIt2ZnnBB/SE/1U3VVDdVU9pQyvqa9W2aKqth+jUYslPjzaK6z/V4+/+52dXM69UNKzq70plIFJ5/DcpbitOo5TtVwe0ZX7b5vUzDxG7YsZk2bKYNu2nHNEyUUoStMCEV0q9WKCFuRjynpsKRgQGs3zSG0oohVNX0AffxpKTl4PE4SU114HDZSE01yMo0cLrAbjOw2WODP8uCcAhCYYXfD7W1isZGRaApzHtbL8dWOoqwN5eQL4cURz6XXDgEK2wjM8tORroNt9vE4zFwu4nd+COqd/O5ssBSqnnW2uez8PrC3LDeQx/TIMVykqocZJip9M0aTLoznXRnGimOFNw2F067C4fNgWEYGIZ2L2meo4pzLwmGgwRCfnzhJj5dkMfziwyoK4L6PpiWndtvCnHMuAKGZPQl1WbTs76TJ+onpt2ue2SGoU2w3nqLkAqzsX4ba2tL8IaaCCuLMl8NJY0VlK14nasDTRQ0mijTwHBA6on/xcjojWHqnqLR3DAiGZgisVOi7VRFT04kI5PubCmUZWF/PJlp8a6RGkxhxEuf0dCUiqVsWMrkkKkF/P0f6W0+gJK14oouTy2/lzsW/LWNjYCwAywHhB1sfaiOQm/ifW1biknviwu0YIRKfDUssAXIcTdQVVcA/kzwp4M/AzOUTrojk3RHFunOTFxGKrOf/l9yvfUJ5VelZnDW5fei0EKLwiKswjQFgjqDlWrksoCf1RuLqGjoRVVDDmF3EadcMIpAQLtcRuNTRN3+Wt4DWj7Qo7M8Ph/UeZs4b23bUzwum4tMdyapjlS+++dGetUn/u7L023sf0sRDYEGav21hJpj88Toa4cTUrWLV6oBDn8Gbus86qv3ZcvmAqoqe1Fbk0FNbRpNgRRMmwtL2bHbtNBomAahoCIcVlhhC5vND8pLRoaXrKw61npWs059nHDMG//amzNGnsGeeXvGVha2EQQ58rQPW2E+3/A576x+J8Hly8DgynFXMiRzT374QXc8Nm3S7palpTHTersd/u+tQjJ9sfLrUwu4+6+6JxE/a97YqK3NfD4od33DNyMOizREjd2w89oJj3JUugvqV0P9Gh1nyVuiLSJCDSS4S0TcKK4os3i8TteaiJuk2+bArxJniz12DzcfejOXjL0EuwpB9SKo/BZKP9WvTaX6t29E3cr0Na+3YJEfPm0y+d5v8oPfxvK/lLYSsoJBLRQtWaLjxJSVVJEf+oBROe8xMHsJRdkbSXU1ELb0gMBmhqnxZlNSPZB11fuxtOYE6j2HkV9k5yZ/Fr6gD4dNd9AsZXHYoMN4/+z3E7NEtby2LXpxf5n1Fx767iHMSDydqKgcJWrmbymLc0adwyPHPZLQka+p0cGQZ8+GDz/UMXCCQT2g792viW29n6K+z9uYA79C2ZoIWSGGZA9h7RVrmwXNpUu1a96KFVoEi7pqfPljIb1Cie2y1l3AVWdta7YCjpqbV1XptmOacNll8PHHMcHA64WrrtL3grQ0fV9ISYE0TxO5gQ9wN3yNp/4zHE2rMSw/YKJsKfhTRtOUPpnG1IlUmhPx+ky8XjjykpngjA1WRo6Ej56cSG93mm6T3s1aAGrcBA1r9avlizwzwpH2aSeESZllkl+/BLvSg+EVAdgr0j2Lxr+ylMWk/pO4b+p9jC4c3fZ1jbu2ISvEs4ue5drZ11LbpK0jApHB9oCUbAapakY4YbADetugKKMv+bmjyEjJJ8XdC5czHbszC8OZg2Fz6WekYcPAxPzmPIxgDe2hAJ/fw5ptw9hS3YfKhlxqR76Azxez3g4G4ep7CklrSKx/Y1oeD1/5cfPv1sAiHArh9wVQwUacVDBj0G8Y6YJsE3Jt0MeVyqC+B5PmziHVnY3LkYbTnkLuEf/GrIw9T6xemYRePwzn5jfbrftyP4zsbF4zbIOwC5QZWYy4v0393Gu5mGGwN3Ho1sP5ZMatkQrpPsY9N/Rn7OhUbKYejJuGiaHirUhiD3TD0CJi7Ezr98pSKEMxfmIThW4/eenl9EqvIC+jnGnP10KoCbB0+7P8MPlfUNlisJ2bDl/cFDsQaEu5UGy7GQuPptGvxV2lDIyCyeQd9KeYZVbk9fBzCnHVxK6tP7uAj/87C6MmMnKPCFRKWShLYZoWCysWci0Pd3Lyu86Vpcfy4bu3Y6AIKxtKGdxy317sO9ps7gsADBxfiL0isV2GehWw6ZtNRMd1ltKTPvGDzT2n9ZR/OGAZ/OGLRyivzyMQclDvyyBv0GAuvKIIy4rFInM6YxZ6LfuEbfVzohb1ayoe47I1F21/vRS6/WNE2nrbm/1u6zGs+/RvoAzClg1/yMWVN/+KIUNidYeYGBx1u4yvf/zEWDgcm4AC6Pd9b75eO57qxmyqG7OpbOyNe8xfcThifRDD0BNV0XMT7xLX0lUp3LCNJl+QcNCPCnr5H/toCKRCUzb4svVrMAUjlEqmI5c0ezYeM50Upwu3w4lp2PREoWFiGjasyCStpXQftikYwBvw4w3Vk+9Yyg9FLUT7bqTf0nPZ9MGd6IulT/Q703LYb187GHoYpRQUjO6LrTyx3YfzCihfsoV4PSO+LRkGjHjcTl38/Ep03BB2No8dCDvZ+uhWCr2JEzHbUmz0/kM/mvt48eMHMwRmEFLbc1luh/g2qYwWY5I2Nv9bqc6+20P0pEh0GjC1hUh0gFLq8rht3gfuaCESXaOUmt9R2T3qbrb+ZahbSSyAo02bXkdjk6iwXvY9C8pbdDRy3PBQJ7brhhP2jVoTGeDI1PEAmsuPLPueCeVxVkB5WfDmMbDhpY7Lf8MG09vJQ7yj/AGY3GJdyxm89ujEpadNMvaA41b2XPkTXtRZXXqq/GOWQtbI7dsnSjIm/d157nsdDId9AM3m2tGbYby1jYL+I6C0RTDgTAMeTqIuBYfGfkPZY2DQuZH7ftydb8+pUB4XbDU/B945FdY91nHZeZPgyM873qa7XT+6q/yvz4eqeTSfd2c2HPhU5BrEqWbDJkJZC1ernBR4qJPgKHkHw5Gf9UzdVz0I869MXJdsu4TO22beIXDkp52XszOubbJlKwXlX+hnS8lbEKjWQbLDXkgbDLn7Q0p//RxIG6If+KZDC70qpMVl7xYtJv3wV71fFHcBnBw37RVuguIXYeW9erBv8+j9rSR9qgybducIN8GZ7bheKAVbZsKSm6Bmkf4uoTZmR9vCnqEHeYVH8EbBBZz75rn4gr5moSvFkcKxw47llVNfaRZ9OuK2z2/jjrl3JIh/HruHGw6+gWG5w7h0xqU0BBpoDOrYO26bm74ZfZl++nSG5AzpsOxXl73K5TMuxxtKjCU1vmg8tx7wCJ+8MZTHHtM6h9OpNY8zz9Sm6kOH6tnbqKs0tBbB24o74PHowcPYsVpwipKTo61M2qPlZFLL48W7fYStMFm3FNFgbMNupWBgAwNcDht37D2DvdLHNw86ovVqq6lv9K7kb8uPwBuqxcDAQtFkNeA2U5l++lu8tuJFpi2bRjAcJKT0STANk1xPLnv02oNUR+tBqUJR2lDKyoqVCRNWHruHvJQ8rjjwCn43+nfYTTtrKtewpmoN186+lo11Xbf4znJl8cDRDzAsZxjDcoeR68lNzgViV73nWGF0vJ6453bz3+jXosGtn+MF+bBpXYf1+ejHj/n7SxdRX7WVBidsS4uMZ7qKgsIGSA9AWgD+UXg6J980rfP9dtVz35bw2Z0kY+bQ1XNT8raeVIjedxWQd1BkVB0dm4S6PvbBBn2OivUBU/rD0Ata12vk8Yl9wLwceOck+PHJjotP6Q9D/xh7n9ofUvpFyo/UffSZreuelwVvHg0bXu68/n2PoTkG1qDf6UQBzSjY+8TEukNy5yZzFOz5FxJUgLQhNMfdInJDHn164rgw2fJNDxy3nOYJYmXp70Nk0jh6vxg+CcriHjT5ufDeGbCmE/GzJ92LAVxAx56gXefGG+Gmmzrfrqu/q7o1xO7H0Rgo9tbrRhza+ty/exqsfaTj8iPJUXoKcTdryU036VyqPUVqqp5u7im601Zue1GRmZ6+/duYIYzrgDT7j0d7zGYsmHCoAUJePRAKefWAwgrpG3zU+iVahorr9DRjxB2DyA9Sz3qS2hf8lbrcUKM+huGg2bomegON+rm3KrvFMZpv4KYWdEo/jg3swn7IPxgy99bbNQ94jMgA0J54LtY9DcVPd3x+428GVjDia+/XAzrLr/9Wocj3iNa9xaih+bxH6mLYtStC2kDi03W3S1dvlD/nzhP07H2hpx9SybAjZSsVceeL/K5C3ogwEYi5Bux9QuvOTV42LHmjtVAYxXRoASWZIKO76qChbhV8c4EWU0I+wNKd2X1ugaJfR1x3VMSNJwmfo7aCBp+ttOvPqvth2e36HhZq8YyJilG9DoKM4WBL0b/3sFffu8rmwronIvePCC0FKIBtH8P3F4NvS+tjbC/uApZOnM2U56dQ4a0gGDFPd9vdHDvsWK6beF2Hg/VXl77K/d/dT1NId5ANDNKcabx+2utMGToF0Ba+939zP9d/fH27FrLJUpBawIsnv8jhgw/n8MN17K2oAJSbEZkURAAAIABJREFUq4P+BwLdl1nK79dWTtXVeonGqwgEYrEmTruiEE9t4n3Vl1nA9P9sa2WVGQzGZqUPO7qOG764hucWPdfspgjauvCWQ2/htL1aBFJowafrP+WyGZe1EtCmDJnCI8c+QkFaAQCNgUZ+/87vmbYsiYF/O9gMG9NOncbJe57cqXijlKLSV8mayjXsO+YoPJV1CZ8HeuVQXbyc/NT85ISgjthV7zm7wrO2q/R03Xu6//1zLn9X6Ie0V/6u0O6j7go9QU+3m0MO0Zlpeoqf87hWxvwd0pMikR0duPpwYDM6cPXZSqllcdscC1xGLHD1g0qpAzor+2ed3ezn/ACHXWOwLHQ/P/cbZU+X35Ntc1e4J+yqVla7cvmdlV2/FmaO0aJZNF7MwHPhgP/T2XY6E4WSSjUO/LoYPj0WGtcnWhll7Akjr4OiEyOielhn9mnLQifUCK+mtV4ftQoLB7TFWPGzWpxuienUonjRCXoG1JGhBfRgLVQvhs1vQeX3bZZf7atm7ONj+bH6x4SPXDZXc+D+lgTDwQRxA3S68YUXL2RwdutgBSvKV3DCKyewpioxKIlpmNjixHGFauVWaWBwzqhzePLXT+K0awXo8cd14GvQsVpMUwfDPvvsWNwYj6dr2Z68Xu1KlhQ72O7nb5nPcS8dx7bGxPuDzbC1m40nZIWaBb0oqY5U3jrzLY4YfES7x1qwdQGPzX+M5xc/T9gK0xRuwm7YOX748aypXsPysuVYWHhsHooyi7jsgMv4zT6/IceTk9R3acXueM+BXeN50lV+znX/udPTfcCfu1DRkyKRtMtfLj/ze1qPiUSRwo8B7kfbtT2llLrdMIyLAZRSjxh6Kuc/wFGAFzi/rXhELflZi0SCIAjx7AoPkV/igKqny++s7CU3w5JbID6g8ImbWpiod0AyqcZBCzKhhpiLqDMHxj6kxSHTmZyFUnvHi1opfXyEdolsKRD1PR6G/QnyD9GWY/Y0HdE0HiugLc1ey2y7fCAQCnDgkweyYNuChI/ddjcuW6JQFLJCze5jUfJS8lh8yWIK0zqOoLu8fDmXvHcJ87fOpzHYiMfuYUDWAN4/+31+2PoD5711Hr6QDwMDp83JpQdcyg0H39A66DLaMufDD3Xq9fnzdUyrYBAOOAD22gsG9AsycvAWBhVsIsO+CaeqxGaGsJs6g2DYshNWDoIqHZ9RxMbKfiwv7sePG1O4994Ov0aMbmj3gVCAM6efyZsrW8e6sbWwLtUxKRLLnlA0gffPeZ8sd1ZSx/MHGvhg+Uu8PP8/bK5YQq4NMk1w2+xMKBrHYQMn0y9zgLZ0M53a/daVC87cyGtW20JnS3bVe86ucL8XBEEQhE7oUZGopxCRSBAEoRvZkQFVTw56kh3w7IoiUfnX8PHhicLK6P+FPa7QcX86I1lLouaw+uhyp36v3ctsbVvhtEtbItGZIfjiRNg2J/F7uPNh/IuQd6AWhrpafov4VXfOvZMbP72xORW1y+biqgOv4uhhRwOwuHQxV394dfPnTpuT3+7zWx497lHMZPN0A7PWzuKi9y6iwluBN+jFYepEBf6wH4/dw5GDj+TBox9kQNaA5AoM1kPpJwRLZmNt+QRboASbVUcYN2HlABSmOwfDmYFh6KQFKhxChZpQvjKUZWEaYWyGD2W4ME9aj+HO6/y43djut9Rv4eL3LmZO8Ry8QS8um4uC1AJm/3Y2Ga4Mpr4wldWVq/GFfKQ6UhmVP4pnT3qW4bnD269D9Q9Q8Q2Ufwk1i6Fxg25HaUMgfThW2kDCjhxMmwvTnophc2sXzHBAb2c1RWJylUBDsXbf9G2Gk7dqd8ieODc/Z7cVEJFIEARB6BZEJBIEQdjd2VVFol1lQNVV14+S9+Db30OoPiay5E+GsQ/qQNVhPzjSk7OMiGKFteXQ+pdh4dWJsYEmTYfex0Bc9q52SUaE2u9+WHRdohtb1mg47CNwZmpLj2RJQiQCWLhtIVNfmPr/7d15mFTVncbx76mq3tn3HdwgLqOoYMQ9EHdDQIxBTQZjEiYbEzHJmMRMJjrR4K4PmonGZQyM22g0mmQUJRGNuCKCjeKCgoBsirTN2kud+ePcXql7q+h7Crro9/M89VDddL91urp+3Fs/zj2HTds2UZOuoSxVxn2T7mNot6Ecf/fxbK7Z3LhV7v3n3M+Zw8/MfQzN1KXruH3B7fx87k/pUV/N/sWG4V0HM23UVEb02A+Sxe7nS3VymyiU9tv5dbBuHiz+d7dzXKLE/V6KOkP/U6HfqdBrNJT2d7Nh0jXB2nrNfuZE0i0q+sgA2NFsIeFM60Flkofm6BPvPcGFj15IdU0122q3UV5UTiqRYkvtFpImSWmqlJlnzORr//S1zOv62DQsvQmWXg+1nwXr/CVh3ymw/79A5xFunbJ0rWsIJcuiX//pOnhk4K4/P+21SaQmjoiIFAA1iURE9maF/KYn7uKyucjlWBdnd7O6bbDs9/D+PVBV6RaKr90Mpb3crny9jnGLSVcMDRoKXYPF9pNNi/XXfOoWi96y3O2+ueEfsGaO+/sGRV3dG+dkDg0iyO1ytlSnljuXpSpg/Ptt23I1xyYRwMdbP+bMe8+kcn0lW2u3UposJZVIsbl2MyXJEvpU9OHpf346fBZLmHQdrH8WPnnZ3TYtxm75kBprIZGiOFmMabHQP4BxzTyTcDO0uh/uNiT45AX3O2hooKU6wZE3w7AL3EYCRV1yH1er5+aNf4c1rZ6ugzbAoJbrMOfklQHwaVnLzx1R15tey9dn/gZgW+02fvXMr5j58szGtZ/KUmV89eCvcsOpN9C9rHv4A755rdt6vPmOeme+CRXDIFUW+m2Ncp1Bl20XxXzPLhQREdmLhTWJclzEQERE2rV8Nojynd+3b/7z8y1V5i4xG/GvbmbFhhdg/TOwqdJdPrPuGajdFKwfVESLbXCBxh0K0zWuKVTSE8oGuN0O65p1DYq7tWwaZVPaN/ub8VYLFHPYjNwuL8v5UrnMepX34vmLnmfaX6fxh8V/YGvtVhLpBOVF5Rwz6Bge/urDdCnZhSZM9Xvw1vWw4t5gN75tjTu5GZOgpNMw6Hqwa2QkS92uj+ka1wCqfheqlsC2Na7JV1W5c36iGM5a6taDSpZkv9Qvy/Nz6tlQVQxFwSS6NNBjO3xw086vjiiv9YcTvgElzV4WW4vgx69v4aqI7ysrKuPqk6/mwpEXcvYDZ1NdU81D5z7E0YOOzv6gXQ9q2lG0Ybe8Dc+757a+xs3Qim0XZt6JiIiIN5pJJCKyNyjkmUTtRZyZRNlk+v307gGVj7g32okidylT2QDXIGoYy0tTYdldQEMHwMDEj6AsevHmnD0xCjYuaPo41RkmbchtraNcF93ONhsEuHvhXVz9f9/kiFKYfMApnLXfOBL124NLwcrd7Kauh7gZPq0bEDs2wgtTYO3TwaVeQdOi076w7zdg6FehfCjYGncZX7LEzeAi4Rputs41ixIl8GDElmNlA2H8e7nP4srSJLriE7i6upyttU2X+VUUVfD3KX9n9MDRuT0GMPXxqdy18C7qmzUPS1OlLPnekoy7wHlTtRTemQnLZ7tGoylyTcmh50CfL7iZc6X9g5lyNUDU6yDhnldb69Ym2vQGDDkn+xg0k0hERKTNdLmZiIhIlHw2idr6ZnZTJTx5VMsFpfufCsf/0TVP4rAW7i9uaqoADDwLxsx2l8NlE7dJ9Nm7sOI+WDsHNi6k3qZJYyjCNmv2JN3ObSYZzPzZ7tZ56jsWBk+Ein3g6RPdDCAbzIgq6w9H3w29T3CzXXZlce9sP9Mhv4CDfgaJUreWVgyf7fiMgTcMZHNN06V+SZPkwpEXcsf4O3LKqKmvoec1PXfKOPfgc7l30r2xxpcza2HrStj4Gnz2lvtz6yqo+QRqqtzrtLiHW5coWRLMpit2l+ula9ylmnVb3ddjoaiba5Se/Gz2x1aTSEREpM10uZmIiEih6XaIa0q8OaNpXZw1T8Ir34HRvwtmIBW1LTtd6xYgbq60n2vK5Iu1sPKPsOQq11BI1zU2d5LBraV6N/unuaolUPWmm2FV1Al2bGj6OTrtB6c875oSbX1eWus8wu22VbcFKn8NKx+BA38Cg8YHzY664PKzLDOM0rWuIWKARDFdSrrw4zE/5pr51zTOJqq39dxfeT+3nnErJansza2/vPMXTKuL04qSRfx67K/b+tPuOmOgYoi7MSHz16Rrmxa4briZpLslit3aTq0Xto4zOzLbOmcdYWakiIhIG6lJJCIi0p4d8guorYJ3f9s0o+iDWW7XrSOuc7N/bNpdkpWL+h1ulk71sp3/bscnrumRi1zWO2q+rsymJTD/Atj8Xsvd2sA1C7of7naF6zfW7RSWLA9mmmxxC1Cvm+saZABYqN/ibs19/k4o7p3bLJ9c11Q6cwms/7vbaW714+55e3UavPRt1xjpdihUDIaKfaHLAUGDqhgwQWNoC2xe5tY92roSqt+BTxfDeTVMHzOd6+Zf1/IZMwkef+dxzjko++VWM1+eSXVNdePHSZNkwogJ+b3MrC0SRW520K7I5+Wz+V7DTUREpIDpcjMRERFon5ebNbf6L27tnfrtLZsjZf1hwFnQ50ToPQbKB7uvaZhdY4xrWtRtdusPrf2ba7hsXOAWcq5a0pRV3MOtebQrl2jlYuWfYP75QZOr2c/c62g49NfQ+5hgu/TizDNy0vVu/A91i36cSZ9ASY/cxpSlSfSTDXDjJoL1i5ye5T158xtz6bllKWz+wDW8qt9zzZ9t64Jd4tI0LT1tqbWGkR/C2zUNP7cBA6fvfyaPn/84lz9zeYvZRAAnDD2BeRfOixz+us3rGHrTUHbU72j8XGmqlMrvVrJfj/1yew7as3yus6aZRCIiIrrcTEREpKANPBMmrHSXWb15FdRWu6bLtjWw7PfuBm4GTlk/twaMSbqvqfkUdnzcKtDA4EluZkvDDmc1G93lYIMn5r5AczYf3Asvf6vlukolPeHzd0G/cU0zoJIRW6cnkrmtk7T6MRg6Obexnx3dJDh75Qvc8oexbK9r2ua9ansVP39hJreddVv4N1obXFKVhkSK3748kxUrLqOehsaepSxZxuR/mgzA9DHTufb5a1tEvLjyReZ/OJ8+nfqEPswdr7VctyhBggkjJuwdDSJQE0dERGQP0UwiERERaP8ziVp8XxrWP+u2HV/3N7dYcMNuYOntwSVjzdYbMim3e5cJLoHqciD0PdGtrfP48Kb1jsDNJhr/fm5NmWyql8FfD22ZX9oXznjDrUOzqzOWMi0snSh1PzO4htNJf4UeR+Z++V2E3zz3G6587kq21DbN3CpNlbLoO4sY3nN41u/ftH0TQ24c0uKSsNJUKeccdA6zJs5q/NwFD1/AvZUtF5ouThZTHLGV/JaaLdhWO4a9/f23Gd4r+7hEREREtLuZiIhIlEJqErWW6dKcnhXw9A8g1cnNrCnpDT1GQZfPuZk5DRb/B7x1bcuZPn1OghP/BMmKll+7K+p3wLwvwdq5NDasTBJOme/WH8q2sHSuawYNOBPW/b2pEWVSMGKaW/A7WQLJTru2E1m61u28tXU16c4HMPaesbyw6gVq6msAt+7PuH3G8eTXn8wSBBc/cTG3vXob2+tdE8tgGNZtGJXfq6S8qGl3ulWfrWLwjYNzH2MGg7sM5sPpH8bKEBERkY5DTSIREZEohdwkipNfv8NtI//p66450qDz/nD8I1AxzO0itivqtgRrKH3dLT7dYNBEGHMPFHXOnpFtO/oG59XDO7e4ncfqt0NdMGvHJNw6TYMnQc/R0Hm4u6Stfjst1kUyCff5mo1Q9RZsmA8f3g+b3oDzLR9v/ZgRt4xg47aNjd9SmirlltNv4cgBR4YO66Pqj5j4wMTG5hJAeVE5r377VQ7sfeBOX3/Sf5/EvBXR6xBFmfvPcxm7z9g2f7+IiIh0LGoSiYhIx5TPBXAht0Vw23OTCNz6Rk8e7Xbhat4oMgnY/1/ggO9D5/3cLJuwBk9NlZuxtHEBvPkbWP1nKOrqdmZrMGYW7PO13MaUa5Po/OBnTNe5NYnevQ3Wz3OziNJ1rS6l6w7lQ9w4E6lg97Rt7udunEllgkvVDJz7GQBPL3uak2ef3OJhEyZBp+Lw5tnW2q3Utdopbsa4GVx63KUZv35l1UqG3DRkp8coyjDjqvli1aBZRCIiIrLr1CQSEZGOKayB4lO2Y2l7bxIB1H4Gz58P657ZeWt5cJerDTgDhnwFKoa6RopNux29qpbAh/8La59qub196ybR8Q+5mT25yOlyswScX5/hZ6l2M4Gqlrj1mjYucFvQ11W7S95Mwn2vTbtFpql3P1+Xz7lZR90Oczu/9Ti8MTLuTJ9BXQaxcvrKyK/55p++yazFs6gNFhIvThQz44szSCWa9hlZtG4RsxfPbmwUpRIp5l80n9EDR7d5bCIiItLxqEkkIiIdk5pEubMWls+GBdPdYtB1GZpFuyJR0nJm0n7fgiNv8rKodM4yzSTr0xs+WOgW+k4Uu8vNIhaJBqhL19Hj6h4tFqE2GDqXdMbQ8vmvrqkmbZsWDk+aJKsvWU3fTn0jH6NqexWDbhjE5trNAHQu7szdX76bSQc1NdbG/WEcf/vgb425kw6axAPnPBCZKyIiItJaWJNoF1ZyFBERkb2aMbDP12HiR3DEjVA2EJLlrtmTq4av73YYdBnR8u9WPOBm+exOmS41XL8BygdCaW+3i1uWBhG4GTuLv7OYzsVNl9sVJ4s57+DzeOrrTzXeLj32UooTTXklyRLmXTgva4MIoGtpV350zI8oS5UBrtk08+WZTcPesp7nP3y+8eOiZBFXjr0ya66IiIhIrtQkEhGRvVvf7G/O23X+npAshv2/DRNWwmkL4NAroOfR7pIsk3S7nqU6u1uy3O0oVjYQ+p3smkvj34czXocjb3azdBrUVcMzZ8SfobSHDOs+jEcnP9rYxNlRv4NZb8xiaLehjB44mkP7HsrNL93cuJtZeVE5N59+M8cOOTbnx5h+9HQSpun07MVVL7J2s1vzavbi2Y1/l0qkGD9iPPv32N/XjyciIiKiJpGIiOzl1q51l1Hl65Zt0epCZgx0/RyMvQFOexHO2eDWAJq8BaYVw2mvwFlL4avbYeIqGDsHDpgK5QPc9/c9Cfb/rmskNfh0IcwdB1tXtb1ZVL/DrYW0B4zdZyzTj57euIV9XbqOS59yi1Hf/NLNjZejlSRLOHnfk5l6xNRdyu9a2pUfjWmaTZQwCWYtmgXAra/cyrY6t8B2KpHSLCIRERHxTk0iERERiZbxkq1P3OVkFYMhkQz/3iOug+HTWjaKPnkJHtsfFv8Saja5S9DqtoVngNtZrabKNYhW3AuPf65tP4sHV3zhCg7ufTCpRIqa+hruX3I/81fO54p5V7C11u2m1rO8J7MmzsK0YU2sS8Zc0jhjaFvdNm595VYWrlnYOKNIs4hEREQkX9QkEhERkfwxBg6fAUfdBqkuTesbpXfA0hvgoR7w1HHw+r/Bmidhx0a3Hb2tdw2h2mq3O9mbM+DZCfBQN3jxIti2eo/9SMlEkkcnP0pFkVuAu6a+hnMePKdxy/uyVBl/Pu/PdC7pHBUTqvVsoo+3fsyVz13JjrqmHc00i0hERETyQbubiYiI5Fuh7G6W7/wdG+GNy2HZnS4zziVjiVKYnGX2EeT1uZmzbA4T7p/QeAkYuHWIZoybwbTPT4uVXbW9ioE3DGRL7RYSJEgmktSma7WjmYiIiHih3c1ERERkzyrpAaNuhkkbYNRvoffxbhHsZAWkOkV/b6LEzUQyRdD1YDj457tnzBFO2e8Uvjf6e43rExUlijhp6En84KgfxM5uPpsoTbpxlpJ2NBMREZF80kwiERGRfCuUmT57It9aqH4XPn4BNvwDtm9wM4zqtkCy1DWPirpAz9HQawx0HwnJkvYxdtzC1aN/P5rX175O7/LevDPtHbqVdvOS3Xw2kcGQMAnOPvBsHvzKg17yRUREpOMKm0mU2hODERER2Wv065d5Yedc5LKocd++e/8Oal2Gu9u+U/b0aHZZKpHiscmPcdzdxzF74mxvDSJws4kuGXMJVz13FWmbpihZxFXjrvKWLyIiItKaLjcTERGJo60NovaSL7EN7jqYFRev4Pihx3vPvmTMJaQSKSyWLw3/knY0ExERkbxSk0hERESknepW2o0ph7kZVppFJCIiIvmmJpGIiIhIO3b9KdezcOpCzSISERGRvFOTSERERKQd61TSiZH9R+7pYYiIiEgHoCaRiIhIHH37FnZ+IevXzy18HXULk+37jHH5IiIiIh2IdjcTERGJY2/eeay906LhIiIiIl7FahIZY3oADwDDgOXAudbaTzN83XKgGqgH6qy1o+I8roiIiIiIiIiI+BX3crOfAnOttQcAc4OPw3zBWjtSDSIRERERERERkfYnbpPoy8A9wf17gAkx80RERERyo/WgRERERLyKuyZRX2vtGgBr7RpjTJ+Qr7PAHGOMBW6z1t4e83FFRESko9N6UCIiIiJeZW0SGWOeBjJt73HZLjzOsdbaj4Im0lPGmKXW2mdDHm8qMBVgyJAhu/AQIiIie6F+/dq+gHLU7l7gZsqo0SIiIiIigaxNImvtF8P+zhizzhjTP5hF1B9YH5LxUfDnemPMI8BRQMYmUTDL6HaAUaNG2ew/goiIyF4snztsrVuXvZEURU0oERERkb1K3DWJHgOmBPenAH9q/QXGmApjTOeG+8ApQGXMxxUREZH2TlvIi4iIiBSUuE2iGcDJxph3gZODjzHGDDDG/DX4mr7AP4wxi4CXgb9Ya5+I+bgiIiIiIiIiIuJRrIWrrbWfAOMyfP4j4Izg/vvAYXEeR0RERERERERE8ivuTCIRERGRzLSFvIiIiEhBUZNIRESkPctno6VvX7A2fzctWi0iIiJSUGJdbiYiIiJ5pkaLiIiIiOwmmkkkIiIiIiIiIiJqEomIiIiIiIiIiJpEIiIiIiIiIiKCmkQiIiIiIiIiIoKaRCIiIiIiIiIigppEIiIiIiIiIiKCmkQiIiIiIiIiIgIYa+2eHkMoY8wGYEWe4nsBH+cpW/l7Llv5ey5b+Xsuu9DzC3nshZ5fyGMv9PxCHnuh5xfy2As9v5DHXuj5hTz2Qs8v5LEXen4hj3135A+11vZu/cl23STKJ2PMq9baUcrf/fmFPPZCzy/ksRd6fiGPPd/5hTz2Qs8v5LEXen4hj73Q8wt57IWeX8hjL/T8Qh57oecX8tgLPb+Qx7478sPocjMREREREREREVGTSEREREREREREOnaT6Hbl77H8Qh57oecX8tgLPb+Qx57v/EIee6HnF/LYCz2/kMde6PmFPPZCzy/ksRd6fiGPvdDzC3nshZ5fyGPfHfkZddg1iUREREREREREpElHnkkkIiIiIiIiIiKBDtkkMsacZox52xjznjHmp56z7zLGrDfGVPrMDbIHG2P+box5yxizxBjzQ8/5pcaYl40xi4L8y33mN3ucpDFmoTHmz3nIXm6MecMY87ox5lXP2d2MMQ8ZY5YGv4MxHrNHBGNuuH1mjLnYV37wGNOD32ulMeY+Y0ypx+wfBrlLfI07Uy0ZY3oYY54yxrwb/NndY/ZXgvGnjTGxdhEIyb82eO0sNsY8Yozp5jn/P4Ps140xc4wxA3xlN/u7HxtjrDGml+ex/8oYs7rZ6/8Mn/nB56cF/+4vMcZc43n8DzQb+3JjzOses0caY15s+DfNGHOU57EfZox5Ifh383FjTJcY+RmPUT7qNiLbS91G5Hup24h8X3UbeX4Qp3Yjxu6lbqPG7qNuI8bvq27D8mPXbkS2l7o1Ied9Pmo2S76vug3Lj123Edm+ajbynDtOzWYZf+y6jRq7p5oNG7uvmg3L93K8jcj3ebxt8V7KV81G5Hs7Rw7J93mO3DrbS82G5Tf7fOxz5JDxeztH3iXW2g51A5LAMmBfoBhYBBzkMf8E4AigMg9j7w8cEdzvDLzjeewG6BTcLwJeAo7Ow89xCXAv8Oc8ZC8HeuXptXMP8K3gfjHQLU+PkwTWAkM9Zg4EPgDKgo8fBC70lH0IUAmUAyngaeAAD7k71RJwDfDT4P5Pgas9Zh8IjACeAUblYeynAKng/tVtHXtEfpdm9/8V+J2v7ODzg4EngRVxaixk7L8Cfuzp9Zgp/wvB67Ik+LiPz/xWf3898EuPY58DnB7cPwN4xvNz8wpwYnD/IuA/Y+RnPEb5qNuIbC91G5HvpW4j8n3Vbej5QdzajRi7l7qNyPdSt1HPTbOviVO3YeOPXbsR2V7qlpDzPh81myXfV92G5ceu24hsXzUbes4dt2azjD923UZk+6rZrO9HYtZs2Pi9HG8j8n0eb1u8l/JVsxH53s6RQ/J9niO3zvZSs2H5wee8nCOHjD92zbbl1hFnEh0FvGetfd9aWwPcD3zZV7i19llgo6+8VtlrrLWvBfergbdwb/595Vtr7ebgw6Lg5nXRKmPMIOBM4A6fufkWdPtPAO4EsNbWWGs35enhxgHLrLUrPOemgDJjTArX0PnIU+6BwIvW2q3W2jpgHjAxbmhILX0Z16wj+HOCr2xr7VvW2rfbkpdj/pzg+QF4ERjkOf+zZh9W0Mbajfg37Ebg39qam0O+FyH53wVmWGt3BF+z3nM+AMYYA5wL3Ocx2wIN/9vYlRh1G5I/Ang2uP8UMClGftgxKnbdhmX7qtuIfC91G5Hvq26jzg9i1e5uOPcIy/dSt9nG76Fuw/Jj125Etpe6jTjv83WszZjvsW7D8mPXbUS2r5qNOueOfbzN5zl9RLavmo0cu4eaDcv3cryNyPdStyHvpbzUbFi+z3PkkHwvx9qQbC81G5Yf8HKO3J7eJ3fEJtFAYGWzj1fh8WRndzHGDAMOx3WnfeYmg+mb64GnrLVe84GbcEWU9pzbwAJzjDFBVl/IAAAHCUlEQVQLjDFTPebuC2wA7g6mAN5hjKnwmN/cZNp44AtjrV0NXAd8CKwBqqy1czzFVwInGGN6GmPKcf/7MthTdmt9rbVrwJ08A33y9Dj5dhHwf75DjTFXGmNWAhcAv/SYOx5Yba1d5Cszgx8E04HvijtNOoPhwPHGmJeMMfOMMaM95zc4HlhnrX3XY+bFwLXB7/U64Gces8HV7/jg/lfwVLutjlFe6zZfx78c8r3Ubet833XbPN937WZ4brzWbat873Ub8rv1Vret8r3Wbqtsb3Ubct7nrWbzfV6ZQ36b6zYs21fNZsr3WbMRz03sug3J9lazWX6vsWs2JN9bzYbk+6rbTO+lfB5n8/1eLVt+nGNtxmyPx9md8j0fZ8Oem3yeI2fUEZtEJsPnvM6WyTdjTCfgYeDiVt3R2Ky19dbakbgO7lHGmEN8ZRtjzgLWW2sX+MrM4Fhr7RHA6cD3jTEneMpN4S7T+C9r7eHAFtx0Tq+MMcW4A8j/es7tjvtfhn2AAUCFMeZrPrKttW/hpoY+BTyBu4SzLvKbOjBjzGW45+d/fGdbay+z1g4Osn/gIzNo/F2Gx6ZTBv8F7AeMxDUxr/ecnwK646Z7/wR4MPifSN/Ow3ODF/c/s9OD3+t0gtmMHl2E+7dyAe5ylpq4gfk8RuUzOyrfV91myvdZt83zg/F6q90MY/datxnyvdZtxGvHS91myPdWuxmyvdVtPs/79nR+3LoNy/ZVsxnyD8VjzYaM30vdhmR7q9ksr5vYNRuS761mQ/Jj122+30vt6fw4NRuV7aNmM+X7PEeOGH++z5Ez6ohNolW07NwOwt9lN3lnjCnCnSj8j7X2j/l6HOsupXoGOM1j7LHAeGPMctxlfmONMbM95mOt/Sj4cz3wCO7yQh9WAaua/U/GQ7imkW+nA69Za9d5zv0i8IG1doO1thb4I3CMr3Br7Z3W2iOstSfgLmfxOZOiuXXGmP4AwZ9tvmxoTzDGTAHOAi6w1uazOX0vMS4bamU/XHNxUVC7g4DXjDH9POVjrV0XnFClgd/jr24brAL+GEwBfxn3PzSxFhZszbjLOM8GHvCZC0zB1Su45rHX58Zau9Rae4q19kjcSfeyOHkhxygvdZvv419Yvq+6zWH8seo2Q7632s00dp91G/LceKvbiN+tl7oNyfdSuyHPvde6DTKbn/d5P9bm6bwyNN/n8TZi7F6Otc3yG/4zz+vxtvn4fR9vWz033o+1GX6vXo+1rfK9H29bPfc+6jbsvZSvms33e7XQfA81m8vY49TsTvnALPzVbMbx74Zz5Iw6YpPoFeAAY8w+wayNycBje3hMOQm68XcCb1lrb8hDfm8TrCZvjCnDNRaW+sq31v7MWjvIWjsM97z/zVrrZTYLgDGmwhjTueE+bhE0L7vMWWvXAiuNMSOCT40D3vSR3Uo+ZiKAu8zsaGNMefA6Godb28ALY0yf4M8huIN3Pn4GcLU6Jbg/BfhTnh7HO2PMacClwHhr7dY85B/Q7MPxeKpda+0b1to+1tphQe2uwi2kutZHPjSe0DSYiKe6beZR3MEcY8xw3MLzH3t+jC8CS621qzznfgScGNwfi+cGbLPaTQC/AH4XIyvsGBW7bnfD8S9jvq+6jcj3UreZ8n3VbsTYvdRtxO/WS91mee3ErtuI/Ni1G/Hce6nbiPM+L8fafJ9XhuX7qNuIbF81myl/oa/jbcT4Y9dtxO/VV81GvW581GxYvpfjbcRzH7tuI95LeanZfL9XC8v3UbMR2V5qNiR/kq+ajRh/vs+RQwfU4W64NVPewXVwL/OcfR9uKlgt7oXyTY/Zx+EujVsMvB7czvCYfyiwMMivpI27BuT4WCfheXcz3LpBi4Lbkjz8bkcCrwbPz6NAd8/55cAnQNc8PeeX4/5hrMR1vks8Zj+Ha5otAsZ5ytyploCewFzcgXsu0MNj9sTg/g5gHfCk57G/h1sPraF227y7Qkj+w8HvdjHwOG5RXC/Zrf5+OfF2N8s09lnAG8HYHwP6e84vBmYHz89rwFif+cHn/xv4Th5e88cBC4Laegk40nP+D3HHw3eAGYCJkZ/xGOWjbiOyvdRtRL6Xuo3I91W3Wc8P2lq7EWP3UrcR+V7qNuq58VS3YeOPXbsR2V7qlpDzPh81myXfV92G5ceu24hsXzWb9Zy7rTWbZfyx6zYi21fNhj43nmo2bPxejrcR+d6Ot0HeSTTtgOWlZiPyvZ0jh+R7O0fOkO2lZsPyW32+zTUbMX5v58i7cjPBg4uIiIiIiIiISAfWES83ExERERERERGRVtQkEhERERERERERNYlERERERERERERNIhERERERERERQU0iERERERERERFBTSIREREREREREUFNIhERERERERERQU0iEREREREREREB/h8PR3Xp7HUgjgAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1236,7 +1133,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1255,7 +1152,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABG0AAAB+CAYAAACeY+zhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3dd5xcdb3/8dc507fvZnfTGy0klFASigIiosAVQVREASv8sN57bajgVVGxIigg3It45aKoIFIE6UUQCElIIaRBQoCUTbYl26efc35/fGfL7Gwv2V32/eQx7M53zvme7+zOTs75zPf7+Vie5yEiIiIiIiIiIuOLPdYDEBERERERERGRXAraiIiIiIiIiIiMQwraiIiIiIiIiIiMQwraiIiIiIiIiIiMQwraiIiIiIiIiIiMQwraiIiIiIiIiIiMQ/7BbFxeXu7NmzdvlIYiIiIiIiIiIjL5rF69ut7zvIru7YMK2sybN49Vq1aN3KhERERERERERCY5y7K299Su5VEiIiIiIiIiIuOQgjYiIiIiIiIiIuOQgjYiIiIiIiIiIuOQgjYiIiIiIiIiIuOQgjYiIiIiIiIiIuOQgjYiIiIiIiIiIuOQgjYiIiIiIiIiIuOQgjYiIiIiIiIiIuOQgjYiIiIiIiIiIuOQgjYiIiIiIiIiIuOQgjYiIiIiIiIiIuOQgjYiIiIiIiIiIuOQf6wHICIiIjJqGl6B5lfBiUGoHCpPgUDhWI9KREREZED6DdpYlnUZcBnAnDlzRn1AIiIiIsNWvxLWfgP2rQbLB55rvuLCwm/Bof+p4I2IiIiMe5bneQPeeMmSJd6qVatGcTgiIiIiw+Cm4PmPwp7HzewaejjP8eWZAM4p98K00/f7EEVERES6syxrted5S7q3K6eNiIiIvD24afjXhzIBmyg9BmzAPJZugWfPhdrn9usQRURERAZDQRsRERHpUSoFf/gDnH46HHkkHHccfPazsHnzWI+sB54LL1wINU9nAjYD4EThmbPMUioRERGRcUhBGxEREcmSSsFvfgMzZ8KXvgRPPQXr18NLL5kgzjHHwJlnwssvj/VIu3j5Stj90MADNu3SbfD06RDdPTrjajdtGljW6N2mTRvd8YuIiMiYUNBGREREOiST8IEPwLe+BXV10Nqa/bjjQDwOjz8O73wnPPbY2IwzS/NrsOWGwQds2jlxWPWlkR1TdzU1E7t/ERERGRMK2oiIiAgAiQT827/Bv/4F0X7iH55ntjnvPHjoof0zvl4HsvwScBPD6CNl8uCIiIiIjDMK2oiIiAiOY5Y8LVsGsdjA94vF4Pzz4ZFHBne88+48jy/84wuD26knu+6HxpdNTpvhGOosHREREZFR5B/rAYiIiMjYu/56WLlycAGbdrEYfPzj0Ng48H2e3/k8ZZGywR+sKycBKz9n8tKIiIiIvA0paCMiIjLJ7dgB3/1u/0ui+hKPD3xbz/NojDWSclJDPyDAjr+CM4Qokxj7VptbqgUChVC2BMqOGetRiYiISBcK2oiIiExingef+pRJQDwciUGklNndspu0l6Y50UwinSDkDw3toBt/CunW/reTTk4CdtxtfnZtb5k2NwV2wHxfMB8WXQFzzgdfcMyGKSIiIoZy2oiIiExi995rSnmn0/vvmBtqNwDg4fFq/atD62TfGmjb3vc2lg/mfwpOewretxxO+D0UHjy0470dxGrgkWPgpS9A8yaTx8eJmkTM7d83bYSXPg+PHgPx2rEesYiIyKSnoI2IiMgk5Xlw+eXQtp9TwqyvXd/xfXsAZ9Bev8XMGulNxUnwwZ2w5EaYdhqUHw/zLoaz1sE77gB7ks0iaXoVHlkMLVv6n52UboXmLfDwYlNOXURERMaMgjYiIiKT1BNPQF3d/j/uyqqVHd+/XPPy4DtwkvDWnwGn58fLT4BTH4HIdJOrpZ0dAH8EZp0Hp9xvZuJMBg2vwGPHmZkz3gCnVHkpiNeY/RrX97+9iIiIjAoFbURERCapH/8YWvuZdHHccXD//fDqq/Dyy/Cd70BR0fCOu7Z6bcf3y3ctH3wHtc/Q6ylM8SJ49+MQKOh9f38eVJ4C7/jT4I890aSj8OwHIN0CeIPc2TNJip89ZzRGJiIiIgOgoI2IiMgktGMHrFjR++NFRfDMM/D003D22bBgASxeDFdcAbt3w6c/PbTjOq7D9sbtWFgAvFo3hJw2ux8Bp5do04l3gC+//z78+TDz/TDjrMEffyJZ9R+QGM50Ks/MuBEREZExoaCNiIjIJPTb3/b+WHExLFsGxx8P+fng67KKKD/f3G66CT73ucEf983GNwl2qUrUlGiiOdE8uE6qHgTPzW2fd7FJNGwP8PTGXwDH/e7tm9+m6iHY/pfhl0VXWXUREZExo6CNiIjIJPTHP/Zcptvng2efhYMOgnC49/3z8uDaa+H88wd33A21G/DZnVGgSCDCprpNA+8gXg/Rnbnt/nxYckPfy6J6EiiGhd8Y3D4TgROHFz9pKkKJiIjIhKWgjYiIyCSzcyfU9lLN+atfhQMPhFCo/37y882MnbKygR97XfU62pKd5arSbpr1NYNIdFvzNNg9DG7eJ8AKDLyfdoF8WHj56M+2mTp1//a/9X/6rq4lIiIiE4KCNiIiIpPMY49lL3lqN3cuXHUVFAxisko4DL/5zcC3X1G1AsfrrPoUTUVZvWf1wDuo+kcmqW43h3178LNs2lk+mP3hoe07UNXVpsZ6f7fe9LdfdXXntk4C1v8QnH5quVeeCif8Hk592HytfNeIPFUREREZOf6xHoCIiIjsX3ffDW09XM9ffz0EBznhJByGc86BY44Z2Pbra3Nn1azavWrgB6x+IrdtylIIDmK6T3eBQljwH0Pff7zZfqcp2d2b0qPh5HsgVG6WlVk2uC7M/ogpC/78R6BhCKXYRUREZMRppo2IiMgkkkrBc8/lts+dC+97HwSGsMIoHIbvfa//7RLpBNWtZkaIz/J1VJDasnfLwA6UboNEfW77AZeALzLQ4fas9Kjh7T9eeB5s+BGke6muNeMseO9zUDDfBKuszKmgbZv7BfPN49PP3H9jFhERkV4paCMiIjKJrFjRc2Dm3/994EWXuvP54Iwz+t9uy94tRPwmuBLwBQj5TW6apJOktq2XJDtdNb8G/rzc9plngz3MycNuHzNTJpLmzRDb0/NjFSfBSXeb2TW9sWxTVevke6D8HaMzRhERERkwBW1EREQmkWXLINatgrPfD5dcMrDkw71xe6jA3V3W0igP/JlAS9gfZkPthv47aNqYW+o7b/bwlka1CxQOv4/xYMc94KVz2wPFJhDTV8CmK38enHwvBIpGdnwiIiIyKAraiIiITCLLl5slUl2ddBJY1vD6zethAkx3L1e/TGvSLNtJOAkc1+n4fkBBm8ZXzBKprqa9p+cgxWT11h3gJnPbj//fwQdgAkVw3K0jMy4REREZEgVtREREJpF163Lb3v9+U757tK2oWoGHqZBUFCoilVmSFE/HWVm1sv8O9q4CulVYmnnu22eWzHC17YS2HbntpceYXDa+8OD680fM0rOSxSMzPhERERk0BW1EREQmiXQadvRwTf+hD5klUqNtc93mju9nF8+mIq+i4/7a6rX9d9D8am5b+QkjMbS3h133dyYW7uqon4I9xLVvdgiO+tnwxiUiIiJDpqCNiIjIJPH666bSU1fTp8OMGaN/7JZECw3xho77B085mLklczvub9u3Dc/zetrVcJKQqMtu84UhNGWkhzpx7bwHnGh2W8GBUHEy2L6h9Wn7oPJdwx+biIiIDImCNiIiIpPE+vW5uWve+U5IJEb/2JvqNpEXMIlvLCwOrzicBVMWdDzus33saOphGlC7RB3Ywey2wgWQjva8/WTU0MPatwM+0/Psm8EY7v4iIiIyZPpXWEREZJLYsAHauuXxPeooKCjYD8eu3UDaNQmD84P5HFh2IIdVHEbANvXH/ba/72TEiXqwu9UqL14EDDOD8ttFrBqcWG77vIvAN4yyYDD8/UVERGTIFLQRERGZJN58M7c094kngm+IK2cGY82eNURTZlaMz/Ixv2Q+80vnE/FHAIilYtklwbtL1JMToCk5cuAlrN/uGtbmJhouOBDClWMzHhERERkR+yHtoIiIiIwHu3fnti1atH+O3bU6VNJJMr90vlkulYnDpNwUy3ct772DeB143SJORQuGnqvl7Wbf6txy6LPOQzORREREJjYFbURERCaJ6urs+5EITNlPeXy37NvS8X3KTTGjcAZ5gTzi6XhH+ys1r/TeQaIeMiXCO4SnjvQwJ67aZ8FLZ7fNONOU7RYREZEJS8ujREREJol9+7Lvz5gB8XjP246kura6rOBMeV45tmVTGi7F7pLkdmfzzo68NzkSdeB2G2yofDSGOzH1VA69dPH+H4eIiIiMKAVtREREJonGxuz7lZXgOKN/3I11Gzty1wDMK54HgGVZTC+Y3tEe9od5fd/rPXcS3ZnbFiwdyWFObIluEbnQFPAXjs1YREREZMQoaCMiIjIJJJO5pb0rK3NLgI+GDbUbSDidB19Q3lnq+4DSAzq+t7F7ryCVbMptCxSN2BgnNCeROwup9Oieq0mJiIjIhKKgjYiIyCSwdy+EulVurqgA/37IbreyamXH8ii/7Wdh+cKOxxZVdGZCbk228nL1yz134nXLZ2PZYAdHfKwTUrwG7O6Vow7KLZEuIiIiE46CNiIiIpNAIgF2t3/1KypyAzmjYc2eNR3fR/yRrNk1h0w5hLDfBBxcXFbsWtFzJ163dVyWP7ea1GQVqwa7W/QtMh18SkIsIiIy0SloIyIiMgk4Tu5SqEhk9GfaeJ7HtoZtHfcty2J+6fyO+/NL5hPydUaONtZt7Lmj7gmKLR+goA0A8erctoJ5ZjaSiIiITGj9nqpZlnUZcBnAnDlzRn1AIiIiMvLS6dygTXA/rC7a1bwLi84Dx9PxrJk280vn43aZMVMXrSOWihEJjPAskXunmWVEfbLhwv4zM8fTce7ddC8fP+LjWPsjKVB/EnXgdht33uyxGYuIiIiMqH4/gvE877ee5y3xPG9JRUXF/hiTiIiIjDC3h0kp3ZdLjYb1tesJ+jqjQ+2lvtvNK5lHNBXtuJ/nz2Nz/ebcjrov//EcBjVhuN+ADQx05s6fXvkTF913ES/uenHgxx9NboqcsYcrx2QoIiIiMrI0b1ZERGQS8PvB87LbUqmetx1J62vWZwVlphVMy5qdkhfIIz+Y33Hf9dyeK0hZ3YM26TFb/nPjihsBuO7F68bk+DncdG5+H0tJiEVERN4OFLQRERGZBHy+3Lb9EbRZUbWClNt5oPkl83O2mVU0q+P7tlQba6vX5nbUvRKS54ITz91ulG2u28ymuk0APLT1IfZG9+73MeTw0kC3iFz3IJeIiIhMSPoXXUREZBLoaaZNU5OpKjWaFaTW1azLut+1xHe7g0oP6giEeHisrFqZ21FoSm5bqhn8+7dC0g0rbsDJVLKysLjt5dv4xju+sV/HkMPyAd1z6/Sfm6fDCOb7GbJp06BmIEvYhmDqVKjuIVmziIjIBKCgjYiIyCRQWJg7s6a2dnSDNmknzfbG7R33/baffbF9/H7t77O26zoTB8ySqhyRWZjARJfIU3IfRKaO4Ij7Fk1F+cMrf8DN5I+JpWNc9+J1fO3Er2GPZaUm25+7VKx7ta2+jGC+nyEbrYDNaPctIiIyyhS0ERERmQRKSkzZ765qa3tOUDxSnnzzyY5ZKQBpN819m+/jgdceyNque9CmJdnC9qbtzC2e29kYLgdfGJxYZ1uiflTG3Zs7N9yZVQkLzFj/+eY/ec8B79mvY8li+cmZaZNqGpOhiIiIyMhSThsREZFJwLKgoCC7rbY2twz4SHrqjady2uJOnLZUW9Yt6SRztnt4y8PZDaGK3OS6sT0jOdx+/XLZL2lLtQEQyOTYaU22cu2L1+7XceQIFGeWSHURrRqbsYiIiMiIUtBGRERkkigtzb5fWwuBUSwytKJqxZD3fX7H89kNofLcCFPTxsEtAxqGNXvWsL3JLPWK+COcOPtEfJlAydNvPs2elv0bQMoSmZa7PKrtzbEZi4iIiIwoBW1EREQmiYqK7PvV1T1XlRop7cmFh2L1ntXZDaHy3LLWTRsh3TbkYwzGr5f/mnjaVKvy8PjS0i+RF8gDwLIsbl1z634ZR4/C08DrtvYtumtMqmsN2dRRzE00mn2LiIiMMgVtREREJolp07Lvex68OYoTMhriDUPed0fTjuyGUAV43TIpN20a3fVdGc2JZv626W+4maDRtIJpfGjhhzrux9NxblxxI447itWV+hKZDk4iuy26M7dtPKuuNi/Ivm696W8/VY4SEZEJTEEbERGRSWL27Ny21atz20ZCY7yxI6gxFLF0DLdrluTQlNylUC1bwTf6Jb//+MofO6pD+W0/Fxx2AX7bz1kHndWxTcJJ8Mjrj4z6WHrkL8it+N3wMtijOI1KRERE9gsFbUREREaB53l89v7P5uZmGUMLFuSW9165EmKxnrcfjsdef2zYfWyo29B5x/abGSVdeemBJyMOD22JjOd5WQmIw/4wH174YQA+dvjHKAwWAqaK1C+X/XJIxxg2y4JAt4RFrW+wX0/z4rVQ9RCs+y48fhLcOwP+VgZ/LYC78uDuYrinEh44GJZ9Al6/FRrW7becRCIiIhOVSn6LiIiMglvX3Mpt627jiTef4I3/eIOAbxQz/g7Q4YeboE2iy6qZtWshmYTICE9YeeatZ4bdx6OvP8qRU4/sbCg+zCz76ar2GZh3cW4i3u4+1G2JzJ8HtqzqxV0vUtdW13HfZ/k4dsaxAJxx0BkkuixBWlG1gu2N25lbMjenn1GXPxsStdltza9C2TH97xueCvGawR3P86DueXj1Wqh9HtKt4AuZHEPd8+tAZ6n2RB20vg477zO/MzcBhQfDGSvAnz+4MYiIiEwCCtqIiIiMsKrmKr722NcA2NOyh5889xO+f+r3x3hUcMQREO+Wm3b5cggGR/5YK3evHHYfy3Ysg3d2aShbCnseB7osm6r6B8w8F4LFwz5eT6578TqiqWjH/XMWnNOxVKogWMDSGUt5YecLALiey80v3czP3/vzURlLn8rfCfvWAF1yv9Q8CyVHmllKfeke0ILeg1qeB1UPwtrLIVYF6WjnMd2EWa5WejRMWQpFh2aWbvnBiZqAzd5VsO8laNve2WfTRgVsREREeqGgjYiIyAjyPI9P3v9JEukEtmXjeA4/f+HnnH/Y+SyqWDSmY6uogHDYzKxpl0rBiy/CaaeN7LG27t067D7WVq/Nbig53AQB0s2dbTVPgy887GP1ZG90L//Y8g+8TFCiKFTExw7/WNY2Fx95MWur1xJNRUk6SW5ZfQs/Ou1HBH2jEAnrS/kJ8MZtkG7pbNt1Hxx0CdhFI3OMVDMsuwiq/wlOl6pdoSlw8BfhgM9A3iwTyLGD4O82fct1zIwcO2CWttU9D5t+AbXPjsz4RERE3oYUtBERERlBf97wZ5bvWk7aS2NncorE03E+9rePsfZza/GNcXLYBQvgpZey2+6+G44/HvJHcLJDe3nsrtpLZPfE8zxi6ezkOk2JpuyNiheRNZMEILHXLJkqPGioQ+3VlU9fSbpLzpXWRCsPvPYAD299uLMt2Uo81flco6ko1y+/nsvfefmIj6dPZceQ87Opf2Fkj/HQESZ3jZt5vnYQDrsSFn4DsMCf+f32NuvJ9mU/Nv1MqDjZJJQWERGRHiloIyIiMkLq2ur44kNf7FhOc2j5oWxv2k5bqo03Gt7g18t/zdff8fUxHePSpblBm0cegeuuG7ljNCeaO2antKvIq6D28tpe9jBBm9DVIVJuZ1nveDqO67kdy5EoPNgss+lux9/g0K+anCojxHVdfrfmd1kVsFxcbll9S5/7pdwUVz171f4P2hQeDG63kuiea5Yyzfk42COQlDheDW5mmpblg1P+DpWndAZrBsuyIVAIJUcNf2wiIiJvU6oeJSIiMkIufeBSYikzWyQvkMctZ9/CnOI5ALSl2vjeP7/Htn3bxnKILF0KBQXZbdu3w+bNw+u3ucuKpY21G3Nm1cwu7qHeeBeWZTG1ILvCk9/2s72xS+4TX8gsv+nujdt6Tn47DNe9eN2QS5ZHU1Ee2bqfy39bNhQektu+7bbspUzD4XZZV7f4p2aWzFADNl2NREBJRETkbUr/SoqIiIyA+1+9nyfffLJjpsjhFYdz0tyT+PnpP6cgaKIkCSfBhfdciOd5fXU1qk47DdI9VFm+9lpoacltH6hUl0ke62vXk3ayD3LIlB4CCt3MK5mXdd9n+1hfuz57oxnvJ+f0pWXLiC+x+fmy4SUT/tYT3xqhkQzC9DNM0t+uap4yS8hGkuWDQ74AASUPFhERGW0K2oiIiAxTY7yRz/79sx3LovID+R0VhM4+5GymFUwDwPEcNtZt7HeJzWiaM8ckJO7u7ruzAy+D0dYGP+8S41i9ezXRdOcyJp/l47CKw/rtZ1F5dqLmaCrK+pruQZt/g0C3qUIAm35qEuWOgJf3vEx9tH5YfayvW8++6L4RGc+AzTm/56TMr/wXpIYRkevOFwZ7EEvR7p1mqlH1eRvbXE8iIiLjlYI2IiIiw9Q1jw2YWSXvmvsuwCz76Trbpi3Vxjce/wa7mneNyVgBzj03d0VKKgVXXQWtrYPvL5mEW7rEoVbtXpX1eCQQ4YDSA/rt59DyQ7OqLqXdNMurlmdvVHkKODFy7LgHkk257UNw+7rbc9qKQ8XMKZrT6y2/26wTC4u7Nt41IuMZsClLTGWm7rb/BRL1JsfNSEi3QesbA98+XjOAjUZobCIiIm8zSkQsIiIyDNcuu5Y7N9zZkXjXwqI+Ws/CmxZmbde1mlJbqo2lv11K1deqsMcgn8c558Af/pCdhwbgppvg85+HQw8deJqR1lazT9e+tuzbkrWNbdkDCtrML51P2B8m6XTmTsmZaRMohMJDoalbu5eGFZ+FU+4zZcGHyHEd7njljqy2vEAeyy9dzqHlh/a63xPbnuAjd3+E5oT5QXh43PzSzXxh6ReGPJZBs2yYdR688X9kBUE8F577MLz3+ZHJQQOw4lJ496Pg1xIpERGR0aSZNiIiIkNU3VrN5U9cnlUpycNjZ/NOXtv7Wtata+logOq2ar748Bf395ABOPlkSCRy210XLrwQ4rnVunuUSsGqVfDXv3a21bTWkHKy11klnSTzS+b3219P21S1VOX0x6wPgtXDjJLqJ6HmX7lVlAbh0dcfJeFk/3BKQiV9BmwA3jXvXVnBJoA3Gt9gXfW6IY9lSOZ9vOegVcNa2HA1pIYwlaqdr0vAp+55WHaxmXXj9PBi6io8te/HRUREpFcK2oiIiAzRqf93ak5p68G4ZfUtbKjdMIIjGphwGE44oefH1q2Db3/b5KnpSyoFtbVw0UXZ7RtqNxD2Z+dVcVyHyvzKfsc1v3R+1jIzgIg/wpa92TN3mHFmz7lbAFZeahLvukOrJnXNsmtoSXbmf7Etm48s+ki/+wV9QU6bf1pWWyKd4PoV1w9pHENW+S7o7TW56Wew82+Q7idw01tgZ9G3wRfpvL/rfnjwENjxV7Nkrbf9PlQNF3qdNxERERkwBW1ERESG4Lntz+UEEywsQr5Qrze/nbsq+ZK/X7K/hpzly1+GwsKeH7vxRvjmN3sP3CQSsGcPHHcc7N6d/dj62vVZS8EAphZMxbKsfsdUFCrKymnTLiewVX5C74lwY3vg8XdAsqH3wE0vQYvtKVixa0VWW34gf0BBG4CLjrioI3cRmMTTd264k5bECCYB7o8dgIO/0MvPx4Pln4GNP4N0NHdGkps07Rt/0nPfR3wXTn0EwtM7Z/PEdsOLn4T758Dq/zRLs1q2mr5SLSbPULLJJIl2YpBsHMlnKyIi8ranoI2IiMggxVIxPn7Px7Nm2RQEC7jvgvuI/1e811vsO7GOSlLtNtRt4L7N9w3q+NWt1Vx0z0UEfxTkiw99kb3RwZd0Puecvh+/+Wb40IfglVdM3prmZmhqgmgUfvc7OPbY3IANwEtVL+UsL5pXPG/A45pROCPrfmuylXU13ZYYWTYceAnYuQEeANrehCdOhPoXzPKd9gS86TYTSFj/wx53u7kR3G4JcV3P5cTZJw5o7GcddFbOEinbsvnT+j8NaP8Rc+hXgD6CZBt/DI8eawIsqRbwHBNU2fZ/8OgxphJXb6a+Cz64HZb8BgoONMEbO2QSHb/xexMUevAQ+GsRPHI0PPFOePJd8OhS+Pt8+FvpCD9ZERGRtzcFbURERAbpyqevZF8su5xzZX4l5yzoOxLit/1c/e6rs2ZjRFNRPvvAZ2mINfR73NZkK9956jsccP0B3LnhTlJuilvX3MrcX8/lJ8/9hFiqh6pKvQgG4XOfg1AflZsffxwWL4bTTjPJhj/zGVMy/MtfhvpeKmKvqV6T07awYmEPW/bsoNKDsu57eCzftbyHDS81wZvetLxuggVPvQc2/xK23gIvXwH3zYTN1+RsnvLglmZygi5nHXRWjzOkelIaKeXwysOz2tpSbVyz7Bo8bz8uC4pMh7kX9Jz3p13zq7DyMri7CP7ih7uL4aXPQfNr/fdvB+CAT8EHtsJpT8KRV8OM90Oo0gTSAsWABW07oGkTNK6Dlm1m9lNvSaKV90ZERKRHqh4lIiIyCKt3r+aWVbcQS3cGSAoCBfz0PT8d0BKgTy7+JFc8dQWtyc4lOrFUjC889AXu/MidPe6TdtPcuvpWrnjqCpJOkng6Tl4gjwuPuJA/rf8Tbak2fvzcj/nV8l9x3fuu46IjL8LuK6CR8dWvmqVQ/XnpJXPrj+u5vNnwZlZb0BdkYfnAgzaLKhfx6LZHs9o21W3K3bDwICg91sym6cveFebWj7+3gtstrlIYLORjh3+s3327uviIi9lUtylriVhNaw0rq1Zy/KzjB9XXsBz5Q9hxF3RP4jxUXwQu6v/1TQFwQBKmAgEgCPiApAMpB1qT8BZQRXbqnZpXRmacIiIibzMK2oiIiAxQ0klywd8uyArYAJTllQ0470nAF+AH7/4Blz9+OW0pkzQm4SR4cMuDPPb6Y5xx0Bkd2+MSfCYAACAASURBVLquy/ef+T43rryRaCpKyk0RsANU5FfwqcWfoixSxmXHXsbtL99OS7KFaCrKJQ9cwlcf+yrfeue3uPydl/c5lhkz4Nxz4d57IZ3uc9MB2dG0A5/tgy6pZML+MPNL+68c1e7gsoOJ+CNZP+O9sb20JdvID3YrL33YFfDCx/pPrDsA1zRAS7egTcJJ8L4D32fuuGmzBCheC4laiNeZ43qOeQzA9nNOOMqVXnYunWgqyq+W/6rXoNyoyJ8Dh/w7bLkJnGj/2/enaYDbtQJDib9MnQpdZiPt3Qtr18KmTbBrF2zfDnf1smswCD6fKVMficCUKVBZCTNnwty5MGsWHHYYHHUUlJUNYWwiIiJjSEEbERGRAbp19a282fgmEX9nBR0L+Mk7v4ZdvwLieyC621zcu0lwE5mvSXCSJreK7eezno//wsGx/SbziAWpdIJL77+YHZ99EitvJstqX+P0P743J0CUclPUttVyzbLcJT7tj++N7eWbT36Tq5+7mn99+l8snra41+d07bXwj3+MTNBmQ+2GnKVEnucNqNx3u/kl8wn6glnPOy+Qx+b6zSyZsSR74xlnmaS4rVuHNW6AzxfDkXFMrpx0C8RqWBJyKHzqZGjdZvLh+POh8FAoOgQChWaZkB3MJP21wI1zoJvk+wcezbbWvSYBb7oJ3BRnH3LWsMc4aIt/DFX/yCx5cvvdvE/FDDxwMwRe5VSeeBxuvx2eegoaGkyVs6Iikz/p2GMh/thUwk012ftNnUrLdlOuPpGAffugpsbkW9qwAdasga9/3QRxREREJiIFbURERAbog4d+EH+qAfatgYa1EK+j0ItyQe1tYL8FRQug8GCYeorJ0eEvMHlXLB9gg2WB5xLyXJ6a/RlWVK0w1XpSTZBsZI4d542Uy3/e+2mefvPpjsCFhUXADvChhR/ioLKDeh3f5vrNPPDaA6QyVYGaE82c+L8ncu6Cc7nmfdcwq2hWzj6zZsFPfgLf+U7/Zb77s75mfU7J7lg6NqiZNvNL5+N0q/rkuA4bajfkBm0sG068DZ5+37Bnk3ym2Nyw/gWpXRDwQbINKj4Ah10JFe8wv1MnboJvlt15w9c+UvBcvr3YzWxjmRLZ8VrImzms8Q2JHYBT7jcJgYc72+b3U03p7r70tjywn3w+GzbA+efDrg+bpNcAJ50Ev/41HH44xOOQnw/+7+Ye3wLa0zJFIlBSAgccYO6fe655TRcX9z1sERGR8cwaTGK8JUuWeKtWrRrF4YiIiAyT65gkqw1rIboL2rZDcp8JnPjC5iLaFwZ/IQQKTLJW2weW31yAey54adOPl8pUHGo2F+v1K6FhNeZSMTNz4ax1ULzQzKbx5/c1sn7dsPzXfPXxr+N6Lj7LZ4I1vhAHFy7migPuwWuZRn29uRB1HHMt7LrmeycT52jxbecu+1z2sRWHJODh4uAjwNcO/F8uWPgJysvNapRw2OzjOGbpyMaN/V5f9yo/H95z67k8sOWBrPa8QB5tVw48GpRIJ8j/ST5OtyVGXz7uy9x4Vi8JeJ77KOy63/y+hsWiI9FKsAze96JJ6hvopTb6aBhi4KNPW2+FNV8ZWuDGlwdLbjAzkPozxLHPmgVVVZ33jzkGli3rO0m2iIjI241lWas9z1vSvV0zbUREZODcFDgxMzvENQEBE+TI3DqWYHSdhWCZr3bAXAD6Iub7ASTtHbSGl82sAjCzXJw4HPQ5OCmTDSPV0rFEySxr6aO6TsdzTmeWOKVg+19g9StmOUy6xTzeus3MsHFTkI5Bl6VTOe6dBvGaXh+u3DmH0/ecyqtNZ1BTA8kkHDJ7Oh89/CLKgjYzj4TSUrNkJBIx18LtgZv262LLmsvPWMUf19/Ovthe0mkzUyEeh/OPPZJj5+Qe1+eDP/8Zjj8eYgMvQNUhFDL7vtJDMtmZhYObYRLyhygKFdEQz66m9VJVH5mQl9wIex6G9BCDNr4wYJnXdrvCg0xJa9vX624d+vm9GjZc6PSzzSg5+P+Bl4S1l2c/x/74InD0LwcWsBmGWbOgrs683sEscUqlTDAxL29UDy0iIjLuKWgjA+Z5HvXRehrjjcwsmkleQGdSIm9LO+6BV74HeJlZJi3mk/biRWY2ih3IzFgJgy8E+DIBGKuzBLPndvnqgpMwAZRkExQeODoBGzDLV6afaWbZJPbh+SJ4La9jNW0yZYhD5ViWL5NjJmaeX1cbfwabf973Mew8OOE22PV3aFwPyy8BPKg82QRv8uZA/jyzHCZQlJnB4zOBIq/vvCI/vOERNu9e1HH/0ENh43ND+UH4uWzJ4C60jzgC/vQnuOiiwQVuQiE45BC46+4U02/alfP4AaUHDGocALOLZucEbV7b20cp6shUOPpaWPO1wc8msXwQKIUT/w9e/KR5TaRbYe9KWHYhHP0LCE0xUTFfvsl2OyTDzCkzXId8CfLnwvMXDOxn5MuDk+6Gmf826kN79FGzPO+220wA8a23YPZsuOIK83osLzevSb/fzA7z93P22h6oTKdNcFMzdkREZCLT8igBTJnWurY63mp8ix8/92N2Ne9ib2wv9W31RNP9n9yVRcoozyunMq+SU+edysVHXsysolm5lT5EZNzz1l6Btfln2W0XxLF8PV/5eF5mnQ4erP8h1sar+z6ALx8uGH61n560tcEpp5hEpFaqieJgFWeeWs23v7oPK91AwGskZDXiJ4odCOJZQcDDax9/BwsrE4CyXvsVltMZ3PHuz8O6u9v7ogUUASVAKVCISXPS/WYDacz1uwN8FOgS/16/43DufOkSHtr2FbZsMbMNzjwTTj8djj7aVHsqLobCQggEzEVp+2yb9pudSZ1jWebiNp2GlhZoaoIDD+z/Z/jgg3DBBQML3IRCsHAhPPssVCU2c9zvjssqZQ7wtRO+xrVnXNt/Z118+K8f5t7N92a1Be0ge76xh7JIH+V/XrkKNl8ziMCNZQIyZ64yAQ3XgV33whu3Q90LJtDoC0HebCg7BooPh7JjTXDOX2ACcVbAfAUzK8tLma9/K8k93IUDOOcajeVRXTWsMzNuap8D3MyMuQw7CNhQ+S4TrCo9cnB9D3Ps9fXw0EPw8MOw7AWP6hrIi3hMmeJx2OEwc6ZFebnNnDkmqJOfb/4OPM+8zltbYedO2LED6utdqqo8Nm6Ar3zVx8aN5vGGBjMz7dOfNl/bK06FQiYgFApl/w21P6X22WyeZ/4u43GT+DgeN/cB1q2Dl14ys+GKi00/P/yh+bsVGYqkk6Q+Wk9dWx17Wvcwp3gOFXkVlEXKTKU+GRHJdJJtDdvY07KH+lg9u5t380rtK6yrWce6PeuoLKgkkU6weNpijqg8gkWVi5iaN5UpeVOYWzKXWYWzsIcc0Bfp1NvyqPETtKl+Cva15wnIKDsmk1/A6/y01nPpPLH2Mt92eQ5W1z8YK5P80eqcpp9shJatnfvjwazzTCWI8cpJmLwMTqxzir7n0pFToeNn42WfMPX0q7W6PGYB2Fj/ffKoDv/Bjz/I2YecParHEJGR8973wpNPAngUhFspzW9gx+vNncuinJhZBoSXeY/NvJd2BD48OpLuYsHyz0CqsfMA4al451XjOOaiJ5k0Fz3pdOetPV8L9H291/Utz7YhGoXFXQol5eXBhRfCrbdm75dIeCQS5kIs01MPvZs3Sts2JYXb87+0tZnKNPX1ZknHvn2mLZ3urGDz7St6vni97lovZ9ztzz0QMMc54dGrOP7RHwDQQgF7mM5eplBPOXuZQh0VRMnDC4ZwQ2FcfxDXF8TxB8GysdMJfOmk+Zo0V5YRYlRQx8cbbiZc0sfyrYyHHzaBG9c1P9Oe5Oebij4PPQQFBXD3xru5+L6LSTqdQYCAHeCGs27g80s+3+8xu/reP7/H1f+6Gq/LP2RBX5AnPvEEp8w9pe+d11wOW28eQODGgmAJnLHSLIUCmDbNRPzalQKzgZmZ76dkvhYBBUDAdEP7qUf7KUoKE4zrek0VrICP1PYzJoYe+Og+9v5MAd4HLAAiQAx4FXgC2Ju9aT1TuP/aN0jnFdHWZl4T7YGJdLozuPGpT/c89jv/4mU9Bc8zf+Ptf38zeJjZ9oOU+1YTSu8i5GshcOjnaAsexZY9h1DTVEHN3gJq6iPs3B1kx06b5mYLx7FIpToDlD6fR3Gxx5zZLrNnJJlaHmPqlFbOOj87Efahh8LmzQP/Uck45sTN7Lj282M3BZ6Tfd3QnhR8INc87dt1LO9tX+rr61ItLmByovmCwxr631/9O3esv4O6tjpq22rZXD+8F6Xf8nNY5WFU5FdQkVfBd0/5LgsrFg6rz+FwPZd4Ok40FaUx1kjIH6IgWEAkECHkC2H1MeN2X2wfL+58kYZ4A/uiDdy18a9s2fsa0VQbCSeJ4/Vf7tDGJugLEfKFKQ1N4ZOLvkhJqJTSSCnXPXcT66NPjOTTzXL57Pt4R9kHaWmBLVtMYNi2zXveBz5gZraK0ZJooaa1huZEM62pVuqj9VQ1V7GnZQ+7ms3s3UggwsyimcwonMGMghmURkrJD+RTGillav5Ugv7h/S2OJ+M+aLPvzmLK3ObsxoF8IgXmk7UNP+h7m1H8ZNdJxml46RZzJ/PzDBRWEMhU6fC6fXo7WG8+fi2HFz6Y3TjQnw30u9b+1Qcg+QxEuqQCyE/B9JbBjTbhg11F4GZ28izYF4EjLrmC/Kt+Ag2vwCPZZWfTS/+A/+BPDOIo2WoatjDnxoUk+1lyMBQ+y8fSwFlUx/bhksJxGqn37yJlJ/Ay/3VnYeP1MAXewsLCJmiHmZe/CL8VJGAH+dTMz3BCyfEkk/Dyy2bbkrIAlgWLFsExR4/Qk/FccxLTVd7MYSdNHU1v1Fex/K21JNMpEukkL+x+hr2xOuJOnGQ6QdJJkHAzX50Eef48oukoIV+IoC9E0A4StEMEfWHzD3a4nHdMezcBX5CAHeDw8qOYUTCr42LDtjtvkYhHJM/MvnA9F8dzcF0Xn+3DZ5vksLZl93nCcdMZ+Xzp8WFWa+mFB8S/fjHuf16E07SJppa3aEknSXkuKQ/S8z5BCo90OknKSZH20pmEtkECth+/z0/AChDwZW52gKkFUwnYAWzbx1PrNvObu16jfh80Nni8UdXKMfPnMX/aFIojBZQURIgEQuRH/BTk+wj4LWzLwuczXy3LwnFdXNfDcT3SaY94zEci6ZF2XNxv3sBV9POePQzWVYBrQ6wUohUQLYdkASQLCLjFFPqmUOAvIT8UIT8UwrZ82NjY+LDx4+LgksbFxfUcookEbYkErU4Djbum4bzwFXMcywRyXnwxO1DkecD0aVjdLqDdyqlEt1XnXJPbtrngDAQwS642X2d+y17aBMcWft0st2r/UMKyoeLEnp9848bs4JnnmFLj7YH9uufNhwCpJtjzmFkCM+9jZvNwJYRKzZu3ZdMSDfE/dxzMT25eiJt5Y7csj2TKZumR+/jx5Rs4aUlNxwVSXayZn/7x13gvb+sYjt+Fb74AFYP8U9heDNcfb4bSLuDC9xadS8HXPwVtu8BLdCaVtvww72KTf8bz4JXvw6u/NO99biL3AP58iMwwlZWKzXK01avh0FOnkd86iMDHIMSKp/LALdXm/X5Dglj+JtqCbxHz9jF1/l6S+dvYum8rT3/6nz3u/72nvsuMwhkUh4uZWTiThRULqciv6NxgsEGbQbibD/NR/pbV1tjYQ1WmnsYwdSpU91N16uHF0JjJh9R+UfzRLudsnmNmL0Fnniwyb973zeg/n9A94N0LccK0UEgzRcSIECdMnDDJSDHJUCGEw9jhIJ7lw8tMt/HaX1Oui52ZVeglU3jxBP5EG8F4M23LLsALmipn21v2sGnvVlKuS8pNkXJSpNw0aTdNyk3jeR6O5+C3/QRsPwE7QMDnJ2D5M+/Jfo6btpiycAl+209ZuJgTZxybCSY4dAbIMYGEgnl9P/cx9mrt69S1NJBIp2iMN7Jy93JiqRhxJ0EinSCR+Tc97sRJOAn8lh/Lsgj5Qubfc3+YkG0uvMOBCAeVLGBu0QEEfQECpHj3upOyD3jyfTD7gyMz+HQMYruz2yxf9gfEw5gBd+4dp/NAzevZjR4UJqA4cytMQCQN4TT4XEj5IOaHWABagtAUgqYwRHu4Zv39I7P4zIrcJasjIWlB6Puj0jUARdtPpnnukNYGD4jvqV/ilG6Gtgpoq4RkHnfcVsDMopnMLppNRX4FttX7zJmkk2R38252teyiprWGaCpKc6KZ2rZaaqO13JRfTUFrJgjnAXkzsU69v1sv7QHCAQy4/WVmWbjpJLWPmPMQorsgVkNo7inkL7rQ9Okv6PzQbNA8/rWskEu/drC5l4ziuQ5X/biA952ZmW3dPgu5438D7DnzHJb+MY+aVHwIYxuYj+5bS3HsKKx0M2z/C0VleZzzqUwMJDwVL1hGx9V5x3upuVYb6BOyLHPOsGlTdvt115kPsYZj3Adtlp69lFVLV2G7kJeChB/8DoQdyHMg4kC+C0HXtNkepG3z5pX0QdJvggYJ2+y74UCo7GvN85zz4aS/jsjYV656ieO2HJfdePK9MPu8gXXQT9Dp7H+9hxce+SHhYJygL0XQTvPDy0s47qgwluViWx4WDlgedsdfUOfvdcbmD+BL7+u1/2/+5ed89Hjzs7AsF5/tcdRlvzUnw2T6syw45BSo7fbxW1kEbux7Dv1Vv4Wrnu1zkyFbPms2J166EzAJmszKAwuf7TcX2JYP27I7vvfZPlzPxXXNhbiTjuG6SRzPrFRwMR+cZtKrsnj7Wayb+8joDB7wDu6hcSSDld0d/AVYevPg9unFvfc+zYc/fFpW2+7dMH36iHTPrMs+wKVb/jFqrx3rqtHpt125DfWueT0FLUhiE/RHCPkzJ6K+ICF/iBeu3EZ5S2dAra7Qx9L/KiCZbCLhQcKDpJfpwzMf4B8Xn8nKcFWvxx4t7e/PeSlzEhlKQ9AxF+Zp27wXx/2dJ5TRgImddPcP+wiC0ak4ro9EKkSSEsref3tHFaT2xLpdlyZ0aHjZ5KsBus7w8RxT6ckmxQ0NN5F+cxvlUYgkAQsO2gczW6CiDSrbTGC6Ow9oC0BtvrlVFcHrpeZ9JRqA+jwI7J2D//XH2VO0gPp6s+To7LPhjDOgstLcCgvNDJ9w2ARiui6zaP8Qt/05ts/MicfN7IXCLV9hevP12QPr6T2hp4vjKflwwyBrdkdmwnl9n9TH47ByJdStuotI9e0cNPV1Dpm+tc99Ohx2JSz+cW579/FPnQqPf77P97QnN7yH9/70yay2DRvgsMN62SFWAxuvhm2/AytofvhuygRrjvklzDwn6wV27rnwQHbhq56vx4YYmLB+MLCTwT3XwLRuv8bqfJh++YB2H3T/A+7bA9JhSOZDKs/cnCC2GybiKyRo5RG0w4T8QVP5zLI7PrCwsHFx8DwPDxcPj6STJOkkSXlREmUvUxaqYVEI5vlhig+mBoLMLJxBZcFUSvMqKAwWEgoW4gsUYtt+bMuHhU3p1l9hO32/7m9shJMyuaZtwB8s5oAz/5kJgnTm4govfC9WXfZ5jlcWwernPMca4J/DUBz/5nmsuD17qeC2bZ1lzYfruB+V8pLb2P+GQ/T9f47eOaCDxa/O9PjGWsxJoA/IC0J5BQQD5hbwm0RJtg98duffvGXBgt2wYE+v/f9xx1w+8dJ2uLfXTYbluo99ha994NfZjR+uN0s2uxri+721xQKr/3PKobznBNJBjlx7BKekVxNJQWsmgFQah5I4FMehMJk5X0iZoLuHOU+I+U2QqT3g1BA2X2dlPruPBuC4/CmUzD8en+3gejapdIDIKb8hWDK749/O9iWLdk8xtL2roMEkr7cyjZ7r4HkOtuVy+jPfwLrXtDvYHUHcFIGsmxsI4wUCYNt4lrm1V5m0PBcLD8vLnLykUvjSCQKkKLm2kbJpXfKyFS2As1/t93cB9Ht+XxuNUJnX7T1p8U/hsG+PSP+/fOGDXH7zfVltTz4J73nPwLrvz80fPJm5Rz9PgWcmrIYs8L//vyktmkVJsICQP9S5eiRrhpwF23+H99b/0uZBowNNrrl2i3rQ6prbBz+X/Zo/8URTjXCiGHLQxrKsy4DLAObMmXPs9u3bR2WAO3eaaebt76WeZ054e6qM0f541++7ntj39Cnmc//zZVrWLMfyIBlI0zQDZh11BHhgY+EBPs9E2CyszKx4E4VbWrqW40pyK2K0S3nw7D/L8T9Vj8+FxjA0ByHkmDepoAOB9ptrvnqWeeNK+Uy0Ou2HZCbglPbBrCZzYuFYMCUGR77e0n/obognko5j1ngnk5239mnL7Ten2ySN9p959589ZLf7fLBi9f/QGmvFtmzibpxmO05R+TRsKxNUyfx3yaVfIb+xqaOftuIibv3Vv+O0bc184u3h4FJiRcjzhfDwcNNBfNY3KJ/XGf2IRMxFU/tYABafOY3gvuyfTapsKmsfyf3Uu+vz86d2MSd/FVOmdP24tzSTfLWLRf8Gdd0CYwMIaP1v7Rm8FPgktmXheR4b6zayeM48LNs2p7mWDZ7FVV/5D4qasmeiNRcV8f3rrzfFfD3zB1IYKmRKXgXgmufw6L2k1q3BAqJ+j+jsEhYuPsoUzwG8zDI7M7u/8zl6wFFlL3BUSe/vcg0pH2vuOIBDnuzyHIuK8BUXZL1APLqcIHX9w+3jvmWBXRSn4Kr3El5yauZ1aOH4SvCsEB7mvueZn1vOL/HNP+Nt/wuW1X3Wk1lqaeNQ9c+zKL//T9iZ6/5owHyKFXBNEMLnmeCw1e1DEA8zm8yxzd9n2jY32zNB5fbHq951GtbVT2U9vWBw+O9plgVtrQ6ha67kmMd/0flAJAzhiJlZYPfws+3qvXE4ve9PObyyk7DO7OdTriG+5zy05SG27ttK2B/GZ/nY3rSdwmAhRaEiCkOFFAYLzfRpv5kxZVkWaTdtPpVNJ2hLtdGcbKY53kxzopm8QB4l4RISToJ4Os7nl3yeguAAPuroKXDQ34yAXqTTZolUaysdy0e6vod2vfl82TO72mfaFBSYJUcVFZlfmeeZWSLpNrNM1o13JnT20p2xec/tPDHv+NvLXIg+c6Ypd57REUT3AcHMzU/nBU/YD+HMOq1gJtBhZ27tf6Nu5uZ5cGk95He+1n79xJXEF1yN34rjt2JMKY5x8IFJLFLYXhLbTmOT7sgZAmb2Dh5YZN4vLPAyU2wWVp9BwDXjr2su56ZfLOCqN18Y3C8nglkKFARagLo+fo+NTdiFRR1BtFjMLF9rX8KXTHYGFLsv3+t6jmmeV+cFRTAID6+4gr1NWymy8yiwwvh9fhYdexTTwuWUh4r7zE8R2fN/RPbcTosLux2od8yvP+qa7/e68MyWj+CrOJs8yghZRRQX+lg4v5iy4DSKAlP6/NQYwPHSNKXq2ZesJua04nhpWtONtKQbSDpxyqZ4LJhdzpTIFEL+ELZlU5lfyczCmUQC/S+5c1yHmrYaqpqrSDgJXM+lIdZAfbSetJcmlooR8UeIBCLUttaSH8ynIr+C4lAxeYE88gJ5hP3hrBmOrucSS8eIJWO0pdpojDdSH60n5aYoDZeax1Ixwv4wHh75gXxC/hCJdILK/EpKI6UUBYsoChcR9od7fk24aVoSLTQnmmmKN1HbVttRjr4t1UZrspX3/KKRxff/qN+fwVCsnj6LHSVLOW/zff1vPAR3LZ3Pc8cWYcXMVfumgmbyDpyFFTCV9bp/9hyw/KQyS1Ps9C78TucHCB5QasMRXU6RzptyCFOO+QWeZ5vZl46NF55m/v0GPM/G8zxzJtLtnyrvrbuwdt6ZM2azvVn2tPnAzfjCRR2P+XwmaN7bv6/Z/fS+GtGyYHtNI89uWUPQ78OyfDSnawgVxCnJD+OzAvitAH47gJ8gfjuAz/Lj4pJ2U6S9JGnXLONJuUlSXhKHNNPD83BcFw+Hcv9cTjnygPbr/Y4ltl2D+q6bO+aextqdbcOi6Wsy759W5y3YmWvLLFP0AKvL+5jpzNt6K9abZl2xRfu5mflqWy6W5WG9+2EIdMndZfkzlfg6jtDzDxdgy82w7ZbeHweoOBne+6++txnq7L5Ui/m30U2bf0/dFB0zX9pnpnbMnM/+MJyt/wPbfttn93d4C6ia9Tl8lp9YKsGrtVs7lmoFMjPB/XaAoC9AMLPMLu06ZmaekyLtpki6SVJumlQ6yfTC6ZSGS0l7aVwvjT8vhj8z+7umtYaqliqCdtDMpLbNDOofXHgLhQ3Z01ybS/P43p//X2YGoLmlnTSHVR5GyBfC8RxCdpBUug2/ZeOzLN7Y9zrxVJSQP0jQFyBkBztmBQbtILZl/oZTboq0m+bf6/6bAq/36bU1TVNpeLf5/ThO5/Lw7q/9rjGB3nQ/P7YscLz/IZWsw2fbpFyHhmScUN50Qr4AQZ+fkB0ws84zN/BwXJe065DcfhfJnX8nQeeHpoU2RCzz4b4HHDfzeDhjeZ+//+EY9zNtREREREREREQmo96CNkpzLSIiIiIiIiIyDiloIyIiIiIiIiIyDiloIyIiIiIiIiIyDiloIyIiIiIiIiIyDiloIyIiIiIiIiIyDiloIyIiIiIiIiIyDiloIyIiIiIiIiIyDiloIyIiIiIiIiIyDiloIyIiIiIiIiIyDiloIyIiIiIiIiIyDiloIyIiIiIiIiIyDiloIyIiIiIiIiIyDiloIyIiIiIiIiIyDlme5w18Y8uqA7aP0ljKgfpR6lv9j13f6n/s+lb/Y9e3+h+7vtX/2PWt/seub/U/dn2r/7HrW/2PXd8Tvf+JPPaJ3v9EHvv+6H+u53kV3RsHFbQZTZZlrfI8b4n63//9T+SxT/T+J/LYJ3r/E3nsE73/iTz2id7/RB77RO9/Io99ovc/kcc+0fufyGOf6P1P5LGPdv8TeewTvf+JPPb90X9vtDxKRERERERERGQcsbFxgQAAAKhJREFUUtBGRERERERERGQcGk9Bm9+q/zHrfyKPfaL3P5HHPtH7n8hjn+j9T+SxT/T+J/LYJ3r/E3nsE73/iTz2id7/RB77RO9/Io99tPufyGOf6P1P5LHvj/57NG5y2oiIiIiIiIiISKfxNNNGREREREREREQyFLQRERERERERERmHFLQRERERERERERmHFLQRERERERERERmHFLQRERERERERERmH/j8weJhRcGD8TgAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -1267,7 +1164,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABHcAAACMCAYAAAD2tUXSAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3hc1Z3/8feZO1VdtmS5gCsGY0oohlBSKElIAgQCJAFSd8MGHpaawG6SzSaQsgthU9nA0skvAQJJCL0mdDBgG4M7Nsa9SK6y2mhm7j2/P+6ojGYkjaSRzNif1/PMo7lX9577nX7nO+d8j7HWIiIiIiIiIiIixSmwuwMQEREREREREZHBU3JHRERERERERKSIKbkjIiIiIiIiIlLElNwRERERERERESliSu6IiIiIiIiIiBQxJXdERERERERERIpYcDgarampsZMnTx6OpkVERERERERE9krz5s3baq2t7bl+WJI7kydPZu7cucPRtIiIiIiIiIjIXskYsybXeg3LEhEREREREREpYkruiIiIiIiIiIgUMSV3RERERERERESKmJI7IiIiIiIiIiJFTMkdEREREREREZEipuSOiIiIiIiIiEgRU3JHRERERERERKSIKbkjIiIiIiIiIlLElNwRERERERERESli/SZ3jDH7GmOeN8YsNcYsNsZcPhKBiYiIiIiIiIhI/4J5bJMCvmOtfcsYUw7MM8Y8a61dMsyxiYiIiIiIiIhIP/rtuWOt3WStfSt9vQlYCkwY7sBERERERERERKR/A6q5Y4yZDBwOvDEcwYiIiIiIiIiIyMDkndwxxpQBfwWusNbuyvH/bxlj5hpj5m7ZsqWQMYqIiMhebNky+MIXYPJkqK2F/faDb38biuJ0w03Ailvg8UPgr3XwtwnwzEdg41Ng7e6OTkRERPYQxuZxYmGMCQGPAU9ba3/Z3/azZs2yc+fOLUB4IiIisrd6/3246ip48klIJsF1u/4XjUIgABddBD/8IVRW7r44c7IerLwD3vkPcFsh1ZL5/2AplE6FWb+BuhN3T4wiIiJSdIwx86y1s7LW95fcMcYY4PfAdmvtFfkcTMkdERERGYp334VjjoGmpsykTk+RCEybBrNnQ0XFyMXXJ2thzkWw6h5wW/re1imBD98Ok88bmdhERESkqPWW3MlnWNbxwFeBk4wxb6cvny14hCIiIiL4PXaOPx4aG/tO7AC0t8PKlXDCCdDSTx5lRFgLb30bVv2x/8QO+L163vgmrHto+GMTERGRPVY+s2W9Yq011tpDrbWHpS9PjERwIiIisnfZsAGOOw527Mi/JE17OyxdCp/8pH99t1p4Dbx3q5+0yZfbBq+dD5ueGbawREREZM82oNmyRERERIbT174GW7eC5w1sv3gc3nkHrr9+eOLKy9Y3YOkNA0vsdHDb4JUvFT6mnsaOBWOG7zJ27PDfBhEREcmi5I6IiIh8IDz+OLzxRv9DsXrT2grXXVfYmPLmufD6N/wkzaDbiBcsnF7V1xd3+yIiIpJTcHcHICIiIhKPwwUXDL1uTjJZmHgGbOVt0LJuaG24I5Dc+aDZ8Q6suAl2rQCbhNgEmPp1GHcKGP0GKSIiki8ld0RERGS3u/562LVr6O2kUgPb/o637uDcg8+lNFw6+IO2b4P5/5ZfAWXxbXrWnya+cRF4CbDdumttfBzC1XDwf8K0byrJIyIikgd9WoqIiMhu1djoJ3daB1GqZih2xndywaMXMHv97KE1tPg6P0Eh+Vl8Hbx0Jmyf4w9jsz3G4aWaoXUdzLsCXjoLXN23IiIi/VFyR0RERHarO+7wa/GOtEUNiwBYumXp4Btx4/DeLeDt7mm6ioC1MO9KWPST/IpOu62w+Rl47hOQUq8oERGRvii5IyIiIruN58H//E9+vXYOPBCOPRYmTizMsRfWLwTgnfp3Bt/ImvuBPOZsD4+C0UdD9eHgRAd/vGI2518HN0389jnw7EeGLy4REZE9gGruiIiIyG7z0kvQ3Nz3Nqed5ieAJkzwa+qEwzB7Nlx9NcyfP/hjz9k4B4C3Nr01+EaW/dIfRtSbaJ1fO2bqP6WHbhnA83uvrLh57ymivOkZWHX34GYTc+Owa3nBQxIREdmTqOeOiIiI7DY339x3cud//xfuuw8OOADKyqCqCkpK4IQT4JVX4NxzB3/suRvnAvDe9vcG10DTe9DUR9Kh4gA4balfFDhYAuEqCFf6xYIP/Qmc8gYEywZ37GKS2Amvnj+0aeIH0ttHRERkL6TkjoiIiOwWra3wyCN+KZZcrr8evv51P6nTk+P4SZ7bb4czzxz4sa21nUmd5kQzW1q2DLyR9+8G6+X+X9lU+OSrEKzMPQwrWApl0+Hkf4ATG/ixi8mbF/Xdu0lERESGTMkdERER2S1eecUfYpXLOefAxRfnTux0V1oK99wD06cP7Njrd63vvB4NRlnYsHBgDQCs+2vuWbJMEE76O4SqINDHqVYwBpWHwNG3DPzYxaLhJdjwqApOi4iIDDMld0RERGS3ePJJaMkxCVJpKfzf//Wf2OkQDvs9eAZiYcNCQk4IANe6ncWV85bYAc3v5/7fAVdApBYCTv/tBGOw79kw+qiBHb9YzP93DakSEREZAUruiIiIyG7x6KPgutnrr70WYgMYqRQMwhFHwBln5L/PgvoFtCb9pEPCTfDGhjfy3xmg/oXcw62iY+HQayA0gFo6ThSOuRvMHnZatm0O7FzQ/3ZVh8B+F8H+l0DdScMfl4iIyB5Is2WJiIjIiNu6Fdaty15fV+cPxxpIcgf8Xj433ujX8MnH6+tfJ+WlOpcHPGPWhscg2ZS9/pBr/WFZA2ECULKv34NnT7L4ur5nAxt9NBz5Wz+5A4ABm/J7Rb3977DmTyMSpoiIyJ5AyR0REREZcc89B5EIJHqUrLnoosG3WVUFJ5+c37bvbH4nY3nVzlV41iOQb++ZTU8BPSpBB8thylfAieTXRnehcpj5vYHvN1B1dVBfP7ztA7TVw8YngF4KTk84HY7/kz+LWE+hcvjw7VB5MCz4wbCFKiIisifZw/r/ioiISDF49FFo6tHxxRi45JKB99rpUFoKV17Z/3ZJN8n6pvUZ60KBEKt2rMrvQK3roX179vpJ5/Y+e1Y+Kg4Y/L752rzZn56sr0tv+tvPWr99gDX3+Q9oLvt8vvfETodgKcy4HI741eBvq4iIyF5EyR0REREZca+8kr3uxBN7nz0rH4EAnJRHyZbl25YTDWbWy3ECTv4zZm19HQI5Aj3gkoHV2ulpoMO5PshW3wtuW/b62Hg49vd9J3Y6BMtgv3+Bujy7Y4mIiOzFlNwRERGREZVKwYYN2evPPz//GbJ603OYVy4LGxZiyOxV0pJoyRqq1audiyDVY5qv6Fgo3z/PKHvhDCGz9UGSaISdvdyXx90zsGFrwVI4/j4IVRQmNhERkT2UkjsiIiIyolat8uvt9PSZz/i9b4aiIo8cwPxN82lONAN0Jnlc6/L6+tfzO8j2OUCPab7GngxeHpmlvcGmpyGQ4wHe5/MwalbuXk99CZbBoT8tTGwiIiJ7KCV3REREZEQtWZKdxNlnH6iuHpnjv77hdWy6GHJJqGt4UN7DsnYuzl434XPqXdJhzZ8glWMmscOuG9ywtWAMpn1z6HGJiIjswZTcERERkRG1eDG0tmauO/lkf7jWSFiyZUnn9bFlYzt779S31BNP9TF1N4CXgrYcY8rGqi4MAJ4Lm5/JXj/m4xAbN/LxiIiI7CWU3BEREZER9eab2Ymc00+H8vLhP3ZTexON8cbO5emjpnf23okFYyzdsrTvBppXgpNZjJny/bLX7a2a3wNyzJJ14NXglA6+3XwKMIuIiOzFlNwRERGREbUwx+inww8fmWMvalhELOTPtV4SLOGg2oMIBvxZqqy1/Q/NalwCpsfpU+Uhfo8egR1vk5XcCUT8nk1DLagkIiIivdKnrIiIiIyoTZsylwMBv+bOSFjYsJCU6ydiQk6II8YfQdJLAtCcbGbexnl9N9CyGtweQ7cqD1LPkg7b52bPJDb2JHDbd088IiIiewkld0RERGTEJJMQ75EbmTw5vynMC2Huxrm0pvyCPykvxdHjjybhdh38jQ1v9N1A2+bsWbFGHwWBUKFDLU5bXgO8zHUTvwDBERhzJyIishdTckdERERGzLZt2dOgz5wJrpt7+0Kbs2FO5/V4Ks7k6snUlNR0rlu2dVnfDbTmKKZcdXChwit+jblmEjtdQ7JERESGmT5pRUREZMRs3QrhcOa6GTMgFhv+Y1trWb59eefyqNgogoEgkysnd65rS7WxrXVb743EN2WvK9m3gFEWsXhD9pC16BgIDmL6cxERERkQJXdERERkxGzdCqZHvd3x47MTPsNhU/MmPNs1ZGhi5UQADqg5oHNdLBjru6hyvCFzOVgO1hY0zqLV/H72rGFVH8pO+IiIiEjBKbkjIiIiI2brVvB6lGQZsWLK9QuJOF1jwmbUzADgoNqDCKVr5rS77Sys7yO5k9ieuRypAU/FggG/HhE9El3Vh4EzAt2yRERE9nJK7oiIiMiI2boVUj1mDR87dmSOvaB+Aa1Jv5iyYxwOqj0IgKnVU4kF/QREPBXnzQ1v9t5IclfmcrQW7AgVDPqgi9dDeuaxTrUfASeSe3sREREpmH6TO8aYO40xDcaYRSMRkIiIiOy5tm3Lni2rpib3toX2+obXO6c9LwmVMLV6KuAnd+g2VGzepl6mQ7c2e5rvyAgFXwzim7OHYFXsv3tiERER2cvk03PnbuDTwxyHiIiI7AXi8ewSNdXVI3Ps+Zvmd143xnQmd6ZUT6Et2db5v/d3vJ9Rm6dTrh46kRowTsFjzYe1FvtBqvfTsoasYVnh0bslFBERkb1Nv8kda+1LwPb+thMRERHpTzKZvW4kiimnvBTrd63vXI6n4p3JnapoFSEn1Pk/J+CwZuea7EasC6bHqVMgkr1uhHz0ro8y5TdTdsuxc2pdn70uXDXycQzW2LF+te/huozU+EMREdkrqeaOiIiIjJhcyR1nBDq+rNi2gkiwq/ZLwAQYFRvVuTy+fHzn9WAgmHvGLJsiY/wWQCCYvW4EtKfaeXPDm6xpXMOmphzTs+8O8frM5WA5WT15Psjq6/vf5oPcvoiI7NWChWrIGPMt4FsAEydOLFSzIiIisgdxc4xs6jk1+nBY2LAQ0y0JM65sHKbbgadVT+O97e8B0JpoZUH9Aj53wOcyG7EeWYkcE8he15sHx2YnQLIE4Pz+CzQ/vuLxzvpB9y68l+8c9538YhhOPevtRMeA2w6BEeiaJSIispcrWM8da+2t1tpZ1tpZtbW1hWpWRERE9iDBHD8r9ZwafTi8vfltmhPNncsdQ7I6HDzm4M7rKZti9vrZ2Y0Yh6yeKJ6bva43/SZ2APK7M26ec7MfEoab596c3/GHW8+aRE4knRATERGR4aZhWSIiIjJiQqHsdSOR3Hl9/evYbkmYmbUzM/4/fdR0SkIlncsL6hdkN5IruWMHkNwpkG2t23h57ct+SMawqXkTixo+AJOa9kzumIJ1EBcREZF+9Pupa4y5DzgBqDHGrAd+ZK29Y7gDExERkT1PruROe/vwH3fxlsWd16PBKDNqZmT8f2r1VEKBruA2N2+mPdWeUacHE8zuieK2jnjvlPsX348TcCCdS0m6Se6afxe/OOUXIxpHwfU7bC2/IWsiIiJ7o3xmyzrPWjvOWhuy1u6jxI6IiIgMVjQKgR5nH9uHeU7O5kQz29u6DhJxIlnDsqZWTyXlpTqXY8EYy7Yuy2woV32d9q25p0gfRjfPvZnWZGvnctJLcvc7d+eevn0k9ZwS3qZyb9ebfoetDfPtq6sr7vZFRGSvpmFZIiIiMmJqavwET3cNDcN7zMUNizOGXLnWZUpV5hTiEysnEk91FQS22OwZs4yBYGnmuvatBY+3Lyu3r2Tl9pWAn4AKO36x4qSb5IXVL4xoLFl6Jne8xG6bJn5QNm8Ga/u/5JLPfps3j+ztERGRvYoGQ4uIiMiIqanJLqo83DNEP7PyGVoSLZ3LzYlmbnjtBn9oUzfBQBA3PZ1Xc6KZR5Y9wlcO/UpmY+EqSDV1Lce3jGhtmbvfvhs33VPI9dzOGb+aE83cMu8WTppy0ojFksWJZC7HGyAQyb2tiIiIFJSSOyIiIjJiamuzpz5fv354j3nfovs6EyId7pjf/yjzp1Y+lb0yPApa13Utt2/NTmoME2stt711Gwk3AcC48nFMrprMi2texGJ59N1HaU22ZvRSGlGROqBbb6fkrpGZ515EREQ0LEtERERGTk1N9uxY69dDPJ57+0JYvXP1oPbrPnV6p+iYzGW3dcRq7ry+/nVakn4PpIAJ8LkDPsc5M88hFowBfs+jh5c9PCKx5FSyT/a6ZOPIxyEiIrIXUs8dERERGTE1NZBMZq5btsxP7vSsxVMInufRlmob1L4Wy6odq5hS3a0+T2xc9oYta6Fi/0FGmL/b3rqts5ByWbiMU6efyuSqyZ1Ds5oSTdw05ybOO+S8YY8lp9JJ+AWnu9Wlad8GkZqRjSOxE7bNgW1vQut6fxhdqgUIQKgMguVQMQNGHw3VHxqxnlciIiLDSckdERERGTGjRmVPfb5kSe4p0gth0ZZFQ9r/seWPcemHL+1aEcvRO2XngmFP7iTcBA8sfqBzRqx4Ks5HJ32UWDBGLBjrTPrM2TiH+uZ66sp2w8xMsbHgRMHtlkxrWgEVBwzvcT0X6p+DlXfAlpehfQs4JZBqBZvMvY8TAxPyYy2bChNOhcOuh4BOjUVEpDhpWJaIiIiMGMeBkh4lYdat89cPhydWPDGk/V9e+3LmilhddpHgbW9Cug7OcHlixRMEus08dVjdYZSESjDGcMp+p3SuD5gA9y68d1hj6VW0zk+YdLfl1eG7b1KtsOi/4ME6ePlsWPsAtG0EL+kPB+ue2AmEMwtfu22Q2uVv0/QuvHujEjsiIlLUlNwRERHZg9274F72/eW+7Izv3N2hdNp33+x1q1cPz7FeXfvqkPaft2le5oqyadnDeBqX+LV3+hMdfG+am+fcTFPCn6Ur4kQ468CzOv935gFnUh4uB6At1cbNc28e9HGGJDo2u4Dyjrfzu28GauOT8PAkWPwzSGxLz2BmIRCCmmPhwKvgpOfgC41wngtfbIVz2+G8FHx+Exx/P0y7wB+eBb338BERESkS+olCRERkD9WSaOHSJy9le3w7Vz51JXededfuDgmAQw/16+x0N2cOzJhR+GO9vfntIe2/YdeGzBWVM8FLZa7b+U5+U36ftTl73b39zya1o20HL655sXM55IQyeuucNOUk2t2usW7rd61nyZYlzKyd2X9MhVQ2BdwelbF3vJ1/TZtoHcTr+97GWljyc1h0bebwLycK+18GB30/vRzx13XofjfHxsKkL8L4z/rr2zbB/Kvzi1FEROQDSj13RERE9lDf/8f32dW+C4D7F9/Pa+te280R+Y46CsLhzHWPPQa7dhX+WPUt/SQL+tHutuN1n96rdFJ2L4/W9ZDcMaTj9OX+xfcT7DZkyGA4tO7QzuXRJaOZUtVV9Dnlpbhz/p3DFk+vYmOzEznxzdkJn96ctRnOt12XXJb+Ahb9ODOxU3McnL4SDvkhhCv9i5NHde5QGQTLoHw6HPvH/GIUERH5gFJyR0REZA/09ua3ue2t20jZFAZDW6qNLz/4ZRLDXBsmHzNnQiyWue655yBS4EmLEqkESW/ow21mr5/dtWACUDIxe6ONT4H1stcXwM9f/XnnFOgA+4/en/sX3c99C+/rvOw/en9MuntK0kty67xbcb2RmaI9Q0WO3kIbHgOvQPfNwh9mDvOqnAknPg0l4yFYOvh2Q2VDj01ERGQ3UnJHRERkD+N6Luf/9fysKcAbWhq47pXrdlNUXWbOzJ4OfetWWL9+6G13zyE8v/r5oTcIPL3y6cwVVYdkb7ThMUg2FeR43b24+kVW7VyVsW5xw2IufOzCjMs/3v8HttsU5E2JJn77xm8LHk+/ao4jcwwUsPbP6Zo4BdC9x44J+okdp6T37UVERPYSqrkjIiKyh7nxzRtZ07gGgLJQGUeMO4LX1r9Ga7KV6165jvMPOZ/9Ru232+KbOBFSqez1jz4Kl1wCwSGcnTQ1QWWlf31H2w7CgTAJr6u30kG1B3HC5BN63X9B/QJeW/carvV7vRhM5/TjnUYf7SdzbLcbUf98fkOBBug/n//PrHVxN048j6FOv37911x57JUFj6lPo2f5Q526J3M2/z3/ujsDMfYkCJZDQL9VioiIKLkjIiKyB1m/az0/eO4HtCb9oStjSsdwy2m3cPith5PyUrS77Xz1b1/ltX9+DdNzZqMREgjApEmwYkXm+nvvhQsugLIhjJAJdZuJe/GWxaS6FT+OOBEuOOICrjjmil73f2LFE5z/1/NpbG8EwGJZUL8gc6PKgyBYAsluRYKSO2H7PKg9bvDB9+B5Hq+uG/xsX2t3rWVb6zZGl4wuWEz9qj4M6FEvx22Dhpdg7Cf8YW2FUn4AOOH+txMREdkL6KcOERGRPcg/P/zPxFN+r46ycBk/OeknzKidwQmTTujshbKwfiF/WPCH3RrnSSdlz5o9Zw5s3z74Nl0XHnmka/n19a/j0dXrJhKMMLV6ap9tTK2emtVT5536dzI3qjk2d5Hg5TdmJnyG6K6378ruNTRAP37xxwWKJk/l++euPbT0Bki1ZK8fipY1kG8NqQfH+jOT9XlxChufiIjICFJyR0REZA/xt6V/49V1r3YOKSoNlfLFg74IwE9P+imxkF/FuCXpT5G+tXXrbov11FOhvDx7/S9/CS2DzAHE4/CrX3UtL9qyKOP/1tp+kzuTqyZ39nrqsLFpY2Yh6mgtlOyTvfO6vw045r7c8NoNQ27j9+/8vgCRDEDA8Xvo9LT579Be4OfbpqezZy7rTX9TrAMwPAWxRURERoKGZYmIiOwBdrXv4oJHL+hMTJSGSvnhx3/YOYX2keOP5EN1H+qc+SmeinPJE5fwp3P+tFvi/fjH/WRMT3fdBT/72eDaXL0a3nzTv96abM1KXrWl2jKmDM8lGoxSHilnZ3xn57pYMMa7W9/lkLpuhZTHnworfpfZS8Vrh+U3wQGXQ7DHdGADlHATrNm5JmNdgAAXHHkBoUAo5z7WWu6YfwftbnvnupZECw0tDYwpHTOkeAZk0rl+DaKeRZTf+R4cffvQZqZyYl1Flb12eOE0OPkf/c+UFa3LM8EjIiJSnJTcERER2QN86g+fYmdbV0KiPdXOQ8se4pF3u8YpJb0kjnFwrUvCTfDnJX/mY3M+xsVHXTzi8VZUwPTpsHhx5vpdu+Caa+BHPxpY7Z3WVrjwwq7lJVuWUBIqYVd71zCpWDBGabj/6bL3rdg3I7kDsLBhYY/kzmdh1e+zh2Et+W+YfiEwtOTOU+89RcgJZRROPmL8Edxy2i197rczvpN7F93buRwOhrlv4X1cfszlQ4pnQMZ/2k+89LTmAdj/cr/oci8Jqn7tfyks/9+u6dC3vQGvngvH/sEvaN1bUeuzNmevu3f31JwSEREZDhqWJSIiUuTunH8nb2x4I6O+TMqmePb9Z3l65dOdl7kb53YO2QLwrMelT16alcgYKWeemXtmrF//GrZty7+d9nZ4/HF4tVvt4YX1C3E9N2O7fSpyDKXKYfro6RnLzYlm5m+en7nRmI9mTsvdIbkL5l4Gyea8jtWbm+fcTFOiq+dL2Alz9oFn97vfGTPOoDzcNd6tNdnKzXNvHlIsAxau9otOZ7Hw6pfAzZH4ydeH/gv2uyBz+vMNj8Ej0+C9WyHVColG6PHYi4iI7OmU3BERESlirYlWLnzswv437IVnPT79x08Pev/Z62bz2PLHBrXvKadASUn2+lQKvvGN/GvvtLfDZZdlrpu3aR4tycwG8p3+/eDagwl0O0WyWF5f/3rmRsHSXhIYwOo/wq5lg05i7Izv5PnVz2esCzthTpl2Sr/7njzl5IxhWQBrG9eybOuyQcUyaJPOz92LpnUdvHnh4IsrBxw48jcw63f+lOuB9BTrie0w73J4aB94/Ruw4n+hcSl4CUi1+cm2VItfCDvVClsGPwuZiIjIB5GSOyIiIkXs8qcuz5juG/xEQEWkIuelPFyOIXM4yhsb3mBh/cIBHbepvYmLHruI4+48jtPvO51T7zmVTU2bBtTGMceA10sN2xdegG9/u/8ET3MzfOpTsLnHqJs3NryRte3BYw7OK65po6ZREs7MOi3dsjR7w0nn+TVgcnn+FGjd0PdsTr0kOB5Y/EBnraQOBsOHxn6oz7gBRpeMZnLl5MzDeCnunH9nv/sW1JQvg7W5/7fmXnj9n/pO8PSX/Jn2DfjcKpj2Tf8xCKbH8CV2wPqHYN4V8PhMeKAcHp4ITxwMjx4Af5sAfy6HZz8ymFslIiLygaXkjoiISJFatWMVf1zwx4x1YSfMs199ltf++bWcl9nfnM1PT/wpsW4Ffw2Grz/09byn3X5k2SNM/e1Ufv/273GMg2Mcnnn/GabfOJ2b59ycdzuhEJx3Hji9zEB9663wH//h19NJZeaviMf9xM6pp8Ib2Xkclm9bnrFcGirNu+fO1OqpOCYzqF3tu2iMN2ZuOOWruaf9Br8nybPHQtvG3EO0kk3Q8FLOXW+ac1NWr6MTp5xIwOR32nbGjDMy4k96Se6aP/Rp1QckNg7GfQropa7N2j/DC6fCzsX+/eMmwEv6w9riDX5ypj/RGjjqd3D2FjjqZqg93k/0OKVdyR4v4c/S1bIG2jb4j4v18E+Be8QWrRvCDRYREdm9VFBZRESkCFlr+fpDXyfpdU0FHQqE+NqHvsbHJn2sz333H70/v3rjV7Sl/JoxFsvybcu57a3buPDI3od4bWraxL88+i88v/p5WpOtlIRK+OTkTzJt1DTuevsuWpItXP3s1dw671buOfseZtbO7Pd2XHgh3Htv7z10fvMb+Pvf4brr/GFcqRQYA7ffDj/9KdTnmACpoaWB9lTm0KRgINjvNOgdplZPzZz6HIiFYixqWMTxE4/vtnIcjD4KtrySu6F4Azw2w68Rc8iP0zNoOdCyCuZf5deK6WF1Et7d9m+IOfcAACAASURBVG7GurJwGWfNOCuv2AFOnX4qt8y7JaOYdLvbzstrXubjkz+edztDNvO7sPk5cHt5cBte9HvU1BwDNcdDIOgPpdr4ONgcNXMuBr7cTxFkA4wFpgH7A6OACBAFXCABtAPrPVgBrAQ6cnb1CwZ6C0VERD4wlNwREREpQvctuo+3Nr2VUSDZCTj84KM/6HffkBPiBx/9Af/x3H909hBpSbZw1TNXccYBZzC2bGzG9ikvxRVPXcHtb91O0kviWY+wE+akySdx/qHnEyBAwk1w99t305Js4e36tzns/w7j9P1P544z7qAqWtVrLEccAePGwXvv9R7v4sVw+ukQi0F5OezYAclk79svrF9IJBjJqD2T9JJ5J3fGlo3NSJoBJN0kCxsWZiZ3AGZ8G3a8kz3tdwevHZb/zp8iPTIKvBQkG3NvC9y9y0/c9Tz2J6Z+Iq/YAY7d99is5FZzoplb5906ssmd2uOgYgbsmNf3dltf9y/96f1u62KBTelLLzm3XtXV9T6UTERE5ANOyR0REZEis6NtBxc/fnHG0J2ACXDq9FOZVDUprzb+5ch/4T+f/8+Mde2pdi589EIePu/hznVPvfcUZ91/Vmcvnw6u53bOwtWh+7CfpJfkwWUP8vC7D/ObT/+Gfz36X3PGYQx873tw+eX+MKu+tLX5l/4sqF+QldxoT7UzoXxC/zvj35d1pXVsaNrQdexUG3M2zOGiWRdlbjzhdAiE82jVQnvfU4BZC7c1klUQeUzpGCZU5Bc7+EPzjp5wNC+vfbnb0S0PLXuItmQbsdDQpmkfkMOvgxfP7L33zkBUkl+CZ7Dqeh+WZa0/g9uGDZCr8tGll/ozv4XDfhKythYmTOi61NX1PvxQRESkEJTcERERKTKXPXUZrcnWjHURJ8K1J1zbtcKN+7VMbNLvLdLx10uCMZSYEN8+8p+4/s1biKeTCUkvyZPvPclT7z3FiZNP5NoXr+V/XvufjF4sBsOEigmUBHNMcwUk3ATrdq3r7FHkWpcrn76S2etnc+NnbqQ6Vp21z3nnwRV5lFjJ1xsb3shKkNSW1uIE8v92PblqckZyB2DuxrnZGwaCcOB3YNFPwW3N/v8ALEvCJtcfhtUh6SY5bf/T/ALDLWv8oV7xBmjfAm2b/Toybpv/uFoXCEAgxNnRNuYEHILG8TNoBIi77Ty//CE+e9B5Q4pzQMZ+wr9sesrvxTQUNwHn59GzxvQydGsAvXIaGuDpp+HZZ+Gll/ykjuNAJAIrAnWM8brGA+6M1tHUBK4LiYSfBNq61b80Nfm9zBIJ2LgRxozJOwQREZEBUXJHRETkg8La9Bd0CybY65fU5vZmf+iUTfmFaG2ST1eP5qD53/R7hwRLIVIDJfv4dWGcEgiEwIn4vUysBS/B5bWVPFxWzbb2Fv+4NgXW8tyKx/jWo99iW+u2zsRO2AlTV1rH819/nmmjpvV5M3a07eAz93yGhQ0LaU22kvSS/GXJX3hs+WPcctotfPGgL2K63bZYDK6/Hq6+Ov/pz/syf/P8rHWTKvPr0dRhZu1MXl2XOV32iu0rsNZmxA7AAZfDsl8NObkzIwT3jYXEMTdB63poXAw7F3Ba61/gz7f5j2PJvlA+HcqnQdlUqJieLiIc86cFt0lw43xrbCO1Na/ixrdAewO01UN7AydPPG5IMQ7KMXfAI/sNPbkzAgWPX3kFLrsMlizxC343N8P++8OVV8Jpp8Fhh0FJyWaa2vxkjjEQMHBj+inhef7LKxDwn9epFCxbBk89pcSOiIgML9NzXHchzJo1y86dm+PXLRERkb2F50LjItj+FrSuheb3IV7vJ1kCMXCiEKqAcDUES8A4fkInEPa/MXrJrt4YXjskdvq1WlJtMPpoWHETtK0HE/KPd+B3YMpXoGSS35PDumACEIj6vUt6m2nJev6MQm47YPGMw6hf7EtjeyPBQNDPN1nLvubDnFz/OJtXV1Ff7395ra72L8Ggv+w4/l/P83ucvFZzAasr7gHrf/O1JgUGzlm7noMnTmD8eJg2DQ44AMaOhYMOgnffzR1mvsIRD34QyyqI/PUPfZ27z7w773Z+NftXfPcf381oJxaM8e4l77Jv5b7ZO6z7G8z+av9TeOdj9Idh58L0YxP3Cw4f/CMY8xEg4D9egUi6QHM/vIT/nDEBfx8njyFkBej5kmX9o/DquYNPgDkl8KU879tBxG8tfPObcP/9/uxsAFVVfkHvc87xm4wNYTRbMukni0RERIbKGDPPWjur53r13BERESm0xf8N73wfguXpL+hJ+OSL/pf0ZLPfQwbjJ10CEf9vX6znJ1+8JODBX2u6zSYU9+u+HPIj/xuqMRAo772tB8f6SabeeIb/XHYRf1hyA0uWQCwCo0bDuWeXcM4/GaZPh7Iyv/ZN9+nJjem6+N+hQ1j7e1oSN2OxOA5EI35vh8qSUoI5bvLdd8NJJ+VXV6c3oTHvQyCUkZQJBoJ5zdzV3dTqqUSD0Yx2Qk6IhQ0Lcyd39jkTqg6DbbN7nx49X9u6ze0+83tw8A/SSbqOBF3uIXE5BcJ+IZjdbZ/TYeI5sPYvA0/wBCJQOnF44kp74QV44IGuxA7Ab38LX/yiPxRrqJTYERGR4abkjoiIfLBZ6/eGSO70/7ptfj0Zt80fkoTFn//Ypi90/UJvjN9rxHT7fyCUHsYSTf8t8XvQhCphADVZ+o65+zTO3Y7buZyODZO7l8GCa2DRtdnrOwSiMPFLsOERf7nhJXjpLJj0Jb/XR8n49NCr9m6JhvRx+ul98faaw7jq9zd1Lidb4L9/DP/aox5yWRl5qRxAIuKYY+DMM+HBB6F9ECN4SkrgK99ZyH1tmY9jSbCEadV9DyXraWr11KxZq9qSbSyoX8Bnp382ewdj4Jg74cnD/OfmYERq/Vm33HjXunC6RlGgl55X3fWXuPMbgvNzTDM+Eo65y0/UrL4n/wSPE4PKmXDSP4Y1tNpav8dZd2vX+j1uCpHc6Y/r+knNeNyPo2N4V/frxvhPg+4Xx/F7FEWjvXdYEhGRvUNew7KMMZ8GfgM4wO3W2uv62n53DMuy1tLY3siGXRvY0LSBhfUL+fv7f6fdbeeIcUdwzD7HMLFyIvtU7ENdad2AiiqKiMhucG+PbyrVh8Nn3to9sQxQYyM8+NcUyYZ3iLW9RTi5hn2qV1JXtZWqUTFKKmKEYzECkXKIjMYESzHGwQbCfhLIOOAlMF4C6yVh0Y8xqW5TSf1rAHZ6EADGAOOBGmA0UJf+O6YSKsdD+TgIxcAJ+T2EnBBgwU2Cm/L/bnvWr9UCeJ7h5heu5u53rmfBAv9L46hR8IUvwNln+/VHKir8L6HdpyM3PfJUtkeezXH8tpJJPwnTm127/CTPypV+Edp8lZT4NVFmXHQNP3v5pxlTxFeEK3j+G89zxLgj8m6vOdFM9fXVpLxUxvozDjiDh859qPcd378b5lw88ARPsBw++RK0rIN5l0H7Vki1Ahb2+Rwcci1UHOi3awLglGYnfPJK7tB/UeLhGJbVvY0FP4Rlv+w/weOU+NOpf+yR/IagdRhk/H/8I1x8sf8cjafza+eeCzfe6Hd+Cof95/BAJZOwahVcdZX//N6+3X+POPFEOOss/7VRUQHl5f7zOBbze/p0JHO694jrSPhY68cYj/t1qhob4bjjBhefSE+u57KpeRNrdq5hTeMa5myYw5PvPcm72/xxsweMPoDPTv8ss8bPYlLlJCZVTWJc2Th9vxIZIb0Ny+o3uWOMcYDlwCeB9cAc4Dxr7ZLe9hnO5M4vX/sFT7/3BOsa17F61zraUvH+d+rHxLIx7FtWx4TSMdx+4vcoD0UBD/8XVSd9MhxN1zVw/ToKGXLdhz1OLAIO4KTHvAe76io4kfQY+Gjv9RD2EtZaWpItbGnZwitrX+GxFY9R31zP1tatNLQ0sK11Gx65u7qHAiFqS2qpLa2lpqSGutI6vnzIlzm47mBqS2pHdtpX2WMlUglW7ljJxqaNNLY3sr1tO+sa17Gm0T/52di0kUggQlmkjImVE5lUNYlJlZOoLamlPFLO2LKxTK2eSkWkYuSCHjsW6vP4sjcYdXWwefPwtA0svfNrlLmL8FyXkGmhtKqS8pNvwWD999TOGiJR/29nT5gALLkBs+x/+j5A7cfhky8MS+xXXQW/+EXmulwftx2/xncuWC89ZKujoLLTuUH3zkjD+rhCZ+GcJspYxgzeYz82MIE1TGQNk9kcnICtG8eocRGqa4MEQg5OKEAg6F881+KlPGzKw0u5NO1w2bopQXLzVqpbN/KXTR+hcmzv78vbt8NRR8G6dZkJpN6UlMDJJ8Pf/gafve8Unln5TMb/Q4EQDZcsoioc82vQeIn0ELc029Hrq/uDZCj/v+Np7jEr2eSKfVh10Zz0Z3i691fPZMLy38H8f8u/d0qw1O+ZUvPhznjs5udIrn0KU/8MwZZ3scbBcyqhYn8CFdMwlftjKg/26zV1vAYC4XSR7Xa/15Ybh+dPyT7e7kzudFj3ECz4D2hek76furUdLPPv15nfhQMu63/YYk9DiH/nTvj5z+Gee/wZszqKKh95JHzsY/6wwSlT/Le/ykr/+dmRbAH/pROJ+Pts2eI/h196CR5/HObMyTzWgw/C5z+fO45UqiuZ0z3sjkRPR68dkaE654FzeGvTW6xtXJuRFB8KxzhMqpzE4eMO5y9f/EtB2twTedZjR9sOtrVt480Nb/Lg0gepb6lne9t2trVuY0fbDlI2lXPfUCBEdaya0bHRjIqNoq60ji8e9EUOH3c4NSU1VEWrCOzl3y33ZENJ7hwLXGOtPSW9/D0Aa+1/97bPcCZ3Rv/EsL3b9/sAMLqklumjprNPxT6MLhnN6NhoSsOlmG4JlqSX7HyhNLQ0sGL7CtbtWpcxlt4A3vQeBzziVzCjgPOzSq/MtcPbn/jd8yyBgF/4Mxz2T9jCYSgtJWfth6Gy1uJal4SbIOkmaUu10dTeRFOiiXgyTmm4lPJIOWXhMqLBKKFAiLATzvmrxytrXmPllnW0JNrYuGsTT69+jJZkM/FUG/FUnHa3jXY3TtyN41mXiBOl3Y0TcWJEnShhJ0rUiRFxopSEyjhk1CwOGnU4JaESosEYp0w+naDjdN4/juP/jURGpjv6B9lwPy/XfytJJBTsfF6GwwV8Pr5/NxzxT9BYoPZ6GkByx7MerucSDASzZxrqRc/NjjkGZs/u3qjrF5u1Xnroke3xN53oSU8D3fnXidDUEuLG0T/i+8kf5xXLQKVweD76aTbGR7OVGuqpo2X0RCpmjCdYU0l4dDnBshjhsjBlFQHC0QABx2ACBuMYAgGDl7K4rsVzPdwkNO9yaW9J4ba08eV/m8A7C4Ps2EHnpeM1233IxpXfzn1f33WnzegF4Lr+l9Rk0l934TVjKWsexuRRHs+d+no/wbNlS1cvilxKSuDYY+HJJ/339e/dfxJ/fu/5jG32n/QpnvjK0wMO8+LHL85KFM0aP4s/nfOn/ndecgMsvKbvBI9x/CF2Jz4BYz7mr+rxkJ14Ijz3Dw9aVmdOhd622S/U3bYpnaxK+Ymdjh+lTBCiY2DDY5kxROvgrN7ve9dzcZzcb0LW8/p//Q408bgfcAp+DzQH2Am8CMyDnr/nPHDrTl5dVNlZtNt14TOf6Sri3ZEQOfPzuWN85GH/nLf7qW/H68BxoNa+RBnv07KzmfoNTcQTEdY2HcxbSyewcn0N9VtL2LojSnvSIRZxCQYto0Z1vW93vI527PB7ncXbHYyB0VVxxtW2Mvec39H245+zg+rOSxsxWiglUT6aZGkVbkk5TkmEQCSENQFswMEEAthAAFwXYz2M54Ln4bUlcFvjhFobCTVt5/RNtxKtKs4fs25/8x7Wbt9Ea7KV93e+x+ubXyDutpF0EyQ9/9LbD3yGAOFAmGAgTCgQJuJEOaLmo0wpP4CSYCmjY7WcNfXrna+tYLDrEo36hbM/0EPa3LhfUN+m0gX2U10JaesBHeP2yC8B23Fj00OWza8P7PxXdSuUJuHgBjhwC0xshEmNUBXP+tkaC+yMwppKWFsJS2tgUR20hGBHt96Zie1fpv2Sr+K2tZByPVJeFM/E8EwYO/o4PJysnp79hd89ydl9uGLH42pNEhtsI+620pJoYUvrFuqb62lONFMeKWdM6RhqS2opDZdSEiohFowRcrILY83f+A5L61fSkmhlS8s2HlrxAC2JZtpSrcRTcdrcNtpTbcTdNiyWqBMj7rYRCoQ7z7ujwRhRJ0ZJsIwDRx3KkWOOpyRYQmm4lH969vT+b/AQ2B/5d+jll/s1xLpraem7F+3udv318PLLXcuhEPz7vw8ud59rn3nbnqc1tY1l7zUze/kytpa9Ssppxg20UTG6jSRx2lJx2pJtOAEH13MxGGKhKLGgfykJRikJxSgLl/HJiR9hStW+xEIl1JSM5rgJH06fgzqZn8uBUEE6dAwluXMO8Glr7QXp5a8CH7bWXtLbPsOZ3Hn2pIv55PabIQSEgVgQDjkGomGIxvwz23AIgukL6TkqjYHIWxDuu0v/LX+FCxfhVyMKAdVVMHEaBJ10290+EQKO3zb4xxnzLtT0Ps3H/O2jiETj/i9rWFzaGX3IpVRPPR8Am/GLocVg0utyP4v936i7nhyrHz6FGdEeJ1T9/To3ED2HSJROhjNWFaTpZMLyb2O+zfeTv85YXxWH0ADrUsaD0NStdqQ1sGh8Dau+PAlG+bULmm0D+045nLFjDsra3xiDIYDt5SSiQ1mwqvP62U9exorUECqA7maPhE7DMf6vNUkvybhpBzLjmM/T69Ovn3dQQ6Bzt2deWs13vns81vp9yj1rufr74zn19FjWm23PXyh7aT7j7xdOXca8pZmFUgv54/LXpn2Ns0N/oCoOZQkIWIiloLYFquP+cl8s0ByGLaXQGPGfj21B/4RoZxj+5QsBLP53mCRezn6AA+EQIOgEcUyAY1OHcXbt63T8DhcADjzg64ypOwqD/z0qYCBgLcYEMJ0fNv77T9Wmx6iqf7zXYx26KsLC1BCnNu5PMgLtFelLJSRjkIpR4lRS6lQSNRXEQhGioQjGGAI4GAwB42CxeNbF4mHxSKRStCXjxN0WIm4ja+6+L+NQF18Mv/tdj+Pn+qKaR2Ji+bbljJ1+OBU7hjY1dm8CuNhu7/+jRsG2bTk2HGT8We/3o2bBp+dkb9ez/XzadhOw9OeZ66JjoXy/rE13Nga54aZ9+c1t++B6EI93Jb9LS1KUxDx+9r1VfONLmwmF/FfPXbc1077qMVzPIeQkKQm38pUrjvWnELdu15ciE0jPTJZus6Pn16o/wOo/9hr+s2uv5I3ULzPWffjDuQvmVrU/z7TG7xBzlxO0XTM9eThYQmyLfpZVFdfRFuz6ZempU29kQ2sVCcLsopzYvrV882dTSboBAuEgxgkQjDhEY4Zw2Pg3I5D+7Ap06wBm/QReMmGJxy3JuEdTcwMP1X+FnbSw02tmWXIDu8j+7Np0A4ztMTHV5lIYd3X2bTy4chqTy8ZTE61iUtuJfOeK/6K8dWuv999QTIisYGN71/MkEukl8Veo5/3kr8Bxf8jarLUVNm6ETZv82lCpFKRe+ipOaitBJ0XISTKmooEJozZQEduFMbC0HWau7f82DuS+725WahRzg9v7P8AgfTdyAfslAZvCtqxih2s460sXEXAcLAFMxhDB9Gupj0+0gAkQMF2v54l/O3W4QmdsspQLX2nhmheHp/25V1Qza+0OeHB42ucshq9tgHt6LO9/Kcz6bfZ2ud7vn7moz/pwf1rwcZZdfwLX0EcNuSE467JyDn2nadgeW3PN8LTb4YTbn2Tn5nI8DB4OB84q4Uc3TgUCBJyO3r3GT2YFunJ4fnB0vsQ8a0nYeMb7/+Y1f+Oz910wbM+dl782ho+e0pC58ow1BSt+X1e6hobWSZ3L5eX+sNZCGe4fbzsSa8NlKMmdLwCn9EjuHG2tvbTHdt8CvgUwceLEI9esWVOo2DOceKI/o0GHXh/oQX6wmysngZOERClgiVY2Ma6mlNJQKaXhrr9+jwd/YHNrspXWpJ8ZbkmmL+nr1dFqXOvSkmjh+OYD+ev+L2Qe8CN/9mePyEc/BTYvmH0Cy6uWgRsE60DJVg6d/CFKImX+l52A43+Rw/9ANcbgWhdrLSem3uVkd0Wfh//ys/vh7PseAeu/lzSVhjh44gkYLAGP9Nd5S8CCwWA8i2fAM5aPBd7n46b3RJC1sGrLFFripSTcMIlUmNTYMwke+u8Z48s9L3dNB+qfg/rnMJ0JGYv1PLAuAZtk3o6lXLH42WF7g7vq8EuZetArHGPnE7IQN1By3LmUlY0hEggRdYKECHT1Jus2FsO6L5LwXiVuIW6h2ULCQsj4f5MWDnq4nKZHy3FxSBEkacKYUdXYYBjPCWKDIbxAMKOftu04lgl0FlQ16U8B43lYzyPguRgvxYFHDd9984tjP8lVszN/+X7kETi9QD9WXPajLzFqwXiq2rveyw7856uIlpX6C6bbh2GPc03bugbT2uN5abqeV8aAfe9OGhv9k9aEGyYVnUbdKdfhuv6vtB3FLjt+Pep4aK0FdiyAxgUdR/PTtZ7FWtc/QXbbOX3XZblvWI635j5PlXN8Rk18+3jWOhMhXuknRpw2zjmzlE/MmtTZZbcqWtX5XtZd0kvSGG9kR3wH29u2s7ZxLQ0tDVRHq2lsb6SxvZEjH1iJ2Xc2YQshC0sdiBz4KUqjVUSdMDEnTEkgTNQJEw2EcKwhiUubmyC+azZtTW/R5kGbhRYPYgGYEOx63icXldOyrInRrVDdBrEkVLTD+GYY2+wn2/oSD8LmMv+L0fYSP6nWGIVtJbA9BnNO9O+2sPEvY8vGMr56Gg4QCgQJGYegE0z3NnLSX1f8O/rDiXc5Ktl7Mv+mnfCvW3L/r6OXXsjx/wYDQRzj4FmPlJfye/t5yc5efzbHo/6p8edy8Zj7OnvtbN/uJxc6eu509P7q3pun+y+d3Yd7WOs/l9vb/b/WwqXHXkIovjJ9luhCeLQ/1XrH9Oqdz8aOQjvdYnzvNlh5e98Pzl8Z0HvODqr4NVfwCsfTSCU1bOUsHuQb/J4wmeO2FjOTO4+6ieCc2cSJ0kQFR37tIOoOHIWLg0sQgg7BaJBILEAgaNKJEZPO7xj/depZrLV4LiTiHsm43y1j+bXXc03bTbkD7c1M4BP4tZBSwCbg8fTfnsaM8ccDDYOF40dx6LeyEwCOcaiIVFARqaA8Uk5JsIRIMELYCeNZj3a3nfZUOy1Nq9nVto1GD1pyvRm9+AN4/icZq3KeZg7yHG2/3+7Hyh0ruzUOuCHwQuCG/etuGGz6OWo7XrWBzh9t/B9uLBjb9de44CSIlm1jfBDKDZQFoDwAVeFSqiIVVEbKKQ3FKAlGCAejBJ1w+lPdEDABzm99jhJ6f1NKWpgTh8qSMcQM/vnKPmdRNfNyKqMVBEyQzF9Uur+uDCy9AZb9gnYPtnnQ8ZHnWmjy4P8tPpYnR88mXQSAjS60B6IEnHBnjAFjMCZAwAQIB0IkvCSe9bDWw0u1Yt04nvV/bAga2DfoX3ctzHktRtnjw/cjVuKyUlrjQVzPIWWDJKv2x37ie3gWrAn6cXnpBFL6W27HvWMbX8Y0Pp++pzq6gLiAh8FlxbZSbgm+SQhDGMNWm6K1fAylFVOJhaJEnSixYIRfXfAwFTszs4WNVVEu+58ptO1cStzS+Zl1cNi/b9otbHv/I+yz3yud+1gLh049lcrSCX5MxmCt5ewv/oHYjsz7MFkVJPS73MNuOtQ9+XniUx8n6IZx3Aih6C4qYxFKw6XEghFiToSwEyQcCBFKPy89PDzP5ZboIqpN3+3vd+UKNjdPJhKMEwm285Fj4/zh/yX9HkJeEmtdTHq4VkeCoeOGGmP9H+/8G4oxEHrpZEzC/7Xh3XiAGUtHgxsBz8F4QSJOGdWxKkImTCQYxSFE0IQIOg6OCYL1e/v6tyHpXyy4+D+Eu57n/9+kOHrTeOpq3yHiBQnjECfFSZ87mTGj9qMsGKMsVEJJKJIentTtNWUt3vv/j9bV99HsQbMHW13/HLzE+I9xq4XPP1lB6yMlneffKYJQXe2fdwfDWCeIGwhhAgYcp+vcO31/dH8DNHR84HoYL4XxXGb8/LnMB2PC6fDxR7IfpEEk1v66ajrPlq7IeA+eMvYo9h1zhD9ZQDq+XM/LtuoYK+48kENbe+8U8b0lM7l6whJGdd/1tAdgzOGdtzjjPay75b+B927stW2A0zYGeLyl4/tLuhUTwDEOTsAhkL6+4r+aqWvO/KCpL4MpV/vvXR7+c8eQ2Rn0Gw/8ntQWQ8BxcQIu+88q5ewrJmGth5NOrAWMlz7N8V/DHd9BqxvvpGrX3X3Gb2s+ivnUS31uMxR7zLAsEREREREREZG9UW/JnXwGfM0BphtjphhjwsC5QI6UooiIiIiIiIiIjLR+y3Zaa1PGmEuAp/F7et5prV087JGJiIiIiIiIiEi/8pqTxVr7BPDEMMciIiIiIiIiIiIDNPR5uEREREREREREZLdRckdEREREREREpIgpuSMiIiIiIiIiUsSU3BERERERERERKWJK7oiIiIiIiIiIFDEld0REREREREREipiSOyIiIiIiIiIiRUzJHRERERERERGRIqbkjoiIiIiIiIhIEVNyR0RERERERESkiCm5IyIiIiIiIiJSxIy1tvCNGrMFWFPwhn01wNZhalvt77621f7ua1vt7762i739Yo692Nsv5tiLvf1ijr3Y2y/m2Iu9/WKOvdjbL+bYi739Yo692Nsv5thHov1J1traniuHJbkznIwxc621s9T+yLdfzLEXe/vFHHuxt1/MsQ93+8Uce7G3X8yxF3v7xRx7sbdfzLEXe/vFHHuxt1/MsRd7+8Uce7G3X8yxj0T7vdGwLBERERERERGRdwTCZAAAC/hJREFUIqbkjoiIiIiIiIhIESvG5M6tan+3tV/MsRd7+8Uce7G3X8yxD3f7xRx7sbdfzLEXe/vFHHuxt1/MsRd7+8Uce7G3X8yxF3v7xRx7sbdfzLGPRPs5FV3NHRERERERERER6VKMPXdERERERERERCStqJI7xphPG2PeNca8Z4z5boHbvtMY02CMWVTIdtNt72uMed4Ys9QYs9gYc3mB248aY940xryTbv/aQrbf7TiOMWa+MeaxYWh7tTFmoTHmbWPM3AK3XWWM+YsxZln6MTi2gG0fkI6547LLGHNFodpPH+PK9OO6yBhznzEmWsC2L0+3u7hQced6LRljRhljnjXGrEj/rS5g219Ix+8ZY4ZUlb6X9m9IP3cWGGP+ZoypKnD7P0m3/bYx5hljzPhCtd3tf1cZY6wxpqbAsV9jjNnQ7fn/2UK2n15/afp9f7Ex5ucFjv/+brGvNsa8XcC2DzPGvN7xnmaMObrAsX/IGDM7/b75qDGmYgjt5/yMKsTrto+2C/K67aP9grxu+2i/UK/bPs8PhvLa7SP2grxu+4q9EK/bPuIv1Ou2t/aH/Nrto+2CvG5NL+d9hXjN9tN+oV63vbU/5NdtH20X6jXb5zn3UF6z/cQ/5NdtX7EX6DXbW+yFes321n5BPm/7aL+Qn7cZ36UK9Zrto/2CnSP30n4hz5F7tl2Q12xv7XdbP+Rz5F7iL9g58oBYa4viAjjASmAqEAbeAWYWsP2PAUcAi4Yh9nHAEenr5cDyAsdugLL09RDwBnDMMNyObwP3Ao8NQ9urgZpheu78HrggfT3M/2/vbGPsqqow/CwZIG1VrMQq0mqRlIaEkAJKjEDBlhCKpFiJBoNJTU2MRqKQ+AGpIRpjAgrqP0ikagKIglTEH0orpuAfEFssVFsRBOzQL9T4SUJBlj/2Hr3cnr1nvPs9rTeuJ7mZM7ftc3f3ue+sdfY95wy8pqfXOQzYA7xZ6DwWeBKYlb+/HfigyH0SsA2YDUwAPwEWCbwHZAn4EnBl3r4SuFboPhFYDGwC3trD2M8DJvL2taOOveJ/9cD2x4EbVe78/ALgHuDplowVxv454JOi92OX/535fXlk/n6e0j/059cDVwvHvgFYkbcvADaJ5+Yh4Oy8vQb4QoO/s0YpcltxS3Jb8UtyW/GrclvsD1qzWxm7JLcVvyS3tbkZ+DstuS2Nvzm7FbcktxT6PkVmp/GrclvyN+e24lZltthzt2Z2mvE357biVmV22uORxsyWxi+ptxW/st6+7FhKldmKX9YjF/zKHnnYLclsyZ+fk/TIhfE3Z3aUxziduXM68Li7/87d9wPfAS5Syd39fuBPKt+Qe7e7b8nbfwO2kw7aVX5397/nbw/PD+nNlMxsPvAu4Calt2/y6vpSYB2Au+939z/39HLLgSfc/WmxdwKYZWYTpIWYXSLvicAD7v6cu78I3AesapUWsnQRaZGN/PXdKre7b3f334zim6F/Q54fgAeA+WL/Xwe+ncOI2a38DPsq8OlRvTPwSyj4Pwpc4+7P57+zT+wHwMwMeB9wm9DtwNSne0fRkNuCfzFwf97eCFzc4C/VqObcltyq3Fb8ktxW/Krc1vqDpuwehN6j5JfkdrrxC3Jb8jdnt+KW5LbS96lqbadfmNuSvzm3Fbcqs7Weu7ne9tnTV9yqzFbHLshsyS+ptxW/JLeFYylJZkt+ZY9c8EtqbcEtyWzJn5H0yP9Lx8njtLhzLLBz4PtJhE3KwcLMFgKnkFaDld7D8mmO+4CN7i71A18jvflfEnuncGCDmW02sw8LvW8BngW+mU+Vu8nM5gj9g1zCiAWrhLs/A1wH/B7YDfzF3TeI9NuApWZ2tJnNJn3asUDkHub17r4bUtMLzOvpdfpmDfAjtdTMvmhmO4FLgauF3pXAM+6+VeXs4LJ82uw3Wk8n7uAE4Cwze9DM7jOzt4n9U5wF7HX33wqdlwNfzvv1OuAqoRtSflfm7fciyu5QjZLmtq/6NwO/JLfDfnVuB/3q7HbMjTS3Q355bgv7VpbbIb80u0NuWW4LfZ8ss333lTPwj5zbkluV2S6/MrOVuWnObcEty+w0+7U5swW/LLMFvyq3XcdSyjrb97HadP6WWtvpFtbZA/ziOluamz575E7GaXHHOp6Tnp3SN2b2SuBO4PKh1chm3P2f7r6EtGJ6upmdpHKb2YXAPnffrHJ2cIa7nwqsAD5mZktF3gnS5Qw3uPspwD9Ipz1KMbMjSD/47xB755JW9Y8D3gjMMbMPKNzuvp10CuVG4MekSx1frP6j/2PMbC1pfm5Vu919rbsvyO7LFM68YLcW4WJRBzcAxwNLSIuP14v9E8Bc0mnRnwJuz5/8qXk/4oVZ0iehV+T9egX57EEha0g/KzeTLvvY3yrss0b16a75Vbnt8itzO+jP45Vlt2Ps0tx2+KW5rbx3JLnt8Muy2+GW5bbPvu9Q+1tzW3KrMtvhPxlhZgvjl+S24JZldpr3TXNmC35ZZgv+5tz2fSx1qP0tma25FZnt8it75Mr4++6ROxmnxZ1JXr5SOh/d5Sm9Y2aHkwr8re6+vq/X8XTJ0SbgfKH2DGClmT1FuhxumZndIvTj7rvy133A90mX4SmYBCYHPjn4HmmxR80KYIu77xV7zwWedPdn3f0FYD3wDpXc3de5+6nuvpR02YfyzIVB9prZMQD568iX1xwKzGw1cCFwqbv3uaj8bRourxnieNKi4Nac3fnAFjN7g8iPu+/NjdBLwNfR5XaKSWB9PlX656RPRJpueDeMpcsd3wN8V+kFVpPyCmnRVzo37r7D3c9z99NIzfITLb5CjZLktu/6V/KrcjuD8TfltsMvy27X2JW5LcyNLLeVfSvJbcEvyW5h7qW5zc7Bvk9ea3vqK4t+Zb2tjF1Sawf8Ux/CSevt4PjV9XZobuS1tmO/SmvtkF9eb4fmXpHb0rGUKrN9H6sV/YLMzmTsLZk9wA/cjC6zneM/CD1yJ+O0uPMQsMjMjstnSVwC3H2IxzQj8ur3OmC7u3+lB//rLN+d3MxmkRYEdqj87n6Vu89394Wkef+pu0vOHgEwszlm9qqpbdLNuSS/tczd9wA7zWxxfmo58GuFe4g+PvmHdDnW281sdn4fLSdduy/BzOblr28iFd0+/g+Qsro6b68GftDT68gxs/OBzwAr3f25HvyLBr5diSi77v6ou89z94U5u5OkG3zuUfjh343IFKsQ5XaAu0hFGDM7gXRD9D+IX+NcYIe7T4q9u4Cz8/YyxAunA9l9BfBZ4MYGV6lGNef2INS/Tr8qtxW/JLddflV2K2OX5LaybyW5nea905zbir85u5W5l+S20vdJam3ffWXJr8htxa3KbJf/YVW9rYy/ObeV/arKbO19o8hsyS+pt5W5b85t5VhKktm+j9VKfkVmK25JZgv+i1WZrYy/7x65OKCxeZDuCfIYacV0rdh9G+mUqRdIO/hDQveZpEvIHgF+mR8XCP0nAw9n/zZGvAv9DF/rHMS/LYt0X5yt+fGrHvbtEuAXeX7uAuaK/bOBPwJH9TTnnyf9QNtGWmk+Uuj+GWmxayuwXOQ8IEvA0cC9pIJ7L/BaoXtV3n4e2AvcIx7746T7fU1ld+S79Rf8d+Z9+wjwQ9LNWiXuoT9/irbfltU19puBR/PY7waOEfuPAG7J87MFWKb05+e/BXykh/f8mcDmnK0HgdPE/k+Q6uFjwDWANfg7a5QitxW3JLcVvyS3Fb8qt9P2B6NmtzJ2SW4rfklua3Mjym1p/M3ZrbgluaXQ9ykyO41flduSvzm3Fbcqs9P23KNmdprxN+e24lZltjg3osyWxi+ptxW/rN5m3zn85zcqSTJb8ct65IJf1iN3uCWZLfmHnh85s5Xxy3rk/+Zh+cWDIAiCIAiCIAiCIAiCMWScLssKgiAIgiAIgiAIgiAIhojFnSAIgiAIgiAIgiAIgjEmFneCIAiCIAiCIAiCIAjGmFjcCYIgCIIgCIIgCIIgGGNicScIgiAIgiAIgiAIgmCMicWdIAiCIAiCIAiCIAiCMSYWd4IgCIIgCIIgCIIgCMaYWNwJgiAIgiAIgiAIgiAYY/4FfmRgjnPhY24AAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1282,13 +1179,13 @@ "output_type": "stream", "text": [ "metacluster_0 pattern_1\n", - "total seqlets: 109\n", + "total seqlets: 81\n", "Task 0 hypothetical scores:\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1307,7 +1204,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1326,7 +1223,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1338,7 +1235,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABG0AAAB+CAYAAACeY+zhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deZwcdZ3/8Vcdfc1MJjPJTGZykiEkkATkiggIIuKCt/50V11dV9cDZdGfx+KxKwqirngsXggsPGRF3V3l564CWVQUUBbUQIKQhAQIOckxmZkcM5npu6p+f3y7Z6a75z56usP7+XhUpvubqm9/prumuupT38MKggAREREREREREaks9kwHICIiIiIiIiIipZS0ERERERERERGpQEraiIiIiIiIiIhUICVtREREREREREQqkJI2IiIiIiIiIiIVSEkbEREREREREZEK5I5n5aampmDp0qXTFIqIiIiIiIiIyAvPhg0buoIgaC4uH1fSZunSpaxfv37qohIREREREREReYGzLGv3UOXqHiUiIiIiIiIiUoGUtBERERERERERqUBK2oiIiIiIiIiIVCAlbUREREREREREKpCSNiIiIiIiIiIiFUhJGxERERERERGRCqSkjYiIiIiIiIhIBVLSRkRERERERESkAilpIyIiIiIiIiJSgZS0ERERERERERGpQEraiIiIiIiIiIhUICVtREREREREREQqkDvTAYiIiMgL1/PPw7p1cPQoNDTAmjWwdOlMRyUiIiJSGUZN2liWdTlwOcCSJUumPSARERE5/u3eDZ//PNx5J4RC4HngupBOw5vfDF/6ErS1zXSUIiIiIjNr1O5RQRDcGgTBmiAI1jQ3N5cjJhERETmOfeUrcMop8J//CckkHDsG8Tj09Jjnd94Jq1bBNdfMdKQiIiIiM0vdo0RERKRsvvEN04ommRx+nWzWLN/4hml987nPlS8+ERERkUqigYhFRESkLG6+2bSeicfHtn48DtdfDzfcML1xiYiIiFQqJW1ERERk2t13H1x11dgTNnnxuGlpc/fd0xOXiIiISCVT0kZERESmVSoF73nP+BM2efE4vP/9UxqSiIiISFVQ0kZERKQKHU0c5aJ/uwg/8Gc6lFF99avQ3T25Onp7pyYWERERkWqipI2IiEgV2tSxiYf2PMSuo7vGvlFrK1jW9C2trSUvuWePSdpMtJVNXiIxue1FREREqpGSNiIiIlVoS+cWADZ3bB77RgcPTlM0w9f/4Q9DOj29LysiIiJyvFLSRkREpAo90f4EAJsObprhSIa3axf85jdm+m4RERERGT8lbURERKrQhgMbAPjTvj/NcCTD+9a3wK/8IXdEREREKpaSNiIiIlVo26FtAGw+OI7uUWWUSsH3vz9616hXvhJ++Uv485/hV7+CV72qPPGJiIiIVAN3pgMQERGR8TmSOEJPqgeAvcf2kvEyhJzQDEdV6H/+x4xNPJxFi+Duu2H5cqirGyh/6Uth5054wxtM9yoRERGRFzK1tBERkePLDMyQVG5PdT5FLBQDIOpGee7wczMcUakbb4Rjx4b+v5YW+OMf4dRTCxM2YJ6vXGn+f+HC6Y9TREREpJIpaSMiIseXGZghqdw2d2wm65vRfS2s8c0gVQa9vfDII0P/X20t/OEPMG8ehIZpHOS6MHeuSdzU109fnCIiIiKVTkkbERGpeJ4HmzfDww/Do4/C/v0zHdHMWr9/PSkvBUBfuo8nDz45wxEVeughiEaH/r/rrjONlcLhkesIhaCpCa6/furjExEREakWStqIiEjF2rIFPv5xc/F+3nnwutfBpZfCsmVw5plw++3Dd8E5nuVnjgLw8Vm3d90MRlPq3ntNa5tiK1bAhz4ENTVjqycWg3e/23SjEhEREXkhUtJGREQqTjoNH/wgrFkD3/seHD1qkgDd3WZJJuGJJ+CjH4XFi+H++8sc4AyOmRMEQf/MUXlbOrdM5287bmvXDj3V9623jt7CplgkYmahEhEREXkhUtJGREQqyt69Jlnz4x9DIgGZzPDr5hM5r3+96XYzVKKg6owyZk5HX0f/eDb9ZfEOktnkdEY1Zu3tZim2ejW8+MVmvJrxcByz7VlnTU18IiIiItVESRsREakYO3fCaafB1q0Qj499u0QCvvY1eMc7pi+2SrG5YzNRt3DAmJgb4+mup2cookIPPDB0a5pPfGL4gYdHE4nAVVdNLi4RERGRaqSkjYiIVIS+PjNeTU8PZLOjrz/U9vfcM/VxVZpNHZtKWtUEBBUzg9S995aOMxSJwNveNvGkjevCG984+dhEREREqo2SNiIiMuOCwLSS2bt3cl2cxtM6p1o9tu+x/pmjLCzAzCD1RPsTo2/c0jKdoUFLCxs2lBa/9rUTS8QNNtntRURERKrROHuWi4iITL1vf9sMJpysjGFZKtrg5EzUjZLIJggIWLdvDDNIDTXYzFAsa+jyIBhxsyCAnbHS8je+EWbNGttLD6e+fnLbi4iIiFQjtbQREZEZ1dkJV19tujfJyIIgYPuR7f3Pm2qa+h9Xwpg2+/aBPcSZxWWXDV0uIiIiIiNTSxsREZlRn/nMyDNEASxdarpPrVhhWuM8+CDcddcLr2XO8z3P41gOAGEnzElzTmJvz14CArqT3RxLHWNWZJJNWiZhyxYzCHEiMVDW1jb5VjYiIiIiL1S67yUiIjNmzx74j/+AdHro/1+wAB56yCQDPvc5ePe74YMfhFtvha4u+Md/HKInz3SP2zKDNndsxnXM/ZaoE+WUplOIhUx/pFgoxpbOLTMZHlu2lCbSLrlk1F5VIiIiIjIMJW1ERGTGXHcdeN7Q//fyl8NTT8G550IsBtFBs1zX10NtLfzTP8F99xWNd9LebrIEoy1Dmeh2ZbLp4CYSmVwzFgtObzmdkG2mZPJ8b8ZnkHrsMUilCssuvth8ViIiIiIyfkraiIjIjEil4D//c+iuUWeeCWvXQkPDyNNE19XBBReYaaYdZ/pirRSP7n+UjG/esEQmwbmLziXrm2mV+jJ9PH7g8ZkMj02bSstOP738cYiIiIgcL5S0ERGRGTFcoqWpCX71K9O6ZiyiUTjjDPiXf5na+IZVhmmzh/Nk+5P9j0NOiFXNq0hmB/ojPbb/sWkNbTSdnaVlbW3lj0NERETkeKGBiEVEZEbccgscO1Za/qMfwezZ45ttqLYW3v9+0zpn2o1l2uwJTpk9Es/32NO9p/95a10rISdEY7SRrkQXAM8eenbC9U+Fnp7C5/Pnz0wcIiIiIscLtbQREZGyO3oUfv/70vKLLoILL4RIZPx11taaAYqPVzuO7CDshPufn9hwIgCL6hf1lyWyCQ7FD5U9NjDd3IoHIV61avhBpkVERERkdEraiIhI2a1dO/RYNTfcMLlBa5uaJr5tpdvcsRnHHuhPtrJ5JQDL5y7vL4u5MZ7qfKrssQEcPmym+x5syRJw1aZXREREZMKUtBERkbK7/37o7S0sO/NMWLFicvXOmjW57SvZxoMb6Uv3ARB1o5w892QAVjevxrbM13naS8/YDFJdXaWJuObmibWaEhERERFDSRsRESm7hx4qLXvve3WBP5JH9z2KF5j50cNOmLZGM8LviY0nUhOqAUz3qPX7189IfF1dpeMQtbaOPPuXiIiIiIxMSRsRESmr3l54/vnCMtuGd75TF/gj2dQxMJ+2H/i0NZikTVtjG4410G1qw/4NZY8NzMxRxeMsL1w4I6GIiIiIHDeUtBERkbJ67LHS6bwvuGDo6b/FSHtpDvQe6H+eyCRY2rAUgLaGNtLewGi/zx15jmASs1RNVG8veF5hmWaPEhEREZkcJW1ERKSs1q2DRKKw7MILIRqdmXiqwbOHniXmDmS6asO1xELm+fxZ88n4mf7/8wOf9t4xTEs+xbLZ0pY29fVlD0NERETkuKKkjYiIlNXTT5vpoQe79NLSmYdkQPHgwgtnDfQ7si2b5prm/ucRJzIjgxF7XmnSRjNHiYiIiEyOkjYiIlJWO3aUlp11VvnjqCZPtj9Jb3pguq1ljcsK/n/J7CX9j5PZ5IwkbYZqaaMubyIiIiKTM2rSxrKsyy3LWm9Z1vrOzs5yxCQiIsexffsKn7e26uJ+NOv2rSNgICOyqnlVwf+f3HRy/+OUl2LdvnVliy3Psswy2AwMrSMiIiJyXBk1aRMEwa1BEKwJgmBNc3PzaKuLiIiMqKOj8PmiRZBKzUws1WJL55b+xzWhGpbPXV7w/6uaVuHaA32Rnmh/omyx5Q3VFap4YGIRERERGR91jxIRkbJJpSAeLyxbtGhmYqkW8UycQ4lD/c9Ddqh/uu+8tsa2goGKdx3dhR/4ZYsRTGspu+isIp0eel0RERERGRslbUREpGwOH4ZIpLBs4cLSMhmwtXMrNaGa/udZP0tbY1HSpqENa1DfJMd22NO9p2wxgmlpU9w96vDhsoYgIiIictxR0kZERMomkyltjdHQoKTNSDZ3bC5oNZPIJlhcv7hgnbbGNlLZgT5mru2WfTDihobSz7a9/DOPi4iIiBxXNBmniIiUTTZb2hojFCq92JcBP97444KZowBW3LiiZL2UN5C06Un18JNNP+F1K1437fHlNTeXfrZ795bt5UVERESOS0raiIhI2Qw1m1Dxhb4UKp4Jyg98dh3dNep29++8f5oiGlpTU+nAwx0dZhwjtaQSERERmRjd2xQRkbIJhUoTN5kM+OUdM7eqFLeyGauuRNcURzKypibzWQ7W2anBiEVEREQmQ0kbEREpG9ctTdD09GjK7+Hs6d5DwBDNk8Yg62dJZpNTHNHwGhpKkzbbt2vabxEREZHJUNJGRETKprGxtOXFvn1qjTGcX2775aS2f3Dng1MUyehsG2prC8u2boWamqHXFxEREZHRKWkjIiJlE4uVjm+yd+/QY90IPLzn4Ult/8DOB6YokrGZPbvw+dGjEI+XNQQRERGR44qSNiIiUlbz5hU+37fPjHUjpTYc2DCp7YsHMZ5uCxaUlj37bFlDEBERETmuKGkjIiJlVXxhv2+fZpAazlhmiRrJls4tUxPIGJ11VmnZhg0aaFpERERkopS0ERGRsmprK3weBLBx48zEUukS2cSktj+SPDJFkYzNmWeWjmFz//1w7NgUvUBrq8nwTdfS2jpFgYqIiIhMDSVtRESkrE4+2cwiNdhvflM689AL3VS0kvEDn55kzxREMzarVpV2dXvwQYhGp+gFDh6coopmqH4RERGRcVLSRkREyuqcc0pnGXr4YQ1YW+zXz/16Suq5b8d9U1LPWKxaBYmixkGHD8Pu3WULQUREROS44o6+ioiIyNQ555zSBM2DD4LjzEw8lSqVTWFj42MGhLGwOKP1DE6dd+qw26zfv56tXVv7n4fsED2p8rW0mTPHtKopnsL9nnvgox8tbWE1Hp4HTkvL9LaGaWmZvrpFREREJkBJGxERKavGRnNtvHfvQFkmAz/7GbzrXUre5G3t2tqfsAGoC9fxmQs+w1tXv3XYbW5+7Gb+4b5/6B8LJ+tnebrr6WmPdbDly83gw4P94hfwgQ9Aff3E6+3rg/r29tFXHG5Ua80rLyIiIlVI3aNERKTsLrigtOz731cXqcEeP/B4wXPLsljasHTEbdoa2wg74f7nAUHZp/0+/3ywi84uHnmktNvUeGWzk9teREREpBopaSMiImX3ylcOPa7NWBpSjGTKZimaYUEQsP3I9oKyVDZFW0PbMFsYbQ1teIFXULa1c+swa0+PV78a6uoKy4IAbrpp4km5ZBJuu23ysYmIiIhUGyVtRESk7F73uqFbTlx1FfT2Trze46Wlzr5j+0rKAgKaappG3O6EhhNIZAqbtBxJHqEv3Tel8Y3kwguHblVzyy3D91waTRDAd787ubhEREREqpGSNiIiUnYtLbBmTWn53XfDU09NrCtMby98+MOTj60SPNXxVEE3J4DWulasUbIeUTfKrMisgrKaUM2UTB8+VnV1ZhapYh0d8MMfjr+bVDJpxjvaV5rHEhERETnuKWkjIiIz4oorYNas0vK3v90MOjse8Tj88pfm4v54sKljE/FMYbOhpbOXjmnbRbMWFTz3fI/NHZunKrQxedObIBQqLf/0pyGVGl9dmQx8/ONTE5eIiIhItVHSRkREZsQb32guyIvt2gVvfvPYuzplMrB7N/zt305peDPq0X2PkvEL35yVzSvHtO1Jc04qeN6X6ePx9seHWXt6XHaZmfq7WHe3ScCMtQtcby985jNw6NDUxiciIiJSLTTlt4iIjOrQIdiyBZ55xnRz2b/fLAcPQleXaRnj++DlxsB1HDODUCwGTU0wbx4sWAALF0Jzs5kWevVqM7bNz38+sF3eAw/A3/0d3H67qaN4NqK8vj7YuRMuvdR0ozlePNH+RMHzsBPmlKZTxrTtquZV3PXMXQQMTHH92L7HpjS+0bz4xaWfad4dd8Ab3mA+s+LBqAfr64OHHjJj4YiIiIi8UClpIyIiJdJp+K//gh/9CB591MzKVFcHJ58ML3oRrFwJb3kLnHSSKQ+FwHVNssayzJg0+SWfWHnySZP4ueIKmDvXvM5118HatUNf4N95pxnf5u67TaKnpsbUD6YVjm3Dv/87fOQjJt7jhR/47Dq6q6As6kZHne47b9mcZdSEaujLDPQxe+bQM1MY4ehc17SW+o//MMm8wYIA3vpWuOceeNnLzOdaLB43+92b3lS6fdkEPvTtgZ5noHc7JDsgeQAS7ZDshPQh8BIQeJjTqQDwwHLAiUF4LkSbIdYK0fnmcd0yqD8FapeApcbOIiIiMjolbUREpMB995mLat83yRrLMgP8fu5zEImYxMlILSTAXLTnNTSYFjYXXGAuxgdfpK9caaaIvueeoQcffuopWLYMzj8f3vc+00InlYJf/9oklA4enJrfuZLsPLKTsBMu6B4VBMGo033ntTW04dqFX+/xdJwjiSM0xhqnNNaRXHEF/OIXQ3eFymZN97jrrhsYPLqmxgxSHASmdc3VVw/dfW5aJQ7Cjh/Anp9C91aTWIk0Q9M5MHs1zL8MZq2AmkUmMWM5YLu5xA3muZ81z70ExPfBsWfh6EZY+k4IN5T5FxIREZFqZwVBMPpaOWvWrAnWr18/jeGIiMhMW7SocKae00+HJ54Yfv3J2r3bJG/GO6vQcMb8tTbUTEzj+E4cd91jrP/uZ+7mXT9/Fz2pnv4y13Y59KlD1EfqR91+19FdnHrTqQUtbWZHZrP2HWu5YMkFo8cOk4p/8KqLF48+69OcOWbw6XnzTFe7n/zE/Jzwy0809q03wJOfNdt7CZOUecltsPjN4KXBrTUJmonwsxPfVkRERF4QLMvaEARByfyqOoMQEZECV19tBosNAtOqZcsWuO02eOc7TQuJurrhx5iZiBNOgE98Ar75zbEPPnw823hwI33pwumzwk54TAkbgEX1i0hmCwf4SXtpNndsHnvSZgpYFlx1FXz2syN/rocPw003lS2s4W25HvxB71vDi0zrGDAJnJH8dyskR2v2ZcM7hhnoR0RERGQY6lAtIiIFPvQh2LHDXHAvXWrKrrrKtIa5/HL47nfhd78zLSgyGTOeTDJpLsx7e83S12dazqTTJtFz4AA88gjcfPPQr3nttaZFTzhcpl+ygq3btw4vKLy4XzBrwZi3d22XObE5BWWJbIL1+8vfUva97526xkvT7sL/gtql4NSabk6H1sEf/sZ0k/LSkD4Kmd5JDLIzU4PziIiISDVTSxsRESkxfz586Utm6e2FjRvN+DJPPQX/+7/ws59BZ6eZwjmVMq0qwmGz2LZJ4mQy5vo2HIb6ejOLVEuLGeukmOuacW1Wr57cODVDDWpbbTYd3FRSdmLjieOqY8nsJXTGOwvKNuzfMKm4JqK+3oxZc+ONU9f9bTjdyW6+99j3eF+dRUtvYaboyOwIe9qf5PTW04evYN6F8IYdcOgx2P8/cPB3sP/XsPunBLEFMPs0gtqlULcUa/ZKrFA92BFwwnDJA6YOP20SPH4KfvuyaftdRURE5IVDSRsRESl17bXwhS8AUAecn1tGEgA+NgEWDh4FI4scBLblHvfmpqIqMneuGWD4pS81rXbG20IjFjNTTVezjJdh37HSQWBWNa8aVz3L5y5nw4HCJM22w9sIggBruDFfpsk118C//dv0JW32H9vP1x/5Orc+fit+4PP5T9pE3ShXnnMla59dy44jO0hlU0S/fx5nzT+L6y6+jouXXjz0+2BZHHHO4fc7zuHRR2HdOti9I05dsIO2hYdYvfwQyxYdYlHzZubEDhIN9RBysoScLBCQ8UJkPJdkdhanxuqI2AOjMAeRFsr7zouIiMjxQEkbEREpde21ZhlJ0UWvBTj4k+oPc/rp8Mc/mhmlurpMK56xqKmBt71t+O5X1eK5w88RdaP0pgcu9mNujOVzlo+rnlVNq3Asp6CblRd4dPR10FLXMmXxjkVtrflc3vMe021uMvUM9vOtP+cjv/xISZLLtV0sy+KW9beYTCIQEJDIJnjk+Ue45IeXELJDvP/M9/OtV32LsGv65D33HHzsY/Db35pZ0np7Yc0a+PL1NVx66an9s1vZtkkQhkIjx5vJfJOehGltFouZOkVERETGS2PaiIhIRTntNNMN6+UvH31q8UjEJGxuugluv71yLowzzXNLyoKW0ZMlmzs2YxW1xwg5oTFP9513YuOJ1IQK+4pFnAibOzaPq56p8pa3wIteNPEBrC0LVqwwj//w/B945Q9fyZvvfPOQrZKyfpbedC89qR560j0lgzIDZPwMN2+4mYU3LOSmx24ikUnwilfAvfeaRGFPj4l33Tr4y7+ExkazbzU0mC5foyVswKxTX2+2qZT9UkRERKqPWtqIiMjQ/Ax0b4Fj26B3J/Tthr6dkGinvwnDUNZdDoEHgW9+eklIdZmBXAkg1mIGfI00g1MDoVkQnm3Wy/SAn2F2Ns4vv2rzm3Unc9NPzuLXjywjHM4SBBYWAX5gURvL8MG/+jPv+z+Ps6SlCzY64NbAqk+N/rsN1xoo3Q2WnVscs5B/PnLnFj/wuXfbvXzh919g80f7SGZNuYVFyAkRdRN89MHP85FzPkJzbfOQdTx58MmCVjb5etsax5e0aWtsw7YKMyTJbJLNHZu55MRLxlXXVLAs+MEPTMuVY8fGv31tLXzhe09zxi1v58mDTw7Ui0XUjfKxs9/P589+F1HvGGS6IciaabaDrNkH/Szgc3/7s7z7j7dzJNVH3EvTlejiynuv5DO/+SRnnfNbDnWdSzoD2azFzp1m8OwzzzS7y2gJxFG1tk5uwKbRtLRAe/v01S8iIiIzQkmbaZTxMhxOHKYr3kVXvItnDj3DxoMb2dO9B4AzWs/gRS0vYnH9YppqmmiqaaI+Ul/28QZk5niemYEnHjdLIjEweGt+8XK9GwbvFoOvN/PllmXKg8A8dhxzVzu/5FskxGIwezY0N496DSovVJ1/gK1fhwP35ZIWwILXmOmPm14C4TlmwNWWNjjYUbhtyzw4+5u5nTQY+EkAdgissBmg9cC/gh0GJwo1S+FVj4ITMev7SfCzWIHHpSvh0vdAd3cvf/yTy5GjFpEILFro8+I1HpZ1GnAaYIHtmDp7d8Lhx+HIE9C7HRL7IdICoXoIN+SSRI3QNBu6ugdib26Eo08OJJvyF/uZnlzS6Qhkj8Hqz5okU05XvIvrH76eO568g750H4lsgogTYVXzKj51/qd4eM/D/Gjjj+hN9XL9w9fz1Ue+ysVLL+bj536cy066rODtW7d3HUFRQiyRSbC0Yem4PsK2hjbSXrqgLOWleHTfo+OqZyqtWGG6Hr3iFePrJlVTA7/6FTSd5HHqznmcGjoVku2Q7SNGlk+eeDorWmuhZzPEFkLtCRCZa6bptpyBBBwWlyzx2X7mP/DNx25ic8dTEGTAS4GX5LxTv8aNn/0h/3r7LO66y8x49prXwIknwnnnmfGSVq40U9Q353JunjdwrIaB462T+7Pp7ITdu2HrVvhbH5wpfUcL9cXh1m+a75Jo1LTwaWiABQvgnHMGYhIREZHqYgXjGHtgzZo1wfr15Z8ytNK1H2tn/g3zp63+0+adxsYrNk5b/dOutaX0wm4qNc+BLWvNxZ4TMbN52BFzURaZW5CZyPpZHMupmMRYcRgNDXDkyMzEIlUk0wM7f1y4A0Xmmf098M2CNyhhgvlZfLi3Bj/IZ/8cWPc+iD8/sF79SnjdlrHF9t+tkBxja4KCpM1jZhaeQUkbiqa9BuCp62HrV8dWPxYQwGnXwWmfM0WBZ8qtCfTTCXxTXy6Rtf/Yfi76wUU8d/i58dc1yE/f8lP+avVfYVkWS765hI6+joJWMhE3wpFPj+/AEAQBkS9FcO2BezN+4POWeYv591f9M2Tj4CUgm4SaheZ9yb1dBB6c+DdDV7zrp8WvlHtfYGAfskz92V6TOHFrzOfccjGEG3n4YbjsMpNcGE0sBmvXmkQPj38Snv6Gef/z+8bbEqZuP2OSgpMR+DB/QX9rmDgxtrKSbSxnO8s4wHzaaaWDeRy25hAPN+KHo7hhGzdi9olsyiOb9rHTSWrSR5gTHKaZTlpp5yauLHi5l7wE/vSnIeIYokVO0NICB9qVaJ8ivu9zJHmEY6lj9GX6OJY6xoHeA+w/tp+9PXsJCGiKNbGgfgEL6hYwp2YOtaFaakO1zInN6R8HCTD7zSffC/9yx/QF/LG3wT+8wxz7scw+78RMAnrehdP3ulMoCEySM5s1P/MJz/zP/E2n/LrFBt+ggoHk6OBEqeuaZaLdMMcino5zJHmEeCZOb7qXzr5O9vfu58CxA/Smewk5IRbULWD+rPm01LVQH6mnxq2hIdpAXbgOezqDK3L77bBrl3lsWSaZe955o29X/P6PdtzZudO8zuDtPvEJc047GUeOmLHFkknTbTWVyp0i+IUJ8+Fuag4Vu2UV3tC0bbPPRKPm5mY0apLyU5bkDnzz/eRnBm4G5W8MlYwBONQ1efEvMKgVcP9jN3dTzNHd2OOAZVkbgiBYU1JeKUmbFde+nm3W2mmpG+B9J19F2Imyc3eWB9YdxFuwDtvJEtgejXOyuGEPz8/2D9poWw5ekMW1XBzbwbFcHMvBsV1cy2X13Fe3gQsAABGcSURBVDNYNOsEXNvF663h//3uO5wWP0BTHFwPoh6sOAStvTCvD5r7TFmxAOiOQEetWfbMhh2NEMlCdwy6asDtq+f+1T3T9t589JSv8c62TxD4cOhwYReAtjY45ZRJvkCDBd2jrzYRB5rgX1fDtb+fnvqfboK733823gVnku58nD917+NwNoNHgGeH8CNNeIFH1jdLbaiGvkwcx7JxbRfXdnL7jYNrOdRH6rloyfm5Mpt3brqFZ9tXEE/VEE/XkPDnELvotv6PIP/llP9iGSzo3orV8zT5g75lQeD7eF4W/DR2kOZ1p92Ok3iegAA/8PHqVxE5/4cMfDEMfNb9JQXH+9KBZvPS3duIfPhi+O9Jv83Du+YaMxju2lOg55n+4iA8F+svuyZV9fzFR2jf29j/3HVNK6ep0tFhTip27IALLggIhQLm5oY5+cp1vbzqtaavxXi+X/OH677nH2XZ9qK5nF71OMw5c2wVbbwWNn9hlJUccGPmoWVD61/A0r+GuedBdF6uhUIas+fkkj4WcPdySI2SpP0vzH5TB8wF6oFaIAbUOjBvDjTXQ1091NSD6wycnbsO+AH4Hng+ZD2Y+zA4Ax/eb7e8mtbFs5gfeZxap5PwrEasZe8lqFuea4UxBys0C9xac/GDZT4Iy4ZN12Ftvm7E8J/IRPly7HWs3baWdDaNj0laOJbD6ubVnLXgLELDJBD2H9vP73f9nmQ2STYw/adqnBrmzZrH51/2eZY2LGXbHTeYTEXOqR1w/vNDVjeiB5fCtqKhdS7/RNFKNYvhTXtKNx6qK8/cWvjOKE1knFp4W+/I6wAPPQTvehccPmxOyovV1ZkT/h/8AC7J9eYKutaTffxqnCOP5JoUunDCW7GWvh2r8XQIzc6dHOf3y7zcH9lT18PW60cO7O+Ztu+r3d9awqM7zqE7Ppuj8QaOpNuYdfaV/bu2kzvfDoUgHM7tktbARUa+NU/+4tbzzEVMvjXmBz4wBV24ZsjV936dLz82hm6NFagG6CseJ/zFN8PyD5WuXPx31dIC931oxONxjwcbMmGy591B1vfY2LmVfcfaSXsp0l6GjJ8h42VI+xnSXoaQ7ZL20oScECE7RNgJEbZDhJ0wYSdExA3ziiUvxc2dm2x64CzuuvOE/tfzfJ9//KcQra1W7q/IZHPN90/Qf8TPH/OtgWeANeg7zTw4s+hr6dRTYdOmYX/dinLbw1/m8vuvnrb6Vze28ee/vAMCn8y2H2PhY+e+ityW87BXvH9S9RefX5x2GmyconvAvg/f//5A627P96idlWX+fLOX+L6PF3j4vocX+Hi+B5aFYznYto1j2eaxZWNZFo5lY1sOVu6GxXdvPczqf/8O1zLaucrEfOWSe7nhiUsLyh54wKZ10D14K3daM+Zp/3L3xoIAmn9TdNI+7yJ45e8mHvAgiXSK+d9YSMZPmyUY44wNo4jYUUJ2hPPmXcrXz7kTMK1iPW9gX4rF4Oyzp+Tlps2XH/gnth/dQcbLcihxmA0HN5H1PfzA7It+kN83/dy+55Dxs2YftM1+afZH8/iUucs4oX4Rru1Q49bwvb/4ZwZuUhW9eLRlYjcFB6n4pM15r/ob/tTSDtkIZKPQvJUzTo0QC8WIuTFioRhRN9r/3LZsMl6GRDZBIpsgmUn2P05kEtSGa2mpbSHlpUhmk/xu1++mJW6AxZkGDn61HdvyCXKf3hVXhvnKV8yHlu+2ElnaijXE3bP07gMl3V3yzy0L/urK6/hN0/U0ZJOEPeiJQNaGkAch3yzuoMeOD54FGcesl7Eh65ifaQesAOYkIeVAygWrxuLwJGZ7GU3jvxygua6biJsiEkpxztkpvvc9O5dlDgZaBlhW0Xl2ANvvgF0/HLbuR/Yu5YLELmotqLPNtVzaiVEbbaQ2VEtNqKZgiTgRAgLimTjxTJy+7m3E4/uJ+9DnQzKAehsSAfT68Abm8TOmr5VQXRoyEYhaZolZELYgbNvUOhFqQ1GijkvIDuHaIWzLwsLCti1sLHwCgiC3AP9at4dG2++vP/MzCP18emL/6fIVrPjMswy+x960/L00rbpy0J2DgNiqy7A6DxdsGzTPJXvPWwhtv3XY+n9xsIk3tRQlZt4xdftp3Rs/QN+uC81+BtiWzW3XnItt5049rdxuaZuT0sFdVoqf95cF9Nf3njecVPD/n/oUfHWsDURGccev/8zOV91VejJjYYaXd3LLoAY0BV8s+RYVeV8DBnr78PYD8NNeU8WKMCwPQVsIFrlwoguLQhYLa5uorZ2PG5uP49Zi2y627WJZLpZl4/sZAj+D52eJHFiL7Q901bG2MSYHvg6tRTmC9lqY/8lRNry28LO54oqAm77da8Y6SR81PzM9/eOcFNz5CryiO1gO/PE9kDkKwK07lvFBbztg/mZDQMaJcN6i87n19bdy0pzCz30oGS/Dt9d9m2t+dw1OrtVOb7qXgIB7rQt59Un/W7jBUPv9cNm+UY7l1hcsYrljTcyGmtwxJ2rb1Lkx6kJRYk6IkGMu8iys/uOOY9n9xxyfAD8I+FZsBw2DjjklVn8WTv/SkP/lefCzn8EnP2muY0Mhcxe+qcn8rbz97YV3O3/yE/jrvwbL8mlr3snS5l3cf/fzputa4iDE94EXN59ZqD6XkGPgu6X/yzW37PyhaW2Uc8leeGAM05JPdL98fS2c4IJrmfe9MRTl7NXvI0RAyLKIuBFCdgjHCePYESzbxsLCsmwaO35DY+dvRw9usFWfgTO+Mr5thvGjGz/Pu+Z8sbBwCo/Hi99wFfvOvIGoFxD2IJ7LeTo+2AE4QeFj1zfnN54Fng2+lXuce+74EPHMOU/agXfveTutCzYTxSWMTU0syrlv/hANkRpmh2dRF6oZdIgsOkDuuJ3kc//GUR96fDjmQwrIBOa84ZgP7+swf1P93+W2GX8g5rjUhWJE7RBRN2Ru5lhmdrPi73LfDwhyf1+3znq+/7v8H59ZRuT326ft5lTs7FtIbvhgQdlUnhLW/t8VxFOzzBPfwbWivGjhcgLfhsDGtlyswMG2LBzb/MFbuXlSBn/XBrmzDd83F10+HoHl8fh1txS83he/CFdPUZ7l9htuJfTUB6n9ozlfs32IZaE+BfVJmJ2C8AiHPw84FoHuqLlB25droNUbNo/XvGsZKxZuL9xoCv+uLviUxZ9iUJs2N4P7whDNQk3G/IxloCb3M5o1py9JF+IuJF2LRCgg4UIibMojWfBtE38Gl2u++NlpS6p85+8ifDS2DNK15rrQizA31kxz7RwiTpSoG8O1wrh2iJCTS/5gDyQRLSt3bmyO9wEBGc8j62fJBinOvrORG7d/rOA1+/pMd9ypcNP/sfj7/Lj/DhCLwKozAB9sC5zcTSjbNl27wZQDLNkJS3YNW/eheJSmfUUD7Afm87Mxx8n8YuWOmT4QWOZYmV/yzwMoOEc8bd2H2fTL7xZU73lT14Jt4Rdd9vtDtGSoEsGmEPwsPfqKEzThpI1lWZcDlwMsWbLk7N27d09PhOlu05QaMBfyuSbsg8dEGK4J2dPfhm2FO1eJxjVw7m2Qu7DyfQhsc0KXv2sVFO+1+Vd65mas7cXzyObuP1gBFgHuW/dhuXW55m/ZQc3g/EEXA0FR9bnf4dfnQXq0VgMWvHEn/QH3N8XI/VPQDQLG8/7c8/tF7Du2FzBfMP/bALSeQGDZg+6pDFyihrDJ5L48rdARCHXnI8QCWh04OTzwq86vayN6/s1E3AgWFmkv3d9MtCZUQ9SNErJDQ3ZZyngZEp5JxPWmezmaOIrruFhYpDyTWb5g/qWkUuZkP9/sdvBnmm92m3/rBv8seIet0p/d3ZCIZwm5+S4APpFIgOuY99t8/qYrQrGTti7HzY6c8Amwsd4xhgPXUHe9xzDo5N69A3dhwfzetl34/gwOfaTDweCPJ3/tM3v2QDPV/JKvZ/D7P7jl0ODXGqpOMDE+u+NJ2u/9KvafNwDQMTvJvDVnE61vzK1flOQbZFXscVbV/Hmkt4bgShfraHbEdSZjx+IwJ7YPOqg7uYGFgsB8MQ81MFHeazPwmuFji/vwgLOSyDnfJuyE+/8WGiIN1IZribrRYf+u/MAnmU2SzCZJZBJ0p7o5lj7G7MhsMn6GVDbV3zLLtU0Lw7095vgQc2NE3IhZHPMz7IRxcPDwSHtpUtkUKS9lfmZTJLIJLCwW1i8km2vNGLJD1IRMc/GQY67Oom6UebXzSmY8Go7nexxOHOZw4nD/hU5vupejyaNc+uNBd88CzM0ALwx+CLxQ/0/LsnEwSabcJRQWNrmURK5eH48sQeCDnaU2cPjuGX9PTSjW/xJz5s5m1YIVY4p71sHbqO/8PgBHPWgv+vNPHl1IInUO9rK/7S9rWTKXUDRcsF7rK16Dc6gwGeo3xrBvHDnr8KMDb2Bf66epdRr6L4wWt9YwN9JKyA6PuG1eEAT0ZA5zNN3V/82Q9OJ0Zw4x91uX8s5x5hYC4DBzOEoDDRxlDoeHvLEZAH1720nHWgq6WeSPMzDx471tw76+3WRrnqeptrH/4jHshJlfN5/YoM97NH3pPg70HiDrm7/hrJ/lUPwQyWwSx3b6byi4tkvEjTA7MptZkVmEnZHffz/w+2fF6k334vkeyWySvkwf8Uyctk9+mpV3Tc/sYPtqY7SfOJezN+2dlvqpAf9vWrG/PigzkU+e9hvmgP/0t+HZ74xcf/PL4C/GkPWY4HdtJmO6cOTPQ/Jj0+X3zcHdOIbaP4c6/wgCk7RMJk1XQnfQKJQhN8B1BxKQgV98DjhI0ZftiRuX4GYHfseED4lQA6GL7sld+ILlRgnZ4UHdyQfa1xR49ruw7Sb8wJw/ZvK/E+DlymqbziX86j+O+P4BE37vX3nu7fh7OsGCnjDMP7OF1792pTk25S7cB7UNIhh8gzwYSNDlf7ualLnIhYBQ1uLkM09g/qrW/nOcbO6rufi4M97zHMeBA888zfl/Wjn6ezNBMQvin+ocuCHRf7N0UPK6oHvr2K8dggCOzDoN58U35lrMmCZCrmuObQNdfIffd4Jnb8LH7De5zsf4mH3HBuqbXwKX3DcwqLyfGYg5GDgvL4x9bNdWW9MWz513V643hcO2w9uwLZuIHSbkuEScMCHbJeyECTkh7MDCCzzSfppMNk06yLVw89KkvQzv2fU5aryBXhHHgjaSl+4o6AZYfO49nv0mX27bYBGwuPE5HKfozpzlMvC5DjomFL/9T3/L/O0O4w/729h7extv3frAsOtMxn0vP5WuQwPfVY8s7o/aKIrX8U0yvt/g02egOQ4nHxooW9Z2HtHr/jBwPCUgGs0dKwNz3T5s/qP4zaf0mBlEW7DePH2D/ld8SxsRERERERERkRei4ZI25RsNS0RERERERERExkxJGxERERERERGRCqSkjYiIiIiIiIhIBVLSRkRERERERESkAilpIyIiIiIiIiJSgZS0ERERERERERGpQEraiIiIiIiIiIhUICVtREREREREREQqkJI2IiIiIiIiIiIVSEkbEREREREREZEKpKSNiIiIiIiIiEgFUtJGRERERERERKQCKWkjIiIiIiIiIlKBrCAIxr6yZXUCu6cpliaga5rqVv0zV7fqn7m6Vf/M1a36Z65u1T9zdav+matb9c9c3ap/5upW/TNXd7XXX82xV3v91Rx7Oeo/IQiC5uLCcSVtppNlWeuDIFij+stffzXHXu31V3Ps1V5/Ncde7fVXc+zVXn81x17t9Vdz7NVefzXHXu31V3Ps1V5/Ncc+3fVXc+zVXn81x16O+oej7lEiIiIiIiIiIhVISRsRERERERERkQpUSUmbW1X/jNVfzbFXe/3VHHu111/NsVd7/dUce7XXX82xV3v91Rx7tddfzbFXe/3VHHu111/NsU93/dUce7XXX82xl6P+IVXMmDYiIiIiIiIiIjKgklraiIiIiIiIiIhIjpI2IiIiIiIiIiIVSEkbEREREREREZEKpKSNiIiIiIiIiEgFUtJGRERERERERKQC/X8uKzOhzGGCUgAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -1435,7 +1332,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 7, "metadata": { "colab": {}, "colab_type": "code", @@ -1453,7 +1350,7 @@ "To be conservative, adjusted frac neg is 0.95\n", "For increasing = True , the minimum IR precision was 0.3469747405521833 occurring at 1.621246337890625e-05 implying a frac_neg of 0.5313343328335832\n", "To be conservative, adjusted frac neg is 0.95\n", - "For increasing = True , the minimum IR precision was 0.40074974232407007 occurring at 6.67572021484375e-06 implying a frac_neg of 0.6687518898670086\n", + "For increasing = True , the minimum IR precision was 0.4006572406407763 occurring at 7.033348083496094e-06 implying a frac_neg of 0.6684943371454617\n", "To be conservative, adjusted frac neg is 0.95\n", "For increasing = False , the minimum IR precision was 0.35928651361524633 occurring at -5.638343282043934e-06 implying a frac_neg of 0.5607600296390388\n", "To be conservative, adjusted frac neg is 0.95\n", @@ -1461,7 +1358,7 @@ "To be conservative, adjusted frac neg is 0.95\n", "For increasing = False , the minimum IR precision was 0.11749949829420027 occurring at -1.7642974853515625e-05 implying a frac_neg of 0.13314383172256963\n", "To be conservative, adjusted frac neg is 0.95\n", - "For increasing = False , the minimum IR precision was 0.2519079426947738 occurring at -3.814697265625e-06 implying a frac_neg of 0.3367338821938512\n", + "For increasing = False , the minimum IR precision was 0.41327328308403144 occurring at -4.0531158447265625e-06 implying a frac_neg of 0.7043709978920574\n", "To be conservative, adjusted frac neg is 0.95\n", "Loaded sliding window sizes: [ 5 9 13 17]\n", "For increasing = True , the minimum IR precision was 0.2954850349262155 occurring at 5.7220458984375e-06 implying a frac_neg of 0.41941626448668695\n", @@ -1470,7 +1367,7 @@ "To be conservative, adjusted frac neg is 0.95\n", "For increasing = True , the minimum IR precision was 0.3469747405521833 occurring at 1.621246337890625e-05 implying a frac_neg of 0.5313343328335832\n", "To be conservative, adjusted frac neg is 0.95\n", - "For increasing = True , the minimum IR precision was 0.40074974232407007 occurring at 6.67572021484375e-06 implying a frac_neg of 0.6687518898670086\n", + "For increasing = True , the minimum IR precision was 0.4006572406407763 occurring at 7.033348083496094e-06 implying a frac_neg of 0.6684943371454617\n", "To be conservative, adjusted frac neg is 0.95\n", "For increasing = False , the minimum IR precision was 0.35928651361524633 occurring at -5.638343282043934e-06 implying a frac_neg of 0.5607600296390388\n", "To be conservative, adjusted frac neg is 0.95\n", @@ -1478,7 +1375,7 @@ "To be conservative, adjusted frac neg is 0.95\n", "For increasing = False , the minimum IR precision was 0.11749949829420027 occurring at -1.7642974853515625e-05 implying a frac_neg of 0.13314383172256963\n", "To be conservative, adjusted frac neg is 0.95\n", - "For increasing = False , the minimum IR precision was 0.2519079426947738 occurring at -3.814697265625e-06 implying a frac_neg of 0.3367338821938512\n", + "For increasing = False , the minimum IR precision was 0.41327328308403144 occurring at -4.0531158447265625e-06 implying a frac_neg of 0.7043709978920574\n", "To be conservative, adjusted frac neg is 0.95\n" ] } @@ -1488,6 +1385,9 @@ "import numpy as np\n", "import modisco\n", "from modisco.tfmodisco_workflow import workflow\n", + "\n", + "from importlib import reload\n", + "\n", "reload(modisco.tfmodisco_workflow.workflow)\n", "reload(modisco.tfmodisco_workflow)\n", "reload(modisco)\n", @@ -1508,7 +1408,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 9, "metadata": { "scrolled": false }, @@ -1518,7 +1418,7 @@ "output_type": "stream", "text": [ "Getting the exemplar motifs\n", - "Numseqles: 142\n" + "Numseqles: 83\n" ] }, { @@ -1526,13 +1426,13 @@ "output_type": "stream", "text": [ "[Parallel(n_jobs=10)]: Using backend LokyBackend with 10 concurrent workers.\n", - "[Parallel(n_jobs=10)]: Done 30 tasks | elapsed: 5.0s\n", - "[Parallel(n_jobs=10)]: Done 142 out of 142 | elapsed: 5.1s finished\n" + "[Parallel(n_jobs=10)]: Done 30 tasks | elapsed: 1.7s\n", + "[Parallel(n_jobs=10)]: Done 83 out of 83 | elapsed: 1.8s finished\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1544,7 +1444,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXAAAAD4CAYAAAD1jb0+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAMq0lEQVR4nO3dYajd9X3H8fen6thQx5RcJajZHSJjUlgsFzcIFLeuxWqZOuiYMJuBEB8oKBO2zCd1z7JS7Z4MIU5ptlmLoKI0pas4hwjF9cZlM5IVS8k6NSQRO9RHQ/3uwf1nu4335t6cc+4952veL7icc/7n3JwvP5I3//zv//xvqgpJUj+fmvYAkqTRGHBJasqAS1JTBlySmjLgktTUuZv5Zlu2bKn5+fnNfEtJau/AgQNvV9Xcqds3NeDz8/MsLi5u5ltKUntJ/nOl7R5CkaSmDLgkNWXAJakpAy5JTRlwSWrKgEtSUwZckpoy4JLUlAGXpKY29ZOYkjSu+d37R/7eI3tunOAk0+ceuCQ1ZcAlqSkDLklNGXBJasqAS1JTBlySmjLgktSUAZekpgy4JDVlwCWpKQMuSU2tGfAkVyR5IcnhJK8luXvYfn+SN5McHL5u2PhxJUknrediVh8A91bVK0kuBA4keW547htV9fWNG0+StJo1A15VR4Gjw/33khwGLtvowSRJp3dGl5NNMg9cA7wM7ADuSvIVYJGlvfSfrfA9u4BdANu2bRtzXEmfBONcElb/b90/xExyAfAkcE9VvQs8BFwJbGdpD/2Blb6vqvZW1UJVLczNzU1gZEkSrDPgSc5jKd6PVdVTAFV1rKo+rKqPgIeBazduTEnSqdZzFkqAR4DDVfXgsu1bl73sFuDQ5MeTJK1mPcfAdwC3Aa8mOThsuw+4Ncl2oIAjwB0bMqEkaUXrOQvlJSArPPXdyY8jSVovP4kpSU0ZcElqyoBLUlMGXJKaMuCS1JQBl6SmDLgkNWXAJakpAy5JTRlwSWrKgEtSUwZckpoy4JLUlAGXpKYMuCQ1ZcAlqSkDLklNredXqknSJ8L87v0jf++RPTdOcJLJcA9ckpoy4JLUlAGXpKYMuCQ1ZcAlqSkDLklNGXBJasqAS1JTBlySmjLgktSUAZekptYMeJIrkryQ5HCS15LcPWy/OMlzSV4fbi/a+HElSSetZw/8A+DeqvoN4LeBO5NcDewGnq+qq4Dnh8eSpE2yZsCr6mhVvTLcfw84DFwG3ATsG162D7h5o4aUJH3cGR0DTzIPXAO8DFxaVUdhKfLAJat8z64ki0kWT5w4Md60kqT/s+6AJ7kAeBK4p6reXe/3VdXeqlqoqoW5ublRZpQkrWBdAU9yHkvxfqyqnho2H0uydXh+K3B8Y0aUJK1kPWehBHgEOFxVDy576llg53B/J/DM5MeTJK1mPb9SbQdwG/BqkoPDtvuAPcATSW4Hfgp8eWNGlCStZM2AV9VLQFZ5+nOTHUeStF5+ElOSmjLgktSUAZekpgy4JDVlwCWpKQMuSU0ZcElqyoBLUlMGXJKaMuCS1JQBl6SmDLgkNWXAJakpAy5JTRlwSWrKgEtSUwZckppaz69Uk6SfM797/7RHEO6BS1JbBlySmjLgktSUAZekpgy4JDVlwCWpKQMuSU0ZcElqyoBLUlMGXJKaMuCS1JQBl6Sm1gx4kkeTHE9yaNm2+5O8meTg8HXDxo4pSTrVevbAvwlcv8L2b1TV9uHru5MdS5K0ljUDXlUvAu9swiySpDMwzvXA70ryFWARuLeqfrbSi5LsAnYBbNu2bYy3kzRJXtO7v1F/iPkQcCWwHTgKPLDaC6tqb1UtVNXC3NzciG8nSTrVSAGvqmNV9WFVfQQ8DFw72bEkSWsZKeBJti57eAtwaLXXSpI2xprHwJM8DlwHbEnyBvBV4Lok24ECjgB3bOCMkqQVrBnwqrp1hc2PbMAskqQz4CcxJakpAy5JTRlwSWrKgEtSUwZckpoy4JLUlAGXpKYMuCQ1ZcAlqSkDLklNGXBJasqAS1JTBlySmjLgktSUAZekpgy4JDVlwCWpKQMuSU0ZcElqyoBLUlMGXJKaMuCS1JQBl6SmDLgkNXXutAeQNLr53funPYKmyD1wSWrKgEtSUwZckpoy4JLU1JoBT/JokuNJDi3bdnGS55K8PtxetLFjSpJOtZ498G8C15+ybTfwfFVdBTw/PJYkbaI1A15VLwLvnLL5JmDfcH8fcPOE55IkrWHUY+CXVtVRgOH2ktVemGRXksUkiydOnBjx7SRJp9rwH2JW1d6qWqiqhbm5uY1+O0k6a4wa8GNJtgIMt8cnN5IkaT1GDfizwM7h/k7gmcmMI0lar/WcRvg48APg15O8keR2YA/w+SSvA58fHkuSNtGaF7OqqltXeepzE55FknQG/CSmJDVlwCWpKQMuSU0ZcElqyoBLUlMGXJKaMuCS1JQBl6SmDLgkNWXAJakpAy5JTRlwSWrKgEtSUwZckpoy4JLUlAGXpKYMuCQ1teZv5JG0seZ375/2CGrKPXBJasqAS1JTBlySmjLgktSUAZekpgy4JDVlwCWpKQMuSU0ZcElqyoBLUlMGXJKaGutaKEmOAO8BHwIfVNXCJIaSJK1tEhez+p2qensCf44k6Qx4CEWSmho34AV8P8mBJLtWekGSXUkWkyyeOHFizLeTJJ00bsB3VNVngC8Cdyb57KkvqKq9VbVQVQtzc3Njvp0k6aSxAl5Vbw23x4GngWsnMZQkaW0jBzzJ+UkuPHkf+AJwaFKDSZJOb5yzUC4Fnk5y8s/5VlV9byJTSZLWNHLAq+onwG9OcBZJ0hnwNEJJasqAS1JTk/gkptTe/O790x5BOmPugUtSUwZckpoy4JLUlAGXpKYMuCQ1ZcAlqSkDLklNeR64Zso452Mf2XPjBCeRft64nxXYiL+f7oFLUlMGXJKaMuCS1JQBl6SmDLgkNWXAJakpTyPUxHlpVmlzuAcuSU0ZcElqyoBLUlMGXJKaMuCS1JQBl6SmDLgkNdXmPHAvM6q1eP65zjbugUtSUwZckpoy4JLUlAGXpKbGCniS65P8KMmPk+ye1FCSpLWNHPAk5wB/A3wRuBq4NcnVkxpMknR64+yBXwv8uKp+UlX/A3wbuGkyY0mS1jLOeeCXAf+17PEbwG+d+qIku4Bdw8P3k/xojPccSf5q1ae2AG9v3iRnxNlG42yjcbbRrHu203RoPX51pY3jBDwrbKuPbajaC+wd4302TJLFqlqY9hwrcbbRONtonG00055tnEMobwBXLHt8OfDWeONIktZrnID/ELgqya8l+QXgj4BnJzOWJGktIx9CqaoPktwF/CNwDvBoVb02sck2x0we2hk422icbTTONpqpzpaqjx22liQ14CcxJakpAy5JTZ0VAU/yaJLjSQ4t23Z/kjeTHBy+bpjSbFckeSHJ4SSvJbl72H5xkueSvD7cXjRDs0197ZL8YpJ/SfJvw2x/OWyfhXVbbbapr9uyGc9J8q9JvjM8nvq6nWa2mVi3JEeSvDrMsDhsm+q6nRXHwJN8Fngf+Luq+vSw7X7g/ar6+pRn2wpsrapXklwIHABuBv4EeKeq9gzXmbmoqv58Rmb7Q6a8dkkCnF9V7yc5D3gJuBv4A6a/bqvNdj0z8HcOIMmfAgvAL1fVl5J8jSmv22lmu58ZWLckR4CFqnp72baprttZsQdeVS8C70x7jpVU1dGqemW4/x5wmKVPud4E7Bteto+lcM7KbFNXS94fHp43fBWzsW6rzTYTklwO3Aj87bLNU183WHW2WTbVdTsrAn4adyX59+EQy9T+y3hSknngGuBl4NKqOgpLIQUumd5kH5sNZmDthv9qHwSOA89V1cys2yqzwQysG/DXwJ8BHy3bNhPrxsqzwWysWwHfT3IgS5cIgSmv29kc8IeAK4HtwFHggWkOk+QC4Engnqp6d5qznGqF2WZi7arqw6raztKngK9N8ulpzLGSVWab+rol+RJwvKoObPZ7r+U0s0193QY7quozLF2B9c7h0OxUnbUBr6pjwz+yj4CHWbq64lQMx0mfBB6rqqeGzceGY9Anj0Ufn5XZZmnthnn+G/hnlo4xz8S6nbR8thlZtx3A7w/Hc78N/G6Sf2A21m3F2WZk3aiqt4bb48DTwxxTXbezNuAnF31wC3Botddu8BwBHgEOV9WDy556Ftg53N8JPDMrs83C2iWZS/Irw/1fAn4P+A9mY91WnG0W1q2q/qKqLq+qeZYuf/FPVfXHzMC6rTbbLKxbkvOHH+ST5HzgC8McU123ca5G2EaSx4HrgC1J3gC+ClyXZDtLx7WOAHdMabwdwG3Aq8MxU4D7gD3AE0luB34KfHmGZrt1BtZuK7AvS79Y5FPAE1X1nSQ/YPrrttpsfz8D67aaWfj7tpqvzcC6XQo8vbRPw7nAt6rqe0l+yBTX7aw4jVCSPonO2kMoktSdAZekpgy4JDVlwCWpKQMuSU0ZcElqyoBLUlP/CyTn056Ott+mAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1558,12 +1458,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "After filtering: numseqlets 141\n" + "After filtering: numseqlets 79\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1577,7 +1477,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Numseqles: 109\n" + "Numseqles: 81\n" ] }, { @@ -1586,12 +1486,12 @@ "text": [ "[Parallel(n_jobs=10)]: Using backend LokyBackend with 10 concurrent workers.\n", "[Parallel(n_jobs=10)]: Done 40 tasks | elapsed: 0.0s\n", - "[Parallel(n_jobs=10)]: Done 109 out of 109 | elapsed: 0.1s finished\n" + "[Parallel(n_jobs=10)]: Done 81 out of 81 | elapsed: 0.1s finished\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1603,7 +1503,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1617,12 +1517,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "After filtering: numseqlets 105\n" + "After filtering: numseqlets 80\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1647,29 +1547,17 @@ "text": [ "[Parallel(n_jobs=10)]: Using backend LokyBackend with 10 concurrent workers.\n", "[Parallel(n_jobs=10)]: Done 40 tasks | elapsed: 0.0s\n", - "[Parallel(n_jobs=10)]: Done 5540 tasks | elapsed: 0.3s\n", - "[Parallel(n_jobs=10)]: Done 7376 out of 7376 | elapsed: 0.4s finished\n", - "[Parallel(n_jobs=10)]: Using backend LokyBackend with 10 concurrent workers.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Took 0.35634303092956543 s\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[Parallel(n_jobs=10)]: Done 1 out of 1 | elapsed: 0.2s finished\n" + "[Parallel(n_jobs=10)]: Done 4090 tasks | elapsed: 0.2s\n", + "[Parallel(n_jobs=10)]: Done 4754 out of 4754 | elapsed: 0.2s finished\n", + "[Parallel(n_jobs=10)]: Using backend LokyBackend with 10 concurrent workers.\n", + "[Parallel(n_jobs=10)]: Done 1 out of 1 | elapsed: 0.1s finished\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ + "Took 0.25251197814941406 s\n", "Getting impscores data\n", "Computing fwd sims\n" ] @@ -1679,22 +1567,22 @@ "output_type": "stream", "text": [ "[Parallel(n_jobs=10)]: Using backend LokyBackend with 10 concurrent workers.\n", - "[Parallel(n_jobs=10)]: Done 40 tasks | elapsed: 0.0s\n" + "[Parallel(n_jobs=10)]: Done 40 tasks | elapsed: 0.0s\n", + "[Parallel(n_jobs=10)]: Done 4090 tasks | elapsed: 0.2s\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Took 0.3716139793395996 s\n" + "Took 0.24987316131591797 s\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "[Parallel(n_jobs=10)]: Done 5540 tasks | elapsed: 0.3s\n", - "[Parallel(n_jobs=10)]: Done 7376 out of 7376 | elapsed: 0.4s finished\n" + "[Parallel(n_jobs=10)]: Done 4754 out of 4754 | elapsed: 0.2s finished\n" ] } ], @@ -1709,12 +1597,12 @@ " .metacluster_idx_to_submetacluster_results[\"metacluster_0\"]\n", " .seqlets_to_patterns_result.patterns),\n", " trim_window_size=SCANNING_WINDOW_WIDTH,\n", - " task_names=tasks, bg_freq=background, track_set=track_set)" + " task_names=tasks, bg_freq=np.array([0.27, 0.23, 0.23, 0.27]), track_set=track_set)" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -1723,7 +1611,7 @@ "text": [ "computing the transformed score track\n", "done computing the transformed score track\n", - "Fraction of values above cutoff: 0.1872\n" + "Fraction of values above cutoff: 0.16915\n" ] } ], @@ -1732,7 +1620,7 @@ "from modisco.hit_scoring import exemplar_based_hitscoring\n", "reload(exemplar_based_hitscoring)\n", "\n", - "CUTOFF_VALUE = 0.2\n", + "CUTOFF_VALUE = 0.8\n", "coordinates_to_be_scanned, task0_transformed_scoretrack =\\\n", " exemplar_based_hitscoring.get_windows_to_be_scanned(\n", " scanning_window_width=SCANNING_WINDOW_WIDTH,\n", @@ -1746,7 +1634,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 18, "metadata": { "scrolled": false }, @@ -1765,15 +1653,15 @@ "text": [ "[Parallel(n_jobs=10)]: Using backend LokyBackend with 10 concurrent workers.\n", "[Parallel(n_jobs=10)]: Done 40 tasks | elapsed: 0.0s\n", - "[Parallel(n_jobs=10)]: Done 10220 tasks | elapsed: 0.5s\n", - "[Parallel(n_jobs=10)]: Done 29060 out of 29060 | elapsed: 1.0s finished\n" + "[Parallel(n_jobs=10)]: Done 9780 tasks | elapsed: 0.4s\n", + "[Parallel(n_jobs=10)]: Done 13870 out of 13870 | elapsed: 0.5s finished\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Took 1.0475728511810303 s\n" + "Took 0.5251750946044922 s\n" ] } ], @@ -1791,7 +1679,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 19, "metadata": { "scrolled": false }, @@ -1805,7 +1693,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1817,7 +1705,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1832,17 +1720,17 @@ "output_type": "stream", "text": [ "tal hits:\n", - "MotifHitAndCoord(motif_idx=0, motif_score=0.6504827158037557, precision_at_motif_score=0.3163707407503883, example_idx=0, start=114, end=139, is_revcomp=False)\n", - "MotifHitAndCoord(motif_idx=0, motif_score=0.997667879007509, precision_at_motif_score=1.0, example_idx=0, start=123, end=148, is_revcomp=True)\n", - "MotifHitAndCoord(motif_idx=0, motif_score=0.5525896556967879, precision_at_motif_score=0.08588468275708364, example_idx=0, start=157, end=182, is_revcomp=False)\n", - "MotifHitAndCoord(motif_idx=0, motif_score=0.9986260150648937, precision_at_motif_score=1.0, example_idx=0, start=166, end=191, is_revcomp=True)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.6285057524184436, precision_at_motif_score=0.3070218532110743, example_idx=0, start=114, end=139, is_revcomp=True)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.99176677132715, precision_at_motif_score=1.0, example_idx=0, start=123, end=148, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.5289917008354178, precision_at_motif_score=0.0, example_idx=0, start=157, end=182, is_revcomp=True)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.9904893311402659, precision_at_motif_score=1.0, example_idx=0, start=166, end=191, is_revcomp=False)\n", "gata hits:\n", - "MotifHitAndCoord(motif_idx=1, motif_score=0.9993490999238629, precision_at_motif_score=1.0, example_idx=0, start=146, end=171, is_revcomp=True)\n" + "MotifHitAndCoord(motif_idx=1, motif_score=0.9979234390801821, precision_at_motif_score=1.0, example_idx=0, start=151, end=176, is_revcomp=False)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1861,7 +1749,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1873,7 +1761,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1888,17 +1776,16 @@ "output_type": "stream", "text": [ "tal hits:\n", - "MotifHitAndCoord(motif_idx=0, motif_score=0.9986260150648937, precision_at_motif_score=1.0, example_idx=1, start=9, end=34, is_revcomp=False)\n", - "MotifHitAndCoord(motif_idx=0, motif_score=0.5525896556967879, precision_at_motif_score=0.08588468275708364, example_idx=1, start=18, end=43, is_revcomp=True)\n", - "MotifHitAndCoord(motif_idx=0, motif_score=0.997667879007509, precision_at_motif_score=1.0, example_idx=1, start=52, end=77, is_revcomp=False)\n", - "MotifHitAndCoord(motif_idx=0, motif_score=0.6504827158037557, precision_at_motif_score=0.3163707407503883, example_idx=1, start=61, end=86, is_revcomp=True)\n", + "\n", "gata hits:\n", - "MotifHitAndCoord(motif_idx=1, motif_score=0.9993490999238629, precision_at_motif_score=1.0, example_idx=1, start=29, end=54, is_revcomp=False)\n" + "MotifHitAndCoord(motif_idx=1, motif_score=0.9962569527702348, precision_at_motif_score=1.0, example_idx=1, start=27, end=52, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=1, motif_score=0.9984996416657448, precision_at_motif_score=1.0, example_idx=1, start=94, end=119, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=1, motif_score=0.999586211201367, precision_at_motif_score=1.0, example_idx=1, start=118, end=143, is_revcomp=False)\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABIUAAACMCAYAAADiDBl2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3xUVd7H8c+ZTHollAQIEAVUmtIULCD2vgo21MfuWla3Pauuu66Ku65lXd3VXeu6tse+KmvDhoKKKIhIRzqhpkAgvUxm7vPHmSQzmRlIICET8n2/Xnklc+fOnTNz5t7c+5vz+x3jOA4iIiIiIiIiItK5uNq7ASIiIiIiIiIisu8pKCQiIiIiIiIi0gkpKCQiIiIiIiIi0gkpKCQiIiIiIiIi0gkpKCQiIiIiIiIi0gkpKCQiIiIiIiIi0gm52+uJu3Xr5uTm5rbX04uIiIiIiIiI7He+//77bY7jdG/Ouu0WFMrNzWXevHnt9fQiIiIiIiIiIvsdY0xec9dV+piIiIiIiIiISCekoJCIiIiIiIiISCekoJCIiIiIiIiISCekoJCIiIiIiIiISCekoJCIiIiIiIiISCekoJCIiIiIiIiISCekoJCIiIiIiIiISCekoJCIiIiIiIiISCekoJCIiIiIiIiISCekoJCIiIiIiIiISCekoJCIiIiIiIiISCekoJDsl957Dz77rL1bISIiIiIiIhK93O3dgP1Sbi7k5bV3Kzq1s9q7AZ1Jv36wfn17t0JERERERERaSEGhtpCXB47T3q3Ye8Z0yNdx2WXwyisQEwP/+79w333t3aJd6KDvcRBj2rsFIiIiIiIisgd2mz5mjHnWGFNojFkS4X5jjHnUGLPaGLPIGDOy9Zsp0nwzZoDXC7W18NFH7d0aERERERERkejUnJpCzwOn7uL+04CB/p9rgSf2vlkie6a4GAoLG28vW9Z+bRERERERERGJZrtNH3Mc50tjTO4uVjkbeNFxHAf41hiTYYzp6TjO1lZqo0izffstJCTYUUIA8fEte/y+LwflQIfPvtofXkPLqIySiIiIiIjsD1qjplBvYGPA7U3+ZQoKyT43axaUlzfe9nha9vh9Xg5qf6kpFO41RKo11NFfLyqjJCIiIiIi+4fWmJI+3OVR2Ks+Y8y1xph5xph5RUVFrfDU0lksK1zGNxu/2e16ixeDz9d4u7q6DRslIiIiIiIi0oG1RlBoE9An4HYOsCXcio7jPO04zmjHcUZ37969FZ5aOosRT43gqGeP2u16SukRERERERERaZ7WCAq9C1zmn4VsLFCiekLS2pzwg89CbAkbjhQRERERERGRpnZbU8gY8yowAehmjNkE3AXEAjiO8yQwDTgdWA1UAle2VWOl8/I63t2u4/HAzp37oDEiIiIiIiIi+4HmzD520W7ud4AbW61FImH4HN9u1ykosDOPVVXZqegLC+HYY/dB40REREREREQ6oNaYfUwkKuTng9sNJ50EvXtDTg6MGNHerRIRERERERGJTq1RU0gkKhQU2KnCjz8eEhMhJgbGjWvvVkkk8+fDypXt3QoREREREZHOS0Eh2W8UFEBdnR0p5HbbwNApp7R3qzqo7GwbYWv6k53dKpv/4Qc48kgYORK2qiy9iIiIiIhIu1BQSPYbBQVQXQ2DBzcuGz26/drToRUUtGx5C912my0MXlsLDz7YKpsUERERERGRFlJQSPYbW7ZARkbwsszM9mmLRObxwJdfguPYv6dObe8WiYiIiIiIdE4KCknUeeop6NcP5swJvW9Xs5Dt3Al9+0JNTeOy2to2aKDslW++gbi4xttKHxMREREREWkfCgpJVNm0CX79a9iwAc4/344mCVTpqYz42NJS6NMn+DEKCrWjrKywy6ZNg4qKxkWxsfuuSSIiIiIiItJIQSGJKu+8Y+sZA+zY0fh3vfLa8oiPLSuzdZADgwxNHy/7UH5+cITOcSA/nzlzwOttXFweuUtFRERERESkDSkoJFHl5Zeh0j8YKNwon4raitCFfuXlNiiUkNC4TKNQos+qVe3dAhEREREREQEFhSSKVFTA99833q4PCnm8nsZ1PJGDQhUVthZRTEzjssAAkbQ/r7fVJjATERERERGRvaSgkESNxYvDB3ECA0G7GilUWWlHCgVy6RMeVTZtskWmjbGpgv/4R3u3SEREREREpPNyt3cDROqtWAG+MJOLBdYR2lVNoepqSE1ti5ZJc6Tdl0ZZbRnOXU7EdTZtsil9p5wCJ5xglz399D5qoIiIiIiIiATROAqJGkuWBM9KVS9wdNCu0seqqyE5uS1aJs1RVlu223U2brSBv/POg8REm+p3xhn7oHEiIiIiIiISQkEhiRqLFtkJqi66CDZvhiFD7PLmpo8pKNSKwk0nv6vlzbRpk+2nU06xqX0JCTZAJCIiIiIiIvue0sckaqxbZ2vNPP44pKXBww/b5c1NH6uthaSktm5lJ5Gfb38b07jMiZwW1lxr19oUv5SUxmWHHLLXmxUREREREZE9oJFCEjXy8+Hww+0IEpcLxo2zy5uTPlY/U5lmG4tuhYUwcCBUVTUucys0LSIiIiIi0i4UFJKoUFVlZw87/fTGwE59oKc56WMVFbaAsYJC0W3nThgwIHhWuMAAkYiIiIiIiOw7CgpJVNi61QZ0xoyxU5YDxMfb34GBoNKa0rCPr6mxgYb6x0h0KimBnBxbZLpeYIaaiIiIiIiI7DsKCklUKCmxM1EF1pepH/UTWEdoR/WOsI93HBtcUCpS+3N2UXuorMymj8XGNi5TIE9ERERERKR9KCgkUaG01AZ1evYMvS8wfSzSSCGfzwYaWqEWsuyl6rrqiPeVl0O/fsHLlPInIiIiIiLSPhQUkqhQWgoZGeGDOoEjhXYVFIqJUVCovfgcX8PfJTUlEderrLT9LCIiIiIiIu1PQSGJCiUl0Lu3rQ3U1M7qnY3rRQg4+Hy2ppCCQu0jMHBXUh05KFRVZaekFxERERERkfanoJBEhdJSSEsLH9QJDDIUVxWHfbzj7GFQqKYYPh0HnxwNNdtb+GCpF9hHkQJ3jmODfikp+6pVIiIiIiIisivNCgoZY041xqwwxqw2xtwW5v4JxpgSY8wC/8+drd9U2Z+VlkJycviZqAKDDJFGodSnj7XYnJ/C9jmw/Tv49qo92IBA8/qoosL2UVLSvmqViIiIiIiI7Mpug0LGmBjgMeA0YDBwkTFmcJhVv3IcZ7j/54+t3E7ZzxUX2xEkrjCfyLLasoa/d1WvpsWjhCq3wJZp4POA44Gtn7RwA/uXl16CCy6Adeta/tjmjBQqK7PFwAOnoxcREREREZH205wJvI8AVjuOsxbAGPMacDawrC0bJp3Ltm02fSxwqvJ69fVqYkxMxJmtXC47WqhF1jwDBEaSWrqB/cf06XDddVBdDV9/DZs2hR+1FUlzRgrV1tqRQnFxe9taERERERERaQ3NSR/rDWwMuL3Jv6ypI40xC40xHxpjhrRK66TTKC6G9PTwQaHSajvjWGp85ArF9UGhlgQy2PIB+AIqW/tqW/Dg/cttt9mZwXw+m8rXoveR5o0U8vlsimBd3d60VAQoWwPzb4Ht89q7JSIiIiIiHVpzRgqFuzxsmqgzH+jnOE65MeZ04L/AwJANGXMtcC1A3759W9hU2Z9VVUFmZvi6QDtr7Oxj6fHpQTORBXK5wOttQTDD54Udi+zfPU8B44ItH+5Byzu+xYth+fLG2+XlkdeNpLSmtOHvXdV9crujeIa43FzIy2vmyk7LI2fSBv7a3g3ouPr1g/Xr27sVIiIiItLOmhMU2gT0CbidA2wJXMFxnNKAv6cZYx43xnRzHGdbk/WeBp4GGD16dLReGko78HptUCic+oBD/UihOl8dblfwR9eYFo4UKl8LJga6DIfx/7XLPh23J03v8KZP34PUuyYCRwdtq9wWdh2fbw9niNtX8vKa3zhD9L4QY6K3ba1h0V2w/EHwVoFxQ845MO4/++7595f3V0FNEREREaF56WPfAQONMQcYY+KAycC7gSsYY7KNsWeYxpgj/NvV/N7SbF6vHUUSTqWnEoBYl80tq6itCFnH5bI1a5p9nVOyGFwxcOg9YGLtz2F/3pOmd3jTptlaQhMmwP33Rw7O7UpxVXHD35GCQl6vHQm2P1xPSzvxeeHHh21ACMCpg83vt2+bREREREQ6sN2OFHIcp84YcxPwMRADPOs4zlJjzPX++58EzgNuMMbUAVXAZMfRpZ80X31q0a4syF8AwMaSjaQnpAfdVz8CpbYWEhKa8YQ7l4K3DnqeZINDAFkTWt7w/cAPP0BqKrz7rp0ZrHv3lm+jqLKo4e/AAFEgRxlXsrd2/EBIRrMrTCEyERERERFpluakj+E4zjRgWpNlTwb8/U/gn63bNOlMfL7w9YR8AXlNjr+U1eayzQzNGhq0XmKi3UZNTTODQhV5kHkY1FU1TodVVwl0rqmxduywU8Xfeqt9/91uuOiilm+nuHL3I4X2aIY4kUAFM2xB+O7jYNTfYPlfIe+19m6ViIiIiEiH1Zz0MZE2F2kUSWltaciycCNRkpPB47EFq5ularOtJxQ4ysDVuQJCACtW2IDa5MmQlGSX7cnsYIF9UlhRGHadPZohTiRQwQybMnbUS5A5Co54GmIz2rtVIiIiIiIdloJCEhVcrvDBiMLy0ABDuKBQTIz9qa5u5hNWF0CXEeBOalwW+HcnUVAAsbEwMGCuwNTUlm+nuLqxT7ZXhS8npqCQ7LUdP0DORIjzB4KMGw66sX3bJCIiIiLSgSkoJFEhJiZ8alFgrZp6O6p3hN1GXBxUVoa5IzvbRiICf9YuhOR+e9nqjq+gwAaEmh1Mi6CowvZTojuRGm9N2HVcLjuay6Wjzn6poAC2t+X0Aj4vVBdCzk8gNs0ucydCn0lt+KQiIiIiIvs3XZ5JVHC57OxUTYUbdVJSXRK6IraWUEXoxGT2arWpeB8kZLWwlfufggLo27cFDwgXYKNx9FZmYuSpy1wu2z/hakdJx/bII5CbC336wOuvt9GT1G63KZ49xgcvTx/cRk8oIiIiIrL/U1BIokJMDJSEifXsqAodFVRSEzkoVF7ejCczQAIQ37VFbdwfbdgA3brZFLJmCRdgAzw+D/Ex8SS4bZXvWm9tyDrx8TbwVxN+IJF0UAsWwO9+Z0ebVVXB1Ve3fBuOAxdfbGuDTZwYPkBMVT64UyCxd/Byn2eP2i0iIiIiIgoKSZSIi7OpJ44TvDxc/aDSmtDi02ALJocLLIU+GeCgArXApk3Qs6cN2OytWm8t63euB2D9jvUh96el2bpRzS4GLh3CrbcG9+mepCLecw+8+65N//zkkwhpoNX5kJgNviZP4ISLIImIiIiISHMoKCTt5tVXoWtX6N+/caRQbZMBJuHqB5XVlIXdXlKSDXIECjuTlgvwATHNmbt+/1ZUZNPHWqPOj4OD13+BvrF0Y8j9iYm2blTYC37pkEpK4MsvbVDx0Ufh3nvD1wbblfx8+7j61M/KygjFzqsLIL4b+Jrs1Eb5iCIiIiIie8rd3g2Qzumrr2yaSVUV7NhhLwy7d7dBnMBRK/UBoFhXLC7josZbQ4UnXOEgSEmxQSGPpzEdqroaUrKygtOe6gMgRjHR2lrIaoPSSlvLtoYsM8b2bbNS/KRDmDnT9unDD9v0L5+v5SPBXnnFfjbGjIEbb4R//SvCitUFEJeJzf8M4GqFYW4iIiIiIp2Uropln3McuPLKxotHx7F1ZsrKQkf2DOo+CICTDzyZKw67AoBDuh0SdrspKTb2E5i+UleHjTgF5qVtK4T4BAWFsLVb4uJa8IBmRpAKKsLXHkpMhNLw2X/SAX36KaSn24BQYqKtCfS737VsGy+/bEcMfvQRXHopfPAB4Qua//4WGxRyNfkuI6YlH2AREREREQmkq2Jpc7XeWszdhkqPzRuaP9/GaUaOtCN7vvkG3G6bNtK0plBNna1KfETOEZxw4AlBy5pKTYUtW4KL1BoTZkXjwhYVCvB2NrwSbuX9m9dr3/tmaxpga9phfoUVhWGXJyfDzp0teD6JakuWwFlnBaeMBaaAHvXvo1hcsDji4z0eWLQIbrvNpn+CDS6FLWjuAtzx6N+WiIiIiEjr0dm1tLnVxasBWLl9JQBvvGHTuz75BHr3huHD4YYbwqcVldfahYnuxIaZrSLNPpaWZmfTCqyPE7aAsokBnOACtdXhR7bs74xpeQ2Y5thetT3s8pQUWLs2eJkKT3dc69fD6afbYF+9+npAHq+HbzZ9w8uLX474+A0b7D564YWNI9YiBiljAOOOEOkVEREREZE9oaCQtLllRcuCfs+cCeee2xiwSUiAI46wg1CaTo1eVmtrCiXGJpIYm2iXRSg03bUrbNzoH2ngF7aAsnHbES6aypqYmAjFuPfSjqrQAuFgg0Jr1gSPJmlaXFyiw5PznuR30yPngjmO3WcPOih4ef0+t2bHGgA2lGyIuI21ayE3t3GU0O4FjEyrH933ioFXVGxaRERERGRPKCgkbW5p4VKgMSi0Zg1ccokNENRLTbUZI01H9uystrlGCe6EhpFC9aOHmurVy6ajVATUod6yJcyKMfF2lJBHxW3cblvLqVW25XIT67JRvbgIdV4yMuzoEI0Oin43fHAD9399f8T7d+60gaGePcPfv7xouf29bXnEbaxdCzk5YQKD4WpXebEzj9WnLAaN7muD4W4iIiIiIp2AgkLS5masn9Hwu6rKXkwOHRq8TlaWTWMqLg5eXlpjAzcJ7gQS3XYIULknfFAoK8sGlebNa1z25ZdhVnTF2sBQTfgUp84kJcWOrmoNfzruT/zrLDt1VI/kHmHXyciwQcFAgSO7QjgOrH4G3s6Ct3vCusipSLJvlZfbtLFI/bekcAnQGBQOJy/PppCGpIzV164KrFn1xz9DXQU4bTC0TURERESkk1JQSNrcl3k2MjN742zWrYMuXexPoLQ0GxRavbpxmccDJdW2flBgTaGK2vBT0mdl2dSVjz+2M5CVlcFnn0VoVGw61BQ13k5og3nZO4BevWyxb08rZNIlxyaTHGeLy2yr3BZ2nexsWLUqOJAQOFtciIV/gO9/CdWFUJ0Pc6+FCEFBaT0+p3HkTUF5+HpbHo9N/Qws7B5o1oZZdj2fBydCQfKKCujePULtr6bcqVCzLbgWmIiIiIiI7BUFhaRN+RwfDg5JsbZoSGmZl549QwMBWVl2WvoffmgsfFxZ2VhTKMGd0FBTqKoufO5RVpYdWPDxx7YWbWwsfP55hIbFZ0JlQG7ZpPw9fo0dWd++Nm2vJvyEbi2SHJdMSpzNCSyuKg67zgEH2L7fHjBIa9GiCBssXwsr/gY9xsPErXDOZug2BmJTIjxAWsu6Hesa/l5YsDDiesZEnICOmXkzG/4uqAgfWKqttaOEwtb+aioxG2qKARWaFhERERFpLQoKSZvK25kHQE5qDgAbd2wlNjZ0xqv0dHuB+cknjTVu4uMDZh+LbRwpVF0XfmhJdrYNbixeDI88AlOm2FEwYcX3gJ0LwNu5qxz36gVFRa1TbDo5NpnkWDtSaEd1+ELTffrY0SXvvWdHmFRWwn/+E2GDK/4JKf1h3Js2IJDUC459b+8bKrsVGAhakL8g7DqxsbY2VEyYGs8+x0ett5YeSTaNsL6eWFNut/0cRAosBUnIhppCm/oJnXZ0n4iIiIhIa1JQSNpUfZHZAZkDANhYvh6vN3RWaWOgRw+b7pVgYz+sWdOYKhZYaLq6rtpGgIwJ+uk2NLshleW3v4UHHthFwxJ7wc7F4K1stdfaEWVlwcqVzUzf2Y3kuMb0sZKakrDr5OTY7nrjDRvAMwY++CDCBrd+DINvAVdA41zhC1hL65q/dX7D319v/DrsOsnJNv0r3Ciz+mDwgK52v68vOl1UBFdfbffxhAQ7E2FpaTNnoEvItmmE9Sblw8XNiSaJiIiIiEgkCgpJizkOTJsGxx9vC0b//OeRR+R8ttYW9dlathWA+QXfsH17+CBEnz72IvOll+ztP/8ZKj2VGAyJ7kQS3YkYDLXeWpvz1IQpLKBbt2a+iOQ+sH0uxESokltbAjuX+tNV9l89ekBhYfCF/Z7WFwocKVRWE35Ks759bQDgs8/gySfh9ttDC08DdgRX2SrIOhFcAVWI/bObSduqrwcEMGPdjLDr1NcF27o19L45m+YA4PXZKO0naz+hvByOOAJmzYL777c/BQW20HmzgkKJ2eCtgpLIs5mJiIiIiEjLKCgkLfbzn8M118CIEXDjjXZa6dgI1+pvLn8TgB8KfgBg5s4XKSgIX1x4yBD7+/rrYdgwePVVWz/IGEOCO4F4dzwOdmSAE27K6qwscnKa+SLSDoG6KqjYEHrf7Mvg7WyYcQpM7Q214VOh9gd9+tj0nVmNMQAq93DwVEpcSsNIoQpP+GLg2dmNqWq/+Q387W8RNla7w6YJJWbvWWMCOI6D+49uHpi1q6FjEqi+OHx6fDpltWUNaZyBjLH9GVgcHmxq6IuLXgRg3hY7FeCnaz7l3nuhWzf4/nt73LjxRvjnP21AOVwKWgh3ChgXbP0QfK1QGV1ERERERBQUkpaZMQPeeQe++w7+9Ce44QZ4/XWbhhRO05mLipyVxMfbQFKg2lo47DCbUlJXB0vsbNZU11XbkUKxibiMC7fLjcGwY92y4EIkjgP5+Rx4YDNfSPpQMDGw+E47zXVdQBCjZjv8ZDWcvQ7OyYO4LpG308ENGGBHCf31r3aKcbDpPHuivtC0wVDpCR9ZcrnsFOS75XhtAICAPn47G14xkGFCUgfJjhw8mrdlHl7Hy19n/7VlL6iTytuZ1xB8rU8DfGfFO2HX7dfPjhoMDCSWlTVOR+/1zxRW5anihRdsSmdSkg0ix8bCoEGwbl0zC00bA8kHwIb/NAaFPOFHpImIiIiISPMoKCQt8thjtiZI16724g4gJcJkUI7jUOO1eUlufwpQrbeWfv0c3nwzeLRQbS0cfHBoWll1XXXDSKH67Rhjwo5cABg9GuICys5Eahvpg209oQ1vwKZ3YPP7jfeNewOSettUpYQeYesX7S4QsaxwGQ/Nfiji/dHC7bYzgn3xhQ30Afzyly3fjsu4gtLHPF4Pdb7w1asHDgy+3bS+FACxaXYkV2Cwrjr8DFa788icRwDYVrWNHVX776iv1vLuindDltWngTY1bBi8+25wH8bHN84+V7/fUpNGUZHDuHHBAaD+/W0Q6eOPQ4vPh9XtSNixAPKn2xTDykiV5EVEREREpDkUFJIWWbQITjqpsRj0rhRW2KKw3ZO6s/O3O8lKtsOJho6o4sUXGy8CfT7YssXWJwpKKzM+PD4PLlwkum3tn7gYG/GpL0Dd1NFHB7ct4oWmOwmS+4Hjg9mXwNeTA5949y9uN4569ihu/vRmZm+cvdfbai0VFfCXv8Bxx8HEifCTn8CZZ8Ihh9iL+uOPt7PATZ3a8m27jIvkuGRiY2JxGRcxrhhKa8IPOTrmmOB0w7CBu9gUO7vU9rmNy+pnm3qcsKPEwqnyVPHy4pdJctsI5v8t/L8WvKrOaVvlNgB6p/ZmQBdbKHpH1Q4cB775Bv7xD7jvPnj8cTjoINixA956y85EVlEBDz3kUFNng8E/3vgjo3qOAp8b43JCRgQlJdnRRvfd17jv7zJ9Mes4m0b2zeXw3XXw+Ul2+c9oUdBWRERERESsZgWFjDGnGmNWGGNWG2NuC3O/McY86r9/kTFmZOs3VaJBWpqtAdKcb/Xrp6Huk96H5Lhk+qb3BeCw41ewcyfcdJNNXaqogLPPttdwvXoFbCC2CrfLjdfxNow4iIuJw2Ai1qwZOdJenNbbZa2SrOPZZQCoPl3pkXIbeGhmIOKrvK8a0m7OevUsfE5zhkC0rZoaO4qqVy+b7vPcc/B//2d/Jk5sDMy0NHWsus5eyTuO0zBKqL6PSqrDz0B22mnBgbtws1cB0GM8/Pg38PhHhU0K/37vym3T7eGq2mvbefOnN7d4G9Gsrg6WL4c5c2ytni1b9n6bK7avAOC+E+7jxYm2NtCqDSWMHg2zZ8P559t994wzYNIk23/XXmtrgD3zDNz51y3UOXVkJmbSL6MfQ3oMgYQduNx1LF0a+nznngsLF8Kvf22LTt9++y4al3Uc+OrAsxPWPg9Vm/f+Bbcix7HvR3k5DTMhioiIiIhEs90GhYwxMcBjwGnAYOAiY8zgJqudBgz0/1wLPNHK7ZQocfnl8PTTwYGXSLNV1U9H379Lf6BxWvqkg78hJsYGJvr3t8WOV660j7nwQpvSBJDSpQK3y43P8TWMEIqPsfllkUYKJSQEpyeNHr2LF3PglRCTtIsV/LzhnyucOl8dE16Y0HC7uKqY6967rtmPbyszZ9pRQBMnQmIiZGTY21262Av7wAtYtzviZkLUB358jq8hcBfvtn0UaVr6UaOC42sR60AN+CkUfgFrn4W6SptO1kJvLH0j6LbH52mYGasjq621gZhbbrFBiH79bF2v77/f+21/v9VuZEDmgIZ99sfXrmTiRIcbb7TB29RU+5x9+sBRR9njwdVXw69+BU5Xu9/3TrXFow7pegi4HHLHfs8dd9ggcL2KCntMcbvtcaVvX/j733fRuOQ+kJLbZKGBZ7OaHbRtC/Pnw6WX2pF4X39tg1xvvgkl4XeBNpVfns/V71zN8qL2naVtaeHSiGm+IiIiIhI9mnP5dwSw2nGctQDGmNeAs4FlAeucDbzoOI4DfGuMyTDG9HQcJ8xkxdJcVZ4qFhUsontyd3IzcnE5DtSV2YtjfwFXjMvO0hSbtlfTdZdUl/Dh6g+Zv3U+JxxwAhNyJxBm1nguv9wWi/3pT+Hhh6F7dxtwOOmk0HUX5C8A4JBuhwT9XlT0PffcA7feCpv9X/TX1yeaNMmmp9TVgceUY2isIwQ0zEC2q4uNiRNtIeuYGDsKIaJuYyG5L5T6L55S/NGkry+CMU/D2ettMOKtrrvYSLDnFzyPz/GRHJtMr9RerCpexUsLX+SRo24gyfjAqfNfvBpw+Ycx1VWBPz2urQwbBnl5sHOnvZ2cbEd7VVba0V/XX2/rRdXURJ5JLpzSmlKy8I8O8vdRojuRitqKiOljLheccgr8970+Jv0AACAASURBVL82GHDhhRE23uNYyDwcfrgVVj4GtGzE1fqd68mvyCc+Jp7tt27n/ln3c89X9/D8gucZkzMmaN3iYsjEjnYxxrbRcSDVt5RUVnHoYTGkp/tHlTkOcBbk/Qe6DPdvwdjC5e4kiO/W2LfYYuvXvX9dQ7Hmm4+8mftPvJ8YV3Om3Apv/nxb9H3VquDlkYp4e7weHp3zKI/MeQSf4+PGI27k5iNvJjYmuLPrfHXk7czDZVz0z+xPt6RuxMfEU5uxmnXrHXw+g89n35+6Ott/DzwAxx7bGCh291yKh8ZgcG5Gri0Wf8r9zPjTO1x4oS1SD3DHHfD++/bz8NFHNoWsaV2xEMMfsCmfdeU2qDtsCgy+pUXvX2u78kobEDr55Ag1spr4Yv0X3P757SwtWsoRvY/gnuPu4fCMbKjZ5i+i7T9GGBe44myqa1x60DbKasr4Mu9LPD4PE3InkB6fzpXvXMkLC18A4NkFzzK+73g+v/zzFn3W6re7o2oHJ/Y/keyUlqXhvbH0DSa/ObmhWPmp/U/lvYvfa6grF2jV9lXc8MENfLbuM2JMDH867k/cdsxtDceScHy+xvify7Xr99vj9RDjisFlWp4pX1heyGtLXmPulrmceMCJTBo0ibSENDxeD0sKlxAbE8sh3Q4J+7p2x3EcqjxVJMYm7vK1hlNbV8sV71zBq0teBeCoPkfxxnlv0DstdOevD7Dm5tovAxzH7mNr10JMrIczLs6jR0oP0uLTYP2rUFsMcV3tuYQx4K1lXfEabl4wlQ+3LiMlLoX7TriPq0Zc1aJ2f7z6Y+6eeTdby7dy1sFn8dujfxu2vR3R6uLVPPzNw8xcP5Ph2cP57dG/5bDsw1hbvJbXlrxGhaeCC4dcyLCsYS16z6rrqvlo9UdMWzmNwT0GM3nIZLJSsqmutn1YP1rbGHvb47Ff7jiOXeZ22//zmZmh+4jP8ZFflk9GYgZJseG/GPN6bXC7stIe642x246JsXUbBw+2Xw6APa949FH7OUtKssdwr9e2a9Uqe1wcMybs0wRxHIcNJRtYVrSMUb1G0SO5xy7X9/mCR63HxDTv+NvWNpVs4q3lb7G9ajvnDjqXYT2G4WrWbAqROY7DHTPu4M9f/RmAUT1H8dzZzzGsx1D7P8MJ+HbWxIArPuTN8Pl8fLvpW95c9ibdk7tz8bCL6ZfRb6/atbs2byrdxJKiJYzMHklWSoQZabDHtblb5vLtxm85ss+RHN7rcOLccWHXrfPVsbhgMV9v/JpRPUcxutfokHOZequLV/PArAeYvnY6h3Q7hDuPvZMj+xwZsl5VlS2PUVPT+D/GGPuZio+HYYf6cMd6G5/Hcfzve0DtTONuPHbugfJyez5UXxe1fjPJzjpSWcmQIQ5pqU0eFJcJXQ9vXNlTBhUbwVuNPY9w7HmEcUN8V1svlcaXUFlpX3vgF8Px8fbYEXQtULEBiueDy91wehJ0LZN94h5dg65ZY2tK1h+njLHvvzG2NMGFF9ovr+ut37meh2Y/xCdrPuGgrgdx+7jbGZMzhvdWvsdDsx+itKaUK4ZfwTUjrqW4MJGKCnv8CjwupqTYrInm7JKz8mbx0LcPsbVsKxcOuZBrRl5DanwqjuOwvXI7KfEpjbUzd6HKU0VsTOwenS/sS8YJ/HY13ArGnAec6jjONf7blwJjHMe5KWCd94H7HceZ5b/9GfBbx3HmRdru6NGjnXnzgu/+4qm/c+ygL2H828Erv2Lg4uB23vHE9dxT+FTIdp2BwOS6oIuyH955ixGxd8Ppi4Jf292hO+4h2w9jzPonuexXYxv+4TkODF2aRNKkebZAsd/6pZt45o8f0Of46+jRw45SqamBcyYaKPgSeoxrWHdzwWZyngydL/2HpMEMn/wn6DOpYZnH6yHuntCD4dpu2Rww6UXoGRCBqd0Bb/WAi4KH63z94CUcffoQGPL74I2EeS9P//MQPqxbRlPOFLj6v1fx77P/jdfn5YxXzuBc7zJOSZ3EZY/+nTlz7MHL54Oyp0K3O/aBocytXspLk17m4mEX8/qS17norYvwDXTgYofrr4cXX7Tv71cv/4fRSX+BU7/j7LNt8do7Hl7LvaX9yUjMZNut2wEY88wYEpfWMHPCThu0qT8QOo59bWdvoLimDzk59qA2850lDNl0JFxQFrRuZiZMnw4j+8z21yVxyB/yOT2HjcX5ajJsehcSs6C6gHX5vTjggifs++7fRp3HITYWnO3zYdkDsGMhJOdy0KwvWeVUMePyGUzIncAJL55AwebPWXJwNkzyx0jfzobqAuasPoIxd80NHuEAcK6BJrsAP4Waa6fw4g938cwzNs3r+OPhsaMN1ZMc7r3X1nXp1QtevvlW0pKreW7xo7zwgj1hGzsWbjhwDL+cNofDD4cRI2yB38R1D3LtuXPZPvg/jBoFW7fCz38Ofx3p78+Af26zXniOY3q/CCd83rD8x6LlHNJ9ENkPZpF/sx2ZcdiTh9H3x3jeO6kKzlgc2kfn7WDtpgwGD7YH59deg+uvLmX1+4/YAsKOA64YYk+bzo+LK+iffwkU2ELHeYW96Nctz37eA7bbqxdMfX0nYzKfhLxXwfHxePmB3Pjju0waNIm3LniLBfkLGPHUCGak5zKnaBo7vIPIyLCbWbwYXnrZhPTF5icG0Pvsx6DXKXbBoimw5G7MJU5It81+8EKOOmMUDL61YVmkffmf3WHSgLt5YtadTJtmT54HDYI3h9rXNCBzAB6vh7ySPE5d+AuSzCO89Vbj4z0e+N8z/4FvwM+5/HLo2dP+41v36b84/rprufMO+xl3u+1onNuqQ491F6bA8weN47lNX/Lyy1BUBP2GbuHzQ3uTFJdKyW0lGGMY+vhQepYtZ/S8x5i383ouusgGg/Py4KZMA+ds5v5He3H33Xa742+/nE+8L3LXsXcxZcIUvt/yPYf/63BK+8OKnBVc+rOB5OXZdY8YuokZv+xDxdkOw4fbz1+XLvD1bw+k73nPQPbxDf1cXeXYC1ufA1+caT8rqQezZEUCQ8/9DfS7MPizFmY/+u6W0Rx+zZVw0M+C7whzXLz8chjQ38sdl74OK/8BnhLodTqMeijkc/Le35/hXx+dyzU/68LIkfZ9374dhiwM3e5FD4znteqvQvrDGUjwum9n8+UPAxk/IR5OmB60brj/XcMq+rE4OS9keTjHlAzjq78tDllupoSuO7yyL3PGJhF3xjcQl9GwfNvT3el27jR7Qur31eIvGf/2sSHbyH50A69P7cP48Y3L8svz6flQz5B1v3AfxvjCXHi0cca7MlJIoyxknzv+T72Z4WtezuSTVeO4bvIxMPze4DvC9P259x3O27URT1+CjFl1AX8fN5CxJw6wJ90ut/0yYdZ5Idv9/eM/5b6iZ0K24Swi5LM679CRjP5zBZz5Y9DycH1/0Naj8HzydcisnsnxlcxbkMSgQY3Lvpo7g/EfHh+yje29Msic9Cl09Q+vXTSF5d/cz+D80Pze+UmHMGLyn4POWyK1rT9JrCG0UFi41zzrhqM55menwtA/BG839NDMLZdOpyr9RP75z+Dl4dpw+vJrcEr/xbRpu1/3uh3jePKcFJgwbbfrjq44kHnJa0OWh3NU8WHMOCGGuFOnB89o+oqB88tsHT2/qdNfZ1JQnUO/KQ5lZcF1+GbP2M4V13VtGG1d7/7L/4r3wBs46bTkhsNiaWUJJ87MoKlhJonFTpM+2noYOR8sYOPG4MUf3H0TZ5ydFrQfLVxoSwCsXx+87qn3DOBj75qQ5ws51gHn3juKtz3zQ19zGEd8dR9D+93Gv//d5I4w+/L7z0znvudO5Ouvg1cN159jthyHZ97nzJ7d5MsJ/3lL4PFvycxvGVp8Tkhae7jtHljehzWjCmFyddDy/Cd6kX3em9D9qIZlJUU7Sf+0S8jryPijmxInOCe5VwxsHpgAFwaPoh71pwzm+5o3TPU1z1gu3JECjwf8j0kE/u2C80qCPpdfPHQjxx6fBCMeDH7NYfbPyfcfxes134Q8X7i+v/7hs3mqLHSCC6Y47NhhR7bXu/3J67m3INK1X21QYOKhl6Zw85q7Q9Z9Pv9SLv3Vkbj6/MTfeHjluW08O/VQpgf/qyXubkPTZIhhtT1YNNoNE4PT1zf8M+C8xa+6eCMJ04fABcFfkg7vv5K7/noQEyc2Lps92464Xt5kkO+GJwbR96y/QM5ZdoH/PJS3CDmGrrprAAMv+wMceLld4L/eAOCi+ll9rfNPXMiI4w/j94GXid5qNj4+kD6XToOMYQ2L5z35c0aPTYHh9wW3AUL688vn/sX4fm/A8Z8GNy7M/vnA75awdPNQXnyR0HXPL4XYxijYk/95iBuWNa8ERK81p5GzYhpzmiQGhDtvWbm4mPEnZYYMLs/8o5sdTvPqAHwZO4Jxk3/Z+L77hTsejHrrfa649gxuuondrntMXRaz3KGT7ITbjwCYez0zZ2cw4Vf3N27XmO8dx9lV3kzjus0ICp0PnNIkKHSE4zg/D1jnA+C+JkGhWx3H+b7Jtq7FppfRt2/fUXl5wSewW1ZvZMVPT+G4mcF7xKtjenHRnOATv8W9MnnyBENe3XZifOCNgUOKYERyNpcMHAx97KgUEuey3buG96f25fLUBHvkGrQZBm3mpak9eT12K/kp4HIgoQ4GzzqPH3P+w4wZwe/Dc0dmceW3hUHLnnFdxTun/5v33gt500Lexwo3XPk/qUztU4bXBY6BAdvhlu+6ce2320LWf+z0HgxbUsiAYqiKhaXdwVMxlNrhGVy0cxPEx8HI7TBiOytWpnPw+U9Bel8bwc17htVzZ1L0cRpHfrIgaLtvj8lh0pzgGXu+7t+LrUMSOfmjNSTVwfYE+LoPTFphLxLu/RQKU+DvR8KxZXD7imROer+CjeRQTCYDWcX//HIYVx47kVOuuY+44lK8GfGs+GMaeTPTOfXt1TaoDCzIhuXD4OJP7e019CeNUnqkFfHRMXGcOq0WD27Wk8tAVvPFJafQ/72PyfEfT7clwYruabw1eSyTz7yE4Wf/nBhfDTGP1fDCc3C5/4BeRDfc1BEXX8NvbxzLZROvCFp3yoN9mLLAf7aTDhio2RlHAjU4GEgGugHFMPaawVw96EQOGzSqYRuuf9YwdWouk35SAIOvt0GD4u/5/INniZ2fzLg3bACyPA5+7Aaf9xjKreXroXsGXLUFknys3DqAg25ezdyvXghq2+Vzj+ayUy9k3CX2xLjohePpUvQxw3/9NX2HHsxvbk8iPR0+/djLwK9Tufuz+Wxx9SF3cDL5+T668iM1NQ6HH9ef301JID0dZs/2EfdiDBd8ClvJppAeJFJFn64b+GpsDCd/UEkFSWwih4NYycRfHsGV43/CaT/9S0N/bvtzGo8WHsnZJ54b1F4ugS2p0Ms/O3hREqzI6sI7F43l/NMmB6374nNwmb+P8skijlrcGR5iHjIkj/8nHDjZ1ox590Cm/DGBKQv9x4gs+wGq2hHPb24awxWTrg7a7l8f78nNk7fCwafCkF+AiaFi+jl89kYXTvh4C8n+/+o/doORO4uZtzCdAQNcDd8e1NVBUrIhj76UJvfEG5+Eq66WdWVd2H7Mdq7auhAyUu3K1+RjrnNwhnW3y2LdMHwbq3pnsu3j1NB97riejJm3ld5ljW1YmX4o1xbP4rGnkjh7YgzGwJYtDn+4byAvZgWfRP/+/aNZl3w/v7rlIEzDVzSw9pEszv/UsJ5cSkkjFg+/jn2YTzynguMEjej5+OpTOPj9TxhgJwVjbRfY1C2F/9kyl7MuOpDb744nPd2e1OffeyYHv/9Bwz5XlAT5WbDxEDcnfmjYQF/KSSGdEr48cX3DPreBPsTiwaSW8t1ph3LKW98S5/9/urQ7zD0UrvzM7vc/cggGh4PdK/jgBDjzY6glljX05wDWcdyvB3D1oBM5dNDIhn7mHx7+9McRTFn1vX0LegH5sKzvIXxx6/GMGjom6DPx07nHcOlZlzD2gt82LFuxZSAfx09g7Ihjgta9Yu7RXHbaZI65+PaGfa5k2Y/EVxfSf2AcDPsZJPSC726Ai8Pky2bB9CNSGf5eHPlk4yGWFMr55vRaLuuTC1162A9wj2X84Cpmw1dpnPLOKhLqoCIW5veEr7sN4LbizZCVaY/vl+aRX9uNFct6cuyw4+zzxH0D8XN4680csuZtYkihfSuWd4ONmV1IyE7jpBl5JNZBnQsWZsHSId2ZmVREZSwYx/7vOXVNGlcsKA059kx7qw8p8zYyrBBifLAmE4oPjOeYX/Ul/owvIKEbLP4jLL2HY74bxtXDTmLIQYc1bKP27x4+eLs3J3yykS7Vtq8XZ8HU3EEcvW0cqUPtt9L2C0aHNc5/OHn6QrpXNq67rfvBLL/+OA4/7MiG7Zp/1PLo48M4ufSgoOklZ2eX89HB81lbuQm3D2IcOG4dZMd3x2wv4qBtUOOGvHTIrcll+aXjmDD2xKDX/OajOZzX5H/i3NyebBqWxKkfrSHJAyXxMK8XbB6QRdbaAgYXgc/Asm5w8JlJHHjVzXCo/wTZf7L86qOh5y1LszN575g4cpfn06sUClKhOBH+O24UV405g345/RvaVnJ/IvfmjeWC0y8Kau9nb/QjZ1YeB9vvSdicCuu6xjO31xhO9g7ACTjpn5fyDBOnp7PFlUNtUgY4DrV1ZXx1gcPQ2UvI3Qml8bCqK6yMyWHKqk3QNQbSksEYaq8v4e1Psjnh03y6V9rXvCgL5uaGP2/5/bmZLHPbg4zXQFYFHL4jlwO6JnHCu8uIcez/8EVZ8H8/OZrLTr+Ioy/6fcM+V71yIduKchmTM8QeaxPmQMJc7ntkLCf7DiUmuX5ErcNaJ5Wv43I465hBEHBc/HblL3gvYRHlsfaznlUBE+acwlc9nuWp57sHxY0/unMC6wpmk+6/Vi9NgJFFWXTN7MLxM4ODcc+f1IMvEwvxuhqfbtymLqR3T+XUzzaQWgvVbrsvFxyYRe6PBQwpsq1anQlFg5I5+pYDiTn1a3uh4/+cPPFsL25IS4deufY156ykuNsm3p2WyekfbaF7JdTE2O3OPaA7py3tT12X7jhu/4gEXy1zsxdy1MoDqEtOx3HFYHxeziy8g4efH82kgLidz+vj71eNpN93CxmwHSribN/v7NKPbwdVUFCxjRifrSsxPg8OcGdw+Ld9qOmSjS82HpfXQ/WAMnJ/lkW3w/3TlG54Dja9wFvPG8Z+2pPtcT3xJiQT461lSZ8aVh9bS6/vlpJZCZvT7HElKyaHc5vsc7MP7MmK4fEc99l60mugIBmW9IAfD8rkyf7F7Iy3/ZldDvd8m0Z52kjGFfXAhwsHg8FhUcKXTG6yz81IPpbbB73POx8kER/v73wDU286nuVbZpJca/toZwJ0WzeOt1I/4ZPP4klJoeG89fRbR3HV4afTv+9BDfti+YNx3LVyDBf/5NKg/fOjN/vS9dsN9hjqwLoMWNUtnvije3DiuMn+ocizwD2bf/+jO1d/WxTUXk9MDB+P7s2ZczYELf/mqL4kr9nAsALbrqIk+LE7LOw1mJtiPRAbAyO3wfBt/HdjP2av85L44yYSvPa19S6FtIwsjp1bQN8Su38uyoLirv1ZctV4jjl8QtDrWLs2hQMnvwRd/RHllY+y7pv32TwtjWM+Df5C4cExwzm5YgiulET/2+uwPK2GnZkLOeGjxWTUQGGS7U9vWm8unBMcTFnUuzsLRyZx0ud5pNfY9i7Mgpdifs2px55D35FdG/o4vyyPHd/9gdM+/oGuVfb4tSALtnfL5n/mBF/Vb8pIY9bYdE6bsZH0Gqj170e5/xtL9oX/tV/yACyagrP4bl75dw8O/y6H2vRu+GJi7TngybB+6af0KYVkD6zsCqlVsZRnHMzP3B5wu2BEEQzfxjP/6M41TfrTm2j48eYshpx1PySmQ/5rUPg6izYM47PvJnFEYvDoqa35v2bk572pSO+FLy4B461j3c50th+Vz1VFyyDdfx565RauWHZUyHlL6bLlfPtRBleWrIfkJLhsAyR5WbI0jaHn/Q0yB9rH5z1L+ao3mPrGMEat6IIvPhGMweVUk37NZ/S++D3o7h/et/Re8r54mfdeyeKmbUsgMx1cBq4u4LVne4bsc/kZPUj2lJBaEfyFwitjenLxnCYJRKkwdWw6Q6f3oCotC587DldNFTm+78isDJ7BeGtaKjOHp3Da3K1kVNv+/CEbig7MJndFfsP50MY0WNvdsLZ3b45cnktdSkbDcXFuj7lcNSf4Wj7flcWknNd58InDSMtsHMlT8NhldJ0+lcMKbIwgPwUW94BFg7uTs66IAduhLN6eT/d0DqZrrxSO+DC4hsPfz+hOypYiDt5uz/XWZ0DvqoGsOOAcjkzJsef0xuA4MNP1BItrf8Q44HNBWg0ctqM3KwZ6qCguJLYOat0wcDsc5Ak9bwGom9wD96vBQaTWDgodCUxxHOcU/+3fATiOc1/AOk8BMx3HedV/ewUwYVfpY+FGCkUTj8eOpPB67fDBLl3CjwjcssUOj62sbByedtrpYcLmHZExId8cvzTxJS459JJdPqZBB3wPwn3jEVbtDpiaAyfOgPShNm3IWw2v+09aw0VwIz1hU1lZIfVQ7rvPpum9/bYdAQV2BMgf/mDTsN5/39Z4cbns7F4HHggvvNC4bk1NM9Jy9lSz37QIvrsRYtNh2J0QkxD8zUZz38dZk20K5ai/gdv/ol8xYbcxebJNp/vFL+x7Ul9DPCGx+a9jb1/ykUfC//6vnQEuXL/k7cwjwZ2wy+HW4Xz6KZx0suGtN+3Im7g4W9dm6NDQde+6y6ZvPvJI4+ekUwm8Ogy3bN1LsPQ+OHmWTVOLibefqUvokMe2EHv7IZ4yhYbhYYHuusveF43CtXlv2+s4ULkByteBr9bOaImB7ONs6t/eaIv2SqfhODYlpT4lJj7epotHQ4pVhxX4P0L7p0h42dlQ0GSES5hrmxY9vqXbEKBlQaHmJLd9Bww0xhwAbAYmAxc3Wedd4CZ/vaExQElHrycUG2tzHHenV68mM2btZzLiM9hZYwvRjO45etcBoc5kw5t2JqS0QTYgFBjIaANPPw3PPx988Z6QYGd7evttOzV4ff5vSYkt+Bu4bpsFhFqDKzbgYirojuY93ueBTVPh7LzGgNDbkeugvPaa/Z8yfboN/Pp8tg7CBXvW+j2yZYstqhypX/Y0z7++tteZZ9p87Npa+z+0PmAdaMYMuO66ThoQao4Vj8Kg34A7zaYj7+Iz1SlNmdLxLn7aos3G2JpPyW1Qm6MjvscSNYyxdX9SU3e/ruxCuOCPMTYAtD98QSDS2vY2cKPAT7vYbVDIcZw6Y8xNwMdADPCs4zhLjTHX++9/EpgGnA6sBiqBK9uuybIvTbtkGkc9a/Od37rwrd2s3YlUbrYXASbcLtTCgoLNOKmorLR1XAL98IMNXI4fH1wQLiHBBgTq04ei3tA74aMj7Ps54Bo4ZzN4q4Jy2XfJW2MDSvHhCoKHfwOyswnK5QYgUsHrNnDLLfZ88j//sbdjYmx/pTTzJe9OfLx9jbsyfjzMmgXnnKPAUFjla6DH+Mb6dG0Y9BURkSil4KyIdALNKoPtOM40bOAncNmTAX87wI2t2zSJBkf2OZIDMg7ggIwD6Jvet72bEz3SDoLVXwD+oin1xQY95c0PZrTACSfYdLA772y8gF+1yqZBVVUFjzj51a9sutlxx9kZZ2Ji7BDy1go4tLr4TDhzKax9Dr66wL6Hcelw9KvNm5XNnQyJPaFgBmQdbwu9TsoHnzeo4Hw0ufFG+0XjyJF25q7UVDuj2Bdf7Ls23Hqrff477oDf/96mFWzYAAMG7Ls2RLXYNDvjRqr/DUnIUmBIRERERPY7u60p1FaivabQXtnbWg3RYk9eR2epKVRXBVOzYcwz0PNUWzjSUw5lqyBzRKs/4YoVdkrXBx6wsxN4vTal7OOP4aWXgmdn8HrtFNk//ABXXWVHE82da6ecbxPR8Hlf8wIsvQcmfGADRGCnV25JSkcLXkdrvWTHsbN4VVTAAQfYNLa91oLGVVXBk0/Cyy/b2bIGDrQz/yXsfobNji+wNkS4/PVJwPUnwXFTG9MSvdU2UNnen/fWEA37rYiIiIi0iVYtNN1WFBTqABQU2rWCmfDFWZB1AnQ9AkpXwOb/wvnNmwq0pU/4ww/w05/aEUKpqbZ2UGYmrFwZPFLI47HpZAsWwBtv2Iv9sWPtFNttkk4WLZ/3ZQ/C4inQZSSYGCj+Di6saP7j2yEo1CaiunFRZHdBoRTgQRcMPd9OvxyXCXlvwEHX7R/vrz4nIiIiIvstBYXa2/5yst2S17GfVIpvcddVF8Kqp2DHfEjpDwNvgNT+bfiEUFhoR5b06gXdusHUqTYFqb6uUGVlK404aa5o+rzXVUDhV7bGUI9jbApQcyko1LmEm32sqYo8+O5nkD8dcNkp2Sdu2j/eX31ORERERPZbCgq1t/3lZLslr2NXc5x2oPdin3fdXj7hL39p032mTYM+fexIoN/8Bp54ohXbuDud8PMe1S85qhsXRZoTFKrnKYW6SkjoYetU7Q/vrz4nIiIiIvut1p6SXlqqX79dB0k6ktZ4HR3qvQgzd3db6rd30xjfey98+CEcfrgtELxliy0qvU+DQiIdSdNRjcbsfkRjbFrLRp2JiIiIiHQQCgq1hfXr27sFrSM311bB7UT6sR7DPvz2PA9opRjUwoWNf+/bOJzTaq+hfTX/dexlLE/aU7g013DLREREREQ6AQWFJLL9JbjVAuvbuwHSfloSBG3FYF6b6FCj86JES96z/eH9VWRTRERERFBQSETE6oRBUBERERER6dzaYoJqERERERERERGJcgoKiYiIiIiIiIh0QgoKiYiIiIiIiIh0QgoKiYiIiIiIiIh0QgoKiYiIiIiIiIh0QgoK2HsFbgAAB1dJREFUiYiIiIiIiIh0QgoKiYiIiIiIiIh0QgoKiYiIiIiIiIh0QgoKiYiIiIiIiIh0QgoKiYiIiIiIiIh0QgoKiYiIiIiIiIh0QgoKiYiIiIiIiIh0QsZxnPZ5YmOKgLwwd3UDtu3j5sjeU791XOq7jkn91nGp7zom9VvHpb7rmNRvHZf6rmNSv3Vc4fqun+M43Zvz4HYLCkVijJnnOM7o9m6HtIz6reNS33VM6reOS33XManfOi71Xcekfuu41Hcdk/qt49rbvlP6mIiIiIiIiIhIJ6SgkIiIiIiIiIhIJxSNQaGn27sBskfUbx2X+q5jUr91XOq7jkn91nGp7zom9VvHpb7rmNRvHdde9V3U1RQSEREREREREZG2F40jhUREREREREREpI1FTVDIGHOqMWaFMWa1Mea29m6PRGaM6WOMmWGMWW6MWWqM+aV/eaYx5lNjzCr/7y7t3VYJZYyJMcb8YIx5339b/dYBGGMyjDFvGmN+9O97R6rvop8x5tf+4+QSY8yrxpgE9Vt0MsY8a4wpNMYsCVgWsa+MMb/zn7OsMMac0j6tlgj99qD/WLnIGDPVGJMRcJ/6LUqE67uA+242xjjGmG4By9R3USBSvxljfu7vm6XGmL8ELFe/RYkIx8vhxphvjTELjDHzjDFHBNynvosCe3Lt3dK+i4qgkDEmBngMOA0YDFxkjBncvq2SXagDfuM4ziBgLHCjv79uAz5zHGcg8Jn/tkSfXwLLA26r3zqGR4CPHMc5BDgM24fquyhmjOkN/AIY7TjOUCAGmIz6LVo9D5zaZFnYvvL/z5sMDPE/5nH/uYzse88T2m+fAkMdxzkUWAn8DtRvUeh5QvsOY0wf4CRgQ8Ay9V30eJ4m/WaMOQ44GzjUcZwhwF/9y9Vv0eV5Qve5vwB3O44zHLjTf1t9F11adO29J30XFUEh4AhgteM4ax3HqQVewx5YJAo5jrPVcZz5/r/LsBenvbF99oJ/tReAc9qnhRKJMSYHOAN4JmCx+i3KGWPSgPHAvwEcx6l1HGcn6ruOwA0kGmPcQBKwBfVbVHIc50uguMniSH11NvCa4zg1juOsA1Zjz2VkHwvXb47jfOI4Tp3/5rdAjv9v9VsUibDPAfwNuBUILHyqvosSEfrtBuB+x3Fq/OsU+per36JIhL5zgDT/3+nY8xRQ30WNPbj2bnHfRUtQqDewMeD2Jv8yiXLGmFxgBDAHyHIcZyvYDy/Qo/1aJhH8HXui5QtYpn6LfgcCRcBz/tS/Z4wxyajvoprjOJux35ZuALYCJY7jfIL6rSOJ1Fc6b+k4rgI+9P+tfotyxpifAJsdx1nY5C71XXQ7CBhnjJljjPnCGHO4f7n6Lfr9CnjQGLMRe87yO/9y9V0Uaua1d4v7LlqCQibMMk2LFuWMMSnAW8CvHMcpbe/2yK4ZY84ECh3H+b692yIt5gZGAk84jjMCqEApR1HPn9t9NnAA0AtINsb8T/u2SlqJzls6AGPM7dhh9y/XLwqzmvotShhjkoDbsSksIXeHWaa+ix5uoAs2teUW4A1jjEH91hHcAPzacZw+wK/xj0pHfRd1WnDt3eK+i5ag0CagT8DtHBqHrkkUMsbEYj+ULzv/3979hExVxWEc//4gFKSlRIILRax9q8iF8uqihbgTBIuXkCTI1qEbt66EtoHvqghSXvTdieA6DawQbRFk1CD9W0ek8rg4V3Tx3sW8hHOG+/1s5s69M3Dg4d4558c5c5L14fQfVbVruL4L+HPs+1qIA8CxqvqFtkRzpaq+wNyWwQyYJbk1vL9CKxKZXd+OAA+S/JXkEbAOvIO5LZOxrOy3dK6qVoGjwMkkzzrD5ta3fbQi+g9DX2U3cKeqXsfsejcD1tPcps1I34m5LYNVWv8E4DLPlxmZXUfmHHvPnV0vRaFvgf1VtbeqttH+GGljwW3SiKHyfwn4McnFFy5t0B4sDK/XXnbbNC7J2SS7k+yh3WM3k7yHuXUvye/Ab1X15nDqMHAfs+vdr8DbVbVjeG4epq0DN7flMZbVBnCiqrZX1V5gP3B7Ae3TJqrqXeBT4FiSf164ZG4dS3I3yWtJ9gx9lRnw1vAbaHZ9uwqsAFTVG8A24G/MbRk8BA4OxyvAT8Ox2XViC2PvubN75f9t8tYkeVxVZ4DrtN1Z1pLcW3CzNO4A8D5wt6q+H86dAy7Qpoueog2Gji+ofZqPuS2HT4Avh8L5z8AHtMK+2XUqya2qugLcoS1h+Q74HHgVc+tOVX0FHAJ2VtUMOM/I8zHJvar6mlacfQx8nOTJQho+cSO5nQW2AzdaX5pvknxkbn3ZLLsklzb7rNn1Y+SeWwPWqm11/h+wOszQM7eOjGT3IfDZsCHGv8Bp8J7rzFxj761kV89n1EqSJEmSJGkqelk+JkmSJEmSpJfIopAkSZIkSdIEWRSSJEmSJEmaIItCkiRJkiRJE2RRSJIkSZIkaYIsCkmSJEmSJE2QRSFJkiRJkqQJsigkSZIkSZI0QU8B++bqfaAp7CoAAAAASUVORK5CYII=\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABI0AAACMCAYAAADx21mCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3hUVfrA8e+ZSU8IBAgJoTepAtIFFFRAUFmRFQURK3YsqLuKugr23ta+6M/KKgq6CCqC0kEh9N4DKSSk90ymnN8fZ2aSSUFCJoD4fp4nT2Zu7px7M7e/55z3KK01QgghhBBCCCGEEEKUZznVKyCEEEIIIYQQQgghTj8SNBJCCCGEEEIIIYQQlUjQSAghhBBCCCGEEEJUIkEjIYQQQgghhBBCCFGJBI2EEEIIIYQQQgghRCUSNBJCCCGEEEIIIYQQlQSc6hU4lsaNG+vWrVuf6tUQQgghhBBCCCGEOGOsX78+Q2sd/UfzndZBo9atWxMfH3+qV0MIIYQQQgghhBDijKGUOnQ880n3NCGEEEIIIYQQQghRiQSNhBBCCCGEEEIIIUQlEjQSQgghhBBCCCGEEJVI0EgIIYQQQgghhBBCVCJBIyGEEEIIIYQQQghRiV+CRkqpkUqp3UqpfUqph6v4++VKqS1KqU1KqXil1GB/LFcIIYQQQgghhBBC1I2A2haglLICbwPDgSRgnVJqntZ6R7nZfgHmaa21Uqo7MBvoVNtlCyGEEEIIIYQQQoi64Y+WRv2AfVrrA1rrUuBL4PLyM2itC7TW2v02HNAIIYQQQgghhBBCiNOWP4JGzYDEcu+T3NN8KKWuUErtAhYAN/lhuUIIIYQQQgghhBCijvgjaKSqmFapJZHW+lutdSdgDPBUtYUpdas771F8enq6H1ZPCCGEEEIIIYQQQtSUP4JGSUCLcu+bAynVzay1Xg60U0o1rubvH2it+2it+0RHR/th9YQQQgghhBBCCCFETfkjaLQO6KCUaqOUCgLGA/PKz6CUaq+UUu7XvYAgINMPyxZCCCGEEEIIIYQQdaDWo6dprR1KqSnAQsAKfKS13q6Uut399/eAvwPXKaXsQDFwdbnE2EIIIYQQQvhN69Zw6NCpXgtxumvVChISTvVaCCHE6U2dzrGbPn366Pj4+FO9GkIIIYQQ4k9EKTipt7iqqhSfnOSVEDV10vcTIYQ4jSil1mut+/zRfP7oniaEEEIIIYQQQgghzjASNBJCCCGEEEIIIYQQlUjQSAghhBBCCCGEEEJUIkEjIYQQQgghhBBCCFGJBI2EEEIIIYQQQgghRCUSNBJCCCGEEEIIIYQQlUjQSAghhBBCCCGEEEJUIkEjIYQQQgghhBBCCFGJBI2EEEIIIYQQQgghRCUSNBJCCCGEEEIIIYQQlUjQSAghhBBCCCGEEEJUEnCqV0AIIYQQojZat4ZDh071WojTjVKVp7VqBQkJdbCwmBhIS6s8TQghhPiTk6CREEIIIf7UDh0CrU/iAquKRnic1BUR1VGq6k1xrE1XK6mpvguQ/UAIIcQZQrqnCSGEEEIIIYQQQohKJGgkhBBCCCFEDThdTpwu56leDSGEEKLO+SVopJQaqZTarZTap5R6uIq/T1RKbXH/rFZK9fDHcoUQQgghhDjZAp4KoOGLDU/1agghhBB1rtZBI6WUFXgbGAV0ASYopbpUmO0gMERr3R14CvigtssVQgghhBDiVHFp16leBSGEEKLO+aOlUT9gn9b6gNa6FPgSuLz8DFrr1VrrbPfb34DmfliuEEIIIYQQp4TD5TjVqyCEEELUOX8EjZoBieXeJ7mnVedm4Mfq/qiUulUpFa+Uik9PT/fD6gkhhBBCCOFfEjQSQgjxV+CPoFFVg5dWOc6oUuoCTNDooeoK01p/oLXuo7XuEx0d7YfVE0IIIYQQwr8kaCSEEOKvIMAPZSQBLcq9bw6kVJxJKdUdmAmM0lpn+mG5QgghhBBCCCGEEKKO+KOl0Tqgg1KqjVIqCBgPzCs/g1KqJTAXmKS13uOHZQohhBBCCHHSaV1lg3r/sOfDmuthz3t1twwhhBCiBmrd0khr7VBKTQEWAlbgI631dqXU7e6/vwc8DjQC3lFKATi01n1qu2whhBBCiJMuJgbS0qqeLs54JY6Suit8zfWQsgAOfwORHSD2orpblhBCCHEc/NE9Da31D8APFaa9V+71ZGCyP5YlhBBCCHFKpaaa38qd1rEuW56I006eLa9uCi5Jh5QfwFUKlMLOlyRoJIQQ4pTzR/c0IYQQQggh/hLqLGh06EtQ1rL3aUvrZjlCCCFEDUjQSAghhBBCiONUZ0Gjg5+Cs6jsvSWobpYjhBBC1IAEjYQQQgghhKjO/v+DdVPAXgD4Bo3sTrt/lqE15O7wneYo8E/ZQgghRC34JaeREEIIIYQQZ5zk+RA/BbQDCg/C0AU+QaP80nwahjas/XKKEgF3bqzQplCaA87i2pcrhBBC1JK0NBJCCCGEEKIqW54wXcZcpZD6K+Db0shvXdVyt5vuaI36wuWH4eJ1vvmNhBBCiFNEgkZCCCGEEEJUlLsD8naWm+AC6iholL8XnCXQ7XFQFghvISOnCSGEOC1I0EgIIYQQQoiKUn4E7Sp77yoFINeW652UW5Jb8VMnJnsLWAIhdpgJGgVEQLtb/FO2EEIIUQsSNBJCCCGEEKKi1F/AZas0Obs42/vafy2NdkPDXqa1EZjAUfRg/5QthBBC1IIEjYQQQgghhKgoK9787j8TLt0Ooc0AyCjK8M7it6CRLQMa9ABLcNm0YD8k2BZCCCFqSUZPE0IIIYQQojxHIZRmQ1RPaDUBLAHQ9WEAskqyvLP5LWhUmgtRPSAgtNw6FENQkH/KF0IIIU6QBI2EEEIIIYQoL283BIRBl2mm9Y/FCm1vAiCzKLNsNn8FjRz50OBs32lK+adsIYQQohake5oQQgghhBDl5e8DjRnBzGI101x2AI4WHvXOllOSU/tlaQ2OIghp6ju9fFc1IYQQ4hSRoJEQ/nTkZ1h1LWStP9VrIoQQ4s+i/Ahd4vRgS4egKAgIL5tmDQF8cxplFGdU/GTNOfJNYCow0ne6VYJGQgghTj3pnib+8lq3hkOH/FXaCPePONO0agUJCad6LYQQZ5SiFPh1mGnV0u8DaHfDqV4j4VGSDvXam9HM3MEiTxAnu6Rs9LSsoqyqPl0zpdmggkx3OCGEEOI045eWRkqpkUqp3UqpfUqph6v4eyel1BqllE0p9aA/limEvxw6ZFqG1+rHpdHzz0Z/oczPrMDq542JRaN8f2Jia78O8lOnP/4LLAoh/mxmbphJ2DN18EC/9hbI3wvaDvF3+r98ceKKkyHyLLBUnYg6Msi0CiofQDphtiwIjKh9OUIIIUQdqHXQSCllBd4GRgFdgAlKqS4VZssC7gFeru3yhDgtZW+EwoNl77XD+7KgtICMwnLN19PSKn++qmlCCCFOC/P3zKfYUezfQjPWQtrSsuuFO1+OOE0Up0JITFkrowoahjYE/JTTyJEPgVHgKq19WUIIIYSf+aOlUT9gn9b6gNa6FPgSuLz8DFrro1rrdYDcEYkzU/J8c8MfEmuG5i2Xl6D5q82Jfjm6VsXnFOfgcDr+eEYhhBDHZXXiah5Y+MBxzesJGDldTv+tQMIXpuuTh5Zz/GmlJA1Cm4HyvVW2OWwARIVGAZBdfGItjVLyU1AzFFpr0E4Iqg8u2QeEEEKcfvwRNGoGJJZ7n+SeJsRfR/L35qZv2FIY8BEM+sr7J5vTVuvio16M4rrvrqt1OUIIIYz7frqPV3979bjmTS9MByCt0I+tQpO+A1ww4GO4bBdEdvJf2aL2SjMhtGmlyXm2PAAigkx3sszizBMqfm/m3rLPaxeowBNcUSGEEKJu+SNopKqYpk+4MKVuVUrFK6Xi09PTa7FaQpwkLifkbIO2N5haSWsIRA/2/rnEUVL9Z4+nePeoOn7vGiGEEH9hNTk3e4JFKfkp/lm4LQtKjkCrq6HllRDRHgb91z9liz+kNSxdCnPnQkl1u4G9AEKaVJp8MMd0RV+VuAqAXFvuCa1Dcn4yAEl5SabSSVmoxe2zEEIIUWf8ETRKAlqUe98cOOG7Kq31B1rrPlrrPtHRtevSI8RJUZxkbvba3lyWyNJaOWFqqdOdqyAmpnIZVU1z89RwZxadWG2mEEKIyrKKzahX+bb8P5zXc/5Nzkv208LjzXWi+1NmSHeLFSLa+ads8YfefRcuvRSuuw7GjjVBpEq0E4IaVJq8P2s/UFahc6KScpMASMxNdLc0qlAHOzcWZimYZa3VcoQQQoja8kfQaB3QQSnVRikVBIwH5vmhXCH+HIqSTeuihueUTbNUPrS8Dxupqb53qFqbadVIzDO9Pz21kkIIIWrPE5D3nGOPxdPN2G/n4cJDJvFxWLk6t2oSLgv/e/BBKCqCwkJYvrxyvAZwB3IqB2yOFh6tNK3UUfME1p79LjEv0VQ8VYxclXi6QtYuOCWEEELUVq2DRlprBzAFWAjsBGZrrbcrpW5XSt0OoJSKVUolAfcDjymlkpRSkdWXKsSfSHGy6VpQxagn5Wsik/KSTqj4w7mHAUgrqJBLw1kKBz6Bve+bZvRCCCGOW6n7nJ2Y+8dBI4+azHtMhYdNRUP5nHcWyWlzspSUgNUKISEmcFQ1Z5VBo4yijErTjhQcqfE67MncA0BCToJZjnZSdcYHIYQQ4tQK8EchWusfgB8qTHuv3OtUTLc1Ic48RckQGmNqJSsoXyN5okEjz0NKob3cna12warxcGQhoOHAxzBidTXVpUIIIarzRy2Nyndf25u11z8LLdgH9dqDNdQ/5YnjUuqu22nSBLZuhfr14bLLjvPDc2OhJI3MKnKhp+Sn0KpBqxqty7aj2wDYmLoRul9iRmCVa7gQQojTkD+6pwnx11Z4yCTLVJVjsOUDRScaNNqfvd/7Wnuar+96zQSMnEXgLIaczXKzKYQQx6nYXjawwKGcQ75/1BpKc7wVAeWTX29P337Cy/wt8TcOZpskyhQkQERbsAadcHmi5lauNL+//NIEjIKC4Ouvq5vb0/rHzd1dLKuK3mIn0tIopcDsV1vStpiWRvbcKls2CSGEEKeaBI2EqK3iFAhtDgGVa4zLB4rKB39qwlMbCZBT4n6Q2fE8uEqg66PQ43lkxBUhhDiGomRI+h4KTNCm/Ll5d+busvlKc+GnPjCnCXzbHPL3++Qx8gyTfiLO/ehcznnfnfuuJFUSX58CGzea3/37m4ARVJmC0FAWcDkqTc6pImhUqft4BdYZVpq90sz73lMBZFEW0yI5sB6UZoMl+A//ByGEEOJk80v3NCH+0lylEBJdZQ1h+QcTT/6CmtqStsX7OjEvkaj87SYPRp93oc21gIKGPU+obCGEOOOlr4YlI01rTJcDrszy6ZK2NW2reaFdsPh8yNsN2m5alizsT8pZrwMQFRJFdkl2rVYlz5ZnXjhtEBpbq7JEzW13NxRzlmtAVK9eNTMrK9hzKk3OdlaeNb0o/ZjLdeHytiwCyLXlAtAgpAFZxVnowCiUoxCpABJCCHE6kpZGQtSWy15t7WBCToL39c6MnSdUfGZxJiEBZlSdxNxEOPIzBEdDm0kQEGZaODUedEJlCyHEGa04DZaMAEc+2PNMl15rsE9C612Zu8yLxLlQcAAiO0LvN6HpMHAUeoP/zSNNasbyXduOV3axCTZpT1BAOyXx9Smw030Zjog4jpkDI6Ck8khpTd31Qxe2vpCOjToC0Kxes0rzeeiKo6JRlquwcVhjADKcLnDZwFFuUIuQmONYSSGEEKLuSdBIiFpT+NQOzo2FWQpmWb1JU4OtwaQWpNa4ZLvTDkDzeuZh5XDuYcheD62u9J1RkqkKIURlO14AlxPOeRnG5cKA/wPKRqVsGtEUcD/Y73wFwlvC8JXQ8W4471toOpyDOaZLW2yEaRlUvrtaVb7Y8gVqhm+OufKVBiaIUGE493LXDVF3Dh6swcxBjUz38wo86QMfHPggf+v4N8B3pNSKyrc4drpMMyVPSzfP/pdYmAVosJclXWdsze8ZhBBCiLogQSMhassSYLqoeZR4chu4SMhOAKBdQ5O7whMEOl6eBKyeWsyEnATI3QnRQ3xzKFnkQUMIIXxoDQc+hA63Q4fbIDASWo4DyroLt6zfEoDsojTIioeeL4I1zHw+IAz6vu3tvlbqMOf5SomzK1i4f6Eps7isK9vO9LKgUUp+igkYlc+XU+66IepOQcEfz+MVEmNyYXkCQu6WP56cRmGBYUQGRwLluh1WYUf6Du9rT+tjTyAprl4cAIl5SWa/Kz52QFIIIYQ4FSRoJERtWYJME3ZdOdGB52YxJc8Ef2o6XLOnNjwk0HRP25K2BYqToH7n2qyxEEKc+QoTzAN/t0chwN0fKSAcgK1HTSBIYZqNpCYvg6AoiB3mG4QPbMCGIxsAWJO0BoDvdn13zMVuTt0MwPoj68umpW32vt6ZsdMEjRw1iWAIf3BWkY+oWqFNzbXdWWLeu1v+5LqDRuFB4YQFmgCjJ0dRVcoHjTwtzuJT4oGya/zmtM0mGXb21hqsoBBCCHFySNBIiNoKjYOiJHD45rlwucChTU1yjs0k01xxaEWNip6zcw4ASxOWuj+/1ORQCmlSu3UWQogzXfZmiOxcZc45z6iUG1JNQGjHvq8gslNZgMBLYXPaACh1tygtn6uuKluOmsEL1iWv8077Pel37+ud6TshIBKKEit9Vvhfan4qRfYiwDQ+O25hzSB/j29LYiC/XEuj8EAThMwoyqi2mPLBQ08A6Ye9PwCwKnEVAPN2z4PA+pCzGRxFNVhJIYQQou5J0EicWrGxJkFAxZ/YOhpVpqrl1VZ4K3dLI3dXA3cT9t1V9ETblbHr+NdLKXbNfgfA+9DidJaYGmolAx8KIcQx5W6Heh2oakQqp7tlaKnTBATs+fshop0ZZr0chzWk0mcTchOqXaTNYfO+/nHfj97Xa1PWel9vTN0IYc0hf2+lrk/Cv7TWNH21KX3/0xcAa016cgdHQ94+qLAPFHhaGgWWtTTKKs6qtpjViau9rz2BxIqj8CXlJUFwY8jeZCqGhBBCiNOIBI3EqZWWVrPpdbW82ghrZoJGnocNdxP2TbbKs+7P3l+j9ToY5nvzaNegtcu3K5wkUBXir+tkB95PI13f7srKQyurn6E0x3Qxsvg+9JdPTOyRX5xhchgp3/NoVYH+Yw1q4GnBZFVWVhw2LUs9o611aNgBcAcO6rWDwkOVuj4J/9qXtQ8oyykVWpMxI4Ibgz0bHIU+k4vKdU8LDzItjcrnrypPa83BnIPUC6oHwLoUEzQqcfi2aMstyYX6XSB7o+nyDiaBuxBCCHEakKCROLViqqldrW56XS2vGrt3wwMPwN//Ds89B+npVcwU2hwK9pXd6Lmlue/3LMpCgMW0DMoorKYJezXrdbSeaQkVGhCKQmGKtEBpZtlMkkBViL+ukx14P03szdzLjowdvLDqhepn0k53y0z3e3eAfevX7QFzbvZ0L8qx5VcZjC/6/mwAokKiGNF2BAAhAZVbH3l4ctV0je4KQGZRprfF0YHsAwBsS98GEW1N/hppVVKnPEnJNRqbw0aLFjX4cL32JgB75GefpOVF7oZr5bunVWw55OHpjpZfakZFO5R7CIfT4R1tzZNIu9RVCvW7mf5zKQtM/3andFMTQghxepCg0V9ZVTXUJ7t2OjXVN8mA1uYntY5qXataXjVefx0GDYLCQvN740Zo2LWK76zzQCjIgqz1Pp8Pdj+o3N33bmZfORuAiOCIY69XhXULjzYjqzx9wdO0jWoLQGlwI8jbXTbfn7xbQ3o6LFkC69bVMEmp+GOnwzEu6lZNAu9nUKuk2dvNOXX+3vnVzxQYAaVZ4O6C5gmwK5dpBtq7aW+evehZABzWMPN3l++8R93npMEtBzPr77MA3y5oFX257UsA7O5g0ML9C/n14K9AWZc4gDRXIOTtAGtQ5UJqq6rtbLWeMdu+Jj7b8pn39erE1Zx1lnldUjF1VVUiO5n8QjueM/uFs5RSDZ7wUWhAqLd7Wr4tv8oiftr3U6Vpiw8sBqBhSEMWTVqEBQsu7cJVrx1Yg2HrDMBpulcK/ytOgwOfwp53IOP3P55fiD+JfFt+jUdpFpXZHDYin4tkd+buP575L0SCRn9lVdVEn+G108dryxZ49ln47Td4+WW4/3748EOwplfx/XhSGeyfCfay0XAS3OftNlFtaNewHVB1t4hj8dRe3tnvTnrG9gQgJzAW0leDO8+RT7cGZwmkLob9/wdJ34O9+mGAT7XMTBg1CoYPh1mz4JVXoHlzKJLK1WOrSSCoro5xlxOSF8DaO2Dl1bD9ecivpuulqFt1HHgf+vFQhn823C9l+VP5FkaHcg5VPVNEe8jfV5Zvzi3R/bZPXB/GdxsPwMaiEsjbW9Zi1B2MT3HHeZrWa0qDkAYAZBZnoqupcFiZaLrLeUbJ+mjjR2xK3QSYLmue0dpW5mSYVkZHFvm/tVFVx7irmpaoZ/g1f23yWhqFNgJgwd4FnG0ajvlUUBQXV/FBMN0VgxtBzlY48Ank7SDfZW6cg6xBKKUIDwpHobwtiSr6Lfm3StO+3/M9ALH1YunXrB+NwxsDkBEYCy4b5G6DbxrBosEn9D+LamgXrJ8KP58LeTvBlgHbTdD4rxhQPW1JZdcJOVp4lMjnIxk3e9yxZzyDKo/qylfbvyK/NJ+XV718wmVkFWd5R8c8U0jQ6ExTmAirr4OFA+DXi2HhQFg10eROqKiqmui66hb2J/PWWzBpEsTFQYS7cVC9elT9/WjgSAAc/BSKDntzVOxzPwdEh0cTHRYNHDsXRkVF9iKK7EUEW4MJCQihRX3Trv6wtTEcnl3pQQiA+Z0hcz0ERpptvnCATyDrdKE1jBgBffvC6tUmYPTBB6Y1V1hYDQpylpgA2ZobYflYWHcXpC3xPkTbbGD/K1e61MUxbsuCn3pB8vdw1p3Q83mTiyMwsnblngJ798J998Fll5mfqVPNtDpxOtyoVRdggirX62jhUZYdWsbiA4uPmej3ZDuQfYD80nw6NuoIwGebP6t6xqieprVGhUDQIfc5oXlkc29AYWV+HrpgX1mgfWwqXKNJdM/brF4zrBYrEUERuLSryu8jz5aHw+V7Xt5wZAMW963W5F6TGdzSBAIyguNM65X195qgkaO6yMUJqOoYt1Rzu1fD84HNBrt2QXw87Nv352gdmlNiRi99e+3bdOtmph05Un0czUfDPuZ3/J3w4znkuUxvxyB3C7GwwDAsyuIdna0il9Ms5OJ2F9O/WX/A7CcATcLNKKieffBwqQNUoPmgo0J3SVF7+943LcIv2QRnPwFdH4VBX5yadcndCQe/gH0fwOGvoaT60fdOF1rraoPlXqfDde4UyCjKIOTpEG9Ou1PhldWvAPC/Pf+rdB3y8Rft0l4Tdy64E4CZG2d6B8uoqUYvNqLV662qbYX6Z+SXoJFSaqRSardSap9S6uEq/q6UUm+6/75FKdXLH8v90yjNhaR55uH2wKeQ+ktZc3l/KkyERYOg3c1w0S8w+Cu4aBGc+39mhK+KqnqAqKtuYX8yu3dDv35VBDCq6UbGZU+YEc0WD4VV1wBw0H3Ojg6LpnGYqUnMteUe+2ReTmKuGY7ZU7vdrF4zANY6wsy2TltqHjQ8+1JYSxgZD53uhZZ/hw63wci1povGaWbtWtOiaNo08x1HRpqf6OgaFFJ4COZ3MTckfd+G876Bsx/nYG4frp2kuOoqeOop+Ne/YORIyD9Tzts1OW7r4hjfNA3iLoFer0CDsyGijXkfUpONZ+QU55BTnFO79TlB774LN90Et94K8+aZn8mToWHDU7I6p6VnVjzjff3CymPkDjrJ7v3xXqCshdHTK56uesb6ncGeCwn/NS0zx6bC+FL2uANBMeEx3kBQqkOjrSGw8+WyxMdOGwc8wX934N+TgyYlP6XS4nalm6TZTcOb8o+B/wBMN7WDuQcBeHDgg1zV9SoAtmXsgoa9oDABfrkQ4qec+BdSUVXHvdNZuTt2Dc4HTic88ohpHbpyJSQnw4IFkFOTw/cUPVB6ugWWOEuIO9t0N7j6atNFragIHn30WOt8kU8idU/QyJPXKjww/JhBowM5Jo/V9KHTmdLPbGNPcnXPNd0TPErMS4IG3SqUoP70XdCB0yOYsOMl6PmcqeCwhoDFCgHu+6MTaK35R/GTKpXmwuKLYM/bprIl5kIIagStu5767+cY2+hg9kEsT1q46NOL6n496urZpA5bMN3w3Q3YnDbGfDmm5h/WGjLXwabHIP4+87NlBuRU0T11+vQqt1Hh9Ed4cfWL3gqKL7YcIxj6F+3SfrwWH1hMob2Qtg1MSpAPN3xY4zJWHV7lff3simf9tm6nWq3H7VZKWYG3geFAErBOKTVPa72j3GyjgA7un/7Au+7fZzatYdM/oSQduk4zQ+xql6n5dBSA9cSfTjZvNjl3YmKgvcnpSYeCNzhv8JVYGvevNETs8XI6YcUK2LDBtxauY0cYMMCct202CAw0rXBq9JBfE9Onw4wZvtOeeAKmT/cmkLSoumso16ULrFljWh+Ehx/HB5qPhh3Pgy0dkr4F4IjDrGN0eDSB1kBCA0KxOW2kFqTSPLL5HxaZmJeIQtEozNRCem4sF+SXcFeQhpXjoN9/INCMykLT4Wa7e7a9JdD8nAb27zcPGiUl5rDYtg3q1wdHhfhZjYZDXn8fdJoKrcZ7/+e80hgGnGdyJDVvbrady2X22Yg6iJ25XPDee7B+PbRrBw0aQG6uqYHv1QvuuKP6Cv7Tidam5cDq1WabeO7XWrY0AbfI8o2I0n6FAR9CgPvAmBvrzv9igWuOv2Y8MTeRlq+3BGD/Pfu9ObtOhsJC06ooNdVsM4+uXTGB2LTfoSjRPRy6MiMkNh5Q9j+fCM9Nr3InOzuRJ45jnBdrpYp125m+kzff6eKd5cXVL3Jr71u9XW3rQmJuIhd8cgGvXPwKl3e8vNr5PKOSudzJ/23OshxDyxOWE38knqkDpqIsgSagufEf0LgfRLSDkjQO2EGhvOfUqJAoiuxFHI0eSeyet6FRf2hxBeTuJMFhgrWXjhgAACAASURBVASewH/D0IYcyT9Ccn4yZ8ec7bNe8UdMEuxRHUbx4vAXeS/+PfJL870BhRaRLWhV31TgbDiyAQZdY4ZYz/zd/JzGnnvO7Cbffw8hIeZcbbebe4FaKygo2/c8/LFfu13R6Qo2p27mQM4BdhesBTqyYQP07GnuYVavhldfrebDTUfB5rKoUp77vsgTNAoLDEMpRamzFJd2Vbov2ZdtRm9rVb+VN9fIwRwTRPTcBzSt1xQw13za3gDZW8DpDlxagut0ZD273XQVLy2F4GBo3LiG1+G6EhtbueVDTEztggeuErCWGz7Pe+2q5lxcxfl23vhZfKkmcPbZ5vpos8GmTaaCqn7941iH9fdB7AXm3sVzPanXnrJs/acfu3LR631T178kYQk/7fuJke1HVj2zP65zfzKzt89mwd4F1A+uz/7s/bz5+5vc0/+e4/uw1rDyKqjfFbpNc09UphVqxXMimH3Sc14s9x3fMHsc7Cy7Jk7+fjKTuk/CUtUNaF1to6ruT6Bm5/K6OO5r6PpvrwfKAv73/3w/d/S947g/73K5uPSLSwHzDPj8queZ0G0C3WO7+39lT7JaB42AfsA+rfUBAKXUl8DlQPmg0eXAp9q0a/xNKdVAKdVUa33ED8uvc1pr0grTiAmPQVV1EFcnb5dpXXRlhWanjQfUan0KCky3nqwsc3H3DCFburUFKm9tWbelE3iY69XLHN93320erAAOHoR77zWtQvr1M8uz201rnIAAiIqq1b9TNc+JsdxJzeVy8caa17j/5/sB+PLvX3J1t6vrYOEwZQoMGQK33WaCDxER5vuoNvDQoDtEdoDszYA2FQdOsFqs3hrq+iH1SS9MJykv6fiCRu6WRjHhJvrfJLwJFmXhYE4SDLoT9rwJa64t+0DWhrLXW6bDNnPyztChXGnvx4YjG/jP6P8wrsu4qi8kdeT2280+MmOGucFyuUxwskMH2LMHOncua9FVWHicQTowLbu0q+yCNzeWpH0NsbKejh1DvTe+VqufHmyq8OyzcOiQCRwpZY4Hh6Ms52ytVHXxhDq5gF51lTm2p0415xcw/0toaBUPELHDIXk+RPWq0Iqtmr4eVdxI7H7iLjqpt73v273Zjk23baJHbI8qi7A77Xyy+RNySnK4s++d3uSzJ8piMT92u9kXPf+jM+lHrDufhcGzIXqg6TakAk2NtDoNnqSqOC/WlaeXV26988yKZ/jo8o/qZHmzts5i4tyJAIz5cgz39r+X10e+Xmm+pLwkcm25hAaEcvi+w9z94918ud0kn75rwV28E/8OYJrqr71lLc26PQ5HBsFPfSCyM+TvIaVcQB+gUVgjkvOT2Rh1AaPS5sGqqyAoCkpzzLyUBY085/OqWhotP7QcwLsft2nQhi1Ht6C1pn5wfYIDgmnVoBUWZWFP5h5oPQE2T/MtJCSGDUc2MHrWaBqGNmTehHm0iWpTy2+39rZtg969zbnUc7zU+Lxa/rxV1T7sx/3adB9siFVZ+Xrc18zcMJPbF9zO/D3zgUmEhZmuqHv3miBYtep3MqOaZa0DIE8HgkUTFmDOQeFB4ThdTgKtgRSUFnhbooHpslJkLyLAEkBMRAwOlwOLsnhzFTaNMMGilpEmeJ6QkwDn/Aviyz1wxl1c6++iKitXmnyNN98MPXqYgFFRkQkehYb+8edr7I+2fS1prSm2FxMWdIxrQ9ubYMeLMOAjk6/qj1Q43/7+m+bBSea+pXzAtKTkD/ah8mzp0Li/uX+Bsvv0Vy1wjfa9cTjZAZdqttGFH51HjjtXG8CoL0aR8Y8Mb4Xmn0YdBEscLgfXzjX34bm2XADu/eleJveafHz3KcXJpifKeV+XTavhs5vD5eCHvT8ApmLiaOFRbE4biw4s4uL2tTx/HOM7c7gcZBdne6+jJ/P+pK6kFaSRUmCu7SPbjWTpoaWUOErYeGQj5zQ957jK+GjjR+SWmn3B08jhrh/uYsWNy6A0xzQa8YzsGlgPAhv44YHh5PBH0KgZkFjufRKVWxFVNU8zoMZBo7UvXUbPq+7G6m7WC3Dgp7fo0MFquqiU0//JGNbqo973AcrKq90u4OZgWMe7JCUHU2pXRNZzsSJhDMPPH8nI7qZr0fyDy1i8ehVvZf230jossIxjyBWXEBLXxztt16ZU0tbNYeCE8WUb3+UgOa01rfd8iKXdRJTLDtuf4/cln7DAFcot4z4gLqIJBaVFzNoznyvsW2gY2Zn9+kbWbQjDatF0apXMw48E8tLMnihV1sq8S5s0fvwxhr/9zUJurkJrsDW+g8Qf/kcvy32obg+j3AfsWwtvJyRpHaOGHiHA6gKlKC5ykrPyObrd9J53J3BmbcOWF0NwUEO0tuCp+dixQ6O1YtQoc3F0OMzFcu9emPdNFpPH/E6gzgZcuFzQIvE6GJdb1gIG+HaOg51LFjJpooOgIPMVOZ2KvT++R79r7yKk3DqsX7SeppZfibvoH3ge00rSNxL6jm+vxvFzxvPgB99w3qEXePKhwwQ7k1G6FJelHrfNGMllYyIY0X8boUXxuCxh7D7UhFYlb9Huiunecp1Z24BuzFt8P5f2ugmAZcnryMnYyJNXRXPuuY8yZgy0bWshfp2T+y96hN7ntyas9XneMvZv2s3k28J4/7V3aJ9zEUoXk0E4DopQLgdRtjScWdk0DArHmeEgbPbdOG/4P591WP7ZbHr2CiKy6xjv9N0Jq9Fo4oLCcGZto5EjDwUk/HwJ/9p/C9POX0JIySaUdlJibcWPy/txecBoLD2eQrWfjG4xhgmvX8pXlhRgmfc7Gz9nPFMCWjDx0kfp23IQDpeD2Xt/onFKEgGJzXC0uhFlsaK1AlxkL5vOpbdcTHC9sujgh/PncIiV3HnJ80SHNmRH1n6+2D2ffzn2sdU+nSxHV1wEoJRm14ZSLh8fR2CglaIis08FBMBXjz/PqJEPMHWqlXMHWsjL03z01QfsP3saOrwRkUER5NjyCA0I4YWczgwa8zeCm/b1rsN2x1RiVl1LY6xY2pqHzc7NdnJZ10+54/bJPPW0hUaNFErBou8OMuPpEGbNjfEeR0rB008pYmLs3DB2D6FF69EqgK2ZjVi4606mXP02beu3IL+0kM93fQ88zexX53D+kBCsAaBRtIkI5+ed/cnLCyYoSHkDEDNnmuDLVZceJqxwOQpNoqsLFy/tR36F4MqLAQ/RgFG079fb51o7uDCLis9kKwcP5KyH+tAoa5t3P3FkbmXCOyMYPnASw9oNo9BexJx9i4jbFcLodoU0GTzFZ1/L/GkKm5hBseUsNFaU0qQdtBE8KA6weo97rcG6ZjyZkZNYua0b2TlWgoM0RXlTuDD4alqVZKA6TkENXwHfn8Wh91vQaqLvhW97286EPdqelplbsTYyrTJKjm6g0zuVeyj3fWoCd6S/wD8eVAQFmXTBWsPF825lE2UP6P9Y9A/6OLrxWdNGdBj/lk8Z05+Non59GDtiP4GlhwEr2zMUN2+5gSOUYrVYcbocRAXXZ/q9DzHswgd449+B9O1rzqH7f0+mW1R9rKFNzcV9+/Ow8wX+vegBcls/zcQRKwh0pAKa9NIQvv3tIa656hU6NDoLl3YxZ9/P7Fq2nubNC7j+4mewKAsHchNZkrSWvqt/oNukl73b1Jm1jcXfbGfDnjYMvLS7Tz3zlCmKl58+Qqcm67E489AqhO2bcukSt4VmF9zpsz3Xvv8gva66i+By035eEsGsWVYeejSMyOKlWJz5lIR05+APrzBowhWElZt3y8odROV9TYtLnvCWm56yitnuUcAO3bgYu8tB+09G8sXC7aS9eZhnX44lsmQFgfYkisIGULzjEw4Wnoe10Tnu4JomORnmflPMuy/tJ9iVhlJOXK4Apr8zlBbtG3H9JSsJtCehsTI/4TB3HvANnrzx+xs41mzggj4dGDNoKgBbM/bw9LIPADgv7hyibKmMbt7LGzTyBIwAUgpSaP5CB3p8u5v5rz1CXNazWHI24yCUdKcFpTSN7Nk4s7YRExSOS7u4bdwFLH79ddrn3oelNBuXCiPNXgJKE+WdNwSNptOP72GPbuuzPZfvWowC2gcF48zaRtcGzdlydAugiQ2uhzNrG81dhSggY1N/briukGdue4qmaY+CtlMcEEfU1sPYt/b2/g9t32zLaNcghsY5uH3sOwRbg8i15fPNvp+5Ku8niJ3M6v0XkZ4ZQHCQJtK1gS4hn9Di0id99pMV779A39EXUT4m7zw0B+eWZ1H9P2TJygakpAZwztkl9FCP4qzXnRWJ15CUHEBAAEy+/DB3PtyJli2jGDPGQmAgFBZq3nx/PJ06RzHmXNP1av3R7fyy+Xfsh/7H5Gs+JCasMXanndl7f6LeihQuGBxHvc6jveuWtfc3kr+7ky43f+qzvonX3k3rH5f67BNHIqy8/1Askya8S+uoNmitmbt/EaOH/YvQfN/uYb90AdB0jmoFOTs5J8I0Kax/ZB4A48dmMuubKEpLFc3jSrni6bb07jGSi9pdRIG9iAUJyynZeimuXQOZdvvjtMq+GnCSFtgVp2sDodqBM2sbAVrj0i4uzupF7rwphF/0T+//sW3/ArR20Sg4Ep29gxiX03RtcwRRZC2hkS7BmbWNJhZzr/b1U0PpflhzebOrqZ/7FWAhRY+m+YoryWv1JL8sDycn10qHtqX8suFm+gzozchzbgBgZcoGcjM3ck7CZraG/ofi0jA0Fiw4id97C30GtOLy/iZPx2+pm3npnaa0aH4ho0ebQJHTabrmvvDmBLp0rMflA03gakvGbhZuXoPtwByuH/8fWtSLpdS9PSNXHmXouY2I7FrWJaegwMKwUQ348EM7DZzrsThzcVkj2bJqP/16FdGo15Xe78eevgXa9iawwLfJ8YrzB9Hpo2toOOAm73XDmbmV4W+dT+hH59Kn6Tlk2/LYnX2QxkeCmWVf4vP5IBXIJT/N45ZpQ4iNC/Re71cte4ihXEaXkjFYzroFNeATWGpazNgOfO9zDt3wy0ZiXT8RN3yad32bR+7CWRzNhg1RdOmiKCw09xch+avI2vJ/xJc8Rk5eEE6XwmpxMjDkPpLUlRxxnIcLK0pBTvK/uOLQNdS3RmBpeYV3nZftHEyfzTN9js/D6xbz0VvJnD/x7+6KPrOfZK94kgsvbUZE+wu98yYlB3DtjRG8966LiNINWJ05OK0N+XDJl3TuFsJV59/v3Z7L9u7ni4euYeZnTYiwbya4ZDu2kC7sWLaKAX0KaNjjCu//vHT9J97k/k8OuJtfEtewLDme2XMHcVOLgcSXPErCoSBcLkVcUztN9oyj86Q3fZ4rbrvFQbNuPX3qjhwOeGDcV1x07SjqR5WNIJm24X8MbL+cpuff4XM+GDsuhAfvSKBt81ysFo1G8e3qNWSHruGuy1+lXlA4ifmpfLN3IVlrFjHioqs5r9NoAH5MWEHWhqMMCd9J84sf8yn3xlsjGTayHn37uIjIX4gzoDFrDg7nzX8rPvh3OvVty7E4c7EHteXeZ89j6PlOxg5aSoAjFa2CeGnzIuwuO90atueNoY/w5O/vsCw5nn88PZQLBvThCvcxtzJlA8u3ZbH6rUv59wuJhKijWJQLl9NCaspIem54DOvZD6GUFbRmT3ZDXswN4J6939G1UXuySnL5ZOd3tIkv5sJBTYnscrn3//jk1+cpchTRpWE7tkz8jg+3z+G2X6cTfMM9sGqPz7HhsFjY9VQ3Ok2e6bONsrb+wOYtFmxxE1GWALOraRcxe66g+/Uv+FznHvxsBq/nfONTboCysipwID0n/ougcvN+NPdz0vUK7hxtttG+nMN8vXchU0tWsMvyDPszu+FwmvtQdXQFg94cTtywh7zHvSNjC/969zqGrXqKoZ3N8bLw0Co2/bYFm3MVU8a+TcOQ+qQVZfDlnh/57Z2buWREYwb2ziSscDUuSzhrky7hxVfD+OB9Ow2KFxHgOEpJaA/++dw5DOhXyrghywh0HEETyBObzfXhyvYj+HLUSzy+5t88G/8BrqvHwwrf7zK5UVPyH21Dh+vf905zaRfTFpj7lVkXv0TvJl3o+NmlRB/ZZLqhD1sKwWW9jJa+9wo9utmI7PK3sjLsxWyf9QhHmr+PyxKBRqHQZG2ew9ABacT2GuWzHrs+u5POk95GBZVV4q6es4iOLRJp1O8mn3mLD68m/tddDL2/uqa1x6b+MKnZHxWg1DjgYq31ZPf7SUA/rfXd5eZZADyntV7pfv8L8E+t9foqyrsVuBWgZcuWvQ8dqpDA+e8K5vpOmnvOFVww1UrUwNtAWSDxY0j+DFVFQtNrd48i6eDXPP9KMD16WQkIgPT0UuI+qFxNMLDgLFZH7KHzUTgrE3Y1ht3RULAulPAFvkkrN/XrTs8nQ+Fi90gZ7pYe02+ewvRWb0GfEGgdBw4nj4TZeE6n0qgQpq2Ez7vDpqYQvyqOWxZ9T9vLujBsuAWHA3753wGWbulEdrbvuu0dbSVx/hBWNbgEZ9sOABTvTSI0/yjTOz8JPYD6QD+wWy0Ejt0F9Tp4P188qyWhJJqajdhYE/l8s5B1n1nJ/GkYm5tfiurQHm2xohOTuKTF66zZdBnFvQahIutBSTFtW7zHpZM7YOn2sAkQaQ3ftuDIHitNb5gN9duaabtfJXH1bFr87RVodVW5DeeOpo+3Q5y75c3Pt7Ps6yUMuTjW5GRyr5t+o5AeW+GCTfDQKrBZ4V8XQMOQC3h1op2A/q9Dw7PBEgBzm/LyLVfz4AP/hu79ocm5YC/ityV7GNC/BEas8ZZb+kYhwddqmK54dBkEO+HxC2FoKCzZ1IiE/0bwITdxmFb0Zj3DXllAl2s+MHkO3GVsvL8Dvz53OQ8UzIDOwECwL4I7RobTdG8hT7nvZ2Z3hcWdWvDBuAy4usjne/9hTx8umXQntLvRO33xE/DhgULu/gYGJkFJADwwAqLXjWV6+lwIBS4DgsA538JTuf9iessZ0BuIAXLg2g7N2enM4anZBbTMhVnd4J1+kFtFTWKTd3by8cedGDWqwh9mKbOfeGyZzphv/sP/rBVq2tO60fz7rSS6w8NOh8YaoHDtfpdVU1eydkN3dNezcQUGodMz+GerCWR+24hvuJI1nEt9cnCNncXb3ddWWreCmFDCr/4Norp712HBZ+tIntWbW1s+Be2BcLO/Z8+DpP914xuuJDWkNQFOG7Gxh/nI+jQHD/qW+0abCdx7x1fQbzzEDQeXg48WfcLNWasqrgJM12iXy5xjyu2/KZ/HMf+nyzjScSiu+g1QuTkE5s7h0Qlz4PzupnuMUhzZ/Qtx+9YS5ICGxWZ75oRC51fjefr/ejN2bDXfe7n9ZNnO8xny94EmL4N7evHrhYRVMXDZS5lDePDaztDvXe+8v9/TlWs/+71Ssme94xVW/mMLv63tDO5t5Ew9yoH8YgKGXc/U+y3ENrNgL9U8/piLwUue5JqQp8x5JgLoAyXWYEKu3AXtB5gWUo3CWXN3N8491wojVvkcy5eus9B3s4vpS83ynz0P2gxuwTXjJsA5L/h8v4PjreSUOLl+kzk+v+gOUdbO/JSTBF/5Jqp6v/MYbrvrZ+h/L8QNA+1kyVeTuTC/8ggW++Kh3vxoPmUSezHjcDclmehmGdzV7wvo39Nkv6/3M99/043Rd0RB7+ehQSdAMeujFkxMzaHnEdj4PvzcDi6eBI1cwWRabCz5GIYmwKCbYHVL0B2otD0nvv05Z4+eyMPlMwE6bez85zl0nnApnHUHhDQGp42lz05g6KWtTNfAcmUAcHUxNGttXv98O/9+JYMLgrfT7cJt0HKcOT9nroesX+CKI9Cmp3felXMWMXhIGFy4yFuu/Y1CbltjocsGFw+uMbO+MAiWlF7GxNyzmHT9q+YcoyCrKIroe7MqJUTe9cMntLd+QcCgmRAWZ2rW/teKj5/uyw13/wZ9HoHYwaCdzPvkWh7PPMCrX2kuTIADUTB5NCx1N7DJfAGiSqDTFMgJb8wFtgzu/RoGJENeMDw4HP4zXzPxCsU7P0CkDT7oBa/3jOSqj6YynRnQB+gJehfcc1Y01uR0Xl4EAS5Y1AY+6gUd5zxh5u0O9AX2ws09WxIabOeVV48Q7IRVLeCtfvDfseW2p/u7vOubz7GX5PLKGxnUK4X4OHjqPIiIhcsXw1XuFBWPXQDLkh9kanA4Y7fOgCFAK9DfQfu74NxdcN9vUBQIz5wPO1rUIykon8++hWu3wIwhMH0ovPO/W/jY8TqPPBFA525WbCWw+MMvmXr5BzBsmc9+cjSvEU3GL4FOw73HJ28WsnPWIEYt+Jyi0IZEx1g4dNjCd4OHMGXdN1x1dwyDhwZgt2k2LlrDP4/+nW+/uZDVnEt+QEMauFJ499FplFjhwOvQMhcaPgSBqgGZwTnctAE+nAffdoKx42GR5RyGTXoAWk/0rlvak2HENEivdGzM3dWfsddOgrPu8k5/9XEbD2Q5uHQPzP8vbIyF3rdBwcuBhBX6jnhwIAraZWu+P0tx2R6wW+Cfw2HcOTDoeY2NIF7mQdJpzN2WV2n3eHKlc0ST+Y8z06UYvWEGDARaQ9JCeOhaGL0Yxru354whENXqfO65xfe+JfO1QqbGw9AVcNNGM+9zg2F9t/aEh6fy4nsFxBTCwQbw2IXQ4btpTHc9B4HAlcB+c9g843iBmWn3cMMN0CjawqZt2XzSMhangtSXIMQBDaZBq+UzGNHucT4wcVVKSzVY7UTNCKbICuveh9gCaPEA9Aiw8Nrii9lx6EL02d3RIaHYijL4Z++xKA2ZL0KDEjhrCmRHRJERkk3/RFjxf/B2X5g6CvYsaUqHZb51v5kqikOTW9Hrqjjo8iCEN4VFg/jvpo5MuHac6Zbl/n6crxdhnaIh1/d7X37TeZx/7wXQfYZ3XscbhQTuq7SJuKSwFT+GHaJTuvnfdkZDaj3M9brC481zz0Hnr55gjP1Jcz4IBfqAukWj7YXQvJ33WF7+9a+cP7wRnP+tz35Z9FUIC+eNZFPsSIiLQ9ltbM/WNLnsCt5404rDAU4XZKTD2d0VGRmaoCCFdmmURbFgAaTc9hi3tHoG2uK9bzlQ0IK213wF3a7wHp/zbxzCoz8vYPNm3/9j00sd6TnxdYgb5V237f9sScG2BvS/sgQ6T4XwZjhXjKHe9nyKrbDvDWiXDc2nQjLNeead63jknmfNPasLsMB3B/sxZtKN0OF2b7nbnnbyzO4SJi6Ay/aa8+0/hsOFud15ZvN33DAtjuEjA7BYYd0aJzdEBFc6lmcuuZmd9qeYfE99d8WYwmbT9Dw3rNI2Wvrm4wwdkO5z38KbhRDeGkbvNff4jiJQAQx+qjmrVDqBTmhU5N7ugNKgFayaCakR8PfxcFvmYN4bGwlDF/iUO/3aR5ne4hmYhjnuFMz9dgzd2idw1vAQ6HCHecjP2sZXd67i6ru3Qq/HIboPOG289/51rMg6yLQvbHQ7CgkNzLPJ5+5G05fshnql8NXZMNHRhk8Gt8d63ifmuu5ywLw2TL9+NNMbz4S+VmjVBFwuvouGK2yVW5ovVL0Yce090PZ67/+x/IkA3j2Qy63fwQUJZdvooh4DuGrSBOh4j3de2yulBAfaK22jqFuyWLo6ih4VG3tXcR963a6WfGk5TPcUaJoPW2LhcIMK9zju42jInLdZbqnQ2yarLZ3m/M7sBVF06mKeda0WWD7z3wzrvsK0unIv7+irhcS479s/mwPZoXDPJdCxJJbdIakEOKF5HhyuDy4LPP38Azx61ytwTj1oMgRKsvh+cUP0+sb8bdLHENUWIttAxjr++9YQJty9Cfo8AdF9wVXK++9PZFlmAo99XkqXdEipB9MuggcGdaD7xLeg6Qjvuu1+OI6Oa5Pha98Ki7tvDCM4qYgXF4NFwyc9YHnbOG4I78d5l7SD8BCwrwDbcvZ80JSzKpxDPw68jq+Hf8KCBb5f265HmtLpxsfNPgllPUrmUCkusuz68xgSCry3wvcPE5vB55VH8VZKrdda96n0h4rz+SFodC4wXWt9sfv9NACt9XPl5nkfWKq1/q/7/W5g6B91T+vTp4+Oj4+v1fpV1LUrvPaaGea7fGuwhJwEur/b3Ttsakx4DFvv2FrW7M6PtNa0eK0FyfllNykKC92/tTNlioXx48u6QdWou0519s2EoiSTFDS4sUnGnfApWMPg6sITL3deOzj3U5P/wVUK256BHc+CNRyurjBiV9J8yFgNkZ0gJBYSPoOEz2u/Dj/2NqNgNLvMPMx7u2Up6P6kuUFRAe4HljZmo1fID6AUMN23hcRrI17jvnPvO/H1Os2tTVrL+R+f780FMrTVUL4evZjdu6wUF5flgVTKdNMLCqpcxsHsg9y14C5+T/mdO/rcwQ3tpnHnLeFMmWJyRUREmNrLlBQqX4hOB9oF8ztBz5dMENDT1WpODO9kFXNXSllAYkK3Cfz3ylnohK8AZfa13yebJLsouKZC16zVk8y+3fs1d14pBd82q3L/85fdGbt5bc1rtIlqwx197iAypPJoZtnZ8OSTJg9a27Zl2yg5GUaP9s1d9MMPJk/DihWmZZhH+e5cflVyFNKWAe7A3O+3VP/9VsVpg+9amEEAItqVdT+Y5T62rznBa53LAV8GwpXZEOROgDQ3FltRGg32QwkwrO0wth/dzpGCI1zW4TLm753PiHYjuKbbNdzwvxtQKHIezvHpulKtA5+Y0XTO/7YsJ5m3ufpx/h8HP4fdb8KFP5uRwyyB8G3z2u9/2gU/9TXn0/7/gciO6G9b8OWaCeSc9R6hoeZcoTWc47iLzj0iUT2fA3s+bH8Odjxntu2YRJP81equ269mG3X8d0f2ZO3h1+t+5bxW5xHydAhO7ayya4SnBeGZ6LFfH+OZFc94u+yN+GwEi9ak0OKHTezc/v/t3Xl8VOW9x/HPLwmQKKtsIksSKIiIC4iKAaEKWBYBDQhGzQAAGuNJREFUvW6o7VXRXqxbRa2KegEVqYIXtG4tVZBaQSi1CqIoSBHFggsisouAGrawQ1iykOf+8UxIwsxAQpaZge/79eJF5szhnEN+Z84853ee5/ckkJRUUDtt377iz0CZmelrsV15pR+qZOavBWlpMHcupKQUbCszM/Tw7Dum38ErX71Cas1UaibW5JtN35BSPYV1u9eRUjOFtb9fy93v382LX77I0M5DGfLLIcf8e1iQvoD2r7WnUfVG/DzwZ8YvGs/N795M16ZdmfmbmUHrhzsnwi3fnbWbKUun0KhGI7qkdiE+LvJDUidPhuefhw8+8EOgKlf2sbj9o1/z5ndvUiW+CmbGgdwDnLNlGM02PsqQIX5YfaVKsH8/vLLscYZ+MrTIdnv8ogfv3/h+0P6av9Cc1dtXM+emOaQ1TiPxqUTyXB6JCYkcyD1QZN1vB3wbXKdj5UuwZW5gCNjJJb92FcOBnANUiq9UZvEp7bVj4EC/jVGjfGyc8723+veHq6+GCy/09Y7y8vxonzbFG+VSPPk3Mt+/CunvQMe3IC5wQZhg3LoJxu6Bq8+4mrPqn8WQOUOonVSbjLSuxG37Ci54Cep0gHeaQHzlYn0/OOdrmk6f7ut/5g/NK7MaZ4fLXAOf9YN2L/ji4fFJ8N1QDi55itR18HOhjmpXtfS9sv6x7B9FNjH6V6O5t32INn3uPni3iZ8Vtvb5sH+TnwU5+Xr/HZdfd+qfdeHgfrhivV8WF2gUhfnumvfTPDqO61hk2TcX9ebcGqfChWN8QfSlf4Tlz4S+ZwK27N3CgzMfZPy342lWqxkTr55Iu9OOel9/TFavhsWLAz3M4wvuAXr2LMHQyzDyvyPyDTv9fV57pAdr1vgJavIfOBWuL1nYvTPu5fkFzxdZNqbXGEYtGHVoUgGAtMZpzGvRyMe041u+7WZx/tzO2Q1pf4NGV/qyA1Ob+bpxV24MxDNw4pa2vVgGMjN9+zv/95J/fbriinIaOkzFJo0SgFVAF2A98CVwg3NuaaF1egF3AT3xQ9f+5Jy74GjbLo+k0dy5fjalhx7yF/KEBF8EsGlTn8x5Zt4zVK9SnTvOv6NM93u47IPZJI9OZtNef4H++tqtdO1Qm4yMojdoUS1rG6ybBPvTC6bbzt0HrR6suBm7di7xRU4b9ob6v/RFIzd/AkuHw+VLCopCH6HhYgbDPnmKx/79GAD3t7+fZ3/1bMUcfwQ55xi7cCznNjiX8047rwy36z9TBw74c7lGjfK70JXKntXwURpcuaGgAVDoPNn1Xzt5ZPYjDDhvAGfXP7v4DcuDWTC5Gly1BSrXCNpuJL+MSmLDBn/zOH06JCf77uRm/qYlKuO59yeY3hqu2VFQfyg/iRymUVZsX9zuZ9k5a7BPQr+bClkZ9F4P7x02adLiAYs5+y9Fb6Ra1m7J8ruWF29fmWvh467Q+V0/M11eDkw7HbIyKHZ9uumtoe0o/1QMyu782/QxzL8Feiwq6GIdrpGVlwMbZvgpruMq+8bbgS2wZhxctckvgyPGaOCHA3lu/nMM7jSYzsmd6fJGF1JqpLD23sO6DHJ8J41mr51Nl7914fwG57Pgtws49dlTyViVTIu581m0KK7I5zE7O3SSP5Rx42DsWJgxo+Dh1OLF0KePr9tSnO18t/k7zv5z0fN9+KXDGTpnKNl52bSu15pV21aRfTCbxbcvDioeXhI5B3NIeiqJg+4g+x/dz4MzH+SFL15g1GWjGHjRwKD1S5o0ikZpab6m5HWHlW9cuXUlLV9qWWTZf/r/h/aN25OZCVu3+mt25cpQv0E2dUbWJjOn4PP1070/0bhG46D93fPBPbzwxQsM6TSEixpfRPc3u9OsZjPuT7ufO96/g2qVq7Enew8dG3fk0/6fBv17lgzz1+LzRh+WNCrZRAkVqSzOhw0b/Kywe/f65JCZrxWYn+Tbv9/fjFetWvzPZ1ih6h3eCfxuOLR62O88cF2dub8Kl6VnFVn1luZdGRv/OfRcBCen+vZPCW6WnfPXixUrfHKywkpk5uzxs00ePOBv8ivXxiU1pN8/r2fysslMvGoi/Vr3IzM7kzoj6hx6KNqydkuW3rE0dC3PFc/Dd0Ogw1tQt6P/npp8MnR6FxoFhgzlf0cl1oO+PxbcVxylfbFw40LOG+Pb1tP6TePyFr1g+1ew5fNAvUT8L7PFncWrsRXDNuzZwLSV07ilzS1Ujq/Mxo0wc6a/TuVPyBYf7+vIHv75yMvL47wx57Fo8yIArjrjKqZc64fH5T+QGNltJA+0+TVMax54KFUoAzXBfO/WC/5cMFviBPN1C6/cWPDwqqzaizGowpJGgZ31BJ7DF8QY65x7ysxuB3DO/dl89egXge7APuAW59xRs0HlkTTyxwTLl/sCttnZ/ul6584VP8vRrgO76PZGN/7a+6+kJJ1Dgwb+KUThp/3l9lT/eJO9C/ZvhLws2LUElo+GbnMKLhBHaLiYQV6eo81f2rAnaw+r71ldsoLnEptyMuFfDaD3SqhSLzC08cjnSemTRtHbcA5l61Z/Y7lkScFMdDk58PLLvnBqVHEOZl4MyddBs1sDM5/hE0gJZZDl2rUC1k+H3F1+2wnV2N30NmqMqBMYce4Y1GEQw7sOp8ULLfh++/fUSqzFjgM7ePvat7nyjCuPvo98Wdvhx4l+Zq24Sv7/llANzn2qeDMiTm0G7cdDvcCTzrI6/74Y4JNmbUYee0+u+f39/6HNSA712svZA0nBU/iO+WoMA6YPIN7iiY+LJ/tgNh0adeCzWz8LWjeWEgEltS9nHycPL9rlOMESuG9vNsuWGU89Bampvj3z4Ydwww3F22737j5BNGBAQTsjO9v3RBw/3k+4UZxezzf+80YmLJkA+ELhmx/YTIsXWhyaOQz8bHW5/5tb6kkYGvxfAzZlbiIxIZHs3GzyyGPuzXO5OPnioHWPh6RRr14+Rv37B/fiGPLvITwx9wkA7jz/Tl7s+WKILXjfbPyGtmN8LblJV0/i2jOvDbney1++zJ3v30m8xZMQl0DWwSw6NenEJ7d8wiXjL2HOujkA7Hp4V+iek7n74OMuPmHd/HZ/Y5az299wR6lYOh+A0Emjs4Anz4Iec/31NT7Jx6JSVeqPrE/GvgySEpLYn7ufjD5DqbvrC+gw0T/wPYaHClOm+OF+L74I7dr53+GqVb7nUSTk5eUVubYs2rSINn/xXbo2P7D50EyZQd47E07tCucOL+hVNMH8rLwXvup/jxbnE1Vf3+fP5TYjILG+T/ps+9rPzBnG5z99zs4DO+nZomdZ/VdPSLsO7KLmMz4RlPVYFpXjCzJLuXm5JMQlwKbZ8O1jcOmMgo4M+ef2xe9A475FlwE0uQ7aPguJDfxJvH0h1C6f3lzRrEKTRuWlvJJG0eqJJ+Djj2HCBN9NLy4O1q3zs0tJCeTu90Mxuszyw+Hybxhz94acMjvmGgxSdtZNgsWPQbsXoe5FftjN+g8gNfiuq0TnSajhaXnZx/3TpIjLyYTFg/3wiFptfHJn25fQa3G57TJ/6BDA7od3U61KNWatmUW3N7oBUKNKDXY+vLPc9h/SshGwZR50mFBwzQtz/SuRGRdA60egUaDw7bH0YHIONs6AVa+AC9ShqVQD0t4ISoht2L2BhqMbFlk2qOMghncZHrTZ4/06njgs8dCTc/Azb224fwPp6TB1qr+HTEyEli19N/biPPdIS4MHHiContoPP8DNN/sehmlpftbL6dNh1qzQ2/l51880ec7PADa131R6n96bcd+Mo//U/jSt1ZQ1O9bQp0Uf3r3+3WP83xfoNK4Tn/5UtIdL1qNZVE4I7r5xPCSNvv7aDx+cNs33iD940D+JP+kkyMzOpNoffSGX4sxmdeZLZ7J251r2PrI37IOxwrHMN7jTYB6/5HE27tnIaaNO47GLH+PJS58MvyPn/PUnY47vkV75FN8DPT7anjR4sXQ+HNGPk3xviQaX+STdvnS44BUmL53MdVN8V7W+p/flndT6kFQPWg/1M4NOKHQulKAn6tat8Pe/+5mUc3N94vqhh6LnQffg2YNpUrMJt7W9LfQKeTm+V9Hlq6BqSsHy/N9HnQ7wiwG+V+2uZdDqD7D9G1j7N9i33j9orNkaWj0UHbOrHueycv33X5WEMNeRXctg9mXQZ3XwKJML/uJnTzz84XCPhb4kwL50/0CsRitoPeiEi6eSRjFqyhR47jnIyPBfYikp8N57UfhUP9qtn+6HUbQeDPU7+xumlS9AhzeDVk1J8b3ORI4kOdkncYsldy/Mu8E3LBr28k+qNn7kC0JL+XMOcvcAcT5RUo49B7fv307tEbU5p/45LLrdd5/Oc3nEP+EbHWMuH8Nvz/ttue0/pIPZ8Nk1kLXVN3or14JtC+CcYaXb7ocX+uEPjQO9piqgB129EfXYsn8LtZNqs23/NtYPXM9p1U8LWu+4ufELo8/EPkxbNY2GVRuyPnM9D6U9xNPdni7VNu+80//ennkmdC+itWshPd33cElNhfr1w2+r6vCq7M3ZS97gPMyM7IPZVBlW5dBwpnn955HWOK1Uxwt+OuNbp956aLunnnwqGx8IXR7zeEgaAXz2Gdx1l6/LX6eOv0lftsy/9+ScJ9mdvZuRl40ss/3VHVGXrfu3HvrMbbp/E/WrHiH4MS7WzocjyjvoS0Zk7/LX/ZMakZ2XQ5Vh/iZi/q3zuXDDOJ/IO/txn6iP0Z7QpbZjEfy7F/Rd6+s5QdEHIVdthYy5vndR1VSoe3HMTI1+wpreGlJv8pOIJFT1icE14+GHv0KX2QUPzvJyitdr+wShpJFI5jr44TXI+MTPHtTkOkj9jS76UnH2/uwbHeT58fJVUyN9RFIOMjIzqJ5YncSEgoqRHV/ryLz0eewZtIeqlSuoxlthzvn6CenvQNYOX+Sz6U0Fs/8diy/v8r3x2jwLlUo7Q0Px/OGjP/Dsf3yNuVOSTmHbg9tCrndc3fiFMGP1DHq82YO2p7Zl4aaFrLxrJS1qtyjVNhcu9EPUvvjCJ4SSksIXvD6a/LZk4R4sXf7WhdlrZwOQ+7+5ZVK4OH+oXmrNVNbuXMuTlzzJY50eC7nu8ZI0yrdjB+zcCQ0alL447ZHc9+F9jJ4/GvCTwmx6oHwmb4gWsXo+lET+kOm8wXnYD6/BT5Pg4rd92/hEtXEmLHkSOk8rKCVwjL2uJErsWg4zO0K9X0LjK/wEK2vG+Z7/larDOcN9O3zTLEi5PtJHGzWKmzSKlZLLIiVXNQXOOUIXapHydnJjSL0x0kch5axe1eB6CbNumsWerAgljMDfCdU+3/8pK02ugc9vgLOf9N2/4+L9cOCyqBkVRtemXQ8ljW5oXcxiPcehDo07APBdxncAND+leam32batL7DcsSPcdpuf9fJf//L1jEoq1HCnAecNYPba2bQ7rV2ZzXR1UqWTqHdSPdbu9MXQOyd3LpPtxoJatfyf8nZZs8sOJY1uOOvE/cwdT1bdvargRcPe8NXdsHsl1DzLDxs8mBW1wwfLjcsNDEMqlBxKrF/Q60piT40z/PC0H8bC2jd8oujcEVCvEyx9CuZ0973wqjX3SaX4aJzVJXrpUyEiIlLGEhMSqXty3UgfRtmq1wlOToZZnX3dqAOb4YdXy3WXHZp0OPTzZc0uK9d9RbNqVaoRRxw5eTl0bNyxzCZr+NOf/PC0SZN8seX0dF8Muyz0+EUPAHq36F02Gwy44eyCRMb5DcswKSoAdGxSMFX4ifyZO24l1Ydf3AZz+8K6N3yv/HXBpRuOewlVfc2twsOU/muT72F0Ig3TO95UrgVn3A+XfgQXT4GGPf2M3uf+Ea7e7mPbe4USRsdAPY1ERETk6Myg01T49EqY09sPdXO5cPrd5bbLwj21Qs2QdSK55sxrmLR0Ev1a9yuzbZrBjTf6P2WtWpVqZD+WXWa9jPJdmnIpz81/DqDIkFApG4U/c/k93OQ403aU71301T0QV9lP1NGsf6SPqmLVaAV7VhbMtJov76DvRSsiRainkYiIiBRPYh3o9qmfnbL9WLh8ebnvsmolfxNbM7Fmue8rmuUPxeqcEjtDsirFVyKuNHW0QsjvCdO6Xusy3a4USAoMOa1W5QSueXM8i6sEF46BXsug4z/83yeaKrV9r5T170FebsHyvAOROyaRKKaeRiIiIlIyddpX2K5W3LWCHft3VNj+olWvFr2o/nF1WtVtFelDiahaSb6wT8/mPY+4XnJy+HkvNB/G0ewDwIZG9igqQnJypI8ggqqmFJ1u/kTT4FeweLCf5ZaqkLcfNn/ihzSJSBGaPU1ERERiWkoK/PhjpI9CYkFyMqxbF+mjEJGI27UCZrSFkxrD2U/44uBLhsH1ZVTYTSQGaPY0EREROSEoCSAiIiVSoyW0vA9WjIZ5/XydvgQNyRQJRUkjERERERERObGcMwyqtYAV/weJp/paTyISREkjEREREREROfE0/W//R0TC0uxpIiIiIiIiIiISREkjEREREREREREJoqSRiIiIiIiIiIgEUdJIRERERERERESClCppZGanmNlMM/s+8HetMOuNNbMMM1tSmv2JiIiIiIiIiEjFKG1Po4eBj51zzYGPA69DeR3oXsp9iYiIiIiIiIhIBSlt0qgvMD7w83jgilArOefmAttLuS8REREREREREakgpU0a1XfObQQI/F2vtAdkZv9jZl+Z2Vdbtmwp7eZEREREREREROQYJBxtBTObBZwa4q1Hy/5wwDk3BhgD0K5dO1ce+xARERERERERkSM7atLIOdc13HtmttnMGjjnNppZAyCjTI9OREREREREREQiorTD06YCNwV+vgl4t5TbExERERERERGRKFDapNHTQDcz+x7oFniNmZ1mZu/nr2RmE4H/AKebWbqZ3VrK/YqIiIiIiIiISDky56K3bJCZbQF+PGxxHWBrBA5HSk+xi02KW+xS7GKT4ha7FLvYpLjFLsUuNilusUuxi03h4pbsnKt7tH8c1UmjUMzsK+dcu0gfh5ScYhebFLfYpdjFJsUtdil2sUlxi12KXWxS3GKXYhebShu30g5PExERERERERGR45CSRiIiIiIiIiIiEiQWk0ZjIn0AcswUu9ikuMUuxS42KW6xS7GLTYpb7FLsYpPiFrsUu9hUqrjFXE0jEREREREREREpf7HY00hERERERERERMpZTCWNzKy7ma00s9Vm9nCkj0dCM7PGZvZvM1tuZkvN7PeB5aeY2Uwz+z7wd61IH6sEM7N4M/vGzN4LvFbcYoCZ1TSzKWa2IvDZu0ixi35mNjBwnVxiZhPNLFFxi05mNtbMMsxsSaFlYWNlZoMC7ZWVZvaryBy1QNjYjQxcLxeb2b/MrGah9xS7KBAqboXee8DMnJnVKbRMcYsS4WJnZncH4rPUzEYUWq7YRYEw18pzzWy+mS0ys6/M7IJC7yluUeBY7r1LGruYSRqZWTzwEtADaAVcb2atIntUEkYucL9z7gygPXBnIFYPAx8755oDHwdeS/T5PbC80GvFLTY8D8xwzrUEzsHHULGLYmbWELgHaOecaw3EA/1Q3KLV60D3w5aFjFXgO68fcGbg37wcaMdIZLxOcOxmAq2dc2cDq4BBoNhFmdcJjhtm1hjoBvxUaJniFl1e57DYmdklQF/gbOfcmcCzgeWKXfR4neDP3AjgcefcucDgwGvFLbqU6N77WGIXM0kj4AJgtXNujXMuG3gLf+GRKOOc2+icWxj4eQ/+5rUhPl7jA6uNB66IzBFKOGbWCOgFvFposeIW5cysOtAJeA3AOZftnNuJYhcLEoAkM0sATgI2oLhFJefcXGD7YYvDxaov8JZzLss5txZYjW/HSASEip1z7iPnXG7g5XygUeBnxS5KhPnMAYwGHgQKF2ZV3KJImNj9DnjaOZcVWCcjsFyxixJh4uaA6oGfa+DbKaC4RY1juPcucexiKWnUEPi50Ov0wDKJYmaWArQBFgD1nXMbwZ/cQL3IHZmE8Ry+IZZXaJniFv2aAluAcYGhha+a2ckodlHNObce/6T1J2AjsMs59xGKWywJFyu1WWJLf+CDwM+KXRQzsz7Aeufct4e9pbhFvxbAxWa2wMw+MbPzA8sVu+h2LzDSzH7Gt1kGBZYrblGomPfeJY5dLCWNLMQyTf0WxcysKvBP4F7n3O5IH48cmZldDmQ4576O9LFIiSUAbYFXnHNtgL1oSFPUC4wt7wukAqcBJ5vZryN7VFJG1GaJEWb2KL5r/5v5i0KspthFATM7CXgUP0Qm6O0QyxS36JIA1MIPn/kDMNnMDMUu2v0OGOicawwMJNCrHcUt6pTg3rvEsYulpFE60LjQ60YUdI+TKGNmlfAn7ZvOubcDizebWYPA+w2AjHD/XiKiA9DHzNbhh39eamZ/R3GLBelAunNuQeD1FHwSSbGLbl2Btc65Lc65HOBtIA3FLZaEi5XaLDHAzG4CLgdudM7lN5gVu+jVDJ9k/zbQVmkELDSzU1HcYkE68LbzvsD3aq+DYhftbsK3TwD+QcEwJsUtipTw3rvEsYulpNGXQHMzSzWzyvjiTVMjfEwSQuCpwWvAcufcqEJvTcVfeAj8/W5FH5uE55wb5Jxr5JxLwX++Zjvnfo3iFvWcc5uAn83s9MCiLsAyFLto9xPQ3sxOClw3u+DHoStusSNcrKYC/cysipmlAs2BLyJwfBKGmXUHHgL6OOf2FXpLsYtSzrnvnHP1nHMpgbZKOtA28B2ouEW/d4BLAcysBVAZ2IpiF+02AJ0DP18KfB/4WXGLEsdw713i2CWU7SGXH+dcrpndBXyIn2FmrHNuaYQPS0LrAPwG+M7MFgWWPQI8je+Keiv+ZumaCB2flIziFhvuBt4MJNXXALfgHwwodlHKObfAzKYAC/HDY74BxgBVUdyijplNBH4J1DGzdGAIYa6PzrmlZjYZn7zNBe50zh2MyIFLuNgNAqoAM317m/nOudsVu+gRKm7OuddCrau4RZcwn7mxwFjz07lnAzcFevgpdlEiTNx+CzwfmLDjAPA/oM9clCnRvfexxM4KeuOKiIiIiIiIiIh4sTQ8TUREREREREREKoiSRiIiIiIiIiIiEkRJIxERERERERERCaKkkYiIiIiIiIiIBFHSSEREREREREREgihpJCIiIiIiIiIiQZQ0EhERERERERGRIEoaiYiIiIiIiIhIkP8Hg3WhpSqJqyAAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -1917,7 +1804,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1929,7 +1816,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1944,16 +1831,19 @@ "output_type": "stream", "text": [ "tal hits:\n", - "\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.6944054987801238, precision_at_motif_score=0.5103364799622766, example_idx=2, start=1, end=26, is_revcomp=True)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.9891952379569223, precision_at_motif_score=1.0, example_idx=2, start=10, end=35, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.6048776086118255, precision_at_motif_score=0.2341240424592603, example_idx=2, start=58, end=83, is_revcomp=True)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.9985309195064332, precision_at_motif_score=1.0, example_idx=2, start=67, end=92, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.8430095831557372, precision_at_motif_score=0.9688114455973597, example_idx=2, start=140, end=165, is_revcomp=True)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.9994820346600571, precision_at_motif_score=1.0, example_idx=2, start=149, end=174, is_revcomp=False)\n", "gata hits:\n", - "MotifHitAndCoord(motif_idx=1, motif_score=0.9933627532372303, precision_at_motif_score=1.0, example_idx=2, start=22, end=47, is_revcomp=True)\n", - "MotifHitAndCoord(motif_idx=1, motif_score=0.998124872090949, precision_at_motif_score=1.0, example_idx=2, start=89, end=114, is_revcomp=True)\n", - "MotifHitAndCoord(motif_idx=1, motif_score=0.9994427100002803, precision_at_motif_score=1.0, example_idx=2, start=113, end=138, is_revcomp=True)\n" + "\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABI0AAACMCAYAAADx21mCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3hUxfrA8e/spicEAoSEGqpUEekCCiogiPxEFAURK3bsXhW9V1HsXa+Vq14rF1EsCCqC0kEh9N4TkkBCes9my/z+mN1NNgUJ2QDi+3mePNk9e3bO7O6p73lnRmmtEUIIIYQQQgghhBCiPMvJroAQQgghhBBCCCGEOPVI0EgIIYQQQgghhBBCVCJBIyGEEEIIIYQQQghRiQSNhBBCCCGEEEIIIUQlEjQSQgghhBBCCCGEEJVI0EgIIYQQQgghhBBCVBJwsitwNI0bN9atW7c+2dUQQgghhBBCCCGEOG2sW7cuQ2sd/WfzndJBo9atWxMfH3+yqyGEEEIIIYQQQghx2lBKJR7LfNI8TQghhBBCCCGEEEJUIkEjIYQQQgghhBBCCFGJBI2EEEIIIYQQQgghRCUSNBJCCCGEEEIIIYQQlUjQSAghhBBCCCGEEEJU4pegkVJqhFJql1Jqr1LqkSpev1QptVkptVEpFa+UGuSP5QohhBBCCCGEEEKIuhFQ2wKUUlbgbWAYkAysVUrN1VpvLzfbr8BcrbVWSnUHZgOdartsIYQQQgghhBBCCFE3/JFp1BfYq7Xer7UuBWYBl5afQWtdoLXW7qfhgEYIIYQQQgghhBBCnLL8ETRqDiSVe57snuZDKXWZUmonMB+40Q/LFUIIIYQQQgghhBB1xB9BI1XFtEqZRFrrb7XWnYAxwPRqC1PqFne/R/Hp6el+qJ4QQgghhBBCCCGEqCl/BI2SgZblnrcADlU3s9Z6GdBOKdW4mtdnaK17a617R0dH+6F6QgghhBBCCCGEEKKm/BE0Wgt0UEq1UUoFAeOBueVnUEq1V0op9+OeQBCQ6YdlCyGEEEIIIYQQQog6UOvR07TWDqXUFGABYAU+0lpvU0rd5n79PeBy4FqllB0oBq4q1zG2EEIIIYQ4jbVuDYmJJ7sW4q8gLg4SEk52LYQQQnioUzl207t3bx0fH3+yqyGEEEIIIWpBKTiFTzlrT1XVxSen+YeuG6f9uiKEEKcIpdQ6rXXvP5vPH83ThBBCCCGEEEIIIcRpRoJGQgghhBBCCCGEEKISCRoJIYQQQgghhBBCiEokaCSEEEIIIYQQQgghKpGgkRBCCCGEEEIIIYSoRIJGQgghhBBCCCGEEKISCRoJIYQQQgghhBBCiEokaCSEEEIIIYQQQgghKpGgkRBCCCGEEEIIIYSoRIJGQgghhBBCCCGEEKISCRoJIYQQQgghhBBCiEoCTnYFhBBCCHH6ad0aEhNPdi3EqUSpytPi4iAh4YRXxf9iYiAtrfI0IYQQ4i9OgkZCCCGE8LvERND6ZNeijlQV/fA4bT907ShV9VdztK/yLyU11fz3fCBZD4QQQpwmpHmaEEIIIYQQQgghhKhEgkZCCCGEEELUgNPlxOlynuxqCCGEEHXOL0EjpdQIpdQupdRepdQjVbw+USm12f23Sil1lj+WK4QQQgghxIkWMD2Ahi82PNnVEEIIIepcrYNGSikr8DYwEugCTFBKdakw2wFgsNa6OzAdmFHb5QohhBBCCHGyuLTrZFdBCCGEqHP+yDTqC+zVWu/XWpcCs4BLy8+gtV6ltc52P/0daOGH5QohhBBCCHFSOFyOk10FIYQQos75I2jUHEgq9zzZPa06NwE/VfeiUuoWpVS8Uio+PT3dD9UTQgghhBDCvyRoJIQQ4u/AH0GjqgZLrXKcUaXU+Zig0cPVFaa1nqG17q217h0dHe2H6gkhhBBCCOFfEjQSQgjxdxDghzKSgZblnrcADlWcSSnVHfgAGKm1zvTDcoUQQgghhBBCCCFEHfFHptFaoINSqo1SKggYD8wtP4NSqhXwDTBJa73bD8sUQgghhBDihNO6yoR6/7Dnw+rrYPd7dbcMIYQQogZqnWmktXYopaYACwAr8JHWeptS6jb36+8BjwONgHeUUgAOrXXv2i5bCCGEEOKEi4mBtLSqp4vTXomjpO4KX30dHJoPB7+GyA4Qe2HdLUsIIYQ4Bv5onobW+kfgxwrT3iv3eDIw2R/LEkIIIYQ4qVJTzX/l7taxLjNPxCknz5ZXNwWXpMOhH8FVCpTCjpckaCSEEOKk80fzNCGEEEIIIf4W6ixolDgLlLXsedqSulmOEEIIUQMSNBJCCCGEEOIY1VnQ6MCn4Cwqe24JqpvlCCGEEDUgQSMhhBBCCCGqs++/sHYK2AsA36CR3Wn3zzK0htztvtMcBf4pWwghhKgFv/RpJIQQQgghxGknZR7ETwHtgMIDMGS+T9AovzSfhqENa7+coiTA3TdWaFMozQFnce3LFUIIIWpJMo2EEEIIIYSoyuYnTJMxVymk/gb4Zhr5rala7jbTHK1RH7j0IFy01rd/IyGEEOIkkaCREEIIIYQQFeVuh7wd5Sa4gDoKGuXvAWcJdHsclAXCW8rIaUIIIU4JEjQSQgghhBCiokM/gXaVPXeVApBry/VOyi3Jrfiu45O9GSyBEDvUBI0CIqDdzf4pWwghhKgFCRoJIYQQQghRUeqv4LJVmpxdnO197L9Mo13QsKfJNgITOIoe5J+yhRBCiFqQoJEQQgghhBAVZcWb//0+gFHbILQ5ABlFGd5Z/BY0smVAg7PAElw2LdgPHWwLIYQQtSSjpwkhhBBCCFGeoxBKsyGqB8RNAEsAdH0EgKySLO9sfgsaleZC1FkQEFquDsUQFOSf8oUQQojjJEEjIYQQQgghysvbBQFh0GWqyf6xWKHtjQBkFmWWzeavoJEjHxqc6TtNKf+ULYQQQtSCNE8TQgghhBCivPy9oDEjmFmsZprLDsCRwiPe2XJKcmq/LK3BUQQhTX2nl2+qJoQQQpwkEjQSwp8O/wIrr4GsdSe7JkIIIf4qyo/QJU4NtnQIioKA8LJp1hDAt0+jjOKMiu+sOUe+CUwFRvpOt0rQSAghxMknzdPEKal1a0hMPNm1OB7D3X/iRIiLg4SEk10LIYQ4TkWH4LehJqul7wxod/3JrpHwKEmHeu3NaGbuYJEniJNdUjZ6WlZRVlXvrpnSbFBBpjmcEEIIcYrxS6aRUmqEUmqXUmqvUuqRKl7vpJRarZSyKaUe9McyxektMdFka/9l/lwaPe9M9BfK/M0MrH7emFg0yvcvJvbkf4a/4N9fM7AohPir+WD9B4Q9UwcX9Gtuhvw9oO0Qf4f/yxfHrzgFIs8AS9UdUUcGmayg8gGk42bLgsCI2pcjhBBC1IFaB42UUlbgbWAk0AWYoJTqUmG2LOBu4OXaLk+IU1L2Big8UPZcO7wPC0oLyCgsl76ellb5/VVNE0IIcUqYt3sexY5i/xaasQbSlpQdL9z95YhTRHEqhMSUZRlV0DC0IeCnPo0c+RAYBa7S2pclhBBC+Jk/Mo36Anu11vu11qXALODS8jNorY9ordcCckYkTk8p88wJf0isGZq3XL8ELV5tQfTL0bUqPqc4B4fT8eczCiGEOCarklbxwIIHjmleT8DI6XL6rwIJX5imTx5a9vGnlJI0CG0OyvdU2eawARAVGgVAdvHxZRodyj+EelKhtQbthKD64JJ1QAghxKnHH0Gj5kBSuefJ7mlC/H2k/GBO+oYugf4fwcAvvS/ZnLZaFx/1YhTXfndtrcsRQghh3Pvzvbz6+6vHNG96YToAaYV+zApN/g5wQf+P4ZKdENnJf2WL2ivNhNCmlSbn2fIAiAgyzckyizOPq/g9mXvK3q9doAKPs6JCCCFE3fJH0EhVMU0fd2FK3aKUildKxaenp9eiWkKcIC4n5GyFttebu5LWEIge5H25xFFS/XuPpXj3qDp+bxohhBB/YzXZN3uCRYfyD/ln4bYsKDkMcVdBqysgoj0M/J9/yhZ/SmtYsgS++QZKqlsN7AUQ0qTS5AM5pin6yqSVAOTaco+rDin5KQAk5yWbm07KQi1On4UQQog644+gUTLQstzzFsBxn1VprWdorXtrrXtHR9euSY8QJ0RxsjnZa3tTWUeW1sodppY63X0VxMRULqOqaW6eO9yZRcd3N1MIIURlWcVm1Kt8W/6fzuvZ/6bkpfhp4fHmONF9uhnS3WKFiHb+KVv8qXffhVGj4NprYexYE0SqRDshqEGlyfuy9gFlN3SOV3JuMgBJuUnuTKMK92C/iYWZCmZaa7UcIYQQorb8ETRaC3RQSrVRSgUB44G5fihXiL+GohSTXdTw7LJplsqblvdiIzXV9wxVazOtGkl5pvWn566kEEKI2vME5D372KPxNDP22364MNF0fBxW7p5bNR0uC//asAEefBCKiqCwEJYtqxyvAdyBnMoBmyOFRypNK3XUvANrz3qXlJdkbjxVjFyVeJpC1i44JYQQQtRWrYNGWmsHMAVYAOwAZmuttymlblNK3QaglIpVSiUD9wP/VEolK6Uiqy9ViL+Q4hTTtKCKUU/K34lMzks+ruIP5h4EIK2gQl8azlLY/wnsed+k0QshhDhmpe59dlLunweNPGoy71EVHjQ3Gsr3eWeRPm1OhGefNU3SrFYICTGBo6o5qwwaZRRlVJp2uOBwjeuxO3M3AAk5CWY52knVPT4IIYQQJ1eAPwrRWv8I/Fhh2nvlHqdimq0JcfopSoHQGHNXsoLydySPN2jkuUgptJc7s9UuWDkeDi8ANOz/GIavquZ2qRBCiOr8WaZR+eZre7L2+GehBXuhXnuwhvqnPHFMSkth3jxo0gS2bIH69eGSS47xzd/EQkkamVX0hX4o/xBxDeJqVJetR7YCsCF1A3S/2IzAKsdwIYQQpyB/NE8T4u+tMNF0lqkqx2DLB4qON2i0L3uf97H2pK/vfM0EjJxF4CyGnE1ysimEEMeo2F42sEBiTqLvi1pDaY73RkD5zq+3pW877mX+nvQ7B7JNJ8oUJEBEW7AGHXd5ouZWrICgIJg1ywSMgoLgq6+qm9uT/ePmbi6WVUVrsePJNDpUYNarzWmbTaaRPbfKzCYhhBDiZJOgkRC1VXwIQltAQOU7xuUDReWDPzXhuRsJkFPivpDZ/jy4SqDrY3DW88iIK0IIcRRFKZD8AxSYoE35ffOuzF1l85Xmws+9YU4T+LYF5O/z6cfIM0z68Tjno3M4+31333clqdLx9UmwYQM0bgz9+pmAEVTZBaGhLOByVJqcU0XQqFLz8QqsT1pp/kpz73PPDSCLspiM5MB6UJoNluBj+hxCCCHEieSX5mlC/K25SiEkuso7hOUvTDz9F9TU5rTN3sdJeUlE5W8z/WD0fhfaXAMoaNjjuMoWQojTXvoqWDzCZGO6HHBFlk+TtC1pW8wD7YJF50HeLtB2k1myoB+HzngdgKiQKLJLsmtVlTxbnnngtEFobK3KEjW3bRtccAE4yyUQ1atXzczKCvacSpOznZVnTS9KP+pyXbi8mUUAubZcABqENCCrOAsdGIVyFCI3gIQQQpyKJNNIiNpy2au9O5iQk+B9vCNjx3EVn1mcSUiAGVUnKTcJDv8CwdHQZhIEhJkMp8YDj6tsIYQ4rRWnweLh4MgHe55p0msN9unQemfmTvMg6Rso2A+RHaHXm9B0KDgKvcH/FpGma8byTduOVXaxCTZpT1BAO6Xj65Ngxw7o3RsiIo5h5sAIKKk8UlpT9/2hC1pfQMdGHQFoXq95pfk8dMVR0Sjrq7BxWGMAMpwucNnAUW5Qi5CYY6ikEEIIUfckaCRErSl87g5+EwszFcy0ejtNDbYGk1qQWuOS7U47AC3qmYuVg7kHIXsdxF3hO6N0piqEEJVtfwFcTjj7ZRiXC/3/C5SNStk0oingvrDf8QqEt4JhK6DjXXDut9B0GAdyTJO22AiTGVS+uVpVvtj8BepJ3z7myt80MEGECsO5lztuiLpz4AB06XKMMwc1Ms3PK/B0H/jggAf5v47/B/iOlFpR+Yxjp8ukKXky3TzrX1JhFqDBXtbpOmNrfs4ghBBC1AUJGglRW5YA00TNo8TTt4GLhOwEANo1NH1XeIJAx8rTAavnLmZCTgLk7oDowb59KFnkQkMIIXxoDfs/hA63QYdbITASWo0DypoLt6rfCoDsojTIioceL4I1zLw/IAz6vO1tvlbqMPv5Sh1nV7Bg3wJTZnFZU7Yd6WVBo0P5h0zAqHx/OeWOG6LuFBRA3LEOchYSY/rC8gSE3Jk/nj6NwgLDiAyOBMo1O6zC9vTt3see7GNPIKlZvWYAJOUlm/Wu+OgBSSGEEOJkkKCRELVlCTIp7LpyRweek8VDeSb4U9Phmj13w0MCTfO0zWmboTgZ6neuTY2FEOL0V5hgLvi7PQYB7vZIAeEAbDliAkEKkzaSmrIUgqIgdqhvED6wAesPrwdgdfJqAL7b+d1RF7spdRMA6w6vK5uWtsn7eEfGDhM0Kt8USZwQTieEhBzjzKFNzbHdWWKeuzN/ct1Bo/CgcMICTYDR00dRVcoHjTwZZ/GH4oGyY/ymtE2mM+zsLcf6UYQQQogTRoJGQtRWaDMoSgaHbz8XLhc4tLmTnGMznWkuT1xeo6Ln7JgDwJKEJe73LzF9KIU0qV2dhRDidJe9CSI7V9nnnGdUyvWpJiC0fe+XENmpLEDgpbA5bQCUujNKy/dVV5XNR8zgBWtT1nqn/ZH8h/fxjvQdEBAJRUmV3iv8LzU/lSJ7EWCSz5T6kzd4hDWH/N2+mcRAfrlMo/BAE4TMKMqotpjywUNPAOnHPT8CsDJpJQBzd82FwPqQswkcRcdYQSGEEOLEkKCROLliY80ZXMW/E7m82FqOYBMe5840cjc1cKew76qiJdrOjJ3HXi+l2Dn7HQDvRYvTWWLuUCsZ+FAIIY4qdxvU60BVI1I53ZmhpU4TELDn74OIdmaY9XIc1sppKQm5CdUu0uaweR//tPcn7+M1h9Z4H29I3QBhLSB/T6WmT8K/tNY0fbUpff7TBwCrFUpL/+RNHsHRkLcXKqwDBZ5Mo8CyTKOs4qxqi1mVtMr72BNIrDgKX3JeMgQ3huyN5saQEEIIcQqRoJE4udLS/nyeul5ebesQ1twEjTwXG+4U9o22yrPuy9537PUCDoT5njzaNWjt8m0KJx2oCvH3VV3gvbbB8L+Arm93ZUXiiupnKM0xTYwsvhf95Tsm9sgvzjB9GCnf/WhVgf6jDWrgyWCyKivLD5rMUs9oax0adgDcgYN67aAwsVLTJ+Ffe7P2AmV9SoWGwqHKfVtXLbgx2LPBUegzuahc87TwIJNpVL7/qvK01hzIOUC9oHoArD1kgkYlDt+MttySXKjfBbI3mCbvYDpwF0IIIU4BEjQSJ1fMCb67WtXyjlKHXbvggQfg8svhuecgPb2KmUJbQMHeshM9tzT3+Z5FWQiwmMygjMJqUtirqcOReibrKjQgFIXCFGmB0syymaQDVSH+vqoLep/ogPwJtidzD9sztvPCyheqn0k73ZmZ7ufuAPuWr9oDZt/saV6UY8uvMhhf9MOZAESFRDG87XAAQgKq7xTH01dN1+iuAGQWZXozjvZn7wdga/pWiGhr+q+RrJI65emUXKOxOWy0bAk7dvzJmzzqtTcB2MO/+HRaXuROXCvfPK1i5pCHpzlafqkZFS0xNxGH0+Edbc3TkXapqxTqdzPt5w7NN+3bndJMTQghxKlBgkZ/Z3XRVKumUlPNSZKH1r7PT8TyUqu+w/v66zBwIBQWmv8bNkDDrlV8Z50HQEEWZK3zeX+w+0Llrj53MfuK2QBEBEccvV4V6hYebUZWefr8p2kb1RaA0uBGkLerbL6/eLOG9HRYvBjWrjWdlAo/OhW2cVG3qgt6VzX9NMpKmr3N7FPn7ZlX/UyBEVCaBe4maJ4Au3KZNNBeTXvx7IXPAuCwhpnXXb7zHnHvkwa1GsTMy2cCvk3QKpq1dRYAdncwaMG+Bfx24DegrEkcQJorEPK2gzWociG1VdXvbLWeNr99TXy2+TPv41VJqzjjDNi4EUoqdl1VlchOpn+h7c+Z9cJZSqkGT/goNCDU2zwt35ZfZRE/7/250rRF+xcB0DCkIQsnLcSCBZd24arXDqzBsOVJwGmaVwr/K06D/Z/C7ncg44+6PecU4gTKt+XXeJRmUZnNYSPyuUh2Ze7685n/RiRo9HdWF021ThObN8Ozz8Lvv8PLL8P998OHH4I1vYrvx9OVwb4PwF42Gk6Ce7/dJqoN7Rq2A6puFnE0nruXd/S9gx6xPQDICYyF9FXg7ufIp1mDswRSF8G+/0LyD2Cvfhjgky0zE0aOhGHDYOZMeOUVaNECiuTm6tHVJBBUV9u4ywkp82HN7bDiKtj2PORX0/RS1K3qAu/VBMNrasjHQxj22TC/lOVP5TOMEnMSq54poj3k7y3rb84tyf20d7PejO82HoANRSWQt6csY9QdjD/kjvM0rdeUBiENAMgszkRXc6G5Isk0l/OMkvXRho/YmLoRME3WPKO1rcjJMFlGhxf6P9uoqm3cVU0m6ml8zLc77axJWUOj0EYAzN8znzPPhN9+871BUVxcTQEBYRDcCHK2wP5PIG87+S5z4hxkDUIpRXhQOArlzSSq6PeU3ytN+2H3DwDE1oulb/O+NA5vDEBGYCy4bJC7Fb5uBAsHHfdnF1XQLlh3H/xyDuTtAFsGbHsWmsb8LQOqpyy52XVcjhQeIfL5SMbNHnf0GU+jm0d15cttX5Jfms/LK18+7jKyirO8o2OeLiRodLopTIJV18KC/vDbRbBgAKycaPpOqKiGTbX+Tt56CyZNgmbNIMKdHFSvHlV/Pxo4HAAHPoWig94+Kva6rwOiw6OJDosGjt4XRkVF9iKK7EUEW4MJCQihZf2WABy0NoaDsytdCAEwrzNkroPASPObL+jvE8g6VWgNw4dDnz6wapUJGM2YYbK5wsJqWNi+/8LqG2DZWFh7J6Qt9l5E22xg/zvfdKmLbdyWBT/3hJQf4Iw7oMfzpi+OwMjalXsS7NkD994Ll1xi/u67z0yrE6fCidrRMjurqNeRwiMsTVzKov2LjtrR74m2P3s/+aX5dGzUEYDPNn1W9YxRPUy2RoVAUKJ7n9AisoU3oLAiPw9dsLcs0D42Fa7WJLnnbV6vOVaLlYigCFzaVeX3kWfLw+Hy3S+vP7wei/tUa3LPyQxqZQIBGcHNTPbKuntM0MhRXeTiOFS1jVuqOd2r4f7AZoOdOyE+HvbuPbWzQz/d9CkAOSVm9NK317xNt25w4AAcPlx9HM1Hw97mf/wd8NPZ5LlMa8cgd4ZYWGAYFmXxjs5WkctpFnJRu4vo17wfYNYTgCbhZhRUzzp4sNQBKtC80VGhuaSovb3vm4zwizfCmU9A18dg4BeclEuh3B1w4AvYOwMOfgUl1Y++d6rQWlcbLPc6FY5zJ0FGUQYhT4d4+7Q7GV5Z9QoA3+/+vtJxyMfftEl7Tdwx/w4APtjwgXewjJpq9GIj4l6PqzYL9a/IL3tKpdQIpdQupdRepdQjVbyulFJvul/frJTq6Y/l/mWU5kLyXHNxu/9TSP21LF3enwqTYOFAaHcTXPgrDPoSLlwI5/zXjPBVUQ2aav3d7NoFfftWEcCophkZlzxhRjRbNARWXg3AAfc+OzosmsZh5k5iri336DvzcpJyzXDMnrvbzes1B2CNI8z81mlLzIWGZ10KawUj4qHTPdDqcuhwK4xYY5ponGLWrDEZRVOnmu84MtL8RUfXoBBPIFQp6PM2nPs1nPk4B3J7c80kxZVXwvTp8K9/wYgRkH+67Ldrst3WxTa+cSo0uxh6vgINzoSINuZ5SE1+PCOnOIec4pza1ec4vfsu3Hgj3HILzJ1r/iZPhoYNT0p1TknPLH/G+/iFFUfpO+gEu+ene4CyDKOnlz9d9Yz1O4M9FxL+ZzIzx6bC+FJ2uwNBMeEx3kBQqkOjrSGw4+Wyjo+dNvZ7gv/uwL+nD5pD+ZV7U96ZbjrNbhrelH8M+AdgmqkdyD0AwIMDHuTKrlcCsDVjJzTsCYUJ8OsFED/l+L+Qiqra7p3Oys1warA/cDrh0UdNduiKFZCSAvPnQ05NN98TOFrqf9b/ByhrFljiLKHZmbsoKYGrrjJN1IqK4LHHjlJI7IU+Hal7gkaefq3CA8OPGjTan2P6sZo2ZBpT+prf2NO5uueY7gkeJeUlQ4NuFUpQf/km6MCpEUzY/hL0eM7c4LCGgMUKARHHna15XK3aSnNh0YWw+21zsyXmAghqBK27nvzv5yi/0YHsA1iesnDhpxfWfT3q6tqkDjOYrv/uemxOG2Nmjan5m7WGzLWw8Z8Qf6/52/wk5FTRPHXatCp/o8Jpj/Liqhe9Nyi+2PxF9cv7mzZpP1aL9i+i0F5I2wamS5AP139Y4zJWHlzpffzs8mf9VreTrdbjdiulrMDbwDAgGVirlJqrtd5ebraRQAf3Xz/gXff/05vWsPEhKEmHrlPNELvaZe58OgrAevxXJ5s2mT53YmKgvenTkw4Fb3DuoCuwNO5XaYjYY+V0wvLlsH697124jh2hf3+z37bZIDDQZOHU6CK/piqeTD7xBEyb5u1A0qLq7u5Qly6werXJPggPP4Y3tBgN258HWzokfwvAYYepY3R4NIHWQEIDQrE5baQWpNIissWfFpmUl4RC0SjM3IX0nFjOzy/hziANK8ZB3/9AoBmVhabDzO/u+e0tgebvFLBvn7nQKCkxm8XWrVC/PjgqxM+sNRkAbt29wLcQN977mfNKY+h/rukjqUUL89u5XGadjaiD2JnLBe+9B+vWQbt20KAB5OaaO/A9e8Ltt1d/g/9UorXJHFi1yvwmnvO1Vq1MwC2yfBJR2m/Q/0MIcG8Y38S6+3+xwNXHfmc8KTeJVq+3AmDf3fu8fXadCIWFJqsoNdX8Zh5du2ICsWl/QFGSezh0ZUZIbNy/7DMfD89Jr2e/djxXHNOmwZNP+k5z7xdrpYq67UjfwZvvdPHO8uKqF7ml1y3eprZ1ISk3ifM/OZ9XLnqFSzteWu18nlHJXO7O/21OG4k5icQ1iBv2HycAACAASURBVGNZwjLiD8dzX//7UJZAE9Dc8A9o3Bci2kFJGvvtoFDefWpUSBRF9iKORI8gdvfb0KgftLwMcneQ4DBBAk/gv2FoQw7nHyYlP4UzY870qVf8YdMJ9sgOI3lx2Iu8F/8e+aX53oBCy8iWxNU3N3DWH14PA682Q6xn/mH+TmHPPWdWkx9+gJAQs6+22825gF9Uc7yvDU9g77JOl7EpdRP7c/azq2ANfft2ZMUK6NHDnMOsWgWvvlpNIU1HwqayqFKe+7zIEzQKCwxDKUWpsxSXdlU6L9mbbUZvi6sf5+1r5ECOCSJ6zgOa1msKmGM+ba+H7M3gdAcuLcF1OrKe3W6aipeWQnAwNG5cw+NwXaq4TsTE1C544CoBa2jZ8z87dlWxv507fiaz1ATOPNMcH20200fW9OnmnOZPrbsXYs+HTveVHU/qtaest/5Tj1256Pm+ude/OGExP+/9mRHtR1Q9sz+Oc38xs7fNZv6e+dQPrs++7H28+ceb3N3v7mN7s9aw4kqo3xW6TXVPVCYLtaqA+rRpZfvFct/x9bPHwY6yY+LkHyYzqfskLFWdgNbVb1TV+QnUbF8eG1s546m2230NXfftdUBZwP/+X+7n9j63H/P7XS4Xo74YBZhrwOdXPs+EbhPoHtvd/5U9wWodNAL6Anu11vsBlFKzgEuB8kGjS4FPtclr/F0p1UAp1VRrfdgPy69zWmvSCtOICY9B1eSuWN5Ok110RYW008b9a1WfggLTrCcryxzcQ93HwNItLVF5a8qaLR3HxVzPnmb7vusuc2EFJpX7nntMVkjfvmZ5drvJxgkIgKioWn2c6mnts1NzuVy8sfo17v/lfgBmXT6Lq7pdVSeLnjIFBg+GW281wYeICPN9VBt4aNAdIjtA9iZAmxsHTrBarN471PVD6pNemE5yXvKxBY3cmUYx4Sb63yS8CRZl4UBOMgy8A3a/CauvKXtD1vqyx5unwVaz887QoVxh78v6w+v5z+j/MK7LuKoPJHXkttvMOvLkk+YEy+UywckOHWD3bujcuSyjq7DwGIN0YDK7oOyA900syXsbYmUdHTuGek98rVY/XthU8OyzkJhoAkdKme3B4Sjrc7ZWqjp4Qp0cQK+80mzb991n9i9gPktoaBUXELHDIGUeRPWskMVWTVuPKk4kdj1xJ53U297n7d5sx8ZbN3JW7FlVFmF32vlk0yfklORwR587vJ3PHi+LxfzZ7WZd9HxGZ/JPWHc8C4NmQ/QA02xIBZo70uoUuJLynDCegBPyp5dVzt55ZvkzfHTpR3WyvJlbZjLxm4kAjJk1hnv63cPrI16vNF9yXjK5tlxCA0I5eO9B7vrpLmZtm8X3u75nV8Yu3ol/BzCp+mtuXkPzbo/D4YHwc2+I7Az5uzlULqAP0CisESn5KWyIOp+RaXNh5ZUQFAWlOWZeyoJGnv15VZlGyxKXAXjX4zYN2rD5yGa01tQPrk9wQDBxDeKwKAu7M3dD6wmwaapvISExrD+8ntEzR9MwtCFzJ8ylTVSb2n/BtbR1K/TqZfalnu3luPar5ZtDep4rKh3vayurOIukvCSsyspX477ig/UfcNv825i3ex4PPTSJ9etNU9Q9e0wQrFr1O5lRzbLWApCnA8GiCQsw+6DwoHCcLieB1kAKSgu8mWhgmqwU2YsIsAQQExGDw+XAoizevgqbRphgUatIEzxPyEmAs/8F8eUuOJtdVOvvoiorVpj+Gm+6Cc46ywSMiopM8Cg09M/fX2Plj1l1sP/SWlNsLyYs6CjHhrY3wvYXof9Hpr8qr6Mcu8rtb//4XfPgJHPeUj5gWlLyJ+tQebZ0aNyv7PzFc57+qgWu1r4nDic64FLNb3TBR+eS4+6rDWDkFyPJ+EeG94bmX0YdBEscLgfXfGPOw3NtuQDc8/M9TO45+djOU4pTTEuUc78qm1bDazeHy8GPe34EzI2JI4VHsDltLNy/kIva13L/cZTvzOFykF2c7T2Onsjzk7qSVpDGoQJzbB/RbgRLEpdQ4ihhw+ENnN307GMq46MNH5FbatYFT5LDnT/eyfIblkJpjkka8YzsGlgPAhvUacatP/kjaNQcSCr3PJnKWURVzdMcqHHQaM1Ll9DjyruwutN6Afb//BYdOlhNE5Vy+j0Vwxp9xPs8QFl5tdv53BQMa3mX5JRgSu2KyHoulieMYdh5IxjR3TQtmndgKYtWreStrP9VqsN8yzgGX3YxIc16e6ft3JhK2to5DJgwvuzHdzlISWtN690fYmk3EeWyw7bn+GPxJ8x3hXLzuBk0i2hCQWkRM3fP4zL7ZhpGdmafvoG168OwWjSd4lJ45NFAXvqgB0qVZZl3aZPGTz/F8H//ZyE3V6E12BrfTtKP39PTci+q2yMo9wb71oLbCEley8ghhwmwukApiouc5Kx4jm43vuddCZxZW7HlxRAc1BCtLXjufGzfrtFaMXKkOTg6HOZguWcPzP06i8lj/iBQZwMuXC5omXQtjMsty4ABvp3jYMfiBUya6CAoyHxFTqdiz0/v0feaOwkpV4d1C9cB1+HM2ornMq0kfQOh7/i2ahw/ZzwPzviacxNf4KmHDxLsTEHpUlyWetz65AguGRPB8H5bCS2Kx2UJY1diE+JK3qLdZdO85TqztvLEu3fSt18vRvW8EYClKWvJydjAU1dGc845jzFmDLRtayF+rZP7L3yUXue1Jqz1ud4y9m3cxeRbw3j/tXdon3MhSheTQTgOilAuB1G2NJxZ2TQMCseZ4SBs9l04r/+vTx2WfTabHj2DiOw6xjt9V8IqNJpmQWE4s7bSyJGHAhJ+uZh/7buZqectJqRkI0o7KbHG8dOyvlwaMBrLWdNR7SejW45hwuuj+NJyCFjq/c7GzxnPlICWTBz1GH1aDcThcjB7z880PpRMQFJzHHE3oCxWtFaAi+yl0xh180UE1yuLDn44bw6JrOCOi58nOrQh27P28cWuefzLsZct9mlkObriIgClNDvXl3Lp+GYEBlopKjLrVEAAfPn484wc8QD33WflnAEW8vI0H305g31nTkWHNyIyKIIcWx6hASG8kNOZgWP+j+Cmfbx12Oa4z2xmez/E0tZcbHZuvoNLun7K7bdNZvrTFho1UigFC787wJNPhzDzmxjvdqQUPD1dERNj5/qxuwktWodWAWzJbMSCnXcw5aq3aVu/JfmlhXy+8wcSfhhC3+a5nDc4BGsAaBRtIsL5ZUc/8vKCCQpS3gDEBx+Y4MuVow4SVrgMhSbJ1YWLlvQlv8IJ6osBD9OAkbTv28vnWDuoMIuK12QrBg3gjId706jctuHI3MKEd4YzbMAkhrYbSqG9iDl7F9JsZwij2xXSZNAUn3Ut8+cpbORJii1noLGilCbtgI3ggc0Aq3e71xqsq8eTGTmJFVu7kZ1jJThIU5Q3hQuCryKuJAPVcQpq2HL44QwS329J3ETfA9+2tp0Je6w9rTK3YG1ksjJKjqyn0zuVWyj3mT6B29Nf4B8PKoKClPc68qK5t7CRsgv0fyz8B70d3fisaSM6jH/Lp4xpz0ZRvz6MHb6PwNKDgJVtGYqbNl/PYUqxWqw4XQ6igusz7Z6HGXrBA7zx70D69DH70H1/pNAtqj7W0Kbm4L7tedjxAv9e+AC5rZ9m4vDlBDpSAU16aQjf/v4wV1/5Ch0anYFLu5iz9xd2Ll1HixYFXHfRM1iUhf25SSxOXkOfVT/SbdLL3t/UmbWVRV9vY/3uNgwY1d3nPvOUKYqXnz5MpybrsDjz0CqEbRtz6dJsM83Pv8Pn91zz/oP0vPJOgstN+2VxBDNnWnn4sTAii5dgceZTEtKdAz++wsAJlxFWbt7NK7YTlfcVLS9+wltu+qGVzHaPApZ4wyLsLgftPxnBFwu2kfbmQZ59OZbIkuUE2pMpCutP8fZPOFB4LtZGZ7uDa5qUFIAm7Fv9G8GuNJRy4nIFMO2dIbRs34jrLl5BoD0ZjZV5CQe5Y79v8OSNP97AsXo95/fuwJiBZlvfkrGbp5fOAODcZmcTZUtldIuezNo2i5fmP0Gytayt1KGCQ7R4oQNnfbuLea89SrOsZ7HkbMJBKOlOC0ppGtmzcWZtJSYoHJd2ceu481n0+uu0z70XS2k2LhVGmr0ElCbKO28IGk2nn97DHt3W5/dctnMRCmgfFIwzaytdG7Rg85HNgCY2uB7OrK20cBWigIyN/bj+2kKeuXU6TdMeA22nOKAZUVsOYt/Sy/sZ2r7ZltGugQxp5uC2se8QbA0i15bP13t/4cq8nyF2Mqv2XUh6ZgDBQZpI13q6hHxCy1FP+awny99/gT6jL6R8TN6ZOAfn5mdR/T5k8YoGHEoN4OwzSzhLPYazXneWJ11NckoAAQEw+dKD3PFIJ1q1imLMGAuBgVBYqHnz/fF06hzFmHNM06t1R7bx66Y/sCd+z+SrPyQmrDF2p53Ze34GppKz8jnqdR7trVvWnt+B/j7He2fWVpKuuYvWPy3xWScOR1h5/+FYJk14l9ZRbdBa882+hYwe+i9C832bh/3aBbgSOkfFQc4Ozo4wKYX1D89leLerGD/2HWZ+HUVpqaJFs1Iue7otvc4awYXtLqTAXsT8hGWUbBmFa+cApt72OHHZVwFO0gK74nStJ1Q7cGZtJUBrXNrFRVk9yZ07hfALH/J+jq375qO1i0bBkejs7cS4nKZpmyOIImsJjXQJzqytNLGYc7Wvpg+h+0HNpc2von7ul4CFQ3o0LZZfQV7cU/y6LJycXCsd2pby6/qb6N2/FyPOvh6AFYfWk5u5gbMTNrEl9D8Ul4ahsWDBSfyem+ndP45L+5l+On5P3cRL7zSlZYsLGD3aBIqcTtM094U3J9ClYz0uHWACV5szdrFg02ps++dw3fj/0LJeLKXu3zNyxRGGnNOIyK5lTXIKCiwMHdmADz+008C5DoszF5c1ks0r99G3ZxGNel7h/X7s6ZuhbS8CC3xTjpefNxBYgbPcccOZuYVhb51H6Efn0Lvp2WTb8tiVfYDGh4OZaV/s8/4gFcjFP8/l5qmDiW0W6D3er1z6MEO4hC4lY7CccTOq/yewZASr9/Sj5/4ffPah63/dQKzrZ5oNm+qtb4vInTiLo1m/PoouXRSFheb8IiR/JVmb/0t8yT/JyQvC6VJYLU4GhNxLsrqCw45zcWFFKchJ+ReXJV5NfWsEllaXeeu8dMcgem/6wGf7PLh2ER+9lcJ5Ey933+gz60n28qe4YFRzItpf4J03OSWAa26I4L13XUSUrsfqzMFpbciHi2fRuVsIV553v/f3XLpnH188fDUffNaECPsmgku2YQvpwvalK+nfu4CGZ13m/cxL1n3i7dz/qf538WvSapamxDP7m4Hc2HIA8SWPkZAYhMulaNbUTpPd4+g86U2f64pbb3bQvFsPn3tHDgc8MO5LLrxmJPWjykaQTFv/PQPaL6Ppebf77A/GjgvhwdsTaNsiF6tFo1F8u2o12aGrufPSV6kXFE5Sfipf71lA1uqFDL/wKs7tNBqAnxKWk7X+CIPDd9Dion/6lHvDLZEMHVGPPr1dROQvwBnQmNUHhvHmvxUz/p1OfdsyLM5c7EFtuefZcxlynpOxA5cQ4EhFqyBe2rQQu8tOt4bteWPIozz1xzssTYnnH08P4fz+vbnMvc2tOLSeZVuzWPXWKP79QhIh6ggW5cLltJB6aAQ91v8T65kPo5QVtGZ3dkNezA3g7j3f0bVRe7JKcvlkx3e0iS/mgoFNiexyqfdzfPLb8xQ5iujSsB2bJ37Hh9vmcOtv0wi+/m5Yudtn23BYLOyc3o1Okz/w+Y2ytvzIps0WbM0moiwBZlXTLmJ2X0b3617wOc49+NmTvJ7ztU+5AcrKysAB9Jj4L4LKzfvRN5+Trpdzx2jzG+3NOchXexZwX8lydlqeYV9mNxxOcx6qjixn4JvDaDb0Ye9278jYzL/evZahK6czpLPZXhYkrmTj75uxOVcyZezbNAypT1pRBrN2/8Tv79zExcMbM6BXJmGFq3BZwlmTfDEvvhrGjPftNCheSIDjCCWhZ/HQc2fTv28p4wYvJdBxGE0gT2yaC8AV7Ycza+RLPL763zwbPwPXVeNhue93mdKoKfmPtaHDde97p7m0i6nzzfnKzIteoleTLnT8bBTRhzeaZuhDl0BwWSujJe+9wlndbER2+b+yMuzFbJv5KIdbvI/LEoFGodBkbZrDkP5pxPYc6VOPnZ/dQedJb6OCym7irpqzkI4tk2jU90afeYsPriL+t50Mub+61NqjU3/aqdmfFaDUOOAirfVk9/NJQF+t9V3l5pkPPKe1XuF+/ivwkNZ6XRXl3QLcAtCqVateiYkVOnC+XME3vpO+Ofsyzr/PStSAW0FZIOljSPkMVUWHptfsGknyga94/pVgzuppJSAA0tNLaTaj8m2CAQVnsCpiN52PwBmZsLMx7IqGgrWhhM/37bRyY9/u9HgqFC5yj5ThzvSYdtMUpsW9Bb1DoHUzcDh5NMzGczqVRoUwdQV83h02NoX4lc24eeEPtL2kC0OHWXA44Nfv97Nkcyeys33rtme0laR5g1nZ4GKcbTsAULwnmdD8I0zr/BScBdQH+oLdaiFw7E6o18H7/uKZrQglydzZiI01kc83C1n7mZXMn4eyqcUoVIf2aIsVnZTMxS1fZ/XGSyjuORAVWQ9Kimnb8j1GTe6ApdsjJkCkNXzbksO7rTS9fjbUb2um7XqVpFWzafl/r0DcleV+OHc0fbwdmrkzb365jaVfLWbI00tNkNpdN/1GIWdtgfM3wsMrwWaFf50PDUPO59WJdgL6vQ4NzwRLAHzTlJdvvooHH/g3dO8HTc4BexG/L95N/34lMHy1t9zSNwoJNtnjPLYUgp3w+AUwJBQWb2xEwv8i+JAbOUgcvVjH0Ffm0+XqGaafA3cZG+7vwG/PXcoDBU9CZ2AA2BfC7SPCabqnkOnu85nZXWFRp5bMGJcBVxX5fO8/7u7NxZPugHY3eKcvegI+3F/IXV/DgGQoCYAHhkP02rFMS/8GQoFLgCBwzrMwPfdfTGv1JPQCYoAcuKZDC3Y4c5g+u4BWuTCzG7zTF3KruJPY5J0dfPxxJ0aOrPDCTGXWE4/N0xjz9X/43lrhTntaN1r8sIUkd3jY6dBYAxSuXe+y8r4VrFnfHd31TFyBQej0DB6Km0Dmt434mitYzTnUJwfX2Jm83X1NpboVxIQSftXvENXdW4f5n63lkpfno/sraA+Em/U9ey4kf9+Nr7mC1JDWBDhtxMYe5CPr0xw44FvuG20mcM/tX0Lf8dBsGLgcfLTwE27KWlmxCugOwASn2ceUW38Pfd6MeT9fwuGOQ3DVb4DKzSEwdw6PTZgD53U3zWOU4vCuX2m2dw1BDmhYbH7PnFDo/Go8T/+3F2PHVvO9l1tPlu44j8GXDzD9MrinF79eSFgVA5e9lDmYB6/pDH3f9c77x91dueazPyp19qy3v8KKf2zm9zWdwf0bOVOPsD+/mICh13Hf/RZim1uwl2oe/6eLQYuf4uqQ6WY/EwH0hhJrMCFX7IT2/U2GVKNwVt/VjXPOscLwlT7b8qi1FvpscjFtiVn+s+dCm0EtuXrcBDj7BZ/vd1C8lZwSJ9dtNNvnF90hytqZn3OS4Uvfjqre7zyGW+/8BfrdA82Ggnay+MvJXJBfeQSLvfFQb140nzKJPZwBQFNSiG6ewZ19v4B+PUzv9/V+4YevuzH69ijo9Tw06AQoZn7UkompOfQ4DBveh1/awUWToJErmEyLjcUfw5AEGHgjrGrlXn8q/J4T3/6cM0dP5JHyPQE6bex46Gw6TxgFZ9wOIY3BaWPJsxMYMirONA0sVwYAVxVD89bm8S+38e9XMjg/eBvdLtgKrcaZ/XPmOsj6FS47DG16eOddMWchgwaHwQULveXa3yjk1tUWuqx38eBqM+sLA2Fx6SVMzD2DSde9avYxCrKKooi+J6tSh8g7f/yEzqOuQ+cfhLBm5s7a93F8/HQfrr/rd+j9KMQOAu1k7ifX8Hjmfl79UnNBAuyPgsmjYYk7wSbzBYgqgU5TICe8MefbMrjnK+ifAnnB8OAwKIwNQ2UW8c6PEGmDGT3h9R6RXPnRfUzjSegN9AC9E+4+IxprSjovL4QAFyxsAx/1hI5znjDzdgf6AHvgph6tCA2288qrhwl2wsqW8FZf+N/Ycr+n+7u88+vPsZfk8sobGdQrhfhmMP1ciIiFSxfBle4uKv55PixNeZD7gsMZu+VJGAzEgf4O2t8J5+yEe3+HokB45jzY3rIeyUH5fPYtXLMZnhwM04bAO9/fzMeO13n0iQA6d7NiK4FFH87ivktnwNClPuvJkbxGNBm/GDoN826fvFnIjpkDGTn/c4pCGxIdYyHxoIXvBg1mytqvufKuGAYNCcBu02xYuJqHjlzOt19fwCrOIT+gIQ1ch3j3samUWGH/69AqFxo+DIGqAZnBOdy4Hj6cC992grHjgWkafeALaD3RW7e0p8KIvfOIz/GeNwv5Zmc/xl4zCc640zv91cdtPJDlYNRumPc/2BALvW6FgpcDCSv0HfFgfxQ8dh1M/BEu2Q12Czw0DMadDQOyBlA6Yy0v8yDpNOYuy6u0ezyl0j6iybzH+cClGL3+SRgAtIbkBfDwNTB6EYx3/55PDoaouPO4++ZY05eku76ZrxVyXzwMWQ43bjDzPjcI1nVrT3h4Ki++V0BMIRxoAP+8ADp8N5VprucgELgC2Gc2m2ccL/BB2t1cfz00irawcWs2n7SKxakg9SUIcUCDqRC37EmGt3ucGSauSmmpBqudqCeDKbLC2vchtgBaPgBnBVh4bdFFbE+8AH1md3RIKLaiDB7qNRalIfNFaFACZ0yB7IgoMkKy6ZcEy/8Lb/eB+0bC7sVN6bDU995vpooicXIcPa9sBl0ehPCmsHAg/9vYkQnXjDPNstzfj/P1IqxTNOT6fu/LbjyXwR8t81knHG8UEri30k/ExYVx/BSWSKd089l2RENqPfe6VuHy5rnnoPOXTzDG/pTZH4Ri/ocBVxZAi3bebXnZV79x3rBGcN63Putl0ZchLJg7go2xI6BZM5TdxrZsTZNLLuONN604HOB0QUY6nNldkZGhCQpSaJdGWRTz58OhW//JzXHPQFu85y37C1rS9uovodtl3u1z3g2DeeyX+Wza5Ps5Nr7UkR4TX4dmI7112/ZQKwq2NqDfFSXQ+T4Ib45z+Rjqbcun2Ap734B22dDiPkihBc+8cy2P3v2sOWd1ARb47kBfxky6ATrc5i1369NOntlVwsT5cMkes7/9xzC4ILc7z2z6juunNmPYiAAsVli72sn1EcGVjnMfLL6JHfbpTL67vvvGmMJm0/Q4J6zSb7TkzccZ0j/d57yFNwshvDWM3mPO8R1FoAIYNL0FK1U6gU5oVOT+3QGlQStY+QGkRsDl4+HWzEG8NzYShsz3KXfaNY8xreUzMBWz3Sn45tsxdGufwBnDQqDD7eYiP2srX96xkqvu2gI9H4fo3uC08d7717I86wBTv7DR7QgkNDDXJp+7k6Yv3gX1SuHLM2Giow2fDGqP9dxPzHHd5YC5bZh23WimNf4A+lghrgm4XHwXDZfZKmeaL1A9GX7N3dD2Ou/nWPZEAO/uz+WW7+D8hLLf6MKz+nPlpAnQ8W7vvLZXSgkOtFf6jaJuzmLJqijOqpjsXcV56LU7WzHLcpDuh6BpPmyOhYMNKpzjuLejwXPeZpmlQmubrLZ0mvMHs+dH0amLuda1WmDZB/9maPflJuvKvbwjrxYS4z5v/2wOZIfC3RdDx5JYdoWkEuCEFnlwsD64LPD08w/w2J2vwNn1oMlgKMnih0UN0esa83+TPoaothDZBjLW8r+3BjPhro3Q+wmI7gOuUt5/fyJLMxP45+eldEmHQ/Vg6oXwwMAOdJ/4FjQd7q3brkea0XFNCnzle8PirhvCCE4u4sVFYNHwyVmwrG0zrg/vy7kXt4PwELAvB9syds9oyhkV9qEfB17LV8M+Yf58369t56NN6XTD42adhLIWJXOoFBdZet25DA4F3lvu+8LE5vB55VG8lVLrtNa9K71QcT4/BI3OAaZprS9yP58KoLV+rtw87wNLtNb/cz/fBQz5s+ZpvXv31vHx8bWqX0Vdu8Jrr5lhvstngyXkJND93e7eYVNjwmPYcvuWsrQ7P9Ja0/K1lqTkl52kKCx0/9bOlCkWxo8vawZVo+Y61dn7ARQlm05BgxubzrgTPgVrGFxVePzlzm0H53xq+n9wlcLWZ2D7s2ANh6sqjNiVPA8yVkFkJwiJhYTPIOHzauvgyQb5Uz/1MqNgNL/EXMx7m2Up6P6UOUFRAe4Lljam4Ar9A3y++XMmfTvJZ9prw1/j3nPurdn38ReyJnkN5318HjanDYAhcUP4avQidu20Ulxc1g+kUqaZXlBQ5TIOZB/gzvl38sehP7i99+1c324qd9wczpQppq+IiAhz9/LQISofiPzkmNeTqmgXzOsEPV4yQUBPU6s5MbyTVcydh8oCEhO6TeCLIQ+gCvYCyqxrf0w2neyi4OoK6e2rJpl1u9dr7n6lFHzbvMr1z192ZezitdWv0SaqDbf3vp3IkMqjmWVnw1NPmX7Q2rYt+41SUmD0aN++i3780fTTsHy5yQzzKN+cy69KjkDaUsDl/n5vrv77rYrTBt+1NIMARLQra34w072jv/o4VxSXA2YFwhXZEOTuAOmbWGxFaTTYByXA0LZD2XZkG4cLDnNJh0uYt2cew9sN5+puV3P999ejUOQ8kuPTdKVa+z8xo+mc921Zn2TedPVj/BwHPoddb/5/e3ceX1V17n/88yQBEmZkFgIJlEHFAUTFMFWmMgjodShq71XRXlTUSrUqyg9QARW8osWhpQpSqwilDiCKghRRFBQBkUEQgUKYwiCQMGRcvz/WdGTY3AAAGw9JREFUCUlIAgknIefA9/168co5+5zsvcNz9j5rP3utZ0GXT/3MYRHl4L2GwX/+XBbMucyfT6/4G1RtgXsvlne+von9zf9CTIw/VzgHrTMGc8FtL/vjMz0ZVj8Na572sb1mqy/+Ghm4t19IjFpMaMH6feuZ/z/z6di4I9Gjosl0meE5NCIIw+YPY/QXo48N2evxZg/mfr2d2I9WsHZ1FDExObXTDh8u+gyUKSm+Ftu11/qhSmb+XJCQAAsXQlxczrpSUgoenn3P7Ht4demrxFePp3p0dZbvXE5c1Tg2H9xMXPU4Nv1hE/d9dB8vfftSgRfyUPTz+JLEJbR7vR0NqzZk65CtTFkxhds+uI1uTbox97/nFu2PPoGDqQeZsXoGDas1pGt8VyIjyn5I6vTp8OKL8PHHfghU+fI+Fnd9+jve+uEtKkRWwMw4mnGUi3ePoumOxxkxwg+rL1cOjhyBV9c8wcjPR+ZZb69f9eKjWz7Kt71mE5qxYd8GFty6gITYBKJHR5PlsoiOiuZoxtE87/1+0Pf563Ssexl2LwwMAatU/HNXwIk+E0fTj1IuslxIxAf8sG4zXxcrJcXvd1qan2jh+uvhiit8vaOsLD/ap3XRRrkUTfaFzE+vQeL70OEdiAicEN427tgJk5Lh+vOu58K6FzJiwQhqxtQkKaEbEXuXwuUvQ6328H4jiCxfpO8H53xN09mzff3P7KF5JVrjLLeUjfDlAGg7wRcPj4yBH0aSuWo08Ztha66Oate19L2y/rnmn3lWMf4343mgXQFt+ozD8EEjPytszcvgyE4/C3Ljm/x3XHbdqX/VhswjcM02vywi0Cgq5Ltr0ZZFdJjcIc+y5Vf25ZJq9eCKib4g+uqnYe2zBV8zAbsP7ebhuQ8z5fspNK3RlKnXT6XtuSe9rj8lGzbAypWBHuaROdcAvXsXY+hlIbK/I7KNavERrz/Wi40b/QQ12TeccteXzO2BOQ/w4pIX8yyb2Gcizy95/tikAgAJsQksat7Qx7TDO77tZhH+s51+EBL+Dg2v9WUHZjb1deOu3RGIZ+CDG2x7sQSkpPj2d/b/S/a58JprSmnoMKc3aRQFrAe6AtuAb4GbnXOrc72nD3Av0Bs/dO3PzrnLT7bu0kgaLVzoZ1N65BF/Io+K8kUAmzTxyZxnFz1L1QpVueeye0p0u8dLy0yj8fjG7DzkT9Df3biHbu1rkpSU9wItpKXuhc3T4EhiznTbGYfh/IeDnrGryMmA/at8kdMGfaHur33RyF2fw+oxcPWqnKLQJ2m4jF44mmH/HgbAg+0e5LnfPBfU/ocD5xyTlk3ikvqXcOm5l5bgev0xdfSo/yxXq1aaJ7ogkkbJG+DTBLh2e04DINfn5MB/7eex+Y8x6NJBXFS3GAXsMlNhehW4bjeUr5ZvvWX5ZVQc27f7i8fZs6FxY9+d3MxftJRWPINyaAvMbgU3/JJTfyg7iVxIo6zIvrnLz7Jz4XCfhP4gHlKT6LsNPjxu0qSVg1Zy0V/zfl5a1mzJ2nvXFm1bKZvgs27Q+QM/M11WOsxqAalJFLk+3exW0OZ5f1cMSu7zt/MzWHw79FqR08W6sEZWVjoWWQ73/UifuLIIPynExslw3U6/DE4YoyGfDOGFxS8wvNNwOjfuTNc3uxJXLY5NDxzXZfAMN3/TfLr+vSuX1b+MJb9fQr3n6pG0vjHNFy5mxYqIPMdjWlrBSf6CTJ4MkybBnDk5N6dWroR+/XzdlqKs54ddP3DRX/J+3sd0GcPIBSNJy0qjVZ1WrN+73k9bHGTSKD0znZjRMWS6TI48foSH5z7MhG8m8HyP5xly5ZAi/MXhJyHB15T87XHlG9ftWUfLl1vmWfb1wK9pF9uOlBTYs8efs8uXh7r106g1riYp6TnH15YHthBbLTbf9u7/+H4mfDOBEZ1GcGXslfR8qydNqzflwYQHueeje6hSvgrJacl0iO3AFwO/yPf7rBrlz8WXjj8uaVS8iRKC+m4vA9u3+1lhDx3yySEzXyswO8l35Ii/GK9cuejHZ6EKqnc4GLh7DJz/qN944Lw690gFeiSm5nnr7c26MSnyK+i9AirF+/ZPMS6WnfPnix9/9MnJ01YiMz3ZzzaZedRf5JeviYtpwIB/3cT0NdOZet1UBrQaQEpaCrXG1jp2U7RlzZasvmd1wbU8f3wRfhgB7d+B2h3899T0StDpA2gYGDKU/R0VXQf6/yfnuuIk7YtlO5Zx6UTftp41YBZXN+8D+5bC7q8C9RLx/5nNBx9XY+vMsz15O7PWzeL21rdTPrI8O3bA3Ln+PJU9IVtkpK8je/zxkZWVxaUTL2XFrhUAXHfedcy40Q+Py74hMa77OB5q/TuY1SxwUypXBupt871bL/+Lb8dlLytfwyeNsm9elVR7MQydtqRRYGO9gRfwBTEmOedGm9ldAM65v5ivHv0S0BM4DNzunDtpNqg0kkZ+n2DtWl/ANi3N313v3Pn0z3J04OgBur/Znb/1/RtxMRdTv76/C5H7bn+p3dUPccVuMKQdgCM7ICsVDqyCteOh+4KcE8RJGi7OOVr/tTXJqclsuH9D8QqeS5kJqmGZngLv1Ye+66BCncDQxlNr4OZxwqRREOstA3v2+AvLVatyZqJLT4dXXvGFU0OKczC3IzT+LTS9IzDzGT6BFFUCWa4DP8K22ZBxwK87qgoHm9xJtbG1AiPOHUPbD2VMtzE0n9Ccn/b9RI3oGvxy9BfevfFdrj3v2pNvI1vqPvjPVD+zVkQ5/7dFVYFLRhdtRsSZTaHdFKgTuNNZUp+/bwb5pFnrcUXqyVXg8bl4oP8bWo/jWK+99GSIyT+F78SlExk0exCRFklkRCRpmWm0b9ieL+/4Mt97z2SH0w9TaUzeLsdRFsUfD6WxZo0xejTEx/v2zCefwM03F229PXv6BNGgQTntjLQ03xNxyhQ/4UZRej3f8q9beHvV24AvFL7roV00n9D82Mxh4GercyOzgkoaAdT/v/rsTNlJdFQ0aRlpZJHFwtsW0rFxx6KtIMz06eNjNHBg/l4cI/49gicXPgnA4MsG81LvlwpYg7d8x3LaTPS15KZdP40bL7ixwPe98u0rDP5oMJEWSVREFKmZqXRq1InPb/+cq6ZcxYLNCwA48OiBgntOZhyGz7r6hHWzu/yFWfpBf8FdDOGWNDqtCkoaXQg8dSH0WujPr5ExPhblKlN3XF2SDicRExXDkYwjJPUbSe0D30D7qf6G7yncVJgxww/3e+klaNvWx2v9et/zqCxkZWXlSQqt2LmC1n/1Xbp2PbTr2EyZ+Xx4AdTrBpeMyelV9Lb5WXmveM3/P1qET1R990f/WW49FqLr+qTP3u/8zJyF+GrLV+w/up/ezXuX1J96Vjpw9ADVn/WJoNRhqZSPzMksZWRlEBURBTvnw/fDoMucnI4M2Z/tju9DbP+8ywAa/RbaPAfR9f2HeN8yqFk6vblC2WlNGpWW0koahaonn4TPPoO33/bd9CIiYPNmP7vU2SaoBkPGET8Uo+s8Pxwu+4Ix41BwU2ZLyAm6Ybl5GqwcBm1fgtpX+mE32z6G+CJedRWmoOFpWWln/N2kMpeeAiuH++ERNVr75M7eb6HPylLbZPbQIYCDjx6kSoUqzNs4j+5vdgegWoVq7H90/4lWUfLWjIXdi6D92znnvJI4/825HFo9Bg0DhW9PcrFR4PHpHOyYA+tfBReoQ1OuGiS8mS8htv3gdhqMb5Bn2dAOQxnTdUxwf0cYih4VfezOOfiZt7Y/uJ3ERJg5019DRkdDy5a+G3tR7nskJMBDD5GvntrPP8Ntt/kehgkJftbL2bNh3ryC17P1wFYaveBnAJs5YCZ9W/Rl8vLJDJw5kCY1mrDxl430a96PmTd/EHTSqNPkTnyxJW8Pl9THUykfFWz3jdD03Xd++OCsWb5HfGamvxNfsSKkpKVQ5WlfyKUoQzYvePkCNu3fxKHHDhV6Yyx3LLMN7zScJ656gh3JOzj3+XMZ1nEYT3V5qvANOefPP0kLfI/08uf4HuiRRb/ToKTRKfjPNN9bon4Pn6Q7nAiXv8r01dP57QzfVa1/i/68H18XYupAq5F+ZtC3c30WitETdc8e+Mc//EzKGRk+cf3II6Fzo3v4/OE0qt6IO9vcWfAbstJ9r6Kr10PluJzl2f8ftdrDrwb5XrUH1sD5f4J9y2HT3+HwNn+jsXorOP+R0Jhd9QyXmuG//ypEFXIeObAG5veAfhvyjzK5/K9+9sTjbw73WuZLAhxO9DfEqp0PrYaedfFU0ihMzZgBL7wASUn+CzMuDj78MATv6peyoBsM22b7YRSthkPdzv6Cad0EaP9Wie2jlL0SaVgmb/A1YJIW+C+N+j19IclgvjQyDsGim33DokEff6dqx6e+ILSUPucgIxmI8ImSUuw5uO/IPmqOrcnFdS9mxV2++3SWyyLySf/5mXj1RH5/6e9LbfsFykyDL2+A1D2+0Vu+BuxdAhePCm69n1zhhz/EBnpNnaQHU0kcn3XG1mH3kd3UjKnJ3iN72TZkG+dWPTe4lYahflP7MWv9LBpUbsC2lG08kvAIz3R/Jqh1Dh7sY/TsswX3Itq0CRITfQ+X+HioW7fwdVUeU5lD6YfIGp6FmZGWmUaFURWODWdaNHAR7RslBJ00mrR8EnfMvOPYeutVqseOh4o9EW9Y+fJLuPdeX5e/Vi1/kb5mjX/tqQVPcTDtION6jCux7dUeW5s9R/YcO+Z2PriTupVPEPxSoKTRKcrK9CUj0g74837FhqRlpVNhlL+IWHzHYq7YPtkn8i56wifqw7QndNB+WQH/7gP9N/l6TpD3Rsh1eyBpoe9dVDkeancMm6nRz1qzW0H8rX4SkajKPjG4cQr8/DfoOj/nxllWetF6bZ8llDSSsBYX54cPipxI48a+N17IOrTVNzrI8uPlK8eX9R5JKUhKSaJqdFWio3IqRnZ4vQOLEheRPDSZyuWDq/F2Spzz9RMS34fUX3yRzya35sz+dyq+vdf3xmv9HJQ7ea+lkrjw+9Onf+K5r32NuXNizmHvw3uDW2GYmrNhDr3e6kWbem1YtnMZ6+5dR/OazYNa57JlfojaN9/4hFBMTOEFr08muy2ZuwdL1793Zf6m+QBk/L8MoiIjg04aZQ/Vi68ez6b9m3jqqqcY1mlY8Xc4DP3yC+zfD/XrB1+c9kT++MkfGb94POAnhdn5UOlM3nAiShqVrOwh01nDs7CfX4ct06Dju35mzbPVjrmw6inoPCunlMAp9rqSEHFgLcztAHV+DbHX+AlWNk72Pf/LVYWLx/h2+M55EHdTWe9tyChq0ihcSi7LWSakEwEiRVUpFuJvKeu9kFJWp3L+egnzbp1HcmoZJYzAX3XVvMz/KymNboCvboaLnvLdvyMi/XDgkqgZVYhuTbodSxrd3CrIYaNhrH1sewB+SPoBgGbnNAt6nW3a+ALLHTrAnXf6WS/fe8/XMyqugoY7Dbp0EPM3zaftuW1LbKariuUqUqdiHTbt98XQOzfuXCLrDQc1avh/pa1H0x7HkkY3X3j2HnNnkvX3rc950qAvLL0PDq6D6hf6YYOZqcUaPnhGcBmBHuW5kkPRdXN6XUn4qXaeH5728yTY9KZPFF0yFup0gtWjYUFP3wuvSjOfVIoMxVldQpeOChERkRIWHRVN7Uq1y3o3SladTlCpMczr7OtGHd0FP79Wqpts36j9scc9mvYo1W2FsioVqhBBBOlZ6XSI7VBikzX8+c9+eNq0ab7YcmKiL4ZdEnr9qhcAfZv3LZkVBtx8UU4i47IGJZgUFQA6NMqZKvxsPubOWDF14Vd3wsL+sPlNSNkMm8/C0g1RlX3NrdzDlP5rp+9hdDYN0zvTlK8B5z0IXT6FjjOgQW8/o/clT8P1+3xs+/6ohNEpUE8jEREROTkz6DQTvrgWFvT1Q91cBrS4r9Q2mbun1pk6Q1ZR3XDBDUxbPY0BrQaU2DrN4JZb/L+SVqVCFdKGpZVYL6NsXeK68MLiFwDyDAmVkpH7mMvu4SZnmDbP+95FS++HiPJ+oo6mA8t6r06vaudD8rqcmVazZWX6XrQikod6GomIiEjRRNeC7l/42SnbTYKr15b6JiuX8xex1aOrl/q2Qln2UKzOceEzJKtcZDkigqmjVYDsnjCt6rQq0fVKjpjAkNMqFc7imjdnsohycMVE6LMGOvzT/zzbVKjpe6Vs+xCyMnKWZx0tu30SCWHqaSQiIiLFU6vdSd/SuHFJTTaTDICNLIl1hbO7gbu5cGRZ78epK+jz0Lhx8dZRI8YX9undrHcJ7JEUJHFIIslpyWW9G1LaKsflnW7+bFP/N7ByuJ/llsqQdQR2fe6HNIlIHpo9TURERERKlWZFlaIK+ZlR5cxw4EeY0wYqxsJFT/ri4KtGwU0lVNhNJAxo9jQRERERCQlKAohISKnWElr+EX4cD4sG+Dp9URqSKVIQJY1ERERERETk7HLxKKjSHH78P4iu52s9iUg+ShqJiIiIiIjI2afJ//h/IlIozZ4mIiIiIiIiIiL5KGkkIiIiIiIiIiL5KGkkIiIiIiIiIiL5KGkkIiIiIiIiIiL5BJU0MrNzzGyumf0U+FmjkPdNMrMkM1sVzPZEREREREREROT0CLan0aPAZ865ZsBngecFeQPoGeS2RERERERERETkNAk2adQfmBJ4PAW4pqA3OecWAvuC3JaIiIiIiIiIiJwmwSaN6jrndgAEftYJdofM7H/NbKmZLd29e3ewqxMRERERERERkVMQdbI3mNk8oF4BLz1e8rsDzrmJwESAtm3butLYhoiIiIiIiIiInNhJk0bOuW6FvWZmu8ysvnNuh5nVB5JKdO9ERERERERERKRMBDs8bSZwa+DxrcAHQa5PRERERERERERCQLBJo2eA7mb2E9A98BwzO9fMPsp+k5lNBb4GWphZopndEeR2RURERERERESkFJlzoVs2yMx2A/85bnEtYE8Z7I4ET7ELT4pb+FLswpPiFr4Uu/CkuIUvxS48KW7hS7ELT4XFrbFzrvbJfjmkk0YFMbOlzrm2Zb0fUnyKXXhS3MKXYheeFLfwpdiFJ8UtfCl24UlxC1+KXXgKNm7BDk8TEREREREREZEzkJJGIiIiIiIiIiKSTzgmjSaW9Q7IKVPswpPiFr4Uu/CkuIUvxS48KW7hS7ELT4pb+FLswlNQcQu7mkYiIiIiIiIiIlL6wrGnkYiIiIiIiIiIlLKwShqZWU8zW2dmG8zs0bLeHymYmcWa2b/NbK2ZrTazPwSWn2Nmc83sp8DPGmW9r5KfmUWa2XIz+zDwXHELA2ZW3cxmmNmPgWPvSsUu9JnZkMB5cpWZTTWzaMUtNJnZJDNLMrNVuZYVGiszGxpor6wzs9+UzV4LFBq7cYHz5Uoze8/Mqud6TbELAQXFLddrD5mZM7NauZYpbiGisNiZ2X2B+Kw2s7G5lit2IaCQc+UlZrbYzFaY2VIzuzzXa4pbCDiVa+/ixi5skkZmFgm8DPQCzgduMrPzy3avpBAZwIPOufOAdsDgQKweBT5zzjUDPgs8l9DzB2BtrueKW3h4EZjjnGsJXIyPoWIXwsysAXA/0NY51wqIBAaguIWqN4Cexy0rMFaB77wBwAWB33kl0I6RsvEG+WM3F2jlnLsIWA8MBcUuxLxB/rhhZrFAd2BLrmWKW2h5g+NiZ2ZXAf2Bi5xzFwDPBZYrdqHjDfIfc2OBJ5xzlwDDA88Vt9BSrGvvU4ld2CSNgMuBDc65jc65NOAd/IlHQoxzbodzblngcTL+4rUBPl5TAm+bAlxTNnsohTGzhkAf4LVcixW3EGdmVYFOwOsAzrk059x+FLtwEAXEmFkUUBHYjuIWkpxzC4F9xy0uLFb9gXecc6nOuU3ABnw7RspAQbFzzn3qnMsIPF0MNAw8VuxCRCHHHMB44GEgd2FWxS2EFBK7u4FnnHOpgfckBZYrdiGikLg5oGrgcTV8OwUUt5BxCtfexY5dOCWNGgBbcz1PDCyTEGZmcUBrYAlQ1zm3A/yHG6hTdnsmhXgB3xDLyrVMcQt9TYDdwOTA0MLXzKwSil1Ic85tw99p3QLsAA445z5FcQsnhcVKbZbwMhD4OPBYsQthZtYP2Oac+/64lxS30Ncc6GhmS8zsczO7LLBcsQttDwDjzGwrvs0yNLBccQtBRbz2LnbswilpZAUs09RvIczMKgP/Ah5wzh0s6/2REzOzq4Ek59x3Zb0vUmxRQBvgVedca+AQGtIU8gJjy/sD8cC5QCUz+13Z7pWUELVZwoSZPY7v2v9W9qIC3qbYhQAzqwg8jh8ik+/lApYpbqElCqiBHz7zJ2C6mRmKXai7GxjinIsFhhDo1Y7iFnKKce1d7NiFU9IoEYjN9bwhOd3jJMSYWTn8h/Yt59y7gcW7zKx+4PX6QFJhvy9loj3Qz8w244d/djGzf6C4hYNEINE5tyTwfAY+iaTYhbZuwCbn3G7nXDrwLpCA4hZOCouV2ixhwMxuBa4GbnHOZTeYFbvQ1RSfZP8+0FZpCCwzs3oobuEgEXjXed/ge7XXQrELdbfi2ycA/yRnGJPiFkKKee1d7NiFU9LoW6CZmcWbWXl88aaZZbxPUoDAXYPXgbXOuedzvTQTf+Ih8POD071vUjjn3FDnXEPnXBz++JrvnPsdilvIc87tBLaaWYvAoq7AGhS7ULcFaGdmFQPnza74ceiKW/goLFYzgQFmVsHM4oFmwDdlsH9SCDPrCTwC9HPOHc71kmIXopxzPzjn6jjn4gJtlUSgTeA7UHELfe8DXQDMrDlQHtiDYhfqtgOdA4+7AD8FHituIeIUrr2LHbuokt3l0uOcyzCze4FP8DPMTHLOrS7j3ZKCtQf+G/jBzFYElj0GPIPvinoH/mLphjLaPykexS083Ae8FUiqbwRux98YUOxClHNuiZnNAJbhh8csByYClVHcQo6ZTQV+DdQys0RgBIWcH51zq81sOj55mwEMds5llsmOS2GxGwpUAOb69jaLnXN3KXaho6C4OedeL+i9iltoKeSYmwRMMj+dexpwa6CHn2IXIgqJ2++BFwMTdhwF/hd0zIWYYl17n0rsLKc3roiIiIiIiIiIiBdOw9NEREREREREROQ0UdJIRERERERERETyUdJIRERERERERETyUdJIRERERERERETyUdJIRERERERERETyUdJIRERERERERETyUdJIRERERERERETyUdJIRERERERERETy+f/rw9gqBUcgeAAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1972,7 +1862,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABIcAAACMCAYAAADm+clLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3de3yU5Z3//9c1M5mcz4EESIAAgYAICBE8Va2K567b7cnDdlvbrnVbu9u6a227/bW77e72tO223XVrPXVr19baqt+6VmvVtioqKESOckgIhCRAQg4Tck5m5vr9kRkMkJAJJLnvybyfj0ceMPfcM/NJcuWeez735/pcxlqLiIiIiIiIiIgkJo/TAYiIiIiIiIiIiHOUHBIRERERERERSWBKDomIiIiIiIiIJDAlh0REREREREREEpiSQyIiIiIiIiIiCUzJIRERERERERGRBOZzOoDhFBQU2Llz5zodhoiIiIiIiIjIlLFp06Zma+20E7ePmhwyxjwEXA80WWuXDnO/AX4AXAt0Ax+11lZG7rs6cp8XeMBa+81Ygp07dy4bN26MZVcREREREREREYmBMaZ2uO2xTCv7H+DqU9x/DVAW+boN+FHkBb3APZH7lwA3GWOWxB6yiIiIiIiIiIhMtFGTQ9bal4HWU+xyA/CwHbQeyDHGzABWA9XW2hprbT/waGRfERERERERERFxifHoOTQLqBtyuz6ybbjta8bh9URERMbN+poWfvLqPrr7Q5P2mj6P4b0ri3nPshkMzs6WeFF5oI2fvV5Lc2ffGT2P3+vhjssWcM7s3HGKTEREROT0jUdyaLizWnuK7cM/iTG3MTgtjdmzZ49DWCIiIiOrOdLJN57dxfNvNzItM5mS3NRJe+3mzn7+9hdv8dC6fXz5usVUzM2btNeWsbPW8qc9R7j3T3vZsK+VrBQfC6ZnnNFz7mrr4ab71/Pft6zksvLCcYpURERE5PSMR3KoHigZcrsYOAj4R9g+LGvtfcB9ABUVFSMmkURERM5Ea1c/P3hhD49sOECyz8NdVy3i4xeVkpLknbQYQmHL45X1/Ptzu3n/va9zzdIivnBNOXPy0yctBhldMBTm6a2HuPelvew63MGM7BS+fN1iblo9m/TkMzuFOtLRx63/8wZ//fAmvvEXZ/PBipLRHyQiIhOqpbOP3mD4pO15aX5S/ZN3niDihPFIDj0F3GGMeZTBaWPt1tpDxpgjQJkxphRoAG4Ebh6H1xMRETmlg4Ee7nu5hr7g8VPFgiHL73YcpqsvyE2rZ/PZKxYyLTN50uPzegwfrCjh+mUzuP/lffz45b28sLOR2y6exz9cuUhTzVziH5/czi831lE2PYN//8By/mz5TPy+WNbyGN20zGQeve18bv/ZJj7/660c6ejjU5fO1+9eRMQh62tauPG+9cPel52axJeuLeeDFSU6TsuUFctS9r8ALgUKjDH1wFeBJABr7b3AMwwuY1/N4FL2t0buCxpj7gCeY3Ap+4estTsm4HsQERE5xlrLP/xqC2/ubyU3zX/S/WtK87n76kWUFWY6EN3x0vw+/u6KMm5aXcI3nt3FPX/cS1FWCh8+f67ToSW8LXUBfrmxjlsvnMv/d90SPJ7x/zCQkezjoY+ey12/3sJ3nttN09FevvKes/BOwGuJiMip3fPHagoykvn8VYuO226xPF7ZwN2Pb+Pxygb+7b1nn/HUYhE3GjU5ZK29aZT7LfDpEe57hsHkkYiIyKR4eushXtvbwtdvOCtukizTs1L47geW09bdz9ef3snKObmcNTPb6bASlrWWrz39NgUZydy5duGEJIai/D4P//HBFUzLSOaBdfsI9Azw/Q+t0JVpEZFJtL2hnVeqmrn76nI+eO7J03w/sKqEX22q49+e2cU1P3iZv7l0AZ+6dP6kTkkXmWjjMa1MRETEFTr7gvzLb99m6awsbl4zx+lwxsTjMXz3A8u59oevcMfP3+L/PnMRGWfY10ZOz/9tPcSm2ja+9b6zyUxJmvDX83gMX75+CenJPn7wYhVXn1XENWfPmPDXFRGRQT96aS+ZyT5uOW/4hZE8HsOHzp3NZeWF/Mtv3+aHL1bx9JaDnDc//6R9CzNT+NvLFyjJL3FnfCbOi4iIuMAPXthDU0cfX79haVxOzcnPSOaHN55DbUsX//jkNgaLc2Uy9Q6E+OYzOzlrZhbvXzW5TaI/c9kCyosy+Zff7qSnPzT6A0RE5Iztb+7i2W2HuOW8OWSNckFgWmYyP7jxHH76sdX4fR5+v6PxuK+ntxzkP17Yw94jXZMUvcj40SVJERGZEnYf7uChV/dz47klnDM71+lwTtuaefl87oqFfPf5PVw4v2DY8naZOPe/XMPB9l6+96EVk55g9Hk9fPU9Z3HT/ev58ct7+ewVCyf19UVEEtF9r9Tg83r42IVzY37MJQunccnCaSdt33Gwnet+uI7dhzvUl0jijiqHREQk7llr+cpvtpOZ4uOuq8qdDueMferdC7hwQT5feWo7exo7nA4nYRxu7+W//7SXa5YWcd68k6cKTIbz5+dz3bIZ/OhPe6lv63YkBhGRRNF0tJdfb6zn/auKmZ6VcsbPt2B6Bl6PYdfho+MQncjkUnJIRETi3m82H2TDvlY+f1U5eeknr1AWb7wew398aAUZyT4+/UilphhNkm8/t4tQ2PLFaxY7Gsc/XrsYY+DfntnpaBwiIlPdQ6/uJxgOc9u75o3L8yX7vMyfls7OQ7qwI/FHySEREYlrR3sH+NdndrK8JIcbp9AUrOmZKXz/Q+dQfaSTy7/7J/7pqR28treZYCjsdGhT0pa6AE9UNvDxd5UyOz/N0Vhm5qTy6UsX8My2w7xa3exoLCIiU9XR3gEeWV/LNWfPYG5B+rg9b3lRliqHJC4pOSQiInHt+89X0dzZx9dvOGtClxx3wkVlBdz34QqWzMzmF28c4Ob7N7DqX17gzl9u5oW3G9WwepwMXbr+U5fOdzocAP764nmU5KXyz/+3gwElBEVExt0j6w/Q0Rfkby4Z3+N++YxM6tt6ONo7MK7PKzLRlBwSEZG41dUX5OHX9/OhihKWFec4Hc6EWLukkAc+UsFbX1nLvX+5issXT+fFXU184uGNVDV1Oh3elFB5IMCm2jY+t7ZsUpauj0VKkpcvX7eEPY2d/O/6WqfDERGZUnoHQjy4bh/vKitg6azscX3uxUVZAOw5rKllEl+UHBIRkbi1raGdYNhy1VlFTocy4dL8Pq5eWsT3PriC+/+qAoDGo70ORzU1bKptBXDdOLpySSHvKivge8/voaWzz+lwRESmjCcqG2ju7Bv3qiEYrBwC2KnkkMQZJYdERCRuba0PALCseHyv+rldXvpgdUtbt0rWx0NlbYA5+WkUZCQ7HcpxjDF89T1L6OkP8cC6fU6HIyIyZfz0tf0sK87m/PnjvzJlUVYK2alJ7DqkvkMSX5QcEhGRuLWlrp2SvFTyXfahfqLlpg2uyNbW1e9wJPHPWsumA22snJ3rdCjDWjA9k3Nm57C+psXpUEREpoSmjl52N3Zw7dkzMGb8exUaYygvymSXKockzig5JCIicWtzXYDlU7TX0Klkpw5WDrUqOXTG6tt6ONLRx8o57kwOAayck8v2hnZ6B0JOhyIiEvfe2Dc4lXhNad6EvUZ5USa7D3cQDmvhCIkfSg6JiEhcOtLRR0OgJyGTQz6vh+zUJNq6lRw6U5UH2gBYOdu942jV7FwGQpZtDe1OhyIiEvc21LSS5veOeyPqocpnZNHZF6Qh0DNhryEy3pQcEhGRuBTtN7S8xL0f6idSXrpflUPjYFNtG+l+L4sKM50OZUSrIlVNm2rbHI5ERCT+bdjXwqo5uSR5J+6jcHlRpCm1+g5JHInpL8IYc7UxZrcxptoY84Vh7r/LGLM58rXdGBMyxuRF7ttvjNkWuW/jeH8DIiKSmLbUt+MxsHRWltOhOCI3LYmAGlKfscoDbayYnYNvAj8knKn8jGRKC9KVHBIROUMtnX3saezkvHnj34h6qIWFmRiD+g5JXBn1TMgY4wXuAa4BlgA3GWOWDN3HWvsda+0Ka+0K4IvAS9ba1iG7vDtyf8U4xi4iIglsS12AhYWZpPl9TofiCFUOnbnu/iA7D3W4thn1UCtn51JZ24a16l8hInK6ov2Gzps3cf2GANKTfczJS2PXYVUOSfyI5TLZaqDaWltjre0HHgVuOMX+NwG/GI/gREREhmOtZUt9gBUJOqUMICfNr55DZ2hLXTuhsHV1M+qoirm5tHT1s7+l2+lQRETi1oZ9raQkeTh71sSfP5QXZbHrkCqHJH7EkhyaBdQNuV0f2XYSY0wacDXw+JDNFvi9MWaTMea20w1UREQk6kBrN4HugYTtNwTvVA6pkuT0HWtGXeL+5JD6DomInLn1NYP9hvy+iZ9KXD4jk30tXfT0a6VJiQ+x/FWYYbaNdCb6HuDVE6aUXWitXcngtLRPG2MuHvZFjLnNGLPRGLPxyJEjMYQlIiKJanPdYDPqZcUTt9KI2+Wm+ekLhunR8uanrbK2jQXTM8hOS3I6lFEtmJZBZoqPTbWto+8sIiInCXT3s7uxgzWlE9tvKKq8KAtrYU+jqockPsSSHKoHSobcLgYOjrDvjZwwpcxaezDybxPwJIPT1E5irb3PWlthra2YNm1aDGGJiEii2lLXTkqSh4UuXmFqouWlDyY02tSU+rRYa9l0oM3VS9gP5fEYVs7OVeWQiMhpemNfK9bCmtKJ7TcUtXjG4DmK+g5JvIglOfQmUGaMKTXG+BlMAD114k7GmGzgEuA3Q7alG2Myo/8HrgS2j0fgIiKSuLbWB1g6M3tCl6F1u9w0PwBtakp9Wmqauwh0DxybrhUPKubksqexk/YeJQRFRMZqw75W/D7PpE1JL8lNI83vZaf6DkmcGPWs2lobBO4AngN2Ao9Za3cYY243xtw+ZNf3Ar+31nYN2VYIrDPGbAHeAH5rrf3d+IUvIiKJZiAUZvvB9oTuNwSQmz6YHNKKZaenMlKBEw8rlUVFE1nRXkkiIhK7DftaOKckh5Qk76S8nsdjWFSUqcohiRsxrf9rrX0GeOaEbfeecPt/gP85YVsNsPyMIhQRERliT2MHvQNhJYeilUNasey0VB5oIyvFx/xpGU6HErPlJTl4PYbK2jbevWi60+GIiMSNo70DvH3wKHdcVjapr1telMWz2w9hrcWY4Vr5irhH4tbji4hIXNpS1w7A8gRuRg2Dq5WBKodOV2VtgJVzcvF44udkPT3Zx+IZmeo7JCIyRhv3txK2cN68yek3FLV4RiaB7gEaj/ZN6uuKnA4lh0REJK5sqQuQk5bE7Lw0p0NxVHZqEsaoIfXpONo7wJ6mjriaUha1anYum+sCBENhp0MREYkbG2pa8Xs9k37cLy/KAmCnppZJHFBySERE4sqW+gDLi3MSvjzb6zHkpCapIfVp2HwggLXEVTPqqJVzcunuD7HrsBqciojEav2+VpaXZE9av6GoRUWRFcvUlFrigJJDIiISN7r7g+xp7Ej4fkNRuWl+WtVzaMw21bbhMcTlOKqYOzglQlPLRERi09kXZHtDO2tK8yf9tbNTk5iVk6qm1BIXlBwSEZG4sb3hKGELK0oSu99QVG66X5VDp6HyQBuLirLISI5pXQ5XmZmdQlFWipJDIiIx2lTbRihsWTPJ/YaiyosyVTkkcUHJIRERiRtb6gIALCuOv4qPiZCb5ldD6jEKhS2bDwRYOTs+x5AxhlVzcpUcEhGJ0YaaFnwe49hU4vIZmew90klfMOTI64vESskhERGJG5vrA8zKSaUgI9npUFwhLz1JS9mPUVVTBx19wbjsNxS1ak4uDYEeDrX3OB2KiIjrbdjXytnF2aT5nakWLS/KIhi27G3qcuT1RWKl5JCIiMSNrfUBVsRhn5iJkpvup617AGut06HEjcraweqzeFypLCqa2Ip+LyIiMrye/hBb6wOO9BuKWjwj0pRafYfE5ZQcEhGRuNDS2Uddaw/L1W/omNw0P/3BMN39KlWP1abaNvLT/czJT3M6lNO2ZGYWKUkeNta2Oh2KiIirVR5oYyDkXL8hgLn56fh9HnZrlUlxOSWHREQkLmytbwdgufoNHZOX5gdQ36ExiFafGWOcDuW0JXk9LCvOoVJ9h0RETil6nKxwcCqxz+uhbHoGO5UcEpdTckhEROLC5roAHgNLZ6lyKCo3fTA5pL5DsRkIhdnX3MWiokynQzljFXNy2XHwKD2qGhMRGVFVUyclealkpiQ5GsfCwkyqG5UcEndTckhEROJCVVMHc/LTSY/D5ccnSl764MmuKodiU9vSRTBsKSvMcDqUM7aiJIdg2PL2oXanQxERca2qpk7Kpjt/QWDB9AwOtvfS0TvgdCgiI1JySERE4kJDWw/FualOh+EquZFpZYFunWzGoqqxE8AVHxTO1OIZWQDsPtzpcCQiIu4UClv2HumkbLrzFwSiMew9ohXLxL2UHBIRkbjQEFBy6ES56jk0JlVNnRgD86c5/0HhTM3KSSXN72WPpimIiAyrrrWb/mCYBW5IDhUOXpSo0jFbXCym5JAx5mpjzG5jTLUx5gvD3H+pMabdGLM58vWVWB8rIiIymp7+EM2d/czKUXJoqKzUJDxGPYdiVdXUSXFuKql+r9OhnDGPx7CwMFOr34iIjKCqKVItWuh8tWhJbip+n4fqJlV7inuN2rjBGOMF7gHWAvXAm8aYp6y1b5+w6yvW2utP87EiIiIjagj0AFCcG7/Lj08Er8eQk+ZX5VCMqho7psSUsqhFhZk8v7MRa21cr74mIjIRqpoGk+duqBzyeT3MK0g/lrAScaNYKodWA9XW2hprbT/wKHBDjM9/Jo8VEREB3kkOzdK0spPkpiWpcigGwVCYmuYuV/SeGC+LijJp7eqnuVO/fxGRE1U3djIzO4UMlyxkUVaYeSxhJeJGsSSHZgF1Q27XR7ad6HxjzBZjzLPGmLPG+FgREZER1bd1A2ha2TBy0/y0dakh9Wjq2npc03tivCwqGqyC0tQyEZGTVTV1ssAFU8qiyqZnUN/WQ3d/0OlQRIYVS3JouDple8LtSmCOtXY58J/A/xvDYwd3NOY2Y8xGY8zGI0eOxBCWiIgkioa2HnweQ2FWitOhuE5uul+VQzGINgF1Q++J8XIsOaQGpyIixwmHLdVN7lipLKpsegbWQo1WLBOXiiU5VA+UDLldDBwcuoO19qi1tjPy/2eAJGNMQSyPHfIc91lrK6y1FdOmTRvDtyAiIlNdQ6CHGTkpeD3qq3KiPPUcikm0z8NUqhwqyEgmP93PHlUOiYgcpyHQQ89AyF3JocLBWDS1TNwqluTQm0CZMabUGOMHbgSeGrqDMabIRDohGmNWR563JZbHioiIjKa+rUdTykYQrRyydtjCXImobnJX74nxsrAwk12qHBIROU71sZXK3JMcmpOfjs9jqGpUU2pxp1GTQ9baIHAH8BywE3jMWrvDGHO7Meb2yG7vB7YbY7YAPwRutIOGfexEfCMiIjJ1NbT1aKWyEeSlJzEQsnT2qYfBqVQ1dbiq98R4WVSUSVVjB+GwkoMiIlHHViqb5p7jfpLXQ6lWLBMXi+nyWWSq2DMnbLt3yP//C/ivWB8rIiISq/5gmMaOXlUOjSAnzQ9AoHuAzJQkh6Nxp2jviVvW5DsdyrhbVJRJd3+IhkAPJXlKoIqIAFQ1djI9M5nsNHe9Ly6YnsEuTQUWl4plWpmIiIhjDrX3YK2WsR9JXiQ5pL5DI2sI9NA7EHZV74nxEm1KrQ8bIiLvqGrqdGWPubLpGdS2dNE7EHI6FJGTKDkkIiKu1tDWA0CxkkPDyk2PJIe0YtmIotML3NR7YrwsjEyV26O+QyIiAFjrvpXKohYUZhK2sK9ZK5aJ+yg5JCIirlYfiCSHcjRlZjh5keRQmyqHRhRt/umm3hPjJSPZR3FuqiqHREQiDh/tpbMv6Mo+c9GElfoOiRspOSQiIq5W39aDMVCUneJ0KK6kaWWjq2pyZ++J8bKoMFPL2YuIREQvCLixcqi0IB2PgWpVe4oLKTkkIiKu1tDWQ1FWCn6f3rKGk5niw2MGG1LL8KqaOqfklLKohUWZ7D3SSX8w7HQoIiKOi1bluDE5lJLkZU6+ViwTd9KZtoiIuFpDoFsrlZ2Cx2PITfOr59AIrLVUN3ZQNt190wvGS3lRJsGwVQ8LERGguqmDvHQ/+RnJTocyrAXTM5QcEldSckhERFytvq1HK5WNIjfdr55DIzjU3ktXf8iVq9aMl2hT6t2apiAiQlWjO1cqiyqbnsH+5i5Ve4rrKDkkIiKuFQpbDrf3aqWyUeSl+dVzaARunl4wXuZPy8DnMew+fNTpUEREHGWtHZxK7OJjfllhBsGwpbZF1Z7iLkoOiYiIazUe7SUYtszSSmWnlJueRJumlQ2rqjG6jP3UnVbm93koLUhn92FNUxCRxHaks4/2ngF3J4ci05w1tUzcRskhERFxrfq2wWXsNa3s1HLT/LSpIfWwqps6yU/3k5fudzqUCbWwKJM9mlYmIgmuOrpSmYsvCMyfloEx76yqJuIWSg6JiIhrNQS6ATStbBTRnkPWWqdDcZ2qJnf3nhgv5YWZHGjtpqsv6HQoIiKOiYepxKl+L8W5qVQ1KaEv7qLkkIiIuFZDtHJIq5WdUl6an2DY0qHEwHGstVQ1dkzpZeyjFhZpmoKISFVTB1kpPqZlunOlsqiy6ZlU63gtLqPkkIiIuFZ9Ww8FGX5SkrxOh+JquZEpU1qx7HhHOvo42huc0svYR5VHkkNqSi0iiayqsZOywkyMMU6Hckpl0zOoOdJFMKQVy8Q9lBwSERHXagj0MCtXzahHk5eeBKAVy04QD9MLxktJbhqpSV41pRaRhFbt8pXKohZMz6A/FOZAa7fToYgco+SQiIi4VkNbD8WaUjaqnLTByqGAmlIfJ7pS2YIEmFbm8RgWFmaoKbWIJKyWzj5auvrjos9ctGG2pgKLm8SUHDLGXG2M2W2MqTbGfGGY+28xxmyNfL1mjFk+5L79xphtxpjNxpiN4xm8iIhMXeGwpT7Qo5XKYpAXSQ6pcuh4VU2dZKcmMS3D3b0nxsvCwkx2HVZySEQSU7SHj5tXKouKJrDUd0jcZNTkkDHGC9wDXAMsAW4yxiw5Ybd9wCXW2mXA14H7Trj/3dbaFdbainGIWUREEkBzVx/9wbBWKovBsZ5D3UoODVUVmV7g9t4T42VRUSbNnX20dPY5HYqIyKSLp6nEGck+ZmanHKtwFXGDWCqHVgPV1toaa20/8Chww9AdrLWvWWvbIjfXA8XjG6aIiCQarVQWu6wUH16PUeXQCaqbOhNipbKoRZGm1HsadSVaRBJPdVMn6X4vM7JTnA4lJgsKMzWtTFwlluTQLKBuyO36yLaRfBx4dshtC/zeGLPJGHPb2EMUEZFEVB9NDqlyaFTGGHLT/KocGqKls4/Wrn4WJMBKZVGLCrVimYgkrqqmDhbEwUplUWXTM6hu6iQUtk6HIgKAL4Z9hvvrGnYEG2PezWBy6KIhmy+01h40xkwHnjfG7LLWvjzMY28DbgOYPXt2DGGJiMhU1hBQ5dBY5KYl0dalhtRR8TS9YLxMy0wmNy2J3aocEpEEVNXYycULpzkdRszKpmfQFwzz2t5mCrOOr3aanpl8bLEJkckSS3KoHigZcrsYOHjiTsaYZcADwDXW2pbodmvtwci/TcaYJxmcpnZScshaex+RXkUVFRVKn4qIJLiGth6yU5PITElyOpS4kJvup1WVQ8fsOjRYPZNI08qMMSwqyuTtQ6ocEpHE0tLZR1NHX1xdECifkQXAhx9846T7ZuWksu7ud8dNFZRMDbEkh94EyowxpUADcCNw89AdjDGzgSeAD1tr9wzZng54rLUdkf9fCXxtvIIXEZGpq76tW1VDY5CX5mfvEVWMRL22t4WSvFRmZCfWGFpRksuD62roHQiRkuR1OhwRkUnxes1gbcLq0jyHI4nd8uJsfvqx1XT2Bo/bXnmgjQfX7WN3YwflRVkORSeJyFg7epGOMeZa4PuAF3jIWvuvxpjbAay19xpjHgDeB9RGHhK01lYYY+YBT0a2+YCfW2v/dbTXq5ibbTd+9aLRdhMRkSlsS32AlCTvsT4qcmo1zZ20dfWzak78nBhPFItlY20b+el+5hXEz1Xk8dDW3c/uxg6WzMgiS1V3IpIgapo7aenqp2JOLmbYrijxoy8Y4q26AHPy0hLuAodMDvOxZzYNt5J8LJVDWGufAZ45Ydu9Q/7/CeATwzyuBlg+5mhFRCShWSx9wTDZqfpwGyuf18NA2GKxcX9ifKY6+4KEwjYhx09GyuCpXUdvUMkhEUkY7T0DZKUkTYn3v2Sfl5QkL+09A0oOyaSKKTk06QrK4NbfOh2FiIg4JNDVzwe//jxfvmIxn3jXPKfDiQu/f6WGf/ntTrbceGVCJkWG+ukfqvj3/XuovHUtpCdWQ88k4Mvfe4mSnFR+cutqp8MREZlwB1q6ee93/sjX1p7FovPnOh3OuHjiN9v59aZ6Nn/4Svy+WBYYFxmDjw2fRNVIExER14muVFacm+ZwJPEjN7KqSVuXmlKvq27mrJlZ5CVYYijq3Lm5bKptI6zlkUUkAayrbgbgwgUFDkcyfi5cUEB3f4jNdQGnQ5EEouSQiIi4Tn1bNDmkcupYRRMhib5iWXd/kMraABdNoQ8JY7VqTh5He4NUNalBuYhMfa9WNzMjO4V5BelOhzJuzpuXj8fAuqojTociCUTJIRERcZ36tm4ArVY2BrnpqhwCeHN/G/2h8JS6gjxW587NBWBjbavDkYiITKxw2PLq3mYuXFAwpZZ9z05NYllxzrGqKJHJoOSQiIi4TkOgh3S/l5y0xO6dMxZ5kWllrQmeHHq1uhm/18O5cxN31bbZeWkUZCSzaX+b06GIiEyotw8dJdA9MCWrRd9VVsCW+naO9g44HYokCCWHRETEdRraepiVmzqlrgJOtJz0wURaoDuxTyLXVTWzak4uqX6v06E4xhjDuXNzeVOVQyIyxb1SNVhZc8GCfIcjGX8XLiggFLZsqNGxXCaHkkMiIuI69W09mlI2RpnJPnwek2laypYAABpsSURBVNA9h1o6+3j70FEuKpt6V5DHatWcXOpae2g82ut0KCIiE+bV6mbKizKZnpnidCjj7pzZOaQmeXlVU8tkkig5JCIirtMQ6NFKZWNkjCE33Z/QPYde3dsCTK0Va05XdFrdRk0tE5EpqncgxBv7W6fsMT/Z52V1aZ76DsmkUXJIRERcpbMvSHvPALO0UtmY5aX5E7rn0KtVzWSm+Dh7VrbToThuycwsUpO8akotIlPWpto2+oPhKdlvKOqiBQVUN3VyuF1VoDLxfE4HICIiMtSBFq1Udrpy05N4tbqZ6374ynHbfR7DV95zFqvm5DoU2cSz1rKuupkL5ufj9ahXVZLXw/KSbFUOiciUta66GZ/HsLp06i5AEK2KerW6mfetKnY4GpnqVDkkIiKu8qtNdfg8ZkonMibKX543h/Pn5zMjO+W4r7q2Hr729NtYa50OccLUtnTTEOiZ0leQx+rcuXm8fegoXX1Bp0MRERl3r1Y3s3J2LunJU7feobwok/x0v/oOyaSYun9JIiISd1q7+nn0jTpuWDGLmaocGrPrl83k+mUzT9r+6BsH+MIT23hhZxNrlxQ6ENnEi/ZkmKq9J07Hqjm5hMKWzXUB/VxEZEoJdPezraGdz16+0OlQJpTHY7hgQQHrqpux1moVV5lQqhwSERHX+Olr++kZCHH7JfOcDmVKed+qYubmp/Hd3+8mHJ6a1UOvVjczMzuF0oJ0p0NxjZVzcjFGTalFZOp5fW8L1sJFZVNvCfsTXbQgn6aOPqqbOp0ORaY4JYdERMQVuvqC/PT1/axdUkhZYabT4UwpSV4Pn1u7kF2HO3h62yGnwxl3obDltb0tXFRWoKuqQ2SlJLGoMFNNqUVkyllX3UxGso9lxTlOhzLhopWfr1RpaplMrJiSQ8aYq40xu40x1caYLwxzvzHG/DBy/1ZjzMpYHysiIgLw6Jt1BLoH+JtL5zsdypT0nmUzKS/K5PvP7yEYCjsdzrjacbCd9p4BTZ0axrlz86isbZtyv3MRSWzrqps5b14eSd6pX+tQnJvG3Pw09R2SCTfqX5MxxgvcA1wDLAFuMsYsOWG3a4CyyNdtwI/G8FgREUlw/cEwD7xSw5rSPFbOViPqieDxGO5cu5Ca5i6eqGxwOpxxFe03dMF8JYdOVDE3l67+ELsOdzgdiojIuKhr7aa2pTuhFiC4qKyA9TUtDCjRLxMolobUq4Fqa20NgDHmUeAG4O0h+9wAPGwHl0FZb4zJMcbMAObG8NiTBMOW1q7+47al+b2kJHlHDdZaS3vPALG2VPB5DVkpSbHtnKC6+oL0BePrQJSa5CXVP/p4AQiGwvgS4KqDjKy7P0jvQHyN8fEQ63F1MvxmcwOH2nv5xl+c7XQoU9raJYUsL8nhBy9WccM5M0n2ueP3f6ZerW6mvCiTaZnJTofiOhVzB5d43lTbxtJZ2Q5HM7yBUBifx8Q0JTActgR6Bs74NXNSk/B4NAVxvH6eU0WS15Dp0s8FfcEQXX0hp8MYUVaKb0LOpzt6BxgIHf/B7oWdjcBgwiRRXLSggP9df4B11c0sT4CpdOPNTee8kyUYCnO0d2yrlcaSHJoF1A25XQ+siWGfWTE+9iQ7Dx1l5defP26bx0B5URbnzM7hnNm5nDM7h9L8dHqDIbbWt/PWgQBvHWjjrboARzr6Yvi23vF3l5fxubVTu9P96XpsYx1femIbwThrYJqS5OG/blrJFaOsyvPcjsN89tHNfOrS+Xzm8rJJik7cIhy23P9KDd95bnfcjfHxkJ2axE9uPdfxSp1w2HLvS3tZPCOLSxZOczSWqc4Ywz9cuZAPP/gGj75Rx0cumOt0SGfkaO8AP35pLxtqWvlonH8vE2VWTiozslPYWNvmyt93XWs3Nz+wnrQkH1//86WsLs0bcd8NNS185Tc72N145lVQS2Zkcc8tKxOugXmgu5/NdQHeOhCg8kAbm+sCdIzxw8NUd/2yGdx11SLm5LtnbDy34zCf//VW2l2cyCvMSubOtQt538ricUkS1bZ08e3ndvPbrcP3ySvKSmH+tIwzfp14cf68AjwGbv3Jm06HEpdSkjx8/KJSPnnJ/ClfGBIMhXm8sp7vPb+HxqNjy4vEkhwa7rLKiZ+iRtonlscOPoExtzE4JY2CWaX885+dddz9zZ19bK4L8NTmgzyy4QAAmSk+uvtDhCIf6ubmp/GuBQUsnpGF3xfbQemNfa384MUqjIHPXqEE0VC/3lTP3Y9v5fx5+Vx1VpHT4YzJrzfV86lHKrn3wyu5rHz4BNHvdxzm049Ukub38t3n92AM3HGZEkSJItDdz98/toUXdzVx5ZLChOtVYq3lJ6/t5yMPvsHPPrGGFSXOXYV6fmcje4908cObzlEz4Ulw0YIC1pTm8Z9/qOYDFcWk+WM5FXCX/mCYRzbU8p9/qKa1q58/Wz6TT797gdNhuVbF3Dw27ndfU+r6tm5uvG89nX1BwmH44I9f5y9WzuKL1yw+rgrsSEcf33hmJ0+81cCsnFS+dG35GVW99QyEuPelvbznP9fxzfedzfXLZo7Ht+NK1lq2Nxzlme2HeP7txmOrHXkMLCzM5PplMymbnoFXVVTA4Jj82fpanttxmL88bw6fuayMvHS/Y/H0B8N863e7eHDdPs6elc37Vs5y5ftk2Fqe2nKQux/fxgOv7OML15RzWfn004q1pbOP//xDNY9sqMXn8XDbxfOYlZN60n7LirNd+bOYKNlpSTz00XOpbel2OpS4tLG2jXv+uJefbzjA315exi1r5sScL4gX1lr+sKuJbz67i6qmTs6ZncPtl8zHM8zfyUe/NfxzmMGZYCMzxpwP/JO19qrI7S9GXvwbQ/b5MfAna+0vIrd3A5cyOK3slI8dTkVFhd24ceOw94XDlr1HOnnrQIAt9QHy0v2cMzuHFSW5p3XwDoUtn//1Vh6vrOfOtQv5W1WPAPBEZT1//6stXDi/gAc+UhF3ZXjt3QPc8uB69hzu5Md/tYp3L5p+3P0vvN3I3zyyiSUzs3n41tX88//t4Im3GrjrqkX6gJEAKg+08Zmfv0VTRy//eO1iPnLB3IQ6wYg6GOjhxvvW09bdz/9+fA3LHUgQWWv58/9+jUB3Py/eeYmmeE6Sjftbef+9r3P31eVx1QDcWstvtx3i27/bzYHWbs6fl8+Xrl3M2cXunC7lFj99bT9ffWoHL911KTOyj/+Q5fWYCUkMWGtPeVxtCPRw432v0949wCOfOI/509P5rz9Uc/8rNaQkebnrqkXceO5sHn3zAN95bje9AyFuu3ged7y7LOZp46fSEOjhMz+vpPJAgA+fN4cvX7942IRT9Dw5nt4jwmHLW3UBfrf9EM9uP0x9Ww9ej+H8efmcPz+fc2bnsKw4h4zk+EsMT4bGo718/4U9/PLNOtL9Pm6/dD4fu7B0XMbdiU71d1Lf1s0dP3+LzXUBPnL+HL503fBj1C2stfxu+2G+/dxu9jV3sbo0jy9eU85ZM2M7PvcFQzz8ei0/+tNeegZCfLCihM9dUcb0rJQJjlwSxbb6dr7x7E5e29vC7Lw07rpqEVeeVYgZtp7lZD6PmbTpyNbak6ZTnsqOg+1849ldvLGvldKCdD5/1SKuXlo04vHFGLPJWltx0vYYkkM+YA9wOdAAvAncbK3dMWSf64A7gGsZnDb2Q2vt6lgeO5xTJYcmQihsuetXW5QciHjyrXrufGwLF8zP54G/OndC3gwnQ6C7n1se2EBVUyf3/1XFsekqf9jVyCd/toklM7J4+ONryE5NIhS2/P1jm/l/mw/G3YcliZ21lgfX7eObz+6iKDuFe25e6UhCxE2iH9AC3QM88ok1k74k7Gt7m7n5/g3863uXcsuaOZP62onu1p+8wStVzSydlc3y4myWlwx+YJxXkO6aXiytXf1sqQ+wpS7A1vp2ttQFaOnqp7wok7uvKefShdPi6kO7U3YcbOe6H64b9j6/z8OSGVmsKMlhWWQclOaPbQyEwpbqps7jfle7GztYU5rH31wyn/Pn5x/3ezpVYrq6qZOvPrWdV6tbyEz20dEX5KIFBfzzDWeN+xSSgVCYb/9uF/e/so+ls7K45+aVZKUkRb6PdrbWB9hS344x8NEL5vKX580hO9W90xF6B0I8XlnP/S/XsL+lG7/Xw0VlBVy9tIi1iwvJdbACJh5VNXbwrd/t5oWdjaT5vSydmc3ykmyWFeewoiSH4tzUMR1/BkJhdh/uOO7vpLqpk9l5aZHj7+BznzUzi1erm7nzsS2EwpZvvW8Z1y2bMYHf6fgaCIV59I0D/ODFKpo7+0d/wAnWLink7qsXsWB65gREJ4nOWstLe47wzWd3jXmhhnS/d/CcqSSH5cWDf7NjPQ6MpO3Y+U70vScw5r+fggw/f3d5GTeunj3qKn6nnRyKPPha4PuAF3jIWvuvxpjbAay195rBn8h/AVcD3cCt1tqNIz12tNeb7OQQcFxy4PNXL+JTlyZmgug3mxv43C83s6Y0n4c+Gr+JoahAdz8337+B6iOdPPBXFYSs5ZMPb2JRUSb/+4k1x53kBUNh7nxsC09tOcgXrynnk5coQTQV9A6EeOtAgNdrWnhpdxNb6ttZu6SQf3//crLT3HuSP5miUzuO9gzw878+b1yb1rZ3D/CnPU38YVcT2+rbT5pX3NrVT5LXw7q73x13FYrxrqmjlwdf2cfmugDbGtrp7h9sdJqZ7KNgmMbOSV7DmtJ8Ll88nfPm5Z/R78tay57GTl7c1cifdh3hSOfJc+J7B0Icau8FwBhYMC2D5SU5vKusgOuXzdQ0mDGw1vLLN+to6Tr5RLOtq5+tDe1sHzoGUnwUZMTW3NtaS1NH33Hj5+zibEoL0nluRyPNnX0sK87m9kvmc9VZRTR19HLjfetp7ewfcUqrtZantx7i5xsOcMt5s7nu7BkTmgR8/u1G/v6xzfQMhI5dqTUG5k/LYFlxNs2d/by85wjpfi83r5nNxy+aR1F2yrFY9zV38XpNC6/tbaG2pYvlxTmcPz+f8+blx/xzHE5H7wBv7m/lteoW3qxtoyDdf+x5l8zIOpbAa+8Z4H/X1/KTV/fT3NnH8uJsPnLBXK5YUjjle2tMhjf3t/LbrYfYUh9gx8Gj9EcWaclNSyInLbaEm7WWQ+29xxZ4yU1LYllxDgsLM9jf0s2WugBNkZ6pPo8hGLYsmZHFf9+ykrlx2hersy/Ik5X1Y2qIu6Y071gTfZGJFApbntl2iAOtsU/Tazzay5b6dnYePEp/ZNW4vHT/sBcNUpO8VMzN5YL5+awpzT8pOX+4vZfXa5p5fW8LG/a1HpsuGH3vWV6cw9z8tJgv1GSl+HjvyuKYK0LPKDk02ZxIDsHgILnzsc38ZvNBPnrBXFc0KUzyekjzD668lRb5SvZ56QuG6O6PfgXp7g8RHKH0LNnniTzed+y5/F4PPQORx/cNPr6+rYcfvLiH1aV5PPTRc+OyD8Vw2rr6ufmBDdQc6cQCCwszeOTj5w2bGAiGwnz2l5t5eushPnFRKeUzst75+ScN/gx9Xvd+IBkIhenuD9EzZGz0BsNkpfiYlpnM9MxkpmWkkJXqO60TbWstfcEwXZEx09UfpKsvSFff4GtF/52o3s4ej4n8HrzHjemBUPid73lgcEw3dfSxvqaFTbVt9AXDeAwsnZXNB1YV85fnzVG1wQnqWt/p/XHn2oVkpfqO/XyjKzwMN2d5OP3BMBv2tfDiziY21rYRClvy0v2snps37Pzu9yyfydpRmsfLxApFpmxvrguwrb592KanR3sH2FDTSs9AiNQkLxeVFXDF4uksnZUd89hoPNrLH3c18eKuJurbegBYOiuL0oKMk4q6fR7DoqJMlhXncHZxtqbATLBj1T91AbY2BDjaE/sHuty0pGErz3oHQjxR2cB9L+9lf0s3c/PTCNvBpPDPPr6acxxuhj9UXWs3D67bR1F2CsuKszl7VvZxq1a9ffAoP355L09vPYTHwHuWzSRsLa/XtBxr+FmUlUJpQTpb6wN0RZJliwozOX9+PnPz02J+3znU3svrNS1sb2gnFLb4fR5WFOdwpLOPfc1dAOSkJbGmNI9pmck8WdlAV3+IixdO4/ZL5nH+vHy9x02Q/mCYPY0dbK4LsONg+5hWD5uemXys4qAk7+Rqg8PtvceqilKSvNx28TxdNBFxof5gmF2Hj7Klvp3t9e30DJx8HGjr7mdTbRvd/SFMZGGt8+fl0xsM8frelmPH8uzUwWP5yjm5w773TBQlh2IUDIW569dbefKtBkde32nnz8vnwY9WTJnEUFRrVz8ffnADXo/h4Y+tPuWVnqEVRFOV3+cZXMY3xpPHsLX0RJJB8bSo1+IZWcd6LKwuzXP1dAA3iK4aVNfaMy7PV16UyeWLp3P54kKWF+eo0mMK6B0I8XpNC3/Y2cSLOxs5GKnsGYuUJA8XLSjgsvJCLiuffqwCQ6auUNjy3I7D3PvSXvY1d/E/t65m1Rz3JIbGIppEevTNA2Qk+zgv8h5zwfyCYwmgYCjMtoZ2XtvbwvqaFt7c30rvQDjm1/B5DCtKBquPzp+Xz8o5uceSBIfae1hf08Jr1S28XtPCofZerl82g09ePJ8lM7Mm6tsWEZExGgiF2VofOHa83lTbht/rYXVp3rBVoJNJyaExCnT3O/4hONqIKloZFK306RsIkRytnkiKVhT5SPKak65CRCs93qkmCdI9EGIgGD5WjZSa9E51wLTM5Cl7tSkUthiI+Q+wubPvWIXM0J9f2IV/M1E+j+ekqprkJA9He4Ic6eijqaOXIx19HOnsI9AV+3KoxkCq30u630d6so/05MHnT/d7SUuO/Ot/Z/tEJQGC4SEVQkN+J0lez3HVdal+H9mpSao0OA0DoTAtnf0nHXd6+kOMsNjkMAxLZ2VRnJs2kaGKw6y17DrcQW1LV8yPyUhOomJurq6GJ6joec1UWCFmIBTG5zn5vGs4/cEwnX2xV2JFqzVj0R8MT4mfp4jIVNcfmcnghsVXlBwSEREREREREUlgIyWHnE9biYiIiIiIiIiIY5QcEhERERERERFJYEoOiYiIiIiIiIgkMFf2HDLGdAC7nY5D4kYB0Ox0EBI3NF5kLDReZCw0XmSsNGZkLDReZCw0XmQkc6y1007c6NalfHYP1yBJZDjGmI0aLxIrjRcZC40XGQuNFxkrjRkZC40XGQuNFxkrTSsTEREREREREUlgSg6JiIiIiIiIiCQwtyaH7nM6AIkrGi8yFhovMhYaLzIWGi8yVhozMhYaLzIWGi8yJq5sSC0iIiIiIiIiIpPDrZVDIiIiIiIiIiIyCVyVHDLGXG2M2W2MqTbGfMHpeMRdjDElxpg/GmN2GmN2GGP+LrL9n4wxDcaYzZGva52OVdzBGLPfGLMtMi42RrblGWOeN8ZURf7NdTpOcQdjzKIhx5HNxpijxpjP6hgjUcaYh4wxTcaY7UO2jXhMMcZ8MXJOs9sYc5UzUYtTRhgv3zHG7DLGbDXGPGmMyYlsn2uM6RlynLnXucjFCSOMlxHff3R8kRHGzC+HjJf9xpjNke06xsioXDOtzBjjBfYAa4F64E3gJmvt244GJq5hjJkBzLDWVhpjMoFNwJ8DHwQ6rbX/7miA4jrGmP1AhbW2eci2bwOt1tpvRpLQudbau52KUdwp8p7UAKwBbkXHGAGMMRcDncDD1tqlkW3DHlOMMUuAXwCrgZnAC8BCa23IofBlko0wXq4E/mCtDRpjvgUQGS9zgaej+0niGWG8/BPDvP/o+CIw/Jg54f7vAu3W2q/pGCOxcFPl0Gqg2lpbY63tBx4FbnA4JnERa+0ha21l5P8dwE5glrNRSRy6Afhp5P8/ZTDBKHKiy4G91tpapwMR97DWvgy0nrB5pGPKDcCj1to+a+0+oJrBcx1JEMONF2vt7621wcjN9UDxpAcmrjTC8WUkOr7IKceMMcYweAH9F5MalMQ1NyWHZgF1Q27Xow/+MoJI9vscYENk0x2REu2HNE1IhrDA740xm4wxt0W2FVprD8FgwhGY7lh04mY3cvwJlY4xMpKRjik6r5HRfAx4dsjtUmPMW8aYl4wx73IqKHGd4d5/dHyR0bwLaLTWVg3ZpmOMnJKbkkNmmG3umPMmrmKMyQAeBz5rrT0K/AiYD6wADgHfdTA8cZcLrbUrgWuAT0fKb0VOyRjjB/4M+FVkk44xcjp0XiMjMsb8IxAEHolsOgTMttaeA9wJ/NwYk+VUfOIaI73/6Pgio7mJ4y9y6Rgjo3JTcqgeKBlyuxg46FAs4lLGmCQGE0OPWGufALDWNlprQ9baMHA/KquVCGvtwci/TcCTDI6Nxkj/qmgfqybnIhSXugaotNY2go4xMqqRjik6r5FhGWM+AlwP3GIjzT8j04NaIv/fBOwFFjoXpbjBKd5/dHyRERljfMBfAL+MbtMxRmLhpuTQm0CZMaY0ctX2RuAph2MSF4nMnX0Q2Gmt/d6Q7TOG7PZeYPuJj5XEY4xJjzQuxxiTDlzJ4Nh4CvhIZLePAL9xJkJxseOutukYI6MY6ZjyFHCjMSbZGFMKlAFvOBCfuIgx5mrgbuDPrLXdQ7ZPizTCxxgzj8HxUuNMlOIWp3j/0fFFTuUKYJe1tj66QccYiYXP6QCiIqs23AE8B3iBh6y1OxwOS9zlQuDDwLbosozAl4CbjDErGCyn3Q980pnwxGUKgScHc4r4gJ9ba39njHkTeMwY83HgAPABB2MUlzHGpDG4aubQ48i3dYwRAGPML4BLgQJjTD3wVeCbDHNMsdbuMMY8BrzN4PShT2slocQywnj5IpAMPB95f1pvrb0duBj4mjEmCISA2621sTYnlilghPFy6XDvPzq+CAw/Zqy1D3Jy30TQMUZi4Jql7EVEREREREREZPK5aVqZiIiIiIiIiIhMMiWHREREREREREQSmJJDIiIiIiIiIiIJTMkhEREREREREZEEpuSQiIiIiIiIiEgCU3JIRERERERERCSBKTkkIiIiIiIiIpLAlBwSEREREREREUlg/z97zL4Lp+2PRgAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1984,7 +1874,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1999,16 +1889,20 @@ "output_type": "stream", "text": [ "tal hits:\n", - "\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.7378554041914969, precision_at_motif_score=0.6443886089735836, example_idx=3, start=8, end=33, is_revcomp=True)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.9925613965072331, precision_at_motif_score=1.0, example_idx=3, start=17, end=42, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.7521851743143521, precision_at_motif_score=0.6885989743362789, example_idx=3, start=44, end=69, is_revcomp=True)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.9989676488963165, precision_at_motif_score=1.0, example_idx=3, start=53, end=78, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.559340500323617, precision_at_motif_score=0.09363245203441768, example_idx=3, start=75, end=100, is_revcomp=True)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.9973942484679885, precision_at_motif_score=1.0, example_idx=3, start=84, end=109, is_revcomp=False)\n", "gata hits:\n", - "MotifHitAndCoord(motif_idx=1, motif_score=0.9994427100002803, precision_at_motif_score=1.0, example_idx=3, start=62, end=87, is_revcomp=False)\n", - "MotifHitAndCoord(motif_idx=1, motif_score=0.998124872090949, precision_at_motif_score=1.0, example_idx=3, start=86, end=111, is_revcomp=False)\n", - "MotifHitAndCoord(motif_idx=1, motif_score=0.9933627532372303, precision_at_motif_score=1.0, example_idx=3, start=153, end=178, is_revcomp=False)\n" + "MotifHitAndCoord(motif_idx=1, motif_score=0.9998660881398925, precision_at_motif_score=1.0, example_idx=3, start=117, end=142, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=1, motif_score=0.9289355656114391, precision_at_motif_score=1.0, example_idx=3, start=161, end=186, is_revcomp=False)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2027,7 +1921,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2039,7 +1933,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABJYAAACMCAYAAAAulSOdAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAASPElEQVR4nO3df6zddX3H8edrrbiJLkAoWNuyVnPdVoxDdsbYmMZfzJYZin+wlEztkKSyWKeL2yySbP61EH9OM4RU6KgZsyMI0hgUauc0+wPkFhEpULlWBhc6WueGZBhY8b0/zrfb8XJuW77nlHs55/lITs75fn6c+27e9HL6ut/v96aqkCRJkiRJkp6rX5jrAiRJkiRJkvTCZLAkSZIkSZKkVgyWJEmSJEmS1IrBkiRJkiRJkloxWJIkSZIkSVIrBkuSJEmSJElqZeFcFzBMJ554Yi1fvnyuy5AkSZIkSRoZO3fu/FFVLeo3N5RgKckq4DPAAuCqqrpsxnya+XOAJ4E/rqo7m7kHgSeAZ4ADVdVpxk8A/glYDjwI/GFV/eeh6li+fDmTk5PD+CNJkiRJkiQJSPJvs80NfClckgXA5cBqYCVwQZKVM5atBiaax3rgihnzb6qq0w6GSo2NwI6qmgB2NMeSJEmSJEmaJ4Zxj6UzgKmq2lNVTwNbgTUz1qwBvlBdtwHHJVl8mPddA2xpXm8BzhtCrZIkSZIkSRqSYQRLS4CHe46nm7EjXVPArUl2Jlnfs+bkqtoL0DyfNIRaJUmSJEmSNCTDuMdS+ozVc1hzVlU9muQkYHuS+6vqW0f8xbth1HqAU0455Ui3SZIkSZIkaUDDOGNpGljWc7wUePRI11TVwed9wI10L60DeOzg5XLN875+X7yqNlVVp6o6ixb1vUG5JEmSJEmSjoJhBEt3ABNJViQ5BlgLbJuxZhvw7nSdCTxeVXuTHJvkZQBJjgV+H7inZ8+65vU64KYh1CpJkiRJkqQhGfhSuKo6kGQDcAuwANhcVbuSXNzMXwncDJwDTAFPAhc2208GbkxysJZ/rKqvNXOXAdcluQh4CDh/0FolSZIkSZI0PKmaeTukF65Op1OTk5NzXYYkSZIkSdLISLKzqjr95oZxKZwkSZIkSZLGkMGSJEmSJEmSWjFYkiRJkiRJUisGS5IkSZIkSWrFYEmSJEmSJEmtGCxJkiRJkiSpFYMlSZIkSZIktWKwJEmSJEmSpFYMliRJkiRJktSKwZIkSZIkSZJaMViSJEmSJElSKwZLkiRJkiRJasVgSZIkSZIkSa0YLEmSJEmSJKkVgyVJkiRJkiS1YrAkSZIkSZKkVoYSLCVZlWR3kqkkG/vMJ8lnm/m7k5zejC9L8o0k9yXZleQDPXs+muSRJHc1j3OGUaskSZIkSZKGY+Ggb5BkAXA5cDYwDdyRZFtV3duzbDUw0Tx+G7iieT4AfKiq7kzyMmBnku09ez9dVZ8YtEZJkiRJkiQN3zDOWDoDmKqqPVX1NLAVWDNjzRrgC9V1G3BcksVVtbeq7gSoqieA+4AlQ6hJkiRJkiRJR9kwgqUlwMM9x9M8Oxw67Joky4HXAbf3DG9oLp3bnOT4IdQqSZIkSZKkIRlGsJQ+Y/Vc1iR5KfAl4INV9ZNm+ArgVcBpwF7gk32/eLI+yWSSyf379z/X2iVJkiRJktTSMIKlaWBZz/FS4NEjXZPkRXRDpWur6oaDC6rqsap6pqp+Bnye7iV3z1JVm6qqU1WdRYsWDfyHkSRJkiRJ0pEZRrB0BzCRZEWSY4C1wLYZa7YB725+O9yZwONVtTdJgKuB+6rqU70bkizuOXwHcM8QapUkSZIkSdKQDPxb4arqQJINwC3AAmBzVe1KcnEzfyVwM3AOMAU8CVzYbD8LeBfwvSR3NWMfqaqbgY8lOY3uJXMPAu8dtFZJkiRJkiQNT6pm3g7phavT6dTk5ORclyFJkiRJkjQykuysqk6/uWFcCidJkiRJkqQxZLAkSZIkSZKkVgyWJEmSJEmS1IrBkiRJkiRJkloxWJIkSZIkSVIrBkuSJEmSJElqxWBJkiRJkiRJrRgsSZIkSZIkqRWDJUmSJEmSJLVisCRJkiRJkqRWDJYkSZIkSZLUisGSJEmSJEmSWjFYkiRJkiRJUisGS5IkSZIkSWrFYEmSJEmSJEmtGCxJkiRJkiSplaEES0lWJdmdZCrJxj7zSfLZZv7uJKcfbm+SE5JsT/JA83z8MGqVJEmSJEnScAwcLCVZAFwOrAZWAhckWTlj2WpgonmsB644gr0bgR1VNQHsaI4lSZIkSZI0TywcwnucAUxV1R6AJFuBNcC9PWvWAF+oqgJuS3JcksXA8kPsXQO8sdm/BfgX4MOHKuSne+9n19/83hD+SJIkSZIkSTqcYVwKtwR4uOd4uhk7kjWH2ntyVe0FaJ5P6vfFk6xPMplksptbSZIkSZIk6fkwjDOW0mdsZsIz25oj2XtIVbUJ2ATQ6XTq1I/863PZLkmSJEmSpEO5tF980zWMM5amgWU9x0uBR49wzaH2PtZcLkfzvG8ItUqSJEmSJGlIhhEs3QFMJFmR5BhgLbBtxpptwLub3w53JvB4c3nbofZuA9Y1r9cBNw2hVkmSJEmSJA3JwJfCVdWBJBuAW4AFwOaq2pXk4mb+SuBm4BxgCngSuPBQe5u3vgy4LslFwEPA+YPWKkmSJEmSpOHJKN3wutPp1OTk5FyXIUmSJEmSNDKS7KyqTr+5YVwKJ0mSJEmSpDFksCRJkiRJkqRWDJYkSZIkSZLUisGSJEmSJEmSWjFYkiRJkiRJUisGS5IkSZIkSWrFYEmSJEmSJEmtGCxJkiRJkiSpFYMlSZIkSZIktWKwJEmSJEmSpFYMliRJkiRJktSKwZIkSZIkSZJaMViSJEmSJElSKwZLkiRJkiRJasVgSZIkSZIkSa0MFCwlOSHJ9iQPNM/Hz7JuVZLdSaaSbOwZ/3iS+5PcneTGJMc148uT/DTJXc3jykHqlCRJkiRJ0vANesbSRmBHVU0AO5rjn5NkAXA5sBpYCVyQZGUzvR14TVW9Fvg+cEnP1h9U1WnN4+IB65QkSZIkSdKQDRosrQG2NK+3AOf1WXMGMFVVe6rqaWBrs4+qurWqDjTrbgOWDliPJEmSJEmSnieDBksnV9VegOb5pD5rlgAP9xxPN2MzvQf4as/xiiTfSfLNJK8fsE5JkiRJkiQN2cLDLUjydeDlfaYuPcKvkT5jNeNrXAocAK5thvYCp1TVfyT5TeDLSU6tqp/0qW89sB7glFNOOcKSJEmSJEmSNKjDBktV9dbZ5pI8lmRxVe1NshjY12fZNLCs53gp8GjPe6wD3g68paqq+ZpPAU81r3cm+QHwamCyT32bgE0AnU6nZs5LkiRJkiTp6Bj0UrhtwLrm9Trgpj5r7gAmkqxIcgywttlHklXAh4Fzq+rJgxuSLGpu+k2SVwITwJ4Ba5UkSZIkSdIQDRosXQacneQB4OzmmCSvSHIzQHNz7g3ALcB9wHVVtavZ/3fAy4DtSe5KcmUz/gbg7iTfBa4HLq6qHw9YqyRJkiRJkoYozdVnI6HT6dTk5LOulpMkSZIkSVJLSXZWVaff3KBnLEmSJEmSJGlMGSxJkiRJkiSpFYMlSZIkSZIktWKwJEmSJEmSpFYMliRJkiRJktSKwZIkSZIkSZJaMViSJEmSJElSKwZLkiRJkiRJasVgSZIkSZIkSa0YLEmSJEmSJKkVgyVJkiRJkiS1YrAkSZIkSZKkVgyWJEmSJEmS1IrBkiRJkiRJkloxWJIkSZIkSVIrBkuSJEmSJElqZaBgKckJSbYneaB5Pn6WdauS7E4ylWRjz/hHkzyS5K7mcU7P3CXN+t1J3jZInZIkSZIkSRq+Qc9Y2gjsqKoJYEdz/HOSLAAuB1YDK4ELkqzsWfLpqjqtedzc7FkJrAVOBVYBn2veR5IkSZIkSfPEoMHSGmBL83oLcF6fNWcAU1W1p6qeBrY2+w73vlur6qmq+iEw1byPJEmSJEmS5olBg6WTq2ovQPN8Up81S4CHe46nm7GDNiS5O8nmnkvpDrdHkiRJkiRJc+ywwVKSrye5p8/jcGcd/d9b9Bmr5vkK4FXAacBe4JNHsGdmfeuTTCaZ3L9//xGWJEmSJEmSpEEtPNyCqnrrbHNJHkuyuKr2JlkM7OuzbBpY1nO8FHi0ee/Het7r88BXDrenT32bgE0AnU6nb/gkSZIkSZKk4Rv0UrhtwLrm9Trgpj5r7gAmkqxIcgzdm3JvA2jCqIPeAdzT875rk7w4yQpgAvj2gLVKkiRJkiRpiA57xtJhXAZcl+Qi4CHgfIAkrwCuqqpzqupAkg3ALcACYHNV7Wr2fyzJaXQvc3sQeC9AVe1Kch1wL3AAeF9VPTNgrZIkSZIkSRqiVI3O1WOdTqcmJyfnugxJkiRJkqSRkWRnVXX6zo1SsJTkCWD3XNehOXMi8KO5LkJzwt6PN/s/vuz9eLP/483+jy97P97s/9z5lapa1G9i0Evh5pvdsyVoGn1JJu3/eLL3483+jy97P97s/3iz/+PL3o83+z8/DXrzbkmSJEmSJI0pgyVJkiRJkiS1MmrB0qa5LkBzyv6PL3s/3uz/+LL3483+jzf7P77s/Xiz//PQSN28W5IkSZIkSc+fUTtjSZIkSZIkSc+TkQmWkqxKsjvJVJKNc12Pjp4ky5J8I8l9SXYl+UAzfkKS7UkeaJ6Pn+tadXQkWZDkO0m+0hzb+zGR5Lgk1ye5v/ke8Dv2f3wk+bPm+/49Sb6Y5Bft/+hKsjnJviT39IzN2u8klzSfA3cnedvcVK1hmKX3H2++99+d5MYkx/XM2fsR0q//PXN/nqSSnNgzZv9HxGy9T/L+pr+7knysZ9zezxMjESwlWQBcDqwGVgIXJFk5t1XpKDoAfKiqfh04E3hf0++NwI6qmgB2NMcaTR8A7us5tvfj4zPA16rq14DfoPvfgf0fA0mWAH8KdKrqNcACYC32f5RdA6yaMda3383ngLXAqc2ezzWfD/XCdA3P7v124DVV9Vrg+8AlYO9H1DU8u/8kWQacDTzUM2b/R8s1zOh9kjcBa4DXVtWpwCeacXs/j4xEsAScAUxV1Z6qehrYSvc/Po2gqtpbVXc2r5+g+w/LJXR7vqVZtgU4b24q1NGUZCnwB8BVPcP2fgwk+WXgDcDVAFX1dFX9F/Z/nCwEfinJQuAlwKPY/5FVVd8CfjxjeLZ+rwG2VtVTVfVDYIru50O9APXrfVXdWlUHmsPbgKXNa3s/Ymb5uw/waeAvgd6bBNv/ETJL7/8EuKyqnmrW7GvG7f08MirB0hLg4Z7j6WZMIy7JcuB1wO3AyVW1F7rhE3DS3FWmo+hv6X6o+FnPmL0fD68E9gN/31wKeVWSY7H/Y6GqHqH7U8qHgL3A41V1K/Z/3MzWbz8Ljpf3AF9tXtv7MZDkXOCRqvrujCn7P/peDbw+ye1Jvpnkt5pxez+PjEqwlD5j/rq7EZfkpcCXgA9W1U/muh4dfUneDuyrqp1zXYvmxELgdOCKqnod8N942dPYaO6lswZYAbwCODbJO+e2Ks0jfhYcE0kupXtbhGsPDvVZZu9HSJKXAJcCf9Vvus+Y/R8tC4Hj6d4C5S+A65IEez+vjEqwNA0s6zleSvf0eI2oJC+iGypdW1U3NMOPJVnczC8G9s22Xy9YZwHnJnmQ7iWvb07yD9j7cTENTFfV7c3x9XSDJvs/Ht4K/LCq9lfV/wA3AL+L/R83s/Xbz4JjIMk64O3AH1XVwX9A2vvR9yq6P1T4bvMZcClwZ5KXY//HwTRwQ3V9m+5VCydi7+eVUQmW7gAmkqxIcgzdm3htm+OadJQ0CfXVwH1V9ameqW3Auub1OuCm57s2HV1VdUlVLa2q5XT/nv9zVb0Tez8WqurfgYeT/Goz9BbgXuz/uHgIODPJS5r/D7yF7j327P94ma3f24C1SV6cZAUwAXx7DurTUZJkFfBh4NyqerJnyt6PuKr6XlWdVFXLm8+A08DpzecC+z/6vgy8GSDJq4FjgB9h7+eVhXNdwDBU1YEkG4Bb6P6WmM1VtWuOy9LRcxbwLuB7Se5qxj4CXEb31MiL6P4D5Pw5qk/PP3s/Pt4PXNv8EGEPcCHdH5LY/xFXVbcnuR64k+5lMN8BNgEvxf6PpCRfBN4InJhkGvhrZvl+X1W7klxHN2w+ALyvqp6Zk8I1sFl6fwnwYmB7N1vmtqq62N6Pnn79r6qr+621/6Nllr/7m4HNSe4BngbWNWcs2vt5JP9/FqkkSZIkSZJ05EblUjhJkiRJkiQ9zwyWJEmSJEmS1IrBkiRJkiRJkloxWJIkSZIkSVIrBkuSJEmSJElqxWBJkiRJkiRJrRgsSZIkSZIkqRWDJUmSJEmSJLXyv6RVn74eFxHHAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -2054,19 +1948,14 @@ "output_type": "stream", "text": [ "tal hits:\n", - "MotifHitAndCoord(motif_idx=0, motif_score=0.704276474569764, precision_at_motif_score=0.44302641367625195, example_idx=4, start=1, end=26, is_revcomp=False)\n", - "MotifHitAndCoord(motif_idx=0, motif_score=0.9952651939732524, precision_at_motif_score=1.0, example_idx=4, start=10, end=35, is_revcomp=True)\n", - "MotifHitAndCoord(motif_idx=0, motif_score=0.635539514810006, precision_at_motif_score=0.28118745516214005, example_idx=4, start=58, end=83, is_revcomp=False)\n", - "MotifHitAndCoord(motif_idx=0, motif_score=0.9995073050902686, precision_at_motif_score=1.0, example_idx=4, start=67, end=92, is_revcomp=True)\n", - "MotifHitAndCoord(motif_idx=0, motif_score=0.8856687419902738, precision_at_motif_score=0.8314828431175738, example_idx=4, start=140, end=165, is_revcomp=False)\n", - "MotifHitAndCoord(motif_idx=0, motif_score=0.999818566464115, precision_at_motif_score=1.0, example_idx=4, start=149, end=174, is_revcomp=True)\n", + "\n", "gata hits:\n", "\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2085,7 +1974,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIkAAACMCAYAAAD4MPn4AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXxV9Z3/8ffn3uwJZF8g7FlAgoKaigoo1C3Wra1jp/6m1trFaavT2s60tdOO1e6dsZ3fz25qWzvd7WqlrYhLXQBRATcSICRhDSSQjUBC1nu/vz9yw4QklyTkJvcmvJ6PRx4399yTcz6Qk+85532+53vMOScAAAAAAACc2TzhLgAAAAAAAADhR0gEAAAAAAAAQiIAAAAAAAAQEgEAAAAAAECERAAAAAAAABAhEQAAAAAAACRFhbuAU8nIyHBz5swJdxkAAAAAAACTxpYtW+qdc5n9p0d0SDRnzhxt3rw53GUAAAAAAABMGma2d7Dp3G4GAAAAAAAAQiIAAAAAAABE+O1mqq+QfnpNuKsAAAAAAACY9OhJBAAAAAAAgAjvSZRRIN32t3BXAQAAAAAAMHl80AadTE8iAAAAAAAAEBIBAAAAAACAkAgAAAAAAAAiJAIAAAAAAIAIiQAAAAAAACBCIgAAAAAAAIiQCAAAAAAAACIkAgAAAAAAgAiJAAAAAAAAIEIiAAAAAAAAiJAIAAAAAAAAClFIZGYlZlZuZpVmdvcgn680s2YzeyPwdU8o1gsAAAAAAIDQiBrtAszMK+n7kq6QVC1pk5mtds5t6zfrOufctaNdHwAAAAAAAEIvFD2JLpBU6Zzb5ZzrlPSopBtCsFwAAAAAAACMk1CERLmS9vd5Xx2Y1t9FZvamma0xs6JgCzOz281ss5ltrqurC0F5AAAAAAAAGEooQiIbZJrr9/41SbOdc4slfVfSn4MtzDn3sHOu2DlXnJmZGYLyAAAAAAAAMJRQhETVkmb2eT9D0sG+MzjnjjrnWgLfPyEp2swyQrBuAAAAAAAAhEAoQqJNkgrMbK6ZxUh6r6TVfWcwsxwzs8D3FwTW2xCCdQMAAAAAACAERv10M+dct5ndKWmtJK+kR5xzZWb20cDnD0r6B0kfM7NuSW2S3uuc639LGgAAAAAAAMLEIjmrKS4udps3bw53GQAAAAAAAJOGmW1xzhX3nx6K280AAAAAAAAwwRESAQAAAAAAgJAIAAAAAAAAhEQAAAAAAAAQIREAAAAAAABESAQAAAAAAAAREgEAAAAAAECERAAAAAAAABAhEQAAAAAAAERIBAAAAAAAABESAQAAAAAAQIREAAAAAAAAECERAAAAAAAAREgEAAAAAAAAERIBAAAAAABAhEQAAAAAAAAQIREAAAAAAABESAQAAAAAAACFKCQysxIzKzezSjO7e5DPzcweCHz+lpmdF4r1AgAAAAAAIDRGHRKZmVfS9yVdLWmhpJvNbGG/2a6WVBD4ul3SD0e7XgAAAAAAAIROKHoSXSCp0jm3yznXKelRSTf0m+cGST93PV6WlGJm00KwbgAAAAAAAIRAVAiWkStpf5/31ZKWDmOeXEk1p1pw5eEWXfvddSdNS02I0RULs3VVUY6yp8addtEAMBk1tXbqv5/Zqdf2NY16WfmZSSpZlKNLC7MUH+MNQXXD55zTU9sO6Q9bqnXtOdN0/eLpMrNRL7f5eJee3n5IT5XVKtrr0ZVF2Xr7gixNiYse1XL9fqfX9jVpTWmtth08qovz0lWyKEcF2VMGnb/i0DE9WVqrFyvq1NblG/B5ztQ4/euV83XWtKmjqgtAZHLOaeehFq0prdH6inq1dw9sB6Ynx+szV80P2o6cSn1Lhx54tkI+v9MnLytQFsfMYVfT3Kb71+5U+aGj4S4lqJyp8fq3qwq1IId9z0Ti8zv95tV9WldRp1svnqOL8zLCXdKk1NzWpe8/V6mm1k594rICzUxLCDpvl8+vn2/cq41V9bpu8XS94+xpivaO73DQzce79Mz2Q1pbVquDzW0j+llzzo1q5WZ2k6SrnHMfDry/RdIFzrl/6TPP3yR9wzm3PvD+WUmfdc5tGWR5t6vnljRNmT7v/Ju+9uhJn+9uaNWuulZJ0vmzU1VSlKOSRTmn/CUBwGTXe4Bw/1PlOtberYvz0hUzip2Rzzm9uf+Imo53KT7aq5XzM1WyKCckgcpQdte36t7VZXphZ50SY7xq7fTpwnlp+vINi1R4GidLdcc69NS2Wj1ZWquNVQ3q9jtNS45Tl8+pvqVDMV6PVhRkqGRRjq5YmK2UhJhhLbfb59cruxu1prRGa8sOqe5Yz7LmZiSq/NAxSVJeZqKuXjRNJYtyJElPltZqTWmNqgL7scUzU5SROHB9r+1r0tH2bt1y4Wx96opCJceP7f85gLHnnFPpgaNaU1qjJ0trtau+VWbSkpkpSuvX7jhJW/Y2qbWjWx+4eI4+eXnBsNrebp9fv3x5r7799E61d/lkMsVEeXTX5QW69eI5436SAqmz269HNuzWA89WqNvvdHFeurwhuOgxFtj3TDxb9jbpnsdLVXbw6IljpmvPmaYvXrNQOcmEw6Hg9zv96fUD+uaa7Wpo7VRslEfOSR+9NE8fW5mnuOiTL6S+VFWve1eXaeehFqUlxqixtVPTk+P0gWVz9N4LZmnqGB5H17d06KmyQ1pTWnPSMe9Z06ZqsFbnkdsu2OKcK+4/PRQh0UWS7nXOXRV4/3lJcs59o888D0l63jn3m8D7ckkrnXOn7ElUXFzsNm/ePGB6xaFjWlPac8C/raYnjfcM8q+O8niUkxynGanxyk2J14zUBM1IjVdyfLT6t80eM81MS9Cc9ARFsQPFJOLzOx1oatPexlZ1dvuH/XNpiTGal5nEAcIE0PcA4aJ56brvhqLTClP6GywEkQZvb+OjvSfa2NzUeM1Ijde05Hgdbe9SdVObDjS1qbrpuKqb2tTW5dPSuem6pDBDKwoyNSc9QWam453d+v5zlfrRi7sVG+XRXVcU6n0XztIftlTrP58sV0vgZOmuIU6Wunx+vbH/iNbtrNMLFfV6q/qInJPmpCeoJBDYLJ6RLL/rOSBes7VWa8tqdeBIW9B/32CcJOc0aIh26Gi71pbVas3WWr2yu0H+wK7WY9LSuem6+uycU/aIPXK8U99+aqd+9cpepSbE6HNXL9A/nDdDnuEWByAs2rt82tPQqj31rapuajvxdeBITxt4rL1bXo/pwnlpKlk0TVctzA7ay6ehpUP3P1WuRzftV0ZSrD5/9QK969zcoL0qN+1p1H/8uVQ7ao9pRUGG7r2+SF4z3feXMj1XXqf8rCTdd32RluXTy2C8rK+o15dWl6qqrlWXn5Wte65dqFnpkXthu6m1U99+uly/emWf0tj3RLS6Yx365pod+uNr1cqZGqcvXnuWLj8rWw++UKUfPl8lr8f0icsK9MFlcxUTxbnt6So90KwvrS7Tlr1NOm9Wir58wyJlJMXq609s1+o3D2pGarz+49qFunJhtmqa2/W1J7brb2/VaGZavO65tkiXLcjS33cc1o/X79LLuxqVGOPVP75tli7OSx+QRwTT0tE9YF9y8EjboOd1vcebs9MTVLIoR1cvmqbFM5KD7jfMbMxCoihJOyVdJumApE2S/o9zrqzPPNdIulPSO9RzK9oDzrkLhlp2sJCor70NrXpm+2EdOd454LPObr8ONreruum4DjS16XDgBOdUYqM8KshO0vzsqVqQM0Uz0xLknWANo8/vV6fPqbPbry6f/8Sr12OK9noUE+VRTODVY6bOwDwd3b7Aq1/+PtuFBXLH3m2r93+j973H7MQyTyw/sGyEhnNOPr878bvqfe32OfmdO3Gy2vOddOR4l3bVtWp3fYv2N7ap0zf8cKi/9MQYzctM1NyMRM1OTxxV75RT8XhMMV47sf1EB7anybwdOefU5XMn/e11dvvV5R/+72tn7TH9+Y2DJw4Qrjl7Wkhuy+qv93aql6oa1DXI9nSsvXvAiVCvKI9pekr8icDe6zFtqKrX/saeUGZGaryW5WVoXUWdDja3693n5urudyxQ1pT/PXFqbO3Uf60t16Ob9ikjKVa3XDhb8f2u3HT5/Xp93xFtrGpQS0e3PIEr9JcUZuqqohwtyJkS9P/GOaetB5q1rqJe7YPc/hVM0fSpQ96O19DSoWe3H5YkXXZWltKTYoe9/L4HJ0tmpuiKhdl92uKh2+bYqJPb5bH8myrIStKcjMQxWXaoNbd1qbz2mJrbuka1HI9JS+elKyl26Lv3Dxxp07aDA28z8Zg0Oz2Ri1QhsrW6WbVH20e1jN62udPnU1e3U0dgn+v3Dzxm9jung0fatKu+p6f7weY29T20ToqN0oxAcD4jNUELp0/VFWdlK3WQHoTBvLn/iO5ZXaY39x9R8exUrVqQJbOeNqDnVdpWc1SPv3FQ05PjdM91C3VVUc5J7d2z2w/pvr9s077G4yopytE5M5NPfDZUWxLl8Sg6yqNYr0fRUaYYr1fRXhuTfc1E5JxTt9+py9ezH+899n51d6PWlNZqdnqC7r2uSKsWZIW71GErPdCsex4v1Wv7jgzY9/QymaK9pthor2K9HsVG95wLeD1js21MiYvS0rlpp73stk6fNu6q1ygOiUfM7waej/U/z+rbXvRtYfqfors+nx5t69avXt6r9m6fPrJinu5Yla/EPvuh/Y3Hdd9ftumZ7YeUl5mom4pnDrv3mplOHC/0ni9GB36vE0nv32Vn98nnTr5B2vFgqupa9LvN+5WaEKO7r16gG/sFphurGnTv6jKVHzqm82enatvBo/I7p4+vzNc/XzpvQA+j0gPN+vG6XfrrWzXqHkEdvdISY04cS+emxA967Bkf49XKwiydNS34MW9fYxYSBRb+Dkn/V5JX0iPOua+Z2UclyTn3oPVU+D1JJZKOS7rNOXfq9EfDC4lGor3Lp4NH2tTS0T3gsy6f0+76VpXXHtWO2mPaUXvsxFVzYKKJifJoTnqC5mYkam5GkuZlJGp2esKwx5VxrucKxa76Fu2q6znw3VXfqvoW/iYiTYzXow+tmKs7+x0ghFtzW5dqmtuUHB+trClxgx5c7G1o1Ys76/RiRb02VjVoVlqC7ruhSG+bkxZ0uX1PlgYzIzVelxRm6pKCDF2UlzEpesI55/TY6wf0jTU7Inq/lJEUoxc+syqitkOpp0fck2W1Kjt4VOW1x7Sj5qgONo8uROjrw8vn6ovX9n+o60DXfXe9th5oDvp5TJRHhdlJWpDTc5HqwnnpWpSbHHR+DFTf0qGlX392RCcBoZAUG6W5GYknLqjMy0zS3PREzUzr7b0++pMrv9/19Kpcu0P1LQMvjMZ4PfrIJXN1x6p8JcQM/jfY3uXTj17cpR88XzXoWGgIrbhoj+5Yma+PXDLwZHEi8Pt79j3ffDJy9j0fXj5XX7jmrNP6m/rqX7fpx+t3j0FV4XFpYaa+dN1CzctMCjrPczsO676/lGlPw/FxrGzy8HpM71s6S5++cn7Q48kun1+/2LhXD71YpcUzUvQf1y4cchicumMdqhnBGEHx0V7lpsYHbdtHY0xDorES6pBopBpbO3XwyMgGeYoEZj09omK83kD6a4qO8sjfm6aeSLOduv1+xUZ5FBvVM29skF5AvZtJb4rdd7PpvXrSNynvGMFtTRger8dO6gUW4/UoymvymJ10RVHqOVgci67BbZ0++caozfD5Aj2lfH519dlOJ7ve32XvFbjYaK+iRvC76+0hONE554Z90OecU2vnwBMck5QQ4520V7f9gd6EfQ23be57BXMs7Gs8ro//6jV95qr5umNV/pis43Tdv7Zc33uuUlEeU35WkhbkTNH8nKlaMG2KMkfQq2swX/7LNjUd79TTn770lPPVt3So+KvP6LZlc3TjeTNO+qzL59euulbt6HeRKj7aq9fvuWJCnlyGy+NvHNAnH31DD9x8ruaNslfbyT3wTLFerzweDdq+JI5ju+ML/F1L/9uD2DkpymuKjRrettLt8w+4ih2sLXHq2T93+Hw9vav6tCf4X1FeO9GjvrcHZ0Ksd9i/k0g22L5H6tlGBrsbYaxC2t9u2q9fvLxXn7q8UJ+8vGBEP3usvUsXfePvujgvXZ+4bGQ/O1qD9ejtf5zXt/kwBf+s77Thblt+v9PxEYTCPr9Tt6/v+WLP7zWCI4Ogeu5KOPn8aSQ93aI8Nun3wcFCosi63Bdh0hJjlDaC7sDAZDfeT7jCmWMkJ1hmNqzbeyYbj8cU54nMv8FFucknxkJ439LZSk6IjB5czW1d+tlLe1RSlKMHbj435OMyXL4wS19/Yodqmts0LTk+6HwbKuslSe9ckjto76BzZ6We9P6pslrd/ost2rirQavmT5xbVMJtXUW9UhKidc3Z0ybcrRHD5fWYvKNsB6K8Ho08u4iMv2mMv1Pte+I1fvukhdOm6ninT//9zE5NiYvSB5fPHfbP/n5ztVo6unXHqvwzroemx3NmHjNhdCb+5WcAABB2/3ploVo6uvXQi1XhLuWEX768V8c6uvUvl+WPycCdy/MzJfUMTnsq6yrqlRwfPeyTk0sKMxUb5dEL5XWjrvFM4ZzT+op6LcvLmLQBEXAm83hM37rxbJUU5ejLf92m323eP6yf8/mdfvrSbhXPTtXimSljXCUwORASAQCAUTtr2lRdv3i6frphjw4fC92YP6errdOnn6zfrVXzM1U0fWyuHC/ImaKMpBitrwweEp0IL/LThx1exEV7dVFeul7YSUg0XFV1Lao92q7lBTy5C5isorwe/b+bl2hFQYbu/uNbemLrKR+ULUl6etsh7W9s04dG0PMIONMREgEAgJD41OWF6vT59YPnwt+b6Dev7lNja+eYjpHk8ZiW52dofUX9oE++kqTKwz3hxYqCzBEte2VhpnbXt2pvQ2soSp30XtzZE9Qt5/HuwKQWG+XVQ7ecr3NnpeqTj74+ZJj+yPrdyk2J1xULs8epQmDiIyQCAAAhMScjUe8pnqFfv7JP1U3he5pKZ7dfD7+4S0vnpqn4FE/LC4XlBZlqaO3U9tqBj7eXem41k0YeXlwaGIvoeW45G5b1lfWam5E45FNlAEx8CTFReuQDb1NB1hR97JdbtL1m8PZ3a3WzXt3TqNuWzVHUJHjIBzBe+GsBAAAh8y9vL5BMeuDZirDV8KfXqlV7tH1cnrTWG/4EG5dofWW95qQnjDi8mJuRqNnpCXq+/PCoa5zsOrv9enlXA72IgDNIcny0fnrb2zQlLkof/tlmNbR0DJjnkQ27lRjj1XveNjMMFQITFyERAAAImekp8brlwtn6w5ZqVdW1jPv6u31+/fCFKp2dm6wV4zA+TU5ynAqzk070GOqrN7wY6a1mvVYWZmrjrga1j+DxxWei1/Y16Xinj/GIgDNM9tQ4/ej9xapv6dBHf7lFnd3+E58dOtquv7x5UO9520xNjePpfMBIEBIBAICQ+vjKPMVHe/Wdp3eO+7r/trVGexuO645V+TIbn6dcLc/P1Kt7GgeEOaMNL1bOz1J7l1+v7G4MRZmT1vqKenk9povy0sNdCoBxds6MFN1/02Jt2tOkL/55q5zrGR/u5xv3yOecPnDxnLDWB0xEhEQAACCk0pNi9cHlc/W3t2pUdrB53Nbr9zv94LkqFWQl6cpxHKR0RWGGOrv92rTn5DBntOHFhfPSFRPl0QuMS3RK6yrrtWRmCr0FgDPUdYun6xNvz9fvNlfrJ+t3q63Tp1+9sk9XnJWt2emJ4S4PmHAIiQAAQMh9eMU8xUR59NhrB8ZtnX/fcVjlh47p46vy5Bnm4+ZDYencNMV4PQPGJRpteBEf49WF89L1/E7GJQrmyPFOvVV9hPGIgDPcXZcXqqQoR19/Yrs+98e3dOR4F4+9B05TVLgLAAAAk09yfLSKZ6dqQ1VDyJf93I7Dgw7ovK6iXjNS43XdOdNDvs5TSYiJ0nmzU/RiRb0+H5jWG1584u0Fo1r2pYWZ+spft2l/43Ge3DWIl6oa5Jx0SSEhEXAm83hM3/nHxbrxh8e1+s2DWpQ7VRfMHdunWwKTFT2JAADAmFiWn6HtNUdVP8hTZ05Ha0e37v7jW7rtfzbpD1uq9fibB0/6OtLWpc9cNT8sjzpeUZCp7TVHVXes598aqvBi5fyeQa95ytng1lXUa0pslBbPSAl3KQDCLCEmSj++tVjnzkrRv105f9zGpQMmG3oSAQCAMbEsP0P/tbZcG6sadN3i0fXu2bK3SZ/+3Rva13hcH1+Zp7suL1RMVORc61pR0PNvfamqXjcsyQ1ZeDEvI1Ez0+L1fHmdbrloTmiKnSScc1pXUacL89LDEgwCiDy5KfF67OPLwl0GMKGxRwUAAGPi7NxkTYmL0obKgY+HH64un1/feXqnbnrwJXX7nH57+0X6bMmCiAqIJKloerJSEqL14s76kIYXZqaVhVl6qapBHd2+oX/gDLK34biqm9p0yWk+PQ4AAAwUWUdYAABg0vB6TBfNS9eGqtMLiY61d+mmBzfqgWcr9M4luVpz14qIHWPC6zEty8/Q+sq6kIcXK+dnqq3Lp027m0KyvMliXSB8XF6QGeZKAACYPAiJAADAmFlekKH9jW3a13B8xD+7prRWb+w/ovtvWqzv/OOSiH/E+Yr8DB062qH/eWmPpNCFFxflpSvG62Fcon7W7axTbkq85qQzoDcAAKFCSAQAAMbMxXk9vWnWn8YtZy/srFPWlFjdeF5uqMsaE8sDPYd++fLekIYXCTFRWjovTc/vrAvJ8iaDbp9fG6sadElhBoPTAgAQQoREAABgzORlJipnatyIbznr9vm1bmedLi3MnDAhwIzUBM3LSFS334U8vLi0MFOVh1tU3TTyHlmT0ZvVzTrW0a3l+dxqBgBAKBESAQCAMWPWM1bPS5X18vvdsH/uzeojOtrerUvnT6wQoLc3UajDi5WB/4fnyulNJEnrKupkJl2clx7uUgAAmFRGFRKZWZqZPW1mFYHX1CDz7TGzrWb2hpltHs06AQDAxLIsP11Nx7u0vfbosH/m+fI6eUxaMcF6irz7vBlaMjNFKwpD+8StvMwkLciZogefr1JrR3dIlz3R1Lf0jPt00bx0pSbGhLscAAAmldH2JLpb0rPOuQJJzwbeB7PKObfEOVc8ynUCAIAJZFl+T2CyYQTjEr2ws07nzkpVckJkD1bd35KZKfrzHctCPsi2memr71ykA0fa9O2ndoZ02RPNV/66Ta0d3brv+qJwlwIAwKQz2pDoBkk/C3z/M0nvHOXyAADAJJM9NU75WUnaUNkwrPnrWzr0VnWzVhZOrF5EY614TppuuXC2fvrSbr2+rync5YTFczsO6/E3DuqOVfkqyJ4S7nIAAJh0RhsSZTvnaiQp8JoVZD4n6Skz22Jmt59qgWZ2u5ltNrPNdXXcdw8AwGSwPD9Dr+5uVEe3b8h511X07P8n2nhE4+GzJfOVPSVOn//TVnV2+8Ndzrhq6ejWFx7bqoKsJH1sZV64ywEAYFIaMiQys2fMrHSQrxtGsJ5lzrnzJF0t6Q4zuyTYjM65h51zxc654sxMDg4BAJgMLs5LV1uXT6/vOzLkvC+U1yk9MUaLpiePQ2UTy5S4aH3lnYu0o/aYHn6xKtzljKv715ar5mi7vnnjOYqN8oa7HAAAJqUhQyLn3OXOuUWDfD0u6ZCZTZOkwOvhIMs4GHg9LOkxSReE7p8AAAAi3YV56fKY9NIQ4xL5/U4vVtTrksJMeTyhe4T8ZHLFwmxdc840PfBspSoPt4S7nHHx+r4m/WzjHt1y4WydP3vQ56QAAIAQGO3tZqsl3Rr4/lZJj/efwcwSzWxK7/eSrpRUOsr1AgCACWRqXLTOmZGi9UOERFsPNKuxtfPEI98xuHuvK1J8jFf//qet8vtduMsZU53dft39x63KmRqnz1w1P9zlAAAwqY02JPqmpCvMrELSFYH3MrPpZvZEYJ5sSevN7E1Jr0r6m3PuyVGuFwAATDDL8zP0ZnWzjrV3BZ3n+fI6mfXMi+Ayp8TqC9ecpVf3NOrRTfvDXc6YeuiFKpUfOqavvnORpoT4qXEAAOBkowqJnHMNzrnLnHMFgdfGwPSDzrl3BL7f5ZxbHPgqcs59LRSFAwCAieXi/HT5/E6v7GoMOs8LOw/rnNxkpSfFjmNlE9NN58/QxXnp+sYT2/Xm/qHHepqINlTW67t/r9S150zTZWdlh7scAAAmvdH2JAIAABiW82alKi7aow1Vg99yduR4p97Yf0SXzg/2sFT0ZWb61o3nKDkhWjc9tFF/2FId7pJCxjmnn6zfrfc/8qpmpyfo3uuLwl0SAABnBEIiAAAwLuKivXrbnDRtCDIu0bqKevmddGkh4xEN18y0BK2+c7mKZ6fq337/pu77S5m6ff5wlzUq7V0+/evv39RX/rpNly3I0mN3LFMGPcsAABgXhEQAAGDcrJqfpZ2HWnTv6jJ19Qszni+vU3J8tJbMTAlTdRNTWmKMfv7BC3Tbsjn66YY9ev8jr6qxtTPcZZ2WmuY2veehjfrTawd01+UFevB95yspNircZQEAcMZgrwsAAMbN+y+arQNH2vST9bu1veaofvBP5yk9KVZ+v9MLO+u0oiBDXo+Fu8wJJ8rr0ZeuK1LR9GT9+2Nbdf331utH7y/WWdOmhru0Ado6fdq4q179Ozwda+/S15/YobbObj18y/m6signPAUCAHAGIyQCAADjJsrr0X9cu1CLcqfq7j9u1fXf26CHbjlfZlJ9S4dWMh7RqPzD+TOUn5Wk23++WZ989HU99alLw13SAN9/rlLfe65y0M/mZiTqNx9ZqoLsKeNcFQAAkAiJAABAGLzr3BkqyJqif/7FFt34w5d0wdw0SdIlBRlhrmziWzIzRXesyteXVpep8nCL8rOSwl3SCc45PbG1RhfMSdM91y0c8Hl+VpLior1hqAwAAEiMSQQAAMJkUW6yVt+5TOfOStG6inotnDZVWVPjwl3WpHBV4FattWW1Ya7kZBWHW7SrvlXXL5muRbnJA74IiAAACC9CIgAAEDbpSbH6xYeW6nMlC/TZkvnhLmfSyEmO07mzUrSmtCbcpZxkzdZamUlXFmWHuxQAADAIQoNTAIYAAAjRSURBVCIAABBW0V6PPrYyj/GIQqykKEelB45qf+PxcJdywpNltSqenaqsKfQYAwAgEhESAQAATEIliyLrlrO9Da3aXnP0xK1wAAAg8hASAQAATEKz0xN11rSperI0MkKi3joIiQAAiFyERAAAAJNUSVGOtuxr0uGj7eEuRU+W1ers3GTNTEsIdykAACAIQiIAAIBJ6uqzc+SctHbbobDWUdPcptf3HTlxCxwAAIhMhEQAAACTVEFWkuZlJGptmG85e6qsJ6QiJAIAILIREgEAAExSZqaSRTnauKtBTa2dYatjTWmNCrKSlJeZFLYaAADA0AiJAAAAJrGSRTny+Z2e2R6eW84aWjr06u5GehEBADABEBIBAABMYmfnJis3JT5sTzl7etsh+R23mgEAMBEQEgEAAExiZqarinK0rqJeLR3d477+J8tqNTMtXgunTR33dQMAgJEZVUhkZjeZWZmZ+c2s+BTzlZhZuZlVmtndo1knAAAARqZkUY46fX79fcfhcV1vc1uXNlTW6+pF02Rm47puAAAwcqPtSVQq6d2SXgw2g5l5JX1f0tWSFkq62cwWjnK9AAAAGKbzZ6cqIyl23J9y9tyOw+ryOV1VxK1mAABMBKMKiZxz251z5UPMdoGkSufcLudcp6RHJd0wmvUCAABg+Lwe05VF2Xqu/LDau3zjtt4nS2uVPTVW585MGbd1AgCA0xc1DuvIlbS/z/tqSUvHYb0AAAAIuHpRjn79yj4t/9bfFeUZn2Ep61o69E9LZ8nj4VYzAAAmgiFDIjN7RtJgfYS/4Jx7fBjrGOyowJ1ifbdLul2SZs2aNYzFAwAAYCgXzUvXx1fmqaGlc9zW6fWaPrR87ritDwAAjM6QIZFz7vJRrqNa0sw+72dIOniK9T0s6WFJKi4uDhomAQAAYPiivB59tmRBuMsAAAARbDz6Gm+SVGBmc80sRtJ7Ja0eh/UCAAAAAABgmEYVEpnZu8ysWtJFkv5mZmsD06eb2ROS5JzrlnSnpLWStkv6nXOubHRlAwAAAAAAIJRGNXC1c+4xSY8NMv2gpHf0ef+EpCdGsy4AAAAAAACMHXMucof9MbNjksrDXQcmjAxJ9eEuAhMG2wtGgu0FI8H2gpFim8FIsL1gJNheEMxs51xm/4mj6kk0Dsqdc8XhLgITg5ltZnvBcLG9YCTYXjASbC8YKbYZjATbC0aC7QUjNR4DVwMAAAAAACDCERIBAAAAAAAg4kOih8NdACYUtheMBNsLRoLtBSPB9oKRYpvBSLC9YCTYXjAiET1wNQAAAAAAAMZHpPckAgAAAAAAwDiIyJDIzErMrNzMKs3s7nDXg8hiZjPN7Dkz225mZWb2ycD0e83sgJm9Efh6R7hrRWQwsz1mtjWwXWwOTEszs6fNrCLwmhruOhEZzGx+n3bkDTM7amZ30cagl5k9YmaHzay0z7SgbYqZfT5wTFNuZleFp2qES5Dt5b/MbIeZvWVmj5lZSmD6HDNr69POPBi+yhEOQbaXoPsf2hcE2WZ+22d72WNmbwSm08ZgSBF3u5mZeSXtlHSFpGpJmyTd7JzbFtbCEDHMbJqkac6518xsiqQtkt4p6T2SWpxz94e1QEQcM9sjqdg5V99n2n9KanTOfTMQRqc65z4XrhoRmQL7pAOSlkq6TbQxkGRml0hqkfRz59yiwLRB2xQzWyjpN5IukDRd0jOSCp1zvjCVj3EWZHu5UtLfnXPdZvYtSQpsL3Mk/bV3Ppx5gmwv92qQ/Q/tC6TBt5l+n39bUrNz7su0MRiOSOxJdIGkSufcLudcp6RHJd0Q5poQQZxzNc651wLfH5O0XVJueKvCBHSDpJ8Fvv+ZeoJGoL/LJFU55/aGuxBEDufci5Ia+00O1qbcIOlR51yHc263pEr1HOvgDDHY9uKce8o51x14+7KkGeNeGCJSkPYlGNoXnHKbMTNTz4X034xrUZjQIjEkypW0v8/7ahEAIIhAGn6upFcCk+4MdN1+hNuH0IeT9JSZbTGz2wPTsp1zNVJP8CgpK2zVIZK9VycfWNHGIJhgbQrHNRjKByWt6fN+rpm9bmYvmNmKcBWFiDPY/of2BUNZIemQc66izzTaGJxSJIZENsi0yLonDhHBzJIk/VHSXc65o5J+KClP0hJJNZK+HcbyEFmWOefOk3S1pDsC3XKBUzKzGEnXS/p9YBJtDE4HxzUIysy+IKlb0q8Ck2okzXLOnSvp05J+bWZTw1UfIkaw/Q/tC4Zys06+2EUbgyFFYkhULWlmn/czJB0MUy2IUGYWrZ6A6FfOuT9JknPukHPO55zzS/qR6G6LAOfcwcDrYUmPqWfbOBQY36p3nKvD4asQEepqSa855w5JtDEYUrA2heMaDMrMbpV0raR/coFBQgO3DTUEvt8iqUpSYfiqRCQ4xf6H9gVBmVmUpHdL+m3vNNoYDEckhkSbJBWY2dzAVdz3Slod5poQQQL31v5E0nbn3Hf6TJ/WZ7Z3SSrt/7M485hZYmCAc5lZoqQr1bNtrJZ0a2C2WyU9Hp4KEcFOuvpGG4MhBGtTVkt6r5nFmtlcSQWSXg1DfYggZlYi6XOSrnfOHe8zPTMwYL7MbJ56tpdd4akSkeIU+x/aF5zK5ZJ2OOeqeyfQxmA4osJdQH+BpzzcKWmtJK+kR5xzZWEuC5FlmaRbJG3tfZyjpH+XdLOZLVFPN9s9kv45POUhwmRLeqwnW1SUpF875540s02SfmdmH5K0T9JNYawREcbMEtTzlM2+7ch/0sZAkszsN5JWSsows2pJX5L0TQ3Spjjnyszsd5K2qee2ojt48tCZJcj28nlJsZKeDuyfXnbOfVTSJZK+bGbdknySPuqcG+4gxpgEgmwvKwfb/9C+QBp8m3HO/UQDx1WUaGMwDBbo3QoAAAAAAIAzWCTebgYAAAAAAIBxRkgEAAAAAAAAQiIAAAAAAAAQEgEAAAAAAECERAAAAAAAABAhEQAAAAAAAERIBAAAAAAAABESAQAAAAAAQNL/B8R7vB8HQfPEAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -2097,7 +1986,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABIcAAACMCAYAAADm+clLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3dfYxc13nf8d8zb7s7S+5yV0tJlkiRlCPHlV0pkbaOUyOunTSpnLpRC6SAhLy4aQJVgZWmRZvYborkjxSokfQtTZwYgqMqgQ0LRuIkQiK/BG6T1A0ki5QtW7KjiCGXFE3FIrnLHXJ2hvP29I97787s7LzcFbmcuXe+H4DYnXvvLM/oiHfPfc5znmPuLgAAAAAAAEymzKgbAAAAAAAAgNEhOAQAAAAAADDBCA4BAAAAAABMMIJDAAAAAAAAE4zgEAAAAAAAwAQjOAQAAAAAADDBcqNuQC9LS0t++PDhUTcDAAAAAAAgNY4dO3be3fd3Hx8aHDKzxyS9V9Jr7v7WHudN0q9J+kFJG5L+hbs/F567LzyXlfQxd/9wnMYePnxYR48ejXMpAAAAAAAAYjCzU72Ox1lW9rik+wacf4+kO8I/D0n6rfAvzEr6SHj+TkkPmtmd8ZsMAAAAAACA3TY0OOTufyFpdcAl90v6XQ88LWmfmb1B0tskHXf3E+5ek/REeC0AAAAAAADGxLUoSH2rpFc6Xp8Jj/U7DiTKNy9W9B//8GuqN1ujbgoAABhDL3/rkv7TH39drZaPuikAgAF+/Qsv69mVQbkvk+taBIesxzEfcLz3DzF7yMyOmtnRc+fOXYNmAdfGn730mj7+9GmdulAedVMAAMAY+vzXv6WPffGkVjdqo24KAKAPd9evfeFlPfmVs6Nuyli6FsGhM5IOdrw+IOnsgOM9ufuj7r7s7sv7928rnA2MzHqlvuUrAABAJ8YKADD+NmpNNVrOvbqPaxEcelLSj1vg7ZLW3f1VSc9KusPMjphZQdID4bVAojDgAwAAg6xvMFYAgHHHc91gcbay/6Skd0laMrMzkn5JUl6S3P2jkp5SsI39cQVb2f9EeK5hZo9I+pyCrewfc/cXd+EzALuqVGls+QoAANCpVA0eNEo8cADA2Nq8V1e5V/cyNDjk7g8OOe+S3t/n3FMKgkdAYpWIMAMAgAGYjQaA8UeW52DXYlkZkGrMBgIAgEHas9FkGQPAuIru0awI6Y3gEDAEs4EAAGCQaIzARBIAjK/Oe3WwAAqdCA4BQ0QDPdamAgCAXtr1CRkrAMC4iu7RtWZLVxqtEbdm/BAcAoYgcwgAAPTTavnmBBJjBQAYX533aO7X2xEcAgZwd9amAgCAvi7XGopWJ5BlDADjq/MeTabndgSHgAHKtaaarWDER3QZAAB0i3a/kRgrAMA4I3NoMIJDwACdEWVmAwEAQLetM9FkGQPAuOq8R/Nstx3BIWCAKKJ809wU0WUAALBNND64eW6asQIAjLFSpa6b56YlkTnUC8EhYIAoc+jgQlGXrzTUarHlIQAAaItmog8uzjATDQBjrFSt6+DiTPA9mZ7bEBwCBogiyrctFuUuXapyEwEAAG2dE0mlSp2JJAAYU+uVug4sFDe/x1YEh4ABop3KDiwWw9fcRAAAQFs0NjiwWFTLpXKNiSQAGEelSl2LswXNFrLsVtYDwSFggPXN2cCZLa/Txt31vf/1z/SJZ06NuikAACTKeqWujEm3zFPHAgDGVb3ZUrnW1Nx0XnMzee7VPRAcAgYoVeoyk25dmNl8nUaVelMnzpX19bOlUTcFAIBEKVXqmpvJa18xH74mcwgAxk1UHmR+Jqf5mTwrQnogOAQMsF6pa89UTvtmCpuv02i1XJMkrW3URtwSAACSZb1SD2aip/ObrwEA4yW6N8/NBPdr7tXbERwCBihV65qfyWs+mg1MaYR5rRx8rihIBAAA4ilVG5qfCZYpBK/TOVYAgCSLVoBE92uyPLcjOAQMUNqcDcxJSu9s4GqYMRQFiQAAQDzrlbrmwmUK0WsAwHjZkjk0k+Ne3UOs4JCZ3WdmL5nZcTP7YI/zP2dmXwn/vGBmTTNbDM+tmNnXwnNHr/UHAHZTqRLMBu6Zyilj6a0jcHGDZWUAALwepUp9a+YQDxwAMHairM75mTw1h/oYGhwys6ykj0h6j6Q7JT1oZnd2XuPuv+ru3+Hu3yHpQ5L+3N1XOy55d3h++Rq2Hdh10WygmaW6qn1nzSF3H3FrAABIjqjm0N6pnMwIDgHAONrMHAprxF2qNtRs8dzTKU7m0NskHXf3E+5ek/SEpPsHXP+gpE9ei8YBoxbVHJKU6gjzWhgcqjddl6+kMzsKAIDdEI0VMhnT3qmcSlV+jwLAuIlWgESZQ5J0mfv1FnGCQ7dKeqXj9Znw2DZmVpR0n6Tf7zjskj5vZsfM7KHX21BgFKLZQEmprmq/2rGcjLpDAADEc6XRVLXe2lxSluYsYwBIsvVKXfmsaTqf2bxnc7/eKk5wyHoc65d/9U8k/b+uJWXvcPd7FCxLe7+ZvbPnX2L2kJkdNbOj586di9EsYHfVmy1t1JpbM4dSegPpDAitUncIAIBYopnouQkYKwBAkkVZnma2+XyX1lUhr1ec4NAZSQc7Xh+QdLbPtQ+oa0mZu58Nv74m6Q8ULFPbxt0fdfdld1/ev39/jGYBu6vUUdE++Jreqvar5ZoK2eB2sMZ29gAAxNKuYZELv5I5BADjaOuKkHTvRP16xQkOPSvpDjM7YmYFBQGgJ7svMrN5Sf9A0h91HJs1s73R95J+QNIL16LhwG6LagZsrTmUznWpaxs1HVmaldQuTg0AAAbr3P0m+spMNACMn1Kl3s7yLLK7ZC9Dg0Pu3pD0iKTPSfqGpE+5+4tm9rCZPdxx6T+T9Hl3L3ccu0nSF83seUlfkvQn7v7Za9d8YPdszgbOpH82cLVc0xtvDIJDbGcPAEA86xOUZQwASdYZHIoyiLhfb5WLc5G7PyXpqa5jH+16/bikx7uOnZB091W1EBiRKJI831FkstZoqVpvajqfHWXTril318WNum5bnFU2YwSHAACIqXusENQcSmeWMQAkWana0G03BJPh1BzqLc6yMmAitesItINDUvrSD8u1pmrNlhZn81ooFrTKbmUAAMRS6h4rTOdVqTdVa7RG2SwAQJeg5lCQG1MsZJXNGJlDXQgOAX2s95gN7DyeFlEB6oViQQvFPAWpAQCIqXsJelTHIm1jBQBIMnfXeqW++TwX7VjGvXorgkNAH1GaYXttam7L8bSIClAvzha0MFtgK3sAAGIqVRuazmc0lQuWm0cZRGkbKwBAkm3Ummq2fPO5Tgqe7VgGvBXBIaCP9UpdhVxms75QWjOHomDQwmxBi8UCmUMAAMS0vtGeiZbSO1YAgCTrXhESfc+9eiuCQ0AfpUpjcwZQ6qw5lK4IcxQMWiwGmUMUpAYAIJ5Std41VgizjHngAICxsbkipOvZjizPrQgOAX2UKnXNz7Q39EvrbGC0rGxhtqDF2bzWNupqtXzErQIAYPx11rCQ0jtWAIAkW9/Ynjk0R+bQNgSHgD5K1XrXutR07la2tlFTNmOam85poVhQs+W6VE1XdhQAALuh71iB36MAMDaie/Jcx8T/3HQ+dStCrhbBIaCP7tnAQi6jmXw2dRHmtY26Fop5mZkWZwvhMZaWAQAwTPdYob0EPV1jBQBIsn41h0qVutxZMREhOAT0UapsrSMgBdHmtK1NXSvXtFAMgkILYXCIHcsAABguqE/YnomezmdVyGUIDgHAGInuyd014mrNlq40WqNq1tghOAT00T0bKKWzqv1qubYZFIqCROxYBgDAYK2Wq1SdjLECACRZdE/eO53+erJXg+AQ0IO7q1RtbFmXKqVzberaRk2LYVAo+rpKcAgAgIEu1xpy15aaQ5I0N52+LGMASLJSta49Uznlsu3wR1rryV4NgkNAD+VaU82WT8Rs4Gq53s4cmg0+LzWHAAAYLNr9pjs4lMaxAgAkWb8VIdE5BAgOAT30WpcqhYXLUjQb6O5B5lAYFNozlVM+a1otp+czAgCwG6LxQK8HjrRlGQNAkpUqjZ6BfEmpera7WgSHgB56VbSXgtnBNEWXS9WGmi3frDVkZlooFqg5BADAEOt9JpLSNlYAgKQLNhrqKhdC5tA2BIeAHjYzh3oEhy5faajVSseWhxfD5WPRFvbR9ywrAwBgsCg7qGfmEDPRADA2+m0eIIlMzw4Eh4Ae+mYOTefkLl2qpuMmEhWejjKHou8JDgEAMFh7IqnX5hX11EwkAUDSrVfq2yb9o53LyBxqixUcMrP7zOwlMztuZh/scf5dZrZuZl8J//xi3PcC46gUBn961RwKzqfjJhIFgRa6MofYrQwAgMEG1RxquVSupWMiCQCSrtSjIHU+m9FsIctuZR1ywy4ws6ykj0j6fklnJD1rZk+6+9e7Lv2/7v7e1/leYKwMqjkUnT943Vt17UWFpxc7Mof2FfNa2+AmCQDAIOuVujImzRa661i0Z6P3dk0yAQCur3qzpXKtuW3SX6JGXLc4mUNvk3Tc3U+4e03SE5Luj/nzr+a9wMhEEeQ9XYXL2mtT03ETiQpPR1vYS0Hm0MWNmpqkwwMA0FcpXKaQydiW49SxAIDxEZUDmZ/ZnhdDjbit4gSHbpX0SsfrM+Gxbt9tZs+b2WfM7C07fK/M7CEzO2pmR8+dOxejWcDuCWb7csp2DfiiiHNaIsyrGzXls6Y9U+2b5UKxoJanJwAGAMBuWK/Ue89Ep2ysAABJtt5noyEpuF9zr26LExyyHse6Uwqek3TI3e+W9OuS/nAH7w0Ouj/q7svuvrx///4YzQJ2T6nae8A3X0xZzaFyTQvFgsza/1SjnctWKUoNAEBfpWpj2/Jzqf0AkpaxAgAkWalPuRApuF+T5dkWJzh0RtpSXuWApLOdF7h7yd0vh98/JSlvZktx3guMo15Fy6RgtzIpPbOBq+Xalm3spXZx6jWKUgMA0Few+03vZQrReQDAaA3MHJrJca/uECc49KykO8zsiJkVJD0g6cnOC8zsZgtTD8zsbeHPvRDnvcA4KlUaPQd8e6Zyylh66ghc3KhrX3HrjTIqTk1RagAA+us7kZSy+oQAkGT9dpaMjpHl2TZ0tzJ3b5jZI5I+Jykr6TF3f9HMHg7Pf1TSD0v6aTNrSKpIesDdXVLP9+7SZwGumfVKXYeXituOm1mqqtqvbtT0ppv2bDkWFacmcwgAgP761RzaO5WTGcEhABgHm5lDfWrEXao21Gz5tlqzk2hocEjaXCr2VNexj3Z8/xuSfiPue4Fx16/mkJSuCHNUc6gTNYcAABiuVO2dOZTJmPZO5VSqpiPLGACSLFrx0S9zSJIuVxubtWXT4Mun1/Tsyqoeeucbd/S+OMvKgImz3idVXEpPVftWy7W2sb3m0Ew+q0IuQ+YQAAB9XGk0Va23etawkJSqLGMASLL1Sl35rGk6vz30MZfSGnEff/q0/vNn/krVenNH7yM4BHSpN1vaqDX7DvjmZ/KpSBUvVetqubZlDpmZFosFrRIcAgCgp2gmOu1jBQBIuijLs3N35sh8SneXXLlQlrv0yurGjt5HcAjoMmi7Qyk9Ve2j4E935pAU7Fi2xrIyAAB6atew6F2hIS1ZxgCQdP3qw0np24k6snK+LEk6GX6Ni+AQ0KW93WHvAd/8TF7rKditLAr+LPQIDi3O5skcAgCgj/UhE0nzLCsDgLFQqtT7Z3kW07esbL1S14XwOY7gEHCVogKSg2oOpSH1cK0cfIaFHsXXFooFXWQrewAAeorGAf1rDuVSMVYAgKQbFByKMorStAx4pSMgtHKB4BBwVQZtdygFA8Fao7XjAl/jJtqNrLvmkBQsNWO3MgAAehu2BJ3MIQAYD4M2GppPYUHqKCC0r5gncwi4WsNrDqUjwrw2qOZQsaD1Sl2NZut6NwsAgLFXGjaRNJ1Xtd7SlUayJ5IAIOlK1Ubf+nDFQlbZjKUq0/PEubLMpO+5Y79WzlOQGrgq7ZpD6Y4wr27UVMhlVCxkt51bnC3IPfmfEQCA3TC0PmExmkhKfo1CAEgqdx+YOWRmqcv0XLlQ1i3zM/r2m/bob0tVbdTi/x4iOAR0iSLH/WsO5bZcl1Rr5ZoWi4We2zruCwe17FgGAMB2pWpD0/mMpnLbJ1ikjjoWCR8rAECSbdSaara876S/FDzbpSmQv3K+rCNLszq8NBu+jp89RHAI6LJeqauQzWgq1/ufR2oyh8r1njuVSe2lZqvlZH9GAAB2w/pG/5loKT1jBQBIsmE7S0bn0nKvdnedDINDR6Lg0A6KUhMcArqUKg3NzeR7ZtRInTWHkh1hXtuoaXG2940yKlLNdvYAAGxXqtb71huS2svNkl6fEACSbHNnyYH363TsRC0Fz26lakOHl2Z1+IYgOLSTotQEh4AuwXaHvWsISOmZDVwr13ruVCa1M4dYVgYAwHaDalhI6RkrAECSrW8MzxyaS1HmUJQldGSpqNmpnG7cO0VwCLgapergAd9mHYGE30TWNvoHh6LjBIcAANiuVK0PqWER1RxKdpYxACRZdA8eNPE/N51P/IqQyMmwvtCRpT3h11mtEBwCXr/1yuBU8UIuo5l8NtER5mbLdbHSv+bQTCGrmXx2c7t7AADQNixzqL0EPbljBQBIurg1h0qVutz9ejVr15w8f1nZjOnAwoykMDhEzSHg9SsNGfBJ4U0kwWtT1yt1uUuLxf6fc3G2QEFqAAB6KFUaA8cK0/mspnIZgkMAMEKlmMGhWrOlK43W9WrWrlk5v6GDCzPKZ4Mwz+GlWZ2/XIv93BorOGRm95nZS2Z23Mw+2OP8j5jZV8M/f2lmd3ecWzGzr5nZV8zsaLyPBYzO+pCaQ1KQmpjkzKGo0HS/zKHgXJ5lZQAAdGm1PCxIPWyskJ46FlLwuX/ls3+ll791adRNAYBYonvw3hgbCKThfh3tVBaJilLHXVo2NDhkZllJH5H0Hkl3SnrQzO7sboekf+Dud0n6ZUmPdp1/t7t/h7svx2oVMCLurlJ18GygFKUfJndtahT0WRwUHCoW2K0MAIAul2sNuWtgzSEp+VnG3V5+7bJ+88/+Rp945vSomwIAsZSqde2dyimb6b0LtdTOKkp6pqe7a+VCWYc7gkO379/ZjmVxMofeJum4u59w95qkJyTd39WQv3T3tfDl05IOxPrbgTFTrjXVbPnAmkNSULgsydHlzcyhPgWpo3NkDgEAsFW0+82w4NDcdLKzjLsdPbW65SsAjLtgRcjw57ro2iR77dIVbdSaWzKHblssyixYbhZHnODQrZJe6Xh9JjzWz09K+kzHa5f0eTM7ZmYPxWoVMCJx1qVG55M8GxgVmh6UORTUHCI4BABAp+j3f9qzjLsdWwnmgb/x6iWVr6TncwFIr1KlESvLU1Kin+2kdnZQtJRMCurf3TI/o5PnL8f6GXGCQ71ysHqW8jazdysIDn2g4/A73P0eBcvS3m9m7+zz3ofM7KiZHT137lyMZgHXXhQxHhphTngdgbVw1nNY5tClakP1ZvKLswEAcK1sjhWGZRknfKzQ7djpNe0r5tVsuZ5/5eKomwMAQ5Uq8erDScnPHIrqCnVmDknS4aWiTl64dplDZyQd7Hh9QNLZ7ovM7C5JH5N0v7tfiI67+9nw62uS/kDBMrVt3P1Rd1929+X9+/fHajxwrcXNHJqbyevylYZarWRuebi2UdN0PqOZQrbvNYuzwX+DixvJvlECAHAtRdlAac8y7nTu0hWdurChH/2uQ5Kko6fWhrwDAEavVI23C7WkxGd6njxfViGb0S37ZrYcP7I0q5PnLst9+HNrnODQs5LuMLMjZlaQ9ICkJzsvMLPbJH1a0o+5+193HJ81s73R95J+QNILMf5OYCRizwZO5+QuXaom8yayWq5pcUDWkNTeyYy6QwAAtJU2s4yHzEZP51Wq1BM7kdTpWFhn6N1vvlFvumkPwSEAiRCn5tDe6XTsVnbyfFm33VDcVnz78A2zKlUbmytHBhkaHHL3hqRHJH1O0jckfcrdXzSzh83s4fCyX5R0g6Tf7Nqy/iZJXzSz5yV9SdKfuPtnY34+4LorVePPBgbXJ/MmslauDdzGXtJm8Ii6QwAAtO2k5lDLpXItmRNJnY6urKmQy+itt87p3kOL+vKpNTVTEPQCkG6lyvDMoXw2o9lCNvG7la1cKG9bUia1l5nF2bFs8JRHyN2fkvRU17GPdnz/U5J+qsf7Tki6O87fAYyD9bizgR1rUw8OvHI8rW7UBhajljoyhwgOAQCwab1SV8ak2cKwsUJ7NnrvkIzkcXfs9JruPjCvqVxWy4cW9MkvndbLr13Sm2+eG3XTAKCnerOlcq05dEWIlPwaca2Wa+XCht717TduOxcFh1bOl3XvoYWBPyfOsjJgYkQR42GDuPba1GTeRNbKtYHFqKV2sepVlpUBALCpFC5TyGR67dnSlpY6FtV6Uy98c133hA8Vy4eDr0dXWFoGYHxd2lwRMjwfJuk14s6uV1RrtLbsVBY5uBgsNVu5MDxziOAQ0GG9Utfeqdy2tZrdogh0UiPMq+XhmUP7isFnJHMIAIC29Uo93kx0wscKka+eWVe96Vo+tChJum2xqKU9BR2j7hCAMRZ3F2opuF8n+V69cj7YjezwUnHbuXw2owMLMzoRY1kZwSGgQ6k6vGiZJM0Xk1tzqNFsqVRtbAZ/+pnOZzVbyGq1nLzPCADAbilVG0NrWEjtB5IkjhU6RUGgaDmCmeneQwsEhwCMtbi7UEvB/TrJWZ4nw6yg25f29Dx/+IbZza3uByE4BHQoxahoLwW7lUnJnA28GLZ5WOaQFNQdusiyMgAANgW738RbphBdn2THTq3q9v2zW8YNy4cWdXp1Q69dqo6wZQDQ344yh2Zyib5XnzxX1kw+q5vmpnqeP7IUBIeGbWdPcAjoUKo0Yq1L3TOVU8aSWUcgWiY2rOaQFASQqDkEAEBbnN1vpI7MoQQ/cLi7jp1a0723bS1iem9Yd+gYdYcAjKm4O0tG1yQ5y3PlQlmHbijKrHdplCNLsyrXmjp36crAn0NwCOgQt46AmSW2qn20NX2szKFigZpDAAB0iDtW2DuVk1myg0N/c66stY36ZhHqyFtumVMhl9FRlpYBGFObmUMxa8RdqjbUbA3OrBlXK+fLun3/9mLUkcMxt7MnOAR0KFXjzQZKyY0wr22QOQQAwOsVd6yQyZj2TuVUqiYvyzjy3Ga9ocUtx6dyWd19YJ66QwDGVrTCI27mkCRdTuD9utFs6fTqRs+dyiK3R9vZD9mxjOAQ0GE9Zs0hKblV7aMC0/Ezh5L3GQEA2A1XGk1V6634Y4WEZhlHjp5a1b5ifvPBotO9hxb14tl1VevNEbQMAAZbr9SVz5qm88NDHnMJrhF3Zq2iRss3s4N6uWXfjArZjE6Gu5r1Q3AICNWbLW3UmjvKHEriDSTKHBq2W5kkLRTzunyloSsNBn4AAOykwKmU3LFC5GhYbyiT2V7HYvnQgupN1/OvXBxBywBgsPWwPly/OjydkryBQHunsv7BoWzGdHBxRifPXx74swgOAaHS5rrU4QWppaCqfRLrCKyWayoWsprOZ4deuxBmF13cSN7nBADgWouWKcQeK0znEzlWkILxwolz5c3i093uCbe2p+4QgHFUqsarDye17+lJLBkSbVE/KHNIinYsI3MIiCWKFM/HyKiRotnA5K1LXSvXYtUbktpLz1YpSg0AQHusMAGZQ1G9oeWuekORxdmCbt8/u3kdAIyT0g7KhUTPf0m8X588X9beqZxuGFIy5MjSrFYulNUaUHSb4BAQigpGxo8wJ7cgdZx6Q1K7aPUaRakBANj8vR+/5lAukWMFKcgIymdNdx2Y73vN8qEFHTu9NvBhAwBGYSfBoej5L4mZnifPl3V4aXbo8rnDS7O60mjpb0vVvtcQHAJCO50NnJvJq9ZoJa4Q4+pGfXO52DBREImi1AAAtB8cJiFz6NipVb3llvmBy9CXDy3q4kZdJ4bUsQCA6y2qORRHkmsOrVwo68iQJWWSdOSG4dvZExwCQjsd8EWR6KRFmNfKNS3GXDq3MBtcx3b2AAB01ieMPxtdrbcSt7FDrdHS82fWtXyod72hSFSPiC3tAYybUrURuz5csZBVNmOJy/S80mjqm2uVofWGpHZNIoJDQAyvZweSzvclxVq5FjtzaHNZGTWHAADoGCvEe+CI6liUElaj8IWz66o1WlruU4w6cvvSrBaKeR1dITgEYHy4+44yh8wskZmer6xuqOXSkaXi0GtvnpvWdD6zWcC6F4JDQCiKFMfOHEpgVftao6VLVxpajFmQOp/NaO90joLUAAAomImezmc0lRu+46fUUcciQWMFSToWBnvuGZI5ZGa699ACmUMAxspGralmy2NP+kvBs13SAvknw93HjiztGXptJmM6fMPs1WcOmdl9ZvaSmR03sw/2OG9m9j/D8181s3vivhcYF+uVugrZjKZy8WKmScwcuhguD4ubOSQFdYcoSA0AgLS+EX8mWkrmWEGSjp5a1W2LRd24d3rotfceWtSJ82VduHzlOrQMAIbbaS3Z6Nqk3atPhvXeonpCwxy+YVYnL1xFcMjMspI+Iuk9ku6U9KCZ3dl12Xsk3RH+eUjSb+3gvcBYKFUampvJD630HmnXHEpOhDmqHRR3K3tJ2lcskDkEAICCDKC49Yak9vKzJNUndHcdO3VxaL2hSLT07LnTF3ezWQAQ2+bOkju6XydvJ+qT5ze0UMxvLmEe5sj+Wb2yutH3fJwUibdJOu7uJ9y9JukJSfd3XXO/pN/1wNOS9pnZG2K+FxgLwXaH8WoISMmcDYx2HYsKTcexWMzr4kZyPiMAALtlJzUspGSOFU6vbuj85StDl5RF/u6t88pnTUdPre5yywAgnvWNnWcOzSUwc2jlfLydyiJHbphVvel9z5t7/5OSZGY/LOk+d/+p8PWPSfoud3+k45o/lvRhd/9i+PoLkj4g6fCw9/Zy5y17/OP/6q7hnw64huqtlmYLOb31lvlY17fc9aWVVWXNlM3EyzYatZa7Gi3XXbfOq1iIFwg7fu6yzl++ooOJcmQAAAe6SURBVEKWEmUAgMlWb7Y0P5PXm2+ei3V9rdnSc6fXlM2YsjEzk0ft9YwVXji7rnKtoXyGsQKA0YvuY2+9ZV57puLdx06cv6zXLiXrmafebOmGPVP6tv3Daw5JQUbV118t6bt/+Zlj7r7cfT7Of6lev8m6I0r9ronz3uAHmD2kYEma7nxDcUdRPuBa2UktnoyZblssqlJL1va0+WxGM4V4hTQl6aa5KWVMGhJHBgBgIiztmYp9bT5rOrBvRlcarV1s0bVXyO1srHBwoajz1BwCMEZyWVNxaifPPEGNtSQ985gpVm24yEw+O/B3WJzg0BlJBzteH5B0NuY1hRjvlSS5+6OSHpWk5eVlf+PP/3mMpgGjdcuoG3Ad7A3/AACAnTEFg9+0mw//AEBSzUq6fdSN2GV5Sd8mSR/onckaJ2fqWUl3mNkRMytIekDSk13XPCnpx8Ndy94uad3dX435XgAAAAAAAIzI0Mwhd2+Y2SOSPicpK+kxd3/RzB4Oz39U0lOSflDScUkbkn5i0Ht35ZMAAAAAAABgx4YWpB6F5eVlP3r06KibAQAAAAAAkBpm1rMg9VgGh8zskqSXRt0OjMSSpPOjbgRGhv6fXPT9ZKP/Jxd9P9no/8lF3082+n+0Drn7/u6D8fZ1u/5e6hXJQvqZ2VH6fnLR/5OLvp9s9P/kou8nG/0/uej7yUb/j6c4BakBAAAAAACQUgSHAAAAAAAAJti4BoceHXUDMDL0/WSj/ycXfT/Z6P/JRd9PNvp/ctH3k43+H0NjWZAaAAAAAAAA18e4Zg4BAAAAAADgOhir4JCZ3WdmL5nZcTP74Kjbg91jZgfN7P+Y2TfM7EUz+9nw+KKZ/amZvRx+XRh1W7F7zCxrZl82sz8OX9P/E8LM9pnZ75nZX4X3ge+m/yeDmf3b8L7/gpl90sym6fv0MrPHzOw1M3uh41jf/jazD4XjwJfM7B+NptW4Fvr0/a+G9/2vmtkfmNm+jnP0fYr06v+Oc//ezNzMljqO0f8p0a/vzexnwv590cx+peM4fT8mxiY4ZGZZSR+R9B5Jd0p60MzuHG2rsIsakv6du/8dSW+X9P6wvz8o6QvufoekL4SvkV4/K+kbHa/p/8nxa5I+6+5vlnS3gv8P6P+UM7NbJf1rScvu/lZJWUkPiL5Ps8cl3dd1rGd/h+OAByS9JXzPb4bjQyTT49re938q6a3ufpekv5b0IYm+T6nHtb3/ZWYHJX2/pNMdx+j/dHlcXX1vZu+WdL+ku9z9LZL+S3icvh8jYxMckvQ2Scfd/YS71yQ9oeB/IKSQu7/q7s+F319S8GB4q4I+/53wst+R9E9H00LsNjM7IOkfS/pYx2H6fwKY2Zykd0r6bUly95q7XxT9PylykmbMLCepKOms6PvUcve/kLTadbhff98v6Ql3v+LuJyUdVzA+RAL16nt3/7y7N8KXT0s6EH5P36dMn3/7kvTfJf28pM7Ct/R/ivTp+5+W9GF3vxJe81p4nL4fI+MUHLpV0isdr8+Ex5ByZnZY0ndKekbSTe7+qhQEkCTdOLqWYZf9DwWDg1bHMfp/Mtwu6Zyk/xUuK/yYmc2K/k89d/+mgtnC05JelbTu7p8XfT9p+vU3Y8HJ8i8lfSb8nr6fAGb2Q5K+6e7Pd52i/9PvTZK+x8yeMbM/N7O/Fx6n78fIOAWHrMcxtlJLOTPbI+n3Jf0bdy+Nuj24PszsvZJec/djo24LRiIn6R5Jv+Xu3ympLJYRTYSwtsz9ko5IukXSrJn96GhbhTHCWHBCmNkvKCgx8InoUI/L6PsUMbOipF+Q9Iu9Tvc4Rv+nS07SgoJyIj8n6VNmZqLvx8o4BYfOSDrY8fqAglRzpJSZ5RUEhj7h7p8OD3/LzN4Qnn+DpNf6vR+J9g5JP2RmKwqWkH6vmX1c9P+kOCPpjLs/E77+PQXBIvo//f6hpJPufs7d65I+Lenvi76fNP36m7HgBDCz90l6r6QfcffoIZC+T783KpgYeD4c/x2Q9JyZ3Sz6fxKckfRpD3xJwcqBJdH3Y2WcgkPPSrrDzI6YWUFBYaonR9wm7JIwUvzbkr7h7v+t49STkt4Xfv8+SX90vduG3efuH3L3A+5+WMG/9f/t7j8q+n8iuPvfSnrFzL49PPR9kr4u+n8SnJb0djMrhr8Hvk9BzTn6frL06+8nJT1gZlNmdkTSHZK+NIL2YZeY2X2SPiDph9x9o+MUfZ9y7v41d7/R3Q+H478zku4JxwT0f/r9oaTvlSQze5OkgqTzou/HSm7UDYi4e8PMHpH0OQW7lzzm7i+OuFnYPe+Q9GOSvmZmXwmP/QdJH1aQZviTCh4i/vmI2ofRoP8nx89I+kQ4GXBC0k8omLCg/1PM3Z8xs9+T9JyCJSVflvSopD2i71PJzD4p6V2SlszsjKRfUp97vbu/aGafUhAsbkh6v7s3R9JwXLU+ff8hSVOS/jSID+tpd3+Yvk+fXv3v7r/d61r6P136/Nt/TNJj4fb2NUnvCzMH6fsxYu1sTgAAAAAAAEyacVpWBgAAAAAAgOuM4BAAAAAAAMAEIzgEAAAAAAAwwQgOAQAAAAAATDCCQwAAAAAAABOM4BAAAAAAAMAEIzgEAAAAAAAwwQgOAQAAAAAATLD/D+iwRRV3noBQAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2112,19 +2001,14 @@ "output_type": "stream", "text": [ "tal hits:\n", - "MotifHitAndCoord(motif_idx=0, motif_score=0.999818566464115, precision_at_motif_score=1.0, example_idx=5, start=26, end=51, is_revcomp=False)\n", - "MotifHitAndCoord(motif_idx=0, motif_score=0.8856687419902738, precision_at_motif_score=0.8314828431175738, example_idx=5, start=35, end=60, is_revcomp=True)\n", - "MotifHitAndCoord(motif_idx=0, motif_score=0.9995073050902686, precision_at_motif_score=1.0, example_idx=5, start=108, end=133, is_revcomp=False)\n", - "MotifHitAndCoord(motif_idx=0, motif_score=0.635539514810006, precision_at_motif_score=0.28118745516214005, example_idx=5, start=117, end=142, is_revcomp=True)\n", - "MotifHitAndCoord(motif_idx=0, motif_score=0.9952651939732524, precision_at_motif_score=1.0, example_idx=5, start=165, end=190, is_revcomp=False)\n", - "MotifHitAndCoord(motif_idx=0, motif_score=0.704276474569764, precision_at_motif_score=0.44302641367625195, example_idx=5, start=174, end=199, is_revcomp=True)\n", + "\n", "gata hits:\n", "\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2143,7 +2027,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2155,7 +2039,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2170,20 +2054,14 @@ "output_type": "stream", "text": [ "tal hits:\n", - "MotifHitAndCoord(motif_idx=0, motif_score=0.8114523781844735, precision_at_motif_score=0.6617643108541413, example_idx=6, start=8, end=33, is_revcomp=False)\n", - "MotifHitAndCoord(motif_idx=0, motif_score=0.9988489961840756, precision_at_motif_score=1.0, example_idx=6, start=17, end=42, is_revcomp=True)\n", - "MotifHitAndCoord(motif_idx=0, motif_score=0.8389726480891654, precision_at_motif_score=0.7246978685792207, example_idx=6, start=44, end=69, is_revcomp=False)\n", - "MotifHitAndCoord(motif_idx=0, motif_score=0.9998068744229901, precision_at_motif_score=1.0, example_idx=6, start=53, end=78, is_revcomp=True)\n", - "MotifHitAndCoord(motif_idx=0, motif_score=0.6694922206103467, precision_at_motif_score=0.3611280077363049, example_idx=6, start=75, end=100, is_revcomp=False)\n", - "MotifHitAndCoord(motif_idx=0, motif_score=0.9995233787592409, precision_at_motif_score=1.0, example_idx=6, start=84, end=109, is_revcomp=True)\n", + "\n", "gata hits:\n", - "MotifHitAndCoord(motif_idx=1, motif_score=0.9998292111100581, precision_at_motif_score=1.0, example_idx=6, start=112, end=137, is_revcomp=True)\n", - "MotifHitAndCoord(motif_idx=1, motif_score=0.8404588409236708, precision_at_motif_score=0.7594466445239779, example_idx=6, start=156, end=181, is_revcomp=True)\n" + "MotifHitAndCoord(motif_idx=1, motif_score=0.8603651821491742, precision_at_motif_score=0.8641402146551365, example_idx=6, start=171, end=196, is_revcomp=False)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABI0AAACMCAYAAADx21mCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3wUxfvA8c/eXRpJSELovRdBOkgRETsKIqIUFRt+7Q3FXgiIBRV/ooiAggrSBUF6UapI772XUEN6T+7u+f0xaUcSCRIg4vN+ve6Vy97c7uze7uzsszOzloiglFJKKaWUUkoppVROtiudAaWUUkoppZRSSilV9GjQSCmllFJKKaWUUkrlokEjpZRSSimllFJKKZWLBo2UUkoppZRSSimlVC4aNFJKKaWUUkoppZRSuWjQSCmllFJKKaWUUkrl4rjSGfg7JUuWlKpVq17pbCillFJKKaWUUkpdNTZs2HBWREqdL12RDhpVrVqV9evXX+lsKKWUUkoppZRSSl01LMs6UpB02j1NKaWUUkoppZRSSuWiQSOllFJKKaWUUkoplYsGjZRSSimllFJKKaVULho0UkoppZRSSimllFK5aNBIKaWUUkoppZRSSuWiQSOllFJKKaWUUkoplYsGjZRSSimllFJKqX8DV6p5KXWZOK50BpRSSimllFJKqatV1apw5Ehhzc2nsGakipgqVeDw4Sudi9wKpaWRZVl3WJa1x7Ks/ZZlvZnH5w9alrU147XKsqxGhbFcpZRSSimllFKqKDtyBEQK4bWiJzLBy7xWPpg1nTCLtxa/XTjL0NcVexVeYLFwXXRLI8uy7MA3wK1AOLDOsqzfRGRnjmSHgPYiEm1ZVkdgFHDdxS5bKaWUUkoppZS66rlS4fgsEKf5P3yGx8fH445fgUyp/4LCaGnUEtgvIgdFJA2YBHTJmUBEVolIdMa/q4GKhbBcpZRSSimllFLq6ndyAVj27P9zvgecbudlzpD6ryiMoFEF4FiO/8MzpuWnDzCvEJarlFJKKaWUUkpd/U7MAWd89v8Z711uFwCpOji2ukQKYyBsK49pkmdCy+qACRpdn+/MLOtJ4EmAypUrF0L2lFJKKaWUUkqpf7Gza/OcHJcaB0BCWsLlzI36DymMlkbhQKUc/1cETpybyLKshsD3QBcRicxvZiIySkSai0jzUqVKFUL2lFJKKaWUUkqpfykRiN9n3tu8zStDTEoMoEEjdekURtBoHVDLsqxqlmV5Az2B33ImsCyrMjAd6C0iewthmUoppZRSSiml1NUv9awZANsRCF0Owd2HzHsgNjXW/E2JvZI5VFexi+6eJiJOy7KeBxYAdmCMiOywLOvpjM9HAO8DocBwy7IAnCLS/GKXrZRSSimllFJKXdUSDoDdB6o8AF5BZlrVXkB2S6O4tLgrlTt1lSuMMY0QkbnA3HOmjcjx/gngicJYllJKKaWUUkop9Z+RcNB0Uav5P3D4m2k1/gdktzDS7mnqUimM7mlKKaWUUkoppZS6FOIPgCsNgq/NnhbSCNAxjdSlp0EjpZRSSimllFKqqEo+AcVrgis5e5orBcge0yjNlVagWVkDLB759ZFCz6K6emnQSCmllFJKKaWUKqpSzkDxuqaLWiZxA9ktjS7E0dijhZUz9R+gQSOllFJKKaWUUqqoSouEgBrgKJY9ze4LQERixIXPzl2wVklKgQaNlFJKKaWUUkqpoistCoKuAZtX9jS7DwARSdlBI3dG66P8pLvSAUhOT/7bdErlpEEjpZRSSimllFKqqEqLA7+yeX50PP541vvzDYYdlRwFQHRKdOHlTV31NGiklFJKKaWUUkoVVc548C6R50cn409mvT/f+EZnk84CEJsSW3h5U1c9DRoppZRSSimllFJFlTMRvILy/CjnmEbnCwZlBo3i0+ILL2/qqqdBI6WUUkoppZRSqihyO8Gdlm/QKC4tDptlLutjUwsWNHK6nYWbR3VV06CRUkoppZRSSilVFLmSwOYAh3++SQK8A4Dzd0+LTI4s1Kyp/wYNGimllFJKKaWUUkWRuAELHH75JgnyMa2Qztc9LWdXNqUKSoNGSimllFJKKaVUUSQuwALLnuujFGcKkB00Ol9Lo5MJ2YNmJ6UnFV4e1VVNg0ZKKaWUUkoppVRRJC6w8r5szwwSBfiY7mnnG9MoPC48631kknZVUwWjQSOllFJKKaWUUqooErdpZSTuXB9ldkcL9gkGsge6zs/hmMNZ78+XVqlMjiudAaWUUkoppZRSSuXFAjLGNco0vSyknCYmxUwL9jVBo/ONWXQ09mjWew0aqYLSlkZKKaWUUkoppVRRZNnB7QYrR9Ao5TQAsS4BwNfLF4AzSWf+dlbRKdHYMrq6adBIFZQGjZRSSimllFJKqaLIsgGSZ/e05cnm789bfwZg7fG1551dqF8oAJHJOqaRKhgNGimllFJKKaWUUkWRZQcE3Gm5PjrqNH+dbvMmKS3/J6Klu9IBKF2sNHD+rmxKZdKgkVJKKaWUUkopVRTZvM0T1Jy5A0JRLs//neLMdzaZLYtC/EIAOB5/vPDyqK5qGjRSSimllFJKKaWKIrsZrwhnfK6Pzg0aucUNZcua8Y/OeZ1t2QCAksVKAnAy4eQlzba6emjQSCmllFJKKaWUKoosC+zFIC0210dRuYc5gtOn85zNAbdpabQzYqfHX6XOR4NGSimllFJKKaVUUeUIgLTo7P99ywAQm1fQKB8rKpu/e6P2AhAeG15YuVNXOQ0aKaWUUkoppZRSRZVXcUg9m/3/vacASLqAoNHJQM///278I6Vy0qCRUkoppZRSSilVVHmHQMJ+cHtGifws87d6cHW87d4ApJcKzXMWp0O8LmkW1dVLg0ZKKaWUUkoppS6d+AMQvRXcrvOnVbn5lIC4veDyfIKab8bV/IrHV9C0bFMAtmyeDyLmlUmEU01r55rt2aSzuaYpdS4NGqmL9sK8F7AGWEjOgkkppZS6Shw7Bn37whNPwJo1Vzo36oK4XZByBlxpVzonSv03pcfByh4w91pY1AbmNQK3dou6YD6lTEujc7qUJWQ0PArwDiDQx/Q/i03JPWA2QFRyVK5p+yL3FW4+1VVJg0bqoq0/sR6AwzGHr2xGlFJKqUI2fz7UqwfDhsHo0dChAyQkXOlcZXClwrYPYHY9WNQOIv680jkqWk79ATOrwIwqMC0U9o7wvPOulLr0VvaE8N+g/F1Q9UFIPAo2x5XO1b+PbxmI2Q52P4/JiRlFmr+Xf1bQKCYlJs9Z+Nh9AKgaXBU/h5lPmvu/EVA/cABWrIDo6POnVblp0EhdtPXHTdBo5dGVVzgnqsDKljWP7zz3Vbbslc7ZhclrPf5t66CUKrKio6FHD7juOti3DyIj4fHHISDgSucMcKXA/Gaw6zPwDoakcPjjNnAmnf+7/wURq2BZZ/AJhWv6Qel2sOlVc55Q6lKIPwARf+X5WPT/rDMr4cxyaD8TWv0ATb+ATruvdK6KlIgI04q1WDEIDITXXoP4+DwSBlQFV7JpuZXBLZAiYLfs2G12gnyCAIhNzXsfzBzzaHHvxdxU7SYA0pxXd9AoPh66d4drr4XOnaFSJUhMvNK5+vfRMK+6KGmutKyR9+ftn0fvRr2vcI5UgZw+fWHTi6q88vtvWwelVJE1ejRUrgy//Qb+/mbaJ59c2Txl2RYGzkS4Yx34lQfLDrv/DxzFrnTOiobVj0LFznDdGLD7gDMZDv54pXOlrkbJp2DVQ3B2Fdi8Tdere0+BV1GILl9hRyZChU5Qsk329rD08jNTQgK0aGHev/46pKTA2LHwxhsmgOTBv7rZv45MhlpPA0J8Rtc0X4cvAMG+wUD+3dOiU0wzmyDfIEL9zGDZV/uYRr16wfbtMHIkNGkCP/2UfT5XBactjdRF2XhyY9b7yTsmX8GcqAtSpsyFTS+q8srvv20dVKEKD4cXXjB3kqpUgbfegrNFuT6kreWKtOnT4dlnwccne1qRaGUkAvtHQYvhEFANvAJNsKjuy1c6Z0VDwkEzjlHLUWa7WHZzwVrjsSudM3W1caXB7zeBOx1u+wu6HIYWwzRglOnkfKjW23N72H3yT38VSXeln7cVz8CBUKIEbN0Kb78N/fvDtm1QsmQeiQNrgLjgwPdmf3OnE5tP0CgzOHSuuFTTSqm4T3FCi11E0MiZBMdnw9GpkHT8wr9/maxdC6tXw7JlptVwgwYQFnalc/XvpKFedVFWHFkBQINSDdgesZ2o5ChK+JW4wrm6QGXL5t06pUwZOHXq8ufncshcr8xm+v/WMR6ulvVQhWLfPtONqFMnmDgR0tJg6NBcT6e99EQgch2cXACSDiXbQtmb8x7DQVvLnV/SCXMH37JBqevBt/RlW/SWLTB+PDgud20p+TTE7QKv4hDS2Kx7TrE7wOYDZW4yd54znTPWxX/WqT/McXfuOUFbOBRJA5YOoHOdzjQt1/RKZ+XChc8w+9WNc7IDI1V6Xtk8FSVJJ6DEv/B3LQTeg0zZLP3zrpuKmFZFEyeamxG2jGI+3/ONfxXTLTlmC6x6EICYjPpNMS/TwjTA2+yDEYkRub6e5koj1ZWKw+bA2+6d1dIoIil32r+191vY8jaEtgKHH2zoC3dtN92ki5ipU02XtBIlwDvjVKmtjP4ZPXv+V6TFmhPb6T9MlLr0jVCpq+nrfxGGrRsGwJHYIwCM3TKWl1vpnU51kWJ3m301PRYCa0LZ28A76ErnSv2dIhB8feopePppc7cuszXIdddd5gpCegIs62TeV74fbF5w6CdTafYtlTt9mTK5t5u2ljOciabLR8IhKHsr4IYt78Jtqy5b5TQtDYIuZ9GTfBpW9YK0OAhtbs7dp5dBlwOmcp4p8SgUr2vGt8h51/7c4NJ/VWoEFKtgWhjl9B9p4fCPXYFy/GjsUcKWhTF8/XBO9ytaAfPYlFjGbh7L89c9j5XfWFiHfjItaTyCt76XJ4P/Cm7PYO30spByGrDBA64rlqtLLTo5u6XPjjM7qF+6fq40p05BUhK0bZsdMALw8spnpjYv0xU56SiE/wpArBsswM/LnB/8vUyFJ69AUGRSJJAdYAryNSe3E/EnCr5i4bPMOHq3rwG/siBuc97xKl7weVxGK1fCyy/n0dVPXTANGv0XRG2EZXfDNa9Bg/dNq4yTv5umjeGz4PgsSI00F+VlboYq3U3BdB5ut5ujsUcBiE8zI7aN3zqel+/55IpfPF6Qc1urgLZYuVKcyfBnT/M40VrPglcwxG6Hf/BkB8n4DbMqenlVhovQPtljag+m7JxCwlsJ+HvrbZALFR1tmiDPmOHZfeiy31Ha9Br4V4MW32SPLVPlgfy7KlwNreUu1YXm6sfBpyS0GY+pFgMNP8h7zJ5LlAdfXzP4dYlL0IA2MhJGjYKNG01wqlxZN/938w34Nfgf1H7GVMYRE4h0nNOCyOYw5/CcQaL/yMVYftJcaaQ50wjwCTCtsFxJGduQHNsG/qvbp6gavHIwAGcSzxCRGEEp/zyC61dIv4X9+H7T91QIqsC99e7NO1HCYajXEuzeeX/+X+dVHBKPZN80yToOL3cT4Etj2zZ45x0zNpGfnynXW7SAsl3GZqX5eu3XjOg0Itd3U1L+QR0lpJEJGmWIzSjKMlsYBXgHYGERlRyV66tnk85iYWUFljIHzT4Zf7Lgy9/6PjQaZLpFF+Ba8UpzOv9+G286tYlUZyqtKra6fJn6lyqUW1KWZd1hWdYey7L2W5b1Zh6fW5ZlfZXx+VbLsv6b7RQLSESyLngLYWaw8n5o/RPU+J/pDxtQHSp1g6V3QcxWaPIZtPsFmg8zrY8KWAhsj9ie9d6ecTfvYMzBwsk3mABCwmGI22fGJvg3XkypC7N9kHmk6PVToMJdULotVH807xYaf8MtbmwDbdgG2kh1pl6avBaiM4lnmLJzCgD9l/a/tAu7VE/OO3Uq9zEq8rcX7AejD7Ivct/FLTdDTIy5k+R3sb1zREyg/cAY2PM1HBgNZ9cWvPw59KOpUOUMbFyJsS3CwnL/xv+mjvxpMRA+E5p/Zbalwy/jdXkHeW7WDGbPNkGdwvTnn+bucqtWMGmSGTvp45eX4BsYaAJGDn8zTpFX8by74wU1gOhNuVvSAOBm08lN2AfY2X32v/OUojrD6hD4SSC7InaZln1n1+VzIX91XKxeEpnleM7y7jzl+MWISY5h+Prh+NhMC7CBywZekuX8E5FJkXy/6XsAuk3phtPtzDuhV3FzEe/OEaCcYMGEvI7N/6BS7eDYNFOnB1PHu0r89ZcZJ+fzz2HmTNOV+Y8/YPBgN4PWZF8Oj9ww0qPlUaZSpSAqCuLicn2Uv9IdPFqyZXZPC8ioZ/h7+2NZVp5jGp1NOotlWQR6m2Y3Qb5BWFicTryAFn7xe6FMhysfMCrgeJD16sHSpZCcnHsWsSmxNB3ZlNajW3M64dK3cjwedxxrgFWkyrkLcdFBI8uy7MA3QEfgGqCXZVnXnJOsI1Ar4/Uk8O3FLvdyWnJoCf4f+rM6fPUlX1ZSehJeH3hhG2jjSMyRi5+hK8UEXkq2ya5sTy8L00OheG0zaKZ3kDnYHMUuqEK+/sR6AHo37E3KuykARCVHkRJ+OHeFI79KR14HfXkLvqgEe4ZCyilwJZpH56ZfwCNMr5ZHyv/XHJ8JlbuZC6ZM/6A7wRuL3sh63/vXjCf6nRvUuIQV4Qt11/i7APCx+zDkryGsPLryCufo0tt9djc1vqpB7WG12Xp660XPr3x508z78GHP6Rc0nlHiMZjfEuL2mq5ltZ+Fyj0gpGGej+kWgSNHTIVkwQJYsiSP5f3DC4gziWfwGeRDq+9b4ZZ/cJEbFpZ7f79UQaN/EDA8L3d6Rrl9TreG/LblJbrYve8++PZbSE3N/m3/7lG9iYmmxdvcuSbY9PvveWfh8cfNfNu1A7vdvEIC4rC8ime3jgGzzpO8cq9zsfLgVw72DjPd+MA8rQmIckLTUU1x46beN/WIS7mQKxLD6YT9+2HzZjOu09GjRfu+zXcbvuNwzGEAmoxsQlJQY0g+BsfngDPFbJue6Zc/Y5eqLnKV1HEemfEIAKluc3Nn2LphxKTEXMksZek0wXQzzrwYf3bOs3knrNIDDv0M7nOvSs1xfCrhFKcSikZd44qodC8cGgvOBFOu33v1bIuwMOjbF2rUMDetgoOhWDGYsmcsKc4Uj7TvL3k/1/cDAsyNiW+/9TyvJCT8zUIr3+dRGMeKA7Ao7mO6h2W2NMoc8DqnyGTTPS3QxwSNivsUx2bZsqYXiG9ZiNnu2YqzCAdJu3eHWbPAlaNxaXrGqaDLpC5Z0zr81AF3xkn+ZPxJOo7vmFU3PXIEBg82D1YZNMi8Xn8dvvnGtCwriDRnGg2+bQCYm8ObT22++JW7zAqjpVFLYL+IHBSRNGAS0OWcNF2AsWKsBoItyypXCMu+5J6e/TQ3jb2JJGcSrUe35pX5rwCwOnw15YeUp/zn5Vl1bFWhLOtMwhmCPwnGJWbPrjq0KksOLbmwmZxbkfAqBsdtcGKOKbBzyvl/5kE/ueB3xBceWAhAi/ItcNgcVAuuBsCGExsuLM/n6gs88BPU6wclW5lBQCvdUyQHWLvk/qa1wKmEU2w4seGfXVAWVeVuz6jkZ5w9t4Zd8H45dcdUPv/r8+z/d07l0z8/LeSMFp4/j/7J+pMmAJvqMhXn3tN7X7oF5hU8u5CL69NLYP0L5tHVp5dBxJ9wYi7s/Aw2vlqgWaw/vp5639TL+r/RiEZZg+r/Uz4+8MQT8L//QXy8ecXFmRZIBbbnKyjVxlTKvAKzn7iUx/gUa9aYliIxMdC6Ndx+O1x/PcSXfBTZ8q55soiHgh+nSw8vpcznZUhzpbHm+BrKfl6WpPRz51e0HTkCQ4aYStVPP8GECfDDDzBsmJkWH3+eGfiWghLNYffQ3Oeuy9hS5NFHzZ3gG26Adetg717onc/h+eyz8MEHUKcO3HEHdOxo9pGQkNxpixeH2Njsyitgxm2K2QJxu7PLwCx5rHOjD2H7x+Ypas5kSDyCW6DSYc9klb+sXODWyykpJu8//mgufmrXhpo1TRDpby9krqCjMUd5cvaTWf+nulK5+eeOUO81WPcMHJ0I6XGmrFLZrnBrRJfblVXHbVe5HWX8TQuUX3b+ctnykJ8jMUdYfdzcKE5INzv+6I2j8y6Hqz4Ikathx2BzHHY2rWedbnh85uOUG1KOckPK0ee3Pvm3VvoXOpt4lvsn30/tr2szf//8/BNW6WG60c5vaobDOHNx5/pClV/w1W4vUEC2dm3zAI4Uz/gQs/fNBuC+evfxdLOnAVhyOO/ruf79TUulKVNMi9bUVHOO3L3b3JBatAgWLoTFi80TwPYer4QE1sr6frQjFEGygkb+Xv7YLBvxqblPsmeTziIihPiak1KQTxA2y0ZsygXclL/mddj8lilTPeo5l/laJJ8bwU63k9l7ZjNn7xxcbhe33Wa2a5cu5isul2khNnztcJYdWZb19V1nd/HukncZsW4E5b8oz/z982k0ohF9Zwykbl147jkTNOrb17wGDIAnn4TQAg4N3GxUM4+AeJORTfL8jYqywhjTqAJwLMf/4cB1BUhTAbiATpTGka9rUvmBSWYAyAxbFyxk+5ZESjXvictp9hu7HV5bF8Rey4mfVzHcCC63k0E1W3J9RC32BH0FbhtuMSMl3DSuBuV/D/dY1ov3lmdkQ8/Bwf5vzf/xzZovSSN7R207pi2tfGHVNXU5XHc9ixbbiY62qFZVuCf0HmyV72VFeG82bLTh5QW3t9xGnYiuJN64ixkzHZw4aVG7lpuuO3I32Xxswk0crB2C866jzJxp59BhG3Vqu+lc4SVs/hU44NWPWXMcWBa0v+4UDZNP54oEfjr8Tf5X+nWCG66FCndDu2mkze3AwlnQyetZqP8mVmbgwZUIG17ieOhH/DrTQVoa3HGbk+rvheI7y7Obz+K3vbG8oUFoTSQ9gUal63Mo5hBVZnVHHpiXOQIFkp4AB3/kzO4N/BH/LVFRFm43+PoKHd4MosaDv2KVbmPSpsWzacq3XLv7OxzB14JXINa2gTi3fcq8LXdhtfga8S2XddO/jGsuTfy+YF+FuSxZaic+3qJWTTdVX6lN454jsFXpmpVfOT4PNr9JYkwC06Y5OBNh0bSJm8DNXWl+f2+P7SZnViB/PcbaklvZuNFGQoJFSIgw+nQ11uB5cd3GuyZvJXcgvfEwbBkZEwHvLU9z+/3XYKvzVFba9ds2MHtlR3rev4K6JeuQmJbIiE2juT9lDYE+LZh3qB+nT5t5hAbG0K3y5/inRmP5hGRtn7s+a8u8AQM88mABrjreRF9/kAVLQjl6zKJUKeFA1GMUr3yEF+/5DV+HL+tPbmTKrum8cXg8ob3+9PyN9n8HUetIbTSKiZMcxMZadOvqpNKmanDjXHafqMe8BQ5q1nDTucFYJHwOO4InsXS5naQkqF03hZV7anP7rW9yS8P/ATBu20S2LV1BSPAanrn/d4J9gzkae4wft44nZvWP3Hbz09zR1AycPm33TFYua8xDaWNolvwY1H4Oq2IX2D6ADfvr0OTwVKwKHbPWeeuSNdROfA3fTsuz1iM1JYruv3QH4KUWzxLoHcigPwfz8/TveD78O/zu3eSxzg8/DK1bC4/dsRBb8lGw7Px1RLhvc19cXsUp7lOcpPQk3OKmV2oNmjetxiO3jwHgr/A1zN6ykW96P8/JHZuwx24yF3oOf/6cu50bbi2J/drsFk9JSVCmnDeHDjsISFiMLW4Lbv9aPDLJVCg+u+lDutbpTLMx13M49jD+/ins2OFNaft67JErcAfU4cupd7F3jzD8/cXYEvaApCO+FYj+vS9lH1hknqyRYdT3DpYtsxj1nQPHialYqRE4y3fn1Ph2VH9wnMd2mDDRwZSpMH68hSN8ElZ6JMklb+WDnzpyyy3Pc0eT5wGYsGMKjTYOp8ENT5tug5A1VsiWIw259qFB2PgixzE3l7MrPmMpc4mKsuF2g1jpPHe2BQBl/ctgWRYnE07xzNeP0L1mEk/0WEm5gLJEJ0czavMPTPlfNwYOqU+nTtn7++IV81i55QEe7rGCasFViU2JZdTmH+h78wqe2vAtdetW49ZbTUVh61/HWDOgGcV6HfI4Ztj0GkejavLH8eeIj8s45rx6c3vQQ4RWWgml2mBtGwg7PsTp9mWtcwj75XHAhgAb1rtwOPxo1AiSkoSYGAu7XRi1/jO6BHeiVsKdJvh07UCsdU8hAlv+PMJfm8oQH2/h5wdl44fT5cateLX6Ouv3OBG9nw4/dfDIakRSBP2+DeWbRreT3ORnJk12EBNjcVdHJ3X218N13c8s3tiCLVttBAcL1b2m0a7SBLxvmuzxO3cdXIVWTe+hV8t+ON1Oftz6M6c2HqBKiY0812M5wb7BnEmMYPSWn5jxxlO89WogdzRdgS1uG9h92bq3FI2nvoLXFM8ycM17N9Likcc8ytBPB5wkuFw5PvzQc7P3e2ovndrtxOeMi/QIAAtJPgHbP2Jz5f1s2GAjPt4iKEjY/NcPfHjLnYREbYAKHaHxJ+yb9yrdY2O4ce5ztKvUlqNxx/ht7xxeOFGNu++shr1Bv6x1Pnx0B1/+0oSHus2nWfmWJKcnM2zDSNZPuJvKvnUY8MYhHGcWgNuJq+SNOJ5rjfdvnq1RAu6E3z4axF1vvE379iZ44u0N19Y6zbxxqykdEmcKYLHYtKI1L75dnZAQW1aw0t9fuPPTANo16819jf5HQloCY7aO4+EnvHn95YEc7xdKl3tM0HPvXn9G//gro1x3Ya/dByu0KdJwEMPHD2FWUAR9tv5M3dDarDu5gbHbJhI/bCpT33yYapvfMQFbmy8PHyhFkkRQIbA8Tzfpw9frR3AmKYIXBtXglvbd6NLadH+dvW8ei1Yksezrnvy52hvb2eXY47ZwxtGJpUurM2OG4OtrkZBgrpd2H5nBuHmP06fXaioElichLYFvNozi+LJfaduyMT1u+hqAP4/9xW9rdzD2xWfYf9AbW9Rq7NGrcZW8EdvhMdiKlcd+zQtMmuTAZoPqjf5i7h+38/ADG6geUg2n28mIjaO5LWEptUPrEpueJ4wAACAASURBVF+1PxMmOnA6Lbp1TadWXW8OHvLC370bR8RCXCFt6PyTKfO717uXW6vdxNPzXmL18dUEt1vI8YkbKbbuBTM+lt2fofNfZrvjE768G+yn52AlH8dZ+VGsWTXw6ziHjXtrsnSZnSqV3ZRO/JHWNZbjdf13njvx7LrQdgoHoxoxa46DalXdlEz5healJuPdYZJH0l2vlaNur3HYKtxmjsO0eE5vXcLaBZtwTU/zqDO0Tb4Bn8ZvMmvD7Zw6ZeHjA4nu70kr9glP9lhOaf9SRCRGMHrLWG546Vpa9xiCrcZDWcvauWwl1c78D990z+jeO89s5O7bTtOsuRfYLBA4tCeKCrV/pFhaPFZGVxVJi2fF/71A2+1DsNV5KrtM2rOP4mta4d/Ls/X7sq/e5vqbS2Kv/0r2xPRYZGZ1NlY7y9p1XiQkWPj7Q5fq/alQLpX9foOYO9+BywVWnV+JT4+nVkg1lj00lzn759N5yv1Ern+duJjNzD/9GceP23C5ICREGPflOj4Y0YbQktklTcjZ4UQfO8yG9A9ISbUQsbBZbu6fUZag+edcCLcD6d+JI1UmMXeencREUwestLMFtR74Fko0yUr65BjzZKp+173EpzcP4s5J9zL/4CKip1fD67ofWLa7A5s22wgIEAL8A1k77xe+uq+b6Z7sXQIR8DoA8EPWPMdsGsPuXWNYWb8+sa1WM2OmgzNnLBrUd9PR/26sKj3Zk9KTOfMc+PkJLWttoeF3HfGa5tnNaOWbHWn98J3Yaj6aNU3iD7Hv5yfYXGoZ6ek2JOPapknUjdTv1te0nM2UcgZmVmVT9bOsXmPK28BA4d4ab1GmrDdHAt9n5iwHbjd0viOOGtsqsqvuSZavKkZsrEk7Iao5K2VH1iw7jjd1M1cdH+TOXSxYWpbtO2xUKC+EH7dIPTONd6/vhPXng6a1EVDh+ZMsaphOdd/52OJ3IT4l+XN5AtfXXY1321Ee61zmo+JE4Bn4bhczjJD9fZgwJgL7qdlYrgTcQU3pNb47t7Z6iF4t+5HudvLd5h+pkrCNB73OssJrPtu3mzprqVLCg4lRnNvJatM1jWh8YgdWTHYQRIDlt11D1A9bsAVfk3UNcud1G/hgkDevJzbhmWfMQxN2H4xnxq7pAAy99WNK+oXyw+YfSDtoWqJJ0glTqIqAZXGb3/P0e7gvzz3XlldeMZO9JJpNm0owybM44aWXTJe2V7uH4bvR3L044mgKzCPI2w9JT8DfZsMtbvqeaYBz/ZvYG72bdSyfij6KIIRkpC1udyDipkNkeb6a0p5nuszEYXOw7cwOpuyaDlu/pnOnsbSsdgducTNq0w+s/bUlj4Q0on1qY6jQ2QRN93xN1RcPMvMaqFk5Eq9j43CVaMNPs1uyYAH8/DPYIv/EFr+D6LL3M+T7utx9R3/a1X8YgEk7fmH9osXYg1fT7/5FlPIvxd7IfXy7cTQfp85jV7GxrDvQjLQ0C5sN/OMW0LPJEHxum+NRxwn9KIRoPAOz3UqUZO4brekQNoOaNS1cLrD5JGP1fRGATzt8QIB3AM8u6MuURWM54Hfc4/tfrv+ICsUfZ+2a8lzfziIlxQKEE3v2UX7XzTi67/JIv/zLl7m+Yx1sdZ7Jmvbzqolsj9iOt92bAe3eYebeOaw+sZbxA3rwxP0tsTfol5U2ISYBKIukRnkMrv/sg9spc02rXHH9hDEB+PfYCd7ZAy8u+24YbRsfwdHiM4+0cngqa2fMptVr0/gnCiNolNfjBM69pVWQNCahZT2J6cJG5cqVc31eZtExrBdbeEz7uNRErn2pNw/e7pm2x6pkUh2Qmpp94hj5zkvYX7yHFx4Ct1twu8HhsNgV6U35CcugYXczmGaoP40bFuehuGjCfkimRjTsCYWB7SG1jDdV9qfy1AawBL5rBr5V7Tw+8j32hdp56RUHNevY2Ls9nd9HhfP0yju593/Q/lYHqSnCqG+d3HS0FQ/cB3fc6aZkBR/+mJfCizVLUGl3FK+sBpvA5PqwsSFsW1qdW7snUaJiMWo28GLk0HSqNPuO7+YO4ye7jTbXW4gIQwZYHP0WeEBMRNyZAF8lkvTaBkL6HIK6n0Htz8ACucmHDUOa0XnKAGgwFooBybBS4Pd5wQy2bLRuA95+FgPesYj9MRWmxUKl2lnzfWpXdYrFxNKm7p1YLhhYGmo3hNK9I7B8QrOeAGTt+pwPB6VzwG8Ugz+zExRsDlrLgoSfzmJ5h3ik3br8MIfWlqdb8dJQrRT4eBNVrwTdvpqZa1yJxD3Q+aYwfBraefoFB0HBNrZtTKem7RQ278DsJxOF+mMt7cjv399L1yVuqtVwUq6aL19+nMbkN05g8/L3SBv5a1fueG8JXZ6y0/txLwICLU6dcPPrd/H4B0JQqvmNovwgatF9TK/9MWPO6aI6ZeNO7N5NTUuFjN9j1ZsOBiYm88sHzfl9HAxrAR+2hxOTXmZ/ldcYPMRBjVqmQrRtnYOAI4mmhVWZMuBMwJoaSK29IRz2h5sOQalEWFINjoTAyMGP8WnfEPq9YdGkmRenwp2MiJ9P1N4Ypr5Uilbh8E1GOPezWpgn5+WYL0D4rFu5ZVI4x6iIEwfv9XMT2TWCFfe9Thd+Ix3wwsXQ9qsZv+dtgpvYePRJB/4BFnP+3Mn/cYZvfn2FuJavcDgYHnkRKqeW4Gh8FK5OlXhvOfS7H36pb0qAH359j5hW75Fqh15vg3NfJxqsuIHmIwZC/almv7wN8Eoyv2elmlm/kbxSE79G6Wb7ZqyHz/RQXjzqT70tiTwdNhyAeg1ge3UHxdoleqS1pgbS4cBNPH7bBkh9FyreBOLC+Ud3It0CqbHE5Cg7vpH12Netp8v9UwlJgaeegejipTg8eDjFUsOg7sOme+f08uyJqsNNXrd4/PZ8KrwtL1Jq+CdQGXPlmZbGs7uqkxIOL37wDt6ud5hdGWbVBr+kT6j66gDoBNgBJwQuf5av756GX+RjUL072L1gYVtKF08wx1ylmiazC58m5a9ouu0IJuDVgdAKsIHPshcpUSwo1zGXsvIYfc4EEDDmKygOOOBoCnyRDsNmvUVcm7c4GQgPvQz+27sybfxybq8xBKpUhcrRYAeHd2KuY27I67+zPm0hw0fYKeZvZVxwe7P1eX8ab0zk6Q2mD/kPjeGbtrH0Px1F5AO1GDofvmsLb90K9yVX4MTuihxvaLosisCsvYv5KjKGP16/lhmT4YMb4MvW0Gk9zFtRg3U0Z+5PHXHg4pmSS/H3SfL4LWRoIne/8SONH3qAV99wUCyjN2T4sWv5tk4X3rumA9RwQHAAtIPSzxxm7pKSPNzGTkKCIAKPPAxHO1Vmot/NJNRrAYGBWMlJrNhchWubtqf2mYHQcBk4ILptMB0H/8ET/cvx4MNeFC9ukZIizP4kGW8vm8d+WXJuLXpFwX0L4d7dkG6DwW2hef0Utv8h3DYznjgCSceLd163+OsWXzp3rUazW93Ub+bN8aNONuxN5ZZ33R7zZUogM10wc90Y3lo3Jvucmlac00lxBN9SiefXwjc3wgftYUzqRrrG/wExr0C5duBMwrF3EF6PlILJJz3OMamHonKVoZ/fUJ0VY+9kfKOWWFWrIN4+2FLi+LzXo+YclWl6WaLOpnHHe0vo+pydhzPK2+go4WTYG5QYvw/q7YO6k8ANZ1qHsiXdzZZ1wxm6bnjWbHolCw6v2h7rvG92c4bGpzP0x5t5aj2srgBbysHAeUt57+7fYWU1qNwF7A5Y/zj0SIfpyVChata6AbRZMoNDMZ8xhsdJwJ8+NcZQ4dMy0GqjWbgrBSwHK98JZc3PXfju5UpYNaojdgfpZ0+yuGcSi9eMpP+akVn5DQN2tV/K7Bdq8fML9UjCj7KcprK3L47FEdD4E6gEVjLsa1KFBbGRLPjVs4lT/10Dqd59OFQFmgIJyXRwV8G/QSLv/N8JKsd+wIPB8PZN8M21h/h+0eck3fg5lkCPdyD5+PV8feoQAW0HwMuABZVTX2JNh0AW+N9MRN12WKVLYbldjKs6nKXVo4l6sA5D58PUJvBWF7C74dtVm+l5x48APPs0bPOqzkexMQRcPwBeMmUPbtgyDRrNgScoxUTMI8lr3f0+W5qkE/loQ4bNg51loO9TsGo97Jm7j1t4kShCESwGvJxEPz6ndIMB8LEppxDos6MWcSeg36Dp+DqnU6cyzK4NfnFD8L9rNlwL1AbOJJK00o8uTT4moPsAyLyOnvgUzp3w6kO/M5KaOLHwxkXf2yJo/754luNfJZI0FXbc+xK3sJgUHHjh4v0bttJ2QO60fl4VsfkEe5S3/V6sSbP73qfvOeMqj2hehaFnbua9D+x0vMtOago8OXk26/3DOdurOkPnw8e3m7Juhde1uY45919P4lcvNVceProJ6J7jmNsahm3nOPyrJOU6J56Ka4Xdu7nHdFnUnoClsfCI5+OHirethKPfMSB7HL4ovxA6Fl9L7zd86NXbi8DiptvNjl6f8+aCH1ld3satHW3YHPD72Ka8fgPcPfoQ1kuB3G6Dj9pAuvdd3JM+hCFf2Lmnmx3LgkMHhSeeake7Gzy3Wbdbb6HNrTV44WU7aanmwsLHB9K8nDD1INRsbRIufBrX1g949tmHWJpip+dDNvwD7YwclsrQOyOwfII9zp8d46JoHhNM325DsZKG8nUJ+K4pHF1egut6NuTGe4XmbR2cPeNi0AgY4P0n1ux4uD4eih/D2gu9rvfluo0pvLDWzHZYS0hpABNmXM8z6210vlsoUcaLxXNSqBuymKGzOzEKG2XKQ3qymypBTlb9XwD8EuXxe0btOYvdu5jH7/zJzc+z03sN48aZZaWlCd7eFkt6x1C/3nKwVzEHy+HviN89mTveWsKt/3PQ5ykHwSEWsTHCkae+ZMi8wQyzbFzXGmx2GPSuRfOg36jbLYAX+joIDbWIixWOhMVTNhFeWgNlEmFmHXPNEr66NDf2EqwyLhq29OLInhR27rXzS7O52EZFQHvAF/gL+ge9R/2V30PNLhDaAKIP4Ajfj0/Dsrn2YdJNT2UvF7gt80pdvoHBbcbh/8dRqNYLfIJw7fmMma4oZv75Fc//+VX2fpJcns9HL+X+Z+z0fMgLP3+Lg/vc7A2rTP2HvodGPbOOI1cvO1azhtBxQ1Yekj9zc+PjfyDZY1sbES46zrmVlcPrMX94K+IIJJSzvP5oMNW2RlM+zLQImlgXtlW36A9YxcpnHYdsH8DOifDe7On0oBaTk7vjhZN7Skxnx8nW/HJ7W6yyZREvB6SlE7LwB949PRPeA8y9dh49voISd8HDfUZjRYymng0+aAP+rV04vL08juXuRwaTfAZ6jJiF1SuQqhZ81BoG3byX6TvTafFqCK3D4aVHYGlVwIKJ39zPga9gdSV4tg/4//UG98RVwjp9xIyF6w3shsciR9C41YcwBPA3u5t88AwPBJcmoPEAeMfMb+2Gp/giFGaPfo7dw54j3QYPvQvV0kpxICmCz7+sTrF0SPQGkkJYMmY5A0fW4dE+DkTMU+aWT3Di6+XMVX61iPLCGQ1dd4NY8GtduCbiLPWi13DktB/j6M1RKnF9ygqWHwqg8rZYngx7DzDDBK6u5c3Jag7eG++k4Wk4EgRhN6byRovKRN7SmlHF2+OuUAlLXJB0gBeGJOXaV0vMqoj99dHA61m7SZ3KoTxxDzw1NY3m7/XnGR/4qB20SN6O4+N5QI6GAL7+QAKWr2cTJnftt0gqUY8zp7J7XlgWlJqTCH2qeKTl3vZ4bUqEtp5ltvVAOVqNv4An5Z0rc9Dlf/oCWgMLcvz/FvDWOWlGAr1y/L8HKHe+eTdr1kwKyu0WiYsTOXtWJCJCJCrKTDvXuHEijzwisnixyIEDIkeOiGzbVuDF5OvLL0W6dhVJTMyelpgoUrmyyPz5IvHx2dN37BAJChJZvtzkOTHR8/OcEhNFQkNFBg4USUoSiYkxf7/6SqROHZP/2FjzOnjw4tfjl19EKlUS2bnT5C0mRuTMmYufb+XKIn/9JZKenj3N5bqwebhcJi8HDojs3Suyb5/IY4+JvPiiSEJCdrrU1Ly/Hx4uEhAgMnp09rbM+b2cHnpI5JNPTLrzcTrNb7p0qcjvv4ssWmT2L+e7/TM7/mS9nBYS0N9bCCP79Za/WJZbUlIubHvktHGjSO3aZr/PXH+nUyT8bLTnssKQeyfdm+c83G6RNm1EvL1FXnpJZPBgkXLlRCIjzXYDkQoVRHx8RBwOkTfe8Nx+SUkijb5tJIQh9YbVk4pfVBTCkJ5TewphiC3MJtWHVs/Kh98gPyEMORF3Qjac2CCEIRWGVPj7Fc25PS9WeqLIlGCRuH0i6cnZ08djXuco+3lZscIsWXd8nYiIFP+4uAwdhrg3vCriSjOJppXJ/f2c+V12r8isa0QiN4q4XWbZW/rnnb/wOSKTionMv05kzzCR5fea+R6bIZKeY8OPR+Recu1rAiJDOpt5ZOZpgj3vZbldIrPqi/xaSeTYTJHo7SITfaXZJw4hDLlm2DVS9f+qCmHIEzOfKOAGNmXisGHmuE9JMX/zO+Y2ndwkhCEhn4TI5O2Ts5a3YP+CXGlT0lPEMdCRa98+Fnss75mXKeOxXeIIEDDHSs7zRF7nDBGRHj1EPvtM5NQp8520NHOeKaihQ0V69jTfy+lCysDkZJHy5UWaNhXZsEHk5EmRvn1FKlYU+fZbcw5JTzfnjNOn85/PiiMrpOZXNaXh8Iay+eRmGbl+pBCGdJ3UVURE2o5uK4EDkdRJxUVidpnjJFM+x8YFidwgcmiieR2eJDIlSJ68aYS8+066JCef/+uZopKiZPTG0bLjzI6/TddlYpdc+0nKur4if9whkh4v4kwRcaaK/FLaHL8FEbdf5PfbRI79KpJwVCTlrMiGV822meSf51f2nN0j3SZ3k5fnvSxRSVEFX9EMLrdL5uydIw9Pf1jWhK8Rd347ax7cbreUGFxCCEN2R+yW/ZH7hTAk6OMgcSeeEJkcmKOMcOQ5j98P/m7Kgm+uERGRXr/0EsIQ+wC72AbYJNVpTjzVv6wujoEOWbJjvGfZk7HfrFsn4ueXfTg6OgwSwpAHfnlARESWH14ujoEOKfdpRalVS8TLS+TZZ0Veftl8T9xukdkNTFn2T/fHxHDPvE3yl3HjzHnuhRfM+fynn0yxkSVHOZ6UJBISYv612czfYsXyTpuXpCSRNWtEFi4UWbBAZN48UzctXdqcw3PWk7Yc22fOnwNscuMPN4ptgE0IQ/ac3ZP3zPv3z30eGNhP5MwqkZOLRU4sEjm5SOTk79nnrUL09tsizz0nueozAweK3HCDqasmJJhyKr9zgY+PyLF8ivJzNW9u6q0ul0h0tHnlV5/++muR9u3N55llcXy85L3NwEzPwek05e348dnLSE/Pf3l52bJFpFQpkc2bs+v/CQkiI0aY+tbSpaasT042+T2vjLwuWyZyzz0ic+eKHD5szg/5XRO88YapN59bv/3hB5Fq1UT27DF5i40VefNNc82U32+Vk9stUquWOV4z69iJiSLff59HYmeyyNQQkaPTRNLiRdxOU6/5pVR2OXy+ut7+0aZ+lBpjynG3S+SX0uKaWkrGbRknVpglfoP8ZOH+hXLrrabun/Ma7ULFxYls3y6yerXIqlXm79q1nsfr+RRG1fVSeGzGY0IY8sWqL8TtdkvARwFCGBL4UaAQhjz525PSZEQTIQwZuHRg/jNa+7zIRN/ssnVaWTN98S1Z07b96CX2AXYJ/iRYRESOxhwV+wC7eA/0ljpf1/E4V7d/P0zq18+9mAvZ5pdUXmXHOeXGP3G59xNgvRQk5lOQRH87A3Ov5yBQDRNv3ALUPyfNXcA8TIujVsDagsz7QoJGF8rlMoVgbGzuk9s/0batOZHktHWrSNWquef/6qsiTz1VsEL4p5/MiTZnWrfbXDwsXux54BTGQdS4sVlmzsDLhQZ38rJrl7loev99U0FavNicJC9W7doif/xRsLT9+5uLv4Kc4B97zFRyLuYEk58JWycIYUjxj4oLYchdP3eS9u1FRo40FYXMis+FXEANGCDyxBN571NHYo5kFcAPTHsg33ksX24qzUuXmvmkpZkKbFiYmT55stmXT5wwFeW8gq1DVg3JdYG29dRWCf442GNa428bS4cfOghhyJuL3pSnfntKCEMem/FY3pkrYKXugsTtF5kaKuLKWUPvn++F3x3j7hDCkEnbJklcSpwQhlz/qUPccxqLxB/MqPCUzj+IE4zIz94iCYc9D6r8Lnp+qyOytFN2gCg9waRNOFqg/IrbLTK9osgkX5HDk83F+gRH3hfG4bPM9KST2dtjPPLVN+T6PdeGr/3bzZpTfLzI8OHmgu/DD00g9v33TbmbF58PfLIukAhDrDBLXO68C6DMfS3kkxAhDLlv8n35Z+ScoJGATCneRzp3Nvv1zp3mNXly/rNISzNp1qwxAfDt2/MPMp3r8GGRunVFVq40x1BcnKlUX0ig/8cfRWrWNN/N9NtvIk2a5C6nLuRccDTmqBCG+A7ylYenPyxWmCU3Dkbcc5uaynymvAKiheSDD0yZm3M9nM7Cm/8DvzyQtf+GxxwTmewvEpvjovufrpvLaY6ZhMMiicfNhVARdd/k+4Qw5IW5L8jL814WwpC7J9wtsu1DU8mfWkJk4fUZFf3cZUSaM02sMMuU3yMaZwVtrTBLvD/wlsikSBERKftZWXEMdMjxZQ+JTPQWWXG/yIn55v20MnLPPeccis2HixVmyZ0/3ykiInP2zhH7ALtU7POSBAWZIFNiojle9uwRE/yY7J+dz/FW/oH3/Gx+R2SCl0dAq1zwKXnvvexzaErKOee4HBeww4eL+PubsszlMkGmUqXyTltQS5bkfSyLiJT6tJRHGRw6OPSC5n05LV4s0rKlqTvExJjyKjpaJDjYBEwKondvkffeK1h9KC3NBEo++UTk00/Nza6PP877hl/VqiJ//vnP1+3vfqOCevhhE4g5N3+VKolMnep5vZBvXfVv6kNOp9n2p0+b7ZbXOWrEiOyb3JnlrNNpAj7Tpnne3PjuO5EuXQp2vbJ0qZnHueuW53ocmiiy+Ka8zzFBeaxbmTzqLbPqmkDoud/Poxxv0UJk+vTcN24ut6IaNJq5a6YQhpT+rLTcOvZWIQwpObik3D7u9lx1wL1n9+Y9k/QkkYk+njcKxlsiv5T0mJ403kesMEusMEvSXemy6ugqIQypPrS6uN3urBsSozeOFrdb5JtvRB580NSBli0zwfb33ru82+dyK6pBo4vuniYiTsuyngcWYDpRjBGRHZZlPZ3x+QhgLnAnsB9IAh672OVeLJsN/P3Pn66g2rUzj9Dt0iV7vmXLmgE009JMc9lM27ZBz54FW/7ChWaAVd8c47BGRpr5tm8Pjhy/oOMif00R2LoVOnc2PWcy2QphuPS6dWHiRLOM5GQzLsSNN178fDt3hmnToGXL7O2Zmuq5vTPNnQtvvmmeVnA+X3xhfsvoaOjTxzwV4fhxM+Dtxep1bS8m75jMzD0zAZjSfTLePeDXX82gapm/dUoKjBxZsEeI169vBsg7V2IiVA6qzNwH5jJm0xjG3nNu29psM2fCLbdA06bZ2zIgAL7/3jzp5667zHYtU8YM7rpsGVSrlp3W5YK+rfryycpPiEiKAKD7Nd25tsy1/P7I7zQb1Qw/hx/JzmQW9l5Iv4WmD+8Xq7/IDC5TOSh3l1TADM5Z2AN0BlQD/8rmqR5VephBj695wwzyl8dTBNtWbsv8A/PNU79CagAQWawWVod55skp8fvMU0LEDZO/8HwCHJjBao/NAO8Qc1BljAWUp+TTkHgEblmaPZ/Mv5v6QasfzLgA9V7JN79ErYf0aGgzCcrdZh5XLs68lxk+Eyp1M4M/27ILkueD4KOkspxKNGPY3FXrLlpUaJH7+/kICIBnnjl/ukyPN3mcb9d/S4hvCJHJkXSu3RmblXcB9ErrV/hh0w9sj9gOwM/3/pz/jPMY5Pv+jNfp03D2rJnWvn3+s/DyMo9u/SeqVIENG8zTtKZPN0/hstmgenV4+mkzBt/5TJ0Kjz3mWbbFx0PFiucMpsyFnQsqBVXCbtlJcaYwdqspHw67fbESD4M7Bdy+HvtE4Tw/w9Nbb5myuWtXM8h06dJw7JgpewvD2K5mvfo07UOFwHJm8E6/8nmkvMB1s9nB79/xtKqKxSsCMGL9CKyMATkqFq8IB8eYsuHObaYr9BT/PMsIL7sXpf1LczrxdNZTX+yWHS+7F063k4S0BEr4lSDZmQwIpU/PhdLtodWPpnxyp5GeEMlC8/wMHnzQnDMmbTPjMGQOEBqXGodb3KRsuZtu3UzdoVhG8VahArBjnBls+LrRUP0RMxj/HzdDw7CCb4wjE0HSoWJX8K/KgeUzSXIG8tZb2edbHx/IY4QEsw1HwM03w2uvmeO4Vi2YMaPgi89L27Zm3Ltff4V77jHbRsSUDdO6T+OGH2+gYmBFwuPD+eX+Kz9QdH5uvtk8CerVV0055+9v6iGxsWY7FcRPP5nBf59/PrtsTE018z23PuTlZQac79gx93zOlZpasPpUfpxOU7Ze0BM5z7F7N3Tr5pmPgwfNb9+pk2f5nm9d9W/qQ3byHng/pyefNL9Hx47myVIVKpinjh48CHfeabZppj59zFMU77nH/B7ly5vzZV7b+6+/zAMDcj6lKt/1SIs0T+G6mAe5pMeDV1AeH+Qux7/7zmx3m83k3eGAM2f+dQ8bvGTaVDZ93c4knmHRwUWAOT+M6DSCakOrEegdSHxaPNdXup5aofkcyKcWmTF4/MpCg/ch/DfzROTUs2DP3uH9SCXYbhHtEk4nnOZ4vBlDqHaJ2liWxYRuExjbdSyOjHrHs8+aV0qKeRiDt7cpZ9TlVxhjGiEiczGBoZzTRuR4L8BzhbGsouqdd6BDXNkfwAAAIABJREFUB3j5ZXjlFVNoHzhg3t9xhxkErHx5U2D9f3t3HidVce5//FM9+8bMAMO+yi4IsqhERAmEiICQYMQ1mqjXaOKuCSomms2YeBNNNPEXrhpjYm7iTUw01xh3o9EralAMuKCIIiCCIjDD7DP1++Ppnu6Z7p6Z7tm64ft+veY13adP9ymonnPqPFX1VGmpnVyXL287cJSZaUGnxsbwxTN00Wpo6HigKFJowYCWqwB0JufCDcDO8J3vwCmnwIkn2s1XcTGsW2dZ7lsKBKIvZvGUlFhQZP16WLPGTlQlJRacas8NXltuX3I79994PzfMu4H8LPsPOfFE+0nGsmWwapVd4G+80S6Ee/bADTfYqgzHjTmO48a03qp65BFYscICZCE1NXa//Y1vhL+rgYAd67jjYOdOOOMMC3S9/DIsWuT45eJfsuxeS9bwg8/8AIBpA6cxqnQUGz/ZyHnTz6OsoIxTDjmFu1+9m4bGhqYV4L58aDfGk10A5j4G/7oENt5pq2Y11tvqYAtfjtq9LL8MgOv+cR3f/ofNPy7KKbIL5MFXRO0fpfxtKJ4AgWCrMF7ACGDnP6FkSjhQFBlg2nwv7HkNisbaBXrvm7BwTYzPeBbyh4UDRq358Ek4/JfNj4f9vd62+DY+/wdLKH/j/BvjfUKnuH7e9dz20m3UNljyslsW3tLq/n8++c+MuWUMv1j4C3IyY0SK26F//6Z0I10qP9/O+cuXJ/f+F1+E73+/eUD/qKPsXNfyvLZvX2KdIrOHz+apd58iPyufyrpKDh+1BKYeC4/Mgqn/CX2mw2f/D969ByZdk9w/oBUZGXbeqq62G5eKCrth956mhKMd+vxABveccE94Q8kU2HIfDF0Ombm2BHRjHQRapkTdf3x56pe5efXNNPgGnLf/1HMOXgyr74AjVlmOu4zW/4YuPuJirn7iaoYXD+e9Pe+xdNxSnt78NLuqdlFRa8mXq+urGZrhyWiotO9ORED75femkpFhAaNVwTy3W77am2eBvbW2PHR5TTkeT8Xbh/LFG5vfcBYUAFsfgEELYPhyC/T3abnuShtqPobKLVA2G478LTjHs7d/xMwjrK0VeTMf62a3oQFefx3uuCP8elYWHHpoYsVoKSvL2oXf/CbcfLOtWFddbe3IV1+dzYDCAWwp30JZfhlzRs7p2MG62LRpcOedzbc9+qitODl7dtttKOfgs5+1n8505pnWHlq1Knx+rKxsf5v06KMtuPL889aBWFBgbfHq6vZ/xpQp8OST1kEXes+uXTBwoAWluoNz1qa7/HLYssU6HyZMgCuuiL6WOGftyH374JVXLGBUWBju+IiUk2P/ny2DaqFgWzP958K67zbPeLtsuy0mcmo7L17DTrQFXIonWNtl2XZoqIl5Hpsyxcr/m99YR1ZFhd2T/fCHza+pB6q++X0ZWDiQDyo+aAoQXXzExYwoGcGyCcu4L5jY++YFN8f/kG1/s8WUjn4GSg6B4SdbJwRAQ1WzXUdkej5pgK3lW9m614JGh/Q/pOn1zED0zW1ubvMBFNL9Or/L8ABVWGgXxM99zi74550HDz4IV19tPajnnmvL8I4dayffe++1nufycnsebynbJUusdzqyJ7mkBEaNgj/+sXmApzOCPfPmWUS+MmIVxZqa+Pv3tPx8GyFzyy3Wa7BmjfXqx+oJWrIE/vCHxJYNnjjRer7PP9+CU50RMAI7QftrPSuOWtH2zu3gHDz0kAWdLrgApk6Fk06y75z3bb8fbInsliOp1q61kQx9+zbfPmKENZwnTLBlJy+4wEbQ1dfD0vFLm/Y7qPSgpse3LrwVgG9/2gIux46yzPUNvgGPZ2DhQIaXtEjm1tVyesORd8PcR2DMeTD+Ejj2+Zi7Ths4remxD+bxH106uv3HCuRYojwfbBnmBiMVGTEaSBUboeTg8POWAaZF/4bZ/2NljxUwAhtpNPDY9t1111c0H3kRcbwl45Y0PZ5QluRQm3YqyS1h/kHzKa8tZ3DR4Pgjz4JG9x6Nv9Zz/mEJDGdKU3V1zQO6YIGVM8+0jok33rAGf2WlNfITcd0x1wEwrs84AK45+hoYdRZ8+u8WoHzxa/DqtVB4UPtPKEnIzYWDD7bg/PjxnRMwiumwW+Ffl8PWv1iwqLE+tZaB7gKT+0+mV3YvGn0jDb6B3MxcpublQGYRDP1CmwEjgPNm2EqPoWXDVxy1gqLsIrz3lNeU0+gbqWmoYVxWo63k2Kt5j/Qzb8ymoQFuvdWu3fn5cN2K3hYkqrEL896avdCQSfWeEqZObX586qugejuMvxQyQxGbBIeM73wWArlw+CoLaGXksbeqF2UDMqO+b4EA4SW5g97OHEeB28eUKYkdtj1KS+3/5sUXbbTNn/5ko78BfrX0VwDcueTOVj4hdX33uzZaYMsW2LvXOrVCIzy7y8qVFoRbvtza1c88Azfd1P73Z2fDAw/YTIFrr7VRo3fdZQGg9rr8crj7bnjpJWv/791r5/X33++89mV7ZWRYe3nSJGsrTpxo9xWRbf7Q4jMFBTYa7rjjLPAXawbCokXW+diy/R3zHqJ4gq289cQC2LMeGmuheqd14rXXpG/Ch0/AC1+F3eug4l3Y/D9xdw+NfL7jDrsXuOkmBYwirZy9EqBpJOppk09rth1g+qDp8T9g+2O2QnfhQdYpG2gR4Zn0LZhro5j6B78/Fz50Ibe8YJ2Dg4sGd8Y/Q7pQJ45TkUDATpqLFjXffvzx9hPpwQdtKOqxx9ryiRs3wsMPR3/m4sU2WumiiywYFZrge/318JWv2M38McdYm+bxx6OPnajvfMcugEOGWG+gc/D00zB/fsc+t6uNGmU/rTnrLLuZuvNO+I//sIuhc9CrV/eUsasFAjb89oQTknt/fX10FP/tt60hUV3dfNh0aL+TTrKfFiVh75V7o6YVLRi9AH9t+IbTOccXJnyBP75uQ+1DF6gekZlvF7pWTB8YvlhmBbKoa6zjs6MS6AotmwUvf4OmWP2y6ClTTRrrbBSRC7Yic/tHBHKC73cB+4nnk1esUZURrKz7WhmHHciF2l3h503HCxBwAT68/EOyMrpnFMbK2St59J1HmzVUBHr3hg0bbEpbpJtuskbwkiU2Sic3F77wBQsgtfcm5MihNjQ9NO1oUr9J9kLhSJjYOYHtlFI2C+b+HV65Cp47A/DQezoMiB0w3l+cNvk0bnvpNnt8yGlQ8TaUTmlaArstpXmlTVOkAGYMmkFxbrEFfWorqKqz3uSJOQFcr3HBXv+8pnPP2s2TmT69eTCwX5FNT9tXZyvV7a3ZC/W5BAI+evTGvnctyFV2VJL/A9jIzJw+UBjuoMjNqqZiV0O74qGvcTAHT/BUVTWfxpOfjwWYPowI8DtnwxhjTI9tS8ub2WNHHcvqs1czY9CMhD8rFZx1lqVWmDoVpk+3kScvvWSjlbtLYaGlkfj7363jdvduaz8ncq6cORM2bbJphE88YaPbf/rT9o+KHDfOgkbHH28jRfv2tQ64sjJL4XDKKeHRbomOGO2o73zHOrxHjoQZwa/Z+vVwWDtnpI8da/+fixZZO3vUKEvxcOGFRC0dD1jg9p1fwTPLYd87kFUCI0+3KWuttW1CcnrDwrU2Unz12VC3F/rOsnQD+/Go0a6ycMxCeMjOwXNGzGlq800bOI3cjFzOmXZO6x9QtRWmXG9pDqB5ZLFoNEy8EptACYHg38oLW19o2iUj0M1RU0mYgkY9ZNEi+OADmwe/bZv1FMe66GRnW9Bm0SK7WRg+3AJMu3ZZL82JJ9pFx3vbtmdP7OO112GHWQT+7LMtz0R2drhXKN0NGGCjcY4/Hn7+cxua+u9/d39vV6rKybEL/KDIASfV0aMb2qMop31vWjJuSVPQaMGoBYkfqBsFAgEm9ZvEuh3rGNJrCJt2b+LEiQnMJ+z/abvp2fQbGHmq9ZTX74vOfQT2Ws2u8M1cKMDU2GB5VNqjajuUTAo/b206XN+ZsPV/7cY5IzcqoNWvsF/7jtkJjh5+NCtnr+SMKWd02zHTweLFcM89dqMRmhYTmiJwzjn2k6ysjCym9J/C2g/XcsKEE5p6GvdrvafbCMNQpOAA+DcvHLOwKWi0aMwi2PO0jQgKBadbCywHXfapy7jskcs4ZvgxBFyA0lxLoFJRW9E0Re2Q3Ay7SQjlsQiee97ZMYr5pzafytM/GDQKBZw+rvoYMmrwjQFqapoHZqh4BwpG2MiwZO8vKjYGpyLXNZVv+sh/8a3766M6TcrLoahFwKfiN9D/zx3La5MM5xyHDzm8ew/ayb7+dZtO+9xz1knVGTkiE5WREbtzNxFFRTYt/4wkL1GLFtnI+Icftt/nnw+bN9vv3Fxr19fV2eisREeNdsTSpTbi/Ljj7H4jI8M6KiJnHrTld7+zTu5DD7WA2t69Nq0vJudsROuos5IvdGY+jLvAfqRDRpaObHr8pSlfavZa1TVVtKp2j7VP+8+J/frBK8BlNgXzJuXA31p8r44a2oHOAOkWChr1oIICG83TlmHDbIjyiy/afOqxY237OefY+5991s69s2Z1TrkWLLChsmvW2GicadPafk+6mDXLOv3++lfrEPzBD3q6RKnjkEPgscdsWkio1y0jo2sbx/MOCmezmzWsk77AXWjOiDms27GOTbs3kRXIaspH1S4ZOXD4/4PV58KOJ2HIUkvievht0fv2ngYbbomeMtJQAYFYiR9jaKyzXvn2GLIU1l4NE68Kj0yKF9DqYs45vjf3e91+3FR32mmWN++ss6wXODPTbiw6a6TkGVPO4PJHLuf0yad3zgemiwMgWBRy9PDw3ducEXPg+V9C/3mQFYxCthZYDloybgmXPXJZ07TVUK63itoKymvLASjNyLTpri3OX1t2DWHmzOaBoLLgFzg00mhX1S7IrKOwpIZXX83lyCMjPqDiHcgfHJ7i29piAvGUv23TdrPCfzhThq2lotxz7712wx65GEXLTpNQoDbm1yaJEUUHmvz8xKZz7a9ycmx0aEhoBNM559h0/1Ae0+4MGoEFfM48MzzNLNFZBjk5toDLD39o/54BAyxfk6SH8X3H88ZHb7SZAzVK5ft2Ts3uHfv1QYubjf6aGbw0ZAYym6Y7T+4/OZkiSzdSTqM04ZzleVi+vHnCxbw8uwDPm9e5CcICAbsxOfLI/S/xWHa2TeH66lftQi0mlLA9cv55bq7lIGjZQO6sQNKgovCwptzM1P+iHT4o3NM7d+TcxD9gxKnwqV/Dh0/Bc1+EzX+IvV+fw+wivPM5670JCSaIbhcHEDHfIpRDKdZpf+gyaKiGJz4DezdYwOjNn7X/WNLlDjvMpp0tXmyrqF15pU116CyLxy4GYN5ILUuyv+qVEw6UlOaV2t954chW3hFtVO9RXD/3es6eakvblRWEg0ahkUa5GZnNV9wLnnt27O0XtSKZc46CrAI8npr6Gj6p+gSAidP28Lvf2RSdkLp9H1vQKHTzkWjACKByc/NcS/cNIBDwXLHoP7nsMhv93dAAb74Ze4We3Nz9Y+S1pJ4VK6xj+NZbLVfS1q09U47iYguennSSTYtORkmJTUVUwCi9nD/jfAqyCuhXkODo8n2b7dwcmfA6NHI1u9R+Ihwb7I8cUmSrevbN60ugM5bqli6lGhIRwBoI69bZ6KvKShuan5UFr70WHTiMbMh31IS+E5g3Ij1uVKcMCGc/nT1sdnIfMuwE+Pw2OHE3nPBx7H0ycq1n5vmzofI9W1q2djc8/bn2HyeQYysFhSzbDqd6ODXGEoIZOXD0Xyzfx98mwb2FsE6jfVLNf/2XTRt+8EG7sZjQiXnJx/YZi7/Wt3tqqaSnY4Yfw6eGBOcFNdZa7rQEXTX7KopzbcRj6OaivLa8KWjkAzl2zgpN/Vu2ncrPeWob8mOuVBj6zpXXlrOnxiIyxx5fzu9/b9P3q6utM6N6Xy1k5Ns0h2RV77Qpbk3PLfB01ZIfMHasjfTIzLTVlt5/P/rtI0daQKnl0u117UsLJdKqfv3g1FNtUZ39rcNWUt9FR1xExdUJrBYUUrPDRpf6iPZlKKhfPClq9bT8YPRhy17Ljzd1YMtVDyQVaXqaiAA2h/3LX4Yf/9hWBenXD/75Txsi/fTTMHduOK9d1PKpHfDa117rvA/rYuP7jm96HLmaWsKca3vq1/Sb4MGJ8L8ToGQylL9lN3ntVTAcPnnZprq1R98j4Pi34fUfWT6k4ae0/1jSLbKy4JprbFXO+nqt/CKJe+pLT4WfuIzwVC9olgC/vUI5jcprwkGjfZnFNg2svqIpKWpVlV03SkqiP8N5G8p6+n2ns27HOgA+/4Vabr/RRitcfbV917PWN3DxhQGa1ukOlTfWCpTxNNZCTlnU5qzMep55xpZj/+tfYcwY+Na3ot8+aZLlo9y5EwZHLPbTMjG2iMgBo7HWEpkTY95ur3ExE5OP7T2WDbs2AJqali4UNBKRJjffbIGhO+6whIiHHGJJd1essMBRQYGNMlq1Ci69tKdL2/2yM8J36YcOOLSVPTtBwTCY/yz843jYsw5cNsyKM50tlt7T4aP/g2EnhXOWtCW3DKbemFx5pdsEAgoYSScI5EBNxEoQra3oGEcor9sT7z7Be3veA2BbRh9L+u/D85jr6+MHVcrrLBfSwxvDS8jm52Zx//2WU+Xaa23Q0vdOyoHGfeHe7CTKi2+IO7oqELDVo847L/7b8/NtQbRbb4VvfjOc1Luqav9ZiVVEJCGNdcERoDGCRrn9w4siRJg+aHpT0GhC304cNi1dRtPTRKRJdrY1hjdsgNWrLfn6ihU2HH/BAnj8cUtweMUVPV3SnpMRXGloQGHbKw11WOlkWPKO/ZywA4Yc3/739p4G2x5uvtpaXRLDjkVk/1QwAvast3xmSXpvtwWKntv8HL999bcArNlXBbvXNctrFEogHWtZ+8IYQe3hxcOZPh3eeANWrrTr0HlfK4SqDxMbcRlTxI1Na7ne4jj5ZLjtNlsqvaLCOlJO0cBMETlQuQA4T8w8mvlD7HVotkLnlP7hdA+je4/uhkJKRyloJCJRhg6FiRNtatrChTB5Mrz0kiVd/+53my+ZfKAZWjwUoPuWJQ9kQN7A6JXU2tJ/no0ieP0nlvC2sQ6qPuiaMopI+imZBBXvQUNN2/vG0a/Qcho10khDcATQntxBUF8O79zdFJDKpIq6uvDKnM2KkRs9Zy0700YD9esH110H3/8+lAweAZUdzA7sAs2n5LWW6y2Oiy6yHEtHHWWrGk6dasvIi4gckFxW9HVk2XYoHG3t15CIxQsiA0UKGqUHBY1EpFXO2QijOXOspziU6+hAteniTfhrY3SXp5qiUdBrPLx6Dby8Ajb8Ah49su33iciBoWgMfLLWEu8naXDR4KhtRfkDoM8R8MoKqHgHGqrI3LeOhobmq3OGtFypx8Wa4gBQeBDsey/mVId2c5lQ17Hlz4YNg29/266HDzxgU7lHjOjQR4qIpK/MfKjeQbORRmB57XJjrH5A80BR5ErKkroUNBKRNuXlwUMPWd6G7dttZRlJA1N/ZKsNvfVzWHOJjTgSEQELGtXuhE9eCW+rr4q/fwxDeg2J2laWXwYTrgAa4aFp8PBMer0wm4YG+Oij6M/om9+32fPMQJx0m4UHQe1HULExoTI2k10ClTGWRUvQN74BP/uZjcJdutSmc4uIHJDyBkPVNsuTF8nX2zk3hsigUbeN3JcOUdBIRNotO9tGHkmaGDgfpt1kIwkyC6DP4T1dIhFJFb3G2cibNZdAfaUlHKr7JKGPCE3XjdSvoB8MXgylwcUCdr9KRkaA4mLYGmN2WSg/XE5wCm5OZpypuNmldlOy8Q4rL0BDgvmN8gbbym6d4OyzYe1auPdeKC7ulI8UEUk/BcOgenuzPHaALTzgYncCFGQnsOqlpAQFjURE9mdjzoWF/4a5j8Pcx3q6NCKSKlwAhnwOPnoB/rkcNv4XPPbphD6iX36/qG0DCwfaZ3/6YZumFsiB/vMYMMCzYUP0ZywYvQCAz476LACHD44T3HYO+s+xkZOVWyyHRqJTzQpHwZ7XEh5RJSIiceQNhobK6IC89+BiJLKLELkqsaQ2BY1ERPZ3RaOh7xHRvUAicmAbe4GNRNz2ILzwFSiPEdVpRSAQbkYGgivkjO4TnHaQWQDz/wEnV8OcvzJihOPJJ23FsZDycigrKAPCPc/Di4fHP+CI0yzp6mPHwJpLE8/TVjQGdj4Hvi68rQOJwEVEDngZ2ZDZC7b+tcXqli1yHLVYrXJ079Esn7i8W4ooHaegkYiIiMiBqM8MGHWO5T6DpJJM52fae6cNmAbA2D5jY+43diw88kjzFdSysqA0txSAjys/BsLT1WIavMR+V2+Ht25LfKpZ4UgLjPnG8LbI1dRERCRxvcbDpruhMXg+ra+0AJKPWJmyxWqVb134Fr/5/G96oLCSDAWNRERERA5U034CI06B4omWAy1B/QptilpVcMpXcU7sBD8zZ8KePfD881BXB7W18NRT0DuvNwC7q3cD0Ymxm8nMgyPvCQe3QsGu9uo7025i1l9vCwM01sOuNYl9hoiINDd4MezdYMH8hhqo2QENVQrK70cUNBIRERE5UAUy4IjbYdE6GPOVhN8eCvLsrNwJQEYgdg6L2bMtUHTmmbBvn01NO+ssKM2zkUZ7aiw/USiIFNeQ42HKD6BkMoy7yPJmtFfRGAhkwRs/hg8egT3r4bnT2v9+ERGJNniRTVN7+evw2Gz4W3AhhNrEFleQ1KUEFyIiIiKSlD55fQD4qPKjVvcbNMh+Nm2C3sG4kPeQGcy1tqtyF9COoBHA+IvtJ1HOweDj4d3fwjPLEn+/iIhEK5lieY3q98HHLwY3Oqj+sEeLJZ1HI41EREREJCmhkUaNvpFeOb1a3fdLX4K8PAsWeW+PQ3bX2PS0dgWNOmL0V5pPa0sij5OIiERwDmbcGj63ukzILoHKbT1bLuk0ChqJiIiISFL6FfRrety/oH8re8Lll0N+RLymVzDGlJ+VT30wgWqXB436HQUD5tsqbACZhV17PBGRA8HQz8OI08FlQMEI6DMTqrY2T4YtaUtBIxERERFJSll+WdPjgYUDW923oAD+/GcoKYHSUvjLX6Lf1+VBI4BP/dpucPrMhHlPdP3xRET2d87BEb+EE3bC4jeg8CCbnlZf3dMlk06gnEYiIiIikpSS3JKmx2UFZa3saWbPhl2Wvgjn7Pew4mFs/GQjAKW5pZ1exijZxXDUH7r+OCIiB5rs4Dk8byB88DD4up4tj3QKjTQSERERkaQ0Cxrltx00AgsWhQJGAEN7DW16nJOZ02llExGRHpJbBuVvN88h11DTc+WRDlHQSERERESSEhk0isxvlIiBRa1PaxMRkTST089WU6uJWFmzQVPV0pWCRiIiIiKSlNK88HSyZPMRhVZgExGR/USvsUAjbLkfGmptm1PoIV2p5kREREQkKZEjjSIfJyIUbMrLzOuUMomISA8rHG0ji17/EdBogaM3f9bTpZIkKWgkIiIiIknpzKBRcU5xp5RJRER6WEY25A2Cfe/C2pWw7UF448c9XSpJkoJGIiIiIpKUyEBR5FS1RDQFjXIVNBIR2W/0/ZT9fuMn8MwyqP2kZ8sjSVPQSERERESSkpuZ2/S4oyONSnOTCzqJiEgKGjC3+eppkrYUNBIRERGRDuto0KgkL7n3i4hIChq0GHxD+HlGbvx9JaUpaCQiIiIiHZZs0Cg0wkg5jURE9iP5g2DAvPBz33NFkY5R0EhEREREOqwouyip9+Vl5TX7LSIi+4nJ37Upahl5MOqcni6NJCmzI292zvUG/gCMAN4FlnvvP2mxz1DgbmAA0Ais8t7/tCPHFREREZHU4pzr0PszXYeapSIiKWv4cOjgKTJNTQP29XQh0sbw4T1dgtg6enW+Enjce3+Dc+7K4PMVLfapBy733q9xzhUB/3LOPeq9f62DxxYRERGR/UB2IJt5I+e1vaOISBp6992eLoFI8joaNFoKzAk+/jXwFC2CRt77D4APgo/LnXOvA4MBBY1ERERE0lyAAI00dugzar5Z00mlERERkc7U0ZxG/YNBoVBwqF9rOzvnRgBTgdUdPK6IiIiIpICsjKyeLoKIiIh0kTZHGjnnHsPyEbW0MpEDOecKgT8Bl3jv97ay37nAuQDDhg1L5BAiIiIi0s0yAhnQ0PZ+IiIikn7aDBp57z8T7zXn3IfOuYHe+w+ccwOBHXH2y8ICRvd47+9r43irgFUAM2bM0MJ8IiIiIinslEmn8PyW53u6GCIiItIFOprT6AHgTOCG4O/7W+7gbCmNO4DXvfc/6eDxRERERCSF3L7k9p4ugoiIiHSRjuY0ugGY75x7C5gffI5zbpBz7m/BfWYBXwTmOudeCf4s7OBxRURERERERESkC3VopJH3/mMgan1U7/02YGHw8T8B15HjiIiIiIiIiIhI9+roSCMREREREREREdkPKWgkIiIiIiIiIiJRFDQSEREREREREZEoChqJiIiIiIiIiEgUBY1ERERERERERCSKgkYiIiIiIiIiIhLFee97ugxxOed2Au+12NwX+KgHiiMdp7pLT6q39KW6S0+qt/SluktPqrf0pbpLT6q39KW6S0/x6m24976srTendNAoFufcS977GT1dDkmc6i49qd7Sl+ouPane0pfqLj2p3tKX6i49qd7Sl+ouPXW03jQ9TUREREREREREoihoJCIiIiIiIiIiUdIxaLSqpwsgSVPdpSfVW/pS3aUn1Vv6Ut2lJ9Vb+lLdpSfVW/pS3aWnDtVb2uU0EhERERERERGRrpeOI41ERERERERERKSLpVXQyDm3wDn3pnPubefclT1dHonNOTfUOfekc+5159x659zFwe29nXOPOufeCv4u7emySjTnXIZz7mXn3P8Gn6ve0oBzrsQ590fn3BvBv71Pqe5Sn3Pu0uDS/b/wAAAFsElEQVR5cp1z7r+dc7mqt9TknLvTObfDObcuYlvcunLOXRVsr7zpnDu2Z0otELfubgyeL191zv3ZOVcS8ZrqLgXEqreI165wznnnXN+Ibaq3FBGv7pxzFwbrZ71z7kcR21V3KSDOufJQ59zzzrlXnHMvOecOj3hN9ZYCkrn3TrTu0iZo5JzLAH4OHAccDJzinDu4Z0slcdQDl3vvJwAzga8F6+pK4HHv/Rjg8eBzST0XA69HPFe9pYefAn/33o8HpmB1qLpLYc65wcBFwAzv/SQgAzgZ1VuqugtY0GJbzLoKXvNOBiYG3/OLYDtGesZdRNfdo8Ak7/1kYANwFajuUsxdRNcbzrmhwHxgc8Q21VtquYsWdeec+zSwFJjsvZ8I/Gdwu+ouddxF9N/cj4Bve+8PBb4VfK56Sy0J3XsnU3dpEzQCDgfe9t6/472vBX6PnXgkxXjvP/Derwk+LsduXgdj9fXr4G6/Bj7XMyWUeJxzQ4BFwO0Rm1VvKc451ws4GrgDwHtf673fjeouHWQCec65TCAf2IbqLSV5758GdrXYHK+ulgK/997XeO83AW9j7RjpAbHqznv/iPe+Pvj0eWBI8LHqLkXE+ZsDuAn4BhCZmFX1lkLi1N35wA3e+5rgPjuC21V3KSJOvXmgV/BxMdZOAdVbykji3jvhukunoNFg4P2I51uC2ySFOedGAFOB1UB/7/0HYF9uoF/PlUziuBlriDVGbFO9pb6DgJ3Ar4JTC293zhWguktp3vutWE/rZuADYI/3/hFUb+kkXl2pzZJezgIeCj5W3aUw59wSYKv3fm2Ll1RvqW8sMNs5t9o59w/n3GHB7aq71HYJcKNz7n2szXJVcLvqLQW189474bpLp6CRi7FNS7+lMOdcIfAn4BLv/d6eLo+0zjm3GNjhvf9XT5dFEpYJTANu895PBfahKU0pLzi3fCkwEhgEFDjnTu/ZUkknUZslTTjnVmJD++8JbYqxm+ouBTjn8oGV2BSZqJdjbFO9pZZMoBSbPvN14F7nnEN1l+rOBy713g8FLiU4qh3VW8pJ4N474bpLp6DRFmBoxPMhhIfHSYpxzmVhX9p7vPf3BTd/6JwbGHx9ILAj3vulR8wCljjn3sWmf851zv0W1Vs62AJs8d6vDj7/IxZEUt2lts8Am7z3O733dcB9wJGo3tJJvLpSmyUNOOfOBBYDp3nvQw1m1V3qGoUF2dcG2ypDgDXOuQGo3tLBFuA+b17ARrX3RXWX6s7E2icA/0N4GpPqLYUkeO+dcN2lU9DoRWCMc26kcy4bS970QA+XSWII9hrcAbzuvf9JxEsPYCcegr/v7+6ySXze+6u890O89yOwv68nvPeno3pLed777cD7zrlxwU3zgNdQ3aW6zcBM51x+8Lw5D5uHrnpLH/Hq6gHgZOdcjnNuJDAGeKEHyidxOOcWACuAJd77yoiXVHcpynv/b+99P+/9iGBbZQswLXgNVL2lvr8AcwGcc2OBbOAjVHepbhtwTPDxXOCt4GPVW4pI4t474brL7Nwidx3vfb1z7gLgYWyFmTu99+t7uFgS2yzgi8C/nXOvBLddDdyADUU9G7tZOrGHyieJUb2lhwuBe4JB9XeAL2MdA6q7FOW9X+2c+yOwBpse8zKwCihE9ZZynHP/DcwB+jrntgDXEuf86L1f75y7Fwve1gNf89439EjBJV7dXQXkAI9ae5vnvffnqe5SR6x6897fEWtf1VtqifM3dydwp7Pl3GuBM4Mj/FR3KSJOvf0H8NPggh3VwLmgv7kUk9C9dzJ158KjcUVEREREREREREw6TU8TEREREREREZFuoqCRiIiIiIiIiIhEUdBIRERERERERESiKGgkIiIiIiIiIiJRFDQSEREREREREZEoChqJiIiIiIiIiEgUBY1ERERERERERCSKgkYiIiIiIiIiIhLl/wOyTQQY6zpVaAAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -2202,7 +2080,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2214,7 +2092,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2229,20 +2107,14 @@ "output_type": "stream", "text": [ "tal hits:\n", - "MotifHitAndCoord(motif_idx=0, motif_score=0.9995233787592409, precision_at_motif_score=1.0, example_idx=7, start=91, end=116, is_revcomp=False)\n", - "MotifHitAndCoord(motif_idx=0, motif_score=0.6694922206103467, precision_at_motif_score=0.3611280077363049, example_idx=7, start=100, end=125, is_revcomp=True)\n", - "MotifHitAndCoord(motif_idx=0, motif_score=0.9998068744229901, precision_at_motif_score=1.0, example_idx=7, start=122, end=147, is_revcomp=False)\n", - "MotifHitAndCoord(motif_idx=0, motif_score=0.8389726480891654, precision_at_motif_score=0.7246978685792207, example_idx=7, start=131, end=156, is_revcomp=True)\n", - "MotifHitAndCoord(motif_idx=0, motif_score=0.9988489961840756, precision_at_motif_score=1.0, example_idx=7, start=158, end=183, is_revcomp=False)\n", - "MotifHitAndCoord(motif_idx=0, motif_score=0.8114523781844735, precision_at_motif_score=0.6617643108541413, example_idx=7, start=167, end=192, is_revcomp=True)\n", + "\n", "gata hits:\n", - "MotifHitAndCoord(motif_idx=1, motif_score=0.8404588409236708, precision_at_motif_score=0.7594466445239779, example_idx=7, start=19, end=44, is_revcomp=False)\n", - "MotifHitAndCoord(motif_idx=1, motif_score=0.9998292111100581, precision_at_motif_score=1.0, example_idx=7, start=63, end=88, is_revcomp=False)\n" + "\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABIUAAACMCAYAAADiDBl2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3xb1fn48c/VtCzP7L0IhFVGCDOUUUbZs1CgpV9KC6UtLb9SWlpWEjaUUShQVihlBCizpIQVICFsshfZibMdO/GUrf38/jiSJVmSLSd2nNjP+/XSy9L11dWRdO7VPc895zmWiKCUUkoppZRSSimluhdbZxdAKaWUUkoppZRSSu18GhRSSimllFJKKaWU6oY0KKSUUkoppZRSSinVDWlQSCmllFJKKaWUUqob0qCQUkoppZRSSimlVDekQSGllFJKKaWUUkqpbsjRWS/cq1cvGTZsWGe9vFJKKaWUUkoppVSXM2vWrEoR6Z3Lup0WFBo2bBgzZ87srJdXSimllFJKKaWU6nIsyyrLdV0dPqaUUkoppZRSSinVDWlQSCmllFJKKaWUUqob0qCQUkoppZRSSimlVDekQSGllFJKKaWUUkqpbqjVoJBlWc9YlrXFsqyFWf5vWZb1sGVZKyzLmm9Z1uj2L6ZSSimllFJKKaWUak+59BR6Fjilhf+fCuwZu10J/HPHi6WUUkoppZRSSimlOlKrQSER+RTY1sIqZwPPifEVUGJZVv/2KqBSSimllFJKKaWUan/tkVNoILAu6fH62LI0lmVdaVnWTMuyZlZUVLTDSyullFJKKaWUUkqp7dEeQSErwzLJtKKIPCkiY0RkTO/evdvhpZVSSimllFJKKaXU9miPoNB6YHDS40HAxnbYrlJKKaWUUkoppZTqIO0RFHob+FlsFrIjgBoR2dQO21VKKaWUUkoppZRSHcTR2gqWZb0EHAf0sixrPTAOcAKIyOPAFOA0YAXQAPy8owqrlFJK7W4iEfjnP+GII2DMmM4ujVJKKaWUUgmtBoVE5OJW/i/Ab9utREoppXaKYcOgrKyzS6F2dUOHwpo1nV0KpZRSSinVEVoNCimllOqayspAMk4LoNrTqFGwbBkUFMDEiXDhhZ1doraxMk0noZRSSimluoT2yCmklFJKqQzq6mD1anO/vh6mTu3c8iillFJKKZVMg0JKKaVUB/nmG/B4Eo8//rjzyqKUUkoppVRzGhRSSimlOsiMGdDQkHi8dm3nlUUppZRSSqnmNCiklFJKdZCpUyEcTjxO7jWklFJKKaVUZ9OgkFJKKdVB4vmE4iKRzimHUkoppZRSmWhQSCmllOoAIlBRkboseSiZUkoppZRSnU2DQkoppVQH2LoVbM1+ZUU6pyxKKaWUUkplokEhpZRSqgOUlYHbbe57PGBZnVsepZRSSimlmtOgkFJKKdUBNmwwf/v1g/p6eOKJzi2PUkoppZRSzWlQSCmllOoA5eVm5rErrzR/f/YzKCjo7FIppZRSSimVoEEhpZRSqgNs3gx+P5x6Krhc5v5hh3V2qZRSSimllErQoJBSSinVAcrKzN8DDzR/PR44+ujOK49SSimllFLNaVBIKaWU6gDr1sHIkWboGJjeQscd16lFUkoppZRSKoUGhZRSSqkOUFEBQ4dCJJJYNnRo55VHKaWUUkqp5jQopJRSSnUAnw+GDAGHI7Gsb9/OK49SSimllFLNOVpfRSmllFJt1dBgegbl5yeWuVydV55OM2xYIsGSUl3d0KGwZk1nl0IppZTKmQaFlFJKqQ7Q2GjiIbakPrl+PzidnVakzlFWBiKdXYodZ1m7zPvw3umlIdSAjNs1ytNudqHPeLtZVmeXQCmllGoTHT6mlFJKdYBAAAYNSl2WnF9Iqe0VlWhnF0EppZRSXYQGhZRSSnVv/fqZq/vNb/36ZX2KbYKN/R7dr8VtBOpDaZvQTgSqPYQioc4uglJKKaW6CA0KKaWU6t7Ky9u2HBCENTVrsq4bxSKEg5KS1OfZ7dtZRqWSRES7nCmllMpizvXw/hHQmP08RqlkmlNIKaWU2g6RaPaGeQP5OAiRl5eaWdqhv7pKKaV2RzppwG4oe49n1YJuOGGAnp4qpZRS2yEUzT6Ex4cXB2Hcbg0KKaWU6gK6wqQBXSGZfWumnwUbJpv7NhdcFNi5r98VPuNuONZfh48ppZRS26GlZL8mKBTB7U5drkEh1Z5kdz/xVkop1X7CjbDpw8RjW3eb7lRtLw0KKaWUUu3Mhxe3U2eIUh3LF/J1dhGUUkrtKso/Nr2D4sL6G6Fyo0EhpZRSqp358OL1Qjjc2SVRXVltoLazi6CUUmpXUTUHIg2dXQq1G9KgkFJKKdUGuUwHrkEhtTPUBeo6uwhKKaV2FZVfgeiJh2o7DQoppZRSbZBL74wQTvK9FhGdOVy1s+Q8QtpTSCmlVJOahebvwLNg9N/BsnduedRuI6eUl5ZlnQI8BNiBp0Xk7mb/Pw74L7A6tugNEbm1HcuplFJK7RJyaYhHseH1WkQ1rZBqZw2hxNAADQoppZQCzIxfjRvBVQpjJ5mAUP2Kzi6V2k202lPIsiw78ChwKrAvcLFlWftmWHWGiBwUu2lASCml1O6hb982Lc/YEG+2rmDhdHe/KU1Vx6sL1mW8r1Rn++47OPpoeOyxzi6JUt2Qfwtgh0HngETBngcjf9XZpVK7iVx6Ch0GrBCRVQCWZb0MnA0s7siCKaWUUh1BBO69FxYvhkcegcLNm80/LCuxQgtqAjVN9wPhAG6HG5ptI/r2O6Z/rVLtLDkoqT2FOsCwYVBWtmPbsLpnQHgf4DOAz4Hfdm5ZVI6GDoU1azq7FKo9+FaD3Q3DfgLOQrOscGTnlkntNnIJCg0E1iU9Xg8cnmG9Iy3LmgdsBK4TkUXNV7As60rgSoAhQ4a0vbRKKaXUDvr3v+HWW00S6IoKmDKlbc9PbojXBetMUKiZaBRsmrVPdYDk5NKaaLoDlJW1GhhukWXt2PPbQyeUYfJk+MlPoK7OvPxpp8H//rdTi7Bz7Qrfc3vopgHMLqlhvamTJQcklkX8pseQUq3I5ZQ109Gi+VFwNjBURA4E/gG8lWlDIvKkiIwRkTG9e/duW0mVUkqpHSQCEyZAQwMEg/DJJ23fRnJQqMZfk3EdEQ0KqY6hPYXUruj++01ACMzxb+pUc//5ec9jTdDAg1IdLlhtAkCu4sQyDQipHOVyyroeGJz0eBCmN1ATEakVkfrY/SmA07KsXu1WSqWUUqodfP45VFYmHm9PIujkQFC2Rnk0qhdgVcdIziNU7a/uxJIoZYTD8OWXqctcLvO3wlcBpM6ap5TqAKFqyB8M4cbEMg0KqRzlEhT6FtjTsqzhlmW5gIuAt5NXsCyrn2WZ01/Lsg6LbXdrexdWKaWU2hHvvguNSedLwWDbt5FLT42uMrJA7XqS69zWRj3VUp1v8WJwNxtFW18f+xsyd+qD9Tu5VEp1M4Ft4B3c+npKZdBqUEhEwsDVwPvAd8B/RGSRZVlXWZZ1VWy1HwELYzmFHgYuEr0koJRSahfz0UcQiezYNrY1bmu6n5x0OpkGhVRHSQ4KVTVWtX0D/fqZCpp869evHUuouptZs8zx7vDDYcsW+NvfEse/+PGysqGyhS0opdok03H80bsgfxDYXJ1dOrUbyiXRdHxI2JRmyx5Puv8I8Ej7Fk0ppZRqPyKwYIE5d/r2W9h7bzjggNaf11xlY6Jxk62nkM22fUPTlGpNcnLpKv92BIXKy3NbplSO5s0zPYPuvRd69YLf/hYeeMD8Lx64rGyoZHjp8E4spVJdSKZjdhHgKjEzkCnVRpoGUymlVLewebMJ1Jx+Ouy1FzidcNNNbd9OSk+hLImmbTbtKaQ6RnIgKJ6vRanONHMmjBwJY8YkOi38NjYlfbyHkA51VKqDeQF3H7C0ea/aTmuNUkqpbiGe9+Kvf4XCQpMI9aKL2r6drQ2Jxk1LPYV2dJiaUpkkByXbfUhONAKL7oEFEyASaN9tqy5r9Wo47rhE78i8PBN8h0Qd7ZDhY1tmwKI7TS4Vpbo7L5Cns3ur7ZPT8DGllFJqd7dqlQnUjB6dWBYMgseT5Qn9+qV30e7bly03lTQ93ObP3BixLPD7dQYy1f6Sg0LbNXysJbN+D6v+Ze5XL4Tvv9q+21ddUk0NfP/7UFCQWLbPPuZvRYPpzZYcTG8X5dNh2mkQDcGKiXDWCj3gqu7NA7h6dnYp1G5Kg0JKKaW6hcpKGD7cBILyYrO05rU0W2uW3CuVDeHENn2Zr37b7dDQYP4q1Z7i09C77W4C7dmbp34VrHoGIn7zeOM77bdt1WVFIuZYd/DBqcvDYdMzs7zeHEe3+La034uKwLdXQaTBPPaXa0BIKQfg6tHZpVC7KR0+ppRSqlvYuNEkl07O9dN8GuVcJPfUyNZTyOMBn0+DQqr9xWe8K/WUbt8G+vbNvGzpPyCaCHg2BYeUakF1tRmKO3Ro6vJQyPxtCJvAzfq69W3feKYZliwLju4JDUnbi/i2s/RKdSE2wFnQ6mpKZaJBIaWUUt3Cxo0mGarXu2PbEYRCVyGQfUpwr9cEhRzaH1e1s+pG01Ooh8dcEY5KG6e527w5NTIqYpatfwskDI5CcJYAmildta6y0vS4bH5cbR4QX1W1qu0bzzYr3vAqCDfGXii/7dtVaneXKbhvAZZeiVLbR4NCSimluoXNm2HgwPYJ1MQb5PGhPM15vTp8THWM+CxOXqdphfuC7dBLIrAVGjeCZwCct8ncikbt+HZVl1dZCT16mGG5yVwukKTgY1l1Wfu96EEAEThxOvzYB0MubL9tK7WTTF8znfNeOW/7npwpuN+zFG3aq+2lNUcppVS3UFkJAwbs2DYCsSBPfOhOtuSpXq/JqREOpy6PtrFTh1LNxZNLb6jbAOSWwHfOHJg7t4UVtn4Ddg8c8jBYTrAccNgT7VFc1cVt3WqCQvHhYnFud2KoI8DGuo3t84JOoA8w5AIojc0acOg/22fbSu1Ed864kzeXvNl+GxTR3Fpqu2lQSCmlVLdQVZW5x3VWGVauHRSb7jV2gS7ea6O5eFAo0CwPcPMgkVItaWiAs86C/Hy45prUC8PxRvaiikUtbuPGG+Hoo+Goo2DChCwrVcUiRgPPALsLbA7oeXg7vAPV1VVXQ2lp5oB3fBr6PEceEYm0uq1wGO65By68EObPz7LSQCAI7HNdIn+KTcfpqt2PP2zytiX3qNshlpX6I/FGP5hkwSTtsqxap0EhpZRS3UIgAL17t+EJGbpnL5n+OgALKxaabWaZ/SkeFPI3y9WrQSHVFr//PXz4ITQ2wsSJ4POlt7xbmtXp88/hwQdNcKmx0TS4M6pbAb0OT00uHQ1mWVmphHAYiosz/y/ei63EXQK03vi99lq49VZ47TUYOxYkUxS/J2B3Q8lBiWXOou0pulKdKn7sjgdPd5wNSPqN8MdzcmkXZdU6DQoppZTqFqJRMyvYjlhbuxaAcNIsTdEMl8hdLvO3vj51uQaFVK6WLIFJkxKBRZ8P6kkPAFU0VGTdxs03m2BQXPL9FL4y6HkkOJKS9jp0FhvVukjE5E7LNGol3tgtyTNBoYZQQ9btzJ5tAp8NDSYW7/eD1TwwD/DSYzDocIhkq8xK7Xpuu81MdPGrXyV61W1pMMfz9bXbMTNfJpYN2jrxgFIxGhRSbTZsWOYZQvWmt+TbsGGdXVOVShWJ7HiS6QpfegM8OW9GMpcLKpqtrjmFVK6efdYEEQ86CG64AQYPhk11m9LWy5ZTqKbG9BQqLIT334cpU1qYea9hA5R8D2zOxDJLTxFV6+JBoUziw2vjQaGWekQ88ojpzdmnDxx2WAsB9IYN4B2i9VPtNp5+Gu6+G1auhBdegOuvN8u3NW4DYF3tunZ6JQvC7TDxgOqWdBCuarOysvQLN2o7WVbm5V3gA8721pTqLNEo2HawHZFpqM6G2g1NiaeT5eXBxma5VXW/ULl69VXTQJ42zQRzLr8cltVvTlsv3rBo7pNPTB3897/hmGPMsqefzvJigS3gHdw+BVfdSkunK/EgUM/8noAJEg0tGZpxG2+8YYb3LlpkenQ+9FCWjdavhPzBYHPvaNGV6nBVVWYYcLyXZkMDPPoo/O1viXXW1bQeFAqHTU+6bdvgssugf/8MK9mcEKxql3Kr7kfD7EoppboFy9rxnjrbGtIb4BvrM8+qk5cHa9emLosPK1OqJVu3wvr1cMcdJsm0wwH9+mUOSlYHqjNuY9o0MyvUD39o6mJeHpxzToYVRSBUA3mZWhlKtcxuz35cjdfX3vkmmVu2nkILF5oeR089BQUFJij0u99leUHfWvAONQnRldrFTZpkzj2OPRY++AAuusjM1BeJJhKvr6lZ0+I2olH46U9Nzq1bboEjjsiyzzmLINBe+YlUd6M9hZRSSnULdrtpeOyIbf70oFB5fXmGNU3DZs0aMyTCHbuo7XRmXFWpFMuXm95B552XqDNeb+ZGdY0/8/DFRYvg9NNTe3JkHJIjYZOHwt2jHUquuhuHwxxXM/UYWrp1KZAIDm2szRxAX7TIDHM88cRE4DxrAD3sA++wHSy1UjvHc8+ZXj2TJ5s6PnasCfhvTur1uaRySYvbePxx8/yGWEquTZuy9Hp2lkAge445pVqiPYWU6kyZZtZo05zZSqlc2WwQ3MEJlaoa07tmZ5v9KT/f9BRKnoFsW+aRPqnCPohqRurubPVq2Hvv9IZ2PH+V0+bE4zBZ0+sCdVm3cfLJph7GFWTKHR0Ng2VPzSekVI7sdqjLXAWZUTYDgKmrpwLwzvJ3Mq63ciUcemjqsTJrAF1C4MiWHEupXUc0CnPmmBxC8Uku8vPNLJDJyaXnl8/Pug0RuPNO07voySdNb6MBA7Ks7O4B/i2JZNN52p5QudOgkFKdKcOU12xOzxmhlNpxTqcZlrMjGsLmUp3H4cEZa0TXB+szrltSkp6DbX3sPHBZ5TKsCRa+YFJSyGgIPv8JvFoCrxbCujd3rLBqt7VqFQwalB4U2qN0DwBOHXkqfzjiDwCM7DEy4zY2bYI998zhxSQMWOgpodoehYVQXZ05X5ovZI5vwYiJxpf7MveqXLQI9torNYCZVTQClg50ULu+detMj7cLLkid5OKQQxLJpW2WjbU1a7NswczKV10NzzwDP/kJHH+8mUAgI3cvCFVDbH/jPG1PqNzpGYBSSqluobgYtmTu1JOzESUjABh/3Hh+tO+PABhanJ44FWDgQFi2LLWhM2+e+Tu3fC4AC7csTPxzxgWw/i3TSI/44Yuf7lhh1W7ru+9g6NDE1eW4eADywH4HMnbIWLMslB6U9PlMr7isV5STWXZAYreYN/rBJAsmZZlWSnUb57x8Di8veDnr/3v2ND0gm/fsCQYhFAmlLMsWFFq6FPbZJ8eca5YNSEqoonVVdZK7ZtzFqm2rsv5/xQpzHG9erxsbEz2FBhUOAkCyZGz/9FOTT+788xP55YqKsrxgXh9o3ATRQJvfi1IaFFJqJ/Lc4eHX//t1ZxdDqW6pZ0/Te2JHxIfvHND3APbsYbph1AZrM647dCjU1iZes64OPv7Y3I93F2/qNr71W9j8IfQYDafNh2Pe1uE8XZSIMPqJ0VmHfYGZTn748PTGRF3QPMfr9JLvNNHGan+1aTVYVtOtsaAX9rCf4uIcCmQ5zHADSUq45Y833ncwM7va7f136X+5fur1KcsqK+G66+AXvzAzLFZWJvKmxQWDEJHUJG5VjVVpdRXLonr2SvbaK8cCWQ6IJo0D1rqqOkFUotzw8Q3c8PENWddZvhwGD04ftu50wsptKwEYWDQQgIqGzLmAZs+G005L7TVaWJjlBd09wdde09ur7kaDQkrtJFGJ4g/7eWPJG51dFKW6pb59zfCtHZmBrMpvcgp5nV4KXCZBS20gc1Bo4EDTUJo+3Ty22eCLL8z96WvMws/XxfqBL3kA8ofA8e9Byfeg/0lwwsfbX1C1y1q+bTlzNs/hi3VfZF0nGMw8lCae0yrfmY/XafKq1AZqoTy1B0YIJy5HNLe6bnMAUQhlD1Kp7mlrgxlvu74uKf/JfBg1Ch5+2Axpufxy0/Mh0KxzQjCYXvl8IV9aXQUI48Cba5ogmzMpEKRU51i2dRkAK7atyLpOZaUZBuxoNtrR44HFFYsBKHaZyH22aennzoUjj8xxaKWzBBrWgj0vh5WVSqVBIaV2kvgPR7aktEqpjtW/v8nx4/O1vm428ZmevC4vXpdpxWxtzJyoqG9f09PjxRcT6cJWxXqaf7buMwD+t+x/ZkH5dPjeLWCLXW6350FhLglh1O7mq/VfAfDNhm9aXC9TjpZ4Xct35jf1FMrU48hGNONsUJlfyGYS92pDWzUza9MswFzUAhNQ/9GPzPEsnvR2331NEHPDhtTn1oQSWfXddndiOxkm04hiy1jfM/L0g7qViWS6SnWCmRtnArBgy4Ks6wQCiSFfyWw2+GK9uSjwcZm5+DN52eSM21i/Hg44IMdCuUpMcD/SmOMTlErQoJBSO0lyAyCsMwsptdMNHAiLF6dOS9/WKerjw3eSe2pkmiYczCgJm800nK6+2kwvDhAIm0vqHoeHrY1bkWANBCphwCmxXhsx9lwuDW6nDEM46Nev415PNflg5QcAvLvi3azruFyZg5fJPYXiQSFf0JfW0HYSIhSx5x4YcvWChqRWvc5ao4BvN3zbdL+yoZIpU0zvh2+/hYsvhhNOMDlPXC7TgyhZyGaOlSNKRrD0ajM1vcfhyTjBhmPY4LSeRll5h0PjBpN3DbSuqk7x2VpzYScYCTYFTZsTyRzcB/CH/U3PB1hUsSjjesEg9OiRY6E8A0yQv/a7HJ+gVIIGhZTaST4t+7Tp/ncVesBWamfr08ckfkzuhl2feeKwrOKzhSXndNnWmHme+SFDIByL/z72WKLRtKRyCQDDS4YDUL5xGniHgL1ZVmFbByZOzTCEI+My1e5eWfQKAF+u/zLrOsXFZkr55rko4sMXU4JCIV9aQ7sgsI2w3U1l5nhlOk9/qFue6H2hs9Yo4MNVHzbdn7VxFu+8A2efbWKQbrcJens8JvHtjBlmGFnc/BWm8pV6ShlSPARI5GRrLj8f1mafgClVwTBo3JzIK6R1VXWCt5a81XQ/2xAytxv8/vSLT/GAULLVVaszbiMazR5YSlMw3OwXa16C2EypSuVKg0JK7ST/XfrfpvutDRsA0+105codn0JbKWUMHAihkBlCFpfTbDdJ4lMsJw8fq26szrjuoEGpjaS4eHLpfXrvA8DqyoXmandkJ84YkmEIR8Zlql01hhoJR8P09PQEUocTT18znbeXvA2YmZjKytLrTzx/VXJQKFMDw+UyDfV1ueYc9Q6BrV9BuI1RUtWlTS+b3nR/5saZTJ0K554LBQWJdWw2k0z3888Tjd9wGD791py8lOSVYFkW+c58ohKlIZTeWN1jDzMtfU49Nz0DoGaR5k1RnSYSjVDuK6dPfh8gMZQMYMkSuOsuuP12c9Fp40Zz3pHs27L0IWfx2ciaczhMYCknngEQDcG61wFr555TqN2eBoWU2gkC4QBbfFuapq6etmZa1nXDYfjLX6BXLzj+eNPb4Ac/yH6yVFYGf/0rHH20OVl7++0dS6SrVFcRiZjZvh5/HF5/3czmFInAI4+Yk7VoFGbNyn17ItLUAPc6vU3Dx7Jd/Y43zJO53fDU7KeARA6B91a8T9o4n46eZjnDEA426xX3jjZ702zAzF4H8PX6r5v+d9y/j+PsV85GRBgxwuSSaH6FOJ4/yOtK9FTLNnxh0CDTOy359yDrb0PBCNgyA6wcZrzLNPRQhx92OfFhsfv0MsHr91a8R3k5HHRQ+roHHwwzZ5oGMJgebq+/a57fw2PGvsSPl/Hk1cn228/04swp35tngBluG2wWjP8NWi/VThHv7b9nT5P3b9qaaUSjcMUVcNRRMGeOGar+5JPmHL15TiGf3wRrBhQM4NIDLgUS+0dzJSXmAnFOLFtsWvqNMPcvsGV6689RKkaDQkrtBPHG38Y6c8b06uJXs677i1/AZ5+ZH5Xly82IjiOOAHuGtuEHH5gTNLcbJkyAiy6CO++E6swdF5TqNubPNwHVhx82J1TvvAPHHGMaK08/bRrH4TDcfHPu24wHhGyWDZfdhdflxcJqyjOUSf/+qY/d7kRgIJ5L4PPN881JXPKV7119mmUNDGyXiXMmAjCvfB4AT856EoDy+sTQvXnl8xg+3Fxxbh4Uqg/VY2F6Xdhtdhw2B5ZlUR9M7+EzciS8+y7UJVXPumxVtXhfCG4zuVpak22YoQ4/7FKenv00ACurTIv0s3WfEYmkN3DBBIU8HnOBCsw5zMYqE/yJ94qLz9aYKTH/nnuaPEXOpJhk1gBm0SjTA2Lta4m8QgCZY/NaL1W7e/TbR4FED6EX5r/AY4/B11/D0qXmHOPxx+GTT2DNmvTnbw1tAuCYocfwwA8fAMh6HrHvvmbfyDn/YdG+5u+yh+GTH+b8npTSoJBS7S1DY+mVu34CQChq+pAGIgG21KfPQrZmjenpM3myOaF3u0037RtuSH8Zvx8uvBDefBP+9CeT8PGCC+Cjj9qQlE6pLqixEY47Dh58EF54AW67DR56CL75BkaMgIYG2H9/M83rtGm5b7cmUIOFhdPmbBoOYVlWU56hTA47LPVxOJwYgpbvMD09vq6rM43xUFKrRpOndkmTl5oLBPE8VB+vMTPPTFowqWmdibMnsueeptfEm28mhh74fNAQbMBm2Zp6CbnsLiyspmFlyQ4+GKZOTW1oZ2rQA9DzcNNb7NvfmFwULeWjyDbMUIcfdilTV00FEsFrAI83nHFI4sEHm3r2xhvQuzeccgrgNec4vfJ7AVDoLgQyJ+bfc0/TUXF1UlqVrL2GPP3B4YGFE8xQmdh5FcVZ1td6qdrZJ2s+Acy5PEBjuJG77xYefNCcfxcVmdv++5vzkXfeSQ3qzFlpdqJBxYOaetJVNlQiGdoPh3xwB1M/jKTsD82Ho6XodTjavFfbQ2uNUjvBwh7m18Bhc2BhLv3OWDsjbb1PPjFDxWzN9szk8ftxU6eaH5wxY8Ab63UaT/qoVHf22msmGHPaaWbfycuDwmzS5JsAACAASURBVEKT9+K448w669bB7Nlt225toBbLsnA7zPTKXqcXm2XLmCMj7oQTUvdfe7G5al3kLuIfp/0Dh81BfTRK1NMf1r0JkV0zeWqFrwJrgsU9n91jFsSHn+kQtDbZ5jfBoHiviYZQA5FohNs+va1pnUe+fYSC4gADB5oLAg0NJpi4ebNpfKQFhSwr47T0J55oGiJ/+pNpYPt88PvfZylY4UjTCNn8IXxzBczKtiL63XcT8Z7NvfN7k+cwvRiH7VfOlCmkzRR20EGJ/FeVlaY6OErN80s9pQCUuEuwsDIOHzv0ULPNq64y9T0USp/NLEWvsWYI2SenwPxxZtljpA/D1XqpcrRkCVx2GZxzDlxyiUmofuWVmYduVTRUACZflt2yQ9jFxk0wdmxqr36HA/be2+QYiucF8vng9Y9XAdC/oD82y0ahqxBBMg4DHs0cZk5vSOnl2WJQqPRgcDQbiqYXmVQOcgoKWZZ1imVZSy3LWmFZ1l8y/N+yLOvh2P/nW5Y1uv2LqtRuIkOujpohJhnd7Ctnc83h1wCwujp9pgGXy5xYNR8ykKkbdWOjCQY171LaPKCkVHezZQsMGJDePvB4TEO5sDCxLOdZPUgk+Y03kOLDx/xhP5Jl7u+jjkrdf/cca1o6+/Xej8sPvpw9SvcAoLL4EFh0J0QaIRrpnJlDsg0JA8546QwA/vLRX1KSI6vcbazbSFSilOaVMudXc5pmZHp85uNNs4rF3ffFfVx4oanLxx8P48bB8T+IEowEm3qpQaIuZuopdOih5u9jj8Evfwk//zk880yWwlk26HeCub9mEqycuONvWO3W4vv5vKvmcf3Y6wEYcPBcXnwxMasimPxsHg+MGpX6/Kh3ExYWRW6TWK3EUwJk7imUl2fyIs6YYYbB33MPnHVWC4UbfB7YvVD5BSy+a/vfpFKYYV8XXmjSMDz3nDlmvvCC+bvHHqnrhiIhqv0mR0PFnyr48X4/BlsImy2acWKYn/7UDCn7xS9M3qzbb4c1tcsB6OM1bYPSvFIsLObMmZLWfjil7jX8jkLOPNPsa34/3HhjC2+m34mJmfkA7Pmab0vlpNXmo2VZduBR4FRgX+Biy7L2bbbaqcCesduVwD/buZxqO1RVmXGon34K06ebmSHWrElvKKmOVdVYxab6TThsDvbrsx+HDDgEgI9Xf5y27qmnmu+qsjL1SkCmGYyOO858p/X16SdoGY0fn/lHYfx4fEEfU5ZNyTiLjdq9RCImQe2iReZK63ffmWNBd3LccSbBdPMAqc8HZ56Zuix5evrW1PjN8C6Pw3TH8zq9RCWK3WZvGhLW3IgRiSE7bjcMGG1yyezb2/yMxhNVzvCMgUAFfHA4bHwHVjyRe8FaMHeuGUZ3//0mwfYjj8B995m/OSevJHXGxFH/GEW0rdnsu+EJ6fra9eTdnofrNhdra9Y2JZXer89+jOwxktH9zfWz1xa/BsCI0hHs13s/wAxPuOwyU3fmzDG54tZt9uGwOYhEIzkFhRwOuPhic7Hh5Zfh1VdbmW1vjyv0CrMCTOBma+NW3HY3/Qr6NSWbrtnzSTZvhvPPh9pac57yz9gZ/x/+kNorMq9HBZZlUew247p6enoiSMagEMCvf22eP3myyfW2bVsLBRx4Jmn51tpQVxctMjlfHnrINPwfe8zcf/ZZ2LQp5810WRUV8P778J//mNurr5qhrLCbTmQiAhl64cQ9/rjpGTRokBn2VVJiLh5lGm67uGIxUYkyoHAADpuDg/sfDDZh6BGzueOO1GGPPh/87Gfm5V95xQyTvPtusErWYrNs9M7vDUDP/J5YlpVxBrKCArO/xfMkjhoFf/97C+/VVQy9jkh677kmI9o5Zm+azZfrvsxp3YZQQ8bfNtUxso0uT3YYsEJEVgFYlvUycDawOGmds4HnxFwq/cqyrBLLsvqLSJsOraFAiPqqOmy21Eu3tVW1IEJRj+LUdavr8RR7yMtLJOesr64hEgpT3LukaVk4GKZuWy15RV48SS0AX2094UCYop7FWLHXjIQj1G6txV3gJt+bWDe8/kMctkY8PYcSG/1DOBzmyyVf8rlvPVvtbvKdHkb3Gc3YvgeTb3NQWFpMOGJaJXZblPWb1uFxF+BylxKVKP6wn1BDECtko7C0ELvD9DkUEb5Z8S1TK6ZSHijHaXdxaN8xnDb4eArtDvKLixAciJgx3HVbq7HsdnAkLn9ffKmH087M4+qrE59jQwOMu9nP2KMdlJYmPmNX4yJqV33NwceMpKTUIv4Gq8vLiYYb8Qz7YdOyYFCAfmxeV4Xbk/jcVy5rRCwHhQXm/VoWSMMmHNWf03v4cPLy7IAAFhKsJty4lfzhpxEMO7DZIBLxs2LjCqoiDYRx4LA5KHEXs25+byCPHn0S30UkAps2RBgyxM5e+9jNAc9yQDQAkSAlJVbTj5ZImC3lFeTnFWHFTnYDkQA9D/ge9srUE5OoBVWD9iA4fXrKd//c81Dvz+Po77vM+4r1mv/22yhBf5SrfuuGaBgsO40+PyF/IwUFFj1jz5+++BMsLAbkD6CuoobB9oHYLBtz18xlzaJVFJQU0Cu2rj1cxZ+viXLSiaXceZeNE04ww1xuvrmep5+ow+PMa6ojkYifa37j5oQflPL0RBsHH2ySiN46PsAdExrT9qOai36OdcnPGTxqWNOy5cuWcN6U81l414SmZUf1P4qnj3qSAoc3dZ8LmZNAT6Er6fu0UV8TIBoNU1KceL2APwD0Y9OaDeTn55tZmyJ+nNEAdgRvSSnhcKxtSISGmlpsTre5ohEXrkeiIYp6lBCOWLF6FWbthrXgdOJ2lhAhQjASwhFwYA9bFPYswhaLBEhUqK6oxuV14S1INHQaGsyVlsJSL3a7qSh233cUzP8ZthPeh/wBTev6139BdPH92IddgJWf6HoS9W1AsOEa8kNCIdNduKqukucXvMw7az/GH/HT39ufS/e5lLG99sNmc5NfmJiGKhSCYCCK3eUCW9JhOOTD5rCR5zZ1OF7fGhvBcuTFem0IWHbqqhqwiFJUlPjc77rXybbaAp580pzcxH27fCZXTrqC+VtjvVR67Mtj338AOIltaxbgcrljawqE6omGgxQOGEUwZJnvSMLUV9dhc+aBPWl8Yuw7Kigx35Flgc2KUF+V4fuM+JBIkKIexQiJ40R1NVh2J9hdsX3ZTkOjk0DQoqjIHDvjdY1gFU63RUG++QwdDvD7GvH7AthchWAzx9CRg+GQAx2cfpqXic/YGDYMamrg5hsaePQhP1dd4eHhR/MIBKBf3yjVW2qxSKSkqNlShb/BT2N9IwWlif1z05aNiAhOcVCzpcrshxKhQApYMm8RQ/sPo3fSNqKhGuw2OP+c/jw/yRw//D2nwSYYnjeMmi1V7OkdCcBbyzZwcv+LKdj2MtanZwMQDDuoZy+sKmIHngjYHMxa9Q2/nHYRZfWmt+EA7wCeP/kZRpeOxF3gIc/jIRyG2lqLMWNKmoLGTb0KoxG2banG5UxEzWq2VOH77Num38SS/uYItnDZfNjLrFPkKqI+VE91oJpHP3iEswefSWHPIkpj26jatJXy8nKKioqa9rlgJNj0mTS31VVAYNU6vEktycb6RgKNAQpKCnA4E/vG1m3gcNsoLHTH6gP4GyP4G4MUFlgkrcrGTRvJ87jpUWLeQyASIBppJE+ieIoKsNldRCImQGILV4NlQxxFTXUqHAziq/Fhc3nBloiiFAM1G9eQV1Dc9BsTDvmpra2iwNsDbO6mY93TsyZy8+xbmp479O9DGdv3KAD2KdiHmi1VfK9of97iLb5Y9wUA/z7xWQYWDGDEv0byWdk0Co+ez4U/2oNXXs3H77fIK6lBLBvhaBj/1gYCViNuyw0RWLt0DZtsG4jnNa/ZUgURH3/6TZhXXh5CMGi+a683TNXmWmw2K6W+NzSAv/FIBntGYq+bDwgR91DqjpqNbUtqVLmhroGgP0hhaSE9kraxdRs48xwUFBWAhMBysnRJgHVlEfoPsDcFacNh+ORDH3vu7WLo0ETCo17VjzIKkMbyRBc+EWqWf0qk7H84xtzZdEwJNAZoqG3AW+rFlRTpmr16Dvcu/BvLapeCZXFEvyO4acyf6O8uJK/Qi83uJho133PjpnlYdhs2Z+qxuRjYtHoTeUW9Yvuck7oqH0TDFCf9zoWDYeqq6sgrysOTNG67GFi7aHXKeWgkYo51eQVuPB4b8WOary5IJByiuMhqesvRqAnku71u8gs85qq/zYWvwSIYhOJic5yNb7diy2aKCzx4PbHztNg+V71+FYWlRWDZEQG7zfwm2hxOcLS8z326dhoWFv09/aitqKa/1Q+bZWN5zafcduMWbrqtFz172nA6wUL40zXVXHQu/P73JYCF1yt4elYQjNpw+G3UbKmiCHOOum71WtYPLCP+E1WzpQqiAY4f42OfUYOZPddJJGLh8Qg1lbVEI5GmYwxAxfoq6urs9B54DQXr/44V9SO2POqOXUakfFvKuuVlm6iqqqK0R2lTW2HN+iBHHt2XhobEdwNgt8IEfDUgNhqTJuuwSz1OewjLXUooZC422G2xJ/k2IPZ8gkFzPPHV1BMKhrG5ipvqcDQSpaayJq1d0VDrIxQIpZy3RCNRNm/eTGFRIYWxLq2BSIBAnZ9oSFLaCgBbtwpOt1BQlNhuY32AQCBMUZGd+Koiwofffci9i//GmroyLMvipCEn8du9f81RgDXBwsLC6/Ty04J/8NEjl7FsGSniQwZrqiOxPE7mXKS62obNFqGoMBF0CQYt6n12vF4bblcYiILlILjuY9weJ3n5ifaDr8HP0nWLqcovBk8JLrub3p5e2BpslNWVEfVETZ1yeRnuHYbdZ09v+9XUEQlFKO6V2OesjZMpqpwIx38AdjdNjTegqnwbtqRuwueeYeP2uwu55hoLp9PCZjP7YbHXF5vW3Wr6Hf1mjdk3RhQMpWZLFYMcA7GwyDvhz7z00FR8PhvXXWfhcsFjj0V56N5q/vonD397IA9fg6nX4ZJNiGXDE8ijZksVvVw9ERGWLFrERuchxM9CzXG8keuvDvHuu4OpqrKoqjLbqN5SnX7e4jeBqJ69Lqdo60yINBIpPADfgg8QEUr6miN2Tfk2iAaQkI/82nIcTvOb6HRCzdZaokLKcbHOV8cXa75gfv0CfFEfpXmlHNX/SA4sHYHb4cBbXEwoFDunlxAuoGbzJrAlvqP3vnuPi6ZdklKnnj3+GY4tPTbtGPr16q8558PzaIyYK+IWFs+f9C9OHTgWR54HV14+Iub1/PXmPDR5n0OiSLAamyt13cqazXy7cSarfJsJRsP09vTmsL6HUhAajNtrJ98bP7+wKAXKlm2lsMiGPfbbFQrB9E8a6d0/n7z8xO9OIADlG8McdoSDwqZzchvVlXW43HaSmiCsKwuydq3Qu78XW+yc1bJg9cZlVNnWMWCIDZvNoshZRF9nX+wBO96S1N+5msoabE6LwuLU6W2jUcFbUoArr6WrPy0QkRZvwI+Ap5MeXwo80myd/wFHJz3+CBiTYVtXAjOBmUOGDJHmPnnwepFfHBRvcydu55G2bNopx4h8cmriyfPGibyIuSWbN04+H3eEyCV9c9ru3L0PEHmjv3lu374iPb0iLyKBiU6R6kUp2/3gbwOE8aTdzh/wH3n4wZA0NkalocHcVqwuy7hu6GxbWhkiVvp6jEfOG/svufXWtI8t8Z779jW3eePk0cuukt9fWi6fTQ/JwvkRWbQwIu9NCUteXvrTp0z4tcis63L6LKfd9H2h2WJ5vW/6MhF59+8PiHxyRsrzfc945Jg+M+S/rwWlfHNUtmwxt9/fd0nG95xpu9+89orIh8enLS8/rbdcZT0mZ51QJ3+6LiJ/vDYi3//JX4TxyDU/jNWboYjtFkSK07/7DT36pX6Wse/+8NIv5eWXU18rFBIZxziRAxF5EJEXEHkcqX6ySKTiq5RtvP8k4hyH/PY08zr1TqTvdcji+0eIrH0z7fXkPOQNzpGDmC1uGqU35XLkzSVijUM+GWa2Me5Y8/nIechrnCcHMUvcNEoPKuXt354uMn989u+zb2xf6OmVC24eKIxH7LcgRX8xn018u80/n6knHy8y7QxJ8XrfjNu94ZaR5mkZvs/6+tRNzHrnQ5E3B6V8DtEXkD/vebfceFWFTJ8WkWVLo7J0SVQefPz1jPVEXkQkUJWyjconSjN+n6tvGiKy6rnUQlQtlLp/7yNSs1QkEhCZe5PIi8iXEw5LXXfeOFl+/x5yzMgl8sWMkGzYEJWNG6OyYUNU9rs1P+c6/NU9Z4gsvi9lWe0LIzKuO/n2G0S+vir9Hxm+o1ePPF8uPX2jzJkZkiWLI7J0SUQWL4pkLNcvf3ds6uvNGyeh5+xy1fBH5c7rq+Tzz6NNn/vL9/5H5OLeaa+3h3e5TJ+eWqz5H30ucoEnbd2tZ5TK73lQThlbI3/4fxH5w/+LyDXnvC0yZXTaWxvHOJF8RC5H5LnY7RpkwQn7yam2KXLqiQG57P8ics6ZIamb6BX58xXpx9FzLXmUq2RPloibRunDJqm4v6fItZdIPflyFDOkD5tlPvtnPIbOvesAkRVPp9Sfz59GXLcgP0n67Eddjbx6wxEiC25Lq2vx72g9A6Qvm+RqHpYfXNdb3OMs+WKQ+d97eyDOmzHvGUTOR2QiIg8jd/T4q7y89ziRQxB5InacuS3z78NlDyCfnnyeHOX6Rk4/JSQ/uSQix4/1y9/2v1b+9KOV8uqkgMz4NCKfTgvLU7e8JfLfEenlTT7mx5b//c7+AiJ/PtGU96uBSP4NsXVDvpR1n32wUBiP/N85Zt3Z/RDHzbHPqnZ59tdLWrbl8Z4i5Z+mrzvJkVZPlty3l0jZq2nrZvp8fv3jq+U3l26TWTMjsnpVVMrKorJgQVT+ceBv5OfHr5YnHo/IlCkReeONqPz3+p+K/Oro9HOGDDvoBXeOybzfx27Xnoxcd5K5f+BfBohzHDJlpNnWZ4MR101I6U3Inr8zv/0Cctz/IT+9B5FL+ooPj5zJf8WDT67Iv11Kb0L2ujpRnp+eixz3+8znLfH69ylHS382yEDWyeT+p2b83JvqX19EHjD1r2aPgozr+p91iVTNT1t+u/uvIj9B5Ok8kTdHiLxQJEft8Zk8/3zqZ1ZdnfGjlBf++MfUf2T67Yrtn19NOExk0T05ffdnn3W9/Pzn6a+X6Rzn9WvONmWoWSbiWy/i2yDiW5fxd276zUeLfHhs+uee/B5iy7+59RCRD49JL0OG4/g31iEy9cyTRCYdKbLwHpHlE0UW3CV3eq4XuRiRNw4T+eZqkW+ulscfPkAYj1x1unnuvL6Jfe5dTpYxfCMD+4Vk0MCIfM82N+P3Wf1U+nnLe7HzlqtPTT1vWfY0Iv/vx/IG50gfNouXOrmGB5rexzucKoXUyM94Vg6+xSvecXZZ3sP87+X9YmXL8H3Ki4hcdaysZ4CM4RspoFb+zu8yfu7XnnqfvD16nIgLketix8vvZz7HueSWwcJ45PFDTBle3B/hFksm7HOT3PiztfLf14Ly+WcR+XxGWG66Ypocemj6V/TpMUfLRcO+kAm3BOWVV6Ly0ktRuf+PH4qAXHdFlbz+WlSmfhiVV16JZjyGLr9/hMj56ef6mc5b5j1WnLEOh5+3iVQvTq9rzeuwiGx6rK/IH/8v5bXCWdoV+03IE6HZ8j/1lMtHvSSP3V0lM6aFZfasiHz7dUTe/svPMu+4zcvwel/577VniHz9q9bXnTdOfnrzkBaPocm33/y/74tMPaHlzyG2fMYtR0pw8jEiDRtFwo0ic2/Mun/Ki8iXPzhGznC/JxeeXie//L+g/OiUWomca8mDXCOjS1fKySeG5eQTw7LvSdeLYxxy35FmW+uKzPmznIesYYhcyrNSQK148MmPXZNEzkOiIJcxUbzUyYl8ICNvt6THOLdUesw27jw6w76R/N6uvUQWsJ8MYY0UUS1P8MuM+9HRoz6VWWeOE7EQ+QMi/0SkX/Z9bt6Fv5CTeF/69wrIiOERGe5al3Hdc2/J0N79S5EMKdwgCxemfqWfPHJH4jPOcGwu+Kv5vBiPXHbNWJH3j8y6bvJtzOUny/77p1epTHXq05vHyj77pK+aabujbugh8lrvDCunn7dserSvuFzpq65+aITIxvdTF77eN+Px/djhH8tTT+VWtvcnjBb57Sk5xS8ERC7pk+FtMFOk5VhP/GaZ9bOzLOsC4Ici8svY40uBw0Tkd0nrvAPcJSKfxR5/BPxZRGZl2+6YMWNk5syZbY9i7Qzjx5uBpcnGjTPLc3DiiSZJ2eWXp/8vEA5QG6glz5FnkpS2IQHMuHFmaND116fmwSh9aDyOOyZkfkKOZc5ZuAHLmY/UrQGJwtK/w7J/mLHdP842bimhthb22svM+LP33ttZhvJp8N39cPA94CyB7+4ntOhhRl1fxr9eHsDo0WaYhgiUbdvAqCfN9ah9e+3LqupV+MN+njv3OS494NLsr5F0lTKrtW/Alz+DQWfAoHOh4gvzWeT1afcksY9++yhXT7maUT1HcdlBl3HTxzcRkQgLfr2A/fvs366vlZV/C2ydBe5Sk/Nk5URY/a/Ed59cKUWwLPjb5/exYtsKBhYO5Iy9zmDTnIOIRCwKCxNdkO12GPthah0O4sRNkJoa05U3foUmuStvJBrBZtmwYkPg0vZZSOwDyd/nkgchVAcDTjfLlz8BK5+EXkfDyenJv5ubPdvM8rZwYW5JvTdtMuWPRs3LWxbYInUM6LnV9IKRKCx9iMjSx3jpq8vofeZEXC5z9dJmg+LwTA7o9zHOPmPM1bnVz0PZi9D7+3DSp60XoAXxnkhx27aZET3B2HD0eG+u5MSJyS67DA4/PDbTTIwI9OmTOowgGoUDDjBDYH7wg8RsSOHqVXjXPgADTzdXrlc+A6ufNd9FuB4a18OIy8CWx7Kpr3LKw7P54KN8+vQh1sPQlLV3tq4oXcHqF+CbX5mhEcX7wMZ3Mx5jPvoI/vxnmDLF5OeIj9BKzp+0vZrXk2wqfBX0uc/kSDh5xMnML5/PZt9mZDwtb6D58bb5/mwBd/4CrvwtSMSst/JJWPl0+vFHhGg0SrmvnA11G/A4PAwoHMBVl5Vy2GHwxz8mNjt1qvnMZs9O7Jtg6lXGOm9ZzJopiJDoyWeFeWPbOO758k4AbJaNcceO48bv34jdlmXH2R219psoUXhvDPQ6Eg6+16xnc8LrfcxMUbn+JmaqbG05vmcwaZKZ/ee22xLnBpYFvXqZxykW3g7fuzmxrfnjzSxXvY+Fk6al/c6llDu+LFOismLgrgvg3F8DUVj1b1jzfObj+ILboKEMDvmH6UH55kDwx6ZVH/uyOV5a5sdw3X8GMWSZSWRy6/G38vaSt5m5aSYyHvYcKbz2mjnnEjH5qYYNy1DeZLmc++xGvlr/FUdOPBKHzcG5e5/L5KWT8Uf8fHjph5w44sSUdUMh2LrV7Nvx85OKCpM8uLbWLItfrP/1r+Gfj1tIVLLnpWvts8xSr78e9wv+OnwVC7csJM+RxxWjr+D6o6/HZXelbjcahcBWkLB5je/ug6VmevNcz8mbtpfL9101D3ocBJs/Mb3jVz9n6nCvo+D4d80xAIHJe0Ngi0l4fPD9Jl/Zqn/B6n+3y3lLSrnBlL21Y0Tz58Xfbyvf0a9+ZXqBPPpoIqWD05mY3GV3NncunHyyGTJ5wgnm/UUipici0OpnU19vUl7cdJOZ2CP50Ffaw0pdkEv9amVdv9/kZHI6zblpfPOjRqUP8/P54IsvzHtJPvcePTrDEOpoGGqXxo6pYVj6KKz4J/wkSzkz1amGDaaNZNnMfrD8cXOO0pb9sINYljVLRMbktG4OQaEjgfEi8sPY478CiMhdSes8AUwTkZdij5cCx0kLw8d26aBQO/H5zLAPkcTsN11Brr8fLQkETGPZ7zeNO6/XJIZtS9LXZJs3w/Dh5jNvHmc766WzmLxsctPjPHsevht8LQfkWjuQRUPwei848C4Y/jNwFkDYB/+JtYQvad8TqmAkiPv21LPXft5+bLpuFxj8nuXH2EJ2qJ5UV5t8WPHEffF6d/HFZn/KSb9+UF6euqxv33aZjaSqymwmGDQ/SCUlO1aHO0OmfXnbNpOratu2RGAhGjXJP9MaUDmqqTHTtPr9qdNjZ7X8cVh0N5zyNTiLABsTfnwHG3uM58G/29qUB2i3FqqHtwbCkAvgkIfNyf+rsTO2ZseYU081ORGuuqr9i9GWY/65L5/LW0vfSlnW5qBQW7ThIs7WrSbhZ2OjqdN1dSah7TXXmFxTBQVm+fLlWS5atMeP3+4m1893/X9NwP24d1LzEk2Kfbe5/ia25TPuqOO7ZUH9WghWmX3O5oLifc0Jf/OgULbG6I7Uk+WPw+apcNTz5gLM5JGJoNCP/bGhMDQFrL5XZrEwmPR6AjIBZs8SDjggc16U7hIUAuh9b28qGxPpAgqcBdTdkD5bXyaBgEnYfuedcNJJiRmkFi6EsUdbTH5bOOooc07S0NDsAkV7fpZtCXq0VVv2uV3hGLiDF+5zDQrV1UHPnub8pSvO6nvSSeZ8+pJLspxT70j9zXQinO3YvKPfZ0fZFep6O2jvoJADWAacAGwAvgUuEZFFSeucDlwNnAYcDjwsIoe1tN3uEBTqqnbV/eTaa81J/333md4lYBI29+sfoce9PZqSla343Qr26LFHC1ui9YPh5o9g5u/g1FmpOVbaegLcBg9++SDXfnAtJe4SqgPVzP3VXA7sd2C7v0572SXqSQcGhbqCnfkdXXONubJ0//2JwFAwCKWlGVZ+73DY43IY8XNzpRyYfvOxXDv5PabN8OBymQBVOGxO2rvCVbuM1r0Fc/8Cp84GRywSluUYc/vt5irao48mPo9wOEuDsI3aUk/C0TDeO7wEY7OfvP/T9zl55A87aQu/UgAADQhJREFULijUDsrKTG+hujpzFXHgQDMTUtp57S5xUNtFLb4Xar6DMQ+DszDRwwY6ptcCdGxQKFsZsvUUyvX5uVo/Gdb+B9yxnlZhn7kSndcbDrzDXN0GsDkpq69g2EPDcNlcBKNBrj3sz9x/2r3U10lKj82M7yNb7zzYNRpm7WB97XoGPzgYu2UnIhGWXb2sKcF/LiIRM3HBF1+YY6rNZo4TN95ksWG9sHKlCRZ5PKbXs+22ndRzv73sbkGhHZXtyl2zY4ffb4JCq1aZYF/8OnI02jVm+R0yBF57zfTyyWhnBYV2VV2hrtPOQaHYBk8D/g7YgWdE5A7Lsq4CEJHHLcuygEeAU4AG4Oci0mLER4NCu69deT9ZsACef950+bUs03Nj/HhYWDmXg584mHP3Ppc3fvxG6xtq7WC48A6oXw2H/N30EnqjX+JKHnRIUCgqUey3muEIF+9/MZPOn9Tur9GeduV6ooyd/R199RX861+mKz6Y4O0//tGsO69E4WUXnLvRDJOCpv1r0ucXcfeMl7jgAtMzcPNmeOklmJV1oPJu7usrTK+Ag+41QaHk40yzY0woZHoJrVsHV19thsasWmWmw91Rba0nM8pmcMyzx1CaV8q267dl30BHXv3uCHpQy67yK1NfT/7S/CbGhX3pM5q1ZFf4jLdnCFtrz28PImb46MqJptcSYo6XYydx/cfjuPeLewFovLGRPKeH/00WTjgh0cshGATXkAyBNNj9GmxtNH7aeCZMn8AVo6/gyTOfbJ+N7gp1tT1oUMjIsA9MnGhmpvvXv2A/MzEkCxfCgbvu9dic/fKXZqj/jTdmuZC0o0GhrlBPdvf3QAcEhTqCBoV2X7vrflLtr6bAVYDD1sKl81yvPC6YAI2bYfT96Y01bHBJx0wBGe8ttPHajfQv7N/6EzrR7lpPupNd8jsKN8KrhXBhQ1MvocT+ZSN8YYQVK8zwtqIiGDmyDcMJdzfvHw77/BmGnG8eT0o6mc0SeF6/HmbONIG3nj3NsLIdvaq5PfXkiW+f4IQ9TmBkj5G7aEXbDl3lfXSUry6HuhWmt1DBCDP8at44OOrZ3LexK3zGO1qGTngPtYFaiu8u5pcH/5KnznoKLIs+vYW77zbTWdtsJu/YOVd1z6BQIBzg0jcu5amznqI4r7j1J+RiV6ir7aE7BoXa8B7mzIGnn4YvY7OoH3mkmRI+p6Hwu7AtW8zQyPPPNz25vV7TY/bkk2MraFBo938PaFBIdbAusp9klmtQaM3LsOxRk1wv+apoqM50nVddu550EbvkdyQCr7jhrFWQP6j19buy98bA9yaYxLKQEhzrqMBzJjtcT4YNM2O0lFJK7VqGDoU1a3Jbd5c8aWijrvAe2kl9vekF9fLL5kLSoYfCxCn9sHY0cNwVPuOu8B5oW1CoHbINKNWF5HrAG3gafHUZ1C6GkoNMj4ZoxMyYpEEhpbafZZkZjNa8BKOuTuTsigZNwtfuJK8fVC+A/j8Em6PdZzXcaXJtcCillNp1DR26e82mkU1XeA/toAD4XewGwMIWVi4vb9vntrt/xkOHdnYJdroukCpLqU7gLIK9/wCfngdrX4FAJZR/BFN/0NklU2r3t8ev4Lv7wbfW9L4L1YO/svXndTUDTjOzEEX8nV0SpZRS3d2aNab3hN701tVv3fBilvYUUmp7HXC76Rn0zZVgc5ueDP1O6uxSKbX7G3YxrH4W3jsUBpxqeght+B9cUNXZJdu5BpwCc66Dyi+h91EmYW9bE/cqpZRSSinVAg0KqTbrKr1Hd5wd+Efspprrhj0vVXuxLDj2f7DkQVj6oJl+ec9fgURjs+50EwUjYPCPYMZ5sPf/g55HwvLH4Lj/dXbJlFJKKaVUF6GJppVSqpvqInn0urZQPcw4Hyo/BwGIwo8bdmoRtJ4opZRSSu1eNNG0UkqpVmmvv91BAfB+6qKLdm4JtNefUkoppVTXpUEhpZTqprphHj2llFJKKaVUkm6UnEEppZRSSimllFJKxWlQSCmllFJKKaWUUqob0qCQUkoppZRSSimlVDekQSGl/n979x96V13Hcfz5wqU1xTSWZW40i1mpmIqJJf2aRUYy+ydYZIyKIjHT0S+XUPSfaFT+UYHomtBQTFeNoHJY1F+b2dR0LXNo6VdXm0Q/KNJW7/44R7xs3yve73T3c7jPxz/fez7nftkHnt97v+d8ds73SpIkSZI0g1wUkiRJkiRJmkEuCkmSJEmSJM0gF4UkSZIkSZJmkItCkiRJkiRJM8hFIUmSJEmSpBnkopAkSZIkSdIMclFIkiRJkiRpBrkoJEmSJEmSNINSVdP5h5O9wB/n2bUEeOIQT0cHz27DZbthsttw2W6Y7DZcthsmuw2X7YbJbsM1X7tXV9XLn8s3T21RaJwkd1XVWdOehyZjt+Gy3TDZbbhsN0x2Gy7bDZPdhst2w2S34TrYdt4+JkmSJEmSNINcFJIkSZIkSZpBLS4KXTftCWhB7DZcthsmuw2X7YbJbsNlu2Gy23DZbpjsNlwH1a65vykkSZIkSZKkF16LVwpJkiRJkiTpBdbMolCS85M8kGRXkiumPR+Nl2RZkp8n2ZlkR5LL+vGXJdmS5MH+67HTnqsOlOSwJHcn+VG/bbcBSHJMkluT/K5/7b3Zdu1LsrZ/n7w/yU1JXmy3NiVZn2RPkvtHxsa2SrKuP2Z5IMl7pjNrjel2Tf9e+Zsk309yzMg+uzVivnYj+z6bpJIsGRmzXQPGdUtyad9mR5KrR8bt1ogx75enJ9ma5J4kdyU5e2Sf7RqwkHPvSds1sSiU5DDgm8B7gZOBDyY5ebqz0rPYB3ymqt4AnANc0ve6ArijqlYAd/Tbas9lwM6RbbsNw7XAT6rq9cAb6RrarmFJTgA+DZxVVacChwGrsVurNgDn7zc2b6v+d95q4JT+e77VH8vo0NvAgd22AKdW1WnA74F1YLcGbeDAdiRZBrwbeGRkzHbt2MB+3ZK8E7gQOK2qTgG+2o/brS0bOPA1dzXwlao6HfhSv227tkx07r2Qdk0sCgFnA7uq6qGqegq4me6NRQ2qqt1Vtb1//A+6k9MT6Jrd2D/tRuD905mhxkmyFHgfcP3IsN0al+Ro4G3ADQBV9VRV/RXbDcEi4CVJFgGLgcexW5Oq6pfAX/YbHtfqQuDmqnqyqh4GdtEdy+gQm69bVd1eVfv6za3A0v6x3Roy5jUH8HXg88DoHz61XSPGdLsYuKqqnuyfs6cft1tDxrQr4Oj+8UvpjlPAds1YwLn3xO1aWRQ6AXh0ZHuuH1PjkiwHzgC2Aa+oqt3Q/fACx01vZhrjG3QHWv8bGbNb+14D7AW+09/6d32SI7Fd06rqMbr/LX0E2A38rapux25DMq6Vxy3D8VHgx/1juzUuySrgsaq6d79dtmvbScBbk2xL8oskb+rH7da+y4FrkjxKd8yyrh+3XYOe47n3xO1aWRTKPGN+LFrjkhwF3AZcXlV/n/Z89OySXADsqapfT3sumtgi4Ezg21V1BvBPvOWoef293RcCJwKvAo5MctF0Z6XnicctA5DkSrrL7jc+PTTP0+zWiCSLgSvpbmE5YPc8Y7ZrxyLgWLpbWz4H3JIk2G0ILgbWVtUyYC39VenYrjkTnHtP3K6VRaE5YNnI9lKeuXRNDUryIrofyo1Vtakf/nOS4/v9xwN7xn2/puJcYFWSP9DdorkyyXex2xDMAXNVta3fvpVukch2bXsX8HBV7a2q/wCbgLdgtyEZ18rjlsYlWQNcAHyoqp4+GLZb215Lt4h+b3+sshTYnuSV2K51c8Cm6txJd0X6Euw2BGvojk8AvscztxnZriETnntP3K6VRaFfASuSnJjkcLo/jLR5ynPSGP3K/w3Azqr62siuzXRvLPRff3io56bxqmpdVS2tquV0r7GfVdVF2K15VfUn4NEkr+uHzgN+i+1a9whwTpLF/fvmeXT3gdttOMa12gysTnJEkhOBFcCdU5if5pHkfOALwKqq+tfILrs1rKruq6rjqmp5f6wyB5zZ/w60Xdt+AKwESHIScDjwBHYbgseBt/ePVwIP9o9t14gFnHtP3G7R8zvlhamqfUk+BfyU7tNZ1lfVjilPS+OdC3wYuC/JPf3YF4Gr6C4X/RjdydAHpjQ/TcZuw3ApsLFfOH8I+Ajdwr7tGlVV25LcCmynu4XlbuA64Cjs1pwkNwHvAJYkmQO+zJj3x6rakeQWusXZfcAlVfXfqUx8xo3ptg44AtjSHUuztao+abe2zNeuqm6Y77m2a8eY19x6YH26jzp/CljTX6Fnt4aMafdx4Nr+AzH+DXwCfM01ZqJz74W0yzNX1EqSJEmSJGlWtHL7mCRJkiRJkg4hF4UkSZIkSZJmkItCkiRJkiRJM8hFIUmSJEmSpBnkopAkSZIkSdIMclFIkiRJkiRpBrkoJEmSJEmSNINcFJIkSZIkSZpB/wcw192GGgBQxgAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2261,7 +2133,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2273,7 +2145,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2290,12 +2162,14 @@ "tal hits:\n", "\n", "gata hits:\n", - "\n" + "MotifHitAndCoord(motif_idx=1, motif_score=0.9981404370073454, precision_at_motif_score=1.0, example_idx=8, start=50, end=75, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=1, motif_score=0.9997666971054194, precision_at_motif_score=1.0, example_idx=8, start=96, end=121, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=1, motif_score=0.999439902805966, precision_at_motif_score=1.0, example_idx=8, start=158, end=183, is_revcomp=False)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2314,7 +2188,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2326,7 +2200,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2341,14 +2215,16 @@ "output_type": "stream", "text": [ "tal hits:\n", - "\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.6473985105327982, precision_at_motif_score=0.36530999962121485, example_idx=9, start=91, end=116, is_revcomp=True)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.9985691044998529, precision_at_motif_score=1.0, example_idx=9, start=100, end=125, is_revcomp=False)\n", "gata hits:\n", - "\n" + "MotifHitAndCoord(motif_idx=1, motif_score=0.9970444216566418, precision_at_motif_score=1.0, example_idx=9, start=20, end=45, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=1, motif_score=0.9977360701996126, precision_at_motif_score=1.0, example_idx=9, start=158, end=183, is_revcomp=False)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2367,7 +2243,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2379,7 +2255,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2396,12 +2272,12 @@ "tal hits:\n", "\n", "gata hits:\n", - "\n" + "MotifHitAndCoord(motif_idx=1, motif_score=0.9987752343034744, precision_at_motif_score=1.0, example_idx=10, start=134, end=159, is_revcomp=False)\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABI0AAACMCAYAAADx21mCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOydd3hUxdeA37slvZEECD10CL0pXSkqYAFBBRsWFLt8Vixogr13sSsWVAQVkaooRemdECCEXhIgCel9d8/3x2STbHYDiQQC/Obl2Se7y+zcuXNnzpw5c+aMISJoNBqNRqPRaDQajUaj0Wg0ZTHVdAE0Go1Go9FoNBqNRqPRaDRnH9popNFoNBqNRqPRaDQajUajcUMbjTQajUaj0Wg0Go1Go9FoNG5oo5FGo9FoNBqNRqPRaDQajcYNbTTSaDQajUaj0Wg0Go1Go9G4oY1GGo1Go9FoNBqNRqPRaDQaNyw1XYATER4eLpGRkTVdDI1Go9FoNBqNRqPRaDSa84b169eniEjtk6U7q41GkZGRrFu3rqaLodFoNBqNRqPRaDQajUZz3mAYxv7KpNPb0zQajUaj0Wg0Go1Go9FoNG5oo5FGo9FoNBqNRqPRaDQajcYNbTTSaDQajUaj0Wg0Go1Go9G4oY1GGo1Go9FoNBqNRqPRaDQaN7TRSKPRaDQajUaj0Wg0Go1G44Y2Gmk0Go1Go9FoNBqNRqPRaNzQRiONRqPRaDQajUaj0Wg0Go0b2mik0Wg0Go1Go9FoNBqNRqNxQxuNNBqNRqPRaDQajUaj0Wg0bmijkUaj0Wg0Go1Go9FoNBqNxg1tNNJoNBqNRqPRaDQajeYcJSM/gyJ7UU0XQ3Oeoo1GGo1Go9FoNBqNRqPRnKOEvBrCuNnjaroYmvMUS00XQKPRaDSnEYcNdn8O+cnQbCz4N6npEmk0Go1Go9FoqonswmwA0vLTargkmvMVbTTSaDSa8xV7Piy9CpKXg6MA4t+GkUfBZK3pkmk0Go1GozlbiIiAo0fdv69bF44cOfPl0VSJhNQEAPam7a3hkmjOV/T2NI3mbCAiAgzD/RURUdMl05zLxL0Eyf8qg5HJGwrTtcFIo9FoNBqNK54MRif6XnNWEZ8aD8C+9H01WxDNeYv2NNJozgb0YK2pbuz5sONtCGgKg5eBNQg2PFrTpdJoNBqNRqPRVCPbk7cDkFOUU8Ml0ZyvaE8jTc2iPWw0mtND4gIwLDBgIVhrKQ+jzi/VdKk0Gk0leGflO/y247eaLoZGo/lfoW7dqn2vOatYdXhVyfvcotwaLEnN0/r91rSf0r6mi3HeoY1GmppFe9go9GDtQl5RHoO+HoRDHDVdlHOX1DVQu5/yMDIVi3qTb82W6VxFG7c1Z5iH/niIEdNH1HQxNBrN2YrDDsfXQ3osiJx6fkeOqHzK5iWi4xmdIyw/sLzk/a7ju2qwJDXPzuM7iUuOq+linHdoo5GmZtHGEoUerF1YfmA5f+/7u8TdVvMfSFkBEYPAHFD6nUmL/P+ENm5rziBF9qKaLsL5gTb2as5X0uNgXntYdDEs7AmLLgKxn7nr6751ViEi5BTlEO4bDkB8SnwNl6jmsDlsJe/1wnP1omcQmprFaSxx4jSc/I8aSzSKZQeWAfDPgX/UF/8DCsrEPydiTDaqL8PMHRDes1oMRdNjp7N47+JqKNQpIAJ5R6DgeM2WQ/O/hyf5cxplz+ajm0ve/69vMzgltLFXcz5SmA5/XQRFWdAhGqIeh4ytYJjd054u3Un3rbOKpOwkAJqHNgdgR8qOmixOjRJ3rNTD6H+5Hk4H2mik0WjOCAnHEwh+JRi74+SrYT/E/qD+blV/q6SgnKMGpu9jvwcgOSe5ejK054Nv9dzzmF/GMPCbgdWS138iZRXM6wC/RcKv9eDvy5Rr/pniLPKIjDsWR+8velcucfY+2PQErLod9k8/s3VWU9hy4fA8ODwXirKrJ09PcuY0To5WHFxR8n5d4jr15gwbrs4LzqJ+q9FUG3Evg3c4XB4HrR6Eto/DsFjPaU+Xced871unW97aciHnINgLqiW7DYkbALAXe5st2rOoWvI9F1l1qDS20+pDq2uwJOcf2mikOXc4R40BHkleDkuHw5woWDYSUs5/wfbN5m/ILMh0mRB5wu6wsyttFybDxLL9yxCRqiko5+gK2KGsQwD8uefP6slQBCjjufRLBHxvwPceViNPQFJWUsn7yhj8qp30OPhrMIS0h0tXqMDe9lwwVe0+TomzaPvomyvfZOWhlexM3XnihAmfwty2cOxfKMqADY9A4XnupbXnG9XO19wNa+5VBkZbNXjqeJIzp3Fy9MfuP0ren0xeak6A9mTWnI8cmA6dXgKLP5i9wOIL3qGe054u485ZNCaeU9hyYPV4+DkM5rSBn8OVx9gp4lxgdRqPVh5aecp5nqss3lfqFb9k/5KaK8h5iDYana+IQwmi82k/5zlqDHBj+9uwbBQEtYXOL6sj0QMia7pUp52vN30NwLdbvj1huq3HtgLQKqwVAPvS97kr/1CxgnIOroCVDVro9LI6ZUxeyo3dSb6zn1RNJsxLmFfyfs3hNdVQsCqy/kFoehNc+DmEdoW6F8OABZ7Tnk+G5QqYsW2G+hs3o+JE6bGw8VHoP0vV1YVfwhU7wKd25S90rtXlkUWwfgL0/AKuSoCrdkLv78DiVw15ezA+nMbJ0dyEuSXvF+5eWCNl0JxniAOOLoWtL8K21yBtS02XSFNZ8pNh16cQ+zwkfKbG8nqXgslSmsZcwSEXFRl34NyR7TXB6ZC34oDFQ1TogEtWwKhj0P83sAaeWr7AlmOqPzuK9bsiRxEOx3k0/6sCZXXW+Qnza7Ak5x/aaHS6OdOKd34yrBgLvzaGP/rArMauE8dzmXPQGOBGzn7YOhkGL4YOz0LD4dDxefA5h+7hP5CRn8HBzIMAfLbhM+U9VAG/bv8VgCCvIAB+i6/isdNVMTCdJTgHNi+zF3MS5lQ9eJ8nObMjBY6vq/AnInLC5+BkWuy0kvdVfhanSlEmJP+r+oilTEBvi/+ZLcfppApu8Cm5KWQXqi1Xryx/peI8d34IkTdCeB+wBoBXsPpbjRw5AvHxkF1NO8BOmc3PQMfJUP9yMHurV8SlNV2qKuMM/m81WQFYsm/J/6zyf15zmra/iMDatfDMM3DHHfDmm7B/xxGY2wG2vQomKziKYPU4KEyrhhvRAKdvO9POD2Fue8jarTyKji0G79pgWE7+2xNxhrfcaoAjf0H+Mbh4LoR2UXpMnYuqJetDmcpTPcArAKPYw3x32u6qZXIebIE+lHmIrMJSz63k3GSOZR+rwRKdX2ij0fmELRfmd4HgtjB8F1z6L1y1C7xCarpk1cP54Gq+eyo0vAr8GpaugFfHSvhZzm87lLGhS0QXANYnra8w7YfrPgRg45GNALyz6p3TXLqa562VbwEQ7B0MwPxd86tmcPak7CWgVpadrs9lDJM2hw3TcyZqv35iz5PcolwW71uMt9kbgE/WfVL1mzsVcvaDXxNXg9GJOBdd5qugvM/cNhOAtuFtyS7MZl/aPs95Jv2hvLNOxVBUgfH1lylHiIqCRx+FKVPgmmsgNfW/X6ZasOcrA2nTW1zlqaWC1fezmG82fwOolWInJQcCaM4fTsOkvagIrr5aGYwuvhgefBCaNIH6e6+DhiOg3wxo+yhEPQGDl4JXrVO6nuY0k7Iatr8FQzdCh5jiZ/ekkndlg17/l63nZ3jLrQbY9x00vlYZbp1U0zZ7S7ER8fOrPqddnXYAHMk+i/We04QnT/3pcdNroCTnJ9ViNDIMY4hhGPGGYewyDOMJD/9vGIbxXvH/bzEMo2t1XPec4ExOYnZ/DnX6Q6sHwOwD1iD1txoQgY0b4YMP4KWX4J13YNEisNlO/ltNGbJ3q21pTnfUkw32Z9jyv2IF3H473HwzjB0LY8bAd99BYeGp5fvYoscAiEtWpxpMmD/BYzoRITVXzUB9LKrtOldQzlcy8zPZl7EPUKsiAG+veLtqmXhS9vYAu34p/TyyVOZ8tv4zAFLzUks8Gzzx4RplwCsoDtaYXpBeGpj3TGDyAns2GGWGqv8Ym+mspQrK+5OLngRUUHmAR/54xHOeYgeTd+nncnWWmZ9JVkHV4yjMnQuvvALLlimD0UsvwYwZEBZW5ayqF3sBYLh6oJ2j7cRpLDeK/wEsP7i8JoukOR2chkn7xx+rwzJ//hkGDYKOHWHEpYewZm2BjjGqfxgmNVH9H1isOqN4WtSEU9tpEP8OtLhDbSt2GsCD24AtSy2ouFEFj0S93fXMU5AC/o1L52XVNEYV2gtJyUvBZJi4Luo6Lqh/AQDxqfEV/iazIBNjssHdc+4u/fI8aBPOe/Y2e+Nl9gKKT1A7D7yozgZO2WhkGIYZ+BAYCkQB1xuGEVUu2VCgZfFrPPDRqV5X44HMHeDXSE204D8aJOpC8grY9qba977tNTJWv0ufHhksXy7cdBM88QTcdRfk5kJ6RTvf8o/BsX8gcSEcXQyZO8+9+EoxMe71ExNzankGtlSBfZ3eH/8xzszpICYGPv0U3n1XGQffew+mToVRo8DL67/nm1eUx7Ec5R7qFOLrkjwbHnan7UYQwn3D+fbqbwnwCsAudo5mn79u08v2LwOUkaxBYAMAdqTuqNiz7u673dvl3Xe7p12UAl5FsPIW5YVYfJLUURvcO+/ekqTDfxheYdkW71UBBa0mK5bi+Anzds6rMH21E9ACbHmQvgXctuicYp85W2L2VHKykeZjkF6gBK7ToFph0PTwnnDwF1V3LjjYm7aX4FeDCXolqMRAW1lefhn+7/8gNBSCgsDfHwJPPRzDqWMNAmtwBdsxa162VgVn4Pmlty7l/aHvA8Vx3TQnZcuRLbyz8p2qb++tCU7DBO2XX+DKK1W/dGIhp3iSWuZaJ9INRdRplTs/hPj3IP592PkRHN/o7nmoOb0UZaoFRqdnyi8R8KOX8jTa8Xbp6ZAjz62J/f8stbqo7fZup3qemrzafVxtQ6vjXwfDMGgZ1hIojQ/qiVHTRwHwyfpP2Ja87ZSuf1JOx1yqApzxQX8d/SszrlVxH3el7TrRTzxis0FyMiQmKk9qLfoU1eFpdAGwS0T2iEgh8CNQfhYyHPhGFKuAEMMw6lXDtTVlqTdUCSQpKvcfVRBID6RBVgK0vh9a3AUtxvPV8ntp2jqIO+80CAlRK1m+vnD55RAeXu732ftgYS9IXQO1OkHEIAjvpQa5woxTvMEzTEyMu1J3qoKu2a2Q+Dtk71WnKJwsltEZtPy//TZMmqQmgcHBEBICPj7qWZ8KzqM/u9Xrxpo71hDmG0ahvZD4FPdVEKcBpXej3gxvM5xu9boB5/f2DOfEf1K/SeydsBcDg8NZh8nIr6C/VLZdeodBo1Fw+HdY0BWWXQXAneXsbwlpCfy87WePl9p0dJP6e/cmfhz1IwBLDyyt9L2dMiYzNL9NnYZly1TK1pUnOTXsLCe/KP8/TWrnqbjw9GvcjyW3LMHL7EVWYZZnF/RW98HuLyD3oDJQj1DeevGF0Oy9ZiXJGrzVgOO5lT9RLTISDhyA/PwqF//0YhjQYjxseFTdr70AhpeuxNscNubtnMehjGKvRU9K7GlUZJ0kpCacML5Ckb2I7SnK869TRCc6RXQCVFwjzYn5fP3ndPqkEw/98RAt3mtBSm5KlfPILMjk8T8e58uNX549hidxQMZ2SFwAh+bAod/V68jfkJfkkrR3bxXPKCenzJeBLcHiA0mL3E8SvNfh2v4tBrxrhYLj0PxOpa80uwWaj4OgNipNZajqJNFeoBYacxMh72j1nHh4NnCq8RWb3gL7ZyhdsTx7voY9X4G9EOzlFwc0p4PMTOWNP3++8rqdNw8WLoQtW9TW0JPS/HY49JuaYxVln9zYV8l+FJ8aj4FB/cD6ADQKaoSBUeK1Wp47Z9/Jor2LSj63m9KOnEIPbay6OB1zKQ+ICBuS1OlxbWu3pW14WwDWHV5X6bnUihVqoXzmTOUUYbOpZHnV1MVEhO3J28krOjf77ClGUgOgAXCwzOdDwIWVSNMASKKKLP3kHVpf0Apv31LXWnPuLrL2rSY1+CZy8gOx2w38fO38vfFtene7gLYNlOIVl76b9dvjWXFsCZa6YQR4+ZFdlEu4TwiJO/cx07GqJE8TBp/WH8m4pikweIlrIba9RlFqHEd8bycxOQAvq1Bgi2dT/BxGDroFq8UHu8PO2tRt2NYdp2XLCOq2aI1z93h67K8U7Z5OXsTNJGfWJb/AhJ+vg6jguXhb8smvNYQt2wMwm4XIiGTi/lpAh8uucNkHu3BJKAcPOOg2MIogRyxgkGIbRtDWb7iAq7B0exWGbVYrEwB7vkb8mhC73R+73aBdqwxWPHINHYZcTljHYQCkbV+M7/rr8Apsg0nsas903EtcZv+Vj1av4cCBAOrVM7DZlOxatGgG9oLNXNJ1MADZRXkcSfyFHgg0uEKtcosdZjVh+55QCmtdROO+Y1yqctWs+bTr043GxZ/TdizBlLeHvIPLCW43kgNHwknLsNK+TQ4b5i6kRbco6pdNm3+QvP1/YWtwPcfSwsgvMBESZKON7/eY/OuT79+TLdv8CQ6ykVu4jbVxfzJqwK2YzF44xMGalDiK1qbQOqoxdSKbl5QrOSmDA+uW0WnIUGqXud4vc2uRnWOiU/8O+BXtwG7yJz3Ll5wtX9D/6guxltmqPOfPWhw/lkevvt5YyAXDICM3hIQ1L3G7YxCm5tdj6voWrLiRtbu7EbLwG8KbNC5pJ0kb/2Tj7Fl0H3EVdcqUYcVKSD6cSte+TbBalRLncBh4J35FUJshmKwhJOz1pWG9AjbFL6bQlsTA7leDYSKzKIetabtg6S46XzYYv6DgkvLeM9qf52I688EUCyIGIuDtrVzeW7dyEOa9C6sjFbvhx+bde8krWM7oQcOwWgzybAVsPL6DVbN607JZEFGt8zA5chDDymubVLyeoWFdiUg9ykW1O/HLgb+Z8OS/jIoy07ZTGH627dgNf77YrFYGOljrkLZjCV1867MU2PH9TBL6ZdGyTNtJ3zKdgj2z8Wt9HYdT65GaZqFF0zx2r/yH+s3CiCyTdt2fP7B03a+MGXYbft6+OMTB2tRtRBXuxqvQh/AOQ9i0NQCr1UFwyD5+//tHrr3sdrytasl2Q+oOtq3bTpPwAPp2HYxhGKTkpxN3ZC/W1bvocfVwrGXcsf5eXouEnQ56DG5PIAkY2MmgPZ98ajB6VC6RYTsxOXJwGL58v04ZY6LsPmQnLKdNUCTbM/fy+0sPMPCqa13ae/yGvZgLk2jaoyfhZb5f9fNvdBjcn4Zlvtu4NZANq8ZyX7eleGfuxpQZT5IN5uYABnzdZzLb0vfwatzXfP3XA/TeOQ9T5GiSUkPJLzCR67ubpOwkfExW6qYcgQI14B5LXErirFsIaXcth5Jrk5pmJapVDsHpP2HzbsyO4xeTmW3GahEahe4lwvYbaUE3sjcpnPwCE0EBdtoGTMfsE0Kmz0XExfvj4+2gVnARM2d507NfKD6mVEySj90UwNwl0dzdvD+1Z0dhbngZFGVTaLOy53gn8pfEYneoYcww4NDGpbRuJdRu3gbnAcQHVs0nbtFcug0fjrVMB419YRIhQTYaduhEaNRAAHat/o1f5n/FtRtmE+KnArFvPr6TzNh0GgWZaNypK86dWClxS3jpzVr0GRRBvQg7Pra9FJrr4W0/hGQl0KZbC7Yn+FNkM9Gq5XEu++F21knpMGjCxHthj9DdP5jmF/RyfZ4P3kj7i/vQqI9aDUzbvpj35jwAOVu5MqwLzTKz6B3egSVH17Nlzijyw8dyXLqRm2fGYhEyMoOpnXoJneZdiLmJiqGW54D2+9Szd1JgL+CqDzrwauDNmJtcjcU7EDAwDAeH18yhU896NCnTjybdMouBN1yMv18Q4+4w4eOjwrAsXgwWC9SpbSfAFovNCCQ13Y+ihO/ofWUPrGU0jZ8W/kbjesH07HgxAEfyUtlx8AB+cfvoesUVWMo8o18WzadOqBd9ugx07XNrivuctUyfWzuC3sav1J7TDUuza8EwcazATPd9Vg4+X0YwAx/Xepwe371Kky7dCWs3qKSO2TkFY+N34B/Jjl1+NGmYT/LuHVhsR6nX/sIS2Zy2Ywmy+zOoOwiHX2t27vGlbu1Cdh9aTlrWLi698BowzOTZCliXEscLS99nLftcyvBK2IP0s4bQqm9/zGbl8bHpeDw2h41giz/2vRuoX5CJCQPLQQdLP3iKqIsHuYxHxqGfKbQ2IbRFD7Zs86d2WBGNau2BpIUket3EoeQwimwGfr4OVm39gs5tmtEmsgcAh3KPkZaVQOu07fi3uRaLby127vGlQ9scVs5ZRf3IWgQ3bF1S3uPHstmz6i86D70cS5kHumnxBurU86Ze6yiMYqOCYcumaNc3eLccg29wGLHb/enULpuf5v9BWAj0iLoEDIPUggw2Hz3Esmm9GHRFY2qFWfGzxZNnaUlS3DoahCbSumsTTMVtNjs/jx9++4yRQ28kLEj1xK1pu/hgxY/8lP1XSZn2pu+l9uu1mWXcTY+hw1xkqDk7jpzErdTqMJzdB0LJzTPTunUqPb69mZ1SatAbN3scT3g/QdDRoVx4WQdMZlOxs44wf+Z++lyYScvW/hgmQQSs+bspOr6Dhl36sPdgENk5Ztq0yGXrnwto0S0K39D6JXkf3JVM+r5NtL14oMvzXDN3Kc07RhLWqLTXOba9TVjLrtAh2qX9LJ82jUZNUgkML41Ld/cV6Qy8tgdPWyOY+ISZ4GA4cMAgMf97+v1zJeYOEzE1vBwGLCB1xkAC7Tl4UWbvuQUcoWCE98JwFCgdcOuLZK57n42HetJxzNMuZfh9yV8E+BdyUfchmIqfZ9zRPViMZHpsWkCdzkPUvW1fjCVzPdm/P4it/jUcTfHH4YAmAWuomzkFLo8Fc52SfDcv+gdr7jbqtSptf3aHnS9//oihA4bTMLwRANvS9xBcuJ/w9KPU6jiCxGMhpGda6BiVzQPfRHMotIgg7xBsYsdkGHQuuI68re0ZMMiLAN88DLFjN/xIWLGUCwa2ILROqdvk2tht7E5cw6iBN2G1Wihy2FibEkeX3Fgsfm3xqX8BcfH+BPrbCTDtJ2XnOpr3HuwiI9bOW0bTdo1c9JYdf/5KUuwK2l9ymUs/Mo4u4OCRcPJDBlBks2AyCdlZzWmUYtDcMQxL58kweBnMac3Pa0bS6YJaNN3wJOYtk8BhIy0niNij/emwY4nLM9qybAuhodCgXYeSMfHQ2oVsmfc73a921S23rtxOoG8ejTp1KRnnDmycz/jZj7LF5ygCFImNFoGNuI9RtAv2p0nXbiVp03YsQRI+wmhwOfg3I363H43q57M5/h9yCw4yqMdIMExkF+Wx8fgOti1bztCLr6Bx7UgAtmfsZWvsLqyFKVx50XWYzUqGrk/dRtw/q7i09yU0rd8CgF1ZB9m8dSeSnciIAddjsVgotBexLnUbW/9ZQ//uvWjTpD0Au7MOEbt9N3mpe7hm8M1YrRZsDjtrU+PolBuL1aclQZGlcwU/DpMUt4aWfUuf587ly+k4qI/bgknS7kPsXfoj2V7dXb6fOTuEvHwLPXoH4eVIQrBwJKsJx9a/xFj7IMyRIzFCOwOwZnd36iz5hpB6jXAO0JnpuWyzJtNty0Jqd7ystB+lryR77iPY6l3NkWNqRXfF8XkIQkOTH2k7lhCSnoJhGNRN30jSnAmEdbqSnbuDKbIZ+NTbxucbPwegf52u7Mo6SGJeMtGv38n1jTrSpPsFLrqI7PoYo94Q8iyt2HvAh7BaNvYkLiU7bx+XXDAKDBO5tnw2pu4g7p/lXNJnKE3rNSt5ninxGdQuyKBl774u+X7waS0atQimRZsQ/GzbKTKFknioCL+sJXQd2B5LGSfIb2Z9Q7dOnWjXtFPJs0/Y603c4hb0HtKScP9ErI7j7Lb5kV2YjcWwEJi0B4cIFsNM4HFf/njrYbpcOsxF3pqOziO/yJ+CWpeSdMwLq0X48MPadOnWmDFjSue6IrD2l5lE1CkiJKLU32X7dgcPxnTn59mBLh7Xzz6UQL3mDbnmOu+SMfFg8h5u+qMnR8yl3t0Ww8xfPW4msiCUtKBrycn1QgT8vQs4vmkanYddgWEpDTGzbU0CvuY0mnTpjslU6vOzasZMOg8bgo9/aQzLHRv2YC06SmT3CzGbS9NmHDtK4mGh9/Wuc/FK4zxB57++gGuBz8t8vhl4v1yauUDfMp//ArpVkN94YB2wrnHjxuLGyJJNGiWvJ9u/IPffUyRHj9ilqNAhdptDjqcVCjG4vfo90cTj955eV905VOwL+okU5YrYC0U2TRKZhsQOaic9rWtk3NgC+eT9PHnntTzpcv8lQgwSfbEq0/sXqDxkGiKFmarsdeuKhPnLnrcj5dJWm+T9d4skId4mhw/aJS7WJvYRyLNES7hvllzcI0v6dsmSi5ovEZkZ5vJ7mYZEWx4ViULkPUQ+V699zzaWaJ4V6YLI/yHyIiJTkeThyGHqSV+WiR/Z4k+WXOi9QpWtXL4v171BZLAh8kEfkd9vF5lzh8h3XpI0rK68zES5NWqV3DVwp9zRfYPUe8ZXiEFWN1D3fPMIdc9T290s8mhTkV9vEfnzIZHvfWXZs31EtkS7Xc+lDHXrimyOFpmG7Bo9QnqwWvzIliDSJYBMj2mPTKkjl0cul4fuL5RlfxfKutVF8tO0QpGRyByGSm2OSiDp4kuONHuwuRjRyHcdVHm/b48Y0eXKACJh/rIy5gKReV3d651oleYqRL5C5Etk06AOIrOauKXdH91AZO+PIgUZIg67iMMmW9/uJy9ao0UiEbkPkRdUPvvfry9ybLlLHsc+Cvf4jGQaIll7S/tEcZ3ZrjbJw7wuvuRIEGniQ66ERlvFiEbiaqt7vmEkQjQe+5E8gKwc+YCM85oqN3faKGN7bJMxoQvkh27XiXwRIbIhRmT3jyLbPpJO0bWEGOSnKPXbcVciwc8hCU+1FYl7UyRzj0hBukjeMRn7TKR0f9JXdtVSaf9pjHS8G3kt6BGRJxCZ3VVk2TiRv8fIHdCr/GMAACAASURBVJOaSdcnvWVbuEq7IQLpfJfnZyTTkAUDb5TG5oNyxeBcuX1MtvTolK/S2vJc0t4SEyHEII9eovL9onNx/xyJ/EMfacw+CSBT/MmSpmMuFSMaebGfSru8kaozczRieQbJtqrve45Dmj3aSOR7i3s78blfxILI/aqNyJdI2oNBsv2xDiLrJoqkbBTJ3CuSGisj7vOWAWORLDVeyJedVf14evZrnususnNKpfrR2H5TZcnF0SJBiExAJBpJ7IF0eRx5cqC6VqEJGXYD8tOz3nJ/1HTpd4GSZ198lC+33r1Huj2OTBxc2kZGX4N8HoPsGHWldGG9+JuyJcIvXXzIkQeavSv3jc+XDetsknTYLgf322XRJ1/K5c2Wy8RHCmXlv0WyZaNN5s4ulPQrg2QUM6RD6wIZf3OOjL02Rzo32iZH324nEvuayPE4VT8zQlWfMyMyGJHJiDyNfHXbWBkyxH14KPzaIpKZ4FI/8W+0EPkp2K3OEqfUEUle5fL9k68FCNHInVeo+91UV8mILa+3EDk0xyVt3lfe8kath0SeQeSnxiJzBoj83FocnyMv9/5aGgRlyLVX5MiNV2dLZMN0IUblVfdRJPgJ1f5+e/JCke1vVep5Xvdsfen5VKAcDFJlW9AcaXNzhPRtuEFm/mSTlGS75Oc5JDvbIeNut8vv3Z4VaYfIY4g8j+R9jvg8i9wyHHGA5JuRITci3S74WB57zL0uK+pzmWPayfvcJwP5U7oY62U0P6hnZEXkSUS+UDJt1ZgeInM7utzb4a9VP/J7SpVBQDrdjfR6qL3ILw1c0h79GrFEI16TStMOGou0fLSJyA/e7n3O+0HVTvqrti4xSNybgUIMUmsiMvQGJUuIQda+0lZk/0z3eh+JzGCkBJEuQcXjxtLH+4okfOqWNusqf7mG6RJozZWe7TKkXkiOhD7jI0Y0sjFClffxwUp2EKNkR5fxSOv71OePHu4vsv4Rl3z3TUW6Po5MGlDa58aMQt685yKRlbd6LG8OvtKLf8WfTPEhV17v/H8ypNcx+WOBTZKP2SU9zS5z1q8VUzTS6KHSfJs+iFz/OiI3NRQHyGD+EAO7vM+9HvWWdS90Efm9tVsZ7N8aIll73Mt2ra8IyCh+EjNFMs77DTFHI9ZnkAJz8fO8GWFCY9V+GiPyCSKfIfIpsv2tpiKJC1zyfe0dqxCN3HS1+n1CKGJ6Fhn0gJfUfwhZH4Gk+RTXewwVjp8HbrlZ+vCP+JEtgWRIhHmPEIM0eBj5v8tKdZnBPT+RSZPK9YuC46X5Oikegz/p+6I0DEiVm67JlXtvzSkdj8r15cVPXyTy7/Un7vfFfW7mhKtlZ/QokfmPiaz7SOSPqypMK9OQ/NGN5Qtuk0uZL51ZL9c5+2coItcoWSDRyKbJnvWWN2o9IDLcS+SLS0Xm3iky5w5JeKO1yPQAl7S27xDfZ1T9JwWUjol1nvCstywf2EIG+Chdbe6sQpn/e6G8NmmXbH2sv8iqKSLxs0QWjxGZhqx/oYvIri9c8ljwqXomne9S19oWrj7/+gEi914iLzFRfMgVf7KkH0s86vRvThgk9tUTRPJTRexFSi+bWcfjM4p6NlCIRn5rra73Wm/VlwtGWOUupkioX6707pgp7Zpmy8TLXhJZenWlnuc/z/YW+bO/S9qMzwLFZBJJSXFtVvPmiXwQ/qxIN0QeKdbpvyqjh/YolnVPIVt7txW5zs9Nr0v9NETk+EZXOfOuZ71l59tNRJL+dPl+/0cBHuty1ctRIvume5RJH3KP+JNVoofWedZbiFb6nKD6rzOfruPVd/uD1eewZ73FiEbW1VPfPzVQ1bsRjVxwh/quwKzGhTrP+IoRjSxp4vqMiEEiHlHjRro3Yn4WaTgpSIxo5Nc2Ku17F5TqwuXnCjGDnhH5e4hre//WJB90ulfeHr1cvn3tsPzyebL88lmyfPrgZyI31ner948jx4u8ESCy+iGRPT+JJEyTv95+Ud4JiRZpisiDxfr/l0jBF1aRjB0u8qQivWX9oFZysfdyue+uAvn5R/Uaft+n0mFi6b2l+SD9b0WOXIUkEyaDWVgy9+tY7xvpOBF5+0KV9og/0vc2ZEVMJ5E937hdb9vgNtKZ9XLZgAKZMD5Hrh+ZJyHPeospGtlaPK/4v8tK6z1ygqr3+DD1+fPH+opsesot38nmSSK3Fs+jvm8k8o2/LH7sIpHVd7ukTfpa5WOdhKT6ILtqFY+ngx6RhQPGi7yOyLRQkRlRcuwLk1z4GHLfsNLncPflyGN39BFZNMCtDBsHdpJevuvlwXsKZNrUfPnqk3yJvm2WfNH7YYkZsFjenLBP3pl4WF67Z7dq27mJLnmsntxdWrcWN3qG/iszZrh+9/fyP4QYxP8p1eYbPqTqbHj96fL6K0WSeNguBQUOKShwSPymYx5l6In0lvLtb+3j3UQeuMJ9nneTB7uKiADrpDI2n8okOmEG0AtYWObzk8CT5dJ8Alxf5nM8UO9keXfr1s3jzZVnxAiRt4r17pwckaws9f5QxiHp/HHnEuF0+bTLJa8or1J5VkRGhkidOiKxsaXXERFZtmutEIMEvBQgr/zzitR5vY4Qg/yx6w+3PK69VuT110Xsdtfvo6NFevUSOXpUJD1dXSshofg/yj/4F+8R+dFPZM39qiHnHBb50Vfk57pu17PZRKKiRPz9RR54QOThh0WCg0+pGkRE5NZfbxVikFf/fVVEROq/WV8p5IfXnviHznuogPR0kYgIkZEjRQ4cEMnLE5k2zXPaAQNEvv1WJDe39Du7XWT9ehFfX5GrrhJZtkzk++9FAm4YJ8Qgk5dMFhGR55c+L8Qgt/56q2u5TlA2EVHC/UffUqVgRi33e7Pli8wIFUnbor4vyhHZ+JRK/6P/ifM/GbYC9bwzdolk7BTJiBfJTJBHHrFLZKTITz+JpKaKLF4s4nffRUIM8u3mb0VEpNm7zYQYZPHexZW7VuoGkdmtlAHIVtx3HHb59vMgIQZp8W4LeWHpC2KabJJLXkMc8zoXp3Gov8XKtNs9O+wq3/gPRIqy1aswUylwHtqwJ9avF2nYUGTrVtVXMjJEsrM9p91yZIsQg/i+4Ctvr3xbmrytjMcfLlgg/v4iQ4eKrFol8tdfIg3GvCDEIDf/crOIiHy/5XsxYgyxPmcVI8Yoad+BLwWKEWNIfEq8ukj5trP8ZpEffYpffqoeVo1TyqqIus+yimUNcuedIhMnqvpzPrqK6jIlRSQsTOT++1WdFxWJfPyxeBw8L71U5MsvVR8uS9++Ik88oeR1ZqbKp/CPoSI7PxJx2FSiE9SP3a7k5K5dIjt2iGzfrv4WFVVwg55kaHS0W7Jft/8qxCBdPu4iIiLfbv5WiEH6f9nfPU9bgcivDUViX1QLCwVpIkU58vYtE6V3z1xJTVWyLD294ro8Vf79t7Te8/LUdap6rZwcNZ6tWSOycqXIihXqb2FhFQuz5EqRH3xKn9mPfqX/V1znBbYCMU82i3myWdLz0kVEJPTVULE8Z5GkR+5yeT4pvoh3tFmMGEMKbaownT/uLObJZpm2ZZpLvtXFv/+qcaNNG5HHHlPt1M/Pc9r+/UWuuaZ0rM7LE4l4rr2YJpvktx2/iYjIiB9GCDHIOyvf8ZyJczJZ9lW3cvLPydChIj4+pT83mdSY6OzHIiKbk7aI9/PeEvBSQMl3wS8Hi9fzXrI+cb2sWKH0A1B/XfBUxxXVe7nvN29W9Qci3j52MU82i9fzXpKUlSQiIm3ebyPmyWZZsPU7kelBpW2nfJ8vznf2jtlixBjSYUoHEZGSz+0/bF/p+iooEGnRQr2mTxf5+2+RwYMr/XNFYZZIzkGRzN3KSJ25W3746ph06+aQ5GTVHrKyivuip2dc0XP2JKcqkFVVyrc6KfOMe37eU4hBZsbNlEJboZgnm4UY5Gj2UZefOBwiDRqIrF7tKp/K6m0nu15+Ub74v+gvxCAT5k+Q3p/3FmKQhxc8LF9+WdrOQMTbu4K8ll0jsu119d6WJ7LxSVf9pMy9jf99vBCDxCyOERGR4T8MF2KQbpftkEsuEUlLU30/J0dk/vzKVl4x5Z5zAVa5pdMG+ewzJXs3bxbZtEnJ4szMKuZdw/zwg3oWN92kjF5PPSVivUnJwSlr1IKXU/8yxZiEGGRz0mZ5bulzQgwS/HKwmCabZGacmhyP+FH91ogxJPTVUBERSUhNEPNks5hiTGKabCrRb8fPVs8s4EVl6Hpx2Yty75x7lRHpDbVw+NKyl0REZNxvaj5w96efip+fyLBhShZ89ZWIJ3+FKlGQLvJTLZHsfUr3d1IF/dYTRUVqbrR+vWs/KjsXLYvDIdKzp4jVquZT118v4uVV+eulp4vUri2yYIFqh9nZSrY1e6u1mCabZO7OuSIiMuS7IUIMEvJyiBCDNHu3mYS+GirEIBP/nOg58xW3iizsXVpHtlxlmHbWT5m+OOy7YW5Gy+fn3qGMagmfqb5cmCkys3al6zc9XemxO3dWri5dqCa9w25XfWXnTvXZOY+p1LWqWfeprNGoOranrQVaGobRFDgMjAFuKJdmNnC/YRg/orauZYhIlbemVcSvv8Lu3SoIYFGRipdqMsHVVzdg410bsTvsAJir4WjD2FioUweaN3eN9dKveXcCvQLJKsziib/UAXJWk5XBzQa75TFxItx/P3TuDL16qSDDqanwxhtqb2ydUi9dFdAwJsZ9/+fS4eA7Frq8UnpijD3P497m779XAb02boQGDZS73SMVHLpTFUa3H83UzVN5Y8UbLD+wnMSsRPwt/iVxaP4rX34JrVvDN9+UBnQcNcpz2tq14dgxsNtLn3tBgarfa69VJ/z4+6t9qfsiOvLUMtiZqmKiJKSqE4jG/54IV5fbq28YEB3ted/tpqeKT+spxu4hwIfZG0alqODkh34Dhw3CukP/2VB/aBVrpHzeXuBX3+Wr48fhww9VPIPWrcFqhf794fGiK4hZsZR1iesY3W40e9L2YGBwYYPyO0grIH0LBLZWburOEx9in+M670xuRgWYm7R4EgA7zA0wWtwFa+6BkA7gGwFBraHdUxA10TXfY8tUu212W+kpLr9EQEHF8T7K89xz6tjvli1PHqi7Q90OhPiEkJ6fzkMLHwLAZJj467NLGDRI9RFnW3sxuAW3zoH96SomSmJWIoJQL7AeBzIOsC15G5EhkWQVZuFv9adlaEv3C2bthoMzoP6V0PtrwATTfVRcitQ1ENajNK3Z3/33Z5i5c+H3310DqPpXUKxPP1Vy65VXStOMHQvLl8PTT6vT92rXVn0uJETJtDFjIDtbbWHavBn27VOnL3qXOeCLdg/C1heg7sUQ0LzMf7iH3jOZlJwsKytPiCcZ6gFnv3AGU9xydAuARznOgRkQ2AraTFAn2/zSFPKP8tzMVFau9yU01P0n1U2fPmrv/XvvqThDFovSJGw2mDBBxSQ7GX5+0L79KRYkPQ6OLIKQdtBzKuQfgb8vVX26TNwGL7MXIT4hpOWnkZiVSKB3IBn5GQiC34uvwRsfl6T1t+VjeykAi2Eh35aP1Wwl36Zkrb/19PSZO++Eiy5SderlpU6NnDzZPd26dbB/PyxY4KoHXNC8FbMTtnI48zAABzIPANA8tLl7JtVAbCwsWaLG9VdeUZ+fe06NA9u2qdOzfH1hR2ItBCiwlY5bzrqs5VOLj2eVxqkyVTXSZUSE+1HxhgF16zJ93JGSWB8mw0SQdxCZBZmk5qYSERBBWn4aAB2PLwRHgRonmo+HeR3d2g5Al3pdEIT9GUo270zdiSD0atSr0sWdOlX9XbdOyS+LBS64oIr3bA1QrzJMflUdIOEW57EqVFJOnS1c3+56Vh1axdN/P83UTVOxi50WIS2o4+8qmB0OSEmBRo1c+0tV4iV6W7wZ2HQgv+/8nXdXv1vy/Z1d7qb/zUrW/fabusbtt1eQSb8ZkHsYDs9XeltoN+j3iwqnUI6BkQP5dP2nrD68GigeCzIakrCqJQf2q7iPTi66qPL3Abg9Zy9gahWzOBtxOOC++5Qe8OCDEBCg6sYxeySvxM9ietx0GgY1ZH/GfiyGhfZ127PpyCa6ftq1JIZYxzod+efgPxzOKpahGUqGGobB8bzjFNgK2JO2B7vYCfUN5Xje8ZLDA5yn0HaO6My/B//l6b9Lt1Ne0vQSvo39ls1HNwOlQaKXfHQNI0eqMAz+/krmDxt2ihWRf0yFE/GtV3ow0ZYYpd+egr6Xm6v6Udu2rn0nIMBz+vnzIS4O/vgDuhfvnnvC7Xzzivn+exgwQOkZZa8RVbcVezLjScxKBNQJxwYGo9uP5pP1n7AnbU9J2kd7P+qecV6S0p9G7FexN53YsmF8NowqMx8zDL5oEk6920q/CvQK5MlwLwgbA5HXq7mJ2QcKkit9b3v2qMM8Gjd21UMrqssTjXP/Nc6syaTm5kuWwN9/l26FA7jlFg/622koQ1U5ZaORiNgMw7gfWAiYgS9FJM4wjLuL//9jYB4wDNgF5AK3VZTff6V5c/XyRHUYi5x06QJpaUrh6NxZdVy7Xb0+GPYBt8y6hSbBTdifsZ+XB71csp+xLN26qWBbW7aoTp2XpwKsBQWpAc+l7J6Kbi+EpD/gyvhSg5EzdpEHvvtOHa7UoIGaIEDl4xmeiL6N+wLqmPDZO2cD0Ci4kcd7BtwbfAWNfepUFZC57KTVZXJZLm1MjDoivk8fNZDHxsL69UqBcOZhsUD7CBVJdm/aXoASwZb2xAT4YmHlbtpRBEkLAAf4NVZGuoJkjwouhgHBbdXrNPP77+r+mzShJK6SyQQ9G6lJ8AdrPmDqpqmAOmHB11pJba3xNRD3Mhz8FZpcq9pe1ON4NRnNY2u+4vUVr1M/oD6J2Yl8M/I7iLy4kiUuIx3dqNysJTVVKeiVPdntw6EfcuOvN5b0z0d7PsEHr5pYv961rbWtqwSJU2nZm67aS5eILhzIOMAn6z5h6X4VDLpNeBvP7X3Pl6p99JoK5jJ1nXdYTY4SPoK2j4FhgZZ3u//+DDNunDI8TJmiHovZrAzwnk7G+v57ddR62Trz9VVG3pwc2LQJdu5U7fCZZ5Sx+qablGzz8oJdu9T/uT3++kOgdl848qdS6ts8quqn1b2cKeoF1iuZ2L78z8vM2jELUIHZ3ciKh+AoyrfXrPxAatVyT366aN++Gow+p0rCFKX8DVqsTvuxtwKkzOmQpTQJbkJqXiqJWYmE+YVhFzsBXgEEeQe5pPM2e+MQBxaTMhoFegeWGD38varfaJSYqIyZS5eWtm2r1fMcfsUKZZS32Vy/71q/I7MTfuFQ5iEAjmSpMaF5rQqUk1NU9D76SPXRVavUiXZDhyqD7f33u6YbXFiLSa/asTvs2Bw2zIaZQnshZpOZWr61+PlnpcOAmphUF999VxogNi8PGvqFk56fzvE8FXw9qzALETt1k2apoMvtn1E6jT1HvcrRILABAV4BZBZkklmQSeyxWAB6Nay80ei77+CBB5QuZCnWgCsykFcFmw2XmIYlnC5l/iw4CrtP4z6ACsTrPOq6VXgrt3Rmsxo3rroKXn8dunZV6tGOHdCjh1vyCvlq+FeEvx6OgYEgXNnqSg5ubkl+PixbpibT3t5qklwhfg3U6yQ4Zf6SfUu4bsZ1Sg84Oozu3dzH+1M9LOR8YcMG1a8efrh0wuvnBzf17ccr8eqgk3WJ6oTLcL9wHu75MGNnjUWK/5kME8NaDuOfg/+UGIadMrSuf12SspPYn7G/RHdvGdqS1YdXlxjnnUaMh3s9zL8H/y0pl7/Vn3t63MO3sd+q49cp1v/zA9m9NYSlC0plgJeXmoudEkEtlSFy7QNqYd/kA+2eVEHlA5r+92yD1NzoxhuVgTqs2N6Smgr167un/+YbtXjevXupMaRFi8pfz2TycGgt0KFOR+Yk/F4yzh3LOYYgPNb7MTYe2ciaw2sA+OKqLwj382BFP7oU6vRX+p2TE8xhI/LNLLt1Gf2n9gdg3fh1mFcOhx5TKjUH9kTHjmrR8dNP4Y47lLOBYShZVaHh6DTg51eBkTImxnXFyjCqZ6A6RarD0wgRmYcyDJX97uMy7wW4rzquVdP4+akV9fvvV8+wSxfV2BYtgrVrb+b2324vEXYTek6oMB/DgE6d1AvUKvzjjyurY9nO7/SecaEwTX3pV8bC5EE5BzUxW75cnYzlVxo7vFIr0CcjwCuA9nXas/XYVmr71SY5N5mJfSae/IcnITlZDf6VwdcXXn1Vvc/PV4pp8+bw77+u9wvQrthodChLCTqnwGsV5q7kVMjx9crrps7FMGABiA1+Cqiw/s8Ue/cqDyNLuR59UQulkdnFTkaBOo2raUgVBi2LPwzdqE7pWHa1Wj0RB/g3Iab/y7y+4nUSsxNpX7s9F1faYATU6aeMJ7s+VaceiUOdiuWwgXflXDTuvBO++AJGjFDtwGRSbaCitn19h+u54/c7SvrnLU2eYWqAu7G5RZgK4pecq1YtnEZG58RvxaEVrDi0AsBtolvCkb+h5b0uwetLqDtAvc4iYmKUEtKzJ/Ttq8amuDh1Okh58vJKlZXy+Psr42VZ2rdXRl0nItCunVJobrih1PBus4GfXwA0urra7uu/4GP2IZNMopdEU+RQM96o2lHuCUM6wfY3wHmUdbHR+MqfbEyZAo89VjrG5+ScFeP96ePo39D6/0pXVc0VW3LbhLdhw5ENJUYjgIaBDd3SGYaBV/GBBXk25UFbYjQ6DZ5Gixcr5br8AoUnpTk4WCnq5YkMUhr57jR1BLLzBK+mtf77ROFELFigVvb9/ZX88/dXBuDy+Fn9EFGTsuzCbCwmC4ZhYHfYyc8I4mCZY0qcxqNKU4Hx4sgROBrp+l29wHokHE8gNS8Vu8NOblEuzaxgiAM6Plc6AagAwzAI9AokuzCb8NfCsTmU1a5FaOVnQhs3wtdfV2DgOQUmTlQTujlz1DhssSivhTM5ATnTdKvfrcTDPsArgOzCbJ7s96THtCNHwqWXqsW8lStVO2vQQC2iVta7LcwvjKf7Pc2L/7wIwPtD3+fzN1W/bd68tO9WdiHpRDQKVvp1ni2PGdvUAR0+IRnsXWm45W+3V7DA+z/G8uVq/C8ocNXDWkdEYjFZsDlsJTs/Lml2CTd1vIm7595NbpGyVD8/4PkSo+Ou1F2ICMdylfd581rNScpO4uGFD3MwQwmsdrXbsfrwaval7wOU8QKga72uPNTzId5e9TagFvSdJ1FuPrqZ2q/VJiUvBdORgbRr5z42V8f8iJ5fwLF/Yf2jYEsHTODXELq8Dqb/PvWOjlYL4y+/rNbgnWvvb77pLtOWLFFes2VlUPl50Ym44Qa18PfXXzBoUOl+yhCH8q7fnbYbESE5R+nKjYMb8/WIr2n7oZrA3dr5Vs8ZmyzgKPTsvTDFBDe4D0L9gOGth9MwqKGas1lD1GmLDrs6Zbc080rdm9msFog++gguu0zptA6HcuCYP99DGzjTRvqz1Ou0WoxG/2s0aaI8O7Kz1dYob294/nml0Hw38juu//l6Xhr4EpYqCIaAADUJvuUW1cmd5OcrgeCCxR/sRWolzlIsDXzqFhsuXDtMXp7KoyrW5aoQfVE01864luzCbABu6nRTxYkr2enq1IHt2yEqqmqu8j4+6mW3q/osvwrcJLgJoNxdB349sMR4EBkSWfmLHFsGUgS9p6ktaI6q+vKfHgICICFBreqWXfUyi0+JJ5BTuRvXxcOs4kRYfJW3RzmPDz9gVJtR/LzjZz664qOq5WmYYPBSWHUb7PsOQrsr19Rj/8KIfZXK4sYb1aDYvz889JBqN1u3qlUuj5c0DKaOmMromaMZ12UcVpMPXl7uk8JQ31C8TF5kFmSy9dhWEo6rbYyj24/mrVXqJDiLYcEmNoa0GOLZg+5LQykNTqNRFVdBzjQmk3Inf+AByMpScqOi7VW9eqktwZ07V00BcWIYaiX4qqvUBKJ3b6VkzpypttTUND0b9WR2/OySCanJMFEvsJ57woYjYPPTsPkp6PSykgsmL6Y8MpWL7ribvXuVsczLS93vCy+c4Rs5UzjskL0bGo1UMvEktK+j3KLijsVhF6UcVrR9y9viTW5RbslWqgL76fM02rdPLVaUn/x5mvSPGAH33qu85tq0UTLXZoMGfuo+4lPiWZ+4nkJHISHeIfhYqmMW4orNBgcPqq2hZWW+JyOXYRj4WdXJMk6jkYjga/Vl+zYTvr7KwFGdxMWp8bigzE5u5xicmptKen46AL38fTCC27l6ZJ6A+oH1ScpOKjHogpokVhZlnK508kozbpzSB9u3VwYSf3/l8bxgQfVf62xiYp+JTFo8iezCbHwtviUe6J4ICFDj9qnwcK+HefGfF/G3+tMkpAnLl8Pll7tO/KvLIFjXvy5Hc47iY/Yh355P924mUv5Wi7ATJqh+V1SkvPPOpHfp2Up2ttqSXr7+LRYY3208U9ZOoVloM7Ylb+O5Ac9hGAYvDnyxJGTA7V1uLzH8bEjawPur38fmsBHiE4K3RY0tcxPmluTrHJed24GdRvoGQQ1cjEbXt78eb4s3JsOEQxyk5Kl0VgIIDjZKvCGrnTp91aua6dAB3n//xGlsNiWPOnf+79cJDFSGwLFjVZtv3Vot6q9Oag5DIPZoLIv2LkIQwv3CsZqttAlvw8M9H6Zv476YjArmRxGDYMVY5QBh9ldGn5FHwJZzwoWDWWNmlX5oeQ/EvwsNhwN+xb/PU/OVSuLtDf/3f+qlqRxnx4z3HCUgAJo1U6slTiF5TdQ1jO00lvsvuP/EP/bAG2+o1ZKoKKWA3HabEg5uWAPUlqf900vj6Yw8AqNzPVpo4QQ7gU6RIS3Ukap5tjyGtx5eJUNZRdx6q/J6KHu0ZVnF82TUr6+2x5S3FJtNZsyGmhEs3re4xB22SmVOXqH2wTvjGTiNAvfiajU3DGVMOENcWhqqRgAAIABJREFUcolaKS8/4SkshAcufACgZFX/ho7lQ479d94b9h6T+k06oaJYIT614eI5MOhvaD4O2j0Nw/dW+udms4p/NXWqimk2a5YaBE60Uj6y7Uh61O9B9EXRNGigBsC0NPd0zuMse33eqyS+TauwVjQLUV5IdQOUJffOrne67zG2AhaBgGal39WwJ1plMQzlAl23bsWK94QJ8NVXqo9lZSmFuapbWho2VK7sb70FTZsqxebff0/+uzPBPd3vAaB9bWXcGBBZgVeYyQyXrlCrXb9Fwl+D4LfmRBTOIDZWTRx//BE++0wZ7T1N5s8LsveoxQu/Mt5CJzCSFtqVdeLNVW9y15y7AFwMAGXxsfjgEEeJ0ciZ7nR4Gjm9eiuzdTs4WD3XSy9VK77Llys5dP9Y5Sa8+ehmLpqqAp3YxHaCnP47CQmqrzYot9OmIo+2QK9ABCGrIIusgiwEIcAawM6d1W8wAmXAL388tdPL9Xje8ZItaj38vFXsOyfOtuMcU8uNqxfP3w6o7YugYkdWxYgYGgrx8VW7l8pgGPDUU0ouDh+uvDY/quJayrnIyLYjS94/cMED1ZdxRIRHnSrUN5Sltywl7t44QBkn+/T5D7G4TnYtw+DRP9QWyZ6NegLwVL8nmTtXbeO+4Qa1WDxpktpxoFEGo+Rk3IwwhYVwXdR1AGxLVitDkbUiAbi5Y6kbckRABA0ClUA7lHWIiX+pnQtF9iKPW8RHtxsNqPhEnT7qhEMc+Fp8sZgsNApuRJhvGD0b9iwxODljbTmN+M0a+rNnz/m5vbCoSPWJU/W6a9lSeQbOnAnjxyudbfHvqh63HN3CyOmq/xfZSx/6m5e9ydVtT+Ax7lUL2jwEi4dCygq106AgBTZ4iH9UEZE3gFeo0rsOTIeU1RB3vq7MnT1oo1E1YzFZ+HrE1wR6ewgGcrLfWlQwtthYZTgZP14F6/JI1ETY9DSkbVYeGrYcOL7BLZmvrzKe7NpV5eJUigCvAGr5qCWW2zpXT6iq229XiteNN6pgo7m58NNPlf99VJSysv/1l+vglZOD23MJ9Kric8rZCxGXVnpV9EzRsaNShm+9Vd1nRobyFnnxRUq2je1L30dEQAR+1upbZq0fWJ/nBz5/aplYg1Rg6OD/b+/Og+Mqz3yPfx91a5e1WPKK5X3DNgYcB7NDDCZAjNl8SUwCTiCYJCQZcrMAwwzM1GQqDMkNIcyQKhch5uaSEAgkYSbksmaS4RabAyTBEwiEsHjBNsYWlixZkvXeP94+0pHULanV3erT0u9T5VL36Vb3W35bp895zvM87+HDarZ1xBE+Zff2232pxkBp4vGiOM9e8SyNNY1UVMCKFT6ttyXUPqOlxX+uAZo7mnGJ8qPastruL8Jt+7dRWVxJXXld/1TAOL5iKVyaVhY8p/B3ucuX+wPlE07wvYq+/OX0+lKELVjgD74vuCB1ZtNIO2WGP9lvavflnMGBaVKl4+Gke+Hc1+H4H8HqLXDa45SU+BPHO+6AH/7Q/11mdFITZR1NUD7Nl5sGBgiSBmWenV2d3QGkxurGpM+tiPuyqiBo1H6oHYfLSabRpEnw1lv9T3ha+68tAfjP7WOP+e+oK6+En/wEvnGdD5w5HC0dfqcSfD9m29at/oA+1fj6qi7zpbT72/d3ZwZXl1Xz0ktDf410vPiiv9izapUvnz72WP99Ab6MZE+rr++bVloKlY09CyIMEmDf8N/+hC8oN1kzf01a41qzxgf8mpt7tqVzUWowZWW+eew55/iA+Gi3sGFh9+2LFl80Iu958syTmVHrs9YOHOjfCzRbPrTdn3EHPXSObzye2bP9cfmll8K+fT4b4+EhtsQc7U491V/86XvBqaODXs3qN3xgQ/ft+op6Vs1axfc+8r3u+4Fgvz+5ajIXLPTBiYrEfiJmMRZPWOxfv6uDP+z6Q7/xvPu1d3nq8qe671+x7AoAjp/mA1BfPm8VTU1+4YDwxcbwvqFQBaWa772XnddraPClpDNn9pQDO1z3d0nS3kUDOfLrvjXFb8/3LT5+dhgc2Dr03y+Kw6m/hAVfhD//Gzx1qW9yn+IClGTHaD2MLWjjx8Pq1XDmmQPUw89YBzM+Co9/CB45ER4+Dp5Y1e9pZr5HyY9+1DsboO8VwEwEV+LPmHNGVl6vutp/8Wzf7ssFpkzxwYChMvPP/9zn/NXY5mZ/UHz77XB4g6+1LU6c0C+oXzDQS/XX+o7vR9O3V83t9F/8dgRrYM18yeRvfuODZhdf7LM3vvtdeq1m94mlA5QPjkFf/7r/XNxyi/+MNDX58rYgoyhQkujRctL0k7q3nbfwPH/jnXd6z/v+NogX9V5V74J34GKXMhOw0Fx9tV8FbcECv1/5yldyl8040sqLy6kpreleteXYaccO/kvxSt/8sqQ2x6OLINfp+7yFPwADBEmD5rlhR046MulLVxRX4HC0dvioRmdXJ865nGQanXyybyjdty/cQBliRx7p++O89BI8+iicf34Rcev9Amn1zEtDe7svsxpqBlsQvGpub2Z/+34Aakpr+KPvJc0ll8C2bTA/S8N92feb5c47/YnGxo10X/G/4/k7WHf/OiDRI8Hi/jMEPZ+d24uSLSjP3Jd9/4y/vOf7Rq2cvTKtcV15Jdx/v79yfuCAz5bM1UW1scDMGF/uI/7plAkOqu/3aopjqq6uLCzskuy9nOPIP/gA5ltNb2EYNWV+ybSSEr+i7y23wA03+O9B8ceeJSW+n19wIa652WeBl8RKqC3134/nL+ydhfLIpY/wmeU9C4L0LeddNGFRd5C4rNg/dsqMUygqKuquHghMqJiQcnwnz/CNlIP934kzjufSS30j5F27fD+blha/fyh0RUW+dPo//zP7Wc7J/t/DweMhMYOFV8MFO2HNX+DCPXDqv6c5kBjM+jic8aRfGOq4Tcn7iErWKGhUqMxg+a1wxlMwZZVfeejDzyZ96iWX+AO2t9/2B0mtrX7Zxmz54QU/5LUvvDb0FbmGYM4ceOYZf7XykUdgx470fv/66/2V4xUr/JKfCxb4bJQgGyr40rrs6FRrsybhHLS/B5XT0xvMCJk1y/fl+MIXfIbZ2rX+fnGsuDvocfqsJEuHj2EnnQQ33+xXAxs/3pc2/vjHPcGh4OAlKKsIBxBWzkpxshIrhZIaaIpAg54cmjvX/9/ddZcvpc3GioxRsXbR2u7bSZtgS49Ymc82Ch+sDRAkDTeFLkocgqRqol9R4q8qt3W20eW6fNAIl9VsycCCBT5L8R/+oeeEp6XFNzZOR5BNE+w7ghOVbCsqSi9QW1/ur+AH5Wngr+q/9Zb/273tNl+lEywskak33/T9fWoTcdR588DwO4l9B/d1N69tdQYd70OiX9VgAfYiK6KxurE7UyndQMVRR/llp6+6yq/idcYZPgtKhu/py5/m4Y8/nHrl3BwqLvaBv1yIF8UZX+YDYuuOWJebNxlFzHzp+qZNfiXHW2/1AZkNicSi4PhpsH3isYf55x01yTfkueDwCzAzZtTM6C5rDTKXgqzwwEBN8Y+a7F/vz3v+3P3cb3zDZ0ItWgTr1vljws+N3IKtOXX22T6TPpwkEM6qz0SQHVxT6gOpp806bXgvVBSD8ik9LT8k0hQ0KnR1R/pu/EffDLXJ113+2Md8ts4HPuBLSa65xu8gs6WiuCJlI9NMzZ/vAz/prjxUUuKXRf7mN/3V2GXLfN+Jwyf4TKOdLf4KUnB/SA7u9ldES0NXMiLW4Liiwmd9/PSnvjStIZExevRkX3SfdOnwMe6qq3xG2re+Bd/5ji9RWb1gNdATXAxKlIJeRjDIMs91H4BtD/rGfIFDWayBkJwKsidLY6XEigaodxSonAmtW9P6fAcNkYNGposnLk76vOCEoK2zrXvltHhRPCdzYua/L26/3Z/kPPaYz0RMthrZQC5cdCEAZ809q9fPbKuq8u3UhtqzYkKl/94Kl6dNqJjArl2+5NTMB6JOz8J1ha4u39vk7LN7SlU6O5MHYFtKJ8P+V+HQ0GvkPjLvI923l05amvb4brjBrww5dao/Ybz55tGTKZkzKXoMAcyrn8cZc7OTaZ6u6dN9f7xcWT3fHwvk6u94tDn9dF+q+8orcN11Puj+z36xO2476zZuOu2mQYP+q+b4qomg5OmYw44BevcXDAJAQbBixWErgFAGeBLB6zUdbKK6tJpYUYyqKp81vWGDX4jDudGRaQTwmc/4nl9XXukTBg4e9BfUs2HNAl8WHPQzPX22LkiPBQoajQGxmM/WOeYYv8z1nXf6tMXRLhbzO83/+i+fHnv00T2lAsFVzrRKB9r3+f474SvqBdLg+IplV1BbVjusXltjwWGH+eDRFVf4K+Oz63x5WlACkezq1YKGAXLSp3wYXrvTLysaUK11wQiuiAYHpjKAklooroG9fc7cOlN3Rw+CB9v2b6M8Xp5ylZWg51xbZ1t3f4vSIazQNlxBqcLPfuZXZLrtNt+7Kx1ByfNf9/qm/rm6oLJwYfKeh6kWAphc5U/ww+Vp42PTaGvzWQHBwhHZKGXYt89//65Y0dNbo6qK7h4kYQfHHQ5NW3zG2hCFMz6Hm3V2yinwxBOweTN89rOjK1MyJ/ou+JBq2whbscLPY6760ASfNV1wG7rVq32p62uv+aqGYHWqufVzuebEawb9/b7H6cHx2AcP62meeMREv0rQSTN8Vniwfxss83BenV8uPgh6gN83/cu/+N5rL7zgW4OMBrNn++b8Dzzg235UVfl+btkQlKMF33PBHMnopqDRGDF5sm8MvXmz79vw9NP5HlF+BPXOO5p9vdukykkDPb23rg7fu6QAT/4vX3Y5e69JskyYJBWs4BH0tQmf+AVZWymXEwWY/Uno2AuPnQzvvwz7/wJPpNd7Q/InOADKVT+aUad2Kbx8C3QM7cwtOOAHOHpK6qWHqkt98+Zw0CgXy9cHzHxJxa9/7U8i7r03/SXTg33Fm01vAnT3e8m2CRN8ltFzz/Xenqr8wCVSaf712X/l1qdvBaD5vWrKy315VpCxlI2G7fv2+d5QfVd/DcoNw8obVvgGprt+A12JiNcgkavgMzNQ/xIZG447Dn75y97bshlAWj1/NTNqZnSXqMvQxOM+k6/vKsZDEVykC/ahwT4//L0RPGdm7Uyg51gtXP6cTNAD7eTpuSkbjpq/+zufLDBzpr84euut2cmqDL7ngsBeLhankOhR0GgMMfONpZcsGcUr+QzCzCguKqb9UDsxi6VXg+86E1lGymMf7YLyl3dafOPNYMUngOevfB534yCfgbIGWHw97H8N/uNw+Pe5sG9LzsYr2WVmtFzXwg/O/UG+h1IYZq2Hnb+G7b/0gaPOA7A59fLb4WDc0ompy4uCfgmtna0jEjQKrFjhr46ffXb6GSjBvmJv296c9F4KW7TIl9WGT5IPpEjwCi6UbNm9hZd2vwTA9l0HiMV6N/JNufhGGoJMo6lT+z8WNOSeW+dP+o6fcxaMPxqe+xy07/Wfn46BL3AEC1rMGz8v88HK0PRdJTTVthG2Zo1fIeqSS/xnv6UF7rsve6/fWNPIG1e/kZd+TWNVsA/t6OroLmUGOGJST9AoOEYLgnnb9m8DejKOUgn6JA10sWK0ufBCn/X1xhs+kzYbH+Vgjg50Hkjv4rsUtDEaOpCx7IRGX2+QdrqxxcAdAkJ73FG0lLr0Fu6/MbFyYvovsPhvYenXoajE98JadG0WRye5VlFSoX5GQzXjIv85/3/r4LfnwiPHweubUj49nMo+UF+5YLWits42WhP9wXIdiMlUY03P+t8fnPrBAZ6ZuU99ymdF3XefP2FuboYLLkj+3GT7sCp8T6lkwZ1MNDVBTU3/pbehp6w3KJWeUTsDlvw9tO6Eh5bAM5fBQ0f0/8WQ4lgxMYtxzvxzsjtwSW2Iq5mNtIYGuOgin220aJEvO7wsjfVNJHrCbRSC43WA2rL+q5MGmUa7W/yqigNmgNMTLEpWKitDN72mZ0GgIa0wK6OCznRlzDll5inAMFa1KSqGQ+09SwPDqFtKXXqED1aGdZXRDA7/Eny0FT7aBkf8fRZHJxIhsTI4/kcQK4edT/iVA8tTX/ENl3uGs/j6StbTKOpBo3hRvPt2uAdHLnz84343c9llcOKJfoWyzZuTPzfZFfjyrklUV2c/83jfPp+EEl61JxCsuhOUk5TFy2DqR2DqWdCxH966D9qbBn2Pzhs6ufYkBeIFvv1tv3rsjh3wu9+lv3CKRE/Quy5ZX8Fp46Z13w4uLDjcgCunBVZMW4G70WV1teexqDjWc0UgaNkgo5+CRjLmBKntwc8hi1VA+x4Y5EqGjA7BlajZtRk2+LMiv6yoyGg29cOw8jGYfAY0roUzUy9pFPQMg4EbRQcBotaOnvK0yuLonxEGV8SDpti5UlUFGzdCeblv4Lpnj+9bkUz4/zxQfmgSU6YkD+5koqkJxo1L3pooKCfZ07qHkliikZIZnPgTWHg11C2D+Z/XcmYyZA0NvrfXVVfBJz4BTz6Z7xFJpoIA0Lz63iWo7kbH2//z7aS/E6ygJiMjuKjTd45k9IoP/hSR0SXop5F2k9vyydDVBgf3DHgVXUaH4GR2bv3gV69EBJhwHKx8eNCnhcv+gvKCZILmmi0dLd1Bo6rSLDTdybFZtbN44Z0XBsyiypZ163wZ2D/9E0ybBps2JX/etOpp/baVHZpIfX0aK6ZNntx7xSwzn1LUp0xp377UvZHC4+i14o4VwZH/7P+JpKm62mccyegwp24OW3ZvGVL20IL6Bbyy5xWWTFwyAiOTwPSa6WzZvWVEvuckGpQyIWNOEBVPu4lmUTHEx0Hr9hyMSqImOKHRqikiuTNQY+sgq6i5vbk7aBRc3YyyYJ8xUBZVNq1dC7//ve/rMiHFgmLhHhSBkkP1VFSk0Rh1iMuu79sHFRXJy96mjJvSfVurE4pIMkFvuKEs5R7sR7Ts+8gKLviM1Pec5J+CRjLmVJVU4W501Jb3b6o3qLLJsOdZcKFLs0NcZloKS3DiF/TgEJGR1XTQ97a56/d3cfH9FwOwszlJ4CJiplT5wEiykrB8mTrOd7sui5d1l/1Zax2VldnvabRrF9TW+hXU+gr+b0ABeRFJbmHDQmBoPexm1sz0PwfIWpXsqy+v7/VTRj8FjUTSUdEI7zwKnft7tqnH0agUNEpcMU118iLZtnzq8kH7E+0/6PezbZ1t3QGkAx0p1pSPkFNnnUqRFUVq9b1gLPGieHeT2b17Y1RXJ1/lLBMtLX71tJKS/o+FM42SZT+JiHz+mM/jbhxaX7PptX4/oiD0yFp/1HoW1C8Y3kIxUpDU00gkHXVHwWsbwUJH2W07oUpfVqPRUA9aRCSJAXrgPHfFc4P+el15Xb9t4eWYo2rtorUcuiF6K2qWxkppbu/JjN27109HtoNGhw75oFGy1w1nGoVvi4gMR5BF2VDRkOeRjC0rZ63k5c+/nO9hyAhSioRIOiad6n/+8R+hs9X/e+aKvA5JRCSShtgDJ5W6sv5Bo6qS6DfCjqoJlT0NjxoqGti3D+rqkpeRJTVp0pC2HTqUOhAVXuo6nHUkIjIcFx9xMe5Gp4wXkRxTppFIOiac6FdQe/l/QWczHNwNOx/P96hEREad+or+vRLGlYwb8ipe0tvkyslsfX9r9+1Dh6A+nXYUQ/z/7ewcWiBKmUYiIiKFQUEjkXSU1EDtkfDec/Dq7YmNStgTEcm2hvL+5QbjSsdlnME0VoXLNyZWTaSjCyoHbis1LF1dQyt5U6aRiIhIYdDZrki6Fv8txEJH2ommoiIikj0Nlf2DRjWlNXkYyegQLk+bUDGBrq40StPSYOYDRykfx5eRjCuJfn8qERERUdBIJH3TzoX6D0JRGcQqYN5V+R6RiEj0DLEHTirJGpvWlCloNFyTqnr+7ydWTuTQISjKwVFgPO5L1FIJ+lKpB4mIiEhhUHmaSLrM4NSH4JXvQmk9zLks3yMSEYmeDHsMxYv6H6LUltVm9JpjWbjcLwgaxXNwFFhU5Jthp1IWL2N/+/7sv7GIiIjkhDKNRIYjXg6Lr4G5nwbTn5GIyEioK++/opoMTfj/rq6sDjNwLvvvE4tBa2vq116zYA315el04BYREZF80tmuiIiIRFLQ/6YsXgbAnLo5GZe9jVV1ZaGgUXndoBlBw1VcDHv3Qnt78sfvWHMH737t3ey/sYiIiOSEgkYiIiISSePLxwNwQuMJAEyrnubL3pzr/S/DUrixIFzaV1dWRyw2cMPq4Ro/HpqaUgeNREREpLBkFDQys/Fm9qiZvZr4mTRv3MzuNLNdZvZSJu8nIiIiY0fQ+Lqtsw2AyuIcrBE/RvQqT8thplFDA7z/fm4CUiIiIjLyMs00uhZ43Dk3D3g8cT+ZTcCZGb6XiIiIjCHVJdUAHOg4AEBliYJGw9WrPK3MB42am7P/PjU10NKSm35JIiIiMvIyDRqdC9yVuH0XcF6yJznnfgu8l+F7iYiIyBgSBImC1baKi4rzOZyC1jfTKB6HPXuSPHHyZL9KqFnPNjO/fQhqa33QSEREREaHTINGk5xzOwASPydmPiQRERERGFcyDoCmtiYALBzIkLTUlNZ0364tq6W21jes7leitnNn8hdItb3v+9T4nkbx+DAHKiIiIpEy6Fe6mT0GJLu8dH32hwNmtgHYADB9+vRcvIWIiIgUgHGlPmgUZBrJ8MWKYt23S2Il1NX53kPt7VBenr33qa2FbdugrCx7rykiIiL5M2jQyDl3eqrHzGynmU1xzu0wsynArkwH5JzbCGwEWL58uSriRURExqjqUt/TqK2zDUNZRtlUXw/bt0NnZ3Zft6YGOjp8FtOECdl9bRERERl5mZanPQisT9xeD/wiw9cTERERAXpWT4OeAJJkR12d7z2U7VXOamt9ydvrr2f3dUVERCQ/Mg0a3QSsMrNXgVWJ+5jZVDN7KHiSmf0YeApYYGZbzezyDN9XRERERrlwHx4FjbJr3Dhobc3+Kmd1dXDwIGze3LOtoyO77yEiIiIjJ6M2hc65PcBpSbZvB84O3V+XyfuIiIjI2FNZXNl9O7xkvGSuuhp274aiTC8f9lFR4XskPfkkXHKJf5/WVijWwnciIiIFKcuHCiIiIiLZUVnSEzQaXz4+jyMZfaqrYceO7DbBDkydCg89BKWl/n4sNvDzRUREJLoUNBIREZFICmcaVZepPC2bqquhuTlJ6dikScl/IdX2JGbP9iuz/epXvtH23XcPf5wiIiKSXxmVp4mIiIjkSjjTqLpEQaNM3Xz6zXQc8lGiceN8P6Pt22HuXP94VxcUvfNOxu+zdCk8/DCsXw8XXgj33AMbNmT8siIiIpIHChqJiIhIJIUzjcIrqcnwfPWEr3bfDlY5e/nlnqBRS4sPJmVq6VKorPTZRj/4QeavJyIiIvmj8jQRERGJpHCmUXglNcnc1KnQ1gZPPeVXO4PsraS2eDGYZee1REREJL8UNBIREZFICmcajSvNQgqMdCsv9/8eegja27P72gsXZv81RUREJD8UNBIREZFICmcahQNIkh2TJsGLL/oAz6FDvnF1NpSVwYknZue1REREJL8UNBIREZFICgeKwgEkyY7p0/3PT3/a9za65prsvfYnPwlVVf52tXqYi4iIFCwFjURERCSSlGmUW0cc4X/+/OewZAm8+Wb2Xvucc3r6GpWUZO91RUREZGQpaCQiIiKRpEyj3FqyBCoqcvPaNTVw772wbBn84he5eQ8RERHJvXi+ByAiIiKSTHGsuPt2RXGOohtj2Pz5UFw8+POG68wz/T8REREpXMo0EhERkchTeVr2LVkCra35HoWIiIhEmYJGIiIiEnkqT8u++nqYPbvnflz55yIiItKHgkYiIiISeco0yo21a3uCReXl+R2LiIiIRI+CRiIiIhJ5yjTKjfPP71ndLFjtTERERCSgoJGIiIhEnjKNcmPZMjjrLH/7u9/N71hEREQkelS9LiIiIpFXXqzaqVy55x7YsQMaG/M9EhEREYkaZRqJiIhI5BWZDllyJR5XwEhERESS0xGYiIiIiIiIiIj0o6CRiIiIRFZxUXG+hyAiIiIyZiloJCIiIpEVL1L7RREREZF8UdBIREREIktBIxEREZH8UdBIREREIitWFMv3EERERETGLAWNREREJLK0apqIiIhI/uhITERERCKrtqw230MQERERGbMyahRgZuOBnwAzgTeAi5xze/s8pxH438BkoAvY6Jy7NZP3FRERkbHhL1/8S76HICIiIjJmZZppdC3wuHNuHvB44n5fncCXnXOHA8cCV5nZogzfV0REREREREREcijToNG5wF2J23cB5/V9gnNuh3Pu+cTt/cCfgMMyfF8REREREREREcmhTINGk5xzO8AHh4CJAz3ZzGYCRwPPZPi+IiIiIiIiIiKSQ4P2NDKzx/D9iPq6Pp03MrMq4H7gaufc+wM8bwOwAWD69OnpvIWIiIiIiIiIiGTJoEEj59zpqR4zs51mNsU5t8PMpgC7UjyvGB8wuts598Ag77cR2AiwfPlyN9j4REREREREREQk+zItT3sQWJ+4vR74Rd8nmJkB3wf+5Jz7dobvJyIiIiIiIiIiIyDToNFNwCozexVYlbiPmU01s4cSzzkBuARYaWYvJv6dneH7ioiIiIiIiIhIDg1anjYQ59we4LQk27cDZyduPwlYJu8jIiIiIiIiIiIjK9NMIxERERERERERGYUUNBIRERERERERkX4UNBIRERERERERkX4UNBIRERERERERkX7MOZfvMaRkZruBN/tsbgDezcNwJHOau8KkeStcmrvCpHkrXJq7wqR5K1yau8KkeStcmrvClGreZjjnJgz2y5EOGiVjZpudc8vzPQ5Jn+auMGneCpfmrjBp3gqX5q4wad4Kl+auMGneCpfmrjBlOm8qTxMRERERERERkX4UNBIREREREREfG/h4AAAGOElEQVQRkX4KMWi0Md8DkGHT3BUmzVvh0twVJs1b4dLcFSbNW+HS3BUmzVvh0twVpozmreB6GomIiIiIiIiISO4VYqaRiIiIiIiIiIjkWEEFjczsTDN7xcxeM7Nr8z0eSc7MGs3s12b2JzPbYmZ/k9g+3sweNbNXEz/r8j1W6c/MYmb2gpn9R+K+5q0AmFmtmf3UzF5O/O0dp7mLPjP7UmI/+ZKZ/djMyjRv0WRmd5rZLjN7KbQt5VyZ2XWJ45VXzOzD+Rm1QMq5+2Zif/kHM/uZmdWGHtPcRUCyeQs99hUzc2bWENqmeYuIVHNnZl9IzM8WM7s5tF1zFwEp9pVHmdnTZvaimW02s2NCj2neImA4597pzl3BBI3MLAb8G3AWsAhYZ2aL8jsqSaET+LJz7nDgWOCqxFxdCzzunJsHPJ64L9HzN8CfQvc1b4XhVuD/OucWAkfi51BzF2FmdhjwRWC5c24JEAM+huYtqjYBZ/bZlnSuEt95HwMWJ37n9sRxjOTHJvrP3aPAEufcUuDPwHWguYuYTfSfN8ysEVgFvBXapnmLlk30mTsz+xBwLrDUObcY+FZiu+YuOjbR/2/uZuAfnXNHATck7mveoiWtc+/hzF3BBI2AY4DXnHOvO+fagXvwOx6JGOfcDufc84nb+/Enr4fh5+uuxNPuAs7LzwglFTObBnwEuCO0WfMWcWZWDZwMfB/AOdfunNuH5q4QxIFyM4sDFcB2NG+R5Jz7LfBen82p5upc4B7n3EHn3F+B1/DHMZIHyebOOfeIc64zcfdpYFrituYuIlL8zQHcAnwNCDdm1bxFSIq5+yxwk3PuYOI5uxLbNXcRkWLeHFCduF2DP04BzVtkDOPcO+25K6Sg0WHA26H7WxPbJMLMbCZwNPAMMMk5twP8hxuYmL+RSQrfwR+IdYW2ad6ibzawG/hBorTwDjOrRHMXac65bfgrrW8BO4Am59wjaN4KSaq50jFLYbkM+FXituYuwsxsDbDNOff7Pg9p3qJvPnCSmT1jZr8xsw8mtmvuou1q4Jtm9jb+mOW6xHbNWwQN8dw77bkrpKCRJdmmpd8izMyqgPuBq51z7+d7PDIwM1sN7HLO/S7fY5G0xYFlwPecc0cDLaikKfISteXnArOAqUClmX0iv6OSLNExS4Ews+vxqf13B5uSPE1zFwFmVgFcjy+R6fdwkm2at2iJA3X48pmvAveamaG5i7rPAl9yzjUCXyKR1Y7mLXLSOPdOe+4KKWi0FWgM3Z9GT3qcRIyZFeM/tHc75x5IbN5pZlMSj08BdqX6fcmLE4A1ZvYGvvxzpZn9HzRvhWArsNU590zi/k/xQSTNXbSdDvzVObfbOdcBPAAcj+atkKSaKx2zFAAzWw+sBj7unAsOmDV30TUHH2T/feJYZRrwvJlNRvNWCLYCDzjvWXxWewOau6hbjz8+AbiPnjImzVuEpHnunfbcFVLQ6DlgnpnNMrMSfPOmB/M8JkkicdXg+8CfnHPfDj30IH7HQ+LnL0Z6bJKac+4659w059xM/N/XE865T6B5izzn3DvA22a2ILHpNOC/0dxF3VvAsWZWkdhvnoavQ9e8FY5Uc/Ug8DEzKzWzWcA84Nk8jE9SMLMzgWuANc65A6GHNHcR5Zz7o3NuonNuZuJYZSuwLPEdqHmLvp8DKwHMbD5QAryL5i7qtgOnJG6vBF5N3Na8RcQwzr3Tnrt4doecO865TjP7PPAwfoWZO51zW/I8LEnuBOAS4I9m9mJi298CN+FTUS/Hnyz9jzyNT9KjeSsMXwDuTgTVXwc+hb8woLmLKOfcM2b2U+B5fHnMC8BGoArNW+SY2Y+BU4EGM9sK3EiK/aNzbouZ3YsP3nYCVznnDuVl4JJq7q4DSoFH/fE2TzvnPqO5i45k8+ac+36y52reoiXF39ydwJ3ml3NvB9YnMvw0dxGRYt6uAG5NLNjRBmwA/c1FTFrn3sOZO+vJxhUREREREREREfEKqTxNRERERERERERGiIJGIiIiIiIiIiLSj4JGIiIiIiIiIiLSj4JGIiIiIiIiIiLSj4JGIiIiIiIiIiLSj4JGIiIiIiIiIiLSj4JGIiIiIiIiIiLSj4JGIiIiIiIiIiLSz/8HrenWSc0gXK0AAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2420,7 +2296,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABIkAAACMCAYAAAD4MPn4AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXhcV5nn8e+pKu1SSbZkrZa8ybYkb4rjOIuz705CnNAkIWEgELpphsB008NAgO5puhkahoaeZklDBwgkDYQ9OJA9DiF7HDt2bGuzbNmytVt7aVdVnflDJUeOSpslVZWk3+d59Eh16+reV6Vb59567znvMdZaRERERERERERkYXOEOwAREREREREREQk/JYlERERERERERERJIhERERERERERUZJIRERERERERERQkkhERERERERERFCSSEREREREREREAFe4AxhPWlqaXb58ebjDEBERERERERGZN/bu3dtsrV3y7uURnSRavnw5e/bsCXcYIiIiIiIiIiLzhjGmOthyDTcTEREREREREREliUREREREREREJMKHm9FcCT++MdxRiIiIiIiIiIjMe+pJJCIiIiIiIiIiEd6TKG01fOTxcEchIiIiIiIiIjJ/3GOCLlZPIhERERERERERUZJIRERERERERESUJBIREREREREREZQkEhERERERERERlCQSERERERERERGUJBIREREREREREZQkEhERERERERERlCQSERERERERERGUJBIREREREREREZQkEhERERERERERlCQSERERERERERFmKElkjLneGFNhjDlijLkvyPPGGPPtwPMHjDGbZ2K/IiIiIiIiIiIyM6adJDLGOIH7ge1AEXCnMaboXattB1YHvj4GfG+6+xURERERERERkZnjmoFtbAWOWGurAIwxvwB2AKUj1tkBPGyttcDrxpgUY0yWtbZ+vA139Xt59WjzGcsy3LGsWpI4A2GfveqWblLio0mOi5pw3eaufnx+S4Y7NgSRLVzVLd2kJsaQGDMTh7SEWm17L9Ut3eEOY0xLU+LJS40PdxgS0NE7SFe/l5yUuLPeRl17L8eDHHNRTgfFuSlEOTUaW2S+G+vcEx1oB1yTaAdm6/qjo3eQzt5BchfP/Lnn6Kkuli2On9TfN1u6+70crO3Ab+20tpO7KH5WXiMRkflirGve8czEGS0HODnicQ1w/iTWyQFGJYmMMR9jqLcR0Zn53PWDN0bt8MqCdD55ZT6b8xZNL/Ip6vf6+PauSr7/5yoSop3ce0U+d1+0nNgo56h1O3oH+f6fj/Lgy8eIcTn4wYe2cP7K1JDGu1D8es9J7vvdQZLjovjUlfncdX4eMa7R/xOJPE2ePr69q5Jf7D6J1z+9C8XZFOU0fOO2Tewozgl3KAveU4ca+PvfH6Sr38t37tzMNUUZU/r95q5+vrOrkp+9cWLMY27pojg+ftkqbtuyVG2JyDw0fO55ZPdJfGO0A3mL4/nE5at47+alRLvOTKZYa3njWCvfff4ILx9pJjkuinu2reDDFy0nOX7iG4jjaenq50cvH+Ph16rp6vdyZUE6916Rz7nLpn/Na63l3549zHeeP8IVa5dw/wc2Ex8d2ptrHb2DPPzqcX70yjHaewanvT2nw3D7lqX87dVrdENWRGSEI01d/McLR9i5v27Mc91YjJ1mBt8YcxtwnbX2LwOPPwhstdZ+asQ6jwNftda+HHi8C/istXbveNsu3FBsf7xz1xnL3jzWyoOvHKOtZ5Bt+al88orVXLByMcaYaf0dEzlY08Fnfv02FY0e3rs5h/aeQZ4vbyIrOZZPX72G927OweV00Dfo4+HXjnP/n47S2TfIzZuyOVTbwcm2Xr51RzHbN2TNapwLibWW/3jhKP/6dAUXrUrFWnitqoXcxXF85tq1vGdjNg7H7B4XcnY8fYP84MUqfvDSMQZ9fu7cmsf2DZk4Zvl9fDashX9/7jBvHGvl728s5C8vWRnukBaktu4BvvSHEnbur2NdthuXw3CwtoOv3LqBO7fmTfj7Xf1efvhSFT94sYo+r587zsvlpo1Zo4655q5+fvjSMfafbCfDHcPHLl3FXVvziItWskhkrvP0DfLAi1X8MHDuuev8PLavz+Ldp54mTz8/fKmKAzUdZCfH8teXreKO83KJcTl4sbKZ7z5fyZvH20hLjOHDFy3j7ZoOni1tJDHGxQcvXMZHL15BWmLMlGJr7OzjgRer+Nkb1fR7/dywIYv8JYk8/NrxGbnm9fr8fOHRg/xqTw0XrkzljWMtbFiawoN3byF1irGejdbuAR58+RgPvXocT7+XqwrS+cAFedNKUlkLT5c08LM3qnE6DPdsW8FfX7ZqUj39RUTmq9K6Tu5/4QhPHKwnxuXgA+cv46rC9KCfsy5clbbXWrvl3ctnIkl0IfAla+11gcefB7DWfnXEOv8JvGCtfSTwuAK4fKLhZlu2bLF79uwZtby738vP3zjBf75YRXNXP1uWLQp6hyXa5SA/PZF12W6WpyacVbfaAa+f7z5fyf0vHCUtMZqvvXcjVxSkA/B6VQtfe7Kc/SfbyU9P5JbibH7+xgnqOvq4bM0SPnv9WtZlJ9PWPcBHH3qTfSfb+aeb1/GhC5cH3VdXv5fGzj5WpiXMetJrrvP5Lf/0hxIefq2aW4qz+fr7NhHlNLxY2czXniynrL6Toiw3n7oyn7SkyV38OB2GDTnJGmYyQyobPbT3jr5LeKCmg/v/dITW7gFu2pjFZ65dy/K0hDBEOHl9gz7+7lf7eeJgA3958Qq+cEOhEpAz7GRrD72DPnIXxY9KyDxb2sgXHj1IW/cAn7pyNZ+4YhWDPj/3/uwt/lRxir+9ejV/c9XqoO1m36CPX+05ybd3VdLcNcD29Zl85rq14w5bttby6tEWvvN8Ja9XtZKaEM37t+ayaWkKRdluclLi1EaLRCBrLYcbu+jsG33ueftkO//xwtFJn3ustbxY2cx3dlWyp3ooIZThjqGkrpPs5Fg+fvkqbt+Se7o3eVl9J/f/6QiPBy7Kd2zKIWWSvYqauwb4w9t1+KxlR3E2n7g8n/z0oTYq2DXvX126kqsK0id9Xdsz4OWTP9/H8+VN/I8r8/n0NWt4trSRTz2yj+yUOB6+Z2vQIVstXf089nYdAEVZbgqy3EETMC1d/ZTVeyir76S5q3/U8x29g+zcX0ef18f29Zl84vJ81uckTyr2yTjR0sM3n61g5/46UuKjuPfyfIrzUib9+yvTEkKSKJtPvD4/B2s7gvbIzUmJI3saw8Fl4eju99Lc1c+y1Mj+HBAp/H7LybYeyuo7KW/w0DvgG7VOZVMXz5c3kRjj4kOBmxbjtW/GmFlLErmAw8BVQC3wJnCXtbZkxDo3Ap8EbmBoKNq3rbVbJ9r2WEmiYcMX/z986RhNnr5Rzw/67OmuVTEuBwWZSRRmuclwx466axTM8B2K8oah3kP/eNO6Ud2IrbU8daiBf326gqrmbjYuTea+6wu4KD/tjPV6B3x86pF9PFfWyL1XrOIz167FGMOgz89Llad4dF8dz5Y20DfoZ9WSBG4pzuGWc3I0zjqIvkEfn/7lfp481MBfX7qSz11fcMYHdr/f8tjbdXzjmQpq2nqntO1MdywfumgZd23NIyU+eqZDn/e8Pj/PlDbyo5ePsbe6bcz1LlqVyn3bC9i4dPIXceHm81v++Q8lPPRaNTdvyuYbt20aNQRBpqalq5/HD9bz6L5a9p1oP708LTGGvMVx5C2Op3fQx9MljRRmufnGbRtZl/3OB4tBn5/P/+4gv9lbw51bc/nyjvW4nA58fsvrVS08uq+Wpw410NXv5fwVi/nc9oIpD1N+8/jQkJIXK08xfLp0x7oozHJTlO1m09IUzl22iKWLlDgSCZeqU13s3F/HY2/Xcax57LoL2/JTue/6QjYsnXyCYnho2f1/OsIpTz8fvmh50CFow440dfG9F47y1KF6fJO8xo5yOLhpUzb//bJVY9a/G77m/f4LR6nr6CMrOZa7tuZxx9Zc0pPGHmbV2j3APT95kwM17Xz5lvV84Pxlp5/bW93KPT/ZQ5TTwU8+ch7rc5Kx1vLWiTb+67VqnjjYwIDPf8b2clLiKMxyk7s4jmPN3ZTVd9LY+U5iKMblGHWN7TSGa9dl8onLV7E6I2lSr8nZOFTbwf99qpyXKpsnXnmEKKfhmqIM7tyax7ZVaboJNI6O3kF+sfsED716nLqO0Z+9hm1dvphbzsnhhg2Zo66nrbXUtveyt7pt3PfrZC1OiGZz3iIKMpPCWmdLJq+2vZeHXj3OI7tP4OnzsiEnmTu35nFzcfaCrC/b7/XxVnU7b51oY/BdbS4MteNl9Z2U1Xvo6vcCYMxQe/tuSbFR/Lfzl016+POsJYkCG78B+HfACTxorf2KMebjANba75uhK+fvAtcDPcBHrLVjZ38CJkoSTWTQ5+foqS5K6zopq++kNPDitnYPTHobWcmxfHnHeq6eoO7FoM/P8eZu8tMTx/yg4PX5+YedJTyy+wS3FGfjjovijwfqae0eYFF8FDdtzGZ1RiKPH6jnjWOtAJy7bBG3nJPDxpxk4qKdxEU5iY1yEhftJMbliMjhOePx+S19Xh99Az56B4e++gb9+Pyj3xDB+C3869MV7D7Wyj/cVMRHL14x5rrDb7jJjsFs7x3gkd0neOVIC3FRTt537lI+sm05K8NcKH0u8PQN8ss3T/LjV45T295L7uI4PnzRCtYGuRhMiY9iXbZ7Tn6gttbyvT8f5etPVbAtP5XPXldAfPQ778nYqKm/L53z4GLUWkuwt5m1ln6vn77T73UfvQN+qpqHPtC9ePgUXr+lIDOJW87JISs5lpq2Xk609HCyrYcTrT209wxyz8Ur+OQV+UE/lFlr+eYzh/nun45wdWE6K5cksnN/LY2d/STFuNi+IZP3bl7K+SumNyy5Z8BLeYPnjPNJeb2H3sGhuzhLkmI4N2+oV+vGpclkJseyOCGaxBjXnDzWRSJdU2cffzhQz879tRyo6cAYuHBlKu/ZlE3uotGJlpT4qBntvRIuXp+f58qa+Nkb1bxU2YzLYbhuXSZ/cW7OqF4+fYN+/uH3h6ht7+Xbd57DdesyR23vSJOHux98k47eQf7qkpU8VdJAWX0niTEu/mJzDh+4YBnJcVGBa+ih6+jSug5q2npZkZZAUSBhXpg19LU4Ifw32ErqOmjrnly9I5+1vHj4FL97q4a2nkFyF8fx/vPyeN+5S6c8ZDCUHIaQnluqW7r58SvH+dWek/QM+Lhg5WLuOn8Zi9+dAMJyoKaD371Vw9FT3UQ5DVesTefGjVmc8vTz1ok29la3nZFYnClxUU6Kc4du3GxelkJ6Uuzpz07x0UPXadFOx5w6J491fTUWAyFNclprp/R67j/Zzg9fquLJQw0AXL8+k01Lk/nt3loqGj3ERzu5eVM2d27NY01G0jvXjoM+egd8DPj8xLgcQ9fdw1/RTlwOM6f+r35rqWjw8MqRZl4+0sybx1vpGxz7s3BijIvCrCSKAu1sUbabNRlJQesiT9WsJolmy3STRGOZ6t88kwedtZZv7ark35+rJMbl4JqiDG49J4dLVi854wNQTVsPj71dx6Nv1VLZ1DVj+58PopyGb95ezM2bsmdl+2X1nTz48jF27q9j0O9n49KUoJnaqUhPimFbfhoX56cF7R3W0TPIa1VDDcXhxuD/73u2Lef69WdX06p3wMcXf39wyj2rJsVCaX0nXf1eti5fzD0Xr+Caoox5kfwYy2/21vC53x6YchG4YKKdDuKinSREO4mPcZEQ7RwqlhyhL5+1lp6BoZN194CXnv6h71N9KTLdsew4J5tbinMozHJPO67/eu04//uxElwOw2Vr0rn1nByuKkyfkRPoWHz+oZP83hNtvFU9dOF7orXnjHWiXQ5SE6JJTYxmZVoi2/JT2ZafxtIgH2JFZHydfYM8daiBx/bX8erRZvwW1ue4uaU4h5s2ZpOZvLAKFx9r7uZnr1fz6701dAQZ3g2QHBfFj+7ewpbli8fcTkNHHx/+8W7KGzwUZrn54AXL2FGcTcICuqPfN+jj6ZIGfrH7JK9VtYQ7nAm5HCZw7eAiPmboe2zU7CRABrx+3q5px+UwvGdTNh+9eMUZvXqDsdZSUtfJ7/fVsvPtOk55hpJCSxfFcW6gTMjmvEWszUzCNc3rxbqOPvZWv3MeLq3vHPP6zOkwxEc5iY0OJI4CCaRI6IFkraV30Hf6uqpnwEfPgG/K15oxLgcJMS7iRxwf0y6lYYduvncP+Ojp99ITiHM4aZMQ4yIuyklCjJP4aBfRTseo69jO3kHKGzwkxbq4c2sed1+0/PQstdZa9p1s55E3TvDHA/Wnb8AtBKvTE09/Rty6cjFJY7S7s5UEU5Iowhxr7iYtMZqk2PG7gVlrqWj0UNvWezqL2uf10zcwlFmN3P9ecA4DscO9oU73vnDgcky+8cpbHB+SGjanPP389PVqdh9rxU7jlbYWjrd0n75rkrc4nm35aWxZtoijp7p45UhzYBpYiI92si7bPSrBcrixi9zF8ey8d9tZxfDVJ8r4zxer2LpiMbORu8lJiefui5bNqeFj03X0VBfHTnWfvsvRN6Jn3GRZC33eoRNu94jES18EnxwNhvgRCa3hi9Qo5+ghBjB0sTLcy2r4fZ+aGE3x0pQZv9t1srWHxBgXi8J4J/uUp5/S+k6aPf20dPfT0j1AS9cAzV39lNR1nr5QXp461A5cuCp1SkVW3bFRZCbHkpYYM68TsXOZ1+dnT3XwLuPTZTAU56VEZHf81u4BSuo6ZmXbbT2DPHmwnl3lTQx4/SxLjWfHpmxuLs45XbtnIesb9PFWdVvQ+jAFmUmkT2LWr+5+L9UtPRRmJc2pO/Kz4VhzN8+UNNDvnfn38EywFgZ8Prr7ffQMvHP90DPgnbV9nrd8MR+8YNmkjqV38/ktB2s7yEqODckMdD0DXkrqOmnrHhhKugRen6Gfh5IvfYHlw895JzmiYTYZhhJ/I5M78dFOop3OSZVJgcCIjcF3buL1BK4rZ+J8FON6Jwk0fGMz2ukIXMeeeeMw2P6cDsPVhRnctiV33HNYZ99Qe9/WM0jsiGvIuCgnUS4HA8M91AeGr739s3K+nW1LF8WxLT8t7LMyKkkkEkbWWo6e6uLlymZePtLCG1UtePq9uByGc/JSuGhVGhevTmPT0pSgQ2q++3wl33jmMLu/eNW4tQeCOVDTzi33v8Id5+Xy1fdunKk/SUSmyFpLZdNQO/DKkWZer2qhO0jRwclwOgzpSTFkuGNZmZbAV27doBnYZkBXv5cvPVZCV9/oD1sbc5P5xOX5E27jt3tr+J+/fns2wgPgrvPz+JdbN8za9s/WnQ+8Pqs9MNISo7lpYzY7irMpzk1Z8IkMERGR6RorSRR5t6JE5iFjDPnpSeSnJ/HhbSvw+vxUNg31DprMHeErCzL4xjOHeaH8FLeflzvp/Q76/Hz2NwdIS4zhvu2F0/kTRGSajDGsyUhiTUYS91y8gkGfn4oGz6R7jlmgvWeQhs4+Gjp6aejo51hzF7/bV8st5+Rw6Zols/sHLABPHKjnN3tryE9PxDkiCdHSPcCu8kb+8uKVExasP1DTTkK0k5/cs3XGR43+xwtHeepQA1/esT6iepJVneritaoWPrJtOTduOLth0eOJdjkoynJHxJAQERGR+U5JIpEwcDkdU6rDUpiVRFZyLLvKG6eUJHrgxSrKGzz85wfPndKQFhGZfVFOx7QL6Xb0DLLpn5+htL5TSaIZ8MeD9eQtjufZT196Rk+VP7xdx6ce2Udlk2fCWhxlDR7WZiZx3jg1YM7W+87t5/nyJnYfa+XCVakzvv2z9as9NTgdhv9+2aqzGo4iIiIikUO3ZETmAGMMVxak81JlM/3eyfU6OHqqi2/tquTGDVlBZzQRkbkvOT6KnJQ4Sus6wx3KnNfWPcArR5q5cWPWqKFMRdlDSf2JXmdrLWX1nTNSjD2Yy9cuITbKwVOH6mdl+2dj0OfnN3truLIgXQkiERGReUBJIpE54urCDHoGfLxR1Trhun6/5b7fHiAuysmXbl4XguhEJFwKs5Ioq1eSaLqeLmnA57dBh0stT00gLspJWb1n3G3UdfTh6fPOWpIoPtrFZWuW8FRJA/4ZmF1xJjxf3kRzVz/vn0IvVxEREYlcShKJzBEXrkolNsrBrrLGCdf92e4TvHm8jb+/sZAlSTEhiE5EwqUoy83RU10RPSveXPD4wXqWp8azLnt0gsfpMKzNTKK0fvzZu8oCPY0Ks5JmJUaA69dn0tjZz/6a9lnbx1T88s2TZLhjuEzDHUVEROYFJYlE5ojYKCcX56exq7yJ8WYlrGvv5WtPlHHJ6jTed+7SEEYoIuFQmOXGb+Fw4/i9XGRsrd0DvHq0JehQs2FF2W7K6j3jtr/DPbrWZs5OTyIYmsggyml46lDDrO1jsuo7enmhoonbzs1VUWkREZF5Qmd0kTnkyoIMatp6qWzqGnOdf/pDCX4L/3LrBk0RLLIATLZejoztnaFm2WOuU5jlpqN3kLqOvjHXKW/wsCx1crNWnq3kuCi25afx5KH6cRNWofCbPTX4Ldy+RUPNRERE5gsliUTmkCsL0gHYVdYU9Pndx1p5uqSRe69YRe7i+FCGJiJhkrtoKCmhukRn7/ED9axMSxh3mFhR1sTJuLL6TgoyZ2+o2bDt6zM52dpLaRj/536/5Zd7TrItP5W8VJ1vRERE5gsliUTmkMzkWNbnuHm+fHRdIr/f8pXHS8l0x/LRi1eGIToRCQeHw1CQmRTWhMFc1tLVz6tHg89qNlJBZhLGMGYyrnfAx7GW7lkrWj3S1YUZOAxhHXL26tEWatp6ueO8vLDFICIiIjNPSSKROebKggz2VrfR1j1wxvI/Hqzn7ZoOPnPdWuKinWGKTkTCYbheTqTMeDWXPFXSgN/CjRtHz2o2UkKMi+WpCWP2JKpo9GAtFMxiPaJhqYkxnL8ilSfDmCT6xZsnSImP4tqijLDFICIiIjNPSSKROeaqgnT8Fl44/M6Qs36vj68/VU5hlptbz8kJY3QiEg6FWW66+r3UtPWGO5Q55/ED9axaksDajImHiRVmJVHWEDxJNNzDqCgEPYkAtm/I5EhTF0eaQl+wvLV7gGdKGrn1nBxio3RTQkREZD5RkkhkjtmQk8ySpJgz6hI9/Go1NW29fOGGApwOFasWWWhO18uZYIp2OdMpTz+vV7Vw48bsSRX6L8pyU93Sg6dvcNRz5fWdJMa4WLoobjZCHeW6dZlAeIacPbqvlgGfnzvOU8FqERGR+UZJIpE5xuEwXLk2nT8fPsWgz097zwDfeb6Sy9Ys4ZLVS8IdnoiEwdrMJBwGSutD36tkLhseanbTBEPNhg3PJFfRMPp1Lqv3DP0fQpSoz3DHsjkvJeRDzqy1/PLNExTnpoRkaJ2IiIiElpJEInPQlYXpePq87DnexneeP0JXv5fP31AQ7rBEJExio5ysXJI47sxbMtrjB+pYnZ7ImkkMNQNOF6V+d5Fway1lDZ3jzo42G7avz6KkrpMTLT0h2+fB2g4ON3bxfvUiEhERmZeUJBKZgy7OTyPa6eAnrx7j4deOc9u5ubqjK7LAFWa5x5x5S0Zr8vTxxrHWCQtWj5TpjmVRfNSoZFxtey+ePm9IZjYb6fr1gSFnJfUh2+e+E+0AXFGQHrJ9ioiISOgoSSQyByXEuLhgVSpPlzTicjj4u2vXhDskEQmzoiw3te29dPSMrpcjoz11qAFr4cYNk08SGWOCJuPKAsP8Qp2sz10cz/ocd0jrEpU3eEiJjyI9KSZk+xQREZHQcYU7ABE5O1cVpPPi4VP81SUryHDHhjscEQmz4aFOZQ2dXLAyNczRRL7H9texNiOJ1ZMcajasKMvNf71ejdfnx+UcutdWHkgaFWSGdrgZwPXrMvnGM4c598vPjnruwlWpfPP2TcS4Zm4GsoqGTtZmJE2q0LeIiIjMPUoSicxR792cQ2fvIB+9ZEW4QxGRCDBcVLm0TkmiiZQ3dLKnuo3Pb596LbfCLDf9Xj/HW7rJT38nMbcsNZ6EmNBfVt25NY/W7kEGfL4zlvf0+/jdvloGfX7uv2vz6YTWdFhrOdzYxV9szpn2tkRERCQyKUkkMkclxUbxqatWhzsMEYkQ6UmxpCVGjyqqLKP99PVqYlwObt8y9eLLw8m4krrO00mi8noPhWGqC5eaGMP/fk9R0Oc2LE3mn/5Qyv/6zQG+edumac+8VtPWS1e/l7WqgSciIjJvqSaRiIjIPKHi1RPz9A3y6Fu1vGdTNosSoqf8+6uWJBLtdJyuQ9Qz4OVYS3fIi1ZPxke2reB/XbeWR/fV8vc7D2Gtndb2KhqG/ua1YRhWJyIiIqGhnkQiIiLzRFGWmx+/cpxBn5+oGRheNB89uq+W7gEfH7xg2Vn9frTLQX564ukeWxUNHqyFgqzITJzce0U+Xf1evvfCUeKjnHzxxsKzridU0agkkYiIyHynJJGIiMg8UZTtZsDn5+iprpDPtDUXWGv5r9eq2bg0mU25KWe9naJsNy9UnAKGZvuCoQRdpPrsdWvp6ffyw5ePkRDj4tPXnN2MmOUNHpYuiiMxDLWXREREJDR0m1FERGSeGB7yVFqnIWfBvF7VSmVTF//tLHsRDSvMctPc1U+Tp4+y+k4SY1wsXRQ3Q1HOPGMM//iedbzv3KV8a1clfypvOqvtVDR0hmUGNxEREQkdJYlERETmiZVpCUS7HKpLNIafvl5NclwUN2/KntZ2hnsNldV7KK/3UJAZ+VPCOxyGf7l1A9FOB69XtUz59we8fqpOdWuomYiIyDynJJGIiMg84XI6KMhM0gxnQTR29vF0SQO3b1lKbJRzWtsqGtFjq6yhMyKLVgcT7XKwJjORkrPoaXb0VBdev9XMZiIiIvOckkQiIiLzSGGmm7J6z7RnsppvHtl9Aq/f8oHzpzfUDCA5PoqclDieLW3A0+eN2KLVwazLSqa0vnPKx8fwzGYabiYiIjK/KUkkIiIyjxRlu2ntHqCxsz/coUSMQZ+fR3af4NI1S1ieljAj2yzMSuKtE+2Bn+dO75qzPT7KG9N057IAABFLSURBVDxEOQ0rZuj1ExERkcikJJGIiMg8crp4dX1HmCOJHM+VNtLY2c+HplmweqThIWfGwNqMudO7pih7KO6SuqkdHxUNnaxakkiUU5eOIiIi85nO9CIiIvPI8NCnsnpPmCOJHA+/Vk1OShxXFKTP2DaHky3LFseTMIemhD/bGfAqGjwaaiYiIrIAKEkkIiIyj7hjo8hdHDflJMB8daTJw2tVLdx1fh5Ox8zNQDacbJlLQ80AEmNcLE+Nn1Jx847eQeo6+lS0WkREZAGY1q0vY8xi4JfAcuA4cLu1ti3IescBD+ADvNbaLdPZr4iIiIxtY04Kbx5vxe+3OGYwMTIXPbqvFqfDcMd5uTO63dxF8RRmubl87ZIZ3W4oFGW7pzTD2eFGFa0WERFZKKbbk+g+YJe1djWwK/B4LFdYa4uVIBIREZldVxak0+Tp50Ct6hI9U9LIecsXkZYYM6PbdTgMT/7NJdxxXt6MbjcU1mUnU93SQ2ff4KTWLw/MbLZWSSIREZF5b7pJoh3AQ4GfHwJumeb2REREZJquLEjH6TA8W9oQ7lDC6nhzN5VNXVxTlBnuUCLKcNHt8knWrapo6CQp1kVWcuxshiUiIiIRYLpJogxrbT1A4PtYFSEt8IwxZq8x5mPT3KeIiIiMY1FCNFuWLeLZ0sZwhxJWw3//tUUZYY4ksgwX3S6d5Axn5fVDRauNWdhDF0VERBaCCZNExpjnjDGHgnztmMJ+tllrNwPbgXuNMZeOs7+PGWP2GGP2nDp1agq7EBERkWHXFGVwuLGL6pbucIcSNs+WNlKQmUTu4vhwhxJR0pNiSEuMnlRdImstFY0eDTUTERFZICZMEllrr7bWrg/ytRNoNMZkAQS+N42xjbrA9ybgUWDrOPt7wFq7xVq7ZcmSuVcMUkREJBJcGxhitVB7E7V2D7CnulW9iIIwxlCY5Z7UDGd1HX14+rya2UxERGSBmO5ws8eAuwM/3w3sfPcKxpgEY0zS8M/AtcChae5XRERExpGXGk9BZhLPLNAk0a6yRvwW1SMaQ1G2m8rGLga8/nHXq2gYSiRpZjMREZGFYbpJoq8B1xhjKoFrAo8xxmQbY54IrJMBvGyMeRvYDTxurX1qmvsVERGRCVxTlMGe4620dg+EO5SQe7a0kazkWNbnqAdMMOuykxnw+Tl6qmvc9YZnNluToSSRiIjIQjCtJJG1tsVae5W1dnXge2tgeZ219obAz1XW2k2Br3XW2q/MROAiIiIyvmuKMvDboV41C0nvgI8XK09xdWGGii2PYXiGs4nqElU0eMhOjiU5LioUYYmIiEiYTbcnkYiIiESoDTnJZLpjF1xdopePNNM36Oca1SMa04q0BOKinJROIkmkotUiIiILh5JEIiIi85QxhquL0nmpspm+QV+4wwmZZ0sbSIpxccHK1HCHErGcDkNBVhKl9R1jrjMYGI6motUiIiILh5JEIiIi89g1RZn0Dvp4ubI53KGEhM9v2VXWxOUF6US7dJkznqIsN6V1nVhrgz5fdaqbQZ9V0WoREZEFRFdPIiIi89iFK1NJinEtmCFn+0600dI9oKFmk1CU7aazz0tNW2/Q58sDM5tpuJmIiMjCoSSRiIjIPBbtcnDZ2iXsKm/E5w/eY2Q+eba0kSin4fK1S8IdSsRbl50MQGl98LpEFQ0eXA7DqiWJoQxLREREwkhJIhERkXnumqIMmrsG2H+yLdyhzCprLc+UNnLBylTcsZqNayJrM5JwGMYsXl3R4GHlkgQN2xMREVlAdNYXERGZ5y5fm47LYXimZH4POTt6qotjzd0aajZJcdFOVi5JpCRIkqi1e4B9J9spUNFqERGRBUVJIhERkXkuOS6KC1amzvu6RM8E/r6rC5Ukmqx12W7K3jXcbMDr5+M/3UtXv5ePXrwiTJGJiIhIOLjCHYCIiIjMvmuKMvjHx0r47d4achfHkxTrCnxFkRDtxBgz6necjtHLIkXfoI/OvkE6e714+gbx9Hn5w9v1rM9xk50SF+7w5oyiLDc799fR3jNASnw01lr+4feH2H2slW+9v5hNuSnhDlFERERCSEkiERGRBeDadRn8n8dL+Z+/fnvSv/Ppq9fwN1evnsWozs6/PXuYb++qDPrc564vCHE0c1tR9tBwstK6Ti7KT+NHLx/jl3tO8skr8tlRnBPm6ERERCTUlCQSERFZALKS43j5c1dS39F3uufN8PeeAd+o9Xfur+W5ssaITBI9V9pIQWYSH7hgGe4RPaKS46LI10xcU1KUFUgS1XfS7/PzL0+Ucd26DP7umjVhjkxERETCQUkiERGRBSLDHUuGO3ZS6/YN+njgxSr6Bn3ERjlnObLJ6x3wUdHo4d7LV/HBC5aFO5w5LzUxhkx3LE8eauBwg4eCTDf/745iHBE81FBERERmjwpXi4iIyCjFuSl4/ZaSuo5wh3KGg7Ud+PyW4jzVypkpRdlu9la3ERPl5Id3byE+WvcQRUREFioliURERGSU4STMvhPtYY7kTPtPtgGwaamSRDNlc14K0S4HD3zoXBX9FhERWeB0q0hERERGSU+KJScljv0nIy1J1E7u4jhSE2PCHcq88bFLV3H7llzSJzkUUUREROYv9SQSERGRoDblJkdekuhEO8W5i8IdxrwS7XIoQSQiIiKAkkQiIiIyhuLcFGraemnu6g93KAA0dfZR19FHca6GmomIiIjMBiWJREREJKjhHjv7I6Qu0b5AryYliURERERmh5JEIiIiEtSGnGScDhMxQ872n2wnymlYl+0OdygiIiIi85KSRCIiIhJUXLSTtRlJkZMkOtFOYZab2ChnuEMRERERmZeUJBIREZExFeel8PbJdvx+G9Y4fH7LgZp2DTUTERERmUVKEomIiMiYinNT8PR7qWruCmscR5q66B7wKUkkIiIiMouUJBIREZExnRNIyuwLc/Hq/SfbABWtFhEREZlNShKJiIjImFYtSSQpxhX2ukT7T7aTHBfFirSEsMYhIiIiMp8pSSQiIiJjcjgMG3OTw54k2neinU25KRhjwhqHiIiIyHymJJGIiIiMqzg3hfIGD70DvrDsv7vfy+FGj4aaiYiIiMwyJYlERERkXMW5i/D5LYfqOsKy/4O1HfjtO/WRRERERGR2KEkkIiIi4xruwbM/TMWrh4e6bVKSSERERGRWKUkkIiIi41qSFENOSlzY6hLtP9HOstR4FidEh2X/IiIiIguFkkQiIiIyoeK8lPAliU62qx6RiIiISAgoSSQiIiITOic3hdr2Xpo8fSHdb0NHHw2dfUoSiYiIiISAkkQiIiIyoXDVJdp/su2M/YuIiIjI7JlWksgYc5sxpsQY4zfGbBlnveuNMRXGmCPGmPums08REREJvfU5ybgcJuRDzvadbCfa6aAo2x3S/YqIiIgsRNPtSXQIeC/w4lgrGGOcwP3AdqAIuNMYUzTN/YqIiEgIxUY5KchKCnmSaP+Jdgqz3cS4nCHdr4iIiMhCNK0kkbW2zFpbMcFqW4Ej1toqa+0A8Atgx3T2KyIiIqFXnJvCgZoO/H4bkv35/JaDtR2co6FmIiIiIiHhCsE+coCTIx7XAOeHYL8iIiIyg4pzF/HT109wwVd34TBm1vfns5aeAZ/qEYmIiIiEyIRJImPMc0BmkKe+aK3dOYl9BLuKHPMWpDHmY8DHAPLy8iaxeREREQmFa9dl8OHa5fQO+EK2z7hoJ1cVpodsfyIiIiIL2YRJImvt1dPcRw2QO+LxUqBunP09ADwAsGXLltD0ZxcREZEJuWOj+NLN68IdhoiIiIjMkukWrp6MN4HVxpgVxpho4P3AYyHYr4iIiIiIiIiITNK0kkTGmFuNMTXAhcDjxpinA8uzjTFPAFhrvcAngaeBMuBX1tqS6YUtIiIiIiIiIiIzaVqFq621jwKPBlleB9ww4vETwBPT2ZeIiIiIiIiIiMweY23klv0xxniAinDHIXNGGtAc7iBkztDxIlOh40WmQseLTJWOGZkKHS8yFTpeZCzLrLVL3r1wWj2JQqDCWrsl3EHI3GCM2aPjRSZLx4tMhY4XmQodLzJVOmZkKnS8yFToeJGpCkXhahERERERERERiXBKEomIiIiIiIiISMQniR4IdwAyp+h4kanQ8SJToeNFpkLHi0yVjhmZCh0vMhU6XmRKIrpwtYiIiIiIiIiIhEak9yQSEREREREREZEQiMgkkTHmemNMhTHmiDHmvnDHI5HFGJNrjPmTMabMGFNijPmbwPIvGWNqjTH7A183hDtWiQzGmOPGmIOB42JPYNliY8yzxpjKwPdF4Y5TIoMxZu2IdmS/MabTGPO3amNkmDHmQWNMkzHm0IhlY7YpxpjPB65pKowx14UnagmXMY6XfzXGlBtjDhhjHjXGpASWLzfG9I5oZ74fvsglHMY4XsY8/6h9kTGOmV+OOF6OG2P2B5arjZEJRdxwM2OMEzgMXAPUAG8Cd1prS8MamEQMY0wWkGWtfcsYkwTsBW4Bbge6rLXfCGuAEnGMMceBLdba5hHLvg60Wmu/FkhGL7LWfi5cMUpkCpyTaoHzgY+gNkYAY8ylQBfwsLV2fWBZ0DbFGFMEPAJsBbKB54A11lpfmMKXEBvjeLkWeN5a6zXG/F+AwPGyHPjj8Hqy8IxxvHyJIOcftS8CwY+Zdz3/TaDDWvvPamNkMiKxJ9FW4Ii1tspaOwD8AtgR5pgkglhr6621bwV+9gBlQE54o5I5aAfwUODnhxhKNIq821XAUWttdbgDkchhrX0RaH3X4rHalB3AL6y1/dbaY8ARhq51ZIEIdrxYa5+x1noDD18HloY8MIlIY7QvY1H7IuMeM8YYw9CN9EdCGpTMaZGYJMoBTo54XIMSADKGQDb8HOCNwKJPBrpuP6jhQzKCBZ4xxuw1xnwssCzDWlsPQ4lHID1s0Ukkez9nXlipjZGxjNWm6LpGJnIP8OSIxyuMMfuMMX82xlwSrqAk4gQ7/6h9kYlcAjRaaytHLFMbI+OKxCSRCbIsssbESUQwxiQCvwX+1lrbCXwPWAUUA/XAN8MYnkSWbdbazcB24N5At1yRcRljooGbgV8HFqmNkbOh6xoZkzHmi4AX+FlgUT2QZ609B/g74OfGGHe44pOIMdb5R+2LTOROzrzZpTZGJhSJSaIaIHfE46VAXZhikQhljIliKEH0M2vt7wCstY3WWp+11g/8AHW3lQBrbV3gexPwKEPHRmOgvtVwnaum8EUoEWo78Ja1thHUxsiExmpTdF0jQRlj7gZuAj5gA0VCA8OGWgI/7wWOAmvCF6VEgnHOP2pfZEzGGBfwXuCXw8vUxshkRGKS6E1gtTFmReAu7vuBx8Ick0SQwNjaHwFl1tp/G7E8a8RqtwKH3v27svAYYxICBc4xxiQA1zJ0bDwG3B1Y7W5gZ3gilAh2xt03tTEygbHalMeA9xtjYowxK4DVwO4wxCcRxBhzPfA54GZrbc+I5UsCBfMxxqxk6HipCk+UEinGOf+ofZHxXA2UW2trhheojZHJcIU7gHcLzPLwSeBpwAk8aK0tCXNYElm2AR8EDg5P5wh8AbjTGFPMUDfb48Bfhyc8iTAZwKNDuUVcwM+ttU8ZY94EfmWM+ShwArgtjDFKhDHGxDM0y+bIduTramMEwBjzCHA5kGaMqQH+EfgaQdoUa22JMeZXQClDw4ru1cxDC8sYx8vngRjg2cD56XVr7ceBS4F/NsZ4AR/wcWvtZIsYyzwwxvFyebDzj9oXgeDHjLX2R4yuqwhqY2QSTKB3q4iIiIiIiIiILGCRONxMRERERERERERCTEkiERERERERERFRkkhERERERERERJQkEhERERERERERlCQSERERERERERGUJBIREREREREREZQkEhERERERERERlCQSERERERERERHg/wPyLjHfn/fs6AAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2432,7 +2308,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2447,14 +2323,15 @@ "output_type": "stream", "text": [ "tal hits:\n", - "\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.5853519199622497, precision_at_motif_score=0.17388317175756188, example_idx=11, start=125, end=150, is_revcomp=True)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.9987065898945097, precision_at_motif_score=1.0, example_idx=11, start=134, end=159, is_revcomp=False)\n", "gata hits:\n", - "\n" + "MotifHitAndCoord(motif_idx=1, motif_score=0.9971862166306695, precision_at_motif_score=1.0, example_idx=11, start=87, end=112, is_revcomp=False)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2473,7 +2350,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2485,7 +2362,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIcAAACMCAYAAADm+clLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3dfZBkV3nf8d8z/TLTvbu9M6AV4N2VJSdrJ4ICm9rIYJIAtnFWNkFJlZOSCtsE26VSChFIYiciVLBTyR9UnDixYxmVCmTZZUChANlbKYGkwilIxUjWSrzoBeRsCYKWJV4JpruH7e7ttyd/3Htn7/b2TN/Z6ds99/b3UzU13efeuzqjI53tec5znmPuLgAAAAAAACympXl3AAAAAAAAAPNDcAgAAAAAAGCBERwCAAAAAABYYASHAAAAAAAAFhjBIQAAAAAAgAVGcAgAAAAAAGCBFefdgXGuuuoqv/baa+fdDQAAAAAAgNx4/PHHX3T3Q6PtE4NDZnaPpLdKOufurxpz3ST9jqSfldSS9E/c/Ynw2onwWkHSh939g0k6e+211+rUqVNJbgUAAAAAAEACZvZ/x7Un2VZ2r6QT21y/UdKx8OtWSR8K/4EFSXeG16+XdIuZXZ+8ywAAAAAAAEjbxOCQu39B0ve2ueUmSX/kgUckrZrZKyTdIOm0uz/n7l1J94X3AgAAAAAAYI+YRkHqw5Kej70/E7Zt1Y4v/bH01Kfm3QsAi+bUH0jPnJx3L4BM+3a9rfff/6R6g+G8uwIAADA10wgO2Zg236Z9/B9idquZnTKzUy+88MIUurWHPXKX9Ng98+4FgEXzxTulx++ddy+ATPv8sy/oo49+S9948fy8uwIAADA10wgOnZF0NPb+iKSz27SP5e53u/txdz9+6NBlhbPzpVMPvgBglph7gF1rtHuXfAcAAMiDaQSHTkr6JQu8TlLD3b8j6TFJx8zsOjMrS7o5vBftevAFALPiztwDTEEUFGoSHAIAADmS5Cj7j0t6k6SrzOyMpN+QVJIkd79L0gMKjrE/reAo+3eG1/pmdrukBxUcZX+Puz+dws+QLYO+1N2Ydy8ALJpeWxr2pE5j3j0BMq3ZIXMIAADkz8TgkLvfMuG6S3rXFtceUBA8QuRCM/je3QgCRYWJQwAAuxdtJ+vUgywiG1cWDsAkZA4BAIA8msa2MuxEvN5HFCgCgLRFGUPDvtRrzbcvQIY1N2sO9efcEwAAgOkhODRr8Xof7fX59QPAYrlk7qHuEHClmhSkBgAAOURwaNbi9T6o/QFgVph7gKlodvrhd4JDAAAgPwgOzVp8WxlHSgOYFeYeYCo4yh4AAOQRwaFZY/UewDww9wC75u6b28ooSA0AAPKE4NCsUfcDwDww92AG6q2uGq38Bk1a3YH6Q5dE5hAAAMgXgkOzxuo9gHlg7sEMvPe/f1m/9smvzLsbqYnXGdrocFoZAADID4JDs9apS9WrpKUidT8AzE6nLu1/+cXXQAqe/15Lz3+vNe9upCbKFnp5bYXMIQAAkCsEh2at05Aqq9LKKqv3AGan05CqL5WWa8w9SE2j3ct10KTZDrKFjr6kou9f6Ks/GM65RwAAANNBcGjW2nVp5WDwRd0PALPC3IOUubvqrZ7WW915dyU1UeDr6FpVElvLAABAfhAcmrVOI8gaqpA5BGCGyFpEyjYu9NUfujq9oTq9wby7k4rohLIjLwmCQ/EaRAAAAFlGcGjWOrHVe+p+AJgV5h6kLH5KWT2nJ5ZdzByqXPIeAAAg6wgOzRqr9wDmgaxFpCy+nSyvW8uiTKHDYXAoqkEEAACQdcV5d2ChuF+s+xG9BoC0DQfShWYw91xoMvcgFeuxbKG8Boca7Z72Lxf1kn3lzfcAAAB5QHBolnptadgLVu+lYPXeXTKbb78A5FuUKVRZlS5skDmEVNRjAaFGTreVNdt9HayUdLBSCt5TcwgAAOQE28pmKarzEdX9GPakXmu+fQKQf6NzT3dDGrAdBtNVvyRzKJ9Bk0a7pwMrRdVWSpvvAQAA8iBRcMjMTpjZs2Z22szuGHP9183sy+HXU2Y2MLOXhNe+aWZPhtdOTfsHyJT46n08ewgA0hTNM1HNISnYXgZM0aLUHDpYKalaLqi4ZJunlwEAAGTdxOCQmRUk3SnpRknXS7rFzK6P3+Puv+XuP+ruPyrpfZI+7+7fi93y5vD68Sn2PXvaI6v38TYASMvYuWd9fv1BLtVbPR1YLmqltHTJFrM8abZ7qlVKMjPVKiUyhwAAQG4kqTl0g6TT7v6cJJnZfZJukvTMFvffIunj0+lezsRX70fbACAtozWH4m3AlNRbXa3uK6k/8NweZd9s9zbrDR2slNTssD0TAADkQ5JtZYclPR97fyZsu4yZVSWdkPSpWLNLesjMHjezW6+0o7kwWvcj3gYAaWHuwQyst3paq5a1Wi3nuuZQVG+otlIkcwgAAORGksyhcUdp+Rb3/n1J/3tkS9kb3P2smV0t6WEz+7q7f+Gyf0gQOLpVkq655poE3cqgzdX7tcvbACAtl9QcInMI6aiHWTVB5lD+tpX1B0Od7w42M4dqlRI1hwAAQG4kyRw6I+lo7P0RSWe3uPdmjWwpc/ez4fdzku5XsE3tMu5+t7sfd/fjhw4dStCtDIrqfizXLm4to+YQgLS165IVpPI+6p0hNfVWV2vVstb2lVTPYdAk2kJWqxTD7wSHAABAfiQJDj0m6ZiZXWdmZQUBoJOjN5nZQUlvlPSnsbZ9ZnYgei3pZyQ9NY2OZ1KnIZUPSIVibGsHq/cAUtZpBPWGzDgpEalZP9/VWrWk1Wo5l5lDUSDo0ppDBIcAAEA+TNxW5u59M7td0oOSCpLucfenzey28Ppd4a3/UNJD7n4+9vjLJN1vZtE/62Pu/tlp/gCZ0qlfDAoVilJ5P3U/AKQvPveUKtJSibkHU9UfDNXs9HWwWlZ/MFS91ZO7K/z7Pxei+kIXaw4Fp5Xl7ecEAACLKUnNIbn7A5IeGGm7a+T9vZLuHWl7TtJrdtXDPIlW7yMrq6zeA0hfp3ExY8gsmIeYezBF0ZartWpQc6g/dH3/Ql8HwkBKHkRZQgerFzOHegNXpzdUpVyYZ9cAAAB2Lcm2MkxLO7Z6LwWvqfsBIG3MPUjZeriNLDitLAie5O04+8syh8LaQ5xYBgAA8oDg0Cx16hdX76Vw9Z5f0ACkrFMfk7XI3IPpiWoMHQxrDkkXA0Z50RhTc0gSdYcAAEAuEByapU7j8tV7tnYASBtzD1IWZQmtVctay2nmULM9clpZmEFE5hAAAMgDgkOz1B6zes/WDgBpcg+3lY1kLTL3YIrWN4ND+c4cKhVMlVJQX2gzc4jgEAAAyIFEBakxBYO+1N1g9R7AbPXa0rDH3INURdvKVsPTyoK2fAVNmp2eaiulzZPJahUyhwAAQH4QHJqVC83g++jqfXcjCBwVGAoAKYhqC42rOeQenF4G7FK91dOSSQeWixq6S8pn5lCULSSROQQAAPKFbWWzEv2CNrp6L10MHAHAtEUZQqNzz7Av9Vrz6RNyZ73V1Wq1rKUlU7GwpAMrxfxlDrV7OhALDh1YiU4r68+rSwAAAFNDcGhW2lus3ktSe332/QGwGKK5ZzRrMX4N2KV6q7d5hL0UFKau5yxzqDmSOVQqLGlfucBpZQAAIBcIDs3KVqv38WsAMG2bc088MM3cg+mqt7tajQVOVqulzSLVedHs9FVbuXQLeK1SouYQAADIBYJDs9LZZvW+w+o9gJRsVXMofg3YpfXzPa2Fp5RJQWHqes6CJqM1h6Sg7hA1hwAAQB4QHJoVMocAzANzD2agHtYciqxVS7naVubuarZ7myeURWorZA4BAIB8IDg0K9vWHGL1HkBK2mOK4VNzCFNWb19ac2i1UtL6+fwEh1rdgfpDvyxzqFYpqdmhIDUAAMg+gkOz0mlISyWpVL3YtrmtjNV7ACnpNKTyfqkQ+6V2hbkH03OhP1CrO9BaPDhULavZ6Wsw9Dn2bHqiotNsKwMAAHlFcGhWOvVg5d7sYlupKi0VqfsBID3R3BO3ua2MuQe7Fx1ZP7qtTFJutlxFP0dtZTRzqEhwCAAA5ALBoVnpNC7dUiYFgaKVVVbvAaSn07i0EL4kLRWk5RpzD6biYnDo0swhSVrPSd2hZjvYOjYuc2jjQn4ypAAAwOIiODQr7TGr91LQRt0PAGlh7kHKogDQpaeVBUGUek6Os9/MHKqMHGUfZhJtdPLxcwIAgMWVKDhkZifM7FkzO21md4y5/iYza5jZl8OvDyR9dmGMW72XgmwiVu8BpGVc1qJE1iKmJjqVLJ45FAWK8nJiWbR1bFzmkJSf7XMAAGBxFSfdYGYFSXdKeoukM5IeM7OT7v7MyK3/y93feoXP5l+nLq1ec3n7ykHqfgBIT6curbzq8nbmHkzJuJpDUaBoPW+ZQ5fVHAreR9vOAAAAsipJ5tANkk67+3Pu3pV0n6SbEv75u3k2X1i9BzAPZC0iZVEAaPS0MilHmUPhtrEDK5euqZE5BAAA8iJJcOiwpOdj78+EbaNeb2ZfMbPPmNkrd/iszOxWMztlZqdeeOGFBN3KEHfqfgCYveFAutBk7kGq6q2uysUlVUqFzbbaSlGFJctVzaH9y0UVC5d+bIpqEDWpOQQAADIuSXDIxrSNHsvxhKQfdPfXSPpvkv5kB88Gje53u/txdz9+6NChBN3KkF5bGva2X713TjoBMGVRZhBZi0hRvdXTaqUks4t/5ZuZDlZKuTqtbLTekETmEAAAyI8kwaEzko7G3h+RdDZ+g7s33f374esHJJXM7Kokzy6EqK7HVqv3w57Ua822TwDyb9Lc092QBtRKwe6st7qXnFQWWa2WcpU5NLqlTLpYg6hJcAgAAGRckuDQY5KOmdl1ZlaWdLOkk/EbzOzlFi4ZmtkN4Z/73STPLoRJq/fxewBgWqJ5ZausRSnYdgbsQr3Vu+Sksshatax6OyeZQ53e2Myharmg4pKROQQAADJvYnDI3fuSbpf0oKSvSfqEuz9tZreZ2W3hbT8v6Skz+4qk35V0swfGPpvGD7KntSes3sfvAYBpSTT3rM+uP8ilrTKH1qolrZ/PR9Ck2e5tnkwWZ2aqVUrUHAIAAJk38Sh7aXOr2AMjbXfFXv+epN9L+uzCSbJ6T+YQgGkjaxEzUG+Pzxw6WCnrmbP5yExrtsdnDklB3aEGR9kDAICMS7KtDLs1qe5H/B4AmBbmHqTM3VVvdTePro9bq5ZUz8l2q0a7t1lfaFRtpUjNIQAAkHkEh2Zhc/V+7fJrrN4DSAtZi0jZ+e5AvYFrbVzNoX1ltboDXegP5tCz6ekPhjrfHWyZOVSrlKg5BAAAMo/g0CxEdT+Wa5dfi35po+YQgGlr1yUrSOV9l1+j3hmmoB4eVT9+W1kpvCfbgZNmJ9gyVquM34lPzSEAAJAHBIdmoVOXygekwpgPlmztAJCWTj3IEAoOk7zUZtYicw+uXBT4Gb+trHzJPVkVZQVtV3OIbWUAACDrCA7NQqcxvuaHFASMyvvZ2gFg+rabe0oVaanE3INdWQ8zh7Y6rSx+T1ZFgZ+taw6V1Gz35e6z7BYAAMBUERyahXZ9/GlBkZVVtnYAmL52fXy9ISnIJqow92B3LmYOjdlWVo22lWU7OLSZOTTmZ5SCzKHuYKhObzjLbgEAAEwVwaFZ2G71XgqusXoPYNqYe5Cy7WoORdlE6xnfVhbVE9oycyisRUTdIQAAkGUEh2ahs83qvRSs3lP3A8C0dRJkLTL3YBeiwM9qZbFrDsXvAwAAyCKCQ7PA6j2AeWDuQcrqrZ72lQsqFy//OLFSWlK5uJT5bWXN9oTTysKMIopSAwCALCM4NAvUHAIwa+7b1xySqDmEXau3umNPKpMkM9NatZT5gtSNdk+lgqlSKoy9TuYQAADIA4JDaRv0pe4Gq/cAZqvXloY95h6kar3V1dq+8dutpGBrWda3lTU7PdVWSjKzsddrYXCImkMAACDLCA6l7UIz+D5p9b67EQSSAGAaolpCSWoOcQQ3rlC93RtbbyhysFLKfHCo0e5tWW9IimUOZfznBAAAi43gUNqiX9Amrd5LFwNJALBbUUbQpLln2Jd6rdn0CblTb/XGnlQWWauWM7+trNnu6cA2waEDK9FpZSzwAACA7CI4lLZ2wtV7SWqvp98fAIshmnsmZS3G7wV2aL3V3TyVbJy1fSXVM16Lpzkhc6hUWNK+coGaQwAAINMIDqVtc/U+wS9o1P4AMC3RfJIkMM3cgyswHLoa7Z7WtskcWq2WVW915Rneutjs9LcNDknB1jJOKwMAAFmWKDhkZifM7FkzO21md4y5/nYz+2r49edm9prYtW+a2ZNm9mUzOzXNzmfCTraVdVi9BzAlnQSZQ8w92IVmpyd36eA2mUOrlZJ6A9f57mCGPZuuRrun2sr4Y+wjtUqJzCEAAJBp23/akWRmBUl3SnqLpDOSHjOzk+7+TOy2b0h6o7uvm9mNku6W9OOx62929xen2O/sYPUewDyQtYiUrYcFmLfLHIq2nNVbXe1fnviRY89x94nbyqQgOMRpZQAAIMuSZA7dIOm0uz/n7l1J90m6KX6Du/+5u0cFcx6RdGS63cyw9g4yh6j7AWBaNuee2tb3MPdgF+phoentag5FxaqzemJZqztQf+ibx9VvpbZSUqNNQWoAAJBdSYJDhyU9H3t/Jmzbyq9I+kzsvUt6yMweN7Nbd97FjOs0pKWSVKpufQ+r9wCmrdOQyvulwja/1JK1iF2IAj4HJ9QckpTZE8uibCBqDgEAgLxLkuNtY9rGVpY0szcrCA797VjzG9z9rJldLelhM/u6u39hzLO3SrpVkq655poE3cqITj1Ynbdx/xpDpaq0VKTuB4Dpieae7VBzCLuwniBzKNpytp7RzKGojlBtZdK2siLBIQAAkGlJMofOSDoae39E0tnRm8zs1ZI+LOkmd/9u1O7uZ8Pv5yTdr2Cb2mXc/W53P+7uxw8dOpT8J9jrOo3t6w1JQeBoZZXVewDT02lsX29IkpYK0nKNuQdXpJ6g5lCUOdTIauZQuFUsSebQxoW+BsPsnsoGAAAWW5Lg0GOSjpnZdWZWlnSzpJPxG8zsGkmflvSL7v6XsfZ9ZnYgei3pZyQ9Na3OZ0I7weq9FNxD3Q8A08Lcg5TVW12ZSQe2yaqJgiqZzxyqTDitLPx3sEFRagAAkFETt5W5e9/Mbpf0oKSCpHvc/Wkzuy28fpekD0h6qaTft2D7VN/dj0t6maT7w7aipI+5+2dT+Un2qiSr91KQXcTqPYBp6TSk1aOT7yNrEVdovRWc4lVY2nrbdLm4pP3LxezWHGonrzkkBcGk1W222QEAAOxVic6VdfcHJD0w0nZX7PWvSvrVMc89J+k1u+xjtnXq0mqCGkorB6n7AWB6OnVp5VWT72PuwRVab3W3rTcUWa2W1Mh65tDEmkPB9SYnlgEAgIxKsq0Mu5Gk5pDE6j2A6SJrESlrtHsTM2qkIDiU2cyhcJvYgZXt19LimUMAAABZRHAoTe7U/QAwe8OBdKHJ3INUBZlDk4NDa9VypmsO7V8uqljY/uNSVJOoSc0hAACQUQSH0tRrS8PezlbvnZNOAOxSlAlE1iJStH6+l3BbWTmzGTXNdj9RdhSZQwAAIOsIDqUpquORdPV+2JN6rXT7BCD/djr3dDekAbVSsDONdk8HE2QOrVayu62s0e5N3FImXaxJ1CQ4BAAAMorgUJp2unoffwYArlQ0jyTNWpSCbWhAQt3+UN+/0E+UObRWLanR7mkwzF5mbLOTrK5StVxQccnIHAIAAJlFcChN7R2u3sefAYArdUVzz3p6/UHu1NtBJlCSmkOr1bLcpY0M1uNptnubJ5Ftx8xUq5SoOQQAADKL4FCarmT1nswhALtF1iJSFh1Nv5okc2hfEFzJYlHqZsIT2aSg7lCDo+wBAEBGERxK007rfsSfAYArxdyDlK1vBoeS1Bwqh89kr+5Qo93brCc0SW2lSM0hAACQWQSH0hRt7aisTb43Wr1nWxmA3drcVraDrEXmHuxAFOhJdlpZEFypZyw41BsMdb47SJw5VKuUqDkEAAAyi+BQmqJtGsu1yfeytQPAtHQakhWk8r7J925mDjH3ILnGDjKHogBSPWPbyjY6wRaxWmXyaWXBfdQcAgAA2UVwKE2dulQ+IBUSfLBkaweAaenUg4wgs8n3bgammXuQXJQ5lKTmUBRAylrNoSgLaCc1h9hWBgAAsorgUJo6jWQ1P6QggFTez+o9gN3bydxTqkhLJeYe7Mh6q6dSwbSvXJh4b22lpCXL3rayKNCTvOZQSc12X+6eZrcAAABSQXAoTe16stOCIiur1P0AsHvterJ6Q1KQXVRh7sHONNpdrVbLsgTZaUtLpoOVUua2lW1mDiXYOicFmUPdwVCd3jDNbgEAAKSC4FCadrJ6LwX3snoPYLeYe5Cy9fM9rSbcbiUF28+ydlpZVD8oceZQWJuIukMAACCLCA6lqbOD1XspWL2n7geA3epcQdYicw92YL3VTXRSWWS1muHMoR3UHIo/BwAAkCUEh9LE6j2AeWDuQcoa7V6ik8oia9Wy6u2MZQ61d3haWZhhRFFqAACQRYmCQ2Z2wsyeNbPTZnbHmOtmZr8bXv+qmb026bO5Rs0hALPmvrOaQxI1h7Bj663ujoJDq5WS1s9nK2jSaAdFtyulyUW3JTKHAABAtk0MDplZQdKdkm6UdL2kW8zs+pHbbpR0LPy6VdKHdvBsPg36UneD1XsAs9VrS8Mecw9S4+5ab/V2uK2snL3Tyjo91VZKiYpuS1ItDA5RcwgAAGRRksyhGySddvfn3L0r6T5JN43cc5OkP/LAI5JWzewVCZ/NpwvN4PtOV++7G0FgCQCuRFQ76EpqDnEENxLo9Ibq9oda3UFwaK1a0vnuQN1+dk7yarR7iesNSbHMoYzVVgIAAJCkJBvpD0t6Pvb+jKQfT3DP4YTPXqZ/9kmd+83rEnRt7ypoqJdK+s2Hv63P/tnnEj3zjwfn9C8kvfDv/7pcyVYqASAumnve/5kz+txDyeaetw9e1LuHfZ37dz+UbueQCy7pi8vSwUeK0uPJ6vH8crevn1/ua/0/KDN/u/1bl4oFk/7zcqL71yR9cbmjpYekcw+n2zcAAIBpS/KpbtznuNHl5a3uSfJs8AeY3apgS5qOvaKmb669PkHX9rZnbVlLV/+03lhcS3R/p3ujvvjid1VwVh0BXLmv27LKV79Zbywm21p2vvtz+uKLDRWcrEUks2Sm1R+oSQnr8Sz1Bvr22aaGGctOO7xakVYrie41Sc2/2qDmEAAA2OO+ObY1SXDojKSjsfdHJJ1NeE85wbOSJHe/W9LdknT8+HG/4T0fS9C1ve8ndvzEW1LoBYBF84Yd3f1qSSfS6QggqSLp+Lw7MQM/Mu8OAAAATPLej49tTlJz6DFJx8zsOjMrS7pZ0smRe05K+qXw1LLXSWq4+3cSPgsAAAAAAIA5mZg55O59M7td0oOSCpLucfenzey28Ppdkh6Q9LOSTktqSXrnds+m8pMAAAAAAABgx8z34P7/48eP+6lTp+bdDQAAAAAAgNwws8fd/bId/3syOGRmG5KenXc/MBdXSXpx3p3A3DD+i4uxX2yM/+Ji7Bcb47+4GPvFxvjP1w+6+6HRxmRn0M7es+MiWcg/MzvF2C8uxn9xMfaLjfFfXIz9YmP8Fxdjv9gY/70pSUFqAAAAAAAA5BTBIQAAAAAAgAW2V4NDd8+7A5gbxn6xMf6Li7FfbIz/4mLsFxvjv7gY+8XG+O9Be7IgNQAAAAAAAGZjr2YOAQAAAAAAYAb2VHDIzE6Y2bNmdtrM7ph3f5AeMztqZv/TzL5mZk+b2XvC9peY2cNm9n/C72vz7ivSY2YFM/uSmf2P8D3jvyDMbNXMPmlmXw/ngdcz/ovBzP55OO8/ZWYfN7MVxj6/zOweMztnZk/F2rYcbzN7X/g58Fkz+3vz6TWmYYux/61w3v+qmd1vZquxa4x9jowb/9i1XzMzN7OrYm2Mf05sNfZm9u5wfJ82s/8Ya2fs94g9Exwys4KkOyXdKOl6SbeY2fXz7RVS1Jf0L939b0p6naR3heN9h6TPufsxSZ8L3yO/3iPpa7H3jP/i+B1Jn3X3vyHpNQr+O2D8c87MDkv6Z5KOu/urJBUk3SzGPs/ulXRipG3seIefA26W9Mrwmd8PPx8im+7V5WP/sKRXufurJf2lpPdJjH1O3avLx19mdlTSWyR9K9bG+OfLvRoZezN7s6SbJL3a3V8p6T+F7Yz9HrJngkOSbpB02t2fc/eupPsU/AeEHHL377j7E+HrDQW/GB5WMOZ/GN72h5L+wXx6iLSZ2RFJPyfpw7Fmxn8BmFlN0t+V9BFJcveuu9fF+C+KoqSKmRUlVSWdFWOfW+7+BUnfG2nearxvknSfu19w929IOq3g8yEyaNzYu/tD7t4P3z4i6Uj4mrHPmS3+35ek/yLpX0mKF75l/HNki7H/p5I+6O4XwnvOhe2M/R6yl4JDhyU9H3t/JmxDzpnZtZJ+TNKjkl7m7t+RggCSpKvn1zOk7L8q+HAwjLUx/ovhhyS9IOkPwm2FHzazfWL8c8/dv61gtfBbkr4jqeHuD4mxXzRbjTefBRfLL0v6TPiasV8AZvY2Sd9296+MXGL88++HJf0dM3vUzD5vZn8rbGfs95C9FByyMW0cpZZzZrZf0qckvdfdm/PuD2bDzN4q6Zy7Pz7vvmAuipJeK+lD7v5jks6LbUQLIawtc5Ok6yT9gKR9ZvYL8+0V9hA+Cy4IM3u/ghIDH42axtzG2OeImVUlvV/SB8ZdHtPG+OdLUdKagnIivy7pE2ZmYuz3lL0UHDoj6Wjs/REFqebIKTMrKQgMfdTdPx02/5WZvSK8/gpJ57Z6Hpn2BklvM7NvKthC+pNm9sdi/BfFGUln3P3R8P0nFQSLGP/8+2lJ33D3F9y9J+nTkn5CjP2i2Wq8+Sy4AMzsHZLeKunt7h79EsjY599fU7Aw8JXw898RSU+Y2cvF+C+CM5I+7YG/ULBz4Cox9nvKXgoOPSbpmJldZ2ZlBYWpTphIt7kAAAG0SURBVM65T0hJGCn+iKSvuftvxy6dlPSO8PU7JP3prPuG9Ln7+9z9iLtfq+D/9T9z918Q478Q3P3/SXrezH4kbPopSc+I8V8E35L0OjOrhn8P/JSCmnOM/WLZarxPSrrZzJbN7DpJxyT9xRz6h5SY2QlJ/1rS29y9FbvE2Oecuz/p7le7+7Xh578zkl4bfiZg/PPvTyT9pCSZ2Q9LKkt6UYz9nlKcdwci7t43s9slPajg9JJ73P3pOXcL6XmDpF+U9KSZfTls+zeSPqggzfBXFPwS8Y/m1D/MB+O/ON4t6aPhYsBzkt6pYMGC8c8xd3/UzD4p6QkFW0q+JOluSfvF2OeSmX1c0pskXWVmZyT9hraY6939aTP7hIJgcV/Su9x9MJeOY9e2GPv3SVqW9HAQH9Yj7n4bY58/48bf3T8y7l7GP1+2+H//Hkn3hMfbdyW9I8wcZOz3ELuYzQkAAAAAAIBFs5e2lQEAAAAAAGDGCA4BAAAAAAAsMIJDAAAAAAAAC4zgEAAAAAAAwAIjOAQAAAAAALDACA4BAAAAAAAsMIJDAAAAAAAAC4zgEAAAAAAAwAL7/xS9nLY5pO/MAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -2500,14 +2377,16 @@ "output_type": "stream", "text": [ "tal hits:\n", - "\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.8154915419587708, precision_at_motif_score=0.8839124803694945, example_idx=12, start=78, end=103, is_revcomp=True)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.9988626778306542, precision_at_motif_score=1.0, example_idx=12, start=87, end=112, is_revcomp=False)\n", "gata hits:\n", - "MotifHitAndCoord(motif_idx=1, motif_score=0.7484393570283403, precision_at_motif_score=0.5937741511866684, example_idx=12, start=166, end=191, is_revcomp=True)\n" + "MotifHitAndCoord(motif_idx=1, motif_score=0.9991338656491993, precision_at_motif_score=1.0, example_idx=12, start=9, end=34, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=1, motif_score=0.9987711343289296, precision_at_motif_score=1.0, example_idx=12, start=54, end=79, is_revcomp=False)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2526,7 +2405,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2538,7 +2417,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2553,14 +2432,15 @@ "output_type": "stream", "text": [ "tal hits:\n", - "\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.5406507678829533, precision_at_motif_score=0.0359706826795211, example_idx=13, start=166, end=191, is_revcomp=True)\n", "gata hits:\n", - "MotifHitAndCoord(motif_idx=1, motif_score=0.7484393570283403, precision_at_motif_score=0.5937741511866684, example_idx=13, start=9, end=34, is_revcomp=False)\n" + "MotifHitAndCoord(motif_idx=1, motif_score=0.997247452387785, precision_at_motif_score=1.0, example_idx=13, start=7, end=32, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=1, motif_score=0.5034202610363904, precision_at_motif_score=0.0, example_idx=13, start=156, end=181, is_revcomp=False)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABI0AAACOCAYAAAC8E/iJAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3yV5f3/8dd1zsneC8IKYSlDxSriwCpq3VZbtNXWVttirX7V2p+1ttZWxS5r67ZqtW6r1lUHjjoRB6Kg7D0SQoDskJ2ccf3+uE5ycpIACQQS5P18PPLIOfe8zn2fe33OdX0uY61FRERERERERESkPU9fF0BERERERERERPofBY1ERERERERERKQTBY1ERERERERERKQTBY1ERERERERERKQTBY1ERERERERERKQTBY1ERERERERERKSTXgkaGWMeNsaUGmOWbGP8VGPMVmPMgvDf9b2xXhERERERERER2T18vbScR4F7gMe3M82H1tozeml9IiIiIiIiIiKyG/VK0MhaO9sYk98by2ovOzvb5uf3+mJFRERERERERPZZ8+fPL7fW5uxout6qadQdRxpjFgKbgKuttUt3NEN+fj7z5s3b/SUTEREREREREdlHGGMKuzPdngoafQEMt9bWGWNOA14CxnQ1oTHmYuBigLy8vD1UPBERERERERERaW+P9J5mra2x1taFX78OxBhjsrcx7QPW2knW2kk5OTusKSUiIiIiIiIiIrvBHgkaGWNyjTEm/HpyeL0Ve2LdIiIiIiIiIiLSc73SPM0Y8zQwFcg2xmwEbgBiAKy19wPnAJcaYwJAI3Cetdb2xrpFRERERERERKT39Vbvad/bwfh7gHt6Y10iIiIiIiIiIrL77ZHmaSIiIiIiIiIisndR0EhERERERERERDpR0EhERERERERERDpR0EhERERERERERDpR0EhERERERERERDpR0EhERERERERERDpR0EhERERERERERDrx9XUBRERERERERPaY/HwoLOzrUkh/N3w4FBT0dSn6nIJGIiIiIiIisu8oLARr+7oU0sqYrodbC8EmmP8LGHwqDD2rf5RrH6PmaSIiIiIiIiLS/yy/DdY9Ap/8AJor+7o0+yQFjURERERERESk/1l1J4RawIZgw3N9XZp9koJGIiIiIiIiItK/NGyElhr3OtgAm97o2/LsoxQ0EhEREREREZH+pfRD8MRE3pd92Hdl2YcpaCQiIiIiIiIi/cvmtyBQG3kfbOy7suzDFDQSERERERERkf6l4tPo9+1rHckeo6CRiIiIiIiIiPQvDZui3web+qYc+zgFjURERERERESk/4gBgvXRw0ItfVKUfZ2CRiIiIiIiIiLSf2QD3sS+LoXQS0EjY8zDxphSY8ySbYw3xpi7jDFrjDGLjDGH9MZ6RUREREREROQrJhswHvDGwwnvw4gf9XWJ9lm9VdPoUeCU7Yw/FRgT/rsYuK+X1isiIiIiIiIi/dG8K+G1A6CxpGfzZQA2ACN/DNlHwaS7lQi7j/RK0MhaOxuo3M4kZwGPW+dTIN0YM6g31i0iIiIiIiIi/UzpbFj7L6hZBfMu3/Z0Awd2HjYk2SW+HnY2eGPBBiFz0u4rq2zTnsppNAQoavd+Y3hYJ8aYi40x84wx88rKyvZI4URERERERESkF617FIKNYP1QPHPb023ZAtZG3lsLvzgfbAiyD3fDvPEw4NjdWlzp2p4KGpkuhtkuhmGtfcBaO8laOyknJ2c3F0tEREREREREepW1UPwqbY/93tiezV9fACmjIlEDbxzkfqMXCyjdtaeCRhuBYe3eDwU27aF1i4iIiIiIiMieUrMcAo2R94G6ns3fVALJI11eo1bJI3qnbNIjeypo9ApwQbgXtSOArdbazXto3SIiIiIiIiKyp5R/Gv3ehno2v78OkvKjk1/H5+5ysaTnfL2xEGPM08BUINsYsxG4AYgBsNbeD7wOnAasARqAH/fGekVERERERESkn9m6DIINOz9/sMEFjbwJkWGmV8IX0kO9stWttd/bwXgLXNYb6xIRERERERGRfqzqS7aRxrh7go2ueZpp1zgq1NTz3Eiyy/ZU8zQRERERERER2RfUrnb/B58Oh9weHfzpjmAzJA6LHtbTJm7SK1S/S0RERERERER6h7XQVAq+JJjytMtLVLWgZ8sINXeRw0h1XvqCtrqIiIiIiIiI9A7/VsDCwBNc7SBvPIy8sPvzB1tc4CkmJXq4x9urxZTuUdBIRERERERERHpHQxF44mDYNPCFAz/ZR3Z//mA9eHwu2NSeiel6etmtFDQSERERERERkd5RX+RyGOUcBZ5wyCHY3P35/XWupzRvXPRwj7Lr9AUFjURERERERESkd7RUgg12TmTdXYF6lwepY82inibTll6hrS4iIiIiIiIivcNfA7FZgI0M8yV2f/5AHfiSwfp7vWjScwoaiYiIiIiIiMhOs9ZibThIFKiFhNzoJmmeHuQjCtS7ntdCgd4tpOwUBY36q01vQtnHfV0KERERERERke3y3ORh2O3h5mgtVZA4BDA7t7Bgkwsa2WCvlU92njJJ9aL8fCgs7K2lndJbC5J+ZvhwKCjo61KIiIiIiIj0Hn8w3JysuQISBoEndieXFAJvEthQr5VNdp6CRr2osBCs3fF02xUKwIsDXHQWIG0CnL5kl8sm/YfZyYC7iIiIiIhIX2pogDPOgNWr4c03YcKEyDh/qDVoVAmp+/esSVp7NgTeWKJyIkmfUdCovyl+NbrtZt36viuLiIiIiIjsk3q3FUV/Y3e65ZREHHBAdCuKpkCTe+GvgtgM8OxkuMGG0A7qPxQ06m/WPeYSh7VqnzxMRERERERkD+iVVhT9lTFf4Q+3+zQ1wYABUBt+XE1Kav2euG3ZGGh0I1q2Qlz2LqwpBEbpl/sL7Yn+puLTDgMiyb/MDMNzS5/bs+URERERERGRfd5LL0XH2hoawv/9DdETBmohLnPnV2QtClX0H9oT/UlzpctlZDxw0J9g7FVto1qjt2sq1/RV6URERERERGQf9dZbUFcXed8aQKpsrIyeMFAPMem7sKaQEsH2I2qe1p9sXQreBMj9Boz9BWCg9AMA6v31ANS11G1nASIiIiIiIiK97wP3aMqBB8KwYfD66+59p6BRKACxqbuwJkOnJNgv5kJTCeCB7we7mglrXRmHDYNRo3Zh9RJFNY36k63LINQCB84AX6LrovCA3wNQ3lAOQFVTVV+WUERERERERPYxLS2wYQOkp8OcOfD88/DNb7pxnYJGWPAm7vzKjCecDLudppLwi1CnyVv94hdw+ukwcSJ82jHri+y0XgkaGWNOMcasNMasMcb8povxU40xW40xC8J/1/fGer9yqheBLwlSwmFRjxcGnQxAWX0ZABWNFX1VOhEREREREdkHrV4N8fEuMGMMJCTAn/7kxrUPGgVDQRfw2aVE1h461TTqRvkeeMDlWaqvh0su2YXVS5Rdbp5mjPEC/wBOBDYCnxtjXrHWLusw6YfW2jN2dX1fafVFkDUZgk3gjXfDQn7wxlPW4IJGrcEjcnOhpKTzMgYOhC1b9lCBRURERERE5Ktu2TLweOCiiyAxXImotQlY+6BRdVM1WexiImvj6XHvdjfeCH5/5P0apQLuNb1R02gysMZau85a2wI8A5zVC8vd9zSXQPqB0VX5wgdLa7CoLWjUVcBoe8NFREREREREdsLmzS5YlJMTGRYIuP/tg0aVjZW9UNPIuMoT3WQtzJwJwXapjhobd2H1EqU3gkZDgKJ27zeGh3V0pDFmoTHmDWPMhF5Y71dPcwVkTgJvbGSYLwmI5DQqbSjd6cVba9t6YRMRERERERHpjpIS2H9/1/yrVXKy+19aH3lG7ZzfCJfE+ikDT3m7tzLjcT2wdTPwtGwZhEKuPHfcARde6N5L7+iN3tO66guvY2TiC2C4tbbOGHMa8BIwpsuFGXMxcDFAXl5eLxRvL9JSDYkdPrPHHVib6zYD0QdkTx38z4NZVLIIe4MCRyIiIiIiItI9xcUwYQLEtqvf4AnHdFqfVSEcNOqYyLobSayjeGIh2ACme0GmuXNdbaMbbnC5jEIhmD+/e6uSHeuNmkYbgWHt3g8FNrWfwFpbY62tC79+HYgxxmR3tTBr7QPW2knW2kk57eu+7QsCNRCX1eWoguqCXV58fUt91yNsCOrWua4RW9WthzcPg1fGQNmcXV63iIiIiIiI7J02bYKhQyP5jNrbUhfJqetqGhm6HSDqii8pXNOoe3VcPvrIBbMuuwzi4tzrv/1t51cv0XojaPQ5MMYYM8IYEwucB7zSfgJjTK4xxoRfTw6vV92AtRdocMGb2PQuR6+p3PVMXnUtdQDRTdSCTfDWFJg5zv3ZEISCMOsMqPwC6tbArNM6d3koIiIiIiIi+4SSEhg2rOtxG2s2tr3usqZRT/mSwV8LnphuTb54MRx/fCQRttcLxx6786uXaLscNLLWBoDLgf8By4FnrbVLjTGXGGNaO7o7B1hijFkI3AWcZ5VcJ1pLtauG50vpcnTh1sK21w3+BtdLWle2NRyoaqwCOrQzXfR7qF4IoRZo2OAO8PWPQX0hbdHhYOMuJjITERERERGRvVVlJQwa1PW49s3TKhorAOOeIXeWLwlsS3TgKX7bz7klJTB1KqS0e5T2dz+PtuxAb+Q0am1y9nqHYfe3e30PcE9vrOsry/rBk7DN4Ex1UzVe4yVog5TVlzF8S6QKICacVmoHcbiWUAsAxbXFZCVmQUsVrLwbQs1ugvB4Vt8HwXqISQNvHDTtfB4lERERERER2bvV1kb3nNZeXUsdMZ4Y/CG/CyB5fNCydedX5kt2qVNCzW5ZANO2uGTaXaiogKOPjuRYgujXsmu0KfsLGwRfvPu/DWlxaQCUNZTt0qqKa4rdi6KX3EGYPBIOnAEZB4O/BqoXQdJw+FYRnLUBBhyzS+sTERERERGRvVcwCBkZ2x6fk+QiSiV1Ja6mkL9651cWkww24FKp7EBzMzQ1wZAO/bd3lXtJdo6CRv1FKBDODt+5tlBL0NUAykzIBKCsvudBo/atAYtrw0GjDc+5Kn/HvwsTroMT3oPSD8EbD0c+Cd4EV9NoyrM9/zwiIiIiIiLylRAKgW877ZQGJA4AoLyh3KVcaana+ZV54txzamAbHTm1U1oK8fGQ3iE1sGoa9Z5eaZ4mvcHSKYb3Yi40lVARcNXwMhIyoCp8IPaQa1vqtNU0KvsIRv0U4nPA4wVvElQtgJhUyDo0UhXQG78zH0hERERERES+AkKh7QdiMhJcNaSyhjKIHQLN7Z5Z4wdCU0n3V2aMCxw1lUJSXtfTVC2AunVs2XACWVlpO8rUIrtA8bf+wnhdFTzatdMMH1hlQXcEtNU02onmaW2BImBt1VrXxjTYBCN/5KoPAnhjoWYFDDze1Xxq1TpeREREREREpIO5xXMBWF+1HmIyXE2j1mfKaVu2M+c2eOOgcWPX4wqedj2Az/kRTR9MJyfH0ty8kwWXHVLQqL9oDRqZzsm9ysJpjgYmuYzxW+p6ftC1NUkDVpSvcL2jxaRB+oToCWvXQPYRENMu9bxHFdJERERERET2VR6Pq220LQ3+BgD8IT/EZrhcuaFd6MLMmwB1BV2Pm3sRBBsgUEugYStxcWa7ZZNdo6BRf2G8EGgI5zWKVhg+1opqigBYUrqkx4tvX9OoLWiUlAfBDiHZhiJI2b/HyxcREREREZGvJo8HAoEdTwcQis2Exk2R3rl3hi8R6td3nQw72Aj5P4DD/kkwNne7uZZk1ylo1F/4ktxBFWjsNOoNF7Tlww0fAjBn45weL7414JQcm0xtSy3UF0DCoM69tTWXu57TRERERERERACvF6q6mdu6xnqgYRNddfLU/RUmuppGHSs5AIy8ECbfD6OnYw67S/mMdjMFjfqLmHRXfc+/tdOoLeGaRoFwm9DWqn89sa5qHQB5aS6RWKCpzAWNTIewbMgPcVk9Xr6IiIiIiIh8NaWkuJ7KuqPc3wJNW1wy650Vl+0qOtAhfYvxwiG3ukoXxosvLrHbNaBk5yho1F94vK4KXvuuCeNdDqPNHSoDBUI9PyoKqgsAGJoyFID6pgp3oLXPV2QtEOocSBIREREREZF9VlYWbNrUvWlLWhpdCxazC+GGpOGukyZvOPDU+gw84BggktLFFxdHTQ09b6LWUgUFT8HGVyAU3PH0+zBFB/qTmFTXrWCraVvgKUN1h6ReIdvzLF/zNs0D4J317wBQXFNEWtYY2iK3L+Z23Q1i23APfF8Hk4iIiIiIyL5m4EAoLnbJsD1dxIJivbEEQ0GCNkhNyOtqBDUUQcronVthUr5rBbN1GWR+DQL1bnjG18Ab3zZZWhqUlEB8fNeL6VLpRzD7rEjOpZQxcMrnXeYXFtU06l9iM2HrEugQFKrvIkbU0NKzJmrN4bagrQGnjbWlrre21gag7QNGtl1NprbhSkcvIiIiIiKyLxo0CIqKoKmLvNQA/572b7474bsAeJKHu+fM8k87Pdt2W+Jg14PappkQbIkEijInRWofhctVVweNnVMDd62pHD443QWIxv0SRlzgAlPbChgZ0/kvN3fnPtNeSkGj/iQ+B6oWul7U2okLVwY6etjRxPvcwVLV1M0sZEBNU02nYWXNNdBSDbaLbhCbK7pfZhEREREREdlrNfmb2Fy7ebvTDB0KS5dCS7sO0dp3c5+fns+w1GEAFAc9EGqCohfAX7tzhYrPBU8MrLrXBWrWPeqGJw6Nmiwjw/XqVlkZPXvLtjpuW/5XiMmEM5bD+N/C126BE97rWdlKumih8xWmoFF/Ej8Iqr6gY62e1nfvXfge+2XtB0BlY4ejYjsWlizsNGxdYx00bu7cexpAfWG3ly0iIiIiIiJ7r9OeOo3Btw0muJ3cPgMHwsqVkJgYGVZXF3mdEptCenw6AFuamwADW95xOXSD26ietD1JeYB1CbWfTYLPL3HD29cIejEXzzOG1PhKVq6Mnn2bNY82PAcT/wAxKeCNdXl+0w/qefn2IQoa9Sep+4erxkVSTYUs1FrwGi8x3hgy4jMAKGso6/ZiS+s7p7lf2xx0QSNPjBsQTroNQG27I679cBERERERkf4sFH7O2dkaLl9xwSBUVIC/XYOTz4o/A2Bu8dxtzjdokAvEtK9k0z75dEpcCilxKQBsqS9xrWgCdTDnAlj3WM8LmpQfCTaF2hU22K5VTjiVSk5KGe+/D83NkVGxsV0ss6XKfTeGngmedhPEJPesbAP3rWdkBY36kD/oJ+uvWSwrW+YGpB8AnnhY9wgEm8Ff15YEOznWfZEzEzIBKG8o7/Z6guHaRBccdAELL3G1jiq9qdCwgbZE2NO2wPfD+Y3K50ZOstO27PwHFBERERER6cLiLYspretmH+7dYS0svxVeHAivTXD/3/1GpNetfVxLC/z61645V14epKbCT34CDS1N1PtdkumXVry0zfknTHDN0R54ABrCcZtVqyLjU+NSSY1LBWBL3RZIHuNGFL0YqSXUE7HpXfe+VrUoul0cMCSzmPfeiw4aVVd3scy69ZA0ome9hVsbyQPc+n7LvvWMrKBRH5q5aiaVTZX8/ZO/uwGp44EQLLsFsGD9lIVrCLYGjXIScwAoq+9+TaPimmIABqcMJjsxG4CFNZUuA33ZR51n2PKeq0YoIiIiIiLSyxr9jRz0z4MYedfI3lvogt/A+ifh+LdhWimcXeq6Z9dzDQDf+hbMmwfLl0NtLWza5II/szfMapvmns/u2eb8o0e7JNh33+3iJk1NcO11kYBcUkwSKbGuplFZQ5nr5WwbzAzDgfceuONCx3eRcLp6EQTDPamFW8UcNeZjvvgCqsJpf+vrXXCrk5DfJdRun6LlxVx4ysBT6jltWxQ06kO/evtXADyy4BHXfjRljPsiN2xwkfH/DmkLGrVGbVuDPl01OduWguoCAAYmDyQrIQuAzY1V2LgcWPNP8Icbo7Z2Y+jfCpVfKCovIiIiIiI7L9gCBU/DohtcUGfVvdBcwdNLngag3l9PVWP3O/jZpqZyWPUPOO51SJ/oAkW+ZBh71a4v+ytg7lwXLHr5ZRgyBDweV+PooYfgoS8fAmBUxigaA42sq1zX5TJiYiA/H7ZuhUmT4PTT4c1ZrjpPvC8eYwypcakYDBUNFZA+3uUL6uDLzV8CsKRsCfUt9dsveHoXgaWSWZFAYLhVzOGjPyMhAS691NWoamyEW27p6kOkuRxJ7XpfU2/hO6agUR9ZVb6KtVVrGZ42HICXV7wMHi+kjnMT+Gsg2EhZ0DUgS4tPAyLN04pqirq9rrVVawEXcIrzxRHnjcMf8tOSc6yrLlj+iWsvWlfgZgg1wSc/cP+Dzdte8E54ffXrDL1t6I5PENI3cnN71KVkeX05D33xELZ9lU0RERERkaqFMHN/aNkKoy6C/a+E5BHYUIhf/u+XbZP968t/7dTi5xTNIe/2PGqba13riewjXJDC0+4Rt6e5ar6i3nwTTj658/DY2BAvLHsBgI01GwH4/fu/3+Zypk51/1esgPfeAxJc50ytPXynxKVgjKG6qRqyJkPHR4T4gfzu/d+1vX34y4e3X/DBp4G3XeZtTxy0lEPF51F5jo4a8wlNTfDGGzB2LIwaFWlCZ62lsLrQPa+kjHHP2bXtAmPtcvgGQgFmzJpBZUP3O53aF/RK0MgYc4oxZqUxZo0x5jddjDfGmLvC4xcZYw7pjfXuzc574TwACre6nsqmvzrdjRhyWlRSrvJwTaPWYFF6fDoGs8MuEdsrqinCYNpqKbVGgLdkfh18qTD7LHj/FHj7KDdD2oFQXwAv5cHL+a6cZXncfjtccw389rdw7bVw003wxRfd/8y1zbWc/tTpFNcWc97z53V/xr1VVwEYY/q6VL0mZEOM/cdYLnr1ImZ8MKOviyMiIiIi/clH34EjHoZRP4KkYZAwCHJP4oGlL1LdHEk48+u3f01LYFv9o3et0d/IUQ8fRVFNEWc+fSbWEwOBBqIeb9XsqE1cnGtO1vF33s+L52OxGCLPKB8UfLDN5Zx4IqSktBsQDholxbgaRalxqXiMh5rmGkg7ILpGT0wqcye/zOurX8cXzil05ZtX0hTYTs9qA46Jfn7KPAx8KfDx96C5vK2CQ1ZKJXl5bpL166GmBuJdHIsZH8wg/858rn7raldJI2syLP2DS9INUTl8p788nRs/uJHD/3X4zv8oHmiEplJoKtu5XuP6oV1u4GmM8QL/AE4ENgKfG2NesdYuazfZqcCY8N/hwH3h/3sta130srnZfY8TKQKGweI/QuJQd4D4a6ChGOKzYfTFrv0k0BxoZsGWBQBkJWRR2VhJdVM1hdWFDB99MSy/rW09pSEflgDZCS7gkxafhjGGkvqSTmXali11W/AYT1vQKCM+g4rGClbF5jPcAIEmKA2fHA64wZ3U513psssDH62cwpUvvc07s1zgvvX4iYuLTja2I2PvGdv2eubqmVw681LuO+O+7i9gW1q2Qt2a8IUiBHhdxDh5xD7Xhnnmypl885lvMjR1KEsuXUKaL8ZF4pu2uB1ncP9jMyDrMIjLil5Aa1K31pPzdk6WUx+dSkVjBV7jZcYHM4j1xPLbY37rmjk2lUKoxXWJ6UtxvSd0lciurzWWuJp2gVqw4aCeDUFsJgw42iXg66amQBNx3jjMtgKD1kL1QtdDog2Ft214nSmjIXOSu5BJ/9NYAqWz3TndGFzOOet+zRzwdXfO70PNzVBa6npB8XhcYsuMjD0Yo87Nje5KBSAROCUT/vAb8Ca4c0HI7/6Sh8PQb+095+euPt/AgftcEszdRtu399iQa2bRUu3ydXhiIC7HXfP3lh+t/DVQ+jE0l7W7bwifb7OPdEEH6VPWQnExFBREet/yel2TpyX+V/nWf84kLS6NdVeuI7Nxi+sBK/wMxIu50FTCPQUdlonlP0v/ww8n/rDb5TjovkgX6bMKZ3HR3EE8FFgCNctd9+ntghWbqgay+gN3vbTWHQ4nAYWFUFkZuX4mJcHQYUF+PesK7pt/H1dMvoLbT74d7568P7MhqF4MNSsieXcs7pqZNh7SJuz4eO7ivHo2ozkqaRF/+1sC8fGuqVkoBO+uew+A6YdM57qjr2PEXSPYVLeJRn8jCTEJnRZ91lnw059G3selV9K8EZJiXdAoJTYFr/FS76/HAmbw6VDwpPsQwea2WkwBGwh/NMuD8x/kisOv6PqzpI6jreMmTywMOcOdGxbfAK+MjKoldPnlcN11Lp9Rqxvev4GbZt+E13i57dPb8Hl8/HX8NfDRd92yx/8ago1u/hJ4vOZxfB4fa6rWcMqTp/C/7W/paEv/AvWFMGwaJA13n7nic8iZArFpPVlSv9Mbd2yTgTXW2nUAxphngLOA9kGjs4DHrQvXfWqMSTfGDLLWdr+6TNiaL5YRF+fB4408gBZt2cjyjUsZkjeE5IRUavy17lgqGU98bAxD8tMwNgAYamta2FpaxbDhccTFR5a7dp2XoI1l6KhsPME6rPFR05jChiIfeUOaSU2sxRCipj6GE05O5fN5XkaNcicXAP+sXwLPwoGR6nZYy38eL8PjiyWnKAC4aOabxU9isUxIPoD/nf4Cv50/g8fXPMXvnriXHw75GVMSjyKxbjbWeFljRgHLiG/2UbxiFYHSOjwY7CY/n736DoNHDaH1caVw8TKKlq9nwPBcktJSwkWwVDRU4MHQsrGK4ppVpJgkQkF4441N5I++mVE1V+MJNRAyCZQOuJGK8gCjY24lNrgCg6Woej8yB8SRmuraiCYkuJNrSYlr01paEsITqgMbIORNpXjZSnIG+sjIjJzQHljwMJvqNgFgMFgs97//Cm9cfitvvZXIfvtFNtvmTZv444w1nHpsJl87JJaQDVHRXEmWvxyPN5HErHz8AYPHY0lccz2JA0bBxD9EfU8WzP+ceO9CUuLddqj311NeXUHlphLGjhpPQnKS2zbNlfhqarEBHwPyR7TNX1VTzdp1ixmTP5bExHQCoQBlTRVsLUkn2JTMiLE5eEKNWAzvvB/Hk8+k8MEH7qLZasVrn3H3HbVMn+7lkONcs8PV87+EQ2HRJx+TlZlDMBSkvLmC6iHUNX0AACAASURBVPJkAlvjGb5fJj4vgKU5YPlw4bukD4phYGoKzaFm/CE/CQ0j8W9NJ2//QcR6mwBLfdDLOa8dyZrmFYCrXpr+13TqxqSTdOJMGH5u9IFUvRjbWE5deSVNzR5ifBZ/QyW1FVXEZQ5mSHiyjctX8q85D3HXlgep8rtfhManjeXUrJP4cMOHQKR3voc+uo7flt0B397oAnZhtetmY4tuIWHMNNrXUV2/cBW2pZrk/U5p68HABOsI1WwgacAwrDeNQNAQF2tZuHoOBU1biE3IAQxBAmSE0lm+YSnVSXUQa/AZH/nJebz5j5M5/uRcjpoS23ZNra9t5OmHNzL5iETGT4jFYvGG6jlg/ehIr4FhzQ3NFC5aSlJdKRDJHeb9883kPvFI1LRb4zxMv3wcL6QsbRs2Ink40zY9T2baGI4/MclVMAMyqx9mdMKrcOyr0fuicQvNNZXUb1hPIGiwFjwei6lZgUnIJhgTuRhWl1aQce+d5DzxZNQiFky/nJgLzid9QGbbME+gkpatpcRlj8TjS3AxDp+leJMhNt6LLy4ZQxAwbC6voLy8hINGDyIuzuAP+SlvqqSmKImE2Bhy8we2Xa/rquqo2lzK0BGpxCW4/RYMwu9viOeks3LYb//IdjfBWma9soqJhyZw0MGJ4c8GlUVFxCdafClD2srbUG8pXNvAgKFppGREqpKvWFRBwCYwJC9SNbmlqYmDv30w8TXRORA2jBhH6V13M2jU0LYbKhtsoal8Dd6koSRlRLbPorVf8n75OxSHarDGkh6TxrHZRzOgPJ0BebkkpUd+Rhv8xQTMWWshKS+yMmuhejHBpnq2lq7BHzD4fJbmmgoGHHcqvspI2Sxw3/EjePbbg6kMVmOM4bCcQxiy7AqqK8dy0c8S8HhceX1Na8kvOJm402ZHBaMqN1dQ9cHv8Q09Dl/2RADWF8Zw9gUj2LABhg1rtyFaqqnZuBFLPM0t7jvl9VoqNhSSmByHJ2lA26S1tZaN6xsYODyD5NTINt60toj4BB+5QyI3jFXVVaxbv5pxY8aTmJzcdm4e39xCx15t/d/3EnPlVTD+V+EAqQXjobAQGuosMSu2YmwLYGhuMWxZV8zQ/IS2ayqAt2UzLQ21pA7ejxa/1x1LtoGVqxcydNAYfHEZbts0V5IUqsHX3EzmsDE0tbjvZVJCgISW5di4gdQFcmhq9hAXa6mrN1RVQUzqUDw0ASFC3lSKlixl0NA40tIi167q0mrGdPH5Ps7NJumDD8kJd7lb01JLdbWPrSXJDBmVTUJ8AGNDhDyJeBoLiYv3kJjowx8weL2WlhZDZYUlLiU1vO9DWBND8ZrNpKV7yRkQucepqKikqLiAsaPGEZ+UgLWW8uYK1qxajT+2hVHDxoS3QxW+Jh/NZbWMHTWe+OTEtmnXrVlHyBdgTL672JY3V+Jr9uIrteTmDyY+ObLvK9cuJDbOkJPXLhgaaqKhdDXBxLEkZA4J/wZhqSzeTGxMM3HpkWOutr6Wx+c/weyWudTZemKMj2Nyj2YC+3PLujtY2bgGgyEzLoPrJvyKy5qaO23fYFILxZ++SmbeaJpbYrAWkhODxDQsoy44mGaT7X4XN7C1pBwCVSRmD4vqDeeT+R8zcugIcgcObrveryxaxR9X/JXFDcsB8Bkfl427mG9zCtkDc6LOoas2ruLmpbcxu+YTjDEk+ZK4aL8LGdc4En9iiEEDBmOxNAWbWP/pWBYtGMu1v0t0cY5wXPmLWcvZssnPOecm4otxy62vqWfjumoG5OeRkBS5Ed28poCkJMuAvMjx2VDbQNmGTQzMH0x8UmQfFa1vJBgKMXhU5ByasPE+chNWwJSnowIrb7xYQrO/iowsH+GQNzbYRFXBSoaOTGP4qMi5bv7Kz3hlyyusC2zGYhgYn8MJydNY8NohnPKtXBISI9u3sngjmwsrOOnUVBKS3M1PMBBkw7J1nc6hr70WpLohk8OnpLX9sGJDlmVzFpKXH8vBkyIH/oAFU4g58TUYcmrUd2LV54tJqq0BT6QL9a3l1aTefRdDn/131LTP/uxc1h0/lviUBAyGRF8Cw+xQ7FY/48aMJSY+nmAoSEVzJZvWFDEgYwCDh7rve52/jtLyCmrKKhg7ehzxiQlt57riNRvITM0kLy8fgFp/HeUV5WwtqWDc6PHEhY/PiuZKNq7dQFpiKiNGjGpb7taaWvyb6zsdcxs2+KhvgPz9szGhJiwempo9JP31OkY8e3/UZ3vvkguYd1Q+sVmJGGPwGg8pWw/mjacP4tIrM0hO9rTdaT3zeBWxCXGcfGpcW2stD37WfLGU9Iw4jjwmpS2Asnj9Ap7b8CxLmgqxWAbE5/DtvLOAi5gzq4ScAbEY68caH8edlMojj/r4xjci5WoKNHHY3ZNYUuPuh7Y2byXrlixmjT2fKZ/+DN/R/3ZBHGsp8sMSv3seWH3OQt4qfpf/m/P/ePjDm5nakEbq4BEEbQLBkCExIUTzdTPIfCR6Hz8wKZ41Z0TX4Hh48dNcMOZajn7vm3gm/g4z5Ew49lV+eNZyxp56AdcdG5l2k3skYdAgGD48Mnzh+oVk3HooQdy97d2f3c19n9/LSxOeYnBSDgPy2923NBjWroEBQxJIS48DQli8fLlmAYvqPiMm2UUu4rxxHJg0Af/mevYbOZbU9PS2c3NicxWBei/Z+WPcj5dA3Mb7SYstgSOju6hftXw5TWU1ZCWvBqA52EJtSxXZLeUkZOaSkplFTa2H1JQQnoCfjmGuMazhh/H/4ugp/8edd3mZMAE2bIBbXnsCUmFywkRiSloYmZLPutoC/v7ITE4YdQzZQwfgCW4l5E3BG6iEplJ+9uNc7v5nBs3NhszBJWxeAvGhWIpXrKLOX0cwFCTUkMErzy7jgMHnMcLzAibUwsaEE3hvpQvDvHvyTJZWL+fnc3/Fv957gEM3jiJ35FBa06IXr1jFmjVerCeOr6WdQ0rlk2C9LNl6Dt7EgYyOeZjYprWY+kIXnIrN4mfnreCmGWOor/cSFxvijAtf56bZNwGR55VbPrmFEeVHcbbnCLKW/AXPkj+ADfBpbSz/qHG13QLhvL5vrXsLgHmvvcegUUPbno9WfbGQFSsXM3bEuLZz3daGYsav+K17rrAhF9h6MRd/XTk1T6aR9XZ0c7cVF15H4Td/zPD9c/F5XBWwgE2geOVahuTFR9XmqthcQUNNHYNHDsEbEzkPr1+0muwh2aRkZbQNqy6tprayikGjhuKLiWkbHvAH8fjiGTYu8ozWE2ZXc5EYY84BTrHWXhR+/0PgcGvt5e2mmQncbK39KPz+XeDX1tp5XSzvYuBigLy8vEMLCwujJzjbwIvRg465Lp0PY6L71Mv1wuYxiXBudO6c2TccxzFbmuGBOZGBXvj43COZctF4GHsuxA8C6+d/9z/CycdtjTpoG5/O55xf3sv0W47l0Cnx4Yuf5dWnV3P5b8di37sKhk6CzS/Dxmcx51saGlygpdUv7v8JD296lAdetJy3FOYPgpN+CFfccgM3MgPSgd8ADfD/Fg/koQNKeOR5OHs5bEiDyT+FLV8DvlsPvkQXTQ7UUfD7LPJzNrgva3hY4M56DljiKuEsvhcSAnDDVLjta8n88vZfuvVNw4XbP4cbH7uaGwN/hxzgSiAJuBdezjqTVyuuIvfUg0nLjqWpLsCTj1Xw2VXTSJu8Hwya6qK/1YvgxDtha/Q+Ovz6ZD7z1DH3QZhcDDdPgWuPyOWQpz/g/v+O5sCDIjfpU/82hLmhzXhCEB+AhhigdjCDHlnJ54uTGRI5X/PQjJf5zpgnSD38fEgaAOsfwa57CM8aNz652d0g1cfBEU3D+DTe5YLyhCDUek9+o+1UoebX9/yYWyoejRoWa2BZ4whGTb8JBh3rfj0H3n3+C/7yj8k8/EwqGRmm7WKdOtMTCUiE98ezV2dz7rUFcGP0LwTBUQbPWashZVTbsHn378dhJavp6Mn/nsv5ly6BYy+BjIPBGJYXzGL8G79jdAX8bjaszIK/HAMXfHQbD1y+gLj9pkJaPhQ8RunC17nqtvuZeOFpTD0plvR098tL8I3DmXjuL2H4eW3ltXfWt23L9g6zaXxutjL7Yfj6BrjlKLjlFJjTdBBjfnANZI9z0YHV9/Pys5s467vZrnoywKIbYckMeIFOx/Ljh/2QdwbfzuXXZjB0qMHng7p6GPVE51pKxzSMZHZi50R92X8u5b15ORzYLm/ec//4mJsfnsL8+e0mtJa3zjiZk36SDQeeDkm5UPAYCz5YxMHjyl3wK7wduCt8Hjm3GbyxbcNfuyadMxqLO5Vh8p2fcs2Dh3P22ZFhVRs3sOHWC5h4zlR3jtj4HBQ+TtaPynjjo2wmT45MW1bmfmjv0Jso6+/anxFn3wZDTo8uWxfb8tRRr3P6L07l8svbDaxbB28eBudURE179IxMPqZzEko7huig2qIb+eC59zi2pAUenNs2uIUY4mhh61ZXy6XVTZfNYl39VB59tMOCuziPf3LK4Rx1TToc92bbulgyA3N+5+Nz7gsvc/hFZ0N1MHrEtM7b4f1Bx3JF5iyWLIkebmZ0/pUuv34I69cWd1rGf48+k29Pb4LDzoG04VDwBB+/vZaLn/+EefOiz++l9+cy4Ho/lEVuDkIGvDd0Wh1nvvMQh3zjJ9zQflz9BioeOYGsc/8N6eEcd0v/zLyZbzOpZADc80ZkXeRw8YinuOjPhzNyfALWuJD8H//fx4w4/Fj+9KcOK+xqu//oCI664gg45HY3IPwrcFffqenTh/PwsA7XZNp9T1p/2cxK4uULjmdCSiOjv3EYDDkUil+Aoqdpbowl7juLIHX/tvnn33wsh47bAGetj/pej/3Zcu7579ioB5On3nyU8+f+uFMZrnv6DzRMuYxzfpLG4MHuIWjl4nKeveotBp55NieeEUd6OtTWwNxv/4Krv3cvnHMWDJjiakFVfgEbHo+6fnJXPYXlwxj+nX/BoJPahi/6Wz0TN8CISnjncVieA2ecD/+39CrumL6ZmIkXQ3I+GC8rl9Qx9VvjKCoCX7uf6d7904854ZvD4KCbIgNbt31rGQDeuoTjXvgHszzl5NTBAaUwdyg0dIyyhB3ePIS5ce6cFHWd68KlVV/n3sfnQlWHJiH/ptNx/8yDK/jnkmd4//0OC+niO/XolBH8+MT1215xO6Pr81h98IZO2/3mP1/DhvFX851LssjLc/tz9vv1/H5GCkUdUjqG0jx4aqJPEgEPxFzfeX3jPLEsD3VuAmMX0elzHHl9Cp+2C1Bsz7R515OaPYNHHukw4inTaX/+/FcZhMZcyT0dOyjqYlvOOvNYpmaWwqPLo0d0sY/e/PccDh/nJeOEX0J8Kqx9ENY9iDnf0tgYaaYB8OK/5nP9HYd267y4X8lkzHtzWbFix+XdnJnLoKlbOg2flP4Z1/7rsKhrYqAlgO97MZ2mveyIu7jt158RN+YYSB8BBY9D4RNdnpOW3TSO8RdcH3Xfwl31mM63Toy1Saww9WDBayHY4dg4oggafbBwEBwSzOILbwUxQUhvgvLEtuf5Tg5pGcgXsSX8fA5cNg/+ehQ8fGjX015ZfQx3VG2Cx9rdWMVC6R9yGHDhczAwEtX45OlnOCr9b3Dq/B1+tgM3Hk/MF+9G3+MA+YkF/PvtfKZMiQyb/XoBP/tlPss7fKW62vdHksKcG2uw9cVRtTn+OvEaGg66lKPOHUZGtg8MrN6ylh8sGsvoCrjpfViVBTceB947V7D+/D8zLPtpGDcBfDHMr/yc4zfA976E+2dCbSxMvBS+VzadzY238L1L0hk92v0QW14Oh6z0dj4v/vcuZlHFB4/AMYVw12S48jS44cYbuHH/GfAtYCTQBK+uP5231/2N48/NY+CwWDxeQ3lJiNOnxfHkHeWMPDiFuAQPWLjtzZN5ivf47mL4znL4zwR4fkLX17mPLz+IKd8YBkf/J7LRXszFLO7cGmRS3SjmJa/tvPO6eAZZ+OFyEt6+nP3OOBFyJ8LG/0DBY237PqPBPc9tSoV8Hzz6v2O4dt4d5J85kSGDgmwp9fLYqT48Zy5319p23x/7PDz/33O4mV+zjlEMpISUPx7I5pZYvri1gQH18Oej4eavw1V/uYEbM2fAr4DBbltSBxR9h8Y7XmUaL7KKMdyQfxwXFhRx1UmGW99y9zwHXAoFr73BrPGfMvmNGTAdGA9r7oLJP4QTVsJzz0GLFyZeAtcnH8X3vn+Cuya2K++N54efjdOA64HP4Ff/uYVjDqnnm6tmwC+BgcCbuKowL8JcJvNdnmUcyxk8/TIeGbaOx16ECxbBs+Ph3O+GvydmhqvWchLQDP9v8QjuyFvPP1+Bi7+AN0fDqT8AeyORlhfhsl3780xutkVc8jnc95r7npz3HXjs+R9wwffnw9RpkDkaFl7JqqIB7De0GM5tiPps7z03leMvGQIH/xQS3A8vZWuXk7PsjE7XxJb/xBD7ip9OurjvLbxtGMM3Hgu3Rf/AzA+GwxMFnRZhjJlvrZ3UeeEdpuuFoNF3gJM7BI0mW2uvaDfNa8BfOgSNrrHWzu9qma0mTZpk583rFFfarlAohMfjce0HV//TVYk0Hle9r/AZ2PAfl0yrfTCp/FOX+PnMdifx1gfbwafDpHtctcrlf4cVt4I3Cc6t62JbbLc1z55x440wo0N+mRtucMN728wJcOjtkH1UJMncCwPhonKo7iL7fDermzf6G5n84GSWlEXuZqblXUz5o/dz/fWGCRPcMGMgEIDkZEjrUONvdsFsjn3s2KhhH//kY/44+4+8sSby0HXSyJN49XszMTaGYDBSZdUYCHmaWF6+jBXlKxiZMZIDM0eS9Np+cPJnkBquGtX6Pck5Fk6ctcPP1lruNRVrWVa2jKGpQ9k/a38Sqz53vdZ53C8VrH8SCp/q+rv2lNe1vY3Laotiu6z/Hvh+sKtVRnniCXjqKZcoLhSKzhXY1y66yFVvbv0K91n59uBxtHKlOyxazx+t55CDDnKfPxSK/l5mZXVvm8yd65Y9YIA7TkIhiPM1cPywfxKTMRIIN8ULnxe/bInj6cE/p3BrIYcMOoTzDjyP4SlDXTNDG8SFX8OF8CZ2q6lDcTF8+aWrkdn++Pr6113z1ijWQrDBNV+ywbbVuWYVO/8lCATcL4otLe51q9Gjox/ie2rBAvj5z+Hee90vla1qatz5KDNz2/PubitWwKJFrgytTQeMgeOO62K7hwKueWYwvN3fmOiahWzjfPLKyle46YObWF+1nry0PH53zO+YNm7atptltmctzLvCNRvIPAQwrgfPtQ/Ciz54IbrHznPHL+aEKw/gjDMis1treWzNrfzug1+1TXfMsKl8eNF7lJQYcnIizaZvvdXlNXjwwQ5leHU/OPwBlxeh/bXr2Xr311GHYz9kQ0y8fyJLSqOfuKsOGEb6UeEAU7AFltxEyScPcul/XuOiayYxbFikiXd81VvkJX9G7MDDiDrnd7Ed6mJh9LVJlJhI2Q4ddChzps8hxhuDP+jHYzx4PV78QT+n/vtU3l3/btu0p485nZfOewmv8dLgd1lBE2NcLYXuNg2rr4dVqzqfkw4+2DVx6G0eD2ze7IrSetxaC0uXuvW3P5YPOzMX0/EzAKGBOaxb+gkLSxaSmZDJwbkHk5GQ0Wm63aqrawn0zvXEhn/NbjtZ4s6V3TgWrXXdbfv90efm7Oz+dU/Qmxr8DUx6YBLLyyPRkp8d+jMmD54cySsa9vGPP2b6K9NZURGJlH1zzDd5+KyH+c27v2HmypkYYzj3gHO57LDL2O+e/aLmNxjWXbmOf3z2D15Y7hIMnz3+bGZMnUFiTGLUtAQa4M3JcNg9MHCqG7YT95bd1dICq1e7/d7+ODrwwC6O5ZLZmNxjsE0V7p6ztVwH3AAH3dir5QKYMMF15X788a6cALHbCJD3ip48uHV1LOcAfz4XTvsRWD+sfwo2PLPN58T1Vet5bOFjLNi8gOHpw/nBxB8wIvYwqqvd/giFIvd6o0Z1vkcprC5k5F0jCdnIM9Y1eS/w+m3TeO89FxiOjXXbLirn0M7y18Iro6ClMtJMruMzdFi/eAbeXbr4cGX1ZQz8+0Bshyzfn/zkE44cduSOlxkKwjM+OKfS3eeG/LD4Jlj6R3hjODzZ4Qe63fUsz54NGh0J3GitPTn8/loAa+1f2k3zT2CWtfbp8PuVwNQdNU/bmaDRTgkFYeWd7lf47MMhYbDbeVWLYMI13V7MV/qA6crLI+GoJyDja67GU+vFZBsny55aU7mGR758hKuPunqnbvRCNsSdc+4k1hfL/x32f20PNZWNlTy64FEunHghWYlZO1hKFxq3QN16CDW7GzRvAmQe2u0H213+niy4Dho3wYTfQOIweHkENJfS3aCR3w+PPgrr1rkb8rQ0lxivuBh+8xsXhOtLhYWwZIl78GsNGp1xxm6+cRCRvc6ayjUMSx1GnC+OLVvgrbdcborWZsJlZbB4MUyZAqec4m6i6+tCjF+SDGesdNd6j3enrl0VDRUMvW0oTeEElxcdchEPnnI7lLzrchkSbqOEhZE/Bl/nvBA99diCx7jqrat46dyX+Prwr2932tK6Uh5d+CgXHXJRW0cae5O1a+GVV9y1KTH8jN3YCFdcQVQTRpGeWl+1nueXPc+lh11Kcqy74SlvKOfoh49mWOowZn5/JnE+F11fuGUht8+5nT9/488MThm8zWW+vfZtTnrypLb3H/34I6bkTdnm9F2y1tUqCDaF7y0Te+W8sauMARtocYGDUIvLkxWfu1tyZFVVwWuvuTh2bGx4kwTgkksi54FetRc+uFlrueeze/hyy5fcferd/PZXSfh88Je/7Ib75IW/g5V3waQ7YcSFUDkf/neEy1M6LfqHhb1wU3bfNj7crZ/cytVvX028L56mQBOnjj6V189/vfvLrVsPxTNdLthw6xWCTbD/5S6H2x6yJ4NGPmAVcAJQDHwOfN9au7TdNKcDlwOn4RJg32WtndzF4qLssaBRR60/ufTQV/qA6UrdOpj3C9ekKvcb7kJStdDlsJBt6pXvSbAFqr50vQZgXZQ6+6i9J9GliMgeEgi4oHhrE53hsW9jFl0L437tumc2HqheAoO76It4OzbXbmbwbYMZkzmGlZev7F5tKxH5Snpz9Zuc+tSpzJk+hyOGHtHXxek1X+lnm6/Ah5s1C66+Gt55xwWNEhNdR027HGSzFp7PhLFXwbhfusoBIT88E45MdcgH+hXYlNu2nQ/301d/yr+++Bex3lgaftuwZxOm95I9FjQKr+w04A7ACzxsrf2TMeYSAGvt/cbdSd0DnAI0AD/uKp9RR30WNNpJ+fmuloTI9gwf7nqcEBGRPhIKQvkcaNjoqt0n5MLA4xV4FxFpZ18NBuxNXn7ZtVw6+miX4mHLFrjjjl1caF0BvH4gfHtzpBk3uDxtoKBRWEuwhbOePou/n/R3JgyYsIcL1jv2aNBod9nbgkYiIiIiIiJfBftqMGBvY61LGl5d7dJO5OTs4m8ghc+61C3HvQExqe3yp4YpaPSV0d2g0S6kARURERERERGRvmKMCxTl5PTSAhs2QsoY2pLsN3XubED2LV/RPhJEREREREREpEesHzyxtAWN4ge2G6nwwb5INY1ERERERERExPXe11Ltcv5Bp97SZN+jUKGIiIiIiIiIQNp42LokXNuoHX9N35RH+pyCRiIiIiIiIiICmZOgdg00booe7onpm/JIn1PQSEREREREREQgNs0lwp53GQTq3TB/Hay4q2/LJX1GQSMRERERERERcQ66Cco+gg++CUUvwYJrYPENfV0q6SNKhC0iIiIiIiIizrBpUPBv2Pw/KPk2eOIhcUhfl0r6iIJGIiIiIiIiEmX4cDCmr0uxu9i2HuWlKwZ4sVtTDqcAzIjdWpo+M3x4X5egX1DQSERERERERKIUFPR1CWTvkA/Yvi6E7EbKaSQiIiIiIiIiIp0oaCQiIiIiIiIiIp0oaCQiIiIiIiIiIp0oaCQiIiIiIiIiIp0oaCQiIiIiIiIiIp0oaCQiIiIiIiIiIp0oaCQiIiIiIiIiIp34dmVmY0wm8B8gHygAvmutrepiugKgFggCAWvtpF1Zr4iIiIiIiIiI7F67WtPoN8C71toxwLvh99tynLX2YAWMRERERERERET6v10NGp0FPBZ+/RjwrV1cnoiIiIiIiIiI9AO7GjQaaK3dDBD+P2Ab01ngLWPMfGPMxbu4ThERERERERER2c12mNPIGPMOkNvFqOt6sJ4p1tpNxpgBwNvGmBXW2tnbWN/FwMUAeXl5PViFiIiIiIiIiIj0FmOt3fmZjVkJTLXWbjbGDAJmWWv338E8NwJ11tq/d2P5ZUBhh8HZQPlOFln6lvbd3kn7be+lfbd30n7be2nf7Z203/Ze2nd7J+23vZf23d5pW/ttuLU2Z0cz71LvacArwIXAzeH/L3ecwBiTBHistbXh1ycBN3Vn4V19AGPMPCXT3jtp3+2dtN/2Xtp3eyftt72X9t3eSftt76V9t3fSftt7ad/tnXZ1v+1qTqObgRONMauBE8PvMcYMNsa8Hp5mIPCRMWYh8BnwmrX2zf/f3v3G2FHVYRz/PukKWgiCaVDoNmk1BQWCQJDwJ6K2JlYlLW9MasQ0ajQS5E/jH1hJIL4jYEReqAmhdUlsIFgLNCYqDRp91aIWEGpFmmLapcWiBjUaKcXHF3NIb3rvGO8u7Zwxz+fNzvzm3uxJnp3Zc86dc2eOvzciIiIiIiIiIo6iOd1pZPvPwPIR9X3AR8r2buDdc/k9ERERERERERFxbM31TqMu3N11A2LWkl0/Jbf+Snb9lNz6K9n1U3Lrr2TXT8mtv5JdP80ptzl9EXZERERERERERPx/6uOdRhERERERERERcZT1atJI0gpJz0jaJemmrtsTo0laJOlnknZK2iHpGfobVgAABWlJREFU+lJ/i6Qtkp4tP0/puq0xTNI8SY9L+mHZT249IOlkSRsl/a6ce5cku/pJWluuk09Luk/SG5NbnSStl3RA0tMDtdasJE2V/sozkj7UTasDWrO7o1wvfyPpQUknDxxLdhUYldvAsS9JsqQFA7XkVom27CRdW/LZIen2gXqyq0DLtfI8SVslPSHpV5IuGjiW3Cowm7H3uNn1ZtJI0jzgW8CHgbOAj0s6q9tWRYtDwBdtvwu4GLimZHUT8KjtpcCjZT/qcz2wc2A/ufXDXcCPbb+T5uEDO0l2VZO0ELgOuND2OcA8YDXJrVbTwIojaiOzKv/zVgNnl/d8u/RjohvTDGe3BTjH9rnA74EpSHaVmWY4NyQtonlq856BWnKryzRHZCfpA8Aq4FzbZwNfL/VkV49phs+524Gv2T4PuKXsJ7e6jDX2nk12vZk0Ai4CdtnebfsgcD/NhScqY3u/7e1l++80g9eFNHndW152L3BlNy2MNpImgY8C9wyUk1vlJJ0EXA6sA7B90PZLJLs+mADeJGkCmA/sI7lVyfYvgL8cUW7LahVwv+2XbT8H7KLpx0QHRmVn+xHbh8ruVmCybCe7SrSccwB3Al8BBr+YNblVpCW7q4HbbL9cXnOg1JNdJVpyM3BS2X4zTT8Fkls1ZjH2Hju7Pk0aLQT2DuzPlFpUTNJi4HxgG/BW2/uh+eMGTu2uZdHimzQdsX8P1JJb/d4OvAh8tywtvEfSCSS7qtl+nuaT1j3AfuCvth8hufVJW1bps/TLp4Efle1kVzFJK4HnbT95xKHkVr8zgPdK2ibp55LeU+rJrm43AHdI2kvTZ5kq9eRWof9x7D12dn2aNNKIWh79VjFJJwI/AG6w/beu2xP/naQrgAO2f911W2JsE8AFwHdsnw/8gyxpql5ZW74KWAKcDpwg6apuWxWvk/RZekLSzTS39m94rTTiZcmuApLmAzfTLJEZOjyiltzqMgGcQrN85svAA5JEsqvd1cBa24uAtZS72klu1Rlj7D12dn2aNJoBFg3sT3L49riojKQ30PzRbrC9qZT/KOm0cvw04EDb+6MTlwErJf2BZvnnMknfI7n1wQwwY3tb2d9IM4mU7Or2QeA52y/afgXYBFxKcuuTtqzSZ+kBSWuAK4BP2H6tw5zs6vUOmkn2J0tfZRLYLultJLc+mAE2ufEYzV3tC0h2tVtD0z8B+D6HlzElt4qMOfYeO7s+TRr9ElgqaYmk42i+vGlzx22KEcqnBuuAnba/MXBoM82Fh/Lz4WPdtmhne8r2pO3FNOfXT21fRXKrnu0XgL2Sziyl5cBvSXa12wNcLGl+uW4up1mHntz6oy2rzcBqScdLWgIsBR7roH3RQtIK4EZgpe1/DhxKdpWy/ZTtU20vLn2VGeCC8j8wudXvIWAZgKQzgOOAP5HsarcPeF/ZXgY8W7aTWyVmMfYeO7uJ17fJR4/tQ5K+APyE5gkz623v6LhZMdplwCeBpyQ9UWpfBW6juRX1MzSDpY911L4YT3Lrh2uBDWVSfTfwKZoPBpJdpWxvk7QR2E6zPOZx4G7gRJJbdSTdB7wfWCBpBriVluuj7R2SHqCZvD0EXGP71U4aHm3ZTQHHA1ua/jZbbX8+2dVjVG621416bXKrS8s5tx5Yr+Zx7geBNeUOv2RXiZbcPgvcVR7Y8S/gc5BzrjJjjb1nk50O340bERERERERERHR6NPytIiIiIiIiIiIOEYyaRQREREREREREUMyaRQREREREREREUMyaRQREREREREREUMyaRQREREREREREUMyaRQREREREREREUMyaRQREREREREREUMyaRQREREREREREUP+AwE9qwQpBbkWAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -2579,7 +2459,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2591,7 +2471,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2608,12 +2488,12 @@ "tal hits:\n", "\n", "gata hits:\n", - "\n" + "MotifHitAndCoord(motif_idx=1, motif_score=0.9753179158689952, precision_at_motif_score=1.0, example_idx=14, start=48, end=73, is_revcomp=False)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2632,7 +2512,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2644,7 +2524,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2659,14 +2539,15 @@ "output_type": "stream", "text": [ "tal hits:\n", - "\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.7153383485669246, precision_at_motif_score=0.5749187397768176, example_idx=15, start=5, end=30, is_revcomp=True)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.9978017165798071, precision_at_motif_score=1.0, example_idx=15, start=14, end=39, is_revcomp=False)\n", "gata hits:\n", - "\n" + "MotifHitAndCoord(motif_idx=1, motif_score=0.99879188230101, precision_at_motif_score=1.0, example_idx=15, start=71, end=96, is_revcomp=False)\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABJQAAACMCAYAAAAqYPOgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3hU1dbA4d+Z9ErovUlvIkqVpqIiWLDXa1fsXvTa7mcB7L0AiiJekSaooCDSRIqIIL1JDRBKKAmE9J5Z3x87ZyaTTEICExJwvc+TZzIzZ87smTNz5py1117bEhGUUkoppZRSSimllCotR0U3QCmllFJKKaWUUkqdWTSgpJRSSimllFJKKaXKRANKSimllFJKKaWUUqpMNKCklFJKKaWUUkoppcpEA0pKKaWUUkoppZRSqkw0oKSUUkoppZRSSimlysS/ohtwMmrUqCFNmjSp6GYopZRSSimllFJKnTXWrFlzVERqlmbZMzKg1KRJE1avXl3RzVBKKaWUUkoppZQ6a1iWtbe0y+qQN6WUUkoppZRSSilVJhpQUkoppZRSSimllFJlogElpZRSSimllFJKKVUmGlBSSimllFJKKaWUUmWiASWllFJKKaWUUkopVSYaUFJKKaWUUkoppZRSZaIBJaWUUkoppZRSSilVJhpQUkoppZRSSimllFJlogElpc4Q6emwYgWIVHRLlFJKKaWUUkr90/kkoGRZ1hWWZW23LCvasqwXvNzf2rKs5ZZlZVmW9UxZHquUMkGkQYOgZ094552Kbo1SSimllFJKqX+6Uw4oWZblB3wKDADaArdZltW20GIJwJPA+yfxWKX+8VatguXLwemE4cMrujVKKaWUUkoppf7pfJGh1BWIFpHdIpINTAEGFVxAROJEZBWQU9bHKqVgxgzIzjb/BwZWbFuUUkoppZRSSilfBJTqA/sLXD+Qf1t5P1apf4xp0yAnPxybmlqxbVFKKaWUUkoppXwRULK83FbassGlfqxlWYMty1ptWdbq+Pj4UjdOqTPdsWOwZ4/7utNZcW1RSimllFJKKaXANwGlA0DDAtcbAAd9/VgRGSMinUWkc82aNU+qoUqdif7+G0JCKroVSimllFJKKaWUmy8CSquAFpZlNbUsKxC4FZh5Gh6r1D/Czp2Qm1vRrVBKKaWUUkoppdz8T3UFIpJrWdbjwDzAD/ifiPxtWdbD+fd/bllWHWA1EAk4LcsaArQVkWRvjz3VNil1NtmyBdLSKroVSimllFJKKaWU2ykHlABEZDYwu9Btnxf4/zBmOFupHquUctu40VzefDN8+CFcemnFtkcppZRSSimllPJJQEkpVX727TOXo0dDVBS8917FtkcppZRSSimllPJFDSWlVDk6fBg6doSAAHA44JJLKrpFSimllFJKKaX+6TSgpFQllp0NqalwxRUmoASQk1OxbVJKKaWUUkoppTSgpFQldugQBAdD9+7mEsBfB6oqpZRSSimllKpgGlBSqhJLSjIBpNat3beFhVVce5RSSimllFJKKdCAklIVxilOrOEWuXm5xS6TnAyWBQ28zpGolFJKKaWUUkpVDA0oKVVBkjKTAEjMTCx2meRkCAlxD3dTSimllFJKKaUqAw0oKVVBjmce97j0JiUF6taFjIzT1SqllFJKKaWUUurENKCkVAU5nnHc49Kb5GSoUQPy8k5Xq5RSSimllFJKqRPTgJJSFaS0GUqhoaerRUoppZRSSimlVOloQEmpCuLKUCohoJSUZAJKDv2mKqWUUkoppZSqRPQ0VakK4spQKmHI27FjEBEBfn6nq1VKKaWUUkoppdSJaUBJqQqSkJHgcel1mQSIjISAgNPVKqWUUkoppZRS6sQ0oKRUBYlPjwfgaPrRYpdJSjIBpcDA09UqpZRSSimllFLqxDSgpFQF2Ze4z1wm7St2mZwcqF79dLVIKaWU8p307HSs4RZOcVZ0U5RSSilVDjSgpFQF2Zu01+PSm7w8k6GklFJKnWkOpx0GIDEzsYJboiqL66ZcR+tRrSu6GUoppXzEv6IboNQ/1YHkAwDEpsQWu4zTCf76LVVKKXUGikuLc11WC6lWwa1RlcHPO34mT/IquhlKKaV8xCcZSpZlXWFZ1nbLsqIty3rBy/2WZVkj8u/faFnW+QXui7Esa5NlWesty1rti/YodSY4knbEXKYeKXYZpxMcmkeolFLqDBSfZmoF2oGlkojAqFHQpw8sW1beLVMVRYNJSil1djnlU1XLsvyAT4EBQFvgNsuy2hZabADQIv9vMDC60P0Xi8h5ItL5VNuj1JnCKU4sLAQpfhkn+PmVccXihDVD4IcasPXDU2ukUkopdZIKZiidyPTp8PzzsHQpXH65GfKtlFJKqcrNF7kPXYFoEdktItnAFGBQoWUGAePFWAFEWZZV1wfPrdQZLcAvoMT7RcCyyrjSPRMgeixkH4ONL4Mz++QbqJQqFWu4xfQt0yu6GUpVKqUNKOXkwJNPQnq6uZ6bexKdKUoppZQ67XwRUKoP7C9w/UD+baVdRoD5lmWtsSxrsA/ao1SlZ894ExYQBkCe03tXrJ+fObAutbwsWPs05KXlX08HR+CpNFUpdQIpWSkAHMs4VsEtUapyOZR6CDhxQGnJEkhJcV/P1n6Qs152nm5kpZQ6G/gioOQtf6LwGJ6SlukpIudjhsU9ZllWH69PYlmDLctabVnW6vj4+JNvrVKVQFJmEgBhgSaglJSV5HU5h8MMeyu1uN/BWZYIlFLqVJX2pFmpf5pdCbsA2H18d4nLzZwJaWlQpw5ccw0EBZ2O1qnylp4Omzd7P47R/aVSSp0dfBFQOgA0LHC9AXCwtMuIiH0ZB/yIGUJXhIiMEZHOItK5Zs2aPmi2UhXneOZxAMIDws31jONel3M4ylhH4sAMyEuFWn2hx3io0v5Um6qUOoGDKeYnz54iXSll7EzYCcC2o9tKXG7uXJORu3w5TJ1qinOrM9v+/dCsGXTtagqti0Badprrfg0oKaXU2cEXAaVVQAvLsppalhUI3ArMLLTMTOCu/NneugNJInLIsqwwy7IiACzLCgMuBzb7oE1KVWp2ACkqJMpcz/QeUPLzg9TUMqz48K/gHwl9ZkDTO6HvjFNtqlLqBA6lHPK4VEoZe5P2AiVnKGVmQkwMPPQQ1KgBwcFw++2nqYGqXIjAnXdCfDxkZMC6daYeZMEgUkkz3CqllDpz+J/qCkQk17Ksx4F5gB/wPxH527Ksh/Pv/xyYDQwEooF04N78h9cGfrRM1WF/YLKIzD3VNilV2dkBpKig/IBSMRlKfn6QkFDKleZlQuoeaP8SOPLHCwRpNp9S5c3OUNqftP8ESyr1z2LXySmpvtiOHSaIdP/9EG6SdrUg9xnur79g9Wp3hrVdbP1ImjuIpBlKSil1djjlgBKAiMzGBI0K3vZ5gf8FeMzL43YDHX3RBqXOJAkZJkoUERThcb2wyEhITDQz4ASUPCEcpO0FvyBofDP4B5vbAiJ81WSlVDHsLIyYxJiKbYhSlVCQXxBZeVnF3n/wIISGQtu2BR6jNZTOaJMmmcyz886Dyy6D8ePN7R4ZSmmaoaSUUmcDnwSUlFJl4xryFlzykLdq1SA5uZQBpYyD4B8B4ef4sqlKqRPYEr8FgLh07XFXymbXy4kMiiQ+PZ5cZy7+jqKHnQcPQuvWZmhUoE5KelaYOdMMX1y82AQLb73V3F5wmFtscmzFNE4ppZRP+aKGklKqjOLTzUyFWbmm1zY+zfvMhTVqmKmUS1WYOz0WIlpAboavmqnUmadOHVOso/BfnTrl9pRbj24tt3Urdaayf+cigyIBOJp+1OtysbFQu/Zpa5YqZ0ePwuHD8PrrEBJiOsNatDD3FcxK2pe0r4JaqJRSypc0oKRUBZi1YxYAU/+eCsDPO372ulxkpJlKuVQBpYxYCKoBiI9aqdQZ6EgxwyiKu90HDqYcxMICIDM3s9ye55+szag2nPf5eRXdDFUG9vCm6iHVPa4XtmuXiffqMLezw86dJpB0443ujLOI/NH3BevM7UvODyh56wQoxw4ApVT5EjGd4aKnI/8YGlBSqgLYad92XYniDrQjI93FLE8odTeE1AGHjhlQZ7bZO2ZjDbeQSng0cjzjuNfZiezhq4dTD5/uJv0jbDu2jQ1HNlRoGx6c+SCNPmpUoW04k9i/azVCa3hcLyw2Fho1MoW51Zlv715o1gz8vRTV2J/sDijtOb7H/OMt2F+OHQBKqfJz/Dice64p2dG6NTidFd0idTpoQEmpCpCSnVLidVtkpNk5O0rzTc06BqENwE+PytWZbWPcRqByzgJU470a1PnA3Xuemp1qbs8/abZnfFNnn8mbJ3ucEPvKiv0reO7X53y+3opWOEOpuKHdWVnQsOFpa5YqZ3v3QpMm3jOr7f1jkF9QsbUjlTorlDD8XkTOymzm3Fzo3dvM3JmbC3v2lPL8RZ3xdDMrVQEyCtU5ysjxXvcoIsIULC1Vz60zBwKqgKVfa3Vm25mwE4BtR7eV/cHFFWPxUZEWp3h2tx1KOQS4A0r2deU7eU73mWlFZq2l55h00cKfgVP1+JzHee/P93y6zsrALrrsyD+jKO67kZOjxbjPJtu3Q4MG3ocw2nWT6kfWB3z/XVKq0ihh+P2SmCWEvBHimrjgbPH99yagXL8+PP64CSyrfwY981SqAmTnZXtcz3HmeF0uMhJSU0tZQ0lyy3242+LF8NZbMG9euT6N+of7O+5v4CQDSocPFx24L2JuLwMRodFHjUhIT/B6f64zF4BDqeYkuU64yVrSDCXfK5gVZL/fFalgHZji9P26L9Zwq1TrszN5zraTi5+2/QTAlM1TAPhx249el8vL8z48qjKZuHEi/Sf0r+hmnBFiY6F5c+8dYcczj2NhEZdqPvMHkw96D/ZrlfazkoipmRYTU9EtKZ2xa8eWej9eFvZEHvYMsWeLDz+EWrVg9Wp47z1YtaqiW3RqYmJg5UrIPPuSyXxOA0pKVYCCPe7ertsiI80P8MFSnaNaIAXWM70OTLZgst/JN7SAYcPgyivh5Zfh+ushOdknq1WqiHWH1gGw/vD6CmtDTGIM+5P3s/zActdtBVPUdx/fDeSfEAFVgqoAOnNRedhxbIfX/0+ngp0ApQl0borbBJQuo8oOmJ1tJxd2cNWuFVjccEF/f5OlVJkNXTSU+bvnn7bns4ZbXD7h8tP2fL6UlQU1axa93d5/CkJqjhkqvPbw2qKdACfRAeAr1nCLp+c+XSHPfbZLT4cbboAOHaBNG7jzzspftHn5fvP7X9wMlSdrc9xmj8uzQVoarF8P779vzl2Cg93F+M80TicMH24+p5deCu3amSF8qngaUFKqAkj+TGz2zFBSzMxskZGm93ZHgXOoDO+j48ARAM4s9/VMO9321FPKf/3V9DbUqAF33QV165q2qX+2H7b8QP0P6/t0nSJCttOcvC+MWejTdZfF2kNrATwKQRcMZtgn/zO2zwBg4qaJAEzbOu10NfEfozIElKITol3/273LJbHrw5QlwHg2nVxA0dqAiZmJXpcLCDAnI5XZgZQDABxLP1buz2UHIf/c/2e5P1d5yM0127Sw7Ue3F7nNDsxXBnbQ+Nc9v1ZwS85ON98Mc+ZAWBiEhsIPP5iSQpWZ3TFwUp1bJQy/t7/bqw6e4Sk8BWzdagLJAwa4M04rW/2k3btNULN3b/j22+KXGzkS3n3XBMXq1jWZSpU9i7aiVbJNrdTZz64ZEOwXTM7LOYT6hwLes5Tq1jWplqtWuXtws7OLLGb4BUPGIVNLycf+8x8Tqd+0yexo11dc4oiqRL5a+xUHUw4WWwPsZNg9gf4O/woLHgD8FfsX4HlStzXeHUiwA0rbj5mTJHsI3IkKiYsI1nCLb9Z/49P2+kKuM7dSDrvacNgd1KuooEvBrKR1h9eVuGzBrKQTnYgULFS99vDak2xd5WRnJtkK1w60hYebA/3KPBuQHWw4HVmTMYkxAKTlVL7vYq4zl5YjW5KdW9yBCPj5ee/Nt/eVBblmeqsE7H3LzmM7K7glZ59Vq2DRIlNXZ/9+MyzynnsqulUnZn/f7azpMvGWeZeffbf+iFnvLzt/8UUzK4W//zbnCVlZJ162Iixdamaf++kn+OMPeOABSEoqulx6uhmJceGFsG8frFsHM2ac/vaeaTSgpNRplpRp9mDhQeH4OfwIDww3t2cV3bOFhJi/+fPNTg68F7oEIKwxZByEPN8O9o2PN0U2v/nGZCWFhZkTAKXs7J3VB1f7bJ32iXvDSDPtk10I+XSz67/MiZ7jus3urQRYGbsSKFpo+EQzt9hBsl93V75e8Id+fojwt8KLHYJbUQoGcE7qwB7yxw7PgZ2j4VjZP692XS+AZfuWlbisHRAAWHNoTcnrjXevd9GeRSdsx8sLXy6Xmh7lwQ6y2nLyvHd2NGliTjAra52K5Cz3+O4TbU9fKLg/Le49qyhrD61lZ8LOEt+HwEDvJ2q7ju8qcltsSqwvm3dK7Pe9cCBUnbrPP4fzzjOlE4KDzd/771d0q0rmFKervumC3Qt8tl77GCHQL/CsGiK/fTs0bWoCypVNdjbccouZTXTVKlMv/c47oUqVosvOnm2G6k2bZi5DQ+Hii9335+WZ2euOlSJZ9YIvLuDCry703QupxDSgpNRpZg+FCA0wmUmhgebyeIb3KXRr1YIVK9zplsUWuQttBFnx7jpKwb4parlyJbRte/pna1h7aC0DJw08vU9aSeXk5ZzcbDglTFvrC3aBZF8OzbCHEzWr2gyouCFOOxN2EuAIMAeV+Sd1BdPT7dpKhQPBeVJyMGbpvqUA/LHvD182F4Bq71Rj5MqRJ/34NQfNSWJF1q7yxh5+CCd5Qp8ZB3POhz9uhrX/gQV9Idv78Kvi2M8bGhDq9cS4oILv3297fitxWTsrItAv0CO4VJyZO2YC7hnUKis7S8vColfDXua2YoZ2N20KcXGVt45Swe25KObEQb9TtSJ2hev/0nwmTic76Lk4ZnGxy1SvDtHRRbdnZk7RiGFlmjp9ScwS1/86uYJvLVliMt1DQty3lWr24gq0K8G9n/dl/TS706xRZCPA9/WZKkpysjlfKbiNT4dn5z+LNdwq8Rh5xgxz6Lt0KXTsaNpZXEBz6VIzbK/gcL2wMHO5YIH5vWrf3sxkd/fdJWfWrj281qMO59lMA0pKnWZ24MjOTLIv7UBTYQ0amIj4a6+Z6y++WMyKQ+pB+kFTSwnget8UtVy71uw8SzXTnA+99vtrzImec8IhRGeFEgI/SZlJBL4eyLvL3i37ekuYtvZUFczMsbN5fGH+LnPgZtdbqYg6IvZra1q1KeAe3vbXATMMrlpwNeLS4nCK05WFEezvPjrOyi2+h3vGNpM7vTdpb6kKNpfW0fSjHM88zsi/Tj6gtCHOZJwt3FNxtasKS8xMRBAclgMLi4zcDNKzy5C1JgK/X2cC7ZcsgBviocc4CIwqUzvsg8JaYbUAXLNUeVMw6HWiz6+dFdGhVgeg+I4F28YjG4ETB6oqmh1orRFag6X3LSUyyBTd8xZAqFfPDC2obPU2bAUDmvOiy3+K0zk73VmRvsz+9IX/rf+fx6U3bdqYYU2F6z3an4HXLn6NH276AYCo4LJ9D8uTHayFyve+n8kyM81U8r16eX7HK2MmS0F2IPmcqucAntnSu47tOulj001HTKZzqxqtgLOndl5eXsXsw+1jxoL76cLmzIHrrjPBLvtzV9xIiyVL4JJLit6/ciUMGgQXXGACVCNHmmWLe80JGe4ZggtmuZ6tKunPt1JnL3snExEY4XFZcOdTUPv25vKdd0yPztKlxaw4tD6k7YGTyWQpwdGjJhJ/unsdft1lhgT9suPsGWNerBICP/aQq5nbZ3pfpiQlFIU8VfYJdrB/MCtiV/gsODJvlzlhW33IHNB/u6mEyonlxD4waVezHWCGXKVnp5OUlYSF5TpZtmeAAYj5d4yrx/FIWvEBu1k7Z7n+35ngu1od9knoya6zYC2fCRsn+KRNvmBnDTjF6cpwWba/5CFnHo6thNRd0G8BVOsC/mFQf1CZ2pDnzHOdPOxPMjOVlVR83c5isT8/JQWJ7ACj3WtdcIhlYQV/I6ZvnV6aplcY+/2KCPL8nSv4ObPVq2dqKFXWE0w7m7B9zfZmhrLs1HJ7LhFh69GtRAWZQIud0VgZ5Dnz2HFsBwGOAKIToosdGmsPYSz8k2Bn/VQLqUbVkKpA5cm0y8zNJDU7lXOiTPDA7jxQp+74cXP8WKNGRbekbOzfGfszYQeCRITmo5rT4MMGJ7XeqZunAu7jDF92yBVRzlnqBYWEQGrq6c803RhnOllm7ZhV7DKLF5tgkJ1pVJJjx0xQvLDBg03drwkTzMxvd99tgkzFKTiEvWD249lKA0pKnWZ2JpLdW2dfFnfS0b69O5hTYrG70AbgzIY43+64LOv0T+2anJXsKkg6Zu2Y0/vkFaGEwM/nqz8HTACnzMPe7KKQ5TAls11T4Nxa5wKwJ9E3xVULF4X2Vsi1vI1ePRqAH7f9CMCIv0aweO9iwAzbsYe1zd45mxxnDuGB4dQOr02tcJO9UtxwCfvkqVOdTgAs3eu7k8XxG8a7/i+Yql9a9hCWaiHV2BS3qUj9m4riLXh0opPs3FwToIiNBdn/I9QdAH4h7q5Ev0DXshM2TODVJa+WuL6C2Qr2treLtntjZyXZwzXtGQALczqdJGaZTDx7f1fSQbF9UOqwHMzYPuOEQdypm6cS+FpghdTEsgNKdgZKlaAqHrcHvR5EwGsmm7ZhQ1Pj4vff3Y9PLb+YTZnZwfzN8SaTYNqW8pvJ0R5Wa+VPf/Xj1h/L7bnKyq6Z176W6eUqbmhs48awZYuppVTQ3qS9AFQNrkrVYBNQKin4HhdnZlrq08dkDIwcCYllG6laanYHlv09nLjR+3dWFZWVm+V1OKNNpGKOI0/VuPXjAPh9n9kx2cdi9uc+x5nj8Tu5fP9yQt4IOWHdM3t9dsmAn7f/7NN2V5TGjWHXrtNbC69gAf3PVn1W7HJJSdCsWenWKVI06+jQIdi5E95+2525FBhoaiwB7Di6A2u45XEeVzDj8Wwqvl4cDShVNqcxmqwqhr3DsQ+07cvihry1aFH0wMyr4DrgCIQdn0Ku747Ga9Y06evpp7E2sj2soHpIdVYcWFGp6iyUi2ICP1kH9rJk7xIiA03QsTKl4dsHW3bB5BErRpzyOtOz011ZKGEBpiupIlKFCw9T2hK/xVWIOcARQJCfqYy/8oDpnrKDwrVCTUCpcKFu2//WmWEi9sxGH6/42CftzXXmsmDPAlcWSElBieLY27NOmPmtWbhnIeRlw5b3YFYHmNkSZpwDK+6HtNNXSDQxw5xBhgaEEuJvIuvFTT+flQVDhkDLlvDUU3DvvfDnrNVQuw8ERBRZXkS466e7GLp4aInF3+2TfH+Hv6sN3qZAB89gnl3Q9bfd3oeneZstrqS0/UmbJgHQpobpPj1RfZ0XF75IjjPHtwez3o5RvByf2IGjasHVAFwZKXFpcRxNP0p2Xja5zlyOpB6haVOz63v/fUjLjydXlhnfEtITXNvRVp4ngHYgwz4eSMlOITmzjPvAUm6jsrL3X/bEIl+t+8rrcuecY44XFi50b8e0NHegvWpIVdfnobj6MevXQ7t25nEjR5rPxp49JcxyWwyn06xrzhxYs6b4oft2QN4OcO1L3oezsnwIK7mQN0IIeTOk2A6viAgz/LHwEMjKzs5Etmd4tDMVv9ngnqG14L79lUWvkJmbyQ9bfihxvYUzHH1amD4n1Uw6cXghJG6Cg7Hl1qlYWPv2pnZasRMHlQM7o7dl9ZbEp8cXO9LD4Sh95lREhBmCXdC6dWaoW+GgqN3Z/+6fpiTFl2u/dN03edNk1/+TNk4q3ZOfwTSgpP55cjNgzyRY/yKsfQa2fghpe0/b09sHinYgye6p+1f/Z70GE9ve1rF003BaFlTrDIfmQtzv7uLcxSnlQWfnzrB5MwQElOllnpLXf38dMD3xQKWcYv10sH+QaoebDKb3/nyvIpvjkpqd6poC3D7ZKmmoTmlFH48GoEW1FqwZbOrQZOVlnVxBci8SMxLp/b/epGSllLicHcSy65tl5WXh7zBV8W9seyOPdHkEgGynOdC0v8P2drJ7Hguzh5LZWSm+KrhrH6zYwbg3/3izzOuYu2su4B569d6yd2HhpZCyC/ovh4Hr4KptUPcy8Dt91VTtg/pxg8bx5dXmYM0+oS3s1ltNYdBNm8yslN9/b/ZfUGBWtOl1YLIFk/08sp/sgJo3dobPnR3u5JMrPgHcGSSF2bP/mWc1y0Qfi/a6rB14rB9Rn6tbXg0UnRmtIDtjLjrBrO+N398odtnDqYddxcOfnvd0scudSIMPG3D5hMvdN3gbnuvlNjugVD20OmAy3+zbx6xxZ52OWTMGh8NM5/zbb/BLfuzriSdOusk+ZWcT+Fl+rmBiwdkefc0OZgf7B+NnmTGAs6Nnl9vzlYUd0NyduBuAbzd7H47csKE50XrpJXe2Qmqq+zNRMEPJ2+y2InDHHSaQ9Nxzpoju+efDq6+aYrqlNXmyCS7/+KPJMPjlF0jwfr7pChqH+Ie4vrenY0a/M93u47tdvzvFDcuPiDCF2tcWHyuvdOyhzWA6kQAOpx3GKU4++esT1312VkxKVgoL9pis7Ud/ebTY9SZlJiEIAY4ALj/H7Fez87JPvWSACGx5H+Z1NbOZpuyA3eMgu5gPfDlo184EfWNiTttTurKL7Y6c9//0Xmm7fv0SJjQqpEcPU3y7YAA0N9cEyrzFmDNzM13B9ecXPE+eM49l+5aR68zFz/LDYTlIzUk9+RlqzxA+CShZlnWFZVnbLcuKtizrBS/3W5Zljci/f6NlWeeX9rH/OHamQkHlFE3+Rzq6EuZ0Av8QaPscnPsq1O0PAZGnrQnx6aaGhH2AbV8Wd9Jcz+8INWu6rxdzHmM0uM4M7VhyDcxsfnINFCckboYji+DIIrq03Mr27cKWLaen1zg7N9s1Jtp+rz5c/mH5P3ExylQA2MdeX2oCa3ZdnMpSN2X9IZPyHRYQ5iomXFzPUFnYwYw2NdvQqkYraoeZAI2vpinVUDUAACAASURBVNa9Y/od/LH/D+7+6e5il0nISCBP8ggPCGf1g6tpEGnqJNi9k9e1vo5/dfgX4J4Gu0aoKQ5RL6IeAHf2f85rcPjgYbMd7QNUQTwOXE+WfYBr93zGpcVxOLX0vxkxx2NwihMLi5AAc9IcdfwvkFy44EMICDe1h/wCTf2h4DKc1ZWRU5zsStjlOsC2g24NqzR0bYtNcZtISIBx42DoUDNRwZAhZsjU6NGmTkJUlJkSOLD2BXBkCeQUDiI6eXL2k65rT855sthgjp1JdGGjC+nfvD/gfQp0cAcTn+nxDJsfMUOk7GE0hW07Zj7vt3e4nYnXm8yUw6mHvZ5c7Di6w7WN7ODmkr3FD29+/tfnAROs2nV8F7/H/F7sssWZuW0msSmx/Lr7V/dsi96G53q57UiqCTLZRcxrhpkfsYMpB3lp4Uuu5V5Z/ApZuVlce605YL/lFtN5MX58kVVWCPt13NLuFqbfYva/5TmtvJ2N+3Kfl7ms2WXAiQu1F1H4ONIHx5BOcboyAwPzh4wmZiZ6PW6xLFNjZP16eOQRk6l09dVm3+qwHFQNqUpEUAQWFrnO3CLDnA8eNBkCN97oWfOkuCK63ixbZobLrV4N//0v3HcfPP88HsdSBdkdI69f8jqd63UGfPe7U1bj1o1zDcGrTESE1QdXewzpeu7X51z/P/TzQ8UGRnr0MPvmgkNZU0ru16lQ9kQcfRv35cgzZh+Qlp3GF6u/AHDtg2fumEliZqIrsNGkShMSsxKZtd17lrBdgLtDrQ7Mu3MetcNqm+OA5FM8Dtj9NRxZCFeshLbPQ4uHzflNcDEf+HJQu7b53X3hBXemaZr3nz6fSMpM4ljGMcA9FL24oaoDBsD06Z6fueLOZ/r2NRmNBT/KDRrAxo1FZybMzYV3/zDZSfbMxF+u+dLVDj+HH/6W+axUptqU5eGUA0qWZfkBnwIDgLbAbZZltS202ACgRf7fYGB0GR575sjLhP3TYdNr8Pdb8PfbsOlV2D4KUn1TX+RslZKVwqBvBzF54+QTL3wq/rwNun8F9a+GwCrgHwpR7SCwavk+bwH2AaqrtkSwqS3xyJfXFhtMvPZa95jeiKIjN9zqD8x/XB6kxZTcEG8HnX+8ZmZEyjoGkW0gsg3VwuI579w87r7bFFdMSTHjkcuLXZskMjCSvo37AiYl2JczYhWWkZPBuaPP5aJxF7lOKkWEh2c9TNhbYbyy6JVye+7iOMXpCja0qNbCNYX9tvhtp70thdm9ufecdw/rH16Pw3JwNONokRODsrIP4lpVN7Of1I+sD7gDTadi7NqxzI6eTXhgOD9u+5Gv133tdTm7F6lF9Ra0qtHKFTCz66c0jmpM46jGgHt4hOukOdQcvHmrWXM8GNICIdgvmKyXsrim5TWAb2axsz8nV7a4krrhdc1695V+vXaB9X7n9OOP+0zgrKozFQmua4JKtul14LtQmFw+1ZNFhP4T+9N8ZHMemmVOTuy6Kw0jG9KwSkMAdq5ozqBB0LOnCSb93//B7bebAFLh3YTV6Ho4NMf8Pjudrtkvf0uDdUfcPYZ5ksfwxcO9tsuuHdO4SmPqRdTDwiI+Ld7rUFw766ldrXY0r26C+vuS9rmGTRRkf49aVGtBZFAkoQGhpOWkeZ09yN4vXtTkIqbeaIq6Hs847vWEPjM3k/EbTUTGHk5x/8z7vb624hxJPcKgqe7i5b2/7m2GAJUyWHEg+QDg/k7YweFfdv7iymiwvbPsHa66yl2UO/c0lO/Kzsum7vt1sYZb7D6+u9jl7O3Zu3Fv+jXtB5jtWdJMjifLKU5X9tkTXZ/ghjY3AO5gdkX6O84EdhtXacyRZ47QNMrMgGkXKi7szjvNscr48dCvH6xaJSRnJeOwHEQFR+GwHIQEhOCwHEU+76GhZnjKqXwOpk2Diy82mVL2SWBxQ3HSstM4mHIQh+VgSPchXNv6WgBWHFhx8g04kWIyxKdsnsK9M+/l8omXs+HwhvJ7/jISER78+UG6fNmFDqM7kOvMZf2h9R6TE8SlxxXb+XfnnSZD7PffTVApNdWctFdW9tDj8+ueT9WQqtQNr4sgfLXWZKKIiCuTbdLGSXyw/AMAYpJiABg8a7DX9doBpZY1WgLQJKqJx+0nbc830PhW8A931wj0L0UFah+yLHjwQZg/3ww5//tv89tcXuxJURpXacx/evwHgKNpR73+Jl5zDfz6qwkKpaWZoa/FlfEYONCU+Xj+ebNMSorZl1kW/PCDZ+ZSVpa4On7tTqZnFzzrChA+3f1pnuhm0m0rKkB9uvgiQ6krEC0iu0UkG5gCFJ5CZRAwXowVQJRlWXVL+djyUR5jzBdeDnlZ0P5FaPEotHwUWg+BVo9DeFPftLuyif8Tdn0Nu8ebYWR7Jpn/d30NR0v3Yzxt6zQi345k5o6Z3PHjHfT8qqfPhrgU4R9ueqrtnugCwx9Ol/j0eCws13Ca8MBwc4KSXnT2G9s115iDLDhBwbvwc6B2P8iPiAMQXMoZvXJSYeVg6PUd1O4LIXXMX60+fPCRPzEx0Lo13HWX9xkQfMWe8eKJbk+w+J7F1AmrQ1pOWrkNM9h8ZDNhb4axKW4TS/YuIeKtCGKTYukwugNfrDG9Ua/9/hoXfnVhuTx/cVbGriTHmUPTqKbseGIH93a6F4CftpfjjCCl9Otu03vaqU4nHJbDNa2ufYJ8stYcNEMM7PXZPT6nGlBKyUrhwZ8fBNxZPPfPvN/rbE32gWTbmqZvo2PtjoCp9eFn+dG4SmOqh1QnwBHgCj7amUnVQ6vjsBwM/KBTkboFyzaYuittarbBsix6NOwBuN/LkxWTGMPRjKOEBYTx820/83xPk5kyfVvps9lm7zRDagY2H8h5dc6jaVRTZqaBM24pZMZBbuEjL9/vn0WEpp80dRV7/3Ltl3T8vCMZORn4WX7UCa9D/Yj6Jn180eM89JApshkYaLIYOncGf38zvMXuBReB9JCuEN4MfusHx1e7Xsv4/J7KzvU6u4YeFDdz2+7ju/Gz/GhUpRH+Dn+qhVTDYTncWTsFrD24FguL5tWaE+gXSK2wWgjClvgtpGWn8dO2n1yFRNcfNsHYplXN8YEdrPI2FPLnHebzc32b67mypQkcZuZlej3ptGt4nBN1juvzEH08ukyZLvfP8AxAxaXF8dGKj0r9+AMpB7CwXLVy7Exc+7t873n38kCnBwDz+WvfHrp2dXeclGY2npN1LP0Y4W+GczjNBMKajWhWbKHtv2L/wsIyQX2/AOqEm+PE8pjqe+exnWTnZVMlqAoRQRGuwLod8C0Xw4YVPRYeNqzIYnbR/q71uxIVHEXX+l2B4rPkLr8cqlVzXw+MTMJhOchz5rmGu9nHPoUDSlWrwpVXwpNPmhO67GzzV5Zsh4svNtlJubnuuknFZSSsP7weC4uGkQ1xWA5a12hd4msrL5+1TeO2abe5rp/3xXmVZphM97HdXcN6th/bTt3367qGezWp0sTV8VLc0OFBg8xsjldfbYL/N98Mt93mdVGv4uLMTMeffgqTJpkT+2+/hc8+g7fe8v0wqz/2myCuXa/OPiaxO5a2PraVz68yRbq/Xv81glAnvA7P9HgGMJmq3mYwtI+R7BlAW9Uw3/GNRzaeWoPrXA6HF0Bu/pdk4zBzbjO1DGl9PvDkk6Zj4MsvTU2lEadeWpOkJPj4Y7Ptv/kGvvvOfAbenG5mSL2+8YO8f/n71IuoR0ZehtffxB49zDHCZZfB8OEwZgycd57356tZEx56CMaONRMCPPigWfa110wm9NSpJuAdGwv97vmTHGcO1UKqMbTvUIL9g0nNTnXtLwdfMJgHzzfHnov2LPLeMX6W1E72P/EiJ1QfKJirdwDoVopl6pfysaXy+/sP0+eK+tD+Zc87Jltwu+cGXPzRs1yUWyjX0oJLa0xk/q7xOCzBVXPhwAzSpQ7fx3zK1q2m6Gf9+vBMPYuU/sf5fkYUa9eacd2XVT2PrlFr8Kt/tYkQb3oNtrxl1jMohlVbGjNlCjRqBI8NHIf/ganIRXP48ktTyOzuu6HWH7WpecsCj6Z9Ou41fk78gA/v+JO2Nduy8chGnpr7FM0OreHcLvfyeD9zkPfZqs9wHFnMYNnGbGsjK1eaGTFq14ZBQZ1pf/urUG+ga71zv9vO/73dqui45t8ugeaDiZFbGTPG9Op06jafz/++kpdv/p0eDXtwOPUwz85/lgmZE+GWLHdEfHod4uPyqBl5DG73/PW++26zg3n2iThTONqZy6qAC7nxhxs9lvvzwJ9MGVeT2y94lOQmrzFihDmouPKOGCbMb8ot1y7k4qYXk+fM49Ulr9I/bSkX1mlPRrsRjBplsmgGD4Ymf1pwSyb4ubulvtz2PdfE3UDtbnebLCVXnSGnOXEqMJTjpy//oHre7/S+7kIzDAwBy0HyrEFE3rwGIlq4lk3fOpXFP24gtuabrtksROC/Lzj59Vfh/Nq/wOHfILAKB2J3AuIqoGtffhy/xwwzKyhuKfz1ABcP3E6TJrBtGzzwAGz6oAcdbn4eGl7rWnTDBujfHw5Hj4DZHcGZA4FRULUj7BnP6mN3MXWq2dlfeVEMvZPawi0FThQDwpkVPYQBq5/G79yXTJHvTcNg86v0At5+W3j+eZg3z+zrHngAmjaFF59Lhe0jwJlFSv27iRxVdCqFuW3a0b/FlcTVf4fPPjPb8+67od2Got/PKStN5kjvRr0B6NWoFz9s/YFeTZtwZN13hOTtzZ82xMFHE7uzKqYXkydkw45RkHkIzrmXnBkdCbhxj5n5Lt///mdSXmf9LLB3ChxfT8Y5g+nweQeP58/MzeSitzsTHXwYP8uPuhF1iU2OZfmB5VSvn8CsH6rR49y9sPMLCKnD/D2P8ezzfmzYABxZDAd/Iaf5Yzw0qisXdLmJxy79FDCzSS1eOIfovOm8e+sSujXoRnRCNE/Ne4pX9h+jyy1DoPHNrnZ8s8QUQL2k6SUA9GvajzFrxtB89Ti+XdOT1NDert+dpIRM/vj+V6ZP8TxhXDZ1Gj2v6wut3TVUUlNNb4sI5vMWOxtq9eHRN6+mZk0Y/lIKbB8JeenQ4lGssHpIdjLEfGuKPIY1YvmuxViYLAwwQZfohGgubnoR2VlCwOHpZrbBsKYsXpDCRV32mszAfOk56Tw7Kow+F43hlk4PIiK8uuRVVu5cioXJRgF3ptKT/Z+C5Kc8Xttb17bi4IB0Xr5jNbXCarH7+G7eW/YeQ/f/RJ1bPbs+H/nyLgAGNB/A25e+zbPzn2X+7vmE/xBR5PM3Z42pA3FubTN7nX1yIeLEz/KjVlgtLMuiTngdUo4lkhiQ4sq+qB5i6sW8djAHYiZBkztc6/0lf71d6nVxrd/C4qZjU9g48zLmbb/FdcIU4ojn+ea1irSNFfdCRCsS6r7AqFHmJCuslwkGdanfxSNQ1fvoNJxrG7Mk6Q1mzzbL9u0LN9wAcnQVHJwLWXEQEMW8TT9iAZ3qmtnnOtfrzPdb9jDw1QnMtfpgNbsXotpDuxdZPHEaFx1MgDs8x97mTXDgd/1+CK3nuu33r7+kzzmzoO8Mj2WTxkZR5ea/ILKV67abPhnA3qS9BPkF0aZmGzYd2cSmuE04gKrBkfg5/PBz+BEeGE67Qc/wyfvzqVkzit69TVApKQnmPD+QK/7vB375JZRevczv9dixFiGOH1n51uUmqCR5ZDjh2xQLEKbfPJ26EXWp8nYVHMlbYVpN5Pp4Jk0yNT+6903Oz6ywXBlS9SLqcexwKF0anUtWpsCeiXB8DblR57MvaS8W0LyayU5qGtWUtONpdPqiE4X5iwMscWV7NKvajOiEaC55ph8UigcueCkA/OGCuhcA5nLWzll0WnQ+3JbH7DkO5s83kzh8fNwMQ3mj3xvc2v5W1h1ax/zd86n6YzW48bj5Xci35MuR9G27DHpOcd0WkxjDL9GmmNHmRzazL2kfAycPZNu0WZC1AC72/H7Ff5F/3BLl3pfuObADkCK1Ao9lHMNhORg5YCSWZfH1+q8JTfgLfunAqFGb6NbNnPjXqWNOAF59FQZedBB2fgYBUaxKfoIbbg5i37rVplZI5mEIb8aQYe156J442rR2QH7tvR27w+hy3dUkxSeZHvyUnVClLTUmmxonFpYJckgeD08YzB3BN9KlYS96N+7N3qS9/LbrN46mx2FhMhYBmldtTtLxJC5Y3LnI93PJB0/Q97IoOPc1122HUg4xfGw9rr9mHpc3u5ycvByGLR7GygmDaBPZlRHvxsPO0ZCTzLqcGoBwTn6AsVWNVjgsB60OBnDj6MZ8ePtSGlVpxIJdC3h58cssD1kB1x/xOG75/avP6dNiPvTx/ABFRuaxZo0fLWptM8NjwpqwbFUEPXsvdU/DBSDCwc8aUi/hGqjmqk7B93+aIRw9Gpj9y4UNL2Tq31NZuOAlMo//zbP9P8eyLEb8NYJje39ieEgsU6Zsp18/s/qQ2vEkOnMIcPgT4GeG/FYJqkLdI1XptnIQNPDMcvv63usZ9Ppn9OtXh0suMev48UfYuxfSU3Ng9zeQuBGqng8Hf4HafTlS5XE+/dQs+/jg4/Sr+Qm9ew/juedMXadDh2DujgsIbxzEmzcvIDQglJ+2/cRLC15CENe+vlX1VibAtCeRFyZ1Z9gtiwn2D+aPfX8wYeMExlz9hfn9PDjP1KyMbM3iOYe4qPsR6Dra43VYlqnrFpH6q2lnWFMWL87hommXQM/Jrvf9SMphHvvAnEDe2OZGEjISWBizkPMfHsmVef9j1sxc8zlJ20t6gxsY8s0l9Or5Cndd+F8ARv41kvQlO3m+03q4zHN4a7Nz8pg4yY8e7bbDrq8gqCbz9/6bZ18IZMPyWNgzATJiyY48l4envUiXLrfwyKUjAZN9M2HeWFamr8TP8qNb/W5sjNvI0YyjfLNuLAC/3f0bDSMbEvVOFJu35FK9upl6nYPz4MhvUP8aHFvfZdan/+LS+29m4ULTrvY9FvHQx5fw4M2r6FyvMylZKQxbMozLV0XT/wbP45ZfZmby++/BrhprtqVjPmBvcA9WrryQVavM2+l0ws255thy3jxzzNqhAyw70pclfhv4V5enaFilIXOj5zJ/13wSGyXBrdngcBcKXbVrmcd+vEOtDizbv4ysvCzqh9elRfUWhAaYXt7D+3ZBALzS5xUe6fIIB5IPMOXvKURNawk3eQae/9jyGxbuAJUdWBq8bxgxG67h+/ltiY01HciZQcPJqvUZz9++ikZVGhGTGMO7y97lvayZhF44id829+WXX8xQ0DatnyN04/1cm3kttHwS6l4Om4fz997GtIv92Zzv5Nu2fB2tD18F13kGvC67DO65B+644ag5R/MLJNrv33TqEkrKvvXmWDH9AIQ15ob/PkK/KyJ59L78ZQGa3ErNX1vz88/CVVe51/vKE+u5rMsmevd2AA6wIDsjkwceCWH8uPzzbfNzzMefwPnn5dDnoiDs8/DF8+vy3Xe9+LNQ0vV/XjU13K7s2B2A7g26M33DHDa/PpLovl+A5d6erZzv8+3TMQx4ZRSjR5sgs5+f+YuNPkidnBmQ9Lf5bXRm8+aAPURHf8+SJWbGyoAAeKBKFNtv282jj1bj0UfNY2vcZQKIT3V/ipf6vERCRgIjV44kPSeNMP9gmkQ1QRCC/YPpcqgJ1twLYIDnSXdu+rEiwZg/6cEDUQvZsu8HSFhnAoWBUfQePIQXn0ngirbTISMWLD927q9Ni9x34QbPpISBA+G+m6K5sdtPkBUPYnEwoRr1jr4Mt3rJsJ3sIK7nQWo1PslAloic0h9wEzC2wPU7gZGFlvkF6FXg+m/ABaV5bIH7BgOrgdWNGjWSwuZ1a2Sfw3v8JVwRWeS2xZf2lsSFj4szda84a9UQZ7VQkUmIzO/ludJptWXZ0B7SslGyzJiWLUlJIunpIps25MlPvbpLFStRHronXUaPFhk+NEdqRWXKlE4PiXRG5IZaIrfWE/kS2X01Mpb7JIQ0AZEQ0uSxjiMk8db68gifSiipAk6JJFFmvNJFsndPE2etGiIgzmqh8sKr9YRhFPkLetlc/toU+a2J+f/852pL66rR8sFbmXL4sFNSUkR27nDK2Bd6Scbmzz1e8/4R9eW5rl/Ib2+tkEXv/iWL3/1LFr37lywfgPzGRRJBkjjIlQCypMm5Y7y24b02PUV6hIs83EXkhctExgVKwhdVZNcnDYu8v0Ob9BZpgsjniHyDyHjk6Ch/efrBIFld12ybDH9kRFdkTn9kP/WlKbskkExxkCMhnT4RhiI97zXL7qiGOF5BHn0fOXT7BdKN5RJMujjIlWoclbXvtpLcw8tMG2rVEOfqITLx0dtlQpunRFoi0heRfoiMQZa+0UFyDizwWDb6w6Yiq59yfx42DBWZhMwdfr5kx8z0WHZAx19k7Fj3onl55vKdRoNE3kVkSmORVY+JLLlFvn29pbw3uJqkBJrXkRqAjOyKTPjvhZK59X8e214mIcdvMp/hA9STr7lbMgiS0c/1lvSNn3q8xzs/aCZvR/3bfM5rInIJIhHIH1cg9/KVhJIqXbrkyfnn5UqTqGjZPapZ0W3U6CKRcES6InKpJXKZQ2QMkjDItHUt58loHpIVdJWhTS8UCUBkGCLjzPbMegdp/ZxDGg1BLhiMtH0UafYksvgBZO4V90gkieJPlkCehJAmf39wjuTFrfRow0cvt5PPHm0k2Q7znHuikIlXItnfNRVJjRXJSRXJOi6SnShTn35QJnV43LThf4hMROQrZNFrHSVn31yPbTTrmYEyttlTIleYZWQ8IqORF+6pLrNamOdygkxth7xwbUt5+ZFqciTM3H4gAhneFxla40aRSERGITLBPOfKazvLJ3WGiDTLb8N4ZP8IxBqK+L+M5OS/jqrPIw2eq+31ezTy2d6SvuETj+3xx0e15e37wuRAhHl8ph/y6fn+AiKZmU6PXVXqyndE/rzbY98lk5CXn+orKctf8Vhv+tfBMjToSZFO+e2dZC6HntNdJASRN93bU0YhX7W/QeRLRBbeJLJxuMiywfLey+fKF482kVzLtG1XVeTjbsjrVe8TeQ2RryyRHxuKfBMsS/97oSTMvcejDbvGIQw1r/2H1sjrvc3//Z9oLZ88XFey/Mx6j4SZ9WaG+xfZj3d/OEIYavYXAjKkv1nnT690lezo7zy+R9PeaCHvDa4m8aFm2bhQ5JNuyPSBF4i8fYPI+P+KfPOCyISeMuOdxvLuA1UkIdgsmxaAjOyCvH1DdZnd3P38yxoiL1xRT96+P9y13iw/ZHRn5KNn+kja2g88XvOKT2rI2/eFurZntgP5/Hykb53v5I1hWZKa6pTUVJHUVJHYmASzD02J8fhuLLgC2UNjacA+CSBL/MiRGhGb5K17QmRrDbPePAsZ1xH586Yo6VR9s1x9aZpMmuSUH34QefTeJIl+qaHI8idE0g6I5GaJZB2XD4aeK6MfbeT6rO6JMu/70PAHRfwR6YDIZYhciCzr20OOzb6zyL5jyevnSs7++R7fuRXDu0j8T9cXWXZH37pFtufUHq1k6CPVJC7U/Z0b2hd5/ZYoWdTEvdyCpsj0K5FjN9aQ3+klY7lPRvKYfMOdsu5K8x3+iy4yikflS+6X2fSX92vk7xc7InIpIucgH93WRKa3dq/390bIN/2Q+GtD5Tp+yP9dFgklVT66rbnHsmvqIq+fX1PerPKoyCv5+5NJ5nLUba1lSjvTDgHZWAt5u2eI9B3ikKcuR6a3Rj7rjFx7C/LxVXVkYgf3sltrmPd91ycNJS9ho8d79s7L7eSLR5u6vnM7q5llD15tyc1McbU3hFS59urHZdSjDSUz/3u0O397rnirreTGLvLYRn8O6ybxP9/msY3yJiJv3hHp8b5/3xb56rIL5Mj0QUW2p7fjlgmvNZf3B1eXtADz+ORA5JOuyFs3V5W5zdzrnX8OMm0AknhTlAjINlrKGB6QRCJlaJ2rze/RJ/n7o6+RrQ+0lOj/NhGZd4XIkWUiyTtFvqtq3v+CNgyVfSMayITzrxcZi8iMC0SW3ycyvb28f0cz+fo8810RkCWNkaf6R3g/xrm6pkxu795Gm2siH3UP8Hps+e8hfSRpydMe78/cMWY9DYe4Xy/DkKh+D8rCq24ybRtnfruSxyKv3x0h6+q4f4++a4tc/nAdr23zdtyyYngXiZ9xU9Hf9qp3iNQ2xzsy0ezzV9/dSQ7/cGWRZae93E2ydk7x2J7fvdFM3nuwmiQGmbYlBSEfdSvaJoYhHd50H7dsobV8zmCJp6q8c0cjj33o8gbIx30ayd4vOxRpw7IBuB4/modkDA/IcrrKB3XuF/ko/zv3XaTIV8jiK5ANdJDqxIs/2eJPtjQO2SMJg5BjVJXvuUFG8LhM4WZp/HyIMAwJeRGp/qxpr/UK8tbdQbKtunsfOv5cpMb/BQnDkHn5n9duD5jlh4Y8InKv5+/n70/1lIT5DxR938PvF3nYc9llz3eXo7Nu91jWORF58e5w+a2pe9t/2x75d9OB8nWrJ0T+z72OrV/geg15FpIYZH77LhrSUQ5/179oG2rcaI55x+Zv+6+RlQ93lgWDLhH5JkBk0U0i656X6B86iWMoEvCy+/Ne6xmk+X8ayouDwyWmirntWAjyVi/kg2tryLQ27u25tBEy/NzG8mbkkyJtPV/z0vztmUKYjOMuGc+/5N0e5jvX8z5z37iO5nUt7N64yHfL6Y/8eXEb+bnmPTKt2zsy7aIRMq3HexIZEC8rVhQ5JZRjg5BneNdjP977vl5eP6/r32spuUeWe3yPPnqlrXz6SAPXb+L+SOS9Hsjrd4TLivqe+8X/u7GNfPxwXde+7kCE2d/++monyd47y2O9/3u1lXz0UE1J93e/l590Qx5pPlwu7ZMpa1bnSXKyyNGjIhcPu04Yhgy+yix77yDT3pVXBEkfFkuNkBS50/K2lgAAIABJREFU6iqRvj1zJJAM+ajWEPMd75n/OzcGGfN8L8nYPNrjM7H7o8ay98tzi35O6vcXCUTkbcw52tfIgSfqypanm4nMvczsb1N2i3xfVYY2ulikav6++Zv8v0/c5wqbaCefM1jW0dF8BtJiPfbNOeMdIr/2LXJ+lTquqkjcHx63Oyciyy9pKT9Xv8ts+4tHyLSe78sLtw6Q0Y82dm2j3VHIM+3PEy8hApE9kyX5X80kF4d8zw3yBQ/KfurLjAE9RKY2FImeKJL4t0jcnyKT/SXp9obiBJnB1fIFD8o+GsiO/O2wnRbyGQ/LFG6WCRe2kQ8equnaL8aHmv3iG7dEyYKmnr9zn17SVg5O7lvkfR/3356SueUrj/3t9vebS/rEpiL7ZonkZYvk5Yj8UEv+eLCpyKKbRVL3ijjzRJy5su+ztrL3i3ZF1rv8kYYiS+8RST+cv45sifuqhSQMiCr6/fpXQy9vmgiwWk4QB7L/LLP8ybMsqwcwTET651//b36g6q0Cy3wBLBaRb/OvbwcuApqc6LHedO7cWVav9vH02XlZpv5RbgpYfuZvzb9p/MhGvvulMRdcYNLpwQw5qlvXpFv26mWiwzk5Jh03KqroqqOjzQwmkZEmK2PrVhMxnzIF/vUvz3GcxW2Oj1d8zFPz3D30o68czY5jO4qkoDf/bTUPXXMBjz3mns6wiAI9Ud6kpposKqcTnn7avK6PP4bHZ/6HD1e4x0e3qt6KrY9t9T7bzbBhJq+woKEvw3njIOsotPmPmeJ+41DTu3Z90RoMl14KixaZqRojI+G3rauwBnczGSNPxzI3ei4DJw2kXc12XLJ9E198YaLOgYHmPXW9vBO83rK8N8Utu3ChmVGoe3czZa6/v+mV6ue4DP+w2tA1fypJyYWZzUwPqpfXfFJO0OYvvoA334TZs812tSwzC1KPHj547rX/gR2fgbPAOLzg2kVeW2oqNG5snn/MGPM9eeYZmGEnLpzofT+yBFb/GwauNUMWLQf8/SZseRvwB4efed7Qemaopd2GwutN2w+zWpvsGwBHENxa0hhCL367xGSO2bVl/MLgllSY1x2OmTon4gihakwgSVlJ7HxiJ7XDahP5diT+Dn+m3jiVG767wbW6UQNG8VjXx0r99J9/bnppO3Y0mZEicOxIMld3+okQ/ywzZmTt05CTDFhFMgUByIyHGY0hr8Bg8PZDTd2tmG+BXMCR/xot6PMT1L7EjMnPS4efmpj3vPBn+M+7IGGN6R0PbQTObJheG370h+88xytcP7QVP1qeU6/PuHUG17S6plTvw9frvua+mfdxTatrmHHrDDqO7sjGuI38euevXHrOpaVaR0VLTjZ1f7KzS5hFsdBnuGdPWLHCZG8EBcHSpd6/NnfdZYaOvPmme/hQ5t9jCT42G3qMN4W2p9eBzAIzdBXOiDoZxX2Xy7JvrUAjRpgivuedZ2q//Pij2V96tXqIyXzp8IrpAZ7TyXxHfLVvL4VPPzV1KoYMMVmjK1fC44+bbIxildc2Kngs4KvtvOgKMwW25BcCtgKg0Y3Q7Ut3jZDJ+c976R+Ql2pOx7EgJx3+uhs6jzKPEWDmOaadxWyjnLwc/jrwF21qtnHNUHdS8t8LpzOPGu/U4HjWcQY2H8iW+C3EJMXw6WVv8Wjsuybzr/tXEBAFM5pAQITXto3fMN41mUCVoCr8cd8ftK/V3uO5SnzPReDnVpAaDXYNK/u36wSvoaR1RydE02JkC4/b1j+0no51Oha/3pMlAgv6mGGrvb6DsMYwvS55EkDLFw4SE2NmhwMzJCavaCk70rLTqPpOVVcRboD3L3uf/1z4nyLLvrTwJd5Y+gZDug1haN+hVH3XZNkl3/41EWsfhzoXQ8vHzfHJlre8H3dEjzXHSW2eguYPmSzfRQNMseTS7ic2vAxb34egahDWCI6uoMEeB7G5TjY8vIHY5FgGTh5Il3pdWBk7sOix97D/g3ajITsRal5o9vkp0aYERP+VJpPbL4S86fUI/jsep+Ug/tl4ooKjCHo9CBHh8DOHXZNPnFBOMvzUCHIKFNv08tuSmp1KxFsmQ/+hCx7il52/cCD5AN/d+B03tbupVE8lYiaZjI9319zy84MDB+Cmm0zG5u23m3OJJUsgLU1YfmA5y/cv595O95qhuHXqeJ+9snbt0zIh0oYNcP31Zjblgudtu4/G0uxTk2VfP6K+qx7e3QdS2boxjLlzzWu1LDN6oUuXk3jywvuOFQ9AzERw5mewWP5Q7yroObHo/rb2xeazH5Bf2DUnyevxPxlHIHGDmWHbxWnqtGYeMceJCCZTyQ/CmkLOcZA80y7Lz4y0cJRuUFV2tinsn5yc/3DLHCu1aOEeUg2Y78CCi2HgBjMxk71++/X54nioOCfaZy++CuoNMMXVLT/3sZpfKNxS4Fjavn0anlnNkcBoP7g9t+iy/9/encdHVZ2PH/+cyUYWQCCQhEV22REEFQEVAXcLFq3iVuvS1p3yrdbt24JW+9PaRat28etaq4IibpS6oeCOoICASmURCDsqhJBAlnl+fzwzmZlkJpnJNjPxeb9evMjc3Jk5mXPn3nPPec5zIOq/zTn3iYiMjGrnaHueIv1Dp82tB3oC6cAKYFC1fU4H/oPGr40CPo72ueH+jRgxImxPWlPo10/krbdESksD2+bMERk3TmTfvtB9y8vDv8aFF4r07Kk9zgcP6gj0HXeIDB8u4vGI/OMfIsuXi4weXXtZNny7QU5/6nQp3FsoIiIlZSWSdntaVS97ym0pMvnMcrn33tDy1uDvlYzgD38Q6dRJZONGkQMHNCpr6VL93exVs4WZyLjHxonX6434GuH/gKdFnmsn8t0qkfISkYpS7bmuPrIoIqtWiWRmivz61/p57dsn8uSs/TqaNNNJRWWFPLD4AWEmctEzV0pmpsjhh4t8951+xpdfHv3fG6Ix992/WWR2W5GyotDtEf7mequjHL17izz3nH4ufrUeH9GqKBWZlS3ybFuRLf8R2fFOxL/tvvtE+vQRKQr6KIqLo/8bRESPm8/uEFl2i8hnt2u0zJLpIs+0Ell4hkYule8LLUP1110xU+SZ9MA+T6HRPNHat15kViuRObkia/4qsnSavsZz7UVmZYW87rjHxwkzkVfWvCJLtiwRZiL97u+nL3Nwn9z65q1V3+Vm99lt+rl9eJlI0X9Flt2s5X4mQ2T+ESIH94hUHPBFbh4bOIZ9kU9h67lsr362e9cEQvREIh4T+w7uk5TbUqrOX+MfHx/Tn7Bt37aq896Qvw6pep2DFQfrfnICefhhkVNPFVm4UGTbNv339ttBOwQdw0uWiGRl6fXDH830yCPhXzc9XV8rxKa5Im+M0++KSLX69DTOHxTpuxzLuTVOystF2rcXOf98kf379TAOOU8FKyvS78vXs0TK9+u2xj6318Hr1fLedVegnAcPiqxcGeEJeXk1RiYFdLtIw+so+DUbQ/FGPU/N7SyyZb7I2of1813zYGAf38i2zMqu+fw1D4i8dapIWVBjrbnqKOhzmPT0pBpREXuW3SbyysDAdzGKshUdKJI31r1Rs+0VzWe+Y5HI7ByRfx+uEQBf/Lnu61+U9bmzeGfV39Wk17Q9q0We6yBSuiOw7SnkxemTpHVrkTffDJwX33or8svsPbC3qrxzP58bcb/FhYtD2tfMRPL/kC/yYk+R9y8M1F15cfh2h9ern++qOwP7VpbHdgyWl2i9vTk+pI1z1j1aLs9tHvHc5hFmIje+cWP41/jv30RmtxbZ9II+v3y/vv+n1wfOXb5rQdc79HWXbVtWdY3NujMrurL6ffVQoG345oRaj7N+9/er8d0oLWt4A3XoUJHjjw+cF4uLRa67LsLOdZ0Xm9jSpSJ9++q9VrCyMpG+f+kb8tn0/dMQycoSWbMmdN/qz41a8Pe7rEjbt7NaiXx+j8iK32jdfTZTo2FEAufbZzJFZmWKvHOW3gvUcj+XsNb/S+Tt07S961fb9aQx1XVeXfuoyNtn6Pf14B6ROZ0Cn++uj7SuKkqDtldrv3krRd48Qa+VFaU6qyPSvrUWM/oIpQbnUBKRCufcNcBrQArwqIisds5d4fv934H5wGnAWqAEuKS25za0TI1pzhxNHnfNNbrsYFoafPihjvxWH/1IDfNpisArr2hyr7ZtdZ/0dH3N3/4W/vhHHVHJzoZXX629LD3a9WDe+YGlKDPTMpl/wXxOfFKXlp13/jwGX5rKCSfoqhZTp+o83J07ocuIMD3wzoXtgX/2WV3qNTc3sCpGP1+qi3MGncPkfpNJT0kPH5lUm01zoNvZOqqUGil8Sj33nEb63HRTIBn1madnUVBYwLbibWzYs6EqKWb6uilkZmoGf3+E2H33xVa0JrH3C2g31Dda6jO3eZOs7dqlPfVnnKHHnV/1pS/rZeurGil0wqvQbrj2okcwdy5cdVXo+2ZnU3NkyH9MhRsZOmSQ/gv29TOw6RkY/XR0K1p8/aTmljp2ro7UVY/QqMvGWUAKTHgL2vTXkZU190HZtxrtFOTI4o9ZCMxYOINM3/Huz8uTk57DHRPuiP59G9u6RyDvOBh5n35ug2/VEdbUbJjwhq6A6Nemf1VOklDVtm17A9ofCZmdA8NAtRzvOek5LPrJIsY+NhaA588NnxQ3kvycfNI8aZR7y6sStrfPbF+1pHWyuOwyzVuwYoUusw16+Et+Pq7ad2N21oMcdthVTJ8eOC+ec06NlwT0WnWw+jT5rmfCN0tg0SQYcIMex2V7Ye1DcMxjjf2nJZ0VK/TQffDBwOcbMTn0znc1B1SXSXVez5rKl19qeadNC5xb09M1ErRF2DhL85qc+G4g4nHx5bDpWeh1MXhawdCZMOiWQB7HYDvf1VH0VF9lNvP11++hHzzEy398may0LErKS5jUbxJtd70Bfa+scd2oTeuM1vWPvlz3qJ7fJy705VYcBp9Oj+36F0HH7I6U/1ojflKjjCKol8KXtT5TfAe7rz5nfTSVk06Co48OfF9ri9Zok9GGb274hm3F26ryAIYzsmAkHjx48ZLqSaWyspKze46F0nkw4r5AmyNS26N4va4u2X86pPjOEbF+PjsW6HE+9rmQ95mUA8/v1zxg/kVszh54dvjXWPcodJ0MBRM1Ksmv43GB74bvOOiXBoUVunJoeaXWaY+2PWIr8/rHAIFTlkBmV10ZNMJx9tAZD3H8E8fTtXVXCvcVcsGQC2iV1rAG6p49OhPk888Dx0N2tibvDqsZopBqM2IEnHKK3gv+/vcazV9eDgsWwPzz59P3gb60TW/L3rK9/H7If7i1hy5jHyzijJRYbPm3RoCOna3fM/HCqtth8/N6DHsyfOfbm2DVbzV34DH/DHwfk03HY2D5jRqJ7y3Xa83QmTDwhmZfIa+G3pfovfKHl2gEWLcpGvk3ZKbmiy3ZpL/vPlUjrcbODn2+88AJb8DWefDxVdpQ6DIJEDjywSYpcqOc+UVkPtppFLzt70E/CxB2Tke45yaSwYM1DHHBAqoSm3bvrh1EZWWBxF6gU8OqNz4LC/XEcMYZoR1OixdDhw6aSd5/Ioi0pGltJvaaSKonFa94OaXPKYCeRJ9/HmbM0ATV+flwF1Vpxmvl9eqyik8+GWhQg07r88tIrUdBAXZ/oGHKaXWvOrBoEVxySeg0kJwc7UQD6PdAv6qL6I4ve3HCCaGfX30+y0aXkQslm0OSggc0xgKLdSsp0XoM19nZYDvehrYDoe3gCH9jwNKluupDxGk99bX7Q00+GI0Du7U++k+H/BOjOg5rKHxJw1Cze+jFJyiJI96DMOJe6PljmNOetl6dVudfNQx0qkLcle2F0q1w7JyaDeLOp4UkMgRg1ztUHa/+UOaK4tCGKWiCwNa9CVkBrI6blTGHjuG8wecxquuoquS9sZgyYAqzV8+mW5tubC7azBUjroj5NRJBSgoccUTd+y0qO4af/zy0czgnwmF83XVw7bU6NTslRdsT5eWO7GG/06kPu96Hbz/Vehwyo3H+kCT34Ye60lhUYyU7F0GHowDfyFIcOis++EBvog8eDNNZH06cb5xitnU+dDkdMjrqjbj/ZnznInh9LPSfBhl5ULxOV9OtLq01lH2jHVEhNz3Nc/31y8vJ44IhF/DUyqcAuHvi3fDWUTDqscDfVJ/jJ5YBmR1v6erD/s+hkW+YmrQjyW/v59oRltZGH/uuL+//dwwPzww9F0Y6L/q1z2pP+6z2te7j8Xi46sireGDJA3TK7sTmos3cMeRUWL85cO2vbVBq90fQ4WioLAt0KMVaz998DJ2Or9ERdWEOXLwDKn0Ly+Tn5DOyc5iZKSKabPjo/6t5zf5mMeRP1A7xVnlwYAfD0mFBqa642jG7IxBY8TQqlQd02vvgGdqZVEdn+3E9jqNL6y4U7isE4P9NqDXjSVQWL9ZB8M6dQ7eXl4ffPxH85S+wejU89hhs2qTt9qFD4fTT+zC221je2/weE3pOID+nS9U9Z6PbOg/a9odOx4aeL/eshPnDofdlmlaieKOeg/tcHmGwMUnk9IKht2u6iiEzdfpx+T5dAGLM0/EuHeSP13/VjYwyYsKToh3JXSc3brkivV2zvEuS83g0+/3VV8P06dpIv+46XZb0ww91dZlNm/T31a1YoSeF6ieyr77S/EtlZYFt6fUcWC//dTmVvwmES6WlaXTSvffqEot33w1u+/ZwAZ01Gh1btmhnTM+e9StLRN5yvei2C5pXX8uFdcUKGDeuZgeEfzUcb1DUT+Hn3TjpJM2z5NdkJ9xYtBumc4A3zg4s5TllO5xTDOeHmdzfBPLztVNp69YmePHvPoXu5wYaSrU4cECX4qwhyuMyol3va2PLP4e7tsbat0v0Ijnghvp1JoGOBPS+LPB+wdoNg94/hXTNszDVt4t/JSEg6vxATaroS8gsgEOG1vxd10k1/7aiNbByhuatKNujx3LhSzWfm5IJZUWhc8Jb5fl+iHypefqsp7nu6Oti/zuAG0bfAARuZq49+tp6vU5CCvPd+DxjOMcdF10H8W23aZTpiBHwm99oWrsTT/T9Mv0QvVHveaGuFJnTown/kOSxeDEMHx7laO+B7b5oW9+5pBEiPWJVVKR51DzVvl7Nfv3zL3scrDGWPS5aA70uCX++Hf+G5pPYv0GP3+BIYL/u5+q5yr+a65Ttmjuima6/wW4ae1PVz/1zfdGtaeEGGJqgWe6tgNJt0POi5I0mAO1U8ZaB11d/rfI4WJ7O1u86M2JE07zlZUdcBsDmos30ad+HtpVFvtUpfde52r73FcWa9yhYrOeJne9BxzGQ4jvP+No4Ho8uSe437ehp4Z+/f6NGj7cZENjmbyf990EtT/l+/W78aB8M1FxSv3vvd/zP675V1mKZjLBvnUay9Lks6sjNe068B4DcrNyqlTQbYvVqXdWtoiJ0e+swp5FEMmgQ3HmnDuj/4x96T+nxwIOnaUTJ/afez5Ahev+4e3foc2tEI9fHnpXQ4yLwhKm3H3wJnY7TztyCk2DP51BwanKfTwB6Xwonvqf5RNc/rh3vh10bObeRiagZhhRapttv16SoN96oEUFt2+q0Ba83tHFXXKw30tWnxy1ZAqNH1z2K0twOHNCOmcrKRo4mqTygF7WUoLCnWi6se/dC75qrz3PcocexYMMCMlIyOFh5EIdj44Y0jjqqEcvaWJyD0U9pcrVvP9XG3IEd8MU9GnbeDDIyNJT2llv0AuUfuQ4XTRezojU6+ubx3b3U0pmTmqodW+GS1jdI6RboEDQqV1tjbf/XkN0r/M1JNCpKoHxP6PsFG3hzyMW1dzqke9Ip85bRKqUVpRWlnNb3tPq9d2Pa+znk9NULaEpG6Ahru6ClzYPrc/sCKHxFR69Ktujn3uOC0NftdDwsvyk0amvKdh3xqe9nXgf/Mvcb9mygVWor8nPiM6WlOVRU6HeoR4/o9k9Lg0cf1QCGt9/WwYtLL23SIia9oiLo0iXKwR1Phn6HvBV6o+sb4W/OcbqMDG1jeMP0pSS9yoO61HG4jm+AVrnQPcJ8T7+88ZDaGt49C478u3YA7luj03ib2eBOg8nLzgt0nqdmaadkK99IS30SuUc78FK8XiOSsoLmycRp+l+DdDgKNr+gC0N4NHl58TeQmqZpKJrC4XmBQdD/GfU/ICWaqNjfy1L1vQeuAi4I6n259Aq4pVqEQazniZKNkHtU4MYiqI1z3uDzeOiThwA4a8BZ4Z7tixzu44vSSw99jfI98NpITUWR0xt2f0j/XG2jBCct79OuT3RlBY0WzO5VMxqqFlMGTAHg+tHXR/8+tSgpCaQYCVa94z1ZDM0fiswIdHCcc44u8PTKK/rY69VTwWGHNfCNir/WTiNPmBEJTxp00vQEVOzXBaza9Av8PhnPJ36ZeRptZRokSb9eiWHSJHj/fZ1W9vXXOgIcbqSwei85wPr12iGVEJE0QdLS9GTc6OXyZOgooTeoGz1C9IKIniDDdWj9ZNhPABiQq6MtYw8dS2mprrqXkDodCyd9oKODC0+HpddAwSnhR1ObyJ/+pBee887TiLqFC/XYbRARXa2vddDqLrV05vTtq+/b6LzlulJNNPatg/bD6j/yULwO0juEjioHX0TzJ9QI/z2pt07HK60oZWDHgaSEu1A3t/1f64i+8y9bGVRvVd/JattP/USnyPW4UKf1nVlY83XbHAYZHeCTX2jnmwiUF2sUWRPxOA8Tek4AfI39FqysTM/LsU5fzcvTiNUf/xj6xHBf8H0UNu9UJO0Oh++Wh0afNnP0y+GH6+BU9Zx4+/Y1WxFUQyNNw9m/UVc+ywhaWSrWmxbngQlv6jl73gCY006nbsTJ9uu3c8uxt+iDjmM1r2RFjKuM1kfxer1WVwa9Vxwi6hqsyw9g17u+3EQa3u+8jRGaEZlzjkEdNc/SlAFTNAK5ZGugDef/3k8th73Vnrwe2PlhaBTHlO3wo6LozxPesoidM2MPHVv1c98OfcPuQ+VBjR6WCO934vs64PPdp9DpWCb0OKHGLmO6jYmurKBR3DndtW0WpYzUDGSGcOOYG6N/n1qkp+t5PNwqfy3BAw/At99qRNPVV8NFF+n9ZIOUF+kASU7Q9JRI59uKEk2NEDxQmIznk3ioHs3bGJG8CcI6lJpYXh6sXVuzwRdxClCcde6sjdFwK2g2SEq6Xoj3BOVcj9AAd05vmvbvpwZ/OOz679YDMKHnBEQSfOThkEFw7LNw1g6YvEET2jV03rH/pBTFialHD821UVQExx4LEyc2QgI/bzngoo48mTQJ/vrX0DoNV78xc6ngDWok1zbFqugL38hZPRO0lu2FrG7hG+WZBaHRdz7jewZGJ0/ufXJs79dUKkt0ypMnTBhGcGL16p/lIYPg0LM0mXmkJDNjnoGvn4I3j9ekjYsvg3cjJAptJGcP0Nf/4YAfNun7xFtGhjaQDzTD/ef3Vc+esHKlRv3UKW887PqQquXs4+Coo7TPxh+B5hduECvpVJZq9E5wh0F9blrS2mjC0h8W6tSGKdsar4wNcei5sPYRHen3+iqvoqRp3quyVAdDInUqJIusLpqEduHpsPk5KNlC62+fobKy5hSgxnTn+DsZljeMvJw8yB0F3y2tmTeyskQb/MG2AuUHdCqNf8l08Ya2Ieri0rRTyC/oupzqSaVjVkeGdBoS+fmedN8MgaA2UfC1vU0/GH6PXrv7T6dne50a4HC0Sdc8EuN7hcnjEsm+NZB9aCDZfBwiV3r0gDVrao4dRnVeTwKtW8Onn2oC7wMHdNpzgwdsy/Zoez7KWSQ1RJHewLRsVvNN7IgjNHppz57Q7V5vlIk/m1l6ukaT/PvfoQ3URrn5zx0Fm54LjOhCxAtrfr4mQ6/OOUevdr0oKisCdMpLamocRmSTzKBBesEpKtKL6rx5dT6lDmGifGq5oPz0p3oBvP56KC3V0aMnn2xoGdDR6yg6KQGNzGk7INCwivXmxFumjchw0WVtB4fe+Pgc2SWw1MzobqNje7+mIkJIUoTgqKTg72N9Ii7aj4CTPtQR0c/v0qSfox5p0vnoZw08i8GdBnNEQRRZrZNYSopOGV2zJt4labnGjNHzVFQDFG3667Sr987RaZ1lRTrK24zS0nSqvf/8evCgrup6+unNWoymIRXawR1jTraIMjpo0tX0xp53XU/dz4W0LPjPMF3NbuursCCGG/dYSGXNQazaPsumyonVGI78G+QeA4t/BvMGkLb8Krp3h48+arq3nNx/MsuuWKYP2gzQDp51jwY6ibyVULo9fKTe6LtgxS3w9dP6vL2rYUHNKKCIWnWCPSsCj6tdl3fesJPPrvws8vOzOmvUUHAHWB3X9v65/RGEorIi0jxpZKXVHCyLqGyvrsjoz58Uh8iVUaM0D2v1ZkdCDzzHKCUFzj0XZs/WBW+iWdSjVt6y2iPZQt48UwdSgu/l4pifLqmEO0ck22IZEbSgr1diysmBbt20Jzm4UyY1VW/uE9EZZ8Bdd2nPt9erCcUbpcOm6w9h/RPaE15ZprknKsL3VB15pK6qVxI0YOcPXz2pV2BVr6F5Qyko0FHlZhMuZLG5G1v1nGKQlVUzWq5ePGmAN3TkrJYLSo8emmzwiSc0Mq+gQDuXGiz3GF1tIpqR3YpSbejUl0upebH1N8ozOwemkAUZnh+YXnFUlwRJ9JWapTe+/sgKf72lt4fitQ1//XZD4cR34NwSmPy13jg1Ye95x+yOrLxyZVXi85Zs2DB47bXQaVktIholQYwapctNf/BBYEAlYkSYc7pk8u6P4JU+8MFUeLn55xTefbfeKJ1wgq5A262b3kwlPU+6Xl+CoyZb0k2LJxVOeFWn9S25Wjsmi5qot9iTHhrJC7V/lpFC1Bs9dL0eUjLg2Od04GLUI3DKUsaOhQcfDI1AabJoFOc0ae9nv4bCF3SAae9qePuU8Pv3/6Uu2PHJNJgwsj4vAAAV6klEQVTdCl4dqausRit3NOz6QKeP10d2T73WF/03dHstbabgdsuRnY+MuF9YlQcCUeBx0q2b5gidMSNw31VS0hgDqS1YVfs23GBjtbZVWo7mZKt+TJnvtZbfAk8A114LjzwCzz+vjdRvvoFduxK30Tdtmo5yHn00LFig0UoN7v0GXVEIr29E7hmNVpp/eNhdx4/X5a6D50D7b6KCoz66t+3OEUfAO+9o5Eu9xdJJlMiNrebiPJDaRlfYidL06fDyy5o4sFMnuOeeRghc6Tgatvw7dFukhpJUBJJS1kdKKyj7NnSq2JTtmtAysyCQJyEoxDs7PZDfqVubhq9e0iiyumm0VvUcB20H6hQebwu4WWuhxo/Xa0nweTE4ktQ0TH6+Tgu+4ALNTQTagRdR7ihdbcylwdbX4rLiTZs2uqrRpZfqANa4cfBZLQELSSPtEL3xdgmQd66p5PSC0z6DY5+HYx7XDvimkJELxRuiWpE1abQbCof+CNoO5MILNZ/p889rR1JxMbz4YhO+9+BbNS/X4svgmRT4z3A4uDP8vp4UGP8mjLwfukyCw66BSeuif6/co2H7m6Ht04oYGrvO6bX9yz9H3SkV3KEUc+SvJ1XbWn5xmArlHNx0k0bu/PrXmnbkiSdsUYpaeTJ0+m3wcVZbp3PbgbDt9apcZkDoALP53rEOpWZwxRU65/XSSzVHUUGBjnquWJGYc3oLCjSR88aNcNJJ8MMf6qprDZbSCsbM0ovhR5fAB+dD2Xdhd506VZPOnXaavvfBg/o5QuiqG845jjkG5s4NfX7Mn6t1EsWudW/4bllMT5k4UadmfPklXHllIwSudD5VQ6o/+1/fyhP7teEcVqSpXlGeBrMPhf2baxb6wE5dPcgTJsl1EJcoc1zbDoR9X9W8uegwSvMfeYMaq+U2lzSRXHSRBiFOnRqYOnrNNfEuVcty//16/Rg7VqcVTJlSxxM6joEzN8M5xTB5Y7OUsbqcHI3QWLtWO8DCrZBaq0RMFJrVRW9MSzbHtxxNzZOiy3B3mwLpbevevz7a9NfOOW+13udIuXyq5wKqa3ucTZigqRouvVTzNU6erIsQNJnULO0IPPQcbUd0PAZOrWWE2DnofQkc/xIc8UfNJxqt/Im6AMqyG3xtnNLYp5H1ukQHcHf7Ip0qSnSBmAj65QZW7xqSV0t+pnA8GTr9t3rS8maOKrzmGh28/Pvf9diYNq0Rcoe2ZK3ytEOoNMocc7ljYO1DoZ2HzbjYkEk81qHUDFq1gsWLYcAAvQlISYHzz4f33gtdTS2Rlv79+c81PNSfxPmDDxrphQsmwqmf6jSYbmfrCmhh5ObCVVfBJ59A+/baYJ49W383sONAADpldwI0X8SOHfC732l4a0kJLIutnyM2SdbYajLthkHhS6F5QyJMYWwymQXQ5QxYcz8sPAOWXguvRZha5lJDG9SxNnRa5QNSs8PKezA0D1E1L059kScmPxHdezSHNgP05mJftXDlzidD0Zew811ttHrLoGRLfMpowureHc46C15/Xc+Rubnwr3/Fu1QtS//+em3Oz9epZFGtjOec5gxJlE7jWIUbOIn3YIrzaDTljoWhUZPNnKeqRchorzf61Vfc9EaYL9sUq/Y1IefghRd0av3ixZpPqXv3Jn7TtBw45gltR5z4ng6wNYWMDtD9HFj7sLZxll2vEVGx6Hmxfp8WngrvnQWvHQ0bIl84+nXoF/bnqGR10RVxm7stWE1amh4HF1+sx8XJJ8Pnn8e1SInNk6Lt6b3VPqRIN6Y9L4ID27VjsvKA/lt6VdOX0ySsGBcgNvXVpQssXw4bNkCHDlBYCMcco1O1xo3TFXxKS3Xeb6IYP17/Nbo2h+mKEnW4+26dHvjcc9qwP9wXmJSZpsMMHbN0mby+fWH4cLjjDv2M8/Phn/+MYfln0M6gcA3ocJ1ECdqoanYdx8Cnv9TOhzRdDSQuIxQj7tM8Jrveh50LI4f1p2RCSSF0iDEngJ9zGom06VkYeGNgeou3wpdTKrzJ/SbX7/2aSkZ7zZf02QwY/aTOha/YD51O0JHXd86Eob/VKSfLb4QfhY8iNPHxj3/olGl/J/+wYfEtT5X8/NBzqL9zJS8v6c6Zw4fD1q0aqZQTfsVu0xwOORzW/QN6TAWPr3HUkqfANaU2/eC/f4GOY7UzBHRgIe2w+JarkfTooVH/s2Zp39fUqfEuUSMa9nvtWK2rjRNJWg6MnQPvnqnTlDwZ0LpvxN17tetV9XNwtFJU2vSDb5clxIqCGRnwt7/FuxRJpHU/jWQLPkdUFoOnTc192w2FQ4bqCobbXgdEo5tGPdacJTYJxCKUmlFKio52tmsHgwfrij3nnaerwFVW6pxfE5CaCo89pqPFr70Wuizm4ssWs+DHC6oeP/igNvznzYOHH9bnxpQXKclG5BJCl8k6KvHWRF3Zo7IUFv2g+cuR1RlOW66jeJ3GacMpXN2/+4VG4DSk0yt3FKx7ONBYqiyHiuLQm5xkWD61109g679h1Z1w8BtY94iOUA3/g0ZyLb8Rlvy85hQJE3fZ2bpgwdy58Oyzen5MCC1s2rBzOlU9WYOOYhJu4CQRIm4P/RHs/UI78Sv261SdJVfHu1TJqedF2ilR+IJ+luX74L0fxbtUjSonBy6/XFc9bN063qVpRJl5cOoynRbZ4Wg4+pHYX6NgoiYy73MFDPwVnPJxxF3TUgIDZHnZMZ4Hcnpr9HNLytf1fdFxDGx+gZBVnGuLNBvzlK5CWLpdp2HWEqlvWj4nTbicc1MZOXKkLF26NN7FaLA//xluvVUjk1JTdbWeJKyOhPHJJ3D22bp63u9+Bz+/opY7AfugG8c7U3TaG6Ih1VKp08jiLdxd4IXANZfBEfcGRl9itfVVXY2n4GQY8zQc2AUvddekql0nNajIzapki65MFZxDw19vX96nHUoAvS+DIx9s/vKZ5FNbz4tI4Pd27jXRqtgPz+dpXrduZ2m+up2LEuMaU5dEO94P7IYXu+kU7dxRsH+Tfp7n2aCBqcndpsevzIjx+N2/Geb1h4kLA9Hg4tX2oUk8weepPSvhtVGaCH7cf3R1wNdHa76wSEq2wOd36c8Db9YBXtNiOOc+EZGR0exr3/A4uvJKGDQI0tO1M8kSxjXMiBE6pfCbbzQHlGkGI+7TOf6gnUmpCTwsuAPYvoSQ0ZdY5U/UVd42z4Fnc+DFrpqUsLIhSwzGQVYXGPn3wChiStAyv/2nwZmFMGm9dSYZY+InNRsG3gCeVjoVY+cii3yor1a50H+6fn67P4TSLZBq8zlNI8vqqm2kVbcHolsiJX83ieWQIb68dW/DnPYwJ1c7mWqT1UVXMBx5v3Umfc9Zh1IctWoFb72lSaWHDNHloI1JKtnd4MT3IXc0tB8JExbU/ZzmEG66xm5g9yrwlge2RbmMbhVPKhz1N22Ue8vQyKw0He1NNr0v1qSih54LI+4N/V2rXGscmNjYYgWmKQz+jUYnpWRpx9KI++Jdosj8U60TbcU8v8PvhO7n6RTttLYaRWJMGN/+6lt2/nJn7E90ThdK2fJv+PLPvhXqftX4BTRN48i/avu2skSjGVMTKLGvSWg25c20XNWTxPolYZJY0whKt8FLPWHQzTDger1Qlu2t31LN/mlh6e11+kB2Nxh2dyBRtzEmVKJNATLJQwT2roa01rowQqKqa9pnoqgohZQMm4ZkmsaORbDoDM0v6ZcM01S/T8LdH/nvjdb/Ez7+qXY8H/uCrgBsvpdsypsxYIm2TajMAk0auOoO+G65Rip9cH79Xqv/NJh6AKZshXbDNSmhJbA2pqZwCfITJWLDJAfn4JDBid2ZlExSM60zyTSdTsdpu8iTro9toC3xhBts92/r9WM4pwTOKbbOJBM1u6IYY74/up8HOHhjLMxKh63zG/6amQXaoZRII9DGJIraGq7GGGNaFufguBcho6NOVc3uFe8SmVh5UqzT2cSkQUeLc669c+4N59xXvv/bRdjvFOfcGufcWufcTUHbZzrntjjnlvv+ndaQ8hhjTK36XK55kPz8I2gNkVkA+9ZAalbd+xpjjDHGtGQZ7XVhj9NW6D9jTIvW0O7Hm4AFItIXWOB7HMI5lwI8CJwKDATOc84NDNrlzyIyzPevEcIFjDEmgtZ9oP/1vlXNXOOsGJRZoDkp9q0NbKu06W/GGPO9YonpjQlISdc2V/AgnjGmRWpoh9Jk4Anfz08AZ4bZ5yhgrYisF5EyYJbvecYY0/yGzAisdnPy4oa/Xuu+UFkKG5+BihLdJuW1P8cYY0zLYnkbjTHJIFwnt3V8mwZoaIdSnohsA/D93ynMPl2AzUGPC33b/K5xzn3mnHs00pQ5Y4xpNJ4U6P8LGPMUtOnX8NdLaw2ZefDln3SZVW8FbH+z4a9rTEtgDVdjjDEmcYTr/LaOb9MAdXYoOefedM6tCvMv2iijcOuo+rPX/g3oDQwDtgF/rKUcP3POLXXOLd21a1eUb22MMc0gdyxU7Ie3ToJVt8Piy+NdImMSgzVcjTHGGGNarDontorIxEi/c87tcM4ViMg251wBsDPMboVAt6DHXYGtvteuWurFOfd/wLxayvEQ8BDAyJEjbTklY0zi6DoJts6Db5fqP2OMMcYYY4xp4Ro65e1l4GLfzxcDL4XZZwnQ1znX0zmXDkz1PQ9fJ5TfD4FVDSyPMcY0v4KTQSrjXQpjjDHGGGOMaTYN7VC6CzjROfcVcKLvMc65zs65+QAiUgFcA7wGfAE8KyKrfc//vXNupXPuM+AEYHoDy2OMMc0voz30vQo8Gfo4JSu+5THGGGOMMcaYJtagtRxF5BtgQpjtW4HTgh7PB+aH2e+ihry/McYkjMH/C1vmQfE66HFhvEtjjDHGGGOMMU2qQR1KxhhjfNIPgdNXQuk2yD403qUxxhhjjDHGmCbV0Clvxhhj/Dxp1plkjDHGGGOM+V6wDiVjjDHGGGOMMcYYExPrUDLGGGOMMcYYY4wxMbEOJWOMMcYYY4wxxhgTE+tQMsYYY4wxxhhjjDExsQ4lY4wxxhhjjDHGGBMT61AyxhhjjDHGGGOMMTGxDiVjjDHGGGOMMcYYExPrUDLGGGOMMcYYY4wxMbEOJWOMMcYYY4wxxhgTEyci8S5DzJxzu4CN1TbnArvjUBzTcFZ3ycnqLXlZ3SUnq7fkZXWXnKzekpfVXXKyekteVnfJKVK9dReRjtG8QFJ2KIXjnFsqIiPjXQ4TO6u75GT1lrys7pKT1VvysrpLTlZvycvqLjlZvSUvq7vk1Bj1ZlPejDHGGGOMMcYYY0xMrEPJGGOMMcYYY4wxxsSkJXUoPRTvAph6s7pLTlZvycvqLjlZvSUvq7vkZPWWvKzukpPVW/KyuktODa63FpNDyRhjjDHGGGOMMcY0j5YUoWSMMcYYY4wxxhhjmkGL6FByzp3inFvjnFvrnLsp3uUx4Tnnujnn3nbOfeGcW+2cm+bb3t4594Zz7ivf/+3iXVYTnnMuxTm3zDk3z/fY6i7BOecOcc7Ncc596fvuHWP1lhycc9N958pVzrlnnHOtrO4Sk3PuUefcTufcqqBtEevKOXezr82yxjl3cnxKbSLU2z2+8+VnzrkXnHOHBP3O6i1BhKu7oN9d75wT51xu0DaruwQQqd6cc9f66ma1c+73Qdut3hJAhHPlMOfcR8655c65pc65o4J+Z/WWIOpz/x1r/SV9h5JzLgV4EDgVGAic55wbGN9SmQgqgF+KyABgFHC1r65uAhaISF9gge+xSUzTgC+CHlvdJb77gFdFpD9wOFp/Vm8JzjnXBbgOGCkig4EUYCpWd4nqceCUatvC1pXvujcVGOR7zl99bRnT/B6nZr29AQwWkaHAf4GbweotAT1OzbrDOdcNOBHYFLTN6i5xPE61enPOnQBMBoaKyCDgD77tVm+J43Fqft9+D9wmIsOA3/geW70lnpjuv+tTf0nfoQQcBawVkfUiUgbMQk9KJsGIyDYR+dT38z70xrYLWl9P+HZ7AjgzPiU0tXHOdQVOBx4O2mx1l8Ccc22A44BHAESkTET2YPWWLFKBTOdcKpAFbMXqLiGJyDvAt9U2R6qrycAsETkoIhuAtWhbxjSzcPUmIq+LSIXv4UdAV9/PVm8JJMJ3DuDPwK+A4CSxVncJIkK9XQncJSIHffvs9G23eksQEepNgDa+n9uibRSwekso9bj/jrn+WkKHUhdgc9DjQt82k8Cccz2A4cBiIE9EtoEe9ECn+JXM1OJetJHmDdpmdZfYegG7gMd8UxUfds5lY/WW8ERkCzpKuwnYBuwVkdexuksmkerK2i3J41LgP76frd4SnHNuErBFRFZU+5XVXWI7DDjWObfYObfIOXekb7vVW2L7BXCPc24z2l652bfd6i1BRXn/HXP9tYQOJRdmmy1dl8CccznA88AvRKQo3uUxdXPOnQHsFJFP4l0WE5NU4AjgbyIyHNiPTZFKCr657JOBnkBnINs5d2F8S2UaibVbkoBz7lZ0qsBT/k1hdrN6SxDOuSzgVnTqTY1fh9lmdZc4UoF26HScG4BnnXMOq7dEdyUwXUS6AdPxRcNj9ZaQYrj/jrn+WkKHUiHQLehxVwIhdybBOOfS0IP5KRGZ69u8wzlX4Pt9AbAz0vNN3IwBJjnnvkanlY53zv0Lq7tEVwgUishi3+M5aAeT1VvimwhsEJFdIlIOzAVGY3WXTCLVlbVbEpxz7mLgDOACEfE3pK3eEltvtAN+ha+t0hX41DmXj9VdoisE5or6GI2Ez8XqLdFdjLZNAJ4jMC3K6i3BxHj/HXP9tYQOpSVAX+dcT+dcOppE6uU4l8mE4RtteAT4QkT+FPSrl9GTEr7/X2ruspnaicjNItJVRHqg37G3RORCrO4SmohsBzY75/r5Nk0APsfqLRlsAkY557J8584J6Lx3q7vkEamuXgamOucynHM9gb7Ax3EonwnDOXcKcCMwSURKgn5l9ZbARGSliHQSkR6+tkohcITvOmh1l9heBMYDOOcOA9KB3Vi9JbqtwPG+n8cDX/l+tnpLIPW4/465/lIbt8jNT0QqnHPXAK+hq+A8KiKr41wsE94Y4CJgpXNuuW/bLcBdaHjrZehN1I/iVD4TO6u7xHct8JSvw309cAk6mGD1lsBEZLFzbg7wKTrtZhnwEJCD1V3Ccc49A4wDcp1zhcAMIpwfRWS1c+5ZtHO3ArhaRCrjUvDvuQj1djOQAbyh7XA+EpErrN4SS7i6E5FHwu1rdZc4InznHgUedbokfRlwsS8y0OotQUSot58C9/kWDjkA/Azs+5aAYrr/rk/9uUAkrzHGGGOMMcYYY4wxdWsJU96MMcYYY4wxxhhjTDOyDiVjjDHGGGOMMcYYExPrUDLGGGOMMcYYY4wxMbEOJWOMMcYYY4wxxhgTE+tQMsYYY4wxxhhjjDExsQ4lY4wxxhhjjDHGGBMT61AyxhhjjDHGGGOMMTGxDiVjjDHGGGOMMcYYE5P/D6yC8VLhzF87AAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2685,7 +2566,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2697,7 +2578,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2712,16 +2593,15 @@ "output_type": "stream", "text": [ "tal hits:\n", - "\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.6892776788679775, precision_at_motif_score=0.49451607322256813, example_idx=16, start=151, end=176, is_revcomp=False)\n", "gata hits:\n", - "MotifHitAndCoord(motif_idx=1, motif_score=0.9971336414418648, precision_at_motif_score=1.0, example_idx=16, start=45, end=70, is_revcomp=True)\n", - "MotifHitAndCoord(motif_idx=1, motif_score=0.9997176352865069, precision_at_motif_score=1.0, example_idx=16, start=91, end=116, is_revcomp=True)\n", - "MotifHitAndCoord(motif_idx=1, motif_score=0.9992547815607424, precision_at_motif_score=1.0, example_idx=16, start=153, end=178, is_revcomp=True)\n" + "MotifHitAndCoord(motif_idx=1, motif_score=0.9986697361501782, precision_at_motif_score=1.0, example_idx=16, start=93, end=118, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=1, motif_score=0.9935929306105755, precision_at_motif_score=1.0, example_idx=16, start=141, end=166, is_revcomp=False)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2740,7 +2620,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2752,7 +2632,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2767,16 +2647,15 @@ "output_type": "stream", "text": [ "tal hits:\n", - "\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.6964419108674892, precision_at_motif_score=0.5166192410700657, example_idx=17, start=51, end=76, is_revcomp=True)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.9889639466665181, precision_at_motif_score=1.0, example_idx=17, start=60, end=85, is_revcomp=False)\n", "gata hits:\n", - "MotifHitAndCoord(motif_idx=1, motif_score=0.9992547815607424, precision_at_motif_score=1.0, example_idx=17, start=22, end=47, is_revcomp=False)\n", - "MotifHitAndCoord(motif_idx=1, motif_score=0.9997176352865069, precision_at_motif_score=1.0, example_idx=17, start=84, end=109, is_revcomp=False)\n", - "MotifHitAndCoord(motif_idx=1, motif_score=0.9971336414418648, precision_at_motif_score=1.0, example_idx=17, start=130, end=155, is_revcomp=False)\n" + "MotifHitAndCoord(motif_idx=1, motif_score=0.980346181222182, precision_at_motif_score=1.0, example_idx=17, start=22, end=47, is_revcomp=False)\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABI0AAACMCAYAAADx21mCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3wUxfvA8c/eXXpvJBB6772jVEGwA2IBbF/svf3sX6oFFRALCHb50qRIEVBEpChdBOkdAgRISALpueTu5vfHpF1ygYQEAvF5+zqTW+Z2J3u3e7PPzjxjKKUQQgghhBBCCCGEECI/U3lXQAghhBBCCCGEEEJcfSRoJIQQQgghhBBCCCEKkaCREEIIIYQQQgghhChEgkZCCCGEEEIIIYQQohAJGgkhhBBCCCGEEEKIQiRoJIQQQgghhBBCCCEKsZR3BS4kNDRU1axZs7yrIYQQQgghhBBCCFFhbN26NU4pFXaxcld10KhmzZr89ddf5V0NIYQQQgghhBBCiArDMIyo4pST4WlCCCGEEEIIIYQQohAJGgkhhBBCCCGEEEKIQiRoJIQQQgghhBBCCCEKkaCREEIIIYQQQgghhChEgkZCCCGEEEIIIYQQohAJGgkhhBBCCCGEEEKIQiRoJIQQQgghhBBCCCEKkaCREEIIIYQQQgghhCikTIJGhmH0NQxjv2EYhwzDeO0C5doZhmE3DOPOstiuEEIIIYQQQgghhLg8Sh00MgzDDEwC+gGNgXsNw2hcRLn3geWl3aYQQgghhBBCCCGEuLzKoqdRe+CQUuqIUioTmA3c7qLcM8B8ILYMtimEEEIIcVUaPx4GDICMjPKuiRBCCCFE6VjKYB2RwIl8z08CHfIXMAwjEugP9ATaXWhlhmE8CjwKUL169TKonhBCCCFq1oSoqPKuxb+Ll1d516DkatSAY8fKuxZCCCGEuFqURU8jw8UyVeD5ROBVpZT9YitTSn2hlGqrlGobFhZWBtUTQgghRFQUKCWPy/14802wZN+Sq1q1/OtT0ocEFoUQQgiRX1n0NDoJVMv3vCpwqkCZtsBswzAAQoGbDMOwKaUWlsH2hRBCCCGuCj/9BDab/v3s2fKtixBCCCFEaZVF0GgLUM8wjFpANHAPMDh/AaVUrZzfDcP4DlgiASMhhBBCVCRpabBvX95zd/fyq4sQQgghRFkoddBIKWUzDONp9KxoZuAbpdRuwzAez/73KaXdhhBCCCHE1W7jRvD0hMxM/Tw5uXzrI4QQQghRWmXR0wil1DJgWYFlLoNFSqkHy2KbQgghhBBXkz178gJGQgghhBAVQVkkwhZCCCGE+Nfbtw8yMsq7FkIIIYQQZUeCRkIIIYQQZWDPnvKugRBCCCFE2ZKgkRBCCCFEGTh6VP8MCIA6dcq3LkIIIYQQZUGCRkIIIYQQZSA2Vv/8/Xc4dAhq1izX6gghhBBClJoEjYQQQgghSikjQz8aN4YGDXRC7AcfLO9aCSGEEEKUjgSNhBBCCCFKIiICDMPpccarJl6OVLp310Xc3eHWW8u1lkIIIYQQpSZBIyGEEEKIkoiJKbToFFWwkMXNN4OPj17WpMkVrpcQQgghRBmToJEQQgghRCmdIQKFQbNmecus1vKrjxBCCCFEWZCgkRBCCCFEKSUSgB0z4eF5yxyO8quPEEIIIURZkKCREEIIIUQppeBLUJjZKVDk7l5+9RFCCCGEKAsSNBJCCCGEKKUUfAmv6uY0JM3Ts/zqI4QQQghRFiRoJIQQQghRSon4E17ZglJ5y0zSyhJCCCHENU6aM0IIIYQQpXSOICpXBoulvGsihBBCCFF2JGgkhBBCCFFK5wkiOFjyGAkhhBCiYpGgkRBCCCFEKSXij5+fBI2EEEIIUbFI0EgIIYQQopSS8ScoqLxrIYQQQghRtiRoJIQQQghREuHhhRYl40tgYDnURQghhBDiMpJ0jUIIIYQQJXHmjP5pGPqnUqTWgYCA8quSEEIIIcTlID2NhBBCCCFKKS0N/P3LuxZCCCGEEGVLgkZCVDB1P6nLN9u+Ke9qCCHEv0pmJvj5lXcthBBCCCHKlgxPE1elmjUhKqq8a3GtOsQwYFh5V+MKqFEDjh0r71oIIQQ4HODjU961EEIIIYQoWxI0ElelqChQqrxrcW0yRhl0rNqRDcM2lHdVLrucdCJCCFHelAIPj/KuhRBCCCFE2SqT4WmGYfQ1DGO/YRiHDMN4zcW/DzEMY0f2Y71hGC3KYrtCCGcqO9JmtVnLuSZCCPHvohSYZNC/EEIIISqYUjdvDMMwA5OAfkBj4F7DMBoXKHYU6KaUag6MAb4o7XaFEIWl29IBSM5MLlZ5pWDfPsjIuJy1EkKIis/hkKCREEIIISqesmjetAcOKaWOKKUygdnA7fkLKKXWK6XOZT/dCFQtg+0KIQqIT4sHICkjKW9hRIQex5X/EREBwEMPQfPm0LIlJCW5WqMQQojiUEqGzAohhBCi4imLoFEkcCLf85PZy4oyDPi5DLYrhCggPj07aJSZLwIUE1O4YEwMGzbA3LmQlQXHj8NHH12hSgohxDXm4cUPY4y6cERIgkZCCCGEqIjKImjkqonkMoWxYRg90EGjV4tcmWE8ahjGX4Zh/HX27NkyqJ4Q/x45PY0ybBcfb/bGG5CuR7ORng7jxl3OmgkhxFXCVe/LfD0wXYlLi7voak0mmcBBCCGEEBVPWQSNTgLV8j2vCpwqWMgwjObAV8DtSqn4olamlPpCKdVWKdU2LCysDKonxL9HTk+ji0nBh3XrnC9wJBeHEOJfwVXvywstJy8Q71COC65agkZCCCGEqGjK4jJxC1DPMIxahmG4A/cAi/MXMAyjOvAjcJ9S6kAZbFMI4UJOT6OLWUcXvLx0oKhDB/D1hZSUy1w5IYS4Rp3POA9AQnpCkWVMJp0MWwhxddi0Cbp1g/ffvzIB3e+/h6FD4eDBy78tIYS4kiylXYFSymYYxtPAcsAMfKOU2m0YxuPZ/z4FGA6EAJMNPeDfppRqW9ptCyGc5R9CoZTCKCLBxno6k5oKo0bBq6/Cjh3QVo5IIYRwKefcGpsaS6h3qMsyhiFBI3H1qVkToqLKuxbla+1aeO21K7e9GTOu3LbKSo0acOxYeddCCHG1KnXQCEAptQxYVmDZlHy/Pww8XBbbEkIU7UzKmdzfk6xJBHgGuCz3B9cTFAQvvABubtCgAdx005WqpRBCXFtyehjFpsbSOKyxyzKGARkXTycnxBUVFfXvHDY5bJgO3lit+nlgIJw7d+HXXKr0dKheHeKy79t5eUFa2uXZ1uUiSfyFEBciWUyEqEBOp5zO/T03v1F4eKFyu4zm3HFHXkPS1xcef/xK1FAIIa49OcPTYlNjiyxjMl3iMN+sFEg9cfFyQohisVph5sy8gBGA3X75trd0qfO2ciYZEUKIikKCRkJUIFGJeX3Qc/MbnTnjdJtRORTnzKH066eDRTmuv/5K1VIIIcqRi0D6BZcDKntS2JiUopNle3pCcnIJ65LwNyysCj/Vg7+eK+GLhRCu/PEHuLuDvz889xy0bn0Jx2YJzJun11+vHtx7L3h4XL5tCSFEeSiT4WlCiKvDicS8u9VFJWxNStLdkNu1c17u6Xk5ayaEEFeJM3nDeHPHZBRz/E7+IcAFeXvr82ux2TPhjzshK1E/P/wVtP24BCsQQriyahWkpureRnfcoXv+1K59+bb3++86QLVxox6aJjfhhBAVjfQ0EuJqFhGhL2ryPyIiiix+Nu1s7u+5w9MKiInRjZoqVZyXSy4OIURFNXYsNGoEr7xS8vwuGba8k2P+3pwF+fjA+fMlWPHxH8Cab7ib/RpLgiLEVWrFCmjWDG6+Wfc48vCAESMuz7ZiYnSwePhw3bby8oIHHrg82xJCiPIiQSMhrmYxLoZCuFqWT6BHIJBveFoBZ85ApUqQmem83CRnAyFEBTR3LowZA/v2weTJJU9QezY1Lxh/KOFQkeX8/UsYNDr8NdhSIbQj1H4ITO4lq5gQwqXDh2HgQD3RB+ie1HfddXm2tWePXv/gwTpgBNKeEkJUPDI8TYgKwu7QWR7DfMI4bz2fO0V0QTExEBqqg0Y5DRyQMfhCiIonJQUeeigvUJSaqnsElUT+5NdHzh0pspyfn56dSalizERkz4S4DRDQBHqu1MuC2134NUKIi3I4IDFRzwjrni8OG+B6MtlSi47WN+ICA/OWyXB/IURFI7FwISqInNl9gr2CATiVcsplubg4HTQqOERDgkZCiIpmwQIdwImMhKeegjp1LlDY1XBgwyD2jhsAMBkmpyHABQUE6CBVVlYxKpawBUye0H4qmDzA4g21ZUyLEKUVG6t7GDVs6Lw8/+xmxbU7djfGKAN1gTGt0dHQpMmlrV8IIa4VEjQS4mrmajafImb4yUl8HeIVAsCZZNcJWzMzIShIuk8LISq+GTN0z4O1a2H8eFi//gKFixj6G5upA/KhXqEX3FZgoA7KF+viMWk/uPlDcBswmfUyw1yMFwohLiQ6GoKD84am5Sj4vDi2ndkGFJ0jEuDIEZ0j0l1GlwohKjC5bBTianbmjHOXIKWcZ/7JJ2c4Wk7S1hNJJ1yWs9vBYinG8AkhhLiGKaWDRc88ozsReXhc2hCVGF/9s5JPJcA5MXZ+QUFw6pQ+x15UylEIaQv2fBEms3T3FKK0oqP18V5wco/8w/GL6+i5o8CFc5kdOQLVq8uQNCFExSZBIyEqiBVHVgDw54k/Adhzdo/LcjYbmM0SNBJCVGxnz+rA0bBh4O2tl13KMNxoP/0z1Fv3NMqf4yg/f389NCb/udXhKGKlSfvAv6EeliaEKDPnzumgUcHg7aX0rj50TgeLcoNGLoawxv32N3XqSO9tIUTFJqc4ISqIk0knAci062nRbA6by3Imk76QKem000IIcS05ckQnqK1Ro5gvKGLo74lKOtIU7qv/vaigka+v7giav0dDenoR20o5rINGpksYMyOEKFJWlj4Wy+LG2K6YXQAciD+gF7gYwmrDjeDg0m9LCCGuZhI0EqKCKHgho3AdFbJYdG8jCRoJISoipfTjyBGoWfMCgZuCXA0HVopNzXWeuF8O/QLA1lNbXb7c11fPzmbLF68vMim29Sz41StmxYQQxZXTm7os/H3mbwA2nNxQ9PawSD4jIUSFJ0EjIa4ip07BG2/ox8mTRRQqaoaf1UsLFU3LTCu0zGLRFzZFDpsQQohrkFIwYYLu6ePpCd99B5Url369sWk6IJ9oTQRgy6ktLssFBemL1VP5Jq60WIpYqSML3AOL+EchxKUyjBLeFCuiTaUi8noebjy5Uf/isjeikptwQogKT4JGQlwlNmyAxo3hgw/0o0kTPdNZIUXN8ONeeDjakXNHCi3z94d4FxOB2FyPZhNCiGvCm2/Cf/+rZy/LzIRVq3TQ6FLyGOVXcKjvqeRTLsvlBKi25uuIVGSeE2UHo6iIkhDiUlksOp+Ry0COqwBREW2qhCQdLPZx8yElM0UvLNgbEbA0bVx0j0IhhKggJGgkxFXAaoX+/XXvnzFj4O239fKSdHlOzr4w8nbzxmToQ/tEcuEZ1CIidNCo4B3wgjONCCHEteLECZg4ETp10smo4+MhMlKfQ0szVMXhoktmdFK0y7JVquhg1bJlkJysl21x3SkJ3fzKt+4fI2CmATPLaFyNEP9Sbm6QmFjEPxYRIHLlUHaeokj/SADOpZ8rcntnz5akhkXLzIRNm2DnTkkhIIS4ukjQSIirwPTpuqfPP//ACy/A88/Djh1FFC4iWWt4hr7YGNNjDE3CmgDg6+br8uUxMYWnh5WeRkKIa9WXX0LVqrBoEYSFQXAw3HZb6S+8ohKjCi07m+r6CjE8XN8AWLVKB+UzMnR9XDJZwJ4v2VJGzsWsjBsWojTCwnQbp+CNMbsd1+2nIroDHqrlD0D1gOoAHD53uMjtHTpU+iH/mzdDvXrQuzd07Ag9exaeAU4IIcqLBI2EuArMnQsPPKBn+vH01I/Q0CIK53SPLpCwNaWubtgMaDSABiENAIhPLzwOLTwckpJ0XqP8yipxpBBCXGnLl8Mzz+i7/jm8vSEtrXQB8fwTDBjo6ZiylOuxKBaLToZ94oTubWS3w7ffFrFiiy+kFg5ICSFKJzISTp8ufGMsPR3Xye4LjmXLbl/tGP44AJ5mvaK9Z/e63F6dOjoHZWl6a58+rYNFnp46L9vw4bBrl7TLhBBXDwkaCVHOlNLdkQcPBh+fvOX5fy+OnCStAR4BBHvrftXxaYWDRqGhugv0rl3Oyy80FM7h0BdBo0bB559foOu3EEJcYQ6HHs5x443O57HQUJ2U2mVuuGLKtOsX96jZg6jndZDHz92vyPIREfrnnXdCYCCcP4/rPCrrDkDSflDZ3RM8XfcgFUKUTGSkbqOkFZgHpKTB4+k7pgPw29HfAPj+n+9dlqtVC6Kjiz7PLNi7gIV7F15wW2++CfXrw99/w4MPwnPPwfbtJauvEFfSyNUjMUYZOJT0jv23kKCREOUsNRVSUnTi69JItuokGn4efoR66W5KrnoaWSw6IPXrr86NnN27Xa83Lg6aN4dHHtHJuqdO1Y0yq7V09RVCiLKQM819rVrOy2vX1hdzhnHp687paRTiFUKgp57trKjcJgB16+b9nnuR6iqPymkg+SDYsq9sB5y59EoKIXIFB+vOQ//847zcy6tk64lLjwMgw6a7EO2Nc93TKDJS34Qr2LMpx4A5A+g/p3+R21FKD2P96CNdR4tFrysoqGT1FeJKmrN7DgCbTm4q55qIK0WCRkKUs4wM3QW5qAZHsdZhyyDLkYWbyQ2LyZJ7cZN/aEV+NWvCkiXkzviRmgo//OB63Xfeqbtf79+vy6xfD5MmlX5GIiGEKAs2mw4MFRzKUbs2HDtWunNVzjk03DccX3edI+689TyqiGRJjRu7WOgqj0oMcHp9kdtVSg+nkZwmV6ddu+Cpp6BdO+jbF2bPlryAVwvD0IGjxYuzh6RlO3myZOvJ6WWYw1XPbdC51BISdAL+HDm9nE4nn85dlv/3/I4e1T/btXNOr+TtXbL6CnGlOJQjN4j6w+4iLh5EhSNBIyHKmaenvjAozXj4nMaMl5u+lebvoRM4FtVI6dxZd4PetEkP7bDZdCCo4DCKw0YddmxOZ8YMnasjIEA3ZAYMuPS6/tvZHDaMUQYjVo0o13qYR5np/HXncq2DEGXB21ufQ3NmLMtRq5a+mPv770tfd0yq7iUU5h2GYRj4uOlxw+czzrssX6+ei4s9V3lUvloEWdFgd04uZ81y5623dI+lzp2hYUPo0QOZ0vsqMm2aDhS1bq1zVr3+ul4mw7avHo0bw7x5eYddaip8/XXxX5/Tm9DN5Eb3Gt0BihyG06SJDk59+23hXJHz9sxz+Xt+CQm6t5Ic49eGuNQ44lLjyrsa5Sp/76KPN31c5E0UUbFI0EiIcubjA35+hXMMlURCegIGeRc0OUGjnAuegrp00UGgYcPgu+9g4MDCjR2AtXSlWzej0N1uv6JTeoiLmLVzFgCj144uty/adcfX4cDBhpMbSMlMKdN1J2YkkpSRVKbrvBCbwyYNlmvQrphd/BH1R5msy8NDTyKwbZvz8oAAnVfo00/1EGBwfZ67kOOJxwEI9tJ54nJ6GxXVi7NlS+ceT0VMzAQhHcBuhZ2jwZaaO/XSLeOWcOqUHlqzerX+OWqUc4JvUXpfbf0K33d9C/UmuZiEBD276apVMGQING0K3brpAEVIyGWq7BWWng7z58PHH+tj56efrr2ARp8+Op/ZpEn6hty5czrBdHEdOXcEgEZhjVj14Cr83P3IcmTlpgHILyREP95/X08ykpGh9xvAxI0Tc8tN3DSx0GtB3zhMTCy7Yzw+LR6bQ7q9XQ4O5SBsXBhh48KwO/693UAnbZkEkDvpzpboLeVZnXJltVlpPKkxf536q7yrctmVSdDIMIy+hmHsNwzjkGEYr7n4d8MwjE+y/32HYRity2K7FU5WMuwZB2vugE2PwaZHYPVtcPALKGHDRlw7DAM6dICZM/MubKBkFzfx6fEYhpF7QRPgGYCBwdk011NDd+2qexcdO6YDRytXZifeLnBHXH39LSZv1+PmHA7YskU3lmfNgp9/ljutF2N32Ll/4f25z5cdXFbylbhKqpuTfbeYnlr2VO7vn23+rOR1KEJKZgqB7wcS8H4AVtvlT3q17vg63Ma48dbvb132bQHcO+9eTKNMZR5o+7dJz0qn2ZRmdP2ua25QprQ6d9YB8Py9jVJSoF8/PXRo1Sqdw23nzpKt92SSHtOSM+TX38MfA6PIgHzr1s4X2L6+RazYKxy8KsPByXB8HiTvY+PBDpzK6sxnnzn37OzQoWR1/rc6d04Po96zx3UaqRyZ9kweWfIIqVmpvPvHuyXaxvLl+v0ID3ceUl5RhhItXgzt2+vfBwyA227T3+vnXXescy3lGGx/E9bfDxsfhvUPwN8vQ9LBy1Fll3r21MHk116Dm24qfFxezKGEQwBU99ez0lbyqQTA4XOHXZbv00cHi1q31vvszTdh66mtHDl/BCP7vyPnjrD11NZCr61fX39eT51yXn4pwx1XHV1F6IehDJ4/uOQvFheVc9MP4NvtRU2NefktO7CMMWvGlMu2HQ4HM3fOBPKCq6+ufJWEBJ2Xa+hQePhhfW3x7LOwY4eLlbhqx15CW/ZKqzmxJqZRJrLseSeT4auGszduLzdOv7HC38AsddDIMAwzMAnoBzQG7jUMo+Co/n5AvezHo8Dnpd1uhePIguXtIaAhdJkBrT+EVuPguh+g1hBsholp/0zjbKrrIEAuWyrErIKj/4Mj38OR/8GZlZB1dV/k/BH1B/vO7rvk1zuUg0MJh8r3gFUOHfizxuv9XYK6DBqku7fHxOiGR0aG8/j4i8kZnpbTw8jfwx+TYSoyYWuNGnrMf36ucmd06QJr1xa+A7ZkiQ48JSToxtnNN+u8R6VJOPtv8NKvLzk97/9DfxyOKzvzxLR/pvFPTF6G0NdXvk5CWkKZrPvOOXfm/j5s8bAyWWdR4tLiuO7b6wB49893L/tdntVHVzN792wUiptn3ly25xq7FTLiICO23M7VGbYMlh1c5tQYulzuX5AXOO3+XfcyOQbuugsWLtRBg7Q0/Th6FO67Twdg+vfXvYC6di3Zes+knMFkmAjy0llpL5YvzmKBNm3ynufPqVJIzcFgcoeND8LSJkSfi6RKlcIXt5I/7sLWrtWBgTlz9Ptus+leWueKyFf+6E+PAuBudmfUmlFsjt4MgFKKb/7+plBi16l/TSXswzCOnjuKp6cOPhb8rrvCp/ELSsxI5OVfXyY6KTp3mUM56PJ1F2p9XIu0rHzTitkzIPU4JB8i6fRJBg9WrF4Nt98O1arptsJdd0FYWDE3HrcZ1twG9R6HdpOg9Tho9ym0eh/865Xp33khbdvqnw6HDhifPVuyGWn3x+8HoE5wHQAi/SMBOBjvOvA1YIA+z5w5AytW6PbU19v0eDizyYzZpLsf5izLz90dOnWCkSOdbxyWdLKRmJQYek7rCcDcPXP57chvJVvBZXY44TCfb/m8WD10kq3JrD229rK06ZW6tFxx5zPOM3TB0Nznj/z0CLEpsWVyIw90O/5konPiLbvDzrw985zyaR1KOMTNs25m+OrhfL6l7C6nlVLcPfdujFEGhxNcB0cBdsTuQKEwMHI/13/vPUu7drrX5dSpMG6c7tk3apTO+VUqV0mAaeqWqUQlRqFQPL7kcQDWRq3lg/Uf4GXxIiE9gff+eI/kZJgxA0aPhnfe0Y9Ro3RO2IIzOl5ryqKnUXvgkFLqiFIqE5gN3F6gzO3ANKVtBAINw6hcBtu+ZiilLnzySz8DqScg8haw+ICbPyxpAHO82TLNF8+3PXlg4QNUGleJKVumuD6IWhuwvBcENIXqd0H1gVDjLmg5BNz9yv2AcyUxI5FOX3Wi63ddaTS5EU8ve7roC4jU43B6JUQvy34shVO/sG7Hl5hHm6n3aT2CPwhmV2zR47ysNiuj14wmaGwQo1aPIiOrFImEcpxdD2vvhBML9ftoS4O0k7oxVkxDhujATMuWMH68Ptm2aFH8KsSnx6OUIsAjAMgLGiVai+76M3x43l1wkwl69SpcpkEDHQz6z3/0yS4pSfeAevBBfUehTx8dfPL313fL/P2LX+d/G4dy8N327wDwcfPBZJjIcmTxy+FfSrYiV/lRzhR/5qUJG3QffX93fzzN+lZ5TldjV5YcWIJ5lBn/9/wvOEvGuHXjWH54ee7zGTtn8P3278usQZWfUorGk5zvTbT7sl3uLDdl7WTSSXpM65H7fG3UWu5bcF/pV7x3Amx+HOI3gz1d3zxIOaKD/6V0Lv0cg+YMwvNtT0auHnnBnl9LDyzF6x0vbp55M+5vu7Pm2Joiy8akxNDnf30wRhl0/bZrkXnTijJ/z3zm7c3L7XH0/FGe/eXZEq3DlQED9FC0Ll1074I339SJZXv21LMQORywd2/Jh9nEp8XroJGnDhqFeOsxSEUFjUD3NMgJ9NSufYGV13kYjLyxbD0ar2Lb3/rmQf5gU0mH1P3b9OkDU6bou9utWunZPu+6y/XsU4cTDudOnZ4zNO2O2XcQnRRNjYk1GPbTMDp+3ZFhi4bhcDi4c86dPL70ceLS4qj9SW1iK3/P9u16JtGcC3ybzfliv6CYlBjuX3A/z/38HEnWshu6G5cWx+D5g7lzzp2cSdHfAfP3zCfw/UDGbxhP1Y+qMnnLZAAixkWw/uR6jp0/RsDYAE4e+J8O7sT+ASY3cA/G7jBwOPRnN/+wSnPmKdj1Luz7GI7OgKh5cGQ67JsIu96D9Hzduk7Mh/Buuiedmx8saQhzA2CWe5n93cVhNsMLLzj3ACvJbGQ7Y3SXxJqBNQGoFainZjyY4Dpo1K+fc/vH25vc4bezB85m1gDdQ6WoIbljxsDcufDWW/pm3LFjOnBXlLSsNEatHsVTS5/KvZncamorpzK9/9e7xL1iFy3S9Zg/X/cinzNHB+N3H0hj9s7Z7IndU6L15Ri9ejR1P63Lk8uexH+sPzvOuOp+ok3fMR3/sf50+74blT6sxL64fTqi5ipwMHJksba/eDE89EzKzBwAACAASURBVJD+u3bs0DcX1q8v2bl1+KrhhZa9+turxV/BBbz3x3uEfhhKtYnVGDR3EBm2DLad3obve74MmjuI0A9D+WLrF0QnRVPv07zg65PLnmTcunGADiY9uOBBpv0zrcRD5xwOB80/b86cPXpGtLqf1s3tVXUw/iD9ZvTjjZVvkJ6VzuL9iwF4psMzpL2Rho+bD0l729OkqYOmTXVwNjBQ95QNCCh8gxpw3Y49sRgW3QbHZkP8X3BuO8SsLpP2UGmtiVrD48sez33+zfZveG/te9wy8xYA0m36C/vNX0dTJdJBp07w0kvw9NN6woRXXtFtlGu9R6pR2iiuYRh3An2VUg9nP78P6KCUejpfmSXAWKXUn9nPVwKvKqUueGu4bdu26q+/nIvsmtCRRveOxeSf1xLbsOA3GgatIKj7+05lu4xvwS6LFW83HxzKgUM5eMD2ECk7/8MjLzXCMPTn1DBg1/TXue3BVvhF1Mh9/dfLF/HcsQ+xkrePvMwe7AmuRs0BX0BE3kXEnnV/E3TkeSL6T3OqQ+cJndmonBvV/UKrsTDCiw2+qzl4yJ2MDAMfH0WlmOHceEMq5lbvYniFw4JIFkdlcntS4dtlqR964J3qfBGQ0tULr+HdMfdaBpmJsPs92Ps+mY+6455aYHibBc6/HcCGOv8QnxSAUmAywBw1hVt6ncWnzXO5RTMzIaRyCPsPe1O5ct7ttT3L57JrpyKgUV9y4o92h515u+oyuO9/6d3wDjLtmXyzcw6WjfEMahxPQNfRua9PsiYT+GnTQn/b0NSeTP9wJY6UfMMWkg9hrLsHBjo31F/99hk+OF54eM3J5g2xVBnO6n29iYs34e6u2Jf+ERPS3ilU9hfTLfQYNBC3aj1zl53YsJDq5mXQo8AF/ebHSTPX49eD93EmxoLZrOjgO4bmjTOh/WRw2GDnSNj9Dqv3dqfDgFvwrD8o9+Uxx8+Stepeqj5Q4A7Q3vGs31mHm194mtRUA6UgIjiR9cNbU+2BlRjZn3eVEsXqb76hXWsrPi2fwPDVn9d3fn2Zt9aPY0Cd3szr/xXHEk9Q/+vuPJ7QmXdvb4lvu5dyy6qUKNQvHchov4B6HdoSE2vGw10xa/TndGu5A/9ObzqVPfXDIK4buRrMHrRrZ+LECQdZsdup3aoZn0224O+vcx6ZzYq9n/Wk2T2vYQ5qlPunrfw5jr2bDvLAMD8MExhkH3e7RuLW4lVOZ3Zk+W9ehATb6d/5d8wHPyK11Rx+WuZNfIKJVi0yMbY8RtuBd2Gpcn3uevds2EPT3n2dPycAm5/CXqkX2+LvYctWd9zdFT6hvzDy0MNYAqoR7h1KfMZ5Mu2ZjEtqT69bO+JR5468z86h05g2DaPKEOehY6unjKdD98p4Nczr9r16pZXn/1uv0NS+mf5+uCc7N9bmNLFw9yAbdQKqc/CRP/jf7h954OcXaLx3JC82asHAAQqTWR9fDqVo0+d6fp79D6E+pzAZ+r7OlpX76dDqPP4dX3F6jw5MvYl6Q7/C8KmSu711c5fSNGIzAdePyl22O+4Azb7rjbvJQuKze9h+dg+dZtxBj7Rm1K9h5cl+nxDpV5kdZ/fy9Y7ZzNi3kIIGZ/Ti43behNyYd9ydz0gk8rOWpONgRKfnSbdb+WDz59yQ2o7lX/yDKdH5/DPUczZ3T4qgS8sTmEwOwODAnhSq2WYSMXCGU9lHn/CiU7tUbuu8GZMtDjDz+e7tvHViCoEe/ozu8hLf7pzDtrO7afHXMp7vHsAt3Y9iMelG06nTJr762sTIseGYsGGgUMDG+Uvo3KsyXo3zgj9Jp6MI+GdgofNM0GhfzqtUelXvQpuIZnyweQoWu5lbVi5iyid2vL0NjJz36LfdnExrTY02XXTvA2VgmBQNotqzM2A+sUmVABOGATfY21HplqkYET31EORdo2H3O+yNbkj9+7/C5Fsttw7r5y+nSdgfBHR926luXXt4MXykhRaRm7CkH0KZ/Rj+5womJznvRwBGKrKOLsQcljdC/NVZo/gw+ptCRUedfIf7hjYgvEZeopbPfp/HqycKBxjPVAknfMBiCGmfu+zAlp347XmYiDvn5i6zOWxETGhCAhm80eFpqvhW4umVw7Gcr0vzX39n2Yx9WGwnMRl2HMrMvt9/ofMt7aBhzveRwdmTMViXdKPqA787V2LfR2zdW5Ubn32epGQTSkF4cArRX7ZgV8QaOvSMJC3NwNtLsXT8eNo2i8en1ZNOx9GJb7pSdehPmIKb5y7zGlcXGza2P/grTULrc/+y55m+ZwG7/RrQ8L5pmCp1yC3L8Xk4YtdzttpH1GkWic1m8PXkeFom3kKje8dirtIjt+y8BV78uMDE5Be/IODE2xgqC7tbJX7Zfz+PfDqal//PTNu2BufPK1ZM+5lR931FcG/nnCi33eHJg/9x47omf+OWthdl8mbGPycZFfM2SQ4H7mZ3Mu2ZBHoGcLs1jF6denN3x5cB+PHgz6zcmMHOb+9jxtwgPJP+wC1tHxmBPYlsWI/x4+wMvnEz7qnbUIYbK4+Z2HtqFE8OWUyodzBWm5Vvds3h9tQ1VA6/jpTwh/hxkTce7opOzY9i2foAkUOcvz9XT51Ih65heDUakrssIcFE244+rP7TD8/ktbil7cXmVZ+Pf/6auvUyeeDGjzAMgz1xB1i85zfidk5hSP/vaFWldW77YsU7nWjc8npef9OMUvr7081N0by5wcLphwg31mPYk1Amb278dSxb7Qd5vMUQ7msykFvnP0RCETdXGmVVZa9b4Sm3frEM4N4PZzNkqJnWbUzExSkmTlT06JrJhNfWYLZGYTgysZv9qbLsAQqOMmp27j5uTxrIiy8qzGZDt0UdipvmPsZ68nqTG4bBLWdGkLJ/OCtXOq8jcpQvp3C+mKprrc4hDxfDPUcqGOncNWqMdyBvdbsb2k/Jy621512+WvUI3+6axISPLDRtpvflsSVjaFrrOHT4Ur/4xwjIiGHOxkG07NuTms3zvu9T4hPI2PIWlfuMgchbMBZVh4wYVu/pRrubOuPdIu/Cy2F3EP19d6retwzDLW8c52dTfDl00MEbT+7BknEQQ9mweVTl7Io3afjAVExeYeiWBPz5w0+0W/M9ntOds92rqYGk9JpPvc7diIs34eGu+OrNafRt/TuBXd92Ou63T7qXZvcOx1K9b+6yup924aj1JLNvncygBjfz9oZPGL5uPCtMneg+9BUstfvnbevYbBx7PmJpymLufTAUq9UgpMYJYu+vgckwSHluH0qB/yeNaJXYgCWtw6h0x/+c36PNT/Huotd4Z2on0jMM3NygWfXdrG56I36LnMetNftvELvMztcFIdYg4j3OEeDux/vd3uB/u+ex7tRWmm1byH/aNmbITdswZ8UBBrHJkdz/dAOWzt6Pu9maey0U2HwQ8fHOF/nHY49T4/MaFLS0eWf6hDdhn9so1m90x2YzaNcqhU/GbOfDD8DHx6zXi+K2ea+y2lY42NR54Q6+HneUymEZ+hJCwYNLJrAws/DNqW1ebWg29APMkb1y3yNO/Yzt6EI2qG85eNhN7/dgB3VOD6Tl4FcwhzTLfX2/m8wMuj+SYcN0LyOHQ9+ovf12uH9oJtc1WIdb2h6UyYs/D9/ImPGRLJgdj9f5XzDZzpHgVo2mSwZixc6WoT/hbnanxfc30jalMT+1CCK8/0ynz9QPH8zBXLUvYfnuGuw48gsvnhpIwXBOJbyJxbkLSkhGEPGeha/9PJQZq2GnVkA1KnmFsOnMdvysviR7FA4OfsF9DO5dDe8Wj+Uuy7JmcWZGL6re9zOGW17Xu5Yfd2NH1rFC63AlVPkRZySz4I4vub1uH/rMHcJv+/+hxbz1PP1KYwYPMbBYDEwm+HTEOrYfbcKYsQFO64id0Y2W9/0XS7U+ufssftG9hHZ+SvfAVQ5YUAUyYthypC2thr6FpdYduWV/X+3BhI8sTP7SC5+EJZhscWT6tmffj2PpfM+duFXJm+Rl2W/LWXX8HZ4fNIdIvwjOpMbyxT+zSN+0hnYdOzOgk/5O/PXYWg7+fZiBjmVO7Ra7w47bBP0+Dm54B5W8Q5j499eEZAQS73me6v6RfHPjh3z693cs2r+KkEnH+WlpJVq1MsjI0Oep1PgYHL9eT9X7na/9Vn85mQ6dvPBq+lDevjltpXaLeoUCmp+Pj8acsou778zAZNYHjMOuqD9/AHGAxWTB7rDhYfZgvHE/gzu549f+Zad1ZEYtZ/OyjVz/snOPR8Mwtiql2l7svbdcrEAxuBqQUjASVZwyuqBhPIoewkb16tUL/XvTdZvgpR5Oy7L6XE9wZDzc4nxi2zASyILkrLxbdnvW2/Dxa0rbds7rbXPgQ2hmBXP23ZAdI0k89qMOGKnsC10g3W7FeswGiVEQmJ09f88HWNcsp3ILB/jWzH09u0bhds6NQA+omwAWB+wPgdRNlbl+23ImTPLlgUfNWCx6ONL7lVO4efI0aPs9hLmBzYF/k3A6p55nzFxFz2NwPABevBGWv9iC/vf9B+o9pu/a21JIvceHb4bU5dnWPtCmKfj5QoQbs55txwNDb4fG/5db9qcHu/POgiWsX6/ItEJmFljMsLPP5/iOPg7kZQw0cMNmSsLNzXC6+3TPM115e1w4/W7NWxafFs+t2+P4fslzsCQv8PRmfFcC390MCd/nLvMzoNtLcM8qeGwrWC3wVg+IiMhiOuSegLMrwcxWdzJ48/VQpy54+4DaSKWoFHqmezDxWytN4mBTFXjhRnhn2qMkthnIm8PNVKthwpYF4z73pqHVzH9/stP2NPxVGd65HiLr7MM9qAbUaa9v8Yb4EPt8A1LTqtAoayKYLZCyDFJ/ZuKHQ5iZ9QSj3nPj1oFm7HaY/t1Ydk14isEtq0PTxjrRQZA7GZZkvAJCwad67n63jQikWqUEp2V8ksqumdBlKezlPSbzJABDUv9H9eCj4FdLJ1CwpWAsqsHh6Ovo0aOvXkf28tuPj+N4PNz/9QqM+2pQzQSvd4Mm9cAvwMOprLGoBsZ88L6zE5uI5GOe5Y70RWStdyOga6NCZSOXwsETfszjTjYc60QbTvFk30kkmjsyP7weZys1webmjUfcCf7vi3VYgptA7exzz6+PU+vENG64/0FoONzp2EibC9/duZwX6YvCwIydP9qd5jrPljz4RzBdupioXM3CxxOy2Nh0NW6vL3Y6ZjOatQb6YhTYl5u+qcn9Kz+kbf8Aru9pISVN8cPs8xxomQHxB9mTr3u5r8UXz4A7nN6PrLfCqB15vtB7lJzUDu+AR52W1x8ZwC3uw1n+fjvcfT1Q+qNKR0fhXh2Nz5p5NN7G4G+PY7xQg0EW2N0dxgweg/vAXeDfUBfMbpAf+Lw55vZrwNwFVBYYZtwX3E5AYNNC71GD0cBLnZy2Z7utG4FhidAv7ziq4Q5PPArdf7fhObw+HYDRXeHPFueYevYkU6f1dVpHhxTosgOe2AJWM3zYBWr6pRPa2+S0HwI+TmXYaQuNtzp4YqS+sI3oCJlVwPRDS7hxk9O+/DLjcbwGbAD/ztk98gzcV/SjcqO4Qvv9QVNTurRoDnVHgG91UA4a/TGRRxMsPPlDEi1eH8EgX3i/G7x1w12E3LUIIu7SF0IYZGxpyYTHw6Hen06fvyrLIvF+PRrIy4dkCwzm9BthVD75J3gEwOHJcGQKww4HYpyGt8esw8O+juvqw76+iv8bNQ7arHJa73Mf/MPbnzanW76ee2vWQJ+PdvLXVn0RlpkJZhNM+HA7fZ97lHYRz+lxICYTBLvRKHIfhLSEqnVyj6OsA6sIrFut0P55Sg2i97lVEPkKVG8F1vOEndtKhywP3ppvpXEcrK0O73SFQ4ClVt7FDkDlmxtwQxNPJn6bQZOz8Ff2OXT4DW9Ct3xf0ztGEnJyBa0yzLw9T59Dt4fDWz3hxKlgwpv+DrWzvz+PfI51zXrqN053qq/bJ6n855gPgYfhjZGfYQC+LSCheQbPfDAES51p4NMNHHZYXAu/054Y5s66J0R2HWx/TKVaSHyh/bBzJrRdCnv4gEk8hcLgyZRJMC2Gpj9WZzldWMyt3JC+kn3HMuh+3Q2FjqPqIUBQM6dlw+y18U/LoH6d3hh2eL4yeLeBxvfuh5A2uixgHP4Gdo3C/HsrIr6uzgJ68w/NGfzwBEwzlH4/85U9syKeAftCCLpuFHQGqoLll2hu7PUeu2Kmsujl25lLK4I4R8/rtxESkFHob74rbgADM38H+8tQoyNkpZL28wckoLtT2bLvfsalJ/A1CXy9bj+D1+W7yXKkB5OOnaPGy6PhpuxlSv/vRQ9PSHwEInuB3cp3v7/OzxkncBvYijf+gOUN4Ol7oN/fcOqnPXRnMKcJwgB6RkSz+JPoQvU9f7493gH/cf5OHOPDE8n3U2P2OIgwg3cE9pQzjM2wY+yAPg8tIDIZnn4A1lWzkGWxMWFmf3ofgkPBcDQYNhrg914jvvzwJlKrNsBucsM3fh+/Pj+fmu73Qb2HwSMI7Gn0XjKObmkRjLx7Bn6ZM1hcDb5tCQcbwEMr4MF/INUN3ugFCXW8aekdyPjPz1M5BdbW0OfLG1N/JCoxmPmTBrKV1oQRx4R2+xh4XwyWyI8guBcYJvixMs1Toc5RePhvfQ79vB281GAVvZ7sAPWzc8tln/OPWw2UR76cgkrhlrGYmtY+bPm5DmDkNpwbJ2TRPgae3QQmB0xuB2lB7kQGWRg3w0bbU7q9+eKNsAwYsRr+uwbMCqa0gR/CqlJzmo2hzatAsya63RLsRvczX3LbxoXM7nQPc6iOGQdB5lR2NLcyuHMLqF8PghPBBD1r/0xo68cholvu8Wls/pivnnia4U0HQj0DgryhI/ivPoLPO2uA9/I+f4ZB9f4Knm3idE5KrvQa74z4Ht/0wVBrIJgs8HsvKkUmQ3aQNud8az/WDc9n2sP/tjp91oz55/F7rBdbqcLHPEuv9N/x+DODoO6RhY77JhFuWEKaOB2fQ9O8OZcSQO8uT2JkwNBAiO4CLW/djyWoni6b3V401t2D+efq3DY9nHn0ZRXdefrYR7x/yoMWf1nxGqGTBU9uDWdqeBHeq3D74vQP8ObiJdxMC2YwBJ+sFPrwK34PucFC5VS2zrp0wlLgsb/AJwu+awmngz1p6m7i0XnJtHnjdQZ4w9tdYUiNl2nfqzc0eBO89QAP07dV2fxlJ2g5P2+n/xgBDGJZm7egbRvMQYFgGJw/fxy/BtDpCPQ5Aif9YVFDME06ROeVE6jTP4iBd1uwWGDzLxv438sjoM02p/eosbUOVa0hjJ8UT6VUWFoPVtwKE9+5D3ptd3rva88bycCMAD6akki1JFhRG/7bA1r23ArBzZ3eo92/zOXez1by7OvB9LvVgruHQdRRO81/3IDl9Vuc1ruwkwerZ93LlxOaQZ06KIs7JCZyR+yPDExaBpnPQ9VOkJWKMecZpjRJoNrW/VD7IfALJfDsfB6NdqPeP3bajtQXPVPawOlqbkR0iy/0mbp3tCI11blnSaItC/spcLODd5Y+H2S4wQ3RirDj8O5K8LTpY3lRM3fSQmD0POh1VF/7vdQHQr29CDyZwuhVJ3BznGBOY5jZwsyG2jBwG9y6H6IC4fO2YA46gk9AI+fP2gQr1UNsENjI6TPVKaMWHTPC+eCTGAKs+j36qAMcrA43b4chOyHWByZ2hJr+lQlz86Z3u0cwsuC9KlC7NXzerDnrHu3Ch4/1JNknAs+MRFLrumNv04WCl/OR1dZhDnY+5havrk+dWUvpVmss1K4FoefBBHXCD2EJauBUNu6XvTxj96TGb9PAtwr4VoV9L2ANDMM9+BWn67lfng3gM3WK8VOdkwN62iFj3VZmvfApPplw22Docq4pT/d0brdYPkllWLQXNfel8+bIhRjokSBLm/oSHJLME1OiafniYJp7Q42u8Finqpzq3J3J4TdAjZqgFI64A7zc+jA86Ryn6OjjhldqFjAyd5nFM5gwj91EHQ3DPyAvfPJoWDXMjx0G31q5x6xKjyE2+0shp+dsmi0dzzP78I/KhJ7O2/MYUoXrp0dzyXKGTV3qA+gELM/3/HXg9QJlpgL35nu+H6h8sXW3adNGVUSDBin14YdK2e3lV4ffflOqfXulzpxRKitLqfR0/bOkkpKUOn5cqcOHlTp0SKmjR5WKPn9adfyqo2IkipGoV359RdntdqXCw5XSNzTyHuHhLtcLl/63rVunVMOGhf8em+0iL8xfLxdOnVIqIECp5GTn9y4zsxiVcrXeC2zrmjViROH3GJQa9X9KJe5X6twupc7tVOr8brVpg015eSnVt69Sf/yh1LffKhUcrFRIiFIbN+rPVmKiUmlpRW9On8HytuMA1SAkVk2bpt+nHKmpJazviBF5G8h5jy5W9lLFrlNq/2SlDn6l1JFpSs0JUGoGSi1toZQtTamsVKW2vaaXzUCp2T6F1+Hq2LrA8eXK6eTTauj8oSriwwj17tp3VVrmBXa8q31R3P2Qflap+eFKJR1Wyp6pVGaSUtte13/bQDfndVZGqR8CnV8/PzxvX+SXlabUD/7Z67UqZT2n1N+v6nKzvJXKStHbTo/RPx2OYu8bl+w2pc5uUir6Z6VOLsn3WKaUzarsdn0Oslr1Oal5c32+zczUn2mr9QKfyxwFzxEF93soSv0QplT6GaVs6XnlXO0fVY6nm4ud6/7+P6X+ek7/npWq1Pa3iv6sl2S9FVHO35weo9S8UKVST+jPfo4i3vv0rHTVb3q/3O/l3tN6q1RrqlJR85Wa7a3ULA+lFtZQagZ6l8as0cdMtlGTvBUjUcMWDVNKKTV582TFSFS/6Tep1q2VMpmUqlJFqdBQpdzdXdS3qL/D4VDq53ZKreihVNoZ/bfMC1ORb5uUaZRJrTu+TimlVM2JNZVplEndPOPm3L8h55GYnlh4/fs+VurPwUrZMvTz/OcNF/un1BbVVirmj7zn/4wo+jOcelKpo7OUOjpTqWOz8875M4yyr5e6Bg+Rpc2VOrHY6fN32d638lCa78+SyIgvvM9yPpc/VlXq4BdKnVqh1IaH8o77YrrhBqU+/ti5nZWS7NDno7gtSsX8qY+H2D/196S9QIM8NVqpdffrOsSuUyphu1IbH8k+ZryLVYcmTZT69Vf9XXpJrAlKzQ1RKumA/t7JMQOlljZTKjNRKVv2yudV0ueQa1VFuwZJOa7UD75K7Z+k28nW887vUYHruVtm3OL0ndHr+17qvbXvFfoueWLJE3nbuBL7pyRt95Rjuo15YqFSJxYpNScw+7xoKnU1gL9UMWI+ZTE8zQIcAHoB0cAWYLBSane+MjcDT6PvZXUAPlFKtXexOieuhqdVBEeO6Kzy994LffuCl5eenaJu3Stbj6ws2L0bjh8ne3iRro97GQ09j0+Lx9PiiY97CbIPZsvpLnspYmL0DBarV+vAtNmsu6KazUWMJx05UmcpK2jECKfx0rGxOm/P8eN6PZbsfnpWazESleZkzcz/R7la9i9y3XUQGqoTxvn46P14zz06j9Lw4cUb+1vwc7JzJ9xyCxw4UEbJY8vzPcpKgrMbIP00urujSeeIqHq7Ux6Ua5LDBgl/QfJBHerDBGY3qHanvqucw54JK7pAw+f1v9kz4Kf6YI3VrxlcoKO33Qqxa/R6czq4GgbUHpbXi7ScZGXpz2dUVN75NiREHweFpmUv5jmJYzPh6HToMgvcs7t/Z/daAGCw8+e2NOfVUrnYcWTPhJMLdB4DN3+dHNqRAQ1f1J/5S11vRZTzN0f/rIcU9Vyet4+y7+xj9oG7XecyiU6KRilF1YCqer/9VB9wwA1rwSMEfvDCGKJQNiuYs0+iP0YwMzaGITHQq1Yvfrv/N17/7XXGrhvLYL8pLBr+GE89pT+ySun2zcyZBepb8D3KWR7/F6y+HW7dm/d3zDTofRJ+S4dZA2dxT9N78H7Hm3RbOmdeOsP0HdN5eYXudp/wSkJuknIn53fCn3fpIebuwbC4bvZ5A1yeO0rr1HLY/Q40Hw3BbfQ52prdc7Kcldtxf6lme8Dtx/TsglCsz7Uowt7xELcBGr+W10Mh+RCEFp6SsbifE6X091dCgs5dU15uuEFPdDBwYF5+zszMElzDnP4VdoyAnr/mnXtyvj+7zIYadzsvg0LfqVe1i7UjruXvz3/+CymHoP2XkDO0daYB84EfXZQfMYK5g5pw17y7+OrWrxjWWuesa/J5E50zCwj3Cefkiyex5LRBr+X9U0LFHZ5W6qBR9sZuAiYCZuAbpdQ7hmE8DqCUmmIYhgF8BvQF0oCH1EXyGUHFDRrlOH0aDh7UQ9N8fPTsCYUuHv6lStvIOXFCJ5M+cwYqVdIXaSdO6KnhS5OIbMECnRH/lVd0wk2HQ09X/8wzF3mhBI2cpKfrxsaBA3pUTo6GDfXMC926FW89BT8nx47pmYtOnaoAQSOhOexw+hc4vRxyBgCaPKDlOzq48G+WckwH1fpt08EWs2e+Bm7hC+MrfvHoqtFaMPB1Na33WpBzTko/C0sb6aGfnhFgyf5is6XqyTSKI3EP/NIOev8Jgc3BZIaZhg4apceAe4gO4v4YwebzMXQ4AQ1CGrDv6X3cPfdu5uyZQ6ctB8mKqcvq1XmzU6Wl5fuevVjQaPtbkB4NbT7WF27Zn9/X42DsORjbayxPttPJc73dvEl5PQXDMFhxeAXNw5sT7hte9N+XdhIOfQ2pR3UAzOHQx0ibCXlDHsuSww4JWyHtODgywS0AqvTTAf9ydM0Fjf5+Eaznod1nenIA0O+X5RrPIlteHFmQ8LcOYgJ4hmcHNp0zh5Tkc1K/Pnz+OXTurG98g74xUnCm3cspPh6eeEKPrOzfX9dj1y54+eWLvxbQE9csbQa37AL3IN2eyPn+7DQNag7JHmZa9HfqNSkiQt9dLyg8vESTqpSrpc2h1Vioe0skQgAAEHRJREFUkj2u+hIDezEpMUSM1xOzHH72MLWDarveP9fSvrkEVzKnEUqpZehh0/mXTcn3uwKeKottVSSVK+uHKHvVqunZvcpa//66J8uff8K2bfpuS/v2+ou22NPNFzwhGUaFPyEVtHWrnlWoUiXn5dWr65ktOnW6tB5vNWvqgNNTT8Enn+RNjZyVpXs1FVvBi1LD+PdclF5tTGaIvFk/hDPfmtDmE1jeQffKCWgC7abC4anQfdlFX37ZjRx5eY6Zy7Xeq1nB7w2vMOgcBJaeUPs/+iLQlgpHp0H3JcVbZ/xfOljkX18fZ/mtuF4HckI7wE07qHNoOpx4KXfWuKjEKACO74pk/Pt5F46gvxeLzRoL3lULBbqauutMkmuj1lLFTyf4r+ZfDSP7i7Z3nd4XX7d3VWg+ogSVKSWTGULboycVFpes1Tg49BUs7wR+dXWvrZTD0G9redfs2mRyc9mzqDRmzdKzRI4YAbfeqo/5det0G/lKCQnRs7slJembwhkZMGhQCdrjXhHQbhIs7wzNR0Jwa+i2BHa9DbvHQuU+unfb7VHZQeAL9HoVV5ay65uHhZQsQB/uG86Pd/1ISmaKDhiJCyqToJEQ/yZubtCjx8XLiaIlJEDVqnpIWv6Ljeef19PkDh6s71R7eempjH19i15XQbNm6TtNzZrp3mBWq777dPRoCSr4b7woFdem6gP13bbYNZC4Wzds204u71qJK+GwO9x6COK3QNIeMHvr2bCKK249BLUkdyjnjxF5/9Z9mR7+uHcCmD0IrtwXs2HmXMY5/r+9ew22q6zvOP79k+QQSExCyA0SciGGJCSIQFAoASmhFQ2COtVSsVhwZMpQC2ixINN22r6hUi849DIMcpnKKASxolgxArb4gqCCkNCAUIEQbuEa0ECSE/59sVbI4Zy9c84+t71W8v3M7DlrP3vts57kd/beaz/ruVxxzxX8+sVfQ2cHzz01mmOPfXsv6ZZ6ee49CzauKSZkHTUOPlpcPBn70Pfghg9z2//dxk+f+CkA23IXuMrfBrNmtXBRqxL2oFgP5+x2V2S30rXXd2+OOKIYbr1iRXGRbuvW4oLd9qHXw2ncOFi0qPf9Gpr1cZh6Ajz9Q3j06mKo04Lz4NVH4NZDi8/XUeOLXpnv67mabC3tCheopy2DJ26ASUcVFxw+2v9/00cWdmvp3BX+f4bIoAxPGyq7+vA0NVe77tS9cZjT29x2W9GR50c/Kj7wt8sshvrdeiuccUbRG2nlSvjmNxv/np39nWzdWswf1tFR9ECq10mzNPh2ufdVDcxPjocD/6y4QTEnBBTD0xr8nXT8Ywdb39zKniP2ZPO2zfDKTPa57nE2bIi35vjrobfhaRsfgh8fAyevhdGT33p4w283MPXLbx96tnzecn7wiT72opKkgdi2GZ7/GWx5uVjddvwiTySr4tWHi6HVS1fA5GOANyFGOoS1n/o6PM0ZdKShMm1a8QHT9UMmoijfzR1yCNx/Pz2+aHR2whVXFJOorltX9BpauLC4etWqUaOKSbXnzPFzXpJ62PZ6MUl0H40fXUy2vnnbZgD22LY3Y8cGnZ19/AWNPhPHL4B7X4M7ToQX7ynnX/klU8buGLs8qpx/aMl+vZ7TStLgGLFn0aNl5h/BhMWeSFbJuPlw5L/DXR+BO0+CVZ+BW/vb3Ux95fA0aag0mmhuZ+W7kf33h4kT4Zpr4Kyzek6kePTRxU2SNET26ChWJNxu9NQdk4k2cOCEA3lh0wtv3R+z1yjeeGMQhqP8xwT4wEFFz6c9Oor5Q/54E4dMOYTVG1Yzf9J81mxYw+nvOn2AB5Ik7RLmfKJo1PvNNfDGs3DYZS1OMKtW2dNIGipTm6zq0qx8N/O5zxWTKN5xRzGB4W9/C2ee2e5aSdJuYvR+8MqvYNuW4v5Hn93pyjMfOuhDACyctBCA4xYs5OWXYePGPh7v2WeLk/rutyefg2NXwPI1cMwN8MHVABw781gAXn79ZQAnKpUk7bDXVFh0ERzxtaJHmA1GQ8pGI2moNDtBdpI1oJi7aO5c+PjHizmHpk6F73+/3bWSpN3E5GPgpfuLYWp9sHTWUgAWTFoAwAcWHcfUqdB96sk+D1frbuyBsP/74R1zATh02qEAPPXaU4wZNYYR3Vd4kyRJw8Lhaaqk+q32oYHYtGnHdiu5t7LahySpi32XwOp/KJYv3u7NTpqdGs7dp2jMeeyVYinKuRPncuSR8PWvw9KlO1a53LIFRs6Y9vah2BHFlYEWLppsb5wCWDpzaZ+fJ0mSBpc9jVRJjz/euJOON29db48/3u6/VEmqqYlHAp2w6tPQuamY32jLK013nz5uOgDrN64H4J0T38kZZ8Bdd8EttxRDjH/3O/jyl2k8d1+L8/ltHwYH8N7p723puZIkafDY00iSJGl3M6ID5l8Aa/8Jbj8eJh0N61YATzfcfY8orjO+8HoxGfas8bOYc0qxqMHpp8OyZUWv0bvvhr8ZhOpNHjP5re1FU1wZR5KkdrGnkSRJ0u7o4Ath3AJ4ZTU8/HXYsvNZrRdPXvzW9qgRoxgxAr77XZgwoVjU4Oc/L1bHbLjgwwAWgeja60iSJA0vexpJkrQbcK449TQGuO9tJTubK27pzKWseX4NU8fsaAA6/HC47z746ldhr73gwguBfQdnwYfxe45n4+aNzNt33qD8PkmS1DobjSRJ2g04B5gGavswscVTFr+tfPZsuPzywT/e5DGT2bh5I6NHjh78Xy5JkvrE4WmSJEnq1fYV1ObvO39Yjnf+e8/nkCmHDMuxJElSYzYaSZIkqVdzJxaNRnP2mTMsxzv3PefywDkPDMuxJElSYzYaSZIkqVezJ8wGYMY7ZrS3IpIkadjYaCRJkqRedYzo4Ct/+BWWH7S83VWRJEnDxImwJUmS1CcXHH1Bu6sgSZKGkT2NJEmSJEmS1IONRpIkSZIkSerBRiNJkiRJkiT1YKORJEmSJEmSerDRSJIkSZIkST0MqNEoIiZGxMqIeKT8uU+DfQ6IiDsjYm1EPBgR5w3kmJIkSZIkSRp6A+1pdBFwe2bOA24v73fXCXw+MxcCRwHnRsTBAzyuJEmSJEmShtBAG41OBa4rt68DPtx9h8x8JjPvLbdfA9YC0wd4XEmSJEmSJA2hgTYaTc3MZ6BoHAKm7GzniJgNHAasGuBxJUmSJEmSNIRG9rZDRPwEmNbgoUtaOVBEjAW+A5yfma/uZL+zgbMBZs6c2cohJEmSJEmSNEh6bTTKzBObPRYRz0XEfpn5TETsB2xost8oigaj6zPz5l6OdyVwJcCSJUuyt/pJkiRJkiRp8EVm/9tlIuIy4MXMvDQiLgImZuYXuu0TFPMdvZSZ57f4+58HnuhWPAl4od+VVjuZXT2ZW32ZXT2ZW32ZXT2ZW32ZXT2ZW32ZXT01y21WZk7u7ckDbTTaF7gRmAmsAz6WmS9FxP7AVZn5wYhYCtwFrAbeLJ/6xcz8YT+P+YvMXNLvSqttzK6ezK2+zK6ezK2+zK6ezK2+zK6ezK2+zK6eBppbr8PTdiYzXwSWNSh/Gvhguf0zIAZyHEmSJEmSJA2vga6eJkmSJEmSpF1QHRuNrmx3BdRvZldP5lZfZldP5lZfZldP5lZfZldP5lZfZldPA8ptQHMaSZIkSZIkaddUx55GkiRJkiRJGmK1ajSKiJMi4uGIeDQiLmp3fdRYRBwQEXdGxNqIeDAizivLJ0bEyoh4pPy5T7vrqp4iYkRE3BcRPyjvm1sNRMSEiLgpIh4qX3tHm131RcQF5fvkmoj4VkSMNrdqioirI2JDRKzpUtY0q4i4uDxfeTgi3t+eWguaZndZ+X75QER8NyImdHnM7CqgUW5dHvuriMiImNSlzNwqoll2EfHZMp8HI+JLXcrNrgKavFe+OyLujohfRcQvIuI9XR4ztwroz3fvVrOrTaNRRIwA/gX4AHAw8CcRcXB7a6UmOoHPZ+ZC4Cjg3DKri4DbM3MecHt5X9VzHrC2y31zq4fLgR9l5gLgUIoMza7CImI68JfAksxcDIwATsPcqupa4KRuZQ2zKj/zTgMWlc/51/I8Ru1xLT2zWwkszsx3Ab8GLgazq5hr6ZkbEXEA8AfAui5l5lYt19Itu4j4feBU4F2ZuQj457Lc7KrjWnq+5r4E/H1mvhv42/K+uVVLS9+9+5NdbRqNgPcAj2bmbzJzC/BtijceVUxmPpOZ95bbr1F8eZ1Okdd15W7XAR9uTw3VTETMAJYDV3UpNreKi4hxwHHANwAyc0tmvoLZ1cFIYK+IGAnsDTyNuVVSZv4P8FK34mZZnQp8OzM3Z+ZjwKMU5zFqg0bZZeaPM7OzvHs3MKPcNruKaPKaA/gq8AWg68Ss5lYhTbI7B7g0MzeX+2woy82uIprklsC4cns8xXkKmFtl9OO7d8vZ1anRaDrwZJf768syVVhEzAYOA1YBUzPzGSj+uIEp7auZmvgaxYnYm13KzK36DgSeB64phxZeFRFjMLtKy8ynKK60rgOeATZm5o8xtzpplpXnLPVyFvBf5bbZVVhEnAI8lZn3d3vI3KrvIODYiFgVEf8dEUeW5WZXbecDl0XEkxTnLBeX5eZWQX387t1ydnVqNIoGZS79VmERMRb4DnB+Zr7a7vpo5yLiZGBDZv6y3XVRy0YChwP/lpmHAb/DIU2VV44tPxWYA+wPjImIT7a3VhoknrPURERcQtG1//rtRQ12M7sKiIi9gUsohsj0eLhBmblVy0hgH4rhMxcCN0ZEYHZVdw5wQWYeAFxA2asdc6ucFr57t5xdnRqN1gMHdLk/gx3d41QxETGK4o/2+sy8uSx+LiL2Kx/fD9jQ7Plqi2OAUyLicYrhnydExDcxtzpYD6zPzFXl/ZsoGpHMrtpOBB7LzOczcytwM/B7mFudNMvKc5YaiIhPAScDp2fm9hNms6uuuRSN7PeX5yozgHsjYhrmVgfrgZuzcA9Fr/ZJmF3VfYri/ARgBTuGMZlbhbT43bvl7OrUaPRzYF5EzImIDorJm25pc53UQHnV4BvA2sz8SpeHbqF446H8+b3hrpuay8yLM3NGZs6meH3dkZmfxNwqLzOfBZ6MiPll0TLgfzG7qlsHHBURe5fvm8soxqGbW300y+oW4LSI2DMi5gDzgHvaUD81EREnAX8NnJKZm7o8ZHYVlZmrM3NKZs4uz1XWA4eXn4HmVn3/CZwAEBEHAR3AC5hd1T0NvK/cPgF4pNw2t4rox3fvlrMbObhVHjqZ2RkRfwHcRrHCzNWZ+WCbq6XGjgH+FFgdEb8qy74IXErRFfXTFF+WPtam+qk15lYPnwWuLxvVfwOcSXFhwOwqKjNXRcRNwL0Uw2PuA64ExmJulRMR3wKOByZFxHrg72jy/piZD0bEjRSNt53AuZm5rS0VV7PsLgb2BFYW59vcnZl/bnbV0Si3zPxGo33NrVqavOauBq6OYjn3LcCnyh5+ZlcRTXL7DHB5uWDHG8DZ4GuuYlr67t2f7GJHb1xJkiRJkiSpUKfhaZIkSZIkSRomNhpJkiRJkiSpBxuNJEmSJEmS1IONRpIkSZIkSerBRiNJkiRJkiT1YKORJEmSJEmSerDRSJIkSZIkST3YaCRJkiRJkqQe/h/8bQuDEoJdcwAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2795,7 +2674,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIcAAACMCAYAAADm+clLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXSc9X3v8c9Xo32zvIyNsbwqtoEEm0UxGAoYUsAmSWlzA4WkaRpCDDnQNultWrhL25t72tCsJSUtcViTJpjkJiS0McEQctgxXrDxghd5lbyv0sjyWLN87x8zMmN5ZI1kSTOeeb/O0bHm9zwz+sp+/HtmPs/v93vM3QUAAAAAAIDCVJTtAgAAAAAAAJA9hEMAAAAAAAAFjHAIAAAAAACggBEOAQAAAAAAFDDCIQAAAAAAgAJGOAQAAAAAAFDAirNdQDqjRo3ySZMmZbsMAAAAAACAvLF8+fID7h7s3t5rOGRmj0n6mKR97v6hNNtN0oOSbpLUIenP3H1Fctvc5LaApEfc/YFMip00aZKWLVuWya4AAAAAAADIgJltT9eeybSyJyTNPc32eZKmJr/mS/r35A8MSPpecvsFkm43swsyLxkAAAAAAACDrddwyN1fkXToNLvcLOmHnvCWpDozGytplqQmd9/i7p2SFib3BQAAAAAAQI4YiDWHxklqTnnckmxL137ZAPw8AMAZCEdiWvj2Dr20Yb/cPdvlAIOmtqJEd1w5SZdOHJHtUgAAAHLaQIRDlqbNT9Oe/kXM5isxLU0TJkwYgLIAAKk6o3H9bHmzHnqpSbtbw5o2plrVZTl5XwJgQKzd1aZfv7tb10wL6r/fME0z6uuyXRIAAEBOGohPBS2Sxqc8rpe0S1JpD+1pufsCSQskqbGxkUvZADBAorG4nnlnpx787Sa1HD6mSybU6Zu3zNQVDSOVuKcAkJ86OqP64Zvb9f2XN+sPHnpd118wRn91/TSdP7Y226UBAADklIEIh56VdK+ZLVRi2liru+82s/2SpprZZEk7Jd0m6VMD8PMAABmKxOL6xL+9odU7W3XhuGH6v3/4Ic2ZFiQUQkGoLC3W3dc06NOXTdATr2/Tgle3aN6Dr+p/ffR83XnVlGyXBwAAkDMyuZX9U5LmSBplZi2S/l5SiSS5+8OSFilxG/smJW5l/7nktqiZ3SvpeSVuZf+Yu68dhN8BANCDPa1hrd7Zqr+47gP68vXTCIVQkGrKS/TnH5mqP509SZ95bIl+tXIX4RAAAECKXsMhd7+9l+0u6Z4eti1SIjwCAGRBKByVJJ0/tpZgCAVvWGWJLp04XE8vbZa7838CAAAgqddb2QMAzl6hcERSYuQEAKkhWK2Ozpj2tIWzXQoAAEDOIBwCgDzWNXKoppy7kgFSIhySpM37jma5EgAAgNxBOAQAeSx0vGvkEOEQIEkNo6skSZv3t2e5EgAAgNxBOAQAeaz9xMghppUBkhSsLlNNeTHhEAAAQArCIQDIY21MKwNOYmZqCFYTDgEAAKQgHAKAPBYKR1UaKFJ5SSDbpQA5oyFYzZpDAAAAKQiHACCPhcIRRg0B3TSMrtKetrDaj0ezXQoAAEBOIBwCgDwWCkcJh4Buuu5YtoWpZQAAAJIIhwAgryVGDrEYNZDqxO3sCYcAAAAkEQ4BQF5j5BBwqokjK1VcZKw7BAAAkEQ4BAB5jHAIOFVJoEgTRlYycggAACCJcAgA8hjTyoD0uJ09AADA+wiHACCPMXIISK8hWK2tB44qGotnuxQAAICsy81PDAc2SY9/NNtVAMBZzeX6gR/SuE0V0uOV2S4HyCl3hMKaEziqyKPfVXFJINvlAAAAZFVGI4fMbK6ZbTCzJjO7L832r5jZyuTXGjOLmdmI5LZtZrY6uW3ZQP8CAID0YnGXJAWKLMuVALmnojQRCIUjsSxXAgAAkH3m7qffwSwgaaOk6yW1SFoq6XZ3X9fD/h+X9GV3vy75eJukRnc/kGlRjY2NvmwZORIAnImdR47pygde0gOfuFC3zZqQ7XKAnNLaEdHMry7W/fPO013XNGS7HAAAgCFhZsvdvbF7eyYjh2ZJanL3Le7eKWmhpJtPs//tkp7qX5kAgIESCkckiQWpgTSGVZZoVHUZi1IDAAAos3BonKTmlMctybZTmFmlpLmSfp7S7JIWm9lyM5vf30IBAH0TCkcliQWpgR40BKu0ef/RbJcBAACQdZmEQ+kWq+hpLtrHJb3u7odS2q5090skzZN0j5ldnfaHmM03s2Vmtmz//v0ZlAUAOJ33Rw4RDgHpNIyuVtO+dvU2xR4AACDfZRIOtUgan/K4XtKuHva9Td2mlLn7ruSf+yQ9o8Q0tVO4+wJ3b3T3xmAwmEFZAIDTeX/kENPKgHQagtVqPRbRoaOd2S4FAAAgqzIJh5ZKmmpmk82sVIkA6NnuO5nZMEnXSPpVSluVmdV0fS/pBklrBqJwAMDptSXDoVpGDgFpNQSrJImpZQAAoOD1Gg65e1TSvZKel/SepJ+6+1ozu9vM7k7Z9Y8kLXb31HdYYyS9ZmarJL0t6dfu/puBKx8A0BMWpAZOryFYLUksSg0AAApeRpeT3X2RpEXd2h7u9vgJSU90a9siaeYZVQgA6JdQOKriIlN5SSaDRIHCM66uQmXFRdq8j3AIAAAUNj4xAECeCoUjqikvllm6+woAKCoyTR5VxcghAABQ8AiHACBPhcJRppQBvWgYXc2aQwAAoOARDgFAnkqEQyxGDZxOQ7BazYc7FI7Esl0KAABA1hAOAUCe6ppWBqBnDcEquUvbDjJ6CAAAFC7CIQDIU0wrA3p34o5l+wiHAABA4SIcAoA8xbQyoHdTglWSuJ09AAAobIRDAJCnQuGIahk5BJxWZWmxxtVVEA4BAICCRjgEAHnI3dV+nJFDQCamBLmdPQAAKGyEQwCQh452xhR3EQ4BGWgIVmvzvqOKxz3bpQAAAGQF4RAA5KFQOCJJLEgNZKBhdLWORWLa0xbOdikAAABZQTgEAHkoFI5KYuQQkIkGFqUGAAAFjnAIAPIQI4eAzI2rq5Ak7Wll5BAAAChMhEMAkIfaGDkEZGxUdZkkaX/78SxXAgAAkB2EQwCQh7qmldUSDgG9qiorVlVpQPtDhEMAAKAwEQ4BQB5iWhnQN8GaMsIhAABQsDIKh8xsrpltMLMmM7svzfY5ZtZqZiuTX3+X6XMBAAOPBamBviEcAgAAhazXTw1mFpD0PUnXS2qRtNTMnnX3dd12fdXdP9bP5wIABlAoHFGgyFRREsh2KcBZIVhTpvV7QtkuAwAAICsyGTk0S1KTu29x905JCyXdnOHrn8lzAQD9FApHVVNeLDPLdinAWSFYzcghAABQuDIJh8ZJak553JJs6262ma0ys+fM7IN9fK7MbL6ZLTOzZfv378+gLABAT7rCIQCZCdaUKRSOKhyJZbsUAACAIZdJOJTusrN3e7xC0kR3nynpXyX9sg/PTTS6L3D3RndvDAaDGZQFAOhJKBxRTRmLUQOZCtYkb2fP6CEAAFCAMgmHWiSNT3lcL2lX6g7u3ubu7cnvF0kqMbNRmTwXADDw2hg5BPTJiXConXAIAAAUnkzCoaWSpprZZDMrlXSbpGdTdzCzcyy5sIWZzUq+7sFMngsAGHiJaWWMHAIyNbqmXBIjhwAAQGHq9bKyu0fN7F5Jz0sKSHrM3dea2d3J7Q9L+qSkL5pZVNIxSbe5u0tK+9xB+l0AAEmhcES15TXZLgM4azCtDAAAFLKM5hwkp4ot6tb2cMr3D0l6KNPnAgAGVygcVTXTyoCMjagqlRnhEAAAKEyZTCsDAJxF3F3tx1lzCOiLkkCRRlSWsuYQAAAoSIRDAJBnOjpjisWdNYeAPgrWlDFyCAAAFCTCIQDIM6FwVJIYOQT0EeEQAAAoVIRDAJBnQuGIJDFyCOijYDXhEAAAKEyEQwCQZ9oYOQT0S7CmTPvbjytxw1UAAIDCQTgEAHmm/XgiHKolHAL6JFhTps5o/ETACgAAUCgIhwAgzzCtDOifYE2ZJG5nDwAACg/hEADkGRakBvonWE04BAAAChPhEADkGUYOAf1zYuRQO+EQAAAoLIRDAJBnQuGoikyqKg1kuxTgrMK0MgAAUKgIhwAgz4TCUVWXFcvMsl0KcFYZVlGikoARDgEAgIJDOAQAeaYtHGFKGdAPZqZgdRnhEAAAKDiEQwCQZ0LhKItRA/0UrCljzSEAAFBwCIcAIM+EwhHVMnII6JdgDSOHAABA4ckoHDKzuWa2wcyazOy+NNs/bWbvJr/eMLOZKdu2mdlqM1tpZssGsngAwKkYOQT0H+EQAAAoRL1+ejCzgKTvSbpeUoukpWb2rLuvS9ltq6Rr3P2wmc2TtEDSZSnbr3X3AwNYNwCgB6FwVFNHEw4B/RGsLtOho8cVi7sCRSzqDgAACkMmI4dmSWpy9y3u3ilpoaSbU3dw9zfc/XDy4VuS6ge2TABApkIsSA30W7CmTHGXDh3tzHYpAAAAQyaTcGicpOaUxy3Jtp58XtJzKY9d0mIzW25m8/teIgAgU+7OtDLgDARryiSJqWUAAKCgZPLpId2Yak+7o9m1SoRDv5fSfKW77zKz0ZJeMLP17v5KmufOlzRfkiZMmJBBWQCA7sKRuKJxZ+QQ0E8nwiHuWAYAAApIJiOHWiSNT3lcL2lX953MbIakRyTd7O4Hu9rdfVfyz32SnlFimtop3H2Buze6e2MwGMz8NwAAnBAKRySJkUNAPwWryyUxcggAABSWTMKhpZKmmtlkMyuVdJukZ1N3MLMJkn4h6TPuvjGlvcrMarq+l3SDpDUDVTwA4GRt4agkwiGgv0bVlEoiHAIAAIWl108P7h41s3slPS8pIOkxd19rZncntz8s6e8kjZT0b2YmSVF3b5Q0RtIzybZiST9x998Mym8CADgxcqiWaWVAv1SWFqu6rJhwCAAAFJSMLi27+yJJi7q1PZzy/Z2S7kzzvC2SZp5hjQCADIUYOQScsWBNGWsOAQCAgpLJtDIAwFni/XCIkUNAfwWry7Q/FM52GQAAAEOGcAgA8ggLUgNnLlhTxrQyAABQUAiHACCPMK0MOHOEQwAAoNAQDgFAHgmFIzKTqkoJh4D+CtaUqS0cVTgSy3YpAAAAQ4JwCADySFs4quqyYhUVWbZLAc5aweoySdIBFqUGAAAFgnAIAPJIKBzlNvbAGQrWJMIhppYBAIBCQTgEAHkkFI6w3hBwhgiHAABAoSEcAoA80n48SjgEnKET4RDTygAAQIEgHAKAPBJKrjkEoP9GVJXKjJFDAACgcBAOAUAeSUwrY80h4EyUBIo0orKUcAgAABQMwiEAyCOhMNPKgIEQrCkjHAIAAAWDcAgA8kgiHGLkEHCmgjVlrDkEAAAKBuEQAOSJcCSmzlickUPAAAhWM3IIAAAUDsIhAMgToXBUklRLOAScsa5pZe6e7VIAAAAGXUbhkJnNNbMNZtZkZvel2W5m9t3k9nfN7JJMnwsAGBihcESSmFYGDIBgTZmOR+MKHY9muxQAAIBB12s4ZGYBSd+TNE/SBZJuN7MLuu02T9LU5Nd8Sf/eh+cCAAZA18ghppUBZy5YUyaJ29kDAIDCkMnIoVmSmtx9i7t3Sloo6eZu+9ws6Yee8JakOjMbm+FzAQAD4P1wiJFDwJkKVhMOAQCAwpHJ5eVxkppTHrdIuiyDfcZl+NxTbNrXrpsefDWD0pBNE0ZU6kvXT9V559T2uE84EtMP39ym/1y1W7H40K3bMKKqVF/7xIUaP6JyyH7m2WTR6t16+OXNisZO/Tf58KThuve6qSeump+pcCSmJ97Ypl+/O7THQF8EikzTxtTo4gl1unhCnaaPqVFx4P3sfG9bWO/sOKwVO45oZfMRtYczn2ZyRcNI3X/T+QoU2WCUfpL3p5Uxcgg4U4wcOruFIzE9/vo2LVqdu+ce5KdhFSWaf80UzZkWlFn6c7+7a9HqPXrq7R363JWT9JHzxwxqTe6uF9bt1dNLm3XV1FH61GUTVVrc8xiB1S2tevC3m7TryLFBrWuojKwu1RfnNOiKhlE97hOPu365cqf+463tCkfiQ1ZbaXGR/vjD43XLpfUnvfcEulu67ZAeeqlpUN+XZPIJIl2v1v0s29M+mTw38QJm85WYkqaac6fo3LqKDEpD9rje2HxAz6/bo09eUq+/umGaxg57/98sHnf9atVOffP5jdp55JgunThcwytLh6y6t7ce1G0L3tLTd12u+uEERKn+c9Uu/eXCd9QQrNbEkVUnbeuMxfXjJTv0/5a3aP7VDbrzqsmqKutf0BCLu555Z6e+vXiDdrWG1ThxuOqG8Bjoi85YXC9v3Kefr2iRJFWWBjSjfpiGV5ZqVfMR7WoNS5JKA0X64LjajPunY5GoHnltqw53RPT1T84Y9ICIaWXAwCEcOjt1nXu+tXiDduf4uQf5acPeNn3u8aWJi0PzzteF9cNO2r5ky0H903Prtar5iCpKAnqt6YDuunqK/vrG6SoZhHBgxY7D+tqi97R022HVVZbot+v36fE3tulvbjxPN114zkkBVvOhDn1z8Qb9auUujagq1SUT6pT+49zZZd2uVn3qB0t07fSg7pt3vqafU3PS9lc37dfXFq3Xut1tmj6mZkgvLu9uPab7f7Faj762VffNPU8fOX90j6EiClPTvnZ9/TfrtXjdXo2pLdOF4+oG7Wdl8gmiRdL4lMf1knZluE9pBs+VJLn7AkkLJKmxsdEf+WxjBqUhm450dOp7v2vSk29s17OrdunzvzdZd89p0KrmIyc62AvHDdM3PjlDV3yg56R+MKxuadWnHnlLt//gLS2cP1vjCBslSb9+d7e+9PRKNU4cocc/9+G0wc+W/e36xvMb9J0XN+o/lmzXl39/mm5tzPxqhrvrlU0H9LVF72n9npBm1A/Tt269SLMbRg70rzOg3F0th49pxY7DemfHEb2z47B2HWnTpZNG6M7xiRFFF5xbq7LiQJ9e98EXN+k7L25UkUn//N9mqGgQA6I2FqQGBsywihKVBEz72wmHzgburpc37tcDz63X+j0hzawfpu/88UW6fEpun3uQfzqjcf1kyXZ996Umffyh13TzRefqr2+YruPRmB54boNefG+vzqkt1zc+OUMfnTFW//jr9/T9V7Zo+fbD+tdPXXzSxdYz0fV+7rk1exSsKdM//dGFurWxXq82HdADi9brnp+s0EXj63T/vPM0bUyNHvpdk3705nYVFUn3XvsB3XXNlLx5P9E1k+Ghl5o078FX9MlL6/Xl66fp0NFOPfDcer266YDGj6jQg7ddpI/POHdQ36t15+5avG6v/vm59brzh8s0a/II3T/vPF08YfiQ1YDctC8U1oMvbtLCpc2qKAnoKzdO1x1XTlZFad8+i6Tz6J+lb7febtFqZsWSNkr6iKSdkpZK+pS7r03Z56OS7pV0kxLTxr7r7rMyeW46jY2NvmzZskx+L+SA5kMd+vYLG/XMOztVXlKkcCSu+uEV+sqN04e8g021qvmI/uSRJRpeVaqn77r8lJNtPO564b29embFTo2pLdPM8XWaUV+nKaOqslbzYPrNmt265yfv6OLxdXrijlmq7mVE0PLtiStNy7Yf1oQRlRkHbG3hiNbuatP4ERX6mxvP00cvHJuXf5998S8vbtS/vLhJt1xaP6gB0Xde2KgHf7tJm//ppiGZxgbkuyu+9ltd8YFR+uYtM7NdCpSY4vv469u0qvnIKdu6zj0TRlTqb+ZO10cvHMvVd2RVKBzR91/eokde26J4XIrG46oqLdYXr23QHVdOVnnJ+x/wfrVyp+7/xWqVlwT07Vtnas700T2+bjzu2nLgqFY1H9G7LUfUtL9d8W6zoGLuWrH9sMqKi9KOBI/FXT9f0aJvL96oPW1hlZcUqTMa1y2XjteXr5+mc4aVD/jfRy5IvbAtkyKxuIZVlOjPr5uqP7l8Qp8vAA6kSCyuhUub9eCLG3WgvVNzP3iOvjinQTPHD94oEWRXNBbXc2v26BcrWk6ZyuhyvdvSqs5oXH9y+UT9+XUf0MjqgVnyQ5LMbLm7nzIap9dwKPnkmyT9i6SApMfc/R/N7G5JcveHLXH2fUjSXEkdkj7n7st6em5vP49w6Oy0ZmerHnt9qy4YW6vPzJ6Y1Q62yzs7Duszj76tUdWlWjh/ts4ZVq7OaFy/XLlT3395szbvP6pgTZmOHo+qozMmSaopK9aF9cN08YQ6zZ4ySpdOHN6nhDYWd63d1ao3Nh/UnuR0pEzUlhfr6mlBXTxheJ8+2Mfirvd2t+nNzQd1PBrT5VNGakZ93UlzyZ9fu0f3/HiFZtQP05N3zMr4SlDX1Yz/eGu7jmc4/9pMuvGD5+jTWT7J5pqu4ObWxno98InBCYi++p/r9NNlzVrzf24c8NcGCtHND72muspSPXnHrGyXUtA272/Xgpe36Jl3dioaj2vm+DqVFJ08mtVMmvuhc/TpXtZSAYbantawHn55s8qKi3TXNQ0aUZV+mmPTvnbd8+MV2rA3pD+86NxTpkPG4q7N+9u1uqVVoeOJaeRVpQFNHVOj0jSjuy84t1b3XPuB064heawzpsff2Kqt+4/qzqumnDLdKl81H+rQ91/ZrLqKUn3h6ikaVpE7I6Taj0e14JUtevy1rQodj+ryKSN019UNmjO95zWscHYJR2L62fIW/eCVLdpxqEPjR1RobO2pF+HrR1ToL66bqkmjqtK8ypk5o3BoqBEOYSAt335If/ro2xpTW65bGsfryTe2aU9bWOePrdXd10w5cXWxaV+7VrUcSV6JadW63W2KxV2lgSJdNKFOVzSM1OwpI9MO920LR7Rk6yG9ufmglmw9eGLtl9ry4ow78vbjUcXiruGVJbp2+mhdd/5oXT0tqNpkkBOLuzo6ozrWGdOB9k69vfWg3th8UEu2HlLrschJr1VREtCHJ4/Q7CkjVVtRrH94dq0uOHeYfvT5WSdeD0PL3fWdFzbquy816Y8bx+uO35usIpPMTEUmFZkpUGSqLA2osrRY5SVFfX4T8JWfrdJrTQf05v0fGaTfAigsdz65VDsOdeipL1yuqrJilRWf+v8ytW/u6yKm5SVFqkj+nz+T0X7urs5YXMc6Y+rojKW92cDZaE9bWI++tkWL1+1VaaBItzaO1xeumqIJI1lLEPnpWGdMX/2vtXpuzR6l+4g2cWSlZtQP08z6Os0cX6eGYDUjhfNUKBzRwreb9djrW7W7NaxpY6r1haumaEZ9Xdr3j+UlAVWWBlRREij4Efv9EYu7jkVi6uiM6ngknvb/35mKxuNatHq3nnhjmw60d+qi8XX64pwGXX/+mCH/NyMcQkFbuu2QPvvY2+rojGn2lJG6e06Drp466rQfvtuPR7V02yG9tTkRwqzZ1dprRzFpZKVmN4zU7IZRunzKCI2uyXxYbuuxiF7ZuF8vrd+n323YpyMdERUXmarLi9XRGVNn9NQPHfXDKxKhVcNIzZ4ySmXFRVqSDI3e3HxQm/a1S5Jm1A/Tjz5/WU5dGSlE7q5vv7BR//pSU6/7miVCvsrSgIqLMrsKfrijUxNHVmrxl68501IBSPrfv1yjH721/cRjM6myJKCK0mJF4/Ee++b+KC0uUmVpIBFAZbgAbMxd4c6YOiKxvL0j17CKEv3p7In67BWTNGoAh9QDwNmgMxrXf727Swte2aL1e0IZPae8pEhVpcWDssB5PnG5OqOJc/nxATqXZ2LO9KDuvqZBl00ekbXRYIRDKHhN+0IKR+L60Lhhve+cRmtHREu3nTpKR0q8qb9k4vABW/g6GovrneYj+t36fQqFo4krAaUBVZUWq6I0oNqKEl08vq7XuynsC4X13u6QLp04vNc1hjA03F1Lth7SwfZOxd0Vd5d74gQViXZdtYjpWGdiqmNHJKZYH0YBXDVtlD4249xB/A2AwrE/dFy/27DvxIicjq7/l50xlQQsMeqnpPhEH11eEsj4vj6uxNDyE68dSYw+ynQKr5QMkUsDJ0YcdgXK+fKBoKykSHOmj+b8BaDgubve3npIB1LeP0pS3F2RmCsciZ04P3W9h8yXUaSDqevCTNe5tKK0WOXFRSoapNDmg+Nqdd45tYPy2n1BOAQAAAAAAFDAegqH8uPSEgAAAAAAAPqFcAgAAAAAAKCAEQ4BAAAAAAAUsJxcc8jMQpI2ZLsOnDVGSTqQ7SJw1uB4QV9wvKAvOF7QVxwz6AuOF/QFxwt6MtHdg90bc/X2DxvSLZAEpGNmyzhekCmOF/QFxwv6guMFfcUxg77geEFfcLygr5hWBgAAAAAAUMAIhwAAAAAAAApYroZDC7JdAM4qHC/oC44X9AXHC/qC4wV9xTGDvuB4QV9wvKBPcnJBagAAAAAAAAyNXB05BAAAAAAAgCGQU+GQmc01sw1m1mRm92W7HuQWMxtvZr8zs/fMbK2Z/WWy/R/MbKeZrUx+3ZTtWpEbzGybma1OHhfLkm0jzOwFM9uU/HN4tutEbjCz6Sn9yEozazOzL9HHoIuZPWZm+8xsTUpbj32Kmd2ffE+zwcxuzE7VyJYejpdvmNl6M3vXzJ4xs7pk+yQzO5bSzzycvcqRDT0cLz2ef+hf0MMx83TK8bLNzFYm2+lj0KucmVZmZgFJGyVdL6lF0lJJt7v7uqwWhpxhZmMljXX3FWZWI2m5pD+UdKukdnf/ZlYLRM4xs22SGt39QErb1yUdcvcHkiH0cHf/22zViNyUPCftlHSZpM+JPgaSzOxqSe2SfujuH0q2pe1TzOwCSU9JmiXpXEkvSprm7rEslY8h1sPxcoOkl9w9amb/LEnJ42WSpP/q2g+Fp4fj5R+U5vxD/wIp/THTbfu3JLW6+1fpY5CJXBo5NEtSk7tvcfdOSQsl3ZzlmpBD3H23u69Ifh+S9J6kcdmtCmehmyU9mfz+SSUCRqC7j0ja7O7bs10Icoe7vyLpULfmnvqUmyUtdPfj7r5VUpMS73VQINIdL+6+2N2jyYdvSaof8sKQk3roX3pC/4LTHjNmZkpcQH9qSIvCWS2XwqFxkppTHreID/7oQTL9vljSkmTTvckh2o8xTQgpXNJiM1tuZvOTbWPcfbeUCBwljc5adchlt+nkNwrWPF0AAALZSURBVFT0MehJT30K72vQmzskPZfyeLKZvWNmL5vZVdkqCjkn3fmH/gW9uUrSXnfflNJGH4PTyqVwyNK05cacN+QUM6uW9HNJX3L3Nkn/LqlB0kWSdkv6VhbLQ2650t0vkTRP0j3J4bfAaZlZqaQ/kPSzZBN9DPqD9zXokZn9T0lRST9ONu2WNMHdL5b0V5J+Yma12aoPOaOn8w/9C3pzu06+yEUfg17lUjjUIml8yuN6SbuyVAtylJmVKBEM/djdfyFJ7r7X3WPuHpf0AzGsFknuviv55z5JzyhxbOxNrl/VtY7VvuxViBw1T9IKd98r0cegVz31KbyvQVpm9llJH5P0aU8u/pmcHnQw+f1ySZslTctelcgFpzn/0L+gR2ZWLOkTkp7uaqOPQSZyKRxaKmmqmU1OXrW9TdKzWa4JOSQ5d/ZRSe+5+7dT2sem7PZHktZ0fy4Kj5lVJRcul5lVSbpBiWPjWUmfTe72WUm/yk6FyGEnXW2jj0EveupTnpV0m5mVmdlkSVMlvZ2F+pBDzGyupL+V9Afu3pHSHkwuhC8zm6LE8bIlO1UiV5zm/EP/gtP5fUnr3b2lq4E+BpkoznYBXZJ3bbhX0vOSApIec/e1WS4LueVKSZ+RtLrrtoyS/oek283sIiWG026TdFd2ykOOGSPpmUSmqGJJP3H335jZUkk/NbPPS9oh6ZYs1ogcY2aVStw1M7Uf+Tp9DCTJzJ6SNEfSKDNrkfT3kh5Qmj7F3dea2U8lrVNi+tA93EmosPRwvNwvqUzSC8nz01vufrekqyV91cyikmKS7nb3TBcnRh7o4XiZk+78Q/8CKf0x4+6P6tR1EyX6GGQgZ25lDwAAAAAAgKGXS9PKAAAAAAAAMMQIhwAAAAAAAAoY4RAAAAAAAEABIxwCAAAAAAAoYIRDAAAAAAAABYxwCAAAAAAAoIARDgEAAAAAABQwwiEAAAAAAIAC9v8BdfHCHh1A/MoAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -2807,7 +2686,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2822,17 +2701,15 @@ "output_type": "stream", "text": [ "tal hits:\n", - "MotifHitAndCoord(motif_idx=0, motif_score=0.6763298538561408, precision_at_motif_score=0.3772269950506758, example_idx=18, start=91, end=116, is_revcomp=False)\n", - "MotifHitAndCoord(motif_idx=0, motif_score=0.999585467994209, precision_at_motif_score=1.0, example_idx=18, start=100, end=125, is_revcomp=True)\n", - "MotifHitAndCoord(motif_idx=0, motif_score=0.7407143227403524, precision_at_motif_score=0.5, example_idx=18, start=154, end=179, is_revcomp=True)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.7090678572343863, precision_at_motif_score=0.5555729505256013, example_idx=18, start=55, end=80, is_revcomp=True)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.9946302266035284, precision_at_motif_score=1.0, example_idx=18, start=64, end=89, is_revcomp=False)\n", "gata hits:\n", - "MotifHitAndCoord(motif_idx=1, motif_score=0.9927436977742843, precision_at_motif_score=1.0, example_idx=18, start=15, end=40, is_revcomp=True)\n", - "MotifHitAndCoord(motif_idx=1, motif_score=0.9955978570801688, precision_at_motif_score=1.0, example_idx=18, start=153, end=178, is_revcomp=True)\n" + "MotifHitAndCoord(motif_idx=1, motif_score=0.9988318641019158, precision_at_motif_score=1.0, example_idx=18, start=81, end=106, is_revcomp=False)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2851,7 +2728,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIkAAACMCAYAAAD4MPn4AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXhc1X3/8feZRdJoGe2WZFmWvMlgG2ywMWDAkLKZpZiQ/FJC0xhoQ9Ynaft72pLwe5qkS5Jf2uZps/xIaUuANoGmAQIJJkDClrDaMt5tGS+yrc3ad42kmTm/P2YkZFuyJM9o7kj+vJ5HjzR3ru79yj5z7p3vnPM9xlqLiIiIiIiIiIic21xOByAiIiIiIiIiIs5TkkhERERERERERJQkEhERERERERERJYlERERERERERAQliUREREREREREBCWJREREREREREQE8DgdwJkUFBTYiooKp8MQEREREREREZk1qqqqWqy1haduj0uSyBjzMHAr0GStXTHG8wb4F+BmoA+421q7baLjVlRUsHXr1niEKCIiIiIiIiIigDHm6Fjb4zXd7BFgwxmevwlYEv26D3gwTucVEREREREREZE4iEuSyFr7OtB2hl02Ao/ZiLeBHGNMSTzOLSIiIiIiIiIisUtUTaJS4Piox7XRbQ0JOr/IjBcOW+o6+jnc0suhph4ONfdQ295P2FqnQ5s1jDGU5vhYPCeTRYUZLJ6TydxsHy6Xids5rLUcbunl1epmtta0sWROJlcvncOqshzccTyPiIiIyEx3uLmHF/ac4N0jrQTDs/ee1xhDWa6PRYWZkfvQOZmU+NPieg8qMlmJShKN1brHfJUbY+4jMiWN+fPnT2dMIjPC8bY+Hvj5bt490kpgKDyy3Z/moTw/A69bF494CYYtO4530Nk/NLItzetiYUH0gj1y4c6gIj+DNK97UscNDIV461Arr1Y38Up1M8fa+gAozfHxwp5GvvvyQXLSvaxfUsiHzivkmso55GakTMvfKCIiIpKsrLXsruvihT2NvLCnkfebegCoLMokMzWp11yKyVDIsv1YO12B4Mi29BQ3CwszIvefhZHE0eI5mZTnp5Pqmdw9qMjZSNQrrRYoG/V4HlA/1o7W2oeAhwDWrFkze9PFIpPw7I56HnhqFxa4a205S4oiiYqFhRnkZ6QQqQkv8WStpa13kINNPRxq7o1+72HbsXae3fFBt+Uy8NlrFvEXN553xuN1B4a486G32VPfhc/rZt2ifD61fiHXVBZSlpdOR98gv32/hVerm3ntQBPP7qgnLyOFF/9sPQWZqdP954qIiIgk3H9vOcbf/GIvpw4OClnLYDCMy8DaBXncdekyblheTGmOz5lAE8haS0vPIIeae0buPw8197K1pp1ntn9wD+p2Ge5ZV8GXbz5fo9BlWiQqSfQs8AVjzBPApUCntVZTzUTG0TMQ5KvP7OHJbbVcND+H7955EWV56U6HdU4wxpCfmUp+ZiqXLsw/6bn+wRCHWyIX7Bf3NPKDVw6Rm57Cn1y1cMxjDYXCfO7H29jf2M0//8EqNqwoPm30UU56Cr+/ci6/v3Iu4bDlnSNt/NF/vMM//Kqa//vRC6ft7xQRERFxQmAoxD++eICyvHTWV562+jaL52Ry3flF5J1jo6qNMRRmpVKYlcplp9yD9g0GOdzcy6HmHl4/0MK//+4IR9v6+Jc7V5GeMntHWIkz4tKijDGPA9cABcaYWuCrgBfAWvtDYDNwM3AQ6APuicd5RWaj7cc7+NIT73G8rY8v/t5ivnjtEjzueC1EKLHwpbhZPjeb5XOzueWCEsLW8nfP7aMwK5WNq0pP2tdaywNP7+K377fw7Y9cyO0XlY5z1A+4XIbLF+Vz75UL+LffHuauS+ezsixnuv4cERERkYR74t1jNHcP8L2PX3RaMkTGlp7iYUVpNitKs9m4qpQLSv38zS/38vGH3ubfN11CYZZGn0v8GJvERW/XrFljt27d6nQYIgnzanUTf/LoVuZkpfLPd17E2gV5TockZxAYCrHp4XfZdqydR+5ZyxWLC0ae++5v3uc7Lx3gi9cu4c+vr5zScbsDQ/zeP71GaY6Ppz67TkULRUREZFYIDIW4+h9eoTw/g59++nKnw5nRXtp7gi8+/h75mSn86O5LWFKU5XRIMsMYY6qstWtO3a7hCSJJ5MW9J0hPcfP8l9YrQTQDpHndPPTJNSwsyOTT/1nF7rpOAH5WVct3XjrAHReX8mfXLZnycbPSvNy/4Ty2H+/gqffq4h22iIiIiCP+p6qWE10DfOnaqd8fycmuX1bEf3/6MgJDYe548E3ePNTidEgySyhJJJJEalp6WTQnk+x0r9OhyCRl+7w8eu9a/Gke7v7RFn665Tj3P7mTKxbn8607Ljzr4uIfvqiUi+bn8K3n99MdGJr4F0RERESS2GAwzIOvHGR1eS7rFmmaWTxcOC+Hn39+HcX+NO7+0RY6+gadDklmASWJRJJITUsvC/IznA5Dpqg4O41H713LUCjMXz65k0WFmTz4idWkeM6+i3W5DF/7/eW09g7wvZcPxjFaERERkcR7clst9Z0BvnjtEq3QG0fzctP5s+srGQyGaewKOB2OzAJKEokkicBQiPrOAOVKEs1IS4qyePjuS7hxeRE/uucS/GmxjwZbWZbDx1aX8fDvjnCwqScOUYqIiIgk3lAozA9eOcjKshzWLymY+BdkSrJ9kfvOzj6NPpfYKUkkkiSOtvYBUFGgpe5nqtXlufzrH61hbo4vbsf8iw1L8aW4+fov9pDMCw2IiIiIjOfp9+qobe/nS9cu1iiiaTD84WRXIOhwJDIbJPfqZhXZdutXr3Q6DJGEaOsd5EBTNyvmZpOZ6nE6HEkiDZ39HG3ro7Ioi7z0FKfDEREREZk0i2X78Q48LsOK0mwMShLFWyAYYvvxDhYVZlKYmep0ODJDmHs3a3UzkWQWCIYASPPqZSknK8pOw+t20doz4HQoIiIiIlPS0jPIQDBMaW66EkTTxOOK/LsGQ2GHI5HZILmHKxQsgXueczoKkYT43lM7ebH7BFV/fL3ToUiScQH/75Et1Lb388I9650OR0RERGRSQmHLH3znNVLz3Wz+3JWgqWbTwoQtd35lM3+6Ygl/el2l0+HITHHv2K9HDVkQSRJHWnqpKFDRahlbZXEWh5p7GAzqEyIRERGZGY629nK4pZdPXl6uWkTTyO0yZKV66OxX4WqJnZJEIkmipqWP8nwVrZaxVRZlEgxbalp7nQ5FREREZFLqOvoBWKgPQqed3+elq1+FqyV2ShKJJIH+wRCNXQEW5OsCKmOrLMoC4MCJbocjEREREZmcuvZIkqg0N34rv8rY/D6vRhJJXChJJJIEhkeHaLqZjGdRYSYuAwcalSQSERGRmaGuox+XgWJ/mtOhzHr+NA9dASWJJHZKEokkgZqWSJJogZJEMo40r5uK/AyqNZJIREREZoi69n6K/Wl43HrbOd0i082UJJLY6dUqkgRqWvsAjSSSM6ssyuL9Ez1OhyEiIiIyKXUd/ZpqliDZShJJnChJJJIEalp6KchMJTPV43QoksQqi7Ooae0lMBRyOhQRERGRCdV19FOaoyRRIvjTvHQFVLhaYqckkUgSONLaS4VWNpMJVBZlErZwsEmjiURERCS5hcKWxs6ARhIlSLbPS89AkGAo7HQoMsMpSSSSBGpaejXVTCa0NLrC2ftNqkskIiIiye1EV4Bg2FKaow9CE8Hvi8xI6NZoIomRkkQiDusdCNLUPaCi1TKhioIMvG5DdaNGEomIiEhyq+voB2BujlY2SwR/mheATtUlkhgpSSTisJrWyMpmFflKEsmZed0uFhZkckArnImIiEiSq48mieZpullCZPsiSaKugJJEEhsliUQcdnRkZTMNxZWJVRZnKUkkIiIiSa+2fXgkkZJEieAfThL1a7qZxCYuSSJjzAZjTLUx5qAx5v4xnr/GGNNpjNke/frreJxXZDY40qKRRDJ5S4syqW3vp3dANwAiIiKSvOo6+snLSCE9Rav3JsLwSCJNN5NYxfyKNca4gR8A1wO1wBZjzLPW2r2n7Ppba+2tsZ5PZLapaemlMCuVjFRdQGViS0aKV/ewqizH4WhERERExlbX3q96RAk0XLha080kVvEYSbQWOGitPWytHQSeADbG4bgi54Sa1l4WaBSRTNLwCmcHGjXlTERERJJXXUc/pZpqljAqXC3xEo8kUSlwfNTj2ui2U11ujNlhjHneGLM8DucVmRWOtPSpHpFMWlleOmleF9WqSyQiIiJJylpLfUc/pTm6x02U9BQ3HpehS0kiiVE85reYMbbZUx5vA8qttT3GmJuBnwNLxjyYMfcB9wHMnz8/DuGJJK/uwBAtPQNUFGgkkUyO22VYPEcrnImIiEjy6ugbom8wRKlWNksYYwx+n1fTzSRm8RhJVAuUjXo8D6gfvYO1tsta2xP9eTPgNcYUjHUwa+1D1to11to1hYWFcQhPJHkNr2ym6WYyFZVFWuFMREREklddR2RlM003S6xsn5dOrW4mMYpHkmgLsMQYs8AYkwLcCTw7egdjTLExxkR/Xhs9b2sczi0yo9W0Rlc200gimYKlRVmc6Bqgs0+fFImIiEjyqW1XksgJ/jSPpptJzGKebmatDRpjvgC8ALiBh621e4wxn4k+/0Pgo8BnjTFBoB+401p76pQ0kXNOTUskSVSer/naMnmVw8Wrm7q5pCLP4WhERERETjYykkjTzRLK7/OqcLXELC5rbkenkG0+ZdsPR/38feD78TiXyGxypKWPIn8q6SlxeSnKOaKyOJIkqm5UkkhERESST31HPz6vm9x0r9OhnFP8Pu9Igk7kbMVjupmInKWa1l4qVI9IpmhudhqZqR7VJRIREZGkVNfeT2muj2jFEUkQf5qXLtUkkhgpSSTioJqWXhaoHpFMkTGGJUVa4UxERESSU11Hv+oROSDb56WrfwhVdpFYKEkk4pCuwBCtvYMqWi1nZWlRFtWN3boJEBERkaRT19HPXCWJEs7v8zAYCjMQDDsdisxgShKJOGS4aLWmm8nZWFKURXvfEC09g06HIiIiIjKibzBIW+8g81S0OuGyfZEaUCpeLbFQkkjEITWtfQBUFGhlM5m6pdEVzt7XlDMRERFJIvUdAQBNN3OAPy2SJOpSkkhioCSRiEOGRxKV52kkkUxdZXEmANVKEomIiEgSGV5dq1QjiRLOr5FEEgdKEok4pKall5LsNHwpbqdDkRmoMDOVnHSvileLiIhIUqlrjySJVJMo8Yanm3UFlCSSs6ckkYhDjrT2qh6RnDVjDJVFWRw40eN0KCIiIiIj6jr6cLsMRVmpTodyzvGneQDo6g86HInMZEoSiTikpqVXK5tJTJYWZXFAK5yJiIhIEqnvCFDsT8Pj1lvNRFPhaokHvXJFHNDRN0h73xALVLRaYlBZlEn3QJCGzoDToYiIiIgAkelmqkfkjCwVrpY4UJJIxAGvVjcDcPH8XIcjkZlsTUUeAJt3NTgciYiIiEhEXUc/81SPyBEpHhc+r1sjiSQmShKJOGDzrgaK/WlKEklMzi/xs6Y8l8feOkoorClnIiIi4qxgKExjV0BFqx2U7fOqcLXEREkikQTrGQjy6oFmNqwoxuUyTocjM9ymdRUca+vj1eomp0MRERGRc1xjV4BQ2Gq6mYP8Po8KV0tMlCQSSbCX9zcxGAxz8wUlTocis8CGFcUU+VN55M0ap0MRERGRc1x9R6ROYqlGEjkm2+fVdDOJiZJEIgm2eWcDc7JSWVOuqWYSO6/bxScuLee377dwsKnH6XBERETkHFbX0QegkUQO8qdpupnERkkikQTqHQjySnUTN2mqmcTRxy+dT4rbxWNv1TgdioiIiJzD6tr7AY0kcpJfI4kkRkoSiSTQK9VNDATD3KSpZhJHBZmp3HphCU9W1dKtT45ERETEIXUd/eRnpJDmdTsdyjkr2+elS0kiiYGSRCIJtHlXAwWZqVwSXbpcJF42raugdzDEz6pqnQ5FREREzlG17f2aauYwf5qH7oEgYa18K2dJSSKRBOkbDPLK/mY2rCjCralmEmcry3K4aH4Oj75Zo5sCERERcUR9R7+mmjnM7/NiLXQPaIUzOTtxSRIZYzYYY6qNMQeNMfeP8bwxxnw3+vxOY8zF8TivyEzyanUz/UMhrWom0+budRXUtPbx2vvNTociIiIi5xhrLXVKEjnO7/MCaMqZnLWYk0TGGDfwA+AmYBnwcWPMslN2uwlYEv26D3gw1vOKzDTP7WogPyOFtZpqJtPkphUlFGal8uibNU6HIiIiIueYtt5BAkNh5ipJ5Ch/WiRJpOLVcrbiMZJoLXDQWnvYWjsIPAFsPGWfjcBjNuJtIMcYo+EUcs7oHwzxyv4mblxRjMetWZ4yPVI8Lv7w0vm8Wt3MkZZep8MRERGZtGAoTH1HPy09A5o2PUPVdURXNlNNIkdlD48k0mImcpY8cThGKXB81ONa4NJJ7FMKNJzpwI2dAb75/L44hDgxr8vFHReXsrAwMyHnk3PLawea6BsMcYummsk0u+vS+fzglYN8+amdrCzLOek5lzGsKc/lyiUFpHq06oiMr2cgyFPbakdu+GerBfkZ3Li8mNyMlLgcbygU5o2DLext6OKqxYWsKPVjzNg16Ky17Kjt5NXqJvqHQnE5/6mWlfi5beXccWOQmWUgGOKJd49T3zk7XpcDQ2EaOwM0dAVo7OynuXuA4dxQittFUXYqJX4fxdlpzMlKxe1OXDv2ulxcsbiAtQvyVEdyCurao0kijSRylN8XeYuv6WbO2tfQxS921BOyk0t6u42hJDuN+fkZlOelU5rrwzvB4IKBYIjjbf0ca+vlaGsfJ7oGsMSeZI9HkmisnvPUyCazT2RHY+4jMiWN1OLFPPJGTUzBTdZQKMxDrx/mcx9axGevWaQ3UBJXm3c1kpeRwqULNNVMptecrDQ+cVk5P3nnGO8d6zjpuVDY8mDYkpXm4YZlxdx6YQlXLC4gxaPRbRLR0jPAI2/U8NhbNXQFgqR4XGNewGcDa2EwFOaBn+/misUF3HpBCTcsLyInfWoJo6FQmLcOtfLczgZ+tadxZHj/t6lmfl46t1xYwi0XlLB8rh+A3XVd/HJXPc/tbKC2vR+XYcKbwFj+vh+/c4xvfHgFi+dkxf0ckjhvH27lK0/v4nBz76x5Xaa4XRRnp1GcncbSokKKs30U+9MYCoVp6Iwkjho6A+yo7aCpa4DwJN9oxUMwbPn+KwcpyEzl5guKueWCEi6pyMOlhNEZDX+wME8jiRw1MpKoX4WrndA3GORffv0+//67IwB4JtlvhMKW4KhRlC4Dc3N8FGalntbnhy2c6ArQ2BVgdNfodRtccfhgyNgYO1xjzOXA16y1N0YffxnAWvvNUfv8K/Cqtfbx6ONq4Bpr7RlHEq1Zs8Zu3bo1pvgmq6k7wN/9ch/P7qhnYWEGf3/7BVy+KD8h55bZLTAUYvXfvsRtq+byzTsudDocOYcNBsO8caiF53Y28MKeRroDQbJ9Xq6uLGRBQQZleemU5fooy0unyJ+mT0/PIcda+3jot4f4n621DIbC3LismM9cs4hVp4xGm02steyp7+K5XQ08t7OBY219eFyGyxflkzvJRNFQKMzbh1tp7xsiM9XD9cuKuOWCEi6cl82r1c38clcDbxxsIRS2LCjIIBS2I+e5ckkBt144l+uXFY3c0MdTOGz56dbjfPP5/fQNBrlv/UK+8KEl+FL0IdhM0tY7yDc27+NnVbWU5fn4240ruGbpHKfDmvWGV6R9blc9L+9vIjAUZk5WKldXFlKen05ZXjrzctMpy/NRmJk6K0frDQYj/dvL+5uASOIncp8Q+buz0k7vt77+iz38dMtxdn/9xln5bzJTdAWGuPBrL/J/bjmfP7lqodPhnFN+s+8Ef/3MHuo6+rnzkjLuv+m8SX/4FA5bmnsGONrax9HWXo639XG0rY+23sEx9y/MSmV+Xjrl+enMz8ugPD+d/IyUKb32jDFV1to1p22PQ5LIAxwArgXqgC3AXdbaPaP2uQX4AnAzkalo37XWrp3o2IlMEg17/UAz/+fnuznW1sdHLp7HX920lPyM1DO+WbLWMhSyhMIWj9vgcZkpd4zWWgZDYULjzMF2GUOqx3XG44bDpx/j1KOd+v99+vNneJJIzZMUj0tvHqfghT2NfPo/q3js3rWsryx0OhwRIDI89Y2DLfxyZwNvHmzlRPfpn0QsKMjg/BL/qK8s5mSlORf0NLI28unNUCic8HN7XC687rO7bgyFLMHw6TFbG3lzeai5h4NNPRxq7uVQcw81Lb0MjvE3dvUP4YlOu/7U+oUsOsemXltrR0b4vFbdzEBwcu3AACtKs7n1whLWVxaS5j09AdPWO8iLexrZvLsRA9xyliOWzlZrzwDf2LyfJ7dFkgxfv205q+fnffAHAMNNb7gFDrdFA7hdE99/yMSG79EmOxrGWti8q4FvbN5HdyDIp9Yv5Iu/pySfE3oHgvxmfxPP7ayn6mgHLT0DJz2f6nFN6f8lLyOF80v8LIt+nV/ip8g/uURTKGwZDEba0XBLGr63/+Dx8A9gsbT0DHK4uYfDLb0caop8r23vY26Ob+T6vqwki/OK/VjgtepmXtzbyMv7m+gOBEnzuvC4XPScspx6VqrntCmAfQMhyvPTeenPr570v4fEXzhsWfzAZj7/ocX87xuWOh1OzM72Hu1s76+GX2eDo+8FRl0vx7pWDif0n9/dyJI5mXzjjgu4ZAYsVjRtSaLowW8G/hlwAw9ba//eGPMZAGvtD03kX/D7wAagD7jHWjth9seJJBFERn58/+WD/OvrhxgKRf593C5DijvS0FI87khSJxhmIBRmKBQ+6c2VMZEhtCkeFynuSELl1LZpbeQTyKFQtBFOstF73dE4PC68bhdDoUgDHj5WonjdhlSPmxSPK5oUS9ipWTE3m3/ftCbpblhfO9DMV5/ZfVptiZ5AEK/HxZYHrpuWKQUi8TAQDFHfEeB4Wx/H2/s41tbH+yd62NfQRUNnYGS/nHQvqbNgepq10ZuAaB86eEo/7oTha8Z4/aq1kSkQQ+Nce84kN93L4jmZLCjIwDdGIiMvI5U715ZR5J+dSUCBtw618sDPI9OVzsbw/UdK9P5jui7B916xgE9fvWh6Dn6Kv/zZDl470Dwtxw5bRu7PBoPhk6YQTMXq8ly+8eELWFqs6YLJon8wRG175Fp5vK2f2va+k99MnoEFGjoD7Gvoorb9g9pS/jTPmImmUBgGg6GRa1Ws9bwLMlNZWJjBvFwfte397GvoojsQSf4YE5kWMxSy5GWkcN35c7hhWXG0jqGLjr6hkb/5eHsfjZ2B0z58BrhqSSHXLSuKLVCJ2cqvv8jtq+by9Y0rJv07P6uq5R9fqI5LTZtYjNyjncX9zlhG3pef4f4qFLYMBMMMBENn/Z461ePii9cu4VNXLZwxpRymNUk0XZxKEg072NTNr/c1MTAUvchHO+iBYBi3K1JDIMXjItU9PLrGRXDUfsPfxxsd5B11s5XicZEaHaEz1n1XMPxBMmlo+HvInnbTNlbjP/WIE93YjU6+jN7VEklsDQxFXkDDL6RgApNTTd0DvLy/iZ986lLWLSpI2Hkn8t6xdu76t3cozfWxpjz3tOeHpxWIzETtvYPsa+xiX0M3h5t7xu3TZhq3y+B1R/re4QSNN8G1PiyRFX1GboSClsHQ+P2qx21Ou/Z43GPH7Pd5WVSYyeI5meTFqTCzzGwDwRC/2NFAV//QaaMQGHnMyBuE4cTk6Hua4aTHdNhR20ldex9vf+Va0lPiUTZzfAeburnuO69z+cJ8yvPT43780R8Yeke9QXFPIbtWmuvj5hUlqoMzS3UFhtjf0M2+hi4ONvWMOUrCRGcSjFyjRt5zRJ+P9v6nNqvRIxyyfV4WRT8kOHVqq7WWuo5+9kXj6BsM8XvnzWF1ea5mDcxwV337ZVbPz+Wf77xo0r9z6/d+S3vvEFctcf49lttlRvrNie53xjJyfxX6YFTQRPdXqR43qR5X5Ls3+oEIjHm9HP5x+HrpMoYblhUzfxquJ9NpvCTR9F6BZ7jFc7JU6DHJBIZCXP7N3/DYm0eTJkl0qLmHex/Zwhx/Ko9/6jIKs1KdDkkkrnIzUli3qCBpXnMicnZSPW4+unqe02GMa2tNGx/94Vv8/L167rp0/rSe67G3jpLidvH9uy4iP1PXbUk8f5qXtQvyWOvgoibGGOblRuorXa/RP7NKts9LV2DyhauPt/Wxu66Lr9x8HvetT8xoTkleM2MclEhUmtfNH1wynxf3NibF0swnugJ88j/exe0yPHbvWiWIREREztLq8lyWlfh57K2aMaexxEt3YIgnq2q5dWWJEkQiMiv507x0RVfbnIxf7W4EYMPykukKSWYQJYlkxvnEZZFPF3/yzlFH4+jsH2LTw+/S0TfII/espTw/w9F4REREZjJjDHevq2B/YzfvHGmbtvM8WVVL72CIu9dVTNs5RESclO3z0jmVJNGeRpaV+GfcdCmZHkoSyYwzLzed684v4vF3jxM4pUh0ogSGQnzqsa0cau7hX/9oDStKsx2JQ0REZDa5bdVcctK9PPZWzbQcPxy2PPbWUVaV5XDhvJxpOYeIiNP8aV66ApNLEp3oClB1tJ2bVhRPc1QyUyhJJDPSpnUVtPUO8tzOhoSfeyAY4ouPv8e7R9r4p4+t4sokKO4mIiIyG6R53fzBmjJe2HOChs74Tyt/41ALh1t62bSuPO7HFhFJFn6fZ9IjiV7YE5lqdtMFShJJhJJEMiOtW5TPosKMafukcTzDU8xe3HuCr9+2nNtWasUyERGRePrEZeWEreUn7xyL+7EfffMoBZkp3HyB6m6IyOyV7fMSiK5IPZHndzWyeE6mFmySEUoSyYxkjGHTugp21Hay/XhHQs5Z39HPx374FlVH2/mXO1exSbUMRERE4q4sL51rzyvi8XePTeoNzmQdb+vjN/tP8PG180n1uON2XBGRZOP3eQHonmCFs7beQd450sqG5RpFJB9QkkhmrDsunkdmqofH3qyZ9nPtb+zijv/3JvUd/abFm5EAAA6wSURBVDx6z1o2riqd9nOKiIicqzatK6elZ5DNu+I3rfy/3j6KyxjuunR+3I4pIpKMsqNJoommnL20t5GwhQ2qRySjKEkkM1ZmqoePrp7HL3c20NIzMG3nefNgC//rwbcA+OlnLmfdYtUgEhERmU5XLCpgYWEGj74Zn5VM+wdDPLHlODcuL6Ik2xeXY4qIJCt/WiRJ1DVBkuj53Y2U5flYPtefiLBkhlCSSGa0T1xWzmAozBPvxr9uQU1LL//4QjWbfvQuJTlpPPW5dZxfog5URERkurlchk9eVs724x3sOGVa+f7GLr6xeR9ffmonbx5qIRy2Ex7vFzvq6ewf4pOXV0xTxCIiycPv8wBnHknUFRjijYMtbFhejDEmUaHJDOBxOgCRWCyek8lVSwr4r7eP8ZmrF+Fxx5b37AoM8dzOBp6sqmXr0XaMgRuWFfHtj64cGbYpIiIi0+8jq+fxDy9U8+hbNTyQez7PbK/nyW217KnvwuMypHpcPP7ucUpzfNxxcSkfuXgeFQUZpx3HWssjb9ZwXnEWly7IS/wfIiKSYMPvW7rOUJPo5X1NDIUsG1aokL+cTEkimfE2XV7Bnzy2lRf3njjr1UqGQmH++pndPLWtjoFgmEWFGfzVhvP48EWlFGenxTliERERmUhWmpePrJ7Hj985xrPb6wmGLStK/Xz195dx28q5pKd4eHFvIz+rquX7rxzkey8fZHV5LuV56ScdJxAMsbehi298+AJ9Wi4i54TJTDd7fncDRf5ULirLSVRYMkMoSSQz3ofOm8OcrFSe29Vw1kmiLUfaePzd49y+ai53X7GAlfOydSMpIiLisD++cgE7aju5dEEeH7l4HkuLT16ieeOqUjauKqWxM8DT79Xxy531bDnadtpxVpfncvtFcxMVtoiIo/wTFK7uGwzy2oFmPramDJdL73nkZEoSyYzndhnWVxby0t4TBEPhs5pyVnW0HYCvb1yhaWUiIiJJojw/g2c+f8WE+xVnp/HZaxbx2WsWJSAqEZHkluZ1k+Jx0RUYO0n0WnUzgaGwVjWTMalwtcwKV1cW0tk/xI7azrP6/apj7VQWZSpBJCIiIiIiM54/zTvudLPndzeSl5HC2grVaZPTKUkks8KViwtwGXj9QPOUfzcctmw72s7q8txpiExERERERCSxsn0euvpPL1w9EAzx8v4mrj+/KOZFf2R2UquQWSE3I4UL5+Xw2lkkiQ4199AVCHLxfCWJRERERERk5vP7vGPWJHqtupmegSA3XaCpZjI2JYlk1ri6spCdtR209w5O6feG6xFpJJGIiIiIiMwG2T7vmDWJntlRT35GClcsLnAgKpkJlCSSWWN9ZSFhC7872DKl36s62k5uupcFBRnTFJmIiIiIiEjijFWTqGcgyK/3nuCWC0vwaqqZjEMtQ2aNlfOyyfZ5p1yXqOpYpB6RlrwXEREREZHZIHuM6WYv7mlkIBjmtpVzHYpKZoKYkkTGmDxjzEvGmPej38ecr2OMqTHG7DLGbDfGbI3lnCLj8bhdXLm4gNffb8ZaO6nfaesd5HBzLxdrqpmIiIiIiMwSfp+HrkDwpPdFz2yvpzTHp1qsckaxjiS6H/iNtXYJ8Jvo4/F8yFq7ylq7JsZziozr6spCTnQNUH2ie1L7v3csWo9IHaWIiIiIiMwS/jQvobCldzAEQGvPAL872MJtq+bicmkGhYwv1iTRRuDR6M+PArfHeDyRmKyvLAQiVfsno+poOx6X4cJ5OdMZloiIiIiISMJk+7wAI3WJNu9qIBS2bFylqWZyZrEmiYqstQ0A0e9zxtnPAi8aY6qMMffFeE6RcRVnp7G0KIvXJlmXqOpoO8tLs/GluKc5MhERERERkcTwDyeJoiucPbO9nqVFWZxX7HcyLJkBJkwSGWN+bYzZPcbXximc5wpr7cXATcDnjTHrz3C++4wxW40xW5ubp1aAWATg6qWFbK1pp3cgeMb9hkJhdtR2aKqZiIiIiIjMKsMjiTr7hjje1sfWo+3cplFEMgkTJomstddZa1eM8fUMcMIYUwIQ/d40zjHqo9+bgKeBtWc430PW2jXW2jWFhYVn8zfJOW79kkIGQ2HePtx6xv321ncRGAqzWkWrRURERERkFvGnDY8kCvKLnfUAWtVMJiXW6WbPApuiP28Cnjl1B2NMhjEma/hn4AZgd4znFRnXmopcfF43r08w5azqaKRo9cXlqkckIiIiIiKzh9/nAaCzf4hnt9ezujyXsrx0h6OSmSDWJNG3gOuNMe8D10cfY4yZa4zZHN2nCPidMWYH8C7wnLX2VzGeV2RcaV43ly3Mm7AuUdWxdkpzfJRk+xIUmYiIiIiIyPQbnm625Ugb+xu7VbBaJs0Tyy9ba1uBa8fYXg/cHP35MLAylvOITNXVlYW8Ut3M0dZeyvMzxtxn29F21lTkJTgyERERERGR6ZUVnW72zI463C7DzReUOByRzBSxjiQSSUpXL40stDfelLP6jn4aOgOsnq+pZiIiIiIiMru4XYasVA+BoTBXLi6gIDPV6ZBkhlCSSGalivx0yvJ84045G65HtLpcI4lERERERGT28UennGmqmUyFkkQyKxljuLqykDcPtdIdGDrt+aqj7fi8bs4ryXIgOhERERERkemVleYh1ePihuXFTociM4iSRDJrbVxVykAwzEcffIvjbX0nPbftWDsry7LxuvUSEBERERGR2eeapXO454oFZKbGVIpYzjF6hyyz1iUVeTxyzyU0dPZz+w/eYGtNGwB9g0H21HexujzX4QhFRERERESmx/03ncf9N53ndBgywyhJJLPaVUsKefrzV+D3ebnr397hyapadtZ2EgpbJYlERERERERERtG4M5n1FhVm8vTn1vG5H2/jf//PDiqLMgG4qExJIhEREREREZFhGkkk54Sc9BQevXctf3jpfA6c6GFRYQa5GSlOhyUiIiIiIiKSNDSSSM4ZXreLv7t9BWsX5JGbrgSRiIiIiIiIyGhKEsk5xRjDxlWlTochIiIiIiIiknQ03UxERERERERERJQkEhERERERERERJYlERERERERERAQw1lqnYxiXMaYbqHY6DpkxCoAWp4OQGUPtRaZC7UWmQu1FpkptRqZC7UWmQu1FxlNurS08dWOyF66uttaucToImRmMMVvVXmSy1F5kKtReZCrUXmSq1GZkKtReZCrUXmSqNN1MRERERERERESUJBIRERERERERkeRPEj3kdAAyo6i9yFSovchUqL3IVKi9yFSpzchUqL3IVKi9yJQkdeFqERERERERERFJjGQfSSQiIiIiIiIiIgmQlEkiY8wGY0y1MeagMeZ+p+OR5GKMKTPGvGKM2WeM2WOM+VJ0+9eMMXXGmO3Rr5udjlWSgzGmxhizK9outka35RljXjLGvB/9nut0nJIcjDFLR/Uj240xXcaYP1UfI8OMMQ8bY5qMMbtHbRu3TzHGfDl6T1NtjLnRmajFKeO0l38wxuw3xuw0xjxtjMmJbq8wxvSP6md+6Fzk4oRx2su41x/1LzJOm/nvUe2lxhizPbpdfYxMKOmmmxlj3MAB4HqgFtgCfNxau9fRwCRpGGNKgBJr7TZjTBZQBdwOfAzosdb+o6MBStIxxtQAa6y1LaO2fRtos9Z+K5qMzrXW/pVTMUpyil6T6oBLgXtQHyOAMWY90AM8Zq1dEd02Zp9ijFkGPA6sBeYCvwYqrbUhh8KXBBunvdwAvGytDRpj/i9AtL1UAL8c3k/OPeO0l68xxvVH/YvA2G3mlOf/Cei01v6N+hiZjGQcSbQWOGitPWytHQSeADY6HJMkEWttg7V2W/TnbmAfUOpsVDIDbQQejf78KJFEo8iprgUOWWuPOh2IJA9r7etA2ymbx+tTNgJPWGsHrLVHgINE7nXkHDFWe7HWvmitDUYfvg3MS3hgkpTG6V/Go/5FzthmjDGGyAfpjyc0KJnRkjFJVAocH/W4FiUAZBzRbPhFwDvRTV+IDt1+WNOHZBQLvGiMqTLG3BfdVmStbYBI4hGY41h0kszu5OQbK/UxMp7x+hTd18hE7gWeH/V4gTHmPWPMa8aYq5wKSpLOWNcf9S8ykauAE9ba90dtUx8jZ5SMSSIzxrbkmhMnScEYkwk8CfyptbYLeBBYBKwCGoB/cjA8SS5XWGsvBm4CPh8dlityRsaYFOA24H+im9THyNnQfY2MyxjzABAEfhzd1ADMt9ZeBPw58BNjjN+p+CRpjHf9Uf8iE/k4J3/YpT5GJpSMSaJaoGzU43lAvUOxSJIyxniJJIh+bK19CsBae8JaG7LWhoF/Q8NtJcpaWx/93gQ8TaRtnIjWtxquc9XkXISSpG4CtllrT4D6GJnQeH2K7mtkTMaYTcCtwB/aaJHQ6LSh1ujPVcAhoNK5KCUZnOH6o/5FxmWM8QB3AP89vE19jExGMiaJtgBLjDELop/i3gk863BMkkSic2v/A9hnrf3OqO0lo3b7MLD71N+Vc48xJiNa4BxjTAZwA5G28SywKbrbJuAZZyKUJHbSp2/qY2QC4/UpzwJ3GmNSjTELgCXAuw7EJ0nEGLMB+CvgNmtt36jthdGC+RhjFhJpL4ediVKSxRmuP+pf5EyuA/Zba2uHN6iPkcnwOB3AqaKrPHwBeAFwAw9ba/c4HJYklyuAPwJ2DS/nCHwF+LgxZhWRYbY1wKedCU+STBHwdCS3iAf4ibX2V8aYLcBPjTF/DBwD/peDMUqSMcakE1llc3Q/8m31MQJgjHkcuAYoMMbUAl8FvsUYfYq1do8x5qfAXiLTij6vlYfOLeO0ly8DqcBL0evT29bazwDrgb8xxgSBEPAZa+1kixjLLDBOe7lmrOuP+heBsduMtfY/OL2uIqiPkUkw0dGtIiIiIiIiIiJyDkvG6WYiIiIiIiIiIpJgShKJiIiIiIiIiIiSRCIiIiIiIiIioiSRiIiIiIiIiIigJJGIiIiIiIiIiKAkkYiIiIiIiIiIoCSRiIiIiIiIiIigJJGIiIiIiIiIiAD/H58+ndrUEtyvAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -2863,7 +2740,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2878,17 +2755,15 @@ "output_type": "stream", "text": [ "tal hits:\n", - "MotifHitAndCoord(motif_idx=0, motif_score=0.7407143227403524, precision_at_motif_score=0.5, example_idx=19, start=21, end=46, is_revcomp=False)\n", - "MotifHitAndCoord(motif_idx=0, motif_score=0.999585467994209, precision_at_motif_score=1.0, example_idx=19, start=75, end=100, is_revcomp=False)\n", - "MotifHitAndCoord(motif_idx=0, motif_score=0.6763298538561408, precision_at_motif_score=0.3772269950506758, example_idx=19, start=84, end=109, is_revcomp=True)\n", + "MotifHitAndCoord(motif_idx=0, motif_score=0.8531186336326444, precision_at_motif_score=1.0, example_idx=19, start=37, end=62, is_revcomp=False)\n", "gata hits:\n", - "MotifHitAndCoord(motif_idx=1, motif_score=0.9955978570801688, precision_at_motif_score=1.0, example_idx=19, start=22, end=47, is_revcomp=False)\n", - "MotifHitAndCoord(motif_idx=1, motif_score=0.9927436977742843, precision_at_motif_score=1.0, example_idx=19, start=160, end=185, is_revcomp=False)\n" + "MotifHitAndCoord(motif_idx=1, motif_score=0.9126089200188778, precision_at_motif_score=1.0, example_idx=19, start=50, end=75, is_revcomp=False)\n", + "MotifHitAndCoord(motif_idx=1, motif_score=0.9993329703323126, precision_at_motif_score=1.0, example_idx=19, start=162, end=187, is_revcomp=False)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2900,6 +2775,7 @@ } ], "source": [ + "from modisco.visualization import viz_sequence\n", "reload(modisco.visualization.viz_sequence)\n", "reload(modisco.visualization)\n", "from matplotlib import pyplot as plt\n", diff --git a/modisco.egg-info/SOURCES.txt b/modisco.egg-info/SOURCES.txt index 7fd3695..1749fb4 100644 --- a/modisco.egg-info/SOURCES.txt +++ b/modisco.egg-info/SOURCES.txt @@ -38,6 +38,7 @@ modisco/cluster/phenograph/louvain/osx-hierarchy modisco/clusterinit/__init__.py modisco/clusterinit/memeinit.py modisco/hit_scoring/__init__.py +modisco/hit_scoring/exemplar_based_hitscoring.py modisco/hit_scoring/fast_hit_scoring.py modisco/seqlet_embedding/__init__.py modisco/seqlet_embedding/advanced_gapped_kmer.py diff --git a/modisco/affinitymat/core.py b/modisco/affinitymat/core.py index 3724595..36f9955 100644 --- a/modisco/affinitymat/core.py +++ b/modisco/affinitymat/core.py @@ -1,5 +1,4 @@ from __future__ import division, print_function, absolute_import -from .. import backend as B import numpy as np from .. import util as modiscoutil from .. import core as modiscocore @@ -629,6 +628,7 @@ def __init__(self, batch_size=50, func_params_size=1000000, self.progress_update = progress_update def __call__(self, filters, things_to_scan, min_overlap): + from .. import backend as B return B.max_cross_corrs( filters=filters, things_to_scan=things_to_scan, diff --git a/modisco/coordproducers.py b/modisco/coordproducers.py index fdcb165..3d2ab0b 100644 --- a/modisco/coordproducers.py +++ b/modisco/coordproducers.py @@ -4,7 +4,6 @@ import numpy as np from collections import defaultdict, Counter, OrderedDict import itertools -from sklearn.neighbors.kde import KernelDensity import sys import time from .value_provider import ( diff --git a/modisco/seqlet_embedding/__init__.py b/modisco/seqlet_embedding/__init__.py index 7215580..1a1224b 100644 --- a/modisco/seqlet_embedding/__init__.py +++ b/modisco/seqlet_embedding/__init__.py @@ -1,3 +1,3 @@ -from . import gapped_kmer +#from . import gapped_kmer #don't want to auto-import tensorflow from . import advanced_gapped_kmer from . import onehot_model_output diff --git a/modisco/seqlet_embedding/advanced_gapped_kmer.py b/modisco/seqlet_embedding/advanced_gapped_kmer.py index 6eec6dd..63d0dd1 100644 --- a/modisco/seqlet_embedding/advanced_gapped_kmer.py +++ b/modisco/seqlet_embedding/advanced_gapped_kmer.py @@ -1,6 +1,5 @@ from __future__ import division, print_function, absolute_import from ..affinitymat.core import MeanNormalizer -from .. import backend as B from .core import (AbstractSeqletsToOnedEmbedder, AbstractSeqletsToOnedEmbedderFactory) from .. import core as modiscocore diff --git a/modisco/tfmodisco_workflow/seqlets_to_patterns.py b/modisco/tfmodisco_workflow/seqlets_to_patterns.py index f9fdc62..1adce02 100644 --- a/modisco/tfmodisco_workflow/seqlets_to_patterns.py +++ b/modisco/tfmodisco_workflow/seqlets_to_patterns.py @@ -64,6 +64,7 @@ def new_constructor(*args, **kwargs): assert 'embedder_factory' not in kwargs,\ ("Cannot both specify embedder_factory and " +str(gapped_kmer_kwargs)) + from modisco.seqlet_embedding import gapped_kmer kwargs['embedder_factory'] = ( seqlet_embedding.gapped_kmer .GappedKmerEmbedderFactory(**gapped_kmer_kwargs)) @@ -85,8 +86,8 @@ def __init__(self, n_cores=4, initclusterer_factory=None, embedder_factory=( - seqlet_embedding.gapped_kmer - .GappedKmerEmbedderFactory()), + seqlet_embedding.advanced_gapped_kmer + .AdvancedGappedKmerEmbedderFactory()), nn_n_jobs=4, nearest_neighbors_to_compute=500, @@ -95,15 +96,15 @@ def __init__(self, n_cores=4, filter_beyond_first_round=False, skip_fine_grained=False, - tsne_perplexity = 10, + tsne_perplexity=10, use_louvain=False, louvain_initclusters_weight=1.0, n_leiden_iterations_r1=-1, n_leiden_iterations_r2=-1, louvain_num_runs_and_levels_r1=[(200,-1)], louvain_num_runs_and_levels_r2=[(200,-1)], - contin_runs_r1 = 50, - contin_runs_r2 = 50, + contin_runs_r1=50, + contin_runs_r2=50, final_louvain_level_to_return=1, frac_support_to_trim_to=0.2, diff --git a/test/test_tfmodisco_workflow.py b/test/test_tfmodisco_workflow.py index f8b197f..dd6ee54 100644 --- a/test/test_tfmodisco_workflow.py +++ b/test/test_tfmodisco_workflow.py @@ -97,7 +97,7 @@ def setUp(self): self.task_to_scores = task_to_scores self.task_to_hyp_scores = task_to_hyp_scores - #@skip + skip def test_base_workflow(self): onehot_data = self.onehot_data @@ -129,7 +129,7 @@ def test_base_workflow(self): null_per_pos_scores = null_per_pos_scores, plot_save_dir="plot_save_directory")) - #@skip + skip def test_memeinit_workflow(self): onehot_data = self.onehot_data @@ -166,7 +166,7 @@ def test_memeinit_workflow(self): null_per_pos_scores = null_per_pos_scores, plot_save_dir="plot_save_directory")) - #@skip + skip def test_norevcomp_memeinit_workflow(self): onehot_data = self.onehot_data @@ -204,6 +204,7 @@ def test_norevcomp_memeinit_workflow(self): plot_save_dir="plot_save_directory", revcomp=False)) + @skip def test_varseqlen_agkm_workflow(self): onehot_data = self.onehot_data From aeb0a20e7133c26e501e1c5418bde83665df617e Mon Sep 17 00:00:00 2001 From: Avanti Shrikumar Date: Mon, 28 Dec 2020 05:19:54 -0800 Subject: [PATCH 29/30] switching default embedder, avoiding default tensorflow import --- test/test_tfmodisco_workflow.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/test/test_tfmodisco_workflow.py b/test/test_tfmodisco_workflow.py index dd6ee54..6325c72 100644 --- a/test/test_tfmodisco_workflow.py +++ b/test/test_tfmodisco_workflow.py @@ -97,7 +97,7 @@ def setUp(self): self.task_to_scores = task_to_scores self.task_to_hyp_scores = task_to_hyp_scores - skip + #@skip def test_base_workflow(self): onehot_data = self.onehot_data @@ -129,7 +129,7 @@ def test_base_workflow(self): null_per_pos_scores = null_per_pos_scores, plot_save_dir="plot_save_directory")) - skip + #@skip def test_memeinit_workflow(self): onehot_data = self.onehot_data @@ -166,7 +166,7 @@ def test_memeinit_workflow(self): null_per_pos_scores = null_per_pos_scores, plot_save_dir="plot_save_directory")) - skip + #@skip def test_norevcomp_memeinit_workflow(self): onehot_data = self.onehot_data @@ -204,7 +204,7 @@ def test_norevcomp_memeinit_workflow(self): plot_save_dir="plot_save_directory", revcomp=False)) - @skip + #@skip def test_varseqlen_agkm_workflow(self): onehot_data = self.onehot_data From e6680302270d94cfdf67c9d07a9e3971ecea76ea Mon Sep 17 00:00:00 2001 From: Av Shrikumar Date: Thu, 7 Jan 2021 18:36:47 -0800 Subject: [PATCH 30/30] Avoid crash when self.total_time_taken is None? --- modisco/tfmodisco_workflow/seqlets_to_patterns.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modisco/tfmodisco_workflow/seqlets_to_patterns.py b/modisco/tfmodisco_workflow/seqlets_to_patterns.py index 1adce02..e6c3c54 100644 --- a/modisco/tfmodisco_workflow/seqlets_to_patterns.py +++ b/modisco/tfmodisco_workflow/seqlets_to_patterns.py @@ -594,8 +594,8 @@ def from_hdf5(cls, grp, track_set): def save_hdf5(self, grp): grp.attrs["success"] = self.success - grp.attrs["total_time_taken"] = self.total_time_taken if (self.success): + grp.attrs["total_time_taken"] = self.total_time_taken if (self.each_round_initcluster_motifs is not None): self.save_each_round_initcluster_motifs( grp=grp.create_group("each_round_initcluster_motifs"))