From 8cd04fefda1df193753dc0024972451a5d344505 Mon Sep 17 00:00:00 2001 From: Chris Russell Date: Wed, 23 Oct 2024 19:06:33 +0100 Subject: [PATCH 1/6] doc strings --- src/oxonfair/learners/fair.py | 136 +++++++++++++++++++++++++--------- 1 file changed, 101 insertions(+), 35 deletions(-) diff --git a/src/oxonfair/learners/fair.py b/src/oxonfair/learners/fair.py index 034b7bf..d1db0ab 100644 --- a/src/oxonfair/learners/fair.py +++ b/src/oxonfair/learners/fair.py @@ -26,6 +26,7 @@ class FairPredictor: """Assess and mitigate the unfairness and effectiveness of a binary predictor post-fit by computing group specific metrics, and performing threshold adjustment. + Parameters ---------- predictor: a binary predictor that will be evaluated and modified. This can be: @@ -164,11 +165,15 @@ def predictor(x): def _to_numpy(self, x, data, name='groups', none_replace=None) -> Optional[np.ndarray]: """helper function for transforming groups into a numpy array of unique values - parameters + + Parameters ---------- x: a standard represenations such as might be used for groups (see class doc) data: a pandas dataframe or a dict containing data - returns + name: optional string, the field extracted from data. + none_replace: Default value used when nothing else is found. + + Returns ------- numpy array """ @@ -198,11 +203,13 @@ def _to_numpy(self, x, data, name='groups', none_replace=None) -> Optional[np.nd def groups_to_numpy(self, groups, data): """helper function for transforming groups into a numpy array of unique values - parameters + + Parameters ---------- - groups: one of the standard represenations of groups (see class doc) + groups: a standard represenations of groups (see class doc) data: a pandas dataframe, numpy array, or a dict containing data - returns + + Returns ------- numpy array """ @@ -210,11 +217,13 @@ def groups_to_numpy(self, groups, data): def cond_fact_to_numpy(self, fact, data): """helper function for transforming fact into a numpy array of unique values - parameters + + Parameters ---------- fact: one of the standard represenations of conditioning factor data: a pandas dataframe, numpy array, or a dict containing data - returns + + Returns ------- numpy array """ @@ -243,7 +252,7 @@ def fit(self, objective, constraint=group_metrics.accuracy, value=0.0, *, additional_constraints=(), force_levelling_up=False): """Fits the chosen predictor to optimize an objective while satisfing a constraint. - parameters + Parameters ---------- objective: a BaseGroupMetric or Scorable to be optimised constraint (optional): a BaseGroupMetric or Scorable that must be above/below a certain @@ -276,7 +285,7 @@ def fit(self, objective, constraint=group_metrics.accuracy, value=0.0, *, If +1 force all weights found to be non-negative -- i.e. fit can only increase the selection rate. If -1 force all weights found to be non-positive -- i.e. fit can only decrease the selection rate. - returns + Returns ------- Nothing """ @@ -320,7 +329,7 @@ def compute_frontier(self, objective1, objective2, greater_is_better_obj1, force_levelling_up=False) -> None: """ Computes the parato frontier. Internal logic used by fit - parameters + Parameters ---------- objective1: a BaseGroupMetric or Scorable to be optimised objective2: a BaseGroupMetric or Scorable to be optimised @@ -336,7 +345,7 @@ def compute_frontier(self, objective1, objective2, greater_is_better_obj1, grid_width: allows manual specification of the grid size. N.B. the overall computational budget is O(grid_width**groups) - returns + Returns ------- Nothing """ @@ -497,7 +506,8 @@ def plot_frontier(self, data=None, groups=None, *, objective1=False, objective2= These do not need to be the same objectives as used when computing the frontier The original predictor, and the predictor selected by fit is shown in different colors. fit() must be called first. - parameters + + Parameters ---------- data: (optional) pandas dataset or dict. If not specified, uses the data used to run fit. groups: (optional) groups data (see class definition). If not specified, uses the @@ -639,14 +649,16 @@ def evaluate(self, data=None, metrics=None, verbose=True) -> pd.DataFrame: """Compute standard metrics of the original predictor and the updated predictor found by fit and return them in a dataframe. If fit has not been called only return the metrics of the original predictor. - parameters + + Parameters ---------- data: (optional) a pandas dataframe to evaluate over. If not provided evaluate over the dataset provided at initialisation. metrics: (optional) a dictionary where the keys are metric names and the elements are either scoreables or group metrics. If not provided report the standard metrics reported by autogluon on binary predictors - returns + + Returns ------- a pandas dataset containing rows indexed by metric name, and columns by ['original', 'updated'] @@ -715,14 +727,16 @@ def fairness_metrics(self, y_true: np.ndarray, proba, groups: np.ndarray, metrics, factor, *, verbose=True) -> pd.DataFrame: """Helper function for evaluate_fairness Report fairness metrics that do not require additional information. - parameters + + Parameters ---------- y_true: numpy array containing true binary labels of the dataset proba: numpy or pandas array containing the output of predict_proba groups: numpy array containing discrete group labelling metrics: a dictionary where keys are the names and values are either Scorable or a BaseGroupMetric. - returns + + Returns ------- a pandas dataframe of fairness metrics """ @@ -740,7 +754,8 @@ def fairness_metrics(self, y_true: np.ndarray, proba, groups: np.ndarray, def evaluate_groups(self, data=None, groups=None, metrics=None, fact=None, *, return_original=True, verbose=True): """Evaluate standard metrics per group and returns dataframe. - parameters + + Parameters ---------- data: (optional) a pandas dataframe to evaluate over. If not provided evaluate over the dataset provided at initialisation. @@ -756,7 +771,8 @@ def evaluate_groups(self, data=None, groups=None, metrics=None, fact=None, *, scores of the updated classifier under key 'updated'. If return_original is false it returns a dataframe of the scores of the updated classifier only. - returns + + Returns ------- either a dict of pandas dataframes or a single pandas dataframe, depending on the value of return original. @@ -812,13 +828,16 @@ def evaluate_groups(self, data=None, groups=None, metrics=None, fact=None, *, def predict_proba(self, data, *, transform_features=True, force_normalization=False): """Duplicates the functionality of predictor.predict_proba for fairpredictor. - parameters + + Parameters ---------- - data a pandas array to make predictions over. - return + data a numpy/pandas array to make predictions over. + + Returns ------ a pandas array of scores. Note, these scores are not probabilities, and not guarenteed to be non-negative or to sum to 1. + To make them positive and sum to 1 use force_normalization=True """ if self.groups is None and self.inferred_groups is False: @@ -887,14 +906,20 @@ def predict(self, data, *, transform_features=True) -> pd.Series: def extract_coefficients(self): """Extracts coefficients used to combine the heads when creating a fair deep classifier. + This code assumes only two groups and that second head of the model is trained to output single values with target values 0 and 1 corresponding to membership of one of two protected groups. + If instead the second head returns a 1-hot encoding, indicating membership of 2 or more groups, use extract_coefficients_1_hot. + This code does not support objects created with use_fast=True. - Returns two coefficients. + + Returns + ------- 1. a scalar a, and 2. bias term b. + Such that head_1 + a * head_2 + b has the same outputs as our fair classifier. This can be used to merge the coefficients of the two heads, creating a single-headed fair classifier. """ @@ -902,11 +927,17 @@ def extract_coefficients(self): def extract_coefficients_1_hot(self): """Extracts coefficients used to combine the heads when creating a fair deep classifier. + This code assumes that second head of the model is trained to output a one hot encoding corresponding to membership of a protected group. For more compact binary encodings see extract_coeefficents + This code does not support objects created with use_fast=True. - Returns a vector coefficient a. + + Returns + ------- + A vector coefficient a. + Such that head_1 + a.dot(head_2) has the same outputs as our fair classifier. This can be used to merge the coefficients of the two heads, creating a single-headed fair classifier. """ @@ -914,10 +945,20 @@ def extract_coefficients_1_hot(self): def merge_heads_pytorch(self, heads): """Merges multiple heads into a single head of the same form, that enforces fairness. - heads is assumed to be a 2-d torch linear layer of dimension: backbone width by number of heads. + + Parameters + ---------- + + heads: a 2-d torch linear layer of dimension: backbone width by number of heads. The first head is assumed to be the classifier response, and the remainder of heads encode the attributes. + If the number of heads is two we asumme the second-head was trained to enocde a binary attributes with labels roughly 0 and 1. - If the number of heads is more than two we assume all heads except the first encode an approximate 1-hot embedding of the attributes""" + + If the number of heads is more than two we assume all heads except the first encode an approximate 1-hot embedding of the attributes + + Returns + -------- + A new linear head of size backbone width x 1 """ from torch.nn import Linear from torch import Tensor assert isinstance(heads, Linear) @@ -943,7 +984,8 @@ def merge_heads_pytorch(self, heads): def _needs_groups(func) -> bool: """Internal helper function. Check if a metric is a scorer. If not assume it requires a group argument. - parameters + + Parameters ---------- func either a Scorable or GroupMetric """ @@ -953,7 +995,11 @@ def _needs_groups(func) -> bool: def is_not_autogluon(predictor) -> bool: - """Internal helper function. Checks if a predictor is not an autogluon fuction.""" + """Internal helper function. Checks if a predictor is not an autogluon tabular predictor. + + Parameters + ---------- + predictor: some sklearn/autogluon like predictor """ if AUTOGLUON_EXISTS: return not isinstance(predictor, TabularPredictor) return True @@ -971,27 +1017,29 @@ def call_or_get_proba(predictor, data) -> np.ndarray: def _guard_predictor_data_match(data, predictor) -> None: + """Internal helper function. Checks that data is in the right format.""" if (data is not None and is_not_autogluon(predictor) and not (isinstance(data, dict) and data.get('data', False) is not False and data.get('target', False) is not False)): - logger.error("""When not using autogluon data must be a dict containing keys - 'data' and 'target'""") - assert False + assert False, """When not using autogluon data must be a dict containing keys + 'data' and 'target'""" def inferred_attribute_builder(train, target, protected, *args, **kwargs): - """Helper function that trains tabular predictors suitible for use when the protected attribute - is inferred when enforcing fairness. - parameters + """Helper function that trains autogluon tabular predictors + so fairness can be enforced without knowing the protected attribute at test time. + + Parameters ---------- train: a pandas dataframe target: a string identifying the column of the dataframe the predictor should try to estimate. protected: a string identifying the column of the dataframe that represents the protected attribute. - returns + + Returns ------- a pair of autogluon tabular predictors. 1. a predictor predicting the target that doesn't use the protected attribute @@ -1018,9 +1066,11 @@ def groups_to_masks(groups): def fix_groups(metric, groups): - """fixes the choice of groups so that BaseGroupMetrics can be passed as Scorable analogs to the + """Fixes the choice of groups so that BaseGroupMetrics can be passed as Scorable analogs to the slow pathway. + This substantially decreases runtime in the slow pathway. + Parameters ---------- metric: a BaseGroupMetric @@ -1128,6 +1178,7 @@ def dispatch_metric(metric, y_true, proba, groups, factor) -> float: def single_threshold(x) -> np.ndarray: """A helper function. Allows you to measure and enforces fairness and performance measures by altering a single threshold for all groups. + To use call FairPredictor with the argument infered_groups=single_threshold""" return np.ones((x.shape[0], 1)) @@ -1159,11 +1210,18 @@ def DeepDataDict(target, score, groups, groups_inferred=None, *, """Wrapper around DataDict for deeplearning with inferred attributes. It transforms the input data into a dict, and creates helper functions so fairpredictor treats them appropriately. + + Parameters + ---------- target: a numpy array containing the values the classifier should predict(AKA groundtruth) score: a numpy array that is either size n by 1, and contains a logit output or n by (1 + #groups) and is a concatination of the logit output with the inferered groups. groups: a numpy array containing true group membership. infered_groups: optional numpy array of size n by #groups. If score is n by 1, infered groups go here. + + Returns + ------- + A dict that can be passed to fairpredictor """ assert score.ndim == 2 assert target.ndim == 1 @@ -1189,6 +1247,10 @@ def DeepFairPredictor(target, score, groups, groups_inferred=None, """Wrapper around FairPredictor for deeplearning with inferred attributes. It transforms the input data into a dict, and creates helper functions so fairpredictor treats them appropriately. + + Paramters + --------- + target: a numpy array containing the values the classifier should predict(AKA groundtruth) score: a numpy array that is either size n by 1, and contains a logit output or n by (1 + #groups) and is a concatination of the logit output with the inferered groups. @@ -1200,6 +1262,10 @@ def DeepFairPredictor(target, score, groups, groups_inferred=None, use_fast: True, False or 'hybrid' (hybrid is prefered for infered groups. Initialises the slow pathway with the output of the fast pathway). By default 'hybrid' unless use_actual_groups is true, in which case True + + Returns + ------- + A fairpredictor """ val_data = DeepDataDict(target, score, groups, groups_inferred, conditioning_factor=conditioning_factor) From 303195d075d46c71236f7eacbf0dc8e026fee7c3 Mon Sep 17 00:00:00 2001 From: Chris Russell Date: Fri, 25 Oct 2024 11:21:47 +0100 Subject: [PATCH 2/6] delete dead code --- src/oxonfair/learners/fair_frontier.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/oxonfair/learners/fair_frontier.py b/src/oxonfair/learners/fair_frontier.py index 5f2ff87..a07b081 100644 --- a/src/oxonfair/learners/fair_frontier.py +++ b/src/oxonfair/learners/fair_frontier.py @@ -48,10 +48,8 @@ def compute_metrics(metrics: Sequence[Callable], y_true: np.ndarray, proba: np.n assert proba.ndim == 1 assert weights.shape[1] == 2 assert weights.shape[0] == threshold_assignment.shape[1] - #assert weights[:, 1, :].sum() == 0 weights = weights[:, 0, :] - threshold_assignment = np.asarray(threshold_assignment) pass_scores = [(isinstance(metric, ScorerRequiresContPred) or From 55d3c0cc870e7708f741aec4f31d81546b702ba7 Mon Sep 17 00:00:00 2001 From: Chris Russell Date: Fri, 25 Oct 2024 16:34:57 +0100 Subject: [PATCH 3/6] improve custom group support --- src/oxonfair/learners/fair.py | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/src/oxonfair/learners/fair.py b/src/oxonfair/learners/fair.py index d1db0ab..16ad4a9 100644 --- a/src/oxonfair/learners/fair.py +++ b/src/oxonfair/learners/fair.py @@ -1012,7 +1012,13 @@ def call_or_get_proba(predictor, data) -> np.ndarray: if isinstance(data, dict): data = data['data'] if callable(predictor): - return np.asarray(predictor(data)) + out = np.asarray(predictor(data)) + if out.ndim == 1: + width = out.max()+1 + new_out = np.zeros((out.shape[0], width)) + new_out[(np.arange(out.shape[0]), out)] = 1 + return new_out + return out return np.asarray(predictor.predict_proba(data)) From 77508298de951ea53e37b49ee15c52bc16528196 Mon Sep 17 00:00:00 2001 From: Chris Russell Date: Sun, 27 Oct 2024 22:06:33 +0000 Subject: [PATCH 4/6] Eodds notebook --- examples/equalized_odds.ipynb | 1035 +++++++++++++++++++++++++++++++++ 1 file changed, 1035 insertions(+) create mode 100644 examples/equalized_odds.ipynb diff --git a/examples/equalized_odds.ipynb b/examples/equalized_odds.ipynb new file mode 100644 index 0000000..d0d84bc --- /dev/null +++ b/examples/equalized_odds.ipynb @@ -0,0 +1,1035 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This notebook demonstrates how to use inferred groups to implement the muliple thresholds per group as used by the original paper on equalized odds\n", + "\n", + "Equality of opportunity in supervised learning\n", + "\n", + "Hardt et al.\n", + "\n", + "and the more recent follow-up work\n", + "\n", + "Unprocessing Seven Years of Algorithmic Fairness\n", + "\n", + "Cruz and Hardt\n", + "\n", + "We will compare these results using inferred attributes with fairlearn." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/miniconda3/envs/ag/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "source": [ + "import oxonfair as fair\n", + "from oxonfair import group_metrics as gm\n", + "import xgboost\n", + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will load the adult dataset, train XGBoost on it, and a fair baseline method using one threshold per group.\n", + "\n", + "For direct comparision with Cruz and Hardt, and fairlearn, we use the L_infinity version of equalized odds given by `gm.equalized_odds_max` -- corresponding to the maximum violation, rather than more stable average violation provided by `gm.equalized_odds`." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "train,val,test = fair.dataset_loader.adult(train_proportion=0.4,test_proportion=0.3)\n", + "classifier = xgboost.XGBClassifier().fit(train['data'],train['target'])\n", + "fpred = fair.FairPredictor(classifier,val).fit(gm.accuracy,gm.equalized_odds_max,0.01)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now define 3 variants of thresholding. \n", + "\n", + "1. `random_group_fn` randomly assigns one of two thresholds to each member of a particular group as in Hardt et al., and Cruz and Hardt.\n", + "2. `groups_fn` is a determenistic version of the same.\n", + "3. `inferred_group_fun` is a modified version of 2. that works when group labels are not available at test time by using a second classifier to infer group membership." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def random_group_fn(data):\n", + " return data['sex']*2 + (np.random.randn(data.shape[0])>0)\n", + "\n", + "def groups_fn(data):\n", + " return data['sex']*2 + classifier.predict(data)\n", + "\n", + "def inferred_group_fun(data):\n", + " return group_class.predict(data)*2 + classifier.predict(data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we generate a comparison of the different strategies (baseline OxonFair, random_groups and deterministic).\n", + "\n", + "We find that deterministic and random strategies are largely interchangeable, and baseline performs much worse." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Substantially fewer groups (2) used in true groups than in the infered groups (4)\n", + "Substantially fewer groups (2) used in true groups than in the infered groups (4)\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'A comparision of randomized and deterministic Eq. Odds Strategies')" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from matplotlib import pyplot as plt\n", + "fpred2 = fair.FairPredictor(classifier,val,inferred_groups=groups_fn,threshold=0).fit(gm.accuracy,gm.equalized_odds_max,0.002)\n", + "fpred3 = fair.FairPredictor(classifier,val,inferred_groups=random_group_fn,threshold=0).fit(gm.accuracy,gm.equalized_odds_max,0.002)\n", + "fpred2.plot_frontier(name_frontier='Deterministic Multi threshold',show_original=False)\n", + "fpred3.plot_frontier(name_frontier='Randomized, p=0.5',new_plot=False,show_original=False)\n", + "fpred.plot_frontier(name_frontier='Single-threshold',show_original=False,new_plot=False)\n", + "\n", + "plt.ylim(bottom=0.84)\n", + "plt.xlim(right=0.03)\n", + "plt.title('A comparision of randomized and deterministic Eq. Odds Strategies')\n", + "#plt.savefig('Eo_comp.pdf')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot the same on test.\n", + "\n", + "There is too much noise to see anything." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(-0.002630489483929168, 0.03)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fpred2.plot_frontier(test,name_frontier='Flip-based')\n", + "fpred3.plot_frontier(test,name_frontier='randomized, p=0.5',new_plot=False)\n", + "fpred.plot_frontier(test,name_frontier='Single-threshold',new_plot=False)\n", + "plt.ylim(bottom=0.84)\n", + "plt.xlim(right=0.03)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To better understand the trade-offs when enforcing equalized odds we plot the per group sensitivity and specificity, and how equalized odds alters these.\n", + "\n", + "While equalized odds can decrease both sensitivity and specificity for the best performing class, it doesn't have to, and you may need to rerun the entire notebook multiple times until you see this behaviour." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.3, 0.9)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fpred.fit(gm.recall,gm.specificity)\n", + "fpred.plot_frontier(objective1=gm.recall.per_group,objective2=gm.specificity.per_group,show_original=False,show_updated=False,name_frontier='Per group thresholding')\n", + "fpred2.plot_frontier(objective1=gm.recall.per_group,objective2=gm.specificity.per_group, new_plot=False,name_frontier='Eodds')\n", + "plt.title('Per group behaviour of Equalized Odds')\n", + "plt.xlim(left=0.8)\n", + "plt.ylim(bottom=0.3,top=0.9)\n", + "#plt.savefig('per_group_eodds.pdf')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now consider the same task but with inferred groups. We reload adult, but discarding the groups and train a baseline method using single thresholds and the new multi-threshold approach." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Substantially fewer groups (2) used in true groups than in the infered groups (4)\n" + ] + } + ], + "source": [ + "train,val,test = fair.dataset_loader.adult(train_proportion=0.4,test_proportion=0.3,discard_groups=True)\n", + "classifier = xgboost.XGBClassifier().fit(train['data'],train['target'])\n", + "group_class = xgboost.XGBClassifier().fit(train['data'],train['groups']==' Female')\n", + "fpred_inf = fair.FairPredictor(classifier,val,inferred_groups=inferred_group_fun,threshold=0).fit(gm.accuracy,gm.equalized_odds_max,0.02)\n", + "fpred_inf_base = fair.FairPredictor(classifier,val,inferred_groups=group_class).fit(gm.accuracy,gm.equalized_odds_max,0.02)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We plot on validation data." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Eodds with inferred groups (Validation)')" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAHHCAYAAABDUnkqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB/gUlEQVR4nO3dd1gUV9sG8Hspy9IRRYoiYAcLGhCCRtFYsGtMYolGMAZjSzRGP1siGqOYYos1MbHErtFoosZGbFEUFbGBggqCCooNBKm75/vDl4kLC9LLev+ua69kz5w588xh13n2zJkZmRBCgIiIiEhL6FR0AERERESlickNERERaRUmN0RERKRVmNwQERGRVmFyQ0RERFqFyQ0RERFpFSY3REREpFWY3BAREZFWYXJDREREWoXJDVVpMpkMM2fOfGW9mTNnQiaTlX1A+Th69ChkMhmOHj1a6Lq///57sba1du1ayGQyxMTEFGv9qKgodOnSBebm5pDJZNi1a1ex2ilPjo6O8PPzq+gwKrWUlBTUrFkTGzduLLNtaPqc+/n5wdHR8ZXrxsTEQCaTYe3ataUaU3l8NgYOHIj+/fuX6TaoaJjcUKnLObjm9zp9+nRFh1gpbNq0CYsWLaroMPLw9fXF5cuXMWfOHKxfvx7u7u4VHRKVgsWLF8PU1BQDBw4EADRv3hx16tRBQU/gadOmDaytrZGdnV1eYRbLqVOnMHPmTDx9+rRCtj958mTs2LEDFy9erJDtU156FR0Aaa+vv/4aTk5Oecrr169fAdFUrHbt2iEtLQ1yuVwq27RpE65cuYLx48eX6rY+/PBDDBw4EAYGBkVeNy0tDcHBwZg+fTrGjh1bqnFRxcnKysLixYvx+eefQ1dXFwAwePBgTJkyBSdOnEC7du3yrBMTE4Pg4GCMHTsWenrFP1SsWrUKKpWq2OsXxqlTpzBr1iz4+fnBwsJCbdn169eho1O2v+NbtmwJd3d3zJ8/H7/99luZbosKh8kNlZlu3brxV///6OjoQKFQlMu2dHV1pQNYUSUmJgJAngNESaSnp0Mul2s8wKSmpsLY2LjUtlWWqlKsue3ZsweJiYlqp04++OADTJ06FZs2bdKY3GzevBlCCAwePLhE29bX1y/R+iVVnCS/OPr374+AgAAsX74cJiYm5bJNyh9PS1GFSk1NxRdffAF7e3sYGBigUaNG+OGHH/IMlWdkZODzzz+HlZUVTE1N0bt3b9y5c0djm//++y9atWoFhUKBevXq4aefftJY79ChQ3jrrbdgYWEBExMTNGrUCNOmTSsw3n79+uGNN95QK+vVqxdkMhn+/PNPqezMmTOQyWT4+++/AeSdi9C+fXvs3bsXt2/flk7X5Z6XoFKpMGfOHNSuXRsKhQIdO3bEjRs3CowP0DznxtHRET179sS///4LDw8PKBQK1K1bV+1X5syZM+Hg4AAAmDRpUp6Y7t69i48++gjW1tYwMDBAkyZNsHr1arVt5+znli1b8OWXX6JWrVowMjJCcnIy/Pz8YGJigps3b6J79+4wNTWVDpwqlQqLFi1CkyZNoFAoYG1tjU8++QRPnjxRa18IgW+++Qa1a9eGkZEROnTogKtXr76yT3I8evQIH374IczMzGBhYQFfX19cvHgxz1yPgmItzGe2oPkjueeJ5cwHu3btGvr37w8zMzNUr14d48aNQ3p6utq6xfnMAsCuXbvg6OiIevXqSWX29vZo164dfv/9d2RlZeVZZ9OmTahXrx48PT1x+/ZtjB49Go0aNYKhoSGqV6+O999/v1DzujTNuXn69Cn8/Pxgbm4u/R00nVK6dOkS/Pz8ULduXSgUCtjY2OCjjz7Co0ePpDozZ87EpEmTAABOTk7S9yknNk1zbm7duoX3338flpaWMDIywptvvom9e/eq1cn5LG/btq1Q38POnTsjNTUVhw4demWfUNnjyA2VmaSkJDx8+FCtTCaToXr16gBeHKh69+6NI0eOYPjw4WjRogUOHDiASZMm4e7du1i4cKG03scff4wNGzbggw8+QOvWrfHPP/+gR48eebZ5+fJldOnSBVZWVpg5cyays7MREBAAa2trtXpXr15Fz5490bx5c3z99dcwMDDAjRs3cPLkyQL3qW3btti9ezeSk5NhZmYGIQROnjwJHR0dnDhxAr179wYAnDhxAjo6OmjTpo3GdqZPn46kpCTcuXNH2s/cv/bmzZsHHR0dTJw4EUlJSfjuu+8wePBgnDlzpsAY83Pjxg289957GD58OHx9fbF69Wr4+fnBzc0NTZo0Qb9+/WBhYYHPP/8cgwYNQvfu3aWY7t+/jzfffBMymQxjx46FlZUV/v77bwwfPhzJycl5Tq3Nnj0bcrkcEydOREZGhnQ6Ljs7Gz4+Pnjrrbfwww8/wMjICADwySefYO3atRg2bBg+++wzREdHY+nSpbhw4QJOnjwp/fqfMWMGvvnmG3Tv3h3du3dHaGgounTpgszMzFfuv0qlQq9evRASEoJRo0ahcePG2L17N3x9fTXW1xRrUT6zRdW/f384OjoiMDAQp0+fxo8//ognT55ICWhxP7PAi9M2uZNy4MWpqREjRuDAgQPo2bOnVH758mVcuXIFM2bMAACcPXsWp06dwsCBA1G7dm3ExMRgxYoVaN++PcLDw6W/Y2EIIdCnTx/8+++/GDlyJJydnfHHH39o/DscOnQIt27dwrBhw2BjY4OrV6/i559/xtWrV3H69GnIZDL069cPkZGR2Lx5MxYuXIgaNWoAAKysrDRu//79+2jdujWeP3+Ozz77DNWrV8e6devQu3dv/P7773jnnXfU6hf2e+ji4gJDQ0OcPHkyTxtUAQRRKVuzZo0AoPFlYGAg1du1a5cAIL755hu19d977z0hk8nEjRs3hBBChIWFCQBi9OjRavU++OADAUAEBARIZX379hUKhULcvn1bKgsPDxe6urri5Y/7woULBQCRmJhYpH07e/asACD27dsnhBDi0qVLAoB4//33haenp1Svd+/eomXLltL7I0eOCADiyJEjUlmPHj2Eg4NDnm3k1HV2dhYZGRlS+eLFiwUAcfny5QJjzOn/6OhoqczBwUEAEMePH5fKHjx4IAwMDMQXX3whlUVHRwsA4vvvv1drc/jw4cLW1lY8fPhQrXzgwIHC3NxcPH/+XC32unXrSmU5fH19BQAxZcoUtfITJ04IAGLjxo1q5fv371crf/DggZDL5aJHjx5CpVJJ9aZNmyYACF9f3wL7ZceOHQKAWLRokVSmVCrF22+/LQCINWvWvDLWwn5mc/rx5TZz5P7MBgQECACid+/eavVGjx4tAIiLFy8KIYr/mc3KyhIymUzt75zj8ePHwsDAQAwaNEitfMqUKQKAuH79uhBC5PlbCiFEcHCwACB+++03qUzT59zX11ftc57Th999951Ulp2dLdq2bZunzzRtd/PmzXk+y99//32ez3wOBwcHtc/G+PHjBQBx4sQJqezZs2fCyclJODo6CqVSqbYvRfkeNmzYUHTr1i1POZU/npaiMrNs2TIcOnRI7ZVzmgYA9u3bB11dXXz22Wdq633xxRcQQkh19+3bBwB56uUeLVAqlThw4AD69u2LOnXqSOXOzs7w8fFRq5szp2T37t1FmuzYsmVLmJiY4Pjx4wBejNDUrl0bQ4cORWhoKJ4/fw4hBP7991+0bdu20O1qMmzYMLUJyDnt3bp1q1jtubi4qMVkZWWFRo0avbI9IQR27NiBXr16QQiBhw8fSi8fHx8kJSUhNDRUbR1fX18YGhpqbG/UqFFq77dv3w5zc3N07txZrW03NzeYmJjgyJEjAIDDhw8jMzMTn376qdpl/YWdkL1//37o6+vD399fKtPR0cGYMWPyXSd3rIX9zBZH7jg+/fRTaZtA8T+zjx8/hhAC1apVy7OsWrVq6N69O/7880+kpqYCePH33rJlC9zd3dGwYUMAUPtbZmVl4dGjR6hfvz4sLCzy/O1fZd++fdDT01PrW11dXWl/X/bydtPT0/Hw4UO8+eabAFDk7b68fQ8PD7z11ltSmYmJCUaMGIGYmBiEh4er1S/K97BatWp5RqupYjC5oTLj4eGBTp06qb06dOggLb99+zbs7Oxgamqqtp6zs7O0POe/Ojo6avMFAKBRo0Zq7xMTE5GWloYGDRrkiSV33QEDBqBNmzb4+OOPYW1tjYEDB2Lbtm2vPGjo6urCy8sLJ06cAPAiuWnbti3eeustKJVKnD59GuHh4Xj8+HGJk5uXEzQA0sEp9zyU4raX0+ar2ktMTMTTp0/x888/w8rKSu01bNgwAMCDBw/U1tF0lRwA6OnpoXbt2mplUVFRSEpKQs2aNfO0n5KSIrWd83nI/fe1srLSeODO7fbt27C1tc1zCiW/q/c0xVrYz2xx5N6vevXqQUdHR5o7UtzPbA6RzyXfgwcPRmpqKnbv3g3gxSmsmJgYtYnEaWlpmDFjhjTPqEaNGrCyssLTp0+RlJRUpP3M+TvkPg2b+zsKvEjMxo0bB2traxgaGsLKykr6bBV1uy9vX9O28vsbFuV7KISo0Ptp0X8454ZeS4aGhjh+/DiOHDmCvXv3Yv/+/di6dSvefvttHDx4sMCrjd566y3MmTMH6enpOHHiBKZPnw4LCws0bdoUJ06ckOb3lDS5yS+G/A5SZdVezsFzyJAh+c5Pad68udr7/EZtDAwM8lw1pVKpCry5XH5zJ8qaplgLK78DnFKpLHYbxf3MWlpaQiaT5ZvE9uzZE+bm5ti0aRM++OADbNq0Cbq6utL9cIAXo0hr1qzB+PHj4eXlJd3gceDAgWV6mXf//v1x6tQpTJo0CS1atICJiQlUKhW6du1a5peX5yjK9+bJkycaf1xR+WNyQxXGwcEBhw8fxrNnz9R+CV+7dk1anvNflUqFmzdvqv3iun79ulp7VlZWMDQ0RFRUVJ5t5a4LvDgl0bFjR3Ts2BELFizA3LlzMX36dBw5cgSdOnXKN+62bdsiMzMTmzdvxt27d6Ukpl27dlJy07BhwzyTmHOrKr/wcq5QUyqVBfZLcdWrVw+HDx9GmzZt8k2KgP8+D1FRUahbt65UnpiYWKjRLAcHBxw5cgTPnz9XG70pzBVoL7dRmM9szq/73FcAFTSyExUVpTbidePGDahUKrUrjYrzmdXT00O9evUQHR2tcbmBgQHee+89/Pbbb7h//z62b9+Ot99+GzY2NlKd33//Hb6+vpg/f75Ulp6eXqyb5jk4OCAoKAgpKSlqoze5v6NPnjxBUFAQZs2aJU1sBqDx+12U75KDg4PGfw9y/w2LKjs7G3FxcdJFBVSxeFqKKkz37t2hVCqxdOlStfKFCxdCJpOhW7duACD998cff1Srl/vuvrq6uvDx8cGuXbsQGxsrlUdERODAgQNqdR8/fpwnnhYtWgB4cdl5QTw9PaGvr49vv/0WlpaWaNKkCYAXSc/p06dx7NixQo3aGBsbF3tovTzp6uri3XffxY4dO3DlypU8y3PujVNc/fv3h1KpxOzZs/Msy87Olg6gnTp1gr6+PpYsWaL2q7mwd3n28fFBVlYWVq1aJZWpVCosW7as0LEW9jNrZmaGGjVqSHOzcixfvjzftnPHsWTJEgD/ff5L8pn18vLCuXPn8l0+ePBgZGVl4ZNPPkFiYmKee9vo6urmGalYsmRJkUaicnTv3h3Z2dlYsWKFVKZUKqX9fXmbQN4REk1/75z7DxUm2erevTtCQkIQHBwslaWmpuLnn3+Go6MjXFxcCrsrasLDw5Geno7WrVsXa30qXRy5oTLz999/S7+GXta6dWvUrVsXvXr1QocOHTB9+nTExMTA1dUVBw8exO7duzF+/Hhpjk2LFi0waNAgLF++HElJSWjdujWCgoI0/uKeNWsW9u/fj7Zt22L06NHIzs7GkiVL0KRJE1y6dEmq9/XXX+P48ePo0aMHHBwc8ODBAyxfvhy1a9dWm2ioiZGREdzc3HD69GnpHjfAi5Gb1NRUpKamFiq5cXNzw9atWzFhwgS0atUKJiYm6NWr1yvXqwjz5s3DkSNH4OnpCX9/f7i4uODx48cIDQ3F4cOHNR54C8vb2xuffPIJAgMDERYWhi5dukBfXx9RUVHYvn07Fi9ejPfeew9WVlaYOHEiAgMD0bNnT3Tv3h0XLlzA33//LV3+W5C+ffvCw8MDX3zxBW7cuIHGjRvjzz//lGIvzK//wn5mgRe3L5g3bx4+/vhjuLu74/jx44iMjMy37ejoaPTu3Rtdu3ZFcHCwdOsDV1dXACX7zPbp0wfr169HZGSkNEn4Zd7e3qhduzZ2794NQ0ND9OvXT215z549sX79epibm8PFxQXBwcE4fPiwdFuHoujVqxfatGmDKVOmICYmBi4uLti5c2eeRN/MzAzt2rXDd999h6ysLNSqVQsHDx7UOALl5uYG4MUtFgYOHAh9fX306tVL400Xp0yZgs2bN6Nbt2747LPPYGlpiXXr1iE6Oho7duwo9qnIQ4cOwcjICJ07dy7W+lTKKuAKLdJyBV0KjlyXej579kx8/vnnws7OTujr64sGDRqI77//Xu1SXyGESEtLE5999pmoXr26MDY2Fr169RJxcXF5LqsVQohjx44JNzc3IZfLRd26dcXKlSuly21zBAUFiT59+gg7Ozshl8uFnZ2dGDRokIiMjCzUPk6aNEkAEN9++61aef369QUAcfPmTbVyTZfIpqSkiA8++EBYWFgIANLlsjl1t2/frtZGQZcXvyy/S8F79OiRp663t7fw9vbOs43cl4ILIcT9+/fFmDFjhL29vdDX1xc2NjaiY8eO4ueff86zn7ljF+LFJcHGxsb5xv3zzz8LNzc3YWhoKExNTUWzZs3E//3f/4l79+5JdZRKpZg1a5awtbUVhoaGon379uLKlSt5LvfNT2Jiovjggw+EqampMDc3F35+fuLkyZMCgNiyZUuhYi3sZ/b58+di+PDhwtzcXJiamor+/fuLBw8e5HspeHh4uHjvvfeEqampqFatmhg7dqxIS0uT6pXkM5uRkSFq1KghZs+enW+dnM90//798yx78uSJGDZsmKhRo4YwMTERPj4+4tq1a3n6vTCXggshxKNHj8SHH34ozMzMhLm5ufjwww/FhQsX8ny+79y5I9555x1hYWEhzM3Nxfvvvy/u3bun8Xs/e/ZsUatWLaGjo6P2+df02bh586Z47733hIWFhVAoFMLDw0Ps2bNHrU5Rv4eenp5iyJAhefqOKoZMiGLOTiQi0gK7du3CO++8g3///Tffmy6WpZkzZ2LWrFlITEws1AhUcc2ePRtr1qxBVFRUsR/PQZqFhYXhjTfeQGhoqHSqkCoW59wQ0WsjLS1N7X3OXA8zMzONd/DVJp9//jlSUlKwZcuWig5F68ybNw/vvfceE5tKhHNuiOi18emnnyItLQ1eXl7IyMjAzp07cerUKcydO7fAK7W0gYmJSZ77EVHpYMJY+TC5IaLXxttvv4358+djz549SE9PR/369bFkyRKMHTu2okMjolLEOTdERESkVTjnhoiIiLQKkxsiIiLSKq/dnBuVSoV79+7B1NS0ytz+noiI6HUnhMCzZ89gZ2f3ypstvnbJzb1792Bvb1/RYRAREVExxMXFoXbt2gXWee2Sm5yH3cXFxcHMzKyCoyEiIqLCSE5Ohr29vdpDa/Pz2iU3OaeizMzMmNwQERFVMYWZUsIJxURERKRVmNwQERGRVmFyQ0RERFqFyQ0RERFpFSY3REREpFWY3BAREZFWYXJDREREWoXJDREREWkVJjdERESkVV67OxQTVTVKlUBI9GM8eJaOmqYKeDhZQldHprEcgMa6BbUjlEo8P3ce2YmJ0LOygpG7G1QynXzbof/k16fa5OV9NNcX+HfXOnwxYQIMDQ3z1BVKJVJDzuL5mTMAACNPDxh7eECmq1veYRdI02e+ssVYVVWWvmVyQ1rv5S+bTo0auGLphAfPs1DD2ACQAQ+Tn8Pu9nXU18uAnpWVtLymkT6aPo6G6uFD6FlZweCNN3A2NkntQCbLzsKTTZuRGRcHub09qn0wCEJPv9AHvNz/ELy8jRrGBjgb8xjr/r2F2neuwzLjGR4bmOJRXRf0alkLf16MR3xSutSWhZE+AODp8yypzNZcgYBeLgCAWX+Fq9W3NVdgntVD2G1YieyEBKk8u7oVVjbrg70WjfO007Wpben8UbTA/ivxGvtUm/op9z6mXD2CR3vmI1nXAt9NGaNWN/ngQcTPCIDq6VOp7NHKldCxsIDt17Ng1qVLeYaer+SDB3F/bqDaZ17PxgbW06ZWmhirqsrUtzIhhCjXLVaw5ORkmJubIykpic+WqqSioqLw7Nkz3I6ORnpEBFRPk3EpSYko4xqobqpAF1cH1HOsA+PYWNjIDV4kLOZ1kHz2HGRh52FooAeFeys07/k2Lm/9C/KVC6H/+KHUfqLCHCub98Upu2Zofe8yRl7aBav0JLXlR2u3RPs7F9TKHxtZYFnTPjhl1wwA8GnU3+gWcQQylUqqI3R08LdzByxp0E0qy++Ap+kfgtzbyC++nPhfRQYgvy94m3uXMT1knVQvh+p/77/x8JW2kbN8xZA3tObAXRL7r8Rj1IbQPH2rTf2kaR8Td36N51EhMG7gid93/iHtY/LBg7j72bgC26v14+IKTx6SDx7E3XHjgdyHvf89q6jW4kUVHmNVVR59W5TjN5MbKjUvj0LoVq8OQED56LHa/+tZWcGwZQukXQhTG0lJSE5DdtgFpMZcx7A5U165rXX29mhlZCy9VwLIPfD5XE8Ow+xMAJoP3r/Xb4/3bhzNd3l+5d94+KLx49sa1835Mv1evz1WN+2ptvzlA15+/xC8vA0A+LKQyUdR6QgV1h6YgxrpSdA0pqQC8NDQAsO6TINKpiPFYGOuwL+T39a6Uy9FoVQJvPXtP2ojNi/Thn7K2cc79+KRfHY3hCobAPD8wh7UMVEiNkUXNd/siwGt7KHQ14fvyVMQDx8W2KaejQ3qBx2usNM/QqnEjY6d1H5MqJHJoGdtXaExVlXl1bdFOX7ztBTlK79kRadaNWREXkfWnbvQq10bN970wfMTx2Dz23LoPEx8dbsyHcjEf6MdMn0j2MoA88znCE9/ccDwfXsqbCzq5Fk34Wks1v0TCCMd9bnwmmbGa0pscuqqAPS7cSzf5aKA9T65+AeqZzzTuG7OSEm/G8fwm0tXZOvoSW3N+iscnV1soCNUuD83MO8vnJe3cWmXxgRLrc7l3Tht20RKPoqiycNbaqNBmuKomfYUTR7ewmWr+sD/9is+KR0h0Y/hVa96kbepLUKiH+eb2ADa0U85+6hMeYKU87uhys6CmUIHTa108XMPI4zYm4noczux6F8V2pibY6jNq0epshMS8PzceRh7epTDHuT1/Nz5/A++ACBEhcdYVVXGvmVyo6XyS0w0TfDSNAHsWVBQnlMm+THFtzAvUnAqtbdmWc/zVLGxqAN7q4b5NiHLdcjX9Pu4oN/ML9KB/Act81tXB0DNjOQCWn6xri4Eetw6id31vaUt5Rzwmj+8WWC/6gCoWUDiIdXJlXwUheX/krPi1HvwLP8D++ugsPtflfspJ3a5dV1YD12EJ38GIv3pPcz21oNHLV3M9tbDe78r4VCvPn6aOBFYtKhQ7WYnvvrHT1kp7LYrMsaqqjL2LZObSip3wvHyqZycBASAxgQmIzoaTzdtgvLJE41t69nYwGrqVFyt+wai//gLLjt/heHTR9JylakZZM9eHMALM6ieM25Q2AF4TaMd2sg29XGesgfP0kv1C17YJCW3xwamxa5X01RRrG1qi8Luf1Xup5djl1s5oMbgH3D3x0E4EavErScq3EkWyFIK/LRtPxyzHiG2kO3qWVmVTcCluO2KjLGqqox9y+SmghR0uVzywYO4P2cusu/f/28FHR3gpYmrOhYWAKB2ZUJhZSUk4N64cQh6ac7Jy4qS2BSl3usm3tgyT1lNU0WpfsELm6TkdrVGXSQqzFE9PUnjKb2cOTdXa9SVynLmkuRccv668nCyhK25AglJ6RrH/rShn3LvY0bcFQghsPhMFjKVAnJdGYQQSIu9AqNePaFrbQ3ly/9eaaBnYyP9KKsIRu5u0LOxefHvqqappv+bF1KRMVZVlbFveRO/MiKUSqSeCUHSnr1IPRMCVWam9D5x2XLceLsjYn19cW/iRMT6+uJGx05IPnhQuuogO/c/FCr1Uzmqp0+LldgA6vNCct7nXq7tCYsKgBIyqPJZnt8JKxWABwZmUEKWbx3xv7b31m0jlcnw4qopDydL6R+CnKsING5DYY5EhXm+8akAPMiVfGgiy+f/VTId/NS8r8arqXImLP/UrI/aZGIACOjlUmUnyZYWXR2ZdHl9fqOQVb2fcu/j88hTAAA9O2fYDPkBenbOAIBdu/6ATFcXNtOnvbJN62lTK3SirkxXF9bTpv7vTa6/zf/eV3SMVVVl7FuO3JSinNGYZ//8g+Q//1Q/LZRr5CW37Pv3cfezcZAZG5VDpK+ec6ItcvZQ09VGO+p7470bR6GCepafszz3pGLpoO/6jnS1VO46OdvbWd8b2Tp6atv+74D34h+Cu+PGv/jiv/RLR9pG874AXlwtlV982zzfU5tMrOk+NzYF3OfmlnMrJLZzynOfG9X/7nNz6qX73Nho2f1bSqprU1usGPJGnj7Vpn56eR+TrOtDv0YdmLV6B3bVjPHlxAO4emATFIoXp6/MunQBflyc5z43AKBrYQGbSnKfG7MuXYDFi/Lei8Xamve5KaHK1re8FLy02tVwzxIquvD0dLx3O+aVV0ttc3BAU8V/d0jVdHVTzgc7WW4E88z/Ji0/MLTAT8365HufmweGFjhWq0We+9w8MrLA8jK+z03ubWiKL+emWMadOvMOxRXsdbtDcWFuSsk7FL/eyrJveZ+bApRFcpPvzYteI5pGSAqqq2m0QwYgJjMT3aNvvbKNwtznJkluhB9bvI/Ttk3Q5OEt1NNJR++3m8HQzb3K3KE4d3zymjX5DzERvZaY3BSgtJObV968qJJSARCQQQahceJVUZMVAEjTNYCRMuOV9ZWQQfelU2JJ8hen4nJGV2IyM/H8f6MhybpynLGog2vVa0NVxwGNbM2LdIfi0DvJWv2rmojodcHkpgClndyknglBrK9vKURWfnLfoVdA85yO3Kdz8qOEDDvre2Ntk+5o9ugWLNKf4YncGDKZDBYZKdL/W2ak4KGBKSKqO8L5UYz0rKR7dRqhj6stnB9Go9rzJFhmpcKhXi3cEka459AINc2NmZgQEb3meIficlSa9yx5MZryItF41WG8KCMruT18ac7JNUuHPHM6cpbnnM6xzFBPVp7qG6Lus/uwTn2M1OrWqDFkEFxtqmGjqQJuDj1w/vYT9dMqKRmoaaqAm0M1nL/9BAlJaXic2gyWJgawMXt5RMVVLc6qeW9XIiKqaExuSqi07lny3xU87fO9Cufl98m5TuUU5Im+EfbUbYO7pjXx2MAUV2vUla6yOWXXTEpibJWpeGZsjjMmdaTlL9/91lShizfsLdC8ujFa2leDrYWhxhGVgm45X1VvR09ERFUHk5sSMnJ3g46FxSvvOfOqZCXPaMrFP2D10m3+Ew3MsN/JC/dMakgJCgCNIysv/3/uZEYTn2Z2GPKmF96s+yLxyJkMm3vkhaeGiIioKmByU0LPgoIKdTM9Va5JtIkKc+x3fFMtWdE0mpIzLyW/BKWwzxXq7FITV+4mq92TI79LlDm6QkREVRmTmxIQSuWLpzvntxxAmq4cX785DFerO6lNon3VaIpKpqOWuFgay/EkNbPIt92zNNbHN32aontzu9finhxERERMbkrgVY95lwEwUmZCBRmydfSK9fTmnOfUfNXDBWM2hWq8Xf7LbMwMMMijDhxrGOdJYHR1ZByVISIircfkpgQKe6VUcZ/c/PJt+7s2tcUKHQ23ey8gmSEiInodMbkpgcJeKVWYJzebGOjBxEAPCcn5P6ema1NbdHax4aklIiKiAjC5KYGcpztnJSRovN+MCi+ugnrVk5sB4Lt3m8On6asTF55aIiIiKhiTmxKQ6erCaupU3Bs3Lt8nN//UrE+BE4cB4JN2Tuje/MXoDBMXIiKikin4qEuvFFHfDd94+OKRwlyt/KGhBb7x8JWe7qyJpbE+ln/QElO7u5R1mERERK8NjtyU0INn6UW6L42lsT7eaVELnVxsOF+GiIioDDC5KaGapgoAee9Lo8n4jg3waccGTGiIiIjKEE9LlZCHkyVszRWvrOff1gnjOzdkYkNERFTGmNyUkK6ODAG9XAp8Ord/W0dM78F5NUREROWByU0p6NrUFiuGvJFnBCdnwvD0Hk0qKDIiIqLXD+fclBLeYI+IiKhyYHJTiniDPSIioorH01JERESkVZjcEBERkVZhckNERERahckNERERaZUKT26WLVsGR0dHKBQKeHp6IiQkpMD6ixYtQqNGjWBoaAh7e3t8/vnnSE9PL6doiYiIqLKr0ORm69atmDBhAgICAhAaGgpXV1f4+PjgwYMHGutv2rQJU6ZMQUBAACIiIvDrr79i69atmDZtWjlHTkRERJVVhSY3CxYsgL+/P4YNGwYXFxesXLkSRkZGWL16tcb6p06dQps2bfDBBx/A0dERXbp0waBBg1452kNERESvjwpLbjIzM3H+/Hl06tTpv2B0dNCpUycEBwdrXKd169Y4f/68lMzcunUL+/btQ/fu3fPdTkZGBpKTk9VeREREpL0q7CZ+Dx8+hFKphLW1tVq5tbU1rl27pnGdDz74AA8fPsRbb70FIQSys7MxcuTIAk9LBQYGYtasWaUaOxEREVVeFT6huCiOHj2KuXPnYvny5QgNDcXOnTuxd+9ezJ49O991pk6diqSkJOkVFxdXjhETERFReauwkZsaNWpAV1cX9+/fVyu/f/8+bGxsNK7z1Vdf4cMPP8THH38MAGjWrBlSU1MxYsQITJ8+HTo6eXM1AwMDGBgYlP4OEBERUaVUYSM3crkcbm5uCAoKkspUKhWCgoLg5eWlcZ3nz5/nSWB0dXUBAEKIsguWiIiIqowKfXDmhAkT4OvrC3d3d3h4eGDRokVITU3FsGHDAABDhw5FrVq1EBgYCADo1asXFixYgJYtW8LT0xM3btzAV199hV69eklJDhEREb3eKjS5GTBgABITEzFjxgwkJCSgRYsW2L9/vzTJODY2Vm2k5ssvv4RMJsOXX36Ju3fvwsrKCr169cKcOXMqaheIiIiokpGJ1+x8TnJyMszNzZGUlAQzM7OKDoeIiIgKoSjH7yp1tRQRERHRqzC5ISIiIq3C5IaIiIi0CpMbIiIi0ipMboiIiEirVOil4NpEKJV4fu48shMToWdlBSN3N8h47x0iIqJyx+SmFCQfPIj7cwORnZAglenZ2MB62lSYdelSgZERERG9fnhaqoSSDx7E3XHj1RIbAMi+fx93x41H8sGDFRQZERHR64nJTQkIpRL35wYCmu6D+L+y+3MDIZTKco6MiIjo9cXkpgSenzufZ8RGjRDITkjA83Pnyy8oIiKi1xyTmxLITkws1XpERERUckxuSkDPyqpQ9UJT2M1ERETlhUfdEjBs2QLQ0UF+Tx4VAJSQ4csoHShVr9XzSYmIiCoMk5sSSLsQBqhUkOWzXAZAFwKWMdcQEv24HCMjIiJ6fTG5KYHCzqWxzHiGB8/SyzgaIiIiApjclEhh59w8NjBFTVNFGUdDREREAJObEjFyd4OetTVU+SxXAXhgaIFHdV3g4WRZnqERERG9tpjclIBMVxfW06dBBuRJcFR4Mefm52Z9MKNPU+jq5Dczh4iIiEoTk5sSMuvSBbV/XAxVdfVTVA8NLbCs/cf48P980bWpbQVFR0RE9PqRCaHp2QHaKzk5Gebm5khKSoKZmVmptSuUSqScPYfrV6PxWGEK01at4FHfiiM2REREpaAox28+FbyUyHR1YfqmJ9zf9KzoUIiIiF5rPC1FREREWoXJDREREWkVJjdERESkVZjcEBERkVZhckNERERahckNERERaRUmN0RERKRVmNwQERGRVmFyQ0RERFqFyQ0RERFpFSY3REREpFWY3BAREZFWYXJDREREWoXJDREREWkVJjdERESkVZjcEBERkVZhckNERERahckNERERaRUmN0RERKRVmNwQERGRVmFyQ0RERFqlUiQ3y5Ytg6OjIxQKBTw9PRESEpJv3fbt20Mmk+V59ejRoxwjJiIiosqqwpObrVu3YsKECQgICEBoaChcXV3h4+ODBw8eaKy/c+dOxMfHS68rV65AV1cX77//fjlHTkRERJVRhSc3CxYsgL+/P4YNGwYXFxesXLkSRkZGWL16tcb6lpaWsLGxkV6HDh2CkZERkxsiIiICUMHJTWZmJs6fP49OnTpJZTo6OujUqROCg4ML1cavv/6KgQMHwtjYWOPyjIwMJCcnq72IiIhIe1VocvPw4UMolUpYW1urlVtbWyMhIeGV64eEhODKlSv4+OOP860TGBgIc3Nz6WVvb1/iuImIiKjyqvDTUiXx66+/olmzZvDw8Mi3ztSpU5GUlCS94uLiyjFCIiIiKm96FbnxGjVqQFdXF/fv31crv3//PmxsbApcNzU1FVu2bMHXX39dYD0DAwMYGBiUOFYiIiKqGip05EYul8PNzQ1BQUFSmUqlQlBQELy8vApcd/v27cjIyMCQIUPKOkwiIiKqQip05AYAJkyYAF9fX7i7u8PDwwOLFi1Camoqhg0bBgAYOnQoatWqhcDAQLX1fv31V/Tt2xfVq1eviLCJiIiokqrw5GbAgAFITEzEjBkzkJCQgBYtWmD//v3SJOPY2Fjo6KgPMF2/fh3//vsvDh48WBEhExERUSUmE0KIig6iPCUnJ8Pc3BxJSUkwMzOr6HCIiIioEIpy/K7SV0sRERER5cbkhoiIiLQKkxsiIiLSKkxuiIiISKswuSEiIiKtwuSGiIiItAqTGyIiItIqTG6IiIhIqzC5ISIiIq3C5IaIiIi0CpMbIiIi0ipMboiIiEirMLkhIiIircLkhoiIiLQKkxsiIiLSKkxuiIiISKswuSEiIiKtwuSGiIiItAqTGyIiItIqTG6IiIhIqzC5ISIiIq3C5IaIiIi0CpMbIiIi0ipMboiIiEirMLkhIiIircLkhoiIiLQKkxsiIiLSKkxuiIiISKswuSEiIiKtwuSGiIiItAqTGyIiItIqTG6IiIhIqzC5ISIiIq3C5IaIiIi0CpMbIiIi0ipMboiIiEirMLkhIiIircLkhoiIiLQKkxsiIiLSKkxuiIiISKswuSEiIiKtwuSGiIiItAqTGyIiItIqFZ7cLFu2DI6OjlAoFPD09ERISEiB9Z8+fYoxY8bA1tYWBgYGaNiwIfbt21dO0RIREVFlV+TkxtHREV9//TViY2NLvPGtW7diwoQJCAgIQGhoKFxdXeHj44MHDx5orJ+ZmYnOnTsjJiYGv//+O65fv45Vq1ahVq1aJY6FiIiItEORk5vx48dj586dqFu3Ljp37owtW7YgIyOjWBtfsGAB/P39MWzYMLi4uGDlypUwMjLC6tWrNdZfvXo1Hj9+jF27dqFNmzZwdHSEt7c3XF1di7V9IiIi0j7FSm7CwsIQEhICZ2dnfPrpp7C1tcXYsWMRGhpa6HYyMzNx/vx5dOrU6b9gdHTQqVMnBAcHa1znzz//hJeXF8aMGQNra2s0bdoUc+fOhVKpzHc7GRkZSE5OVnsRERGR9ir2nJs33ngDP/74I+7du4eAgAD88ssvaNWqFVq0aIHVq1dDCFHg+g8fPoRSqYS1tbVaubW1NRISEjSuc+vWLfz+++9QKpXYt28fvvrqK8yfPx/ffPNNvtsJDAyEubm59LK3ty/6zhIREVGVUezkJisrC9u2bUPv3r3xxRdfwN3dHb/88gveffddTJs2DYMHDy7NOAEAKpUKNWvWxM8//ww3NzcMGDAA06dPx8qVK/NdZ+rUqUhKSpJecXFxpR4XERERVR56RV0hNDQUa9aswebNm6Gjo4OhQ4di4cKFaNy4sVTnnXfeQatWrQpsp0aNGtDV1cX9+/fVyu/fvw8bGxuN69ja2kJfXx+6urpSmbOzMxISEpCZmQm5XJ5nHQMDAxgYGBRlF4mIiKgKK/LITatWrRAVFYUVK1bg7t27+OGHH9QSGwBwcnLCwIEDC2xHLpfDzc0NQUFBUplKpUJQUBC8vLw0rtOmTRvcuHEDKpVKKouMjIStra3GxIaIiIheP0Ueubl16xYcHBwKrGNsbIw1a9a8sq0JEybA19cX7u7u8PDwwKJFi5Camophw4YBAIYOHYpatWohMDAQADBq1CgsXboU48aNw6effoqoqCjMnTsXn332WVF3g4iIiLRUkZObBw8eICEhAZ6enmrlZ86cga6uLtzd3Qvd1oABA5CYmIgZM2YgISEBLVq0wP79+6VJxrGxsdDR+W9wyd7eHgcOHMDnn3+O5s2bo1atWhg3bhwmT55c1N0gIiIiLSUTr7qsKRcPDw/83//9H9577z218p07d+Lbb7/FmTNnSjXA0pacnAxzc3MkJSXBzMysosMhIiKiQijK8bvIc27Cw8Pxxhtv5Clv2bIlwsPDi9ocERERUakqcnJjYGCQ5wonAIiPj4eeXpHPchERERGVqiInN126dJHuHZPj6dOnmDZtGjp37lyqwREREREVVZGHWn744Qe0a9cODg4OaNmyJQAgLCwM1tbWWL9+fakHSERERFQURU5uatWqhUuXLmHjxo24ePEiDA0NMWzYMAwaNAj6+vplESMRERFRoRVrkoyxsTFGjBhR2rEQERERlVixZwCHh4cjNjYWmZmZauW9e/cucVBERERExVWsOxS/8847uHz5MmQymfT0b5lMBgBQKpWlGyERERFRERT5aqlx48bByckJDx48gJGREa5evYrjx4/D3d0dR48eLYMQiYiIiAqvyCM3wcHB+Oeff1CjRg3o6OhAR0cHb731FgIDA/HZZ5/hwoULZREnERERUaEUeeRGqVTC1NQUAFCjRg3cu3cPAODg4IDr16+XbnRERERERVTkkZumTZvi4sWLcHJygqenJ7777jvI5XL8/PPPqFu3blnESERERFRoRU5uvvzyS6SmpgIAvv76a/Ts2RNt27ZF9erVsXXr1lIPkIiIiKgoivxUcE0eP36MatWqSVdMVWZ8KjgREVHVU2ZPBc/KyoKenh6uXLmiVm5paVklEhsiIiLSfkVKbvT19VGnTh3ey4aIiIgqrSJfLTV9+nRMmzYNjx8/Lot4iIiIiEqkyBOKly5dihs3bsDOzg4ODg4wNjZWWx4aGlpqwREREREVVZGTm759+5ZBGERERESlo1SulqpKeLUUERFR1VNmV0sRERERVXZFPi2lo6NT4GXfvJKKiIiIKlKRk5s//vhD7X1WVhYuXLiAdevWYdasWaUWGBEREVFxlNqcm02bNmHr1q3YvXt3aTRXZjjnhoiIqOqpkDk3b775JoKCgkqrOSIiIqJiKZXkJi0tDT/++CNq1apVGs0RERERFVuR59zkfkCmEALPnj2DkZERNmzYUKrBERERERVVkZObhQsXqiU3Ojo6sLKygqenJ6pVq1aqwREREREVVZGTGz8/vzIIg4iIiKh0FHnOzZo1a7B9+/Y85du3b8e6detKJSgiIiKi4ipychMYGIgaNWrkKa9Zsybmzp1bKkERERERFVeRk5vY2Fg4OTnlKXdwcEBsbGypBEVERERUXEVObmrWrIlLly7lKb948SKqV69eKkERERERFVeRk5tBgwbhs88+w5EjR6BUKqFUKvHPP/9g3LhxGDhwYFnESERERFRoRb5aavbs2YiJiUHHjh2hp/didZVKhaFDh3LODREREVW4Yj9bKioqCmFhYTA0NESzZs3g4OBQ2rGVCT5bioiIqOopyvG7yCM3ORo0aIAGDRoUd3UiIiKiMlHkOTfvvvsuvv322zzl3333Hd5///1SCYqIiIiouIqc3Bw/fhzdu3fPU96tWzccP368VIIiIiIiKq4iJzcpKSmQy+V5yvX19ZGcnFwqQREREREVV5GTm2bNmmHr1q15yrds2QIXF5dSCYqIiIiouIo8ofirr75Cv379cPPmTbz99tsAgKCgIGzatAm///57qQdIREREVBRFTm569eqFXbt2Ye7cufj9999haGgIV1dX/PPPP7C0tCyLGImIiIgKrcinpQCgR48eOHnyJFJTU3Hr1i30798fEydOhKura7GCWLZsGRwdHaFQKODp6YmQkJB8665duxYymUztpVAoirVdIiIi0j7FSm6AF1dN+fr6ws7ODvPnz8fbb7+N06dPF7mdrVu3YsKECQgICEBoaChcXV3h4+ODBw8e5LuOmZkZ4uPjpdft27eLuxtERESkZYp0WiohIQFr167Fr7/+iuTkZPTv3x8ZGRnYtWtXsScTL1iwAP7+/hg2bBgAYOXKldi7dy9Wr16NKVOmaFxHJpPBxsamWNsjIiIi7VbokZtevXqhUaNGuHTpEhYtWoR79+5hyZIlJdp4ZmYmzp8/j06dOv0XkI4OOnXqhODg4HzXS0lJgYODA+zt7dGnTx9cvXo137oZGRlITk5WexEREZH2KnRy8/fff2P48OGYNWsWevToAV1d3RJv/OHDh1AqlbC2tlYrt7a2RkJCgsZ1GjVqhNWrV2P37t3YsGEDVCoVWrdujTt37misHxgYCHNzc+llb29f4riJiIio8ip0cvPvv//i2bNncHNzg6enJ5YuXYqHDx+WZWwaeXl5YejQoWjRogW8vb2xc+dOWFlZ4aefftJYf+rUqUhKSpJecXFx5RwxERERladCJzdvvvkmVq1ahfj4eHzyySfYsmUL7OzsoFKpcOjQITx79qzIG69RowZ0dXVx//59tfL79+8Xek6Nvr4+WrZsiRs3bmhcbmBgADMzM7UXERERaa8iXy1lbGyMjz76CP/++y8uX76ML774AvPmzUPNmjXRu3fvIrUll8vh5uaGoKAgqUylUiEoKAheXl6FakOpVOLy5cuwtbUt0raJiIhIOxX7UnDgxfyX7777Dnfu3MHmzZuL1caECROwatUqrFu3DhERERg1ahRSU1Olq6eGDh2KqVOnSvW//vprHDx4ELdu3UJoaCiGDBmC27dv4+OPPy7JrhAREZGWKPIdijXR1dVF37590bdv3yKvO2DAACQmJmLGjBlISEhAixYtsH//fmmScWxsLHR0/svBnjx5An9/fyQkJKBatWpwc3PDqVOn+FwrIiIiAgDIhBCiooMoT8nJyTA3N0dSUhLn3xAREVURRTl+l+i0FBEREVFlw+SGiIiItAqTGyIiItIqTG6IiIhIqzC5ISIiIq3C5IaIiIi0CpMbIiIi0ipMboiIiEirMLkhIiIircLkhoiIiLQKkxsiIiLSKkxuiIiISKswuSEiIiKtwuSGiIiItAqTGyIiItIqTG6IiIhIqzC5ISIiIq3C5IaIiIi0CpMbIiIi0ipMboiIiEirMLkhIiIircLkhoiIiLQKkxsiIiLSKkxuiIiISKswuSEiIiKtwuSGiIiItAqTGyIiItIqTG6IiIhIqzC5ISIiIq3C5IaIiIi0CpMbIiIi0ipMboiIiEirMLkhIiIiraJX0QEQEVU1KpUKmZmZFR0GkdaRy+XQ0Sn5uAuTGyKiIsjMzER0dDRUKlVFh0KkdXR0dODk5AS5XF6idpjcEBEVkhAC8fHx0NXVhb29fan8wiSiF1QqFe7du4f4+HjUqVMHMpms2G0xuSEiKqTs7Gw8f/4cdnZ2MDIyquhwiLSOlZUV7t27h+zsbOjr6xe7Hf7sICIqJKVSCQAlHjInIs1yvls537XiYnJDRFREJRkuJ6L8ldZ3i8kNERERaRUmN0REVGWsXbsWFhYWFR0GVXJMboiIXhNxcXH46KOPYGdnB7lcDgcHB4wbNw6PHj0q1zj8/Pwgk8nyvG7cuPHKdQcMGIDIyMhyiJKqskqR3CxbtgyOjo5QKBTw9PRESEhIodbbsmULZDIZ+vbtW7YBEhGVIqVKIPjmI+wOu4vgm4+gVIky3+atW7fg7u6OqKgobN68GTdu3MDKlSsRFBQELy8vPH78uMxjeFnXrl0RHx+v9nJycnrleoaGhqhZs2a+y/O7uWL79u2xdu3a4oZLVUyFJzdbt27FhAkTEBAQgNDQULi6usLHxwcPHjwocL2YmBhMnDgRbdu2LadIiYhKbv+VeLz17T8YtOo0xm0Jw6BVp/HWt/9g/5X4Mt3umDFjIJfLcfDgQXh7e6NOnTro1q0bDh8+jLt372L69Om4du0ajIyMsGnTJmm9bdu2wdDQEOHh4QCA2NhY9OnTByYmJjAzM0P//v1x//59qf7MmTPRokULrF+/Ho6OjjA3N8fAgQPx7NkztXgMDAxgY2Oj9tLV1cWCBQvQrFkzGBsbw97eHqNHj0ZKSoq0Xu7TUjnb++WXX+Dk5ASFQlFGPUhVSYUnNwsWLIC/vz+GDRsGFxcXrFy5EkZGRli9enW+6yiVSgwePBizZs1C3bp1yzFaIqLi238lHqM2hCI+KV2tPCEpHaM2hJZZgvP48WMcOHAAo0ePhqGhodoyGxsbDB48GFu3bkWjRo3www8/YPTo0YiNjcWdO3cwcuRIfPvtt3BxcYFKpUKfPn3w+PFjHDt2DIcOHcKtW7cwYMAAtTZv3ryJXbt2Yc+ePdizZw+OHTuGefPmFSpWHR0d/Pjjj7h69SrWrVuHf/75B//3f/9X4Do3btzAjh07sHPnToSFhRWpb0g7VehN/DIzM3H+/HlMnTpVKtPR0UGnTp0QHByc73pff/01atasieHDh+PEiRPlESoRUYkoVQKz/gqHphNQAoAMwKy/wtHZxQa6OqV7qXlUVBSEEHB2dta43NnZGU+ePEFiYiJGjx6Nffv2YciQIZDL5WjVqhU+/fRTAEBQUBAuX76M6Oho2NvbAwB+++03NGnSBGfPnkWrVq0AvLjT7Nq1a2FqagoA+PDDDxEUFIQ5c+ZI29yzZw9MTEyk9926dcP27dsxfvx4qczR0RHffPMNRo4cieXLl+e7f5mZmfjtt99gZWVVvA4irVOhyc3Dhw+hVCphbW2tVm5tbY1r165pXOfff//Fr7/+WujsPCMjAxkZGdL75OTkYsdLRFRcIdGP84zYvEwAiE9KR0j0Y3jVq14mMQhRuLk9q1evRsOGDaGjo4OrV69K9x6JiIiAvb29lNgAgIuLCywsLBARESElN46OjlJiAwC2trZ5php06NABK1askN4bGxsDAA4fPozAwEBcu3YNycnJyM7ORnp6Op4/f57vXaEdHBzyJDZz587F3LlzpfdpaWk4ffo0xo4dK5WFh4ejTp06heoTqloq/LRUUTx79gwffvghVq1ahRo1ahRqncDAQJibm0uvl7+URETl5cGz/BOb4tQrivr160MmkyEiIkLj8oiICFSrVk1KEC5evIjU1FSkpqYiPr7op8py3zZfJpPledCosbEx6tevL71sbW0RExODnj17onnz5tixYwfOnz+PZcuWAch/onBOW7mNHDkSYWFh0svd3R1ff/21WpmdnV2R942qhgodualRowZ0dXXVJqMBwP3792FjY5On/s2bNxETE4NevXpJZTlfGD09PVy/fh316tVTW2fq1KmYMGGC9D45OZkJDhGVu5qmhZvoWth6RVG9enV07twZy5cvx+eff6427yYhIQEbN27E0KFDIZPJ8PjxY/j5+WH69OmIj4/H4MGDERoaCkNDQzg7OyMuLg5xcXHSv6Ph4eF4+vQpXFxcShzn+fPnoVKpMH/+fOmhpNu2bStWW5aWlrC0tJTe51xlVb9+/RLHSZVfhY7cyOVyuLm5ISgoSCpTqVTSpYm5NW7cGJcvX1bLvHv37o0OHTogLCxMY9JiYGAAMzMztRcRUXnzcLKErbkC+c2mkQGwNVfAw8kynxols3TpUmRkZMDHxwfHjx9HXFwc9u/fj86dO6NWrVrSfJiRI0fC3t4eX375JRYsWAClUomJEycCADp16oRmzZpJCU9ISAiGDh0Kb29vuLu7lzjG+vXrIysrC0uWLMGtW7ewfv16rFy5ssTt0uunwk9LTZgwAatWrcK6desQERGBUaNGITU1FcOGDQMADB06VJpwrFAo0LRpU7WXhYUFTE1N0bRpUz7MjogqLV0dGQJ6vRjdyJ3g5LwP6OVS6pOJczRo0ADnzp1D3bp10b9/f9SrVw8jRoxAhw4dEBwcDEtLS/z222/Yt28f1q9fDz09PRgbG2PDhg1YtWoV/v77b8hkMuzevRvVqlVDu3bt0KlTJ9StWxdbt24tlRhdXV2xYMECfPvtt2jatCk2btyIwMDAUmmbXi8yUdgZZmVo6dKl+P7775GQkIAWLVrgxx9/hKenJ4AXN15ydHTM9+ZLfn5+ePr0KXbt2lWobSUnJ8Pc3BxJSUkcxSGiIklPT0d0dHSJ7qey/0o8Zv0Vrja52NZcgYBeLuja1La0QiWqkgr6jhXl+F0pkpvyxOSGiIqrNJIb4MVl4SHRj/HgWTpqmr44FVVWIzZEVUlpJTcVOqGYiOh1pKsjK7PLvYmoEsy5ISIiIipNTG6IiIhIqzC5ISIiIq3C5IaIiIi0CpMbIiIi0ipMboiIiEirMLkhIiIircLkhoiIChQTEwOZTIawsLBCr7N27VpYWFhUeBxlTSaTSXfIr4zxva6Y3BARvQbi4uLw0Ucfwc7ODnK5HA4ODhg3bhwePXr0ynXt7e0RHx+Ppk2bFnp7AwYMQGRkZElCrnKK2k9+fn7o27dv2Qb1mmJyQ0RUAdLS0jB37lykpaWV+bZu3boFd3d3REVFYfPmzbhx4wZWrlyJoKAgeHl54fHjx/mum5mZCV1dXdjY2EBPr/A3tTc0NETNmjVLI/wyl5WVVSrtFKefSkNmZma5bq8qYHJDRFQBduzYgenTp2Pnzp1lvq0xY8ZALpfj4MGD8Pb2Rp06ddCtWzccPnwYd+/exfTp06W6jo6OmD17NoYOHQozMzOMGDFC4+mWP//8Ew0aNIBCoUCHDh2wbt06yGQyPH36FEDe01IzZ85EixYtsH79ejg6OsLc3BwDBw7Es2fPpDr79+/HW2+9BQsLC1SvXh09e/bEzZs3i7SvOfEPGjQIxsbGqFWrFpYtW6ZWRyaTYcWKFejduzeMjY0xZ84cAMDu3bvxxhtvQKFQoG7dupg1axays7Ol9aKiotCuXTsoFAq4uLjg0KFDau1q6qerV6+iZ8+eMDMzg6mpKdq2bYubN29i5syZWLduHXbv3g2ZTAaZTIajR48CAC5fvoy3334bhoaGqF69OkaMGIGUlBSpzZwRnzlz5sDOzg6NGjUqUh+9DpjcEBFVgN+3b/vff7eX6XYeP36MAwcOYPTo0TA0NFRbZmNjg8GDB2Pr1q14+RnKP/zwA1xdXXHhwgV89dVXedqMjo7Ge++9h759++LixYv45JNP1BKk/Ny8eRO7du3Cnj17sGfPHhw7dgzz5s2TlqempmLChAk4d+4cgoKCoKOjg3feeQcqlapI+/z9999L8U+ZMgXjxo3Lk4jMnDkT77zzDi5fvoyPPvoIJ06cwNChQzFu3DiEh4fjp59+wtq1a6XER6VSoV+/fpDL5Thz5gxWrlyJyZMnFxjH3bt30a5dOxgYGOCff/7B+fPn8dFHHyE7OxsTJ05E//790bVrV8THxyM+Ph6tW7dGamoqfHx8UK1aNZw9exbbt2/H4cOHMXbsWLW2g4KCcP36dRw6dAh79uwpUv+8FsRrJikpSQAQSUlJFR0KEVUxaWlpIjw8XKSlpRV53YSEBDF58mQxYcIEMWHCBKEwkAsnC5lQGMilssmTJ4v79++XasynT58WAMQff/yhcfmCBQsEAGm7Dg4Oom/fvmp1oqOjBQBx4cIFIYQQkydPFk2bNlWrM336dAFAPHnyRAghxJo1a4S5ubm0PCAgQBgZGYnk5GSpbNKkScLT0zPf2BMTEwUAcfnyZY1xaOLg4CC6du2qVjZgwADRrVs36T0AMX78eLU6HTt2FHPnzlUrW79+vbC1tRVCCHHgwAGhp6cn7t69Ky3/+++/1fo2d3xTp04VTk5OIjMzU2Osvr6+ok+fPmplP//8s6hWrZpISUmRyvbu3St0dHREQkKCtJ61tbXIyMjItx+qqoK+Y0U5fvOp4ERE5SA+Ph6LFy9CenoGLAx10aSGLpZ3M8Lov7OwesViPE1TQqEwwMCBA8tkrop4aWTmVdzd3Qtcfv36dbRq1UqtzMPD45XtOjo6wtTUVHpva2uLBw8eSO+joqIwY8YMnDlzBg8fPpRGbGJjY4s0mdnLyyvP+0WLFqmV5d7Hixcv4uTJk9JIDQAolUqkp6fj+fPniIiIgL29Pezs7PLdTm5hYWFo27Yt9PX1Cx17REQEXF1dYWxsLJW1adMGKpUK169fh7W1NQCgWbNmkMvlhW73dcPTUkRE5aBFixY4d+48mro0Rnq2QEBbXXjU0kVAW12kZws0dXHGuXPn0aJFi1Ldbv369SGTyRAREaFxeUREBKpVqwYrKyup7OUDa2nKfZCXyWRqp5x69eqFx48fY9WqVThz5gzOnDkDoGwmzObex5SUFMyaNQthYWHS6/Lly4iKioJCoSjWNnKfBixNZfU30hZMboiIykmTJk1w/N9TyFQCJ2KVWHw6A8dvK5GpBI7/exJNmjQp9W1Wr14dnTt3xvLly/NcmZWQkICNGzdiwIABkMlkhW6zUaNGOHfunFrZ2bNnSxTno0ePcP36dXz55Zfo2LEjnJ2d8eTJk2K1dfr06TzvnZ2dC1znjTfewPXr11G/fv08Lx0dHTg7OyMuLg7x8fH5bie35s2b48SJE/lejSWXy6FUKtXKnJ2dcfHiRaSmpkplJ0+ehI6ODicOFwGTGyKicnT8+HGoVCosPpOF8Qcy8GNIFlQqFU6cOFFm21y6dCkyMjLg4+OD48ePIy4uDvv370fnzp1Rq1YttVMxhfHJJ5/g2rVrmDx5MiIjI7Ft2zasXbsWAIqUJL2sWrVqqF69On7++WfcuHED//zzDyZMmFCstk6ePInvvvsOkZGRWLZsGbZv345x48YVuM6MGTPw22+/YdasWbh69SoiIiKwZcsWfPnllwCATp06oWHDhvD19cXFixdx4sSJV06iHjt2LJKTkzFw4ECcO3cOUVFRWL9+Pa5fvw7gxWm6S5cu4fr163j48CGysrIwePBgKBQK+Pr64sqVKzhy5Ag+/fRTfPjhh9IpKXo1JjdEROUo59Jvr9ZtEBwcjDe9WquVl4UGDRrg3LlzqFu3Lvr374969ephxIgR6NChA4KDg2FpaVmk9pycnPD7779j586daN68OVasWCEd6A0MDIoVo46ODrZs2YLz58+jadOm+Pzzz/H9998Xq60vvvgC586dQ8uWLfHNN99gwYIF8PHxKXAdHx8f7NmzBwcPHkSrVq3w5ptvYuHChXBwcJDi++OPP5CWlgYPDw98/PHHr0wKq1evjn/++QcpKSnw9vaGm5sbVq1aJZ2e8/f3R6NGjeDu7g4rKyucPHkSRkZGOHDgAB4/foxWrVrhvffeQ8eOHbF06dJi9cXrSiaKMstMCyQnJ8Pc3BxJSUkwMzOr6HCIqApJT09HdHQ0nJycij0P48cff0R6ejq++OIL6OrqQqlUYv78+VAoFPjss89KOeLyM2fOHKxcuRJxcXEVGoejoyPGjx+P8ePHV2gcVDwFfceKcvzm1VJEROUodwKjq6uL//u//6ugaIpv+fLlaNWqFapXr46TJ0/i+++/z3MvFqKKwuSGiIiKLCoqCt988w0eP36MOnXq4IsvvsDUqVMrOiwiAExuiIioGBYuXIiFCxdWdBh5xMTEVHQIVAlwQjERERFpFSY3REREpFWY3BAREZFWYXJDREREWoXJDREREWkVJjdERESkVZjcEBFRibRv377C7gh89OhRyGQyPH36tEK2n1tMTAxkMhnCwsIAVL74XhdMboiItFx+ycfatWthYWFR7vG8Tgf81q1bIz4+Hubm5oWqX5GJojbhTfyIiMpJVFQUnj17lu9yU1NTNGjQoBwjovxkZWVJD7gsCblcDhsbm1KIqGgyMzMhl8vLfbuVBUduiIjKQVRUFBo2bAg3N7d8Xw0bNkRUVFSFxejn54e+ffti1qxZsLKygpmZGUaOHInMzEypTmpqKoYOHQoTExPY2tpi/vz5edpZv3493N3dYWpqChsbG3zwwQd48OABgBenbTp06AAAqFatGmQyGfz8/AAAKpUKgYGBcHJygqGhIVxdXfH777+rtb1v3z40bNgQhoaG6NChQ6HuSCyTybBixQp069YNhoaGqFu3rlq7OaeStm7dCm9vbygUCmzcuBEA8Msvv8DZ2RkKhQKNGzfG8uXL1doOCQlBy5YtoVAo4O7ujgsXLqgt1zRKdfLkSbRv3x5GRkaoVq0afHx88OTJE/j5+eHYsWNYvHgxZDIZZDKZtH/Hjh2Dh4cHDAwMYGtriylTpiA7O1tqs3379hg7dizGjx+PGjVqvPIp6NqOIzdEROUgZ8Sm9ojaMLAzyLM8414G7vx8p8CRnfIQFBQEhUKBo0ePIiYmBsOGDUP16tUxZ84cAMCkSZNw7Ngx7N69GzVr1sS0adMQGhqKFi1aSG1kZWVh9uzZaNSoER48eIAJEybAz88P+/btg729PXbs2IF3330X169fh5mZGQwNDQEAgYGB2LBhA1auXIkGDRrg+PHjGDJkCKysrODt7Y24uDj069cPY8aMwYgRI3Du3Dl88cUXhdqvr776CvPmzcPixYuxfv16DBw4EJcvX4azs7NUZ8qUKZg/f76UrGzcuBEzZszA0qVL0bJlS1y4cAH+/v4wNjaGr68vUlJS0LNnT3Tu3BkbNmxAdHQ0xo0bV2AcYWFh6NixIz766CMsXrwYenp6OHLkCJRKJRYvXozIyEg0bdoUX3/9NQDAysoKd+/eRffu3eHn54fffvsN165dg7+/PxQKBWbOnCm1vW7dOowaNQonT54sVJ9oNfGaSUpKEgBEUlJSRYdCRFVMWlqaCA8PF2lpaUVe9/z58wKAqDeznmi6tmmeV72Z9QQAcf78+VKP29vbW4wbNy5P+Zo1a4S5ubn03tfXV1haWorU1FSpbMWKFcLExEQolUrx7NkzIZfLxbZt26Tljx49EoaGhhrbz3H27FkBQDx79kwIIcSRI0cEAPHkyROpTnp6ujAyMhKnTp1SW3f48OFi0KBBQgghpk6dKlxcXNSWT548OU9buQEQI0eOVCvz9PQUo0aNEkIIER0dLQCIRYsWqdWpV6+e2LRpk1rZ7NmzhZeXlxBCiJ9++klUr15d7fOwYsUKAUBcuHBB474OGjRItGnTJt9YNf2tpk2bJho1aiRUKpVUtmzZMunvkrNey5Yt8223qijoO1aU4zdHboiISOLq6gojIyPpvZeXF1JSUhAXF4enT58iMzMTnp6e0nJLS0s0atRIrY3z589j5syZuHjxIp48eQKVSgUAiI2NhYuLi8bt3rhxA8+fP0fnzp3VyjMzM9GyZUsAQEREhNq2c+IrjNz1vLy8pCuacri7u0v/n5qaips3b2L48OHw9/eXyrOzs6XJwREREWjevDkUCkWh4wkLC8P7779fqJhzREREwMvLCzKZTCpr06YNUlJScOfOHdSpUwcA4ObmVqR2tRmTGyIiLWdmZoakpKQ85U+fPi30VTyFlZqaCh8fH/j4+GDjxo2wsrJCbGwsfHx81Obu5JaSkgIA2Lt3L2rVqqW2zMAg72m8smBsbJwnnlWrVuVJqHR1dYu9jZxTcGXh5fhfd5xQTESk5Ro1aoTQ0NA85aGhoWjYsKFa2cWLF5GWlia9P336NExMTGBvb4969epBX18fZ86ckZY/efIEkZGR0vtr167h0aNHmDdvHtq2bYvGjRtLk4lz5FzFo1QqpTIXFxcYGBggNjYW9evXV3vZ29sDAJydnRESEqLW1unTpwvVB7nrnT59Wm2+TW7W1taws7PDrVu38sTj5OQkxXPp0iWkp6cXOp7mzZsjKCgo3+VyuVytX3K2ExwcDCGEVHby5EmYmpqidu3aBW7vdcXkhohIy40aNQqRkZH47LPPcOnSJVy/fh0LFizA5s2b80zIzczMxPDhwxEeHo59+/YhICAAY8eOhY6ODkxMTDB8+HBMmjQJ//zzD65cuQI/Pz/o6Px3KKlTpw7kcjmWLFmCW7du4c8//8Ts2bPVtuHg4ACZTIY9e/YgMTERKSkpMDU1xcSJE/H5559j3bp1uHnzJkJDQ7FkyRKsW7cOADBy5EhERUVh0qRJuH79OjZt2oS1a9cWqg+2b9+O1atXIzIyEgEBAQgJCcHYsWMLXGfWrFkIDAzEjz/+iMjISFy+fBlr1qzBggULAAAffPABZDIZ/P39pf764YcfCmxz6tSpOHv2LEaPHo1Lly7h2rVrWLFiBR4+fAgAcHR0xJkzZxATE4OHDx9CpVJh9OjRiIuLw6effopr165h9+7dCAgIwIQJE9T6nl5SBvOBKjVOKCai4iqNCcW1R9QW9WbWy/OqPaJ2mU0oFkKIkJAQ0blzZ2FlZSXMzc2Fp6en+OOPP9Tq+Pr6ij59+ogZM2aI6tWrCxMTE+Hv7y/S09OlOs+ePRNDhgwRRkZGwtraWnz33Xd5JsFu2rRJODo6CgMDA+Hl5SX+/PNPtUm2Qgjx9ddfCxsbGyGTyYSvr68QQgiVSiUWLVokGjVqJPT19YWVlZXw8fERx44dk9b766+/RP369YWBgYFo27atWL16daEmFC9btkx07txZGBgYCEdHR7F161Zpec6E4pfjy7Fx40bRokULIZfLRbVq1US7du3Ezp07peXBwcHC1dVVyOVy0aJFC7Fjx44CJxQLIcTRo0dF69athYGBgbCwsBA+Pj7S8uvXr4s333xTGBoaCgAiOjpaWqdVq1ZCLpcLGxsbMXnyZJGVlSW1md+k8aqmtCYUy4R4aZzrNZCcnAxzc3MkJSXBzMysosMhoiokPT0d0dHRcHJyUptEWhg597l5lcjIyAq7kZ+fnx+ePn2KXbt2Vcj2y4pMJsMff/yBvn37VnQo9AoFfceKcvzmhGIionLQoEEDREZG8g7FROWAyQ0RUTlh4kJUPirFTKRly5bB0dERCoUCnp6eeWbDv2znzp1wd3eHhYUFjI2N0aJFC6xfv74coyUi0k5r167VulNSACCE4Cmp10yFJzdbt27FhAkTEBAQgNDQULi6usLHxyfPpYM5LC0tMX36dAQHB+PSpUsYNmwYhg0bhgMHDpRz5ERERFQZVXhys2DBAvj7+2PYsGFwcXHBypUrYWRkhNWrV2us3759e7zzzjtwdnZGvXr1MG7cODRv3hz//vtvOUdORERElVGFJjeZmZk4f/48OnXqJJXp6OigU6dOCA4OfuX6QggEBQXh+vXraNeuncY6GRkZSE5OVnsRERGR9qrQ5Obhw4dQKpWwtrZWK7e2tkZCQkK+6yUlJcHExARyuRw9evTAkiVL8jyPJEdgYCDMzc2lV86dLomIiEg7VfhpqeIwNTVFWFgYzp49izlz5mDChAk4evSoxrpTp05FUlKS9IqLiyvfYImIiKhcVWhyU6NGDejq6uL+/ftq5ffv34eNjU2+6+no6KB+/fpo0aIFvvjiC7z33nsIDAzUWNfAwABmZmZqLyIiqprWrl0LCwuLig4DwIubHr7qKqyjR49CJpPh6dOnhW7X0dERixYtKlFsxSGTyUp8tVz79u0xfvz4AuuUx/5VaHIjl8vh5uam9hAxlUqFoKCgQj/GPmedjIyMsgiRiEgrxMXF4aOPPoKdnR3kcjkcHBwwbtw4PHr0qNxj8fPzg0wmy/O6cePGK9cdMGCA2oM6CysnyahWrZragy4B4OzZs1IMJaHpwN66dWvEx8fD3Nw83/3OeTk6OpZo+/SfCj8tNWHCBKxatQrr1q1DREQERo0ahdTUVAwbNgwAMHToUEydOlWqHxgYiEOHDuHWrVuIiIjA/PnzsX79egwZMqSidoGIqEiEUonUMyFI2rMXqWdCIHI9Bbq03bp1C+7u7oiKisLmzZtx48YNrFy5Uvoh+fjx4zLdviZdu3ZFfHy82ivnadsFMTQ0RM2aNfNdnpmZWeD6pqam+OOPP9TKfv31V9SpU6dwgReRXC6HjY0NZDIZFi9erLa/ALBmzRrp/dmzZ4u9naysrNIKWStUeHIzYMAA/PDDD5gxYwZatGiBsLAw7N+/X5pkHBsbK30IACA1NRWjR49GkyZN0KZNG+zYsQMbNmzAxx9/XFG7QERUaMkHD+JGx06I9fXFvYkTEevrixsdOyH54MEy2+aYMWMgl8tx8OBBeHt7o06dOujWrRsOHz6Mu3fvYvr06QCAa9euwcjICJs2bZLW3bZtGwwNDREeHg7gxb/Jffr0gYmJCczMzNC/f3+1qQUzZ86Ubq7q6OgIc3NzDBw4MM9jJwwMDGBjY6P20tXVxYIFC9CsWTMYGxvD3t4eo0ePRkpKirRe7tNSOdv75ZdfCvXML19fX7VbjaSlpWHLli3w9fVVq5fT7ssWLVqU7+iKn58fjh07hsWLF0sjMTExMWqnpczNzdX2FwAsLCyk91ZWVlJ7z58/x0cffQRTU1PUqVMHP//8s7QsJiYGMpkMW7duhbe3NxQKBTZu3AgA+OWXX+Ds7AyFQoHGjRtj+fLl0nqZmZkYO3YsbG1toVAo4ODgkGdKx8OHD/HOO+/AyMgIDRo0wJ9//qm2/NixY/Dw8ICBgQFsbW0xZcoUZGdn59vfDx48QK9evWBoaAgnJycpzjJX2k/0rOz4VHAiKq6SPBVcCCGSDhwQ4Y2dRXijxuqvxs4ivLGzSDpwoJQjFuLRo0dCJpOJuXPnalzu7+8vqlWrJlQqlRBCiGXLlglzc3Nx+/ZtERcXJ6pVqyYWL14shBBCqVSKFi1aiLfeekucO3dOnD59Wri5uQlvb2+pvYCAAGFiYiL69esnLl++LI4fPy5sbGzEtGnTpDo5Tx/XZOHCheKff/4R0dHRIigoSDRq1EiMGjVKWr5mzRphbm6utj1jY2PRtWtXERoaKi5evKix3Zync1+/fl0YGBiI27dvCyGEWL9+vXB1dRV//PGHePmQGBAQIFxdXfPE5uDgoHE/nj59Kry8vIS/v7+Ij48X8fHxIjs7W+NTwXMAyPNkdiGEcHBwEJaWlmLZsmUiKipKBAYGCh0dHXHt2jUhxH9PMXd0dBQ7duwQt27dEvfu3RMbNmwQtra2UtmOHTuEpaWlWLt2rRBCiO+//17Y29uL48ePi5iYGHHixAmxadMmtXhq164tNm3aJKKiosRnn30mTExMxKNHj4QQQty5c0cYGRmJ0aNHi4iICPHHH3+IGjVqiICAAKmN3E8n79atm3B1dRXBwcHi3LlzonXr1sLQ0FAsXLhQ49+ptJ4KzmdLERGVA6FU4v7cQEAIDQsFIJPh/txAmHbsCJmubqltNyoqCkIIODs7a1zu7OyMJ0+eIDExETVr1sTo0aOxb98+DBkyBHK5HK1atcKnn34KAAgKCsLly5cRHR0t3Vbjt99+Q5MmTXD27Fm0atUKwIt5kGvXroWpqSkA4MMPP0RQUBDmzJkjbXfPnj0wMTGR3nfr1g3bt29Xm7Pi6OiIb775BiNHjlQbgcgtMzMTv/32m9rIR35q1qyJbt26Ye3atZgxYwZWr16Njz766JXrvYq5uTnkcjmMjIwKvCCmsLp3747Ro0cDACZPnoyFCxfiyJEjaNSokVRn/Pjx6Nevn/Q+ICAA8+fPl8qcnJwQHh6On376Cb6+voiNjUWDBg3w1ltvQSaTwcHBIc92/fz8MGjQIADA3Llz8eOPPyIkJARdu3bF8uXLYW9vj6VLl0Imk6Fx48a4d+8eJk+ejBkzZkBHR/1kUGRkJP7++2+EhIRIn41ff/01389iaWJyQ0RUDp6fO4/sAu7fBSGQnZCA5+fOw9jTo9S3LzQlVflYvXo1GjZsCB0dHVy9elWaaBsREQF7e3u1+4W5uLjAwsICERER0gHM0dFRSmwAwNbWNs8jdTp06IAVK1ZI742NjQEAhw8fRmBgIK5du4bk5GRkZ2cjPT0dz58/h5GRkcZ4HRwcCpXY5Pjoo48wbtw4DBkyBMHBwdi+fTtOnDhR6PXLQ/PmzaX/l8lksLGxydOH7u7u0v+npqbi5s2bGD58OPz9/aXy7OxsmJubA3iRuHTu3BmNGjVC165d0bNnT3Tp0iXf7RobG8PMzEzabkREBLy8vNQmXrdp0wYpKSm4c+dOnnlLERER0NPTg5ubm1TWuHHjcrnarcLn3BARvQ6yExNLtV5h1a9fHzKZDBERERqXR0REoFq1amrJwcWLF5GamorU1FS1OY+Fpa+vr/ZeJpNBpVKplRkbG6N+/frSy9bWFjExMejZsyeaN2+OHTt24Pz581i2bBmAgicK5yRGhdWtWzekpaVh+PDh6NWrF6pXr56njo6OTp6EsDwn7Ra2D3PkzEtatWoVwsLCpNeVK1dw+vRpAMAbb7yB6OhozJ49G2lpaejfvz/ee++9Im+3KmByQ0RUDvQKObJQ2HqFVb16dXTu3BnLly9HWlqa2rKEhARs3LgRAwYMkH6NP378GH5+fpg+fTr8/PwwePBgaT1nZ2fExcWp3Qw1PDwcT58+hYuLS4ljPX/+PFQqFebPn48333wTDRs2xL1790rcbm56enoYOnQojh49mu8pKSsrKyQkJKglOGFhYQW2K5fLoSzjK9/yY21tDTs7O9y6dUstaaxfv77aVWhmZmYYMGAAVq1aha1bt2LHjh2FvlrO2dkZwcHBan1y8uRJmJqaonbt2nnqN27cGNnZ2Th//rxUdv369SLd86e4mNwQEZUDI3c36NnYAPndS0Umg56NDYzc3TQvL4GlS5ciIyMDPj4+OH78OOLi4rB//3507twZtWrVUpsLM3LkSNjb2+PLL7/EggULoFQqMXHiRABAp06d0KxZMwwePBihoaEICQnB0KFD4e3trXaKpLjq16+PrKwsLFmyBLdu3cL69euxcuXKEreryezZs5GYmAgfHx+Ny9u3b4/ExER89913uHnzJpYtW4a///67wDYdHR1x5swZxMTE4OHDh+U+4jFr1iwEBgbixx9/RGRkJC5fvow1a9ZgwYIFAF48qHrz5s24du0aIiMjsX37dtjY2BT6NNHo0aMRFxeHTz/9FNeuXcPu3bsREBCACRMm5JlvA0A6/fXJJ5/gzJkzOH/+PD7++GMYGhqW5m5rxOSGiKgcyHR1YT3tf/fsyp3g/O+99bSppTqZOEeDBg1w7tw51K1bF/3790e9evUwYsQIdOjQAcHBwbC0tATwYnLwvn37sH79eujp6cHY2BgbNmzAqlWr8Pfff0Mmk2H37t2oVq0a2rVrh06dOqFu3brYunVrqcTp6uqKBQsW4Ntvv0XTpk2xcePGfO8+X1JyuRw1atTI98Z9zs7OWL58OZYtWwZXV1eEhIRISV5+Jk6cCF1dXbi4uMDKygqxsbFlEXq+Pv74Y/zyyy9Ys2YNmjVrBm9vb6xdu1YauTE1NcV3330Hd3d3tGrVCjExMdi3b5/GxESTWrVqYd++fQgJCYGrqytGjhyJ4cOH48svv8x3nTVr1sDOzg7e3t7o168fRowYUeB9ikqLTBRllpkWSE5Ohrm5OZKSkvgoBiIqkvT0dERHRxfqfir5ST54EPfnBqpNLtazsYH1tKkwyzW5k+h1U9B3rCjHb14tRURUjsy6dIFpx44vrp5KTISelRWM3N3KZMSG6HXF5IaIqJzJdHXL5HJvInqBc26IiIhIqzC5ISIiIq3C5IaIiIi0CpMbIiIi0ipMboiIiEirMLkhIiIircLkhoiIiLQKkxsiIiqR9u3bY/z48RWy7aNHj0Imk5XLwxgLIyYmBjKZTHrIZmWL73XB5IaISMvll3ysXbu20A9NLE2v0wG/devWiI+Ph7m5eaHqV2SiqE14h2IionISFRWFZ8+e5bvc1NQUDRo0KMeIKD9ZWVnQ19cvcTtyuRw2NjalEFHRZGZmQi6Xl/t2KwuO3BARlYOoqCg0bNgQbm5u+b4aNmyIqKioCovRz88Pffv2xaxZs2BlZQUzMzOMHDkSmZmZUp3U1FQMHToUJiYmsLW1xfz58/O0s379eri7u8PU1BQ2Njb44IMP8ODBAwAvTtt06NABAFCtWjXIZDL4+fkBAFQqFQIDA+Hk5ARDQ0O4urri999/V2t73759aNiwIQwNDdGhQwfExMS8cr9kMhlWrFiBbt26wdDQEHXr1lVrN+dU0tatW+Ht7Q2FQoGNGzcCAH755Rc4OztDoVCgcePGWL58uVrbISEhaNmyJRQKBdzd3XHhwgW15ZpGqU6ePIn27dvDyMgI1apVg4+PD548eQI/Pz8cO3YMixcvhkwmg0wmk/bv2LFj8PDwgIGBAWxtbTFlyhRkZ2dLbbZv3x5jx47F+PHjUaNGDfj4+LyyX7QZR26IiMpBzoiN79tTYWNRJ8/yhKexWPdPYIEjO+UhKCgICoUCR48eRUxMDIYNG4bq1atjzpw5AIBJkybh2LFj2L17N2rWrIlp06YhNDQULVq0kNrIysrC7Nmz0ahRIzx48AATJkyAn58f9u3bB3t7e+zYsQPvvvsurl+/DjMzMxgaGgIAAgMDsWHDBqxcuRINGjTA8ePHMWTIEFhZWcHb2xtxcXHo168fxowZgxEjRuDcuXP44osvCrVfX331FebNm4fFixdj/fr1GDhwIC5fvgxnZ2epzpQpUzB//nwpWdm4cSNmzJiBpUuXomXLlrhw4QL8/f1hbGwMX19fpKSkoGfPnujcuTM2bNiA6OhojBs3rsA4wsLC0LFjR3z00UdYvHgx9PT0cOTIESiVSixevBiRkZFo2rQpvv76awCAlZUV7t69i+7du8PPzw+//fYbrl27Bn9/fygUCsycOVNqe926dRg1ahROnjxZqD7RauI1k5SUJACIpKSkUm03W6kSp248FLsu3BGnbjwU2UpVqbZPRBUvLS1NhIeHi7S0tCKve/78eQFATO63Qiz9JCjPa3K/FQKAOH/+fKnH7e3tLcaNG5enfM2aNcLc3Fx67+vrKywtLUVqaqpUtmLFCmFiYiKUSqV49uyZkMvlYtu2bdLyR48eCUNDQ43t5zh79qwAIJ49eyaEEOLIkSMCgHjy5IlUJz09XRgZGYlTp06prTt8+HAxaNAgIYQQU6dOFS4uLmrLJ0+enKet3ACIkSNHqpV5enqKUaNGCSGEiI6OFgDEokWL1OrUq1dPbNq0Sa1s9uzZwsvLSwghxE8//SSqV6+u9nlYseLF3/HChQsa93XQoEGiTZs2+caq6W81bdo00ahRI6FS/XdcWbZsmfR3yVmvZcuW+bZbVRT0HSvK8ZsjN6Vg/5V4zPorHPFJ6VKZrbkCAb1c0LWpbQVGRkRUNK6urjAyMpLee3l5ISUlBXFxcXj69CkyMzPh6ekpLbe0tESjRo3U2jh//jxmzpyJixcv4smTJ1CpVACA2NhYuLi4aNzujRs38Pz5c3Tu3FmtPDMzEy1btgQAREREqG07J77CyF3Py8tLuqIph7u7u/T/qampuHnzJoYPHw5/f3+pPDs7W5ocHBERgebNm0OhUBQ6nrCwMLz//vuFijlHREQEvLy8IJPJpLI2bdogJSUFd+7cQZ06L0YC3dzcitSuNmNyU0L7r8Rj1IZQiFzlCUnpGLUhFCuGvMEEh4gqlJmZGZKSkvKUP336tNBX8RRWamoqfHx84OPjg40bN8LKygqxsbHw8fFRm7uTW0pKCgBg7969qFWrltoyAwODUo0xP8bGxnniWbVqVZ6ESldXt9jbyDkFVxZejv91xwnFJaBUCcz6KzxPYgNAKpv1VziUKk01iIjKR6NGjRAaGpqnPDQ0FA0bNlQru3jxItLS0qT3p0+fhomJCezt7VGvXj3o6+vjzJkz0vInT54gMjJSen/t2jU8evQI8+bNQ9u2bdG4cWNpMnGOnKt4lEqlVObi4gIDAwPExsaifv36ai97e3sAgLOzM0JCQtTaOn36dKH6IHe906dPq823yc3a2hp2dna4detWnnicnJykeC5duoT09P9G7V8VT/PmzREUFJTvcrlcrtYvOdsJDg6GEP8dS06ePAlTU1PUrl27wO29rpjclEBI9GO1U1G5CQDxSekIiX5cfkEREeUyatQoREZG4rPPPsOlS5dw/fp1LFiwAJs3b84zITczMxPDhw9HeHg49u3bh4CAAIwdOxY6OjowMTHB8OHDMWnSJPzzzz+4cuUK/Pz8oKPz36GkTp06kMvlWLJkCW7duoU///wTs2fPVtuGg4MDZDIZ9uzZg8TERKSkpMDU1BQTJ07E559/jnXr1uHmzZsIDQ3FkiVLsG7dOgDAyJEjERUVhUmTJuH69evYtGkT1q5dW6g+2L59O1avXo3IyEgEBAQgJCQEY8eOLXCdWbNmITAwED/++CMiIyNx+fJlrFmzBgsWLAAAfPDBB5DJZPD395f664cffiiwzalTp+Ls2bMYPXo0Ll26hGvXrmHFihV4+PAhAMDR0RFnzpxBTEwMHj58CJVKhdGjRyMuLg6ffvoprl27ht27dyMgIAATJkxQ63v6D3ulBB48yz+xKU49ItJ+CU9jEZcYmeeV8DS2zLZZt25dHD9+HNeuXUOnTp3g6emJbdu2Yfv27ejatata3Y4dO6JBgwZo164dBgwYgN69e6tdkfP999+jbdu26NWrFzp16oS33npLba6HlZUV1q5di+3bt8PFxQXz5s3Lc8CvVasWZs2ahSlTpsDa2lpKMmbPno2vvvoKgYGBcHZ2RteuXbF3715ppKROnTrYsWMHdu3aBVdXV6xcuRJz584tVB/MmjULW7ZsQfPmzfHbb79h8+bN+c7/yfHxxx/jl19+wZo1a9CsWTN4e3tj7dq1UjwmJib466+/cPnyZbRs2RLTp0/Ht99+W2CbDRs2xMGDB3Hx4kV4eHjAy8sLu3fvhp7ei1kiEydOhK6uLlxcXKRTerVq1cK+ffsQEhICV1dXjBw5EsOHD8eXX35ZqH1/HcnEy+Ncr4Hk5GSYm5sjKSkJZmZmJWor+OYjDFr16iHRzf5vwqte9RJti4gqXnp6OqKjo+Hk5KQ2ibQwcu5z8yqRkZEVdiM/Pz8/PH36FLt27aqQ7ZcVmUyGP/74A3379q3oUOgVCvqOFeX4zQnFJeDhZAlbcwUSktI1zruRAbAxV8DDybK8QyOiSqZBgwaIjIzkHYqJygGTmxLQ1ZEhoJcLRm0IhQxQS3ByLtgL6OUCXR2ZhrWJ6HXDxIWofDC5KaGuTW2xYsgbee5zY8P73BBRFVPYyblVzWs2+4LA5KZUdG1qi84uNgiJfowHz9JR0/TFqSiO2BAREZU/JjelRFdHxknDRERElQAvBSciKiKe5iAqG6X13WJyQ0RUSDm33S/oMQJEVHw5362SPOIC4GkpIqJC09PTg5GRERITE6Gvr8+7wxKVIpVKhcTERBgZGUk3NSwuJjdERIUkk8lga2uL6Oho3L59u6LDIdI6Ojo6qFOnjtoT0IuDyQ0RURHI5XI0aNCAp6aIyoBcLi+VEVEmN0RERaSjo1Pkxy8QUfnhCWMiIiLSKkxuiIiISKswuSEiIiKt8trNucm5QVBycnIFR0JERESFlXPcLsyN/l675ObZs2cAAHt7+wqOhIiIiIrq2bNnMDc3L7COTLxm9xFXqVS4d+8eTE1NS3wdfW7Jycmwt7dHXFwczMzMSrXt1x37tmyxf8sO+7ZssX/LTmXrWyEEnj17Bjs7u1deLv7ajdzo6Oigdu3aZboNMzOzSvFB0Ebs27LF/i077Nuyxf4tO5Wpb181YpODE4qJiIhIqzC5ISIiIq3C5KYUGRgYICAgAAYGBhUditZh35Yt9m/ZYd+WLfZv2anKffvaTSgmIiIi7caRGyIiItIqTG6IiIhIqzC5ISIiIq3C5IaIiIi0CpObAixbtgyOjo5QKBTw9PRESEhIgfW3b9+Oxo0bQ6FQoFmzZti3b5/aciEEZsyYAVtbWxgaGqJTp06Iiooqy12o1Eqzf7OysjB58mQ0a9YMxsbGsLOzw9ChQ3Hv3r2y3o1KqbQ/uy8bOXIkZDIZFi1aVMpRVx1l0b8RERHo3bs3zM3NYWxsjFatWiE2NrasdqHSKu2+TUlJwdixY1G7dm0YGhrCxcUFK1euLMtdqNSK0r9Xr17Fu+++C0dHxwK/80X9m5ULQRpt2bJFyOVysXr1anH16lXh7+8vLCwsxP379zXWP3nypNDV1RXfffedCA8PF19++aXQ19cXly9flurMmzdPmJubi127domLFy+K3r17CycnJ5GWllZeu1VplHb/Pn36VHTq1Els3bpVXLt2TQQHBwsPDw/h5uZWnrtVKZTFZzfHzp07haurq7CzsxMLFy4s4z2pnMqif2/cuCEsLS3FpEmTRGhoqLhx44bYvXt3vm1qq7LoW39/f1GvXj1x5MgRER0dLX766Sehq6srdu/eXV67VWkUtX9DQkLExIkTxebNm4WNjY3G73xR2ywvTG7y4eHhIcaMGSO9VyqVws7OTgQGBmqs379/f9GjRw+1Mk9PT/HJJ58IIYRQqVTCxsZGfP/999Lyp0+fCgMDA7F58+Yy2IPKrbT7V5OQkBABQNy+fbt0gq4iyqpv79y5I2rVqiWuXLkiHBwcXtvkpiz6d8CAAWLIkCFlE3AVUhZ926RJE/H111+r1XnjjTfE9OnTSzHyqqGo/fuy/L7zJWmzLPG0lAaZmZk4f/48OnXqJJXp6OigU6dOCA4O1rhOcHCwWn0A8PHxkepHR0cjISFBrY65uTk8PT3zbVNblUX/apKUlASZTAYLC4tSibsqKKu+ValU+PDDDzFp0iQ0adKkbIKvAsqif1UqFfbu3YuGDRvCx8cHNWvWhKenJ3bt2lVm+1EZldVnt3Xr1vjzzz9x9+5dCCFw5MgRREZGokuXLmWzI5VUcfq3ItosLUxuNHj48CGUSiWsra3Vyq2trZGQkKBxnYSEhALr5/y3KG1qq7Lo39zS09MxefJkDBo0qNI88K08lFXffvvtt9DT08Nnn31W+kFXIWXRvw8ePEBKSgrmzZuHrl274uDBg3jnnXfQr18/HDt2rGx2pBIqq8/ukiVL4OLigtq1a0Mul6Nr165YtmwZ2rVrV/o7UYkVp38ros3S8to9FZy0X1ZWFvr37w8hBFasWFHR4VR558+fx+LFixEaGgqZTFbR4WgdlUoFAOjTpw8+//xzAECLFi1w6tQprFy5Et7e3hUZXpW3ZMkSnD59Gn/++SccHBxw/PhxjBkzBnZ2dnlGfUh7cORGgxo1akBXVxf3799XK79//z5sbGw0rmNjY1Ng/Zz/FqVNbVUW/ZsjJ7G5ffs2Dh069FqN2gBl07cnTpzAgwcPUKdOHejp6UFPTw+3b9/GF198AUdHxzLZj8qqLPq3Ro0a0NPTg4uLi1odZ2fn1+pqqbLo27S0NEybNg0LFixAr1690Lx5c4wdOxYDBgzADz/8UDY7UkkVp38ros3SwuRGA7lcDjc3NwQFBUllKpUKQUFB8PLy0riOl5eXWn0AOHTokFTfyckJNjY2anWSk5Nx5syZfNvUVmXRv8B/iU1UVBQOHz6M6tWrl80OVGJl0bcffvghLl26hLCwMOllZ2eHSZMm4cCBA2W3M5VQWfSvXC5Hq1atcP36dbU6kZGRcHBwKOU9qLzKom+zsrKQlZUFHR31Q52urq40Yva6KE7/VkSbpaZCpzNXYlu2bBEGBgZi7dq1Ijw8XIwYMUJYWFiIhIQEIYQQH374oZgyZYpU/+TJk0JPT0/88MMPIiIiQgQEBGi8FNzCwkLs3r1bXLp0SfTp0+e1vhS8NPs3MzNT9O7dW9SuXVuEhYWJ+Ph46ZWRkVEh+1hRyuKzm9vrfLVUWfTvzp07hb6+vvj5559FVFSUWLJkidDV1RUnTpwo9/2rSGXRt97e3qJJkybiyJEj4tatW2LNmjVCoVCI5cuXl/v+VbSi9m9GRoa4cOGCuHDhgrC1tRUTJ04UFy5cEFFRUYVus6IwuSnAkiVLRJ06dYRcLhceHh7i9OnT0jJvb2/h6+urVn/btm2iYcOGQi6XiyZNmoi9e/eqLVepVOKrr74S1tbWwsDAQHTs2FFcv369PHalUirN/o2OjhYANL6OHDlSTntUeZT2Zze31zm5EaJs+vfXX38V9evXFwqFQri6uopdu3aV9W5USqXdt/Hx8cLPz0/Y2dkJhUIhGjVqJObPny9UKlV57E6lU5T+ze/fVW9v70K3WVFkQghRQYNGRERERKWOc26IiIhIqzC5ISIiIq3C5IaIiIi0CpMbIiIi0ipMboiIiEirMLkhIiIircLkhoiIiLQKkxsiKrT27dtj/Pjx0ntHR0csWrSozLYXExMDmUyGsLCwMtuGTCbDrl27yjSGR48eoWbNmoiJiSl2GzlmzpyJFi1aFGmd58+f491334WZmRlkMhmePn2KN998Ezt27ChxPESVEZMbokrOz88PMpksz6tr164VHRrOnj2LESNGVHQYuHr1Kvr37w8rKysYGBigYcOGmDFjBp4/f17RoQEA5syZgz59+kgPGi1JwjRx4sQ8z1N6lXXr1uHEiRM4deoU4uPjYW5uji+//BJTpkx57Z6xRK8HJjdEVUDXrl0RHx+v9tq8eXNFhwUrKysYGRlVaAynT5+Gp6cnMjMzsXfvXkRGRmLOnDlYu3YtOnfujMzMzAqN7/nz5/j1118xfPjwUmnPxMSkyA+FvXnzJpydndG0aVPY2NhAJpOhW7duePbsGf7+++9SiYuoMmFyQ1QFGBgYwMbGRu1VrVo1aXlUVBTatWsHhUIBFxcXHDp0SO10y9GjR6XTETnCwsIgk8mkUyWPHj3CoEGDUKtWLRgZGaFZs2avTKBePi21du1ajSNMM2fOlOr/8ssvcHZ2hkKhQOPGjbF8+XK19kJCQtCyZUsoFAq4u7vjwoULBW5fCIHhw4fD2dkZO3fuhIeHBxwcHPD+++/jr7/+QnBwMBYuXFhgP+X2qhiePHmCwYMHw8rKCoaGhmjQoAHWrFmTb4z79u2DgYEB3nzzzQL3pbByn5by8/ND37598cMPP8DW1hbVq1fHmDFjkJWVBeDFqcT58+fj+PHjkMlkaN++PYAXT8bu3r07tmzZUipxEVUmehUdABGVjEqlQr9+/WBtbY0zZ84gKSlJbV5MYaWnp8PNzQ2TJ0+GmZkZ9u7diw8//BD16tWDh4fHK9cfMGCA2qmyo0eP4sMPP0SbNm0AABs3bsSMGTOwdOlStGzZEhcuXIC/vz+MjY3h6+uLlJQU9OzZE507d8aGDRsQHR2NcePGFbjNsLAwhIeHY9OmTdDRUf+t5urqik6dOmHz5s2YPHlyofqpMDF89dVXCA8Px99//40aNWrgxo0bSEtLyzfGEydOwM3N7ZX9VxJHjhyBra0tjhw5ghs3bmDAgAFo0aIF/P39sXPnTkyZMgVXrlzBzp07IZfLpfU8PDwwb968Mo2NqCIwuSGqAvbs2QMTExO1smnTpmHatGk4fPgwrl27hgMHDsDOzg4AMHfuXHTr1q1I26hVqxYmTpwovf/0009x4MABbNu2rVDJjaGhIQwNDQG8OA0yZswYzJ07F507dwYABAQEYP78+ejXrx8AwMnJCeHh4fjpp5/g6+uLTZs2QaVS4ddff4VCoUCTJk1w584djBo1Kt9tRkZGAgCcnZ01Lnd2dsa///4LAIXqp8LEEBsbi5YtW8Ld3R0ApHk0+bl9+7a0vbJSrVo1LF26FLq6umjcuDF69OiBoKAg+Pv7w9LSEkZGRpDL5bCxsVFbz87ODnFxcVCpVHmSQ6KqjMkNURXQoUMHrFixQq3M0tISABAREQF7e3u1A6iXl1eRt6FUKjF37lxs27YNd+/eRWZmJjIyMoo8pyYpKQk9e/ZEjx49MGnSJABAamoqbt68ieHDh8Pf31+qm52dDXNzc2k/mjdvDoVCUeT9EEK8sk5h+qkwMYwaNQrvvvsuQkND0aVLF/Tt2xetW7fOd7tpaWlq7ZWFJk2aQFdXV3pva2uLy5cvv3I9Q0NDqFQqZGRkSIkpkTZgckNUBRgbG6N+/frFXj/nV/nLSUDOnIwc33//PRYvXoxFixahWbNmMDY2xvjx44s0IVepVGLAgAEwMzPDzz//LJWnpKQAAFatWgVPT0+1dV4+KBdVw4YNAbxISlq2bJlneUREhFSntHTr1g23b9/Gvn37cOjQIXTs2BFjxozBDz/8oLF+jRo18OTJk1KNITd9fX219zKZrFBXQT1+/BjGxsZMbEjrcBySqIpzdnZGXFwc4uPjpbLTp0+r1bGysgIAtTq5L0M+efIk+vTpgyFDhsDV1RV169aVTvsU1ueff47Lly9j165daqMV1tbWsLOzw61bt1C/fn21l5OTk7Qfly5dQnp6er77kVuLFi3QuHFjLFy4MM/B/OLFizh8+DAGDRoktf+qfipsDFZWVvD19cWGDRuwaNEitUQut5YtWyI8PLzA/agoV65c0ZgUElV1TG6IqoCMjAwkJCSovR4+fAgA6NSpExo2bAhfX19cvHgRJ06cwPTp09XWr1+/Puzt7TFz5kxERUVh7969mD9/vlqdBg0a4NChQzh16hQiIiLwySef4P79+4WOcc2aNVi+fDlWrlwJmUwmxZkzajNr1iwEBgbixx9/RGRkJC5fvow1a9ZgwYIFAIAPPvgAMpkM/v7+CA8Px759+/IdDckhk8nw66+/Ijw8HO+++y5CQkIQGxuL7du3o1evXvDy8pImDRemnwoTw4wZM7B7927cuHEDV69exZ49e/Kd8wMAPj4+uHr1qsbRm+vXryMsLEztlXtErSydOHECXbp0KbftEZUXJjdEVcD+/ftha2ur9nrrrbcAvDjl9McffyAtLQ0eHh74+OOPMWfOHLX19fX1sXnzZly7dg3NmzfHt99+i2+++Uatzpdffok33ngDPj4+aN++PWxsbNC3b99Cx3js2DEolUr07t1bLc6c5ODjjz/GL7/8gjVr1qBZs2bw9vbG2rVrpZEbExMT/PXXX7h8+TJatmyJ6dOn49tvv33ldlu3bo3Tp09DV1cX3bp1Q/369TF16lT4+vri0KFDMDAwKHQ/FSYGuVyOqVOnonnz5mjXrh10dXULvJy6WbNmeOONN7Bt27Y8ywYOHIiWLVuqvYqSUJbE3bt3cerUKQwbNqxctkdUnmSiMDPxiKjKkclk+OOPP4qUoFDZ2Lt3LyZNmoQrV65UmquSJk+ejCdPnhR4So2oquKEYiKiMtajRw9ERUXh7t27sLe3r+hwAAA1a9bEhAkTKjoMojLBkRsiLcWRm6qpSZMmuH37tsZlP/30EwYPHlzOERFVPUxuiIgqkdu3b+c7qdja2hqmpqblHBFR1cPkhoiIiLRK5ZjZRkRERFRKmNwQERGRVmFyQ0RERFqFyQ0RERFpFSY3REREpFWY3BAREZFWYXJDREREWoXJDREREWmV/wdf2mXVYpmqYAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fpred_inf_base.plot_frontier(new_plot=False,name_frontier='OxonFair+')\n", + "fpred_inf.plot_frontier(new_plot=False, show_original=False,name_frontier='OxonFair MultiThreshold')\n", + "plt.title('Eodds with inferred groups (Validation)')\n", + "#plt.savefig('eodd_val.pdf')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we compare against fairlearn when enforcing equalized odds." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/miniconda3/envs/ag/lib/python3.10/site-packages/fairlearn/reductions/_moments/utility_parity.py:214: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", + "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", + "A typical example is when you are setting values in a column of a DataFrame, like:\n", + "\n", + "df[\"col\"][row_indexer] = value\n", + "\n", + "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + "\n", + " self.pos_basis[i][\"+\", e, g] = 1\n", + "/opt/miniconda3/envs/ag/lib/python3.10/site-packages/fairlearn/reductions/_moments/utility_parity.py:215: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", + "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", + "A typical example is when you are setting values in a column of a DataFrame, like:\n", + "\n", + "df[\"col\"][row_indexer] = value\n", + "\n", + "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + "\n", + " self.neg_basis[i][\"-\", e, g] = 1\n", + "/opt/miniconda3/envs/ag/lib/python3.10/site-packages/fairlearn/reductions/_moments/utility_parity.py:214: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", + "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", + "A typical example is when you are setting values in a column of a DataFrame, like:\n", + "\n", + "df[\"col\"][row_indexer] = value\n", + "\n", + "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + "\n", + " self.pos_basis[i][\"+\", e, g] = 1\n", + "/opt/miniconda3/envs/ag/lib/python3.10/site-packages/fairlearn/reductions/_moments/utility_parity.py:215: FutureWarning: ChainedAssignmentError: behaviour will change in pandas 3.0!\n", + "You are setting values through chained assignment. Currently this works in certain cases, but when using Copy-on-Write (which will become the default behaviour in pandas 3.0) this will never work to update the original DataFrame or Series, because the intermediate object on which we are setting values will behave as a copy.\n", + "A typical example is when you are setting values in a column of a DataFrame, like:\n", + "\n", + "df[\"col\"][row_indexer] = value\n", + "\n", + "Use `df.loc[row_indexer, \"col\"] = values` instead, to perform the assignment in a single step and ensure this keeps updating the original `df`.\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + "\n", + " self.neg_basis[i][\"-\", e, g] = 1\n" + ] + }, + { + "data": { + "text/html": [ + "
ExponentiatedGradient(constraints=<fairlearn.reductions._moments.utility_parity.EqualizedOdds object at 0x32ee43b80>,\n",
+       "                      estimator=XGBClassifier(base_score=None, booster=None,\n",
+       "                                              callbacks=None,\n",
+       "                                              colsample_bylevel=None,\n",
+       "                                              colsample_bynode=None,\n",
+       "                                              colsample_bytree=None,\n",
+       "                                              device=None,\n",
+       "                                              early_stopping_rounds=None,\n",
+       "                                              enable_categorical=False,\n",
+       "                                              eval_metric=None,\n",
+       "                                              feature_types=None, g...\n",
+       "                                              importance_type=None,\n",
+       "                                              interaction_constraints=None,\n",
+       "                                              learning_rate=None, max_bin=None,\n",
+       "                                              max_cat_threshold=None,\n",
+       "                                              max_cat_to_onehot=None,\n",
+       "                                              max_delta_step=None,\n",
+       "                                              max_depth=None, max_leaves=None,\n",
+       "                                              min_child_weight=None,\n",
+       "                                              missing=nan,\n",
+       "                                              monotone_constraints=None,\n",
+       "                                              multi_strategy=None,\n",
+       "                                              n_estimators=None, n_jobs=None,\n",
+       "                                              num_parallel_tree=None,\n",
+       "                                              random_state=None, ...),\n",
+       "                      nu=0.0010112214200075562)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "ExponentiatedGradient(constraints=,\n", + " estimator=XGBClassifier(base_score=None, booster=None,\n", + " callbacks=None,\n", + " colsample_bylevel=None,\n", + " colsample_bynode=None,\n", + " colsample_bytree=None,\n", + " device=None,\n", + " early_stopping_rounds=None,\n", + " enable_categorical=False,\n", + " eval_metric=None,\n", + " feature_types=None, g...\n", + " importance_type=None,\n", + " interaction_constraints=None,\n", + " learning_rate=None, max_bin=None,\n", + " max_cat_threshold=None,\n", + " max_cat_to_onehot=None,\n", + " max_delta_step=None,\n", + " max_depth=None, max_leaves=None,\n", + " min_child_weight=None,\n", + " missing=nan,\n", + " monotone_constraints=None,\n", + " multi_strategy=None,\n", + " n_estimators=None, n_jobs=None,\n", + " num_parallel_tree=None,\n", + " random_state=None, ...),\n", + " nu=0.0010112214200075562)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from fairlearn.reductions import ExponentiatedGradient, EqualizedOdds\n", + "mitagator = ExponentiatedGradient(xgboost.XGBClassifier(), EqualizedOdds())\n", + "mitagator.fit(X=train['data'],y=train['target'],sensitive_features=train['groups']==' Female')" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "fl=fair.performance.evaluate_fairness(test['target'],mitagator.predict(test['data']),test['groups'], metrics={'a':gm.accuracy, 'b':gm.equalized_odds_max})\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we generate a table of results." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
OriginalOxonFair MultiOxonFair +FairLearn
Accuracy0.8757250.8723810.8708110.873132
Equalized Odds (L_inf)0.0892020.0247070.0242920.041808
\n", + "
" + ], + "text/plain": [ + " Original OxonFair Multi OxonFair + FairLearn\n", + "Accuracy 0.875725 0.872381 0.870811 0.873132\n", + "Equalized Odds (L_inf) 0.089202 0.024707 0.024292 0.041808" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results = pd.concat((fpred_inf.evaluate_fairness(test,metrics={'a':gm.accuracy, 'b':gm.equalized_odds_max})['original'],\n", + " fpred_inf.evaluate_fairness(test,metrics={'a':gm.accuracy, 'b':gm.equalized_odds_max})['updated'],\n", + " fpred_inf_base.evaluate_fairness(test,metrics={'a':gm.accuracy, 'b':gm.equalized_odds_max})['updated'],\n", + " fl),axis=1,keys=['Original','OxonFair Multi','OxonFair +','FairLearn'])\n", + "results" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And plot a comparision on test data." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fpred_inf_base.plot_frontier(test,name_frontier='OxonFair+')\n", + "fpred_inf.plot_frontier(test,name_frontier='OxonFair MultiThreshold',new_plot=False, show_original=False,)\n", + "plt.title('Eodds with inferred groups (Test)')\n", + "plt.scatter(fl['Equalized Odds (L_inf)'],fl['Accuracy'], label='Fairlearn',marker='x')\n", + "plt.legend()\n", + "#plt.savefig('eodd_test.pdf')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ag", + "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.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 49e4b7a3952662f905b91291a57fd1bbaf0e17fe Mon Sep 17 00:00:00 2001 From: Chris Russell Date: Sun, 27 Oct 2024 22:07:06 +0000 Subject: [PATCH 5/6] compress notebook --- examples/equalized_odds.ipynb | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/examples/equalized_odds.ipynb b/examples/equalized_odds.ipynb index d0d84bc..60cbc20 100644 --- a/examples/equalized_odds.ipynb +++ b/examples/equalized_odds.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "This notebook demonstrates how to use inferred groups to implement the muliple thresholds per group as used by the original paper on equalized odds\n", + "This notebook demonstrates how to use inferred groups to implement the multiple thresholds per group as used by the original paper on equalized odds\n", "\n", "Equality of opportunity in supervised learning\n", "\n", @@ -46,7 +46,7 @@ "source": [ "We will load the adult dataset, train XGBoost on it, and a fair baseline method using one threshold per group.\n", "\n", - "For direct comparision with Cruz and Hardt, and fairlearn, we use the L_infinity version of equalized odds given by `gm.equalized_odds_max` -- corresponding to the maximum violation, rather than more stable average violation provided by `gm.equalized_odds`." + "For direct comparison with Cruz and Hardt, and fairlearn, we use the L_infinity version of equalized odds given by `gm.equalized_odds_max` -- corresponding to the maximum violation, rather than more stable average violation provided by `gm.equalized_odds`." ] }, { @@ -67,7 +67,7 @@ "We now define 3 variants of thresholding. \n", "\n", "1. `random_group_fn` randomly assigns one of two thresholds to each member of a particular group as in Hardt et al., and Cruz and Hardt.\n", - "2. `groups_fn` is a determenistic version of the same.\n", + "2. `groups_fn` is a deterministic version of the same.\n", "3. `inferred_group_fun` is a modified version of 2. that works when group labels are not available at test time by using a second classifier to infer group membership." ] }, @@ -121,7 +121,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmoAAAHHCAYAAAAPuHTSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAC9G0lEQVR4nOzdd1xT1/sH8E8SIBA2CgQVARFRnKBCcaKiWJXWal04wIGjWge1ilZFtIraSrG1jvanYB2ttWrVqrTFWSdWXFQFVAS1IC62gCTn9wff3BIySJAR9Hl/X3l9m3vPvffcDPJ4xnN4jDEGQgghhBCic/h1XQFCCCGEEKIcBWqEEEIIITqKAjVCCCGEEB1FgRohhBBCiI6iQI0QQgghREdRoEYIIYQQoqMoUCOEEEII0VEUqBFCCCGE6CgK1AghhBBCdBQFam8pHx8f+Pj4aHVMTEwMeDwe7t+/XyN1qi5ffPEFmjVrBoFAgA4dOtR1ddQ6efIkeDweTp48+dZcuyqfvZr0up/roKAgODo6VmuddMH9+/fB4/EQExNTpeN5PB6WLl2qE3V5Uzk6OiIoKKjScvXlb7euWrp0KXg8Xp1d/40I1DZs2AAejwcvL6+6rgqpY3/88QfmzZuHrl27Ijo6GitXrqzrKhGi0oYNGyj4KGfXrl2Iioqq0WvIgj5Vj1WrVtXo9QGAMYbt27ejR48esLCwgEgkQtu2bbFs2TIUFBTU+PVfh1QqxQ8//AAvLy9YWVnB1NQULVq0wLhx43DhwgWu3M2bN7F06dIaCw7fpu+OXl1XoDrs3LkTjo6OiI+Px507d9C8efO6rpLO++OPP7Q+ZuzYsRg5ciSEQmEN1Kh6HD9+HHw+H1u2bIGBgUFdV0en9ejRAy9fvqTXqQ5t2LABDRs21KhVpLY5ODjg5cuX0NfXr9LxL1++hJ6edj8xu3btQmJiImbPnl2tdVFm1KhRGDBggMJ2d3f3aruGMhKJBAEBAfj555/RvXt3LF26FCKRCH/99RfCw8OxZ88exMXFwdbWtkbrUVUzZ87Et99+i/fffx+jR4+Gnp4ekpKScPToUTRr1gzvvPMOgLJALTw8HD4+PjXS4lyb351FixYhNDS0xq+jSr0P1FJTU3Hu3Dns27cPU6ZMwc6dOxEWFlbX1dJZhYWFEIlEVfpxFggEEAgENVCr6pOVlQUjI6MqBx+y1+dtwOfzYWhoWNfVINWstLQUUqn0tQNwHo/3Wp+P6vxsvW5dlPHw8MCYMWOq9ZyaWLNmDX7++WfMnTsXX3zxBbd98uTJGD58OAYPHoygoCAcPXq01utWmcePH2PDhg0IDg7Gd999J7cvKioKT548qdJ5GWMoKiqCkZFRdVSz2unp6Wn9j47qVO+7Pnfu3AlLS0sMHDgQH374IXbu3KnV8UePHkXPnj1hamoKMzMzdO7cGbt27ZIrs2fPHnTs2BFGRkZo2LAhxowZg0ePHsmVCQoKgomJCdLT0zFo0CCYmJigcePG+PbbbwEAN27cQO/evWFsbAwHBweFa8jGEJw+fRpTpkxBgwYNYGZmhnHjxuHFixdyZQ8cOICBAweiUaNGEAqFcHZ2xvLlyyGRSOTK+fj4oE2bNrh8+TJ69OgBkUiEhQsXcvsqjhP65ptv0Lp1a4hEIlhaWqJTp05y9VQ1zmHDhg1o3bo1hEIhGjVqhOnTpyM7O1tpXW7evIlevXpBJBKhcePGWLNmjeo3p5zS0lIsX74czs7OEAqFcHR0xMKFC1FcXMyV4fF4iI6ORkFBAdeNoa5pXN3ro+1rrMl9PXz4EIMHD4axsTFsbGwwZ84cufqXVxufuYpj1GTvr7JHxc/Kjh07uPpZWVlh5MiRePDggcJ9fPfdd3B2doaRkRE8PT3x119/qXw/KoqOjkbv3r1hY2MDoVAINzc3bNy4UaGco6MjBg0ahDNnzsDT0xOGhoZo1qwZfvjhB4Wy//zzD3r37g0jIyM0adIEn3/+OaRSqcZ1+vXXX9GmTRsYGhqiTZs22L9/v9JyUqkUUVFRaN26NQwNDWFra4spU6bIfZcdHR3xzz//4NSpU0pf5+zsbMyePRv29vYQCoVo3rw5Vq9eLVdfWTfel19+iaioKO77Iet24vF4SE5OxpgxY2Bubg5ra2ssXrwYjDE8ePAA77//PszMzCAWi7F27Vq5e1A2Lkz2mXv06BEGDx4MExMTWFtbY+7cuQrfjYpj1PLy8jB79mw4OjpCKBTCxsYGffv2RUJCAoCy79Lhw4eRlpbGvR6ylhhVY9Ru376N4cOHw9raGkZGRnB1dcVnn31W2duoMcYYPv/8czRp0gQikQi9evXCP//8o/HYsIpevnyJL774Ai1atEBERITCfn9/fwQGBiI2NlauG1FVPZTR9DP+999/w8/PDw0bNoSRkRGcnJwwYcIEtfVPTU0FYwxdu3ZV2Mfj8WBjYwOg7G/JsGHDAAC9evXi3k/Z3xrZd/b3339Hp06dYGRkhM2bNwPQ7HtfHd8dAHj27BnGjh0LMzMzWFhYIDAwENeuXVP4rKkao6bJ38GUlBQMHToUYrEYhoaGaNKkCUaOHImcnBy1r3V59b5FbefOnRgyZAgMDAwwatQobNy4EZcuXULnzp0rPTYmJgYTJkxA69atsWDBAlhYWODKlSuIjY1FQEAAV2b8+PHo3LkzIiIi8PjxY6xbtw5nz57FlStXYGFhwZ1PIpHg3XffRY8ePbBmzRrs3LkTM2bMgLGxMT777DOMHj0aQ4YMwaZNmzBu3Dh4e3vDyclJrk4zZsyAhYUFli5diqSkJGzcuBFpaWncj6qsTiYmJggJCYGJiQmOHz+OJUuWIDc3V+5faEDZB/Hdd9/FyJEjMWbMGJXN6d9//z1mzpyJDz/8ELNmzUJRURGuX7+Oixcvcq+FMkuXLkV4eDh8fX0xbdo0rs6XLl3C2bNn5boqXrx4gf79+2PIkCEYPnw4fvnlF8yfPx9t27bFu+++q/a9mjRpErZt24YPP/wQn3zyCS5evIiIiAjcunWL+7Hcvn07vvvuO8THx+P//u//AABdunRRe15Vr482r7Em9/Xy5Uv06dMH6enpmDlzJho1aoTt27fj+PHjCnWq7c+cTI8ePbB9+3a5bWlpaVi0aBH3BxgAVqxYgcWLF2P48OGYNGkSnjx5gm+++QY9evSQq9+WLVswZcoUdOnSBbNnz8a9e/fw3nvvwcrKCvb29mrfFwDYuHEjWrdujffeew96eno4dOgQPvroI0ilUkyfPl2u7J07d/Dhhx9i4sSJCAwMxNatWxEUFISOHTuidevWAIDMzEz06tULpaWlCA0NhbGxMb777juN/xX/xx9/YOjQoXBzc0NERASePXuG8ePHo0mTJgplp0yZwr2PM2fORGpqKtavX48rV65w34uoqCh8/PHHMDEx4YIL2eevsLAQPXv2xKNHjzBlyhQ0bdoU586dw4IFC5CRkaEwjis6OhpFRUWYPHkyhEIhrKysuH0jRoxAq1atsGrVKhw+fBiff/45rKyssHnzZvTu3RurV6/Gzp07MXfuXHTu3Bk9evRQ+zpIJBL4+fnBy8sLX375JeLi4rB27Vo4Oztj2rRpKo+bOnUqfvnlF8yYMQNubm549uwZzpw5g1u3bsHDwwOfffYZcnJy8PDhQ3z11VcAABMTE5Xnu379Orp37w59fX1MnjwZjo6OuHv3Lg4dOoQVK1aovQfZa/z06VOF7RYWFlzryZIlS/D5559jwIABGDBgABISEtCvXz+UlJRUen5lzpw5gxcvXmDWrFkqW2jGjRuH6Oho/Pbbb1w3oqb10PQznpWVhX79+sHa2hqhoaGwsLDA/fv3sW/fPrX1d3BwAFD2D8lhw4ap7H3o0aMHZs6cia+//hoLFy5Eq1atAID7fwBISkrCqFGjMGXKFAQHB8PV1RWAZt/76vjuSKVS+Pv7Iz4+HtOmTUPLli1x4MABBAYGqn0NZDT5O1hSUgI/Pz8UFxfj448/hlgsxqNHj/Dbb78hOzsb5ubmGl0LrB77+++/GQD2559/MsYYk0qlrEmTJmzWrFmVHpudnc1MTU2Zl5cXe/nypdw+qVTKGGOspKSE2djYsDZt2siV+e233xgAtmTJEm5bYGAgA8BWrlzJbXvx4gUzMjJiPB6P/fTTT9z227dvMwAsLCyM2xYdHc0AsI4dO7KSkhJu+5o1axgAduDAAW5bYWGhwv1MmTKFiUQiVlRUxG3r2bMnA8A2bdqkUL5nz56sZ8+e3PP333+ftW7dWulrVbGOqampjDHGsrKymIGBAevXrx+TSCRcufXr1zMAbOvWrQp1+eGHH7htxcXFTCwWs6FDh6q97tWrVxkANmnSJLntc+fOZQDY8ePHuW2BgYHM2NhY7fkq1knZ66Pta1zZfUVFRTEA7Oeff+a2FRQUsObNmzMA7MSJE4yx2v3MnThxQu7aFb18+ZJ17NiRNWrUiGVkZDDGGLt//z4TCARsxYoVcmVv3LjB9PT0uO2y++jQoQMrLi7myn333XcMgNxnTxVl74Gfnx9r1qyZ3DYHBwcGgJ0+fZrblpWVxYRCIfvkk0+4bbNnz2YA2MWLF+XKmZuby32uVenQoQOzs7Nj2dnZ3LY//viDAWAODg7ctr/++osBYDt37pQ7PjY2VmF769atlb4Wy5cvZ8bGxiw5OVlue2hoKBMIBCw9PZ0xxlhqaioDwMzMzFhWVpZc2bCwMAaATZ48mdtWWlrKmjRpwng8Hlu1ahW3Xfa5CQwM5LbJzh0dHc1tk33mli1bJnctd3d31rFjR7ltFT9v5ubmbPr06Qr3Wt7AgQPlXkt1denRowczNTVlaWlpcmVlf79VkZ1L1eP8+fOMsf/+vg0cOFDunAsXLmQA5F4rTcn+Duzfv19lmefPnzMAbMiQIVrXQ9PP+P79+xkAdunSJa3vYdy4cQwAs7S0ZB988AH78ssv2a1btxTK7dmzR+XfF9l3NjY2VmGfpt/71/3u7N27lwFgUVFRXBmJRMJ69+6t8FmTfZdkNP07eOXKFQaA7dmzR6Ge2qjXXZ87d+6Era0tevXqBaCs6XXEiBH46aefFJrhK/rzzz+Rl5eH0NBQhbEPsparv//+G1lZWfjoo4/kygwcOBAtW7bE4cOHFc47adIk7r8tLCzg6uoKY2NjDB8+nNvu6uoKCwsL3Lt3T+H4yZMny7VCTZs2DXp6ejhy5Ai3rfy/jvLy8vD06VN0794dhYWFuH37ttz5hEIhxo8fr/a1kNX14cOHuHTpUqVlZeLi4lBSUoLZs2eDz//voxQcHAwzMzOF18fExERuTIiBgQE8PT2Vvg7lye49JCREbvsnn3wCAErfB02pen20eY01ua8jR47Azs4OH374IbdNJBJh8uTJcueqi8+cKh999BFu3LiBvXv3QiwWAwD27dsHqVSK4cOH4+nTp9xDLBbDxcUFJ06ckLuPqVOnyo2VCgoK0vhfkeXfg5ycHDx9+hQ9e/bEvXv3FLoN3Nzc0L17d+65tbU1XF1dFd6Dd955B56ennLlRo8eXWldMjIycPXqVQQGBsrVv2/fvnBzc5Mru2fPHpibm6Nv375yr1HHjh1hYmLCvUbq7NmzB927d4elpaXcOXx9fSGRSHD69Gm58kOHDoW1tbXSc5X/fAgEAnTq1AmMMUycOJHbLvvcaPr5mDp1qtzz7t27V3qshYUFLl68iH///Veja6jz5MkTnD59GhMmTEDTpk3l9mmaRmHy5Mn4888/FR6y91P29+3jjz+WO2fFiQ7ayMvLAwCYmpqqLCPbl5ubq3U9NP2My1q9f/vtN7x69Uqre4iOjsb69evh5OSE/fv3Y+7cuWjVqhX69OmjMDxDHScnJ/j5+Sls1+Z7r4ym353Y2Fjo6+sjODiYO5bP5yu01iuj6d9B2d+K33//HYWFhZWeV5V62/UpkUjw008/oVevXkhNTeW2e3l5Ye3atTh27Bj69eun8vi7d+8CANq0aaOyTFpaGgBwTbLltWzZEmfOnJHbZmhoqPDH0tzcHE2aNFH442Fubq4w9gwAXFxc5J6bmJjAzs5OblzYP//8g0WLFuH48ePcl1mm4ge5cePGGg0qnj9/PuLi4uDp6YnmzZujX79+CAgIUDoWQUbV62NgYIBmzZpx+2WUvQ6Wlpa4fv262rqlpaWBz+crzOYVi8WwsLBQuI42VL0+2rzGmtxXWloamjdvrlCu4mtXF585ZTZv3ozo6Ghs3ryZ634BysZbMMYUPqcysn9kyO6jYjl9fX00a9ZMozqcPXsWYWFhOH/+vMIfuZycHLmAqeKPNVD2HpS/37S0NKUpfJS91hWpuh/Z8bJxVkDZa5STkyPXXVxeVlZWpddLSUnB9evXVQZfFc+hqjsbUHxtzM3NYWhoiIYNGypsf/bsWaV1U/aZq/haK7NmzRoEBgbC3t4eHTt2xIABAzBu3DiNPw/lyYJCdX+/K+Pi4gJfX1+V+1W959bW1rC0tKzSNWVBmCxgU6ZiMKdNPTT9jPfs2RNDhw5FeHg4vvrqK/j4+GDw4MEICAiodFa/LJiZPn06nj17hrNnz2LTpk04evQoRo4cqfE4VFWfWW2+98po+t1JS0uDnZ2dQvetJlkjNP076OTkhJCQEERGRmLnzp3o3r073nvvPW7MqKbqbaB2/PhxZGRk4KeffsJPP/2ksH/nzp1qA7WaoGpGpKrtjDGtr5GdnY2ePXvCzMwMy5Ytg7OzMwwNDZGQkID58+crDJbUdPxNq1atkJSUhN9++w2xsbHYu3cvNmzYgCVLliA8PFzreirzuq9DTSQcVPb6aPsaV+f7q62a+MzFx8dj1qxZmDRpkkKLn1QqBY/Hw9GjR5VeQ92YIm3cvXsXffr0QcuWLREZGQl7e3sYGBjgyJEj+Oqrr3TqPahIKpXCxsZG5cQmVT8gFc/Rt29fzJs3T+n+Fi1ayD1X9z1X9tq8zutV1Znfw4cPR/fu3bF//3788ccf+OKLL7B69Wrs27ev0jGqbwrZGK3r169j8ODBSsvI/oFXsaW2OvF4PPzyyy+4cOECDh06hN9//x0TJkzA2rVrceHCBY2/xw0aNMB7772H9957Dz4+Pjh16hTS0tK4sWzqKPvMavu9V0bb705VaPN3cO3atQgKCsKBAwfwxx9/YObMmYiIiMCFCxeUjm9Vpt4Gajt37oSNjQ03w628ffv2Yf/+/di0aZPKP2DOzs4AgMTERJURtOzDlpSUhN69e8vtS0pK0ujDqK2UlBSuKxcA8vPzkZGRweX7OXnyJJ49e4Z9+/bJDfot36pYVcbGxhgxYgRGjBiBkpISDBkyBCtWrMCCBQuUTo0v//qU/1dxSUkJUlNT1f5rVRsODg6QSqVISUmRG4z6+PFjZGdnV/v7UBOvsYODAxITE8EYkws4k5KSFMrJttfWZ668J0+e4MMPP0SHDh2UfrecnZ3BGIOTk5PaP3iyeqakpMjdx6tXr5Camor27durrcehQ4dQXFyMgwcPyrUIadJtqK5OKSkpCtsrvgeqjgWg0fHOzs6Ii4tD165dK/2Hkqp/fDg7OyM/P7/avkO6ws7ODh999BE++ugjZGVlwcPDAytWrOACNU3/MSb7e5OYmFhjdS3/npf/+/bkyRONW6Yr6tatGywsLLBr1y589tlnSn/kZbOVBw0apHU9tP2Mv/POO3jnnXewYsUK7Nq1C6NHj8ZPP/0k112uqU6dOuHUqVPIyMiAg4NDlf5hrc33/nW/Ow4ODjhx4oRCSqY7d+5UWk9N/w7KtG3bFm3btsWiRYtw7tw5dO3aFZs2bcLnn39e6bFAPU3P8fLlS+zbtw+DBg3Chx9+qPCYMWMG8vLycPDgQZXn6NevH0xNTREREYGioiK5fbJ/VXbq1Ak2NjbYtGmTXBqFo0eP4tatWxg4cGC139t3330nN2Zg48aNKC0t5f6Qyb7Y5f/lW1JSgg0bNrzWdSt2eRgYGMDNzQ2MMZVjGHx9fWFgYICvv/5arj5btmxBTk5Otb0+siC14ky3yMhIAKj296EmXuMBAwbg33//xS+//MJtKywsVMhFVBefORmJRIKRI0eipKQEe/fuVdolPGTIEAgEAoSHhyu0vjDGuM9Rp06dYG1tjU2bNsnNTIuJiVFI3aKMsvcgJycH0dHRVbk1AGXvwYULFxAfH89te/LkiUYpfezs7NChQwds27ZNruv7zz//xM2bN+XKDh8+HBKJBMuXL1c4T2lpqdz9GxsbK309hg8fjvPnz+P3339X2JednY3S0tJK66xLJBKJwpABGxsbNGrUSO5zbmxsrNE4JGtra/To0QNbt25Fenq63L7qakX19fWFvr4+vvnmG7lzKls54dWrV7h9+zYyMjLUnlMkEmHu3LlISkpSmkbk8OHDiImJgZ+fHzfkQJt6aPoZf/HihcLrJFtuT1XKIKBsVmnFzztQ9vfx2LFjckNUjI2NAUCj77uMNt/71/3u+Pn54dWrV/j++++5/VKpVOk/UCvS9O9gbm6uwne1bdu24PP5al/niupli9rBgweRl5eH9957T+n+d955B9bW1ti5cydGjBihtIyZmRm++uorTJo0CZ07d0ZAQAAsLS1x7do1FBYWYtu2bdDX18fq1asxfvx49OzZE6NGjeJSJTg6OmLOnDnVfm8lJSXo06cPhg8fjqSkJGzYsAHdunXj7rVLly6wtLREYGAgZs6cCR6Ph+3bt7/2H6d+/fpBLBaja9eusLW1xa1bt7B+/XoMHDhQ5cBXa2trLFiwAOHh4ejfvz/ee+89rs6dO3eutmSS7du3R2BgIL777juuWzI+Ph7btm3D4MGD5Vogq0NNvMbBwcFYv349xo0bh8uXL8POzg7bt29XGB9RF585mU2bNuH48eOYOnWqwr9gbW1t0bdvXzg7O+Pzzz/HggULcP/+fQwePBimpqZITU3F/v37MXnyZMydOxf6+vr4/PPPMWXKFPTu3RsjRoxAamoqoqOjNRqT1K9fPxgYGMDf3x9TpkxBfn4+vv/+e9jY2FT6Y6jKvHnzsH37dvTv3x+zZs3iUhc4ODhUOk4SACIiIjBw4EB069YNEyZMwPPnz7ncg/n5+Vy5nj17YsqUKYiIiMDVq1fRr18/6OvrIyUlBXv27MG6deu4SSUdO3bExo0b8fnnn6N58+awsbFB79698emnn+LgwYMYNGgQl2akoKAAN27cwC+//IL79+8rjDHTZXl5eWjSpAk+/PBDtG/fHiYmJoiLi8OlS5fk8rd17NgRu3fvRkhICDp37gwTExP4+/srPefXX3+Nbt26wcPDA5MnT4aTkxPu37+Pw4cP4+rVq5XWKSEhATt27FDY7uzsDG9vby4/XEREBAYNGoQBAwbgypUrOHr0qMJr/+jRI7Rq1QqBgYGVLmsUGhqKK1euYPXq1Th//jyGDh0KIyMjnDlzBjt27ECrVq2wbds2rrw29dD0M75t2zZs2LABH3zwAZydnZGXl4fvv/8eZmZmSldrkHn48CE8PT3Ru3dv9OnTB2KxGFlZWfjxxx9x7do1zJ49m6tThw4dIBAIsHr1auTk5EAoFHL50VTR5nv/ut+dwYMHw9PTE5988gnu3LmDli1b4uDBg3j+/DkA9a27mv4dPH78OGbMmIFhw4ahRYsWKC0txfbt2yEQCDB06FCV51fwWnNG64i/vz8zNDRkBQUFKssEBQUxfX199vTpU7XnOnjwIOvSpQszMjJiZmZmzNPTk/34449yZXbv3s3c3d2ZUChkVlZWbPTo0ezhw4dyZVSlhejZs6fStBcODg5s4MCB3HNZ6otTp06xyZMnM0tLS2ZiYsJGjx7Nnj17Jnfs2bNn2TvvvMOMjIxYo0aN2Lx589jvv/+uMBVa1bVl+8pPbd68eTPr0aMHa9CgARMKhczZ2Zl9+umnLCcnR6GOFdMYrF+/nrVs2ZLp6+szW1tbNm3aNPbixQuNXofAwECl0/ErevXqFQsPD2dOTk5MX1+f2dvbswULFsilypCdT5v0HKpen9d9jZXdV1paGnvvvfeYSCRiDRs2ZLNmzeJSNlScwl4bn7mK6TlkU9CVPSpOg9+7dy/r1q0bMzY2ZsbGxqxly5Zs+vTpLCkpSa7chg0bmJOTExMKhaxTp07s9OnTCp89VQ4ePMjatWvHDA0NmaOjI1u9ejXbunWrwmew4n2Vfx0qXuf69eusZ8+ezNDQkDVu3JgtX76cbdmyRaP0HLL7btWqFRMKhczNzY3t27dP5Wf4u+++Yx07dmRGRkbM1NSUtW3bls2bN4/9+++/XJnMzEw2cOBAZmpqqvA65+XlsQULFrDmzZszAwMD1rBhQ9alSxf25Zdfcil8ZKkmvvjiC4Xry97PJ0+eyG3X9HOjKj2HsmMrpi9gTD49R3FxMfv0009Z+/btmampKTM2Nmbt27dnGzZskDsmPz+fBQQEMAsLC7m0J8rqwhhjiYmJ7IMPPmAWFhbM0NCQubq6ssWLFyvUr7zK0nOUT3chkUhYeHg4s7OzY0ZGRszHx4clJiYyBwcHpalMNE3ZIZFIWHR0NOvatSszMzNjhoaGrHXr1iw8PJzl5+crLa9JPRjT7DOekJDARo0axZo2bcqEQiGzsbFhgwYNYn///bfaeufm5rJ169YxPz8/1qRJE6avr89MTU2Zt7c3+/777xVSo3z//fesWbNmTCAQyP2tUfWdZUzz7/3rfncYY+zJkycsICCAmZqaMnNzcxYUFMTOnj3LAMilN1L2+Was8r+D9+7dYxMmTGDOzs7M0NCQWVlZsV69erG4uDi1r3NFPMbqYLQtUSBLjnnp0iV06tSprqtDCCFEBUdHR/j4+Lw1i4K/TX799Vd88MEHOHPmjNqsB7WpXo5RI4QQQgh5HS9fvpR7LpFI8M0338DMzAweHh51VCtF9XKMGiGEEELI6/j444/x8uVLeHt7o7i4GPv27cO5c+ewcuVKnVogngI1QgghhLx1evfujbVr1+K3335DUVERmjdvjm+++QYzZsyo66rJoTFqhBBCCCE6isaoEUIIIYToKArUCCGEEEJ0FI1RqyKpVIp///0XpqamNbIGJSGEEEKqH2MMeXl5aNSoEfh83W+vokCtiv7991/Y29vXdTUIIYQQUgUPHjzQeGH0ukSBWhXJllV68OABzMzM6rg2hBBCCNFEbm4u7O3tVS6PqGsoUKsiWXenmZkZBWqEEEJIPVNfhi3pfucsIYQQQshbigI1QgghhBAdRYEaIYQQQoiOokCNEEIIIURHUaBGCCGEEKKjKFAjhBBCCNFRFKgRQgghhOgoCtQIIYQQQnQUBWqEEEIIITqKAjVCCCGEEB1FgRohhBBCiI6iQI0QQgghREdRoEYIIYQQoqMoUCOEEEII0VEUqBFCCCGE6CgK1AghhBBCdBQFaoQQQgghOooCNUIIIYQQHUWBGiGEEEKIjqJAjRBCCCFER1GgRgghhBCioyhQI4QQQgjRURSoEUIIIYToKArUCCGEEEJ0FAVqhBBCCCE6igI1QgghhBAdRYEaIYQQQoiOokCNEEIIIURHUaBGCCGEEKKjKFAjhBBCCNFRFKgRQgghhOgoCtQIIYQQQnSUTgRq3377LRwdHWFoaAgvLy/Ex8erLR8VFQVXV1cYGRnB3t4ec+bMQVFREbff0dERPB5P4TF9+nSujI+Pj8L+qVOn1tg9EkIIIYRoS6+uK7B7926EhIRg06ZN8PLyQlRUFPz8/JCUlAQbGxuF8rt27UJoaCi2bt2KLl26IDk5GUFBQeDxeIiMjAQAXLp0CRKJhDsmMTERffv2xbBhw+TOFRwcjGXLlnHPRSJRDd0lIYQQQoj26jxQi4yMRHBwMMaPHw8A2LRpEw4fPoytW7ciNDRUofy5c+fQtWtXBAQEAChrPRs1ahQuXrzIlbG2tpY7ZtWqVXB2dkbPnj3ltotEIojF4uq+JUIIIYSQalGnXZ8lJSW4fPkyfH19uW18Ph++vr44f/680mO6dOmCy5cvc92j9+7dw5EjRzBgwACV19ixYwcmTJgAHo8nt2/nzp1o2LAh2rRpgwULFqCwsFBlXYuLi5Gbmyv3IIQQQgipSXXaovb06VNIJBLY2trKbbe1tcXt27eVHhMQEICnT5+iW7duYIyhtLQUU6dOxcKFC5WW//XXX5GdnY2goCCF8zg4OKBRo0a4fv065s+fj6SkJOzbt0/peSIiIhAeHq79TRJCCCGEVFGdd31q6+TJk1i5ciU2bNgALy8v3LlzB7NmzcLy5cuxePFihfJbtmzBu+++i0aNGsltnzx5Mvffbdu2hZ2dHfr06YO7d+/C2dlZ4TwLFixASEgI9zw3Nxf29vbVeGeEEEIIIfLqNFBr2LAhBAIBHj9+LLf98ePHKseOLV68GGPHjsWkSZMAlAVZBQUFmDx5Mj777DPw+f/15qalpSEuLk5lK1l5Xl5eAIA7d+4oDdSEQiGEQqHG90YIIYQQ8rrqdIyagYEBOnbsiGPHjnHbpFIpjh07Bm9vb6XHFBYWygVjACAQCAAAjDG57dHR0bCxscHAgQMrrcvVq1cBAHZ2dtrcAiGEEEJIjanzrs+QkBAEBgaiU6dO8PT0RFRUFAoKCrhZoOPGjUPjxo0REREBAPD390dkZCTc3d25rs/FixfD39+fC9iAsoAvOjoagYGB0NOTv827d+9i165dGDBgABo0aIDr169jzpw56NGjB9q1a1d7N08IIYQQokadB2ojRozAkydPsGTJEmRmZqJDhw6IjY3lJhikp6fLtaAtWrQIPB4PixYtwqNHj2BtbQ1/f3+sWLFC7rxxcXFIT0/HhAkTFK5pYGCAuLg4Lii0t7fH0KFDsWjRopq9WUIIIYQQLfBYxf5CopHc3FyYm5sjJycHZmZmdV0dQgghhGigvv1+68QSUoQQQgghRBEFaoQQQgghOooCNUIIIYQQHUWBGiGEEEKIjqJAjRBCCCFER1GgRgghhBCioyhQI4QQQgjRURSoEUIIIYToKArUCCGEEEJ0FAVqhBBCCCE6igI1QgghhBAdRYEaIYQQQoiOokCNEEIIIURH6dV1BQghhBDy5pNIJUjISsCTwiewFlnDw8YDAr6g3l2jtlGgRgghhJAaFZcWh1Xxq/C48DG3zVZki1DPUPg6+Naba9QF6vokhBBCSI2JS4tDyMkQuQAKALIKsxByMgRxaXH14hp1hQI1QgghhFSZRCrBpcxLOHLvCC5lXoJEKpHbtyp+FRiYwnGybavjV8sdU5Xr1/Q16hJ1fRJCCCFELVVjvyrrbkzISlBo5SqPgSGzMBMJWQnoLO5cpbrVxjXqEgVqhBBCSB2RShkyUrJRkFsMYzMh7FwswOfzIJEyxKc+R1ZeEWxMDeHpZAUBnwcAavdVl5LSEuxO3o0HuQ/wsvQlzmWcQ1ZhFrffVmSLAU4DEPNPjEJLlqy7MdInEiWSEo2u96TwSZXrqumxr3ONukSBGiGEEFIH7l7Jwl+7U1CQXcxtM7YQwsS7IdbefIiMnCJuu525IcL83QAA4YduKt3Xv41dtdQr8u9IbLu5DVImVVnmceFjRP8TrXQfAwMPPKyOX43lXZdrdE1rkXWV6qrNsa9zjbpEgRohhBCigepsybp7JQuxmxMVthdkFyP/6EOYiEoAg/+2Z+YUYeqOBKXnyswpwrQdCdg4xkMuWNMmVYWs7LbEbTj16FSV7qk8WXcjj8eDrcgWWYVZSseQ8VC238PGo8rX8rDxqPFr1CUK1AghhJBKHLmegUUHEvG84L+uPG1bsmTdnPnZRTiz547asr1f6uOOfjHY/+JAxfDjPwwAD8DSQ4mwsHqA50VPkZ6Xjl+Sf9EoVYWycWbV5dnLZwj1DEXIyRDwwJMLpHgou7n5nvNfK9eZgC+o8WvUJR5jTN37T1TIzc2Fubk5cnJyYGZmVtfVIYQQUk0qtkT9cdkI3/+VprQsD1BoyVJGWTdnZX4yLsYDfdXdj+XpmSZCaHsIfP0clWVkQUukTyQXrMnSWihriaoOW/22orO4s9JgUCwSY77n/BrNo6bsGvXt95sCtSqqb280IYQQecq6Mk88OKbwYy99ZY7ix/4ozWuj9Dx25oY4M7+3ym5QVd2clTkkKsFtg8pTSuiZJsKw8Q4AAK+SnlhZN2Ds0FgAgN9evxppSSt/HVlLlq6sTFDffr+p65MQQshbJzYxQ2FQvrVtEoqsFAfI8/RyYNh4B4oejVEarGXkFCE+9Tm8nRso7JNKGf7anVKlOhbwNGlHkUJoe6isnhoMlyufqgJAtQRpmnY3CviCGk+PURvXqG2U8JYQQshbJTYxA9N2JCAjpxAC0V3omV2FQJSCQtO9UNbHJAuAygIi5V2RWXlFSrdnpGRr1d0JlAVTuTwpHupV3u0pEKWCr5+jUZBW3pPCJ6+VroL3v/+Nbz0eNiIbuX22Ilu57lXyeqhFjRBCSL3xut1nEilD+KGbEGgwpqs8Hg/g6edAIEqFpNBZYb+NqaHS4wpytQvSZE4YveImEgBlY+GYsv/Wy6vS+V83VYWtyJYb+zXLY9YbtxC6LqFAjRBCSL1QHYtux6c+xxPp39yYLm0pC4waGBvA08lKaXljM6FW5zexFML4nYbIu/kQKNctK1aRR42Vmmp1/oqpKtSltah4nJ+jH3rZ91IIxt7E7kZdQoEaIYQQnadqdmL5LPiaBGuZuQVajemqSFlgtPz9NionEti5WMDYQqi2+9PQRB/dhrnAxOK/lQk+8G+hMmdbXzcxt6+hSWeEXTmocbAFyI8dU5XWQqZbo27o0rgLRrQYAQM9A4X9pOZRoEYIIUSnVbbotiwLfi/7XpV2ueVIkzXu7pS7DgNYqTkkhU5y26f0cMKAdqpTc/D5PHQf4aJ21qfPaFc4u8uP8xLweUonJyjbF6qvPtiSKd9dKePr4ItIn8gaT51Bqo4CNUIIITql4jg0iVRSbYtuN7TQbswYj/EgznGG6JUZsnO8UMj4YDzAylgfn7/fBgPaNar0HM7uNug/pY1CHjUTSyG6DXdRCNK0pSrYsjWyxYctPkRTs6Zqx475Oviil30vGmemoyhQI4QQUiU1kRdL2Tg0MwPNcl0dvZWE0oJmapd2sjXWPChyetYOXe8PgUmJJbdNYshHcz97+Pk102r5KGd3Gzi1t1a6AHt1eN1gi8aZ6S5KeFtF9S1hHiGEVAdZcHYi/QR+u/cbXhS/4PZpO7C/otfNkl+YFgxJobPapZ0kUkmlSV7N9RrC9s4E9Mooay2Tje0qr/+UNq/dEkbqRn37/aY8aoQQQjQSlxYHv71+mPD7BGy/tV0uSAP+G9gflxan9bnVjUMD/jdGTEX8xljZ6gGy8WOyRcpjEzMUysrWhZTlAStPti2sy2fwf9lMaRmZMz+nQCqldg5S8yhQI4SQt5xEKsGlzEs4cu8ILmVeQklpidxziVTCtXZVNlYMAFbHr4ZEWvnSR+UlZCWoPTePV/aoGKzJnhc/9ofsJ01WJPzQTUiUBFOyMV2qErW6lXSsNElt/otiZKRkqy1DSHWgMWqEEPIWUzYmjM/jQ8r+y4pvY2SDYmmxRl2S2gzsl6tHsmbLLDGJEXh6L/97Xqp8HU4G9Us7qRvTlXwpU6O6VDWZLSHa0IkWtW+//RaOjo4wNDSEl5cX4uPj1ZaPioqCq6srjIyMYG9vjzlz5qCo6L/EgI6OjuDxeAqP6dOnc2WKioowffp0NGjQACYmJhg6dCgeP67+hWkJIURXqWolKx+kAUDWyyzkFGuX0kKb5YliEzOw5eRTjcoWPQpAYVowXj4aicK0YBTcma9ysXRA9dJOwH8D6Ac0G4DO4s7cwHtNk9Rqm8yWkKqo80Bt9+7dCAkJQVhYGBISEtC+fXv4+fkhKytLafldu3YhNDQUYWFhuHXrFrZs2YLdu3dj4cKFXJlLly4hIyODe/z5558AgGHDhnFl5syZg0OHDmHPnj04deoU/v33XwwZMqRmb5YQQnSARCrBxYyLWHpuaZUH7ldG0yWKZEs6lRY6QfrKXINxaM6QFDqjNLfD/5ZyUv8zpmppJ3VkSWrVMbEsm7VJSE2r80AtMjISwcHBGD9+PNzc3LBp0yaIRCJs3bpVaflz586ha9euCAgIgKOjI/r164dRo0bJtcJZW1tDLBZzj99++w3Ozs7o2bMnACAnJwdbtmxBZGQkevfujY4dOyI6Ohrnzp3DhQsXauW+CSGkplUceyYba+a31w+T/piEnBLtE79WhgcexCIxt0RRZeJTn/9vOST+/8aZaTYOrfJ6AHbmhiqXdlJHlqRWnW7DXaottQYh6tTpGLWSkhJcvnwZCxYs4Lbx+Xz4+vri/PnzSo/p0qULduzYgfj4eHh6euLevXs4cuQIxo4dq/IaO3bsQEhICHj/Wy/k8uXLePXqFXx9/5tC3rJlSzRt2hTnz5/HO++8U413SQghtU/Z2DNzA/MaCc5klC1RVJnyXZOleW1Q9GgMhLaHwCu3eoCqcWiq61EmzN9Nq1xn5dV0klpCNFWngdrTp08hkUhga2srt93W1ha3b99WekxAQACePn2Kbt26gTGG0tJSTJ06Va7rs7xff/0V2dnZCAoK4rZlZmbCwMAAFhYWCtfNzFQ+iLS4uBjFxf99WXNzczW4Q0IIqV6aJJlVlY+sOoI0xlSvkalsiaLKVOyaLM1rg9I8NwhEqeDp5YGVmv4v7YbqljQrYwM8LyjhnovV5FHTRk0nqSVEE/Vu1ufJkyexcuVKbNiwAV5eXrhz5w5mzZqF5cuXY/HixQrlt2zZgnfffReNGlW+zIc6ERERCA8Pf61zEEKIJlQFY0qz9us3RIDzTEztPBgCPq/SfGRVxRjAJCKA6YGn/98/VKWlxugq7ovgju9VaWUCTycr2JkbIjOnqFyN+f8bf6YeD2VB2alPe+Fy2gulC5i/Lj6fh8aulpUXJKSG1Gmg1rBhQwgEAoXZlo8fP4ZYLFZ6zOLFizF27FhMmjQJANC2bVsUFBRg8uTJ+Oyzz8Dn//evrrS0NMTFxWHfvn1y5xCLxSgpKUF2drZcq5q66y5YsAAhISHc89zcXNjb22t1v4QQUhllwZityBYDnAYg5p8YJa1kT7Hx1hLEnEvF8r6j0KDhQ7X5yDRRsdWMGyOWOURpa9d4ny7oLFa+gHhlBHwewvzdMG1HAniA3N2Vf65sH1DWvWmgx1e5gDkh9V2dTiYwMDBAx44dcezYMW6bVCrFsWPH4O3trfSYwsJCuWAMAASCsn/BVVwNKzo6GjY2Nhg4cKDc9o4dO0JfX1/uuklJSUhPT1d5XaFQCDMzM7kHIYRUJ1XpMh4XPkb0P9FKW8lkAVWh6T5M2/G3xvnI1JNvjWKl5ih6NOZ/Y8T43KxLaaEz7MxFVRqwX17/NnbYEOCO9kJDtCwRwP4VHzxW1lq2aYwHNo3xgNhcvotUbG6IjWM8Xrt7kxBdV+ddnyEhIQgMDESnTp3g6emJqKgoFBQUYPz48QCAcePGoXHjxoiIiAAA+Pv7IzIyEu7u7lzX5+LFi+Hv788FbEBZwBcdHY3AwEDo6cnfprm5OSZOnIiQkBBYWVnBzMwMH3/8Mby9vWkiASGk2mizaPnrdFnyeABPPwcCUSr2XTIAGmpf17KuTSMUPRoNSaEjBKI0uVYzXoV/11fHgH2Zu1ey8Hh3Kvpm8wAYAAD0TfTRq58rXNqUDdrv6yZGfOrzGuneJESX1XmgNmLECDx58gRLlixBZmYmOnTogNjYWG6CQXp6ulwL2qJFi8Dj8bBo0SI8evQI1tbW8Pf3x4oVK+TOGxcXh/T0dEyYMEHpdb/66ivw+XwMHToUxcXF8PPzw4YNG2ruRgkhbxVlXZiWBtZY5L0A/Rz7KpSvbAkljejl4cmTdmjayBrZJU81Dvr+69ocCklhcwD4b3HzIW4AypZjKkujUaa6BuzfvZKF2M2JCttf5b/CH98ngs8vW/xcwOdR9yZ5K/FYxf5CopHc3FyYm5sjJyeHukEJIZBIGdfi87A4HptvhykESoyVtUSNc16CT7sPk9t35N4RzP9r/mvVoTAtGJJCZ0zun4+f0sr+8Vq+DjzwwMBgLjSXW2lA+kox/cUcXxfM6O3CtVqVv7/qatGSShl+WHhO7bqaJpZCjF3RhWZakmpT336/67xFjRBC6rvYxIxyLU5SGDdfC74eqzjUi1tUPCZpHVpbeGNA2ybcPk0z+SvDWNk4srI0FkAve194OjVQOilhvud8bo3LuOQU7LuUiydPGkM2ZNlORUtZTbRoZaRka7z4Oc28JG8rCtQIIeQ1xCZmYNqOBK7dSiBKBV9fdb4y2XiysD9+g1/rKVyrlIeNB2xFtsgqzFLfZckgFwCWz9rPAx9ic1lrl+pFxwGgs7gzOos7Y1636m8p05Smi5rT4ufkbVbnS0gRQkh9JJEynE15itC9N+TTRujlaXT8i+JniE99zj0X8AUI9QwtO0eFpjje//43vvV4mBvIzxSQzciU/K/bsvzgflWLjpcn4PPg5WSFTkYiNHj+Cpkp2ZBKa2dEDC1+TkjlqEWNEPLG0GaWpWbnU97aJN/VKY+Vmmp0blZqKrd8EgD4Ovgi0idSZZelr4MvZnnMwqaLfyL64nW8yDXksvY3MjPEpx4OaPaSh0dJLzTOoH/3SpbCMknGFkJ0H1HzyyTJFj+vbIwaLX5O3mY0maCK6ttgRELedKoSxYZ6hmq1pJGMsmDMztwQ77W3w3enU9V0Tkph3Hw1eHo5Spdako0nK7gzHz8Gd1E67kuTgLN8EKmfUYSsU5laB1uqZlzK9J/SpsaDNV2oA3m71LffbwrUqqi+vdGEvMlUrW0p60KM9InUKlirOO5MW3qmiTBsvKOsDkrGkxU9GgNrfiecmd+7WnKQVSXQ0aUZl8pa9Wjxc1JT6tvvN3V9EkJ0liYpIdQlimVg4IGH1fGr0cu+l0bdoBIpQ/ihm6+1UmZpXhsUPRoDoe0h8MpNLGClZWkwJHltEDbm9RPFSqUMf+1WvxLBmZ9T4NTeWiHY0qUZl7T4OSGqUaBGCNFJqroeK6aOqCxRLANDZmEmErIS0FncudLrxqc+Vzr2TFuSvDYoyHODueUDFEhecBn+7cxFCBvz+oligdcLtnRtxiUtfk6IchSoEUJ0hqwF7c+bmdh69r7C/sycIkzbkSC3xuOTwicanVvTchUH+FeVLHN/X7dBNZb+4nWCLZpxSUj9QIEaIUQnqJtJKSNLIRZ+6Cb6uokh4PM0ThSraTkbU8PKC6lhYaSPb0d74J1mDbiArKaWPnqdYItmXBJSP1AeNUJInZMN3teky5EByMgp4nKQtW/YHpZC1V1mPPAgFonhYeOhUV08naxgZ25YcVEBJedVfM4DsGpoW3Rt3rBWksbKgi11VAVbfD4P3Ue4qD2223AXGidGSB2jQI0QUmskUgkuZV7CkXtHcCnzEiRSSZUH72flFSEuLQ4D9g/Ai+IXSsvIZn3O95yvcT41AZ+HMH+3/x1f8Xxljyk9nCA2l295E5sbynXJ1obXDbac3W3Qf0obhWDPxFJIaTEI0RGUnqOK6tv0XkLqmqo8Zx80nY4v9htofb5PPyhRuvB5eWKRmEsUq63KJjPUxCLlVfW66S2kUkYzLslbo779flOgVkX17Y0mpC7IEreeSD+B7be2K+zngQcGhpcPx6D0f0sgVYYHwNbcACbNV6ud7WkptETch3Ew0NM+CJTRpWCsMhRsEaKZ+vb7TZMJCCFa0yRzvrIWtIpkrWFC20MozXNDZaMxZGHHWB8JNiWrPi8AvCh+gWtPr2mUkkMVAZ9XYxMBqkpVQEbpLQh5M1GgRgjRiiZLNalaKUAVvn4O9ESpKC10VltOlvJCKroCJFd+Xk1TctQXdbkuJyGkblCgRshbTNtFzFUFYI8LHyPkZAgifSLRy76XypUC1OHp5YEHKD1qYldH+LqJua7HS5kPNTqnpik56gNVS0UVZBcjdnMiDf4n5A1FgRohbylNWsbKj9FqaKKPVVdUB2CMMYSfXQkTHxO13Z2qzO7VETtO6le6EgEAeNh4wFZki6zCLKX14YEHW5Gtxik5dN3rLBVFCKnfKFAjpJ7TtlUMUN0yllWYxbWMlea1lpv1KBDdhchBTQDGA7JfPcFPN05oVX9ZUDXVqy+mevE1Grwv4AsQ6hmKkJMh3ISE8ucDtEvJoet0aV1OQkjtokCNkHpMk1axijRZxDz87Eo8vD4HrNzgfp5enkZ1Op3yBDDVrP7KgipNB+/7Ovgi0idS6f1XNSWHrtK1dTkJIbWHAjVC6pnKUl6UbxVTFqxosoh59qsn4ItSISk3uJ+VahZ95TxvisYNrJFd8rTScWqvG1T5Oviil30vrVsU6xtal5OQtxcFaoTUI5qmvOCBh9Xxq9HLvpdC0KLpTMiKLWiSQidIX5mDp5cDnpJhUIwBrNQckkJn9Lebgp/SVih0S8qMbTUWvZr2qpagSsAXvFYKjvqA1uUk5O1FS0gRoiOULa9UnmxcmSYD9RkYMgszkZCVoLBP05mQii1ofBQ/9i/bVyH2kj0v289HL/uybkkbkfwsRLFIjK98vsI8z3noLO78xrV81RRal5OQtxe1qBGiAyoba6ZuXJk6ylrPKpsxCQDSV+aQFDopbC/Na4OiR2MgtD0Enn4Ot52VmqP4sT8keW1gZy6bBPB2dEvWFtm6nK+zVBQhpP6hQI2QOqbJDExzoXmVUl4oaz3TZMakKG8ICsFXGsaV5rVBaZ4b9ESpgF4eWKkpJIVO4P2vgT7M342bqfk2dEvK1MYSTs7uNnBqb01LRRHyFqFAjZDXpCo9hqp1IjXNTVZ+rNksj1la1amyPGKVzZgszWuNaTsSFBLQysKByT2ccfCaSC7nmVhFzrO3QW2uGEBLRRHydqFAjZDXoKrL0k88BfvOWCkkb32vvR0OXsvQODeZbKzZi+IXGtdJ0zxilc2Y3DjGQy6PGiAfjM3r36reLFhek2jFAEJITaJAjZAqUrec0ra7y1AkHQOgDbc9I6cIm0+nypXVNDeZpdCy0nFlMtqkvFDXNdm/jR36uolVBmO6uGB5baMVAwghNY0CNUL+R5sM/5oM7hfaHkJpnhvUTa7WNDeZrbGtynFlMtWZ8kKGgjH1aMUAQkhNo0CNvFWUBWMAH5su/Ypdd79G7qunXFl1Gf4rSxrL4wE8/RwIKiSNVahPJbnJyo81E/AFSseViUXiNy4Tf31BKwYQQmoaBWrkraFsPJm5fkMUPm+LEpOy9SnLB0vqMvxXNWmsorLcZIaNd4Ax+esrG2v2tmTiry9oxQBCSE2jQI28FVSNJ8sueQooCdIA9Rn+q540VpGq3GSqxpq9TSkvdB2tGEAIqWkUqJF6qbrGkynrbiyvfIb/8sFRZUlj/1tOSTFprNI65rWBKd8DUYHmeF70lFrK6gnZigHKZn3K0IoBhJDXQYEaqXcqy+JfUWXjyTRRsatTXdJYGdlySpWR/YQv9W+Ddxq9fTnI6jtaMYAQUpMoUCN1SpuWMUCzLP5VHU+mjrKuTlVJY8UiMfqJJ2NfhhUyoD6PGvB2J4p9U9CKAYSQmsJjrOLyykQTubm5MDc3R05ODszMzOq6OvWSJi1jFbP4h10JUNk6JpshGTs0Vi7Yu5R5CRN+n1DleopFYoVzlvc6KxO8zYliCSGkLtS3329qUSPVTpNWMnXJYmUtY6V5reUy42uaxb8q48lk5MasMYDH41Wa4V/V4H5VOcgoN1n9VRvreRJCSHmVD6CpYd9++y0cHR1haGgILy8vxMfHqy0fFRUFV1dXGBkZwd7eHnPmzEFRUZFcmUePHmHMmDFo0KABjIyM0LZtW/z999/c/qCgIPB4PLlH//79a+T+3jZxaXHw2+uHCb9PwPy/5mPC7xPgt9cPcWlxXJnKksUyxvDZ6c8xbcffcl2EmmbxVzWeDPgv5cV/1yr7/5JnPcBKzeX2WRhYK+1KJfWPVMrwKOkFki9l4lHSC0il2nck3L2ShR8WnsOvX13Bn1tu4tevruCHhedw90pWDdSYEELK1GmL2u7duxESEoJNmzbBy8sLUVFR8PPzQ1JSEmxsFAfg7tq1C6Ghodi6dSu6dOmC5ORkLuiKjIwEALx48QJdu3ZFr169cPToUVhbWyMlJQWWlvJZwfv374/o6GjuuVBIeY5el6bjxyod3M8DCqXPwK+QLFbTLP7ajCezNLBG0eNByH/iipIn/SEQpcLSrAjjvdphqldfmnX5BqiOBdNpPU9CSF2p00AtMjISwcHBGD9+PABg06ZNOHz4MLZu3YrQ0FCF8ufOnUPXrl0REBAAAHB0dMSoUaNw8eJFrszq1athb28vF4Q5OSmmSBAKhRCLxdV9S28tda1kFfORVTVZrDZZ/JVRlSwW4JcbM9aFxoy9QaojwKL1PAkhdanOuj5LSkpw+fJl+Pr+163E5/Ph6+uL8+fPKz2mS5cuuHz5Mtc9eu/ePRw5cgQDBgzgyhw8eBCdOnXCsGHDYGNjA3d3d3z//fcK5zp58iRsbGzg6uqKadOm4dmzZ2rrW1xcjNzcXLkH+U9lrWTlx49VPVks/38pL+THlQHKs/grIxtPNqDZAHQWd4aAL+DGjL3foTG8nRtQkPaG0DTAqqwbVJv1PAkhpLrVWaD29OlTSCQS2Nraym23tbVFZmam0mMCAgKwbNkydOvWDfr6+nB2doaPjw8WLlzIlbl37x42btwIFxcX/P7775g2bRpmzpyJbdu2cWX69++PH374AceOHcPq1atx6tQpvPvuu5BIJCrrGxERAXNzc+5hb2//mq/Am0XTVrInhU/gYeMBM/2GCsGWDGOA9JXyZLGyLP4Vx5PZimxpPBmRU10BFq3nSQipS/Vq1ufJkyexcuVKbNiwAV5eXrhz5w5mzZqF5cuXY/HixQAAqVSKTp06YeXKlQAAd3d3JCYmYtOmTQgMDAQAjBw5kjtn27Zt0a5dOzg7O+PkyZPo06eP0msvWLAAISEh3PPc3Nw3IlhLSUlBXl4eJFIJbj+/jRdFL2BpaImWVi0h4AtgamoKFxeXSs+jaSuZtcgaAr4AAc4zsfHWEoX1LWXBm7pksZTFn2iiugIsWs+TEFKX6ixQa9iwIQQCAR4/lu8ue/z4scqxY4sXL8bYsWMxadIkAGVBVkFBASZPnozPPvsMfD4fdnZ2cHNzkzuuVatW2Lt3r8q6NGvWDA0bNsSdO3dUBmpCofCNm3CQkpKCFi1aVFouOTm50mCtshQYFcePTe08GDHnUlFouk9ufUtWao7ix/4ozWvzv+MgdzbK4k80VV0BFq3nSQipS3XW9WlgYICOHTvi2LFj3DapVIpjx47B29tb6TGFhYXg8+WrLBCUtaLI8vZ27doVSUlJcmWSk5Ph4OCgsi4PHz7Es2fPYGf3dv3w5+WVDdZfbWeHXxwcFR6r//d6yMqpoy4FhrLxYwI+D8v7jkLhnfl4mRaMl49GojAtGAV35kOS1wY8AFN6OEFsbih3LrG5ITaO8aAs/qRSsgBLHU0CLNl6nurQep6EkJpSp12fISEhCAwMRKdOneDp6YmoqCgUFBRws0DHjRuHxo0bIyIiAgDg7++PyMhIuLu7c12fixcvhr+/PxewzZkzB126dMHKlSsxfPhwxMfH47vvvsN3330HAMjPz0d4eDiGDh0KsViMu3fvYt68eWjevDn8/Pzq5oWoIxJp2Zg8ZwMh3AwNKy1XGVUpMGxFtpjvOV9h/Fj/NnbYOKYTwg+JVC6pNK9/K8riT6qkOhdMp/U8CSF1pU4DtREjRuDJkydYsmQJMjMz0aFDB8TGxnITDNLT0+Va0BYtWgQej4dFixbh0aNHsLa2hr+/P1asWMGV6dy5M/bv348FCxZg2bJlcHJyQlRUFEaPHg2grAXu+vXr2LZtG7Kzs9GoUSP069cPy5cvf+O6Nitz+/ltjct1hmLmfWVUpcBQNX6sfxs79G5pi+3n7yPteSEcrEQY6+0IA72y952y+JPXUZ0BFq3nSQipC7TWZxXVt7XClPn64NeY9f4s/OLgqLRF7WZRET5Mu491B9Zh5nsza6QOsYkZcstEAWWLl9Mi5aQ60dJPhBCZ+vb7Xa9mfZLqZWloWXkhLcppovyC5PefFiIqLllh6kFmThGm7UigsWik2vD5PDR2rb7PMSGE1BYK1N5iLa1aVmu5yihrPVOGoWx2Z/ihm+jrJqYxaYQQQt5aFKi9ZSRSCTd+7MydMwCAuyXK0w7ItldHfrLYxAxM25GgYhl2RQxARk4R4lOf0xg1Qgghby0K1N4icWlxcjMyizPLArH5GRlqjzM11WwxdFUkUobwQzc1DtLKy8pT3/pGCCGEvMkoUHuDlW89S89Lx4arG+SS0QrFQriscoG0SKpwrJXQCt/6fgsLcwuNViZQJz71eaXdnarYmKpOG0IIIYS86ShQe0NVbD1TRShWnpLkJV4CTQAXseZBWvmJAuVznlWlVYyHsnxqnk5WWh9LCCGEvCkoUHsDxaXFIeRkiNKlnLSh6ULrQNkYtKUHbyIzt1ziWjNDLH3PTetWMdnUgTB/N5pIQAgh5K1WZ0tIkZohkUqwKn7VawdpgOYLrccmZmDqjgS5IA0AMnOLMHVHAl4UFMPO3BCahly0TBQhhBBShlrU3jAJWQmVdndqQiwScwuoqyORMoTuu6G2zGe/JmLF4LaYvitB6SLrDMAcXxc4NjSmZaIIIYSQcihQe8No012pDJMy8Pg8uQXU1blw7xmyC1+pLfOi8BXMRfrYOMZDIY+amFYhIIQQQlSiQO0No2l3JYcxgPdf69WrF6/wof1UhQXUVTl/95nG5eb6uaKvm5gWWSeEEEI0RIHaG+ZF0Qu1+xlj4JULzGwlEnyYm4+mpaV4kfUKY9Y+Q4OdrbS4ojYpbGmRdUIIIUQbFKi9QSRSCdZcWlNpucHpz+FtKIW1RAKPomLIOjgTciUAA6xEBhpf07tZQ6w/cVejcoQQQgjRDgVqbxBNJhLweDy0zC3GAInqcWWtG5trfM13nBvAQqSvdpyahUgf71ArGiGEEKI1CtTeIJpOJLhZxC9rPavg1pOyFQq0GTMm4POwakhbTN2RoLLMqiFtaRwaIYQQUgVaB2qOjo6YMGECgoKC0LRp05qoE6kiTScSrIsrxMrbBSr3a7u2Z/82dtg0xgNLD/6DzNz/FngXmwmx9L3WNKOTEEIIqSIeY0yrzKhRUVGIiYlBYmIievXqhYkTJ+KDDz6AUKh8KaI3VW5uLszNzZGTkwMzM7O6rg6AsjFqfnv9kFWYpTThLQ88WBlY4csWX4IxHv55lIPnhSWwEhmgdWNzCPg8mJqaVnltT1VLSBFCCCG6Qhd/v9XROlCTSUhIQExMDH788UdIJBIEBARgwoQJ8PCoPEnqm0BX32jZ8lEA5II13v/WBYj0idQ49QYhhBDyptHV329Vqhyoybx69QobNmzA/Pnz8erVK7Rt2xYzZ87E+PHj5dJAvGl0+Y1WtiC7WCTGfM/5FKQRQgh5q+ny77cyVQ7UXr16hf379yM6Ohp//vkn3nnnHUycOBEPHz7Et99+i969e2PXrl3VXV+doetvtEQqQUJWAp4UPoG1yBoeNh4Q8AXUPUkIIeStpuu/3xVpPZkgISEB0dHR+PHHH8Hn8zFu3Dh89dVXaNmyJVfmgw8+QOfOnau1okQ7Ar4AncXy70FsYobCEk52tIQTIYQQorO0DtQ6d+6Mvn37YuPGjRg8eDD09fUVyjg5OWHkyJHVUkFSNRVbzl4UlGD6rgSFKQaZOUWYtiMBG8d4ULBGCCGE6Bituz7T0tLg4OBQU/WpN3S56fTI9QwsOpCI5wUl3DY+D5CqeKd5KFsc/cz83tQNSggh5I2my7/fyvC1PSArKwsXL15U2H7x4kX8/fff1VIpUnURR27io10JckEaoDpIA8pW4czIKUJ86vOarRwhhBBCtKJ1oDZ9+nQ8ePBAYfujR48wffr0aqkUqZoj1//F5tOpVT4+K6+o8kKEEEIIqTVaB2o3b95UmivN3d0dN2/erJZKEe1JpAyLDiS+1jlsTA2rqTaEEEIIqQ5aB2pCoRCPHysu/J2RkQE9PVo6tK7Epz7H8wLVC6Orw0PZ7E9PJ6vqrRQhVSCVMjxKeoHkS5l4lPQCUnX99oQQ8obTOrLq168fFixYgAMHDsDc3BwAkJ2djYULF6Jv377VXkGimap2W8qmDoT5u9FEAlLn7l7Jwl+7U1CQ/d+ascYWQnQf4QJnd5s6rBkhhNQNrVvUvvzySzx48AAODg7o1asXevXqBScnJ2RmZmLt2rU1UUeiAU27LSvGYmJzQ0rNQXTC3StZiN2cKBekAUBBdjFiNyfi7pWsOqoZIYTUHa1b1Bo3bozr169j586duHbtGoyMjDB+/HiMGjVKaU41Ujs8naxgZ24ol8xWma9HuKOBqZBWJiA6RSpl+Gt3itoyZ35OgVN7a/Dp80oIeYtUaVCZsbExJk+eXN11Ia9BwOchzN8N03YoJrWVmdLDCYM6NKrVehGiiYyUbIWWtIryXxQjIyUbjV0ta6lWhBBS96o8+v/mzZtIT09HSYl8vq733nvvtStFqqZ/GztsHOOhsEyUlbE+Pn+/DQa0oyCN6KaCXPVBmrblCCHkTaF1oHbv3j188MEHuHHjBng8HmQLG/B4Zd0REomkemtItNK/jR36uolp4XVSrxibCau1HCGEvCm0nkwwa9YsODk5ISsrCyKRCP/88w9Onz6NTp064eTJkzVQRaItAZ8Hb+cGeL9DY3g7N6Agjeg8OxcLGFuoD8JMLIWwc7GonQoRQoiO0DpQO3/+PJYtW4aGDRuCz+eDz+ejW7duiIiIwMyZM2uijqQKJFIJLmVewpF7R3Ap8xIkUmrpJLqLz+eh+wgXtWW6DXehiQSEkLeO1l2fEokEpqamAICGDRvi33//haurKxwcHJCUlFTtFSTai0uLw6r4VXhc+F9iYluRLUI9Q+Hr4FuHNSNENWd3G/Sf0kYhj5qJpRDdhlMeNULI20nrFrU2bdrg2rVrAAAvLy+sWbMGZ8+exbJly9CsWTOtK/Dtt9/C0dERhoaG8PLyQnx8vNryUVFRcHV1hZGREezt7TFnzhwUFcmnpHj06BHGjBmDBg0awMjICG3btpVbMJ4xhiVLlsDOzg5GRkbw9fVFSor61AD1RVxaHEJOhsgFaQCQVZiFkJMhiEuLq6OaEVI5Z3cbjFvZBYPnuKPvRDcMnuOOsSu6UJBGCHlraR2oLVq0CFKpFACwbNkypKamonv37jhy5Ai+/vprrc61e/duhISEICwsDAkJCWjfvj38/PyQlaU8seWuXbsQGhqKsLAw3Lp1C1u2bMHu3buxcOFCrsyLFy/QtWtX6Ovr4+jRo7h58ybWrl0LS8v/pvSvWbMGX3/9NTZt2oSLFy/C2NgYfn5+CgFffSORSrAqfhWYkgQdsm2r41dTNyjRaXw+D41dLdGisxiNXS2pu5MQ8lbjMdm0zdfw/PlzWFpacjM/NeXl5YXOnTtj/fr1AACpVAp7e3t8/PHHCA0NVSg/Y8YM3Lp1C8eOHeO2ffLJJ7h48SLOnDkDAAgNDcXZs2fx119/Kb0mYwyNGjXCJ598grlz5wIAcnJyYGtri5iYGIwcOVKjuufm5sLc3Bw5OTkwMzPT6r5ryqXMS5jw+4RKy23124rO4s61UCNCCCFEt+ji77c6WrWovXr1Cnp6ekhMTJTbbmVlpXWQVlJSgsuXL8PX978xU3w+H76+vjh//rzSY7p06YLLly9z3aP37t3DkSNHMGDAAK7MwYMH0alTJwwbNgw2NjZwd3fH999/z+1PTU1FZmam3HXNzc3h5eWl8roAUFxcjNzcXLmHrnlS+KRayxFCCCGkbmkVqOnr66Np06bVkivt6dOnkEgksLW1ldtua2uLzMxMpccEBARg2bJl6NatG/T19eHs7AwfHx+5rs979+5h48aNcHFxwe+//45p06Zh5syZ2LZtGwBw59bmugAQEREBc3Nz7mFvb1+l+65J1iLrai1HCCGEkLql9Ri1zz77DAsXLsTz589roj5qnTx5EitXrsSGDRuQkJCAffv24fDhw1i+fDlXRiqVwsPDAytXroS7uzsmT56M4OBgbNq06bWuvWDBAuTk5HCPBw8evO7tVDsPGw/YimzBg/LWTR54EIvE8LDxqOWaEUIIIaQqtE7PsX79ety5cweNGjWCg4MDjI2N5fYnJCRodJ6GDRtCIBDg8WP52YmPHz+GWCxWeszixYsxduxYTJo0CQDQtm1bFBQUYPLkyfjss8/A5/NhZ2cHNzc3ueNatWqFvXv3AgB37sePH8POzk7uuh06dFBZX6FQCKFQt7OiC/gChHqGIuRkiMI+WfA233M+BHxBbVeNEABli69npGSjILcYxmZlCWxpsgAhhKimdaA2ePDgarmwgYEBOnbsiGPHjnHnlEqlOHbsGGbMmKH0mMLCQvD58o2AAkFZ0CGbE9G1a1eFfG7JyclwcHAAADg5OUEsFuPYsWNcYJabm4uLFy9i2rRp1XJvdak0rzWEz4NQaLoPfP0cbru5fkOEdV1IedRInbl7JUshR5qxhRDdR1CONEIIUUXrQC0sLKzaLh4SEoLAwEB06tQJnp6eiIqKQkFBAcaPHw8AGDduHBo3boyIiAgAgL+/PyIjI+Hu7g4vLy/cuXMHixcvhr+/PxewzZkzB126dMHKlSsxfPhwxMfH47vvvsN3330HoGxN0tmzZ+Pzzz+Hi4sLnJycsHjxYjRq1KjagtC6EpuYgWk7EsDgCjyeD4EoFTy9PKDUFPmFTiht17quq0jeUnevZCF2c6LC9oLsYsRuTkT/KW0oWCOEECW0DtSq04gRI/DkyRMsWbIEmZmZ6NChA2JjY7mB/unp6XItaIsWLQKPx8OiRYvw6NEjWFtbw9/fHytWrODKdO7cGfv378eCBQuwbNkyODk5ISoqCqNHj+bKzJs3j+syzc7ORrdu3RAbGwtDQ8Pau/lqJpEyhB+6WS6DGh+SQmfuGQ9A+KGb6OsmprU/Sa2SShn+2q0+ofSZn1Pg1N6aukEJIaQCrfOo8fl8tak4qmNGaH2ga3lYzt99hlHfX6i03I/B78DbuUEt1IiQMo+SXuDXr65UWm7wHHc0drWstBwhhLwOXfv9rozWLWr79++Xe/7q1StcuXIF27ZtQ3h4eLVVjGgnK0+zVRU0LUdIdSnILa68kBblCCHkbaJ1oPb+++8rbPvwww/RunVr7N69GxMnTqyWihHt2Jhq1m2raTlCqouxmWazpTUtRwghbxOt86ip8s4778gt7URql6eTFezMDVVkUCsbo2ZnbghPJ6varBYhsHOxgLGF+iDMxLIsVQchhBB51RKovXz5El9//TUaN25cHacjVSDg8xDmX5Y/rmKwJnse5u9GEwlIrePzeeg+wkVtmW7DXWgiASGEKKF112fFxdcZY8jLy4NIJMKOHTuqtXJEO/3b2GHjGA+EH7qJjJz/xqKJzQ0R5u+G/m3s1BxNSM1xdrdB/yltFPKomVgK0W045VEjhBBVtJ71GRMTIxeo8fl8WFtbw8vLC5aWb8+MLV2eNSKRMsSnPkdWXhFsTMu6O6kljegCWpmAEFLXdPn3WxmtAzVSpr690YQQQgipf7/fWo9Ri46Oxp49exS279mzB9u2bauWShFCCCGEkCoEahEREWjYsKHCdhsbG6xcubJaKkUIIYQQQqoQqKWnp8PJyUlhu4ODA9LT06ulUoQQQgghpAqBmo2NDa5fv66w/dq1a2jQgJYmIoQQQgipLloHaqNGjcLMmTNx4sQJSCQSSCQSHD9+HLNmzcLIkSNroo6EEEIIIW8lrfOoLV++HPfv30efPn2gp1d2uFQqxbhx42iMGiGEEEJINapyeo6UlBRcvXoVRkZGaNu2LRwcHKq7bjqtvk3vJYQQQkj9+/3WukVNxsXFBS4u6peFIYQQQgghVaf1GLWhQ4di9erVCtvXrFmDYcOGVUulCCGEEEJIFQK106dPY8CAAQrb3333XZw+fbpaKkUIqZ+kUoZHSS+QfCkTj5JeQCqlhU8IIeR1aN31mZ+fDwMDA4Xt+vr6yM3NrZZKEULqn7tXshQWXTe2EKL7CFp0nRBCqkrrFrW2bdti9+7dCtt/+uknuLm5VUulCCH1y90rWYjdnCgXpAFAQXYxYjcn4u6VrDqqGSGE1G9at6gtXrwYQ4YMwd27d9G7d28AwLFjx7Br1y788ssv1V5BQohuk0oZ/tqdorbMmZ9T4NTeGnw+r5ZqRQghbwatAzV/f3/8+uuvWLlyJX755RcYGRmhffv2OH78OKysrGqijoQQHZaRkq3QklZR/otiZKRko7GrZS3VihBC3gxVSs8xcOBADBw4EEBZPpIff/wRc+fOxeXLlyGRSKq1goQQ3VaQqz5I07YcIYSQ/2g9Rk3m9OnTCAwMRKNGjbB27Vr07t0bFy5cqM66EULqAWMzYbWWI4QQ8h+tWtQyMzMRExODLVu2IDc3F8OHD0dxcTF+/fVXmkhAyFvKzsUCxhZCtd2fJpZC2LlY1F6lCCHkDaFxi5q/vz9cXV1x/fp1REVF4d9//8U333xTk3UjhNQDfD4P3UeoX6Wk23AXmkhACCFVoHGL2tGjRzFz5kxMmzaNlo4ihMhxdrdB/yltFPKomVgK0W045VEjhJCq0jhQO3PmDLZs2YKOHTuiVatWGDt2LEaOHFmTdSOE1CPO7jZwam9dNgs0txjGZmXdndSSRgghVcdjjGm1xktBQQF2796NrVu3Ij4+HhKJBJGRkZgwYQJMTU1rqp46Jzc3F+bm5sjJyYGZmVldV4eQSqWkpCAvLw9SKcPT9Dy8LCiBkbEBGjY1BZ/Pg6mpKbWWE0LeePXt91vrQK28pKQkbNmyBdu3b0d2djb69u2LgwcPVmf9dFZ9e6PJ2y0lJQUtWrSotFxycjIFa4SQN1p9+/2uUh41GVdXV6xZswYRERE4dOgQtm7dWl31IlUgkUqQkJWAJ4VPYC2yhoeNBwR8QV1Xi+iAvLw8AECAVwfYmJko7M/Kzceui1e5coQQQnTDawVqMgKBAIMHD8bgwYOr43SkCuLS4rAqfhUeFz7mttmKbBHqGQpfB986rBnRBVJpWcO5jZkJmliaV1qOEEKIbqhywluiO+LS4hByMkQuSAOArMIshJwMQVxaXB3VjOiKp+matZRpWo4QQkjtoECtnpNIJVgVvwoMii0hsm2r41dDIqWlvd5mLwtKqrUcIYSQ2kGBWj2XkJWg0JJWHgNDZmEmErISarFWRNcYGRtUazlCCCG1gwK1eu5J4ZNqLUfeTA2bapY6R9NyhBBCake1TCYgdcdaZF2t5cibSZZ0Nis3X+l+2XZKTksIIbpFJ1rUvv32Wzg6OsLQ0BBeXl6Ij49XWz4qKgqurq4wMjKCvb095syZg6KiIm7/0qVLwePx5B4tW7aUO4ePj49CmalTp9bI/dUkDxsP2IpswYPyH1geeBCLxPCw8ajlmhFdIktGveviVUT9eUbhseviVblyhBBCdEOdt6jt3r0bISEh2LRpE7y8vBAVFQU/Pz8kJSXBxkZxfcBdu3YhNDQUW7duRZcuXZCcnIygoCDweDxERkZy5Vq3bo24uP9mO+rpKd5qcHAwli1bxj0XiUTVfHc1T8AXINQzFCEnQ8ADT25SgSx4m+85n/KpveVcXFyQnJxMKxMQQkg9U+eBWmRkJIKDgzF+/HgAwKZNm3D48GFs3boVoaGhCuXPnTuHrl27IiAgAADg6OiIUaNG4eLFi3Ll9PT0IBaL1V5bJBJVWqY+8HXwRaRPpNI8avM951MeNQIA8kFYp7qrByGEEM3VaddnSUkJLl++DF/f/wIJPp8PX19fnD9/XukxXbp0weXLl7nu0Xv37uHIkSMYMGCAXLmUlBQ0atQIzZo1w+jRo5Genq5wrp07d6Jhw4Zo06YNFixYgMLCQpV1LS4uRm5urtxDl/g6+OL3ob9jq99WrO6+Glv9tiJ2aCwFaYQQQkg9Vqctak+fPoVEIoGtra3cdltbW9y+fVvpMQEBAXj69Cm6desGxhhKS0sxdepULFy4kCvj5eWFmJgYuLq6IiMjA+Hh4ejevTsSExO5MTgBAQFwcHBAo0aNcP36dcyfPx9JSUnYt2+f0utGREQgPDy8mu68Zgj4AnQWd67rahBCCCGkmrzWouyv699//0Xjxo1x7tw5eHt7c9vnzZuHU6dOKXRnAsDJkycxcuRIfP755/Dy8sKdO3cwa9YsBAcHY/HixUqvk52dDQcHB0RGRmLixIlKyxw/fhx9+vTBnTt34OzsrLC/uLgYxcXF3PPc3FzY29vXm0VdCSGEEPKWLcr+uho2bAiBQIDHj+UTtj5+/Fjl2LHFixdj7NixmDRpEgCgbdu2KCgowOTJk/HZZ5+Bz1fszbWwsECLFi1w584dlXXx8vICAJWBmlAohFAo1PjeCCGEEEJeV52OUTMwMEDHjh1x7NgxbptUKsWxY8fkWtjKKywsVAjGBIKyGY2qGgfz8/Nx9+5d2NnZqazL1atXAUBtGUIIIYSQ2lTnsz5DQkIQGBiITp06wdPTE1FRUSgoKOBmgY4bNw6NGzdGREQEAMDf3x+RkZFwd3fnuj4XL14Mf39/LmCbO3cu/P394eDggH///RdhYWEQCAQYNWoUAODu3bvYtWsXBgwYgAYNGuD69euYM2cOevTogXbt2tXNC0EIqVUSiQSvXr2q62oQQqqZvr4+Fw+8Ceo8UBsxYgSePHmCJUuWIDMzEx06dEBsbCw3wSA9PV2uBW3RokXg8XhYtGgRHj16BGtra/j7+2PFihVcmYcPH2LUqFF49uwZrK2t0a1bN1y4cAHW1mXZ+Q0MDBAXF8cFhfb29hg6dCgWLVpUuzdPCKl1jDFkZmYiOzu7rqtCCKkhFhYWEIvF4PHq/2ordTqZoD6rb4MRCSFlMjIykJ2dDRsbG4hEojfiDzkhpAxjDIWFhcjKyoKFhYXS4Uz17fe7zlvUCCGktkgkEi5Ia9CgQV1XhxBSA4yMjAAAWVlZsLGxqffdoBSoEVIHpFKGjJRsFOQWw9hMCDsXC1oQvRbIxqTVx+XiCCGak33HX716RYEaIUQ7d69k4a/dKSjI/i8vn7GFEN1HuMDZXXF9W1L9qLuTkDfbm/Qdr9P0HIS8be5eyULs5kS5IA0ACrKLEbs5EXevZNVRzQghhOgiCtQIqSVSKcNfu1PUljnzcwqkUprfQ95sS5cuRYcOHbQ6xtHREVFRUVW+ZkxMDCwsLKp8fE3w8fHB7Nmz1Zapar2DgoIwePDgKtXrdWhyT5XR5PNRV/dXFyhQI6SWZKRkK7SkVZT/ohgZKdm1UyFSbwQFBYHH44HH40FfXx+2trbo27cvtm7dCqlUqtW5qhIkVbe5c+fKJTrXxKVLlzB58mSNyioL6kaMGIHk5GStrlleTEwMeDweWrVqpbBvz5494PF4cHR0rPL5garV+/79++DxeFzSdvLmoUCNkFpSkKs+SNO2HKk7EinD+bvPcODqI5y/+wySWmgF7d+/PzIyMnD//n0cPXoUvXr1wqxZszBo0CCUlpbW+PUrKikpqfKxJiYmWs+6tba2fq1JIEZGRrCxeb0xoMbGxsjKysL58+fltm/ZsgVNmzZ9rXOrUh311tTrvKek5lCgRkgtMTbTbK1YTcuRuhGbmIFuq49j1PcXMOunqxj1/QV0W30csYkZNXpdoVAIsViMxo0bw8PDAwsXLsSBAwdw9OhRxMTEcOWys7MxadIkWFtbw8zMDL1798a1a9cAlLUKhYeH49q1a1wLnexYdccB/7XE/d///R+cnJxgaGgIoGzQ9ubNmzFo0CCIRCK0atUK58+fx507d+Dj4wNjY2N06dIFd+/eVTiXjKwb68svv4SdnR0aNGiA6dOny60cUb61iTGGpUuXomnTphAKhWjUqBFmzpwJoKzrLS0tDXPmzOHuUXbvFbsQDx06hM6dO8PQ0BANGzbEBx98oPY90NPTQ0BAALZu3cpte/jwIU6ePImAgAC5ssq65mbPng0fHx+l59am3uU5OTkBANzd3cHj8RTOX9lrunz5cowbNw5mZmZci+WZM2fQvXt3GBkZwd7eHjNnzkRBQQF33IYNG+Di4gJDQ0PY2triww8/lLumVCrFvHnzYGVlBbFYjKVLl8rtT09Px/vvvw8TExOYmZlh+PDhCmt+lyeRSBASEgILCws0aNAA8+bNU7lk5JuIAjVCaomdiwWMLdQHYSaWZak6iG6KTczAtB0JyMgpktuemVOEaTsSajxYq6h3795o37499u3bx20bNmwYsrKycPToUVy+fBkeHh7o06cPnj9/jhEjRuCTTz5B69atkZGRgYyMDIwYMaLS42Tu3LmDvXv3Yt++fXJdbbIf+6tXr6Jly5YICAjAlClTsGDBAvz9999gjGHGjBlq7+XEiRO4e/cuTpw4gW3btiEmJkYuAC1v7969+Oqrr7B582akpKTg119/Rdu2bQEA+/btQ5MmTbBs2TLuHpU5fPgwPvjgAwwYMABXrlzBsWPH4OnpWelrPmHCBPz8888oLCwEUBZI9e/fn1tNp6o0rXdF8fHxAIC4uDhkZGTIfRY0eU2//PJLtG/fHleuXMHixYtx9+5d9O/fH0OHDsX169exe/dunDlzhnv//v77b8ycORPLli1DUlISYmNj0aNHD7lzbtu2DcbGxrh48SLWrFmDZcuW4c8//wRQFsS9//77eP78OU6dOoU///wT9+7d4z6HyqxduxYxMTHYunUrzpw5g+fPn2P//v0avT5vAkrPQUgt4fN56D7CBbGbE1WW6TbchfKp6SiJlCH80E0o+3c8A8ADEH7oJvq6iSGoxfewZcuWuH79OoCylpD4+HhkZWVBKCz7R8GXX36JX3/9Fb/88gsmT54MExMT6OnpQSwWc+fQ5DigrGvshx9+4Jbjkxk/fjyGDx8OAJg/fz68vb2xePFi+Pn5AQBmzZrFrd+siqWlJdavXw+BQICWLVti4MCBOHbsGIKDgxXKpqenQywWw9fXF/r6+mjatCkXZFlZWUEgEMDU1FTuHitasWIFRo4cifDwcG5b+/bt1dYRKGu5atasGX755ReMHTsWMTExiIyMxL179yo9Vh1N612R7L1o0KCBwnGavKa9e/fGJ598wj2fNGkSRo8ezU0IcHFxwddff42ePXti48aNSE9Ph7GxMQYNGgRTU1M4ODjA3d1d7rrt2rVDWFgYd/z69etx7Ngx9O3bF8eOHcONGzeQmpoKe3t7AMAPP/yA1q1b49KlS+jcubPCPUZFRWHBggUYMmQIAGDTpk34/fffNX6N6jtqUSOkFjm726D/lDYKLWsmlkL0n9KG8qjpsPjU5wotaeUxABk5RYhPfa6yTE1gjHHdZNeuXUN+fj4aNGgAExMT7pGamirX9ViRpsc5ODgoBGlA2Q+zjKxlSdbCJdtWVFSE3NxclXVo3bq1XGJSOzs7ZGUpT1czbNgwvHz5Es2aNUNwcDD279+v9Ti9q1evok+fPlodIzNhwgRER0fj1KlTKCgowIABA6p0npqmyWvaqVMnuefXrl1DTEyM3OfAz88PUqkUqamp6Nu3LxwcHNCsWTOMHTsWO3fu5FoXZcp/Hipe99atW7C3t+eCNABwc3ODhYUFbt26pXAPOTk5yMjIgJeXF7dNT09Pod5vMmpRI6SWObvbwKm9Na1MUM9k5akO0qpSrrrcunWLG6eUn58POzs7nDx5UqGcunFOmh5nbGys9Hh9fX3uv2VBo7Jt6maoli8vO0ZVeXt7eyQlJSEuLg5//vknPvroI3zxxRc4deqUwnlUkS0zVBWjR4/GvHnzsHTpUowdOxZ6eoo/pXw+X2EcVfnxYbVBk9e04nuan5+PKVOmcGP+ymvatCkMDAyQkJCAkydP4o8//sCSJUuwdOlSXLp0ifusaPNekspRoEZIHeDzeWjsalnX1SBasDE1rNZy1eH48eO4ceMG5syZAwDw8PBAZmYm9PT0VKaKMDAwgEQikdumyXG6xsjICP7+/vD398f06dPRsmVL3LhxAx4eHkrvsaJ27drh2LFjlXbJKmNlZYX33nsPP//8MzZt2qS0jLW1NRIT5Yc5XL16VW0gqUm9lR0DQOvjVPHw8MDNmzfRvHlzlWX09PTg6+sLX19fhIWFwcLCAsePH+e6JtVp1aoVHjx4gAcPHnCtajdv3kR2djbc3NwUypubm8POzg4XL17kxsKVlpZy4yjfBtT1SQghGvB0soKduSFUtXvyANiZG8LTyapGrl9cXIzMzEw8evQICQkJWLlyJd5//30MGjQI48aNAwD4+vrC29sbgwcPxh9//IH79+/j3Llz+Oyzz/D3338DKJvpl5qaiqtXr+Lp06coLi7W6DhdEhMTgy1btiAxMRH37t3Djh07YGRkBAcHBwBl93j69Gk8evQIT58+VXqOsLAw/PjjjwgLC8OtW7dw48YNrF69Wqs6PH36FC1btlS6v3fv3vj777/xww8/ICUlBWFhYQqBW0Wa1LsiGxsbGBkZITY2Fo8fP0ZOTo7G96DM/Pnzce7cOcyYMQNXr15FSkoKDhw4wE0m+O233/D111/j6tWrSEtLww8//ACpVApXV1eNzu/r64u2bdti9OjRSEhIQHx8PMaNG4eePXuq7M6cNWsWVq1ahV9//RW3b9/GRx99hOzs7Ne6z/qEAjVCCNGAgM9DmH/Zv/grBmuy52H+bjU2kSA2NhZ2dnZwdHRE//79ceLECXz99dc4cOAANw6Jx+PhyJEj6NGjB8aPH48WLVpg5MiRSEtL48aODR06FP3790evXr1gbW2NH3/8UaPjdImFhQW+//57dO3aFe3atUNcXBwOHTrE5WZbtmwZ7t+/D2dnZ6Vj6oCydBh79uzBwYMH0aFDB/Tu3ZubQakJIyMjtbng/Pz8sHjxYsybNw+dO3dGXl4eF1Crokm9K9LT08PXX3+NzZs3o1GjRnj//fc1vgdl2rVrh1OnTiE5ORndu3eHu7s7lixZgkaNGgEoe+337duH3r17o1WrVti0aRN+/PFHtG7dWqPz83g8HDhwAJaWlujRowd8fX3RrFkz7N69W+Uxn3zyCcaOHYvAwEB4e3vD1NS00lQqbxIee5uSkVSj3NxcmJubIycnB2ZmZnVdHUKIBoqKipCamiqXB0xbsYkZCD90U25igZ25IcL83dC/jV11VZUQ8hrUfdfr2+83jVEjhBAt9G9jh75uYsSnPkdWXhFsTMu6O2szJQch5O1BgRohhGhJwOfB21m7JZAIIaQqaIwaIYQQQoiOokCNEEIIIURHUaBGCCGEEKKjKFAjhBBCCNFRFKgRQgghhOgoCtQIIYQQQnQUBWqEEEIIITqKAjVCCHnL+fj4YPbs2XVy7ZMnT4LH4+nM2o33798Hj8fD1atXAehe/cjbhwI1QgjRcaoCqZiYGFhYWNR6fd6m4KVLly7IyMiAubm5RuXrMuglbyZamYAQQjSUkpKCvLw8lftNTU3h4uJSizUiqrx69Qr6+vqvfR4DAwOIxeJqqJF2SkpKYGBgUOvXJbqHWtQIIUQDKSkpaNGiBTp27Kjy0aJFC6SkpNRZHYOCgjB48GCEh4fD2toaZmZmmDp1KkpKSrgyBQUFGDduHExMTGBnZ4e1a9cqnGf79u3o1KkTTE1NIRaLERAQgKysLABlXYO9evUCAFhaWoLH4yEoKAgAIJVKERERAScnJxgZGaF9+/b45Zdf5M595MgRtGjRAkZGRujVqxfu379f6X3xeDxs3LgR7777LoyMjNCsWTO588q6K3fv3o2ePXvC0NAQO3fuBAD83//9H1q1agVDQ0O0bNkSGzZskDt3fHw83N3dYWhoiE6dOuHKlSty+5W1Hp49exY+Pj4QiUSwtLSEn58fXrx4gaCgIJw6dQrr1q0Dj8cDj8fj7u/UqVPw9PSEUCiEnZ0dQkNDUVpayp3Tx8cHM2bMwOzZs9GwYUP4+flV+rqQtwO1qBFCiAZkLWk7PjBCK2vFf+PeeiLFmP0v1ba41YZjx47B0NAQJ0+exP379zF+/Hg0aNAAK1asAAB8+umnOHXqFA4cOAAbGxssXLgQCQkJ6NChA3eOV69eYfny5XB1dUVWVhZCQkIQFBSEI0eOwN7eHnv37sXQoUORlJQEMzMzGBkZAQAiIiKwY8cObNq0CS4uLjh9+jTGjBkDa2tr9OzZEw8ePMCQIUMwffp0TJ48GX///Tc++eQTje5r8eLFWLVqFdatW4ft27dj5MiRuHHjBlq1asWVCQ0Nxdq1a7nAa+fOnViyZAnWr18Pd3d3XLlyBcHBwTA2NkZgYCDy8/MxaNAg9O3bFzt27EBqaipmzZqlth5Xr15Fnz59MGHCBKxbtw56eno4ceIEJBIJ1q1bh+TkZLRp0wbLli0DAFhbW+PRo0cYMGAAgoKC8MMPP+D27dsIDg6GoaEhli5dyp1727ZtmDZtGs6ePavRa0LeEoxUSU5ODgPAcnJy6roqhBANvXz5kt28eZO9fPlS62MvX77MALDLk40ZCzNTeFyebFy2//Llaq93z5492axZsxS2R0dHM3Nzc+55YGAgs7KyYgUFBdy2jRs3MhMTEyaRSFheXh4zMDBgP//8M7f/2bNnzMjISOn5ZS5dusQAsLy8PMYYYydOnGAA2IsXL7gyRUVFTCQSsXPnzskdO3HiRDZq1CjGGGMLFixgbm5ucvvnz5+vcK6KALCpU6fKbfPy8mLTpk1jjDGWmprKALCoqCi5Ms7OzmzXrl1y25YvX868vb0ZY4xt3ryZNWjQQO7zsHHjRgaAXblyRem9jho1inXt2lVlXZW9VwsXLmSurq5MKpVy27799lvufZEd5+7urvK8RDvqvuv17febWtQIIeQN0r59e4hEIu65t7c38vPz8eDBA2RnZ6OkpAReXl7cfisrK7i6usqd4/Lly1i6dCmuXbuGFy9eQCqVAgDS09Ph5uam9Lp37txBYWEh+vbtK7e9pKQE7u7uAIBbt27JXVtWP01ULOft7c3NzJTp1KkT998FBQW4e/cuJk6ciODgYG57aWkpNzHg1q1baNeuHQwNDTWuz9WrVzFs2DCN6ixz69YteHt7g8fjcdu6du2K/Px8PHz4EE2bNgUAdOzYUavzkrcDBWqEEKLjzMzMkJOTo7A9Oztb49mImiooKICfnx/8/Pywc+dOWFtbIz09HX5+fnJj3SrKz88HABw+fBiNGzeW2ycUCqu1jqoYGxsr1Of7779XCA4FAkGVryHr5q0J5etPiAxNJiCEEB3n6uqKhIQEhe0JCQlo0aKF3LZr167h5cuX3PMLFy7AxMQE9vb2cHZ2hr6+Pi5evMjtf/HiBZKTk7nnt2/fxrNnz7Bq1Sp0794dLVu25CYSyMhmI0okEm6bm5sbhEIh0tPT0bx5c7mHvb09AKBVq1aIj4+XO9eFCxc0eg0qlrtw4YLc+LSKbG1t0ahRI9y7d0+hPk5OTlx9rl+/jqKiIo3r065dOxw7dkzlfgMDA7nXRXad8+fPgzHGbTt79ixMTU3RpEkTtdcjhAI1QgjRcdOmTUNycjJmzpyJ69evIykpCZGRkfjxxx8VBuOXlJRg4sSJuHnzJo4cOYKwsDDMmDEDfD4fJiYmmDhxIj799FMcP34ciYmJCAoKAp//309B06ZNYWBggG+++Qb37t3DwYMHsXz5crlrODg4gMfj4bfffsOTJ0+Qn58PU1NTzJ07F3PmzMG2bdtw9+5dJCQk4JtvvsG2bdsAAFOnTkVKSgo+/fRTJCUlYdeuXYiJidHoNdizZw+2bt2K5ORkhIWFIT4+HjNmzFB7THh4OCIiIvD1118jOTkZN27cQHR0NCIjIwEAAQEB4PF4CA4O5l6vL7/8Uu05FyxYgEuXLuGjjz7C9evXcfv2bWzcuBFPnz4FADg6OuLixYu4f/8+nj59CqlUio8++ggPHjzAxx9/jNu3b+PAgQMICwtDSEiI3GtPiFJ1PUiuvqpvgxEJIdUzmWDHB0bs8mRjhceOD4xqbDIBY4zFx8ezvn37Mmtra2Zubs68vLzY/v375coEBgay999/ny1ZsoQ1aNCAmZiYsODgYFZUVMSVycvLY2PGjGEikYjZ2tqyNWvWKAyA37VrF3N0dGRCoZB5e3uzgwcPyg2wZ4yxZcuWMbFYzHg8HgsMDGSMMSaVSllUVBRzdXVl+vr6zNramvn5+bFTp05xxx06dIg1b96cCYVC1r17d7Z161aNJhN8++23rG/fvkwoFDJHR0e2e/dubr9sMkH5+sns3LmTdejQgRkYGDBLS0vWo0cPtm/fPm7/+fPnWfv27ZmBgQHr0KED27t3r9rJBIwxdvLkSdalSxcmFAqZhYUF8/Pz4/YnJSWxd955hxkZlX0eUlNTuWM6d+7MDAwMmFgsZvPnz2evXr3izqlqwgipmjdpMoFOBGrr169nDg4OTCgUMk9PT3bx4kW15b/66ivWokULZmhoyJo0acJmz54t92aEhYUxAHIPV1dXuXO8fPmSffTRR8zKyooZGxuzIUOGsMzMTI3rXN/eaELI6wVqycnJCn9XlD2Sk5NroOaakQVqbxoACkEpIeq8SYFanU8m2L17N0JCQrBp0yZ4eXkhKioKfn5+SEpKgo2NjUL5Xbt2ITQ0FFu3bkWXLl2QnJyMoKAg8Hg8rjkbAFq3bo24uDjuuZ6e/K3OmTMHhw8fxp49e2Bubo4ZM2ZgyJAhlL+GEKKUi4sLkpOTaWUCQkitqvNALTIyEsHBwRg/fjwAYNOmTTh8+DC2bt2K0NBQhfLnzp1D165dERAQAKBsPMCoUaPkBscCZYGZqmU/cnJysGXLFuzatQu9e/cGAERHR6NVq1a4cOEC3nnnneq8RULIG4KCMEJIbavTUYwlJSW4fPkyfH19uW18Ph++vr44f/680mO6dOmCy5cvczOH7t27hyNHjmDAgAFy5VJSUtCoUSM0a9YMo0ePRnp6Orfv8uXLePXqldx1W7ZsiaZNm6q8bnFxMXJzc+UehBCiS2JiYvDrr7/WdTWqHWMMgwcPrutqEFIn6rRF7enTp5BIJLC1tZXbbmtri9u3bys9JiAgAE+fPkW3bt3AGENpaSmmTp2KhQsXcmW8vLwQExMDV1dXZGRkIDw8HN27d0diYiJMTU2RmZkJAwMDWFhYKFw3MzNT6XUjIiIQHh7+ejdMCCGEEKKFejcv+OTJk1i5ciU2bNiAhIQE7Nu3D4cPH5abPv7uu+9i2LBhaNeuHfz8/HDkyBFkZ2fj559/rvJ1FyxYgJycHO7x4MGD6rgdQgghhBCV6rRFrWHDhhAIBHj8+LHc9sePH6scX7Z48WKMHTsWkyZNAgC0bdsWBQUFmDx5Mj777DOlOWksLCzQokUL3LlzBwAgFotRUlKC7OxsuVY1ddcVCoW1ll2bEEIIIQSo4xY1AwMDdOzYUS7Ls1QqxbFjx1Sut1ZYWKgQjMmWA2Hlsj6Xl5+fj7t378LOzg5A2Xpq+vr6ctdNSkpCenq6xuvOEUIIIYTUtDqf9RkSEoLAwEB06tQJnp6eiIqKQkFBATcLdNy4cWjcuDEiIiIAAP7+/oiMjIS7uzu8vLxw584dLF68GP7+/lzANnfuXPj7+8PBwQH//vsvwsLCIBAIMGrUKACAubk5Jk6ciJCQEFhZWcHMzAwff/wxvL29acYnIYQQQnRGnQdqI0aMwJMnT7BkyRJkZmaiQ4cOiI2N5SYYpKeny7WgLVq0CDweD4sWLcKjR49gbW0Nf39/rFixgivz8OFDjBo1Cs+ePYO1tTW6deuGCxcuwNramivz1Vdfgc/nY+jQoSguLoafnx82bNhQezdOCCGEEFIJHlPVX0jUys3Nhbm5OXJycmBmZlbX1SGEaKCoqAipqalwcnKCoaFhXVen3uDxeNi/f3+Npsi4f/8+nJyccOXKFXTo0KFGrhETE4PZs2cjOzu7Rs5PdIe673p9+/2ud7M+CSHkbSNbfYXH40FfXx9OTk6YN28eioqK6rpq1cbe3h4ZGRlo06ZNXVelxqWnp2PgwIEQiUSwsbHBp59+itLSUrXHODo6cp8B2WPVqlW1VGNSl+q865MQQuobiVSChKwEPCl8AmuRNTxsPCDgC2r0mv3790d0dDRevXqFy5cvIzAwEDweD6tXr67R69YWgUCgctb9m0QikWDgwIEQi8U4d+4cMjIyMG7cOOjr62PlypVqj122bBmCg4O556ampjVdXaIDqEWNEEK0EJcWB7+9fpjw+wTM/2s+Jvw+AX57/RCXFlf5wa9BKBRCLBbD3t4egwcPhq+vL/78809u/7NnzzBq1Cg0btwYIpEIbdu2xY8//ih3Dh8fH8ycORPz5s2DlZUVxGIxli5dKlcmJSUFPXr0gKGhIdzc3OSuIXPjxg307t0bRkZGaNCgASZPnoz8/Hxuf1BQEAYPHoyVK1fC1tYWFhYWWLZsGUpLS/Hpp5/CysoKTZo0QXR0NHfM/fv3wePxcPXqVe4cFVuQeDweTp48CaBstZi5c+eicePGMDY2hpeXF7dPJiYmBk2bNoVIJMIHH3yAZ8+eaf26+/j4YMaMGZgxYwbMzc3RsGFDLF68WGWWgcr88ccfuHnzJnbs2IEOHTrg3XffxfLly/Htt9+ipKRE7bGmpqYQi8Xcw9jYuEp1IPULBWqEEKKhuLQ4hJwMweNC+dyPWYVZCDkZUuPBmkxiYiLOnTsHAwMDbltRURE6duyIw4cPIzExEZMnT8bYsWO55fZktm3bBmNjY1y8eBFr1qzBsmXLuGBMKpViyJAhMDAwwMWLF7Fp0ybMnz9f7viCggL4+fnB0tISly5dwp49exAXF4cZM2bIlTt+/Dj+/fdfnD59GpGRkQgLC8OgQYNgaWmJixcvYurUqZgyZQoePnyo9B7XrVuHjIwM7jFr1izY2NigZcuWAIAZM2bg/Pnz+Omnn3D9+nUMGzYM/fv3R0pKCgDg4sWLmDhxImbMmIGrV6+iV69e+Pzzz6v0em/btg16enqIj4/HunXrEBkZif/7v//j9k+dOhUmJiZqHzLnz59H27Zt5Vbk8fPzQ25uLv755x+19Vi1ahUaNGgAd3d3fPHFF5V2l5I3BCNVkpOTwwCwnJycuq4KIURDL1++ZDdv3mQvX77U+thSSSnr83Mf1iamjdJH25i2zPdnX1YqKa32egcGBjKBQMCMjY2ZUChkABifz2e//PKL2uMGDhzIPvnkE+55z549Wbdu3eTKdO7cmc2fP58xxtjvv//O9PT02KNHj7j9R48eZQDY/v37GWOMfffdd8zS0pLl5+dzZQ4fPsz4fD7LzMzk6uvg4MAkEglXxtXVlXXv3p17XlpayoyNjdmPP/7IGGMsNTWVAWBXrlxRuI+9e/cyQ0NDdubMGcYYY2lpaUwgEMjVkzHG+vTpwxYsWMAYY2zUqFFswIABcvtHjBjBzM3NVb9gSvTs2ZO1atWKSaVSbtv8+fNZq1atuOePHz9mKSkpah8ywcHBrF+/fnLXKCgoYADYkSNHVNZj7dq17MSJE+zatWts48aNzMLCgs2ZM0ere3mbqPuu17ffbxqjRgghGkjISlBoSSuPgSGzMBMJWQnoLO5c7dfv1asXNm7ciIKCAnz11VfQ09PD0KFDuf0SiQQrV67Ezz//jEePHqGkpATFxcUQiURy52nXrp3cczs7O2RlZQEAbt26BXt7ezRq1IjbXzEJ+K1bt9C+fXu5breuXbtCKpUiKSmJaylq3bq1XGolW1tbuYkCAoEADRo04K6typUrVzB27FisX78eXbt2BVDW9SqRSNCiRQu5ssXFxWjQoAFXzw8++EBuv7e3N2JjY9VeT5l33nkHPB5P7jxr166FRCKBQCCAjY0NbGxstD6vNkJCQrj/bteuHQwMDDBlyhRERETQqjlvOArUCCFEA08Kn1RrOW0ZGxujefPmAICtW7eiffv22LJlCyZOnAgA+OKLL7Bu3TpERUWhbdu2MDY2xuzZsxXGPenr68s95/F4kEql1V5fZdfR9tqZmZl47733MGnSJO4+gbLVZgQCAS5fvswlOpcp381YW6ZOnYodO3aoLSMbwycWixW6o2XLKGozmcLLywulpaW4f/8+XF1dtawxqU8oUCOEEA1Yi6wrL6RFudfB5/OxcOFChISEICAgAEZGRjh79izef/99jBkzBkDZeLPk5GS4ublpfN5WrVrhwYMHyMjI4Jbcu3DhgkKZmJgYFBQUcK1qZ8+eBZ/Pr9aAoaioCO+//z5atmyJyMhIuX3u7u6QSCTIyspC9+7dVd7LxYsX5bZVvBdNKTuPi4sLFyQuW7YMc+fO1ehc3t7eWLFiBbKysrhWuD///BNmZmZavVdXr14Fn8+v8ZY8UvdoMgEhhGjAw8YDtiJb8MBTup8HHsQiMTxsPGqlPsOGDYNAIMC3334LAHBxccGff/6Jc+fO4datW5gyZQrXUqMpX19ftGjRAoGBgbh27Rr++usvfPbZZ3JlRo8eDUNDQwQGBiIxMREnTpzAxx9/jLFjx8oNkH9dU6ZMwYMHD/D111/jyZMnyMzMRGZmJkpKStCiRQuMHj0a48aNw759+5Camor4+HhERETg8OHDAICZM2ciNjYWX375JVJSUrB+/foqdXsCZXnPQkJCkJSUhB9//BHffPMNZs2axe23sbFB8+bN1T5k+vXrBzc3N4wdOxbXrl3D77//jkWLFmH69OlcF2Z8fDxatmyJR48eASibgBAVFYVr167h3r172LlzJ+bMmYMxY8bA0tKyqi8xqScoUCOEEA0I+AKEeoYCgEKwJns+33N+jedTk9HT08OMGTOwZs0aFBQUYNGiRfDw8ICfnx98fHwgFou1XkmAz+dj//79ePnyJTw9PTFp0iS55fkAQCQS4ffff8fz58/RuXNnfPjhh+jTpw/Wr19fjXcHnDp1ChkZGXBzc4OdnR33OHfuHAAgOjoa48aNwyeffAJXV1cMHjwYly5dQtOmTQGUjSv7/vvvsW7dOrRv3x5//PEHFi1aJHcNWUqQimk9Kho3bhz3mkyfPh2zZs3C5MmTq3RfAoEAv/32GwQCAby9vTFmzBiMGzcOy5Yt48oUFhYiKSkJr169AlCWmuWnn35Cz5490bp1a6xYsQJz5szBd999V6U6kPqFlpCqovq2BAUhpHqWkIpLi8Oq+FVyEwvEIjHme86Hr4NvdVWV1IITJ05gyJAhuHfvnsqWKR8fH3To0AFRUVG1WznyWt6kJaRojBohhGjB18EXvex71frKBKT6HTlyBAsXLqTuQ6LTKFAjhBAtCfiCGknBQWrXF198UddVIKRSFKgRQgghKlQ2fo2QmkaTCQghhBBCdBQFaoQQQgghOooCNUIIIYQQHUWBGiGEEEKIjqJAjRBCCCFER1GgRgghhBCioyhQI4SQt5yPjw9mz55dJ9c+efIkeDwesrOz6+T6FcmWlbp69SoA3asfeftQoEYIITpOVSAVExMDCwuLWq/P2xS8dOnSBRkZGTA3N9eofF0GveTNRAlvCSFEQykpKcjLy1O539TUFC4uLrVYI6LKq1evoK+v/9rnMTAwgFgsroYaaaekpAQGBga1fl2ie6hFjRBCNJCSkoIWLVqgY8eOKh8tWrRASkpKndUxKCgIgwcPRnh4OKytrWFmZoapU6eipKSEK1NQUIBx48bBxMQEdnZ2WLt2rcJ5tm/fjk6dOsHU1BRisRgBAQHIysoCUNY12KtXLwCApaUleDwegoKCAABSqRQRERFwcnKCkZER2rdvj19++UXu3EeOHEGLFi1gZGSEXr164f79+5XeF4/Hw8aNG/Huu+/CyMgIzZo1kzuvrLty9+7d6NmzJwwNDbFz504AwP/93/+hVatWMDQ0RMuWLbFhwwa5c8fHx8Pd3R2Ghobo1KkTrly5IrdfWevh2bNn4ePjA5FIBEtLS/j5+eHFixcICgrCqVOnsG7dOvB4PPB4PO7+Tp06BU9PTwiFQtjZ2SE0NBSlpaXcOX18fDBjxgzMnj0bDRs2hJ+fX6WvC3k7UIsaIYRoQNaSttrODs4GQoX9d0uKMT8jQ22LW204duwYDA0NcfLkSdy/fx/jx49HgwYNsGLFCgDAp59+ilOnTuHAgQOwsbHBwoULkZCQgA4dOnDnePXqFZYvXw5XV1dkZWUhJCQEQUFBOHLkCOzt7bF3714MHToUSUlJMDMzg5GREQAgIiICO3bswKZNm+Di4oLTp09jzJgxsLa2Rs+ePfHgwQMMGTIE06dPx+TJk/H333/jk08+0ei+Fi9ejFWrVmHdunXYvn07Ro4ciRs3bqBVq1ZcmdDQUKxdu5YLvHbu3IklS5Zg/fr1cHd3x5UrVxAcHAxjY2MEBgYiPz8fgwYNQt++fbFjxw6kpqZi1qxZautx9epV9OnTBxMmTMC6deugp6eHEydOQCKRYN26dUhOTkabNm2wbNkyAIC1tTUePXqEAQMGICgoCD/88ANu376N4OBgGBoaYunSpdy5t23bhmnTpuHs2bMavSbkLcFIleTk5DAALCcnp66rQgjR0MuXL9nNmzfZy5cvtT728uXLDAD7xcGR3XRtqfD4xcGRAWCXL1+u9nr37NmTzZo1S2F7dHQ0Mzc3554HBgYyKysrVlBQwG3buHEjMzExYRKJhOXl5TEDAwP2888/c/ufPXvGjIyMlJ5f5tKlSwwAy8vLY4wxduLECQaAvXjxgitTVFTERCIRO3funNyxEydOZKNGjWKMMbZgwQLm5uYmt3/+/PkK56oIAJs6darcNi8vLzZt2jTGGGOpqakMAIuKipIr4+zszHbt2iW3bfny5czb25sxxtjmzZtZgwYN5D4PGzduZADYlStXlN7rqFGjWNeuXVXWVdl7tXDhQubq6sqkUim37dtvv+XeF9lx7u7uKs9LtKPuu17ffr+pRY0QQt4g7du3h0gk4p57e3sjPz8fDx48QHZ2NkpKSuDl5cXtt7Kygqurq9w5Ll++jKVLl+LatWt48eIFpFIpACA9PR1ubm5Kr3vnzh0UFhaib9++cttLSkrg7u4OALh165bctWX100TFct7e3tzMTJlOnTpx/11QUIC7d+9i4sSJCA4O5raXlpZyEwNu3bqFdu3awdDQUOP6XL16FcOGDdOozjK3bt2Ct7c3eDwet61r167Iz8/Hw4cP0bRpUwBAx44dtToveTtQoEYIITrOzMwMOTk5Ctuzs7M1no2oqYKCAvj5+cHPzw87d+6EtbU10tPT4efnJzfWraL8/HwAwOHDh9G4cWO5fUKhYldxTTA2Nlaoz/fff68QHAoEgipfQ9bNWxPK158QGZpMQAghOs7V1RUJCQkK2xMSEtCiRQu5bdeuXcPLly+55xcuXICJiQns7e3h7OwMfX19XLx4kdv/4sULJCcnc89v376NZ8+eYdWqVejevTtatmzJTSSQkc1GlEgk3DY3NzcIhUKkp6ejefPmcg97e3sAQKtWrRAfHy93rgsXLmj0GlQsd+HCBbnxaRXZ2tqiUaNGuHfvnkJ9nJycuPpcv34dRUVFGtenXbt2OHbsmMr9BgYGcq+L7Drnz58HY4zbdvbsWZiamqJJkyZqr0cIBWqEEKLjpk2bhuTkZMycORPXr19HUlISIiMj8eOPPyoMxi8pKcHEiRNx8+ZNHDlyBGFhYZgxYwb4fD5MTEwwceJEfPrppzh+/DgSExMRFBQEPv+/n4KmTZvCwMAA33zzDe7du4eDBw9i+fLlctdwcHAAj8fDb7/9hidPniA/Px+mpqaYO3cu5syZg23btuHu3btISEjAN998g23btgEApk6dipSUFHz66adISkrCrl27EBMTo9FrsGfPHmzduhXJyckICwtDfHw8ZsyYofaY8PBwRERE4Ouvv0ZycjJu3LiB6OhoREZGAgACAgLA4/EQHBzMvV5ffvml2nMuWLAAly5dwkcffYTr16/j9u3b2LhxI54+fQoAcHR0xMWLF3H//n08ffoUUqkUH330ER48eICPP/4Yt2/fxoEDBxAWFoaQkBC5154Qpep6kFx9Vd8GIxJCqmcywWo7O/aLg6PCY7WdXY1NJmCMsfj4eNa3b19mbW3NzM3NmZeXF9u/f79cmcDAQPb++++zJUuWsAYNGjATExMWHBzMioqKuDJ5eXlszJgxTCQSMVtbW7ZmzRqFAfC7du1ijo6OTCgUMm9vb3bw4EG5AfaMMbZs2TImFosZj8djgYGBjDHGpFIpi4qKYq6urkxfX59ZW1szPz8/durUKe64Q4cOsebNm/9/e3ceV0W5/wH8MyDnHPZN4KCXTVDBREAMRE30CuGSS1qamoEhpmlp3vwhloJ6FUtFKrdyw3L3ul23CknNFERBFGUVUbwGkgooO3K+vz98MXlkERQ4oN/36zWv25l55nm+z+M5w/fOzDNDUqmU3njjDdq0aVO9JhOsXr2avL29SSqVkrW1Ne3atUvcXjWZ4Mn4qmzbto2cnZ1JIpGQoaEh9e3bl/bt2yduj46OJicnJ5JIJOTs7Ex79+6tczIBEdHJkyepV69eJJVKycDAgHx8fMTtqamp1LNnT9LU1CQAlJmZKe7z+uuvk0QiIblcToGBgVRRUSHWWduEEfZ8XqbJBALRE+diWb09ePAA+vr6KCgogJ6enqrDYYzVQ2lpKTIzM2FjY6N0A3l9VD1H7VnS0tJU9tBbPz8/5Ofn48CBAyppv6kIgoD9+/djxIgRqg6FtRJ1/dZb299vnkzAGGP10LFjR6SlpfGbCRhjzYoTNcYYqydOwhhjzY0TNcYYe0nU98b81obv0GGvMp5uwhhjjDHWQrWIRG316tWwtraGTCaDu7t7tefsPC08PBydO3eGpqYmLCws8Nlnnyk9B+dJS5cuhSAImDlzptL6fv36iS/NrVqmTJnSWF1ijDHGGHthKr/0uWvXLsyaNQvr1q2Du7s7wsPD4ePjg9TUVJiamlYrv337dsyZMwebNm1Cr169kJaWBj8/PwiCID4bp8r58+fx/fffo1u3bjW2HRAQIL44F4DSa1cYY4wxxlRN5WfUwsLCEBAQgIkTJ6JLly5Yt24dtLS0sGnTphrLnz17Fr1798a4ceNgbW2NN998E2PHjq12Fq6wsBDjx4/H+vXrYWhoWGNdWlpakMvl4tIapukyxhhj7NWh0kStvLwccXFx8PLyEtepqanBy8sL0dHRNe7Tq1cvxMXFiYnZ9evXcfToUQwePFip3LRp0zBkyBClup+2bds2tG3bFl27dkVQUBCKi4trLVtWVoYHDx4oLYwxxhhjTUmlidrdu3dRWVkJMzMzpfVmZmbIycmpcZ9x48Zh4cKF6NOnDzQ0NGBra4t+/fph7ty5YpmdO3ciPj4eoaGhtbY9btw4bN26FSdOnEBQUBB++uknvP/++7WWDw0Nhb6+vrhUvbuOMcZaAkEQGv1BtyEhIXB2dm7UOqv069ev2r3DzcHa2hrh4eEvVIefn98zH76rqv6xl4/KL3021MmTJ7FkyRKsWbMG8fHx2LdvH44cOSK+i+7WrVuYMWMGtm3bVueTxydPngwfHx84Ojpi/Pjx+PHHH7F//35kZGTUWD4oKAgFBQXicuvWrSbpH2OM1eSvv/7C1KlTYWlpCalUCrlcDh8fH5w5cwYAkJ2djUGDBqk4yupOnjwJQRCQn5+v6lAYa5VUOpmgbdu2UFdXx507d5TW37lzB3K5vMZ95s2bhwkTJmDSpEkAAEdHRxQVFWHy5Mn44osvEBcXh9zcXHTv3l3cp7KyEr///jtWrVqFsrIyqKurV6vX3d0dAHDt2jXY2tpW2y6VSiGVSp+7r4yxl4dCQchOz0fRgzJo60lh3tEAampCk7Y5atQolJeXY8uWLejQoQPu3LmDqKgo3Lt3DwBqPWa+TCoqKqChoaHqMBhrVio9oyaRSODq6oqoqChxnUKhQFRUFDw8PGrcp7i4GGpqymFXJV5EhAEDBiAxMREJCQni0qNHD4wfPx4JCQk1JmkAkJCQAAAwNzdvhJ4xxl5WGRdz8ePcsziw8iIiNybhwMqL+HHuWWRczG2yNvPz83H69Gl89dVX6N+/P6ysrODm5oagoCAMGzYMgPKlzxs3bkAQBOzbtw/9+/eHlpYWnJycqt37u379elhYWEBLSwtvv/02wsLCYGBgUGcsGzZsgIODA2QyGezt7bFmzZpay964cQP9+/cHABgaGkIQBPj5+YnbFQoF/u///g9GRkaQy+UICQlR2l8QBKxduxbDhg2DtrY2Fi9eDAA4ePAgunfvDplMhg4dOmDBggV49OgRgMd/B0JCQsQzj+3atcOnn36qVG9xcTE+/PBD6OrqwtLSEj/88IPS9sTERPzzn/+EpqYmjI2NMXnyZBQWFtbaz6KiInzwwQfQ0dGBubk5VqxYUecYMtYgKn0lPBHt3LmTpFIpRUREUFJSEk2ePJkMDAwoJyeHiIgmTJhAc+bMEcsHBweTrq4u7dixg65fv06//vor2dra0ujRo2ttw9PTk2bMmCF+vnbtGi1cuJAuXLhAmZmZdPDgQerQoQP17du33nEXFBQQACooKGh4pxljKlFSUkJJSUlUUlLyXPtfi79Dqz6KqnW5Fn+nkSN+rKKignR0dGjmzJlUWlpaYxkAtH//fiIiyszMJABkb29Phw8fptTUVHrnnXfIysqKKioqiIjojz/+IDU1NVq2bBmlpqbS6tWrycjIiPT19cU6g4ODycnJSfy8detWMjc3p71799L169dp7969ZGRkRBERETXG9OjRI9q7dy8BoNTUVMrOzqb8/Hwienxc1tPTo5CQEEpLS6MtW7aQIAj066+/KvXJ1NSUNm3aRBkZGXTz5k36/fffSU9PjyIiIigjI4N+/fVXsra2ppCQECIi2rNnD+np6dHRo0fp5s2bdO7cOfrhhx/EOq2srMjIyIhWr15N6enpFBoaSmpqapSSkkJERIWFhWRubk4jR46kxMREioqKIhsbG/L19RXr8PX1peHDh4ufp06dSpaWlnT8+HG6fPkyvfXWW6Srq6v0d4c1r7p+663t77fKEzUiou+++44sLS1JIpGQm5sbxcTEiNs8PT2VfiAVFRUUEhJCtra2JJPJyMLCgj7++GPKy8urtf6nE7WsrCzq27cvGRkZkVQqJTs7O5o9e3aD/tFa2z80Y+zFErXKSgVtDvyjzkQtYs4fVFmpaILIif7zn/+QoaEhyWQy6tWrFwUFBdGlS5fE7TUlahs2bBC3X716lQBQcnIyERGNGTOGhgwZotTG+PHj60zUbG1tafv27Ur7LFq0iDw8PGqN+8SJEwSg2jHa09OT+vTpo7Tu9ddfp8DAQKU+zZw5U6nMgAEDaMmSJUrrfvrpJzI3NyciohUrVlCnTp2ovLy8xnisrKzo/fffFz8rFAoyNTWltWvXEhHRDz/8QIaGhlRYWCiWOXLkCKmpqYknEJ5M1B4+fEgSiYR2794tlr937x5pampyoqZCL1OipvIH3gLA9OnTMX369Bq3nTx5UulzmzZtEBwcjODg4HrX/3QdFhYWOHXqVEPDZIy9wrLT81GUX1ZnmcK8MmSn56N955qf3fgiRo0ahSFDhuD06dOIiYnBsWPH8PXXX2PDhg1KlxOf9OTDvqtu68jNzYW9vT1SU1Px9ttvK5V3c3PD4cOHa6yrqKgIGRkZ8Pf3R0BAgLj+0aNH0NfXBwAMGjQIp0+fBgBYWVnh6tWrdfbp6YeRm5ubIzdX+RJyjx49lD5funQJZ86cES+DAo/vQy4tLUVxcTHeffddhIeHo0OHDhg4cCAGDx6MoUOHok2bv//cPdmuIAiQy+Viu8nJyXBycoK2trZYpnfv3lAoFEhNTa32lIKMjAyUl5eL9zkDgJGRETp37lxn3xmrrxaRqDHGWEtX9KDuJK2h5Z6HTCaDt7c3vL29MW/ePEyaNAnBwcG1JmpP3ngvCI8nOygUiudqu+oerfXr1yslJcDf9wlv2LABJSUl1dquzdNlBEGoFt+TCVNVHAsWLMDIkSOr1SeTyWBhYYHU1FQcP34ckZGR+Pjjj7Fs2TKcOnVKbK8+7TLWUnCixhhj9aCtV79Z3/Ut1xi6dOny3M9O69y5M86fP6+07unPTzIzM0O7du1w/fp1jB8/vsYy7du3r7ZOIpEAeHzWqzF0794dqampsLOzq7WMpqYmhg4diqFDh2LatGmwt7dHYmKi0tMAauPg4ICIiAgUFRWJSeKZM2egpqZW41kyW1tbaGho4Ny5c7C0tAQA5OXlIS0tDZ6ens/ZS8b+xokaY4zVg3lHA2gbSOu8/Klj+PhRHY3t3r17ePfdd/Hhhx+iW7du0NXVxYULF/D1119j+PDhz1XnJ598gr59+yIsLAxDhw7Fb7/9hmPHjoln3mqyYMECfPrpp9DX18fAgQNRVlaGCxcuIC8vD7NmzapxHysrKwiCgMOHD2Pw4MHQ1NSEjo7Oc8UMAPPnz8dbb70FS0tLvPPOO1BTU8OlS5dw5coV/Pvf/0ZERAQqKyvh7u4OLS0tbN26FZqamrCysqpX/ePHj0dwcDB8fX0REhKCv/76C5988gkmTJhQ7bInAOjo6MDf3x+zZ8+GsbExTE1N8cUXX1R7OgFjz4u/SYwxVg9qagLeGNOxzjJ9Rndskuep6ejowN3dHStXrkTfvn3RtWtXzJs3DwEBAVi1atVz1dm7d2+sW7cOYWFhcHJyws8//4zPPvuszgeFT5o0CRs2bMDmzZvh6OgIT09PREREwMbGptZ92rdvjwULFmDOnDkwMzOr9X7k+vLx8cHhw4fx66+/4vXXX0fPnj2xcuVKMREzMDDA+vXr0bt3b3Tr1g3Hjx/HoUOHYGxsXK/6tbS08Msvv+D+/ft4/fXX8c4772DAgAF1jvOyZcvwxhtvYOjQofDy8kKfPn3g6ur6Qv1krIpARKTqIFqjBw8eQF9fHwUFBfwyd8ZaidLSUmRmZsLGxqbOhKQuGRdzcXpXutKZNR1DKfqM7ghbF9PGClUlAgICkJKSIk4IYKy1quu33tr+fvOlT8YYawBbF1PYOJk0+5sJmsLy5cvh7e0NbW1tHDt2DFu2bKnzAbaMsebHiRpjjDWQmprQJI/gaG6xsbH4+uuv8fDhQ3To0AHffvut+Ho+xljLwIkaY4y9onbv3q3qEBhjz8CTCRhjjDHGWihO1BhjjDHGWii+9PmSqVQQYjPvI/dhKUx1ZXCzMYJ6K7zJmTHGGGOcqL1Ufr6SjQWHkpBdUCquM9eXIXhoFwzsaq7CyBhjjDH2PPjS50vi5yvZmLo1XilJA4CcglJM3RqPn69kqygyxhhjjD0vTtReApUKwoJDSajpycVV6xYcSkKlgp9tzBhjjLUmnKi9BGIz71c7k/YkApBdUIrYzPvNFxRjrNXo168fZs6cqZK2T548CUEQkJ+fr5L2n3bjxg0IgoCEhAQALS8+9urhRO0lkPuw9iTtecoxxlqW2hKpiIgIGBgYNHs8r1Ly0qtXL2RnZ0NfX79e5VWZ9LKXE08meAmY6tbvnYX1LccYq1l6ejoePnxY63ZdXV107Fj3i9tZ86ioqICGhsYL1yORSCCXyxshooYpLy+HRCJp9nZZy8Nn1F4CbjZGMNeXobaHcAh4PPvTzcaoOcNi7KWSnp6OTp06wdXVtdalU6dOSE9PV1mMfn5+GDFiBBYsWAATExPo6elhypQpKC8vF8sUFRXhgw8+gI6ODszNzbFixYpq9fz000/o0aMHdHV1IZfLMW7cOOTm5gJ4fGmwf//+AABDQ0MIggA/Pz8AgEKhQGhoKGxsbKCpqQknJyf85z//Uar76NGj6NSpEzQ1NdG/f3/cuHHjmf0SBAFr167FoEGDoKmpiQ4dOijVW3W5cteuXfD09IRMJsO2bdsAABs2bICDgwNkMhns7e2rvcs0NjYWLi4ukMlk6NGjBy5evKi0vaazh2fOnEG/fv2gpaUFQ0ND+Pj4IC8vD35+fjh16hS++eYbCIIAQRDE/p06dQpubm6QSqUwNzfHnDlz8OjRI7HOfv36Yfr06Zg5cybatm0LHx+fZ44LezXwGbWXgLqagOChXTB1azwEQGlSQVXyFjy0Cz9PjbEXUHUmbZy7M0z1dKptz31QiO3nEuo849YcoqKiIJPJcPLkSdy4cQMTJ06EsbExFi9eDACYPXs2Tp06hYMHD8LU1BRz585FfHw8nJ2dxToqKiqwaNEidO7cGbm5uZg1axb8/Pxw9OhRWFhYYO/evRg1ahRSU1Ohp6cHTU1NAEBoaCi2bt2KdevWoWPHjvj999/x/vvvw8TEBJ6enrh16xZGjhyJadOmYfLkybhw4QL+9a9/1atf8+bNw9KlS/HNN9/gp59+wnvvvYfExEQ4ODiIZebMmYMVK1aIide2bdswf/58rFq1Ci4uLrh48SICAgKgra0NX19fFBYW4q233oK3tze2bt2KzMxMzJgxo844EhISMGDAAHz44Yf45ptv0KZNG5w4cQKVlZX45ptvkJaWhq5du2LhwoUAABMTE9y+fRuDBw+Gn58ffvzxR6SkpCAgIAAymQwhISFi3Vu2bMHUqVNx5syZeo0Je0UQey4FBQUEgAoKClQdiuhY4p/Uc8lxsgo8LC49lxynY4l/qjo0xlqEkpISSkpKopKSkgbvGxcXRwBopncfWj56SLVlpncfAkBxcXGNHrenpyfNmDGj2vrNmzeTvr6++NnX15eMjIyoqKhIXLd27VrS0dGhyspKevjwIUkkEtq9e7e4/d69e6SpqVlj/VXOnz9PAOjhw4dERHTixAkCQHl5eWKZ0tJS0tLSorNnzyrt6+/vT2PHjiUioqCgIOrSpYvS9sDAwGp1PQ0ATZkyRWmdu7s7TZ06lYiIMjMzCQCFh4crlbG1taXt27crrVu0aBF5eHgQEdH3339PxsbGSt+HtWvXEgC6ePFijX0dO3Ys9e7du9ZYa/q3mjt3LnXu3JkUCoW4bvXq1eK/S9V+Li4utdbLGqau33pL/PtdFz6j9hIZ2NUc3l3k/GYCxl5hTk5O0NLSEj97eHigsLAQt27dQn5+PsrLy+Hu7i5uNzIyQufOnZXqiIuLQ0hICC5duoS8vDwoFAoAQFZWFrp06VJju9euXUNxcTG8vb2V1peXl8PFxQUAkJycrNR2VXz18XQ5Dw8PcWZmlR49eoj/XVRUhIyMDPj7+yMgIEBc/+jRI3FiQHJyMrp16waZ7O/7d58VT0JCAt599916xVwlOTkZHh4eEIS/j8W9e/dGYWEh/ve//8HS0hIA4Orq2qB62auBE7WXjLqaAA9bY1WHwRhrRHp6eigoKKi2Pj8/v96zEeurqKgIPj4+8PHxwbZt22BiYoKsrCz4+Pgo3ev2tMLCQgDAkSNH0L59e6VtUqm0UWOsjba2drV41q9fXy05VFdXf+42qi7zNoUn42esCk8mYIyxFq5z586Ij4+vtj4+Ph6dOnVSWnfp0iWUlJSIn2NiYqCjowMLCwvY2tpCQ0MD586dE7fn5eUhLS1N/JySkoJ79+5h6dKleOONN2Bvby9OJKhSNRuxsrJSXNelSxdIpVJkZWXBzs5OabGwsAAAODg4IDY2VqmumJiYeo3B0+ViYmKU7k97mpmZGdq1a4fr169Xi8fGxkaM5/Llyygt/fvRRc+Kp1u3boiKiqp1u0QiURqXqnaio6NB9PcdxGfOnIGuri7+8Y9/1NkeY5yoMcZYCzd16lSkpaXh008/xeXLl5GamoqwsDDs2LGj2s345eXl8Pf3R1JSEo4ePYrg4GBMnz4dampq0NHRgb+/P2bPno3ffvsNV65cgZ+fH9TU/v5TYGlpCYlEgu+++w7Xr1/Hf//7XyxatEipDSsrKwiCgMOHD+Ovv/5CYWEhdHV18fnnn+Ozzz7Dli1bkJGRgfj4eHz33XfYsmULAGDKlClIT0/H7NmzkZqaiu3btyMiIqJeY7Bnzx5s2rQJaWlpCA4ORmxsLKZPn17nPgsWLEBoaCi+/fZbpKWlITExEZs3b0ZYWBgAYNy4cRAEAQEBAeJ4LV++vM46g4KCcP78eXz88ce4fPkyUlJSsHbtWty9excAYG1tjXPnzuHGjRu4e/cuFAoFPv74Y9y6dQuffPIJUlJScPDgQQQHB2PWrFlKY89YjVR9k1xr1dpuRmSMNc5kgnHuzjTTu0+1ZZy7c5NNJiAiio2NJW9vbzIxMSF9fX1yd3en/fv3K5Xx9fWl4cOH0/z588nY2Jh0dHQoICCASktLxTIPHz6k999/n7S0tMjMzIy+/vrrajfAb9++naytrUkqlZKHhwf997//VbrBnoho4cKFJJfLSRAE8vX1JSIihUJB4eHh1LlzZ9LQ0CATExPy8fGhU6dOifsdOnSI7OzsSCqV0htvvEGbNm2q12SC1atXk7e3N0mlUrK2tqZdu3aJ26smEzwZX5Vt27aRs7MzSSQSMjQ0pL59+9K+ffvE7dHR0eTk5EQSiYScnZ1p7969dU4mICI6efIk9erVi6RSKRkYGJCPj4+4PTU1lXr27EmampoEgDIzM8V9Xn/9dZJIJCSXyykwMJAqKirEOmubMMKez8s0mUAgIn4B5HN48OAB9PX1UVBQAD09PVWHwxirh9LSUmRmZsLGxkbpBvL6qHqO2rOkpaWp7KG3fn5+yM/Px4EDB1TSflMRBAH79+/HiBEjVB0KayXq+q23tr/fPJmAMcbqoWPHjkhLS+M3EzDGmhUnaowxVk+chDHGmhsnaowx9pKo7435rQ3focNeZTzdhDHGGGOsheJEjTHGGGOsheJEjTH2yuFLaYy93F6m3zgnaoyxV4aGhgYAoLi4WMWRMMaaUtVvvOo335rxZALG2CtDXV0dBgYG4iuRtLS0lF6UzRhr3YgIxcXFyM3NhYGBwQu917Wl4ESNMfZKkcvlAFDt/ZWMsZeHgYGB+Ftv7ThRY4y9UgRBgLm5OUxNTVFRUaHqcBhjjUxDQ+OlOJNWpUUkaqtXr8ayZcuQk5MDJycnfPfdd3Bzc6u1fHh4ONauXYusrCy0bdsW77zzDkJDQ2t8JczSpUsRFBSEGTNmIDw8XFxfWlqKf/3rX9i5cyfKysrg4+ODNWvWwMzMrCm6yBhrYdTV1V+qgzlj7OWk8skEu3btwqxZsxAcHIz4+Hg4OTnBx8en1ssS27dvx5w5cxAcHIzk5GRs3LgRu3btwty5c6uVPX/+PL7//nt069at2rbPPvsMhw4dwp49e3Dq1Cn8+eefGDlyZKP3jzHGGGPseak8UQsLC0NAQAAmTpyILl26YN26ddDS0sKmTZtqLH/27Fn07t0b48aNg7W1Nd58802MHTsWsbGxSuUKCwsxfvx4rF+/HoaGhkrbCgoKsHHjRoSFheGf//wnXF1dsXnzZpw9exYxMTFN1lfGGGOMsYZQaaJWXl6OuLg4eHl5ievU1NTg5eWF6OjoGvfp1asX4uLixMTs+vXrOHr0KAYPHqxUbtq0aRgyZIhS3VXi4uJQUVGhtM3e3h6Wlpa1tssYY4wx1txUeo/a3bt3UVlZWe2+MDMzM6SkpNS4z7hx43D37l306dMHRIRHjx5hypQpSpc+d+7cifj4eJw/f77GOnJyciCRSGBgYFCt3ZycnBr3KSsrQ1lZmfi5oKAAAPDgwYNn9pMxxhhjLUPV3+3W8lDcFjGZoCFOnjyJJUuWYM2aNXB3d8e1a9cwY8YMLFq0CPPmzcOtW7cwY8YMREZG1ji54HmFhoZiwYIF1dZbWFg0WhuMMcYYax737t2Dvr6+qsN4JpUmam3btoW6ujru3LmjtP7OnTu1Pv9k3rx5mDBhAiZNmgQAcHR0RFFRESZPnowvvvgCcXFxyM3NRffu3cV9Kisr8fvvv2PVqlUoKyuDXC5HeXk58vPzlc6q1dVuUFAQZs2aJX5WKBS4f/8+jI2NW8QDMx88eAALCwvcunULenp6qg6nVeAxaxger4bjMWs4HrOG4fFquIKCAlhaWsLIyEjVodSLShM1iUQCV1dXREVFYcSIEQAeJ0BRUVGYPn16jfsUFxdDTU351rqqKfZEhAEDBiAxMVFp+8SJE2Fvb4/AwECoq6vD1dUVGhoaiIqKwqhRowAAqampyMrKgoeHR43tSqVSSKVSpXVPXzptCfT09PjH2kA8Zg3D49VwPGYNx2PWMDxeDfd0LtFSqfzS56xZs+Dr64sePXrAzc0N4eHhKCoqwsSJEwEAH3zwAdq3b4/Q0FAAwNChQxEWFgYXFxfx0ue8efMwdOhQqKurQ1dXF127dlVqQ1tbG8bGxuJ6fX19+Pv7Y9asWTAyMoKenh4++eQTeHh4oGfPns07AIwxxhhjtVB5ojZmzBj89ddfmD9/PnJycuDs7Iyff/5ZnGCQlZWllPV++eWXEAQBX375JW7fvg0TExMMHToUixcvblC7K1euhJqaGkaNGqX0wFvGGGOMsZZCoNYy7YHVqaysDKGhoQgKCqp2iZbVjMesYXi8Go7HrOF4zBqGx6vhWtuYcaLGGGOMMdZCtY476RhjjDHGXkGcqDHGGGOMtVCcqDHGGGOMtVCcqDHGGGOMtVCcqLUQq1evhrW1NWQyGdzd3cWXztdmz549sLe3h0wmg6OjI44ePaq0nYgwf/58mJubQ1NTE15eXkhPT1cqc//+fYwfPx56enowMDCAv78/CgsLG71vTUUVY2ZtbQ1BEJSWpUuXNnrfmkJjj9e+ffvw5ptvim/nSEhIqFZHaWkppk2bBmNjY+jo6GDUqFHV3kTSkqlizPr161ftOzZlypTG7FaTaswxq6ioQGBgIBwdHaGtrY127drhgw8+wJ9//qlUR2s+lqlivFrzcQxo/N9lSEgI7O3toa2tDUNDQ3h5eeHcuXNKZVT6HSOmcjt37iSJREKbNm2iq1evUkBAABkYGNCdO3dqLH/mzBlSV1enr7/+mpKSkujLL78kDQ0NSkxMFMssXbqU9PX16cCBA3Tp0iUaNmwY2djYUElJiVhm4MCB5OTkRDExMXT69Gmys7OjsWPHNnl/G4OqxszKyooWLlxI2dnZ4lJYWNjk/X1RTTFeP/74Iy1YsIDWr19PAOjixYvV6pkyZQpZWFhQVFQUXbhwgXr27Em9evVqqm42KlWNmaenJwUEBCh9xwoKCpqqm42qsccsPz+fvLy8aNeuXZSSkkLR0dHk5uZGrq6uSvW01mOZqsartR7HiJrmd7lt2zaKjIykjIwMunLlCvn7+5Oenh7l5uaKZVT5HeNErQVwc3OjadOmiZ8rKyupXbt2FBoaWmP50aNH05AhQ5TWubu700cffURERAqFguRyOS1btkzcnp+fT1KplHbs2EFERElJSQSAzp8/L5Y5duwYCYJAt2/fbrS+NRVVjBnR4wPcypUrG7EnzaOxx+tJmZmZNSYd+fn5pKGhQXv27BHXJScnEwCKjo5+gd40D1WMGdHjRG3GjBkvFLuqNOWYVYmNjSUAdPPmTSJq3ccyVYwXUes9jhE1z5gVFBQQADp+/DgRqf47xpc+Vay8vBxxcXHw8vIS16mpqcHLywvR0dE17hMdHa1UHgB8fHzE8pmZmcjJyVEqo6+vD3d3d7FMdHQ0DAwM0KNHD7GMl5cX1NTUqp3ybWlUNWZVli5dCmNjY7i4uGDZsmV49OhRY3WtSTTFeNVHXFwcKioqlOqxt7eHpaVlg+pRBVWNWZVt27ahbdu26Nq1K4KCglBcXNzgOppbc41ZQUEBBEEQ37XcWo9lqhqvKq3tOAY0z5iVl5fjhx9+gL6+PpycnMQ6VPkdU/krpF51d+/eRWVlpfjKrCpmZmZISUmpcZ+cnJway+fk5Ijbq9bVVcbU1FRpe5s2bWBkZCSWaalUNWYA8Omnn6J79+4wMjLC2bNnERQUhOzsbISFhb1wv5pKU4xXfeTk5EAikVT7A9HQelRBVWMGAOPGjYOVlRXatWuHy5cvIzAwEKmpqdi3b1/DOtHMmmPMSktLERgYiLFjx4ovIG+txzJVjRfQOo9jQNOO2eHDh/Hee++huLgY5ubmiIyMRNu2bcU6VPkd40SNsQaYNWuW+N/dunWDRCLBRx99hNDQ0FbxKhLW8k2ePFn8b0dHR5ibm2PAgAHIyMiAra2tCiNTrYqKCowePRpEhLVr16o6nBavrvHi41h1/fv3R0JCAu7evYv169dj9OjROHfuXLUETRX40qeKtW3bFurq6tVmwt25cwdyubzGfeRyeZ3lq/73WWVyc3OVtj969Aj379+vtd2WQlVjVhN3d3c8evQIN27caGg3mk1TjFd9yOVylJeXIz8//4XqUQVVjVlN3N3dAQDXrl17oXqaWlOOWVXScfPmTURGRiqdHWqtxzJVjVdNWsNxDGjaMdPW1oadnR169uyJjRs3ok2bNti4caNYhyq/Y5yoqZhEIoGrqyuioqLEdQqFAlFRUfDw8KhxHw8PD6XyABAZGSmWt7GxgVwuVyrz4MEDnDt3Tizj4eGB/Px8xMXFiWV+++03KBQK8Q9DS6WqMatJQkIC1NTUWsT/66pNU4xXfbi6ukJDQ0OpntTUVGRlZTWoHlVQ1ZjVpOoRHubm5i9UT1NrqjGrSjrS09Nx/PhxGBsbV6ujNR7LVDVeNWkNxzGgeX+XCoUCZWVlYh0q/Y41+XQF9kw7d+4kqVRKERERlJSURJMnTyYDAwPKyckhIqIJEybQnDlzxPJnzpyhNm3a0PLlyyk5OZmCg4NrfNSEgYEBHTx4kC5fvkzDhw+v8fEcLi4udO7cOfrjjz+oY8eOrWJKO5Fqxuzs2bO0cuVKSkhIoIyMDNq6dSuZmJjQBx980Lydfw5NMV737t2jixcv0pEjRwgA7dy5ky5evEjZ2dlimSlTppClpSX99ttvdOHCBfLw8CAPD4/m6/gLUMWYXbt2jRYuXEgXLlygzMxMOnjwIHXo0IH69u3bvJ1/To09ZuXl5TRs2DD6xz/+QQkJCUqPkygrKxPraa3HMlWMV2s+jhE1/pgVFhZSUFAQRUdH040bN+jChQs0ceJEkkqldOXKFbEeVX7HOFFrIb777juytLQkiURCbm5uFBMTI27z9PQkX19fpfK7d++mTp06kUQioddee42OHDmitF2hUNC8efPIzMyMpFIpDRgwgFJTU5XK3Lt3j8aOHUs6Ojqkp6dHEydOpIcPHzZZHxtbc49ZXFwcubu7k76+PslkMnJwcKAlS5ZQaWlpk/azsTT2eG3evJkAVFuCg4PFMiUlJfTxxx+ToaEhaWlp0dtvv62UyLV0zT1mWVlZ1LdvXzIyMiKpVEp2dnY0e/bsVvMcNaLGHbOqx5jUtJw4cUIs15qPZc09Xq39OEbUuGNWUlJCb7/9NrVr144kEgmZm5vTsGHDKDY2VqkOVX7HBCKipj9vxxhjjDHGGorvUWOMMcYYa6E4UWOMMcYYa6E4UWOMMcYYa6E4UWOMMcYYa6E4UWOMMcYYa6E4UWOMMcYYa6E4UWOMMcYYa6E4UWOMNat+/fph5syZ4mdra2uEh4c3WXs3btyAIAjiq5iagiAIOHDgQJPGcO/ePZiamjbK+xhDQkLg7OzcoH2Ki4sxatQo6OnpQRAE5Ofno2fPnti7d+8Lx8MYqx0naoy9Avz8/CAIQrVl4MCBqg4N58+fx+TJk1UdBq5evYrRo0fDxMQEUqkUnTp1wvz581FcXKzq0AAAixcvxvDhw2FtbQ3gxZK/zz//vNr7D59ly5YtOH36NM6ePYvs7Gzo6+vjyy+/xJw5c6BQKBocA2OsfjhRY+wVMXDgQGRnZystO3bsUHVYMDExgZaWlkpjiImJgbu7O8rLy3HkyBGkpaVh8eLFiIiIgLe3N8rLy1UaX3FxMTZu3Ah/f/9GqU9HR6deL+t+UkZGBhwcHNC1a1fI5XIIgoBBgwbh4cOHOHbsWKPExRirjhM1xl4RUqkUcrlcaTE0NBS3p6eno2/fvpDJZOjSpQsiIyOVLumdPHlSvORVJSEhAYIgiJfj7t27h7Fjx6J9+/bQ0tKCo6PjM5PBJy99RkRE1HjmLyQkRCy/YcMGODg4QCaTwd7eHmvWrFGqLzY2Fi4uLpDJZOjRowcuXrxYZ/tEBH9/fzg4OGDfvn1wc3ODlZUV3n33XRw6dAjR0dFYuXJlneP0tGfFkJeXh/Hjx8PExASampro2LEjNm/eXGuMR48ehVQqRc+ePevsS309fenTz88PI0aMwPLly2Fubg5jY2NMmzYNFRUVAB5frl6xYgV+//13CIKAfv36AQDU1dUxePBg7Ny5s1HiYoxV10bVATDGVE+hUGDkyJEwMzPDuXPnUFBQoHQfWX2VlpbC1dUVgYGB0NPTw5EjRzBhwgTY2trCzc3tmfuPGTNG6XLsyZMnMWHCBPTu3RsAsG3bNsyfPx+rVq2Ci4sLLl68iICAAGhra8PX1xeFhYV466234O3tja1btyIzMxMzZsyos82EhAQkJSVh+/btUFNT/v+uTk5O8PLywo4dOxAYGFivcapPDPPmzUNSUhKOHTuGtm3b4tq1aygpKak1xtOnT8PV1fWZ4/ciTpw4AXNzc5w4cQLXrl3DmDFj4OzsjICAAOzbtw9z5szBlStXsG/fPkgkEnE/Nzc3LF26tEljY+xVxokaY6+Iw4cPQ0dHR2nd3LlzMXfuXBw/fhwpKSn45Zdf0K5dOwDAkiVLMGjQoAa10b59e3z++efi508++QS//PILdu/eXa9ETVNTE5qamgAeX2qbNm0alixZAm9vbwBAcHAwVqxYgZEjRwIAbGxskJSUhO+//x6+vr7Yvn07FAoFNm7cCJlMhtdeew3/+9//MHXq1FrbTEtLAwA4ODjUuN3BwQF//PEHANRrnOoTQ1ZWFlxcXNCjRw8AEO87q83NmzfF9pqKoaEhVq1aBXV1ddjb22PIkCGIiopCQEAAjIyMoKWlBYlEArlcrrRfu3btcOvWLSgUimqJLmPsxXGixtgron///li7dq3SOiMjIwBAcnIyLCwslJIBDw+PBrdRWVmJJUuWYPfu3bh9+zbKy8tRVlbW4HvQCgoK8NZbb2HIkCGYPXs2AKCoqAgZGRnw9/dHQECAWPbRo0fQ19cX+9GtWzfIZLIG94OInlmmPuNUnximTp2KUaNGIT4+Hm+++SZGjBiBXr161dpuSUmJUn1N4bXXXoO6urr42dzcHImJic/cT1NTEwqFAmVlZWKSzRhrPJyoMfaK0NbWhp2d3XPvX3W25MmEpuoepirLli3DN998g/DwcDg6OkJbWxszZ85s0M34lZWVGDNmDPT09PDDDz+I6wsLCwEA69evh7u7u9I+TyYYDdWpUycAjxMsFxeXatuTk5PFMo1l0KBBuHnzJo4ePYrIyEgMGDAA06ZNw/Lly2ss37ZtW+Tl5TVqDE/T0NBQ+iwIQr1mc96/fx/a2tqcpDHWRPg8NWMMDg4OuHXrFrKzs8V1MTExSmVMTEwAQKnM04+GOHPmDIYPH473338fTk5O6NChg3hpsb4+++wzJCYm4sCBA0pnkczMzNCuXTtcv34ddnZ2SouNjY3Yj8uXL6O0tLTWfjzN2dkZ9vb2WLlyZbXE5NKlSzh+/DjGjh0r1v+scapvDCYmJvD19cXWrVsRHh6ulJQ+zcXFBUlJSXX2Q1WuXLlSY4LLGGscnKgx9oooKytDTk6O0nL37l0AgJeXFzp16gRfX19cunQJp0+fxhdffKG0v52dHSwsLBASEoL09HQcOXIEK1asUCrTsWNHREZG4uzZs0hOTsZHH32EO3fu1DvGzZs3Y82aNVi3bh0EQRDjrDqbtmDBAoSGhuLbb79FWloaEhMTsXnzZoSFhQEAxo0bB0EQEBAQgKSkJBw9erTWs1RVBEHAxo0bkZSUhFGjRiE2NhZZWVnYs2cPhg4dCg8PD3HCQH3GqT4xzJ8/HwcPHsS1a9dw9epVHD58uNZ75ADAx8cHV69erfGsWmpqKhISEpSWp890NqXTp0/jzTffbLb2GHvVcKLG2Cvi559/hrm5udLSp08fAI8va+7fvx8lJSVwc3PDpEmTsHjxYqX9NTQ0sGPHDqSkpKBbt2746quv8O9//1upzJdffonu3bvDx8cH/fr1g1wux4gRI+od46lTp1BZWYlhw4YpxVmV6EyaNAkbNmzA5s2b4ejoCE9PT0RERIhn1HR0dHDo0CEkJibCxcUFX3zxBb766qtntturVy/ExMRAXV0dgwYNgp2dHYKCguDr64vIyEhIpdJ6j1N9YpBIJAgKCkK3bt3Qt29fqKur1/mIC0dHR3Tv3h27d++utu29996Di4uL0tKQ5PhF3L59G2fPnsXEiRObpT3GXkUC1ecOWsbYK0kQBOzfv79ByRZrGkeOHMHs2bNx5cqVFjO7MjAwEHl5eXVetmWMvRieTMAYY63AkCFDkJ6ejtu3b8PCwkLV4QAATE1NMWvWLFWHwdhLjc+oMcZqxWfUWqfXXnsNN2/erHHb999/j/HjxzdzRIyx58WJGmOMvWRu3rxZ64QCMzMz6OrqNnNEjLHnxYkaY4wxxlgL1TLuSGWMMcYYY9VwosYYY4wx1kJxosYYY4wx1kJxosYYY4wx1kJxosYYY4wx1kJxosYYY4wx1kJxosYYY4wx1kJxosYYY4wx1kL9P18Vp6QfmmsnAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -170,7 +170,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -213,7 +213,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -284,7 +284,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -972,7 +972,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "And plot a comparision on test data." + "And plot a comparison on test data." ] }, { @@ -992,7 +992,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] From f43646419c2209ce44213d1b71f712d92f19654f Mon Sep 17 00:00:00 2001 From: Chris Russell Date: Mon, 28 Oct 2024 11:01:29 +0000 Subject: [PATCH 6/6] version increment --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index b0c739a..34bc19a 100644 --- a/setup.py +++ b/setup.py @@ -4,7 +4,7 @@ FAIR = "oxonfair" -version = "0.2.1.7" +version = "0.2.1.8" PYTHON_REQUIRES = ">=3.8"