From 2c93b054c37509377d51ce7b44519cdac581f5bd Mon Sep 17 00:00:00 2001 From: Connor Wagaman <43150981+cwagaman@users.noreply.github.com> Date: Tue, 14 Jun 2022 14:38:56 -0400 Subject: [PATCH 1/2] new simulation (and visualization) for finding funniest caption --- .../simulation-finding-funniest.py | 427 ++++++++++++++++++ .../visualization-finding-funniest.ipynb | 168 +++++++ 2 files changed, 595 insertions(+) create mode 100644 docs/example-analyses/simulation-finding-funniest.py create mode 100644 docs/example-analyses/visualization-finding-funniest.ipynb diff --git a/docs/example-analyses/simulation-finding-funniest.py b/docs/example-analyses/simulation-finding-funniest.py new file mode 100644 index 0000000..64f7989 --- /dev/null +++ b/docs/example-analyses/simulation-finding-funniest.py @@ -0,0 +1,427 @@ +import numpy as np +from typing import List, Dict, Any + +# R is half of the range of possible values. Here, it's (3-1)/2 = 2/2 = 1. +R = 1.0 + +# delta is the failure probability -- i.e. set delta = 0.05 for 1-delta = 95% success probability. +delta = 0.05 + +# ------------------- DEFINE CLASSES FOR DIFFERENT SAMPLERS ------------------- + +class Random: + def __init__(self, n:int): + """ + Parameters + ---------- + - n:int, number of targets (captions/videos/etc) + + Vars in function + ---------------- + - self._initialized tracks whether some lists, other variables have been created yet + - self.name gives the model a name for purposes of tracking simulation results, + in case we want to plot simulation results for multiple models + """ + self.n = n + self.name = self.model_name() + " " + str(n) + self._initialized = False + + def model_name(self): + return "Random" + + def get_queries(self, n_queries=100): + """ + Parameters + ---------- + n_queries: int + Number of queries to queue up for a user + + Returns + ------- + indices:List[int], len(indices) = n + uniformly random permutation of values from 0 to "number of targets - 1" (i.e. n-1) + scores:List[float], len(scores) = n + List of n scores (where the score at index i corresponds to caption i) between 0 and 1. + Represents quality of the query that can be posed to the user. + Note that, for class Random, scores are just assigned randomly, so they don't really represent quality here. + """ + indices = np.arange(self.n).astype(int) + scores = np.random.uniform(0, 1, size=len(indices)) + + return indices, scores + + def _initialize(self): + """ + Initializes lists for storing info about user ratings of captions. + Index i of self._reward_ stores the sum of user-provided ratings for caption i. + Index i of self._reward_squared_ stores the sum of the squares of user-provided ratings for caption i. + Index i of self._hits_ stores the number of times users have rated caption i. + Set self._initialized = True so this initialization does not overwrite things every time. + Index i of self.emp_avg_ratings_ stores the average user-provided rating for caption i. + Index i of self.ucbs_ stores the distance from caption i to its upper (lower) "delta"-width confidence bound. + """ + self._reward_ = np.zeros(self.n) + self._reward_squared_ = np.zeros(self.n) + self._hits_ = np.zeros(self.n) + self.emp_avg_ratings_ = self._reward_ / np.maximum(self._hits_, 1) + self.ucbs_ = self.calculate_ucbs(self._hits_,self.emp_avg_ratings_,np.arange(self.n),np.zeros(self.n)) + self.cis_ = self.calculate_95_ci(self._reward_squared_, self.emp_avg_ratings_, self._hits_) + self._initialized = True + + def partial_fit(self, answers:List[Dict[str, int]]): + """ + Parameters + ---------- + answers:List[Dict[str, int]] + A list of user-provided ratings of captions; each dict stores a single rating. + Format of each dictionary is {"index": caption index, "rating": 1 <= rating <= 3}. + + Returns + ------- + self, which is the model + self.emp_avg_ratings_ is a list of ratings, where index i contains the average rating for caption i + self.ucbs_ is a list of numbers related to confidence intervals, where index i contains self.ucbs_, + where self.emp_avg_ratings_ \pm self.ucbs_ is the "delta" CI for the rating for caption i + """ + if not self._initialized: + self._initialize() + for answer in answers: + self._reward_[answer["index"]] += answer["rating"] + self._reward_squared_[answer["index"]] += answer["rating"]**2 + self._hits_[answer["index"]] += 1 + self.emp_avg_ratings_ = self._reward_ / np.maximum(self._hits_, 1) + answer_indices = [answer["index"] for answer in answers] + self.ucbs_ = self.calculate_ucbs(self._hits_, self.emp_avg_ratings_, answer_indices, self.ucbs_) + self.cis_ = self.calculate_95_ci(self._reward_squared_, self.emp_avg_ratings_, self._hits_) + + return self + + def calculate_ucbs(self, num_hits:List[int], emp_avg_ratings, answer_indices:List[int], old_ucbs:List[float]): + """ + Parameters + ---------- + num_hits:List[int] + A list of the number of user-provided ratings for a caption, where index i contains the + number of user-provided ratings received for caption i. + emp_avg_ratings + A list of average user-provided ratings, where index i contains the average rating for caption i. + answer_indices:List[int] + List of caption numbers that received a user rating in the most recent round. Permits more efficient calculation + of UCBS when using lil_KLUCB. + old_ucbs:List[float] + List of old ucbs, where index i refers to the old ucb for caption i. Used for more efficiently + calculating ucbs for lil_KLUCB. + + Returns + ------- + dist_to_upper:List[float] + A list of the distances from the average ratings for captions to the upper confidence bound on each caption's rating. + For caption i, index i is the distance from self.emp_avg_ratings_[i] to the upper confidence bound on the rating for caption i. + Note that the calculation of the UCB depends on "delta", where we want to find the best caption w.p. 1-delta. + This is done according to the lil-UCB algorithm. + See https://proceedings.neurips.cc/paper/2017/file/c02f9de3c2f3040751818aacc7f60b74-Paper.pdf. + """ + # Formula from + # https://github.com/nextml/NEXT/blob/4c8f4d5a66376a18c047f4c9409f73c75925bf07/apps/CardinalBanditsPureExploration/algs/LilUCB.py#L103 + dist_to_upper = np.zeros(len(num_hits)) + 1e8 + dist_to_upper[np.nonzero(num_hits)] = 2.0*R*R*np.log(4*num_hits[np.nonzero(num_hits)]* + num_hits[np.nonzero(num_hits)]/delta ) / num_hits[np.nonzero(num_hits)] + return dist_to_upper + + def calculate_95_ci(self, sum_rewards_squared, empirical_mean, num_hits): + ''' + Parameters + ---------- + sum_rewards_squared + A list of ints, where index j stores Sum_i(rating_i^2) for caption j. + (We need to store this because Sum_i(rating_i^2) can't be computed directly from Sum_i(rating_i).) + empirical_mean + A list of floats, where index j stores [Sum_i(rating_i)]/n for caption j, where n is num_hits. + num_hits + A list of ints, where index j stores the number of user ratings for caption j. + + Returns + ------- + A list of floats, where index j stores 1.96 times the standard deviation of the user-provided ratings for caption j. + (The 95% CI for caption j, then, is its empirical mean \pm this value.) + ''' + + ''' + Want to calculate + 1.96 * sqrt{ \frac{ 1/n * (Sum_i (reward_i^2) - n * empirical_mean^2) } { (n-1) * n } }. + See https://github.com/nextml/NEXT/blob/4c8f4d5a66376a18c047f4c9409f73c75925bf07/apps/CardinalBanditsPureExploration/algs/LilUCB.py#L73 + ''' + ci_95 = np.zeros(len(num_hits)) + 1e8 + numerator = sum_rewards_squared - num_hits * empirical_mean**2 + denominator = (num_hits - 1) * num_hits ** 2 + + ci_95[np.argwhere(num_hits > 1)] = 1.96 * np.sqrt(numerator[np.argwhere(num_hits > 1)] / denominator[np.argwhere(num_hits > 1)]) + return ci_95 + +class Active(Random): + def model_name(self): + return "Active" + + def get_queries(self, n_queries=100): + """ + Parameters + ---------- + n_queries:int + Number of queries to queue up for a user + + Returns + ------- + indices:List[int], len(indices) = min(n_queries, n) + uniformly random permutation of values from 0 to "number of targets - 1" (i.e. n-1) + scores:List[float], len(scores) = n_queries + list of n_queries decimal values between 0 and 1. Represents quality of the query that can be posed to the user + """ + if not self._initialized: + self._initialize() + + indices = np.arange(self.n).astype(int) + scores = self.emp_avg_ratings_ + self.ucbs_ + + return indices, scores + +class lil_KLUCB(Active): + def model_name(self): + return "lil_KLUCB" + + def calculate_ucbs(self, num_hits:List[int], emp_avg_ratings, answer_indices:List[int], old_ucbs:List[float]): + """ + Parameters + ---------- + num_hits:List[int] + A list of the number of user-provided ratings for a caption, where index i contains the + number of user-provided ratings received for caption i. + emp_avg_ratings + A list of average user-provided ratings, where index i contains the average rating for caption i. + answer_indices:List[int] + List of caption numbers that received a user rating in the most recent round. Permits more efficient calculation + of UCBS when using lil_KLUCB. + old_ucbs:List[float] + List of old ucbs, where index i refers to the old ucb for caption i. Used for more efficiently + calculating ucbs for lil_KLUCB. + + Returns + ------- + dist_to_upper:List[float] + A list of the distances from the average ratings for captions to the upper "delta"-width confidence bound on each caption's rating. + For caption i, index i is the distance from self.emp_avg_ratings_[i] to the upper "delta"-width + confidence bound on the rating for caption i. + This is done according to the lil-KLUCB algorithm as stated in + https://proceedings.neurips.cc/paper/2017/file/c02f9de3c2f3040751818aacc7f60b74-Paper.pdf. + """ + mu = emp_avg_ratings + UCB = old_ucbs + for i in answer_indices: + if num_hits[i]==0: + # mu[i] = float('inf') + UCB[i] = 1e8 + else: + # UCB[i] = mu[i] + np.sqrt( 2.0*R*R*np.log( 4*T[i]*T[i]/delta ) / T[i] ) + # Note that the line below only makes sense when the responses take values in {1,2,3} + # UCB[i] = self.computeUCB(muhat=(mu[i]-1)/2,threshold=(np.log(2*num_hits[i]*num_hits[i]/delta)/num_hits[i])) + UCB[i] = ( self.computeUCB(muhat=(mu[i]-1)/2,threshold=(np.log(2*num_hits[i]*num_hits[i]/delta)/num_hits[i])) )*2+1 - mu[i] + return UCB# - emp_avg_ratings + + # Inspired by code at + # https://github.com/nextml/NEXT/blob/4c8f4d5a66376a18c047f4c9409f73c75925bf07/apps/CardinalBanditsPureExploration/algs/KLUCB.py#L128-L157 + def computeUCB(self,muhat,threshold,accuracy=(10**(-6))): + lower=muhat + upper=1 + UCB=(lower+upper)/2 + while (upper-lower)>accuracy: + new=self.leftright(muhat,lower,upper,threshold) + lower=new[0] + upper=new[1] + UCB=new[2] + return UCB + + # Also inspired by code at + # https://github.com/nextml/NEXT/blob/4c8f4d5a66376a18c047f4c9409f73c75925bf07/apps/CardinalBanditsPureExploration/algs/KLUCB.py#L128-L157 + def leftright(self,muhat,lower,upper,threshold): + if muhat*(1-muhat)!=0: + silly=(upper+lower)/2 + KL=(muhat*np.log(muhat/silly))+((1-muhat)*np.log((1-muhat)/(1-silly))) + if KL>=threshold: + return [lower,silly,(silly+lower)/2] + if KL=threshold: + return [lower,silly,(silly+lower)/2] + if KL int: + """ + Parameters + ----------- + index:int + Which index do we want the score for? + captions:List[List[int]] + A list of caption scores. For any `i`, `len(captions[i]) == 3` because + it represents the number of unfunny, somewhat funny and funny ratings. + + Returns + ------- + rating:int + A rating of 1, 2 or 3 representing the "funniness" of a caption. + """ + assert 0 <= index < len(captions) + ratings = np.asarray(captions[index]).astype(float) + ratings /= ratings.sum() + return np.random.choice([1, 2, 3], p=ratings) + +def num_potential_funniest(emp_avg_ratings, ucbs): + """ + Parameters + ---------- + emp_avg_ratings + Index i of emp_avg_ratings stores the average user-provided rating for caption i. + ucbs + Index i of ucbs stores the distance from caption i to its upper confidence bound for finding the best caption w.p. 1-delta. + + Returns + ------- + Let j be the index of the caption with the highest empirical average rating. + This returns $Sum_i (emp_avg_ratings[i] + ucbs[i] > emp_avg_ratings[j] - ucbs[j])$ + """ + best_caption_index = np.argmax(emp_avg_ratings) + c = 1 + best_avg_lower = emp_avg_ratings[best_caption_index] - c * ucbs[best_caption_index] + upper_bounds = emp_avg_ratings + c * ucbs + return (upper_bounds > best_avg_lower).sum() + +def num_geq_funniest(emp_avg_ratings): + """ + Parameters + ---------- + emp_avg_ratings + Index i of emp_avg_ratings stores the average user-provided rating for caption i. + + Returns + ------- + Let j be the index of the caption with the highest empirical average rating. + This returns $Sum_i (emp_avg_ratings[i] + ucbs[i] > emp_avg_ratings[j] - ucbs[j])$ + """ + return (emp_avg_ratings >= emp_avg_ratings[0]).sum() + +# simulation as a function +def simulate_model(model_name, top_n_scores:int, total_queries:int): + ''' + Parameters + ---------- + model_name:str + The name with which we want to associate simulation results for that model. + top_n_scores:int + The number of captions each user should respond to. For example, top_n_scores = 5 simulates + the case in which each user rates 5 captions. + total_queries:int + The number of ratings to collect from users in a given caption contest. For example, total_queries = 400_000 + simulates a caption contest with a total of 400,000 user-provided ratings. + + Returns + ------- + A list of flat data with the items listed below in 'datum' + ''' + data = [] + for query_batch_num in range(total_queries//top_n_scores): + list_of_dicts = [] + query_indices, query_scores = the_model.get_queries() + + top_score_indices = np.argpartition(query_scores, -top_n_scores)[-top_n_scores:] + + # pose queries to the human, and store in dict_ans + for index in query_indices[top_score_indices]: + # dictionary of answers + dict_ans = {} + index_rating = simulate_human_answer(index, no_header[:,-3:]) + dict_ans["index"] = index + dict_ans["rating"] = index_rating + list_of_dicts.append(dict_ans) + + the_model.partial_fit(list_of_dicts) + datum = {"num_funniest": num_potential_funniest(the_model.emp_avg_ratings_, the_model.cis_), + "num_queries": (query_batch_num+1)*top_n_scores, + "query_batch": query_batch_num, + "top_n_scores": top_n_scores, + "sampler": the_model.name, + "num_geq_funniest": num_geq_funniest(the_model.emp_avg_ratings_) + } + data.append(datum) + + return data + +# ------------------- END OF FUNCTIONS FOR RUNNING THE SIMULATION ------------------- + +# ------------------- RUN THE SIMULATION ------------------- + +# Read CSV +import pandas as pd +# # Read dataset from download +# df = pd.read_csv('803.csv') + +# Read dataset from online +contest = 803 +dfs = pd.read_html(f"https://nextml.github.io/caption-contest-data/dashboards/{contest}.html") +# Get the last table in the webpage +df = dfs[-1] + +# .values removes the header row. (In this specific case, also want to remove first column.) +no_header = df.values[:,1:] + +# PARAMETRIZE THE SIMULATION + +total_queries = 400_000 + +# Create model and get queries +the_model = lil_KLUCB(len(no_header)) + +list_of_models = [lil_KLUCB(len(no_header)), Active(len(no_header)), Random(len(no_header))] +list_of_models = ["lil_KLUCB", "Active", "Random"] + +top_n_scores = 5 + +data = [] +num_samples = 10 +for _ in range(num_samples): + the_model = 0 + for model_name in list_of_models: + if model_name == "lil_KLUCB": + the_model = lil_KLUCB(len(no_header)) + elif model_name == "Active": + the_model = Active(len(no_header)) + elif model_name == "Random": + the_model = Random(len(no_header)) + data = data + simulate_model(the_model, top_n_scores, total_queries) + +# WRITE SIMULATION RESULTS TO CSV + +import pandas as pd +def list_to_csv(input_list, save_name): + df = pd.DataFrame(input_list) + df.to_csv(save_name) + +def csv_to_dataframe(input_csv): + return pd.read_csv(input_csv) + +import datetime + +current_datetime = datetime.datetime.now() +current_datetime = current_datetime.strftime('%Y%m%d%T').replace(":","") +# list_to_csv(data, "seaborn" + str(current_datetime) + ".csv") +list_to_csv(data, "seaborn_test_huge2.csv") diff --git a/docs/example-analyses/visualization-finding-funniest.ipynb b/docs/example-analyses/visualization-finding-funniest.ipynb new file mode 100644 index 0000000..443e807 --- /dev/null +++ b/docs/example-analyses/visualization-finding-funniest.ipynb @@ -0,0 +1,168 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b29449d7-13d2-4a80-b5d0-c706f9a4bd9a", + "metadata": {}, + "source": [ + "# Finding the funniest caption\n", + "\n", + "The visualizations in this notebook attempt to show how quickly a \"best caption\" rises to the top of the rankings. We perform two visualizations.\n", + "1. The graph titled \"# Captions within 95% CI of Current Funniest\" provides a visualization for how soon *a* caption (not necessarily the *true* funniest caption) can plausibly be identified as the funniest. First, the average user-provided rating is computed for each caption. Then, a 95% CI is computed for each of these average user-provided ratings (basically using the central limit theorem). The corresponding graph displays the number of captions with a 95% CI intersecting the 95% CI around the caption with the highest average user-provided rating.\n", + "1. The graph titled \"# Captions with Simulated Rating Higher than True Funniest\" provides a visualization for how quickly the funniest caption can be correctly identified. the following. Recall that we have access to the ground truth for which caption is funniest. This graph displays how many captions, after a given number of queries, have recieved an average user-provided rating that is better than the average user-provided rating received by the true funniest caption.\n", + "\n", + "Each visualization is performed for three different learning strategies.\n", + "1. \"Random\" randomly selects captions for users to rate.\n", + "1. \"Active\" adaptively chooses captions for users to rate according to the upper confidence bound strategy described in https://arxiv.org/abs/1312.7308.\n", + "1. \"lil_KLUCB\" adaptively chooses captions for users to rate according to the upper confidence bound strategy described in https://arxiv.org/abs/1709.03570.\n", + "\n", + "The line on each graph is a plot of the mean, taken over 10 samples. The shaded region around each line is the standard deviation." + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "f102aef8-fa04-43e7-8390-a37880067ef3", + "metadata": {}, + "outputs": [], + "source": [ + "!python simulation-finding-funniest.py" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "1e88d592-f52d-4128-8552-82edc83cad42", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "def list_to_csv(input_list, save_name):\n", + " df = pd.DataFrame(input_list)\n", + " df.to_csv(save_name)\n", + " \n", + "def csv_to_dataframe(input_csv):\n", + " return pd.read_csv(input_csv)" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "e67afb0b-f6c1-43d7-8437-a9dd6c002f14", + "metadata": {}, + "outputs": [], + "source": [ + "df = csv_to_dataframe(\"seaborn_test_huge2.csv\")" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "cae4b546-268d-4eb8-847f-c79747d374dc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.8, 19908.988191069886)" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "ax = sns.lineplot(\n", + " x=\"num_queries\",\n", + " y=\"num_funniest\",\n", + " hue=\"sampler\",\n", + " ci=\"sd\",\n", + " data=df,\n", + ")\n", + "ax.set_yscale(\"log\")\n", + "# ax.set_xscale(\"log\")\n", + "ax.set_title(\"# Captions within 95% CI of Current Funniest\")\n", + "ax.set_ylim(bottom=.8)" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "ef750b6a-6696-4358-b6bb-a4c271ce7c79", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.8, 19721.710540423195)" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "ax = sns.lineplot(\n", + " x=\"num_queries\",\n", + " y=\"num_geq_funniest\",\n", + " hue=\"sampler\",\n", + " ci=\"sd\",\n", + " data=df,\n", + ")\n", + "ax.set_yscale(\"log\")\n", + "# ax.set_xscale(\"log\")\n", + "ax.set_title(\"# Captions with Simulated Rating Higher than True Funniest\")\n", + "ax.set_ylim(bottom=.8)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 76ed443d32bbad10f1966947059427a92620bd10 Mon Sep 17 00:00:00 2001 From: Connor Wagaman <43150981+cwagaman@users.noreply.github.com> Date: Thu, 16 Jun 2022 11:28:34 -0400 Subject: [PATCH 2/2] IQR-based CIs for graphs --- docs/example-analyses/stats_next.py | 246 ++++++++++++++++++ .../visualization-finding-funniest.ipynb | 53 ++-- docs/example-analyses/viz.py | 49 ++++ 3 files changed, 328 insertions(+), 20 deletions(-) create mode 100644 docs/example-analyses/stats_next.py create mode 100644 docs/example-analyses/viz.py diff --git a/docs/example-analyses/stats_next.py b/docs/example-analyses/stats_next.py new file mode 100644 index 0000000..d0aae53 --- /dev/null +++ b/docs/example-analyses/stats_next.py @@ -0,0 +1,246 @@ +""" +From https://github.com/stsievert/salmon-experiments/blob/8daa4e23ca9960bc585a83828ff6ab71f1b90584/response-rate-next2/stats_next.py + +This file is a collection of various stat functions. +Input: embedding filenames. +Output: stats for each embedding. +The following stats are collected: +* Accuracy +* Distance from ground truth embedding +* Nearest neighbor accuracy +""" + +from time import time +from typing import Tuple, Union, Dict, List, Tuple +from numbers import Number as NumberType +import msgpack +import pandas as pd +from pprint import pprint + +import numpy as np +from scipy.spatial import procrustes +from scipy.spatial.distance import pdist, squareform +from sklearn.manifold import SpectralEmbedding +import numpy.linalg as LA + +ArrayLike = Union[list, np.ndarray] +Number = Union[NumberType, int, float, np.integer, np.floating] + + +def collect( + embedding: ArrayLike, targets: List[int], X_test: ArrayLike +) -> Dict[str, float]: + embedding = np.asarray(embedding) + X_test = np.asarray(X_test) + + accuracy = _get_acc(embedding, X_test) + nn_acc, nn_diffs = _get_nn_diffs(embedding, targets) + + diff_stats = { + f"nn_diff_p{k}": np.percentile(nn_diffs, k) + for k in [99, 98, 95, 90, 80, 70, 60, 50, 40, 30, 20, 10, 5, 2, 1] + } + nn_dists = {f"nn_acc_radius_{k}": (nn_diffs <= k).mean() for k in range(30)} + + n, d = embedding.shape + stats = {} + if d > 1: + reduce = SpectralEmbedding(n_components=1, affinity="nearest_neighbors") + embedding = reduce.fit_transform(embedding) + norm = np.linalg.norm + if targets: + ground_truth = np.array(targets) + assert (np.diff(ground_truth) > 0).all() + ground_truth = ground_truth.reshape(-1, 1) + else: + ground_truth = np.arange(n).reshape(-1, 1) + Y1, Y2, disparity = procrustes(ground_truth, embedding) + stats = { + "embedding_error": norm(Y1 - Y2), + "embedding_rel_error": norm(Y1 - Y2) / norm(Y1), + "procrustes_disparity": disparity, + } + + return { + "accuracy": accuracy, + "nn_diff_median": np.median(nn_diffs), + "nn_diff_mean": nn_diffs.mean(), + "nn_acc": nn_acc, + "avg_items_closer_than_NN": np.mean(items_closer_than_true_NN(embedding, targets)), + **diff_stats, + **stats, + **nn_dists, + **_dist_stats(ground_truth, embedding), + } + + +def _dist_stats(ground_truth: np.ndarray, em: np.ndarray) -> Dict[str, Number]: + D_star = pdist(ground_truth) + D_hat = pdist(em) + D_star /= D_star.max() + D_hat /= D_hat.max() + return {"dist_rel_error": LA.norm(D_hat - D_star) / LA.norm(D_star)} + + +def _get_acc(embedding: np.ndarray, X: np.ndarray) -> float: + assert isinstance(embedding, np.ndarray) + n, d = embedding.shape + # X[i] is always [h, w, l] so zero is the right choice. + y = np.zeros(len(X)).astype("int") + assert X.ndim == 2 and X.shape[1] == 3, f"{type(X)}, {X.shape}" + y_hat = TSTE_predict(X, embedding=embedding) + assert all(_.dtype.kind in ["u", "i"] for _ in [y, y_hat]) + acc = (y == y_hat).mean() + return acc + + +def nn_accs(em: np.ndarray, targets: List[int]): + nn_acc, nn_diffs = _get_nn_diffs(embedding, targets) + + diff_stats = { + f"nn_diff_p{k}": np.percentile(nn_diffs, k) + for k in [99, 98, 95, 90, 80, 70, 60, 50, 40, 30, 20, 10, 5, 2, 1] + } + nn_dists = {f"nn_acc_radius_{k}": (nn_diffs <= k).mean() for k in range(30)} + return nn_dists + +def _get_nn_diffs(embedding, targets: List[int]) -> Tuple[float, np.ndarray]: + """ + Get the NN accuracy and the number of objects that are closer than the + true NN. + """ + true_nns = [] + t = np.array(targets) + for ti in targets: + true_dist = np.abs(t - ti).astype("float32") + true_dist[true_dist <= 0] = np.inf + true_nns.append(true_dist.argmin()) + true_nns = np.array(true_nns).astype("int") + + dists = distances(gram_matrix(embedding)) + dists[dists <= 0] = np.inf + + neighbors = dists.argmin(axis=1) + neighbor_dists = np.abs(neighbors - true_nns) + nn_acc = (neighbor_dists == 0).mean() + return nn_acc, neighbor_dists + +def items_closer_than_true_NN(embedding, targets) -> List[int]: + # find true nearest neighbors + true_nns = [] + t = np.array(targets) + for ti in targets: + true_dist = np.abs(t - ti).astype("float32") + true_dist[np.abs(true_dist) < 1e-3] = np.inf + true_nns.append(true_dist.argmin()) + + # for each item in the embedding, how many items are between + # it and the true NN? + + ## so, get distance matrix + dists = distances(gram_matrix(embedding)) + dists[dists <= 0] = np.inf + + items_closer_than_NNs = [] + for dist, true_nn in zip(dists, true_nns): + true_nn_dist = dist[true_nn] + items_closer_than_NN = (dist < true_nn_dist).sum() + items_closer_than_NNs.append(items_closer_than_NN) + return items_closer_than_NNs + + +################################################################# +## everything from here down copied from Salmon +# salmon/triplets/samplers/_adaptive_runners.py#Adaptive.predict +# salmon/triplets/samplers/adaptive/search/gram_utils.py +################################################################# +Array = np.ndarray +def gram_matrix(X: Array) -> Array: + """ + Get Gram matrix from embedding + Arguments + --------- + X : Array + Embedding. X.shape == (num_items, item_dim) + Returns + ------- + G : Array + Gram matrix. G.shape == (n, n) + """ +# if isinstance(X, torch.Tensor): +# return X @ X.transpose(0, 1) + return X @ X.T + + +def distances(G: Array) -> Array: + """ + Get distance matrix from gram matrix + Arguments + --------- + G : Array + Gram matrix. G.shape == (n, n) for n objects + Returns + ------- + D : Array + Distance matrix. D.shape == (n, n) + """ + G1 = np.diag(G).reshape(1, -1) + G2 = np.diag(G).reshape(-1, 1) + + D = -2 * G + G1 + G2 + return D + +def TSTE_predict(X, embedding=None): + """ + Predict the answers of queries from the current embedding. + Parameters + ---------- + X : array-like + Each row is ``[head, left, right]``. Each element in ``X`` or + ``X[i, j]`` is an index of the current embedding. + Returns + ------- + y : array-like + The winner of each query. An element of ``y`` is 0 if the left + item is the predicted winner, and 1 if the right element is the + predicted winner. + """ + head_idx = X[:, 0].flatten() + left_idx = X[:, 1].flatten() + right_idx = X[:, 2].flatten() + + head = embedding[head_idx] + left = embedding[left_idx] + right = embedding[right_idx] + + ldiff = LA.norm(head - left, axis=1) + rdiff = LA.norm(head - right, axis=1) + + # 1 if right closer; 0 if left closer + # (which matches the labeling scheme) + right_closer = rdiff < ldiff + return right_closer.astype("uint8") + +if __name__ == "__main__": + file = "salmon/io/2021-05-18/ARR-1_history.msgpack" + file = "next/io/2021-05-18/rate=1_history.msgpack" + with open(file, "rb") as f: + history = msgpack.load(f) + datum = history[-1] + em = datum["embedding"] + n_responses = datum["meta"]["n_responses"] + fnames = pd.read_csv("targets.csv.zip", header=None)[0].tolist() + targets = [int(f.strip("i.png")) for f in fnames] + targets = list(sorted(targets)) + + X_test = [ + [i_h, i_l, i_r] if abs(h - l) < abs(h - r) else [i_h, i_r, i_l] + for i_h, h in enumerate(targets) + for i_l, l in enumerate(targets) + for i_r, r in enumerate(targets) + if h not in [l, r] and l != r + ] + + s = collect(em, targets, X_test) + print(len(history)) + print(n_responses, s["accuracy"]) diff --git a/docs/example-analyses/visualization-finding-funniest.ipynb b/docs/example-analyses/visualization-finding-funniest.ipynb index 443e807..b9fd9fa 100644 --- a/docs/example-analyses/visualization-finding-funniest.ipynb +++ b/docs/example-analyses/visualization-finding-funniest.ipynb @@ -21,7 +21,7 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": null, "id": "f102aef8-fa04-43e7-8390-a37880067ef3", "metadata": {}, "outputs": [], @@ -31,12 +31,25 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 1, + "id": "60a0aac3-b89f-4c1c-92fd-9e1709366c5a", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import seaborn as sns\n", + "import viz" + ] + }, + { + "cell_type": "code", + "execution_count": 2, "id": "1e88d592-f52d-4128-8552-82edc83cad42", "metadata": {}, "outputs": [], "source": [ "import pandas as pd\n", + "import seaborn as sns\n", "def list_to_csv(input_list, save_name):\n", " df = pd.DataFrame(input_list)\n", " df.to_csv(save_name)\n", @@ -47,8 +60,8 @@ }, { "cell_type": "code", - "execution_count": 48, - "id": "e67afb0b-f6c1-43d7-8437-a9dd6c002f14", + "execution_count": 3, + "id": "d373c4e3-15a7-4871-9fb5-cca15aeafc00", "metadata": {}, "outputs": [], "source": [ @@ -57,23 +70,23 @@ }, { "cell_type": "code", - "execution_count": 49, - "id": "cae4b546-268d-4eb8-847f-c79747d374dc", + "execution_count": 4, + "id": "864c5d01-4f90-4a20-847e-37da471e0038", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(0.8, 19908.988191069886)" + "(0.8, 11867.903583496167)" ] }, - "execution_count": 49, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -85,13 +98,13 @@ } ], "source": [ - "import seaborn as sns\n", - "ax = sns.lineplot(\n", + "ax = viz.lineplot(\n", " x=\"num_queries\",\n", " y=\"num_funniest\",\n", " hue=\"sampler\",\n", - " ci=\"sd\",\n", + " ci=.25,\n", " data=df,\n", + " palette = sns.color_palette()\n", ")\n", "ax.set_yscale(\"log\")\n", "# ax.set_xscale(\"log\")\n", @@ -101,23 +114,23 @@ }, { "cell_type": "code", - "execution_count": 50, - "id": "ef750b6a-6696-4358-b6bb-a4c271ce7c79", + "execution_count": 5, + "id": "1119e1a9-8127-444a-ba18-cac4d693210a", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(0.8, 19721.710540423195)" + "(0.8, 11867.903583496167)" ] }, - "execution_count": 50, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZQAAAEXCAYAAACK4bLWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAACUAklEQVR4nOydd5wcZf3438/MbN/rd8ml9x5S6J3E0JsKKFEURBQRESsi6Jf2taAgCv5ARJrla2gqUiLGAKFLICGQQkhC6uVy/W5v+055fn/M3l7vey2Zd173yu6UZ56dnZ3PfLqQUuLg4ODg4NBflKGegIODg4PDwYEjUBwcHBwcsoIjUBwcHBwcsoIjUBwcHBwcsoIjUBwcHBwcsoIjUBwcHBwcsoIjUPqAEOJfQojLhnoebRFCXCKEWNXF+iVCiLIsHeskIcRH2Rirg7FvEUL8ZSDG7uBYWTsnPTzekF07vfnOBvu8pI/5qBDiJ4N5zIMdIcSNQogHB+t4w1agCCHWCiFmCCGmCiHWd7OtEEJcK4TYJISICiHKhBBPCiEOy8I82t3cpJRnSSn/2N+xs42U8v+klKc3vRdCSCHE9L6OJ4SYJ4RYJYSoF0I0CCHWCSHOTh/rNSnlrGzMuz8M9E0ofQ6jQoiIEGK/EOIuIYTaw30H7drpTAAIIdYIIb6SPvaw+M4AhBBfEkK8PgTHnZj+Lpv+Wn6/ESHESQN47FuEEHqb4/9goI4HIKX8mZTyK/0ZozffldafAw0UQggXMAnYAVwEdClQgLuBc4CvAm8AKvDp9LKNAzfTg55ngd8B56bfHwWIoZvOkLFQSrkjLZxfAT4E/jDEcxoxCCE0KaUx1PMAkFLuBYJN74UQkvT323bbAZr341LKL2R5zOGDlHLY/QGLgZfTr38BXN3FtjMAEzi6i23OAd4DGoF9wC0t1k0GJHAlUA4cAL6XXncmkAJ0IAK8n16+BvhK+rUC/BjYA1QBfwLy2ox9GbAXqAF+1OLYRwPvpudVCdzVyfxfAS5Mvz4xPebZ6fenAhvSr78EvJ5+/Wp6u2h67hcDS4Ay4HvpuR4ALu/kmMXp/fM7Wb8EKGvxfjdwHfBB+pgPAaOBfwFhYDVQ0NG+LfY/Nf36FuAvLdY9CVQAofTnmpdefmX6u0mlP+Oz6eVjgb8B1cAu4NoWY/mAR4F6YEt6zmUdfcb09hKY3uL9E8C9Ld7fjX1NNQLrgJN6ce18CXgduDM9n13AWS3GnpL+vE3n796W56Wr76PF8pbHa/udHY79uwinz/HjwE9abtvZtQJ40vPei33t3g/42ux7ffp7+3ObOc0BEti/2wjQkF7+aPozPp+e09vAtO7OdYtr5gns318Y2Awc2YN7Teb7TX8fbwC/BuqAn9D+Wpyc3kdLv8/DvtYPAPvT+6idHKvVWJ0t7+AYa4D/Tc8tDKwCint4j2k79rHAm0AD8D6wpMW6LwE708fYBVzS2XfV2d+wMnkJIS4XQjRgn7jj0q+/B/wibXKZ0sFuy7B/JGu7GDoKXArkYwuXrwshPtVmm6XYwul04IdCiFOllC8AP8N+qghKKRd2MPaX0n9LganYTz//r802JwKz0nO9SQgxJ738buBuKWUuMA37B9ERr2D/SAFOxv7ST2nx/pW2O0gpT06/XJie++Pp96XYP4JxwBXAvUKIgg6OWYutIf5FCPEpIcToTubWkguB04CZwHnYwuRGbOGkANf2YIyO+Bf2dzMKW1v9PwAp5QPp179Mf8bzhBAKtmb1fvozLgO+LYQ4Iz3WzdjnehpwBvYPsUcIIWYDJ2GflybeARYBhcBfgSeFEN4eXjsAxwAfYZ+jXwIPCSGatMC/AmuBIuwbwxd7OtcefBY38A/sm3ghsAJbq29JV9fKL7C/50XA9PQ2N7XZtxDb0nBly0GllB8CVwFvpc9NfovVnwNuBQqwz/NPW6zr8Fy3WH8+8Bj27/wZ2v8Oe8Ix2L+vUW2O3Rl/BAzsc7AY+/7RLxNTJ3weuDw9Lzfw/TbrO7vHZBBCjMMW1j/BPoffB/4mhCgRQgSAe7AfaHKA47EfVLv6rtoxrASKlPKR9ITXYUvSBcAmIFdKmS+l3NXBbkXYTwddjbtGSrlRSmlJKT/A/vGc0mazW6WUUSnlRuAR7Au7J1yCrVnslFJGgBuA5UKIlubEW6WUcSnl+9g3uqabiw5MF0IUSykjUsr/dnKMV2gtQH7e4v0pdCBQukAHbpNS6lLKldhPHe3s6tJ+ZFmKrTn8CjgghHhVCDGji7F/K6WslFLuB14D3pZSvielTGLfvBb3Yp4t5/KwlDKcHucWYKEQIq+TzY8CSqSUt0kpU1LKndjmqeXp9Z8FfiqlrJNS7sP+EXXHeiFEFNvUtQa4r8Xc/iKlrJVSGlLKX2E/uffGT7FHSvkHKaWJfXMaA4wWQkxMf5ab0p/jdeybZFeMTT94Zf6wbzQdcSy2yfue9LXwd2zh1ZIOr5W0wPsq8J30eQxjC8/lLfa1gJullEkpZbyH5wLg71LKtdI2Nf0ftgABenSuX5dSrkyfyz/T/DvrDeVSyt+mj9HlvNMPWWcB307fO6qwtZvlXez22Tbf0dgezusRKeW29JyeoMV5SdPZPaYlXwBWps+RJaX8D7aF5Oz0eguYL4TwSSkPSCk393BuGYaNQBFCFKZPcAhbOq7BfnKbBdQLIb7dya612D/CrsY+RgjxshCiOj3+VdhPhC3Z1+L1HmyzSU8Ym96+5b4atrmniYoWr2M023CvwH7K2yqEeEcIcS4d8xYwM30BL8JW6ycIIYqxzWav9nCuALWytV245XxaIaUsk1JeI6Wchv2kGU0fuzMqW7yOd/C+w+N0hRBCFULcLoT4WAjRiC3goP3318Qk2txYsbWkpu9jLO2/6+44PD33i7GfYAMt5vc9IcSHQohQ+lh5XcytIzLXhpQyln4ZTM+zrsUy2sy7I8rTD16ZP2yTWkeMBfanHxw6G7+za6UE8APrWpzjF9LLm6iWUia6mW9HdPZb6cm5bruvt82DXU/o7hy3ZBLgwn7YajoPv8fWIjrjiTbfUXkPj9Xpeenh+qb5fqaDB44xUsoo9vV9VfrzPJ/WyHvFsBEo6SedfOBrwIPp1y8A56VP/G862fVFYLwQ4sguhv8r9tPdBCllHra9t61zeUKL1xOx/Slg2ye7ohz7i2q5r0Hrm2mHSCm3Syk/h30B/gJ4Kq16tt0uhq21fQvYJKVMYdtBvwt8LKWs6e5Y/SX9NH8vMD8Lw0Wxb0iALTRofTNqyeeBT2L7ivKwbcbQ/P21/X72Abva/GhzpJRNT2EHaP9dd4u0eQJbuN+UnvdJ2H6Cz2L7h/Kx/Tydza03HAAKhRD+FssmdLZxH8cf18K81pvxa7AfEOa1OMd5UsqWN7HuPnuvzk0PznW2aDuvVtcqtimviX1AEtuf0XQecqWU83p5zK6OkU32YfuzWv42AlLK2wGklP+WUp6G/YC+lebAkx5/V8NGoLTgCJqjuhZj30g7RUq5HdsEsSIdOukWQniFEMuFED9Mb5aD/bSXEEIcjX2Tasv/CCH8Qoh52LbKJp9DJTA5bZvviBXAd4QQU4QQQZrt5t1GhwghviCEKJFSWthOMrCdXx3xCnANzeatNW3ed0Qltl+n1wghCoQQtwohpgshlLQ29GWgM7Ncb9iG/fR4Tjqi78fY5ouOyMH+0dZi/+h+1mZ928+4FmgUQlwvhPClNZz5Qoij0uufAG5If77xwDd7OffbgSuFEKXpuRnYzn9NCHETkNtmbl1dO50ipdyDbY64JX1NH4ftl8oWb2Ffa9cIITQhxCextd2ezM3Cvtn8WggxCmz7fAs/VU+oxH4QdPdw++7O9UCxAThZ2OHGedgmbQCklAewHeS/EkLkpn8n04QQbc3pfT5GlvkLcJ4Q4oz078KbvmeOF0KMFkKcn36gTWKbN5vuRT3+roatQBFCFAGmlLK+B/tci+2Auxf7xvwxtoPx2fT6q4HbhBBh7KfLjpzfr2A7AV8E7pRSNiUIPpn+v1Z0nA/zMLa99lXsyIgEPb9JnQlsFkJEsB30y7swE7yC/aN6tZP3HXEL8Me0evvZHs6piRS2NrAaO6pmE/aF9qVejtMOKWUI+zt5EDsyJoodFdQRf8I2S+3HjspqK9AeAuamP+PTafv5edimwV3YT9MPYms3YDt896TXrcL+7noz943Y5/464N/YAQPb0mMmaG0y6e7a6Y5LgOOwhelPsB9ykn0Ypx1pLfcCbLNrA7Z9/blejH899u/lv2lT5Gp65zt6CTsSq0II0RMNu7tzPSCk/QyPY0cvrsM+Ry25FNtJvgU7Uu8pujHB9+EYWSFtZfgktgm4Gvv8XYctBxTsAKhy7Ai3U7B/o9CL70q0NqEeegghJmPfXFw90SocHIYKIcTjwFYp5c0DNP7bwP1SykcGYnyHg5/hqKE4ODgAQoij0iYURQhxJvbT5dNZHP8UIURp2uR1GXZU5QvZGt/h0GNYZso7ODgAtnP279ih8WXA16WU72Vx/FnY5t8gtpn4orRfwMGhTxzyJi8HBwcHh+zgmLwcHBwcHLLCiDd5FRcXy8mTJw/1NBwcHBxGFOvWrauRUnaW/9UnRrxAmTx5Mu++++5QT8PBwcFhRCGE6EmViF7hmLwcHBwcHLKCI1AcHBwcHLKCI1AcHBwcHLLCiPehODg4DA66rlNWVkYi0Zciwg5DhdfrZfz48bhcrgE/liNQHBwcekRZWRk5OTlMnjyZ1kWKHYYrUkpqa2spKytjypSO+hNmF8fk5eDg0CMSiQRFRUWOMBlBCCEoKioaNK3SESgODg49xhEmI4/B/M4cgeLg4ODgkBUcgeLg4ODQDUuWLHESqHuAI1AcHBwcsoxpdtZ49eBm2AkUIURACLFOCHHuUM/FwcFh+BKNRjnnnHNYuHAh8+fP5/HHH+e2227jqKOOYv78+Vx55ZU0VVNfsmQJ3/nOdzj55JOZM2cO77zzDhdccAEzZszgxz/+MQC7d+9m9uzZXHbZZSxYsICLLrqIWCzW7rirVq3iuOOO4/DDD+czn/kMkUgEsMtA3XbbbZx44ok8+eST7fY7FBhwgSKEeFgIUSWE2NRm+ZlCiI+EEDta9H4Hu7VoRy16HRwcHDK88MILjB07lvfff59NmzZx5plncs011/DOO++wadMm4vE4zz3X3E3X7Xbz6quvctVVV/HJT36Se++9l02bNvHoo49SW1sLwEcffcSVV17JBx98QG5uLvfdd1+rY9bU1PCTn/yE1atXs379eo488kjuuuuuzHqv18vrr7/O8uXLB+ckDDMGQ0N5FLt3egYhhIrd//0sYC7wOSHEXCHEqdi9mSsHYV4ODg4jmMMOO4zVq1dz/fXX89prr5GXl8fLL7/MMcccw2GHHcZLL73E5s2bM9uff/75mf3mzZvHmDFj8Hg8TJ06lX377Pb0EyZM4IQTTgDgC1/4Aq+//nqrY/73v/9ly5YtnHDCCSxatIg//vGP7NnTXGPx4osvHuiPPawZ8MRGKeWr6b7tLTka2CGl3AkghHgMu71pEAhgC5m4EGKllNJqO6YQ4krgSoCJEycO4OwdHByGKzNnzmTdunWsXLmSG264gdNPP517772Xd999lwkTJnDLLbe0yr/weDwAKIqSed303jAMoH2Ibdv3UkpOO+00VqxY0eGcAoFAVj7bSGWofCjjgH0t3pcB46SUP5JSfhv4K/CHjoQJgJTyASnlkVLKI0tK+l7Of2/jXlJmqs/7Ozg4DB3l5eX4/X6+8IUv8P3vf5/169cDUFxcTCQS4amnnur1mHv37uWtt94CYMWKFZx44omt1h977LG88cYb7NixA4BYLMa2bdv6+UkOHoaq9EpHmTaZXsRSyke7HUCI84Dzpk+f3udJHIgcIG7EmVU4q89jODg4DA0bN27kuuuuQ1EUXC4Xv/vd73j66ac57LDDmDx5MkcddVSvx5wzZw5//OMf+drXvsaMGTP4+te/3mp9SUkJjz76KJ/73OdIJpMA/OQnP2HmzJlZ+UwjnUHpKZ82eT0npZyffn8ccIuU8oz0+xsApJQ/7+3YRx55pOxrfPib+9/Epbo4qrT3F56Dw6HGhx9+yJw5c4Z6GgPG7t27Offcc9m0aVP3G48wOvruhBDrpJRHZvM4Q2XyegeYIYSYIoRwA8uBZ4ZiIikz1drsJSUYKft/BwcHB4ceMxhhwyuAt4BZQogyIcQVUkoDuAb4N/Ah8ISUcnNX43Qw7nlCiAdCoVCf5nXzoxdz58rvUhYuY0vtluYVdbvg4xchWt2ncR0cHEYmkydPPii1k8FkMKK8PtfJ8pXAyn6M+yzw7JFHHvnVvuwfC29ke65KQ6qBlJXCsAw0RYNIJUjL/nNwcHBw6DHDLlN+sDjCsh3xCgqhZIiYEbNNXakIKBpYxhDP0MHBwWFkMWIFSn9NXiIdaCaEwKf6aEg0IJNhe6Wighixp8bBwcFhSBixd00p5bNSyivz8vL6tH/TB29INmBIg73hvejxeiQKlmPtcnBwcOg1I1ag9BePtD/62gNrKfGXYFgG8Ug5e8IWHx5oYHdVIxvLQpiWE+3l4ODg0BNGrEDpr8mr0HIDkOvJBSBpJNha+yH1uoUpFcoakuyrjxKK61mbs4ODQ/8IBoOAnSV/0UUXAbBmzRrOPbfz4uSPPvoo11xzDQCWZXHZZZfx5S9/GSklkydPpqampsNjdLQ/wJ/+9Cfmz5/PvHnzmDt3LnfeeScAX/rSl5gyZQqLFi1i9uzZ3HrrrR3O5+KLL2bRokUsWrSIyZMns2jRIsDOg/H5fJl1V111VWafxx9/nAULFjBv3jx+8IMfZJbfddddzJ07lwULFrBs2bJWdcWGghErUPpr8gJQpeTtA28DUOopoDEZY1+8Fp9HoSjoIeAZqkICDg4OXTF27Nhel1aRUnLVVVeh6zoPPvhgn1rj/utf/+I3v/kNq1atYvPmzaxfv56W96A77riDDRs2sGHDBv74xz+ya9eudmM8/vjjmW0uvPBCLrjggsy6adOmZdbdf//9ANTW1nLdddfx4osvsnnzZiorK3nxxRcBWLx4Me+++y4ffPABF110USthMxQc0ndMs8UFpVkmKcukzqhnm1XLpPwZJBM1iEgCwiGI1oA7CAWTIVAMTm9th0OYW5/dzJbyxqyOOXdsLjefN69H2/Ylq/1b3/oWtbW1PP744yhK356lf/7zn3PnnXcyduxYwC5X/9Wvts9caCpK2VWxSCklTzzxBC+99FKXx9y5cyczZ86kqW7hqaeeyt/+9jeWLVvG0qVLM9sde+yx/OUvf+n1Z8omI1ZDyQaX1McB+4tFj6MbELNixGWSHeWrqStfiVq1BRlvwFC9JCM1xHe/Q0MkSlVjgvpoisrGBCnD8eI7OAxn/vrXv7Ju3Toee+wxNK3vz9GbNm3iiCOO6HT9ddddx6JFixg/fjzLly9n1KhRnW772muvMXr0aGbMmJFZtmvXLhYvXswpp5zCa6+9BsD06dPZunUru3fvxjAMnn766Uy5/ZY89NBDnHXWWX3+bNlgxGoo2SgOucetAlAWLmNCKolX5DHB56XGqMIvFKJ6Dh9HPVhRHSl1BB60ZB3Vsh6X24MEIgmDRRPyGV/oz84Hc3AYAfRUkxguHH744WzdupW1a9dm+p30hp6ax+644w4uuugiIpEIy5Yt48033+T444/vcNsVK1bwuc81532PGTOGvXv3UlRUxLp16/jUpz7F5s2bKSgo4He/+x0XX3wxiqJw/PHHs3PnzlZj/eUvf+Hdd9/llVde6fVnyyYjVkPJhg/lpKhdw+u6V69Dj4eImwqaojDGU0pAy6XA78LrUsn1usjzucj1ucj1uCjN9VIY8FAU8JDrdTnWLweHYc7s2bN54oknuPjii1s13eoIn89HKtVc36+uro7i4mIA5s2bx7p167o9XjAYZMmSJe0adDVhGAZ///vfWzXk8ng8FBUVAXDEEUcwbdq0TGn88847j7fffpu33nqLWbNmtdJqVq9ezU9/+lOeeeaZVn1ehoIRK1Cyga9FAchIshETjbzG3QTD5QBoikBTBSlLpyZZx2BUZnZwcBgYjj/+eO6//37OOecc9u7d2+l2p5xySsYXEY/HeeKJJzK+ihtuuIEf/OAHVFRUAJBMJrnnnnvajWEYBm+//TbTpk3r8BirV69m9uzZjB8/PrOsuroa0zQB22+yfft2pk6dCkBVVRUA9fX13HfffXzlK18B4L333uNrX/sazzzzTJfmtcFixJq8ssGkVLPvI2VKEHDc23cgkLx+1Peoy5tAfSrE7sR+LGlS4M5zanw5OIxgzj33XKqrqznzzDMzPooFCxZknPSf/exnufvuu/na177GPffcg5SSSy+9lJNPPhmAs88+m8rKSk499VSklAgh+PKXv5wZ/7rrruMnP/kJqVSKZcuWtYrgasljjz3WytwF8Oqrr3LTTTehaRqqqnL//fdTWFgI2AEF77//PgA33XRTpv/KddddRyQS4TOf+Qxgd7B95pkhKdwODFI/lIGkr/1QXr/r88wLvcKvTr+cf+74J6fnH85JwRP51GvfB6CyeB6vL7ycpJUiVw0SteIszJmNJ1ZNdNzJSM0LQH00xbRRAcYVOD4Uh4Obg70fysHMwd4Ppd/0N7GxiVE+W038OH6AkvDuzHLVMggZYXLUoF2FOI1U3P06noODg8PByogVKNlwygOcPN5WZQ0pyQvtRCIIB8cigLGe0biUnlkFpZREkwa1kSS7a6J8VNHIjsowllO6xcFhUHjkkUcyWeZNf9/4xjeGelqHFIe0DwWawwH3pCp4J1HPpEApuubrccdGU0r21sb5uDqKJSWWBW5NQRWCcCrJpOIACk4YmIPDQHP55Zdz+eWXD/U0DmkOeYHSko1WI6fmTycQrQRaCxRLWpQnq8jVk2DGMTEAgdtlEjVS+FwappkkZjVSHQ9jSJ2GeJJgxSiCLj+qUNEUjSl5U1FalMa3JMj0sZqqHOuWRcCtoSqOIHJwcBg5HPICJZKK8OmS4/lH9Zv8x+/hi75JBGKV7XSKlKWzO16GV0+Sql+PUL1YWCBBU1yIBKSMJC7VjVv14ldziOBmy/4wQkSxpEnCiDKrwI+7hR9GSjIVjYUAgS1kXJrgiEmFBJ16Yg4ODiOEQ/5uZZk6p+Yt5B/VbwLwveQH3CdhlGitoYz22IlNCiESnhKk2oFz3tX6bWmur9X7sC4p8rtxq90nH9VFU1gjPALPwcHh0GLEOuWzFeWlCYG0FOZY9k2+2mrkj1K2tXh1jJRoiXqQZr/m4ODg0HP+8Y9/IIRg69at3W77m9/8hlgslnl/9tln09DQ0K/jh8PhVo7/4uJivv3tbwN2qfuSkpLMugcffDCz3/XXX8/8+fOZP38+jz/+eGb5JZdcwqxZs5g/fz5f/vKX0fWR2zJjxAqUbEV5YRokTYtbGpslyLtBA53uExhdkf246z9C1eP9m4ODg0OPWbFiBSeeeCKPPfZYt9u2FSgrV64kPz+/X8fPycnJlJjfsGEDkyZNapXAePHFF2fWNWW0P//886xfv54NGzbw9ttvc8cdd9DYaFdrvuSSS9i6dSsbN24kHo+3EkIjjRErULKGNNF1kymRAxym28mKFW7Jq8muHeJqogF3ZD+g4IqUDcJEHRwcIpEIb7zxBg899FArgWKaJt///vc57LDDWLBgAb/97W+55557KC8vZ+nSpZnSKU0Nta6//nruu+++zP633HILv/rVrwC7wONRRx3FggULuPnmm7ucz/bt26mqquKkk07qcrstW7ZwyimnoGkagUCAhQsX8sILLwC21iSEQAjB0UcfTVnZyL2fHPI+FEwTNdGIT49yVngRGwv/C8BuVfLkuvXcsngxY6vWM+fDx9k59Uz2lR6BsHTcjbswPTlIoaDq0SH+EA4Og8y/fggVG7M7ZulhcNbtXW7y9NNPc+aZZzJz5kwKCwtZv349hx9+OA888AC7du3ivffeQ9M06urqKCws5K677uLll1/OFHdsYvny5Xz729/m6quvBuCJJ57ghRdeYNWqVWzfvp21a9cipeT888/n1VdfzZReacuKFSu4+OKLW1Uj/tvf/sarr77KzJkz+fWvf82ECRNYuHAht956K9/97neJxWK8/PLLzJ07t9VYuq7z5z//mbvvvrsvZ29YcMhrKKaZIhCvBmBDfDL59V8C4E8lBvHcVbjefoRFHzyER48w56OnQFq4ohWAtLPmhSOTHRwGixUrVrB8+XLAFgorVqwA7GKLV111VabXSVMNrM5YvHgxVVVVlJeX8/7771NQUMDEiRNZtWoVq1atYvHixZmS99u3b+90nLY1uc477zx2797NBx98wKmnnspll10GwOmnn87ZZ5/N8ccfz+c+9zmOO+64dn1Zrr76ak4++eRutZ3hzCF/N7T0FHlpgfJ6eCJjR2+jocX62bEP2Db9PKZ//C8UaXDi2jv5YM7FNBTPH5L5OjgMC7rRJAaC2tpaXnrpJTZt2oQQAtM0EULwy1/+MlOosTdcdNFFPPXUU1RUVGSElJSSG264ga997Wvd7v/+++9jGEarhltN5ecBvvrVr3L99ddn3v/oRz/iRz/6EQCf//znW5Wgv/XWW6murub3v/99rz7DcOOQ11AMI0UgUU9K8VApCziiYBpnxFJ8r7YegF/lfpOdU89i81z7KcSfqCcnWgktkhPpaVSYg4NDn3nqqae49NJL2bNnD7t372bfvn1MmTKF119/ndNPP537778fwzAAu4cJ2A70cDjc4XjLly/nscce46mnnuKiiy4C4IwzzuDhhx8mEokAsH///kzp+La0bZAFcODAgczrZ555JlOQ0TRNamtrAfjggw/44IMPOP300wF48MEH+fe//82KFSv63Jp4uHDIayjJVBx/so5qtQQBzCl0c+KBUbxpfQzAXm0CAAdKj8RUXCza+DCmK9hmFCej3cFhoFmxYgU//OEPWy278MIL+etf/8pvf/tbtm3bxoIFC3C5XHz1q1/lmmuu4corr+Sss85izJgxvPzyy632nTdvHuFwmHHjxjFmzBjANk19+OGHHHfccYDdKOsvf/lLh71GnnjiCVauXNlq2T333MMzzzyDpmkUFhby6KOPArZ/pMmUlZuby1/+8peMyeuqq65i0qRJmWNecMEF3HTTTf08W0PDIV++fvXp3+P0N37Ph6kxfFd8l5uWhlGNBGsbN/FY7WpmRL7LlYvtJEZfrIZTXr+JjfO+yP5xx2XGUpMhYqOOyMgVxUigRSuwXD5MTz4yncgY1kPMyV/U48TGxZPyyfW6ut3WwWEwcMrXj1yc8vXdkK3ERqFbBBJ1fGyMZnyunaBoal6sdCa8IWL8vWoVd+z+A+V6AwCv73Hzw1W5bDjg4i/v+4jpzRqKMFN46rfhDu/DW/sharKhX/NzcHBwGCmMWIGSrcRGfyqOZqXYro+iNKd9xvuuwP28FVpPlV7LvR8kANhZr9KQULj/nQCv7/HwvTW2WUyYSbx1H4I00INjMD05ThSYg4PDIcOIFSjZwhtrAKBcFlEabM6ON1tkysf3fxaAcWmBc86MONceG+GGk21n32i/jmLE8DTsQJgpLHfuIM3ewcHBYfhwyAsUV8ouf1AlCygNNmso032TSNUfRWT7DXx1gS0gjp1o19gp9lvMHWUwKd9k3igdTZF467eiJesxvQWD/yEcHBwchgGHvD3Gk7DDA6tlHiWBZq2k2F3AtdNPJ2euxHJJqAXZQTSXvURiuvyYjmbi4OBwCHPIayieVDpG3Z+DS229blqhyahgR0UiW0fGSaF17yuRJlq8Dn/FO2ix6r5P2MHBwWGYcsgLFG8qQoggRTlqt9vuS9W0el964F2ebLySI6xNXe7nCu/FV7MRV2gnWrzaKXfv4NBHVFVl0aJFzJ8/n/POO6/fpeibePTRR7nmmmuyMlZLTjrppEwp+7Fjx/KpT30KgDVr1pCXl5dZd9ttt2X2ufvuu5k/fz7z5s3jN7/5TWb5ddddx+zZs1mwYAGf/vSns/bZs8khL1A8qTCVVj6jg53f5L2KnTeyOvwezwf8CCkJRspZtPFhfCRZYG3rdF9hxHFFypGKC9NXhOkK2K0ZHRwceo3P52PDhg1s2rSJwsJC7r333qGeUpe89tprmVL2xx13XKsy9yeddFJmXVMi46ZNm/jDH/7A2rVref/993nuuecytcROO+00Nm3axAcffMDMmTP5+c9/PiSfqSscgZKKUSnzKfJ33v8k35XLSfl2/s8PRxWjWCkWvv8QSXcOAKKL3imKEQOhZpIbHRwcssNxxx3H/v37AVi7di3HH388ixcv5vjjj+ejjz4CbM3jggsu4Mwzz2TGjBn84Ac/yOz/yCOPMHPmTE455RTeeOONzPI9e/awbNkyFixYwLJly9i7dy8AX/rSl/j617/O0qVLmTp1Kq+88gpf/vKXmTNnDl/60pe6nGs4HOall17KaCid8eGHH3Lsscfi9/vRNI1TTjmFf/zjH4Cdxd+UXX/ssccOyzL3h7xT3qvHqSWXAl/XDbXOLzkVt2nwYngDK2pf5tpEAx8tvJpF63+H0lkhLylR9BiWyz8AM3dwGDp+sfYXbK3rvmNib5hdOJvrj76++w2xa2O9+OKLXHHFFfa+s2fz6quvomkaq1ev5sYbb+Rvf/sbABs2bOC9997D4/Ewa9YsvvnNb6JpGjfffDPr1q0jLy+PpUuXsnjxYgCuueYaLr30Ui677DIefvhhrr32Wp5++mkA6uvreemll3jmmWc477zzeOONN3jwwQc56qij2LBhA4sWLepwvv/4xz9YtmwZubnNgTtvvfUWCxcuZOzYsdx5553MmzeP+fPn86Mf/Yja2lp8Ph8rV67kyCPbJ7M//PDDXHzxxT09tYOGI1DMOA0ySIGv+xI0J+TM58XwBv6RE+S1YD7XF89FIlDalK+REurjgnA9TM2LYAVLB2r6Dg6HFPF4nEWLFrF7926OOOIITjvtNABCoRCXXXYZ27dvRwjRqo3usmXLaEqAnjt3Lnv27KGmpoYlS5ZQUlIC2F0Wt22zTddvvfUWf//73wH44he/2EqrOe+88xBCcNhhhzF69GgOO+wwwK4Ltnv37k4FyooVKzLdGwEOP/xw9uzZQzAYZOXKlXzqU59i+/btzJkzh+uvv57TTjuNYDDIwoUL25W5/+lPf4qmaVxyySX9OZUDwrASKEKIOcC3gGLgRSnl7wbyeAoSj5WkET9jvN23/C3S8li/ay+XjC3lQw+827iRExEILEwLttZovLNfY0voAEn/e2jBjzjZPJFPdiBQpJTsCn9ErjufYm9HAmdk11hzOLjpqSaRbZp8KKFQiHPPPZd7772Xa6+9lv/5n/9h6dKl/OMf/2D37t0sWbIks4/H02xuVlU1U5G4p+XuW27XNJaiKK3GVRQlM25bamtrWbt2bcZ0BbTSVM4++2yuvvpqampqKC4u5oorrshoXjfeeCPjx4/PbPvHP/6R5557jhdffLHX5foHgwH3oQghHhZCVAkhNrVZfqYQ4iMhxA4hxA8BpJQfSimvAj4LZLVoWUcEiKMgieAn6O7+Bq67/NSOWsQlo88D4PHK5zluyhiM4Gvc+Uo5923cz+bgLchxv8ddsBbFFeL15PNUtogOE0iEZZCykkT0EPsiO9ke2jxgn9HB4WAkLy+Pe+65hzvvvBNd1wmFQowbNw4gU+G3K4455hjWrFlDbW0tuq7z5JNPZtYdf/zxmfbC//d//8eJJ57Yr7k++eSTnHvuuXi93syyiooKmgrzrl27FsuyMr1Umsrl7927l7///e+ZEvkvvPACv/jFL3jmmWfw+4enGX0wNJRHgf8H/KlpgRBCBe4FTgPKgHeEEM9IKbcIIc4HfpjeZ0DRhK2VJDVfjwKvpKKyYdGVeIBbC2ezsmYNbze+z51FBcCfaPqKNaGxJGcZz21z4S19jjv3PEiBlkepp4QxxedQ3JQgKcGnBojqYQxLR1OcysIODj1l8eLFLFy4kMcee4wf/OAHXHbZZdx111184hOf6HbfMWPGcMstt3DccccxZswYDj/8cEzTjvS85557+PKXv8wdd9xBSUkJjzzySL/m+dhjj7Uru//UU0/xu9/9Dk3T8Pl8PPbYYxmN48ILL6S2thaXy8W9995LQYFdfeOaa64hmUxmzHzHHnss999/f7/mlm0GpXy9EGIy8JyUcn76/XHALVLKM9LvbwCQUv68xT7PSynP6W7s/pSvP7HxeQB+qH2TJZ/oW1lub8U2Jn74/3hkxjJ2qTDNP5GjcxdSG9W46aVczlv4IWpwO3vj5WyP7+bKUedw6pTLifry+aj+fYLuPMKpBuYVHtFKoNRFkyyeVOCUr3cYNjjl60cug1W+fqh8KOOAfS3elwHHCCGWABcAHmBl+91shBBXAlcCTJw4sd+TSbm83W/UCT63YKpucJ5vNnVFs9qtL1ImcmzRGBqNCP+76/9RrYfYGf2Y0b4jOhjNwcHBYeTSY4EihHhRSrmsu2U9Ha6DZVJKuQZY093OUsoHgAfA1lD6cPxWGJqv7zun1VTRxonemQktbMaoS9ahR3aSslKt1llSEk0aKMPQ2ebg4ODQHd0KFCGEF/ADxUKIApqFQS4wto/HLQMmtHg/HijvzQBCiPOA86ZPn97HKTRjevquoTQXjOxYrpWFVB6ucpEb0EGFXbWjKKtyYSrV6KYkmQgR0w3Kat9utd9JM4r5QdDNYePy+zw3B4dsI6UcltFFDp0zmF15e6KhfA34NrbwWEezQGnEdqz3hXeAGUKIKcB+YDnw+d4MIKV8Fnj2yCOP/Gof59A8ltvT9x9KehfR5ktThf1+9U5bWAnNQ3AGfFjrRYSDaJpAUwR5fonXJQDJEZMK2FLeSFw3eW17DTNGBR2B4jBs8Hq91NbWUlRU5AiVEYKUktra2lYRZgNJtwJFSnk3cLcQ4ptSyt/29gBCiBXAEmwNpwy4WUr5kBDiGuDfgAo8LKXsVexstjQUUwpUj4uwGSVXC9pZifYBerS/zERetxYoBT7JxfNjeDVJ3BBMKY5wXyV8bm4dR40VGL6izLYtnfKWlFSEEnxzxXtYTiqKwzBi/PjxlJWVUV3tVMseSXi93la5LANJb5zyFUKIHCllWAjxY+Bw4CdSyvVd7SSl/Fwny1fSheO9O7KlocTwEvRIUpadWeuKVSIVDcNX3LMBmgSPbO9DWTq12UfSaHSfOAmgCMHY/H74dBwcBgiXy8WUKVOGehoOw5jeJDb+T1qYnAicAfwRGNBM9sEggZugGzyK215gGQgj0eP9m8RIS6e8aiQortncTsh0hi51Yka0x8d0cHBwGI70RkNpqu9+DvA7KeU/hRC3ZH9KPSNbJq+Y9JDjlqii+34oHU8kLZPTwsMXr+W4//4Ct253gnx38TeoKZnX5RApM0FZdDfehJepubMzy6VTfsXBwWEE0RsNZb8Q4vfYZVFWCiE8vdw/q0gpn5VSXtlU9K2vxPHgd7WIYxaiWUj0grzGPUzZtYpj3/5lRpgAHPle27iF9kKi1D+B2kQFEb2xOSLD8Xk6ODiMMHpz5/wsthP9TCllA1AIXDcQkxpMErjxuVrc5IUCSs+1laaw4ek7/8Ws7U9jqh7eXXw1KVeg1XaiGwkxLjAZ2UVfFQcHB4fhTo8FipQyBlQBTZXSDGD7QExqMIlJD161+WYvFReyr+Yv4K1jrqOmZD4vLb2D+vxp1Of13Yk5iOHjDg4ODv2mN5nyN2NXAJ4FPAK4gL8AJwzM1LqdT1Z8KAk8eFQNXTZFZIkWyYrdEwmOZdekZeydcApxf+vIMEvREFbHJa27w7F4OTg4jDR6Y/L6NHA+EAWQUpYDOQMxqZ6QLR9KUnjwqe7Me2HEQen5aZGKykezLmwnTNqSE7ZLl83e9k/OebbDSGoHBweHEU1vorxSUkophJ0CLoQIdLfDSEBXPLiBkBEmakQYrXltx7yUPU5u7Aq3HuGMVd+gThEwaXCSixwcHByGgt5oKE+ko7zyhRBfBVYDfxiYaXWPEOI8IcQDoVCoX+MYwi4Pb0gTM1aB5c7BEhpkyUEejFYikOwfe2xWxnNwcHAYrvTGKX8n8BTwN2w/yk19KcWSLbJl8pLpHiRNFX6l6gGhkY0WvMKyU3dqCmezbean7fF7um+/j+7g4OAwuPSqH4qU8j/AfwZoLkNCk0BRhYpU3aRyJuIJ7URIC9nPu3phww4A9kxckln2s+JCooqCK1nH2qqXyXHnc8yopSh9yH1xcHBwGE70pHz961LKE4UQYVo/YAvsHia5Aza7wUCxT4E3GSKqepCqGyk0hNXz8iudkXTn4kk1Ul0yH7dsjva6uzAfPvhB5v32ho1cOuvbAAg9Bu6Dwj3l4OBwiNGTasMnpv8fsoiugUCRaR+JqmEhcZkWituPYem4FRVhdr1/T3j9+B8hpAVCwS3c3Dj568x782YuGVvaarttjZswU2FcoV14UyqJMUcBTh6Kg4PDyKJXdhYhhCqEGCuEmNj0N1AT68Fc+uWUV7E1BqG4sKSFonlRAuOoTlSQlCbI/jvldXcOKU+zj6fAlceCZIpLQuHMsnML7DzRA/v/gxavQjHTmtFQO1HK34cdL8O+d4Z4Ig4ODiOFHgsUIcQ3gUpsH8rz6b/nBmhe3dJfp7wq7XL1UtGwpIlQ3ZiaB5fiQgiVbEV5dcQP6+ozr2e7xwBQo0gMXxFS6VppDKfCbK7tVeuYvpGKQLQS1F652RwcHA5henO3+BYwS0pZO1CTGUy0Jp+Gotnl6hU3SSuFT/MjFd12EA3g8X86/Xp0lx/RsBUAU/bMxrY3vJeqaBWGaaCpGvOK0pWMy9+z/UGpKARKoGhazyaSikIyAjmj7ffxeqjdAXoMgqMYwvqfDg4OI4zeCJR9QP+SPoYRalqgSEVDpkLgtjUdTbjs4pBZMHl1hS8Vwp+oJWba87CwMKTBx4n9jE1v07Z8fWW0EgBDGuwL7yPXk8vm2s3My5sBkWpbCJgp0Dw9n0i0GkL7oH4XWDoobgjthcCoTMCCg4ODQ0/ozR1jJ7BGCPE8kGxaKKW8K+uzGgSaBAqqy75ta34EpPuiDLR+Akoqhh4sxXIHoMpOrIybCSzhJ2Xap7cuUUdDooF8bz4AFbEK4noc3dKZ4ilgd+NeprnybaFgJqFgEkRrIGdM9xMwDTDitkbSeMDWRhKNdoRZcDR4ciAVG7gT4ODgcNDRG4GyN/3nTv+NaJp8KCgaWCbSk4OSjdCuHmL4CkEoqOlM/YpkNQsDMwgZYVKRXUhpoVspPg59jDfqRSAwLIP1+/dQ6BnDnvqt5LrqcZsquPy2gOiOVAzCB+zt63dDvM7WxDQPePPsPwcHB4c+0mOBIqW8dSAn0lv6W21YaWnyUjSk5kW1kt3slT2k5gVAEyqqUFGEQoErl3qjior4PiQeUnqM8kgCv+ZnlH8U/927A0sPUh+LkpMIk8rLp9btpkRPgdUDYVizDRr326+NBBRM7lMzMQcHB4eO6E2U10whxANCiFVCiJea/gZycl3R7ygvy9ZQhKKBoiJVH+oQ3FyFEPgUL+80fkCdHqJIy2GiKVAAn24wNX8qhjR4c+9HGIaGIgOM8aZwKyYCiBtpU1fR1I4P0HgADrxvm8JSEVsjyx0LhVMdYeLg4JBVemPyehK4H3iQ5v7yIxYl40NRQagIpcl3Mvh8smQZ/1fxDD/f8wduG3MJQTMJcgopw+TD8kZMKwcvfkxpMq7AhxWOIBWNHM1PyIiwObwHgHm5UwBpm7UsE1w+CJVBw24wkmDotm/EwcHBYQDojUAxpJS/G7CZDDJKOkxXRSAVFTGE4bGLcuZSkazhxfo3OZCsZlr+XEAQNQSVjbYZboI7QrFHwcCHkAZSaPg1L7WpRvbFqnArGgLB3GQS9CTU7ABvLugJW7jU7bId7y7fkH1OBweHg5veCJRnhRBXA/+gdZRXXdZnNQiIdOKiIiykUBFZ6H3SH2YHpvFi/ZtY0kSqXoSAgAbj892AwN1QhrAMDG8+WrIu0/d+gn8UAPWpMIWuHEgm7egtXwEkQj3PRxnB7AvvozHVSIGngLHBsd3v4ODgMCD0RqBclv7/uhbLJNCJ8X54I9J5Jqqwy68MNU3l86205iQAYRn4K9+zG31ZOggNf9X7mHoS3O1zTWpTIWpjBwCYWzQdEei6i+TBQm28lvJIOTWuGsoiZQS0AAiYmjcVn+ZoZA4Og0VvorymDOREBh87z0QVAsMVHOK5gJI2uem+ouaFloGZzkFRE3UoegQ9Zzy6ZqEq7TWqsBEn5QlgSckHoR1oQmVe3oiU970i6ApS5CvCq3nZ27gXVahoqsb44HhHoDg4DCI9FihCiEs7Wi6l/FP2pjN4NPlQNEVgat4BTmPsniaTm9VJDTHL5aeroIGwEUMTKl7NjWkZ7I1X4VPcGNJES2e8+xQ343wleNQRn0bUIZqiMTXfFqD18fputnZwcMg2vTF5HdXitRdYBqwHRqRAyfhQpJGV3vH9RUkLC9myZn2L11L1YqreTvef6B+NlLKVL8iwDMri1fhUD6a08Chu6vUwXtVDQPUyOdCDjHoHBweHHtIbk9c3W74XQuQBf876jHpIvxMb0zqJUFWkSD+xD6JcmfbxSj6ednaL+dgmL6tJVxLQ2/IvbQMLNEVjcmAMVtpfZEqL/fFqXEKjyJOPIU2mB8d3M6q0BdswELptiekxdoZ2opt65jM6ODgMHf2JlY0BM7I1kd7S38TGpgZbQqig2aVNFFTEICX7zfg4Xfk/Mw/7hv1O4weZbSx3dnJGFKGgCAVXWsCM8hZQnaynPF7LuvqtrK/fxvsN29ncuKvNnumclqqtWZlHtokZMcrCZeyP7Merda69OTg4DA698aE8S/MjswLMBZ4YiEkNBqLpoygak3JmEbbiNOr1GU1hoDFUD0jJmf+5hp2TTyc1/RwAtsXa3tRb82Tlv1jb+D7nFS9jUtHJfTq2S9GY4B9FTTJEecLuRiAQ5GtBGvUoua50C2J3wK5ePAy1EwBNaOS4czLFMx0cHIaWnvSU90gpk8CdLRYbwB4pZdmAzWyAUdI+FKFqKJoX9AQCZcDzUV4/7scsfv8BFMvAF7dv5hPKXmXbzE8x1TuenYky9iUOIII7kcxrte/+RAVrG98H4NmaF3m25kU+N+FUPjn2pD7NpdiTR3GLjpI1yVD78jNOCXsHB4ce0pPH8bfS/39FSvlK+u+NkSxMoFmgoGggBFJatkAZYEdKJGcsodxJ+BJ1TNn9HwBcRoIzV13NWQc2AXDPvj+ilD7BOu/NPFL+FGA72H+z79F2463Ytzprc4sZCXZE9mdtvIFkf2Q/H9V/RMJIDPVUHBwc0vTk8dMthLgMOF4IcUHblVLKv2d/WgNPRkNJZ5xLZCa5cKAprVwPwMSy11otvzQU5t6C/FbLtkR3cN322zNRYABH5yzkglFn8MOPf0lATedZSImix3BHqjB8BRi+1uP0hFHefOr0RkJ6hLxhkJvTFQoKVbEqJudNHuqpODg4pOmJQLkKuATIB85rs04CI1qgNJl0LGkNuHaSOXabdr/lpUexbcYnmbHjWT7Y9TbfnH8mL+8dj1K0KrNNU/TXF0s/xWzfDLypRmb5xxK2UqiJEFNW/wxPpCqz/eblj7Q7bmUowagcb6dFhr2qh4SRbPYjScsuKqnH7dpg+RN61w1yIBFQ6C1E6WEQhSUtauI1VMeryXHlMDF34gBP0MHh0KNbgSKlfB14XQjxrpTyoc62E0KcJqX8T1ZnN4A0OeVlOpJKYg1aOfdwcCw5kXJeP/7HuFNh6gpmghDUFM9h3IG3+WzesbxcP53D/Sew/LAY9+//Kzvj+wiofhbkzMZKxVn26o08NbqEj/w+Zj7zfRTLoHruuZRsea7T48Z1k9pYinjKFmgTCnydh0pvXwUv/8zu/njubyBcAakwjF2c/RPSQzbXbs68bpWv0wEJM0FZpIzdod1oqkZMjxE34sSNOHnuPEegODgMAL3JQ+lUmKT5BTBiBIqa1lDUdLtdKeWg1Rtee9R30PQ4cX/HtbbGl78Jws6vEULw9fGXsC9xAK9iawdT9q0BYE4qxet+H6ZloABV8z/dpUCREqobkxiWhaYq7KuP45VJpsZ2EJ5wZGY7pWEfvP5r+034gK2hKCrkTej3Z+8ruqlTG68lnArjUlx4NS+m7LyLglfzsq9xH7qlo6AgkYzLGUeeJ49IKsLmms0gwKf5iKQimJbJ5LzJFHgLBvFTOTgcXGQzhGd4xpZ2QpOGYnlzAeyb0yD5UHRXAL0pNLcFLt3u4T511yo2K6vYWTuFbelanBO8zVntcz5+FgBx2Gdh3785fMpESg2DO5FES2YiO9G0UqZFNGUwOtdLbSSJblos23gfo0Lb2fWJH1K4/UVy/QUEPkqb2jw5YBl2YUpPDiCgcgvEamD0fPAXZvGsdI8ilIzPxLRM1LT/qyMKvAUdCgcpJXWJOsKpMAKBEAJNaMTNOBNyh05gOjgcDGRToAx1OaxeoUgLWlQaFkIMmg+lM7yJ1p0Apuq72JZ+rZg6qplEdzc7y5eMOZYH9v0bgApN4/6dT3OnlASrt1Ly/t+oGXUYcsxMTEuiCsGUstdYvONJdk9cwuS9a4h7C/Al7JpXU166HYBMEPHx37TNXFuegeIZELVDnInVQGM5FEwddIHSkq6ESVcIITL1vppoTDXittxD/v07OIx0DtkesBmTV7oVsJRyyG8o3kQDAJZQaJC24Ji49xV8sRpOfv1mlq35AQCh4DiqiuehCIXHjrmVBw7/AYXuXMoTNYjaHawM+Cn88DmKN/2TfbUxzE1r0De+yOIdTwIwee8agIwwAahccBEAtWMWELn4LzD/QlA9toYCaQd9HEwd/EUM1vPDzoadGdPVQJHrzh2wsR0cDiWyqaHs7u8AQohPAecAo4B7pZSrut6j7yjCviGafrtcvCRdr6obZ+9AsmvyaeSHdvHWsT9k2cu2qWvu1sdbbXPS67fgi9dQVzCDhG7iVlVytQClnkK2hHdzzGTbbHM98PsDOznzP99od5xIoJRgtIK3jvkBFa5RTBmdi8vlombuOTQkG1nQpHkoKkjTPieJBjiw0TZ/AcTr7aivASRpJqmIVpAwE1TEKjCtEd952sHhoKY3pVfa5aC0RErZ4XohxMPAuUCVlHJ+i+VnAncDKvCglPJ2KeXTwNNCiALszPwBEyiZeahNphOJYGjtduHcCbx60v8CYEqBKiT1eVPYN/4kFmy2izoHYlXsKVjIq97jKWlMoRsmhpQdJiR+bcwo/r1vP3WKyhO5Qeo0D5NGn8Rho5dktrGSRufZ8E1mJWml/wxbiERrBiV8WCCwpMXowGh2NuzErQxs2X2nwKSDQ//ojYZyBXA88FL6/VJgDRCi63yUR4H/R4sy90IIFbgXOA0oA94RQjwjpdyS3uTH6fUDTpMPxUqbvOQwcQUlceMnyfrFX0d3BzMC5WvjHuLfH/vgANw1ro5wUqc44KFEK2G/Xs4x5HGclcPE6vf47ugSzpgwrvXAjf+1/4BfTr++60k0CRTLSLcSTpsEVQ3adrms2wX5E5v3yTJt/R7ZxrAMEqaTde/g0B96I1AkMFdKeQBACDEG2yx1eZc7SfmqEGJym8VHAzuklDvTYz0GfFII8SFwO/AvKeX6zsYUQlwJXAkwcWL/8gmaqwsPvQ+lJf/gFC5hVSYabP2iK6nbvMUWJmka4gaqAqoi+OakL7A7vo+pvomkDIvGgqWcHd/AytTGzPZFrnwUFKp12/kfsxJAF+2PRZOGYoLSjUbSWA6N+2HMwnRE2MjCpbpQGRhh6OBwqNAbgTK5SZikqQRm9vG444B9Ld6XAccA3wROBfKEENOllPd3tLOU8gHgAYAjjzyyXyqF0OxTkDQTDKfI59vlF1ld+hkuFrbP4jXlSH4dXgLAuTOjPLctgGFJfJotEFWhMM0/CQCPS4XCUubGlnFyzplsimxjYc6czNhvNqznH9WruGXn3faCvfZ/C/Om88UJZ1CXasSveZsjqTryXZgpSEWhZhuUzLYd9noSjBQMk2T6viClZEvtFhAwOXcygQ7Cux0cHDqmNwJljRDi38AKbG1lOfByH4/b0Z1bSinvAe7p0QD9bLDVYpz0hARD7kRpQTil8vKeAJtqTAxTUJ+wBcftp4dYW5b2JUhwqR0H6nk0ldG5tkBoKUwAjs5dwGsN71Cjt26T+35oB6WeQgKaj7ARYxbC1l9ita21jlidLWRC+2xzWGO5/d7lz8pn31y72f4eBAMa3dUS0zKpTdSS782nNlFLXI+TMBIsHrW4x+VdHBwOdXr8S5FSXgPcDywEFgEPtO3i2AvKgJYhQuOB8t4M0N8GWxnSjt4JwamMD0zp31gDQHVUZVyuyZwSnR+eFCbfKzPSOODV8Ll7b6bRFI3rJ3+Ny8dcCMAkfynfmv4ZNKFiIak3wuyPVxOqSTfW+ttXWg/gzbMd84FiSITs8iz5EyDZCKH+F6EOJUKZxlmD5dcQQlAZq+SDarvB2fjc8dTEaniv6j0+qvtoUObg4DDS6W3Y8HogLKVcLYTwCyFypJThPhz3HWCGEGIKsB9b2/l8H8bpN2r6CV9r62QeYn55egivJnF38Q35XSqdKCg9Ym5wBrdM/D7TRgVxqYK7dzzJS9XruGLKuYT0CB9MO4FPbF8NlkFVop5R6czzqNvPbsNNUaKW0pJZzQOauh1e3IuWwVWxKqpj1XbCYd5UvJoXC4vxud21Js4uhV47VLo2VpvRn8fljGNveC8NSgMJM8GknElOMy8Hhy7o8e1ICPFV4Cng9+lF44Cne7DfCuyeKrOEEGVCiCuklAZwDfBv4EPgCSnl5q7G6WDc84QQD4RCod7s1o5emzOk0a/j9ZRcb+fCZKAqxByWOw1TWtQkG8hzBRmdP5ldU45D17zoLT73rugB9ser2R4ua902OG+c7VvpIVJKdoV2sadxDwciB1hXuY5NNZt6PW9LWtQn6llfuR7d7J+JLGElMuHDQggm5U4i15PL3sa91Cfru9nbweHQpjcayjewo7PeBpBSbhdCjOpuJynl5zpZvhJY2Yvjt93/WeDZI4888qt9HQNAKL0TKK5IBVLVMPyl/TnssOTiCZ9g4+aPWV31LssnnApAjjsXIS3K4tXUp8L4VA95riAhI0rMSNCQCrOhfhulviJKvUV2IckeIpHops6kPDuY4EDkAAkjgaeXOS43vHYDexr3tFv+lcO+wqmTTu3VWC7FRaqNUPS7/BT6CvGqTt96B4eu6I1ASUopUxknthAaw8aF3Q96+bgvVReiF0/hI4npQdvMlGzpCBd2rd7aZIgGEcanesl3BalLNTI1MJb6VJj9iRriVoraZIgcPUlfA7nHBMdQG6+lMdloF3aU2Bn5qSgES0FrcblKbBOb5molTIq8RdQm7Lpju0O7ez2HUf5un5EcHBw6oTcC5RUhxI2ATwhxGnA18OzATKt7shbl1ctEPClUxEFWAq1ltZmg5sNskTEuzCSKqXPa6l+y96Rr2Rdwsy9eSbHbDoYocOdQ4M5hZ7SculQjo6RCiRHH113Elx63BUUbinxFFPmKwNCheqsdPRavA3cQtPz0vglo2GOHKI+eT447h2PHHMsVh10BQMJI8K2XvmUnqVZutR8aRs1qdywHB4fs0huB8kPsbPmNwNewzVUPDsSkekK2TF59yT2Rw6Vr4QCgCrVVCRJ/7U4AXPF6pq26lcTyRyjx5Lfbb2pgLAD76nawpXYLXpedgDmncE6HfiqjfAMhPQzeNoLHNKDuY1sDaapw7PLbeS4NYUjFQI9BKoIUGslkI0haJaV6NS+KUNJNuCyQI/8BwLRM9jTuIapHmZg7kTxPP6MbHRwGgN402LKAP6T/Dhp660ORipYuImk2Z5IPEQNRfUxFwWjRuCpWNBVf3e7M+8kv/YJA1Vb2HX8VjROPabf/BF8xO6MHcCtuXIqL8cHxzTe/UJmtXUSrqQ/tYS86yHzw5IOSFgg12+y8FyNphye7fHYZ/brddkCEadrPAMHRrNr7Io9sspMzWzXbSsUQloEVq7FNZgdBZFY4FWZHww50U6c0cPD57xwODnpTHHIj7e9eIeBd4CdSytpsTqwH88mKyav3FfwFUth+FKn5ut98ABjIfH5TmuyMlNvl/IWgctHnqJl7LlP+81OSeePIOWDnaRRvfaFDgQIwNW8qCNjbuJc9jXuYnDeZur1vEY1VM1r1UWhZCEtH1xtJxWttX4jLbwtoy7SFSLCFL8OXb//vad1/5UDKjrqamDORw4oPsxdKILQPIS1beKWi4MlOefraRC11SbtszcyCmbj6GGoupaQsXEZjqhFN0RgXHEfAFUAIkTnv7fZB4nf5QaPD9Q4Ow4HemLz+BZjAX9Pvl6f/b8QuAHle9qbVPVkzefXhxykVFS1WhZ5zEHT4a/PxQ0aUkBHlp1v/xI/nXGZHtPkKcMdqcceanxlkD8Raib+EA9EDNMRqsGo2k0iGqNG8FBTMwLAs6uN15CoaRKuhSTgnGiA4uvVAndQGWxu2Q5Z/OetSe0HFJls46XGEULDcPlsYtXAS1cXrCOthJuVO6nb+LVGFSmW0kqSZRBUqjclGwI4AO6z4sF6FnyfNJLsadxFOhtEUjZp4DV7NS9JI4k2XvNFNHa/mZUxgDIXeQhKGU7jSYfjTG4FygpTyhBbvNwoh3pBSniCE+EK2JzZo9FGgDAcGonXLZ8Yt5cn9L7OpcSd/3vNvvjjpjFbrI6PnoqZiiB4c3Kf5GG+CGa8ExYM6eiENqTB74hVgGhQIlfyimXZp/FAZuP2Q17OExhX7VlNn2C2TaSy3y+lbum3e8hUgFJWEqbMlVonq8nL7C5fj03zUpbti3rvsXtv5j53HsrF6IzMKZthaQAfkuHPIcduCTUpJ3Ihn8l9ieoxgi06a3WFYBoZpMDl/MgAxPUZDsoFcdy4V0QoAPJqH6ng1DckGXIoL3dIJp8LkuEZe4U2HQ4feCJSgEOIYKeXbAEKIo4GmX9HgZPsNAH0yHgitr3tmBzFw0doXjl/CkpLFfGPDXTxf8SbPV7wJwGeLCvhBysOepdcx4dW7ccXrOh+kKh1ZpcdAT6CaaX8IkO/OId/d5qYoVCjoncawN1YJwH3zr4FASbv11ckGqpMNrK3fklkWN5pzZL7x4jf4zMzPkOPO4eFNDwMwNjCWu5be1e2xhRAZwVOXqKM6Xt2lQNFNnS21W9AUDYkkZaZIWsnMer/LnxmvKSenCcMyCKfCeFQP+Tn5NKS7ejo4DEd6I1C+AjwshGj65YSBK4QQAeDnWZ9ZN2SvOGQfI4CGiZbSX1KGRW00yZi85qS9Ik8efzrqxzxVtoZnDrwOwBO5OZy56Pv4gW2KSVKV5EqrvaknFbez5U3D1hhyx4Ka3d7zVYl6tkf2MStnIoUdCBOAgOolmq4DNsM7igJXgOWTzsKjx/n2tj+hS5Mntz3Zah+ts0ZjXZDjatZcOiOiR6iIVWCY9nNX0BNkTGBMj8bXFM3OyWlB3Ii36l4Z0SP4NT8udXiVD3I49OhNlNc7wGFCiDxASCkbWqx+QghxmZTyj9meYBfzyVLYcB+P34ebz3AkZVoYZnuNx624+PzE01icP4NbP3wEgC9vuNNe6QJcAtbeyndmXMwxhXObd8wbAw17+6R1dEXUiPOviv/SoEdYXfUuYAuWzrhzwTW8XL2eWe5C5mm5kDPajhxz5/Lnw64llFNKzOVmb3gva/at4eOGj8nNkvO+LQJBwBWgIKeg+427QVEUdod2Ux4pR1M0DMsgaSYJuAKU+EqYmNs6rfRA5ABRPcqY4BgCrkCnTn8Hh2zQ67uilLKz4lnfAgZNoGSNPvy4DF8Jahc3s8Hiey/k8T9LGhmX27/WtV2dgTm5k1lx9C08X/Emf9nbviPzPduf5O5F32Zi6ADxwqlIzQ2547oZtfe817Cdp/avabXsezOXd7wxdsLlBeNOgXiDXRFZ89p/AEaSPHcOeYFCxgTHcMyYY/jft/6XSCqSlblKKdnZsBNVUYnqUXxZjAbM8+QR1aMkjSQRPZLx7VTHq9FNnfpEPQXeAmS6YVxlrJLaeC31yXp8qg9TmhjSQBUqC0sWOsLFIatk8zH7kLkyLc2HVDSEmUSqg5/kuK2m2bTxv2tyUYTEkoKlU5KEU4L3yl2UBCxu+UTrQtDvHXAxf5SOq421rrtUHCEE5445gbNLj+P7H9xLeaKG6akUiwITeEqv5JoNdxG0LP690c++ZTcMiDmwqTXzNdMuZGe0nE+PPZmcnvRfcfu7LlhpmlD3ccbpnQ3iRpyySBmGtJ3vbtWdlXGbCLgC7Rp/jQmMYW/jXixpURmrxG7vI/Brfop8RSSMBHXxOhShYEiDgCuAJS3UIc6lcji4yKZAGZF1vfr6gCaFijDiQyJQ6uOtJ21J+/3Lu5rnUhFRWVfu4oixdl2uXfUqv3+n9U3opiWNvFfu4+ycnn11ilD4ybyvMu7paxhrmERFJWphPo/n5hBRFC53NXJNeD+jcsZ1P1gP2Ber5M5tj1GZrGN2jm0+mx4cx4nFC3o+iOpundPSEtOESAVYBj7N13lRyqqP7PyYvLHNOTFpLCwqo5UkjATjc8bTkGjgQNRubFoaKMW0zEFp0KUIhcl5k1vPTVrsbdzLKP8oCn2FFPqafVn1WdSwdVOnIlaBR/WQ484hqkepjFWSMlJMzJ2YiaZzOPgZsRpK9hIb+4iiohgG/TM29Q3Dan2qf3ZqiBtX5zExz+DGUyI8ucnLizu9/OHdAM8GTSoiKlcc0b5u1m1rbJ9BXSLJjZ/o2bH9mpexhu0QDkjJj2vrubG2noVTJrLN4+baLQ9w3+LvUejuvz9iR2Q/lelEwq3h9tWE+4yUdgRapNLuOGnq5Bk670fKiex6jbiVoqR4tl2OH+xto9WgudoJFI/qYV94HzXxGvsmaqZoTDVmhIg6hMEbilAYGxybdQ2pIlLBnvAegq4gswpnURWrYnPNZjRFw626SZgJNDQSZsIugYMkz5130AcNOP6p7AqUN7I4VrdkrXx9n3e0NZShYGqhQXm4+UZV6Jfcf35D5n1Lk1ZFxH7z0Lpm7eSLC2P8+f1mc9HYHIveVAzYeeqNuGJ1JAomMeP5Gzhw9BXc6RJ8v9z2sdyw8X5um/cVfKqH3H70ZG8yc/2/Rd9hU+MudkbLGeXpv2ObZNgu52ImQPVAMsqr6fDir2y+N7PZxbMu5tOlx9kZ98FRdHSOgu4gQXeQhkQD4VQYIQSlgdJ2JfCHiu6EiW7qmNLEq3Vemj9lpmxTmWWgCIUD0QNE9AgNyYaM38nv8rfTRFJmitp4LVXxKtyKm7HBseR78mlMNVLiLyE3Cw8dQ4mUkogeIWkmMSyD/ZH9aEKjNFCKR/UQcAdAgiHt89aUnNpVHbbOvo+6RB0pM8Uo/6hh3ZK6N6VX8oFLgckt95NSXpv+/5osz21YY0d5Dc3TyMXz4yydkuT2V3P41Nz2Qk3tYloXzo1zwqQUJ0xKEUkKvv/vPDS1d9bKePEMmo66+eKHQCiMB95740GuKh3F2z741vt2ja3vzVjOUYVzOh2rZwiWlCxmScnifo6TGc6uYOwvtJ320uKO+Vdz/ab7sVronI9/9DjHu0czWo+Bu2vHettOjn0JQR5MTMtkQ/UGEkYCTdE4uvToVk/XkZQtMNyqm10huyJBU5WASCrCqMAo3Ko7I1CaOl62xK26GZ2uehDTY+xs2IlLtZM0q2PVHDH6iA61luH6pK+bema+UkrKImXsbdxL3IjbAsNM4FN9hFIhEkbCjqpDYlgGmqIRN+K4FXdGWGiKhktxoSkauqkT0SOZmnQe1YNX8+JVvRjSoCZWgxCCHHdOO//ZcKI3V/1K4L/Y1YaHwtIzIPT5whUKva8Dlh1cKozLtfjtuR0H3NUnmj/TCROTvLG32TcwJsdst73oj2Bs8bSkAQ9WVPHkgnNZ7Za8WbuRdQ0fdSlQXqx6lz/ssrsgXDDuFM4tPZ7vf3AvdXpj3+fUHYFRtlARqp2lXzCJCcBfj7mZ5W/fDMCnSk/g6Yo3uOnDB7lvymex9bwR6SbsEI/moTHVSL4nn2iLNgK6qVObqKU6Vs2exj0E3UGSRpKgx9bE3Iq7lfDsaYWApuRNK527VB+vz2igQKZrJ9g304WjFmaexONGPKuRcn0haSbZULUBsKtZJ4wEUT2KpmiMCXacU9Sk0SlCIWWmKPAWkDJTWNIiYSaIp+IkjASmZZLjySHXnYumaCTNJDE9RigZwrAMXKoLVagIKUgYCfyaf1gKXOidQPFKKb87YDMZaUir+/CoIeKTsxPUxhSqoyqfXxDn7JkJfrTaVrPLGlXmj04XNkhfk67+NKbvgGPypjJ33GK2NO6iUW++WflqdyIBYZlMffFnGKqL5RObf4x/3/8Kf9//SrvxCrtJHOw1rhbmhE5yZc4OTOJZ3iJkxPhveBcn5LSo8GuaoI7s6KiWpWQaZSNb67aS68lFFSrvV7+PaZkU+YuybpZqEhIpK8Wu0C4Sht1yOayHMaVJwBWgJlHDxuqNFPmKqEvUEdWjLChZQGOykfJoOfOK5nVpossmUkoORA5Qn6wnrsdxa27qEnX4NT+jA6O73Lelltpkemz6v6v5ezVvh+v3hPawpXYLo/yjmJo/lYZEAyX+jhN7h4reCJQ/p/vKPwdk6kZIKbuowXEQI9Rhm9yY55V85/jmG3mRXzKrWOejGjtsuC3Zeu7ee+I3mfj6b7HS5yVixFnfsA2A3H3vMP6N+zK60It+H7cV22aSHM3PNdMu5OHdz2ec8JdPOpsidx6HF8zs0GYsjCRaPISek90Oi48eeSNKtBa3qXPHgm/w3Q9+y28rXuG3Fa9wRvHhXG6eZzvypbTrh42aBQ1lEChuLahGEG7NTVmkDD2kU+QrQkFhfA9rqvUVn8vH7sbdIO1otLE5YzM3YIGgLllHbbwWVVVJ6Am21G4hqkcxLKNVv56BImkmqYpWUR4tt/N+zCRBV3BI+9CMyxlHwkhQn6jnvar3kJa0v69h5FPpzR0xBdwB/Ijme5AEpmZ7Uj1hqKO8UjnjUeODWrG/X7QUME1kW2k2vLmtxh3rLWZvvDJjRmLKRM6KRBlnGDyY3/zD/NqUT7Iwfzq/WnANX3jnNgDm5k5hkhYkuO8dguUbqZ1zFsm8cajJCNP+9SNcCdsktu/4q2mceFTWPoNX9UDOGJAWYxWV3069mG/ufByAV+s2cnnR4bbgSMXs7So/tD+xHoWSkdkVMtedS647l6SZ5EDkAONzBlaYtDxmR7SsbQZgeAxieow8Tx7hVJhwKtxpEc+2NKYaiaQiFHoLM6anJjNdU0h3S/NRU921xlRjxjfSmUlrsNEUzQ4ASTaQMlL9M1UPEL0RKN8FpkspawZqMr1hyEuvCNchlMrZU1qfkFvHncHlO/7Uatm/gu0disF0d0dNUblv6sWsrd7ASa/dS6B+b2abgt0dBxFOePM+Nk98pPUsjCTj37yfmnnnYqluFDNFvGhaLz6GyDRPKymZy2Mlt/LrbSvYH6uC/HTLAjVkhx0HSmxtxe2zhcuoORA+YOet6FHbX6N57R4vw/x68ageJuRMGNJQ547QFC1TFkdKSX2yvp25qanHTGmwlNp4LX6XH5/q44PqD4imogTdQUxp4lbc5LhzSJpJkmYSBSXTMgAJCTNBdbya0kBpq7yd4UR+umNqfXzoq3W0pTcCZTMQG6iJjDgESKEhLGPYmr56SrZdzZNeaa7YuzH9f9iXz+5z7+CaD+6mLtXIWMVHuWXHii1e9ROm6gbbzruDk168g5N6cIz6qSdRsPO19iukZOaz30dLRsgt35BZvHn5I+237QWa4mpdUtubBwi7AKZlgg6kIlC5KV1lOQlai5DdnLHgHf6l54ebMGmL3+UnlAzZpfzdOZnWA0nLdmQfiB0grsfRFA2v5iVlpBifOx5LWggEZeEyonoUExO/6sftchNKhYjpMSxpke/NZ3zO+GFlRhpJ9OZOaAIbhBAv09qHcm3WZzWESCSVyUqm9GRjodi5DErPe2EMSzqQKPvq4hQF3fjd7W8wDTGdcMLAtCSqIphQaGsYltY+56HsmK8SmnQsKAoKcN/i7wEQ2PAY5yU/BGCibt+qZz57Xat9k8FRlB91ORNfuxvVSPDR+b/C8Dc/NTYJlHmPXY6lqChW+wi2bKEJlYpkHf+ueJsidx5HFMxCuAMQLrfPXyJkZ+XH623fSs4oCB2wO1EmI5CfvUKZhzJezcue0B4SeQly3Dnolk5dog5N1fC7/AgEBd4CdEvHsAxy02bYJgExIXdCJoy35ZhONn926I1AeTr9d1Chm1arKCcpJT21TUihoKYaMVzZEShliQpK3IV4lOxmNneH2eIzSwvKGuLopkltJAUBN35Ps1DZV2drFSnTpD6mUxJsdkQn88aze+l1TH75DlL+Ij4+6ydYnTiqlaLprHnrP1QuuJDQzNkUbWsuPLl7yfeJlcyyG5kJwdYL7gVklzXC2gqTmtlnUrz1hd6eik7xp6NuHtmzstXyMd4ibp11KbmevPZ1fKRhm7+a6omlz0XKTPHo5kfZVr+NC2ZcwPyi+QTdQapjdl+VjvIMkmaStQfWogqV+SXzR3xSYF9RhEK+Jx/d0qmIVlAdq0ZK2S4PpitNa7jnCI1kelO+fuRVEu4Be2pjTB/VLBCaqrT2CKEizPZRU33FpWjU6yFKPYMTCth0/0sZkvqogcelUB1O0pCIo+LCq0FNJMVEj4+qxiRSQtIwiSQMDEuiCYEiWg8YHTW3R+al8PjDSZ71M2TOaCqNJIY3h3jhFKKl89pv3El49sen30zO/g3UzfgEUlGxXL7mvBjLIplTSqDyQ/L3vo2aaMT09v0mfMHYU5gRnEDEiPHw7ucBKHTnciBRy4u17/Ppcae030la4A7Y/4cPgDcXJLy7/y1e2vsSAPesv6fdbgWeAvK9+cwpnMMX5n4BRSg8s+MZ/rb9bwAcM+YYvnPEd/r8WUY6mqqxo2EHhmmQslLd9qNxGDx6kym/iw6MI1LKIYnyyhZtUzAs2XOziVSy62VVhULCGvySHaZpUdYQw6Uo7I6VI6VCsVpEQhd4XRY7Kk1QwLQk8aRJQcCDAKrCCaw2rYB31djRZGMLfMRTJvk+F6a0TWOtEAqpHNuxKjUPNXPP7fW8E4WTSRRO7nilotAw7RTGvfMoALOf/hYViy4meGATkTHzqJ+2xBZAPSTH5ef4ovkAnD76aPv4ZpIvvfszHi97qWOB0pTj0rCPhkQI7/71xI0ET21/AoDjCuezP17N3nhlq93qk/XUJ+vZFdrFyl0ruWvJXXxYZ5sHVWGXxD+UcQTI8KU3ut+RLV57gc8AwzMMohcoHQiFnouJ7KrOGkPjEE2aFjkeF6oiKBI+ctUc6vQGfEYBCd0kkkqiouLRVPJ9bjqSo7opqQglSOgWppR8XBVBEYJo0iBlWIwt8OHRWkvvhqhOns/FYPk/SzfY4b/Bys346nZTdvzX+zVeZ6bJlKXzcWQ/c3InI6VkV7yKGz96sN123xr7CdDcWKPmsj9Zy9jAWExpogqVuBHnK6u+AsB31zTnE88unI1uZU8rdnDIJr0xebVNuviNEOJ14KbsTmlw6VjJ6KnJC7JZfqXP7Yj7ery0wtlSg/ApHvyql5ChkOtX0NCoNWOY0iJqGRSopa3GMCyL3TVRLCmJpSwShgkSRud6qY0mMeMS07L/WtKY0KmJJQknDSwpmVDgH5DCA6bmRTUS1E89CW/dbhRTxxOuQNH7X9hTCJExg30c2c+04Dh2RQ/w+51PsztWkdmuULN9IicXLyRlGRyTP4t5it+OEDNAsQwmuApAUVHTDxVBd5BHz3yUf+/+N1WxKsb4SphSMINnPn6Gulgd2+q3UZ+opzRQSjgVZmLOxAHrOOng0FN6Y/I6vMVbBVtjGTLdM1uJjR1mYfe4To4g24/XQbVnCVvZRBFuwK6EKhAoQsGneKnW65BAvpZDQPUTNWPsT1Yyxl2SOW/1MR2fphLXTfL9LnK8royQ9rtU3KpKYzJFdTjFpCLbxLSvznb6R+IGEWGgKQq6ZeHpRKI0BQp0FnXWFTtP+x+CFZuom3V6ZtmUVXbyJJZFoOpDJr3yK7ZecF+nAQRdsT2yD4AfbX6AW+dewc1bHmq3TZ1hm6iunnZB88ImU2Gszm6ZnIrauS8uH6T9SF7NyycnnWEnUYb2gbuIF1UfB6IHuOmN9s9xh5cs5vxp5zM+dwL1iXp2hnZyIHqAXaFdfHbWZ5mW34tcHAeHPtAbm82vaPahGMBubLPXkJCtxMZ+uUGE6HuHrmHEv7Z7+eScROZ9sSsfS1rkyiAy/W+afyI1qTpUoRC3kgTUZv9Drs9Frq991Vif2768UqYkrhvsq4uT49VImiYNUR2vS8WlCpKGSUUoQcCj4XepraLKwBYmDbEUUsLEot4VCUzljaUub2ybpQJhmcx74orMknH//QP7Tvpmh2MoegJhGViaF6m2/sl8adJZPLrnXwDthMnvD7+Or62/A4BSTxvrcOa6kZAIY0fl69AyAikRhprtzduYOuflzuTNiv92OM/11e+xvvq9Dte9X/0+YGeoN6bsKgP3fOIeRvmzW7rG4dCmNwLlLOBCWpevXw7cluU5DSpKBwKhpyLCdAXRhmmByP6gCJVp/ontlhe7C2k0IpQnqwgbEUqCxRhW93WVcj0a0aSBYUqiKfv/Ar8bd9qnEk4Y1EdT1EdTeN0qJTkeigJu9tXF8XtUoimDpGFhZCnPxF+3s/0c96+ndN1fAHCHK6mfvpTweFspn/M329eSzCllxzk/b7XfmaXHsrTkcH6z40nea9jGcYXzuXb6RRktd8XRt7A7dgCts1a7pgFm0nbgmyn7feWHtgZjGZBstJfnjYdUlCm5E3hsztftXJdkmKZnvDojxtU7HwPAJVT0NsEl+Z58GpINGWECsKN+R58Eyv7IfvaH9zMxdyKlgVISRoJ94X2UBkozDnPDMginwhR4s9C/xmHE0Ns8lAZgPU32kUMcxYwjh6iE/VAhkWiKhoqCqogeZVb73BqGCQnDQKKQ1C3yWmg0o3NtU5NpSWoiSTRVEEuaJHQD07JI6na0mDLAwjt/91tIIdBSUXIqNrF5+SOoieYbsCdc0eF+HtXN9bMu6XCdEIIpgbYaUgvMJHjSlmPLsv0qoRoyxoBAiZ3HAnbYcdM+gUJb2OSOBdVFIfBYya3N49bvQSL4Q81aPjX6GEb5RvFGqoq9iWrmF8/np//9KaY02RXaRWOqkcOKD+s2OzyUDJHjzuF7a76XWfbtw7/N37b/jX1h2/RX4ishnAqTMO1bxPLZy/nU9E91Oa7DwUNvBMp4KeWZAzaTYUXPdBTdPwYtWjXAcxk4ZB+KSxnSJKD40WXvIo1yfBo5TZdbJ1YrVRFoiiASN2iUOk1+/OKgB8OycGUpTDvlL8Qdq+PA4ZcwZv3/ZZZvvdDu1jjvscsByN37DhPevA8A0+VDDEQmvqJBkzPdMiHRaAuQQHHn+7Qsud+ZEBAKQqhcOW6ZrclEqzhhzEJOCJZQF7crOt+7obk75U3H3cTcormArV1srdvK6j2rcatuNlZvpD7Zcd2o36z/Tav3dYm6TJMogMe2PsaLe15kUu4kzppyFvOKO8gzOgjQTZ01ZWsYHxzP7MLZnfphTcvsU3mbptIxw7UPShO9EShvCiEOk1Ju7H7TkUNHD709/cqkooxoH4rZhyrgU30T2J+sol7vuLlXfykMeIgmDYLe1pemYULKyE7Z8u3n/8o2KQlBMncMk9fcSdmxV7bbrkmYAERLZhGs2JSV47eiqW89gCdg//WUTnq5ALbmAraAAlsLSvtngu4gHtVD0sxUUOLhTQ9z1YKr2BveywMfPNDhkPmefBJGgoSZ4L7Df4BWMJX/7HuRylgl50w9h0m5refz4MYHWb1nNdXxaqrj1bxb+W5m3YnjTuQbi77R7gZpSYuYHutx466hJKbH+Pv2v7MvvC/jowK7yOa0/GkUegspDZTy1LanWu33+dmfZ0bBDGYVzsKSFu9UvMPu0G6iRhSBwO/yU+wrZmbBTIq8RayrXMfv3v8d0FrwD0d6I1BOBL6UTnBMYt93pZRywYDMbJCw2qVqQs/DhrURLVDcvWz9C+BS7BauYTNCrpb9H70QtBMmANFUeyHT7wMB0dJ5bP30bzE9XX8WT6QSxTLwV25FDxRheoJYmnf4fv9tn4JTYbveWLQKN/DQ4dcjBCRNnS+v+zll4TJ+/MaPM5sHNB/nlh7PgVSIsJXie1M+2VyyRE+CEYf63Vw488JOp/CVw77CuVPPxa24qYhVcNtbze7W1/e/zlGlR3HMmGMA2FC1gdvX3p5Zf/NxNzOnaA4f1X3E7Wtv585T7hzSelt1iTp+ve7XbK/fztcXfh1Tmq0E7+Tcyexu3M2swlm4FBebato/fKhCxZQmf9361z7P47a3buNPZ/0p06hruNFbp/xBR0dO+aEkZiXIZ3DyCTwaTMg1cPVSA8935RI2o5QlKhjnGT0oarhrAKvgdiZMtnzmD8x90g4i9DTa7WmnvPyLzPpkcBQ7zv1Fh/sOLyRIYfteUnFIhNCkBUj8WNw/9XM8E9rKylo7Quyo3Gl8b9pF9q6WYZePidXanSqFAGlCoAiMZOeHTFMasPOWCn2FPHj6g9z21m34XD4+qvuI5z5+jrlFc2lMNbYSJgC3vnVr5uEF4Odv/5yySBkA3zvyexxVmr0eOF1hWAardq9ixdYVmbk0aQsAo/yj+PWSX7czY0VSETZUbSCUCjHaP5qFJQtxqS621G5hb+NeXit7jVAqRE3c7gZy6dxLWTJhCaqi8ub+N3l+5/NoikZjqpG6ROsehlevvpo7l9zJS/teYmLuRCbmtg+gGSp6k9i4ZyAnMlTIDkrtDm3jGknICBM2ooz3lna/eT8JuCUps/3nPRCxyPMI/K7260rS0V4gqDdCFLryB3yeKcPE7R6con7bzrsTRY8h0x89Omo29VNOYvzbf2i1nScyAvxnqsvWViwTGvbZpr78CfZrRYO8CeSbBpf6i/ns5DP5ILSTowvnQKjMVtQty9ZspGVXU85tcU32QKC0JOgO8stTfolpmVyy8hK2N2znq6uao/5PnXgqX1nwFVZsXcE/d/yzVUWAJmEC8G7Fu70SKEkziVtx05Bs4K3yt1g6cWm3Peq31G7hpb0v8fr+11st/9bh3+KdineYlj+NMyaf0WmhyaA7yInjT2y3fG7RXOYWzeXMKZ27o5dOXMrSiUvbLX9h1ws8uvlRInqEq/5zFQCnjD9lZAqUg5XhFqOlCpWwEUVTVKSUA/70r4j2Bdoak5JLn4uQ7xE8+emOc1en+ibwUWwnujU4l5Ahe2+e6yt6oAiwzSsfn34zqZzRWC4foSnHZ7aZ/tz1eCJV5O16HcU0iI6aRSp3eHT2a4UnaGsYlt7cthgAaSdRAqgaBIrxAkc32eebGol1hZS2zbiXwRKqovLVw77Kv3f/m71hu4nad4/4LkePsWukfW725/jc7M+lDyHZVr+NP235E27FzYd1H7K2Yi1fp33ZnKay9CkzhUtxETfiPLr5UV4re63Vg+OftvyJUyedyuo9qwH4+sKvM7doLhE9QrGvmB+//mMqY8311ZZOWMqxY45lct5k8jx5HDf2uF593mxx5pQzWTRqETe/cTOhVIiAFhiyuXTGIS9QOtJGhlI/cQsXOgYBxc/+ZOWAaylCtPYj7apz84P/2v1JGpKSlR+nOHtaa3vtaY/Zjt4rj/RSWlCD3zc4vdRNUxJLmu0SHweSzopPNmkn499uTmbcctH9yMwNexghhK1dtCR/Ynb8P9KkL7eRZZOWsWzSsm63E0Iwq3AWPz3xpwDc+NqN7AztpD5RT4G3gPpEPV9f3SxcZhbMZFv9tm7HbRIm0NqE1YRbcXNYyWEcMfoIPjHxEz35SINCaaCU351mz7ch3jDsSvEPq9kIIaZi96zPk1JeNNTzGQoMTHK1IO5BulAiKcGeBo0XtnuYWWTwu/+2bq3663cSvFdpUORTqE9YvLSnuW/hA+/mADn89txqFKGgdpa8lwW8LhXdlO2qGw8V5Ud8kbHr/txq2dynrmLPyd9m0qu/wXT5iBVPp/zoKzB8eUM0yy7IluY7yN/HmVPO5L4N93HP+nu4+fib+eeOf7Za31aYjPKP4vaTbs/0oD8QOcB31nyHqXlTOX/a+cwpmsOKrStYs29NZp8CTwG/XfbbYXezbqIpX2g4hhAP+BkTQjwMnAtUSSnnt1h+JnA3oAIPSilvl1LuBK4QQjzV8WgDMcEeLxwUlLQRbiBvzi3Z02BfAk9/2LlNec1eo9N1APVGI4Y0GO0uIWmoRFOCkkB2Qnyb8LoU4rqJWxseLWrrZ3wCT+N+ira/1Gr5pFd/A4Cqx8k5sJFZ//w2ADuX3Ui8ZMYgz3KAkdKO9tLal90ZKE4adxIPfPAAoVSI5c8tzyz//pHfJ5wK05BsYMmEJZ1m6I8JjuGxcx9rteyqhVdx1cKrBnTehwqDIYIfBf4f8KemBUIIFbgXOA0oA94RQjwjpdwyCPNpxXCT8SLzvxjUQpE+TXL54VGSMs6ZE8bwmb/bQsSjQrKTfD6vJikMJAiqAVQh2NFYz69fsQsQTikw2FWv8aXFUeaUGOR6ZKuHYilh5TYPs4oNCn0WBT7Z5UOzJ12A0raFt+2MCPvq45lWxB1hWpKUaeHrbUhbF1QcfgkgKNr+Yrt1uq8AV7w5GXDqiz/rd1/7YUcvuptmCyEEx489nlfLXs0s++ysz3Jk6ZFd7OUwWAy4QJFSviqEmNxm8dHAjrRGghDiMeCTwKALFABLylbhw0OpSapCI24mCKi+bkthZIOzZiQ4EFa46ugYAI1GApcq+M/y5tDl361PEDMky+d4CLjsUGtTSv7ntQgf1fowrTD3vV3Ijrpmc9muevvSevQ9O1HvkoUxTppkNw+TEn71RpAddRrPfmRvf+WRUQ4f2032vYTaaJKxea0FR0NMx5KS8oY4pgUTCnzt7nPlDQmShsmoXA+53o6fqMMJg6RuUZzTwxh/oVBxxBcIj1tMKmc0epvs9qaM+ya8dbsIVG3FUj34ancSL55G/fT20TwjBwna4OdDXDr3Uo4bexxl4TJOmXDKIdsOeTgyVEbCccC+Fu/LgGOEEEXAT4HFQogbpJQ/72hnIcSVwJUAEyf2M2ROgGFK3NrQ6yoCuw1w2OjaxJRNWlYZ7oyvH96R013wUbpDznX/al1g8BNTk5w9M8H3X2j2Hfzf+36m5BuMz7P4+rP57UaL6t2ff4nENGnnmA94NQ40JjBMC1UR7K61GF/gR1MECKiN2oIskjQYTecBBLZggi6KnnRIh22LO2DaqtZ1VAt2v0EibzyJwintqhiPCBTVLrk/yATdQRaPWsziUYsH/dgOXTNUV3FHdw+ZbuLVrTFTSvkA8ADAkUce2SevYLksZKyoQxFi2Dh6AdzCPezMcL3hZ2fupdCdS6IDmfiTV9o/SZ40Kclrezx8XKtlNJjO0E1JfczeJqar+N0qtZEUAtuklUyXZjEsiwOhZkFpSUk0aWBZknjKJKdNxv2+OrvZVso0MTounTBgTH3xZ1TPPZeqBZ1nnA9bBqK2mcOIZqgEShnQMtB9PFDemwH622Dr7OTPKREhboJhJVBUoQzb6JLO+M/yXKoSIbbHd6CnxaFXg+tODDMu1+TbK/Pb7ZPvtbj99EYSBry2x8N/y9xMLjCYmGcytbD1jSqUEFy/Ko8LZjewsDRBTDeI6Qa1EXu9R1MwDIvigAdVFVQ2JoilDFKmXVDPkrb/BGxtxZKS0lwviLQgMk10QxLLcnmX7Wf/DIAZK28EsH0oUiIsg7lPNtcO0+INTP33Lew9+TuY7sDI0laMBKjDv+6Ww+AwVFfuO8AMIcQUYD92X5XP92aA/jbYaiCHBpmTSQYeLqhCwSMGL2qmP9x3eoDquH3yXCqY0sSrNJuUpqUFw/87t4Frnstvte8NJ4ft/Vq4iR7baAchfOf4CLOKDXbVq5Q3qvz5fXv537fms7C0gnDCoNjvwUKSSFnUJFK4VQVVtYWZEBBPmeT73EhsYWKZEkPa/ViCHo199XF8bpVwXCeeNDPajZpFB1pTouPuJd9PJ0vak5Oqi83LH8EVrmLm89dTsMvOxm6KCNv82Qfb1+IarugJO3nSwYHBCRteASwBioUQZcDNUsqHhBDXAP/GDht+WEq5uZfjZqUFMEJk+qm3WNi/MfvBOE8pdXpj9xsOA2YUqsxI90BvMBoJqD5EB4EEmgI/ObURTZHke1trg6oC1x4bQQK/fydAyhT8+s0gVxwe5aH1nVTelaCqAhWBy6eQ49NapfsH3BqRlJEWMAJNVfC7NSobEyAhFLed/9GkgZE2lRUHPSQNE3MATF6d+lg6CbpQ9Xi3xSqHDX1om+xw8DIYUV6f62T5SmBlP8bNSgtgQfuorqGs5aUJFZcYQSaPNB7FTY4WJGLG2Z+oQAKj3EW4FVvbKvZ3rgbOHWU7XE6dlmTlNvsG1VaY+F0WMV2hJOjtWN63WBZwax1G6hUHPBjSQhECl6pgWhLDbG72pSlKjzpQZo9m4fXhBfeSt/dtxr77J4SlI0wdf9VW8vf8l2TuWAq3r2b3J64nlTPw9d16jKKCOgwrAzgMGSPvzpVlXEp7DWWoneLZNLsMFmM9o8EDW6M7Edimu2q9lnGent8Az52VyAiUJn5+WogCn2TlNg/PbPUhAbW70yPA30EhSVuraTYlte04ObjCBBTTDjCIF0zEcvuRad/ZlNU/wx2tabf91FX/m2kC5uAwHBmxAiVrJq9hiDIEoZjZwiU0FNWHKlRiVoKElcSr9OwpVhGwqDTFhgo3t36ikdHB5ht8kxAxLdtMNhB4NJWkMXiRS8ncMdTMPpO66emaVungkI6ECUAybyzCSKKYKcx022BFTzD+rfvJKX+f+qknUTvzNJI9Kezo4DAAjFiBki2Tl25JUqZJnm/41B1WUTooqj8ymOqbgC4NBIKEleh1BN0VR8SoiSVaCROApmaNUV3g1gbm7Ax6bSShULno4szbks3PtFq9/ZzbKdn8DPm738Tw5OKv2cHcp+yo+v1HXc64d1pn3hfsfI2Cna9l1jdMO3lg52+ZtK9V7XAoM2IFSn+5//xSdlfWI4CqcDJjRweGvAufR3WTNLvOyRiuCCFwp6PUfIqXuNW7nhkuFcbktDc9vbPfzsh+ZbeHT/UgGbOvDOXt0Wrh4N71ietJ5Yxm/7FfZf+xX22Xdd9WmLRl3DuPZLYJj12I4c2ldtYZJFu2HO43ElKxIcmWdxieDJ/H8kFm0bgASye6EIhh5ZQHmOgdS77WcR+SQ5XamH2pvrB94KKKBEPrP9t5+i00TDqOLRf9ntio2a3WRUtmAVA/+YRWyy3VRdX8T/Lhhb9j8/JH2HLR79uNm1P+PgU7X2P6v5pb/ArTAClR9Dg5ZevRorXNO0ir50mLRryHn87hUGDEaij99aEYprQ1ETH82gA7tOdTc+M8uclPvncYJQ1lGalq7D/uyg7X7TnlO7hidaRyx1A763RSuWMY9cHfqJl7TsafAiA1N1s//Vtm/+Ob7cZI5I1rp+m0ZO9J1+Jp2M/ojX8jXjCJnWfc0t2Me9210eHgZsRqKFLKZ6WUV+bl9a3XRFNklxAQaNOwyREvw49TJqfS/x+aNzCpeTKJksmCiUjVReXi5a2ESROmJ0jFos8SGT0P2eJq9ob2d3mMia/dw+iNfwPAV99Fx29pNfdBMQ/N78OhY0asQMkmhjn8HItJmSJpjUw/ykDQFOVVF+/4kq2K9P9SbqqaEE4YGKbM1PgaidTOPos9S7+P6MYrZLXt5NiCmf/8LsHy9wFwRWvI3/k6SirGvMevYN7jX2bi2w+h6CP3HDlkn0PW5BVPNduIPdrwk6sJc+QLlISVpNGI4HX3P/mtySr52h4Pn5kXx63B9lqVKQUmGw64eHBdgC8fHuXo8d2UwO/yIGBKSUNMp4F+jDOMkEIgpGTbub9EWAauaA3R0vmtAk/c4Qpy966lZt756feVzHj+h7ji9Ux69Tek/IW4Y3UAjFvb3PI4p+ojvPX7iI1dNKifyWH4MmIFSn/Dhr0uFR1wqQKlgyS4oUaIoQ4N6D+qUNGt7N+Yr+2g2CTAw+sD/HOryQ9OjJDn7b/WOYxqhvaZj0+/hWDlh+jBEqC5vlhLUjmlGWFiv2/dBrpJmHSILz8r83Q4OBh+j+aDhBD2Tds1UFly/SRHC4zoBEcAn+rFpw5urafamMr1q/KIpvonjkNxnXi6L01DTKcu2rm2GE2ahBPGsEzJSBZMpHb2GVkbTyKonnM2u5ZeD9Bh7TaHQ5fh92g+yAx6MlsPCRvRoU6H6Te5apAa6rvfsIdcf1KYX7xmO6G/fnSEuSUG9/w3yPba9pfx915oHazxw5PC3P5aDtceG8nUDusIw2wRRSYhoVuEEwaWlBQGOvY3VIcTxFMW00cHcXVbF2Zk0NSu2Fu3i2mrbqNu+lIOHHlpZr2vZof9Qh68UXcOvcd5vBjGjMQikQPJlAKTkyYlGZtjsrDUwKXCV46IZtb/+qyGTve9PS2I7vlv11V8DSkzpi4JVIebo5jiutnu/rmvLo6Utu8lFBvZPq+OSBROYfPyR1oJEyBTKVk4TbYcWjBi71gHcy2vJka+FyX7XLKwdVRRnldy//kNmff3n9/AVc/kdzlGKCE69LG8U+aivFHh5MkJLEuiKSpSgoUkkjBQhMDnVsn1uthbF8W0JJLmKMFoyup1++CRimwydTkCxaEFI1ZD6W8eynBnkm+cI1D6yOIxtqbwlSOi/ODEcLv1j230tVtWE1N4aH2Af+3IpSEhKQh4kBKM9A3TSBcTi6dMEoZBQreQ0u5Tn8gUlJSD3kJ4yGjSUFKRIZ6Iw3BixAqU/jLcI3iGugzISGZ6ke0jKfZbTC00mVnUOtLsvQPtfSE/Xt3c7z6aUlCApGGSNCThuI6BpDGh05jQqYvYbYQDHg13C5+JaVnURg4+s1dHyCYHXyoyLIMRHIaGQ1agDH8ccdJXlkxOccPJYSYX2JrD+bMT5Hosbl7a3Anzf9fksKVK48Wd7nYmsjyvGwQYlt0yOGlYuBRh5y5Juy99U8+aPJ+H4oAHicSyIGUcIk7qJg3F1KHmI0hG7EKRdbuHdl4OQ8qI9aFki1jKIJ4y8bmHY4iuQEo5bCPROkNNhmwb+xBNW1VgUn6zbX96kckvz2jdVnl/o9q5g14oQHp/CcVBDwndRDcNcn0ucmmuTK2kW36aliSqG3hcw/E6yj4yI1AMsCQ07gdfkVOK5RDH0VCAmD48HYtCdFc4Y3iixavR4tVDPY0OuXh+jBlF7cOGZxXrXDw/BthNvADcqoIm7I6eAY/G6NzOc2oMS6KbElPKLnNWMtubtgltpCJMe+55e960zV4A8Vowh+dvyWFwGLEayqEQ5TWSzV4i7aRSk3WgBYe8x0wTS6emWDrVvuFvrNT41zYvQbfk6mOibK6yfw5NfvUCfy/7fEiIJ01UIfBqJn5P59rKgVAC07LIcbsYibmBrridX5RTtdUWKO60tte2j0+oAlQV0pn6Dgc3I1agZKtjI7RJZhsmKCM8xqupyq1iJgALGH6moMNGGxw2ujlKKdNmuEkt7MUX4HdpxFIGScMkiEbKtPB38pmTun29GVJSG0vhVgV+t4YQEEuZ5HiH/89StqziICXE022LFRdUbLGFSMksaCwDVXMEyiHC8L9yB4iUtwjdZ98zhqE8GXF+k3YIECPMnq4IW5KYVu/PfY5XQwBR3SCp29pJOGHQENOZUOijIpQgZUjG5nspb4hjWpJwQicSM/B6VALpenJJw6Quat+sCwIaud5mf01lKGGb3VpMzzAloYROwK3hdQ2eqmO5/S3etTDMminbjyJ8ULnVXqYMv4cJh4FhBCrb2SFsujGDpUBzb5ThxvCcVQ+R4IqWY6pexAjp6mdJ+4w3JAS6Cbvre3cjDHo1kBDTDaS0a4CBrXXopsSSMm3qkiQMC1Pa+0SStmZjWhYNcZ1o0qAmkqAilGB3bSwzfsqUVDY2tz+Wlm06iyXNVhn9g0Ei3Uq4eu65dnKjngCh2f9HqyG019ZajLjdhKv6o0Gdn8PQcMhqKE0IMXwFykBiWAaaMrBff4PQiCDJNxKYrq5LngwHmp6z/7TBz6Pv2dfET5Y1UhzonQqbMiXV4SQp00RKiKaTHz2qiiklhmVhWJKSHC+mZYEE3ZQ0xnWQtrbjcymE0k77pr4slpSkTCirizO+0Ec0ZdcYsyMBFfbWxplY5MMwbcE1obB9AmfWSDt+LM0LBRPtZZYFyXQiacEkqN9jbydUcNrOHxIcshpKvt/V/UYHKbV6AxWpmgE9hsDCp3pQhdJtk6fhQtNzRZOmAlCf6P5h45mtXq56Jp9XdrnRFAESgh6NQr+HooCHgEejKGD3hPG7VTRF4HepKIJMtWvDsrAkjMqxI8k0VcGjqliWrfEkDZNoWpPRTYuGmE51OEkkaVATTaX9N3b0Wm00RW8S9lOGpDKUpLwhTqKTiMf2zcbs8+JpLG9epCitzVvedBULc+RGszn0jkNWoLQkz3doCZe4mRhgc5qCVNxIIZCKG2Ekut9lGDApv304sZSwuUpjXXnH18hTm72s3GYLgRUb/QS9mm366oCgV8OlKuT53OS08I2U5HhJphMiW7rOFAXiKQPLtB35sZRJQ0wnkjKoiSQJJw3iaQFgayu2MGlKrmyMd3Ajl+mOlC0kjm5apEwL07KrK7elLprCMC0qQgkaYjr76uLsbbBNbPm732y9cU4p5I5NfwDVtsuZyeFfmsIhKxzyJq+gR8M0Oy9nPtRY0kQZiKrDA+X0lxIQSEUlx0jgVb0jJjehIzlw39ogCcM+V6VLGhmXa1ETVfjxi7nkey0aEq2fyXbWe5hT0rvrqUkz8rtaT8Dv1lAVgUdT0U2LuG5SGHCjIKiJJlEEFPjchOIpFAQpw2JPTRRJsxk3N/2wtK8ujiJsc1oobhBNGpTm2YKw5a3elBLTkq3MwNGkSdK00EwF3bTNbEqLR5JJL99B+VGXoQdHpTWUtJbiDoLLD6GyXp0Ph5GLo6F0yHDxqQgsBiYETRmor17awsN05yGFC1CQ6sjVAJuECcD/rsnlzteD/PhFu+5XW2ECcPdbQV7b3b3DoCqicNvLOa0agakdxAB4NHuhpij4XCouVUFVBV6XigW4NYWSHC9FQbv8i9+jpYtattYILCmxJNTHbE1GN5vXNyZsDcS0JLGkSWW4BxpliweSYOUWZj53fcfbOBFehxQjVqAIIc4TQjwQCoWGeioDhhADU3dPCPsGNRB4GncjVRdSSd9UBVjKyPHInjsrzsQ8g5MndRw1taOuWYuYW6K3+r+J//vAT6gT34tpwUPr/Nz0Ui7lYZXvvZDHz14JEkr68Lk610SFaNY2wPbFtLo4BBT4PQTc6Yz+9LpI0rR7ttBkdWreqSJkCw7TtE1dkaRBOKETjhvsq4vbXSh7gZoIEajc0vFKOTK0VIf+MWIFysFevr4JZQC0JTGgtYy11klvCNRU+xLyw5VzZyW58ZQIh4/t2pF8zPgU1x4X5f7zG/jGMdF2629/NQfdtDURgJQBZSGF378T4J39rQXs3pDGXW/m9coK6VKVLkvBAESTOtsqGommWguGePp9Sy0ladoZ/rGUaRfBxA577o1Qmf30t5n88h1gdbCPtCBS1eOxqP6o+S/R2PE2esKOLHMYNhzyPpThjEBgSBMX2TUZiQHMwjc9QWTa52N6ciEZ62aP4cnsEgO3KkmZ9pk6Z2aC57d5+eXpIQJuidriUUxV2jf2qk8oPLTOz4YKN7efHuL5j7y8tsfT5TE3V2nMKjbQOnnMs2Szv6U7NEWgWxYBj0bKsEjXsEQCKdNC001URVAfTQtOaQcB5PtcNCR0aqNJNEUhmrSLp5pIErqJAqQsyegcL5uXP8K+ujhnrrq61bHdkRpSOaObzWJuvx1OrLkhOKpnHyAZtbWaZNQWHGMXtt+mYY8dSZZT2rMxHQYcR6AMc+QAGL0GPAs/raFIoQ0fd1QfuOOMEOGkgkuV5HgkJ05KkttBp8fO2FBhayI/XNWxFn3DyWF+/mpO5v1v09WPz5mZ4LzZrf0YjQnB/7yYy5cOj7F4TLP21CTEvJrkN2c3m3+LAh7bua4KdFPHtOyvwq0phA2DlGnh1VQ0Na1NSFvrcakKo9tUTA54Wt8mKhsTXQZtzVh5A9Dcl55ACURremm/tdL96g263NEJHhtWjFiT16GCS2TfoT2wVcJam9OkKwioCL1ZU0lYScwRYFP3aFAcsMjzynREVdd3r++d0Gza+8y8OOfNijN/lM5n5sUzXSQBPjE1yQ9PCjMp32RWcXvT2vPb7LyW76y0BdHfNnv56Ss5JE3Bc1u9PLLeT0wX/Hdf87WRMAQPrfNjpcOcr3o2H5Omni0uctLhzO4W6o+VjuhKGrYGovTxQeO/Mz7P7kmfaLd83mOXM++xyxn/xn1p4eBwsPP/2zvzIDmq+45/ft091x6SVqsTnQgBiYTFtVEAUQQIYBCYlDGhDClsiMvENgTHVColgmOTUDgGh4TYkNgQg4sjCBwSYqgQwFgCx1ySgEVskNBJdKF7V7s798zLH+/tzrEzs9dcu/s+VVPT87r7ve+8me5fv+v3sy2UOmfsPeAbxebmpFwPXBdRyf6HycOJThqcIC2+8TX+dWJrim8s7+FQ2OHCRX0GRA/un7cQHn0PpgTTXHNKpvVxw+lhVm8M0f7pwIkLkaTwbEeQV7Zlxkr2dLvs6XZp9Kf51fbcMZR1e/ykFWzYq/P66YZGvr48d3wnmYZtRycxb3IEVIJYMkVPLEnAc0fsMWLHzOV0NvhRi9o4fs29A/ZP3rWOaOM0Dp16zYjyt4wdJnwLJZJIkarjOOCR9NhysNiHcnwoM5MsLS5uLHc2XmqcPrEum5XMMiYZfC7c1BbOMSagWz1fX55pvS2fE+fWszIekLONSTb5xqSPPmMC0P7pwNbtsx0hHmtv4O7XW3PSG8oQYC4887f7t/csvzFn38xNL446f0v9M+FbKOm0Xl08qS5XywuqAutQ3Ko9RzgkfZNI+6M4WQ4iKzFzbaxz/8pOlNLdbI7oz6s3NvDWLj8rT4qy/YjLpkOF/6P3r+xk7Y4Az3000HdXfnjjfBIpxavbm3jtk4yvtc8ujvL5JRnDdyQs3PdGE986p5dpDfr/GEkk2Xqgh5RS/eN8u45E4Jp/QVQa5fqY886juYWlE3BgM8w4OZN27FMINEOgMZN28GPtcDIV12MkiSjs3mB2Onr2AIJ2ghbVg/7BSSW/p6U6TPgWiqZ+WyjlJpFOVPzbqmx7kb3K34zkOuKQov7HUKpJ0IOQLzOLK+jBF5ZEuGRxlItOiPHVtjA+R7FifoyLT8jc7C87MUrQg3MXxFk6I8HlJ0X52u8MnMZciDWftHAs5uYYE4CXtgbZc8yhz3PLy9uCHA67PL8pSFdU8HkhkmkXz9H+xvoam2mlwHH7F7Juufxv2dv2pUzGyejAsZRoVybiYz9KGx9fo57BFWiG8GGIHNH74t36nHi3fkU6h/R9LZVnwrdQgBEPRo5F9scP43O8yrZSxKV/nmqh3QgOjvGSO3Hqfrg0BxRXZbUUfnRFpttQAb/cFuTixbpLtMmv+NOzMobkvIUxXt8Z4Jx5Md7YVXi68todAdbuKLzvrrWTmBxMc88lx/qPeXu3n7d36y61qaE037u4yPoQQ7x5FvHmWRy3/jEAfD0HSbQ0ljwnh0DeseLalfd1zoQ3KEGf2+8Jtt4QpKyzoY4kOsuWV0nyjIRyfCgvhBPvwk30IIEQ0VSMQ4mjTPdPrY6mccZVS6JcujhGg69we/OaUyJcuCjGzMY0ZxyXwOfCobDD9IYUf/9Gc8Fz8umKOqzeWNgF/pGIfiDZfsTl4fWtXHdqlKUzSi8GXfDmQ2y97O7BC1aKJS+sQkxrpvu4U/m/z3x+wGGT9rYTbZ5FfPL8wfO0VIUJ3+Xl95y6nkrVm9JjD93JXjoTpZ8IByNccS/DGpVfillQ56TjoFT/tOW4moBuzVURL8DDxBFoChTvvPQcmNWURgROmZnk5GlJVsyPc9K0FCvmF57ocVNbL3/Slttdtm536bHFF7cEORr1ePDt4vFuuua1ARDo2U/w6Ccl8wPw9R7uNyYAzXvbkeTAiQ7zNjzJiWvvGzQ/S/WoqxaKiDQC/wTEgbVKqSdrLKmmZD/oH0t2o4ApvlEOPlbBoqj+wF11bKlrREopIolUTSeBXH9ahOtPiwwYsO9zN/PjKztLnt933oNvN7LlcOYW8vymIDefM7Cn8+gJFzB513oATvjlXXT81qX9B7VuepHwnDOINM/sP755X/uAMpe8+j0AeqafTFNe9Edf96ckWmwrpR6oeAtFRB4RkQMi8mFe+qUisllEtorIKpN8FfBvSqmvAldWWlsx6rFbv3wD6VX4cpL7t0r59dOrJDNPxiKVXV5Z7yg1+IrzSvN7CzO/x+3nDd3fWt95x8IJpgczeby4JUSkkBuvPEekXvhI//as9mdY9F+rcvbP3vBE0bLzjQlA076NQ9JtqTzVaKH8DHgAeKwvQURc4EHgYmA3sE5EfgHMBfr+HXYaUB7lMHTVuIknG2aadScmdK1/yoCSdRzH8Te7bn93FBQFHTcqBV2ROJ4rdEbiNPhdumOJfh9Z05pLO3ssN9cui3DtsvxIjEM/z9e9G1B8Zc1n+vd9f42D6+T+ricnPO7K+hx5/C/pdXIH3Dsfum1AOfc0f5MNgdMBeObQDQC8HLiAS2Jrco6LbXiFzvaOYX+PsY5Csf3y77J42YpaS+mn4gZFKfW6iCzMS14ObFVKbQcQkdXAH6CNy1zgfUq0nkTkJuAmgPnzx29TtxI3/2q0C5INM3DjpcMKBBw/0TG6aHNQilRxKp0mkVI0hzwafB7JVBrPdUik0vhcp//z2MGsBclid9dA/fvUopzPrYkDtORV0tzYzgHn/XfvUsJhPavrCS7lCJP4deJMLiFjUHYyCycVZ25q4PkTgZ7e+grfUasxlDnArqzPu4HfBX4IPCAilwPPFztZKfUQ8BBAW1vb+HvMLcrojEE1u5gkFUMpRTwVRTkB0r5GcH04ZsW8Jx59bknGA6mUjnI48BZbmCkNvoynX0MsORYNCtx9wV5am4KkERa0NhQ4zqGj+x7whcDfCFkr6jsObIbQFMgaQ+k4uBl6D/JAow/tHBI4ehY4Hr/fOImO2L3o500zcD95PkzAMZSjkaOcM+ecWsvIoVYGpdC9TSmleoEbC+wbmIHI54DPLV68eFRCIvH6db2S7Wa+fGtlqmdWkiRxxCWc7CWQV/Z4Gz85FI7RFPBw0ONDR8NxRCCeTNPo94gnU8TTCkTfCpuDHp1hbVA8x8F1hJ5ocoBn35Gy/1gUTwTXE5LJNCG/R08sSaPfI5pI0hT0CJYI6DV0hFBkHz78xJrmliE/y1imVo9Du4F5WZ/nAnuHk0G5AmwlUmkO9dTxk7K585YlZK9Ud8JBGoUjDt2JrgEOZDynriYYloVwLImI0NoUYGqDnwVTG1jQ2siclhDzpjbSFPCY2uBjckgvDpw9OUjI79IU8Cryu4QCLtObAoQC2pgg0BtPEvTruPI5z1EjeaYSQXl+0hXwiG0Zm9Tqql4HnCgixwN7gC8C11VbRN/zv69uuxlyQ2GNdvxDKhpaK5dE0zySYQdSXSCOnuljrIpffLgyvlY8C3qiQd8Et0khL3dqsNID9n7XZcYk3V7zXMEzvlZG+quklTFkDngiRJNpkkld0T5XmNLgIxJPofqMlgLPE5rEoztqJgSIkEYxJeTrj2E/WJmJVApRQtJtIunzgCG4exnul+w9qN2vGFcupJOQyu4mHGoHo6VaVNygiMhTwPnANBHZDXxXKfVTEbkFeAlwgUeUUsOaptHX5QUcE5EtI5Q3DTg0wnMridU1PKyu4WF1DY961QWj07agnEIARNVyInyNEZH1Sqm2WuvIx+oaHlbX8LC6hke96oL601avfT0Wi8ViGWNYg2KxWCyWsjDRDcpDtRZQBKtreFhdw8PqGh71qgvqTNuEHkOxWCwWS/mY6C0Ui8VisZQJa1AsFovFUh6UUhPyBVwKbAa2AqsqVMZOtPfk94H1Jm0q8Aqwxby3ZB1/u9GzGfhsVvqZJp+taH9nfV2VAeBpk/42sLCIjkeAA8CHWWlV0QF82ZSxBfjyEHTdiV7s+r55rayBrnnAGuAjoAP4Zj3UWQldNa0zIAi8A7QbXX9dJ/VVTFdN6ytrvwu8B7xQD/VVlnteOTMbKy/zQ24DFgF+84dbUoFydgLT8tLuxRgwYBVwj9leYnQEgOONPtfsewc4G700+EXgMpP+DeDHZvuLwNNFdJwHnEHujbviOswFst28t5jtlkF03Qn8eYHvUE1ds4EzzHYz8LEpv6Z1VkJXTevM5NFktn3oG9hZdVBfxXTVtL6yyrsN+FcyBqXm1+So73nlvomOhZf5AV7K+nw7cHsFytnJQIOyGZhttmcDmwtpQHsRONscsykr/VrgJ9nHmG0PvWJWimhZSO6Nu+I6so8x+34CXDuIrjspfLFXVVde2f+Jjt1TF3VWQFfd1BnQALyL9h5eN/WVp6vm9YX2X/gqcCEZg1I39TXS10QdQynkPn9OBcpRwMsissHEcAGYqZTaB2DeZwyiaY7ZLqS1/xylVBLoAlqHqK0aOkZaz7eIyAcm2mdLLXWZWD6no59u66bO8nRBjetMRFwReR/dhfmKUqou6quIrprXF3A/8BeQ4ze15vU1WiaqQSnoPr8C5axQSp0BXAbcLCLnjUBTKa2V+B7l1DESff8MnACcBuwD7quVLhFpAp4F/kwpdayE5qpqK6Cr5nWmlEoppU5DP3kvF5FTChzf/xVqrKum9SUiVwAHlFIbChxTiFpfk0NmohqUUbvPHwpKqb3m/QDwH+hIlftFZDaAeT8wiKa+KJaFtPafIyIeMBk4wtCoho5h17NSar+5CaSBh9F1VnVdIuJD37SfVEr9u0mueZ0V0lUvdWa0dAJr0ZNeal5fhXTVQX2tAK4UkZ3AauBCEXmCOqqvEVOuvrOx9EL3KW5HD3D1DcovLXMZjUBz1vYb6IvsB+QOvN1rtpeSO/C2nczA2zr0YGLfwNtKk34zuQNvz5TQs5DcsYqK60AP/O1AD/61mO2pg+ianbX9LWB1tXWZfB4D7s/TWtM6K6GrpnUGTAemmO0Q8Gvgijqor2K6av4fyyr/fDJjKHVxTY7qvlfOm+hYegEr0bNktgF3VCD/ReZP0I6esniHSW9FD8ZtMe/ZN7I7jJ7NmNkaJr0N+NDse4DM1MAg8HP01MB3gEVFtDyFbton0E8oX6mWDuCPTfpW4MYh6HocPQ3yA+AX5F781dJ1Lrob4AOyppbWus5K6KppnQHL0NNfPzB5fqea//UR6Kr5fyzrmPPJGJSaX5OjfVnXKxaLxWIpCxN1DMVisVgsZcYaFIvFYrGUBWtQLBaLxVIWrEGxWCwWS1mwBsVisVgsZcEaFIvFYrGUBWtQLJYxgIj8jYhcVGsdFksp7DoUi6XOERFXKZWqtQ6LZTBsC8UyrhGRhSLykYg8LCIdIvKyiIREZK2ItJljphm/SojIDSLynIg8LyI7ROQWEblNRN4TkbdEZGqJss4UkXYReVNEfiAiH2bl+UDWcS+IyPlm+xJz/Lsi8nPj+BER2Ski3xGR/wH+UER+JiJXZ5XzmvFi/VKW/6dbReR/jRfd1ZWoT4ulFNagWCYCJwIPKqWWAp3AFwY5/hTgOrTTwLuBsFLqdOBN4EslznsUuFUpdfZQRInINODbwEVKe6Vejw661EdUKXWuUmp11jk+4EfA1UqpM9FRL+82u1cBpyullgFfG4oGi6WceLUWYLFUgR1KqffN9ga0Q8pSrFFKdQPdItIFPG/SN6L9Qw1ARCajHRG+ZpIeR4ctKMVZ6Gh8vxER0I5K38za/3SBc05GG7xXzDku2h8aaN9UT4rIc8Bzg5RtsZQda1AsE4FY1nYK7Xk2SaaFHixxfDrrc5ri14xQPK5EdlnZ5Qk66NO1Rc7rLVJOR5FW0OXosMpXAn8lIkuVDq5ksVQF2+VlmajsBM4021ePNjOl4210ici5JumP8so6TUQcEZlHJv7GW8AKEVkMICINInLSIEVtBqaLyNnmHJ+ILBURB5inlFqDjgQ4BWga7feyWIaDbaFYJip/BzwjItcDvypTnjcCj4hIGB3Tu4/foONObES7Gn8XQCl1UERuAJ4SkYA59tvosAoFUUrFzeD8D003m4cOJ/sx8IRJE+AfjJGzWKqGnTZssVQAE/P9BaVUqVC4Fsu4wnZ5WSwWi6Us2BaKxTJMRORBdFzwbP5RKfVoLfRYLPWCNSgWi8ViKQu2y8tisVgsZcEaFIvFYrGUBWtQLBaLxVIWrEGxWCwWS1n4f2mK217Ff79UAAAAAElFTkSuQmCC\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEICAYAAACwDehOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAACY5klEQVR4nOydd3ykVb24n/OWaelte6/ALr13EFAUsKJgRVGx/LDce1VsV+Vey/WKBRQrICpKBy8oAtKlLn3ZZRtsTbKbTc/0ecv5/XHeqZkkk012NwnvwyfszFvOe953Zs73nG8VUkp8fHx8fHwAtP3dAR8fHx+fiYMvFHx8fHx8cvhCwcfHx8cnhy8UfHx8fHxy+ELBx8fHxyeHLxR8fHx8fHK8YYWCEOIfQoiL9nc/ShFCfFAIcf8w+08TQrSO07VOFkJsGI+2yrT9HSHEDXuj7TLXGrdnUuH19tt3ZzSf2b5+Lt41rxdCfHdfXnOqI4T4uhDimn11vb0qFIQQq4QQS4UQi4QQL4xwrBBCfF4IsUYIERdCtAohbhVCHDwO/Rg0QEkp3yql/MNY2x5vpJR/llK+OfteCCGFEEv2tD0hxAohxP1CiF4hRJ8Q4nkhxNu8a/1LSrl8PPo9Fvb2QOI9w7gQIiaEaBNC/EQIoVd47j777gw1iAshHhFCfMK79oT4zACEEB8VQjy+H647z/sss3+Fn29MCHHyXrz2d4QQVsn1v7K3rgcgpfy+lPITY2ljNJ+VMZYLjdAJE5gPvAacDwwrFIArgXOATwJPADrwLm/bK3urn28A7gZ+BZzrvT8aEPuvO/uNQ6WUr3kC9lFgHfC7/dynSYMQwpBS2vu7HwBSyu1Adfa9EELifb6lx+6lft8spfzQOLc5cZBS7pU/4HDgYe/1D4HPDnPsUsABjhnmmHOAF4EBYAfwnYJ9CwAJXAK0AzuB//D2nQ1kAAuIAS972x8BPuG91oBvAtuA3cAfgbqSti8CtgNdwDcKrn0M8JzXrw7gJ0P0/1HgPd7rk7w23+a9PxN4yXv9UeBx7/Vj3nFxr+8XAKcBrcB/eH3dCXxsiGs2e+fXD7H/NKC14P1W4MvAau+a1wLTgX8AUeABoKHcuQXnn+m9/g5wQ8G+W4FdQL93Xyu87Zd4n03Gu8e7ve2zgNuBTmAL8PmCtsLA9UAv8KrX59Zy9+gdL4ElBe9vAa4ueH8l6js1ADwPnDyK785HgceBK7z+bAHeWtD2Qu9+s8/v6sLnMtznUbC98Hqln9kRqN9F1HvGNwPfLTx2qO8KEPT6vR313f01EC459zLvc/tTSZ8OBFKo320M6PO2X+/d49+9Pj0DLB7pWRd8Z25B/f6iwFrgqArGmtzn630eTwA/BXqA7zL4u7jAO8fw3tehvus7gTbvHH2IaxW1NdT2Mtd4BPhvr29R4H6gucIxprTt44AngT7gZeC0gn0fBTZ719gCfHCoz2qov3FXHwkhPiaE6PNu/njv9X8AP/TUFwvLnHYG6ou+apim48BHgHqUgPiMEOKdJcecjhIwbwa+KoQ4U0p5L/B9lHSvllIeWqbtj3p/pwOLULOQX5QccxKw3Ovrt4QQB3rbrwSulFLWAotRX+pyPIr6oQGcgvrgTi14/2jpCVLKU7yXh3p9v9l7PwP1RZ4NfBy4WgjRUOaa3aiV2g1CiHcKIaYP0bdC3gOcBSwDzkMJhK+jBIwGfL6CNsrxD9RnMw21avwzgJTyt97r//Xu8TwhhIZa4bzs3eMZwBeFEG/x2vo26lkvBt6C+jFVhBDiAOBk1HPJ8ixwGNAI/AW4VQgRqvC7A3AssAH1jP4XuFYIkV2N/QVYBTShftwfrrSvFdxLALgTNRA3AjeiVteFDPdd+SHqcz4MWOId862ScxtRK/5LChuVUq4DPg085T2b+oLd7wcuBxpQz/l7BfvKPuuC/W8HbkL9zu9i8O+wEo5F/b6mlVx7KP4A2KhncDhq/BiTumYIPgB8zOtXAPhSyf6hxpgcQojZKIH7XdQz/BJwuxCiRQhRBVyFmpTUACegJpvDfVaDGHehIKX8vXfR51ES7RBgDVArpayXUm4pc1oTSkoP1+4jUspXpJSulHI16gdwaslhl0sp41LKV4Dfo76clfBB1Ax/s5QyBnwNuFAIUaheu1xKmZRSvowarLIDhAUsEUI0SyljUsqnh7jGoxQLgR8UvD+VMkJhGCzgv6SUlpTyHpT0H6RnlmrqcDpqBv9jYKcQ4jEhxNJh2v65lLJDStkG/At4Rkr5opQyjRqADh9FPwv7cp2UMuq18x3gUCFE3RCHHw20SCn/S0qZkVJuRql6LvT2vw/4npSyR0q5A/VDGIkXhBBxlNroEeCXBX27QUrZLaW0pZQ/Rs2gR6O33yal/J2U0kENMDOB6UKIed69fMu7j8dRA91wzPImT7k/1GBRjuNQKuCrvO/CHSgBVEjZ74ontD4J/Jv3HKMoAXhhwbku8G0pZVpKmazwWQDcIaVcJZXa5s8oIQBU9Kwfl1Le4z3LP5H/nY2Gdinlz71rDNtvb6L0VuCL3tixG7XKuHCY095X8hnNqrBfv5dSbvT6dAsFz8VjqDGmkA8B93jPyJVS/hOlqXibt98FVgohwlLKnVLKtRX2Lce4CgUhRKP3kPpRUuoR1AxqOdArhPjiEKd2o35Iw7V9rBDiYSFEp9f+p1Ezs0J2FLzehlJBVMIs7/jCcw2U6iTLroLXCfI6zY+jZlvrhRDPCiHOpTxPAcu8L+FhqCXyXCFEM0oF9ViFfQXolsV60sL+FCGlbJVSXiqlXIya8cW9aw9FR8HrZJn3Za8zHEIIXQjxP0KI14UQAyghBYM/vyzzKRkcUauV7Ocxi8Gf9Ugc4fX9AtRMsqqgf/8hhFgnhOj3rlU3TN/KkftuSCkT3stqr589Bdso6Xc52r3JU+4PpZ4qxyygzRP+Q7U/1HelBYgAzxc843u97Vk6pZSpEfpbjqF+K5U869JzQyWTs0oY6RkXMh8wUROm7HP4DWo2PxS3lHxG7RVea8jnUuH+bH/fW2bSMFNKGUd9vz/t3c/fvZXxqBhXoeDNOOqBTwHXeK/vBc7zHt7Phjj1QWCOEOKoYZr/C2qWNVdKWYfSf5YaTOcWvJ6Hsi+A0tcNRzvqYReea1M8IJZFSrlJSvl+1Jfoh8Bt3jKu9LgEavX0BWCNlDKD0gv+O/C6lLJrpGuNFW9WfTWwchyai6MGFUAN/BQPKIV8AHgHynZSh9KhQv7zK/18dgBbSn54NVLK7GxoJ4M/6xGRiltQAvpbXr9PRunN34eyl9Sj7B5D9W007AQahRCRgm1zhzp4D9ufXaCqGk37XSghv6LgGddJKQsHopHufVTPpoJnPV6U9qvou4pSi2XZAaRR+v3sc6iVUq4Y5TWHu8Z4sgNl3yn8bVRJKf8HQEp5n5TyLNQkez15Z4qKP6u95ZJ6JHlvo8NRg+GQSCk3oZbzN3pueQEhREgIcaEQ4qveYTWoWVdKCHEMaqAp5T+FEBEhxAqU7i6rg+8AFni66nLcCPybEGKhEKKavB55RK8FIcSHhBAtUkoXZfgBZdApx6PApeRVRY+UvC9HB8rOMWqEEA1CiMuFEEuEEJq3KrkYGErFNRo2omZx53ieZt9EqQLKUYP64XWjfjjfL9lfeo+rgAEhxGVCiLC30lgphDja238L8DXv/uYAnxtl3/8HuEQIMcPrm40yaBtCiG8BtSV9G+67MyRSym2opf13vO/08Sg7zXjxFOq7dqkQwhBCvAO16qykby5qwPipEGIaKH11gd2mEjpQk7lAhceP9Kz3Fi8BpwjlylqHUg8DIKXciTL6/lgIUev9ThYLIUpV03t8jXHmBuA8IcRbvN9FyBsz5wghpgsh3u5NStMoVWF2LKr4s9qrQkEI0QQ4UsreCs75PMqodDVqcH0dZTS729v/WeC/hBBR1CyvnEH3UZRh60HgCillNgjsVu/fblE+XuI6lP7yMZTFPkXlA83ZwFohRAxldL5wmCX3o6gfxmNDvC/Hd4A/eEvF91XYpywZ1Kz8AZS3xxrUl+Wjo2xnEFLKftRncg3KYyOO8lYpxx9RKp42lLdQqVC6FjjIu8e/evrk81Bqti2oWe01qFUGKCPmNm/f/ajPbjR9fwX17L8M3Icygm/02kxRrH4Y6bszEh8EjkcJxO+iJirpPWhnEN5q890oFWYfSt/8t1G0fxnq9/K0p9Z7gNHZUh5CeQjtEkJUstId6VnvFTy9+80or7rnUc+okI+gDL+vojzIbmMEdfYeXGNc8Fb770CpUztRz+/LqLFcQzn1tKM8r05F/UZhFJ+VKFZHTk6EEAtQA4RZyezex2d/IYS4GVgvpfz2Xmr/GeDXUsrf7432faY+b9g0Fz4++wIhxNGeOkITQpyNmuX9dRzbP1UIMcNTH12E8va7d7za93njsdcimn18fABlcLwD5XbdCnxGSvniOLa/HKVKrUapXM/39OQ+PnvElFAf+fj4+PiMD776yMfHx8cnx4RQHzU3N8sFCxbs7274+Pj4TCqef/75LinlUPFBe8ReEQqen+xjqBD5EV2zFixYwHPPPbc3uuLj4+MzZRFCVBLNPyoqUh8JIa4TQuwWQqwp2X62EGKDEOK1giAzUP7PQyWG8/Hx8fGZoFRqU7geFaSVw0trcDUqmdRBwPuFEAcJIc5EBYGMmCLCx8fHx2diUZH6SEr5mBcgVsgxwGtSZbBECHETyge7GpVs7CAgKYS4xwupL0IIcQleOt558ypKXePj4+Pjs5cZi01hNsUh6q3AsVLKS0GVfwO6ygkEyOXR/y3AUUcd5fvF+vjsAyzLorW1lVRqT5Kf+uwvQqEQc+bMwTTNvX6tsQiFcpkNc4O7lPL6MbTt4+OzF2htbaWmpoYFCxZQnFzVZ6IipaS7u5vW1lYWLixXo2x8GUucQivFaXrnkE9VXRFCiPOEEL/t7+8fQzd8fHwqJZVK0dTU5AuESYQQgqampn22uhuLUHgWWOqlmw6gKhWNVFWqCCnl3VLKS+rqhirA5ePjM974AmHysS8/s4rUR0KIG1H1hZuFEK2o+INrhRCXotLh6sB1oy39JoQ4DzhvyZIlo+u1x7NrH8Tq3cIJMxYU7wjWwpyjwf/y+/j4+IyKilYKUsr3SylnSilNKeUcKeW13vZ7pJTLpJSLpZSVFMgubXdMK4Wrn/ohn9/0U5wb3gOFf9eeRe+6/2PX7rXsiu+iJ9WzR+37+PjsHe68806EEKxfv37EY3/2s5+RSOQrmr7tbW+jr69vTNePRqMcdthhub/m5ma++MUvAnD99dfT0tKS23fNNdfkzrvssstYuXIlK1eu5Oabb85t/+AHP8jy5ctZuXIlF198MZZljal/+5NJnfuoP7SQtKbx+in/Be/4Fbzjajj8wwBs3fEvXt/2CBu717O+85X93FMfH59CbrzxRk466SRuuummEY8tFQr33HMP9fX1Y7p+TU0NL730Uu5v/vz5vPvd787tv+CCC3L7PvGJTwDw97//nRdeeIGXXnqJZ555hh/96EcMDAwASiisX7+eV155hWQyWSRIJhv7VSiM1dBcX6XKKseWnQeHfwBWng/1apswq6jXAtR3vYbetWnc+uzj4zM2YrEYTzzxBNdee22RUHAchy996UscfPDBHHLIIfz85z/nqquuor29ndNPP53TTz8dUGlxurq6uOyyy/jlL3+ZO/873/kOP/7xjwH40Y9+xNFHH80hhxzCt789fD2jTZs2sXv3bk4++eRhj3v11Vc59dRTMQyDqqoqDj30UO69V5WueNvb3oYQAiEExxxzDK2tQxUhnPjs14R4Usq7gbuPOuqoT45325qmQ6hGOclmYvkdrgOaPt6X8/GZdFx+91pebR8Y1zYPmlXLt88bvub9X//6V84++2yWLVtGY2MjL7zwAkcccQS//e1v2bJlCy+++CKGYdDT00NjYyM/+clPePjhh2lubi5q58ILL+SLX/win/2sqjh5yy23cO+993L//fezadMmVq1ahZSSt7/97Tz22GOccsopZftz4403csEFFxQZc2+//XYee+wxli1bxk9/+lPmzp3LoYceyuWXX86///u/k0gkePjhhznooIOK2rIsiz/96U9ceeWVe/L4JgSTWn1UHhUq0bx7A+iBvLHZSsHWJ6FjVLZwHx+fcebGG2/kwgsvBNTAfuONNwLwwAMP8OlPfxrDUHPVxsbGYds5/PDD2b17N+3t7bz88ss0NDQwb9487r//fu6//34OP/xwjjjiCNavX8+mTUNrC2666Sbe//73596fd955bN26ldWrV3PmmWdy0UUXAfDmN7+Zt73tbZxwwgm8//3v5/jjj8/1NctnP/tZTjnllBFXHROZCZE6ezxxjRAa0Lz5CbpXng+A41qw42lIDUCkYf920MdngjDSjH5v0N3dzUMPPcSaNWsQQuA4DkII/vd//xcp5ahdL88//3xuu+02du3alRM0Ukq+9rWv8alPfWrE819++WVs2+bII4/MbWtqasq9/uQnP8lll12We/+Nb3yDb3zjGwB84AMfYOnSpbl9l19+OZ2dnfzmN78Z1T1MNCa1TaEcqcaFuJpOZ9Vc2vqSaFLDTg9gCyBcP27X8fHxGT233XYbH/nIR9i2bRtbt25lx44dLFy4kMcff5w3v/nN/PrXv8a2bQB6epTXYE1NDdFotGx7F154ITfddBO33XYb55+vJoFvectbuO6664jFlNq4ra2N3bt3lz3/xhtvLFolAOzcma9metddd3HggQcCyubR3d0NwOrVq1m9ejVvfvObAbjmmmu47777uPHGG9G0ya2AmXI2haRr4VRNBwTRtI2jhdCqp4NZDVYCXBv6tkPtbN+24OOzj7nxxhv56le/WrTtPe95D3/5y1/4+c9/zsaNGznkkEMwTZNPfvKTXHrppVxyySW89a1vZebMmTz88MNF565YsYJoNMrs2bOZOXMmoNQ869at4/jjjwegurqaG264gWnTpg3qzy233MI999xTtO2qq67irrvuwjAMGhsbuf766wFlL8iqhWpra7nhhhty6qNPf/rTzJ8/P3fNd7/73XzrW98a49PaP0yIGs1HHXWU3JMiOx+78/s8N3Ajfzjj/zhiziKwUmxbdycN/7yc2uhOnl3+QQKHnkHUjnFc4woMKwHCACsOC04CM7wX7sbHZ+Kybt263MzXZ3JR7rMTQjwvpTxqPK8zudc5ZYjaCapjqpTD0Rv+XLxTD0C6Hxx7P/TMx8fHZ+Iz5WwKA1YczcvW3VNTUqfBCELNDND3fvpZHx8fn8nIfhUK450Qz3IsUo7LS4veAUDGqBqXdn18fHzeKEwp9VFaWmS0MJunH0tf7YL93R0fHx+fScfUEgpIUloEXfOzo/r4+PjsCVNKKKTsFCnLxZjkfsI+Pj4++4spZWiOWTHstI2BMy7t+fj4jD+6rnPYYYexcuVKzjvvvDGnwc5y/fXXc+mll45LW4WcfPLJuTTas2bN4p3vfCcAjzzyCHV1dbl9//Vf/5U758orr2TlypWsWLGCn/3sZ7ntX/7ylznggAM45JBDeNe73jVu9z6eTClDc38qjuZKdDLj0p6Pj8/4Ew6Heemll1izZg2NjY1cffXV+7tLw/Kvf/0rl0b7+OOPL0qxffLJJ+f2ZYPV1qxZw+9+9ztWrVrFyy+/zN/+9rdc7qWzzjqLNWvWsHr1apYtW8YPfvCD/XJPwzGl9CzRTAJCDbh6KL9xAgTn+fj4lOf444+nra0NgFWrVnHCCSdw+OGHc8IJJ7BhwwZArQDe/e53c/bZZ7N06VK+8pWv5M7//e9/z7Jlyzj11FN54oknctu3bdvGGWecwSGHHMIZZ5zB9u3bAfjoRz/KZz7zGU4//XQWLVrEo48+ysUXX8yBBx7IRz/60WH7Go1Geeihh3IrhaFYt24dxx13HJFIBMMwOPXUU7nzzjsBFW2djYI+7rjjJmSK7SmTEM92bVKWhSbycs5w0hx097+xa94xcMq+T/7l4zOh+cdXYdc4F6CacTC89X8qOtRxHB588EE+/vGPA3DAAQfw2GOPYRgGDzzwAF//+te5/fbbAXjppZd48cUXCQaDLF++nM997nMYhsG3v/1tnn/+eerq6jj99NM5/PDDAbj00kv5yEc+wkUXXcR1113H5z//ef76178C0Nvby0MPPcRdd93FeeedxxNPPME111zD0UcfzUsvvcRhhx1Wtr933nknZ5xxBrW1tbltTz31FIceeiizZs3iiiuuYMWKFaxcuZJvfOMbdHd3Ew6HueeeezjqqMFBx9dddx0XXHBBpU92nzFlhILlWmRsB0He86h5YLP6t+3F/dUtHx+fEpLJJIcddhhbt27lyCOP5KyzzgKgv7+fiy66iE2bNiGEKCppecYZZ5BVMx900EFs27aNrq4uTjvtNFpaWgBVLW3jxo2AGqzvuOMOAD784Q8XrS7OO+88hBAcfPDBTJ8+nYMPPhhQeZS2bt06pFC48cYbc1XYAI444gi2bdtGdXU199xzD+985zvZtGkTBx54IJdddhlnnXUW1dXVHHrooYNSbH/ve9/DMAw++MEPjuVR7hWmlFBIWg4hXYAF9QNbc/vi9XOp32898/GZoFQ4ox9vsjaF/v5+zj33XK6++mo+//nP85//+Z+cfvrp3HnnnWzdupXTTjstd04wGMy91nU9l0m10lTbhcdl29I0rahdTdNy7ZbS3d3NqlWrcmogoGjF8La3vY3PfvazdHV10dzczMc//vHcCujrX/86c+bMyR37hz/8gb/97W88+OCDo04Vvi+YMt5HtmuTtlz0koeciTQNcYaPj8/+pK6ujquuuoorrrgCy7Lo7+9n9uzZALnMpMNx7LHH8sgjj9Dd3Y1lWdx66625fSeccEKu1Oef//xnTjrppDH19dZbb+Xcc88lFMrbK3ft2kU2oeiqVatwXTdXiyGbqnv79u3ccccdufTc9957Lz/84Q+56667iEQiY+rT3mLKpM7O2BnStouhK6HwxHFfI25LTtn4R9/Y7OMzQTn88MM59NBDuemmm/jKV77CRRddxE9+8hPe9KY3jXjuzJkz+c53vsPxxx/PzJkzOeKII3Ac5Y5+1VVXcfHFF/OjH/2IlpYWfv/734+pnzfddNOglN+33XYbv/rVrzAMg3A4zE033ZSb+b/nPe+hu7sb0zS5+uqraWhQxb0uvfRS0ul0TmV23HHH8etf/3pMfRtvpkzq7NoqjQc2rmeuYWNGd+AGaomlbc558YfEq5upf9tPMLL1E+LdsOBEP3W2zxsOP3X25MVPnT1K4pkkupgyt+Pj4+OzX5gyo2jSSqEJv5Kaj4+Pz1iYMkIhnkkhyt3OxDPu+/j4+ExYpoxQSFhpDDFlPGx9fHx89gtTQii40iVpWxj6lLgdHx8fn/3GlBhFHelgu+4wdRT2v4eVj4+Pz2RgSggFV7pkbIlWNjrQNyr4+Pj4VMqUiGh2pIPlSDRvpaA5GczojvHooo+PzzhTXV0NQHt7O+effz6gahOce+65Q55TWCvBdV0uuugiLr74YqSULFiwgK6urrLXKHc+wB//+MdcvYODDjqIK664AlBZVBcuXMhhhx3GAQccwOWXX162PxdccEGujsKCBQty+ZK2bt1KOBzO7fv0pz+dO+fmm2/mkEMOYcWKFUW5mH7yk59w0EEH5TK6btu2bdjnt7eZEvUUXOngOE4uxYWwk0jDD0zz8ZnIzJo1i9tuu21U50gp+fSnP41lWVxzzTV7lDvoH//4Bz/72c+4//77Wbt2LS+88AKFY9CPfvSjXI2EP/zhD2zZsmVQGzfffHPumPe85z1FNRYWL16c25eNVu7u7ubLX/4yDz74IGvXrqWjo4MHH3wQUFHdzz33HKtXr+b8888vEhj7gynhrmNJBxfIfj+kEUQKA+GkARClJgUnDR2vQsN8qGrep3318Zko/HDVD1nfs35c2zyg8QAuO+ayio7dunUr5557LmvWrKm4/S984Qt0d3dz8803o+1h2d0f/OAHXHHFFcyaNQuAUCjEJz85ONNOKpUCoKqqasi2pJTccsstPPTQQ8Nec/PmzSxbtiyX0fXMM8/k9ttv54wzzuD000/PHXfcccdxww03jPqexpMpYVOwHQdkdpWQxtXDuEYIzbWGOCENfdvASu7DXvr4+IyFv/zlLzz//PPcdNNNg1JRj4Y1a9Zw5JFHDrn/y1/+Mocddhhz5szhwgsvZNq0aUMe+69//Yvp06ezdOnS3LYtW7Zw+OGHc+qpp/Kvf/0LgCVLlrB+/Xq2bt2Kbdv89a9/ZceOwSrua6+9lre+9a17fG/jwZRYKdjSRXjLAc1THbl6CJkeQig0LoR4l5/7yOcNTaUz+onCEUccwfr161m1ahUnnnjiqM+vVNX0ox/9iPPPP59YLMYZZ5zBk08+yQknnFD22BtvvDGXARVUkr7t27fT1NTE888/zzvf+U7Wrl1LQ0MDv/rVr7jgggvQNI0TTjiBzZs3F7V1ww038Nxzz/Hoo4+O+t7GkymyUrCR3krBqp6NVT275AjfJdXHZ7JzwAEHcMstt3DBBRewdu3aYY8Nh8NkMvla7T09PTQ3K1XxihUreP7550e8XnV1NaeddhqPP/542f22bXPHHXcUVU8LBoO59NlHHnkkixcvzhX+Oe+883jmmWd46qmnWL58edHq4oEHHuB73/sed911V1GNh/3BlBAKjitzyfBcM8J2q5vbO+7hrr6HecXwXVJ9fKYKJ5xwAr/+9a8555xzcnWXy3HqqafmdPPJZJJbbrklp7v/2te+xle+8hV27doFQDqd5qqrrhrUhm3bPPPMMyxevLjsNR544AEOOOCAogI6nZ2dufTdmzdvZtOmTSxatAjI11jo7e3ll7/8Za6K24svvsinPvUp7rrrrmFVVfuKqaE+cp3c0tCVLn/c8EviTg8CwZ1B+FK5hUKqD/p2QP8OmHX4Pu2vj4/PnnPuuefS2dnJ2WefndPZH3LIITnD8/ve9z6uvPJKPvWpT3HVVVchpeQjH/kIp5xyCqCqpHV0dHDmmWcipUQIwcUXX5xr/8tf/jLf/e53yWQynHHGGUWeRYXcdNNNRaojgMcee4xvfetbGIaBruv8+te/prGxEVBG8pdffhmAb33rWyxbtix3vVgsxnvf+14A5s2bx1133TVej2vUTIl6Ct84/CqiKYtp1XVsGdjAtRt+RLLt/cyYdzcnJqJ8RdZTd87P8vUUALo2AgIaFsDcY8btXnx8JjJ+PYXJi19PYRS4rks2cvnVvheRroEdPQBQ1oSygq95GVRPpy0d4rmtPbzaPvaSoD4+Pj6TnSmhPnJk3qawqX8NTmIRyCACgesJi4xrFa8UgNe74nSLIG16ktn1oUHt+vj47Ft+//vfc+WVVxZtO/HEE7n66qv3U4/eeEwRoeCgaQH60j10pXZhx/M+yDIb0FbigdQZTRNL2fRLm/kLIjju/lej+fjsC7J69InIxz72MT72sY/t725MOPalmn/c1UdCiAOFEL8WQtwmhPjMeLdfDuV9JNgSVdGZTnyJ6gsCFwBJQDMLjofd0RQDKYt5TX6sgs8bh1AoRHd39z4dZHzGhpSS7u5uQqF9o82oaKUghLgOOBfYLaVcWbD9bOBKQAeukVL+j5RyHfBpIYQG/G4v9HkQEhddaOyIvU5QCxFNT1f984SCKMmUmsjY9CUtZtWHsfdFB318Jghz5syhtbWVzs7O/d0Vn1EQCoWKXF/3JpWqj64HfgH8MbtBCKEDVwNnAa3As0KIu6SUrwoh3g581Ttnr+O6EmEI2hLbmFU1ny5vASTAWykUk7IdgoYODBHx7OMzRTFNk4ULF+7vbvhMYCpSH0kpHwN6SjYfA7wmpdwspcwANwHv8I6/S0p5AvDBodoUQlwihHhOCPHcWGctEheBpCPRxqzIvPw1EGVjmZMZZ1CQs+svp318fHzGZGieDRRmdGoFjhVCnAa8GwgC9wx1spTyt8BvQcUpjKEfuI6kJ9OJLS1mFgoFkVUfFTffn7QImpqf/cLHx8enhLEIhXLuC1JK+QjwyBjaHTUu0JlqA2BGJK93E4ic91EWKcFyJHH6aUt30ByomhrBGj4+Pj7jwFjGw1ZgbsH7OUD7aBoYr8prrnTpTLajodEcmpFvH4EDRPrbofs1cCxStkNPeoBep49dmW4GrCgAof7N0PoctL/op9T28fF5wzKWlcKzwFIhxEKgDbgQ+MBoGpBS3g3cfdRRRw2ucDEKXCSdqXYaQ9NA5m9JINCsJKFkL9ypyuKFgd0n/C9pN0GdYxNODxDuegXbdaGvBxCQ7IdgDcwZOuf6ntDel8TUNVpq9m8WRB8fH5+hqGilIIS4EXgKWC6EaBVCfFxKaQOXAvcB64BbpJTD57Md3O64rBSkK+lK7WRaaCart+fT5QohSNQNduP6wJNfoUavwg5Pw0x2EhzYipHqBiQ0zIPYLjACY+pTlkTGZvdAira+JG19CV7bHRuXdn18fHz2BpV6H71fSjlTSmlKKedIKa/1tt8jpVwmpVwspfzeaC8+XjWaHVx60100BFtY354XClJKXrS6efeBR5L42D/5+5l5D9lqowqEIFM7n3TtAox0L2gmCA3CDRDrUqqk9hchumuP+7axI8qqLT1s6ojS1pvC1CdmJKmPj48PTJGEeAlrAFvaNASbeX13Pvbg8OACtV86tG5+lWjnRl6afTyONlhrlqpbAvWeiaR6GsQ7oGcL9GxVGVWdPQtzS2ZcGqsCNFUFmdsQ2aM2fHx8fPYV+zX3kRDiPOC8JUuWjKmdqN0LQJAmuqIuQVOQtiQH1B3FK7RTQ4gXXEkiUkstGrprKzek4WhZnn8d72JP/Vdt16U6MCVSTPn4+LwB2K8rhfFSHw1YSigMROsBWDxNDcKpmgVIoZPWwnSGZmGHIoTsFACz254c0zUrIW07WI6LoU+JBZmPj88bgCkxWsVsZaju6K4hYMCcRiUUBALLcbEch3AoxfSWo9g29yQADn71z7T0vrZX+tMdS7OjJ0FrbxLL9iPkfHx8Jg9TQigk7SghPcKOLo25TQaaljXmCi9NMGRctUKI1sxm9YoPAXD6i78d03V3D6QGpdyWUrKlK84L23vZ0ZMgHNCHONvHx8dn4rFfhcJ4uaQmnRjVRi2tPTYLmvMpsl3AdUHXJNVmbW57+6xj6atTScGOeOQ/9uiaadthe0+CpKVUROt29rOzL8nLrf10DKSY2xChqSpIQ2R8XFt9fHx89gVTwqaQtGOYohZXwrzmvFHXcSQSSUALUhdoLDpn1VFfBCCU7GL6Y1+g27NLVMqGXVGiKQtdCOJpm23dSTZ1xOhPWNSGTEzfjuDj4zMJmRIjV8pNIO0qAOY25oWCLjQMTUMTg2/T1U3+fvxXAWjs34wuRlbzbO6M8ejG3Ty2cTe7o2kynr0gbbtoAhqqAjRWBaj3Vwc+Pj6TlCnhK5lxk2TsMJGAoLE6LwBaqkMIMbQzaTzcSG/tfOK6iSlGfhT9SYuQoRM2lQDpTahAuWjKxvXLefr4+EwBpoRNwXLTZDJBmmv04tqzFdShdZEjxywApPoRsd0YmoYQAiEEKculK5YmnraxfaHg4+MzBZgSNgWJJJ0J0lBVfDv5MpxqwI6lXDJO8XkS0MtmAS+hdxt656tUdb+S25S0HV5p66O9P+lVcvPx8fGZ3EwJmwJAIhWkvqxQyA/437ilhyuemZZ7n3EtXFFSwTmTgGd+A+lofpuTASRGqotAqotQ12oAFjdXM7ehiozt+jmNfHx8pgRTRijYVoiGquLZuvTUR7JAPbS1P28ETrsZbw1RoPppfwFevhH+cF5+WzqKG9uNlGBY/RipHoSTzu2e31hFU/XI6bAdV5KxXRhoB9cZ8XgfHx+ffc2UEQrSzauP8qFr5cvDFeIiEYU2BaNgcH/9YfVvy3IcO0Oqahbp+iWDTBC6VtkqQctWAI12+IV8fHx8JiRTwtAMgBOmPlJ6O8MP1jOCLRhaACllfjVROOI/eDnSdemJZxgIziQjQqpVNzOscTq0+0VCnS8T6lqNcPKpvDUhMCsUID4+Pj77gylhaAaQ7mD1UVgPD3uOIXRcqbO9L8Bdm0p2miruIfrcjbzWGWNLV5xsPJrmWAR7N6JlBsq2K1ybYP/rmLGdhDpX52wQPj4+PhOdKaM+0mSImnDxLNzUlP1ADpP22nIFGpIn27JbvGPf+j8A1L70O5Jpi7qwmQtKE26awMA2An3lE+q5gVqsyAzscDOB2I6ccKjI9dXHx8dnPzJlhEJNMIJWEpcghMbIVgXQcbFdr4hOdtwWGpzyFQCWrv910fHp+iVYkRaMVB/B3o1Dtit1k3T9YjQ7jhnfSbjrZcxkZ8X35OPj47OvmTJCoSEyWFVUGqdQjjkD6zlcew2kW3ysELDszQDM6ngYI15cklOaEfTMAHqqd9C+UtL1S3B1k1B0G8H+zf6KwcfHZ8IyJYSCdE0aImaZ7WLEdULUS5T3e+dbJXsEFjpPHvl1ABb+8xODzk3XL8KM7yQwsJVQ15phr+OEm0nVLCSQaIdkd0XR1j4+Pj77mikiFELUhPKDbEdMZTzVNGV4Hm5e/pdDvwfAMrkdBnYWHe04kvbILKJVMwBo2HgbCSdZFPeQrluIGW9HeBXdhkUIYjWLSdkulKkT7ePj47O/mRouqW6AoJkXCkKoQVvk/leMGWsv6ITGcamfq9cPXl6g2hHKQC1cnjjm3wBofvV6dkRfJ+rEC2+CTM1ctIJgtuFwXMnuaGXH+vj4+OxrpoRLqnQNQp5QSNsWIaMkdXWJDl8aIZB27v0umhigCjrXw9O/UhuFOk3ikjFC9Cx7LwBnPf4dglpx+1JoSM0A18GMbh+6n1KScVxqQ4NVXT4+Pj4TgSmhPkIauZXClr42gl5UspIFg5cKjlGFKEkz8THzv9WL/h3eFkFrskNlUQW6D/wI/VXTCdopqsrYD4RrYcZaCQxsHzJ+Qdc0bEdi+AFsPj4+E5SpIxQMNdCm7AwBXenrxVDGXD0wyNDbqbXA+2/Mb3BtejIxoo6XGE8IHj7q/wEw/+nvFp3roGElOtjW8yJOshsj1YVwBtsYNA0ifs1mHx+fCcyUsHZKmVcf1QSriAaCQDLnklqJA6iUsMOqR19xMbPWXscGmSZmOcSdFFW6MjRndJXmQnMzvBbfhoWNlC6WtHFkHGOgh+16NfPqT9gbt+nj4+Oz15kSQiGrPupNDlATqGJuXQvQh5SCck6pq9oCtEd1EDpdifxi6eG2dci6A5h+zhUIbHozURr0WgAc6SKR7KpfiIGgw+rC9lRQET1EY2ga/UaYxsjCfXLLPj4+PnuDKSEUlKFZoz3axaKGWSQ91VB2nVCa5uLaF9VArwmJKz21k+OyttuhpirOQTPmEAkY1Gk26+M9IGFrshVbOrgIHNdiRqBlH96hj4+Pz75hSggFpEnQFDi2JGyGcpt70p24uUjlYv779G5aanSSFvzbP+rpjJvcvHo2M6ttzpiXImMrTyGEQ7fVhyVtkk4KV0CwkkptPj4+PpOQKSEUpGdojphhFtTPYdvOBAAuLmq9ULxSCBku06ocJPqgwOKEJWjtTaEJcCUgHOJOhumBFprMeiSiuP7CHnW4vKDy8fHx2d9MkeA1A1fEiZhhljXPyG+X5bNJzKnNu6MW7taFxJaCmpBBVdCgJmQQMHRcZC7ZnhQagrEN6sJOQcerY2rDx8fHZ28wJYLXkAaWmyZsBAmXcfksndcfNiMfUawXPIGAIbGdYikiVUfz74UYc0I7KQQke8fUho+Pj8/eYErEKQh0+tID1AQiZfeWsrzJyr3WC3YHdcg4xWN+vVFDo1mfe6/UR2NbKciaWX5CPB8fnwnJpBYK0lPjaELDlYKgYZbsLy6xGQ4IFk0zmFdXoD4qGJsDukQilC3BQxc6YT3E2t0GX7q3lg2dtXTGDP66Lm/Q9vHx8ZkqTGqh4Hj5i3ShYzuCpnD9oGMK5+OagNkNQ9vWg7qSBlaZhcBzbSaxjEZ92EXHZWuvH5ns4+Mz9ZjUQkFKNePXNEFAM6gJVJU5SlQU0QwQ8OSF5dkVnm0z+eOLYVr7Nbb3GSxvtpjXIAhozjCt+Pj4+ExeJrVLqosanHWhEdBNmqqrx9Re6UrhrnUhOhM6T+5QCfYabEGyuZ5F8jka3D7Az3bq4+MztZjcKwXPpqBrgoBh0lxVXJIzbzBWL2yXIntBKYGsUPBWCnErr3yaXePw0cMT9NUvBuBoZ/U43IGPj4/PxGJyCwWZNTQr9ZGpD76dwtxHaUvyxMahK6RlvVmzwiNZIBT+8/Qoy5ttEhGV3iIpfEOzj4/P1GOSq48KVgp6cND+B9am6LdBFw73rU6M2F7QUCuFjCNI28r9tJTstjFHNfv4+PhMQCa1UMi5pKKha3lvoOxQ/s9XkoTnCcDhnu1KKMxvHvqWs+qjpCXoSQ6xiMol29szoeAnuPDx8ZnITGqh4HreR0IIqozwoP0NVRrTWySGFuDjpzSRsqSq0Na3q2x7c734haueHs5gXZlQSLsZpJSESlYwqYzDroEUNZE09O2A+rnDtuPj4+OzL9krQkEI8U7gHGAacLWU8v69cZ3C4DW9jD0hHBAIIRBCua1GgsNHER812yKeSWK7YOiSiCH5w0vFbq5yBKEgkWyMb/WOFCytWlC8X0oQGmSiqgKcj4+PzwSiYkOzEOI6IcRuIcSaku1nCyE2CCFeE0J8FUBK+Vcp5SeBjwIXjGuPCygUClXm4JVCOOAlsRuk/y8/oBsanLE4zVuWpjljUYbj51mDD/Lkyq6oxpPbBw/qu9Kd9Nh99NnRsldxshtD9Uo4+Pj4+EwgRjMqXQ+cXbhBCKEDVwNvBQ4C3i+EOKjgkG96+/cKjszGKejUBQfnPcoKhUFIFyPeAV5E9GgoXCn88aUIHTGNVEEzQgiCIkDaTZc9vyZk0FQV8NryjdU+Pj4Ti4rVR1LKx4QQC0o2HwO8JqXcDCCEuAl4hxBiHfA/wD+klC+Ua08IcQlwCcC8efP2oOvgeuUwNaERMAannYgENKLlPIi0IHaoCTO2E6t6Nh85qJOGusErDYDPHhOjIVw4eBdWdYNvP1TLvDqbr58aA5Sg0oVGlR6hzqgp33GvxMO6nVFmz26gLuIHwfn4+EwMxqq/mA3sKHjf6m37HHAmcL4Q4tPlTpRS/lZKeZSU8qiWlj0rbZlfKWiYen5gzQ7hQ60U0g1LkGYEhIGQDqdO72B5s41TJrLtkBl2zgAN5LyPNKFUV9OqHKKZ/GOUgC0dtAoerZSStD3KlBmxTmh9Aayh4y18fHx89pSxGprLjbpSSnkVcNUY2x4RR2bjFDQCev5W4hmlz3Hd8h0EsMMt6Jl+9FQPAAPJDGnHZXrN8EFppbEL06tdWvv1gv0SQ+i4Q8QxSClJZlySuEhDqZtGRWoA+raAk4ZZh0EZW4qPj4/PnjLWlUIrUOhTOQdor/TksVZey7qk6pqOoeWFQtRT8jfXqsG6nO7eCdbhmFUIJwO6STDeVmGn1T+a12aVWdy2lHLYVUIs7bCtO8bGjii9iQyGNkqhYAQgUA2JLkj0jO5cHx8fnxEYq1B4FlgqhFgohAgAFwJ3VXryWCuvZdVHhqZh6vnZelYohAzB0GsFQBigBxhwg6REGMMeOepZeo8s65KqaXmRk3RTpN0M1nAGbAlpW1IXEJDopTNW3iA9LJoOVhK6NkLbi+q1j4+PzzgwGpfUG4GngOVCiFYhxMellDZwKXAfsA64RUq5du90dTBuofqoIKK5P6lcSfM2BVlyHgwkLbqM6fSJOhIWZMxagpnKZ94akl+/vS9rM1ZXkZKoHaPWGDr4rSZkUBsy0awBzORu3IHygXQj0rxUybu+bbB7/Z614ePj41PCaLyP3j/E9nuAe/bk4kKI84DzlixZsien59VH6ESC+VvZuCsKQG1YQyQKh22F7bgEDI3ZLU3QUkOit4OOri4cPYxwbaQ2zGMZJs2FU0GZzqynUTq4gGD7JoLpLmDpiOeVJVQPrgNVzXt2vo+Pj08J+zV6aqzqo1xCPF0r0s1nPXoasvEAZWy+uiZ5suOf1NdUUTNtPvGaRVhmHUZ85/B99tRR9SGncGOOkDY4MV9ZNIN0sIF6La0Gdh8fH58JwOQOqfVm5obQ0Qq8eK7+4BEcvaCB+XUzi1JnF3Llmm/wp1f/xC0bb8kdYQdqiTlmeSmSQx19ztKxu4SaVY0EUl3Q/mJeMDi2byPw8fHZb+zXhHhjVh+RDV7T0QpWCicsbqYmZNKbiHpbBg/yfZluAFoHWnPb6qYvgI5+9FgbTvUMZYguQYpiO4UQQyXNqAAhcCNN0LddvZ++AlqfU40uOKnkwjKnuvLx8fHZW0xq9VE+91H5wVKgjRgH0BBqyL2uDQfQzTB2sAEzvnvY87L1FMY8TAeqoWY6pKJgpyDV58UibM+7nPZsUV5GQ+GMPl2Hj4+PTzkmtfooKxQMMTjFhSg6rpjHd/0j97o+VO8dr87I1MzDCjbiBGowkp2Dr5lLYjeOeYvMCKR6oXsLGGG1IujdBm3Pw8BOpSbLRCFVJp7DsaB3K8S7xq8/Pj4+b1j2q1AYr+A1TRssFHLXKBAPW6Ib+eazn+ChnXfmth3YeGDR8dIIk6mejWuqvEVmvB2kkxMQ0hNAMzryKZ3GpQhb9TQVkGanoGYGxHerlcKu1WrAT/aq19ESQ3j1dCUw0rFx6ISPj88bnf1qU5BS3g3cfdRRR31yj873Zuv6CCuF1vhmvvnsJ8q2ESitaaABLqTrFyD7JLK/Dd2xEK4N0sUxglhGiIa+zZiZKFA+zcSo1UqBKrUSyK5EGhepf+Nd0L9DCY1Uvwqy0ApkuRAQrN6TK/r4+PgMYpKrj/IRzUOxJbph0La3z7uIDy35fO59qdlBSkAY9BjTGXAMZRDWAuhptaLZMfcUAJa+9rfxH4pLYx2qmqFpMQRroHY21M6A2lnjfVUfHx8fYJILhaxeX6uwWM2bZr2d7x59DYc1nTjkMbbtkrbVwGwLE6Hp4DpIPYjrZWLduOTtAMxr/RcGZQrx7CmOBe4IRuPhAut8fHx8xsiktilkdflDeR8V8l9H/ZY3zX572X0Zu3h2nk2TkXFcNFyMVDcIDSPd53U8/9iu67iEaEbj+fY9q4lgOS7JjEMy45AKNIBRYfCbj4+Pz15gUruk5lYKFWQaza4m7DI1E9J2Pse2rglqQwYDSYuQqYMRxgk1ITUdV8+n1b7/jJ/lXp+jPc3mnqGN3cPR2pvklbZ+1u4cYF2Pi6yesUftTBo6N8L2Z1TA3vZnlIeVj4/PhGGSq48UlQgFgKTlsKu/fCSyEBBL2+iaYGZ9mCMWNHDw3EZkuBHXiCC1AK5ZjRlTmcFdPcAjJ38XgKsDV7E0Pdh2MRKJjIPluDRUBagLm2WL/Ew5Et3QuwX6W2GgDfrboP2lsblwSana89OF+PiMmUktFLLDiFFhpK87xKDruCqjkSuVC2tha+mq2aQblpBuWIobrFdpqz1S4UaedZcB8NXuH+b7JSGRESRGMjfIcY12mBwYIaifC3VzoHGhMqQP7FQut3uClLBjlVqB7FqjqtJlRk6B7uPjU55JLRTyhuax+QDpmqAubGLqEDI1qoLljbmZ6hk4ZjVmNF+B9L2Z7+Re1yZ7iKT6+MemIN96YBaX/M3k8VYLIzF8dHQ5EhmHlDVy1tUcIxmoJyrZynGdG/asxKidVqsPAfRvV6nE+7ZVfr7rQCYOdsZrLzNOgSc+PpOTSZ37KPvTLScURiMnBGDqOgtbhq6DoA40sKpmIOx8YZx5dTa/jL+dzxp38b5nfwHAu4H7xB9ISxO7t42Fz10KwKZ3/q2ouXBwaDvEho4oQV3joFm1I9+Ak4FEJ8hF+y8/kusAIh9D4ToqxiLRA/VzlEvtUNRMh57XlQF/ztHFcRiVoJsQblB/qQEQuhrcdXPk55HshZ2r1bFmGNJRCNdDzUz1Ot4FugGNiyHSOLp++fhMQia3odmTCnqFA+FQhw01H3elMkwXap3syPSiQes/Toxxh3PSoHM3BC/i6eD/I+TGc9uW/N/b0TIDI/ZTyqxKq8IBPhv4tr9WC+mYUuG0v6AG5UxcBdzteAZ2r1E2g11rh87RJIQK1htoV+eMlCU21a9yQe18WdkSCmM7hFBR363PQtcmdc1da1SfMnFVuLvo2ponVLuVGivVr15vfQI616v76G9XAsLH5w3AlHB6rzBMYUg0oJyt2nZdqkM6fYk0jVUlrqLSBmEQNCBi5KVGR/MKpnep4nMzRC8f3nJZvp/SpeWVa+g48t9z21Tth2J3VleqKm6W4yJl1tYxzAQ6UA2Wt3pxXSUcjMAQB48jjqVKgjqOGpxDtWowDUTUfk2H+iVqsM3E1Qw8Eyt/I0JTK4q+7bDLULP2GSvV/UhHzeSzdG2Enq3qeq6jckdlCdaoBILSUQN8fyvYSejbAWZIVayrm1N8bc2AhvnqtWtDohcaF+S/WPFuJXh9fN4ATGqbghwnm0Jt2KA2PFg+VgUNFjVXD4qYds1qjFSBYbTg8nf3LmdJ6o886B5edE7b8Zera+14iKZX/whAXdhkWk2IoXCRvNYZ44XtPaxu6yPjVGBjaH9Rpd/Ozoh7t6kZtTOOQXZZUgNq0E10Q91spb6pboZYhxqUs5HXtTPVvztXq4HaKJ8aBM1QeZ/6t0OsU6me2p5T95PsUyuSaIcSBJFGlfqjdiaES1aajQuhYSFUt6gUINXToKoJYrvV84h2DH1PmqHOK5xpSFetYnx83gBMiZWCPkodtOOqWXiWSNAoKudZiHJ3LRY6drgFzcqrhdrJl8O00xlsDD6e+RLXm//LafrLALhGmM4VF9Oy9joaN96C1Ex6Dihb4TSHlMpNtjpgkrCcyuyfqT41eMY61IDZu1UNrhKYflDxjHusGEE1szbDeYMxqNl4KTXTK2vTjKgBvXerEmapAaXeMUIq8Z+UarUxUpBfuSSJzUuV7cK1wUqo2X8lwjJUq1YLUnp98QMMfaYuk3qlMKz30TCLh4GURWdazfyebn96xKtYJTN0WTLgpAnyXPAI73VWbSP4qHUZa12llpB6kL6l7yZVpxLdNa3/8+ALSRVIl/HKifYlLJBg6KNZCQlwUmpQ3faUGsiqm6HnNTWrHyvxLqUKymKEhjci7wlCKBWPpkPDPLXiiLZBsl/p9o2gWpXsSbtNS9TAvmsNbH1cxUyM5BisB8CKKTtF+0vKVrF7fbGXkuuqvhXaTVL9ea8mH59JwpRYKVRskPWQEjqSaoB8eMfDfPCgDw55rOPKQQZqIV2EnUJoJtLTZ/+i7jOcpT3PNVuPKjr2gsx/8v2lGznQEwY7Tr+KxXe/B81Jo6f7cYJ51UfKdljd2oemCaSE5uoAocAeRErXzoboLjUjDkQgNANC9UrXPtCmPHz2dLa7+1UIN8GMFXt2fqXoZn5VE4iolYh0y68ARkuVt7JzHWVvCI3g6CCEEnyx3YBUz9YIKLVUuAE6XoX0gDKQB2tUAkM7BbvXqXuINCuPqGnLx953H5+9zJRwSR2tSUGpi9XsvyZQ2Sx3IGljGoKwqePqARBgZPqxzAjRjMYj26t4PnASUTRaqhyOnB3nzPlhvvTPCNsajuPAgk7uPvSzzHjhp8z512VsO+NXuRuwXElTlTnKlUGWglmrGVFGW6HnH064QdVrSCaUymRPhYKUqiBQVpWyr+pJC6HuZzzRdGWkr4RQXbHwGNgJu15Rr1MDYAaV2s5OqVoYjq3sKpFGpbIK1QG+UPCZ+EzqegpZhiq5abnll+61QZNKM6wKAXURkx3xtQzEJHNrZ/HczvuZbqdxpMvt7X+gerlBbMPlLGt2aKlyeccBKeJOHMMpNqhu6nH47P1xfnnGCbyNnxKItVL/+l/pW/IudYAcg9HcsZRKJCscSrOpCgFVLUo3PhaErtQi3a/lB8E3IjUzwLU89VyLErJVLWqfa0M6rp55qFbZLrLeYal+JUj1gBLUft3tiYHrKluVlVSOE+F6NbkSYuSV5BRjkquPhtcF2zJDUA+RdkoGLpH/Lbql9QsoPVQpp65Z97Ohj9FstGAnnzyqvCfRj1eluG+zxZouZSt4pN1mxdxTmb/jUVrWXIuR6iE+7UgaaleOOm4rhxlSdoPsF3lv4VhKnbPrFaieUbkBeaohhBrYy6EZgz2inIyK1Yh1KGcAMwx1c2HageOjEttfRDuU/Wr6CmVr0U3QTLVCijSNPhBxf5EegO1PKyHvZpRgb1yk7GfzT3xDCe9JLhSGJ6hF+PjyrxAxBvuYS08YDLXKGG+Mgt+GJuDVA96HOfMkZq36Hg2v3UnDa3eSeesNONQP2YY7nPtRuEENUiMIubHjQKjJS0nhRTH7jIydhIEdSl3VuFDNSHu3qPiI8TbU7yusFPRsVsGC6ajnBBBSgyoazDwkH/8x4ZFKmFc1qbfpqLIdaYYSFL5QmFyUnYtISFoWOiEiegMZ2yVj5wdV11tl7Irt4tYNt3LOonOIFAZBDcPlR/4aXTMQTppN2+7i+u77KBcXXRgJ/aM3VXHWTSqauTOp1FrxWcfTfszXmbXq+wC0rP4Nmp2kb+E5JGYcPai97T1JZtaGqAkZ2FJilkbcVRJgJV2l9hgtrlusKgo3qFliuH70bb3hEGqFFWlUgyaolYIehO7X8+62VdOVt9VkIRNXjgv189QKITuggkof0r99dELBSqnBWNOVoHQsNdHR98MwFaxRqtJCT7s3CJNcKAw9c26IBBhIh+mw8obbkKmRcdTr7ErBxeX2Tbfz8I6H+eWZv6zoqrqnr5d6sMA/f3BfskJhVrW65nuWB7h9Q4YDpsfJyKxgOIGtZ/6WBQ9cQk3bvwCo6niO3kXn0XXIp3JtWY6L60ps6bJ+VxQh4IAZezDDzMRUENncY4pjC4YiHVNeS0ZA2RGyNhgjmNel+wyPpuddbAsJ1Si1RbxTPWfXUbEl4xlLMp7YaTVod6xV6pVgrfJqK9ffYE3ejlIpyV7lJmyGlKC0U6r97MRDSiVksjp+KwXIyr7HQ5EaUKuBrk3qsygUbIGIimfJIqUSEmZk8qjF9oBJLhQ8yiztZtaHaazRyLRHaIqowTNju6xtVbN1WTKIx63KZgRHNhfnOXIDKmHdJUfHgOKZelYoZI3Hx882uH1DBlfaOJ4qqD29m7A9wIKS6zRsvpuGzXfTdsJ/k5h2OCnbIRN1SGRs0rZDU2najUppWKB0wB2vwpwji/c5NiR7lME0+0x3vqQGLN30on2n5Y8fy4/xjUY5u4ERysd5CKHsDq3Pwfzji4/rfh2i7TD3+H0za84kVH9LBf7O1UqAGUH1fejfrgzuQ+FayrGhd9vg+9c0aF42+BqRBgg3oiZZQg3KKa8yY6Jbqd2MUD4A0XVg0akjq3fiXeqcTEIN/kJT0e79bZ5rcqq8J5qTUWlVMjEvJ363Uv81LZnctqBhmBpCYRjcIdLdNYXU4NYYaqQn1cP7h4kult4AfnzLWzlnwXuKd+pqYGyKDL6Ok0vYV9IeMqeJ77ejxJ28QOpc+Qla1lyTez/7yf8EoL75aFpnvhWtdjqB+jkYFRYWGoQQatafzfRqpSC2SwmLRLcSFgtOyP9YHUu5VgbqJ+4MdipghtUAKoQKOpx3nIoJie5S+zNxVaWucaESzKkB5W1mJ1GeE5oy9la3jO66jq2umR3g0lFlcBW6UgvVzVbX3v2qOjbSqL4bUirVzlArRaGp79j2J9V3LJvyJEusQ7Ux42B1/Xi3+h6CN8B73+9ClagZUUJJM9SqQmj5+JGs4V838yqfRLdqp2mxSv+SRTfUvcQ6lDDQA+r5h8pkJDaCKiliOqp+C8EaJSRqZ6u+jVfszARiSgiFoYZHgcAYqtC9N2AfPeNo7tt6H9evvZ6zF55d9lBXKq8hIcu05Q2UIjMAoZk5o5QEBqwEUIcm4PXEdtpTOlCDJR02dAW4/eUE5x8qcQu+VFLTUflRi1cyLV3P0tL1LADx+uV0nPx9QM1s4hkVRVsVqPDjlFL9YFufVz+sWIeXTiKtZlG71sKcI1TUrp2C6umVf/FdB+7/T/UDbzkAVrwTmpa+oQx1e4QZgTpv5TXQBlseU7PaSEM++21stxrw9IASBql+JcyFUNHebc/BtIPKq6qGou05NcjOOkJ9DxJdgFQDZ8crKpEgjpoxCyM/MRBieNWh0Ib3TKudpepeOBn1HbMtSHYNTlZY1KbIr1Q1zbNzpdXqStOVjcYIqHswq9Rkxsmowdu1h1/VDEWkSa1OApF84sXsqqNrk/o8GuYrVVomqlZTwRqYeVhlKqadq5V6rH7i2JImdfBaJbjSJZqJDgpSm1u9CDoeZFb1rCHOzJN2lYHVloMNtCIrdJwMSBczvgvXCBEXDmlX/WgyMk3STZGW6gcVy7jc/FIjYPPuQyRWYYK4ggCtvoXnUL/l74OuWdW3gfpNt5OZ9gmiKZvtPUrvefjc+hHvBVCDSrIb7DgYEfVl7t3q6XG9wWbHKvWvbo5uJpSOqtkhKM+UDffA+dcp9z6f4ckKzpqZakasZ1U4QTWwhevz3mVmUM3aszaeSIP6vHa/qtRNIe/73rjYM9pm1KBZqn5ybXWt9hfUAJceUMdn/7ICaajJ1Z5iBJVtINapBk9NVy66ldqoQvWDt6UGlMqqdnb+O5voUc9kLIWTBqlJvWp/bkalMelvVXm10lGlZkr1q9XRghPyp9heenbwYiDC6pjsimcCMcmD10b+oF3p0p3oHiQUjmg5ngWNjdQGRy5ik3JU1G6tObjISjbFhh2oQk/3AQLNSlAXaWa7FQOaEQIs18b2vJ9ufikviNRKOT+L1lO9pOsXE+p7jb7Fb6fz0M9Qs/0hZrzwk6Lr1m+6nbXL30lvv1cpTkgSGYdIJWkxqprVgGIl1Y8nvFhtT/erwTvVp2aImj56l8LOderf4/4f4MLTv1I/FJ/K0fTys1qhDT+AZKOunYxSdWTVJ6moyt007SClSinEjKiZeqJbtV0urfjeIit4xoty6p9IoxIW4xlkWdWiVm2RJjWRshJ5J4xIk5pIJXtVZt9kn7q2EVB5s5AwbYVa4aT6VHsTbBU9JdRHQ0UBZwfsUNYNsITGUCP6CLPge7few40bblDt6INdPoX3I7VCzYhMBoTA1SOENYNmU3kymJqg1qhGTyojd8R0SVjqvISTotoI07ny47SsuZZU4wFE555GqGc9VpUSHoUJ+NK1CzDiO9GdNOt7t5OxNaoNnXRaUt+3hMXTKkjbkB1cSn+Q2dlXVUs+One0rLlD/TvtgPws03X2rC2fPUMPgI6akcZ2KyERbij+HBK9+brYZri4JsVUI1QLVFDBcDQUOVxEoK7k+blSqbWctBIAwRqVA0vTlI0i+9uwEko9O4GYWOuWvUQ2QE1KcHBJ23mjcGCoqFSPrEAAqCtIXpdr2xM8CQ1cPYjUDFwzjJ4eoCqgVgbz6tSPscdSwmlJU5qqgNq2qUfi4rJ5/ulsevv/kZh+JFb1bKLzzsjPIApUSqtWfpit05XX0LlPfRvN6WB3uhtbuiRsh82dMaLpfKbOjGuxbmBrzli+15GOsiHMODi/hPeFwv4hUK1cXAtXe47nERTrUAbTZD9+AOJeoLpZubfWzlLOAVXNSqUXqFKva2aov0jThDNUT2qhkHUrrTRLqislVQED2y72FDph1gnMqBreCHXanNOZHVk8aHv22poWwDWrEK6t4hekZEYkw2UnR3nvSqV+cryFWZ2RIp5RX4TrVy3Adm16rYEhvxyyYAnf6ybYWjsbgLAV54jdL2MgkFKSSDl0DKRJZfKD8KboDgbsBAP2PgrCsTN5fXa23/urTGgWKfd/H0rZ65HnZUh0Q9sLKhYg2Qu4Sq0xxEra543JpBYKOSqc6GTTRDgls2aBGGSeeLHjRS7824UAmFqAi1eWN3vk0mRIFczmaiZ2ZDpusA4jsYvFke5ciovsZQOR+qI20jJDRB/6hykLVjNx12bLtAO554wrsTST5Vvu5dzVf8IgRG3YJGjkBUtvJootHZJOCn28M4yWo2+HinPI9jd7ze7X9/61h+Ph78Mf3zFxBMPG++F3b1Iz9X2FEVQ2o0S3UhelB6BqmvKqmWA6bZ/9y5QQCqP5SmuaGFwfQYhB8QyPtz2eex0xRtbT224GJ9SIXT0TJ1CHHazHNasRgBndgZHsyqe9KNHfSiRBbWg1VrLpYLoOuojNC87CjrTQZNYjNZ0HVrwPgJb+zdT2vpyzrUgpsV2H9lQX3ZkBXAn6vvBwuP8bqmxlyCuAk10pPPs7ePqXKhJ2f/DaP5Vnzb5K8z0Sj6i0Jjz6v/vumkZQ6a5rZ6pYhuppE05t4TMxmBKG5nIJ74YjY8tcAFnciqMJbZDOfVH9Ip5of4ILl3+IA6pPwXZtEnaMoBPGdi0GrF4CWpBndj8MwJO7H+CgxiNwPC8nu2oGbqCWQHQ7AJqdyoWslQoly7WHVYFJ3aR32XvZEN9MtWsT1kM40qWtYTHPHvl5jn7+Kt766m9JtN5P98w30V39Fnb099FvxUk6acLDrELGldSAik046YvqfaGxevUt6m/mYer94tPhoHfsm35l2Rt1qke8ZgYe/oFKDrfiXcX7ul97wyVb85n4THKhkB3IK5/xCATLZ9RQHdTpyeSjlUvTXtyz+R4ATp9zJp0DNjui2xmwYrgp0xMogrSTYlHNgbzS8ywHNw5OYOeaEVINywn1bsDVAgQNdY2QWTwIVOvDp4uQUhJ3kqTcNDXxHrXs11TMQ3fTAayefRyHtD1NZGArkYHreKoqzMCcecwKN9MTTYCbHOy8m4l5futeMFLfDrjv63DKl1VAVDb1QiHtL8JjP4J3/rK8n7hrq1TQWV/zUC1c8oh6veEfsPFeQKrayztfglmHQf1eyKLZ+hw89F3l8rfi3fnt6ahyUcymOwhE9q7LJcCqa2Dzw+rv1bvybohZpKOCwkYiEx9ssH/9QXjiyvz7s38Asw73bQQ+Y2KSCwXFaDI+CGBmvfrR9GSy5w9eKXSnVKBJxAxg6I5KEi0EQT1MxKjKzewzrkoXUWUM4fImBKnGAzCSXZw6dwfJyBxOOSDM317MJ9qK9Q/AMHKhNb2LjGuRzESpNUJo6T6kMHN6s2cXnYk0Ajh6mCM230dz2zPsbFhMeMuDnPrKX1Q/j/gwHHGRGgRf+gus+q06+aR/gwPOgV0vK1e5uz+vts8/Ed70jbyqK9UHf/s39Xrzo4Nn+dGdXoDUEKkwlr9V/QG89iA89N/w1/8HH7y1fA6ldFS1l+pXgmMkVYedVjr6UB3c86X89rV35F/fehEc+2l45ValW591OJz70+HbHSvZNBXg1YMuwbVHFkzbn4J7vzbytbLHvP+mPYve9fFhigiFoWRCwk5U5JmkkkoUC4UTZ53IE+1PYBoaC5qr2NANAg1DMzmg/tBcptTqqBIGlpuhN91NQ7BpUPugPIg0w+RNKyK5Pmev+L0nD+LacyUNJeOpK11aUzvps6OYmonrppGhmdiaBukBhCeQpNB4dv5pzAnNQG6+n0g6jnQM6NuJq+lorkPghT8hd75C9E0/pPa56/IXefynapCfdVjxxbc9AXd+Bt55tRq4bji//MNzbdhwL/zrCvW+kvKWS86A565V9odbLoJzf1IcNDXQBjcV1M1e9lY47bLh27z1ouIBuGaWyh+UFQoHvh3W3QXP/LrgOu0j93VP6NuuImmnHaj81FsOgDO/rXIaVbeoNCBZXFupkHq3QMPC8qqkflVPnGMuKY74tZIqEn3Jmep6bc/B6w/Bi39SKz4fnz1gSgiFUHDoWWTYDBPzImpLXfWFUF5HQohBK4WaQA0Ro9ggHNKrqDXr0Qo9ebwf8e1brgXgK4deQW2gflA/pBYsjlzWIOsZ60gNu78NwlU5tRCAJW12ZbpJuxmV6ls6SC2AVT0LjG7o60VP96MLDcdzcUwHa5ndt47lu56gbmA7TqCK54+9hKMfvQKx8yXkQ5ergahpCSw+A1b9RqU4aH8h39kjLoI1t6ncNNefm7+H2tmIgTbldpply7/yAuHoTxSra4bjHb+EOz+l/OXvuAQ+dk9+39/+vfjYjf+AEz83dIBVsrdYIAC89/dqAD34PSovTbBGCQWAN/83vP6wUmONJ3ZKJZN74Dvq/czD1IonUKVSV6ws82xcG174Azx/PZz9Q5h37OD9259Srw9+7/BJCZeepYTC+r8rAdO8LJ9wzsenQsbdJUUIsUgIca0Q4rbxbnswaiA3hlAt1AXrqCoxQpf7fUQzURxZrK91pVtUv9nUAgS0ABGzuqhaW6mRe0t0Q/meFmZ+BI5YWJzjZSDQgFYmFN8UBjMCzSAEmtBwjTCuGcGuno1dMxfhpJkZnMackFIXdDUdBMDK9TfT0v86dqiO3ZGZPHz0VeqZ7PTyEmVicNj74UO3F6uCTr0MjvgwnPVfg/qy6TBvtt7zmsrY6drFOvLDP6T09JUQrlc5kZa/TUV1FvrtWwk1kJ93FRzqZa+1Sp5Noic/g05H1b+Lz8jvz86oa2fnI7c/eCt85C5YcLJqfzwMz9l019ufVgI0KxBA2U16Xi9vf8myY5USCABrb/eiYDPF+9s8gT2Smkk385/bU79QqsDWZ0d3P6BsF+0vlneZTfQoA7nPlKUioSCEuE4IsVsIsaZk+9lCiA1CiNeEEF8FkFJullJ+fG90dihKU1OXMpQKSfP+09EH1Wp2KRYKtYEaDC1AS2jmCH2pzOh94fHFapZ+z1i+ObGD1xPb6Ux305XpxcVBExqzg9OZFWjO911ozKhbhjTCmNFWkMoHf6B2blG7207/sjKKBxt5/sTf5ndkc9RHmuDEL+S3TzswlzXztVN/kdv8ykm/pFOfiWtEYON98Pf/wH7ql1g9m70b+ktF9120IgtU5VMqF8YQSFfNemcekt9fIrS572tw84dU+uhsIZRFp8LF98FH/1b+4lUt+fw4uql89cfKpn8qG8a9X83fw4p3wYfugHf+Wv2d9tXicy66G07/hnr98Pfz23esUm098xslsDrWqmRuAOf+rLIZ/8JT4H1/gBM+p97/4ysq1cVoaH9R2Y/uuAR2PAO7Vuf/7vw03P6JfOp1nylHpeqj64FfAH/MbhBC6MDVwFlAK/CsEOIuKeWr493JkRkmOlRQNLgXomkajcFGqsqUsXSlWzTA266L7TAoFXep2skcKt5AM4oik3VN8ON32Lzyeh/Xr2nGkco1NSMtOtJd1HqxEUExXHpiAykEdmQ6wk4jTYMdc06mr34RSbOWAQIsC9ZAqpe6sElt1Sx6px1Lw+5nSM89GWyXoOHlQWpcpLKaujaWI3FciVWrPIMS9ctIR2ZSY2i0v/nXzDH64a7PYXj6elcP0G0GGSlbUl8myuvxNnQ0DmtY5t1DQSqM7ON2nbxhuTQq2rHUvk5vRXbXpaqKHKiBPptVFLBcSV88gxCC5uqSzyU7CejapDJc7inZZH/n/Bj+/h/q9fGXqj5GBidQBNTKZckZygaw8T6YcYgacGceqlRaa25X9oINBSq10RiO6+cXeyrd/XllfM4+u5FiVgqFyD+GsOXYSb/q3hSlIqEgpXxMCLGgZPMxwGtSys0AQoibgHcA+14oDPMlN4Zx99PQ0DUdgRi8UpBukZoolXHQyiysStNpl7aTRWoG6exA6GFWNxIJ9Kl2XHDcFLa0aTBrqdIrU8NkahegZQYIxPqwDZV7aaB2HlJCOplhU0eUjLBo8MbYLQd/kSqjlTXOfBZmbIKGN1jOOVoJBTNMe3+SjGfweOrYnxMI1uaM4k6kGRrn4Sw4CX3r43QvPYOepWeQsQZoCZc3smfptWJ0pQcI6Sarel7l0LolBMulwnCdvLAozJ8kJVx7lpqJtyyHzo0qv8yOVd4DLRbuqYzD+l1RGqvMwUJhztFq8L3jk0rlsvCUip73ILIqqBmHqBm6ZlQWFCY0OPk/lBG9ZZlSgYUblGfWoz8sFggwetfZxkXw9qtUbEjbi/lnd9A7lMfZcLzsrfre/L3BA/+Ge5TdotCu5DOlGIuheTawo+B9K3CsEKIJ+B5wuBDia1LKH5Q7WQhxCXAJwLx5e1pgwhuqZGWGNL2M72rEiOSEwi9e/AV96T6+edw3i2wKGSejaiqIwQO1XZI6odSLadjeawYirKJ/f/RIgCema5x3hE1YmJjRVlwjjDPCQOsE63EC9eiZKMJ1kF6+fCGgLhxgdyxF0rFY3KzuxdaDbDCWkXFKUj4c9THlrVM7G7c7nr0ZUsEZGCGD+ohJMuOQsV027IoSO+B9aI1zaW9ZhqZrzCuTcO+1WCtpJ8OKukUknTTVRhhHOkRtG9t1lHE8O4BKRxlIn7hK5cTPPtfClURWhbT2zvxF3vIDpbc3wqryWAmaBmlbEk3b1AQLvu5zjoYzv6NsAA98J9+PFe+C4z47+EGnBuCWj6hB9aiPFXwAnlDQjNHHXOiBvNdX1oi+7C1KrWYlVKnIF/+Ub3+0zDgEtj6h7BTZ5/nqXVA7B571VIkr3g3HfSZ/zmsPKltN3VxYcOLgNlP9Sijc9AEl2I79FKx8z+DjfCYtYxEK5UZiKaXsBj490slSyt8CvwU46qijxpTCs9xgX45wQGdhc6nhWfBI6yNYrpVLbZHNeRQ2lOfS7sRuUo4DlBMKalDIurW2xbdw745bOHnG2Rw97dThOyQ0Fsyfxkm97bzWGmJ9v+BsO05tsBnXrK48f4cANBM91YMd0nPBUEJAS3WImG0R0JVQSGUcHFeilTZuhJTfPmA7EttxSXmrhWz6DMeV9MQz2K5Dl3AJzT4CmQiTMfqwpcu2+C5CeoDpIaU2SbsWtnTZHG8nasUxNGOw0MwOxvd9U3kQOZ6uOmvzyA6Gbc+VN3A2Lx1W/RMydDK2g+WUrOA0HRadpgzrfSrqnC2Pwbq/K5XSIe+DeQW1kjfep4zqq28uFgptz6t/x8vDR2j5VcuOZ4r7uydouhIIOU8rCS/9WbkOm2F1P01LlA0HlIsyKIFZjrnHKO80J6MCEp+6WgmWiebhtPH+4tVW81I4/v/tv/5MIsYiFFqBQqvmHGBUjt/jVXlNDPOFLN2nl7FKW255L5SknaQn1TPstR3PwGtoJpab4dGd6ov4f9v+xKFNxxHQh9e7BgzBCQdapFO1bN0lca0EwrSRuoGQDsK12dATxHYFKxoGn9/Rb2M7MLd2HgHH8rK05j9WTYArZG4wdlxoDpkkLIdoysbUNGpCg78GXdEMNSEDQxMEvGdmO5KM5ZJwLXbbAywLtZBB3X97souYnUAIjZAeoC8Toy8TxZI2MTtBSA/lvmzZvkik0qPPPlINXHWzYcFJyk016xE17UD179Yn8oVS3vVrZfCsEEMfRoeeDagDNTiuu0sZr2tmFguFAc/TqbSCXGxXkRvxcDguxNM2QlD2mQ+ieRnMPU4F5JWxe1WEZqhnu7tAq1vVpLy+QvUqiPDh76ljlr5Z2UhqZw0uxpMlWJMXiu0vKEFZaVT2viDRrVYyr96lkjM2LVHfp50vQbhRLR0bFsDcY0dq6Q3LWD7JZ4GlQoiFQBtwIfCB0TSwLyqvzaqaxa74rrL7RgpsMzUT27WZFp5Gja6xLZXCclxMPR8BPS2s0lgfO+1NPL7r3qLzn9n9MCfPLF/3eXBnXGzXIYyGkejCqpmDFAIj1ctPnlReR795a1/RKbYj+f7/qW1XfqQZqQcxkp04QaHSd5ehKqhj6BpBKdnenaA3nqEubBIydKbXhmjrS2DZLpGgQVVI/WWRSGwpmV5n0tqjFRnwJZI6s5o+K8or/ZuRQFgP0JOKUmtU0ZHqVi61hQIB1A/0nB/n25GyWJBXT1O69oRX1L5urgoGGwEp96AC45Iz1N+NFw7OqJpVE5UOzlYqL7gKrg3Fk2fblWzuitMVTdEQCXDgzAqKvoQb4K3/M8qbKCG70soWswd4+y/yUeQP/bf699Ef5gvHHPj2ytpeeKoy+FcSlb23kVJlgX3xhrx6ccW7lGfdK7eqFc2q36jtZgQ+dNvULiw0Bir6JIUQNwKnAc1CiFbg21LKa4UQlwL3ofxGrpNS7pc0mENVXgNVda3U+0hKyUBGuSOG9BCPX/g4j+x4JFevORvMtjO2EwBd0zm4ZQW7B17MCYX2/iSGptFYVcs3j/g5/eluHt91L3WBRvozanWRsAeXofz2c5/GkTYfWvo5Dqg/FICIUUPGSeEIHbPpYNz+rXz6rjqOni/41LK8J4goccv8yT19xfdlBJFGCGEni4SCJW2wYuh2moYqVSgoZOq0VGskLYeBpEWvtGiuCdLelyIS0KkODv3V2JXuxJWSRDrfHxc1mDcEige7RV71uHqzGls6BDSDrYldSKDfimNLh6yebHuig4STYmFkJtNCBcuiecfnVQHLCmb2BVHQyYxDa1+SRc3VSCSvtg2Qcdw9qx+TnV0Xko0dKHWNdawiIbVpd4z+hBIgTdUmC5uVF1lvPENPLE3akkgJ8YyNLjRC5l7OXptNY776ZvXvJx4sVkXVzcnHe2S9p4IVRKXDxKmXASouY83t+fcfvScv+OYep4QCqADLZ69RMSXn/3705WbfAFTqffT+IbbfA9xTbl8ljJf6aLTErTg9yR4iRoSGUAOtsVZCRohIycxB13RmVc3C1E1qgiaaEPQmMiQth3BApzpo5mo0ZFcdhUFw0yMl9W7Jq5vW9DyXEwoNwSaqzBhSpiHcyM3PqmCsZ7dJLlmWH9Ue3V7NCQeqj6y126atV10ra1LJ1MzFFTqhgc2qXwXCsiO+g5rwHHBtFSQnBJhVVOsGrgvRtMXOfpVaOlSmznPCSbI11U6zUHEaYdNQFd4kmBXkXzM0HaMkcWFnupdX+nupNsKk3QyWaxPQTaJ2gmkUCIUjL8rbDbIqnXf+UgWgeSQt9SxcJFJKMq5LXUSpdfqTowxSyxpTj7hI5XTa/Ch0eCE6ha6eyV5lAyl4AFKq9WskoBNLO2zaHSNs6kRTdi51enc8g+kV2VhaSfnUsbD8rRDvLB4wC3nL96B3mzJsZxLKrXfR6ZW1PZGEwvanldorm7qkMIiybg686T/Vyqt5qRLwL/xRJWg89lP7p78TmP265hu7+kghRojBk1LiuE5OLZFxM9kTB3kPFRIxIsysnpmrynb64pUIGcSVktbeJI6b109kazU7Be3JYaprtYSLg+CEUGVdEQYPbFOz+aABGTc/kN71Wj3HH6wGoGe3KP26JmB2Y/5jdMLN2Kke9FQvTqgeM9WN5sTBrAdNR0gHI9WLa4TRMjGEa2FHWjA1ne5YhkhQGSZ3Wb00mHW5Og9tqQ5P0KjrmLpGtWEQS9vMCU/DyrrmutmZv/dshjGQSimRuNQHqkk5GdpTXZjSHBxXUj0d56B3oGLCPfE77aCiQwZSNinLYX27WgEOMiyPgJSq+JKhiXyE9It/Uj77nevyNSIKg7a2qfQTfXoTO1r70TRBxnGLFieOK9nWHcd1ob7KpCGisWsgH52dXeEAzKoPURUY/JN0XJUWZY8I1amo8JxQKNGp1c/f80y1WaGQikKwbv8am6Wj7nXlewarhYRQasEsh1yohELPZi+J4/Aled9oTIkiOyMhkWwb2MbW/q1s7d9KX6qP2mAtNYGa3Ay/XDyDEIKGAjVGU6SGxqoAjZHBX6JsO0knr7stjVn4Z2velbI5WFysWxODdeDNNTqfeyj/g5USkpbkC3/s4okNKYKm4IBZZlEAndQDpOuXeLEbLk5BWm7HqEL3vHpSzQeTajkEJ9SIcB0iQYPqkEGEFEaql2SslZSXcC+d7kWzEwjXIerEvME8f01TM6gxI15W0wFIdkOyT71O9atArII+VuthpJT0WDGqvfxSRi5QUBLRg6SdDDuTXWQ8J4B1A1tZN7CVV6NbBz17UEIgmrIxdA1D12iMjC6w6rXOGJs7S0qWvvaACiqbdzx88BZlEO9crwTDxvvgMVUkp6flWGxXoglBUNeoCxcbniMBgxn1IUKmjuEZ7XviGVKWQyyjVhCuKxlIlp+gbO6KYbuy7L6KqGpWdbPHm2yK7ls+nFfP7A92vaI81xoXq0juo0dIqBCIqM9yxzNw/XkQ78rvs5Lw29NgzR1Dnj7V2a9CQQhxnhDit/39/XvYQvaHMvKsUOTnmAgEESNC2AgT0AMIxKBIZVCR0OUC1sq2XyaAzsWlLb6VuBXlle5VPLrz70Oeb7uSRKb4h98Vc3Gl4C0LoxwxI4krIZ5Wx1gOpC1ZfnKm6SAddG/GK1wbhCA542hSTQeRrl+ME6hRZUPNavR0L5qVjU2QWGY1aAb96R56Mr28HttEhx2jL93G9swOJGrlNQjpqiV6/QLlvdK0BMJN4Ngq9sBjWqgBCcSdJA1eUSJD03P2h65MP6/F21gzsIVtCeUk4Mq8GOq3im01hcK0z+lFCgdtD77ZbjnL9FEXEz/ko0pV5g2smdV3IF9/WHkdnfkdEloYQxcYulBqIZFvqz9hETCKO9MYMQnoGhnbpS9hgXdvyUyZZ1rmHveIc65QacLH0yC84ERlyK2ZCdseH/n40dD6nHJ53fCPvMtwOaSrDMmQd6uthOM+qwzqThq2/iu/Pel5G2bbHAk7pSYPG/6hvJzK0bUpfy97KzPvODIl1EfaMCOARKIJDVM3VR1lzyCaVSU50hmUDTXXrtAqNlSGyhTKcaXDr179bkXnP7VJzcqjybyAs2w1Ehy7QOOJzRauDGKYBpAfPARi0IAhhUmmfgkgkZqBZWi4Us1e7epZ2KjBN2YNsFWkmF+7ADnwOhEvInizG8XWTDpSbVTbA+gIwjULkMkN9LtJ2tO7mR5QQXWaFYekDYFw/lnVF9hSqpuhY10uN1NBL8s+h6STZkt8JwJlH+jLxNga34ktHTSphO9rsXaObFhG0nLojWdoqMqv3PqsKHEnxfzwrBGe+DAc+n54+Ua12jrsA7R3paA/Rc38E2D1TQSe87xYGhbiLDgNq7WPkFmsJrMdSV/SosrUBwmFiGfEb+1J4kpJzDPYz20o/g71xDNEAoZaSUjJnlnNPUJ1uTiUcSNQpTx8NvxDJc8brypydkrlbMqutGceBuf9rPyxnetVfAkoz7RKaVqsYlHW3QUv35SvipdzHatwVrHlX8qlF1QK8zd9c/AxD38/X0tj/onKjjOBmSDOxXuGFCP/TCzHImyEi9RAoOwFcStO3IoPG+dQKYVC4UuH/C9XrP4Kr/QUZ6j8+AFfIWnH+MtrvxyynYwtaarW6I65OcOkMIMYso9yGoSyXRdgF0RCW26STJkiQLuT7Uijit1CR1r9LPC2u7hIIQhYKZoI4+pVZMwqTGHQ5SRpMJsxPd98TVoQnq6MmZoGVeUErIBkv6ol4OEMY2+pM6vos2IsiMwgbqfYleqhM9MHgI5Gk+fhlLJcdvQmqQkVq2tK620XMpC02B1NF31vXCBlOejZh3nMJXCYF7FbOLOeeQh86A627O6jPmzS0JS/n7IecBIaStNrFDCnUX1n6iPq+qVzm+54hrTtks445VcxE4UFJymh8ORVgwdTzYRDL1AryEpxLCUQjrhIDfqd61WFudcfUgMvQP08FctSmD13tLaBujnKrXbHM/Dkz9W2rCqpUqGQrfsdaVZqrHu/qtpY8U7o8QRB7xZYcAqkelWdkgnOfhUK4+V9NCg6twwRI8LCuoVF29Z2ja8H7YqGI3GlS41Zy4zwXHYlWnP7poVmMadqAd2p8kvMuU0GO7ptAoYYNIcWwRo0PY6LwNUjQJpptXpuEBlZ3SxwzaGDnxJ2gnC22ItHrHoWTrAKN9mPa0ZwArXYkRnM7G+lNjUARsab7AuongENXqqScoFcjQsGl6EcAkneFqMJTdkqgM5MHwFh4Ei3wP6QZ2N8Gx2JGPURkzBD2xMSlkNnLD3I5bYrmmF6rXeeEPl024Blu9iOZN2uKLajI40mohbs6rKQMkPGcQfFuuujnGjE0jaOK1m3MwpCXbN09TFhmb5SBcJt+mfxdinBiquV4wHnlj21LNkJQ6hORVB3rM3HHqy5XQ3+Tka1WZj+vNK07YXMP1Flhd14n3qfTXDYsHDocwrJOpbMPUatWLY/rd4/dkWxYAlWqySC2WtUUoxqPzHJ1Ucjz56EEOhCHzJQLaSHiJXoqCslY7u4BSPy+5fkc8hcuvLbgHKHjKZs5pSoBl4feJUbX/8VAJ9beTlHLWpkR7fN7atixFLFM13d0OlN69iuYF27+hGcflCYE5aF+M9bexhIury0Lc1h8/OD4arXUyxoMZlWO/zAknJU2mlH19nY8xzCdUlEWujXBdOrF5CK2EhNZVINtCwmUDcDN7Ydq3YBwZ51qhFNH/4HqasCQ1JK/rHraZYHltORSuYG4UTaYXc0zYKmCBJJoIxg6Y6l0aRLU41Oys2QdNKAhuNKNnfGSGQseq1+XMtgZrA4X6uUFHmKhQx9yAHXdiWv7Y7huhLLcREIEpZDVVBHuhLLkfQnLKbVBpFem9VBY9AsPxzUmVWuzOgQpDIuSDA0DU1AdyxDQ5Wp0pJM5FUCwOwj4CN/Hbw9k4Dr36bUS0Ivjh4fjqxQEEKl0Fj5Hnjsx7D+bjjp35Ud4Kmr1cCb8Gb277lmz+wly96s/rKko/CH81S0tmMVFzVa/zeYdSTUep6D6/6Wd1U+7jNw6leUkTrL7COV8Nr5cj6tSuuzsHM1zD9h9H3dR0wJ76Ph1D+GMDA1k2mRaYP2LWtcRkukZcjMpiNFPAsBKXto4+BwrOp8NPf652u+zZwGg7qIxsZdFiFTEDCgJiSY06gTCQqeblczi4de9dwXvbSnA54N4v7ViaL2//xEjB/9rXfEfvRlutGFgd14EFbtIhAaQhhMD89Wtav1QD6FgaYjTDWQu3qg8iU2gGayvW8Lf9x+L9e1/ZWEZeeimztjaRKeF86CyAyqSgrPR1M204zphDR17aSTxnKz6UUEAV0noGs0DOFxJFA6/nU7o+zsH1zIqJB1OwfojqcRCHriFt2JDMmMQ8jUMQ2VEmRWfZiAoWF6f6U2g9wt78Gvy9RVm5GATjRp053IYLujc6+dMJhhlcak67V8TfBKyAmFggd40Hlq9j73aGg5EKqmwY6nVT6s+vlQPb18W3vSZz2gZvPdm/LbHUsJoWwNc1AVB19/SL3Oul5n61iEG5RQyKqXNFOlLYE9K3y0D5nUNoWxYhbMSIUQbO7bXLS/NlA7qF7CSMQzNpbtkrJcQqZGbBiPkkKWzDD5r/OHyL9fEBDXFXVYMcdkQUvxbLqt1+HRdUmqgoJYSvU5U2FMUTY/06ZOg+m1Ddz6XJoLjweBS2uPzfQ6nZ6Yy8JpJiDUrE8IUtLh9r5HmLVpGx855GISaZsdvcmcKHWBOfVhqkMGm3TJ7e2PAPB6chsrQsuYj1qiO3YaMz0ASQst3ACazoJIvn5ANGUN0tlvT3SwOxGnK61Sg+g6yqG/rN1FYLuSaMqiJmjm3ELLEUtbNFeFlHkkoBO3Bn9+ezLYV4KKClevG6sD9CcsqoMG0fQ4VIjbHwgB512p7AGvPVj5eTmhULCaa16mSqyC8nb64C3j189CNEN5at31eaVS6vBUzNmswvFO5ZlUugrMrlJWvqc4a+xAm7K3aIYKnAs3qLa2/ksVfdrxrMo5NZaaHuPMlLApDDufF7lrDXOIwNRMgkYwl0ZbExqmZg65igAVW5C2i/fbjqQ+EqA/aTG/KcKGjihSKgOnBFxnsEqhyqgZtK24gzpLp+ts6nBwXJheW/5ju+PZYj/7SEDds8TFcjNs7HvF67fG/JqluQyvoNxbf/HPfCWy7V19TKvV2bjLwtSVC6zKrxQg3bAEqZm8rFu8lNrES9s38ZFDLibjSHrjGWo9w+9AymJ6tRI4v9t4M9tjedfCu3r/ydEzPgn9rRgpi0SgkV1xG5FOgG7gupKM7aJ56hT1bF26YhkM4ZJOxWhNdFJDHXHbIqAFaTTq6bJ6B2ViHUha1IYNbNfFMIZf/Rmalhv0DV1TN74PaKkJ0hvPFDkOZCOyJz1CL44EH4lC9dH+oHqGUhu9+n/l95fGZFS1DK26ygYGZlVOmunV0b47f0ztbFheYY60fcAktykohst9ZGomc2rmEDaG1u8G9AA1gRpqvbQJ9cF6+tJ9gMqdNBQhU1c2hYKZoxBqJim8/QD1EZMFTVXYjmRjh2ROZCmtifzS9ODGo0e8x0vf0kDakjhSEjaH/7GcvDzEvzakOGGZ6rsjHXYn8/7RdYFGdsQ205vuotrzSirVW/cl8t5P2XExY0tlCPdWWEk5uNCKqefVKdl03RnLYSAz2G5T49bQL22EmyBpayQ1DenYoEHGkSQyNjVhg7ChUm73JSxEwEHDxXAyOI5LXSRMn5eXSB9GneXKSixQFAWJVYcMgqY27PdrvBjuEpIRMr1OdLy4mRGx015ofxn10b6kehpc9LfiWtmFdK6He76sXh/zKTj4/KH7evD5cMDb8lHWuqmM71lmHDyhBAJMevVRZaqdumDdsPuzq4jpkek0h1VG0tnVs8fUM0c62K6NjiCga1SHDCxvVTG/ZmGRUKiUoKkSPYxEd8wpSovgSoewXkXEqMKRDi4OCTtGxKimylSrlHtfTgxqZyBZvAr6yl+6+dQZtaSCz3P7lmtZUJOvJBdP24OCryTwmUc+MmQ/X+/rYrqIIDMOzc0BTMcGAVLXCRoQ0AWxtE3cyxs0s7oWNIduqw9HyxAwdFVLo8x4k3YzuRQd1SGDRNom4wz/fXGkVAZfDyEY0l6wL9kXQmmvolWwUujdCrd+VL0+70r1b4X1zvcKRnDocqORfK10amYUG6PLUZh2o3SSWdUy4dJsTHKhoBjJIFxpG3qFX0JXSkrr+mSHm2zK5gGri65kEogU/aiFBqfMPIfDZy7DSszkNxu/MaZ+/+e7GvjvO5VB+filQZ7alB6k8agLNBLUQ7n60bsSrSCUm2yWrmj5H+2yGSYbd1m5e+yNu7zcp/TDhVlgN+yMIkHVfPYYyhxTbzbQZ/WS0ZKEAzXI0DSscCNuWqCne1WGVwFBUyc4yEvIBKt4OmBLm347yjQvoC7uJGlN7WJxRLnJVgcNUiOogRoiJn1xi6rgJHEDnUyIClYKhZG+US/V/UQVhg0LVHEmO6WqFY6Gk/5NeSxtfVx5IM06Yq90cSxMcqGghoYKq3GOiD6K6lZZQVQTMmjvy1Ad0DCCBlKqgTFgaLkkcc01asYhvNw4ISPCodNP4vltvYT1qopLeEopeW3gVZJ2nIybZkntCppr8sbpRdNMntqUpj6iecer7dWmUhHZrkVrfEvRDB/gwTUJtuwebJWuCQn+35vr+I//uxcnOR9pV/Fw69Mka7YOOnZj7Gl6UrsRQqMhqGZSXYnyBYouWHgxv9n4Y16KrmFJy1tAN9kar+bl1yxCmTQNERsbm352s6guzbLqRgKuxbrUTmoiM6nWI6RkOicEXOmyvn0Gz6UDYNQR0Eyq9QAbAxkWN+gsqht5tl9aO2K8MOO7kHoAYSexwy3Km2uUOK5KU14XnqQ/V01XdoL1f2PIlW7nhvzrrHfO/lIfjYQQlbvXljJjpfo7VFV3zFUYnEBMakOzoWk4FM9Ox0K5pHjDsXJ2LUIIeteFiGc9zwTURwIcFG5id6wPTc+vYwxdeOqIgpXDKGZDq3tWcevm3+XeH9l8Eu9a+NHc+2xi0KxNo5R7tt/Mqs5H+NzKy5nuFQdKWS53vTBYdQSqzGlfupvwrNsAcK1akmbeGG25eZ3rX7f+oeL70Dz7zjOxdRwz/0KmR2Zzw//1sqtfAEqghGb/BbN2NY/1wsGphRweXsgfex6CbhWs+MOll+XamxmcxuWvZCO2C7PPpphXq/Gbt1Qpm8k+dvfX0/1IYZCuX0awb2PegLoHpCx78gqFKk/d8tgVlR3/2gPq38jw9cl99g6T2tBsGgKlhp54y0yBUJ5I4cCg6FmR+9/o6E13Fb23S/IJZQO0hqpZ3ZFsAyBp5w1daSs/Uv7gwkZ0IfjKjd1eO8WlSrUCgaCul1cJ/PvBP+Anr3wNUGk+AK5Y/ZWy/ShMKZ4VLGk734/vvtXmN2076fMuvT2zm7lmfoBwS0b3wizZnzvlNUJakAazlnvWNfF6r4OhC6JJe5978wgnQ6r5EOQ4qEHGkiR1v7P8HFXoZiShGIgoI7OdUnr60aTG8Bk3JunUwyObG2gfy4ShBt0sKTuFpkPQ1KgzjEF1offUkaRU+L3e/yob+lajBcFNz8oNjoWX25lopbevGsJb2BZTxu3WHptpAZe2Xpsd3XnBEglo7IhtITTzXuz4YmRYY0P/0LrgwjThdcG8Gqu+4HU5Xt6RDyCTXp6iwvispkCyKBag34mzKT10dslYJn/DdSGbsK7TYLikHZedcck/Xs8QNg2OrdnH9gJh4ATr0DLREQ9NW+6wasRYegIUstlThMivFiqiglKlPnuNyS0UPPa1UBBCcPCcoT2abGkTFIKgoTO9buSyZOUC5PqSFvUlefnjdvFMPWYP8KdNV1G1CKLrfsCCFvVxHjg7wNOvqYH36rXfwc3UowX6cufd/rTNP/U++pNuPimkt+83676HWQ9m/fNYwL07hu53ofqo3GqtOTiTrvTO/H26AYSW4Z8vBqn2YnWycSBZl9h5dRYInSqjhp50Z+7cUqGgZfLP4idP5FVGwoqBk0FzBc/uVDPNnzyrnsW/Hepy7mID4WRAaDihepXlVUrcvZmLRggkGmaiC9cMY4fqB3nWOMMtBTznBcuRmMME3vn4jAeTWihUaqCtlEEVv/YQUzMxtUqNx+W3x1I2tSGzyMsp5QyXosFhfrPJFR9sGjRwFAoEAOmG6EurwfjsQ8IcsyREQ6T43puDc7hw8WcwdcFPX/l60b6jw1/g4dUhPvGmam7a8Z9AeaFw0ZJvEg4IHt+Q4O4XkiB1aiMgbY3kjg8TnvunnCrIdeHEZSHOP6IKS9dZXn8IO+KbiW/+HO86JEJ9ww5u2fEXdT9oXmpwRUdcCafzj9Cxa+Zi6SHSgSageHadsW00x8Gqno0ZVdLOSHaDlGT2olBwAnXYkelodhJXDyIcC2lUvmqR3t9AyqKpamK5L/pMPSaoeX90jItNYYxNJG2H/qSFI236Mr1FKTQK0YTI6YdNXWVETWRs4mmb9r7UsDNGdzi3Ps3OtTka6qt0mqp1tBKVWH2wjhlV02kK5XNGSVcNSAvr5yLtBqq0vEqgnMFcExq6MJCuCdIENBxH99pSK6isfcFxwdRBC4SReiCXKtpNz8Q05tJQna9AZ2gmTqA295dFD4RxzCocsxo3MHgl52pBEBp2qKlopu4GazDiHWhWeYP7nqCl+5GaiRQaaLpX0GjoTLWVMNHz4vlMDSb1SqEmUEM6md7vhubm6iCWbbF0Wi0ZN4PtBgjqQarLzD51LV8Ux9Q1Uk6MNf2P86bMBbheNs+szeL2LdcSs/qJW1E+ddDXean7qSH7oJk9QL64jRbZyCr3urLHBhqeRo+8jh5u4+990Lf9LNb2vlh0TNgoHsAEIqf/D+g6YPOze/upOVDt3z2QF1hf+GMXjdUarqsKGqUKjNnZynFCV+5av3x0A1ZvM8Fp99CKxg2belnf93LRlR9am+Rjs/JfVcMTuHc+GyuKAQmOEOmdrplHbNYsRIFwdc1qUo0Hoqf7MeLtysA5hECvGOmgOWlSjQfl0h84oXriM48n1LUa4RnvN3Q7XPrPkhKgWBw6TeeHp0VGtF2BSrPiupKgoe+1nEw+bywmtUvqH87+A7978S/Uh/cgj/o4omsaAQN2J3dRFagqKvtZKWkngSYiRcVUXi4QAp3JoQ2tAG85vNizw5x++xBHQqDpsaL3T3T8k4AW5KCGI3ipW3k4vXXu+3L73zH/w8yrXsov1l6OBOY2BTh5ueBfG/LqrPZem+SOD+dWAAuaDa9sp8TUNJ7fqlQ8y2aYHLYgwJPdW+gHAs0PYfWeSKDpMTqAjr7S3qpkdjO9QDSAOVUqkd4j69T1s2k9Dpxt0mup1UfCLh1sQSKUz7xTEnktDJxALUayCyMTxdWDY5rVm4kuXCOCLE2tUhIHs6Gn/Mrv5d0OKRuymiI3GxFZho27o6Qtl7qwydJpEzdHv8/kYb/OLaSUd0spL6mrGz4NxVDMq53HhSvPoyq4fxc8pi6Y2xTBEAaWs2cZLVNOZlgRUmg/CWp54/UlByo30EXTS59BvrV016lE1/0PTmro9MJ1gQbOX5QveF4bqM+9PnraqUyPzCJbCzto6Jx/bPEAZDsSO7YCJ7EYgAuPr+Gjp9Tx8dPq+cgptcysVwPiO4+u4sRlYVbOVoJcaEM/r+V1h3DskiCOU6yeKo0nqQ1rXr8KEwAOtr8Mp32xq2YQn3UCVmTWqPQ0rnRJlth6pGaSmHY4Tkm1PwAhXYRrIZwMljO0i2ZhRg7pffq26+K6KhOv7UpSlottS5VexLVJp1Kk0ynSGYt0KoWdSeNm0iqnkK3KvQ5zSZ/9wTACf38xqdVH440xxqLmASPAQHqAQDCgMkyP4BZlFKz3wwFJlaGub7uSUElAnlOg8tAK9OHZqnOyxAdcynL16IaeA+hiZJVJVjCVM8iXlpUotaPa3iiXvS1Ty1Y5G1ooaELH0ERRkjoAWxafk92bvV9HOqTdNJRUYNsbJS23JFtxpcvSqgUVHW+HGjETnWh2BidtAeUNzoU1mV1XpQ93XYlluyQtFyFUAaeU5WBLSby7nVeTTRiZAYR0kIFqwqEwmiZY1FwFmTi4Fpv7YHZ9mEjAT+cxIXAye1YcaC/iayELGKtQ0NBygmBW1ciF45fOyM+2f7fhv7h12894sftfSClJy2L309+u+0HudWGOpuxA/adNV+G4Nuv7XuKpjgfQAmVSTLhDe66M5t7LqcVufKo4C2qpOjw7883WMsjaBYSQhOeVL8CiC52UJYmnJf9+Qz5wb2P/Gn78YN4Gcs9LiWzHmF21gJmRebmI7UKGkgm2K/nFQ5voiqXLH+DxapfN9avzq4Lb1qf56ZNVPNtWuUeQVbeQxMxjuKG1md+tG3pgLlopSEnadrFdSdLKh+6lLIfptSHm1Iepq6nGmH88kZpGqoMmvbXLScw4imjLkSo/T83M3AMY1v3VZ98itD0rI7oXmVgiapLiuA474ztzGVYNfejHWh8JlJ2xOtJmV2I7lmNzUN2JdGWGDhC4+IAvsal/DY3BabTGt+a2bxpYyw2bfjHo+OpggFlzAry6611ULfpZ2TYPazoegLPmvLtIf1/Ipw/8Omt7X8gJvo+cXMOfn/s0erXKW3PkwiAnLQ+xtjUzaJV0yZtqeXJjioYqNQ85YfqZPNB2JzLTQjnFzvTwbM6ZdyFXrVFeVY4Lb5r1dh5qvwuA3sifga8WnVMqqj51Ri1rd3bx+Ktq0B6qYNKLbXHue7WDrniGH5w49IrpCw8o4fPRQ5T67jcvpQGTDV0mH1g25Gllue7Z3bnXlxwW5LcvKYH09qUmd22yRhXBrKd6cfURSn/qAbCSBHrbSdmN1Mwq/xm/YRnYBbqhoqnr5ox8PICVgNTA2Gb6QuzfbLBl8IXCeFAyGg2XbbWpuvys8k3z3kR3spu4FefweQ1sW69Ghf+34ttcvfby3HHfPOLnhPQw08JqJbJq9yO5faUqpCzvWLGCw6bX8oU/zii7f171Eo6b/iYATp35tiH7Pqd6EXOqF+XeH7kwyJELj+ILf1wAKCEBKjFfKTPrDd5zTH5lFNCDfPfoa4a8VpbpdQM5z6Y3zX47rfHNbOxfA3o/V35ECeEv/FGtIkoF0UGzA9TXW7zniJn82w3dQ9oUsl68lc6gVZbc8fF4u/6cambXaDmhsLRBB0YnFJAumboFwx/TvAQS3biiAzs1MPyxb0R0A+YeAztWVX6OdKFurkpwN4XwhQJK7TNWdKGjFfxnuRYJKzFoEiyRGJqRK+hT2Add6NhudmZs59otvo4x5PuhqsQNFTNR2CtQFco0TeRyNUVTNq5UCqrSQDrAM3YOnxK5tTdJTcigLrxnbp6lqyote7+jGJOz4/dQ6qOsSksZfiVGuh9baLhGGCPVW3CyugfbhUEqeel6xwpwK3c2MEu+eqYVB3RI9qFr4IQGO2EIO4lhJwikkhhmxIuvqPCBeHETxLtUwrmJmp56byFdSPQw6Hk5dn5bvLuytqwkhIdP6TIZmRJCYaxxCtMi02go4ylSKZrQmF+ngqvSbpqZ1TNJ22lmVM1gbs3comPTTpqNvRsHtSGEwNCMnEHZkUMJheL3RsGA7zKEUNCHX55mB0tJ3iAMYEuXJS3VtPUmsR13UMGZRNohYY2ckyeasvdYKBR6y0gp9yjqPLuCGMrQbHjSznElmdp5oOmY0VZcPYgUGqnmlRiJTnSxG0eKIYSCg9QCpJoOBARymIp9hZTmwXLq5gFtuGjomX5cc7C+WbMSuIEqEGmSzQeDELhmBe6oQscOt5BqWQzODjVATjDVxV7HsZQqbXrJ7F4ICNbA7CNH5w1kVvY5TyamhFAYK7qmj6qWwkjUB+vpTKi8PaXCJu2kyw5sAiUUdid2c8VzP6It2qH6VrIyKD03WzgH4B/byxczN0e8t/yPoFAtoiGoDZl0GukiYbEvKRQK3/trL9p015uwS368+qtMD89BjxxDZP5v+eazcNbsdyOEYEntCmZVFevNb3p2B5s746za2kOtqXNQS4Kn2w1gGwDrd0X5/j+38uTr3YDBcbNSSFcjobfxgZURHK9wxztuH5zg7suPpLnoQJ3Fsxr48m2rmd0Qpj5sctEJC9CEYGuXuu77jiqeJJSuFPACHuOWABO6k5Ib1zu8/8DizzBpS67bEGCF5qAJwSnLAtzxQiu/fzINhIFNwCb++tkT8id5n61TNR1ibSM//KmKHoCqIdJyR6bezH+0TOrgtSxBfYiyefuIwpVKdtAesEbW2yasBMfNPI6ndz7NO5e8k1e7X6U91k5PqhtNaCysXoFwi4OoepP9aLqLADJOOmdbADC1wbOWoHUgVcEISTvOcctcYvq5xI0XmBFeQMZNsXHgBSTQGU1REzKxpaQvqQLNgrqOEALHlfTEM1SHDOJpm+m16jqulIRMjXOPCJHMqPMMTRuUKnwkumMZkpbDnIbBxtJ3HV3F/97dB0Bn1KW5bkZWi0NvuovedBeR+S/ljv9n2x0A3M/tfPfoa5BIYgWfxc4B5SU1YAnWdGYodcBTAkHx/C4Ly9WAfr7WNnwxlJd2u7y02+WbTS+yoSPBhg4lOFqaOpnXAt+5NYPlwPL5O9E1DYFEItg8sApNMzh9fhOz6iTbBtTNvZrcSSoQ41fPm2zsqaaxro0lTRa6DkY6ykOtM3mgtZF7W9Wqs7FpG79/cnBsxpNtz7HbCtEZS2P2vQZ2huh2eLpnA4abQkqLhqqZnNzQwu6YTVUwwLSa4t/T611xhBAsaqrAS8a1IFidE25DkolBOlZZ9LiVhPphjL/xbm/VU8EqUrrF5TR9BjGp6ykArGhaMY492jOy6ol5NfPoS/Xlt4+g1rKlzaWHXcp7l7+XxnAjJ805iZPmnKT2OZLVO/qQwK9O+yN1kQCbO2N0JbpZVLOcarOWdb0vUm3U8d2jr+H13i2smLaEpuoAa9r7+c6taiC89Pwklpsk7Ricd2SQrsQxzKh6M7oI0WNvZ+PqF5BSUhU0WDq9hm3dCQoWH2iaSsdh6IJUxsEqWDG4UlITNDhrZYBFLdV0x1Ls6BkuaV95ksPYJVpq8j/0xmqNS44/np+vubfitmdXLaAtvhVQg9Rl5zVw6R/UKuxjp9fx8/uHTms9s8Fge/fw0V4/+2ANV9y9k9YB1X7ajVOor9ZFkP7MThy3ChD0ZfqYXT2HxdOVvaYnXEcgvpMLlptk6pfwak8IsKB+OUzTsbU+AKZHqpgWsdkdTaHbOmlqivoRMiLA4Gcf1MIgg4R0HZ0gUkLGChBsOoyeVJpE3/PUOjZpRyM643hieoBpJRmA+41eTF2DYTID5+h+HaIVrEJcBxoXQ9PikY/d/LBS6Qxn/5h7NJTY6YZkolZ0myD46qMJSuHXX2gCTcv7/meN2YPOEZUXeRdCQ88dq2pOF54qxOhUq5o2uipye8J4t26MUNiikuSCQjOKDPCDand7KiddU+OgK9VqUuKtKr0BShMammbkPxPvvSsFIDF0ga5paELD0PRBA+RQthYhhGrb+5Pev4ZhoGmuSv2hjswboUvVjZquPuBKVKyjsVGICtus5JOvuC2fkfCFwjgw2jKeE4eJ7XnSn7SKUkFoanwcEz0F1esy7vBZUSsthqSJfB9daZPTb5G3iWTHcNfNpwo3dAjr4aIE33lPKVl0frYvAV0jMApvuUTGpSuaxnJdAtJESpWPShcCRyoh1Z9J8MCuV4llIBQM8kqPRKAxvSZI0nLoiiVpDE0nuXUGnenNvGnx4YRL8zr5TBkm62g2oRguWG0yMN51KcaLaNouEgJ7uhKZFZkPKFtBtVkLKDfTsBkGhkuzUdn1wnpeCDSGpuXaB6VimxWZj6H1kEHSHFKR1mqlAE2BJkyzL3d89h6zq7RsvEJ2BdIQCaBldGoqtNtEkxYB06WpKshuYyauDjNrQ+iaYEZtiIGBaWgyjmu7pC2dNH1IYTMtPIeMY5K2BEidvlSUWrOO/lSyqAyrz9Rjco9mPmMia/OYqEKhFCFG19fO5E4kkoiRN3pmCpLXmdncU1oS3BBCjyHM/v/f3tkHSVLedfzz6+6Z6Xnbnd293dvde4W73MFBEkBEXkykKDVAuGjFSiVYasoEsYqgoqKGIgqWZZFgVGLhS2KFisQYEqNWhAIJpghaIbzc8XoETrjj4A6O21327Xbep/vxj6dnpmd3Znf2bnZnD55PVdf0dD/dz3ee6X5+3c/veX4PIIiVx3PS2PEcyo8hVrEWATakiGzZwRIfKzqGX+7n2EyjD+LYjEfarZArad1vTfvMxioUywo3CPUtIrVfNVcZx4pNcKwwSXEiz2R2BKwC0+UZVC6HY8Px41mmSwMQ8itMznlYsaP45T7wXZAi4swxVRakGGUotYVoxGZ8toIz69GTsHhjskKfEmzLDpqV7FqnZlvsYNHdgLsdnt6wehij0AVKXomSV1o64UnynuEIkG+5PxXRlcqmZBvOvhD5kkcsYpMreaTd1pdQdpnzChfKHm7ExleQCx1bbTXaNhQh4bQf0vpL+/449O02tmx+kT9/+m4s9zr6nK0kYhYSmSS1/XYKb12FO3xfw/FvAYklOtHc9iwwCMlB/f2OBz7fsP/epxqbqO78Xr0n1FBPYxv4G7nDfOfNvyJ5Ojw4AUyAs11X/XdPEX4BQVlR4BaqAfX+7L6XSG77EgDHX/w86TNuAeCBcWAcPi7XUpk7m689kid8TSSjA9x6yZHFf6ThXYUxCh0i6STxfA/XcZccQexYDuO5cdKx9KLplqb109sf7c7QE7eY81t3je131/FLW65jV/97l+VUnimU6QUG09GGSK/zmcqVGe51mc23N8J3Yq7Exr44xYpHxBE298WZmCtx44dTTGaFXRuitdHHABcOXUbEijKa2MxTbz+KUoqeaIanJn644Nx/cFUvj08dYnISdl84zYXDGRJRi589p8Bjc+Ckf7ykvtLbH8DL60GKO4YtDjt3L0jzqZ9Jc9cj9R5NfUmLqazfsL+KnlO7/v9km8wB0Zj/B/nJTD975l4j0vs0iAdKGwXLrc+FffGOCM8H69sSF3Mg9yjZyhyT0wubfbIl0xPH0IgxCh0iERp52s5AuJVulx3t03/t3BIzTPbH1uNYDmVv+XpsS5aMkmCJnJA/O+1GGO3VRsGNCmf1RRfMRHbVll+urb934AIADs8dbGoUhjMWkVl9fNIVElFdGZ61IcZj+6EdD3Ylux0vuxOAa36xj1v2LDQK798SA+pGYbTPbjAKen+IUC/SViPSq3i5LQz3bcArlAKjoEJxw+v/39mbHJ4P5mTqj2zhAI+i8E0DkKEtzGOC4V2Bnkp0YbUo1a6csniFHCSqrbUbL2s5b2CtAhrW9tfyrOqopxdpbG6rYgXNS74yRsHQHuZNoUsoFPlynoSt3zAm8hPEnTi22LhB3BwfxVwxR7YMqgDTxSIzhSzZUgUneDIsVCoohFzZo+JVqE4sM5U/jqd0wLqK71Esz5GOpil4OSATaIBCyW8YPOYrn5JXIN4k5s5E/m1cO4lj666KiKLklxscuQpF2dMzhIUpe/6CyXKakS975EsePYGvouDlKFTyzExG8GSWDT2DC46p+PqJOVfyKM6f7SdgOlciW9L7wiG0qzqlHQe2qhuCTo7JEK+IiFCRJd7WlB4JXdUhUp9bIfymEJZmBbe4r/yWb3WWV2gZTHH5KCjl9ECy+WMnynk9B7bYOs2yzjnXendl+QMmDa0xRqGDxCNxhhP18NStYhzZYjMQHyATy1DxKwzFh/CURzqa5ujcUVyn2mUwzpG5cVLRfnKVGQpelk09GxhIpJjK+jgkKHmK/mSE3liC12aPsKn/TNKxCOP5CeJWL+vi65nMFhlMpnEsRSKSYKQ3xbrYJqaLU6TcGJlEBNexiVgWRRnHdnzW9/TXjEUq5mBbUFAVPCYZSGwhHrWZLh9hNl8h4zaOJD02WyTmVAdl6eXY8SLDPS7ugmA/9YB0APGoraOquhEqvs9sZYJN6Q3MFvJMF2xmy1MLjn9rpgACiahNtMXggtliMTRYr85ULnjClnYe6Tv/rO3bLuWUDlWSm1vK4StUoj3UX/BDFXnYKFjhI4I3BVobhVJsHRWszgTHS/TrwHKlrP4Mk58EO6a3Oy7E2wxC2XcalBep+BOD+nyGjtBxoyAiSeDvgBLwA6XUNzqdx1olZsfYkNb90JNOsqnjsNq1L2pF2dmv26dfePsFIirCjr4djOXGqgnZ2B9HOQl64wkKc8exxeLckZ1szGR4/ODbOJ5NMhLn57fv4qt7j+FTwrLgjJE0zsQMtjdEMl4k6o+yvW+Q7UMpHn/9AAMpj10DQxyeSvLC+AG2rqv36Em7guCQcvUCMJzRN9x4wSFf9jlzVBuBg9MRMvEYmzP6rcISqf0+S6TWt766dbjXJZNoP1pqIXiyjzsuBccLfDXNn2gFsEVY39uqcqjPgRDu1lrvatkloxCJU4psBaCcfXPxxMrCj6brbywhQyZhoxB6E6qGGleLNB/l01upKP+kBwYC2igkhyA7tnCf2NQyiaVaB6WbTzuhMAwdo62GURG5S0TGRGTfvO2Xi8h+EXlFRKrTYH0U+I5S6jeAj3RYr8GwKK360+vmkYUGYFlGQa2sC67VzHB1WvsUwm8KYWNR9ymoFQ9DYnhn0O5V/jXg8vAGEbGBvwWuAHYBV4vILmAjUJ1L0gx9NKwJdO+bxtHCsDxHs1phV61aovdR1Sgp1URzgz8i5IAOjIJapPnIYAjTVvORUup/RGTrvM0XAK8opQ4CiMg9wC8AR9CG4RlM76YTIl9pPeCsStlTFCoeEavx6bKdY8MoVNNjFjvP/H3V74VKiblilpLvY3s2Bc+j6Aklr0zJr1Co5MlX2h/QVmjiNC5W6hXeTEE3z5X8EiJQ8hzcFk/8d7/6udr6/Yfv4f7D9zTst0P9/Fvi17uTVvOez+eevIb0mfXvh4F0T3j/0tkoP4JYC8d2KGXz3b05nB5926a23970+K8f/v3a+v1PeyS22Dz85r3AvQ3aqvz1i0trCnPbM8tLb1icDw1dzxev+M1uy6hxMj6FDdTfCEAbg58C/ga4U0Q+DNzb6mARuRa4FmDz5lN7EvHeaC890UZn61BiqGnFals2qUhq4ViG4CluJDlC0SvWnmolIQzGByl7Zcq9cQZTCSK2xWjGxckNsT7Vg23Z9MczpOP9JIMRv+tTQo+9HtvJ46oYqZiDG7HZ3LuOVEyPpu51I5zRv4mkU2/nHw2cnglnYe+jbX0bKFUqtTzmp1VulNGMQ7GiJ35xLIuBZBRbCvS4ioybIuG0f8nFLJ9N6VEsETamRkg4Do4Nv7bjtxl0R+hztSPTdbShcSyLHQOj3HDeDXi+x+szY3z/yH9x7sDFCDa+8tk39QTnrruoVr4V3+fF6b0M2GcyUX6V3ad9FFscvvrS7dz4/i/w+GuH+NFLKSrWEc4Z2cIHdsZJxy364g4fO/0aHjv2MMOJjTw5/gi7+s5jOL6RyayH5+nAor1xi6PTHilXiNhCym39nOQpRcJO8/RLm4gnj/Eq/0Rp8hKc9I/pqVzIjtHTGEpHeeD5nRTHLieT8hhKOxyaKGMJqMx/k4kO8b7+C/jh6/vIz41y6bZtTPErFDmGrxQHx3RZpeMWx/M+WwedUIwnRbUZLdxJojpjnW5+UkuHvPArSJMpSatzSOgM7GBUtmEktb7bEhqQpdsxg4T6TeE+pdTZwfePAR9SSl0TfP9V4AKl1G8tV8T555+v9uzZs9zDDAaD4V2NiOxVSp3fyXOeTPPOESA8t+BGYInuE42IyG4R+crMzOKzWhkMBoNhdTgZo/Ak8B4ROU1EosAngP9czgmUUvcqpa7t7W1jRieDwWAwrDjtdkn9JvAjYKeIHBGRTyulKsD1wIPAi8C3lVIvrJxUg8FgMKw0bfsUViRzkd3AbuDjwMsneJp1wMSSqVYfo2t5GF3LY63qgrWr7Z2oa4tSamHsl5Ogq0ahE4jInk47WjqB0bU8jK7lsVZ1wdrVZnS1hxlHYDAYDIYaxigYDAaDocY7wSh8pdsCWmB0LQ+ja3msVV2wdrUZXW1wyvsUDAaDwdA53glvCgaDwWDoEMYoGAwGg6GOUuqUXdDhvPcDrwCfXaE8DgHPo6O+7gm29QMPocdWPAT0hdLfFOjZj44NVd3+E8F5XkEHDaw23cWAbwXbHwe2ttBxFzAG7AttWxUdwCeDPF4GPtmGrluBN4Iyewa4sgu6NgEPowdWvgD8zloos0V0dbXMABd4Ang20PWna6S8WunqanmF9tvA0+i4cF0vr47UeZ082WouwZ9xADgdiAYXza4VyOcQsG7ettsJjBDwWeALwfquQEcMOC3QZwf7ngAuQsdDfQC4Ith+HfAPwfongG+10PFB4DwaK98V1xFc5AeDz75gvW8JXbcCNzb5DaupawQ4L1hPA/8X5N/VMltEV1fLLDhHKliPoCuhC9dAebXS1dXyCuX3e8C/UDcKXb8nT7rO63QlulpLUIgPhr7fBNy0AvkcYqFR2A+MhG7y/c00oEOAXBSkeSm0/Wrgy+E0wbqDHtkoLbRspbHyXXEd4TTBvi8DVy+h61aa37Crqmte3t8Ffm6tlFkTXWumzIAE8BQ6FP6aKa95urpeXuggoN8HLqNuFNZMeZ3ocir7FJrN57BhBfJRwPdEZG8wBwTAeqXUUYDgc2gJTRuC9WZaa8coHU9qBmhz8tpV0XGi5Xy9iDwXTOVanaG9K7qCsO/nop8y10yZzdMFXS4zEbFF5Bl0c+BDSqk1UV4tdHW9vIA7gD+kceLwrpfXyXIqG4VmM32oFcjnEqXUeehpRz8jIh88AU2LaV2J39FJHSei7++BbcA5wFHgL7ulS0RSwL8BNyilZhfRvKramujqepkppTyl1DnoJ+ALROTsJulrP6HLurpaXiJyFTCmlNrbJE0zun1Pts2pbBROej6HdlBKvRl8jgH/gZ6G9JiIjAAEn2NLaKpOUdpMa+0YEXGAXmCyTXmroWPZ5ayUOhbcyD7wj+gyW3VdIhJBV7zfUEr9e7C562XWTNdaKbNAyzTwA3RHjq6XVzNda6C8LgE+IiKHgHuAy0Tkn1lD5XXCdKodarUXdBvbQbTTpupoPqvDeSSBdGj9UfSN8hc0OpNuD9bPotGZdJC6M+lJtIOs6ky6Mtj+GRqdSd9eRM9WGtvuV1wH2pn1Ktqh1Res9y+hayS0/rvAPautKzjP3cAd87R2tcwW0dXVMgMGgUywHgf+F7hqDZRXK11dv8ZC+V9K3aewJu7Jk6r3OlmJrvYCXInuvXEAuHkFzn968Ec+i+4Od3OwfQDtYHo5+AxXRjcHevYT9CIItp8P7Av23Um925kL/Cu629kTwOkttHwT/ZpcRj8pfHq1dACfCra/Avx6G7q+ju5i9xx64qWRLuj6afQr9XOEui12u8wW0dXVMgPeh+5a+Vxwzj9ZzWv9BHR1/RoLpbmUulHo+j15sosJc2EwGAyGGqeyT8FgMBgMHcYYBYPBYDDUMEbBYDAYDDWMUTAYDAZDDWMUDAaDwVDDGAWDwWAw1DBGwWAwGAw1/h/pCUcrsuMRrwAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -129,13 +142,13 @@ } ], "source": [ - "import seaborn as sns\n", - "ax = sns.lineplot(\n", + "ax = viz.lineplot(\n", " x=\"num_queries\",\n", " y=\"num_geq_funniest\",\n", " hue=\"sampler\",\n", - " ci=\"sd\",\n", + " ci=.25,\n", " data=df,\n", + " palette = sns.color_palette()\n", ")\n", "ax.set_yscale(\"log\")\n", "# ax.set_xscale(\"log\")\n", diff --git a/docs/example-analyses/viz.py b/docs/example-analyses/viz.py new file mode 100644 index 0000000..04e47ca --- /dev/null +++ b/docs/example-analyses/viz.py @@ -0,0 +1,49 @@ +""" +From https://github.com/stsievert/salmon-experiments/blob/8daa4e23ca9960bc585a83828ff6ab71f1b90584/response-rate-next2/viz.py +""" + +import stats_next as stats +import pandas as pd +import msgpack +import warnings + +import matplotlib.pyplot as plt +import matplotlib as mpl +import numpy as np + +def lineplot( + data, x, y, hue, style="-", hue_order=None, ci=0.25, ax=None, estimator="median", palette="copper" +): + if ax is None: + fig, ax = plt.subplots() + if hue_order is None: + hue_order = sorted(data[hue].unique()) + if isinstance(palette, list): + colors = palette + else: + cmap = mpl.cm.get_cmap(palette) + colors = [cmap(x) for x in np.linspace(0, 1, num=len(hue_order))] + for k, (h, color) in enumerate(zip(hue_order, colors)): + show = data[data[hue] == h] + kwargs = dict(index=x, values=y) + middle = show.pivot_table(aggfunc=estimator, **kwargs) + if not len(middle): + continue + _style = style if "C" not in style else style.format(k=k) + if isinstance(style, list): + _style = style[k] + + ax.plot(middle, _style, label=h, color=color) + if ci > 0: + lower = show.pivot_table(aggfunc=lambda x: x.quantile(q=ci), **kwargs) + upper = show.pivot_table(aggfunc=lambda x: x.quantile(q=1 - ci), **kwargs) + assert (lower.index == upper.index).all() + ax.fill_between( + lower.index.values, + y1=lower.values.flatten(), + y2=upper.values.flatten(), + color=color, + alpha=0.2, + ) + ax.legend(loc="best") + return ax